add proper query interface

datastore/datastore.nim

@@ -11,35 +11,29 @@ export key, query
 push: {.upraises: [].}
 
 type
+  DatastoreError* = object of CatchableError
+  DatastoreKeyNotFound* = object of DatastoreError
+
+  CodexResult*[T] = Result[T, ref DatastoreError]
   Datastore* = ref object of RootObj
 
-method contains*(
+method contains*(self: Datastore, key: Key): Future[?!bool] {.base, locks: "unknown".} =
-  self: Datastore,
-  key: Key): Future[?!bool] {.base, locks: "unknown".} =
-
   raiseAssert("Not implemented!")
 
-method delete*(
+method delete*(self: Datastore, key: Key): Future[?!void] {.base, locks: "unknown".} =
-  self: Datastore,
-  key: Key): Future[?!void] {.base, locks: "unknown".} =
-
   raiseAssert("Not implemented!")
 
-method get*(
+method get*(self: Datastore, key: Key): Future[?!seq[byte]] {.base, locks: "unknown".} =
-  self: Datastore,
-  key: Key): Future[?!(?seq[byte])] {.base, locks: "unknown".} =
-
   raiseAssert("Not implemented!")
 
-method put*(
+method put*(self: Datastore, key: Key, data: seq[byte]): Future[?!void] {.base, locks: "unknown".} =
-  self: Datastore,
-  key: Key,
-  data: seq[byte]): Future[?!void] {.base, locks: "unknown".} =
-
   raiseAssert("Not implemented!")
 
-iterator query*(
+method close*(self: Datastore): Future[?!void] {.base, locks: "unknown".} =
+  raiseAssert("Not implemented!")
+
+method query*(
   self: Datastore,
-  query: Query): Future[QueryResponse] =
+  query: Query): Future[QueryIter] =
 
   raiseAssert("Not implemented!")

datastore/query.nim

@@ -1,61 +1,31 @@
 import ./key
 
 type
-  Node* = object of RootObj
-    next*: Node
-    prev*: Node
-
-  Filter* = object of Node
-    field*: string
-    value*: string
-
-  FilterBool* = object of Filter
-    a*, b*: Filter
-
-  FilterAnd = object of FilterBool
-  FilterOr = object of FilterBool
-
-  Eq = object of Filter
-  Lt = object of Filter
-  Gt = object of Filter
-  Not = object of Filter
-
   SortOrder* {.pure.} = enum
     Assending,
     Descensing
 
-  Order* = object
-    field*: string
-    sort*: SortOrder
-
   Query* = object
     key*: Key
+    value*: bool
     limit*: int
     skip*: int
-    orders*: seq[Order]
+    sort*: SortOrder
-    filters*: seq[Filter]
 
   QueryResponse* = tuple[key: Key, data: seq[byte]]
-
+  QueryIter* = iterator(): QueryResponse {.closure.}
-proc `==`*(a, b: Filter): Filter = discard
-
-proc `!=`*(a, b: Filter): Filter = discard
-proc `>`*(a, b: Filter): Filter = discard
-proc `>=`*(a, b: Filter): Filter = discard
-proc `<`*(a, b: Filter): Filter = discard
-proc `<=`*(a, b: Filter): Filter = discard
 
 proc init*(
   T: type Query,
   key: Key,
-  orders: openArray[Order] = [],
+  value = false,
-  filters: openArray[Filter] = [],
+  sort = SortOrder.Descensing,
   skip = 0,
   limit = 0): T =
 
   T(
     key: key,
-    filters: @filters,
+    value: value,
-    orders: @orders,
+    sort: sort,
     skip: skip,
     limit: limit)