Merge pull request #63 from JuliaML/col-names

`Tables.columnnames(table)` => `Tables.columnnames(cols)`

Author: juliohm

src/colspec.jl

@@ -24,7 +24,8 @@ end
 2. use `choose(colspec, names)` function in apply:
 ```julia
 function apply(transform::MyTransform, table)
-  names = Tables.columnnames(table)
+  cols = Tables.columns(table)
+  names = Tables.columnnames(cols)
   # selected column names
   snames = choose(transform.colspec, names)
   # code...

src/transforms.jl

@@ -130,8 +130,8 @@ function apply(transform::Colwise, table)
   end
 
   # retrieve column names and values
-  names = Tables.columnnames(table)
   cols  = Tables.columns(table)
+  names = Tables.columnnames(cols)
 
   # function to transform a single column
   function colfunc(n)
@@ -159,9 +159,9 @@ function revert(transform::Colwise, newtable, cache)
   @assert isrevertible(transform) "transform is not revertible"
 
   # transformed columns
-  names = Tables.columnnames(newtable)
   cols  = Tables.columns(newtable)
-
+  names = Tables.columnnames(cols)
+  
   # function to transform a single column
   function colfunc(i)
     n = names[i]
@@ -185,9 +185,9 @@ function reapply(transform::Colwise, table, cache)
   end
 
   # retrieve column names and values
-  names = Tables.columnnames(table)
   cols  = Tables.columns(table)
-
+  names = Tables.columnnames(cols)
+  
   # check that cache is valid
   @assert length(names) == length(cache) "invalid cache for table"
 

src/transforms/coerce.jl

@@ -37,8 +37,9 @@ function apply(transform::Coerce, table)
 end
 
 function revert(transform::Coerce, newtable, cache)
-  names = Tables.columnnames(newtable)
   cols = Tables.columns(newtable)
+  names = Tables.columnnames(cols)
+  
   oldcols = map(zip(cache, names)) do (T, n)
     x = Tables.getcolumn(cols, n)
     collect(T, x)
@@ -47,4 +48,3 @@ function revert(transform::Coerce, newtable, cache)
   𝒯 = (; zip(names, oldcols)...)
   𝒯 |> Tables.materializer(newtable)
 end
-

src/transforms/eigenanalysis.jl

@@ -53,7 +53,8 @@ function apply(transform::EigenAnalysis, table)
   end
 
   # original columns names
-  names = Tables.columnnames(table)
+  cols = Tables.columns(table)
+  names = Tables.columnnames(cols)
 
   # table as matrix
   X = Tables.matrix(table)
@@ -77,7 +78,8 @@ end
 
 function revert(::EigenAnalysis, newtable, cache)
   # transformed column names
-  names = Tables.columnnames(newtable)
+  cols = Tables.columns(newtable)
+  names = Tables.columnnames(cols)
 
   # table as matrix
   Z = Tables.matrix(newtable)
@@ -103,7 +105,8 @@ function reapply(transform::EigenAnalysis, table, cache)
   end
 
   # original columns names
-  names = Tables.columnnames(table)
+  cols = Tables.columns(table)
+  names = Tables.columnnames(cols)
 
   # table as matrix
   X = Tables.matrix(table)

src/transforms/filter.jl

@@ -102,16 +102,17 @@ _nonmissing(::Type{Union{Missing,T}}, x) where {T} = collect(T, x)
 _nonmissing(x) = _nonmissing(eltype(x), x)
 
 function apply(transform::DropMissing, table)
-  names = Tables.columnnames(table)
+  cols = Tables.columns(table)
+  names = Tables.columnnames(cols)
   types = Tables.schema(table).types
   snames = choose(transform.colspec, names)
   ftrans = _ftrans(transform, snames)
   newtable, fcache = apply(ftrans, table)
 
   # post-processing
-  cols = Tables.columns(newtable)
+  ncols = Tables.columns(newtable)
   pcols = map(names) do n
-    x = Tables.getcolumn(cols, n)
+    x = Tables.getcolumn(ncols, n)
     n ∈ snames ? _nonmissing(x) : x
   end
   𝒯 = (; zip(names, pcols)...)
@@ -125,7 +126,7 @@ function revert(::DropMissing, newtable, cache)
 
   # pre-processing
   cols = Tables.columns(newtable)
-  names = Tables.columnnames(newtable)
+  names = Tables.columnnames(cols)
   pcols = map(zip(types, names)) do (T, n)
     x = Tables.getcolumn(cols, n)
     collect(T, x)

src/transforms/functional.jl

@@ -59,7 +59,7 @@ _functuple(func::NamedTuple, names) = func
 
 function apply(transform::Functional, table) 
   cols = Tables.columns(table)
-  names = Tables.columnnames(table)
+  names = Tables.columnnames(cols)
   funcs = _functuple(transform.func, names)
 
   ncols = map(names) do nm
@@ -77,7 +77,7 @@ function revert(transform::Functional, newtable, cache)
   @assert isrevertible(transform) "Transform is not revertible."
 
   cols = Tables.columns(newtable)
-  names = Tables.columnnames(newtable)
+  names = Tables.columnnames(cols)
   funcs = _functuple(transform.func, names)
 
   ocols = map(names) do nm

src/transforms/parallel.jl

@@ -33,7 +33,8 @@ function apply(p::Parallel, table)
   newtable = tablehcat(tables)
 
   # save original column names
-  onames = Tables.columnnames(table)
+  ocols = Tables.columns(table)
+  onames = Tables.columnnames(ocols)
 
   # find first revertible transform
   ind = findfirst(isrevertible, p.transforms)
@@ -42,7 +43,8 @@ function apply(p::Parallel, table)
   rinfo = if isnothing(ind)
     nothing
   else
-    tnames = Tables.columnnames.(tables)
+    tcols  = Tables.columns.(tables)
+    tnames = Tables.columnnames.(tcols)
     ncols  = length.(tnames)
     nrcols = ncols[ind]
     start  = sum(ncols[1:ind-1]) + 1
@@ -99,7 +101,7 @@ function tablehcat(tables)
   varsdict = Set{Symbol}()
   for 𝒯 in tables
     cols = Tables.columns(𝒯)
-    vars = Tables.columnnames(𝒯)
+    vars = Tables.columnnames(cols)
     vals = [Tables.getcolumn(cols, var) for var in vars]
     for (var, val) in zip(vars, vals)
       while var ∈ varsdict

src/transforms/rename.jl

@@ -35,7 +35,8 @@ end
 
 
 function _rename(names, table)
-  oldnames = Tables.columnnames(table)
+  cols = Tables.columns(table)
+  oldnames = Tables.columnnames(cols)
 
   # check if requested renames exist in the table
   @assert keys(names) ⊆ oldnames "invalid column names"
@@ -46,7 +47,6 @@ function _rename(names, table)
   end
 
   # table with new tables
-  cols = Tables.columns(table)
   vals = [Tables.getcolumn(cols, name) for name in oldnames]
   𝒯 = (; zip(newnames, vals)...) |> Tables.materializer(table)
 

src/transforms/select.jl

@@ -80,8 +80,11 @@ Select(cols::T...) where {T<:ColSelector} =
 isrevertible(::Type{<:Select}) = true
 
 function apply(transform::Select, table)
+  # original columns
+  cols = Tables.columns(table)
+
   # retrieve relevant column names
-  allcols = collect(Tables.columnnames(table))
+  allcols = collect(Tables.columnnames(cols))
   select  = choose(transform.colspec, allcols)
   reject  = setdiff(allcols, select)
 
@@ -95,9 +98,6 @@ function apply(transform::Select, table)
   reject = reject[sorted]
   rinds  = rinds[sorted]
 
-  # original columns
-  cols = Tables.columns(table)
-
   # rejected columns
   rcols = [Tables.getcolumn(cols, name) for name in reject]
 
@@ -107,7 +107,7 @@ end
 function revert(::Select, newtable, cache)
   # selected columns
   cols   = Tables.columns(newtable)
-  select = Tables.columnnames(newtable)
+  select = Tables.columnnames(cols)
   scols  = [Tables.getcolumn(cols, name) for name in select]
 
   # rejected columns
@@ -162,7 +162,8 @@ Reject(cols::T...) where {T<:ColSelector} =
 isrevertible(::Type{<:Reject}) = true
 
 function apply(transform::Reject, table)
-  allcols = Tables.columnnames(table)
+  cols = Tables.columns(table)
+  allcols = Tables.columnnames(cols)
   reject  = choose(transform.colspec, allcols)
   select  = setdiff(allcols, reject)
   strans  = Select(select)