refactoring to non-async

datastore/backend.nim

@@ -33,6 +33,9 @@ type
 
 proc `$`*(id: KeyId): string = $(id.data)
 
+proc new*(tp: typedesc[KeyId], id: cstring): KeyId =
+  KeyId(data: DataBuffer.new(id.pointer, 0, id.len()-1))
+
 proc toDb*(key: Key): DbKey {.inline, raises: [].} =
   let id: string = key.id()
   let db = DataBuffer.new(id.len()+1) # include room for null for cstring compat

datastore/sql/sqliteds.nim

@@ -103,9 +103,9 @@ proc close*(self: SQLiteDatastore): ?!void =
   return success()
 
 
-iterator query*(self: SQLiteDatastore,
+proc query*(self: SQLiteDatastore,
             query: DbQuery
-                ): ?!DbQueryResponse {.closure.} =
+            ): Result[iterator(): ?!DbQueryResponse {.closure.}, ref CatchableError] =
 
   var
     queryStr = if query.value:
@@ -132,7 +132,7 @@ iterator query*(self: SQLiteDatastore,
 
   var
     v = sqlite3_bind_text(
-      s, 1.cint, (query.key.id & "*").cstring, -1.cint, SQLITE_TRANSIENT_GCSAFE)
+      s, 1.cint, ($query.key & "*").cstring, -1.cint, SQLITE_TRANSIENT_GCSAFE)
 
   if not (v == SQLITE_OK):
     return failure newException(DatastoreError, $sqlite3_errstr(v))
@@ -149,35 +149,20 @@ iterator query*(self: SQLiteDatastore,
     if not (v == SQLITE_OK):
       return failure newException(DatastoreError, $sqlite3_errstr(v))
 
-  let lock = newAsyncLock()
+  let iter = iterator(): ?!DbQueryResponse {.closure.} =
-  proc next(): ?!QueryResponse =
-    defer:
-      if lock.locked:
-        lock.release()
-
-    if lock.locked:
-      return failure (ref DatastoreError)(msg: "Should always await query features")
-
-    if iter.finished:
-      return failure((ref QueryEndedError)(msg: "Calling next on a finished query!"))
-
-    await lock.acquire()
 
+    try:
       let
         v = sqlite3_step(s)
 
       case v
       of SQLITE_ROW:
         let
-        key = DbKey.init(
+          key = KeyId.new(sqlite3_column_text_not_null(s, QueryStmtIdCol))
-          $sqlite3_column_text_not_null(s, QueryStmtIdCol))
-          .expect("should not fail")
 
           blob: ?pointer =
-          if query.value:
+            if query.value: sqlite3_column_blob(s, QueryStmtDataCol).some
-              sqlite3_column_blob(s, QueryStmtDataCol).some
+            else: pointer.none
-            else:
-              pointer.none
 
         # detect out-of-memory error
         # see the conversion table and final paragraph of:
@@ -188,39 +173,29 @@ iterator query*(self: SQLiteDatastore,
         # error it is necessary to check that the result is a null pointer and
         # that the result code is an error code
         if blob.isSome and blob.get().isNil:
-        let
+          let v = sqlite3_errcode(sqlite3_db_handle(s))
-          v = sqlite3_errcode(sqlite3_db_handle(s))
 
           if not (v in [SQLITE_OK, SQLITE_ROW, SQLITE_DONE]):
-          iter.finished = true
             return failure newException(DatastoreError, $sqlite3_errstr(v))
 
         let
           dataLen = sqlite3_column_bytes(s, QueryStmtDataCol)
-        data = if blob.isSome:
+          data =
-            @(
+            if blob.isSome: DataBuffer.new(blob.get(), 0, dataLen - 1)
-              toOpenArray(cast[ptr UncheckedArray[byte]](blob.get),
+            else: DataBuffer.new(0)
-              0,
-              dataLen - 1))
-          else:
-            @[]
 
         return success (key.some, data)
       of SQLITE_DONE:
-      iter.finished = true
+        return success (KeyId.none, DataBuffer.new(0))
-      return success (DbKey.none, EmptyBytes)
       else:
-      iter.finished = true
         return failure newException(DatastoreError, $sqlite3_errstr(v))
 
-  iter.dispose = proc(): ?!void =
+    finally:
       discard sqlite3_reset(s)
       discard sqlite3_clear_bindings(s)
-    s.dispose
+      s.dispose()
-    return success()
+      return
 
-  iter.next = next
-  return success iter
 
 proc new*(T: type SQLiteDatastore,
           path: string,

datastore/threads/databuffer.nim

@@ -68,6 +68,9 @@ proc new*[T: byte | char](tp: type DataBuffer, data: openArray[T], opts: set[Dat
     copyMem(result[].buf, baseAddr data, data.len())
   result[].size = data.len()
 
+proc new*(tp: type DataBuffer, data: pointer, first, last: int): DataBuffer =
+  DataBuffer.new(toOpenArray(cast[ptr UncheckedArray[byte]](data), first, last))
+
 proc clear*(db: DataBuffer) =
   zeroMem(db[].buf, db[].cap)
   db[].size = 0

datastore/threads/threadresult.nim

@@ -38,8 +38,8 @@ converter toExc*(e: ThreadResErr): ref CatchableError =
   of ErrorEnum.DatastoreErr: (ref DatastoreError)(msg: $e[1])
   of ErrorEnum.CatchableErr: (ref CatchableError)(msg: $e[1])
 
-converter toQueryResponse*(r: DbQueryResponse): QueryResponse =
+# converter toQueryResponse*(r: DbQueryResponse): QueryResponse =
-  if not r.key.data.isNil and r.key.data.len > 0 and key =? Key.init($r.key.data):
+#   if not r.key.data.isNil and r.key.data.len > 0 and key =? Key.init($r.key.data):
-    (key.some, @(r.val))
+#     (key.some, @(r.val))
-  else:
+#   else:
-    (Key.none, EmptyBytes)
+#     (Key.none, EmptyBytes)