Use Opt in multiGet to indicate when values don't exist (#95)

Author: bhartnett

rocksdb/columnfamily.nim

@@ -82,10 +82,9 @@ template multiGet*(
     cf: ColFamilyReadOnly | ColFamilyReadWrite,
     keys: openArray[seq[byte]],
     sortedInput = false,
-    errorOnValueNotExists = true,
-): RocksDBResult[seq[seq[byte]]] =
+): RocksDBResult[seq[Opt[seq[byte]]]] =
   ## Get a batch of values for the given set of keys.
-  cf.db.multiGet(keys, sortedInput, errorOnValueNotExists, cf.handle)
+  cf.db.multiGet(keys, sortedInput, cf.handle)
 
 template put*(cf: ColFamilyReadWrite, key, val: openArray[byte]): RocksDBResult[void] =
   ## Puts a value for the given key into the column family.

rocksdb/rocksdb.nim

@@ -286,9 +286,8 @@ proc multiGet*(
     db: RocksDbRef,
     keys: openArray[seq[byte]],
     sortedInput = false,
-    errorOnValueNotExists = true,
     cfHandle = db.defaultCfHandle,
-): RocksDBResult[seq[seq[byte]]] =
+): RocksDBResult[seq[Opt[seq[byte]]]] =
   ## Get a batch of values for the given set of keys.
   ##
   ## The multiGet API improves performance by batching operations
@@ -333,26 +332,26 @@ proc multiGet*(
       rocksdb_free(e)
       return res
 
-  var values = newSeq[seq[byte]](keys.len())
+  var values = newSeq[Opt[seq[byte]]](keys.len())
   for i, v in valuesPtrs:
     if v.isNil():
-      if errorOnValueNotExists:
-        return err("rocksdb: value does not exist at index " & $i)
-      else:
-        continue
+      values[i] = Opt.none(seq[byte])
+      continue
 
-    var vLen: csize_t
+    var vLen: csize_t = 0
     let src = rocksdb_pinnableslice_value(v, vLen.addr)
-
-    if vLen > 0:
-      var dest =
-        when NimMajor >= 2 and NimMinor >= 2:
-          newSeqUninit[byte](vLen.int)
-        else:
-          newSeq[byte](vLen.int)
-      copyMem(dest[0].addr, src, vLen)
-      values[i] = dest
-
+    if vLen == 0:
+      values[i] = Opt.some(default(seq[byte]))
+      continue
+
+    assert vLen > 0
+    var dest =
+      when NimMajor >= 2 and NimMinor >= 2:
+        newSeqUninit[byte](vLen.int)
+      else:
+        newSeq[byte](vLen.int)
+    copyMem(dest[0].addr, src, vLen)
+    values[i] = Opt.some(dest)
     rocksdb_pinnableslice_destroy(v)
 
   ok(values)

tests/test_columnfamily.nim

@@ -144,6 +144,6 @@ suite "ColFamily Tests":
     let dataRes = cf.multiGet(@[keyValue1, keyValue2, keyValue3]).expect("ok")
     check:
       dataRes.len() == 3
-      dataRes[0] == keyValue1
-      dataRes[1] == keyValue2
-      dataRes[2] == default(seq[byte])
+      dataRes[0] == Opt.some(keyValue1)
+      dataRes[1] == Opt.some(keyValue2)
+      dataRes[2] == Opt.some(default(seq[byte]))

tests/test_rocksdb.nim

@@ -574,45 +574,38 @@ suite "RocksDbRef Tests":
       let dataRes = db.multiGet(@[keyValue1]).expect("ok")
       check:
         dataRes.len() == 1
-        dataRes[0] == keyValue1
+        dataRes[0] == Opt.some(keyValue1)
 
     block:
       let dataRes = db.multiGet(@[keyValue1, keyValue2]).expect("ok")
       check:
         dataRes.len() == 2
-        dataRes[0] == keyValue1
-        dataRes[1] == keyValue2
+        dataRes[0] == Opt.some(keyValue1)
+        dataRes[1] == Opt.some(keyValue2)
 
     block:
-      let dataRes =
-        db.multiGet(@[keyValue2, keyValue3], errorOnValueNotExists = false).expect("ok")
+      let dataRes = db.multiGet(@[keyValue2, keyValue3]).expect("ok")
       check:
         dataRes.len() == 2
-        dataRes[0] == keyValue2
-        dataRes[1] == default(seq[byte])
+        dataRes[0] == Opt.some(keyValue2)
+        dataRes[1] == Opt.none(seq[byte])
 
     block:
-      let
-        res1 = db.multiGet(@[keyValue1, keyValue2, keyValue3])
-        res2 =
-          db.multiGet(@[keyValue1, keyValue2, keyValue3], errorOnValueNotExists = true)
+      let dataRes = db.multiGet(@[keyValue1, keyValue2, keyValue3]).expect("ok")
       check:
-        res1.isErr()
-        res2.isErr()
+        dataRes.len() == 3
+        dataRes[0] == Opt.some(keyValue1)
+        dataRes[1] == Opt.some(keyValue2)
+        dataRes[2] == Opt.none(seq[byte])
 
     block:
-      let dataRes = db
-        .multiGet(
-          @[keyValue1, keyValue2, keyValue3],
-          sortedInput = true,
-          errorOnValueNotExists = false,
-        )
-        .expect("ok")
+      let dataRes =
+        db.multiGet(@[keyValue1, keyValue2, keyValue3], sortedInput = true).expect("ok")
       check:
         dataRes.len() == 3
-        dataRes[0] == keyValue1
-        dataRes[1] == keyValue2
-        dataRes[2] == default(seq[byte])
+        dataRes[0] == Opt.some(keyValue1)
+        dataRes[1] == Opt.some(keyValue2)
+        dataRes[2] == Opt.none(seq[byte])
 
     block:
       let
@@ -621,15 +614,15 @@ suite "RocksDbRef Tests":
             keyValue1, keyValue2, keyValue3, keyValue4, keyValue5, keyValue6, keyValue7,
             keyValue8, keyValue9,
           ]
-        dataRes = db.multiGet(keys, errorOnValueNotExists = false).expect("ok")
+        dataRes = db.multiGet(keys).expect("ok")
       check:
         dataRes.len() == 9
-        dataRes[0] == keyValue1
-        dataRes[1] == keyValue2
-        dataRes[2] == default(seq[byte])
-        dataRes[3] == default(seq[byte])
-        dataRes[4] == keyValue5
-        dataRes[5] == default(seq[byte])
-        dataRes[6] == keyValue7
-        dataRes[7] == default(seq[byte])
-        dataRes[8] == keyValue9
+        dataRes[0] == Opt.some(keyValue1)
+        dataRes[1] == Opt.some(keyValue2)
+        dataRes[2] == Opt.none(seq[byte])
+        dataRes[3] == Opt.none(seq[byte])
+        dataRes[4] == Opt.some(keyValue5)
+        dataRes[5] == Opt.none(seq[byte])
+        dataRes[6] == Opt.some(keyValue7)
+        dataRes[7] == Opt.none(seq[byte])
+        dataRes[8] == Opt.some(keyValue9)