func (iter *Iterator) Seek(key []byte) {
var ck *C.char
if len(key) > 0 {
ck = (*C.char)(unsafe.Pointer(&key[0]))
}
C.rocksdb_iter_seek(iter.it, ck, C.size_t(len(key)))
}
// Scan returns up to max key/value objects starting from
// start (inclusive) and ending at end (non-inclusive).
// If max is zero then the number of key/values returned is unbounded.
func (r *RocksDB) Scan(start, end Key, max int64) ([]RawKeyValue, error) {
var keyVals []RawKeyValue
if bytes.Compare(start, end) >= 0 {
return keyVals, nil
}
// In order to prevent content displacement, caching is disabled
// when performing scans. Any options set within the shared read
// options field that should be carried over needs to be set here
// as well.
opts := C.rocksdb_readoptions_create()
C.rocksdb_readoptions_set_fill_cache(opts, 0)
defer C.rocksdb_readoptions_destroy(opts)
it := C.rocksdb_create_iterator(r.rdb, opts)
defer C.rocksdb_iter_destroy(it)
byteCount := len(start)
if byteCount == 0 {
// start=Key("") needs special treatment since we need
// to access start[0] in an explicit seek.
C.rocksdb_iter_seek_to_first(it)
} else {
C.rocksdb_iter_seek(it, bytesPointer(start), C.size_t(byteCount))
}
for i := int64(1); C.rocksdb_iter_valid(it) == 1; C.rocksdb_iter_next(it) {
if max > 0 && i > max {
break
}
var l C.size_t
// The data returned by rocksdb_iter_{key,value} is not meant to be
// freed by the client. It is a direct reference to the data managed
// by the iterator, so it is copied instead of freed.
data := C.rocksdb_iter_key(it, &l)
k := C.GoBytes(unsafe.Pointer(data), C.int(l))
if bytes.Compare(k, end) >= 0 {
break
}
data = C.rocksdb_iter_value(it, &l)
v := C.GoBytes(unsafe.Pointer(data), C.int(l))
keyVals = append(keyVals, RawKeyValue{
Key: k,
Value: v,
})
i++
}
// Check for any errors during iteration.
var cErr *C.char
C.rocksdb_iter_get_error(it, &cErr)
if cErr != nil {
return nil, charToErr(cErr)
}
return keyVals, nil
}
// scan returns up to max key/value objects starting from
// start (inclusive) and ending at end (non-inclusive).
// If max is zero then the number of key/values returned is unbounded.
func (r *RocksDB) scan(start, end Key, max int64) ([]KeyValue, error) {
// In order to prevent content displacement, caching is disabled
// when performing scans. Any options set within the shared read
// options field that should be carried over needs to be set here
// as well.
opts := C.rocksdb_readoptions_create()
C.rocksdb_readoptions_set_fill_cache(opts, 0)
defer C.rocksdb_readoptions_destroy(opts)
it := C.rocksdb_create_iterator(r.rdb, opts)
defer C.rocksdb_iter_destroy(it)
keyVals := []KeyValue{}
C.rocksdb_iter_seek(it, (*C.char)(unsafe.Pointer(&start[0])), C.size_t(len(start)))
for i := int64(1); C.rocksdb_iter_valid(it) == 1; C.rocksdb_iter_next(it) {
if max > 0 && i > max {
break
}
var l C.size_t
// The data returned by rocksdb_iter_{key,value} is not meant to be
// freed by the client. It is a direct reference to the data managed
// by the iterator, so it is copied instead of freed.
data := C.rocksdb_iter_key(it, &l)
k := C.GoBytes(unsafe.Pointer(data), C.int(l))
if bytes.Equal(k, end) {
break
}
data = C.rocksdb_iter_value(it, &l)
v := C.GoBytes(unsafe.Pointer(data), C.int(l))
keyVals = append(keyVals, KeyValue{
Key: k,
Value: Value{Bytes: v},
})
i++
}
// Check for any errors during iteration.
var cErr *C.char
C.rocksdb_iter_get_error(it, &cErr)
if cErr != nil {
return nil, charToErr(cErr)
}
return keyVals, nil
}
// Seek moves the iterator the position of the key given or, if the key
// doesn't exist, the next key that does exist in the database. If the key
// doesn't exist, and there is no next key, the Iterator becomes invalid.
//
// This method is safe to call when Valid returns false.
func (it *Iterator) Seek(key []byte) {
C.rocksdb_iter_seek(it.Iter, (*C.char)(unsafe.Pointer(&key[0])), C.size_t(len(key)))
}
// Seek moves the iterator to the position greater than or equal to the key.
func (i *Iterator) Seek(key []byte) {
cKey := byteToChar(key)
C.rocksdb_iter_seek(i.c, cKey, C.size_t(len(key)))
}