Rearrange some definitions to make DataValues/Enumerables work better

Author: quinnj

src/Tables.jl

@@ -22,6 +22,13 @@ function __init__()
         allocatecolumn(::Type{WeakRefString{T}}, rows) where {T} = StringVector(rows)
         allocatecolumn(::Type{Union{Missing, WeakRefString{T}}}, rows) where {T} = StringVector{Union{Missing, String}}(rows)
     end
+    @require IteratorInterfaceExtensions="82899510-4779-5014-852e-03e436cf321d" begin
+        using .IteratorInterfaceExtensions
+        IteratorInterfaceExtensions.getiterator(x::RowTable) = datavaluerows(x)
+        IteratorInterfaceExtensions.isiterable(x::RowTable) = true
+        IteratorInterfaceExtensions.getiterator(x::ColumnTable) = datavaluerows(x)
+        IteratorInterfaceExtensions.isiterable(x::ColumnTable) = true
+    end
 end
 
 include("utils.jl")
@@ -89,11 +96,11 @@ struct ColumnAccess <: AccessStyle end
 "Tables.schema(s) => NamedTuple{names, types}"
 function schema end
 
-function istable(x::T) where {T}
-    hasmethod(AccessStyle, Tuple{T}) &&
-    hasmethod(schema, Tuple{T}) &&
-    AccessStyle(T) === RowAccess() ? hasmethod(rows, Tuple{T}) :
-    AccessStyle(T) === ColumnAccess() ? hasmethod(columns, Tuple{T}) : false
+function istable(::Type{T}) where {T}
+    hasmethod(Tables.AccessStyle, Tuple{T}) &&
+    hasmethod(Tables.schema, Tuple{T}) &&
+    (Tables.AccessStyle(T) === Tables.RowAccess() ? hasmethod(Tables.rows, Tuple{T}) :
+    Tables.AccessStyle(T) === Tables.ColumnAccess() ? hasmethod(Tables.columns, Tuple{T}) : false)
 end
 
 include("namedtuples.jl")
@@ -154,17 +161,19 @@ end
 @inline add!(val, col::Int, nm::Symbol, ::Base.HasLength, nt, row) = setindex!(nt[col], val, row)
 @inline add!(val, col::Int, nm::Symbol, T, nt, row) = push!(nt[col], val)
 
+@inline function buildcolumns(sch, rowitr::T) where {T}
+    L = Base.IteratorSize(T)
+    len = L == Base.HasLength() ? length(rowitr) : 0
+    nt = allocatecolumns(sch, len)
+    for (i, row) in enumerate(rowitr)
+        unroll(add!, sch, row, L, nt, i)
+    end
+    return nt
+end
+
 @inline function columns(x::T) where {T}
     if AccessStyle(T) === RowAccess()
-        sch = schema(x)
-        rowitr = rows(x)
-        L = Base.IteratorSize(typeof(rowitr))
-        len = L == Base.HasLength() ? length(rowitr) : 0
-        nt = allocatecolumns(sch, len)
-        for (i, row) in enumerate(rowitr)
-            unroll(add!, sch, row, L, nt, i)
-        end
-        return nt
+        return buildcolumns(schema(x), rows(x))
     elseif AccessStyle(T) === ColumnAccess()
         return x
     else

src/datavalues.jl

@@ -1,6 +1,16 @@
 using .DataValues
 
 # DataValue-compatible row iteration for Data.Sources
+nondatavaluetype(::Type{DataValue{T}}) where {T} = Union{T, Missing}
+nondatavaluetype(::Type{T}) where {T} = T
+Base.@pure function nondatavaluetype(::Type{NT}) where {NT <: NamedTuple{names}} where {names}
+    TT = Tuple{Any[ nondatavaluetype(fieldtype(NT, i)) for i = 1:fieldcount(NT) ]...}
+    return NamedTuple{names, TT}
+end
+
+unwrap(x) = x
+unwrap(x::DataValue) = isna(x) ? missing : DataValues.unsafe_get(x)
+
 datavaluetype(::Type{T}) where {T <: DataValue} = T
 datavaluetype(::Type{T}) where {T} = DataValue{T}
 datavaluetype(::Type{Union{T, Missing}}) where {T} = DataValue{T}

src/enumerable.jl

@@ -1,19 +1,9 @@
 using .QueryOperators
 
-nondatavaluetype(::Type{DataValue{T}}) where {T} = Union{T, Missing}
-nondatavaluetype(::Type{T}) where {T} = T
-
-Base.@pure function nondatavaluetype(::Type{NT}) where {NT <: NamedTuple{names}} where {names}
-    TT = Tuple{Any[ nondatavaluetype(fieldtype(NT, i)) for i = 1:fieldcount(NT) ]...}
-    return NamedTuple{names, TT}
-end
-
 struct DataValueUnwrapRow{T}
     row::T
 end
 
-unwrap(x) = x
-unwrap(x::DataValue) = isna(x) ? missing : DataValues.unsafe_get(x)
 Base.getproperty(d::DataValueUnwrapRow, ::Type{T}, col::Int, nm::Symbol) where {T} = unwrap(getproperty(getfield(d, 1), T, col, nm))
 Base.getproperty(d::DataValueUnwrapRow, nm::Symbol) = unwrap(getproperty(getfield(d, 1), nm))
 Base.propertynames(d::DataValueUnwrapRow) = propertynames(getfield(d, 1))
@@ -36,10 +26,3 @@ function Base.iterate(rows::DataValueUnwrapper{NT}, st=()) where {NT <: NamedTup
     row, st = x
     return DataValueUnwrapRow(row), (st,)
 end
-
-using IteratorInterfaceExtensions
-
-IteratorInterfaceExtensions.getiterator(x::RowTable) = datavaluerows(x)
-IteratorInterfaceExtensions.isiterable(x::RowTable) = true
-IteratorInterfaceExtensions.getiterator(x::ColumnTable) = datavaluerows(x)
-IteratorInterfaceExtensions.isiterable(x::ColumnTable) = true