RocksDB

java.lang.Object
- org.rocksdb.AbstractNativeReference
- - org.rocksdb.AbstractImmutableNativeReference
  - - org.rocksdb.RocksObject
    - - org.rocksdb.RocksDB

All Implemented Interfaces:

java.lang.AutoCloseable

Direct Known Subclasses:

OptimisticTransactionDB, TransactionDB, TtlDB
```
public class RocksDB
extends RocksObject
```
A RocksDB is a persistent ordered map from keys to values. It is safe for concurrent access from multiple threads without any external synchronization. All methods of this class could potentially throw RocksDBException, which indicates sth wrong at the RocksDB library side and the call failed.

Field Summary

Fields
Modifier and Type Field and Description

static byte[] DEFAULT_COLUMN_FAMILY

static int NOT_FOUND

protected DBOptionsInterface options_
- Fields inherited from class org.rocksdb.RocksObject
  nativeHandle_

Fields
Modifier and Type	Field and Description
`static byte[]`	`DEFAULT_COLUMN_FAMILY`
`static int`	`NOT_FOUND`
`protected DBOptionsInterface`	`options_`

Constructor Summary

Constructors
Modifier Constructor and Description

protected RocksDB(long nativeHandle)
Private constructor.

Constructors
Modifier	Constructor and Description
`protected`	`RocksDB(long nativeHandle)` Private constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`compactRange()` Range compaction of database.
`void`	`compactRange(boolean reduce_level, int target_level, int target_path_id)` Deprecated. Use `compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions)` instead
`void`	`compactRange(byte[] begin, byte[] end)` Range compaction of database.
`void`	`compactRange(byte[] begin, byte[] end, boolean reduce_level, int target_level, int target_path_id)` Deprecated. Use `compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions)` instead
`void`	`compactRange(ColumnFamilyHandle columnFamilyHandle)` Range compaction of column family.
`void`	`compactRange(ColumnFamilyHandle columnFamilyHandle, boolean reduce_level, int target_level, int target_path_id)` Deprecated. Use `compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions)` instead
`void`	`compactRange(ColumnFamilyHandle columnFamilyHandle, byte[] begin, byte[] end)` Range compaction of column family.
`void`	`compactRange(ColumnFamilyHandle columnFamilyHandle, byte[] begin, byte[] end, boolean reduce_level, int target_level, int target_path_id)` Deprecated. Use `compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions)` instead
`void`	`compactRange(ColumnFamilyHandle columnFamilyHandle, byte[] begin, byte[] end, CompactRangeOptions compactRangeOptions)` Range compaction of column family.
`void`	`continueBackgroundWork()` Resumes backround work which was suspended by previously calling `pauseBackgroundWork()`
`ColumnFamilyHandle`	`createColumnFamily(ColumnFamilyDescriptor columnFamilyDescriptor)` Creates a new column family with the name columnFamilyName and allocates a ColumnFamilyHandle within an internal structure.
`void`	`delete(byte[] key)` Delete the database entry (if any) for "key".
`void`	`delete(byte[] key, int offset, int len)` Delete the database entry (if any) for "key".
`void`	`delete(ColumnFamilyHandle columnFamilyHandle, byte[] key)` Delete the database entry (if any) for "key".
`void`	`delete(ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len)` Delete the database entry (if any) for "key".
`void`	`delete(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpt, byte[] key)` Delete the database entry (if any) for "key".
`void`	`delete(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpt, byte[] key, int offset, int len)` Delete the database entry (if any) for "key".
`protected void`	`delete(long handle, byte[] key, int keyOffset, int keyLength)`
`protected void`	`delete(long handle, byte[] key, int keyOffset, int keyLength, long cfHandle)`
`protected void`	`delete(long handle, long writeOptHandle, byte[] key, int keyOffset, int keyLength)`
`protected void`	`delete(long handle, long writeOptHandle, byte[] key, int keyOffset, int keyLength, long cfHandle)`
`void`	`delete(WriteOptions writeOpt, byte[] key)` Delete the database entry (if any) for "key".
`void`	`delete(WriteOptions writeOpt, byte[] key, int offset, int len)` Delete the database entry (if any) for "key".
`void`	`deleteRange(byte[] beginKey, byte[] endKey)` Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey".
`void`	`deleteRange(ColumnFamilyHandle columnFamilyHandle, byte[] beginKey, byte[] endKey)` Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey".
`void`	`deleteRange(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpt, byte[] beginKey, byte[] endKey)` Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey".
`protected void`	`deleteRange(long handle, byte[] beginKey, int beginKeyOffset, int beginKeyLength, byte[] endKey, int endKeyOffset, int endKeyLength)`
`protected void`	`deleteRange(long handle, byte[] beginKey, int beginKeyOffset, int beginKeyLength, byte[] endKey, int endKeyOffset, int endKeyLength, long cfHandle)`
`protected void`	`deleteRange(long handle, long writeOptHandle, byte[] beginKey, int beginKeyOffset, int beginKeyLength, byte[] endKey, int endKeyOffset, int endKeyLength)`
`protected void`	`deleteRange(long handle, long writeOptHandle, byte[] beginKey, int beginKeyOffset, int beginKeyLength, byte[] endKey, int endKeyOffset, int endKeyLength, long cfHandle)`
`void`	`deleteRange(WriteOptions writeOpt, byte[] beginKey, byte[] endKey)` Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey".
`static void`	`destroyDB(java.lang.String path, Options options)` Static method to destroy the contents of the specified database.
`void`	`disableFileDeletions()` Prevent file deletions.
`protected void`	`disposeInternal(long handle)`
`void`	`dropColumnFamily(ColumnFamilyHandle columnFamilyHandle)` Drops the column family identified by columnFamilyName.
`void`	`enableFileDeletions(boolean force)` Allow compactions to delete obsolete files.
`void`	`flush(FlushOptions flushOptions)` Flush all memory table data.
`void`	`flush(FlushOptions flushOptions, ColumnFamilyHandle columnFamilyHandle)` Flush all memory table data.
`byte[]`	`get(byte[] key)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(byte[] key, byte[] value)` Get the value associated with the specified key within column family*
`byte[]`	`get(byte[] key, int offset, int len)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Get the value associated with the specified key within column family*
`byte[]`	`get(ColumnFamilyHandle columnFamilyHandle, byte[] key)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value)` Get the value associated with the specified key within column family.
`byte[]`	`get(ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Get the value associated with the specified key within column family.
`byte[]`	`get(ColumnFamilyHandle columnFamilyHandle, ReadOptions opt, byte[] key)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(ColumnFamilyHandle columnFamilyHandle, ReadOptions opt, byte[] key, byte[] value)` Get the value associated with the specified key within column family.
`byte[]`	`get(ColumnFamilyHandle columnFamilyHandle, ReadOptions opt, byte[] key, int offset, int len)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(ColumnFamilyHandle columnFamilyHandle, ReadOptions opt, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Get the value associated with the specified key within column family.
`protected byte[]`	`get(long handle, byte[] key, int keyOffset, int keyLength)`
`protected int`	`get(long handle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength)`
`protected int`	`get(long handle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength, long cfHandle)`
`protected byte[]`	`get(long handle, byte[] key, int keyOffset, int keyLength, long cfHandle)`
`protected byte[]`	`get(long handle, long readOptHandle, byte[] key, int keyOffset, int keyLength)`
`protected int`	`get(long handle, long readOptHandle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength)`
`protected int`	`get(long handle, long readOptHandle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength, long cfHandle)`
`protected byte[]`	`get(long handle, long readOptHandle, byte[] key, int keyOffset, int keyLength, long cfHandle)`
`byte[]`	`get(ReadOptions opt, byte[] key)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(ReadOptions opt, byte[] key, byte[] value)` Get the value associated with the specified key.
`byte[]`	`get(ReadOptions opt, byte[] key, int offset, int len)` The simplified version of get which returns a new byte array storing the value associated with the specified input key if any.
`int`	`get(ReadOptions opt, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Get the value associated with the specified key.
`protected long`	`getAggregatedLongProperty(long nativeHandle, java.lang.String property, int propertyLength)`
`long`	`getAggregatedLongProperty(java.lang.String property)` Return sum of the getLongProperty of all the column families
`ColumnFamilyHandle`	`getDefaultColumnFamily()` Gets the handle for the default column family
`long`	`getLatestSequenceNumber()` The sequence number of the most recent transaction.
`long`	`getLongProperty(ColumnFamilyHandle columnFamilyHandle, java.lang.String property)` Similar to GetProperty(), but only works for a subset of properties whose return value is a numerical value.
`protected long`	`getLongProperty(long nativeHandle, long cfHandle, java.lang.String property, int propertyLength)`
`protected long`	`getLongProperty(long nativeHandle, java.lang.String property, int propertyLength)`
`long`	`getLongProperty(java.lang.String property)` Similar to GetProperty(), but only works for a subset of properties whose return value is a numerical value.
`java.lang.String`	`getProperty(ColumnFamilyHandle columnFamilyHandle, java.lang.String property)` DB implements can export properties about their state via this method on a per column family level.
`java.lang.String`	`getProperty(java.lang.String property)` DB implementations can export properties about their state via this method.
`protected java.lang.String`	`getProperty0(long nativeHandle, long cfHandle, java.lang.String property, int propertyLength)`
`protected java.lang.String`	`getProperty0(long nativeHandle, java.lang.String property, int propertyLength)`
`Snapshot`	`getSnapshot()` Return a handle to the current DB state.
`protected long`	`getSnapshot(long nativeHandle)`
`TransactionLogIterator`	`getUpdatesSince(long sequenceNumber)` Returns an iterator that is positioned at a write-batch containing seq_number.
`void`	`ingestExternalFile(ColumnFamilyHandle columnFamilyHandle, java.util.List<java.lang.String> filePathList, IngestExternalFileOptions ingestExternalFileOptions)` ingestExternalFile will load a list of external SST files (1) into the DB We will try to find the lowest possible level that the file can fit in, and ingest the file into this level (2).
`void`	`ingestExternalFile(java.util.List<java.lang.String> filePathList, IngestExternalFileOptions ingestExternalFileOptions)` ingestExternalFile will load a list of external SST files (1) into the DB We will try to find the lowest possible level that the file can fit in, and ingest the file into this level (2).
`protected long`	`iterator(long handle)`
`protected long`	`iterator(long handle, long readOptHandle)`
`protected long`	`iteratorCF(long handle, long cfHandle)`
`protected long`	`iteratorCF(long handle, long cfHandle, long readOptHandle)`
`protected long[]`	`iterators(long handle, long[] columnFamilyHandles, long readOptHandle)`
`boolean`	`keyMayExist(byte[] key, int offset, int len, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`boolean`	`keyMayExist(byte[] key, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`boolean`	`keyMayExist(ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`boolean`	`keyMayExist(ColumnFamilyHandle columnFamilyHandle, byte[] key, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`protected boolean`	`keyMayExist(long handle, byte[] key, int keyOffset, int keyLength, long cfHandle, java.lang.StringBuilder stringBuilder)`
`protected boolean`	`keyMayExist(long handle, byte[] key, int keyOffset, int keyLength, java.lang.StringBuilder stringBuilder)`
`protected boolean`	`keyMayExist(long handle, long optionsHandle, byte[] key, int keyOffset, int keyLength, long cfHandle, java.lang.StringBuilder stringBuilder)`
`protected boolean`	`keyMayExist(long handle, long optionsHandle, byte[] key, int keyOffset, int keyLength, java.lang.StringBuilder stringBuilder)`
`boolean`	`keyMayExist(ReadOptions readOptions, byte[] key, int offset, int len, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`boolean`	`keyMayExist(ReadOptions readOptions, byte[] key, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`boolean`	`keyMayExist(ReadOptions readOptions, ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`boolean`	`keyMayExist(ReadOptions readOptions, ColumnFamilyHandle columnFamilyHandle, byte[] key, java.lang.StringBuilder value)` If the key definitely does not exist in the database, then this method returns false, else true.
`protected static byte[][]`	`listColumnFamilies(long optionsHandle, java.lang.String path)`
`static java.util.List<byte[]>`	`listColumnFamilies(Options options, java.lang.String path)` Static method to determine all available column families for a rocksdb database identified by path
`static void`	`loadLibrary()` Loads the necessary library files.
`static void`	`loadLibrary(java.util.List<java.lang.String> paths)` Tries to load the necessary library files from the given list of directories.
`void`	`merge(byte[] key, byte[] value)` Add merge operand for key/value pair.
`void`	`merge(byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Add merge operand for key/value pair.
`void`	`merge(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value)` Add merge operand for key/value pair in a ColumnFamily.
`void`	`merge(ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Add merge operand for key/value pair in a ColumnFamily.
`void`	`merge(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpts, byte[] key, byte[] value)` Add merge operand for key/value pair.
`void`	`merge(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpts, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Add merge operand for key/value pair.
`protected void`	`merge(long handle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength)`
`protected void`	`merge(long handle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength, long cfHandle)`
`protected void`	`merge(long handle, long writeOptHandle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength)`
`protected void`	`merge(long handle, long writeOptHandle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength, long cfHandle)`
`void`	`merge(WriteOptions writeOpts, byte[] key, byte[] value)` Add merge operand for key/value pair.
`void`	`merge(WriteOptions writeOpts, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Add merge operand for key/value pair.
`java.util.Map<byte[],byte[]>`	`multiGet(java.util.List<byte[]> keys)` Returns a map of keys for which values were found in DB.
`java.util.Map<byte[],byte[]>`	`multiGet(java.util.List<ColumnFamilyHandle> columnFamilyHandleList, java.util.List<byte[]> keys)` Returns a map of keys for which values were found in DB.
`protected byte[][]`	`multiGet(long dbHandle, byte[][] keys, int[] keyOffsets, int[] keyLengths)`
`protected byte[][]`	`multiGet(long dbHandle, byte[][] keys, int[] keyOffsets, int[] keyLengths, long[] columnFamilyHandles)`
`protected byte[][]`	`multiGet(long dbHandle, long rOptHandle, byte[][] keys, int[] keyOffsets, int[] keyLengths)`
`protected byte[][]`	`multiGet(long dbHandle, long rOptHandle, byte[][] keys, int[] keyOffsets, int[] keyLengths, long[] columnFamilyHandles)`
`java.util.Map<byte[],byte[]>`	`multiGet(ReadOptions opt, java.util.List<byte[]> keys)` Returns a map of keys for which values were found in DB.
`java.util.Map<byte[],byte[]>`	`multiGet(ReadOptions opt, java.util.List<ColumnFamilyHandle> columnFamilyHandleList, java.util.List<byte[]> keys)` Returns a map of keys for which values were found in DB.
`RocksIterator`	`newIterator()` Return a heap-allocated iterator over the contents of the database.
`RocksIterator`	`newIterator(ColumnFamilyHandle columnFamilyHandle)` Return a heap-allocated iterator over the contents of the database.
`RocksIterator`	`newIterator(ColumnFamilyHandle columnFamilyHandle, ReadOptions readOptions)` Return a heap-allocated iterator over the contents of the database.
`RocksIterator`	`newIterator(ReadOptions readOptions)` Return a heap-allocated iterator over the contents of the database.
`java.util.List<RocksIterator>`	`newIterators(java.util.List<ColumnFamilyHandle> columnFamilyHandleList)` Returns iterators from a consistent database state across multiple column families.
`java.util.List<RocksIterator>`	`newIterators(java.util.List<ColumnFamilyHandle> columnFamilyHandleList, ReadOptions readOptions)` Returns iterators from a consistent database state across multiple column families.
`static RocksDB`	`open(DBOptions options, java.lang.String path, java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors, java.util.List<ColumnFamilyHandle> columnFamilyHandles)` The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the specified options and db path and a list of column family names.
`protected static long`	`open(long optionsHandle, java.lang.String path)`
`protected static long[]`	`open(long optionsHandle, java.lang.String path, byte[][] columnFamilyNames, long[] columnFamilyOptions)`
`static RocksDB`	`open(Options options, java.lang.String path)` The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the specified options and db path.
`static RocksDB`	`open(java.lang.String path)` The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the default options w/ createIfMissing set to true.
`static RocksDB`	`open(java.lang.String path, java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors, java.util.List<ColumnFamilyHandle> columnFamilyHandles)` The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the specified options and db path and a list of column family names.
`static RocksDB`	`openReadOnly(DBOptions options, java.lang.String path, java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors, java.util.List<ColumnFamilyHandle> columnFamilyHandles)` The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the specified options and db path.
`static RocksDB`	`openReadOnly(Options options, java.lang.String path)` The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the specified options and db path.
`static RocksDB`	`openReadOnly(java.lang.String path)` The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the default options.
`static RocksDB`	`openReadOnly(java.lang.String path, java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors, java.util.List<ColumnFamilyHandle> columnFamilyHandles)` The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the default options.
`protected static long`	`openROnly(long optionsHandle, java.lang.String path)`
`protected static long[]`	`openROnly(long optionsHandle, java.lang.String path, byte[][] columnFamilyNames, long[] columnFamilyOptions)`
`void`	`pauseBackgroundWork()` This function will wait until all currently running background processes finish.
`void`	`put(byte[] key, byte[] value)` Set the database entry for "key" to "value".
`void`	`put(byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Set the database entry for "key" to "value"
`void`	`put(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value)` Set the database entry for "key" to "value" in the specified column family.
`void`	`put(ColumnFamilyHandle columnFamilyHandle, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Set the database entry for "key" to "value" in the specified column family.
`void`	`put(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpts, byte[] key, byte[] value)` Set the database entry for "key" to "value" for the specified column family.
`void`	`put(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpts, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Set the database entry for "key" to "value" for the specified column family.
`protected void`	`put(long handle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength)`
`protected void`	`put(long handle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength, long cfHandle)`
`protected void`	`put(long handle, long writeOptHandle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength)`
`protected void`	`put(long handle, long writeOptHandle, byte[] key, int keyOffset, int keyLength, byte[] value, int valueOffset, int valueLength, long cfHandle)`
`void`	`put(WriteOptions writeOpts, byte[] key, byte[] value)` Set the database entry for "key" to "value".
`void`	`put(WriteOptions writeOpts, byte[] key, int offset, int len, byte[] value, int vOffset, int vLen)` Set the database entry for "key" to "value".
`protected void`	`releaseSnapshot(long nativeHandle, long snapshotHandle)`
`void`	`releaseSnapshot(Snapshot snapshot)` Release a previously acquired snapshot.
`void`	`remove(byte[] key)` Deprecated. Use `delete(byte[])`
`void`	`remove(ColumnFamilyHandle columnFamilyHandle, byte[] key)` Deprecated. Use `delete(ColumnFamilyHandle, byte[])`
`void`	`remove(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpt, byte[] key)` Deprecated. Use `delete(ColumnFamilyHandle, WriteOptions, byte[])`
`void`	`remove(WriteOptions writeOpt, byte[] key)` Deprecated. Use `delete(WriteOptions, byte[])`
`void`	`setOptions(ColumnFamilyHandle columnFamilyHandle, MutableColumnFamilyOptions mutableColumnFamilyOptions)`
`void`	`singleDelete(byte[] key)` Remove the database entry for `key`.
`void`	`singleDelete(ColumnFamilyHandle columnFamilyHandle, byte[] key)` Remove the database entry for `key`.
`void`	`singleDelete(ColumnFamilyHandle columnFamilyHandle, WriteOptions writeOpt, byte[] key)` Remove the database entry for `key`.
`protected void`	`singleDelete(long handle, byte[] key, int keyLen)`
`protected void`	`singleDelete(long handle, byte[] key, int keyLen, long cfHandle)`
`protected void`	`singleDelete(long handle, long writeOptHandle, byte[] key, int keyLen)`
`protected void`	`singleDelete(long handle, long writeOptHandle, byte[] key, int keyLen, long cfHandle)`
`void`	`singleDelete(WriteOptions writeOpt, byte[] key)` Remove the database entry for `key`.
`protected void`	`storeOptionsInstance(DBOptionsInterface options)`
`void`	`write(WriteOptions writeOpts, WriteBatch updates)` Apply the specified updates to the database.
`void`	`write(WriteOptions writeOpts, WriteBatchWithIndex updates)` Apply the specified updates to the database.
`protected void`	`write0(long handle, long writeOptHandle, long wbHandle)`
`protected void`	`write1(long handle, long writeOptHandle, long wbwiHandle)`

Methods inherited from class org.rocksdb.RocksObject
disposeInternal

Methods inherited from class org.rocksdb.AbstractImmutableNativeReference
close, disOwnNativeHandle, isOwningHandle

Methods inherited from class org.rocksdb.AbstractNativeReference
dispose, finalize

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_COLUMN_FAMILY
```
public static final byte[] DEFAULT_COLUMN_FAMILY
```
  - NOT_FOUND
```
public static final int NOT_FOUND
```
    See Also:
    Constant Field Values
  - options_
```
protected DBOptionsInterface options_
```
- Constructor Detail
  - RocksDB
```
protected RocksDB(long nativeHandle)
```
    Private constructor.
    
    Parameters:
    nativeHandle - The native handle of the C++ RocksDB object
- Method Detail
  - loadLibrary
```
public static void loadLibrary()
```
    Loads the necessary library files. Calling this method twice will have no effect. By default the method extracts the shared library for loading at java.io.tmpdir, however, you can override this temporary location by setting the environment variable ROCKSDB_SHAREDLIB_DIR.
  - loadLibrary
```
public static void loadLibrary(java.util.List<java.lang.String> paths)
```
    Tries to load the necessary library files from the given list of directories.
    
    Parameters:
    paths - a list of strings where each describes a directory of a library.
  - open
```
public static RocksDB open(java.lang.String path)
                    throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the default options w/ createIfMissing set to true.
    
    Parameters:
    path - the path to the rocksdb.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    See Also:
    Options.setCreateIfMissing(boolean)
  - open
```
public static RocksDB open(java.lang.String path,
           java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors,
           java.util.List<ColumnFamilyHandle> columnFamilyHandles)
                    throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the specified options and db path and a list of column family names.
    If opened in read write mode every existing column family name must be passed within the list to this method.
    
    If opened in read-only mode only a subset of existing column families must be passed to this method.
    
    Options instance *should* not be disposed before all DBs using this options instance have been closed. If user doesn't call options dispose explicitly, then this options instance will be GC'd automatically
    
    ColumnFamily handles are disposed when the RocksDB instance is disposed.
    
    Parameters:
    path - the path to the rocksdb.
    columnFamilyDescriptors - list of column family descriptors
    columnFamilyHandles - will be filled with ColumnFamilyHandle instances on open.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    See Also:
    DBOptions.setCreateIfMissing(boolean)
  - open
```
public static RocksDB open(Options options,
           java.lang.String path)
                    throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the specified options and db path.
    Options instance *should* not be disposed before all DBs using this options instance have been closed. If user doesn't call options dispose explicitly, then this options instance will be GC'd automatically.
    
    Options instance can be re-used to open multiple DBs if DB statistics is not used. If DB statistics are required, then its recommended to open DB with new Options instance as underlying native statistics instance does not use any locks to prevent concurrent updates.
    
    Parameters:
    options - Options instance.
    path - the path to the rocksdb.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    See Also:
    Options.setCreateIfMissing(boolean)
  - open
```
public static RocksDB open(DBOptions options,
           java.lang.String path,
           java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors,
           java.util.List<ColumnFamilyHandle> columnFamilyHandles)
                    throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance given the path to the database using the specified options and db path and a list of column family names.
    If opened in read write mode every existing column family name must be passed within the list to this method.
    
    If opened in read-only mode only a subset of existing column families must be passed to this method.
    
    Options instance *should* not be disposed before all DBs using this options instance have been closed. If user doesn't call options dispose explicitly, then this options instance will be GC'd automatically.
    
    Options instance can be re-used to open multiple DBs if DB statistics is not used. If DB statistics are required, then its recommended to open DB with new Options instance as underlying native statistics instance does not use any locks to prevent concurrent updates.
    
    ColumnFamily handles are disposed when the RocksDB instance is disposed.
    
    Parameters:
    options - DBOptions instance.
    path - the path to the rocksdb.
    columnFamilyDescriptors - list of column family descriptors
    columnFamilyHandles - will be filled with ColumnFamilyHandle instances on open.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    See Also:
    DBOptions.setCreateIfMissing(boolean)
  - openReadOnly
```
public static RocksDB openReadOnly(java.lang.String path)
                            throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the default options.
    
    Parameters:
    path - the path to the RocksDB.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - openReadOnly
```
public static RocksDB openReadOnly(java.lang.String path,
                   java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors,
                   java.util.List<ColumnFamilyHandle> columnFamilyHandles)
                            throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the default options.
    
    Parameters:
    path - the path to the RocksDB.
    columnFamilyDescriptors - list of column family descriptors
    columnFamilyHandles - will be filled with ColumnFamilyHandle instances on open.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - openReadOnly
```
public static RocksDB openReadOnly(Options options,
                   java.lang.String path)
                            throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the specified options and db path. Options instance *should* not be disposed before all DBs using this options instance have been closed. If user doesn't call options dispose explicitly, then this options instance will be GC'd automatically.
    
    Parameters:
    options - Options instance.
    path - the path to the RocksDB.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - openReadOnly
```
public static RocksDB openReadOnly(DBOptions options,
                   java.lang.String path,
                   java.util.List<ColumnFamilyDescriptor> columnFamilyDescriptors,
                   java.util.List<ColumnFamilyHandle> columnFamilyHandles)
                            throws RocksDBException
```
    The factory constructor of RocksDB that opens a RocksDB instance in Read-Only mode given the path to the database using the specified options and db path.
    This open method allows to open RocksDB using a subset of available column families
    
    Options instance *should* not be disposed before all DBs using this options instance have been closed. If user doesn't call options dispose explicitly,then this options instance will be GC'd automatically.
    
    Parameters:
    options - DBOptions instance.
    path - the path to the RocksDB.
    columnFamilyDescriptors - list of column family descriptors
    columnFamilyHandles - will be filled with ColumnFamilyHandle instances on open.
    
    Returns:
    a RocksDB instance on success, null if the specified RocksDB can not be opened.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - listColumnFamilies
```
public static java.util.List<byte[]> listColumnFamilies(Options options,
                                        java.lang.String path)
                                                 throws RocksDBException
```
    Static method to determine all available column families for a rocksdb database identified by path
    
    Parameters:
    options - Options for opening the database
    path - Absolute path to rocksdb database
    
    Returns:
    List<byte[]> List containing the column family names
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - storeOptionsInstance
```
protected void storeOptionsInstance(DBOptionsInterface options)
```
  - put
```
public void put(byte[] key,
       byte[] value)
         throws RocksDBException
```
    Set the database entry for "key" to "value".
    
    Parameters:
    key - the specified key to be inserted.
    value - the value associated with the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - put
```
public void put(byte[] key,
       int offset,
       int len,
       byte[] value,
       int vOffset,
       int vLen)
         throws RocksDBException
```
    Set the database entry for "key" to "value"
    
    Parameters:
    key - The specified key to be inserted
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and must be non-negative and no larger than ("key".length - offset)
    value - the value associated with the specified key
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if errors happens in underlying native library.
  - put
```
public void put(ColumnFamilyHandle columnFamilyHandle,
       byte[] key,
       byte[] value)
         throws RocksDBException
```
    Set the database entry for "key" to "value" in the specified column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the specified key to be inserted.
    value - the value associated with the specified key. throws IllegalArgumentException if column family is not present
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - put
```
public void put(ColumnFamilyHandle columnFamilyHandle,
       byte[] key,
       int offset,
       int len,
       byte[] value,
       int vOffset,
       int vLen)
         throws RocksDBException
```
    Set the database entry for "key" to "value" in the specified column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - The specified key to be inserted
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and must be non-negative and no larger than ("key".length - offset)
    value - the value associated with the specified key
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if errors happens in underlying native library.
  - put
```
public void put(WriteOptions writeOpts,
       byte[] key,
       byte[] value)
         throws RocksDBException
```
    Set the database entry for "key" to "value".
    
    Parameters:
    writeOpts - WriteOptions instance.
    key - the specified key to be inserted.
    value - the value associated with the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - put
```
public void put(WriteOptions writeOpts,
       byte[] key,
       int offset,
       int len,
       byte[] value,
       int vOffset,
       int vLen)
         throws RocksDBException
```
    Set the database entry for "key" to "value".
    
    Parameters:
    writeOpts - WriteOptions instance.
    key - The specified key to be inserted
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and must be non-negative and no larger than ("key".length - offset)
    value - the value associated with the specified key
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - put
```
public void put(ColumnFamilyHandle columnFamilyHandle,
       WriteOptions writeOpts,
       byte[] key,
       byte[] value)
         throws RocksDBException
```
    Set the database entry for "key" to "value" for the specified column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpts - WriteOptions instance.
    key - the specified key to be inserted.
    value - the value associated with the specified key. throws IllegalArgumentException if column family is not present
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    See Also:
    IllegalArgumentException
  - put
```
public void put(ColumnFamilyHandle columnFamilyHandle,
       WriteOptions writeOpts,
       byte[] key,
       int offset,
       int len,
       byte[] value,
       int vOffset,
       int vLen)
         throws RocksDBException
```
    Set the database entry for "key" to "value" for the specified column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpts - WriteOptions instance.
    key - The specified key to be inserted
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and must be non-negative and no larger than ("key".length - offset)
    value - the value associated with the specified key
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - keyMayExist
```
public boolean keyMayExist(byte[] key,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    key - byte array of a key to search for
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(byte[] key,
                  int offset,
                  int len,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    key - byte array of a key to search for
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(ColumnFamilyHandle columnFamilyHandle,
                  byte[] key,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - byte array of a key to search for
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(ColumnFamilyHandle columnFamilyHandle,
                  byte[] key,
                  int offset,
                  int len,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - byte array of a key to search for
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(ReadOptions readOptions,
                  byte[] key,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    readOptions - ReadOptions instance
    key - byte array of a key to search for
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(ReadOptions readOptions,
                  byte[] key,
                  int offset,
                  int len,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    readOptions - ReadOptions instance
    key - byte array of a key to search for
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(ReadOptions readOptions,
                  ColumnFamilyHandle columnFamilyHandle,
                  byte[] key,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    readOptions - ReadOptions instance
    columnFamilyHandle - ColumnFamilyHandle instance
    key - byte array of a key to search for
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - keyMayExist
```
public boolean keyMayExist(ReadOptions readOptions,
                  ColumnFamilyHandle columnFamilyHandle,
                  byte[] key,
                  int offset,
                  int len,
                  java.lang.StringBuilder value)
```
    If the key definitely does not exist in the database, then this method returns false, else true. This check is potentially lighter-weight than invoking DB::Get(). One way to make this lighter weight is to avoid doing any IOs.
    
    Parameters:
    readOptions - ReadOptions instance
    columnFamilyHandle - ColumnFamilyHandle instance
    key - byte array of a key to search for
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - StringBuilder instance which is a out parameter if a value is found in block-cache.
    
    Returns:
    boolean value indicating if key does not exist or might exist.
  - write
```
public void write(WriteOptions writeOpts,
         WriteBatch updates)
           throws RocksDBException
```
    Apply the specified updates to the database.
    
    Parameters:
    writeOpts - WriteOptions instance
    updates - WriteBatch instance
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - write
```
public void write(WriteOptions writeOpts,
         WriteBatchWithIndex updates)
           throws RocksDBException
```
    Apply the specified updates to the database.
    
    Parameters:
    writeOpts - WriteOptions instance
    updates - WriteBatchWithIndex instance
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(byte[] key,
         byte[] value)
           throws RocksDBException
```
    Add merge operand for key/value pair.
    
    Parameters:
    key - the specified key to be merged.
    value - the value to be merged with the current value for the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(byte[] key,
         int offset,
         int len,
         byte[] value,
         int vOffset,
         int vLen)
           throws RocksDBException
```
    Add merge operand for key/value pair.
    
    Parameters:
    key - the specified key to be merged.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the value to be merged with the current value for the specified key.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(ColumnFamilyHandle columnFamilyHandle,
         byte[] key,
         byte[] value)
           throws RocksDBException
```
    Add merge operand for key/value pair in a ColumnFamily.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the specified key to be merged.
    value - the value to be merged with the current value for the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(ColumnFamilyHandle columnFamilyHandle,
         byte[] key,
         int offset,
         int len,
         byte[] value,
         int vOffset,
         int vLen)
           throws RocksDBException
```
    Add merge operand for key/value pair in a ColumnFamily.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the specified key to be merged.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the value to be merged with the current value for the specified key.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(WriteOptions writeOpts,
         byte[] key,
         byte[] value)
           throws RocksDBException
```
    Add merge operand for key/value pair.
    
    Parameters:
    writeOpts - WriteOptions for this write.
    key - the specified key to be merged.
    value - the value to be merged with the current value for the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(WriteOptions writeOpts,
         byte[] key,
         int offset,
         int len,
         byte[] value,
         int vOffset,
         int vLen)
           throws RocksDBException
```
    Add merge operand for key/value pair.
    
    Parameters:
    writeOpts - WriteOptions for this write.
    key - the specified key to be merged.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the value to be merged with the current value for the specified key.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(ColumnFamilyHandle columnFamilyHandle,
         WriteOptions writeOpts,
         byte[] key,
         byte[] value)
           throws RocksDBException
```
    Add merge operand for key/value pair.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpts - WriteOptions for this write.
    key - the specified key to be merged.
    value - the value to be merged with the current value for the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - merge
```
public void merge(ColumnFamilyHandle columnFamilyHandle,
         WriteOptions writeOpts,
         byte[] key,
         int offset,
         int len,
         byte[] value,
         int vOffset,
         int vLen)
           throws RocksDBException
```
    Add merge operand for key/value pair.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpts - WriteOptions for this write.
    key - the specified key to be merged.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the value to be merged with the current value for the specified key.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public int get(byte[] key,
      byte[] value)
        throws RocksDBException
```
    Get the value associated with the specified key within column family*
    
    Parameters:
    key - the key to retrieve the value.
    value - the out-value to receive the retrieved value.
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public int get(byte[] key,
      int offset,
      int len,
      byte[] value,
      int vOffset,
      int vLen)
        throws RocksDBException
```
    Get the value associated with the specified key within column family*
    
    Parameters:
    key - the key to retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the out-value to receive the retrieved value.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public int get(ColumnFamilyHandle columnFamilyHandle,
      byte[] key,
      byte[] value)
        throws RocksDBException,
               java.lang.IllegalArgumentException
```
    Get the value associated with the specified key within column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the key to retrieve the value.
    value - the out-value to receive the retrieved value.
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    
    java.lang.IllegalArgumentException
  - get
```
public int get(ColumnFamilyHandle columnFamilyHandle,
      byte[] key,
      int offset,
      int len,
      byte[] value,
      int vOffset,
      int vLen)
        throws RocksDBException,
               java.lang.IllegalArgumentException
```
    Get the value associated with the specified key within column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the key to retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the out-value to receive the retrieved value.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    
    java.lang.IllegalArgumentException
  - get
```
public int get(ReadOptions opt,
      byte[] key,
      byte[] value)
        throws RocksDBException
```
    Get the value associated with the specified key.
    
    Parameters:
    opt - ReadOptions instance.
    key - the key to retrieve the value.
    value - the out-value to receive the retrieved value.
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public int get(ReadOptions opt,
      byte[] key,
      int offset,
      int len,
      byte[] value,
      int vOffset,
      int vLen)
        throws RocksDBException
```
    Get the value associated with the specified key.
    
    Parameters:
    opt - ReadOptions instance.
    key - the key to retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the out-value to receive the retrieved value.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public int get(ColumnFamilyHandle columnFamilyHandle,
      ReadOptions opt,
      byte[] key,
      byte[] value)
        throws RocksDBException
```
    Get the value associated with the specified key within column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    opt - ReadOptions instance.
    key - the key to retrieve the value.
    value - the out-value to receive the retrieved value.
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public int get(ColumnFamilyHandle columnFamilyHandle,
      ReadOptions opt,
      byte[] key,
      int offset,
      int len,
      byte[] value,
      int vOffset,
      int vLen)
        throws RocksDBException
```
    Get the value associated with the specified key within column family.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    opt - ReadOptions instance.
    key - the key to retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    value - the out-value to receive the retrieved value.
    vOffset - the offset of the "value" array to be used, must be non-negative and no longer than "key".length
    vLen - the length of the "value" array to be used, must be non-negative and must be non-negative and no larger than ("value".length - offset)
    
    Returns:
    The size of the actual value that matches the specified key in byte. If the return value is greater than the length of value, then it indicates that the size of the input buffer value is insufficient and partial result will be returned. RocksDB.NOT_FOUND will be returned if the value not found.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(byte[] key)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    key - the key retrieve the value.
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(byte[] key,
         int offset,
         int len)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    key - the key retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(ColumnFamilyHandle columnFamilyHandle,
         byte[] key)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the key retrieve the value.
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(ColumnFamilyHandle columnFamilyHandle,
         byte[] key,
         int offset,
         int len)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the key retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(ReadOptions opt,
         byte[] key)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    key - the key retrieve the value.
    opt - Read options.
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(ReadOptions opt,
         byte[] key,
         int offset,
         int len)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    key - the key retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    opt - Read options.
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(ColumnFamilyHandle columnFamilyHandle,
         ReadOptions opt,
         byte[] key)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the key retrieve the value.
    opt - Read options.
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - get
```
public byte[] get(ColumnFamilyHandle columnFamilyHandle,
         ReadOptions opt,
         byte[] key,
         int offset,
         int len)
           throws RocksDBException
```
    The simplified version of get which returns a new byte array storing the value associated with the specified input key if any. null will be returned if the specified key is not found.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - the key retrieve the value.
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    opt - Read options.
    
    Returns:
    a byte array storing the value associated with the input key if any. null if it does not find the specified key.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - multiGet
```
public java.util.Map<byte[],byte[]> multiGet(java.util.List<byte[]> keys)
                                      throws RocksDBException
```
    Returns a map of keys for which values were found in DB.
    
    Parameters:
    keys - List of keys for which values need to be retrieved.
    
    Returns:
    Map where key of map is the key passed by user and value for map entry is the corresponding value in DB.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - multiGet
```
public java.util.Map<byte[],byte[]> multiGet(java.util.List<ColumnFamilyHandle> columnFamilyHandleList,
                                    java.util.List<byte[]> keys)
                                      throws RocksDBException,
                                             java.lang.IllegalArgumentException
```
    Returns a map of keys for which values were found in DB.
    Note: Every key needs to have a related column family name in columnFamilyHandleList.
    
    Parameters:
    columnFamilyHandleList - List containing ColumnFamilyHandle instances.
    keys - List of keys for which values need to be retrieved.
    
    Returns:
    Map where key of map is the key passed by user and value for map entry is the corresponding value in DB.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    
    java.lang.IllegalArgumentException - thrown if the size of passed keys is not equal to the amount of passed column family handles.
  - multiGet
```
public java.util.Map<byte[],byte[]> multiGet(ReadOptions opt,
                                    java.util.List<byte[]> keys)
                                      throws RocksDBException
```
    Returns a map of keys for which values were found in DB.
    
    Parameters:
    opt - Read options.
    keys - of keys for which values need to be retrieved.
    
    Returns:
    Map where key of map is the key passed by user and value for map entry is the corresponding value in DB.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - multiGet
```
public java.util.Map<byte[],byte[]> multiGet(ReadOptions opt,
                                    java.util.List<ColumnFamilyHandle> columnFamilyHandleList,
                                    java.util.List<byte[]> keys)
                                      throws RocksDBException
```
    Returns a map of keys for which values were found in DB.
    Note: Every key needs to have a related column family name in columnFamilyHandleList.
    
    Parameters:
    opt - Read options.
    columnFamilyHandleList - List containing ColumnFamilyHandle instances.
    keys - of keys for which values need to be retrieved.
    
    Returns:
    Map where key of map is the key passed by user and value for map entry is the corresponding value in DB.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    
    java.lang.IllegalArgumentException - thrown if the size of passed keys is not equal to the amount of passed column family handles.
  - remove
```
@Deprecated
public void remove(byte[] key)
            throws RocksDBException
```
    Deprecated. Use delete(byte[])
    
    Remove the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(byte[] key)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(byte[] key,
          int offset,
          int len)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    key - Key to delete within database
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - remove
```
@Deprecated
public void remove(ColumnFamilyHandle columnFamilyHandle,
                     byte[] key)
            throws RocksDBException
```
    Deprecated. Use delete(ColumnFamilyHandle, byte[])
    
    Remove the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(ColumnFamilyHandle columnFamilyHandle,
          byte[] key)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(ColumnFamilyHandle columnFamilyHandle,
          byte[] key,
          int offset,
          int len)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    key - Key to delete within database
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - remove
```
@Deprecated
public void remove(WriteOptions writeOpt,
                     byte[] key)
            throws RocksDBException
```
    Deprecated. Use delete(WriteOptions, byte[])
    
    Remove the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    writeOpt - WriteOptions to be used with delete operation
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(WriteOptions writeOpt,
          byte[] key)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    writeOpt - WriteOptions to be used with delete operation
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(WriteOptions writeOpt,
          byte[] key,
          int offset,
          int len)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    writeOpt - WriteOptions to be used with delete operation
    key - Key to delete within database
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - remove
```
@Deprecated
public void remove(ColumnFamilyHandle columnFamilyHandle,
                     WriteOptions writeOpt,
                     byte[] key)
            throws RocksDBException
```
    Deprecated. Use delete(ColumnFamilyHandle, WriteOptions, byte[])
    
    Remove the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpt - WriteOptions to be used with delete operation
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(ColumnFamilyHandle columnFamilyHandle,
          WriteOptions writeOpt,
          byte[] key)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpt - WriteOptions to be used with delete operation
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - delete
```
public void delete(ColumnFamilyHandle columnFamilyHandle,
          WriteOptions writeOpt,
          byte[] key,
          int offset,
          int len)
            throws RocksDBException
```
    Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpt - WriteOptions to be used with delete operation
    key - Key to delete within database
    offset - the offset of the "key" array to be used, must be non-negative and no larger than "key".length
    len - the length of the "key" array to be used, must be non-negative and
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - singleDelete
```
@Experimental(value="Performance optimization for a very specific workload")
public void singleDelete(byte[] key)
                  throws RocksDBException
```
    Remove the database entry for key. Requires that the key exists and was not overwritten. It is not an error if the key did not exist in the database. If a key is overwritten (by calling put(byte[], byte[]) multiple times), then the result of calling SingleDelete() on this key is undefined. SingleDelete() only behaves correctly if there has been only one Put() for this key since the previous call to SingleDelete() for this key. This feature is currently an experimental performance optimization for a very specific workload. It is up to the caller to ensure that SingleDelete is only used for a key that is not deleted using Delete() or written using Merge(). Mixing SingleDelete operations with Deletes and Merges can result in undefined behavior.
    
    Parameters:
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - singleDelete
```
@Experimental(value="Performance optimization for a very specific workload")
public void singleDelete(ColumnFamilyHandle columnFamilyHandle,
                                  byte[] key)
                  throws RocksDBException
```
    Remove the database entry for key. Requires that the key exists and was not overwritten. It is not an error if the key did not exist in the database. If a key is overwritten (by calling put(byte[], byte[]) multiple times), then the result of calling SingleDelete() on this key is undefined. SingleDelete() only behaves correctly if there has been only one Put() for this key since the previous call to SingleDelete() for this key. This feature is currently an experimental performance optimization for a very specific workload. It is up to the caller to ensure that SingleDelete is only used for a key that is not deleted using Delete() or written using Merge(). Mixing SingleDelete operations with Deletes and Merges can result in undefined behavior.
    
    Parameters:
    columnFamilyHandle - The column family to delete the key from
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - singleDelete
```
@Experimental(value="Performance optimization for a very specific workload")
public void singleDelete(WriteOptions writeOpt,
                                  byte[] key)
                  throws RocksDBException
```
    Remove the database entry for key. Requires that the key exists and was not overwritten. It is not an error if the key did not exist in the database. If a key is overwritten (by calling put(byte[], byte[]) multiple times), then the result of calling SingleDelete() on this key is undefined. SingleDelete() only behaves correctly if there has been only one Put() for this key since the previous call to SingleDelete() for this key. This feature is currently an experimental performance optimization for a very specific workload. It is up to the caller to ensure that SingleDelete is only used for a key that is not deleted using Delete() or written using Merge(). Mixing SingleDelete operations with Deletes and Merges can result in undefined behavior. Note: consider setting WriteOptions.setSync(boolean) true.
    
    Parameters:
    writeOpt - Write options for the delete
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - singleDelete
```
@Experimental(value="Performance optimization for a very specific workload")
public void singleDelete(ColumnFamilyHandle columnFamilyHandle,
                                  WriteOptions writeOpt,
                                  byte[] key)
                  throws RocksDBException
```
    Remove the database entry for key. Requires that the key exists and was not overwritten. It is not an error if the key did not exist in the database. If a key is overwritten (by calling put(byte[], byte[]) multiple times), then the result of calling SingleDelete() on this key is undefined. SingleDelete() only behaves correctly if there has been only one Put() for this key since the previous call to SingleDelete() for this key. This feature is currently an experimental performance optimization for a very specific workload. It is up to the caller to ensure that SingleDelete is only used for a key that is not deleted using Delete() or written using Merge(). Mixing SingleDelete operations with Deletes and Merges can result in undefined behavior. Note: consider setting WriteOptions.setSync(boolean) true.
    
    Parameters:
    columnFamilyHandle - The column family to delete the key from
    writeOpt - Write options for the delete
    key - Key to delete within database
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - getProperty
```
public java.lang.String getProperty(ColumnFamilyHandle columnFamilyHandle,
                           java.lang.String property)
                             throws RocksDBException
```
    DB implements can export properties about their state via this method on a per column family level.
    If property is a valid property understood by this DB implementation, fills value with its current value and returns true. Otherwise returns false.
    
    Valid property names include:
    - "rocksdb.num-files-at-level<N>" - return the number of files at level <N>, where <N> is an ASCII representation of a level number (e.g. "0").
    - "rocksdb.stats" - returns a multi-line string that describes statistics about the internal operation of the DB.
    - "rocksdb.sstables" - returns a multi-line string that describes all of the sstables that make up the db contents.
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    property - to be fetched. See above for examples
    
    Returns:
    property value
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - deleteRange
```
public void deleteRange(byte[] beginKey,
               byte[] endKey)
                 throws RocksDBException
```
    Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey". a non-OK status on error. It is not an error if no keys exist in the range ["beginKey", "endKey"). Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    beginKey - First key to delete within database (included)
    endKey - Last key to delete within database (excluded)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - deleteRange
```
public void deleteRange(ColumnFamilyHandle columnFamilyHandle,
               byte[] beginKey,
               byte[] endKey)
                 throws RocksDBException
```
    Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey". a non-OK status on error. It is not an error if no keys exist in the range ["beginKey", "endKey"). Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    beginKey - First key to delete within database (included)
    endKey - Last key to delete within database (excluded)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - deleteRange
```
public void deleteRange(WriteOptions writeOpt,
               byte[] beginKey,
               byte[] endKey)
                 throws RocksDBException
```
    Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey". a non-OK status on error. It is not an error if no keys exist in the range ["beginKey", "endKey"). Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    writeOpt - WriteOptions to be used with delete operation
    beginKey - First key to delete within database (included)
    endKey - Last key to delete within database (excluded)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - deleteRange
```
public void deleteRange(ColumnFamilyHandle columnFamilyHandle,
               WriteOptions writeOpt,
               byte[] beginKey,
               byte[] endKey)
                 throws RocksDBException
```
    Removes the database entries in the range ["beginKey", "endKey"), i.e., including "beginKey" and excluding "endKey". a non-OK status on error. It is not an error if no keys exist in the range ["beginKey", "endKey"). Delete the database entry (if any) for "key". Returns OK on success, and a non-OK status on error. It is not an error if "key" did not exist in the database.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    writeOpt - WriteOptions to be used with delete operation
    beginKey - First key to delete within database (included)
    endKey - Last key to delete within database (excluded)
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - getProperty
```
public java.lang.String getProperty(java.lang.String property)
                             throws RocksDBException
```
    DB implementations can export properties about their state via this method. If "property" is a valid property understood by this DB implementation, fills "*value" with its current value and returns true. Otherwise returns false.
    Valid property names include:
    - "rocksdb.num-files-at-level<N>" - return the number of files at level <N>, where <N> is an ASCII representation of a level number (e.g. "0").
    - "rocksdb.stats" - returns a multi-line string that describes statistics about the internal operation of the DB.
    - "rocksdb.sstables" - returns a multi-line string that describes all of the sstables that make up the db contents.
    Parameters:
    property - to be fetched. See above for examples
    
    Returns:
    property value
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - getLongProperty
```
public long getLongProperty(java.lang.String property)
                     throws RocksDBException
```
    Similar to GetProperty(), but only works for a subset of properties whose return value is a numerical value. Return the value as long.
    
    Note: As the returned property is of type uint64_t on C++ side the returning value can be negative because Java supports in Java 7 only signed long values.
    
    Java 7: To mitigate the problem of the non existent unsigned long tpye, values should be encapsulated using java.math.BigInteger to reflect the correct value. The correct behavior is guaranteed if 2^64 is added to negative values.
    
    Java 8: In Java 8 the value should be treated as unsigned long using provided methods of type Long.
    
    Parameters:
    property - to be fetched.
    
    Returns:
    numerical property value.
    
    Throws:
    
    RocksDBException - if an error happens in the underlying native code.
  - getLongProperty
```
public long getLongProperty(ColumnFamilyHandle columnFamilyHandle,
                   java.lang.String property)
                     throws RocksDBException
```
    Similar to GetProperty(), but only works for a subset of properties whose return value is a numerical value. Return the value as long.
    
    Note: As the returned property is of type uint64_t on C++ side the returning value can be negative because Java supports in Java 7 only signed long values.
    
    Java 7: To mitigate the problem of the non existent unsigned long tpye, values should be encapsulated using java.math.BigInteger to reflect the correct value. The correct behavior is guaranteed if 2^64 is added to negative values.
    
    Java 8: In Java 8 the value should be treated as unsigned long using provided methods of type Long.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    property - to be fetched.
    
    Returns:
    numerical property value
    
    Throws:
    
    RocksDBException - if an error happens in the underlying native code.
  - getAggregatedLongProperty
```
public long getAggregatedLongProperty(java.lang.String property)
                               throws RocksDBException
```
    Return sum of the getLongProperty of all the column families
    
    Note: As the returned property is of type uint64_t on C++ side the returning value can be negative because Java supports in Java 7 only signed long values.
    
    Java 7: To mitigate the problem of the non existent unsigned long tpye, values should be encapsulated using java.math.BigInteger to reflect the correct value. The correct behavior is guaranteed if 2^64 is added to negative values.
    
    Java 8: In Java 8 the value should be treated as unsigned long using provided methods of type Long.
    
    Parameters:
    property - to be fetched.
    
    Returns:
    numerical property value
    
    Throws:
    
    RocksDBException - if an error happens in the underlying native code.
  - newIterator
```
public RocksIterator newIterator()
```
    Return a heap-allocated iterator over the contents of the database. The result of newIterator() is initially invalid (caller must call one of the Seek methods on the iterator before using it).
    
    Caller should close the iterator when it is no longer needed. The returned iterator should be closed before this db is closed.
    
    Returns:
    instance of iterator object.
  - newIterator
```
public RocksIterator newIterator(ReadOptions readOptions)
```
    Return a heap-allocated iterator over the contents of the database. The result of newIterator() is initially invalid (caller must call one of the Seek methods on the iterator before using it).
    
    Caller should close the iterator when it is no longer needed. The returned iterator should be closed before this db is closed.
    
    Parameters:
    readOptions - ReadOptions instance.
    
    Returns:
    instance of iterator object.
  - getSnapshot
```
public Snapshot getSnapshot()
```
    Return a handle to the current DB state. Iterators created with this handle will all observe a stable snapshot of the current DB state. The caller must call ReleaseSnapshot(result) when the snapshot is no longer needed.
    
    nullptr will be returned if the DB fails to take a snapshot or does not support snapshot.
    
    Returns:
    Snapshot Snapshot instance
  - releaseSnapshot
```
public void releaseSnapshot(Snapshot snapshot)
```
    Release a previously acquired snapshot. The caller must not use "snapshot" after this call.
    
    Parameters:
    snapshot - Snapshot instance
  - newIterator
```
public RocksIterator newIterator(ColumnFamilyHandle columnFamilyHandle)
```
    Return a heap-allocated iterator over the contents of the database. The result of newIterator() is initially invalid (caller must call one of the Seek methods on the iterator before using it).
    
    Caller should close the iterator when it is no longer needed. The returned iterator should be closed before this db is closed.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    
    Returns:
    instance of iterator object.
  - newIterator
```
public RocksIterator newIterator(ColumnFamilyHandle columnFamilyHandle,
                        ReadOptions readOptions)
```
    Return a heap-allocated iterator over the contents of the database. The result of newIterator() is initially invalid (caller must call one of the Seek methods on the iterator before using it).
    
    Caller should close the iterator when it is no longer needed. The returned iterator should be closed before this db is closed.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    readOptions - ReadOptions instance.
    
    Returns:
    instance of iterator object.
  - newIterators
```
public java.util.List<RocksIterator> newIterators(java.util.List<ColumnFamilyHandle> columnFamilyHandleList)
                                           throws RocksDBException
```
    Returns iterators from a consistent database state across multiple column families. Iterators are heap allocated and need to be deleted before the db is deleted
    
    Parameters:
    columnFamilyHandleList - List containing ColumnFamilyHandle instances.
    
    Returns:
    List containing RocksIterator instances
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - newIterators
```
public java.util.List<RocksIterator> newIterators(java.util.List<ColumnFamilyHandle> columnFamilyHandleList,
                                         ReadOptions readOptions)
                                           throws RocksDBException
```
    Returns iterators from a consistent database state across multiple column families. Iterators are heap allocated and need to be deleted before the db is deleted
    
    Parameters:
    columnFamilyHandleList - List containing ColumnFamilyHandle instances.
    readOptions - ReadOptions instance.
    
    Returns:
    List containing RocksIterator instances
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - getDefaultColumnFamily
```
public ColumnFamilyHandle getDefaultColumnFamily()
```
    Gets the handle for the default column family
    
    Returns:
    The handle of the default column family
  - createColumnFamily
```
public ColumnFamilyHandle createColumnFamily(ColumnFamilyDescriptor columnFamilyDescriptor)
                                      throws RocksDBException
```
    Creates a new column family with the name columnFamilyName and allocates a ColumnFamilyHandle within an internal structure. The ColumnFamilyHandle is automatically disposed with DB disposal.
    
    Parameters:
    columnFamilyDescriptor - column family to be created.
    
    Returns:
    ColumnFamilyHandle instance.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - dropColumnFamily
```
public void dropColumnFamily(ColumnFamilyHandle columnFamilyHandle)
                      throws RocksDBException,
                             java.lang.IllegalArgumentException
```
    Drops the column family identified by columnFamilyName. Internal handles to this column family will be disposed. If the column family is not known removal will fail.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
    
    java.lang.IllegalArgumentException
  - flush
```
public void flush(FlushOptions flushOptions)
           throws RocksDBException
```
    Flush all memory table data.
    
    Note: it must be ensured that the FlushOptions instance is not GC'ed before this method finishes. If the wait parameter is set to false, flush processing is asynchronous.
    
    Parameters:
    flushOptions - FlushOptions instance.
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - flush
```
public void flush(FlushOptions flushOptions,
         ColumnFamilyHandle columnFamilyHandle)
           throws RocksDBException
```
    Flush all memory table data.
    
    Note: it must be ensured that the FlushOptions instance is not GC'ed before this method finishes. If the wait parameter is set to false, flush processing is asynchronous.
    
    Parameters:
    flushOptions - FlushOptions instance.
    columnFamilyHandle - ColumnFamilyHandle instance.
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
public void compactRange()
                  throws RocksDBException
```
    Range compaction of database.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    See also
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
public void compactRange(byte[] begin,
                byte[] end)
                  throws RocksDBException
```
    Range compaction of database.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    See also
    Parameters:
    begin - start of key range (included in range)
    end - end of key range (excluded from range)
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
@Deprecated
public void compactRange(boolean reduce_level,
                           int target_level,
                           int target_path_id)
                  throws RocksDBException
```
    Deprecated. Use compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions) instead
    Range compaction of database.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    Compaction outputs should be placed in options.db_paths [target_path_id]. Behavior is undefined if target_path_id is out of range.
    
    See also
    Parameters:
    reduce_level - reduce level after compaction
    target_level - target level to compact to
    target_path_id - the target path id of output path
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
@Deprecated
public void compactRange(byte[] begin,
                           byte[] end,
                           boolean reduce_level,
                           int target_level,
                           int target_path_id)
                  throws RocksDBException
```
    Deprecated. Use compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions) instead
    Range compaction of database.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    Compaction outputs should be placed in options.db_paths [target_path_id]. Behavior is undefined if target_path_id is out of range.
    
    See also
    Parameters:
    begin - start of key range (included in range)
    end - end of key range (excluded from range)
    reduce_level - reduce level after compaction
    target_level - target level to compact to
    target_path_id - the target path id of output path
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
public void compactRange(ColumnFamilyHandle columnFamilyHandle)
                  throws RocksDBException
```
    Range compaction of column family.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    See also
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance.
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
public void compactRange(ColumnFamilyHandle columnFamilyHandle,
                byte[] begin,
                byte[] end)
                  throws RocksDBException
```
    Range compaction of column family.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    See also
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance.
    begin - start of key range (included in range)
    end - end of key range (excluded from range)
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
public void compactRange(ColumnFamilyHandle columnFamilyHandle,
                byte[] begin,
                byte[] end,
                CompactRangeOptions compactRangeOptions)
                  throws RocksDBException
```
    Range compaction of column family.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance.
    begin - start of key range (included in range)
    end - end of key range (excluded from range)
    compactRangeOptions - options for the compaction
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
@Deprecated
public void compactRange(ColumnFamilyHandle columnFamilyHandle,
                           boolean reduce_level,
                           int target_level,
                           int target_path_id)
                  throws RocksDBException
```
    Deprecated. Use compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions) instead
    Range compaction of column family.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    Compaction outputs should be placed in options.db_paths [target_path_id]. Behavior is undefined if target_path_id is out of range.
    
    See also
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance.
    reduce_level - reduce level after compaction
    target_level - target level to compact to
    target_path_id - the target path id of output path
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - compactRange
```
@Deprecated
public void compactRange(ColumnFamilyHandle columnFamilyHandle,
                           byte[] begin,
                           byte[] end,
                           boolean reduce_level,
                           int target_level,
                           int target_path_id)
                  throws RocksDBException
```
    Deprecated. Use compactRange(ColumnFamilyHandle, byte[], byte[], CompactRangeOptions) instead
    Range compaction of column family.
    
    Note: After the database has been compacted, all data will have been pushed down to the last level containing any data.
    
    Compaction outputs should be placed in options.db_paths [target_path_id]. Behavior is undefined if target_path_id is out of range.
    
    See also
    Parameters:
    columnFamilyHandle - ColumnFamilyHandle instance.
    begin - start of key range (included in range)
    end - end of key range (excluded from range)
    reduce_level - reduce level after compaction
    target_level - target level to compact to
    target_path_id - the target path id of output path
    
    Throws:
    
    RocksDBException - thrown if an error occurs within the native part of the library.
  - pauseBackgroundWork
```
public void pauseBackgroundWork()
                         throws RocksDBException
```
    This function will wait until all currently running background processes finish. After it returns, no background process will be run until continueBackgroundWork() is called
    
    Throws:
    
    RocksDBException - If an error occurs when pausing background work
  - continueBackgroundWork
```
public void continueBackgroundWork()
                            throws RocksDBException
```
    Resumes backround work which was suspended by previously calling pauseBackgroundWork()
    
    Throws:
    
    RocksDBException - If an error occurs when resuming background work
  - getLatestSequenceNumber
```
public long getLatestSequenceNumber()
```
    The sequence number of the most recent transaction.
    
    Returns:
    sequence number of the most recent transaction.
  - disableFileDeletions
```
public void disableFileDeletions()
                          throws RocksDBException
```
    Prevent file deletions. Compactions will continue to occur, but no obsolete files will be deleted. Calling this multiple times have the same effect as calling it once.
    
    Throws:
    
    RocksDBException - thrown if operation was not performed successfully.
  - enableFileDeletions
```
public void enableFileDeletions(boolean force)
                         throws RocksDBException
```
    Allow compactions to delete obsolete files. If force == true, the call to EnableFileDeletions() will guarantee that file deletions are enabled after the call, even if DisableFileDeletions() was called multiple times before.
    
    If force == false, EnableFileDeletions will only enable file deletion after it's been called at least as many times as DisableFileDeletions(), enabling the two methods to be called by two threads concurrently without synchronization -- i.e., file deletions will be enabled only after both threads call EnableFileDeletions()
    
    Parameters:
    force - boolean value described above.
    
    Throws:
    
    RocksDBException - thrown if operation was not performed successfully.
  - getUpdatesSince
```
public TransactionLogIterator getUpdatesSince(long sequenceNumber)
                                       throws RocksDBException
```
    Returns an iterator that is positioned at a write-batch containing seq_number. If the sequence number is non existent, it returns an iterator at the first available seq_no after the requested seq_no.
    
    Must set WAL_ttl_seconds or WAL_size_limit_MB to large values to use this api, else the WAL files will get cleared aggressively and the iterator might keep getting invalid before an update is read.
    
    Parameters:
    sequenceNumber - sequence number offset
    
    Returns:
    TransactionLogIterator instance.
    
    Throws:
    
    RocksDBException - if iterator cannot be retrieved from native-side.
  - setOptions
```
public void setOptions(ColumnFamilyHandle columnFamilyHandle,
              MutableColumnFamilyOptions mutableColumnFamilyOptions)
                throws RocksDBException
```
    Throws:
    
    RocksDBException
  - ingestExternalFile
```
public void ingestExternalFile(java.util.List<java.lang.String> filePathList,
                      IngestExternalFileOptions ingestExternalFileOptions)
                        throws RocksDBException
```
    ingestExternalFile will load a list of external SST files (1) into the DB We will try to find the lowest possible level that the file can fit in, and ingest the file into this level (2). A file that have a key range that overlap with the memtable key range will require us to Flush the memtable first before ingesting the file. (1) External SST files can be created using SstFileWriter (2) We will try to ingest the files to the lowest possible level even if the file compression doesn't match the level compression
    
    Parameters:
    filePathList - The list of files to ingest
    ingestExternalFileOptions - the options for the ingestion
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - ingestExternalFile
```
public void ingestExternalFile(ColumnFamilyHandle columnFamilyHandle,
                      java.util.List<java.lang.String> filePathList,
                      IngestExternalFileOptions ingestExternalFileOptions)
                        throws RocksDBException
```
    ingestExternalFile will load a list of external SST files (1) into the DB We will try to find the lowest possible level that the file can fit in, and ingest the file into this level (2). A file that have a key range that overlap with the memtable key range will require us to Flush the memtable first before ingesting the file. (1) External SST files can be created using SstFileWriter (2) We will try to ingest the files to the lowest possible level even if the file compression doesn't match the level compression
    
    Parameters:
    columnFamilyHandle - The column family for the ingested files
    filePathList - The list of files to ingest
    ingestExternalFileOptions - the options for the ingestion
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - destroyDB
```
public static void destroyDB(java.lang.String path,
             Options options)
                      throws RocksDBException
```
    Static method to destroy the contents of the specified database. Be very careful using this method.
    
    Parameters:
    path - the path to the Rocksdb database.
    options - Options instance.
    
    Throws:
    
    RocksDBException - thrown if error happens in underlying native library.
  - open
```
protected static long open(long optionsHandle,
        java.lang.String path)
                    throws RocksDBException
```
    Throws:
    
    RocksDBException
  - open
```
protected static long[] open(long optionsHandle,
          java.lang.String path,
          byte[][] columnFamilyNames,
          long[] columnFamilyOptions)
                      throws RocksDBException
```
    Parameters:
    optionsHandle - Native handle pointing to an Options object
    path - The directory path for the database files
    columnFamilyNames - An array of column family names
    columnFamilyOptions - An array of native handles pointing to ColumnFamilyOptions objects
    
    Returns:
    An array of native handles, [0] is the handle of the RocksDB object [1..1+n] are handles of the ColumnFamilyReferences
    
    Throws:
    
    RocksDBException - thrown if the database could not be opened
  - openROnly
```
protected static long openROnly(long optionsHandle,
             java.lang.String path)
                         throws RocksDBException
```
    Throws:
    
    RocksDBException
  - openROnly
```
protected static long[] openROnly(long optionsHandle,
               java.lang.String path,
               byte[][] columnFamilyNames,
               long[] columnFamilyOptions)
                           throws RocksDBException
```
    Parameters:
    optionsHandle - Native handle pointing to an Options object
    path - The directory path for the database files
    columnFamilyNames - An array of column family names
    columnFamilyOptions - An array of native handles pointing to ColumnFamilyOptions objects
    
    Returns:
    An array of native handles, [0] is the handle of the RocksDB object [1..1+n] are handles of the ColumnFamilyReferences
    
    Throws:
    
    RocksDBException - thrown if the database could not be opened
  - listColumnFamilies
```
protected static byte[][] listColumnFamilies(long optionsHandle,
                          java.lang.String path)
                                      throws RocksDBException
```
    Throws:
    
    RocksDBException
  - put
```
protected void put(long handle,
       byte[] key,
       int keyOffset,
       int keyLength,
       byte[] value,
       int valueOffset,
       int valueLength)
            throws RocksDBException
```
    Throws:
    
    RocksDBException
  - put
```
protected void put(long handle,
       byte[] key,
       int keyOffset,
       int keyLength,
       byte[] value,
       int valueOffset,
       int valueLength,
       long cfHandle)
            throws RocksDBException
```
    Throws:
    
    RocksDBException
  - put
```
protected void put(long handle,
       long writeOptHandle,
       byte[] key,
       int keyOffset,
       int keyLength,
       byte[] value,
       int valueOffset,
       int valueLength)
            throws RocksDBException
```
    Throws:
    
    RocksDBException
  - put
```
protected void put(long handle,
       long writeOptHandle,
       byte[] key,
       int keyOffset,
       int keyLength,
       byte[] value,
       int valueOffset,
       int valueLength,
       long cfHandle)
            throws RocksDBException
```
    Throws:
    
    RocksDBException
  - write0
```
protected void write0(long handle,
          long writeOptHandle,
          long wbHandle)
               throws RocksDBException
```
    Throws:
    
    RocksDBException
  - write1
```
protected void write1(long handle,
          long writeOptHandle,
          long wbwiHandle)
               throws RocksDBException
```
    Throws:
    
    RocksDBException
  - keyMayExist
```
protected boolean keyMayExist(long handle,
                  byte[] key,
                  int keyOffset,
                  int keyLength,
                  java.lang.StringBuilder stringBuilder)
```
  - keyMayExist
```
protected boolean keyMayExist(long handle,
                  byte[] key,
                  int keyOffset,
                  int keyLength,
                  long cfHandle,
                  java.lang.StringBuilder stringBuilder)
```
  - keyMayExist
```
protected boolean keyMayExist(long handle,
                  long optionsHandle,
                  byte[] key,
                  int keyOffset,
                  int keyLength,
                  java.lang.StringBuilder stringBuilder)
```
  - keyMayExist
```
protected boolean keyMayExist(long handle,
                  long optionsHandle,
                  byte[] key,
                  int keyOffset,
                  int keyLength,
                  long cfHandle,
                  java.lang.StringBuilder stringBuilder)
```
  - merge
```
protected void merge(long handle,
         byte[] key,
         int keyOffset,
         int keyLength,
         byte[] value,
         int valueOffset,
         int valueLength)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - merge
```
protected void merge(long handle,
         byte[] key,
         int keyOffset,
         int keyLength,
         byte[] value,
         int valueOffset,
         int valueLength,
         long cfHandle)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - merge
```
protected void merge(long handle,
         long writeOptHandle,
         byte[] key,
         int keyOffset,
         int keyLength,
         byte[] value,
         int valueOffset,
         int valueLength)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - merge
```
protected void merge(long handle,
         long writeOptHandle,
         byte[] key,
         int keyOffset,
         int keyLength,
         byte[] value,
         int valueOffset,
         int valueLength,
         long cfHandle)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected int get(long handle,
      byte[] key,
      int keyOffset,
      int keyLength,
      byte[] value,
      int valueOffset,
      int valueLength)
           throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected int get(long handle,
      byte[] key,
      int keyOffset,
      int keyLength,
      byte[] value,
      int valueOffset,
      int valueLength,
      long cfHandle)
           throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected int get(long handle,
      long readOptHandle,
      byte[] key,
      int keyOffset,
      int keyLength,
      byte[] value,
      int valueOffset,
      int valueLength)
           throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected int get(long handle,
      long readOptHandle,
      byte[] key,
      int keyOffset,
      int keyLength,
      byte[] value,
      int valueOffset,
      int valueLength,
      long cfHandle)
           throws RocksDBException
```
    Throws:
    
    RocksDBException
  - multiGet
```
protected byte[][] multiGet(long dbHandle,
                byte[][] keys,
                int[] keyOffsets,
                int[] keyLengths)
```
  - multiGet
```
protected byte[][] multiGet(long dbHandle,
                byte[][] keys,
                int[] keyOffsets,
                int[] keyLengths,
                long[] columnFamilyHandles)
```
  - multiGet
```
protected byte[][] multiGet(long dbHandle,
                long rOptHandle,
                byte[][] keys,
                int[] keyOffsets,
                int[] keyLengths)
```
  - multiGet
```
protected byte[][] multiGet(long dbHandle,
                long rOptHandle,
                byte[][] keys,
                int[] keyOffsets,
                int[] keyLengths,
                long[] columnFamilyHandles)
```
  - get
```
protected byte[] get(long handle,
         byte[] key,
         int keyOffset,
         int keyLength)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected byte[] get(long handle,
         byte[] key,
         int keyOffset,
         int keyLength,
         long cfHandle)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected byte[] get(long handle,
         long readOptHandle,
         byte[] key,
         int keyOffset,
         int keyLength)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - get
```
protected byte[] get(long handle,
         long readOptHandle,
         byte[] key,
         int keyOffset,
         int keyLength,
         long cfHandle)
              throws RocksDBException
```
    Throws:
    
    RocksDBException
  - delete
```
protected void delete(long handle,
          byte[] key,
          int keyOffset,
          int keyLength)
               throws RocksDBException
```
    Throws:
    
    RocksDBException
  - delete
```
protected void delete(long handle,
          byte[] key,
          int keyOffset,
          int keyLength,
          long cfHandle)
               throws RocksDBException
```
    Throws:
    
    RocksDBException
  - delete
```
protected void delete(long handle,
          long writeOptHandle,
          byte[] key,
          int keyOffset,
          int keyLength)
               throws RocksDBException
```
    Throws:
    
    RocksDBException
  - delete
```
protected void delete(long handle,
          long writeOptHandle,
          byte[] key,
          int keyOffset,
          int keyLength,
          long cfHandle)
               throws RocksDBException
```
    Throws:
    
    RocksDBException
  - singleDelete
```
protected void singleDelete(long handle,
                byte[] key,
                int keyLen)
                     throws RocksDBException
```
    Throws:
    
    RocksDBException
  - singleDelete
```
protected void singleDelete(long handle,
                byte[] key,
                int keyLen,
                long cfHandle)
                     throws RocksDBException
```
    Throws:
    
    RocksDBException
  - singleDelete
```
protected void singleDelete(long handle,
                long writeOptHandle,
                byte[] key,
                int keyLen)
                     throws RocksDBException
```
    Throws:
    
    RocksDBException
  - singleDelete
```
protected void singleDelete(long handle,
                long writeOptHandle,
                byte[] key,
                int keyLen,
                long cfHandle)
                     throws RocksDBException
```
    Throws:
    
    RocksDBException
  - deleteRange
```
protected void deleteRange(long handle,
               byte[] beginKey,
               int beginKeyOffset,
               int beginKeyLength,
               byte[] endKey,
               int endKeyOffset,
               int endKeyLength)
                    throws RocksDBException
```
    Throws:
    
    RocksDBException
  - deleteRange
```
protected void deleteRange(long handle,
               byte[] beginKey,
               int beginKeyOffset,
               int beginKeyLength,
               byte[] endKey,
               int endKeyOffset,
               int endKeyLength,
               long cfHandle)
                    throws RocksDBException
```
    Throws:
    
    RocksDBException
  - deleteRange
```
protected void deleteRange(long handle,
               long writeOptHandle,
               byte[] beginKey,
               int beginKeyOffset,
               int beginKeyLength,
               byte[] endKey,
               int endKeyOffset,
               int endKeyLength)
                    throws RocksDBException
```
    Throws:
    
    RocksDBException
  - deleteRange
```
protected void deleteRange(long handle,
               long writeOptHandle,
               byte[] beginKey,
               int beginKeyOffset,
               int beginKeyLength,
               byte[] endKey,
               int endKeyOffset,
               int endKeyLength,
               long cfHandle)
                    throws RocksDBException
```
    Throws:
    
    RocksDBException
  - getProperty0
```
protected java.lang.String getProperty0(long nativeHandle,
                            java.lang.String property,
                            int propertyLength)
                                 throws RocksDBException
```
    Throws:
    
    RocksDBException
  - getProperty0
```
protected java.lang.String getProperty0(long nativeHandle,
                            long cfHandle,
                            java.lang.String property,
                            int propertyLength)
                                 throws RocksDBException
```
    Throws:
    
    RocksDBException
  - getLongProperty
```
protected long getLongProperty(long nativeHandle,
                   java.lang.String property,
                   int propertyLength)
                        throws RocksDBException
```
    Throws:
    
    RocksDBException
  - getLongProperty
```
protected long getLongProperty(long nativeHandle,
                   long cfHandle,
                   java.lang.String property,
                   int propertyLength)
                        throws RocksDBException
```
    Throws:
    
    RocksDBException
  - getAggregatedLongProperty
```
protected long getAggregatedLongProperty(long nativeHandle,
                             java.lang.String property,
                             int propertyLength)
                                  throws RocksDBException
```
    Throws:
    
    RocksDBException
  - iterator
```
protected long iterator(long handle)
```
  - iterator
```
protected long iterator(long handle,
            long readOptHandle)
```
  - iteratorCF
```
protected long iteratorCF(long handle,
              long cfHandle)
```
  - iteratorCF
```
protected long iteratorCF(long handle,
              long cfHandle,
              long readOptHandle)
```
  - iterators
```
protected long[] iterators(long handle,
               long[] columnFamilyHandles,
               long readOptHandle)
                    throws RocksDBException
```
    Throws:
    
    RocksDBException
  - getSnapshot
```
protected long getSnapshot(long nativeHandle)
```
  - releaseSnapshot
```
protected void releaseSnapshot(long nativeHandle,
                   long snapshotHandle)
```
  - disposeInternal
```
protected void disposeInternal(long handle)
```
    Specified by:
    
    disposeInternal in class RocksObject

Class RocksDB

Field Summary

Fields inherited from class org.rocksdb.RocksObject

Constructor Summary

Method Summary

Methods inherited from class org.rocksdb.RocksObject

Methods inherited from class org.rocksdb.AbstractImmutableNativeReference

Methods inherited from class org.rocksdb.AbstractNativeReference

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_COLUMN_FAMILY

NOT_FOUND

options_

Constructor Detail

RocksDB

Method Detail

loadLibrary

loadLibrary

open

open

open

open

openReadOnly

openReadOnly

openReadOnly

openReadOnly

listColumnFamilies

storeOptionsInstance

put

put

put

put

put

put

put

put

keyMayExist

keyMayExist

keyMayExist

keyMayExist

keyMayExist

keyMayExist

keyMayExist

keyMayExist

write

write

merge

merge

merge

merge

merge

merge

merge

merge

get

get

get

get

get

get

get

get

get

get

get

get

get

get

get

get

multiGet

multiGet

multiGet

multiGet

remove

delete

delete

remove

delete

delete