func (db *DB) NewIterator() driver.IIterator { it := new(Iterator) it.it = C.rocksdb_create_iterator(db.db, db.iteratorOpts.Opt) return it }
func (db *DB) NewIterator(opt *ReadOptions) *Iterator { var rOpt = db.rOpt if opt != nil && opt.rOpt != nil { rOpt = opt.rOpt } var iter = new(Iterator) iter.it = C.rocksdb_create_iterator(db.db, rOpt) return iter }
// 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 }
func (s *Snapshot) NewIterator() driver.IIterator { it := new(Iterator) it.it = C.rocksdb_create_iterator(s.db.db, s.db.iteratorOpts.Opt) return it }
// NewIterator returns an Iterator over the the database that uses the // ReadOptions given. func (self *DB) NewIterator(opts *ReadOptions) *Iterator { cIter := C.rocksdb_create_iterator(self.c, opts.c) return NewNativeIterator(cIter) }
// NewIterator returns an Iterator over the the database that uses the // ReadOptions given. // // Often, this is used for large, offline bulk reads while serving live // traffic. In that case, it may be wise to disable caching so that the data // processed by the returned Iterator does not displace the already cached // data. This can be done by calling SetFillCache(false) on the ReadOptions // before passing it here. // // Similiarly, ReadOptions.SetSnapshot is also useful. func (db *DB) NewIterator(ro *ReadOptions) *Iterator { it := C.rocksdb_create_iterator(db.Ldb, ro.Opt) return &Iterator{Iter: it} }
// NewIterator returns an Iterator over the the database that uses the // ReadOptions given. func (db *DB) NewIterator(opts *ReadOptions) *Iterator { cIter := C.rocksdb_create_iterator(db.c, opts.c) return NewNativeIterator(unsafe.Pointer(cIter)) }