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) }