257 lines
7.8 KiB
Nim
257 lines
7.8 KiB
Nim
# Nim-RocksDB
|
|
# Copyright 2018 Status Research & Development GmbH
|
|
# Licensed under either of
|
|
#
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
|
|
# * GPL license, version 2.0, ([LICENSE-GPLv2](LICENSE-GPLv2) or https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)
|
|
#
|
|
# at your option. This file may not be copied, modified, or distributed except according to those terms.
|
|
|
|
import cpuinfo, options, stew/ranges
|
|
|
|
const useCApi = true
|
|
|
|
when useCApi:
|
|
import rocksdb/librocksdb
|
|
export librocksdb
|
|
|
|
type
|
|
RocksPtr[T] = object
|
|
res: T
|
|
|
|
import typetraits
|
|
|
|
when false:
|
|
# XXX: generic types cannot have destructors at the moment:
|
|
# https://github.com/nim-lang/Nim/issues/5366
|
|
template managedResource(name) =
|
|
template freeResource(r: `rocksdb name t`) =
|
|
`rocksdb name destroy`(r)
|
|
|
|
managedResource(WriteOptions)
|
|
managedResource(ReadOptions)
|
|
template initResource(resourceName): auto =
|
|
var p = toRocksPtr(`rocksdb resourceName create`())
|
|
# XXX: work-around the destructor issue above:
|
|
# XXX: work-around disabled - it frees the resource too early - need to
|
|
# free resource manually!
|
|
# defer: freeResource p.res
|
|
p.res
|
|
|
|
proc `=destroy`*[T](rocksPtr: var RocksPtr[T]) =
|
|
freeResource rocksPtr.res
|
|
|
|
proc toRocksPtr[T](res: T): RocksPtr[T] =
|
|
result.res = res
|
|
|
|
else:
|
|
{.error: "The C++ API of RocksDB is not supported yet".}
|
|
|
|
# The intention of this template is that it will hide the
|
|
# difference between the C and C++ APIs for objects such
|
|
# as Read/WriteOptions, which are allocated either on the
|
|
# stack or the heap.
|
|
template initResource(resourceName) =
|
|
var res = resourceName()
|
|
res
|
|
|
|
type
|
|
# TODO: Replace this with a converter concept that will
|
|
# handle openarray[char] and openarray[byte] in the same way.
|
|
KeyValueType = openarray[byte]
|
|
|
|
RocksDBInstance* = object
|
|
db: rocksdb_t
|
|
backupEngine: rocksdb_backup_engine_t
|
|
options: rocksdb_options_t
|
|
readOptions: rocksdb_readoptions_t
|
|
writeOptions: rocksdb_writeoptions_t
|
|
|
|
RocksDBResult*[T] = object
|
|
case ok*: bool
|
|
of true:
|
|
when T isnot void: value*: T
|
|
else:
|
|
error*: string
|
|
|
|
proc `$`*[T](s: RocksDBResult[T]): string =
|
|
if s.ok:
|
|
when T isnot void:
|
|
$s.value
|
|
else:
|
|
""
|
|
else:
|
|
"(error) " & s.error
|
|
|
|
template returnOk() =
|
|
result.ok = true
|
|
return
|
|
|
|
template returnVal(v: auto) =
|
|
result.ok = true
|
|
result.value = v
|
|
return
|
|
|
|
template bailOnErrors {.dirty.} =
|
|
if not errors.isNil:
|
|
result.ok = false
|
|
result.error = $errors
|
|
rocksdb_free(errors)
|
|
return
|
|
|
|
proc init*(rocks: var RocksDBInstance,
|
|
dbPath, dbBackupPath: string,
|
|
readOnly = false,
|
|
cpus = countProcessors(),
|
|
createIfMissing = true,
|
|
maxOpenFiles = -1): RocksDBResult[void] =
|
|
rocks.options = rocksdb_options_create()
|
|
rocks.readOptions = rocksdb_readoptions_create()
|
|
rocks.writeOptions = rocksdb_writeoptions_create()
|
|
|
|
# Optimize RocksDB. This is the easiest way to get RocksDB to perform well:
|
|
rocksdb_options_increase_parallelism(rocks.options, cpus.int32)
|
|
# This requires snappy - disabled because rocksdb is not always compiled with
|
|
# snappy support (for example Fedora 28, certain Ubuntu versions)
|
|
# rocksdb_options_optimize_level_style_compaction(options, 0);
|
|
rocksdb_options_set_create_if_missing(rocks.options, uint8(createIfMissing))
|
|
# default set to keep all files open (-1), allow setting it to a specific
|
|
# value, e.g. in case the application limit would be reached.
|
|
rocksdb_options_set_max_open_files(rocks.options, maxOpenFiles.cint)
|
|
|
|
var errors: cstring
|
|
if readOnly:
|
|
rocks.db = rocksdb_open_for_read_only(rocks.options, dbPath, 0'u8, errors.addr)
|
|
else:
|
|
rocks.db = rocksdb_open(rocks.options, dbPath, errors.addr)
|
|
bailOnErrors()
|
|
rocks.backupEngine = rocksdb_backup_engine_open(rocks.options,
|
|
dbBackupPath, errors.addr)
|
|
bailOnErrors()
|
|
returnOk()
|
|
|
|
template initRocksDB*(args: varargs[untyped]): Option[RocksDBInstance] =
|
|
var db: RocksDBInstance
|
|
if not init(db, args):
|
|
none(RocksDBInstance)
|
|
else:
|
|
some(db)
|
|
|
|
when false:
|
|
# TODO: These should be in the standard lib somewhere.
|
|
proc to*(chars: openarray[char], S: typedesc[string]): string =
|
|
result = newString(chars.len)
|
|
copyMem(addr result[0], unsafeAddr chars[0], chars.len * sizeof(char))
|
|
|
|
proc to*(chars: openarray[char], S: typedesc[seq[byte]]): seq[byte] =
|
|
result = newSeq[byte](chars.len)
|
|
copyMem(addr result[0], unsafeAddr chars[0], chars.len * sizeof(char))
|
|
|
|
template toOpenArray*[T](p: ptr T, sz: int): openarray[T] =
|
|
# XXX: The `TT` type is a work-around the fact that the `T`
|
|
# generic param is not resolved properly within the body of
|
|
# the template: https://github.com/nim-lang/Nim/issues/7995
|
|
type TT = type(p[])
|
|
let arr = cast[ptr UncheckedArray[TT]](p)
|
|
toOpenArray(arr[], 0, sz)
|
|
else:
|
|
proc copyFrom(v: var seq[byte], data: cstring, sz: int) =
|
|
v = newSeq[byte](sz)
|
|
if sz > 0:
|
|
copyMem(addr v[0], unsafeAddr data[0], sz)
|
|
|
|
proc copyFrom(v: var string, data: cstring, sz: int) =
|
|
v = newString(sz)
|
|
if sz > 0:
|
|
copyMem(addr v[0], unsafeAddr data[0], sz)
|
|
|
|
template getImpl {.dirty.} =
|
|
doAssert key.len > 0
|
|
|
|
var
|
|
errors: cstring
|
|
len: csize
|
|
data = rocksdb_get(db.db, db.readOptions,
|
|
cast[cstring](unsafeAddr key[0]), key.len,
|
|
addr len, errors.addr)
|
|
bailOnErrors()
|
|
if not data.isNil:
|
|
result.ok = true
|
|
result.value.copyFrom(data, len)
|
|
rocksdb_free(data)
|
|
else:
|
|
result.error = $errors
|
|
|
|
proc get*(db: RocksDBInstance, key: KeyValueType): RocksDBResult[string] =
|
|
## Get value for `key`. If no value exists, set `result.ok` to `false`,
|
|
## and result.error to `""`.
|
|
getImpl
|
|
|
|
proc getBytes*(db: RocksDBInstance, key: KeyValueType): RocksDBResult[seq[byte]] =
|
|
## Get value for `key`. If no value exists, set `result.ok` to `false`,
|
|
## and result.error to `""`.
|
|
getImpl
|
|
|
|
proc put*(db: RocksDBInstance, key, val: KeyValueType): RocksDBResult[void] =
|
|
doAssert key.len > 0
|
|
|
|
var
|
|
errors: cstring
|
|
|
|
rocksdb_put(db.db, db.writeOptions,
|
|
cast[cstring](unsafeAddr key[0]), key.len,
|
|
cast[cstring](if val.len > 0: unsafeAddr val[0] else: nil), val.len,
|
|
errors.addr)
|
|
|
|
bailOnErrors()
|
|
returnOk()
|
|
|
|
proc del*(db: RocksDBInstance, key: KeyValueType): RocksDBResult[void] =
|
|
var errors: cstring
|
|
rocksdb_delete(db.db, db.writeOptions,
|
|
cast[cstring](unsafeAddr key[0]), key.len,
|
|
errors.addr)
|
|
bailOnErrors()
|
|
returnOk()
|
|
|
|
proc contains*(db: RocksDBInstance, key: KeyValueType): RocksDBResult[bool] =
|
|
doAssert key.len > 0
|
|
|
|
var
|
|
errors: cstring
|
|
len: csize
|
|
data = rocksdb_get(db.db, db.readOptions,
|
|
cast[cstring](unsafeAddr key[0]), key.len,
|
|
addr len, errors.addr)
|
|
bailOnErrors()
|
|
result.ok = true
|
|
if not data.isNil:
|
|
result.value = true
|
|
rocksdb_free(data)
|
|
|
|
proc backup*(db: RocksDBInstance): RocksDBResult[void] =
|
|
var errors: cstring
|
|
rocksdb_backup_engine_create_new_backup(db.backupEngine, db.db, errors.addr)
|
|
bailOnErrors()
|
|
returnOk()
|
|
|
|
# XXX: destructors are just too buggy at the moment:
|
|
# https://github.com/nim-lang/Nim/issues/8112
|
|
# proc `=destroy`*(db: var RocksDBInstance) =
|
|
proc close*(db: var RocksDBInstance) =
|
|
template freeField(name) =
|
|
if db.`name`.isNil:
|
|
`rocksdb name destroy`(db.`name`)
|
|
db.`name` = nil
|
|
freeField(writeOptions)
|
|
freeField(readOptions)
|
|
freeField(options)
|
|
|
|
if not db.backupEngine.isNil:
|
|
rocksdb_backup_engine_close(db.backupEngine)
|
|
db.backupEngine = nil
|
|
|
|
if not db.db.isNil:
|
|
rocksdb_close(db.db)
|
|
db.db = nil
|