Improve juliatype() (#232)

* add comments for juliatype() methods

* juliatype(): support more SQLite type strings

addresses issue mentioned in #219

* juliatype(): fall back to stored type when typestr

is not recognized

* more SQLite -> Julia type conversion tests

Author: alyst

src/SQLite.jl

@@ -345,46 +345,56 @@ end
  #int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
  #int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 
+# get julia type for given column of the given statement
 function juliatype(handle, col)
-    t = SQLite.sqlite3_column_decltype(handle, col)
-    if t != C_NULL
-        T = juliatype(unsafe_string(t))
-        T !== Any && return T
+    stored_typeid = SQLite.sqlite3_column_type(handle, col)
+    if stored_typeid == SQLite.SQLITE_BLOB
+        # blobs are serialized julia types, so just try to deserialize it
+        deser_val = SQLite.sqlitevalue(Any, handle, col)
+        # FIXME deserialized type have priority over declared type, is it fine?
+        return typeof(deser_val)
+    else
+        stored_type = juliatype(stored_typeid)
     end
-    x = SQLite.sqlite3_column_type(handle, col)
-    if x == SQLite.SQLITE_BLOB
-        val = SQLite.sqlitevalue(Any, handle, col)
-        return typeof(val)
+    decl_typestr = SQLite.sqlite3_column_decltype(handle, col)
+    if decl_typestr != C_NULL
+        return juliatype(unsafe_string(decl_typestr), stored_type)
     else
-        return juliatype(x)
+        return stored_type
     end
 end
 
+# convert SQLite stored type into Julia equivalent
 juliatype(x::Integer) =
     x == SQLITE_INTEGER ? Int :
     x == SQLITE_FLOAT ? Float64 :
     x == SQLITE_TEXT ? String :
     Any
 
-function juliatype(typestr::AbstractString)
-    typeuc = uppercase(typestr)
+# convert SQLite declared type into Julia equivalent,
+# fall back to default (stored type), if no good match
+function juliatype(decl_typestr::AbstractString,
+                   default::Type = Any)
+    typeuc = uppercase(decl_typestr)
     if typeuc in ("INTEGER", "INT")
         return Int
-    elseif typeuc in ("NUMERIC", "REAL")
+    elseif typeuc in ("NUMERIC", "REAL", "FLOAT")
         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 default # FIXME
+    elseif typeuc == "TIMESTAMP"
+        return default # FIXME
+    elseif occursin(r"^(?:N?VAR)?CHAR\(\d+\)$", typeuc)
         return String
     elseif occursin(r"^NUMERIC\(\d+,\d+\)$", typeuc)
         return Float64
     else
-        @warn "Unsupported SQLite type $typestr"
-        return Any
+        @warn "Unsupported SQLite declared type $decl_typestr, falling back to $default type"
+        return default
     end
 end
 

test/runtests.jl

@@ -272,15 +272,36 @@ stmt = DBInterface.prepare(db, "INSERT INTO tbl (a) VALUES (@a);")
 SQLite.bind!(stmt, "@a", 1)
 SQLite.clear!(stmt)
 
-binddb = SQLite.DB()
-DBInterface.execute(binddb, "CREATE TABLE temp (n NULL, i6 INT, f REAL, s TEXT, a BLOB)")
-DBInterface.execute(binddb, "INSERT INTO temp VALUES (?1, ?2, ?3, ?4, ?5)", [missing, Int64(6), 6.4, "some text", b"bytearray"])
-r = DBInterface.execute(binddb, "SELECT * FROM temp") |> columntable
-@test isa(r[1][1], Missing)
-@test isa(r[2][1], Int)
-@test isa(r[3][1], Float64)
-@test isa(r[4][1], AbstractString)
-@test isa(r[5][1], Base.CodeUnits)
+@testset "SQLite to Julia type conversion" begin
+    binddb = SQLite.DB()
+    DBInterface.execute(binddb,
+        "CREATE TABLE temp (n NULL, i1 INT, i2 integer,
+                            f1 REAL, f2 FLOAT, f3 NUMERIC,
+                            s1 TEXT, s2 CHAR(10), s3 VARCHAR(15), s4 NVARCHAR(5),
+                            d1 DATETIME, ts1 TIMESTAMP,
+                            b BLOB,
+                            x1 UNKNOWN1, x2 UNKNOWN2)")
+    DBInterface.execute(binddb, "INSERT INTO temp VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        [missing, Int64(6), Int64(4),
+         6.4, 6.3, Int64(7),
+        "some long text", "short text", "another text", "short",
+        "2021-02-21", "2021-02-12::1532",
+        b"bytearray",
+        "actually known", 435])
+    rr = (;) # just to have the var declared
+    @test_logs(
+        (:warn, "Unsupported SQLite declared type UNKNOWN1, falling back to String type"),
+        (:warn, "Unsupported SQLite declared type UNKNOWN2, falling back to $(Int) type"),
+        rr = DBInterface.execute(rowtable, binddb, "SELECT * FROM temp"))
+    @test length(rr) == 1
+    r = first(rr)
+    @test typeof.(Tuple(r)) == (Missing, Int, Int,
+                            Float64, Float64, Int,
+                            String, String, String, String,
+                            String, String,
+                            Base.CodeUnits{UInt8, String},
+                            String, Int)
+end
 
 ############################################