Struct rocksdb::WriteOptions

pub struct WriteOptions { /* private fields */ }

Optionally disable WAL or sync for this write.

Examples

Making an unsafe write of a batch:

use rocksdb::{DB, Options, WriteBatch, WriteOptions};

let path = "_path_for_rocksdb_storageY1";
{
    let db = DB::open_default(path).unwrap();
    let mut batch = WriteBatch::default();
    batch.put(b"my key", b"my value");
    batch.put(b"key2", b"value2");
    batch.put(b"key3", b"value3");

    let mut write_options = WriteOptions::default();
    write_options.set_sync(false);
    write_options.disable_wal(true);

    db.write_opt(batch, &write_options);
}
let _ = DB::destroy(&Options::default(), path);

Implementations

impl WriteOptions

pub fn new() -> WriteOptions

pub fn set_sync(&mut self, sync: bool)

Sets the sync mode. If true, the write will be flushed from the operating system buffer cache before the write is considered complete. If this flag is true, writes will be slower.

Default: false

pub fn disable_wal(&mut self, disable: bool)

Sets whether WAL should be active or not. If true, writes will not first go to the write ahead log, and the write may got lost after a crash.

Default: false

pub fn set_ignore_missing_column_families(&mut self, ignore: bool)

If true and if user is trying to write to column families that don’t exist (they were dropped), ignore the write (don’t return an error). If there are multiple writes in a WriteBatch, other writes will succeed.

Default: false

pub fn set_no_slowdown(&mut self, no_slowdown: bool)

If true and we need to wait or sleep for the write request, fails immediately with Status::Incomplete().

Default: false

pub fn set_low_pri(&mut self, v: bool)

If true, this write request is of lower priority if compaction is behind. In this case, no_slowdown = true, the request will be cancelled immediately with Status::Incomplete() returned. Otherwise, it will be slowed down. The slowdown value is determined by RocksDB to guarantee it introduces minimum impacts to high priority writes.

Default: false

pub fn set_memtable_insert_hint_per_batch(&mut self, v: bool)

If true, writebatch will maintain the last insert positions of each memtable as hints in concurrent write. It can improve write performance in concurrent writes if keys in one writebatch are sequential. In non-concurrent writes (when concurrent_memtable_writes is false) this option will be ignored.

Default: false

Trait Implementations

impl Default for WriteOptions

fn default() -> Self

Returns the “default value” for a type.

impl Drop for WriteOptions

fn drop(&mut self)

Executes the destructor for this type.

impl Send for WriteOptions

impl Sync for WriteOptions