func (w *WriteBatch) commit(wb *WriteOptions) error {
var errStr *C.char
C.rocksdb_write(w.db.db, wb.Opt, w.wbatch, &errStr)
if errStr != nil {
return saveError(errStr)
}
return nil
}
// Write writes a WriteBatch to the database
func (db *DB) Write(opts *WriteOptions, batch *WriteBatch) error {
var cErr *C.char
C.rocksdb_write(db.c, opts.c, batch.c, &cErr)
if cErr != nil {
defer C.free(unsafe.Pointer(cErr))
return errors.New(C.GoString(cErr))
}
return nil
}
// Write atomically writes a WriteBatch to disk.
func (db *DB) Write(wo *WriteOptions, w *WriteBatch) error {
var errStr *C.char
C.rocksdb_write(db.Ldb, wo.Opt, w.wbatch, &errStr)
if errStr != nil {
gs := C.GoString(errStr)
C.free(unsafe.Pointer(errStr))
return DatabaseError(gs)
}
return nil
}
// writeBatch applies the puts, merges and deletes atomically via
// the RocksDB write batch facility. The list must only contain
// elements of type Batch{Put,Merge,Delete}.
func (r *RocksDB) writeBatch(cmds []interface{}) error {
if len(cmds) == 0 {
return nil
}
batch := C.rocksdb_writebatch_create()
defer C.rocksdb_writebatch_destroy(batch)
for i, e := range cmds {
switch v := e.(type) {
case BatchDelete:
if len(v) == 0 {
return emptyKeyError()
}
C.rocksdb_writebatch_delete(
batch,
(*C.char)(unsafe.Pointer(&v[0])),
C.size_t(len(v)))
case BatchPut:
key, value := v.Key, v.Value
valuePointer := (*C.char)(nil)
if len(value.Bytes) > 0 {
valuePointer = (*C.char)(unsafe.Pointer(&value.Bytes[0]))
}
// We write the batch before returning from this method, so we
// don't need to worry about the GC reclaiming the data stored.
C.rocksdb_writebatch_put(
batch,
(*C.char)(unsafe.Pointer(&key[0])),
C.size_t(len(key)),
valuePointer,
C.size_t(len(value.Bytes)))
case BatchMerge:
key, value := v.Key, v.Value
valuePointer := (*C.char)(nil)
if len(value.Bytes) > 0 {
valuePointer = (*C.char)(unsafe.Pointer(&value.Bytes[0]))
}
C.rocksdb_writebatch_merge(
batch,
(*C.char)(unsafe.Pointer(&key[0])),
C.size_t(len(key)),
valuePointer,
C.size_t(len(value.Bytes)))
default:
panic(fmt.Sprintf("illegal operation #%d passed to writeBatch: %v", i, reflect.TypeOf(v)))
}
}
var cErr *C.char
C.rocksdb_write(r.rdb, r.wOpts, batch, &cErr)
if cErr != nil {
return charToErr(cErr)
}
return nil
}
func (db *DB) Commit(wb *WriteBatch) error {
if wb != nil && wb.batch != nil {
var errStr *C.char
C.rocksdb_write(db.db, db.wOpt, wb.batch, &errStr)
C.rocksdb_writebatch_clear(wb.batch)
if errStr != nil {
defer C.free(unsafe.Pointer(errStr))
return errors.New(C.GoString(errStr))
}
}
return nil
}
// writeBatch applies all puts and deletes atomically via RocksDB write
// batch facility.
func (r *RocksDB) writeBatch(puts []KeyValue, dels []Key) error {
batch := C.rocksdb_writebatch_create()
defer C.rocksdb_writebatch_destroy(batch)
for _, put := range puts {
key, value := put.Key, put.Value
if len(key) == 0 {
return emptyKeyError()
}
// Empty values correspond to a null pointer.
valuePointer := (*C.char)(nil)
if len(value.Bytes) > 0 {
valuePointer = (*C.char)(unsafe.Pointer(&value.Bytes[0]))
}
// We write the batch before returning from this method, so we
// don't need to worry about the GC reclaiming the data stored in
// the "puts" and "dels" parameters.
C.rocksdb_writebatch_put(
batch,
(*C.char)(unsafe.Pointer(&key[0])),
C.size_t(len(key)),
valuePointer,
C.size_t(len(value.Bytes)))
}
for _, key := range dels {
if len(key) == 0 {
return emptyKeyError()
}
C.rocksdb_writebatch_delete(
batch,
(*C.char)(unsafe.Pointer(&key[0])),
C.size_t(len(key)))
}
var cErr *C.char
C.rocksdb_write(r.rdb, r.wOpts, batch, &cErr)
if cErr != nil {
return charToErr(cErr)
}
return nil
}
// Write writes a WriteBatch to the database
func (db *DB) Write(opts *WriteOptions, batch *WriteBatch) error {
var cErr *C.char
C.rocksdb_write(db.c, opts.c, batch.c, &cErr)
return convertErr(cErr)
}