Implement a generic row iterator

src/TableTransforms.jl

@@ -30,6 +30,7 @@ include("assertions.jl")
 include("tabletraits.jl")
 include("distributions.jl")
 include("tableselection.jl")
+include("tablerows.jl")
 include("transforms.jl")
 
 export

src/tablerows.jl

@@ -0,0 +1,126 @@
+"""
+    tablerows(table)
+
+Returns an appropriate iterator for table rows.
+The rows are iterable, implement the `Tables.AbstractRow` interface
+and the following ways of column access:
+
+```julia
+row.colname
+row."colname"
+row[colindex]
+row[:colname]
+row["colname"]
+```
+"""
+function tablerows(table)
+  if !Tables.istable(table)
+    throw(ArgumentError("the argument is not a table"))
+  end
+
+  if Tables.rowaccess(table)
+    RTableRows(table)
+  else
+    CTableRows(table)
+  end
+end
+
+#------------------
+# COMMON INTERFACE
+#------------------
+
+abstract type TableRow end
+
+# column access
+Base.getproperty(row::TableRow, nm::Symbol) = Tables.getcolumn(row, nm)
+Base.getproperty(row::TableRow, nm::AbstractString) = Tables.getcolumn(row, Symbol(nm))
+Base.getindex(row::TableRow, i::Int) = Tables.getcolumn(row, i)
+Base.getindex(row::TableRow, nm::Symbol) = Tables.getcolumn(row, nm)
+Base.getindex(row::TableRow, nm::AbstractString) = Tables.getcolumn(row, Symbol(nm))
+
+# iterator interface
+Base.length(row::TableRow) = length(Tables.columnnames(row))
+Base.iterate(row::TableRow, state=1) =
+  state > length(row) ? nothing : (Tables.getcolumn(row, state), state + 1)
+
+#--------------
+# COLUMN TABLE
+#--------------
+
+struct CTableRows{T}
+  cols::T
+  nrows::Int
+
+  function CTableRows(table)
+    cols = Tables.columns(table)
+    nrows = _nrows(cols)
+    new{typeof(cols)}(cols, nrows)
+  end
+end
+
+# iterator interface
+Base.length(rows::CTableRows) = rows.nrows
+Base.iterate(rows::CTableRows, state::Int=1) = 
+  state > length(rows) ? nothing : (CTableRow(rows.cols, state), state + 1)
+
+struct CTableRow{T} <: TableRow
+  cols::T
+  ind::Int
+end
+
+# getters
+getcols(row::CTableRow) = getfield(row, :cols)
+getind(row::CTableRow) = getfield(row, :ind)
+
+# AbstractRow interface
+Tables.columnnames(row::CTableRow) = Tables.columnnames(getcols(row))
+Tables.getcolumn(row::CTableRow, i::Int) = Tables.getcolumn(getcols(row), i)[getind(row)]
+Tables.getcolumn(row::CTableRow, nm::Symbol) = Tables.getcolumn(getcols(row), nm)[getind(row)]
+
+#-----------
+# ROW TABLE
+#-----------
+
+struct RTableRows{T}
+  rows::T
+
+  function RTableRows(table)
+    rows = Tables.rows(table)
+    new{typeof(rows)}(rows)
+  end
+end
+
+# iterator interface
+Base.length(rows::RTableRows) = length(rows.rows)
+function Base.iterate(rows::RTableRows, args...)
+  next = iterate(rows.rows, args...)
+  if isnothing(next)
+    nothing
+  else
+    row, state = next
+    (RTableRow(row), state)
+  end
+end
+
+struct RTableRow{T} <: TableRow
+  row::T
+end
+
+# getters
+getrow(row::RTableRow) = getfield(row, :row)
+
+# AbstractRow interface
+Tables.columnnames(row::RTableRow) = Tables.columnnames(getrow(row))
+Tables.getcolumn(row::RTableRow, i::Int) = Tables.getcolumn(getrow(row), i)
+Tables.getcolumn(row::RTableRow, nm::Symbol) = Tables.getcolumn(getrow(row), nm)
+
+#-------
+# UTILS
+#-------
+
+function _nrows(cols)
+  names = Tables.columnnames(cols)
+  isempty(names) && return 0
+  column = Tables.getcolumn(cols, first(names))
+  length(column)
+end

src/transforms/filter.jl

@@ -12,6 +12,10 @@ Filters the table returning only the rows where the `func` returns true.
 ```julia
 Filter(row -> sum(row) > 10)
 Filter(row -> row.a == true && row.b < 30)
+Filter(row -> row."a" == true && row."b" < 30)
+Filter(row -> row[1] == true && row[2] < 30)
+Filter(row -> row[:a] == true && row[:b] < 30)
+Filter(row -> row["a"] == true && row["b"] < 30)
 ```
 
 ## Notes
@@ -26,7 +30,7 @@ isrevertible(::Type{<:Filter}) = true
 
 function preprocess(transform::Filter, table)
   # lazy row iterator
-  rows = Tables.rows(table)
+  rows = tablerows(table)
 
   # selected indices
   sinds, nrows = Int[], 0

test/colspec.jl

@@ -3,104 +3,104 @@
   tupnames = (:a, :b, :c, :d, :e, :f)
 
   # vector of symbols
-  colspec = TableTransforms.colspec([:a, :c, :e])
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec([:a, :c, :e])
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # tuple of symbols
-  colspec = TableTransforms.colspec((:a, :c, :e))
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec((:a, :c, :e))
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # vector of strings
-  colspec = TableTransforms.colspec(["a", "c", "e"])
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec(["a", "c", "e"])
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # tuple of strings
-  colspec = TableTransforms.colspec(("a", "c", "e"))
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec(("a", "c", "e"))
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # vector of integers
-  colspec = TableTransforms.colspec([1, 3, 5])
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec([1, 3, 5])
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # tuple of integers
-  colspec = TableTransforms.colspec((1, 3, 5))
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec((1, 3, 5))
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # regex
-  colspec = TableTransforms.colspec(r"[ace]")
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec(r"[ace]")
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :c, :e]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :c, :e]
 
   # colon
-  colspec = TableTransforms.colspec(:)
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec(:)
+  snames = TT.choose(colspec, vecnames)
   @test snames == [:a, :b, :c, :d, :e, :f]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == [:a, :b, :c, :d, :e, :f]
 
   # nothing
-  colspec = TableTransforms.colspec(nothing)
-  snames = TableTransforms.choose(colspec, vecnames)
+  colspec = TT.colspec(nothing)
+  snames = TT.choose(colspec, vecnames)
   @test snames == Symbol[]
-  snames = TableTransforms.choose(colspec, tupnames)
+  snames = TT.choose(colspec, tupnames)
   @test snames == Symbol[]
 
   # throws
-  colspec = TableTransforms.colspec(r"x")
-  @test_throws AssertionError TableTransforms.choose(colspec, vecnames)
-  @test_throws AssertionError TableTransforms.choose(colspec, tupnames)
-  @test_throws AssertionError TableTransforms.colspec(Symbol[])
-  @test_throws AssertionError TableTransforms.colspec(String[])
-  @test_throws AssertionError TableTransforms.colspec(Int[])
-  @test_throws ArgumentError TableTransforms.colspec(())
-  @test_throws ArgumentError TableTransforms.colspec(missing)
+  colspec = TT.colspec(r"x")
+  @test_throws AssertionError TT.choose(colspec, vecnames)
+  @test_throws AssertionError TT.choose(colspec, tupnames)
+  @test_throws AssertionError TT.colspec(Symbol[])
+  @test_throws AssertionError TT.colspec(String[])
+  @test_throws AssertionError TT.colspec(Int[])
+  @test_throws ArgumentError TT.colspec(())
+  @test_throws ArgumentError TT.colspec(missing)
 
   # type stability
-  colspec = TableTransforms.colspec([:a, :b])
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec((:a, :b))
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec(["a", "b"])
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec(("a", "b"))
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec([1, 2])
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec((1, 2))
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec(r"[ab]")
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec(:)
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
-  colspec = TableTransforms.colspec(nothing)
-  @inferred TableTransforms.choose(colspec, vecnames)
-  @inferred TableTransforms.choose(colspec, tupnames)
+  colspec = TT.colspec([:a, :b])
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec((:a, :b))
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(["a", "b"])
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(("a", "b"))
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec([1, 2])
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec((1, 2))
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(r"[ab]")
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(:)
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(nothing)
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
 end

test/distributions.jl

@@ -1,6 +1,6 @@
 @testset "Distributions" begin
   values = randn(1000)
-  d = TableTransforms.EmpiricalDistribution(values)
+  d = TT.EmpiricalDistribution(values)
   @test 0.0 ≤ cdf(d, rand()) ≤ 1.0
   @test minimum(values) ≤ quantile(d, 0.5) ≤ maximum(values)
 end

test/runtests.jl

@@ -39,8 +39,16 @@ Polynomial(args::T...) where {T<:Real} = Polynomial(collect(args))
 include("metatable.jl")
 
 # list of tests
-testfiles =
-  ["distributions.jl", "colspec.jl", "assertions.jl", "transforms.jl", "metadata.jl", "tableselection.jl", "shows.jl"]
+testfiles = [
+  "distributions.jl",
+  "colspec.jl",
+  "assertions.jl",
+  "transforms.jl",
+  "metadata.jl",
+  "tableselection.jl",
+  "tablerows.jl",
+  "shows.jl"
+]
 
 @testset "TableTransforms.jl" begin
   for testfile in testfiles