Options

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

All Implemented Interfaces:

java.lang.AutoCloseable, ColumnFamilyOptionsInterface, DBOptionsInterface, MutableColumnFamilyOptionsInterface
```
public class Options
extends RocksObject
implements DBOptionsInterface, ColumnFamilyOptionsInterface, MutableColumnFamilyOptionsInterface
```
Options to control the behavior of a database. It will be used during the creation of a RocksDB (i.e., RocksDB.open()). If AbstractNativeReference.dispose() function is not called, then it will be GC'd automaticallyand native resources will be released as part of the process.

Field Summary
- Fields inherited from class org.rocksdb.RocksObject
  nativeHandle_
- Fields inherited from interface org.rocksdb.ColumnFamilyOptionsInterface
  DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET

Constructor Summary

Constructors
Constructor and Description
`Options()` Construct options for opening a RocksDB.
`Options(DBOptions dbOptions, ColumnFamilyOptions columnFamilyOptions)` Construct options for opening a RocksDB.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`adviseRandomOnOpen()` If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened.
`boolean`	`allowConcurrentMemtableWrite()` If true, allow multi-writers to update mem tables in parallel.
`boolean`	`allowMmapReads()` Allow the OS to mmap file for reading sst tables.
`boolean`	`allowMmapWrites()` Allow the OS to mmap file for writing.
`boolean`	`allowOsBuffer()` Data being read from file storage may be buffered in the OS Default: true
`long`	`arenaBlockSize()` The size of one block in arena memory allocation.
`int`	`baseBackgroundCompactions()` Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`int`	`bloomLocality()` Control locality of bloom filter probes to improve cache miss rate.
`long`	`bytesPerSync()` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`CompactionStyle`	`compactionStyle()` Compaction style for DB.
`java.util.List<CompressionType>`	`compressionPerLevel()` Return the currently set `CompressionType` per instances.
`CompressionType`	`compressionType()` Compress blocks using the specified compression algorithm.
`boolean`	`createIfMissing()` Return true if the create_if_missing flag is set to true.
`boolean`	`createMissingColumnFamilies()` Return true if the create_missing_column_families flag is set to true.
`Options`	`createStatistics()` Creates statistics object which collects metrics about database operations.
`java.lang.String`	`dbLogDir()` Returns the directory of info log.
`long`	`deleteObsoleteFilesPeriodMicros()` The periodicity when obsolete files get deleted.
`boolean`	`disableAutoCompactions()` Disable automatic compactions.
`boolean`	`disableDataSync()` If true, then the contents of data files are not synced to stable storage.
`protected void`	`disposeInternal(long handle)`
`boolean`	`enableWriteThreadAdaptiveYield()` If true, threads synchronizing with the write batch group leader will wait for up to `DBOptionsInterface.writeThreadMaxYieldUsec()` before blocking on a mutex.
`boolean`	`errorIfExists()` If true, an error will be thrown during RocksDB.open() if the database already exists.
`Env`	`getEnv()` Returns the set RocksEnv instance.
`long`	`hardPendingCompactionBytesLimit()` All writes are stopped if estimated bytes needed to be compaction exceed this threshold.
`double`	`hardRateLimit()` Puts are delayed 1ms at a time when any level has a compaction score that exceeds hard_rate_limit.
`InfoLogLevel`	`infoLogLevel()` Returns currently set log level.
`long`	`inplaceUpdateNumLocks()` Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
`boolean`	`inplaceUpdateSupport()` Allows thread-safe inplace updates.
`boolean`	`isFdCloseOnExec()` Disable child process inherit open files.
`long`	`keepLogFileNum()` Returns the maximum number of info log files to be kept.
`int`	`level0FileNumCompactionTrigger()` Number of files to trigger level-0 compaction.
`int`	`level0SlowdownWritesTrigger()` Soft limit on number of level-0 files.
`int`	`level0StopWritesTrigger()` Maximum number of level-0 files.
`boolean`	`levelCompactionDynamicLevelBytes()` Return if `LevelCompactionDynamicLevelBytes` is enabled.
`int`	`levelZeroFileNumCompactionTrigger()` The number of files in level 0 to trigger compaction from level-0 to level-1.
`int`	`levelZeroSlowdownWritesTrigger()` Soft limit on the number of level-0 files.
`int`	`levelZeroStopWritesTrigger()` Maximum number of level-0 files.
`long`	`logFileTimeToRoll()` Returns the time interval for the info log file to roll (in seconds).
`long`	`manifestPreallocationSize()` Number of bytes to preallocate (via fallocate) the manifest files.
`int`	`maxBackgroundCompactions()` Returns the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`int`	`maxBackgroundFlushes()` Returns the maximum number of concurrent background flush jobs.
`long`	`maxBytesForLevelBase()` The upper-bound of the total size of level-1 files in bytes.
`double`	`maxBytesForLevelMultiplier()` The ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
`int[]`	`maxBytesForLevelMultiplierAdditional()` Different max-size multipliers for different levels.
`long`	`maxCompactionBytes()` Control maximum size of each compaction (not guaranteed)
`long`	`maxLogFileSize()` Returns the maximum size of a info log file.
`long`	`maxManifestFileSize()` Manifest file is rolled over on reaching this limit.
`int`	`maxMemCompactionLevel()` This does nothing anymore.
`int`	`maxOpenFiles()` Number of open files that can be used by the DB.
`long`	`maxSequentialSkipInIterations()` An iteration->Next() sequentially skips over keys with the same user-key unless this option is set.
`int`	`maxSubcompactions()` This value represents the maximum number of threads that will concurrently perform a compaction job by breaking it into multiple, smaller ones that are run simultaneously.
`long`	`maxSuccessiveMerges()` Maximum number of successive merge operations on a key in the memtable.
`long`	`maxTableFilesSizeFIFO()` FIFO compaction option.
`long`	`maxTotalWalSize()` Returns the max total wal size.
`int`	`maxWriteBufferNumber()` Returns maximum number of write buffers.
`java.lang.String`	`memTableFactoryName()` Returns the name of the current mem table representation.
`long`	`memtableHugePageSize()` Page size for huge page TLB for bloom in memtable.
`double`	`memtablePrefixBloomSizeRatio()` if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio.
`int`	`minPartialMergeOperands()` The number of partial merge operands to accumulate before partial merge will be performed.
`int`	`minWriteBufferNumberToMerge()` The minimum number of write buffers that will be merged together before writing to storage.
`int`	`numLevels()` If level-styled compaction is used, then this number determines the total number of levels.
`boolean`	`optimizeFiltersForHits()` Returns the current state of the `optimize_filters_for_hits` setting.
`Options`	`optimizeForPointLookup(long blockCacheSizeMb)` Use this if you don't need to keep the data sorted, i.e.
`Options`	`optimizeLevelStyleCompaction()` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`Options`	`optimizeLevelStyleCompaction(long memtableMemoryBudget)` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`Options`	`optimizeUniversalStyleCompaction()` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`Options`	`optimizeUniversalStyleCompaction(long memtableMemoryBudget)` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`boolean`	`paranoidChecks()` If true, the implementation will do aggressive checking of the data it is processing and will stop early if it detects any errors.
`boolean`	`paranoidFileChecks()` After writing every SST file, reopen it and read all the keys.
`Options`	`prepareForBulkLoad()` Set appropriate parameters for bulk loading.
`boolean`	`purgeRedundantKvsWhileFlush()` Purge duplicate/deleted keys when a memtable is flushed to storage.
`int`	`rateLimitDelayMaxMilliseconds()` The maximum time interval a put will be stalled when hard_rate_limit is enforced.
`Options`	`setAdviseRandomOnOpen(boolean adviseRandomOnOpen)` If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened.
`void`	`setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)` If true, allow multi-writers to update mem tables in parallel.
`Options`	`setAllowMmapReads(boolean allowMmapReads)` Allow the OS to mmap file for reading sst tables.
`Options`	`setAllowMmapWrites(boolean allowMmapWrites)` Allow the OS to mmap file for writing.
`Options`	`setAllowOsBuffer(boolean allowOsBuffer)` Data being read from file storage may be buffered in the OS Default: true
`Options`	`setArenaBlockSize(long arenaBlockSize)` The size of one block in arena memory allocation.
`void`	`setBaseBackgroundCompactions(int baseBackgroundCompactions)` Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`Options`	`setBloomLocality(int bloomLocality)` Control locality of bloom filter probes to improve cache miss rate.
`Options`	`setBytesPerSync(long bytesPerSync)` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`Options`	`setCompactionStyle(CompactionStyle compactionStyle)` Set compaction style for DB.
`Options`	`setComparator(AbstractComparator<? extends AbstractSlice<?>> comparator)` Use the specified comparator for key ordering.
`Options`	`setComparator(BuiltinComparator builtinComparator)` Set `BuiltinComparator` to be used with RocksDB.
`Options`	`setCompressionPerLevel(java.util.List<CompressionType> compressionLevels)` Different levels can have different compression policies.
`Options`	`setCompressionType(CompressionType compressionType)` Compress blocks using the specified compression algorithm.
`Options`	`setCreateIfMissing(boolean flag)` If this value is set to true, then the database will be created if it is missing during `RocksDB.open()`.
`Options`	`setCreateMissingColumnFamilies(boolean flag)` If true, missing column families will be automatically created
`Options`	`setDbLogDir(java.lang.String dbLogDir)` This specifies the info LOG dir.
`Options`	`setDeleteObsoleteFilesPeriodMicros(long micros)` The periodicity when obsolete files get deleted.
`Options`	`setDisableAutoCompactions(boolean disableAutoCompactions)` Disable automatic compactions.
`Options`	`setDisableDataSync(boolean disableDataSync)` If true, then the contents of manifest and data files are not synced to stable storage.
`void`	`setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)` If true, threads synchronizing with the write batch group leader will wait for up to `DBOptionsInterface.writeThreadMaxYieldUsec()` before blocking on a mutex.
`Options`	`setEnv(Env env)` Use the specified object to interact with the environment, e.g.
`Options`	`setErrorIfExists(boolean errorIfExists)` If true, an error will be thrown during RocksDB.open() if the database already exists.
`Options`	`setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit)` All writes are stopped if estimated bytes needed to be compaction exceed this threshold.
`Options`	`setHardRateLimit(double hardRateLimit)` Puts are delayed 1ms at a time when any level has a compaction score that exceeds hard_rate_limit.
`Options`	`setIncreaseParallelism(int totalThreads)` By default, RocksDB uses only one background thread for flush and compaction.
`Options`	`setInfoLogLevel(InfoLogLevel infoLogLevel)` Sets the RocksDB log level.
`Options`	`setInplaceUpdateNumLocks(long inplaceUpdateNumLocks)` Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
`Options`	`setInplaceUpdateSupport(boolean inplaceUpdateSupport)` Allows thread-safe inplace updates.
`Options`	`setIsFdCloseOnExec(boolean isFdCloseOnExec)` Disable child process inherit open files.
`Options`	`setKeepLogFileNum(long keepLogFileNum)` Specifies the maximum number of info log files to be kept.
`Options`	`setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger)` Number of files to trigger level-0 compaction.
`Options`	`setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger)` Soft limit on number of level-0 files.
`MutableColumnFamilyOptionsInterface`	`setLevel0StopWritesTrigger(int level0StopWritesTrigger)` Maximum number of level-0 files.
`Options`	`setLevelCompactionDynamicLevelBytes(boolean enableLevelCompactionDynamicLevelBytes)` If `true`, RocksDB will pick target size of each level dynamically.
`Options`	`setLevelZeroFileNumCompactionTrigger(int numFiles)` Number of files to trigger level-0 compaction.
`Options`	`setLevelZeroSlowdownWritesTrigger(int numFiles)` Soft limit on number of level-0 files.
`Options`	`setLevelZeroStopWritesTrigger(int numFiles)` Maximum number of level-0 files.
`Options`	`setLogFileTimeToRoll(long logFileTimeToRoll)` Specifies the time interval for the info log file to roll (in seconds).
`Options`	`setLogger(Logger logger)` Any internal progress/error information generated by the db will be written to the Logger if it is non-nullptr, or to a file stored in the same directory as the DB contents if info_log is nullptr.
`Options`	`setManifestPreallocationSize(long size)` Number of bytes to preallocate (via fallocate) the manifest files.
`Options`	`setMaxBackgroundCompactions(int maxBackgroundCompactions)` Specifies the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`Options`	`setMaxBackgroundFlushes(int maxBackgroundFlushes)` Specifies the maximum number of concurrent background flush jobs.
`Options`	`setMaxBytesForLevelBase(long maxBytesForLevelBase)` The upper-bound of the total size of level-1 files in bytes.
`Options`	`setMaxBytesForLevelMultiplier(double multiplier)` The ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
`Options`	`setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional)` Different max-size multipliers for different levels.
`Options`	`setMaxCompactionBytes(long maxCompactionBytes)` Maximum size of each compaction (not guarantee)
`Options`	`setMaxLogFileSize(long maxLogFileSize)` Specifies the maximum size of a info log file.
`Options`	`setMaxManifestFileSize(long maxManifestFileSize)` Manifest file is rolled over on reaching this limit.
`Options`	`setMaxMemCompactionLevel(int maxMemCompactionLevel)` This does nothing anymore.
`Options`	`setMaxOpenFiles(int maxOpenFiles)` Number of open files that can be used by the DB.
`Options`	`setMaxSequentialSkipInIterations(long maxSequentialSkipInIterations)` An iteration->Next() sequentially skips over keys with the same user-key unless this option is set.
`void`	`setMaxSubcompactions(int maxSubcompactions)` This value represents the maximum number of threads that will concurrently perform a compaction job by breaking it into multiple, smaller ones that are run simultaneously.
`Options`	`setMaxSuccessiveMerges(long maxSuccessiveMerges)` Maximum number of successive merge operations on a key in the memtable.
`Options`	`setMaxTableFilesSizeFIFO(long maxTableFilesSize)` FIFO compaction option.
`Options`	`setMaxTotalWalSize(long maxTotalWalSize)` Once write-ahead logs exceed this size, we will start forcing the flush of column families whose memtables are backed by the oldest live WAL file (i.e.
`Options`	`setMaxWriteBufferNumber(int maxWriteBufferNumber)` The maximum number of write buffers that are built up in memory.
`Options`	`setMemTableConfig(MemTableConfig config)` Set the config for mem-table.
`Options`	`setMemtableHugePageSize(long memtableHugePageSize)` Page size for huge page TLB for bloom in memtable.
`Options`	`setMemtablePrefixBloomSizeRatio(double memtablePrefixBloomSizeRatio)` if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio.
`Options`	`setMergeOperator(MergeOperator mergeOperator)` Set the merge operator to be used for merging two different key/value pairs that share the same key.
`Options`	`setMergeOperatorName(java.lang.String name)` Set the merge operator to be used for merging two merge operands of the same key.
`Options`	`setMinPartialMergeOperands(int minPartialMergeOperands)` The number of partial merge operands to accumulate before partial merge will be performed.
`Options`	`setMinWriteBufferNumberToMerge(int minWriteBufferNumberToMerge)` The minimum number of write buffers that will be merged together before writing to storage.
`Options`	`setNumLevels(int numLevels)` Set the number of levels for this database If level-styled compaction is used, then this number determines the total number of levels.
`Options`	`setOptimizeFiltersForHits(boolean optimizeFiltersForHits)` This flag specifies that the implementation should optimize the filters mainly for cases where keys are found rather than also optimize for keys missed.
`Options`	`setParanoidChecks(boolean paranoidChecks)` If true, the implementation will do aggressive checking of the data it is processing and will stop early if it detects any errors.
`Options`	`setParanoidFileChecks(boolean paranoidFileChecks)` After writing every SST file, reopen it and read all the keys.
`Options`	`setPurgeRedundantKvsWhileFlush(boolean purgeRedundantKvsWhileFlush)` Purge duplicate/deleted keys when a memtable is flushed to storage.
`Options`	`setRateLimitDelayMaxMilliseconds(int rateLimitDelayMaxMilliseconds)` The maximum time interval a put will be stalled when hard_rate_limit is enforced.
`Options`	`setRateLimiter(RateLimiter rateLimiter)` Use to control write rate of flush and compaction.
`Options`	`setRateLimiterConfig(RateLimiterConfig config)` Use to control write rate of flush and compaction.
`Options`	`setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit)` All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold.
`Options`	`setSoftRateLimit(double softRateLimit)` Puts are delayed 0-1 ms when any level has a compaction score that exceeds soft_rate_limit.
`Options`	`setStatsDumpPeriodSec(int statsDumpPeriodSec)` if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
`Options`	`setTableCacheNumshardbits(int tableCacheNumshardbits)` Number of shards used for table cache.
`Options`	`setTableFormatConfig(TableFormatConfig config)` Set the config for table format.
`Options`	`setTargetFileSizeBase(long targetFileSizeBase)` The target file size for compaction.
`Options`	`setTargetFileSizeMultiplier(int multiplier)` targetFileSizeMultiplier defines the size ratio between a level-L file and level-(L+1) file.
`Options`	`setUseAdaptiveMutex(boolean useAdaptiveMutex)` Use adaptive mutex, which spins in the user space before resorting to kernel.
`Options`	`setUseFsync(boolean useFsync)` If true, then every store to stable storage will issue a fsync.
`Options`	`setVerifyChecksumsInCompaction(boolean verifyChecksumsInCompaction)` If true, compaction will verify checksum on every read that happens as part of compaction Default: true
`Options`	`setWalDir(java.lang.String walDir)` This specifies the absolute dir path for write-ahead logs (WAL).
`Options`	`setWalSizeLimitMB(long sizeLimitMB)` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`Options`	`setWalTtlSeconds(long walTtlSeconds)` `DBOptionsInterface.walTtlSeconds()` and `DBOptionsInterface.walSizeLimitMB()` affect how archived logs will be deleted.
`Options`	`setWriteBufferSize(long writeBufferSize)` Amount of data to build up in memory (backed by an unsorted log on disk) before converting to a sorted on-disk file.
`void`	`setWriteThreadMaxYieldUsec(long writeThreadMaxYieldUsec)` The maximum number of microseconds that a write operation will use a yielding spin loop to coordinate with other write threads before blocking on a mutex.
`void`	`setWriteThreadSlowYieldUsec(long writeThreadSlowYieldUsec)` The latency in microseconds after which a std::this_thread::yield call (sched_yield on Linux) is considered to be a signal that other processes or threads would like to use the current core.
`long`	`softPendingCompactionBytesLimit()` All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold.
`double`	`softRateLimit()` Puts are delayed 0-1 ms when any level has a compaction score that exceeds soft_rate_limit.
`Statistics`	`statisticsPtr()` Returns statistics object.
`int`	`statsDumpPeriodSec()` If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
`int`	`tableCacheNumshardbits()` Number of shards used for table cache.
`java.lang.String`	`tableFactoryName()`
`long`	`targetFileSizeBase()` The target file size for compaction.
`int`	`targetFileSizeMultiplier()` targetFileSizeMultiplier defines the size ratio between a level-(L+1) file and level-L file.
`boolean`	`useAdaptiveMutex()` Use adaptive mutex, which spins in the user space before resorting to kernel.
`Options`	`useCappedPrefixExtractor(int n)` Same as fixed length prefix extractor, except that when slice is shorter than the fixed length, it will use the full key.
`Options`	`useFixedLengthPrefixExtractor(int n)` This prefix-extractor uses the first n bytes of a key as its prefix.
`boolean`	`useFsync()` If true, then every store to stable storage will issue a fsync.
`boolean`	`verifyChecksumsInCompaction()` If true, compaction will verify checksum on every read that happens as part of compaction Default: true
`java.lang.String`	`walDir()` Returns the path to the write-ahead-logs (WAL) directory.
`long`	`walSizeLimitMB()` `DBOptionsInterface.walTtlSeconds()` and `#walSizeLimitMB()` affect how archived logs will be deleted.
`long`	`walTtlSeconds()` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`long`	`writeBufferSize()` Return size of write buffer size.
`long`	`writeThreadMaxYieldUsec()` The maximum number of microseconds that a write operation will use a yielding spin loop to coordinate with other write threads before blocking on a mutex.
`long`	`writeThreadSlowYieldUsec()` The latency in microseconds after which a std::this_thread::yield call (sched_yield on Linux) is considered to be a signal that other processes or threads would like to use the current core.

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

- Constructor Detail
  - Options
```
public Options()
```
    Construct options for opening a RocksDB. This constructor will create (by allocating a block of memory) an rocksdb::Options in the c++ side.
  - Options
```
public Options(DBOptions dbOptions,
       ColumnFamilyOptions columnFamilyOptions)
```
    Construct options for opening a RocksDB. Reusing database options and column family options.
    
    Parameters:
    dbOptions - DBOptions instance
    columnFamilyOptions - ColumnFamilyOptions instance
- Method Detail
  - setIncreaseParallelism
```
public Options setIncreaseParallelism(int totalThreads)
```
    Description copied from interface: DBOptionsInterface
    
    By default, RocksDB uses only one background thread for flush and compaction. Calling this function will set it up such that total of `total_threads` is used.
    
    You almost definitely want to call this function if your system is bottlenecked by RocksDB.
    
    Specified by:
    
    setIncreaseParallelism in interface DBOptionsInterface
    
    Parameters:
    totalThreads - The total number of threads to be used by RocksDB. A good value is the number of cores.
    
    Returns:
    the instance of the current Options
  - setCreateIfMissing
```
public Options setCreateIfMissing(boolean flag)
```
    Description copied from interface: DBOptionsInterface
    
    If this value is set to true, then the database will be created if it is missing during RocksDB.open(). Default: false
    
    Specified by:
    
    setCreateIfMissing in interface DBOptionsInterface
    
    Parameters:
    flag - a flag indicating whether to create a database the specified database in RocksDB.open(org.rocksdb.Options, String) operation is missing.
    
    Returns:
    the instance of the current Options
    See Also:
    RocksDB.open(org.rocksdb.Options, String)
  - setCreateMissingColumnFamilies
```
public Options setCreateMissingColumnFamilies(boolean flag)
```
    Description copied from interface: DBOptionsInterface
    
    If true, missing column families will be automatically created
    
    Default: false
    
    Specified by:
    
    setCreateMissingColumnFamilies in interface DBOptionsInterface
    
    Parameters:
    flag - a flag indicating if missing column families shall be created automatically.
    
    Returns:
    true if missing column families shall be created automatically on open.
  - setEnv
```
public Options setEnv(Env env)
```
    Use the specified object to interact with the environment, e.g. to read/write files, schedule background work, etc. Default: Env.getDefault()
    
    Parameters:
    env - Env instance.
    
    Returns:
    the instance of the current Options.
  - getEnv
```
public Env getEnv()
```
    Returns the set RocksEnv instance.
    
    Returns:
    RocksEnv instance set in the Options.
  - prepareForBulkLoad
```
public Options prepareForBulkLoad()
```
    Set appropriate parameters for bulk loading. The reason that this is a function that returns "this" instead of a constructor is to enable chaining of multiple similar calls in the future.
    
    All data will be in level 0 without any automatic compaction. It's recommended to manually call CompactRange(NULL, NULL) before reading from the database, because otherwise the read can be very slow.
    
    Returns:
    the instance of the current Options.
  - createIfMissing
```
public boolean createIfMissing()
```
    Description copied from interface: DBOptionsInterface
    
    Return true if the create_if_missing flag is set to true. If true, the database will be created if it is missing.
    
    Specified by:
    
    createIfMissing in interface DBOptionsInterface
    
    Returns:
    true if the createIfMissing option is set to true.
    See Also:
    DBOptionsInterface.setCreateIfMissing(boolean)
  - createMissingColumnFamilies
```
public boolean createMissingColumnFamilies()
```
    Description copied from interface: DBOptionsInterface
    
    Return true if the create_missing_column_families flag is set to true. If true column families be created if missing.
    
    Specified by:
    
    createMissingColumnFamilies in interface DBOptionsInterface
    
    Returns:
    true if the createMissingColumnFamilies is set to true.
    See Also:
    DBOptionsInterface.setCreateMissingColumnFamilies(boolean)
  - optimizeForPointLookup
```
public Options optimizeForPointLookup(long blockCacheSizeMb)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Use this if you don't need to keep the data sorted, i.e. you'll never use an iterator, only Put() and Get() API calls
    
    Specified by:
    
    optimizeForPointLookup in interface ColumnFamilyOptionsInterface
    
    Parameters:
    blockCacheSizeMb - Block cache size in MB
    
    Returns:
    the instance of the current Object.
  - optimizeLevelStyleCompaction
```
public Options optimizeLevelStyleCompaction()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for level style compaction.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    Specified by:
    
    optimizeLevelStyleCompaction in interface ColumnFamilyOptionsInterface
    
    Returns:
    the instance of the current Object.
  - optimizeLevelStyleCompaction
```
public Options optimizeLevelStyleCompaction(long memtableMemoryBudget)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for level style compaction.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    Specified by:
    
    optimizeLevelStyleCompaction in interface ColumnFamilyOptionsInterface
    
    Parameters:
    memtableMemoryBudget - memory budget in bytes
    
    Returns:
    the instance of the current Object.
  - optimizeUniversalStyleCompaction
```
public Options optimizeUniversalStyleCompaction()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for universal style compaction.
    
    Universal style compaction is focused on reducing Write Amplification Factor for big data sets, but increases Space Amplification.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    Specified by:
    
    optimizeUniversalStyleCompaction in interface ColumnFamilyOptionsInterface
    
    Returns:
    the instance of the current Object.
  - optimizeUniversalStyleCompaction
```
public Options optimizeUniversalStyleCompaction(long memtableMemoryBudget)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for universal style compaction.
    
    Universal style compaction is focused on reducing Write Amplification Factor for big data sets, but increases Space Amplification.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    Specified by:
    
    optimizeUniversalStyleCompaction in interface ColumnFamilyOptionsInterface
    
    Parameters:
    memtableMemoryBudget - memory budget in bytes
    
    Returns:
    the instance of the current Object.
  - setComparator
```
public Options setComparator(BuiltinComparator builtinComparator)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set BuiltinComparator to be used with RocksDB. Note: Comparator can be set once upon database creation. Default: BytewiseComparator.
    
    Specified by:
    
    setComparator in interface ColumnFamilyOptionsInterface
    
    Parameters:
    builtinComparator - a BuiltinComparator type.
    
    Returns:
    the instance of the current Object.
  - setComparator
```
public Options setComparator(AbstractComparator<? extends AbstractSlice<?>> comparator)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Use the specified comparator for key ordering. Comparator should not be disposed before options instances using this comparator is disposed. If dispose() function is not called, then comparator object will be GC'd automatically. Comparator instance can be re-used in multiple options instances.
    
    Specified by:
    
    setComparator in interface ColumnFamilyOptionsInterface
    
    Parameters:
    comparator - java instance.
    
    Returns:
    the instance of the current Object.
  - setMergeOperatorName
```
public Options setMergeOperatorName(java.lang.String name)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set the merge operator to be used for merging two merge operands of the same key. The merge function is invoked during compaction and at lookup time, if multiple key/value pairs belonging to the same key are found in the database.
    
    Specified by:
    
    setMergeOperatorName in interface ColumnFamilyOptionsInterface
    
    Parameters:
    name - the name of the merge function, as defined by the MergeOperators factory (see utilities/MergeOperators.h) The merge function is specified by name and must be one of the standard merge operators provided by RocksDB. The available operators are "put", "uint64add", "stringappend" and "stringappendtest".
    
    Returns:
    the instance of the current Object.
  - setMergeOperator
```
public Options setMergeOperator(MergeOperator mergeOperator)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set the merge operator to be used for merging two different key/value pairs that share the same key. The merge function is invoked during compaction and at lookup time, if multiple key/value pairs belonging to the same key are found in the database.
    
    Specified by:
    
    setMergeOperator in interface ColumnFamilyOptionsInterface
    
    Parameters:
    mergeOperator - MergeOperator instance.
    
    Returns:
    the instance of the current Object.
  - setWriteBufferSize
```
public Options setWriteBufferSize(long writeBufferSize)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Amount of data to build up in memory (backed by an unsorted log on disk) before converting to a sorted on-disk file. Larger values increase performance, especially during bulk loads. Up to max_write_buffer_number write buffers may be held in memory at the same time, so you may wish to adjust this parameter to control memory usage. Also, a larger write buffer will result in a longer recovery time the next time the database is opened. Default: 4MB
    
    Specified by:
    
    setWriteBufferSize in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    writeBufferSize - the size of write buffer.
    
    Returns:
    the instance of the current Object.
  - writeBufferSize
```
public long writeBufferSize()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Return size of write buffer size.
    
    Specified by:
    
    writeBufferSize in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    size of write buffer.
    See Also:
    MutableColumnFamilyOptionsInterface.setWriteBufferSize(long)
  - setMaxWriteBufferNumber
```
public Options setMaxWriteBufferNumber(int maxWriteBufferNumber)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The maximum number of write buffers that are built up in memory. The default is 2, so that when 1 write buffer is being flushed to storage, new writes can continue to the other write buffer. Default: 2
    
    Specified by:
    
    setMaxWriteBufferNumber in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    maxWriteBufferNumber - maximum number of write buffers.
    
    Returns:
    the instance of the current Object.
  - maxWriteBufferNumber
```
public int maxWriteBufferNumber()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Returns maximum number of write buffers.
    
    Specified by:
    
    maxWriteBufferNumber in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    maximum number of write buffers.
    See Also:
    MutableColumnFamilyOptionsInterface.setMaxWriteBufferNumber(int)
  - errorIfExists
```
public boolean errorIfExists()
```
    Description copied from interface: DBOptionsInterface
    
    If true, an error will be thrown during RocksDB.open() if the database already exists.
    
    Specified by:
    
    errorIfExists in interface DBOptionsInterface
    
    Returns:
    if true, an error is raised when the specified database already exists before open.
  - setErrorIfExists
```
public Options setErrorIfExists(boolean errorIfExists)
```
    Description copied from interface: DBOptionsInterface
    
    If true, an error will be thrown during RocksDB.open() if the database already exists. Default: false
    
    Specified by:
    
    setErrorIfExists in interface DBOptionsInterface
    
    Parameters:
    errorIfExists - if true, an exception will be thrown during RocksDB.open() if the database already exists.
    
    Returns:
    the reference to the current option.
    See Also:
    RocksDB.open(org.rocksdb.Options, String)
  - paranoidChecks
```
public boolean paranoidChecks()
```
    Description copied from interface: DBOptionsInterface
    
    If true, the implementation will do aggressive checking of the data it is processing and will stop early if it detects any errors. This may have unforeseen ramifications: for example, a corruption of one DB entry may cause a large number of entries to become unreadable or for the entire DB to become unopenable. If any of the writes to the database fails (Put, Delete, Merge, Write), the database will switch to read-only mode and fail all other Write operations.
    
    Specified by:
    
    paranoidChecks in interface DBOptionsInterface
    
    Returns:
    a boolean indicating whether paranoid-check is on.
  - setParanoidChecks
```
public Options setParanoidChecks(boolean paranoidChecks)
```
    Description copied from interface: DBOptionsInterface
    
    If true, the implementation will do aggressive checking of the data it is processing and will stop early if it detects any errors. This may have unforeseen ramifications: for example, a corruption of one DB entry may cause a large number of entries to become unreadable or for the entire DB to become unopenable. If any of the writes to the database fails (Put, Delete, Merge, Write), the database will switch to read-only mode and fail all other Write operations. Default: true
    
    Specified by:
    
    setParanoidChecks in interface DBOptionsInterface
    
    Parameters:
    paranoidChecks - a flag to indicate whether paranoid-check is on.
    
    Returns:
    the reference to the current option.
  - maxOpenFiles
```
public int maxOpenFiles()
```
    Description copied from interface: DBOptionsInterface
    
    Number of open files that can be used by the DB. You may need to increase this if your database has a large working set. Value -1 means files opened are always kept open. You can estimate number of files based on target_file_size_base and target_file_size_multiplier for level-based compaction. For universal-style compaction, you can usually set it to -1.
    
    Specified by:
    
    maxOpenFiles in interface DBOptionsInterface
    
    Returns:
    the maximum number of open files.
  - setMaxTotalWalSize
```
public Options setMaxTotalWalSize(long maxTotalWalSize)
```
    Description copied from interface: DBOptionsInterface
    
    Once write-ahead logs exceed this size, we will start forcing the flush of column families whose memtables are backed by the oldest live WAL file (i.e. the ones that are causing all the space amplification).
    
    If set to 0 (default), we will dynamically choose the WAL size limit to be [sum of all write_buffer_size * max_write_buffer_number] * 2
    
    Default: 0
    
    Specified by:
    
    setMaxTotalWalSize in interface DBOptionsInterface
    
    Parameters:
    maxTotalWalSize - max total wal size.
    
    Returns:
    the instance of the current Object.
  - maxTotalWalSize
```
public long maxTotalWalSize()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the max total wal size. Once write-ahead logs exceed this size, we will start forcing the flush of column families whose memtables are backed by the oldest live WAL file (i.e. the ones that are causing all the space amplification).
    
    If set to 0 (default), we will dynamically choose the WAL size limit to be [sum of all write_buffer_size * max_write_buffer_number] * 2
    
    Specified by:
    
    maxTotalWalSize in interface DBOptionsInterface
    
    Returns:
    max total wal size
  - setMaxOpenFiles
```
public Options setMaxOpenFiles(int maxOpenFiles)
```
    Description copied from interface: DBOptionsInterface
    
    Number of open files that can be used by the DB. You may need to increase this if your database has a large working set. Value -1 means files opened are always kept open. You can estimate number of files based on target_file_size_base and target_file_size_multiplier for level-based compaction. For universal-style compaction, you can usually set it to -1. Default: 5000
    
    Specified by:
    
    setMaxOpenFiles in interface DBOptionsInterface
    
    Parameters:
    maxOpenFiles - the maximum number of open files.
    
    Returns:
    the instance of the current Object.
  - disableDataSync
```
public boolean disableDataSync()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then the contents of data files are not synced to stable storage. Their contents remain in the OS buffers till the OS decides to flush them. This option is good for bulk-loading of data. Once the bulk-loading is complete, please issue a sync to the OS to flush all dirty buffers to stable storage.
    
    Specified by:
    
    disableDataSync in interface DBOptionsInterface
    
    Returns:
    if true, then data-sync is disabled.
  - setDisableDataSync
```
public Options setDisableDataSync(boolean disableDataSync)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then the contents of manifest and data files are not synced to stable storage. Their contents remain in the OS buffers till theOS decides to flush them.
    
    This option is good for bulk-loading of data.
    
    Once the bulk-loading is complete, please issue a sync to the OS to flush all dirty buffers to stable storage.
    
    Default: false
    
    Specified by:
    
    setDisableDataSync in interface DBOptionsInterface
    
    Parameters:
    disableDataSync - a boolean flag to specify whether to disable data sync.
    
    Returns:
    the instance of the current Object.
  - useFsync
```
public boolean useFsync()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then every store to stable storage will issue a fsync.
    
    If false, then every store to stable storage will issue a fdatasync. This parameter should be set to true while storing data to filesystem like ext3 that can lose files after a reboot.
    
    Specified by:
    
    useFsync in interface DBOptionsInterface
    
    Returns:
    boolean value indicating if fsync is used.
  - setUseFsync
```
public Options setUseFsync(boolean useFsync)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then every store to stable storage will issue a fsync.
    
    If false, then every store to stable storage will issue a fdatasync. This parameter should be set to true while storing data to filesystem like ext3 that can lose files after a reboot.
    
    Default: false
    
    Specified by:
    
    setUseFsync in interface DBOptionsInterface
    
    Parameters:
    useFsync - a boolean flag to specify whether to use fsync
    
    Returns:
    the instance of the current Object.
  - dbLogDir
```
public java.lang.String dbLogDir()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the directory of info log. If it is empty, the log files will be in the same dir as data. If it is non empty, the log files will be in the specified dir, and the db data dir's absolute path will be used as the log file name's prefix.
    
    Specified by:
    
    dbLogDir in interface DBOptionsInterface
    
    Returns:
    the path to the info log directory
  - setDbLogDir
```
public Options setDbLogDir(java.lang.String dbLogDir)
```
    Description copied from interface: DBOptionsInterface
    
    This specifies the info LOG dir. If it is empty, the log files will be in the same dir as data. If it is non empty, the log files will be in the specified dir, and the db data dir's absolute path will be used as the log file name's prefix.
    
    Specified by:
    
    setDbLogDir in interface DBOptionsInterface
    
    Parameters:
    dbLogDir - the path to the info log directory
    
    Returns:
    the instance of the current Object.
  - walDir
```
public java.lang.String walDir()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the path to the write-ahead-logs (WAL) directory. If it is empty, the log files will be in the same dir as data, dbname is used as the data dir by default If it is non empty, the log files will be in kept the specified dir. When destroying the db, all log files in wal_dir and the dir itself is deleted
    
    Specified by:
    
    walDir in interface DBOptionsInterface
    
    Returns:
    the path to the write-ahead-logs (WAL) directory.
  - setWalDir
```
public Options setWalDir(java.lang.String walDir)
```
    Description copied from interface: DBOptionsInterface
    
    This specifies the absolute dir path for write-ahead logs (WAL). If it is empty, the log files will be in the same dir as data, dbname is used as the data dir by default If it is non empty, the log files will be in kept the specified dir. When destroying the db, all log files in wal_dir and the dir itself is deleted
    
    Specified by:
    
    setWalDir in interface DBOptionsInterface
    
    Parameters:
    walDir - the path to the write-ahead-log directory.
    
    Returns:
    the instance of the current Object.
  - deleteObsoleteFilesPeriodMicros
```
public long deleteObsoleteFilesPeriodMicros()
```
    Description copied from interface: DBOptionsInterface
    
    The periodicity when obsolete files get deleted. The default value is 6 hours. The files that get out of scope by compaction process will still get automatically delete on every compaction, regardless of this setting
    
    Specified by:
    
    deleteObsoleteFilesPeriodMicros in interface DBOptionsInterface
    
    Returns:
    the time interval in micros when obsolete files will be deleted.
  - setDeleteObsoleteFilesPeriodMicros
```
public Options setDeleteObsoleteFilesPeriodMicros(long micros)
```
    Description copied from interface: DBOptionsInterface
    
    The periodicity when obsolete files get deleted. The default value is 6 hours. The files that get out of scope by compaction process will still get automatically delete on every compaction, regardless of this setting
    
    Specified by:
    
    setDeleteObsoleteFilesPeriodMicros in interface DBOptionsInterface
    
    Parameters:
    micros - the time interval in micros
    
    Returns:
    the instance of the current Object.
  - maxBackgroundCompactions
```
public int maxBackgroundCompactions()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool. When increasing this number, we may also want to consider increasing number of threads in LOW priority thread pool. Default: 1
    
    Specified by:
    
    maxBackgroundCompactions in interface DBOptionsInterface
    
    Returns:
    the maximum number of concurrent background compaction jobs.
    See Also:
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int)
  - createStatistics
```
public Options createStatistics()
```
    Description copied from interface: DBOptionsInterface
    
    Creates statistics object which collects metrics about database operations. Statistics objects should not be shared between DB instances as it does not use any locks to prevent concurrent updates.
    
    Specified by:
    
    createStatistics in interface DBOptionsInterface
    
    Returns:
    the instance of the current Object.
    See Also:
    RocksDB.open(org.rocksdb.Options, String)
  - statisticsPtr
```
public Statistics statisticsPtr()
```
    Description copied from interface: DBOptionsInterface
    
    Returns statistics object. Calls DBOptionsInterface.createStatistics() if C++ returns nullptr for statistics.
    
    Specified by:
    
    statisticsPtr in interface DBOptionsInterface
    
    Returns:
    the instance of the statistics object.
    See Also:
    DBOptionsInterface.createStatistics()
  - setBaseBackgroundCompactions
```
public void setBaseBackgroundCompactions(int baseBackgroundCompactions)
```
    Description copied from interface: DBOptionsInterface
    
    Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool. Default: 1
    
    Specified by:
    
    setBaseBackgroundCompactions in interface DBOptionsInterface
    
    Parameters:
    baseBackgroundCompactions - Suggested number of background compaction jobs
  - baseBackgroundCompactions
```
public int baseBackgroundCompactions()
```
    Description copied from interface: DBOptionsInterface
    
    Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool. Default: 1
    
    Specified by:
    
    baseBackgroundCompactions in interface DBOptionsInterface
    
    Returns:
    Suggested number of background compaction jobs
  - setMaxBackgroundCompactions
```
public Options setMaxBackgroundCompactions(int maxBackgroundCompactions)
```
    Description copied from interface: DBOptionsInterface
    
    Specifies the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool. If you're increasing this, also consider increasing number of threads in LOW priority thread pool. For more information, see Default: 1
    
    Specified by:
    
    setMaxBackgroundCompactions in interface DBOptionsInterface
    
    Parameters:
    maxBackgroundCompactions - the maximum number of background compaction jobs.
    
    Returns:
    the instance of the current Object.
    See Also:
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int), DBOptionsInterface.maxBackgroundFlushes()
  - setMaxSubcompactions
```
public void setMaxSubcompactions(int maxSubcompactions)
```
    Description copied from interface: DBOptionsInterface
    
    This value represents the maximum number of threads that will concurrently perform a compaction job by breaking it into multiple, smaller ones that are run simultaneously. Default: 1 (i.e. no subcompactions)
    
    Specified by:
    
    setMaxSubcompactions in interface DBOptionsInterface
    
    Parameters:
    maxSubcompactions - The maximum number of threads that will concurrently perform a compaction job
  - maxSubcompactions
```
public int maxSubcompactions()
```
    Description copied from interface: DBOptionsInterface
    
    This value represents the maximum number of threads that will concurrently perform a compaction job by breaking it into multiple, smaller ones that are run simultaneously. Default: 1 (i.e. no subcompactions)
    
    Specified by:
    
    maxSubcompactions in interface DBOptionsInterface
    
    Returns:
    The maximum number of threads that will concurrently perform a compaction job
  - maxBackgroundFlushes
```
public int maxBackgroundFlushes()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the maximum number of concurrent background flush jobs. If you're increasing this, also consider increasing number of threads in HIGH priority thread pool. For more information, see Default: 1
    
    Specified by:
    
    maxBackgroundFlushes in interface DBOptionsInterface
    
    Returns:
    the maximum number of concurrent background flush jobs.
    See Also:
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int)
  - setMaxBackgroundFlushes
```
public Options setMaxBackgroundFlushes(int maxBackgroundFlushes)
```
    Description copied from interface: DBOptionsInterface
    
    Specifies the maximum number of concurrent background flush jobs. If you're increasing this, also consider increasing number of threads in HIGH priority thread pool. For more information, see Default: 1
    
    Specified by:
    
    setMaxBackgroundFlushes in interface DBOptionsInterface
    
    Parameters:
    maxBackgroundFlushes - number of max concurrent flush jobs
    
    Returns:
    the instance of the current Object.
    See Also:
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int), DBOptionsInterface.maxBackgroundCompactions()
  - maxLogFileSize
```
public long maxLogFileSize()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the maximum size of a info log file. If the current log file is larger than this size, a new info log file will be created. If 0, all logs will be written to one log file.
    
    Specified by:
    
    maxLogFileSize in interface DBOptionsInterface
    
    Returns:
    the maximum size of the info log file.
  - setMaxLogFileSize
```
public Options setMaxLogFileSize(long maxLogFileSize)
```
    Description copied from interface: DBOptionsInterface
    
    Specifies the maximum size of a info log file. If the current log file is larger than `max_log_file_size`, a new info log file will be created. If 0, all logs will be written to one log file.
    
    Specified by:
    
    setMaxLogFileSize in interface DBOptionsInterface
    
    Parameters:
    maxLogFileSize - the maximum size of a info log file.
    
    Returns:
    the instance of the current Object.
  - logFileTimeToRoll
```
public long logFileTimeToRoll()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the time interval for the info log file to roll (in seconds). If specified with non-zero value, log file will be rolled if it has been active longer than `log_file_time_to_roll`. Default: 0 (disabled)
    
    Specified by:
    
    logFileTimeToRoll in interface DBOptionsInterface
    
    Returns:
    the time interval in seconds.
  - setLogFileTimeToRoll
```
public Options setLogFileTimeToRoll(long logFileTimeToRoll)
```
    Description copied from interface: DBOptionsInterface
    
    Specifies the time interval for the info log file to roll (in seconds). If specified with non-zero value, log file will be rolled if it has been active longer than `log_file_time_to_roll`. Default: 0 (disabled)
    
    Specified by:
    
    setLogFileTimeToRoll in interface DBOptionsInterface
    
    Parameters:
    logFileTimeToRoll - the time interval in seconds.
    
    Returns:
    the instance of the current Object.
  - keepLogFileNum
```
public long keepLogFileNum()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the maximum number of info log files to be kept. Default: 1000
    
    Specified by:
    
    keepLogFileNum in interface DBOptionsInterface
    
    Returns:
    the maximum number of info log files to be kept.
  - setKeepLogFileNum
```
public Options setKeepLogFileNum(long keepLogFileNum)
```
    Description copied from interface: DBOptionsInterface
    
    Specifies the maximum number of info log files to be kept. Default: 1000
    
    Specified by:
    
    setKeepLogFileNum in interface DBOptionsInterface
    
    Parameters:
    keepLogFileNum - the maximum number of info log files to be kept.
    
    Returns:
    the instance of the current Object.
  - maxManifestFileSize
```
public long maxManifestFileSize()
```
    Description copied from interface: DBOptionsInterface
    
    Manifest file is rolled over on reaching this limit. The older manifest file be deleted. The default value is MAX_INT so that roll-over does not take place.
    
    Specified by:
    
    maxManifestFileSize in interface DBOptionsInterface
    
    Returns:
    the size limit of a manifest file.
  - setMaxManifestFileSize
```
public Options setMaxManifestFileSize(long maxManifestFileSize)
```
    Description copied from interface: DBOptionsInterface
    
    Manifest file is rolled over on reaching this limit. The older manifest file be deleted. The default value is MAX_INT so that roll-over does not take place.
    
    Specified by:
    
    setMaxManifestFileSize in interface DBOptionsInterface
    
    Parameters:
    maxManifestFileSize - the size limit of a manifest file.
    
    Returns:
    the instance of the current Object.
  - setMaxTableFilesSizeFIFO
```
public Options setMaxTableFilesSizeFIFO(long maxTableFilesSize)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    FIFO compaction option. The oldest table file will be deleted once the sum of table files reaches this size. The default value is 1GB (1 * 1024 * 1024 * 1024).
    
    Specified by:
    
    setMaxTableFilesSizeFIFO in interface ColumnFamilyOptionsInterface
    
    Parameters:
    maxTableFilesSize - the size limit of the total sum of table files.
    
    Returns:
    the instance of the current Object.
  - maxTableFilesSizeFIFO
```
public long maxTableFilesSizeFIFO()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    FIFO compaction option. The oldest table file will be deleted once the sum of table files reaches this size. The default value is 1GB (1 * 1024 * 1024 * 1024).
    
    Specified by:
    
    maxTableFilesSizeFIFO in interface ColumnFamilyOptionsInterface
    
    Returns:
    the size limit of the total sum of table files.
  - tableCacheNumshardbits
```
public int tableCacheNumshardbits()
```
    Description copied from interface: DBOptionsInterface
    
    Number of shards used for table cache.
    
    Specified by:
    
    tableCacheNumshardbits in interface DBOptionsInterface
    
    Returns:
    the number of shards used for table cache.
  - setTableCacheNumshardbits
```
public Options setTableCacheNumshardbits(int tableCacheNumshardbits)
```
    Description copied from interface: DBOptionsInterface
    
    Number of shards used for table cache.
    
    Specified by:
    
    setTableCacheNumshardbits in interface DBOptionsInterface
    
    Parameters:
    tableCacheNumshardbits - the number of chards
    
    Returns:
    the instance of the current Object.
  - walTtlSeconds
```
public long walTtlSeconds()
```
    Description copied from interface: DBOptionsInterface
    WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
    1. If both set to 0, logs will be deleted asap and will not get into the archive.
    2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0, WAL files will be checked every 10 min and if total size is greater then WAL_size_limit_MB, they will be deleted starting with the earliest until size_limit is met. All empty files will be deleted.
    3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then WAL files will be checked every WAL_ttl_secondsi / 2 and those that are older than WAL_ttl_seconds will be deleted.
    4. If both are not 0, WAL files will be checked every 10 min and both checks will be performed with ttl being first.
    Specified by:
    
    walTtlSeconds in interface DBOptionsInterface
    
    Returns:
    the wal-ttl seconds
    See Also:
    DBOptionsInterface.walSizeLimitMB()
  - setWalTtlSeconds
```
public Options setWalTtlSeconds(long walTtlSeconds)
```
    Description copied from interface: DBOptionsInterface
    DBOptionsInterface.walTtlSeconds() and DBOptionsInterface.walSizeLimitMB() affect how archived logs will be deleted.
    1. If both set to 0, logs will be deleted asap and will not get into the archive.
    2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0, WAL files will be checked every 10 min and if total size is greater then WAL_size_limit_MB, they will be deleted starting with the earliest until size_limit is met. All empty files will be deleted.
    3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then WAL files will be checked every WAL_ttl_secondsi / 2 and those that are older than WAL_ttl_seconds will be deleted.
    4. If both are not 0, WAL files will be checked every 10 min and both checks will be performed with ttl being first.
    Specified by:
    
    setWalTtlSeconds in interface DBOptionsInterface
    
    Parameters:
    walTtlSeconds - the ttl seconds
    
    Returns:
    the instance of the current Object.
    See Also:
    DBOptionsInterface.setWalSizeLimitMB(long)
  - walSizeLimitMB
```
public long walSizeLimitMB()
```
    Description copied from interface: DBOptionsInterface
    DBOptionsInterface.walTtlSeconds() and #walSizeLimitMB() affect how archived logs will be deleted.
    1. If both set to 0, logs will be deleted asap and will not get into the archive.
    2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0, WAL files will be checked every 10 min and if total size is greater then WAL_size_limit_MB, they will be deleted starting with the earliest until size_limit is met. All empty files will be deleted.
    3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then WAL files will be checked every WAL_ttl_seconds i / 2 and those that are older than WAL_ttl_seconds will be deleted.
    4. If both are not 0, WAL files will be checked every 10 min and both checks will be performed with ttl being first.
    Specified by:
    
    walSizeLimitMB in interface DBOptionsInterface
    
    Returns:
    size limit in mega-bytes.
    See Also:
    DBOptionsInterface.walSizeLimitMB()
  - setWalSizeLimitMB
```
public Options setWalSizeLimitMB(long sizeLimitMB)
```
    Description copied from interface: DBOptionsInterface
    WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
    1. If both set to 0, logs will be deleted asap and will not get into the archive.
    2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0, WAL files will be checked every 10 min and if total size is greater then WAL_size_limit_MB, they will be deleted starting with the earliest until size_limit is met. All empty files will be deleted.
    3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then WAL files will be checked every WAL_ttl_secondsi / 2 and those that are older than WAL_ttl_seconds will be deleted.
    4. If both are not 0, WAL files will be checked every 10 min and both checks will be performed with ttl being first.
    Specified by:
    
    setWalSizeLimitMB in interface DBOptionsInterface
    
    Parameters:
    sizeLimitMB - size limit in mega-bytes.
    
    Returns:
    the instance of the current Object.
    See Also:
    DBOptionsInterface.setWalSizeLimitMB(long)
  - manifestPreallocationSize
```
public long manifestPreallocationSize()
```
    Description copied from interface: DBOptionsInterface
    
    Number of bytes to preallocate (via fallocate) the manifest files. Default is 4mb, which is reasonable to reduce random IO as well as prevent overallocation for mounts that preallocate large amounts of data (such as xfs's allocsize option).
    
    Specified by:
    
    manifestPreallocationSize in interface DBOptionsInterface
    
    Returns:
    size in bytes.
  - setManifestPreallocationSize
```
public Options setManifestPreallocationSize(long size)
```
    Description copied from interface: DBOptionsInterface
    
    Number of bytes to preallocate (via fallocate) the manifest files. Default is 4mb, which is reasonable to reduce random IO as well as prevent overallocation for mounts that preallocate large amounts of data (such as xfs's allocsize option).
    
    Specified by:
    
    setManifestPreallocationSize in interface DBOptionsInterface
    
    Parameters:
    size - the size in byte
    
    Returns:
    the instance of the current Object.
  - allowOsBuffer
```
public boolean allowOsBuffer()
```
    Description copied from interface: DBOptionsInterface
    
    Data being read from file storage may be buffered in the OS Default: true
    
    Specified by:
    
    allowOsBuffer in interface DBOptionsInterface
    
    Returns:
    if true, then OS buffering is allowed.
  - setAllowOsBuffer
```
public Options setAllowOsBuffer(boolean allowOsBuffer)
```
    Description copied from interface: DBOptionsInterface
    
    Data being read from file storage may be buffered in the OS Default: true
    
    Specified by:
    
    setAllowOsBuffer in interface DBOptionsInterface
    
    Parameters:
    allowOsBuffer - if true, then OS buffering is allowed.
    
    Returns:
    the instance of the current Object.
  - allowMmapReads
```
public boolean allowMmapReads()
```
    Description copied from interface: DBOptionsInterface
    
    Allow the OS to mmap file for reading sst tables. Default: false
    
    Specified by:
    
    allowMmapReads in interface DBOptionsInterface
    
    Returns:
    true if mmap reads are allowed.
  - setAllowMmapReads
```
public Options setAllowMmapReads(boolean allowMmapReads)
```
    Description copied from interface: DBOptionsInterface
    
    Allow the OS to mmap file for reading sst tables. Default: false
    
    Specified by:
    
    setAllowMmapReads in interface DBOptionsInterface
    
    Parameters:
    allowMmapReads - true if mmap reads are allowed.
    
    Returns:
    the instance of the current Object.
  - allowMmapWrites
```
public boolean allowMmapWrites()
```
    Description copied from interface: DBOptionsInterface
    
    Allow the OS to mmap file for writing. Default: false
    
    Specified by:
    
    allowMmapWrites in interface DBOptionsInterface
    
    Returns:
    true if mmap writes are allowed.
  - setAllowMmapWrites
```
public Options setAllowMmapWrites(boolean allowMmapWrites)
```
    Description copied from interface: DBOptionsInterface
    
    Allow the OS to mmap file for writing. Default: false
    
    Specified by:
    
    setAllowMmapWrites in interface DBOptionsInterface
    
    Parameters:
    allowMmapWrites - true if mmap writes are allowd.
    
    Returns:
    the instance of the current Object.
  - isFdCloseOnExec
```
public boolean isFdCloseOnExec()
```
    Description copied from interface: DBOptionsInterface
    
    Disable child process inherit open files. Default: true
    
    Specified by:
    
    isFdCloseOnExec in interface DBOptionsInterface
    
    Returns:
    true if child process inheriting open files is disabled.
  - setIsFdCloseOnExec
```
public Options setIsFdCloseOnExec(boolean isFdCloseOnExec)
```
    Description copied from interface: DBOptionsInterface
    
    Disable child process inherit open files. Default: true
    
    Specified by:
    
    setIsFdCloseOnExec in interface DBOptionsInterface
    
    Parameters:
    isFdCloseOnExec - true if child process inheriting open files is disabled.
    
    Returns:
    the instance of the current Object.
  - statsDumpPeriodSec
```
public int statsDumpPeriodSec()
```
    Description copied from interface: DBOptionsInterface
    
    If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
    
    Specified by:
    
    statsDumpPeriodSec in interface DBOptionsInterface
    
    Returns:
    time interval in seconds.
  - setStatsDumpPeriodSec
```
public Options setStatsDumpPeriodSec(int statsDumpPeriodSec)
```
    Description copied from interface: DBOptionsInterface
    
    if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
    
    Specified by:
    
    setStatsDumpPeriodSec in interface DBOptionsInterface
    
    Parameters:
    statsDumpPeriodSec - time interval in seconds.
    
    Returns:
    the instance of the current Object.
  - adviseRandomOnOpen
```
public boolean adviseRandomOnOpen()
```
    Description copied from interface: DBOptionsInterface
    
    If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened. Default: true
    
    Specified by:
    
    adviseRandomOnOpen in interface DBOptionsInterface
    
    Returns:
    true if hinting random access is on.
  - setAdviseRandomOnOpen
```
public Options setAdviseRandomOnOpen(boolean adviseRandomOnOpen)
```
    Description copied from interface: DBOptionsInterface
    
    If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened. Default: true
    
    Specified by:
    
    setAdviseRandomOnOpen in interface DBOptionsInterface
    
    Parameters:
    adviseRandomOnOpen - true if hinting random access is on.
    
    Returns:
    the instance of the current Object.
  - useAdaptiveMutex
```
public boolean useAdaptiveMutex()
```
    Description copied from interface: DBOptionsInterface
    
    Use adaptive mutex, which spins in the user space before resorting to kernel. This could reduce context switch when the mutex is not heavily contended. However, if the mutex is hot, we could end up wasting spin time. Default: false
    
    Specified by:
    
    useAdaptiveMutex in interface DBOptionsInterface
    
    Returns:
    true if adaptive mutex is used.
  - setUseAdaptiveMutex
```
public Options setUseAdaptiveMutex(boolean useAdaptiveMutex)
```
    Description copied from interface: DBOptionsInterface
    
    Use adaptive mutex, which spins in the user space before resorting to kernel. This could reduce context switch when the mutex is not heavily contended. However, if the mutex is hot, we could end up wasting spin time. Default: false
    
    Specified by:
    
    setUseAdaptiveMutex in interface DBOptionsInterface
    
    Parameters:
    useAdaptiveMutex - true if adaptive mutex is used.
    
    Returns:
    the instance of the current Object.
  - bytesPerSync
```
public long bytesPerSync()
```
    Description copied from interface: DBOptionsInterface
    
    Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background. Issue one request for every bytes_per_sync written. 0 turns it off. Default: 0
    
    Specified by:
    
    bytesPerSync in interface DBOptionsInterface
    
    Returns:
    size in bytes
  - setBytesPerSync
```
public Options setBytesPerSync(long bytesPerSync)
```
    Description copied from interface: DBOptionsInterface
    
    Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background. Issue one request for every bytes_per_sync written. 0 turns it off. Default: 0
    
    Specified by:
    
    setBytesPerSync in interface DBOptionsInterface
    
    Parameters:
    bytesPerSync - size in bytes
    
    Returns:
    the instance of the current Object.
  - setAllowConcurrentMemtableWrite
```
public void setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)
```
    Description copied from interface: DBOptionsInterface
    
    If true, allow multi-writers to update mem tables in parallel. Only some memtable factorys support concurrent writes; currently it is implemented only for SkipListFactory. Concurrent memtable writes are not compatible with inplace_update_support or filter_deletes. It is strongly recommended to set DBOptionsInterface.setEnableWriteThreadAdaptiveYield(boolean) if you are going to use this feature. Default: false
    
    Specified by:
    
    setAllowConcurrentMemtableWrite in interface DBOptionsInterface
    
    Parameters:
    allowConcurrentMemtableWrite - true to enable concurrent writes for the memtable
  - allowConcurrentMemtableWrite
```
public boolean allowConcurrentMemtableWrite()
```
    Description copied from interface: DBOptionsInterface
    
    If true, allow multi-writers to update mem tables in parallel. Only some memtable factorys support concurrent writes; currently it is implemented only for SkipListFactory. Concurrent memtable writes are not compatible with inplace_update_support or filter_deletes. It is strongly recommended to set DBOptionsInterface.setEnableWriteThreadAdaptiveYield(boolean) if you are going to use this feature. Default: false
    
    Specified by:
    
    allowConcurrentMemtableWrite in interface DBOptionsInterface
    
    Returns:
    true if concurrent writes are enabled for the memtable
  - setEnableWriteThreadAdaptiveYield
```
public void setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)
```
    Description copied from interface: DBOptionsInterface
    
    If true, threads synchronizing with the write batch group leader will wait for up to DBOptionsInterface.writeThreadMaxYieldUsec() before blocking on a mutex. This can substantially improve throughput for concurrent workloads, regardless of whether DBOptionsInterface.allowConcurrentMemtableWrite() is enabled. Default: false
    
    Specified by:
    
    setEnableWriteThreadAdaptiveYield in interface DBOptionsInterface
    
    Parameters:
    enableWriteThreadAdaptiveYield - true to enable adaptive yield for the write threads
  - enableWriteThreadAdaptiveYield
```
public boolean enableWriteThreadAdaptiveYield()
```
    Description copied from interface: DBOptionsInterface
    
    If true, threads synchronizing with the write batch group leader will wait for up to DBOptionsInterface.writeThreadMaxYieldUsec() before blocking on a mutex. This can substantially improve throughput for concurrent workloads, regardless of whether DBOptionsInterface.allowConcurrentMemtableWrite() is enabled. Default: false
    
    Specified by:
    
    enableWriteThreadAdaptiveYield in interface DBOptionsInterface
    
    Returns:
    true if adaptive yield is enabled for the writing threads
  - setWriteThreadMaxYieldUsec
```
public void setWriteThreadMaxYieldUsec(long writeThreadMaxYieldUsec)
```
    Description copied from interface: DBOptionsInterface
    
    The maximum number of microseconds that a write operation will use a yielding spin loop to coordinate with other write threads before blocking on a mutex. (Assuming DBOptionsInterface.writeThreadSlowYieldUsec() is set properly) increasing this value is likely to increase RocksDB throughput at the expense of increased CPU usage. Default: 100
    
    Specified by:
    
    setWriteThreadMaxYieldUsec in interface DBOptionsInterface
    
    Parameters:
    writeThreadMaxYieldUsec - maximum number of microseconds
  - writeThreadMaxYieldUsec
```
public long writeThreadMaxYieldUsec()
```
    Description copied from interface: DBOptionsInterface
    
    The maximum number of microseconds that a write operation will use a yielding spin loop to coordinate with other write threads before blocking on a mutex. (Assuming DBOptionsInterface.writeThreadSlowYieldUsec() is set properly) increasing this value is likely to increase RocksDB throughput at the expense of increased CPU usage. Default: 100
    
    Specified by:
    
    writeThreadMaxYieldUsec in interface DBOptionsInterface
    
    Returns:
    the maximum number of microseconds
  - setWriteThreadSlowYieldUsec
```
public void setWriteThreadSlowYieldUsec(long writeThreadSlowYieldUsec)
```
    Description copied from interface: DBOptionsInterface
    
    The latency in microseconds after which a std::this_thread::yield call (sched_yield on Linux) is considered to be a signal that other processes or threads would like to use the current core. Increasing this makes writer threads more likely to take CPU by spinning, which will show up as an increase in the number of involuntary context switches. Default: 3
    
    Specified by:
    
    setWriteThreadSlowYieldUsec in interface DBOptionsInterface
    
    Parameters:
    writeThreadSlowYieldUsec - the latency in microseconds
  - writeThreadSlowYieldUsec
```
public long writeThreadSlowYieldUsec()
```
    Description copied from interface: DBOptionsInterface
    
    The latency in microseconds after which a std::this_thread::yield call (sched_yield on Linux) is considered to be a signal that other processes or threads would like to use the current core. Increasing this makes writer threads more likely to take CPU by spinning, which will show up as an increase in the number of involuntary context switches. Default: 3
    
    Specified by:
    
    writeThreadSlowYieldUsec in interface DBOptionsInterface
    
    Returns:
    writeThreadSlowYieldUsec the latency in microseconds
  - setMemTableConfig
```
public Options setMemTableConfig(MemTableConfig config)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set the config for mem-table.
    
    Specified by:
    
    setMemTableConfig in interface ColumnFamilyOptionsInterface
    
    Parameters:
    config - the mem-table config.
    
    Returns:
    the instance of the current Object.
  - setRateLimiterConfig
```
public Options setRateLimiterConfig(RateLimiterConfig config)
```
    Description copied from interface: DBOptionsInterface
    
    Use to control write rate of flush and compaction. Flush has higher priority than compaction. Rate limiting is disabled if nullptr. Default: nullptr
    
    Specified by:
    
    setRateLimiterConfig in interface DBOptionsInterface
    
    Parameters:
    config - rate limiter config.
    
    Returns:
    the instance of the current Object.
  - setRateLimiter
```
public Options setRateLimiter(RateLimiter rateLimiter)
```
    Description copied from interface: DBOptionsInterface
    
    Use to control write rate of flush and compaction. Flush has higher priority than compaction. Rate limiting is disabled if nullptr. Default: nullptr
    
    Specified by:
    
    setRateLimiter in interface DBOptionsInterface
    
    Parameters:
    rateLimiter - RateLimiter instance.
    
    Returns:
    the instance of the current Object.
  - setLogger
```
public Options setLogger(Logger logger)
```
    Description copied from interface: DBOptionsInterface
    
    Any internal progress/error information generated by the db will be written to the Logger if it is non-nullptr, or to a file stored in the same directory as the DB contents if info_log is nullptr.
    
    Default: nullptr
    
    Specified by:
    
    setLogger in interface DBOptionsInterface
    
    Parameters:
    logger - Logger instance.
    
    Returns:
    the instance of the current Object.
  - setInfoLogLevel
```
public Options setInfoLogLevel(InfoLogLevel infoLogLevel)
```
    Description copied from interface: DBOptionsInterface
    
    Sets the RocksDB log level. Default level is INFO
    
    Specified by:
    
    setInfoLogLevel in interface DBOptionsInterface
    
    Parameters:
    infoLogLevel - log level to set.
    
    Returns:
    the instance of the current Object.
  - infoLogLevel
```
public InfoLogLevel infoLogLevel()
```
    Description copied from interface: DBOptionsInterface
    
    Returns currently set log level.
    
    Specified by:
    
    infoLogLevel in interface DBOptionsInterface
    
    Returns:
    InfoLogLevel instance.
  - memTableFactoryName
```
public java.lang.String memTableFactoryName()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Returns the name of the current mem table representation. Memtable format can be set using setTableFormatConfig.
    
    Specified by:
    
    memTableFactoryName in interface ColumnFamilyOptionsInterface
    
    Returns:
    the name of the currently-used memtable factory.
    See Also:
    ColumnFamilyOptionsInterface.setTableFormatConfig(org.rocksdb.TableFormatConfig)
  - setTableFormatConfig
```
public Options setTableFormatConfig(TableFormatConfig config)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set the config for table format.
    
    Specified by:
    
    setTableFormatConfig in interface ColumnFamilyOptionsInterface
    
    Parameters:
    config - the table format config.
    
    Returns:
    the reference of the current Options.
  - tableFactoryName
```
public java.lang.String tableFactoryName()
```
    Specified by:
    
    tableFactoryName in interface ColumnFamilyOptionsInterface
    
    Returns:
    the name of the currently used table factory.
  - useFixedLengthPrefixExtractor
```
public Options useFixedLengthPrefixExtractor(int n)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    This prefix-extractor uses the first n bytes of a key as its prefix. In some hash-based memtable representation such as HashLinkedList and HashSkipList, prefixes are used to partition the keys into several buckets. Prefix extractor is used to specify how to extract the prefix given a key.
    
    Specified by:
    
    useFixedLengthPrefixExtractor in interface ColumnFamilyOptionsInterface
    
    Parameters:
    n - use the first n bytes of a key as its prefix.
    
    Returns:
    the reference to the current option.
  - useCappedPrefixExtractor
```
public Options useCappedPrefixExtractor(int n)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Same as fixed length prefix extractor, except that when slice is shorter than the fixed length, it will use the full key.
    
    Specified by:
    
    useCappedPrefixExtractor in interface ColumnFamilyOptionsInterface
    
    Parameters:
    n - use the first n bytes of a key as its prefix.
    
    Returns:
    the reference to the current option.
  - compressionType
```
public CompressionType compressionType()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Compress blocks using the specified compression algorithm. This parameter can be changed dynamically. Default: SNAPPY_COMPRESSION, which gives lightweight but fast compression.
    
    Specified by:
    
    compressionType in interface ColumnFamilyOptionsInterface
    
    Returns:
    Compression type.
  - setCompressionPerLevel
```
public Options setCompressionPerLevel(java.util.List<CompressionType> compressionLevels)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Different levels can have different compression policies. There are cases where most lower levels would like to use quick compression algorithms while the higher levels (which have more data) use compression algorithms that have better compression but could be slower. This array, if non-empty, should have an entry for each level of the database; these override the value specified in the previous field 'compression'.
    NOTICE
    If level_compaction_dynamic_level_bytes=true, compression_per_level[0] still determines L0, but other elements of the array are based on base level (the level L0 files are merged to), and may not match the level users see from info log for metadata.
    
    If L0 files are merged to level - n, then, for i>0, compression_per_level[i] determines compaction type for level n+i-1.
    Example
    For example, if we have 5 levels, and we determine to merge L0 data to L4 (which means L1..L3 will be empty), then the new files go to L4 uses compression type compression_per_level[1].
    
    If now L0 is merged to L2. Data goes to L2 will be compressed according to compression_per_level[1], L3 using compression_per_level[2]and L4 using compression_per_level[3]. Compaction for each level can change when data grows.
    
    Default: empty
    
    Specified by:
    
    setCompressionPerLevel in interface ColumnFamilyOptionsInterface
    
    Parameters:
    compressionLevels - list of CompressionType instances.
    
    Returns:
    the reference to the current option.
  - compressionPerLevel
```
public java.util.List<CompressionType> compressionPerLevel()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Return the currently set CompressionType per instances.
    
    See: ColumnFamilyOptionsInterface.setCompressionPerLevel(java.util.List)
    
    Specified by:
    
    compressionPerLevel in interface ColumnFamilyOptionsInterface
    
    Returns:
    list of CompressionType instances.
  - setCompressionType
```
public Options setCompressionType(CompressionType compressionType)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Compress blocks using the specified compression algorithm. This parameter can be changed dynamically. Default: SNAPPY_COMPRESSION, which gives lightweight but fast compression.
    
    Specified by:
    
    setCompressionType in interface ColumnFamilyOptionsInterface
    
    Parameters:
    compressionType - Compression Type.
    
    Returns:
    the reference to the current option.
  - compactionStyle
```
public CompactionStyle compactionStyle()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Compaction style for DB.
    
    Specified by:
    
    compactionStyle in interface ColumnFamilyOptionsInterface
    
    Returns:
    Compaction style.
  - setCompactionStyle
```
public Options setCompactionStyle(CompactionStyle compactionStyle)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set compaction style for DB. Default: LEVEL.
    
    Specified by:
    
    setCompactionStyle in interface ColumnFamilyOptionsInterface
    
    Parameters:
    compactionStyle - Compaction style.
    
    Returns:
    the reference to the current option.
  - numLevels
```
public int numLevels()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    If level-styled compaction is used, then this number determines the total number of levels.
    
    Specified by:
    
    numLevels in interface ColumnFamilyOptionsInterface
    
    Returns:
    the number of levels.
  - setNumLevels
```
public Options setNumLevels(int numLevels)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Set the number of levels for this database If level-styled compaction is used, then this number determines the total number of levels.
    
    Specified by:
    
    setNumLevels in interface ColumnFamilyOptionsInterface
    
    Parameters:
    numLevels - the number of levels.
    
    Returns:
    the reference to the current option.
  - levelZeroFileNumCompactionTrigger
```
public int levelZeroFileNumCompactionTrigger()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The number of files in level 0 to trigger compaction from level-0 to level-1. A value < 0 means that level-0 compaction will not be triggered by number of files at all. Default: 4
    
    Specified by:
    
    levelZeroFileNumCompactionTrigger in interface ColumnFamilyOptionsInterface
    
    Returns:
    the number of files in level 0 to trigger compaction.
  - setLevelZeroFileNumCompactionTrigger
```
public Options setLevelZeroFileNumCompactionTrigger(int numFiles)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Number of files to trigger level-0 compaction. A value < 0 means that level-0 compaction will not be triggered by number of files at all. Default: 4
    
    Specified by:
    
    setLevelZeroFileNumCompactionTrigger in interface ColumnFamilyOptionsInterface
    
    Parameters:
    numFiles - the number of files in level-0 to trigger compaction.
    
    Returns:
    the reference to the current option.
  - levelZeroSlowdownWritesTrigger
```
public int levelZeroSlowdownWritesTrigger()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Soft limit on the number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    Specified by:
    
    levelZeroSlowdownWritesTrigger in interface ColumnFamilyOptionsInterface
    
    Returns:
    the soft limit on the number of level-0 files.
  - setLevelZeroSlowdownWritesTrigger
```
public Options setLevelZeroSlowdownWritesTrigger(int numFiles)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Soft limit on number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    Specified by:
    
    setLevelZeroSlowdownWritesTrigger in interface ColumnFamilyOptionsInterface
    
    Parameters:
    numFiles - soft limit on number of level-0 files.
    
    Returns:
    the reference to the current option.
  - levelZeroStopWritesTrigger
```
public int levelZeroStopWritesTrigger()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    Specified by:
    
    levelZeroStopWritesTrigger in interface ColumnFamilyOptionsInterface
    
    Returns:
    the hard limit of the number of level-0 file.
  - setLevelZeroStopWritesTrigger
```
public Options setLevelZeroStopWritesTrigger(int numFiles)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    Specified by:
    
    setLevelZeroStopWritesTrigger in interface ColumnFamilyOptionsInterface
    
    Parameters:
    numFiles - the hard limit of the number of level-0 files.
    
    Returns:
    the reference to the current option.
  - maxMemCompactionLevel
```
public int maxMemCompactionLevel()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    This does nothing anymore. Deprecated.
    
    Specified by:
    
    maxMemCompactionLevel in interface ColumnFamilyOptionsInterface
    
    Returns:
    Always returns 0.
  - setMaxMemCompactionLevel
```
public Options setMaxMemCompactionLevel(int maxMemCompactionLevel)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    This does nothing anymore. Deprecated.
    
    Specified by:
    
    setMaxMemCompactionLevel in interface ColumnFamilyOptionsInterface
    
    Parameters:
    maxMemCompactionLevel - Unused.
    
    Returns:
    the reference to the current option.
  - targetFileSizeBase
```
public long targetFileSizeBase()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The target file size for compaction. This targetFileSizeBase determines a level-1 file size. Target file size for level L can be calculated by targetFileSizeBase * (targetFileSizeMultiplier ^ (L-1)) For example, if targetFileSizeBase is 2MB and target_file_size_multiplier is 10, then each file on level-1 will be 2MB, and each file on level 2 will be 20MB, and each file on level-3 will be 200MB. by default targetFileSizeBase is 2MB.
    
    Specified by:
    
    targetFileSizeBase in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the target size of a level-0 file.
    See Also:
    MutableColumnFamilyOptionsInterface.targetFileSizeMultiplier()
  - setTargetFileSizeBase
```
public Options setTargetFileSizeBase(long targetFileSizeBase)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The target file size for compaction. This targetFileSizeBase determines a level-1 file size. Target file size for level L can be calculated by targetFileSizeBase * (targetFileSizeMultiplier ^ (L-1)) For example, if targetFileSizeBase is 2MB and target_file_size_multiplier is 10, then each file on level-1 will be 2MB, and each file on level 2 will be 20MB, and each file on level-3 will be 200MB. by default targetFileSizeBase is 2MB.
    
    Specified by:
    
    setTargetFileSizeBase in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    targetFileSizeBase - the target size of a level-0 file.
    
    Returns:
    the reference to the current option.
    See Also:
    MutableColumnFamilyOptionsInterface.setTargetFileSizeMultiplier(int)
  - targetFileSizeMultiplier
```
public int targetFileSizeMultiplier()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    targetFileSizeMultiplier defines the size ratio between a level-(L+1) file and level-L file. By default targetFileSizeMultiplier is 1, meaning files in different levels have the same target.
    
    Specified by:
    
    targetFileSizeMultiplier in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the size ratio between a level-(L+1) file and level-L file.
  - setTargetFileSizeMultiplier
```
public Options setTargetFileSizeMultiplier(int multiplier)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    targetFileSizeMultiplier defines the size ratio between a level-L file and level-(L+1) file. By default target_file_size_multiplier is 1, meaning files in different levels have the same target.
    
    Specified by:
    
    setTargetFileSizeMultiplier in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    multiplier - the size ratio between a level-(L+1) file and level-L file.
    
    Returns:
    the reference to the current option.
  - setMaxBytesForLevelBase
```
public Options setMaxBytesForLevelBase(long maxBytesForLevelBase)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The upper-bound of the total size of level-1 files in bytes. Maximum number of bytes for level L can be calculated as (maxBytesForLevelBase) * (maxBytesForLevelMultiplier ^ (L-1)) For example, if maxBytesForLevelBase is 20MB, and if max_bytes_for_level_multiplier is 10, total data size for level-1 will be 20MB, total file size for level-2 will be 200MB, and total file size for level-3 will be 2GB. by default 'maxBytesForLevelBase' is 10MB.
    
    Specified by:
    
    setMaxBytesForLevelBase in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    maxBytesForLevelBase - maximum bytes for level base.
    
    Returns:
    the reference to the current option.
    See Also:
    MutableColumnFamilyOptionsInterface.setMaxBytesForLevelMultiplier(double)
  - maxBytesForLevelBase
```
public long maxBytesForLevelBase()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The upper-bound of the total size of level-1 files in bytes. Maximum number of bytes for level L can be calculated as (maxBytesForLevelBase) * (maxBytesForLevelMultiplier ^ (L-1)) For example, if maxBytesForLevelBase is 20MB, and if max_bytes_for_level_multiplier is 10, total data size for level-1 will be 20MB, total file size for level-2 will be 200MB, and total file size for level-3 will be 2GB. by default 'maxBytesForLevelBase' is 10MB.
    
    Specified by:
    
    maxBytesForLevelBase in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the upper-bound of the total size of level-1 files in bytes.
    See Also:
    MutableColumnFamilyOptionsInterface.maxBytesForLevelMultiplier()
  - setLevelCompactionDynamicLevelBytes
```
public Options setLevelCompactionDynamicLevelBytes(boolean enableLevelCompactionDynamicLevelBytes)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    If true, RocksDB will pick target size of each level dynamically. We will pick a base level b >= 1. L0 will be directly merged into level b, instead of always into level 1. Level 1 to b-1 need to be empty. We try to pick b and its target size so that
    1. target size is in the range of (max_bytes_for_level_base / max_bytes_for_level_multiplier, max_bytes_for_level_base]
    2. target size of the last level (level num_levels-1) equals to extra size of the level.
    At the same time max_bytes_for_level_multiplier and max_bytes_for_level_multiplier_additional are still satisfied.
    
    With this option on, from an empty DB, we make last level the base level, which means merging L0 data into the last level, until it exceeds max_bytes_for_level_base. And then we make the second last level to be base level, to start to merge L0 data to second last level, with its target size to be 1/max_bytes_for_level_multiplier of the last levels extra size. After the data accumulates more so that we need to move the base level to the third last one, and so on.
    
    Example
    
    For example, assume max_bytes_for_level_multiplier=10, num_levels=6, and max_bytes_for_level_base=10MB.
    
    Target sizes of level 1 to 5 starts with:
    [- - - - 10MB]
    with base level is level. Target sizes of level 1 to 4 are not applicable because they will not be used. Until the size of Level 5 grows to more than 10MB, say 11MB, we make base target to level 4 and now the targets looks like:
    [- - - 1.1MB 11MB]
    While data are accumulated, size targets are tuned based on actual data of level 5. When level 5 has 50MB of data, the target is like:
    [- - - 5MB 50MB]
    Until level 5's actual size is more than 100MB, say 101MB. Now if we keep level 4 to be the base level, its target size needs to be 10.1MB, which doesn't satisfy the target size range. So now we make level 3 the target size and the target sizes of the levels look like:
    [- - 1.01MB 10.1MB 101MB]
    In the same way, while level 5 further grows, all levels' targets grow, like
    [- - 5MB 50MB 500MB]
    Until level 5 exceeds 1000MB and becomes 1001MB, we make level 2 the base level and make levels' target sizes like this:
    [- 1.001MB 10.01MB 100.1MB 1001MB]
    and go on...
    
    By doing it, we give max_bytes_for_level_multiplier a priority against max_bytes_for_level_base, for a more predictable LSM tree shape. It is useful to limit worse case space amplification.
    
    max_bytes_for_level_multiplier_additional is ignored with this flag on.
    
    Turning this feature on or off for an existing DB can cause unexpected LSM tree structure so it's not recommended.
    
    Caution: this option is experimental
    
    Default: false
    Specified by:
    
    setLevelCompactionDynamicLevelBytes in interface ColumnFamilyOptionsInterface
    
    Parameters:
    enableLevelCompactionDynamicLevelBytes - boolean value indicating if LevelCompactionDynamicLevelBytes shall be enabled.
    
    Returns:
    the reference to the current option.
  - levelCompactionDynamicLevelBytes
```
public boolean levelCompactionDynamicLevelBytes()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Return if LevelCompactionDynamicLevelBytes is enabled.
    
    For further information see ColumnFamilyOptionsInterface.setLevelCompactionDynamicLevelBytes(boolean)
    
    Specified by:
    
    levelCompactionDynamicLevelBytes in interface ColumnFamilyOptionsInterface
    
    Returns:
    boolean value indicating if levelCompactionDynamicLevelBytes is enabled.
  - maxBytesForLevelMultiplier
```
public double maxBytesForLevelMultiplier()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The ratio between the total size of level-(L+1) files and the total size of level-L files for all L. DEFAULT: 10
    
    Specified by:
    
    maxBytesForLevelMultiplier in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    maxBytesForLevelMultiplier in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
    See Also:
    MutableColumnFamilyOptionsInterface.maxBytesForLevelBase()
  - setMaxBytesForLevelMultiplier
```
public Options setMaxBytesForLevelMultiplier(double multiplier)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The ratio between the total size of level-(L+1) files and the total size of level-L files for all L. DEFAULT: 10
    
    Specified by:
    
    setMaxBytesForLevelMultiplier in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    setMaxBytesForLevelMultiplier in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    multiplier - the ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
    
    Returns:
    the reference to the current option.
    See Also:
    MutableColumnFamilyOptionsInterface.setMaxBytesForLevelBase(long)
  - maxCompactionBytes
```
public long maxCompactionBytes()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Control maximum size of each compaction (not guaranteed)
    
    Specified by:
    
    maxCompactionBytes in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    maxCompactionBytes in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    compaction size threshold
    See Also:
    MutableColumnFamilyOptionsInterface.setMaxCompactionBytes(long)
  - setMaxCompactionBytes
```
public Options setMaxCompactionBytes(long maxCompactionBytes)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Maximum size of each compaction (not guarantee)
    
    Specified by:
    
    setMaxCompactionBytes in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    setMaxCompactionBytes in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    maxCompactionBytes - the compaction size limit
    
    Returns:
    the reference to the current option.
    See Also:
    MutableColumnFamilyOptionsInterface.maxCompactionBytes()
  - softRateLimit
```
public double softRateLimit()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Puts are delayed 0-1 ms when any level has a compaction score that exceeds soft_rate_limit. This is ignored when == 0.0. CONSTRAINT: soft_rate_limit ≤ hard_rate_limit. If this constraint does not hold, RocksDB will set soft_rate_limit = hard_rate_limit Default: 0 (disabled)
    
    Specified by:
    
    softRateLimit in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    softRateLimit in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    soft-rate-limit for put delay.
  - setSoftRateLimit
```
public Options setSoftRateLimit(double softRateLimit)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Puts are delayed 0-1 ms when any level has a compaction score that exceeds soft_rate_limit. This is ignored when == 0.0. CONSTRAINT: soft_rate_limit ≤ hard_rate_limit. If this constraint does not hold, RocksDB will set soft_rate_limit = hard_rate_limit Default: 0 (disabled)
    
    Specified by:
    
    setSoftRateLimit in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    setSoftRateLimit in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    softRateLimit - the soft-rate-limit of a compaction score for put delay.
    
    Returns:
    the reference to the current option.
  - hardRateLimit
```
public double hardRateLimit()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Puts are delayed 1ms at a time when any level has a compaction score that exceeds hard_rate_limit. This is ignored when ≤ 1.0. Default: 0 (disabled)
    
    Specified by:
    
    hardRateLimit in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    hardRateLimit in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the hard-rate-limit of a compaction score for put delay.
  - setHardRateLimit
```
public Options setHardRateLimit(double hardRateLimit)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Puts are delayed 1ms at a time when any level has a compaction score that exceeds hard_rate_limit. This is ignored when ≤ 1.0. Default: 0 (disabled)
    
    Specified by:
    
    setHardRateLimit in interface ColumnFamilyOptionsInterface
    
    Specified by:
    
    setHardRateLimit in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    hardRateLimit - the hard-rate-limit of a compaction score for put delay.
    
    Returns:
    the reference to the current option.
  - rateLimitDelayMaxMilliseconds
```
public int rateLimitDelayMaxMilliseconds()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The maximum time interval a put will be stalled when hard_rate_limit is enforced. If 0, then there is no limit. Default: 1000
    
    Specified by:
    
    rateLimitDelayMaxMilliseconds in interface ColumnFamilyOptionsInterface
    
    Returns:
    the maximum time interval a put will be stalled when hard_rate_limit is enforced.
  - setRateLimitDelayMaxMilliseconds
```
public Options setRateLimitDelayMaxMilliseconds(int rateLimitDelayMaxMilliseconds)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The maximum time interval a put will be stalled when hard_rate_limit is enforced. If 0, then there is no limit. Default: 1000
    
    Specified by:
    
    setRateLimitDelayMaxMilliseconds in interface ColumnFamilyOptionsInterface
    
    Parameters:
    rateLimitDelayMaxMilliseconds - the maximum time interval a put will be stalled.
    
    Returns:
    the reference to the current option.
  - arenaBlockSize
```
public long arenaBlockSize()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The size of one block in arena memory allocation. If ≤ 0, a proper value is automatically calculated (usually 1/10 of writer_buffer_size). There are two additional restriction of the The specified size: (1) size should be in the range of [4096, 2 << 30] and (2) be the multiple of the CPU word (which helps with the memory alignment). We'll automatically check and adjust the size number to make sure it conforms to the restrictions. Default: 0
    
    Specified by:
    
    arenaBlockSize in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the size of an arena block
  - setArenaBlockSize
```
public Options setArenaBlockSize(long arenaBlockSize)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    The size of one block in arena memory allocation. If ≤ 0, a proper value is automatically calculated (usually 1/10 of writer_buffer_size). There are two additional restriction of the The specified size: (1) size should be in the range of [4096, 2 << 30] and (2) be the multiple of the CPU word (which helps with the memory alignment). We'll automatically check and adjust the size number to make sure it conforms to the restrictions. Default: 0
    
    Specified by:
    
    setArenaBlockSize in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    arenaBlockSize - the size of an arena block
    
    Returns:
    the reference to the current option.
  - disableAutoCompactions
```
public boolean disableAutoCompactions()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Disable automatic compactions. Manual compactions can still be issued on this column family
    
    Specified by:
    
    disableAutoCompactions in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    true if auto-compactions are disabled.
  - setDisableAutoCompactions
```
public Options setDisableAutoCompactions(boolean disableAutoCompactions)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Disable automatic compactions. Manual compactions can still be issued on this column family
    
    Specified by:
    
    setDisableAutoCompactions in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    disableAutoCompactions - true if auto-compactions are disabled.
    
    Returns:
    the reference to the current option.
  - purgeRedundantKvsWhileFlush
```
public boolean purgeRedundantKvsWhileFlush()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Purge duplicate/deleted keys when a memtable is flushed to storage. Default: true
    
    Specified by:
    
    purgeRedundantKvsWhileFlush in interface ColumnFamilyOptionsInterface
    
    Returns:
    true if purging keys is disabled.
  - setPurgeRedundantKvsWhileFlush
```
public Options setPurgeRedundantKvsWhileFlush(boolean purgeRedundantKvsWhileFlush)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Purge duplicate/deleted keys when a memtable is flushed to storage. Default: true
    
    Specified by:
    
    setPurgeRedundantKvsWhileFlush in interface ColumnFamilyOptionsInterface
    
    Parameters:
    purgeRedundantKvsWhileFlush - true if purging keys is disabled.
    
    Returns:
    the reference to the current option.
  - verifyChecksumsInCompaction
```
public boolean verifyChecksumsInCompaction()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    If true, compaction will verify checksum on every read that happens as part of compaction Default: true
    
    Specified by:
    
    verifyChecksumsInCompaction in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    true if compaction verifies checksum on every read.
  - setVerifyChecksumsInCompaction
```
public Options setVerifyChecksumsInCompaction(boolean verifyChecksumsInCompaction)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    If true, compaction will verify checksum on every read that happens as part of compaction Default: true
    
    Specified by:
    
    setVerifyChecksumsInCompaction in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    verifyChecksumsInCompaction - true if compaction verifies checksum on every read.
    
    Returns:
    the reference to the current option.
  - maxSequentialSkipInIterations
```
public long maxSequentialSkipInIterations()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    An iteration->Next() sequentially skips over keys with the same user-key unless this option is set. This number specifies the number of keys (with the same userkey) that will be sequentially skipped before a reseek is issued. Default: 8
    
    Specified by:
    
    maxSequentialSkipInIterations in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the number of keys could be skipped in a iteration.
  - setMaxSequentialSkipInIterations
```
public Options setMaxSequentialSkipInIterations(long maxSequentialSkipInIterations)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    An iteration->Next() sequentially skips over keys with the same user-key unless this option is set. This number specifies the number of keys (with the same userkey) that will be sequentially skipped before a reseek is issued. Default: 8
    
    Specified by:
    
    setMaxSequentialSkipInIterations in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    maxSequentialSkipInIterations - the number of keys could be skipped in a iteration.
    
    Returns:
    the reference to the current option.
  - inplaceUpdateSupport
```
public boolean inplaceUpdateSupport()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Allows thread-safe inplace updates. If inplace_callback function is not set, Put(key, new_value) will update inplace the existing_value iff * key exists in current memtable * new sizeof(new_value) ≤ sizeof(existing_value) * existing_value for that key is a put i.e. kTypeValue If inplace_callback function is set, check doc for inplace_callback. Default: false.
    
    Specified by:
    
    inplaceUpdateSupport in interface ColumnFamilyOptionsInterface
    
    Returns:
    true if thread-safe inplace updates are allowed.
  - setInplaceUpdateSupport
```
public Options setInplaceUpdateSupport(boolean inplaceUpdateSupport)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Allows thread-safe inplace updates. If inplace_callback function is not set, Put(key, new_value) will update inplace the existing_value iff * key exists in current memtable * new sizeof(new_value) ≤ sizeof(existing_value) * existing_value for that key is a put i.e. kTypeValue If inplace_callback function is set, check doc for inplace_callback. Default: false.
    
    Specified by:
    
    setInplaceUpdateSupport in interface ColumnFamilyOptionsInterface
    
    Parameters:
    inplaceUpdateSupport - true if thread-safe inplace updates are allowed.
    
    Returns:
    the reference to the current option.
  - inplaceUpdateNumLocks
```
public long inplaceUpdateNumLocks()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
    
    Specified by:
    
    inplaceUpdateNumLocks in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the number of locks used for inplace update.
  - setInplaceUpdateNumLocks
```
public Options setInplaceUpdateNumLocks(long inplaceUpdateNumLocks)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
    
    Specified by:
    
    setInplaceUpdateNumLocks in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    inplaceUpdateNumLocks - the number of locks used for inplace updates.
    
    Returns:
    the reference to the current option.
  - memtablePrefixBloomSizeRatio
```
public double memtablePrefixBloomSizeRatio()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio. If it is larger than 0.25, it is santinized to 0.25. Default: 0 (disable)
    
    Specified by:
    
    memtablePrefixBloomSizeRatio in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the ratio
  - setMemtablePrefixBloomSizeRatio
```
public Options setMemtablePrefixBloomSizeRatio(double memtablePrefixBloomSizeRatio)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio. If it is larger than 0.25, it is santinized to 0.25. Default: 0 (disable)
    
    Specified by:
    
    setMemtablePrefixBloomSizeRatio in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    memtablePrefixBloomSizeRatio - The ratio
    
    Returns:
    the reference to the current option.
  - bloomLocality
```
public int bloomLocality()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Control locality of bloom filter probes to improve cache miss rate. This option only applies to memtable prefix bloom and plaintable prefix bloom. It essentially limits the max number of cache lines each bloom filter check can touch. This optimization is turned off when set to 0. The number should never be greater than number of probes. This option can boost performance for in-memory workload but should use with care since it can cause higher false positive rate. Default: 0
    
    Specified by:
    
    bloomLocality in interface ColumnFamilyOptionsInterface
    
    Returns:
    the level of locality of bloom-filter probes.
    See Also:
    ColumnFamilyOptionsInterface.setBloomLocality(int)
  - setBloomLocality
```
public Options setBloomLocality(int bloomLocality)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Control locality of bloom filter probes to improve cache miss rate. This option only applies to memtable prefix bloom and plaintable prefix bloom. It essentially limits the max number of cache lines each bloom filter check can touch. This optimization is turned off when set to 0. The number should never be greater than number of probes. This option can boost performance for in-memory workload but should use with care since it can cause higher false positive rate. Default: 0
    
    Specified by:
    
    setBloomLocality in interface ColumnFamilyOptionsInterface
    
    Parameters:
    bloomLocality - the level of locality of bloom-filter probes.
    
    Returns:
    the reference to the current option.
  - maxSuccessiveMerges
```
public long maxSuccessiveMerges()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Maximum number of successive merge operations on a key in the memtable. When a merge operation is added to the memtable and the maximum number of successive merges is reached, the value of the key will be calculated and inserted into the memtable instead of the merge operation. This will ensure that there are never more than max_successive_merges merge operations in the memtable. Default: 0 (disabled)
    
    Specified by:
    
    maxSuccessiveMerges in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    the maximum number of successive merges.
  - setMaxSuccessiveMerges
```
public Options setMaxSuccessiveMerges(long maxSuccessiveMerges)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Maximum number of successive merge operations on a key in the memtable. When a merge operation is added to the memtable and the maximum number of successive merges is reached, the value of the key will be calculated and inserted into the memtable instead of the merge operation. This will ensure that there are never more than max_successive_merges merge operations in the memtable. Default: 0 (disabled)
    
    Specified by:
    
    setMaxSuccessiveMerges in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    maxSuccessiveMerges - the maximum number of successive merges.
    
    Returns:
    the reference to the current option.
  - minWriteBufferNumberToMerge
```
public int minWriteBufferNumberToMerge()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The minimum number of write buffers that will be merged together before writing to storage. If set to 1, then all write buffers are flushed to L0 as individual files and this increases read amplification because a get request has to check in all of these files. Also, an in-memory merge may result in writing lesser data to storage if there are duplicate records in each of these individual write buffers. Default: 1
    
    Specified by:
    
    minWriteBufferNumberToMerge in interface ColumnFamilyOptionsInterface
    
    Returns:
    the minimum number of write buffers that will be merged together.
  - setMinWriteBufferNumberToMerge
```
public Options setMinWriteBufferNumberToMerge(int minWriteBufferNumberToMerge)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The minimum number of write buffers that will be merged together before writing to storage. If set to 1, then all write buffers are flushed to L0 as individual files and this increases read amplification because a get request has to check in all of these files. Also, an in-memory merge may result in writing lesser data to storage if there are duplicate records in each of these individual write buffers. Default: 1
    
    Specified by:
    
    setMinWriteBufferNumberToMerge in interface ColumnFamilyOptionsInterface
    
    Parameters:
    minWriteBufferNumberToMerge - the minimum number of write buffers that will be merged together.
    
    Returns:
    the reference to the current option.
  - minPartialMergeOperands
```
public int minPartialMergeOperands()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The number of partial merge operands to accumulate before partial merge will be performed. Partial merge will not be called if the list of values to merge is less than min_partial_merge_operands. If min_partial_merge_operands < 2, then it will be treated as 2. Default: 2
    
    Specified by:
    
    minPartialMergeOperands in interface ColumnFamilyOptionsInterface
    
    Returns:
    min partial merge operands
  - setMinPartialMergeOperands
```
public Options setMinPartialMergeOperands(int minPartialMergeOperands)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    The number of partial merge operands to accumulate before partial merge will be performed. Partial merge will not be called if the list of values to merge is less than min_partial_merge_operands. If min_partial_merge_operands < 2, then it will be treated as 2. Default: 2
    
    Specified by:
    
    setMinPartialMergeOperands in interface ColumnFamilyOptionsInterface
    
    Parameters:
    minPartialMergeOperands - min partial merge operands
    
    Returns:
    the reference to the current option.
  - setOptimizeFiltersForHits
```
public Options setOptimizeFiltersForHits(boolean optimizeFiltersForHits)
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    This flag specifies that the implementation should optimize the filters mainly for cases where keys are found rather than also optimize for keys missed. This would be used in cases where the application knows that there are very few misses or the performance in the case of misses is not important.
    
    For now, this flag allows us to not store filters for the last level i.e the largest level which contains data of the LSM store. For keys which are hits, the filters in this level are not useful because we will search for the data anyway.
    
    NOTE: the filters in other levels are still useful even for key hit because they tell us whether to look in that level or go to the higher level.
    
    Default: false
    
    Specified by:
    
    setOptimizeFiltersForHits in interface ColumnFamilyOptionsInterface
    
    Parameters:
    optimizeFiltersForHits - boolean value indicating if this flag is set.
    
    Returns:
    the reference to the current option.
  - optimizeFiltersForHits
```
public boolean optimizeFiltersForHits()
```
    Description copied from interface: ColumnFamilyOptionsInterface
    
    Returns the current state of the optimize_filters_for_hits setting.
    
    Specified by:
    
    optimizeFiltersForHits in interface ColumnFamilyOptionsInterface
    
    Returns:
    boolean value indicating if the flag optimize_filters_for_hits was set.
  - setMemtableHugePageSize
```
public Options setMemtableHugePageSize(long memtableHugePageSize)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Page size for huge page TLB for bloom in memtable. If ≤ 0, not allocate from huge page TLB but from malloc. Need to reserve huge pages for it to be allocated. For example: sysctl -w vm.nr_hugepages=20 See linux doc Documentation/vm/hugetlbpage.txt
    
    Specified by:
    
    setMemtableHugePageSize in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    memtableHugePageSize - The page size of the huge page tlb
    
    Returns:
    the reference to the current option.
  - memtableHugePageSize
```
public long memtableHugePageSize()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Page size for huge page TLB for bloom in memtable. If ≤ 0, not allocate from huge page TLB but from malloc. Need to reserve huge pages for it to be allocated. For example: sysctl -w vm.nr_hugepages=20 See linux doc Documentation/vm/hugetlbpage.txt
    
    Specified by:
    
    memtableHugePageSize in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The page size of the huge page tlb
  - setSoftPendingCompactionBytesLimit
```
public Options setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold. Default: 64GB
    
    Specified by:
    
    setSoftPendingCompactionBytesLimit in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    softPendingCompactionBytesLimit - The soft limit to impose on compaction
    
    Returns:
    the reference to the current option.
  - softPendingCompactionBytesLimit
```
public long softPendingCompactionBytesLimit()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold. Default: 64GB
    
    Specified by:
    
    softPendingCompactionBytesLimit in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The soft limit to impose on compaction
  - setHardPendingCompactionBytesLimit
```
public Options setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    All writes are stopped if estimated bytes needed to be compaction exceed this threshold. Default: 256GB
    
    Specified by:
    
    setHardPendingCompactionBytesLimit in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    hardPendingCompactionBytesLimit - The hard limit to impose on compaction
    
    Returns:
    the reference to the current option.
  - hardPendingCompactionBytesLimit
```
public long hardPendingCompactionBytesLimit()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    All writes are stopped if estimated bytes needed to be compaction exceed this threshold. Default: 256GB
    
    Specified by:
    
    hardPendingCompactionBytesLimit in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The hard limit to impose on compaction
  - setLevel0FileNumCompactionTrigger
```
public Options setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Number of files to trigger level-0 compaction. A value < 0 means that level-0 compaction will not be triggered by number of files at all. Default: 4
    
    Specified by:
    
    setLevel0FileNumCompactionTrigger in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    level0FileNumCompactionTrigger - The number of files to trigger level-0 compaction
    
    Returns:
    the reference to the current option.
  - level0FileNumCompactionTrigger
```
public int level0FileNumCompactionTrigger()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Number of files to trigger level-0 compaction. A value < 0 means that level-0 compaction will not be triggered by number of files at all. Default: 4
    
    Specified by:
    
    level0FileNumCompactionTrigger in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The number of files to trigger
  - setLevel0SlowdownWritesTrigger
```
public Options setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Soft limit on number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    Specified by:
    
    setLevel0SlowdownWritesTrigger in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    level0SlowdownWritesTrigger - The soft limit on the number of level-0 files
    
    Returns:
    the reference to the current option.
  - level0SlowdownWritesTrigger
```
public int level0SlowdownWritesTrigger()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Soft limit on number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    Specified by:
    
    level0SlowdownWritesTrigger in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The soft limit on the number of level-0 files
  - setLevel0StopWritesTrigger
```
public MutableColumnFamilyOptionsInterface setLevel0StopWritesTrigger(int level0StopWritesTrigger)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    Specified by:
    
    setLevel0StopWritesTrigger in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    level0StopWritesTrigger - The maximum number of level-0 files
    
    Returns:
    the reference to the current option.
  - level0StopWritesTrigger
```
public int level0StopWritesTrigger()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    Specified by:
    
    level0StopWritesTrigger in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The maximum number of level-0 files
  - setMaxBytesForLevelMultiplierAdditional
```
public Options setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Different max-size multipliers for different levels. These are multiplied by max_bytes_for_level_multiplier to arrive at the max-size of each level. Default: 1
    
    Specified by:
    
    setMaxBytesForLevelMultiplierAdditional in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    maxBytesForLevelMultiplierAdditional - The max-size multipliers for each level
    
    Returns:
    the reference to the current option.
  - maxBytesForLevelMultiplierAdditional
```
public int[] maxBytesForLevelMultiplierAdditional()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    Different max-size multipliers for different levels. These are multiplied by max_bytes_for_level_multiplier to arrive at the max-size of each level. Default: 1
    
    Specified by:
    
    maxBytesForLevelMultiplierAdditional in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    The max-size multipliers for each level
  - setParanoidFileChecks
```
public Options setParanoidFileChecks(boolean paranoidFileChecks)
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    After writing every SST file, reopen it and read all the keys. Default: false
    
    Specified by:
    
    setParanoidFileChecks in interface MutableColumnFamilyOptionsInterface
    
    Parameters:
    paranoidFileChecks - true to enable paranoid file checks
    
    Returns:
    the reference to the current option.
  - paranoidFileChecks
```
public boolean paranoidFileChecks()
```
    Description copied from interface: MutableColumnFamilyOptionsInterface
    
    After writing every SST file, reopen it and read all the keys. Default: false
    
    Specified by:
    
    paranoidFileChecks in interface MutableColumnFamilyOptionsInterface
    
    Returns:
    true if paranoid file checks are enabled
  - disposeInternal
```
protected final void disposeInternal(long handle)
```
    Specified by:
    
    disposeInternal in class RocksObject

Class Options

Field Summary

Fields inherited from class org.rocksdb.RocksObject

Fields inherited from interface org.rocksdb.ColumnFamilyOptionsInterface

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

Constructor Detail

Options

Options

Method Detail

setIncreaseParallelism

setCreateIfMissing

setCreateMissingColumnFamilies

setEnv

getEnv

prepareForBulkLoad

createIfMissing

createMissingColumnFamilies

optimizeForPointLookup

optimizeLevelStyleCompaction

optimizeLevelStyleCompaction

optimizeUniversalStyleCompaction

optimizeUniversalStyleCompaction

setComparator

setComparator

setMergeOperatorName

setMergeOperator

setWriteBufferSize

writeBufferSize

setMaxWriteBufferNumber

maxWriteBufferNumber

errorIfExists

setErrorIfExists

paranoidChecks

setParanoidChecks

maxOpenFiles

setMaxTotalWalSize

maxTotalWalSize

setMaxOpenFiles

disableDataSync

setDisableDataSync

useFsync

setUseFsync

dbLogDir

setDbLogDir

walDir

setWalDir

deleteObsoleteFilesPeriodMicros

setDeleteObsoleteFilesPeriodMicros

maxBackgroundCompactions

createStatistics

statisticsPtr

setBaseBackgroundCompactions

baseBackgroundCompactions

setMaxBackgroundCompactions

setMaxSubcompactions

maxSubcompactions

maxBackgroundFlushes

setMaxBackgroundFlushes

maxLogFileSize

setMaxLogFileSize

logFileTimeToRoll

setLogFileTimeToRoll

keepLogFileNum

setKeepLogFileNum

maxManifestFileSize

setMaxManifestFileSize

setMaxTableFilesSizeFIFO

maxTableFilesSizeFIFO

tableCacheNumshardbits

setTableCacheNumshardbits

walTtlSeconds

setWalTtlSeconds

walSizeLimitMB

setWalSizeLimitMB

manifestPreallocationSize