wip: implement Rename transform

src/TableTransforms.jl

@@ -31,6 +31,7 @@ export
   # built-in
   Select,
   Reject,
+  Rename,
   Identity,
   Center,
   Scale,

src/transforms.jl

@@ -213,6 +213,7 @@ end
 
 include("transforms/identity.jl")
 include("transforms/select.jl")
+include("transforms/rename.jl")
 include("transforms/center.jl")
 include("transforms/scale.jl")
 include("transforms/zscore.jl")

src/transforms/rename.jl

@@ -0,0 +1,50 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+  Rename(:col₁ => :newcol₁, :col₂ => :newcol₂, ..., :col₁ => :newcolₙ)
+
+The transform that renames `col₁` to `newcol₁`, `col₂` to `newcol₂`, ...
+"""
+struct Rename <: Stateless
+  names::Dict{Symbol,Symbol}
+end
+
+pairsyms(x::Pair) = Symbol(first(x)) => Symbol(last(x))
+
+Rename(names::Pair) = pairsyms(names) |> Dict |> Rename
+Rename(names...) = pairsyms.(names) |> Dict |> Rename
+
+function apply(transform::Rename, table)
+  _rename(transform.names, table)
+end
+
+function revert(transform::Rename, table, cache)
+  # reversing the key-value pairs of the Dict
+  newnames = Dict()
+  for (old, new) in transform.names
+    newnames[new] = old
+  end
+  _rename(newnames, table) |> first
+end
+
+
+function _rename(names, table)
+  oldnames = Tables.columnnames(table)
+
+  # check if requested renames exist in the table
+  diff = setdiff(keys(names), oldnames) .|> String |> Tuple
+  @assert length(diff) == 0
+    "The following column[s] were not found in the source table: $diff"
+
+  newnames = map(oldnames) do oldname
+    oldname in keys(names) ? names[oldname] : oldname
+  end
+
+  cols = Tables.columns(table)
+  vals = [Tables.getcolumn(cols, name) for name in oldnames]
+  𝒯 = (; zip(newnames, vals)...) |> Tables.materializer(table)
+
+  𝒯, nothing
+end

test/transforms.jl

@@ -131,6 +131,59 @@
     @test n1 == n2
   end
 
+  @testset "Rename" begin
+    a = rand(4000)
+    b = rand(4000)
+    c = rand(4000)
+    d = rand(4000)
+    t = Table(; a, b, c, d)
+
+    T = Rename(Dict(:a => :x))
+    n, c = apply(T, t)
+    @test Tables.columnnames(n) == (:x, :b, :c, :d)
+    tₒ = revert(T, n, c)
+    @test t == tₒ
+
+    T = Rename(Dict(:a => :x, :c => :y))
+    n, c = apply(T, t)
+    @test Tables.columnnames(n) == (:x, :b, :y, :d)
+    tₒ = revert(T, n, c)
+    @test t == tₒ
+
+    # rename with string pairs
+    T = Rename("a" => "x", "c" => "y")
+    n, c = apply(T, t)
+    @test Tables.columnnames(n) == (:x, :b, :y, :d)
+    tₒ = revert(T, n, c)
+    @test t == tₒ
+
+    # rename with symbol pairs
+    T = Rename(:a => :x, :c => :y)
+    n, c = apply(T, t)
+    @test Tables.columnnames(n) == (:x, :b, :y, :d)
+    tₒ = revert(T, n, c)
+    @test t == tₒ
+
+    # rename with mixed pairs
+    T = Rename("a" => :x)
+    n, c = apply(T, t)
+    @test Tables.columnnames(n) == (:x, :b, :c, :d)
+    tₒ = revert(T, n, c)
+    @test t == tₒ
+
+    T = Rename("a" => :x, :c => "y")
+    n, c = apply(T, t)
+    @test Tables.columnnames(n) == (:x, :b, :y, :d)
+    tₒ = revert(T, n, c)
+    @test t == tₒ
+
+    # reapply test
+    T = Rename(:b => :x, :d => :y)
+    n1, c1 = apply(T, t)
+    n2 = reapply(T, t, c1)
+    @test n1 == n2
+  end
+
   @testset "Identity" begin
     x = rand(4000)
     y = rand(4000)