Correct scheme for empty Query (#231)

* juliatype(str): recognize more SQLite decltypes

* add isempty(Query)

* Query: provide proper schema if result is empty

Author: alyst

src/SQLite.jl

@@ -360,8 +360,33 @@ function juliatype(handle, col)
     end
 end
 
-juliatype(x::Integer) = x == SQLITE_INTEGER ? Int : x == SQLITE_FLOAT ? Float64 : x == SQLITE_TEXT ? String : Any
-juliatype(x::String) = x == "INTEGER" ? Int : x in ("NUMERIC","REAL") ? Float64 : x == "TEXT" ? String : Any
+juliatype(x::Integer) =
+    x == SQLITE_INTEGER ? Int :
+    x == SQLITE_FLOAT ? Float64 :
+    x == SQLITE_TEXT ? String :
+    Any
+
+function juliatype(typestr::AbstractString)
+    typeuc = uppercase(typestr)
+    if typeuc in ("INTEGER", "INT")
+        return Int
+    elseif typeuc in ("NUMERIC", "REAL")
+        return Float64
+    elseif typeuc == "TEXT"
+        return String
+    elseif typeuc == "BLOB"
+        return Any
+    elseif typeuc == "DATETIME"
+        return Any # FIXME
+    elseif occursin(r"^NVARCHAR\(\d+\)$", typeuc)
+        return String
+    elseif occursin(r"^NUMERIC\(\d+,\d+\)$", typeuc)
+        return Float64
+    else
+        @warn "Unsupported SQLite type $typestr"
+        return Any
+    end
+end
 
 sqlitevalue(::Type{T}, handle, col) where {T <: Union{Base.BitSigned, Base.BitUnsigned}} = convert(T, sqlite3_column_int64(handle, col))
 const FLOAT_TYPES = Union{Float16, Float32, Float64} # exclude BigFloat

src/tables.jl

@@ -10,13 +10,27 @@ struct Query
     lookup::Dict{Symbol, Int}
 end
 
+# check if the query has no (more) rows
+Base.isempty(q::Query) = q.status[] == SQLITE_DONE
+
 struct Row <: Tables.AbstractRow
     q::Query
 end
 
 getquery(r::Row) = getfield(r, :q)
 
 Tables.isrowtable(::Type{Query}) = true
+Tables.columnnames(q::Query) = q.names
+
+function Tables.schema(q::Query)
+    if isempty(q)
+        # when the query is empty, return the types provided by SQLite
+        # by default SQLite.jl assumes all columns can have missing values
+        Tables.Schema(Tables.columnnames(q), q.types)
+    else
+        return nothing # fallback to the actual column types of the result
+    end
+end
 
 Base.IteratorSize(::Type{Query}) = Base.SizeUnknown()
 Base.eltype(q::Query) = Row
@@ -57,7 +71,7 @@ Tables.getcolumn(r::Row, ::Type{T}, i::Int, nm::Symbol) where {T} = getvalue(get
 
 Tables.getcolumn(r::Row, i::Int) = Tables.getcolumn(r, getquery(r).types[i], i, getquery(r).names[i])
 Tables.getcolumn(r::Row, nm::Symbol) = Tables.getcolumn(r, getquery(r).lookup[nm])
-Tables.columnnames(r::Row) = getquery(r).names
+Tables.columnnames(r::Row) = Tables.columnnames(getquery(r))
 
 function Base.iterate(q::Query)
     done(q) && return nothing

test/runtests.jl

@@ -84,6 +84,23 @@ results1 = SQLite.tables(db)
     DBInterface.close!(employees_stmt)
 end
 
+@testset "isempty(::Query)" begin
+    @test !DBInterface.execute(isempty, db, "SELECT * FROM Employee")
+    @test DBInterface.execute(isempty, db, "SELECT * FROM Employee WHERE FirstName='Joanne'")
+end
+
+@testset "empty query has correct schema and return type" begin
+    empty_scheme = DBInterface.execute(Tables.schema, db, "SELECT * FROM Employee WHERE FirstName='Joanne'")
+    all_scheme = DBInterface.execute(Tables.schema, db, "SELECT * FROM Employee WHERE FirstName='Joanne'")
+    @test empty_scheme.names == all_scheme.names
+    @test all(ea -> ea[1] <: ea[2], zip(empty_scheme.types, all_scheme.types))
+
+    empty_tbl = DBInterface.execute(columntable, db, "SELECT * FROM Employee WHERE FirstName='Joanne'")
+    all_tbl = DBInterface.execute(columntable, db, "SELECT * FROM Employee")
+    @test propertynames(empty_tbl) == propertynames(all_tbl)
+    @test all(col -> eltype(empty_tbl[col]) >: eltype(all_tbl[col]), propertynames(all_tbl))
+end
+
 DBInterface.execute(db, "create table temp as select * from album")
 DBInterface.execute(db, "alter table temp add column colyear int")
 DBInterface.execute(db, "update temp set colyear = 2014")