Use an empty DataFrame for DataFrame indexing things & import/export cleanup (#21)

Author: krynju

Project.toml

@@ -1,7 +1,7 @@
 name = "DTables"
 uuid = "20c56dc6-594c-4682-91cf-1d46875b1eba"
 authors = ["Krystian Guliński", "Julian Samaroo", "and contributors"]
-version = "0.2.0"
+version = "0.2.1"
 
 [deps]
 Dagger = "d58978e5-989f-55fb-8d15-ea34adc7bf54"

src/DTables.jl

@@ -5,22 +5,22 @@ module DTables
 ############################################################################################
 
 using Dagger: Dagger
-using DataAPI: BroadcastedSelector
+using DataAPI: All, Between, Cols
 using DataFrames:
-    AbstractDataFrame,
+    DataFrame,
     AsTable,
-    ByRow,
     ColumnIndex,
     MultiColumnIndex,
     normalize_selection,
     Index,
     make_pair_concrete
-using InvertedIndices: BroadcastedInvertedIndex
+using InvertedIndices: Not
 using SentinelArrays: ChainedVector
 using TableOperations: TableOperations
 using Tables:
     columnindex,
     columnnames,
+    ByRow,
     columns,
     columntable,
     getcolumn,
@@ -50,28 +50,44 @@ import Base:
     reduce,
     show,
     wait
+
 import DataAPI: leftjoin, ncol, nrow, innerjoin
 import Tables:
     columnaccess, columnnames, columns, getcolumn, istable, partitions, rowaccess, rows, schema
-import DataFrames: broadcast_pair, select
+import DataFrames: broadcast_pair, select, index
 
 ############################################################################################
 # Export
 ############################################################################################
 
-export DTable, DTableColumn, innerjoin, leftjoin, select, tabletype, tabletype!, trim, trim!
-
+export All,
+    AsTable,
+    Between,
+    ByRow,
+    Cols,
+    DTable,
+    DTableColumn,
+    innerjoin,
+    leftjoin,
+    ncol,
+    Not,
+    nrow,
+    select,
+    tabletype,
+    tabletype!,
+    trim,
+    trim!
 ############################################################################################
 
 include("table/dtable.jl")
 include("table/gdtable.jl")
 include("table/tables.jl")
-include("table/operations.jl")
-include("table/groupby.jl")
-include("table/join_interface.jl")
-include("table/join.jl")
 include("table/dtable_column.jl")
-include("table/dataframes_interface_utils.jl")
-include("table/dataframes_interface.jl")
+include("operations/operations.jl")
+include("operations/groupby.jl")
+include("operations/join_interface.jl")
+include("operations/join.jl")
+include("operations/dataframes_interface_utils.jl")
+include("operations/dataframes_interface.jl")
 
 end

src/table/dataframes_interface.jl renamed to src/operations/dataframes_interface.jl

@@ -1,8 +1,4 @@
-struct DTableAbstractDataFrameWrapper <: AbstractDataFrame
-    d::DTable
-end
-
-broadcast_pair(df::DTable, p) = broadcast_pair(DTableAbstractDataFrameWrapper(df), p)
+broadcast_pair(dt::DTable, p) = broadcast_pair(empty_dataframe(dt), p)
 
 # Not copied - full custom implementation
 # There's a copymetadata here now

src/table/dataframes_interface_utils.jl renamed to src/operations/dataframes_interface_utils.jl

@@ -270,6 +270,7 @@ function merge_chunks(sink, chunks)
 end
 
 names(dt::DTable) = string.(columnnames_svector(dt))
+names(dt::DTable, cols) = names(empty_dataframe(dt), cols)
 propertynames(dt::DTable) = columnnames_svector(dt)
 
 function wait(dt::DTable)
@@ -294,3 +295,11 @@ end
 ncol(d::DTable) = length(columns(d))
 nrow(d::DTable) = length(d)
 index(df::DTable) = Index(columnnames_svector(df))
+
+function empty_dataframe(dt::DTable)
+    s = determine_schema(dt)
+    return DataFrame(
+        Pair{Symbol}[s.names[i] => s.types[i][] for i in eachindex(s.names, s.types)];
+        copycols=false,
+    )
+end

src/table/groupby.jl renamed to src/operations/groupby.jl

@@ -52,4 +52,13 @@ using SentinelArrays: ChainedVector
         @test fetch(select(dt, [] => ByRow(rand) => :x)).x isa ChainedVector{Float64, Vector{Float64}}
         @test fetch(select(dt, [] => (() -> rand(s)) => :x)).x isa ChainedVector{Float64, Vector{Float64}}
     end
+
+    @testset "names" begin
+        v = DTable((a=[1], x1=[2], x2=[3], x3=[4], x4=[5]))
+        @test names(v, All()) == names(v, :) == names(v) == ["a", "x1", "x2", "x3", "x4"]
+        @test names(v, Between(:x1, :x3)) == ["x1", "x2", "x3"]
+        @test names(v, Not(:a)) == names(v, r"x") == ["x1", "x2", "x3", "x4"]
+        @test names(v, :x1) == names(v, 2) == ["x1"]
+        @test names(v, Cols()) == names(v, Cols()) == []
+    end
 end