DBOptions (schwefel 7.2.2.1 API)

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

All Implemented Interfaces:

AutoCloseable, DBOptionsInterface<DBOptions>, MutableDBOptionsInterface<DBOptions>
```
public class DBOptions
extends RocksObject
implements DBOptionsInterface<DBOptions>, MutableDBOptionsInterface<DBOptions>
```
DBOptions to control the behavior of a database. It will be used during the creation of a RocksDB (i.e., RocksDB.open()). As a descendent of AbstractNativeReference, this class is AutoCloseable and will be automatically released if opened in the preamble of a try with resources block.

Field Summary
- Fields inherited from class org.rocksdb.RocksObject
  nativeHandle_
- Fields inherited from class org.rocksdb.AbstractImmutableNativeReference
  owningHandle_

Constructor Summary

Constructors
Constructor and Description
`DBOptions()` Construct DBOptions.
`DBOptions(DBOptions other)` Copy constructor for DBOptions.
`DBOptions(Options options)` Constructor from Options

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`AccessHint`	`accessHintOnCompactionStart()` Specify the file access pattern once a compaction is started.
`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`	`allow2pc()` if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
`boolean`	`allowConcurrentMemtableWrite()` If true, allow multi-writers to update mem tables in parallel.
`boolean`	`allowFAllocate()` Whether fallocate calls are allowed
`boolean`	`allowIngestBehind()` Returns true if ingest behind is allowed.
`boolean`	`allowMmapReads()` Allow the OS to mmap file for reading sst tables.
`boolean`	`allowMmapWrites()` Allow the OS to mmap file for writing.
`boolean`	`atomicFlush()` Determine if atomic flush of multiple column families is enabled.
`boolean`	`avoidFlushDuringRecovery()` By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files.
`boolean`	`avoidFlushDuringShutdown()` By default RocksDB will flush all memtables on DB close if there are unpersisted data (i.e. with WAL disabled) The flush can be skip to speedup DB close.
`boolean`	`avoidUnnecessaryBlockingIO()` If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it.
`boolean`	`bestEffortsRecovery()` By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST.
`long`	`bgerrorResumeRetryInterval()` If max_bgerror_resume_count is ≥ 2, db resume is called multiple times.
`long`	`bytesPerSync()` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`long`	`compactionReadaheadSize()` If non-zero, we perform bigger reads when doing compaction.
`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.
`String`	`dbLogDir()` Returns the directory of info log.
`List<DbPath>`	`dbPaths()` A list of paths where SST files can be put into, with its target size.
`long`	`dbWriteBufferSize()` Amount of data to build up in memtables across all column families before writing to disk.
`long`	`delayedWriteRate()` The limited write rate to DB if `ColumnFamilyOptions.softPendingCompactionBytesLimit()` or `ColumnFamilyOptions.level0SlowdownWritesTrigger()` is triggered, or we are writing to the last mem table allowed and we allow more than 3 mem tables.
`long`	`deleteObsoleteFilesPeriodMicros()` The periodicity when obsolete files get deleted.
`protected void`	`disposeInternal(long handle)`
`boolean`	`dumpMallocStats()` If true, then print malloc stats together with rocksdb.stats when printing to LOG.
`boolean`	`enablePipelinedWrite()` Returns true if pipelined writes are enabled.
`boolean`	`enableThreadTracking()` If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API.
`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.
`boolean`	`failIfOptionsFileError()` If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted.
`static DBOptions`	`getDBOptionsFromProps(ConfigOptions cfgOpts, Properties properties)` Method to get a options instance by using pre-configured property values.
`static DBOptions`	`getDBOptionsFromProps(Properties properties)` Method to get a options instance by using pre-configured property values.
`Env`	`getEnv()` Returns the set RocksEnv instance.
`InfoLogLevel`	`infoLogLevel()` Returns currently set log level.
`boolean`	`isFdCloseOnExec()` Disable child process inherit open files.
`long`	`keepLogFileNum()` Returns the maximum number of info log files to be kept.
`List<AbstractEventListener>`	`listeners()` Sets the `EventListener`s whose callback functions will be called when specific RocksDB event happens.
`long`	`logFileTimeToRoll()` Returns the time interval for the info log file to roll (in seconds).
`long`	`logReadaheadSize()` The number of bytes to prefetch when reading the log.
`long`	`manifestPreallocationSize()` Number of bytes to preallocate (via fallocate) the manifest files.
`boolean`	`manualWalFlush()` Returns true if automatic WAL flushing is disabled.
`int`	`maxBackgroundCompactions()` Deprecated.
`int`	`maxBackgroundFlushes()` Deprecated.
`int`	`maxBackgroundJobs()` Returns the maximum number of concurrent background jobs (both flushes and compactions combined).
`int`	`maxBgerrorResumeCount()` It defines how many times db resume is called by a separate thread when background retryable IO Error happens.
`int`	`maxFileOpeningThreads()` If `MutableDBOptionsInterface.maxOpenFiles()` is -1, DB will open all files on DB::Open().
`long`	`maxLogFileSize()` Returns the maximum size of a info log file.
`long`	`maxManifestFileSize()` Manifest file is rolled over on reaching this limit.
`int`	`maxOpenFiles()` Number of open files that can be used by the DB.
`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`	`maxTotalWalSize()` Returns the max total write-ahead log size.
`long`	`maxWriteBatchGroupSizeBytes()` The maximum limit of number of bytes that are written in a single batch of WAL or memtable write.
`DBOptions`	`optimizeForSmallDb()` Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
`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`	`persistStatsToDisk()` If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct.
`long`	`randomAccessMaxBufferSize()` This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode.
`long`	`recycleLogFileNum()` Recycle log files.
`Cache`	`rowCache()` A global cache for table-level rows.
`DBOptions`	`setAccessHintOnCompactionStart(AccessHint accessHint)` Specify the file access pattern once a compaction is started.
`DBOptions`	`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.
`DBOptions`	`setAllow2pc(boolean allow2pc)` if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
`DBOptions`	`setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)` If true, allow multi-writers to update mem tables in parallel.
`DBOptions`	`setAllowFAllocate(boolean allowFAllocate)` Whether fallocate calls are allowed
`DBOptions`	`setAllowIngestBehind(boolean allowIngestBehind)` Set this option to true during creation of database if you want to be able to ingest behind (call IngestExternalFile() skipping keys that already exist, rather than overwriting matching keys).
`DBOptions`	`setAllowMmapReads(boolean allowMmapReads)` Allow the OS to mmap file for reading sst tables.
`DBOptions`	`setAllowMmapWrites(boolean allowMmapWrites)` Allow the OS to mmap file for writing.
`DBOptions`	`setAtomicFlush(boolean atomicFlush)` If true, RocksDB supports flushing multiple column families and committing their results atomically to MANIFEST.
`DBOptions`	`setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery)` By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files.
`DBOptions`	`setAvoidFlushDuringShutdown(boolean avoidFlushDuringShutdown)` By default RocksDB will flush all memtables on DB close if there are unpersisted data (i.e. with WAL disabled) The flush can be skip to speedup DB close.
`DBOptions`	`setAvoidUnnecessaryBlockingIO(boolean avoidUnnecessaryBlockingIO)` If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it.
`DBOptions`	`setBestEffortsRecovery(boolean bestEffortsRecovery)` By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST.
`DBOptions`	`setBgerrorResumeRetryInterval(long bgerrorResumeRetryInterval)` If max_bgerror_resume_count is ≥ 2, db resume is called multiple times.
`DBOptions`	`setBytesPerSync(long bytesPerSync)` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`DBOptions`	`setCompactionReadaheadSize(long compactionReadaheadSize)` If non-zero, we perform bigger reads when doing compaction.
`DBOptions`	`setCreateIfMissing(boolean flag)` If this value is set to true, then the database will be created if it is missing during `RocksDB.open()`.
`DBOptions`	`setCreateMissingColumnFamilies(boolean flag)` If true, missing column families will be automatically created Default: false
`DBOptions`	`setDbLogDir(String dbLogDir)` This specifies the info LOG dir.
`DBOptions`	`setDbPaths(Collection<DbPath> dbPaths)` A list of paths where SST files can be put into, with its target size.
`DBOptions`	`setDbWriteBufferSize(long dbWriteBufferSize)` Amount of data to build up in memtables across all column families before writing to disk.
`DBOptions`	`setDelayedWriteRate(long delayedWriteRate)` The limited write rate to DB if `ColumnFamilyOptions.softPendingCompactionBytesLimit()` or `ColumnFamilyOptions.level0SlowdownWritesTrigger()` is triggered, or we are writing to the last mem table allowed and we allow more than 3 mem tables.
`DBOptions`	`setDeleteObsoleteFilesPeriodMicros(long micros)` The periodicity when obsolete files get deleted.
`DBOptions`	`setDumpMallocStats(boolean dumpMallocStats)` If true, then print malloc stats together with rocksdb.stats when printing to LOG.
`DBOptions`	`setEnablePipelinedWrite(boolean enablePipelinedWrite)` By default, a single write thread queue is maintained.
`DBOptions`	`setEnableThreadTracking(boolean enableThreadTracking)` If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API.
`DBOptions`	`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.
`DBOptions`	`setEnv(Env env)` Use the specified object to interact with the environment, e.g. to read/write files, schedule background work, etc.
`DBOptions`	`setErrorIfExists(boolean errorIfExists)` If true, an error will be thrown during RocksDB.open() if the database already exists.
`DBOptions`	`setFailIfOptionsFileError(boolean failIfOptionsFileError)` If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted.
`DBOptions`	`setIncreaseParallelism(int totalThreads)` By default, RocksDB uses only one background thread for flush and compaction.
`DBOptions`	`setInfoLogLevel(InfoLogLevel infoLogLevel)` Sets the RocksDB log level.
`DBOptions`	`setIsFdCloseOnExec(boolean isFdCloseOnExec)` Disable child process inherit open files.
`DBOptions`	`setKeepLogFileNum(long keepLogFileNum)` Specifies the maximum number of info log files to be kept.
`DBOptions`	`setListeners(List<AbstractEventListener> listeners)` Sets the `EventListener`s whose callback functions will be called when specific RocksDB event happens.
`DBOptions`	`setLogFileTimeToRoll(long logFileTimeToRoll)` Specifies the time interval for the info log file to roll (in seconds).
`DBOptions`	`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.
`DBOptions`	`setLogReadaheadSize(long logReadaheadSize)` The number of bytes to prefetch when reading the log.
`DBOptions`	`setManifestPreallocationSize(long size)` Number of bytes to preallocate (via fallocate) the manifest files.
`DBOptions`	`setManualWalFlush(boolean manualWalFlush)` If true WAL is not flushed automatically after each write.
`DBOptions`	`setMaxBackgroundCompactions(int maxBackgroundCompactions)` Deprecated.
`DBOptions`	`setMaxBackgroundFlushes(int maxBackgroundFlushes)` Deprecated.
`DBOptions`	`setMaxBackgroundJobs(int maxBackgroundJobs)` Specifies the maximum number of concurrent background jobs (both flushes and compactions combined).
`DBOptions`	`setMaxBgErrorResumeCount(int maxBgerrorResumeCount)` It defines how many times db resume is called by a separate thread when background retryable IO Error happens.
`DBOptions`	`setMaxFileOpeningThreads(int maxFileOpeningThreads)` If `MutableDBOptionsInterface.maxOpenFiles()` is -1, DB will open all files on DB::Open().
`DBOptions`	`setMaxLogFileSize(long maxLogFileSize)` Specifies the maximum size of a info log file.
`DBOptions`	`setMaxManifestFileSize(long maxManifestFileSize)` Manifest file is rolled over on reaching this limit.
`DBOptions`	`setMaxOpenFiles(int maxOpenFiles)` Number of open files that can be used by the DB.
`DBOptions`	`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.
`DBOptions`	`setMaxTotalWalSize(long maxTotalWalSize)` Set the max total write-ahead log size.
`DBOptions`	`setMaxWriteBatchGroupSizeBytes(long maxWriteBatchGroupSizeBytes)` The maximum limit of number of bytes that are written in a single batch of WAL or memtable write.
`DBOptions`	`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.
`DBOptions`	`setPersistStatsToDisk(boolean persistStatsToDisk)` If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct.
`DBOptions`	`setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize)` This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode.
`DBOptions`	`setRateLimiter(RateLimiter rateLimiter)` Use to control write rate of flush and compaction.
`DBOptions`	`setRecycleLogFileNum(long recycleLogFileNum)` Recycle log files.
`DBOptions`	`setRowCache(Cache rowCache)` A global cache for table-level rows.
`DBOptions`	`setSkipCheckingSstFileSizesOnDbOpen(boolean skipCheckingSstFileSizesOnDbOpen)` If true, then `RocksDB.open(String)` will not fetch and check sizes of all sst files.
`DBOptions`	`setSkipStatsUpdateOnDbOpen(boolean skipStatsUpdateOnDbOpen)` If true, then DB::Open() will not update the statistics used to optimize compaction decision by loading table properties from many files.
`DBOptions`	`setSstFileManager(SstFileManager sstFileManager)` Use to track SST files and control their file deletion rate.
`DBOptions`	`setStatistics(Statistics statistics)` Sets the statistics object which collects metrics about database operations.
`DBOptions`	`setStatsDumpPeriodSec(int statsDumpPeriodSec)` if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
`DBOptions`	`setStatsHistoryBufferSize(long statsHistoryBufferSize)` If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at `statsHistoryBufferSize` Default: 1MB
`DBOptions`	`setStatsPersistPeriodSec(int statsPersistPeriodSec)` If not zero, dump rocksdb.stats to RocksDB every `statsPersistPeriodSec` Default: 600
`DBOptions`	`setStrictBytesPerSync(boolean strictBytesPerSync)` When true, guarantees WAL files have at most `MutableDBOptionsInterface.walBytesPerSync()` bytes submitted for writeback at any given time, and SST files have at most `MutableDBOptionsInterface.bytesPerSync()` bytes pending writeback at any given time.
`DBOptions`	`setTableCacheNumshardbits(int tableCacheNumshardbits)` Number of shards used for table cache.
`DBOptions`	`setTwoWriteQueues(boolean twoWriteQueues)` If enabled it uses two queues for writes, one for the ones with disable_memtable and one for the ones that also write to memtable.
`DBOptions`	`setUnorderedWrite(boolean unorderedWrite)` Setting `DBOptionsInterface.unorderedWrite()` to true trades higher write throughput with relaxing the immutability guarantee of snapshots.
`DBOptions`	`setUseAdaptiveMutex(boolean useAdaptiveMutex)` Use adaptive mutex, which spins in the user space before resorting to kernel.
`DBOptions`	`setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction)` Enable the OS to use direct reads and writes in flush and compaction Default: false
`DBOptions`	`setUseDirectReads(boolean useDirectReads)` Enable the OS to use direct I/O for reading sst tables.
`DBOptions`	`setUseFsync(boolean useFsync)` If true, then every store to stable storage will issue a fsync.
`DBOptions`	`setWalBytesPerSync(long walBytesPerSync)` Same as `MutableDBOptionsInterface.setBytesPerSync(long)` , but applies to WAL files Default: 0, turned off
`DBOptions`	`setWalDir(String walDir)` This specifies the absolute dir path for write-ahead logs (WAL).
`DBOptions`	`setWalFilter(AbstractWalFilter walFilter)` A filter object supplied to be invoked while processing write-ahead-logs (WALs) during recovery.
`DBOptions`	`setWalRecoveryMode(WALRecoveryMode walRecoveryMode)` Recovery mode to control the consistency while replaying WAL Default: `WALRecoveryMode.PointInTimeRecovery`
`DBOptions`	`setWalSizeLimitMB(long sizeLimitMB)` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`DBOptions`	`setWalTtlSeconds(long walTtlSeconds)` `DBOptionsInterface.walTtlSeconds()` and `DBOptionsInterface.walSizeLimitMB()` affect how archived logs will be deleted.
`DBOptions`	`setWritableFileMaxBufferSize(long writableFileMaxBufferSize)` This is the maximum buffer size that is used by WritableFileWriter.
`DBOptions`	`setWriteBufferManager(WriteBufferManager writeBufferManager)` Use passed `WriteBufferManager` to control memory usage across multiple column families and/or DB instances.
`DBOptions`	`setWriteDbidToManifest(boolean writeDbidToManifest)` Historically DB ID has always been stored in Identity File in DB folder.
`DBOptions`	`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.
`DBOptions`	`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.
`boolean`	`skipCheckingSstFileSizesOnDbOpen()` If true, then `RocksDB.open(String)` will not fetch and check sizes of all sst files.
`boolean`	`skipStatsUpdateOnDbOpen()` If true, then DB::Open() will not update the statistics used to optimize compaction decision by loading table properties from many files.
`Statistics`	`statistics()` Returns statistics object.
`int`	`statsDumpPeriodSec()` If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
`long`	`statsHistoryBufferSize()` If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at `statsHistoryBufferSize`
`int`	`statsPersistPeriodSec()` If not zero, dump rocksdb.stats to RocksDB every `statsPersistPeriodSec`
`boolean`	`strictBytesPerSync()` Return the strict byte limit per sync.
`int`	`tableCacheNumshardbits()` Number of shards used for table cache.
`boolean`	`twoWriteQueues()` Returns true if two write queues are enabled.
`boolean`	`unorderedWrite()` Returns true if unordered write are enabled.
`boolean`	`useAdaptiveMutex()` Use adaptive mutex, which spins in the user space before resorting to kernel.
`boolean`	`useDirectIoForFlushAndCompaction()` Enable the OS to use direct reads and writes in flush and compaction
`boolean`	`useDirectReads()` Enable the OS to use direct I/O for reading sst tables.
`boolean`	`useFsync()` If true, then every store to stable storage will issue a fsync.
`long`	`walBytesPerSync()` Same as `MutableDBOptionsInterface.bytesPerSync()` , but applies to WAL files Default: 0, turned off
`String`	`walDir()` Returns the path to the write-ahead-logs (WAL) directory.
`WalFilter`	`walFilter()` Get's the filter for processing WALs during recovery.
`WALRecoveryMode`	`walRecoveryMode()` Recovery mode to control the consistency while replaying WAL Default: `WALRecoveryMode.PointInTimeRecovery`
`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`	`writableFileMaxBufferSize()` This is the maximum buffer size that is used by WritableFileWriter.
`WriteBufferManager`	`writeBufferManager()` Reference to `WriteBufferManager` used by it.
`boolean`	`writeDbidToManifest()` Historically DB ID has always been stored in Identity File in DB folder.
`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, getNativeHandle

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

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

- Constructor Detail
  - DBOptions
```
public DBOptions()
```
    Construct DBOptions. This constructor will create (by allocating a block of memory) an rocksdb::DBOptions in the c++ side.
  - DBOptions
```
public DBOptions(DBOptions other)
```
    Copy constructor for DBOptions. NOTE: This does a shallow copy, which means env, rate_limiter, sst_file_manager, info_log and other pointers will be cloned!
    
    Parameters:
    
    other - The DBOptions to copy.
  - DBOptions
```
public DBOptions(Options options)
```
    Constructor from Options
    
    Parameters:
    
    options - The options.
- Method Detail
  - getDBOptionsFromProps
```
public static DBOptions getDBOptionsFromProps(ConfigOptions cfgOpts,
                                              Properties properties)
```
    Method to get a options instance by using pre-configured property values. If one or many values are undefined in the context of RocksDB the method will return a null value.
    
    Note: Property keys can be derived from getter methods within the options class. Example: the method allowMmapReads() has a property key: allow_mmap_reads.
    
    Parameters:
    
    cfgOpts - The ConfigOptions to control how the string is processed.
    
    properties - Properties instance.
    
    Returns:
    
    instance or null.
    
    Throws:
    
    IllegalArgumentException - if null or empty Properties instance is passed to the method call.
  - getDBOptionsFromProps
```
public static DBOptions getDBOptionsFromProps(Properties properties)
```
    Method to get a options instance by using pre-configured property values. If one or many values are undefined in the context of RocksDB the method will return a null value.
    
    Note: Property keys can be derived from getter methods within the options class. Example: the method allowMmapReads() has a property key: allow_mmap_reads.
    
    Parameters:
    
    properties - Properties instance.
    
    Returns:
    
    instance or null.
    
    Throws:
    
    IllegalArgumentException - if null or empty Properties instance is passed to the method call.
  - optimizeForSmallDb
```
public DBOptions optimizeForSmallDb()
```
    Description copied from interface: DBOptionsInterface
    
    Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
    
    Specified by:
    
    optimizeForSmallDb in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the instance of the current object.
  - setIncreaseParallelism
```
public DBOptions 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<DBOptions>
    
    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 DBOptions 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<DBOptions>
    
    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)
  - 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<DBOptions>
    
    Returns:
    
    true if the createIfMissing option is set to true.
    
    See Also:
    
    DBOptionsInterface.setCreateIfMissing(boolean)
  - setCreateMissingColumnFamilies
```
public DBOptions 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<DBOptions>
    
    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.
  - 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<DBOptions>
    
    Returns:
    
    true if the createMissingColumnFamilies is set to true.
    
    See Also:
    
    DBOptionsInterface.setCreateMissingColumnFamilies(boolean)
  - setErrorIfExists
```
public DBOptions 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<DBOptions>
    
    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)
  - 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<DBOptions>
    
    Returns:
    
    if true, an error is raised when the specified database already exists before open.
  - setParanoidChecks
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    paranoidChecks - a flag to indicate whether paranoid-check is on.
    
    Returns:
    
    the reference to the current option.
  - 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<DBOptions>
    
    Returns:
    
    a boolean indicating whether paranoid-check is on.
  - setEnv
```
public DBOptions setEnv(Env env)
```
    Description copied from interface: DBOptionsInterface
    
    Use the specified object to interact with the environment, e.g. to read/write files, schedule background work, etc. Default: Env.getDefault()
    
    Specified by:
    
    setEnv in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    env - Env instance.
    
    Returns:
    
    the instance of the current Options.
  - getEnv
```
public Env getEnv()
```
    Description copied from interface: DBOptionsInterface
    
    Returns the set RocksEnv instance.
    
    Specified by:
    
    getEnv in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    RocksEnv instance set in the options.
  - setRateLimiter
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    rateLimiter - RateLimiter instance.
    
    Returns:
    
    the instance of the current object.
  - setSstFileManager
```
public DBOptions setSstFileManager(SstFileManager sstFileManager)
```
    Description copied from interface: DBOptionsInterface
    
    Use to track SST files and control their file deletion rate. Features: - Throttle the deletion rate of the SST files. - Keep track the total size of all SST files. - Set a maximum allowed space limit for SST files that when reached the DB wont do any further flushes or compactions and will set the background error. - Can be shared between multiple dbs. Limitations: - Only track and throttle deletes of SST files in first db_path (db_name if db_paths is empty).
    
    Specified by:
    
    setSstFileManager in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    sstFileManager - The SST File Manager for the db.
    
    Returns:
    
    the instance of the current object.
  - setLogger
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    logger - Logger instance.
    
    Returns:
    
    the instance of the current object.
  - setInfoLogLevel
```
public DBOptions setInfoLogLevel(InfoLogLevel infoLogLevel)
```
    Description copied from interface: DBOptionsInterface
    
    Sets the RocksDB log level. Default level is INFO
    
    Specified by:
    
    setInfoLogLevel in interface DBOptionsInterface<DBOptions>
    
    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<DBOptions>
    
    Returns:
    
    InfoLogLevel instance.
  - setMaxOpenFiles
```
public DBOptions setMaxOpenFiles(int maxOpenFiles)
```
    Description copied from interface: MutableDBOptionsInterface
    
    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: -1
    
    Specified by:
    
    setMaxOpenFiles in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxOpenFiles - the maximum number of open files.
    
    Returns:
    
    the instance of the current object.
  - maxOpenFiles
```
public int maxOpenFiles()
```
    Description copied from interface: MutableDBOptionsInterface
    
    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: -1
    
    Specified by:
    
    maxOpenFiles in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum number of open files.
  - setMaxFileOpeningThreads
```
public DBOptions setMaxFileOpeningThreads(int maxFileOpeningThreads)
```
    Description copied from interface: DBOptionsInterface
    
    If MutableDBOptionsInterface.maxOpenFiles() is -1, DB will open all files on DB::Open(). You can use this option to increase the number of threads used to open the files. Default: 16
    
    Specified by:
    
    setMaxFileOpeningThreads in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxFileOpeningThreads - the maximum number of threads to use to open files
    
    Returns:
    
    the reference to the current options.
  - maxFileOpeningThreads
```
public int maxFileOpeningThreads()
```
    Description copied from interface: DBOptionsInterface
    
    If MutableDBOptionsInterface.maxOpenFiles() is -1, DB will open all files on DB::Open(). You can use this option to increase the number of threads used to open the files. Default: 16
    
    Specified by:
    
    maxFileOpeningThreads in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum number of threads to use to open files
  - setMaxTotalWalSize
```
public DBOptions setMaxTotalWalSize(long maxTotalWalSize)
```
    Description copied from interface: MutableDBOptionsInterface
    
    Set the max total write-ahead log 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
    
    The oldest WAL files are the ones that are causing all the space amplification.
    For example, with 15 column families, each with write_buffer_size = 128 MB max_write_buffer_number = 6 max_total_wal_size will be calculated to be [15 * 128MB * 6] * 4 = 45GB
    The RocksDB wiki has some discussion about how the WAL interacts with memtables and flushing of column families, at ...
    
    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] * 4
    
    This option takes effect only when there are more than one column family as otherwise the wal size is dictated by the write_buffer_size.
    
    Default: 0
    
    Specified by:
    
    setMaxTotalWalSize in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxTotalWalSize - max total wal size.
    
    Returns:
    
    the instance of the current object.
  - maxTotalWalSize
```
public long maxTotalWalSize()
```
    Description copied from interface: MutableDBOptionsInterface
    
    Returns the max total write-ahead log 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.
    
    The oldest WAL files are the ones that are causing all the space amplification.
    For example, with 15 column families, each with write_buffer_size = 128 MB max_write_buffer_number = 6 max_total_wal_size will be calculated to be [15 * 128MB * 6] * 4 = 45GB
    The RocksDB wiki has some discussion about how the WAL interacts with memtables and flushing of column families, at ...
    
    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] * 4
    
    This option takes effect only when there are more than one column family as otherwise the wal size is dictated by the write_buffer_size.
    
    Default: 0
    
    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] * 4
    
    Specified by:
    
    maxTotalWalSize in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    max total wal size
  - setStatistics
```
public DBOptions setStatistics(Statistics statistics)
```
    Description copied from interface: DBOptionsInterface
    
    Sets the 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:
    
    setStatistics in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    statistics - The statistics to set
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    RocksDB.open(org.rocksdb.Options, String)
  - statistics
```
public Statistics statistics()
```
    Description copied from interface: DBOptionsInterface
    
    Returns statistics object.
    
    Specified by:
    
    statistics in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the instance of the statistics object or null if there is no statistics object.
    
    See Also:
    
    DBOptionsInterface.setStatistics(Statistics)
  - setUseFsync
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    useFsync - a boolean flag to specify whether to use fsync
    
    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<DBOptions>
    
    Returns:
    
    boolean value indicating if fsync is used.
  - setDbPaths
```
public DBOptions setDbPaths(Collection<DbPath> dbPaths)
```
    Description copied from interface: DBOptionsInterface
    
    A list of paths where SST files can be put into, with its target size. Newer data is placed into paths specified earlier in the vector while older data gradually moves to paths specified later in the vector. For example, you have a flash device with 10GB allocated for the DB, as well as a hard drive of 2TB, you should config it to be: [{"/flash_path", 10GB}, {"/hard_drive", 2TB}] The system will try to guarantee data under each path is close to but not larger than the target size. But current and future file sizes used by determining where to place a file are based on best-effort estimation, which means there is a chance that the actual size under the directory is slightly more than target size under some workloads. User should give some buffer room for those cases. If none of the paths has sufficient room to place a file, the file will be placed to the last path anyway, despite to the target size. Placing newer data to earlier paths is also best-efforts. User should expect user files to be placed in higher levels in some extreme cases. If left empty, only one path will be used, which is db_name passed when opening the DB. Default: empty
    
    Specified by:
    
    setDbPaths in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    dbPaths - the paths and target sizes
    
    Returns:
    
    the reference to the current options
  - dbPaths
```
public List<DbPath> dbPaths()
```
    Description copied from interface: DBOptionsInterface
    
    A list of paths where SST files can be put into, with its target size. Newer data is placed into paths specified earlier in the vector while older data gradually moves to paths specified later in the vector. For example, you have a flash device with 10GB allocated for the DB, as well as a hard drive of 2TB, you should config it to be: [{"/flash_path", 10GB}, {"/hard_drive", 2TB}] The system will try to guarantee data under each path is close to but not larger than the target size. But current and future file sizes used by determining where to place a file are based on best-effort estimation, which means there is a chance that the actual size under the directory is slightly more than target size under some workloads. User should give some buffer room for those cases. If none of the paths has sufficient room to place a file, the file will be placed to the last path anyway, despite to the target size. Placing newer data to earlier paths is also best-efforts. User should expect user files to be placed in higher levels in some extreme cases. If left empty, only one path will be used, which is db_name passed when opening the DB. Default: Collections.emptyList()
    
    Specified by:
    
    dbPaths in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    dbPaths the paths and target sizes
  - setDbLogDir
```
public DBOptions setDbLogDir(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<DBOptions>
    
    Parameters:
    
    dbLogDir - the path to the info log directory
    
    Returns:
    
    the instance of the current object.
  - dbLogDir
```
public 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<DBOptions>
    
    Returns:
    
    the path to the info log directory
  - setWalDir
```
public DBOptions setWalDir(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<DBOptions>
    
    Parameters:
    
    walDir - the path to the write-ahead-log directory.
    
    Returns:
    
    the instance of the current object.
  - walDir
```
public 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<DBOptions>
    
    Returns:
    
    the path to the write-ahead-logs (WAL) directory.
  - setDeleteObsoleteFilesPeriodMicros
```
public DBOptions 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<DBOptions>
    
    Specified by:
    
    setDeleteObsoleteFilesPeriodMicros in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    micros - the time interval in micros
    
    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<DBOptions>
    
    Specified by:
    
    deleteObsoleteFilesPeriodMicros in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the time interval in micros when obsolete files will be deleted.
  - setMaxBackgroundJobs
```
public DBOptions setMaxBackgroundJobs(int maxBackgroundJobs)
```
    Description copied from interface: MutableDBOptionsInterface
    
    Specifies the maximum number of concurrent background jobs (both flushes and compactions combined). Default: 2
    
    Specified by:
    
    setMaxBackgroundJobs in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxBackgroundJobs - number of max concurrent background jobs
    
    Returns:
    
    the instance of the current object.
  - maxBackgroundJobs
```
public int maxBackgroundJobs()
```
    Description copied from interface: MutableDBOptionsInterface
    
    Returns the maximum number of concurrent background jobs (both flushes and compactions combined). Default: 2
    
    Specified by:
    
    maxBackgroundJobs in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum number of concurrent background jobs.
  - setMaxBackgroundCompactions
```
@Deprecated
public DBOptions setMaxBackgroundCompactions(int maxBackgroundCompactions)
```
    Deprecated.
    
    Description copied from interface: MutableDBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes` (we replace -1 by 1 in case one option is unset). 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 MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxBackgroundCompactions - the maximum number of background compaction jobs.
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority), DBOptionsInterface.maxBackgroundFlushes()
  - maxBackgroundCompactions
```
@Deprecated
public int maxBackgroundCompactions()
```
    Deprecated.
    
    Description copied from interface: MutableDBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes` (we replace -1 by 1 in case one option is unset). 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 MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum number of concurrent background compaction jobs.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority)
  - setMaxSubcompactions
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    maxSubcompactions - The maximum number of threads that will concurrently perform a compaction job
    
    Returns:
    
    the instance of the current object.
  - 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<DBOptions>
    
    Returns:
    
    The maximum number of threads that will concurrently perform a compaction job
  - setMaxBackgroundFlushes
```
@Deprecated
public DBOptions setMaxBackgroundFlushes(int maxBackgroundFlushes)
```
    Deprecated.
    
    Description copied from interface: DBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes`. 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<DBOptions>
    
    Parameters:
    
    maxBackgroundFlushes - number of max concurrent flush jobs
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority), MutableDBOptionsInterface.maxBackgroundCompactions()
  - maxBackgroundFlushes
```
@Deprecated
public int maxBackgroundFlushes()
```
    Deprecated.
    
    Description copied from interface: DBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes`. 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<DBOptions>
    
    Returns:
    
    the maximum number of concurrent background flush jobs.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority)
  - setMaxLogFileSize
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    maxLogFileSize - the maximum size of a info log file.
    
    Returns:
    
    the instance of the current object.
  - 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<DBOptions>
    
    Returns:
    
    the maximum size of the info log file.
  - setLogFileTimeToRoll
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    logFileTimeToRoll - the time interval in seconds.
    
    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<DBOptions>
    
    Returns:
    
    the time interval in seconds.
  - setKeepLogFileNum
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    keepLogFileNum - the maximum number of info log files to be kept.
    
    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<DBOptions>
    
    Returns:
    
    the maximum number of info log files to be kept.
  - setRecycleLogFileNum
```
public DBOptions setRecycleLogFileNum(long recycleLogFileNum)
```
    Description copied from interface: DBOptionsInterface
    
    Recycle log files. If non-zero, we will reuse previously written log files for new logs, overwriting the old data. The value indicates how many such files we will keep around at any point in time for later use. This is more efficient because the blocks are already allocated and fdatasync does not need to update the inode after each write. Default: 0
    
    Specified by:
    
    setRecycleLogFileNum in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    recycleLogFileNum - the number of log files to keep for recycling
    
    Returns:
    
    the reference to the current options
  - recycleLogFileNum
```
public long recycleLogFileNum()
```
    Description copied from interface: DBOptionsInterface
    
    Recycle log files. If non-zero, we will reuse previously written log files for new logs, overwriting the old data. The value indicates how many such files we will keep around at any point in time for later use. This is more efficient because the blocks are already allocated and fdatasync does not need to update the inode after each write. Default: 0
    
    Specified by:
    
    recycleLogFileNum in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the number of log files kept for recycling
  - setMaxManifestFileSize
```
public DBOptions 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 1GB so that the manifest file can grow, but not reach the limit of storage capacity.
    
    Specified by:
    
    setMaxManifestFileSize in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxManifestFileSize - the size limit of a manifest file.
    
    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 1GB so that the manifest file can grow, but not reach the limit of storage capacity.
    
    Specified by:
    
    maxManifestFileSize in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the size limit of a manifest file.
  - setTableCacheNumshardbits
```
public DBOptions setTableCacheNumshardbits(int tableCacheNumshardbits)
```
    Description copied from interface: DBOptionsInterface
    
    Number of shards used for table cache.
    
    Specified by:
    
    setTableCacheNumshardbits in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    tableCacheNumshardbits - the number of chards
    
    Returns:
    
    the instance of the current object.
  - tableCacheNumshardbits
```
public int tableCacheNumshardbits()
```
    Description copied from interface: DBOptionsInterface
    
    Number of shards used for table cache.
    
    Specified by:
    
    tableCacheNumshardbits in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the number of shards used for table cache.
  - setWalTtlSeconds
```
public DBOptions 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_seconds / 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<DBOptions>
    
    Parameters:
    
    walTtlSeconds - the ttl seconds
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    DBOptionsInterface.setWalSizeLimitMB(long)
  - 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_seconds / 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<DBOptions>
    
    Returns:
    
    the wal-ttl seconds
    
    See Also:
    
    DBOptionsInterface.walSizeLimitMB()
  - setWalSizeLimitMB
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    sizeLimitMB - size limit in mega-bytes.
    
    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<DBOptions>
    
    Returns:
    
    size limit in mega-bytes.
    
    See Also:
    
    DBOptionsInterface.walSizeLimitMB()
  - setMaxWriteBatchGroupSizeBytes
```
public DBOptions setMaxWriteBatchGroupSizeBytes(long maxWriteBatchGroupSizeBytes)
```
    Description copied from interface: DBOptionsInterface
    
    The maximum limit of number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit. Default: 1 MB
    
    Specified by:
    
    setMaxWriteBatchGroupSizeBytes in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxWriteBatchGroupSizeBytes - the maximum limit of number of bytes, see description.
    
    Returns:
    
    the instance of the current object.
  - maxWriteBatchGroupSizeBytes
```
public long maxWriteBatchGroupSizeBytes()
```
    Description copied from interface: DBOptionsInterface
    
    The maximum limit of number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit. Default: 1 MB
    
    Specified by:
    
    maxWriteBatchGroupSizeBytes in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum limit of number of bytes, see description.
  - setManifestPreallocationSize
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    size - the size in byte
    
    Returns:
    
    the instance of the current object.
  - 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<DBOptions>
    
    Returns:
    
    size in bytes.
  - setAllowMmapReads
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    allowMmapReads - true if mmap reads are 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<DBOptions>
    
    Returns:
    
    true if mmap reads are allowed.
  - setAllowMmapWrites
```
public DBOptions setAllowMmapWrites(boolean allowMmapWrites)
```
    Description copied from interface: DBOptionsInterface
    
    Allow the OS to mmap file for writing. Default: false
    
    Specified by:
    
    setAllowMmapWrites in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    allowMmapWrites - true if mmap writes are allowd.
    
    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<DBOptions>
    
    Returns:
    
    true if mmap writes are allowed.
  - setUseDirectReads
```
public DBOptions setUseDirectReads(boolean useDirectReads)
```
    Description copied from interface: DBOptionsInterface
    
    Enable the OS to use direct I/O for reading sst tables. Default: false
    
    Specified by:
    
    setUseDirectReads in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    useDirectReads - if true, then direct read is enabled
    
    Returns:
    
    the instance of the current object.
  - useDirectReads
```
public boolean useDirectReads()
```
    Description copied from interface: DBOptionsInterface
    
    Enable the OS to use direct I/O for reading sst tables. Default: false
    
    Specified by:
    
    useDirectReads in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    if true, then direct reads are enabled
  - setUseDirectIoForFlushAndCompaction
```
public DBOptions setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction)
```
    Description copied from interface: DBOptionsInterface
    
    Enable the OS to use direct reads and writes in flush and compaction Default: false
    
    Specified by:
    
    setUseDirectIoForFlushAndCompaction in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    useDirectIoForFlushAndCompaction - if true, then direct I/O will be enabled for background flush and compactions
    
    Returns:
    
    the instance of the current object.
  - useDirectIoForFlushAndCompaction
```
public boolean useDirectIoForFlushAndCompaction()
```
    Description copied from interface: DBOptionsInterface
    
    Enable the OS to use direct reads and writes in flush and compaction
    
    Specified by:
    
    useDirectIoForFlushAndCompaction in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    if true, then direct I/O is enabled for flush and compaction
  - setAllowFAllocate
```
public DBOptions setAllowFAllocate(boolean allowFAllocate)
```
    Description copied from interface: DBOptionsInterface
    
    Whether fallocate calls are allowed
    
    Specified by:
    
    setAllowFAllocate in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    allowFAllocate - false if fallocate() calls are bypassed
    
    Returns:
    
    the reference to the current options.
  - allowFAllocate
```
public boolean allowFAllocate()
```
    Description copied from interface: DBOptionsInterface
    
    Whether fallocate calls are allowed
    
    Specified by:
    
    allowFAllocate in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    false if fallocate() calls are bypassed
  - setIsFdCloseOnExec
```
public DBOptions setIsFdCloseOnExec(boolean isFdCloseOnExec)
```
    Description copied from interface: DBOptionsInterface
    
    Disable child process inherit open files. Default: true
    
    Specified by:
    
    setIsFdCloseOnExec in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    isFdCloseOnExec - true if child process inheriting open files is disabled.
    
    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<DBOptions>
    
    Returns:
    
    true if child process inheriting open files is disabled.
  - setStatsDumpPeriodSec
```
public DBOptions setStatsDumpPeriodSec(int statsDumpPeriodSec)
```
    Description copied from interface: MutableDBOptionsInterface
    
    if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
    
    Specified by:
    
    setStatsDumpPeriodSec in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    statsDumpPeriodSec - time interval in seconds.
    
    Returns:
    
    the instance of the current object.
  - statsDumpPeriodSec
```
public int statsDumpPeriodSec()
```
    Description copied from interface: MutableDBOptionsInterface
    
    If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
    
    Specified by:
    
    statsDumpPeriodSec in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    time interval in seconds.
  - setStatsPersistPeriodSec
```
public DBOptions setStatsPersistPeriodSec(int statsPersistPeriodSec)
```
    Description copied from interface: MutableDBOptionsInterface
    
    If not zero, dump rocksdb.stats to RocksDB every statsPersistPeriodSec Default: 600
    
    Specified by:
    
    setStatsPersistPeriodSec in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    statsPersistPeriodSec - time interval in seconds.
    
    Returns:
    
    the instance of the current object.
  - statsPersistPeriodSec
```
public int statsPersistPeriodSec()
```
    Description copied from interface: MutableDBOptionsInterface
    
    If not zero, dump rocksdb.stats to RocksDB every statsPersistPeriodSec
    
    Specified by:
    
    statsPersistPeriodSec in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    time interval in seconds.
  - setStatsHistoryBufferSize
```
public DBOptions setStatsHistoryBufferSize(long statsHistoryBufferSize)
```
    Description copied from interface: MutableDBOptionsInterface
    
    If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at statsHistoryBufferSize Default: 1MB
    
    Specified by:
    
    setStatsHistoryBufferSize in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    statsHistoryBufferSize - the size of the buffer.
    
    Returns:
    
    the instance of the current object.
  - statsHistoryBufferSize
```
public long statsHistoryBufferSize()
```
    Description copied from interface: MutableDBOptionsInterface
    
    If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at statsHistoryBufferSize
    
    Specified by:
    
    statsHistoryBufferSize in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the size of the buffer.
  - setAdviseRandomOnOpen
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    adviseRandomOnOpen - true if hinting random access is on.
    
    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<DBOptions>
    
    Returns:
    
    true if hinting random access is on.
  - setDbWriteBufferSize
```
public DBOptions setDbWriteBufferSize(long dbWriteBufferSize)
```
    Description copied from interface: DBOptionsInterface
    
    Amount of data to build up in memtables across all column families before writing to disk. This is distinct from ColumnFamilyOptions.writeBufferSize(), which enforces a limit for a single memtable. This feature is disabled by default. Specify a non-zero value to enable it. Default: 0 (disabled)
    
    Specified by:
    
    setDbWriteBufferSize in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    dbWriteBufferSize - the size of the write buffer
    
    Returns:
    
    the reference to the current options.
  - setWriteBufferManager
```
public DBOptions setWriteBufferManager(WriteBufferManager writeBufferManager)
```
    Description copied from interface: DBOptionsInterface
    
    Use passed WriteBufferManager to control memory usage across multiple column families and/or DB instances. Check https://github.com/facebook/rocksdb/wiki/Write-Buffer-Manager for more details on when to use it
    
    Specified by:
    
    setWriteBufferManager in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    writeBufferManager - The WriteBufferManager to use
    
    Returns:
    
    the reference of the current options.
  - writeBufferManager
```
public WriteBufferManager writeBufferManager()
```
    Description copied from interface: DBOptionsInterface
    
    Reference to WriteBufferManager used by it.
    Default: null (Disabled)
    
    Specified by:
    
    writeBufferManager in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    a reference to WriteBufferManager
  - dbWriteBufferSize
```
public long dbWriteBufferSize()
```
    Description copied from interface: DBOptionsInterface
    
    Amount of data to build up in memtables across all column families before writing to disk. This is distinct from ColumnFamilyOptions.writeBufferSize(), which enforces a limit for a single memtable. This feature is disabled by default. Specify a non-zero value to enable it. Default: 0 (disabled)
    
    Specified by:
    
    dbWriteBufferSize in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the size of the write buffer
  - setAccessHintOnCompactionStart
```
public DBOptions setAccessHintOnCompactionStart(AccessHint accessHint)
```
    Description copied from interface: DBOptionsInterface
    
    Specify the file access pattern once a compaction is started. It will be applied to all input files of a compaction. Default: AccessHint.NORMAL
    
    Specified by:
    
    setAccessHintOnCompactionStart in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    accessHint - The access hint
    
    Returns:
    
    the reference to the current options.
  - accessHintOnCompactionStart
```
public AccessHint accessHintOnCompactionStart()
```
    Description copied from interface: DBOptionsInterface
    
    Specify the file access pattern once a compaction is started. It will be applied to all input files of a compaction. Default: AccessHint.NORMAL
    
    Specified by:
    
    accessHintOnCompactionStart in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    The access hint
  - setCompactionReadaheadSize
```
public DBOptions setCompactionReadaheadSize(long compactionReadaheadSize)
```
    Description copied from interface: MutableDBOptionsInterface
    
    If non-zero, we perform bigger reads when doing compaction. If you're running RocksDB on spinning disks, you should set this to at least 2MB. That way RocksDB's compaction is doing sequential instead of random reads. Default: 0
    
    Specified by:
    
    setCompactionReadaheadSize in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    compactionReadaheadSize - The compaction read-ahead size
    
    Returns:
    
    the reference to the current options.
  - compactionReadaheadSize
```
public long compactionReadaheadSize()
```
    Description copied from interface: MutableDBOptionsInterface
    
    If non-zero, we perform bigger reads when doing compaction. If you're running RocksDB on spinning disks, you should set this to at least 2MB. That way RocksDB's compaction is doing sequential instead of random reads. Default: 0
    
    Specified by:
    
    compactionReadaheadSize in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    The compaction read-ahead size
  - setRandomAccessMaxBufferSize
```
public DBOptions setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize)
```
    Description copied from interface: DBOptionsInterface
    
    This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode. We need to maintain an aligned buffer for reads. We allow the buffer to grow until the specified value and then for bigger requests allocate one shot buffers. In unbuffered mode we always bypass read-ahead buffer at ReadaheadRandomAccessFile When read-ahead is required we then make use of MutableDBOptionsInterface.compactionReadaheadSize() value and always try to read ahead. With read-ahead we always pre-allocate buffer to the size instead of growing it up to a limit. This option is currently honored only on Windows Default: 1 Mb Special value: 0 - means do not maintain per instance buffer. Allocate per request buffer and avoid locking.
    
    Specified by:
    
    setRandomAccessMaxBufferSize in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    randomAccessMaxBufferSize - the maximum size of the random access buffer
    
    Returns:
    
    the reference to the current options.
  - randomAccessMaxBufferSize
```
public long randomAccessMaxBufferSize()
```
    Description copied from interface: DBOptionsInterface
    
    This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode. We need to maintain an aligned buffer for reads. We allow the buffer to grow until the specified value and then for bigger requests allocate one shot buffers. In unbuffered mode we always bypass read-ahead buffer at ReadaheadRandomAccessFile When read-ahead is required we then make use of MutableDBOptionsInterface.compactionReadaheadSize() value and always try to read ahead. With read-ahead we always pre-allocate buffer to the size instead of growing it up to a limit. This option is currently honored only on Windows Default: 1 Mb Special value: 0 - means do not maintain per instance buffer. Allocate per request buffer and avoid locking.
    
    Specified by:
    
    randomAccessMaxBufferSize in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum size of the random access buffer
  - setWritableFileMaxBufferSize
```
public DBOptions setWritableFileMaxBufferSize(long writableFileMaxBufferSize)
```
    Description copied from interface: MutableDBOptionsInterface
    
    This is the maximum buffer size that is used by WritableFileWriter. On Windows, we need to maintain an aligned buffer for writes. We allow the buffer to grow until it's size hits the limit. Default: 1024 * 1024 (1 MB)
    
    Specified by:
    
    setWritableFileMaxBufferSize in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    writableFileMaxBufferSize - the maximum buffer size
    
    Returns:
    
    the reference to the current options.
  - writableFileMaxBufferSize
```
public long writableFileMaxBufferSize()
```
    Description copied from interface: MutableDBOptionsInterface
    
    This is the maximum buffer size that is used by WritableFileWriter. On Windows, we need to maintain an aligned buffer for writes. We allow the buffer to grow until it's size hits the limit. Default: 1024 * 1024 (1 MB)
    
    Specified by:
    
    writableFileMaxBufferSize in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the maximum buffer size
  - setUseAdaptiveMutex
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    useAdaptiveMutex - true if adaptive mutex is used.
    
    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<DBOptions>
    
    Returns:
    
    true if adaptive mutex is used.
  - setBytesPerSync
```
public DBOptions setBytesPerSync(long bytesPerSync)
```
    Description copied from interface: MutableDBOptionsInterface
    
    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 MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    bytesPerSync - size in bytes
    
    Returns:
    
    the instance of the current object.
  - bytesPerSync
```
public long bytesPerSync()
```
    Description copied from interface: MutableDBOptionsInterface
    
    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 MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    size in bytes
  - setWalBytesPerSync
```
public DBOptions setWalBytesPerSync(long walBytesPerSync)
```
    Description copied from interface: MutableDBOptionsInterface
    
    Same as MutableDBOptionsInterface.setBytesPerSync(long) , but applies to WAL files Default: 0, turned off
    
    Specified by:
    
    setWalBytesPerSync in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    walBytesPerSync - size in bytes
    
    Returns:
    
    the instance of the current object.
  - walBytesPerSync
```
public long walBytesPerSync()
```
    Description copied from interface: MutableDBOptionsInterface
    
    Same as MutableDBOptionsInterface.bytesPerSync() , but applies to WAL files Default: 0, turned off
    
    Specified by:
    
    walBytesPerSync in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    size in bytes
  - setStrictBytesPerSync
```
public DBOptions setStrictBytesPerSync(boolean strictBytesPerSync)
```
    Description copied from interface: MutableDBOptionsInterface
    
    When true, guarantees WAL files have at most MutableDBOptionsInterface.walBytesPerSync() bytes submitted for writeback at any given time, and SST files have at most MutableDBOptionsInterface.bytesPerSync() bytes pending writeback at any given time. This can be used to handle cases where processing speed exceeds I/O speed during file generation, which can lead to a huge sync when the file is finished, even with MutableDBOptionsInterface.bytesPerSync() / MutableDBOptionsInterface.walBytesPerSync() properly configured. - If `sync_file_range` is supported it achieves this by waiting for any prior `sync_file_range`s to finish before proceeding. In this way, processing (compression, etc.) can proceed uninhibited in the gap between `sync_file_range`s, and we block only when I/O falls behind. - Otherwise the `WritableFile::Sync` method is used. Note this mechanism always blocks, thus preventing the interleaving of I/O and processing. Note: Enabling this option does not provide any additional persistence guarantees, as it may use `sync_file_range`, which does not write out metadata. Default: false
    
    Specified by:
    
    setStrictBytesPerSync in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    strictBytesPerSync - the bytes per sync
    
    Returns:
    
    the instance of the current object.
  - strictBytesPerSync
```
public boolean strictBytesPerSync()
```
    Description copied from interface: MutableDBOptionsInterface
    
    Return the strict byte limit per sync. See MutableDBOptionsInterface.setStrictBytesPerSync(boolean)
    
    Specified by:
    
    strictBytesPerSync in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the limit in bytes.
  - setListeners
```
public DBOptions setListeners(List<AbstractEventListener> listeners)
```
    Description copied from interface: DBOptionsInterface
    
    Sets the EventListeners whose callback functions will be called when specific RocksDB event happens. Note: the RocksJava API currently only supports EventListeners implemented in Java. It could be extended in future to also support adding/removing EventListeners implemented in C++.
    
    Specified by:
    
    setListeners in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    listeners - the listeners who should be notified on various events.
    
    Returns:
    
    the instance of the current object.
  - listeners
```
public List<AbstractEventListener> listeners()
```
    Description copied from interface: DBOptionsInterface
    
    Sets the EventListeners whose callback functions will be called when specific RocksDB event happens. Note: the RocksJava API currently only supports EventListeners implemented in Java. It could be extended in future to also support adding/removing EventListeners implemented in C++.
    
    Specified by:
    
    listeners in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the instance of the current object.
  - setEnableThreadTracking
```
public DBOptions setEnableThreadTracking(boolean enableThreadTracking)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API. Default: false
    
    Specified by:
    
    setEnableThreadTracking in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    enableThreadTracking - true to enable tracking
    
    Returns:
    
    the reference to the current options.
  - enableThreadTracking
```
public boolean enableThreadTracking()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API. Default: false
    
    Specified by:
    
    enableThreadTracking in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if tracking is enabled
  - setDelayedWriteRate
```
public DBOptions setDelayedWriteRate(long delayedWriteRate)
```
    Description copied from interface: MutableDBOptionsInterface
    
    The limited write rate to DB if ColumnFamilyOptions.softPendingCompactionBytesLimit() or ColumnFamilyOptions.level0SlowdownWritesTrigger() is triggered, or we are writing to the last mem table allowed and we allow more than 3 mem tables. It is calculated using size of user write requests before compression. RocksDB may decide to slow down more if the compaction still gets behind further. If the value is 0, we will infer a value from `rater_limiter` value if it is not empty, or 16MB if `rater_limiter` is empty. Note that if users change the rate in `rate_limiter` after DB is opened, `delayed_write_rate` won't be adjusted. Unit: bytes per second. Default: 0 Dynamically changeable through RocksDB.setDBOptions(MutableDBOptions).
    
    Specified by:
    
    setDelayedWriteRate in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    delayedWriteRate - the rate in bytes per second
    
    Returns:
    
    the reference to the current options.
  - delayedWriteRate
```
public long delayedWriteRate()
```
    Description copied from interface: MutableDBOptionsInterface
    
    The limited write rate to DB if ColumnFamilyOptions.softPendingCompactionBytesLimit() or ColumnFamilyOptions.level0SlowdownWritesTrigger() is triggered, or we are writing to the last mem table allowed and we allow more than 3 mem tables. It is calculated using size of user write requests before compression. RocksDB may decide to slow down more if the compaction still gets behind further. If the value is 0, we will infer a value from `rater_limiter` value if it is not empty, or 16MB if `rater_limiter` is empty. Note that if users change the rate in `rate_limiter` after DB is opened, `delayed_write_rate` won't be adjusted. Unit: bytes per second. Default: 0 Dynamically changeable through RocksDB.setDBOptions(MutableDBOptions).
    
    Specified by:
    
    delayedWriteRate in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    the rate in bytes per second
  - setEnablePipelinedWrite
```
public DBOptions setEnablePipelinedWrite(boolean enablePipelinedWrite)
```
    Description copied from interface: DBOptionsInterface
    
    By default, a single write thread queue is maintained. The thread gets to the head of the queue becomes write batch group leader and responsible for writing to WAL and memtable for the batch group. If DBOptionsInterface.enablePipelinedWrite() is true, separate write thread queue is maintained for WAL write and memtable write. A write thread first enter WAL writer queue and then memtable writer queue. Pending thread on the WAL writer queue thus only have to wait for previous writers to finish their WAL writing but not the memtable writing. Enabling the feature may improve write throughput and reduce latency of the prepare phase of two-phase commit. Default: false
    
    Specified by:
    
    setEnablePipelinedWrite in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    enablePipelinedWrite - true to enabled pipelined writes
    
    Returns:
    
    the reference to the current options.
  - enablePipelinedWrite
```
public boolean enablePipelinedWrite()
```
    Description copied from interface: DBOptionsInterface
    
    Returns true if pipelined writes are enabled. See DBOptionsInterface.setEnablePipelinedWrite(boolean).
    
    Specified by:
    
    enablePipelinedWrite in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if pipelined writes are enabled, false otherwise.
  - setUnorderedWrite
```
public DBOptions setUnorderedWrite(boolean unorderedWrite)
```
    Description copied from interface: DBOptionsInterface
    
    Setting DBOptionsInterface.unorderedWrite() to true trades higher write throughput with relaxing the immutability guarantee of snapshots. This violates the repeatability one expects from ::Get from a snapshot, as well as ::MultiGet and Iterator's consistent-point-in-time view property. If the application cannot tolerate the relaxed guarantees, it can implement its own mechanisms to work around that and yet benefit from the higher throughput. Using TransactionDB with WRITE_PREPARED write policy and DBOptionsInterface.twoWriteQueues() true is one way to achieve immutable snapshots despite unordered_write. By default, i.e., when it is false, rocksdb does not advance the sequence number for new snapshots unless all the writes with lower sequence numbers are already finished. This provides the immutability that we except from snapshots. Moreover, since Iterator and MultiGet internally depend on snapshots, the snapshot immutability results into Iterator and MultiGet offering consistent-point-in-time view. If set to true, although Read-Your-Own-Write property is still provided, the snapshot immutability property is relaxed: the writes issued after the snapshot is obtained (with larger sequence numbers) will be still not visible to the reads from that snapshot, however, there still might be pending writes (with lower sequence number) that will change the state visible to the snapshot after they are landed to the memtable.
    
    Specified by:
    
    setUnorderedWrite in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    unorderedWrite - true to enabled unordered write
    
    Returns:
    
    the reference to the current options.
  - unorderedWrite
```
public boolean unorderedWrite()
```
    Description copied from interface: DBOptionsInterface
    
    Returns true if unordered write are enabled. See DBOptionsInterface.setUnorderedWrite(boolean).
    
    Specified by:
    
    unorderedWrite in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if unordered write are enabled, false otherwise.
  - setAllowConcurrentMemtableWrite
```
public DBOptions 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: true
    
    Specified by:
    
    setAllowConcurrentMemtableWrite in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    allowConcurrentMemtableWrite - true to enable concurrent writes for the memtable
    
    Returns:
    
    the reference to the current options.
  - 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: true
    
    Specified by:
    
    allowConcurrentMemtableWrite in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if concurrent writes are enabled for the memtable
  - setEnableWriteThreadAdaptiveYield
```
public DBOptions 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: true
    
    Specified by:
    
    setEnableWriteThreadAdaptiveYield in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    enableWriteThreadAdaptiveYield - true to enable adaptive yield for the write threads
    
    Returns:
    
    the reference to the current options.
  - 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: true
    
    Specified by:
    
    enableWriteThreadAdaptiveYield in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if adaptive yield is enabled for the writing threads
  - setWriteThreadMaxYieldUsec
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    writeThreadMaxYieldUsec - maximum number of microseconds
    
    Returns:
    
    the reference to the current options.
  - 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<DBOptions>
    
    Returns:
    
    the maximum number of microseconds
  - setWriteThreadSlowYieldUsec
```
public DBOptions 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<DBOptions>
    
    Parameters:
    
    writeThreadSlowYieldUsec - the latency in microseconds
    
    Returns:
    
    the reference to the current options.
  - 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<DBOptions>
    
    Returns:
    
    writeThreadSlowYieldUsec the latency in microseconds
  - setSkipStatsUpdateOnDbOpen
```
public DBOptions setSkipStatsUpdateOnDbOpen(boolean skipStatsUpdateOnDbOpen)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then DB::Open() will not update the statistics used to optimize compaction decision by loading table properties from many files. Turning off this feature will improve DBOpen time especially in disk environment. Default: false
    
    Specified by:
    
    setSkipStatsUpdateOnDbOpen in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    skipStatsUpdateOnDbOpen - true if updating stats will be skipped
    
    Returns:
    
    the reference to the current options.
  - skipStatsUpdateOnDbOpen
```
public boolean skipStatsUpdateOnDbOpen()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then DB::Open() will not update the statistics used to optimize compaction decision by loading table properties from many files. Turning off this feature will improve DBOpen time especially in disk environment. Default: false
    
    Specified by:
    
    skipStatsUpdateOnDbOpen in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if updating stats will be skipped
  - setSkipCheckingSstFileSizesOnDbOpen
```
public DBOptions setSkipCheckingSstFileSizesOnDbOpen(boolean skipCheckingSstFileSizesOnDbOpen)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then RocksDB.open(String) will not fetch and check sizes of all sst files. This may significantly speed up startup if there are many sst files, especially when using non-default Env with expensive GetFileSize(). We'll still check that all required sst files exist. If paranoid_checks is false, this option is ignored, and sst files are not checked at all. Default: false
    
    Specified by:
    
    setSkipCheckingSstFileSizesOnDbOpen in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    skipCheckingSstFileSizesOnDbOpen - if true, then SST file sizes will not be checked when calling RocksDB.open(String).
    
    Returns:
    
    the reference to the current options.
  - skipCheckingSstFileSizesOnDbOpen
```
public boolean skipCheckingSstFileSizesOnDbOpen()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then RocksDB.open(String) will not fetch and check sizes of all sst files. This may significantly speed up startup if there are many sst files, especially when using non-default Env with expensive GetFileSize(). We'll still check that all required sst files exist. If paranoid_checks is false, this option is ignored, and sst files are not checked at all. Default: false
    
    Specified by:
    
    skipCheckingSstFileSizesOnDbOpen in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true, if file sizes will not be checked when calling RocksDB.open(String).
  - setWalRecoveryMode
```
public DBOptions setWalRecoveryMode(WALRecoveryMode walRecoveryMode)
```
    Description copied from interface: DBOptionsInterface
    
    Recovery mode to control the consistency while replaying WAL Default: WALRecoveryMode.PointInTimeRecovery
    
    Specified by:
    
    setWalRecoveryMode in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    walRecoveryMode - The WAL recover mode
    
    Returns:
    
    the reference to the current options.
  - walRecoveryMode
```
public WALRecoveryMode walRecoveryMode()
```
    Description copied from interface: DBOptionsInterface
    
    Recovery mode to control the consistency while replaying WAL Default: WALRecoveryMode.PointInTimeRecovery
    
    Specified by:
    
    walRecoveryMode in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    The WAL recover mode
  - setAllow2pc
```
public DBOptions setAllow2pc(boolean allow2pc)
```
    Description copied from interface: DBOptionsInterface
    
    if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
    
    Specified by:
    
    setAllow2pc in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    allow2pc - true if two-phase-commit is enabled
    
    Returns:
    
    the reference to the current options.
  - allow2pc
```
public boolean allow2pc()
```
    Description copied from interface: DBOptionsInterface
    
    if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
    
    Specified by:
    
    allow2pc in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if two-phase-commit is enabled
  - setRowCache
```
public DBOptions setRowCache(Cache rowCache)
```
    Description copied from interface: DBOptionsInterface
    
    A global cache for table-level rows. Default: null (disabled)
    
    Specified by:
    
    setRowCache in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    rowCache - The global row cache
    
    Returns:
    
    the reference to the current options.
  - rowCache
```
public Cache rowCache()
```
    Description copied from interface: DBOptionsInterface
    
    A global cache for table-level rows. Default: null (disabled)
    
    Specified by:
    
    rowCache in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    The global row cache
  - setWalFilter
```
public DBOptions setWalFilter(AbstractWalFilter walFilter)
```
    Description copied from interface: DBOptionsInterface
    
    A filter object supplied to be invoked while processing write-ahead-logs (WALs) during recovery. The filter provides a way to inspect log records, ignoring a particular record or skipping replay. The filter is invoked at startup and is invoked from a single-thread currently.
    
    Specified by:
    
    setWalFilter in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    walFilter - the filter for processing WALs during recovery.
    
    Returns:
    
    the reference to the current options.
  - walFilter
```
public WalFilter walFilter()
```
    Description copied from interface: DBOptionsInterface
    
    Get's the filter for processing WALs during recovery. See DBOptionsInterface.setWalFilter(AbstractWalFilter).
    
    Specified by:
    
    walFilter in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the filter used for processing WALs during recovery.
  - setFailIfOptionsFileError
```
public DBOptions setFailIfOptionsFileError(boolean failIfOptionsFileError)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted. DEFAULT: false
    
    Specified by:
    
    setFailIfOptionsFileError in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    failIfOptionsFileError - true if we should fail if there is an error in the options file
    
    Returns:
    
    the reference to the current options.
  - failIfOptionsFileError
```
public boolean failIfOptionsFileError()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted. DEFAULT: false
    
    Specified by:
    
    failIfOptionsFileError in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if we should fail if there is an error in the options file
  - setDumpMallocStats
```
public DBOptions setDumpMallocStats(boolean dumpMallocStats)
```
    Description copied from interface: DBOptionsInterface
    
    If true, then print malloc stats together with rocksdb.stats when printing to LOG. DEFAULT: false
    
    Specified by:
    
    setDumpMallocStats in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    dumpMallocStats - true if malloc stats should be printed to LOG
    
    Returns:
    
    the reference to the current options.
  - dumpMallocStats
```
public boolean dumpMallocStats()
```
    Description copied from interface: DBOptionsInterface
    
    If true, then print malloc stats together with rocksdb.stats when printing to LOG. DEFAULT: false
    
    Specified by:
    
    dumpMallocStats in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if malloc stats should be printed to LOG
  - setAvoidFlushDuringRecovery
```
public DBOptions setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery)
```
    Description copied from interface: DBOptionsInterface
    
    By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files. If this option is enabled, RocksDB will try to avoid (but not guarantee not to) flush during recovery. Also, existing WAL logs will be kept, so that if crash happened before flush, we still have logs to recover from. DEFAULT: false
    
    Specified by:
    
    setAvoidFlushDuringRecovery in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    avoidFlushDuringRecovery - true to try to avoid (but not guarantee not to) flush during recovery
    
    Returns:
    
    the reference to the current options.
  - avoidFlushDuringRecovery
```
public boolean avoidFlushDuringRecovery()
```
    Description copied from interface: DBOptionsInterface
    
    By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files. If this option is enabled, RocksDB will try to avoid (but not guarantee not to) flush during recovery. Also, existing WAL logs will be kept, so that if crash happened before flush, we still have logs to recover from. DEFAULT: false
    
    Specified by:
    
    avoidFlushDuringRecovery in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true to try to avoid (but not guarantee not to) flush during recovery
  - setAvoidFlushDuringShutdown
```
public DBOptions setAvoidFlushDuringShutdown(boolean avoidFlushDuringShutdown)
```
    Description copied from interface: MutableDBOptionsInterface
    
    By default RocksDB will flush all memtables on DB close if there are unpersisted data (i.e. with WAL disabled) The flush can be skip to speedup DB close. Unpersisted data WILL BE LOST. DEFAULT: false Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions) API.
    
    Specified by:
    
    setAvoidFlushDuringShutdown in interface MutableDBOptionsInterface<DBOptions>
    
    Parameters:
    
    avoidFlushDuringShutdown - true if we should avoid flush during shutdown
    
    Returns:
    
    the reference to the current options.
  - avoidFlushDuringShutdown
```
public boolean avoidFlushDuringShutdown()
```
    Description copied from interface: MutableDBOptionsInterface
    
    By default RocksDB will flush all memtables on DB close if there are unpersisted data (i.e. with WAL disabled) The flush can be skip to speedup DB close. Unpersisted data WILL BE LOST. DEFAULT: false Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions) API.
    
    Specified by:
    
    avoidFlushDuringShutdown in interface MutableDBOptionsInterface<DBOptions>
    
    Returns:
    
    true if we should avoid flush during shutdown
  - setAllowIngestBehind
```
public DBOptions setAllowIngestBehind(boolean allowIngestBehind)
```
    Description copied from interface: DBOptionsInterface
    
    Set this option to true during creation of database if you want to be able to ingest behind (call IngestExternalFile() skipping keys that already exist, rather than overwriting matching keys). Setting this option to true will affect 2 things: 1) Disable some internal optimizations around SST file compression 2) Reserve bottom-most level for ingested files only. 3) Note that num_levels should be >= 3 if this option is turned on. DEFAULT: false
    
    Specified by:
    
    setAllowIngestBehind in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    allowIngestBehind - true to allow ingest behind, false to disallow.
    
    Returns:
    
    the reference to the current options.
  - allowIngestBehind
```
public boolean allowIngestBehind()
```
    Description copied from interface: DBOptionsInterface
    
    Returns true if ingest behind is allowed. See DBOptionsInterface.setAllowIngestBehind(boolean).
    
    Specified by:
    
    allowIngestBehind in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if ingest behind is allowed, false otherwise.
  - setTwoWriteQueues
```
public DBOptions setTwoWriteQueues(boolean twoWriteQueues)
```
    Description copied from interface: DBOptionsInterface
    
    If enabled it uses two queues for writes, one for the ones with disable_memtable and one for the ones that also write to memtable. This allows the memtable writes not to lag behind other writes. It can be used to optimize MySQL 2PC in which only the commits, which are serial, write to memtable. DEFAULT: false
    
    Specified by:
    
    setTwoWriteQueues in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    twoWriteQueues - true to enable two write queues, false otherwise.
    
    Returns:
    
    the reference to the current options.
  - twoWriteQueues
```
public boolean twoWriteQueues()
```
    Description copied from interface: DBOptionsInterface
    
    Returns true if two write queues are enabled.
    
    Specified by:
    
    twoWriteQueues in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if two write queues are enabled, false otherwise.
  - setManualWalFlush
```
public DBOptions setManualWalFlush(boolean manualWalFlush)
```
    Description copied from interface: DBOptionsInterface
    
    If true WAL is not flushed automatically after each write. Instead it relies on manual invocation of FlushWAL to write the WAL buffer to its file. DEFAULT: false
    
    Specified by:
    
    setManualWalFlush in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    manualWalFlush - true to set disable automatic WAL flushing, false otherwise.
    
    Returns:
    
    the reference to the current options.
  - manualWalFlush
```
public boolean manualWalFlush()
```
    Description copied from interface: DBOptionsInterface
    
    Returns true if automatic WAL flushing is disabled. See DBOptionsInterface.setManualWalFlush(boolean).
    
    Specified by:
    
    manualWalFlush in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if automatic WAL flushing is disabled, false otherwise.
  - setAtomicFlush
```
public DBOptions setAtomicFlush(boolean atomicFlush)
```
    Description copied from interface: DBOptionsInterface
    
    If true, RocksDB supports flushing multiple column families and committing their results atomically to MANIFEST. Note that it is not necessary to set atomic_flush to true if WAL is always enabled since WAL allows the database to be restored to the last persistent state in WAL. This option is useful when there are column families with writes NOT protected by WAL. For manual flush, application has to specify which column families to flush atomically in RocksDB.flush(FlushOptions, List). For auto-triggered flush, RocksDB atomically flushes ALL column families. Currently, any WAL-enabled writes after atomic flush may be replayed independently if the process crashes later and tries to recover.
    
    Specified by:
    
    setAtomicFlush in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    atomicFlush - true to enable atomic flush of multiple column families.
    
    Returns:
    
    the reference to the current options.
  - atomicFlush
```
public boolean atomicFlush()
```
    Description copied from interface: DBOptionsInterface
    
    Determine if atomic flush of multiple column families is enabled. See DBOptionsInterface.setAtomicFlush(boolean).
    
    Specified by:
    
    atomicFlush in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if atomic flush is enabled.
  - setAvoidUnnecessaryBlockingIO
```
public DBOptions setAvoidUnnecessaryBlockingIO(boolean avoidUnnecessaryBlockingIO)
```
    Description copied from interface: DBOptionsInterface
    
    If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it. Use it if you're latency-sensitive. If set to true, takes precedence over ReadOptions.setBackgroundPurgeOnIteratorCleanup(boolean).
    
    Specified by:
    
    setAvoidUnnecessaryBlockingIO in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    avoidUnnecessaryBlockingIO - If true, working thread may avoid doing unnecessary operation.
    
    Returns:
    
    the reference to the current options.
  - avoidUnnecessaryBlockingIO
```
public boolean avoidUnnecessaryBlockingIO()
```
    Description copied from interface: DBOptionsInterface
    
    If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it. Use it if you're latency-sensitive. If set to true, takes precedence over ReadOptions.setBackgroundPurgeOnIteratorCleanup(boolean).
    
    Specified by:
    
    avoidUnnecessaryBlockingIO in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true, if working thread may avoid doing unnecessary operation.
  - setPersistStatsToDisk
```
public DBOptions setPersistStatsToDisk(boolean persistStatsToDisk)
```
    Description copied from interface: DBOptionsInterface
    
    If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct. User can query through `GetStatsHistory` API. If user attempts to create a column family with the same name on a DB which have previously set persist_stats_to_disk to true, the column family creation will fail, but the hidden column family will survive, as well as the previously persisted statistics. When peristing stats to disk, the stat name will be limited at 100 bytes. Default: false
    
    Specified by:
    
    setPersistStatsToDisk in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    persistStatsToDisk - true if stats should be persisted to hidden column family.
    
    Returns:
    
    the instance of the current object.
  - persistStatsToDisk
```
public boolean persistStatsToDisk()
```
    Description copied from interface: DBOptionsInterface
    
    If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct. User can query through `GetStatsHistory` API. If user attempts to create a column family with the same name on a DB which have previously set persist_stats_to_disk to true, the column family creation will fail, but the hidden column family will survive, as well as the previously persisted statistics. When peristing stats to disk, the stat name will be limited at 100 bytes. Default: false
    
    Specified by:
    
    persistStatsToDisk in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true if stats should be persisted to hidden column family.
  - setWriteDbidToManifest
```
public DBOptions setWriteDbidToManifest(boolean writeDbidToManifest)
```
    Description copied from interface: DBOptionsInterface
    
    Historically DB ID has always been stored in Identity File in DB folder. If this flag is true, the DB ID is written to Manifest file in addition to the Identity file. By doing this 2 problems are solved 1. We don't checksum the Identity file where as Manifest file is. 2. Since the source of truth for DB is Manifest file DB ID will sit with the source of truth. Previously the Identity file could be copied independent of Manifest and that can result in wrong DB ID. We recommend setting this flag to true. Default: false
    
    Specified by:
    
    setWriteDbidToManifest in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    writeDbidToManifest - if true, then DB ID will be written to Manifest file.
    
    Returns:
    
    the instance of the current object.
  - writeDbidToManifest
```
public boolean writeDbidToManifest()
```
    Description copied from interface: DBOptionsInterface
    
    Historically DB ID has always been stored in Identity File in DB folder. If this flag is true, the DB ID is written to Manifest file in addition to the Identity file. By doing this 2 problems are solved 1. We don't checksum the Identity file where as Manifest file is. 2. Since the source of truth for DB is Manifest file DB ID will sit with the source of truth. Previously the Identity file could be copied independent of Manifest and that can result in wrong DB ID. We recommend setting this flag to true. Default: false
    
    Specified by:
    
    writeDbidToManifest in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true, if DB ID will be written to Manifest file.
  - setLogReadaheadSize
```
public DBOptions setLogReadaheadSize(long logReadaheadSize)
```
    Description copied from interface: DBOptionsInterface
    
    The number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0, then the prefetching is disabled. Default: 0
    
    Specified by:
    
    setLogReadaheadSize in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    logReadaheadSize - the number of bytes to prefetch when reading the log.
    
    Returns:
    
    the instance of the current object.
  - logReadaheadSize
```
public long logReadaheadSize()
```
    Description copied from interface: DBOptionsInterface
    
    The number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0, then the prefetching is disabled. Default: 0
    
    Specified by:
    
    logReadaheadSize in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the number of bytes to prefetch when reading the log.
  - setBestEffortsRecovery
```
public DBOptions setBestEffortsRecovery(boolean bestEffortsRecovery)
```
    Description copied from interface: DBOptionsInterface
    
    By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST. Best-efforts recovery is another recovery mode that tries to restore the database to the most recent point in time without missing file. Currently not compatible with atomic flush. Furthermore, WAL files will not be used for recovery if best_efforts_recovery is true. Default: false
    
    Specified by:
    
    setBestEffortsRecovery in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    bestEffortsRecovery - if true, RocksDB will use best-efforts mode when recovering.
    
    Returns:
    
    the instance of the current object.
  - bestEffortsRecovery
```
public boolean bestEffortsRecovery()
```
    Description copied from interface: DBOptionsInterface
    
    By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST. Best-efforts recovery is another recovery mode that tries to restore the database to the most recent point in time without missing file. Currently not compatible with atomic flush. Furthermore, WAL files will not be used for recovery if best_efforts_recovery is true. Default: false
    
    Specified by:
    
    bestEffortsRecovery in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    true, if RocksDB uses best-efforts mode when recovering.
  - setMaxBgErrorResumeCount
```
public DBOptions setMaxBgErrorResumeCount(int maxBgerrorResumeCount)
```
    Description copied from interface: DBOptionsInterface
    
    It defines how many times db resume is called by a separate thread when background retryable IO Error happens. When background retryable IO Error happens, SetBGError is called to deal with the error. If the error can be auto-recovered (e.g., retryable IO Error during Flush or WAL write), then db resume is called in background to recover from the error. If this value is 0 or negative, db resume will not be called. Default: INT_MAX
    
    Specified by:
    
    setMaxBgErrorResumeCount in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    maxBgerrorResumeCount - maximum number of times db resume should be called when IO Error happens.
    
    Returns:
    
    the instance of the current object.
  - maxBgerrorResumeCount
```
public int maxBgerrorResumeCount()
```
    Description copied from interface: DBOptionsInterface
    
    It defines how many times db resume is called by a separate thread when background retryable IO Error happens. When background retryable IO Error happens, SetBGError is called to deal with the error. If the error can be auto-recovered (e.g., retryable IO Error during Flush or WAL write), then db resume is called in background to recover from the error. If this value is 0 or negative, db resume will not be called. Default: INT_MAX
    
    Specified by:
    
    maxBgerrorResumeCount in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    maximum number of times db resume should be called when IO Error happens.
  - setBgerrorResumeRetryInterval
```
public DBOptions setBgerrorResumeRetryInterval(long bgerrorResumeRetryInterval)
```
    Description copied from interface: DBOptionsInterface
    
    If max_bgerror_resume_count is ≥ 2, db resume is called multiple times. This option decides how long to wait to retry the next resume if the previous resume fails and satisfy redo resume conditions. Default: 1000000 (microseconds).
    
    Specified by:
    
    setBgerrorResumeRetryInterval in interface DBOptionsInterface<DBOptions>
    
    Parameters:
    
    bgerrorResumeRetryInterval - how many microseconds to wait between DB resume attempts.
    
    Returns:
    
    the instance of the current object.
  - bgerrorResumeRetryInterval
```
public long bgerrorResumeRetryInterval()
```
    Description copied from interface: DBOptionsInterface
    
    If max_bgerror_resume_count is ≥ 2, db resume is called multiple times. This option decides how long to wait to retry the next resume if the previous resume fails and satisfy redo resume conditions. Default: 1000000 (microseconds).
    
    Specified by:
    
    bgerrorResumeRetryInterval in interface DBOptionsInterface<DBOptions>
    
    Returns:
    
    the instance of the current object.
  - disposeInternal
```
protected final void disposeInternal(long handle)
```
    Specified by:
    
    disposeInternal in class RocksObject

Class DBOptions

Field Summary

Fields inherited from class org.rocksdb.RocksObject

Fields inherited from class org.rocksdb.AbstractImmutableNativeReference

Constructor Summary

Method Summary

Methods inherited from class org.rocksdb.RocksObject

Methods inherited from class org.rocksdb.AbstractImmutableNativeReference

Methods inherited from class java.lang.Object

Constructor Detail

DBOptions

DBOptions

DBOptions

Method Detail

getDBOptionsFromProps

getDBOptionsFromProps

optimizeForSmallDb

setIncreaseParallelism

setCreateIfMissing

createIfMissing

setCreateMissingColumnFamilies

createMissingColumnFamilies

setErrorIfExists

errorIfExists

setParanoidChecks

paranoidChecks

setEnv

getEnv

setRateLimiter

setSstFileManager

setLogger

setInfoLogLevel

infoLogLevel

setMaxOpenFiles

maxOpenFiles

setMaxFileOpeningThreads

maxFileOpeningThreads

setMaxTotalWalSize

maxTotalWalSize

setStatistics

statistics

setUseFsync

useFsync

setDbPaths

dbPaths

setDbLogDir

dbLogDir

setWalDir

walDir

setDeleteObsoleteFilesPeriodMicros

deleteObsoleteFilesPeriodMicros

setMaxBackgroundJobs

maxBackgroundJobs

setMaxBackgroundCompactions

maxBackgroundCompactions

setMaxSubcompactions

maxSubcompactions

setMaxBackgroundFlushes

maxBackgroundFlushes

setMaxLogFileSize

maxLogFileSize

setLogFileTimeToRoll

logFileTimeToRoll

setKeepLogFileNum

keepLogFileNum

setRecycleLogFileNum

recycleLogFileNum

setMaxManifestFileSize

maxManifestFileSize

setTableCacheNumshardbits

tableCacheNumshardbits

setWalTtlSeconds

walTtlSeconds

setWalSizeLimitMB

walSizeLimitMB

setMaxWriteBatchGroupSizeBytes

maxWriteBatchGroupSizeBytes

setManifestPreallocationSize

manifestPreallocationSize

setAllowMmapReads