syndesizer/sqlite_actor: move out compile conditional

src/syndesizer.nim

@@ -7,19 +7,22 @@ import syndicate, syndicate/relays, syndicate/actors/timers
 
 const
   withPostgre* {.booldefine.}: bool = true
+  withSqlite* {.booldefine.}: bool = true
 
 import ./syndesizer/[
   cache_actor,
   file_system_usage,
   json_socket_translator,
   json_translator,
-  sqlite_actor,
   webhooks,
   websockets]
 
 when withPostgre:
   import ./syndesizer/postgre_actor
 
+when withSqlite:
+  import ./syndesizer/sqlite_actor
+
 runActor("syndesizer") do (turn: var Turn; root: Cap):
   connectStdio(turn, root)
   discard spawnTimers(turn, root)

src/syndesizer/sqlite_actor.nim

@@ -1,71 +1,68 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 
-const withSqlite* {.booldefine.}: bool = true
+import preserves, syndicate, syndicate/relays
+import ../schema/[config, sql]
 
-when withSqlite:
+# Avoid Sqlite3 from the standard library because it is
-  import preserves, syndicate, syndicate/relays
+# only held together by wishful thinking and dlload.
-  import ../schema/[config, sql]
 
-  # Avoid Sqlite3 from the standard library because it is
+{.passC: staticExec("pkg-config --cflags sqlite3").}
-  # only held together by wishful thinking and dlload.
+{.passL: staticExec("pkg-config --libs sqlite3").}
 
-  {.passC: staticExec("pkg-config --cflags sqlite3").}
+{.pragma: sqlite3h, header: "sqlite3.h".}
-  {.passL: staticExec("pkg-config --libs sqlite3").}
 
-  {.pragma: sqlite3h, header: "sqlite3.h".}
+var
-
-  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
+const
   SQLITE_INTEGER = 1
   SQLITE_FLOAT = 2
   SQLITE_TEXT = 3
   SQLITE_BLOB = 4
   # SQLITE_NULL = 5
 
-  type
+type
   Sqlite3 {.importc: "sqlite3", sqlite3h.} = distinct pointer
   Stmt {.importc: "sqlite3_stmt", sqlite3h.} = distinct pointer
 
-  {.pragma: importSqlite3, importc: "sqlite3_$1", sqlite3h.}
+{.pragma: importSqlite3, importc: "sqlite3_$1", sqlite3h.}
 
-  proc libversion_number: cint {.importSqlite3.}
+proc libversion_number: cint {.importSqlite3.}
 
-  proc open_v2(filename: cstring; ppDb: ptr Sqlite3; flags: cint; zVfs: cstring): cint {.importSqlite3.}
+proc open_v2(filename: cstring; ppDb: ptr Sqlite3; flags: cint; zVfs: cstring): cint {.importSqlite3.}
-  proc close(ds: Sqlite3): int32 {.discardable, importSqlite3.}
+proc close(ds: Sqlite3): int32 {.discardable, importSqlite3.}
 
-  proc errmsg(db: Sqlite3): cstring {.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 prepare_v2(db: Sqlite3; zSql: cstring, nByte: cint; ppStmt: ptr Stmt; pzTail: ptr cstring): cint {.importSqlite3.}
 
-  proc step(para1: Stmt): cint {.importSqlite3.}
+proc step(para1: Stmt): cint {.importSqlite3.}
 
-  proc column_count(stmt: Stmt): int32 {.importSqlite3.}
+proc column_count(stmt: Stmt): int32 {.importSqlite3.}
-  proc column_blob(stmt: Stmt; col: cint): pointer {.importSqlite3.}
+proc column_blob(stmt: Stmt; col: cint): pointer {.importSqlite3.}
-  proc column_bytes(stmt: Stmt; col: cint): cint {.importSqlite3.}
+proc column_bytes(stmt: Stmt; col: cint): cint {.importSqlite3.}
-  proc column_double(stmt: Stmt; col: cint): float64 {.importSqlite3.}
+proc column_double(stmt: Stmt; col: cint): float64 {.importSqlite3.}
-  proc column_int64(stmt: Stmt; col: cint): int64 {.importSqlite3.}
+proc column_int64(stmt: Stmt; col: cint): int64 {.importSqlite3.}
-  proc column_text(stmt: Stmt; col: cint): cstring {.importSqlite3.}
+proc column_text(stmt: Stmt; col: cint): cstring {.importSqlite3.}
-  proc column_type(stmt: Stmt; col: cint): cint {.importSqlite3.}
+proc column_type(stmt: Stmt; col: cint): cint {.importSqlite3.}
-  proc finalize(stmt: Stmt): cint {.importSqlite3.}
+proc finalize(stmt: Stmt): cint {.importSqlite3.}
 
-  doAssert libversion_number() == SQLITE_VERSION_NUMBER
+doAssert libversion_number() == SQLITE_VERSION_NUMBER
 
-  proc logError(db: Sqlite3; context: string) =
+proc logError(db: Sqlite3; context: string) =
   writeLine(stderr, errmsg(db), ": ", context)
 
-  proc extractValue(stmt: Stmt; col: cint): Value =
+proc extractValue(stmt: Stmt; col: cint): Value =
   case column_type(stmt, col)
   of SQLITE_INTEGER:
-      result = toPreserve(column_int64(stmt, col))
+    result = toPreserves(column_int64(stmt, col))
   of SQLITE_FLOAT:
-      result = toPreserve(column_double(stmt, col))
+    result = toPreserves(column_double(stmt, col))
   of SQLITE_TEXT:
     result = Value(kind: pkString, string: newString(column_bytes(stmt, col)))
     if result.string.len > 0:
@@ -77,11 +74,11 @@ when withSqlite:
   else:
     result = initRecord("null")
 
-  proc extractRecord(stmt: Stmt; label: Value, arity: cint): Value =
+proc extractRecord(stmt: Stmt; label: Value, arity: cint): Value =
   result = initRecord(label, arity)
   for col in 0..<arity: result.record[col] = extractValue(stmt, col)
 
-  proc spawnSqliteActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
+proc spawnSqliteActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
   spawn("sqlite-actor", turn) do (turn: var Turn):
     during(turn, root, ?:SqliteArguments) do (path: string, ds: Cap):
       var db: Sqlite3
@@ -108,7 +105,7 @@ when withSqlite:
     do:
       close(db)
 
-  when isMainModule:
+when isMainModule:
   runActor("main") do (turn: var Turn; root: Cap):
     connectStdio(turn, root)
     spawnSqliteActor(turn, root)