porting query tests

datastore/backend.nim

@@ -32,7 +32,7 @@ type
   DbQueryHandle* = ref object
     cancel*: bool
 
-  DbQueryResponse* = tuple[key: Option[KeyId], val: DataBuffer]
+  DbQueryResponse* = tuple[key: Option[KeyId], data: DataBuffer]
 
 proc `$`*(id: KeyId): string = $(id.data)
 

tests/datastore/sql/testsqliteds.nim

@@ -100,3 +100,218 @@ suite "Test DataBuffer SQLiteDatastore":
     ds.close().tryGet()
 
   testBasic(ds, key, bytes, otherBytes, batch)
+
+suite "queryTests":
+  let
+    ds = SQLiteBackend.new(Memory).tryGet()
+
+  var
+    key1: KeyId
+    key2: KeyId
+    key3: KeyId
+    val1: DataBuffer
+    val2: DataBuffer
+    val3: DataBuffer
+
+  setup:
+    key1 = KeyId.new "/a"
+    key2 = KeyId.new "/a/b"
+    key3 = KeyId.new "/a/b/c"
+    val1 = DataBuffer.new "value for 1"
+    val2 = DataBuffer.new "value for 2"
+    val3 = DataBuffer.new "value for 3"
+
+  test "Key should query all keys and all it's children":
+    let
+      q = DbQuery(key: key1)
+
+    ds.put(key1, val1).tryGet
+    ds.put(key2, val2).tryGet
+    ds.put(key3, val3).tryGet
+
+    let
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+
+    check:
+      res.len == 3
+      res[0].key.get == key1
+      res[0].data == val1
+
+      res[1].key.get == key2
+      res[1].data == val2
+
+      res[2].key.get == key3
+      res[2].data == val3
+
+  test "Key should query all keys without values":
+    let
+      q = DbQuery(key: key1, value: false)
+
+    ds.put(key1, val1).tryGet
+    ds.put(key2, val2).tryGet
+    ds.put(key3, val3).tryGet
+
+    let
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+      
+    check:
+      res.len == 3
+      res[0].key.get == key1
+      res[0].data.len == 0
+
+      res[1].key.get == key2
+      res[1].data.len == 0
+
+      res[2].key.get == key3
+      res[2].data.len == 0
+
+
+  test "Key should not query parent":
+    let
+      q = DbQuery(key: key1)
+
+    ds.put(key1, val1).tryGet
+    ds.put(key2, val2).tryGet
+    ds.put(key3, val3).tryGet
+
+    let
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+
+    check:
+      res.len == 2
+      res[0].key.get == key2
+      res[0].data == val2
+
+      res[1].key.get == key3
+      res[1].data == val3
+
+  test "Key should all list all keys at the same level":
+    let
+      queryKey = Key.init("/a").tryGet
+      q = DbQuery(key: key1)
+
+    ds.put(key1, val1).tryGet
+    ds.put(key2, val2).tryGet
+    ds.put(key3, val3).tryGet
+
+    var
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+
+    res.sort do (a, b: DbQueryResponse) -> int:
+      cmp($a.key.get, $b.key.get)
+
+    check:
+      res.len == 3
+      res[0].key.get == key1
+      res[0].data == val1
+
+      res[1].key.get == key2
+      res[1].data == val2
+
+      res[2].key.get == key3
+      res[2].data == val3
+
+  test "Should apply limit":
+    let
+      key = Key.init("/a").tryGet
+      q = DbQuery(key: key1, value: false)
+
+    for i in 0..<100:
+      let
+        key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+        val = ("val " & $i).toBytes
+
+      ds.put(key, val).tryGet
+
+    let
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+
+    check:
+      res.len == 10
+
+  test "Should not apply offset":
+    let
+      key = Key.init("/a").tryGet
+      keyId = KeyId.new $key
+      q = DbQuery(key: KeyId.new $key, offset: 90)
+
+    for i in 0..<100:
+      let
+        key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+        val = DataBuffer.new("val " & $i)
+
+      ds.put(keyId, val).tryGet
+
+    let
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+
+    check:
+      res.len == 10
+
+
+  test "Should not apply offset and limit":
+    let
+      key = Key.init("/a").tryGet
+      keyId = KeyId.new $key
+      q = DbQuery(key: keyId, offset: 95, limit: 5)
+
+    for i in 0..<100:
+      let
+        key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+        val = DataBuffer.new("val " & $i)
+
+      ds.put(key, val).tryGet
+
+    let
+      (handle, iter) = ds.query(q).tryGet
+      res = iter.mapIt(it.tryGet())
+
+    check:
+      res.len == 5
+
+    for i in 0..<res.high:
+      let
+        val = ("val " & $(i + 95)).toBytes
+        key = Key.init(key, Key.init("/" & $(i + 95)).tryGet).tryGet
+
+      check:
+        res[i].key.get == key
+        res[i].data == val
+
+
+    test "Should apply sort order - descending":
+      let
+        key = Key.init("/a").tryGet
+        q = DbQuery(key: key, sort: SortOrder.Descending)
+
+      var kvs: seq[DbQueryResponse]
+      for i in 0..<100:
+        let
+          k = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = DataBuffer.new ("val " & $i)
+
+        kvs.add((k.some, val))
+        ds.put(k, val).tryGet
+
+      # lexicographic sort, as it comes from the backend
+      kvs.sort do (a, b: DbQueryResponse) -> int:
+        cmp($a.key.get, $b.key.get)
+
+      kvs = kvs.reversed
+      let
+        (handle, iter) = ds.query(q).tryGet
+        res = iter.mapIt(it.tryGet())
+
+      check:
+        res.len == 100
+
+      for i, r in res[1..^1]:
+        check:
+          res[i].key.get == kvs[i].key.get
+          res[i].data == kvs[i].data