Return values in types other than string

.envrc

@@ -1,2 +1,2 @@
-use flake "git+https://gitea.c3d2.de/ehmry/meta?ref=flake#simplex_history_actor"
 source_env ..
+use flake syndicate#sqlite_actor

README.md

@@ -2,6 +2,10 @@
 
 Syndicate actor for accessing SQLite databases.
 
+## Build
+
+Depends on the [SQLcipher](https://www.zetetic.net/sqlcipher/) library and pkg-config.
+
 ## Example configuration
 ```
 ? <example-dataspace ?ds> [

src/sqlite_actor.nim

@@ -1,27 +1,112 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 
+# Avoid Sqlite3 from the standard library because it is
+# only held together by wishful thinking and dlload.
+
 {.passC: staticExec("pkg-config --cflags sqlcipher").}
 {.passL: staticExec("pkg-config --libs sqlcipher").}
 
-import std/db_sqlite
+{.pragma: sqlite3h, header: "sqlite3.h".}
+
+var
+  SQLITE_VERSION_NUMBER {.importc, sqlite3h.}: cint
+  SQLITE_OK {.importc, sqlite3h.}: cint
+  SQLITE_ROW {.importc, sqlite3h.}: cint
+  SQLITE_DONE {.importc, sqlite3h.}: cint
+  SQLITE_OPEN_READONLY {.importc, sqlite3h.}: cint
+
+const
+  SQLITE_INTEGER = 1
+  SQLITE_FLOAT = 2
+  SQLITE_TEXT = 3
+  SQLITE_BLOB = 4
+  # SQLITE_NULL = 5
+
+type
+  Sqlite3 {.importc: "sqlite3", sqlite3h.} = distinct pointer
+  Stmt {.importc: "sqlite3_stmt", sqlite3h.} = distinct pointer
+
+{.pragma: importSqlite3, importc: "sqlite3_$1", sqlite3h.}
+
+proc libversion_number: cint {.importSqlite3.}
+
+proc open_v2(filename: cstring; ppDb: ptr Sqlite3; flags: cint; zVfs: cstring): cint {.importSqlite3.}
+proc close(ds: Sqlite3): int32 {.discardable, importSqlite3.}
+
+proc errmsg(db: Sqlite3): cstring {.importSqlite3.}
+
+proc prepare_v2(db: Sqlite3; zSql: cstring, nByte: cint; ppStmt: ptr Stmt; pzTail: ptr cstring): cint {.importSqlite3.}
+
+proc step(para1: Stmt): cint {.importSqlite3.}
+
+proc column_count(stmt: Stmt): int32 {.importSqlite3.}
+proc column_blob(stmt: Stmt; col: cint): pointer {.importSqlite3.}
+proc column_bytes(stmt: Stmt; col: cint): cint {.importSqlite3.}
+proc column_double(stmt: Stmt; col: cint): float64 {.importSqlite3.}
+proc column_int64(stmt: Stmt; col: cint): int64 {.importSqlite3.}
+proc column_text(stmt: Stmt; col: cint): cstring {.importSqlite3.}
+proc column_type(stmt: Stmt; col: cint): cint {.importSqlite3.}
+proc finalize(stmt: Stmt): cint {.importSqlite3.}
+
+doAssert libversion_number() == SQLITE_VERSION_NUMBER
+
 import preserves, syndicate
-import ./sqlite
+import ./sql
 
-type Value = Preserve[void]
+proc logError(db: Sqlite3; context: string) =
+  writeLine(stderr, errmsg(db), ": ", context)
 
-type Args {.preservesDictionary.}= object
-  database: string
-  dataspace: Ref
+type
+  Value = Preserve[void]
+  Args {.preservesDictionary.} = object
+    database: string
+    dataspace: Ref
+
+proc extractValue(stmt: Stmt; col: cint): Value =
+  case column_type(stmt, col)
+  of SQLITE_INTEGER:
+    result = toPreserve(column_int64(stmt, col))
+  of SQLITE_FLOAT:
+    result = toPreserve(column_double(stmt, col))
+  of SQLITE_TEXT:
+    result = Value(kind: pkString, string: newString(column_bytes(stmt, col)))
+    if result.string.len > 0:
+      copyMem(addr result.string[0], column_text(stmt, col), result.string.len)
+  of SQLITE_BLOB:
+    result = Value(kind: pkByteString, bytes: newSeq[byte](column_bytes(stmt, col)))
+    if result.bytes.len > 0:
+      copyMem(addr result.bytes[0], column_blob(stmt, col), result.bytes.len)
+  else:
+    result = initRecord[void]("null")
+
+proc extractRecord(stmt: Stmt; label: Value, arity: cint): Value =
+  result = initRecord(label, arity)
+  for col in 0..<arity: result.record[col] = extractValue(stmt, col)
 
 runActor("main") do (root: Ref; turn: var Turn):
   connectStdio(root, turn)
   during(turn, root, ?Args) do (path: string, ds: Ref):
-    let db = open(path, "", "", "")
-    during(turn, ds, ?Query) do (label: Value, statement: string):
-      for row in rows(db, sql statement):
-        var rec = initRecord(label, len(row))
-        for col, val in row: rec[col] = val.toPreserve
-        discard publish(turn, ds, rec)
+    var db: Sqlite3
+    if open_v2(path, addr db, SQLITE_OPEN_READONLY, nil) != SQLITE_OK:
+      logError(db, path)
+    else:
+      during(turn, ds, ?Query) do (label: Value, statement: string):
+        var stmt: Stmt
+        if prepare_v2(db, statement, statement.len.cint, addr stmt, nil) != SQLITE_OK:
+          logError(db, statement)
+        else:
+          try:
+            let arity = column_count(stmt)
+            var res = step(stmt)
+            while res == SQLITE_ROW:
+              var rec = extractRecord(stmt, label, arity)
+              discard publish(turn, ds, rec)
+              res = step(stmt)
+            assert res != 100
+            if res != SQLITE_DONE:
+              logError(db, statement)
+          finally:
+            if finalize(stmt) != SQLITE_OK: logError(db, statement)
   do:
     close(db)