DBOptionsInterface

All Known Implementing Classes:: DBOptions, Options

public interface DBOptionsInterface<T extends DBOptionsInterface>

Method Summary

All Methods Instance Methods Abstract 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`	`allowMmapReads()` Allow the OS to mmap file for reading sst tables.
`boolean`	`allowMmapWrites()` Allow the OS to mmap file for writing.
`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.
`int`	`baseBackgroundCompactions()` Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`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.
`java.lang.String`	`dbLogDir()` Returns the directory of info log.
`java.util.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.
`boolean`	`dumpMallocStats()` If true, then print malloc stats together with rocksdb.stats when printing to LOG.
`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 `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.
`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.
`long`	`logFileTimeToRoll()` Returns the time interval for the info log file to roll (in seconds).
`long`	`manifestPreallocationSize()` Number of bytes to preallocate (via fallocate) the manifest files.
`int`	`maxBackgroundCompactions()` Deprecated. Use `setMaxBackgroundJobs(int)`
`int`	`maxBackgroundFlushes()` Returns the maximum number of concurrent background flush jobs.
`int`	`maxBackgroundJobs()` Returns the maximum number of concurrent background jobs (both flushes and compactions combined).
`int`	`maxFileOpeningThreads()` If `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 wal size.
`boolean`	`newTableReaderForCompactionInputs()` If true, always create a new file descriptor and new table reader for compaction inputs.
`T`	`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.
`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.
`T`	`setAccessHintOnCompactionStart(AccessHint accessHint)` Specify the file access pattern once a compaction is started.
`T`	`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.
`T`	`setAllow2pc(boolean allow2pc)` if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
`T`	`setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)` If true, allow multi-writers to update mem tables in parallel.
`T`	`setAllowFAllocate(boolean allowFAllocate)` Whether fallocate calls are allowed
`T`	`setAllowMmapReads(boolean allowMmapReads)` Allow the OS to mmap file for reading sst tables.
`T`	`setAllowMmapWrites(boolean allowMmapWrites)` Allow the OS to mmap file for writing.
`T`	`setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery)` By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files.
`T`	`setAvoidFlushDuringShutdown(boolean avoidFlushDuringShutdown)` By default RocksDB will flush all memtables on DB close if there are unpersisted data (i.e.
`void`	`setBaseBackgroundCompactions(int baseBackgroundCompactions)` Deprecated. Use `setMaxBackgroundJobs(int)`
`T`	`setBytesPerSync(long bytesPerSync)` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`T`	`setCompactionReadaheadSize(long compactionReadaheadSize)` If non-zero, we perform bigger reads when doing compaction.
`T`	`setCreateIfMissing(boolean flag)` If this value is set to true, then the database will be created if it is missing during `RocksDB.open()`.
`T`	`setCreateMissingColumnFamilies(boolean flag)` If true, missing column families will be automatically created
`T`	`setDbLogDir(java.lang.String dbLogDir)` This specifies the info LOG dir.
`T`	`setDbPaths(java.util.Collection<DbPath> dbPaths)` A list of paths where SST files can be put into, with its target size.
`T`	`setDbWriteBufferSize(long dbWriteBufferSize)` Amount of data to build up in memtables across all column families before writing to disk.
`T`	`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.
`T`	`setDeleteObsoleteFilesPeriodMicros(long micros)` The periodicity when obsolete files get deleted.
`T`	`setDumpMallocStats(boolean dumpMallocStats)` If true, then print malloc stats together with rocksdb.stats when printing to LOG.
`T`	`setEnableThreadTracking(boolean enableThreadTracking)` If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API.
`T`	`setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)` If true, threads synchronizing with the write batch group leader will wait for up to `writeThreadMaxYieldUsec()` before blocking on a mutex.
`T`	`setEnv(Env env)` Use the specified object to interact with the environment, e.g.
`T`	`setErrorIfExists(boolean errorIfExists)` If true, an error will be thrown during RocksDB.open() if the database already exists.
`T`	`setFailIfOptionsFileError(boolean failIfOptionsFileError)` If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted.
`T`	`setIncreaseParallelism(int totalThreads)` By default, RocksDB uses only one background thread for flush and compaction.
`T`	`setInfoLogLevel(InfoLogLevel infoLogLevel)` Sets the RocksDB log level.
`T`	`setIsFdCloseOnExec(boolean isFdCloseOnExec)` Disable child process inherit open files.
`T`	`setKeepLogFileNum(long keepLogFileNum)` Specifies the maximum number of info log files to be kept.
`T`	`setLogFileTimeToRoll(long logFileTimeToRoll)` Specifies the time interval for the info log file to roll (in seconds).
`T`	`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.
`T`	`setManifestPreallocationSize(long size)` Number of bytes to preallocate (via fallocate) the manifest files.
`T`	`setMaxBackgroundCompactions(int maxBackgroundCompactions)` Specifies the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`T`	`setMaxBackgroundFlushes(int maxBackgroundFlushes)` Deprecated. Use `setMaxBackgroundJobs(int)`
`T`	`setMaxBackgroundJobs(int maxBackgroundJobs)` Specifies the maximum number of concurrent background jobs (both flushes and compactions combined).
`T`	`setMaxFileOpeningThreads(int maxFileOpeningThreads)` If `maxOpenFiles()` is -1, DB will open all files on DB::Open().
`T`	`setMaxLogFileSize(long maxLogFileSize)` Specifies the maximum size of a info log file.
`T`	`setMaxManifestFileSize(long maxManifestFileSize)` Manifest file is rolled over on reaching this limit.
`T`	`setMaxOpenFiles(int maxOpenFiles)` Number of open files that can be used by the DB.
`void`	`setMaxSubcompactions(int maxSubcompactions)` This value represents the maximum number of threads that will concurrently perform a compaction job by breaking it into multiple, smaller ones that are run simultaneously.
`T`	`setMaxTotalWalSize(long maxTotalWalSize)` Once write-ahead logs exceed this size, we will start forcing the flush of column families whose memtables are backed by the oldest live WAL file (i.e.
`T`	`setNewTableReaderForCompactionInputs(boolean newTableReaderForCompactionInputs)` If true, always create a new file descriptor and new table reader for compaction inputs.
`T`	`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.
`T`	`setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize)` This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode.
`T`	`setRateLimiter(RateLimiter rateLimiter)` Use to control write rate of flush and compaction.
`T`	`setRecycleLogFileNum(long recycleLogFileNum)` Recycle log files.
`T`	`setRowCache(Cache rowCache)` A global cache for table-level rows.
`T`	`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.
`T`	`setStatistics(Statistics statistics)` Sets the statistics object which collects metrics about database operations.
`T`	`setStatsDumpPeriodSec(int statsDumpPeriodSec)` if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
`T`	`setTableCacheNumshardbits(int tableCacheNumshardbits)` Number of shards used for table cache.
`T`	`setUseAdaptiveMutex(boolean useAdaptiveMutex)` Use adaptive mutex, which spins in the user space before resorting to kernel.
`T`	`setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction)` Enable the OS to use direct reads and writes in flush and compaction Default: false
`T`	`setUseDirectReads(boolean useDirectReads)` Enable the OS to use direct I/O for reading sst tables.
`T`	`setUseFsync(boolean useFsync)` If true, then every store to stable storage will issue a fsync.
`T`	`setWalBytesPerSync(long walBytesPerSync)` Same as `setBytesPerSync(long)` , but applies to WAL files Default: 0, turned off
`T`	`setWalDir(java.lang.String walDir)` This specifies the absolute dir path for write-ahead logs (WAL).
`T`	`setWalRecoveryMode(WALRecoveryMode walRecoveryMode)` Recovery mode to control the consistency while replaying WAL Default: `WALRecoveryMode.PointInTimeRecovery`
`T`	`setWalSizeLimitMB(long sizeLimitMB)` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`T`	`setWalTtlSeconds(long walTtlSeconds)` `walTtlSeconds()` and `walSizeLimitMB()` affect how archived logs will be deleted.
`T`	`setWritableFileMaxBufferSize(long writableFileMaxBufferSize)` This is the maximum buffer size that is used by WritableFileWriter.
`T`	`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.
`T`	`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`	`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)
`int`	`tableCacheNumshardbits()` Number of shards used for table cache.
`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 `bytesPerSync()` , but applies to WAL files Default: 0, turned off
`java.lang.String`	`walDir()` Returns the path to the write-ahead-logs (WAL) directory.
`WALRecoveryMode`	`walRecoveryMode()` Recovery mode to control the consistency while replaying WAL Default: `WALRecoveryMode.PointInTimeRecovery`
`long`	`walSizeLimitMB()` `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.
`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.

- Method Detail
  - optimizeForSmallDb
```
T optimizeForSmallDb()
```
    Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
    
    Returns:
    
    the instance of the current object.
  - setEnv
```
T setEnv(Env env)
```
    Use the specified object to interact with the environment, e.g. to read/write files, schedule background work, etc. Default: Env.getDefault()
    
    Parameters:
    
    env - Env instance.
    
    Returns:
    
    the instance of the current Options.
  - getEnv
```
Env getEnv()
```
    Returns the set RocksEnv instance.
    
    Returns:
    
    RocksEnv instance set in the options.
  - setIncreaseParallelism
```
T setIncreaseParallelism(int totalThreads)
```
    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.
    
    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
```
T setCreateIfMissing(boolean flag)
```
    If this value is set to true, then the database will be created if it is missing during RocksDB.open(). Default: false
    
    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
```
boolean createIfMissing()
```
    Return true if the create_if_missing flag is set to true. If true, the database will be created if it is missing.
    
    Returns:
    
    true if the createIfMissing option is set to true.
    
    See Also:
    
    setCreateIfMissing(boolean)
  - setCreateMissingColumnFamilies
```
T setCreateMissingColumnFamilies(boolean flag)
```
    If true, missing column families will be automatically created
    
    Default: false
    
    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
```
boolean createMissingColumnFamilies()
```
    Return true if the create_missing_column_families flag is set to true. If true column families be created if missing.
    
    Returns:
    
    true if the createMissingColumnFamilies is set to true.
    
    See Also:
    
    setCreateMissingColumnFamilies(boolean)
  - setErrorIfExists
```
T setErrorIfExists(boolean errorIfExists)
```
    If true, an error will be thrown during RocksDB.open() if the database already exists. Default: false
    
    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
```
boolean errorIfExists()
```
    If true, an error will be thrown during RocksDB.open() if the database already exists.
    
    Returns:
    
    if true, an error is raised when the specified database already exists before open.
  - setParanoidChecks
```
T 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. 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
    
    Parameters:
    
    paranoidChecks - a flag to indicate whether paranoid-check is on.
    
    Returns:
    
    the reference to the current option.
  - paranoidChecks
```
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. 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.
    
    Returns:
    
    a boolean indicating whether paranoid-check is on.
  - setRateLimiter
```
T setRateLimiter(RateLimiter rateLimiter)
```
    Use to control write rate of flush and compaction. Flush has higher priority than compaction. Rate limiting is disabled if nullptr. Default: nullptr
    
    Parameters:
    
    rateLimiter - RateLimiter instance.
    
    Returns:
    
    the instance of the current object.
    
    Since:
    
    3.10.0
  - setLogger
```
T 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.
    
    Default: nullptr
    
    Parameters:
    
    logger - Logger instance.
    
    Returns:
    
    the instance of the current object.
  - setInfoLogLevel
```
T setInfoLogLevel(InfoLogLevel infoLogLevel)
```
    Sets the RocksDB log level. Default level is INFO
    
    Parameters:
    
    infoLogLevel - log level to set.
    
    Returns:
    
    the instance of the current object.
  - infoLogLevel
```
InfoLogLevel infoLogLevel()
```
    Returns currently set log level.
    
    Returns:
    
    InfoLogLevel instance.
  - setMaxOpenFiles
```
T setMaxOpenFiles(int maxOpenFiles)
```
    Number of open files that can be used by the DB. You may need to increase this if your database has a large working set. Value -1 means files opened are always kept open. You can estimate number of files based on target_file_size_base and target_file_size_multiplier for level-based compaction. For universal-style compaction, you can usually set it to -1. Default: 5000
    
    Parameters:
    
    maxOpenFiles - the maximum number of open files.
    
    Returns:
    
    the instance of the current object.
  - maxOpenFiles
```
int maxOpenFiles()
```
    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.
    
    Returns:
    
    the maximum number of open files.
  - setMaxFileOpeningThreads
```
T setMaxFileOpeningThreads(int maxFileOpeningThreads)
```
    If 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
    
    Parameters:
    
    maxFileOpeningThreads - the maximum number of threads to use to open files
    
    Returns:
    
    the reference to the current options.
  - maxFileOpeningThreads
```
int maxFileOpeningThreads()
```
    If 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
    
    Returns:
    
    the maximum number of threads to use to open files
  - setMaxTotalWalSize
```
T setMaxTotalWalSize(long maxTotalWalSize)
```
    Once write-ahead logs exceed this size, we will start forcing the flush of column families whose memtables are backed by the oldest live WAL file (i.e. the ones that are causing all the space amplification).
    
    If set to 0 (default), we will dynamically choose the WAL size limit to be [sum of all write_buffer_size * max_write_buffer_number] * 2
    
    Default: 0
    
    Parameters:
    
    maxTotalWalSize - max total wal size.
    
    Returns:
    
    the instance of the current object.
  - maxTotalWalSize
```
long maxTotalWalSize()
```
    Returns the max total wal size. Once write-ahead logs exceed this size, we will start forcing the flush of column families whose memtables are backed by the oldest live WAL file (i.e. the ones that are causing all the space amplification).
    
    If set to 0 (default), we will dynamically choose the WAL size limit to be [sum of all write_buffer_size * max_write_buffer_number] * 2
    
    Returns:
    
    max total wal size
  - setStatistics
```
T setStatistics(Statistics statistics)
```
    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.
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    RocksDB.open(org.rocksdb.Options, String)
  - statistics
```
Statistics statistics()
```
    Returns statistics object.
    
    Returns:
    
    the instance of the statistics object or null if there is no statistics object.
    
    See Also:
    
    setStatistics(Statistics)
  - setUseFsync
```
T setUseFsync(boolean useFsync)
```
    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
    
    Parameters:
    
    useFsync - a boolean flag to specify whether to use fsync
    
    Returns:
    
    the instance of the current object.
  - useFsync
```
boolean useFsync()
```
    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.
    
    Returns:
    
    boolean value indicating if fsync is used.
  - setDbPaths
```
T setDbPaths(java.util.Collection<DbPath> dbPaths)
```
    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
    
    Parameters:
    
    dbPaths - the paths and target sizes
    
    Returns:
    
    the reference to the current options
  - dbPaths
```
java.util.List<DbPath> dbPaths()
```
    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()
    
    Returns:
    
    dbPaths the paths and target sizes
  - setDbLogDir
```
T setDbLogDir(java.lang.String dbLogDir)
```
    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.
    
    Parameters:
    
    dbLogDir - the path to the info log directory
    
    Returns:
    
    the instance of the current object.
  - dbLogDir
```
java.lang.String dbLogDir()
```
    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.
    
    Returns:
    
    the path to the info log directory
  - setWalDir
```
T setWalDir(java.lang.String walDir)
```
    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
    
    Parameters:
    
    walDir - the path to the write-ahead-log directory.
    
    Returns:
    
    the instance of the current object.
  - walDir
```
java.lang.String walDir()
```
    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
    
    Returns:
    
    the path to the write-ahead-logs (WAL) directory.
  - setDeleteObsoleteFilesPeriodMicros
```
T setDeleteObsoleteFilesPeriodMicros(long micros)
```
    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
    
    Parameters:
    
    micros - the time interval in micros
    
    Returns:
    
    the instance of the current object.
  - deleteObsoleteFilesPeriodMicros
```
long deleteObsoleteFilesPeriodMicros()
```
    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
    
    Returns:
    
    the time interval in micros when obsolete files will be deleted.
  - setBaseBackgroundCompactions
```
void setBaseBackgroundCompactions(int baseBackgroundCompactions)
```
    Deprecated. Use setMaxBackgroundJobs(int)
    
    Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool. Default: 1
    
    Parameters:
    
    baseBackgroundCompactions - Suggested number of background compaction jobs
  - baseBackgroundCompactions
```
int baseBackgroundCompactions()
```
    Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool. Default: 1
    
    Returns:
    
    Suggested number of background compaction jobs
  - setMaxBackgroundCompactions
```
T setMaxBackgroundCompactions(int maxBackgroundCompactions)
```
    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
    
    Parameters:
    
    maxBackgroundCompactions - the maximum number of background compaction jobs.
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int), maxBackgroundFlushes()
  - maxBackgroundCompactions
```
int maxBackgroundCompactions()
```
    Deprecated. Use setMaxBackgroundJobs(int)
    
    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
    
    Returns:
    
    the maximum number of concurrent background compaction jobs.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int)
  - setMaxSubcompactions
```
void setMaxSubcompactions(int maxSubcompactions)
```
    This value represents the maximum number of threads that will concurrently perform a compaction job by breaking it into multiple, smaller ones that are run simultaneously. Default: 1 (i.e. no subcompactions)
    
    Parameters:
    
    maxSubcompactions - The maximum number of threads that will concurrently perform a compaction job
  - maxSubcompactions
```
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. Default: 1 (i.e. no subcompactions)
    
    Returns:
    
    The maximum number of threads that will concurrently perform a compaction job
  - setMaxBackgroundFlushes
```
T setMaxBackgroundFlushes(int maxBackgroundFlushes)
```
    Deprecated. Use setMaxBackgroundJobs(int)
    
    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
    
    Parameters:
    
    maxBackgroundFlushes - number of max concurrent flush jobs
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int), maxBackgroundCompactions()
  - maxBackgroundFlushes
```
int maxBackgroundFlushes()
```
    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
    
    Returns:
    
    the maximum number of concurrent background flush jobs.
    
    See Also:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, int)
  - setMaxBackgroundJobs
```
T setMaxBackgroundJobs(int maxBackgroundJobs)
```
    Specifies the maximum number of concurrent background jobs (both flushes and compactions combined). Default: 2
    
    Parameters:
    
    maxBackgroundJobs - number of max concurrent background jobs
    
    Returns:
    
    the instance of the current object.
  - maxBackgroundJobs
```
int maxBackgroundJobs()
```
    Returns the maximum number of concurrent background jobs (both flushes and compactions combined). Default: 2
    
    Returns:
    
    the maximum number of concurrent background jobs.
  - setMaxLogFileSize
```
T setMaxLogFileSize(long maxLogFileSize)
```
    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.
    
    Parameters:
    
    maxLogFileSize - the maximum size of a info log file.
    
    Returns:
    
    the instance of the current object.
    
    Throws:
    
    java.lang.IllegalArgumentException - thrown on 32-Bit platforms while overflowing the underlying platform specific value.
  - maxLogFileSize
```
long maxLogFileSize()
```
    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.
    
    Returns:
    
    the maximum size of the info log file.
  - setLogFileTimeToRoll
```
T setLogFileTimeToRoll(long logFileTimeToRoll)
```
    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)
    
    Parameters:
    
    logFileTimeToRoll - the time interval in seconds.
    
    Returns:
    
    the instance of the current object.
    
    Throws:
    
    java.lang.IllegalArgumentException - thrown on 32-Bit platforms while overflowing the underlying platform specific value.
  - logFileTimeToRoll
```
long logFileTimeToRoll()
```
    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)
    
    Returns:
    
    the time interval in seconds.
  - setKeepLogFileNum
```
T setKeepLogFileNum(long keepLogFileNum)
```
    Specifies the maximum number of info log files to be kept. Default: 1000
    
    Parameters:
    
    keepLogFileNum - the maximum number of info log files to be kept.
    
    Returns:
    
    the instance of the current object.
    
    Throws:
    
    java.lang.IllegalArgumentException - thrown on 32-Bit platforms while overflowing the underlying platform specific value.
  - keepLogFileNum
```
long keepLogFileNum()
```
    Returns the maximum number of info log files to be kept. Default: 1000
    
    Returns:
    
    the maximum number of info log files to be kept.
  - setRecycleLogFileNum
```
T setRecycleLogFileNum(long recycleLogFileNum)
```
    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
    
    Parameters:
    
    recycleLogFileNum - the number of log files to keep for recycling
    
    Returns:
    
    the reference to the current options
  - recycleLogFileNum
```
long recycleLogFileNum()
```
    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
    
    Returns:
    
    the number of log files kept for recycling
  - setMaxManifestFileSize
```
T setMaxManifestFileSize(long maxManifestFileSize)
```
    Manifest file is rolled over on reaching this limit. The older manifest file be deleted. The default value is MAX_INT so that roll-over does not take place.
    
    Parameters:
    
    maxManifestFileSize - the size limit of a manifest file.
    
    Returns:
    
    the instance of the current object.
  - maxManifestFileSize
```
long maxManifestFileSize()
```
    Manifest file is rolled over on reaching this limit. The older manifest file be deleted. The default value is MAX_INT so that roll-over does not take place.
    
    Returns:
    
    the size limit of a manifest file.
  - setTableCacheNumshardbits
```
T setTableCacheNumshardbits(int tableCacheNumshardbits)
```
    Number of shards used for table cache.
    
    Parameters:
    
    tableCacheNumshardbits - the number of chards
    
    Returns:
    
    the instance of the current object.
  - tableCacheNumshardbits
```
int tableCacheNumshardbits()
```
    Number of shards used for table cache.
    
    Returns:
    
    the number of shards used for table cache.
  - setWalTtlSeconds
```
T setWalTtlSeconds(long walTtlSeconds)
```
    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.
    Parameters:
    
    walTtlSeconds - the ttl seconds
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    setWalSizeLimitMB(long)
  - walTtlSeconds
```
long walTtlSeconds()
```
    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.
    Returns:
    
    the wal-ttl seconds
    
    See Also:
    
    walSizeLimitMB()
  - setWalSizeLimitMB
```
T setWalSizeLimitMB(long sizeLimitMB)
```
    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.
    Parameters:
    
    sizeLimitMB - size limit in mega-bytes.
    
    Returns:
    
    the instance of the current object.
    
    See Also:
    
    setWalSizeLimitMB(long)
  - walSizeLimitMB
```
long walSizeLimitMB()
```
    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.
    Returns:
    
    size limit in mega-bytes.
    
    See Also:
    
    walSizeLimitMB()
  - setManifestPreallocationSize
```
T setManifestPreallocationSize(long size)
```
    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).
    
    Parameters:
    
    size - the size in byte
    
    Returns:
    
    the instance of the current object.
    
    Throws:
    
    java.lang.IllegalArgumentException - thrown on 32-Bit platforms while overflowing the underlying platform specific value.
  - manifestPreallocationSize
```
long manifestPreallocationSize()
```
    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).
    
    Returns:
    
    size in bytes.
  - setUseDirectReads
```
T setUseDirectReads(boolean useDirectReads)
```
    Enable the OS to use direct I/O for reading sst tables. Default: false
    
    Parameters:
    
    useDirectReads - if true, then direct read is enabled
    
    Returns:
    
    the instance of the current object.
  - useDirectReads
```
boolean useDirectReads()
```
    Enable the OS to use direct I/O for reading sst tables. Default: false
    
    Returns:
    
    if true, then direct reads are enabled
  - setUseDirectIoForFlushAndCompaction
```
T setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction)
```
    Enable the OS to use direct reads and writes in flush and compaction Default: false
    
    Parameters:
    
    useDirectIoForFlushAndCompaction - if true, then direct I/O will be enabled for background flush and compactions
    
    Returns:
    
    the instance of the current object.
  - useDirectIoForFlushAndCompaction
```
boolean useDirectIoForFlushAndCompaction()
```
    Enable the OS to use direct reads and writes in flush and compaction
    
    Returns:
    
    if true, then direct I/O is enabled for flush and compaction
  - setAllowFAllocate
```
T setAllowFAllocate(boolean allowFAllocate)
```
    Whether fallocate calls are allowed
    
    Parameters:
    
    allowFAllocate - false if fallocate() calls are bypassed
    
    Returns:
    
    the reference to the current options.
  - allowFAllocate
```
boolean allowFAllocate()
```
    Whether fallocate calls are allowed
    
    Returns:
    
    false if fallocate() calls are bypassed
  - setAllowMmapReads
```
T setAllowMmapReads(boolean allowMmapReads)
```
    Allow the OS to mmap file for reading sst tables. Default: false
    
    Parameters:
    
    allowMmapReads - true if mmap reads are allowed.
    
    Returns:
    
    the instance of the current object.
  - allowMmapReads
```
boolean allowMmapReads()
```
    Allow the OS to mmap file for reading sst tables. Default: false
    
    Returns:
    
    true if mmap reads are allowed.
  - setAllowMmapWrites
```
T setAllowMmapWrites(boolean allowMmapWrites)
```
    Allow the OS to mmap file for writing. Default: false
    
    Parameters:
    
    allowMmapWrites - true if mmap writes are allowd.
    
    Returns:
    
    the instance of the current object.
  - allowMmapWrites
```
boolean allowMmapWrites()
```
    Allow the OS to mmap file for writing. Default: false
    
    Returns:
    
    true if mmap writes are allowed.
  - setIsFdCloseOnExec
```
T setIsFdCloseOnExec(boolean isFdCloseOnExec)
```
    Disable child process inherit open files. Default: true
    
    Parameters:
    
    isFdCloseOnExec - true if child process inheriting open files is disabled.
    
    Returns:
    
    the instance of the current object.
  - isFdCloseOnExec
```
boolean isFdCloseOnExec()
```
    Disable child process inherit open files. Default: true
    
    Returns:
    
    true if child process inheriting open files is disabled.
  - setStatsDumpPeriodSec
```
T setStatsDumpPeriodSec(int statsDumpPeriodSec)
```
    if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
    
    Parameters:
    
    statsDumpPeriodSec - time interval in seconds.
    
    Returns:
    
    the instance of the current object.
  - statsDumpPeriodSec
```
int statsDumpPeriodSec()
```
    If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
    
    Returns:
    
    time interval in seconds.
  - setAdviseRandomOnOpen
```
T 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. Default: true
    
    Parameters:
    
    adviseRandomOnOpen - true if hinting random access is on.
    
    Returns:
    
    the instance of the current object.
  - adviseRandomOnOpen
```
boolean adviseRandomOnOpen()
```
    If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened. Default: true
    
    Returns:
    
    true if hinting random access is on.
  - setDbWriteBufferSize
```
T setDbWriteBufferSize(long dbWriteBufferSize)
```
    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)
    
    Parameters:
    
    dbWriteBufferSize - the size of the write buffer
    
    Returns:
    
    the reference to the current options.
  - dbWriteBufferSize
```
long dbWriteBufferSize()
```
    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)
    
    Returns:
    
    the size of the write buffer
  - setAccessHintOnCompactionStart
```
T setAccessHintOnCompactionStart(AccessHint accessHint)
```
    Specify the file access pattern once a compaction is started. It will be applied to all input files of a compaction. Default: AccessHint.NORMAL
    
    Parameters:
    
    accessHint - The access hint
    
    Returns:
    
    the reference to the current options.
  - accessHintOnCompactionStart
```
AccessHint accessHintOnCompactionStart()
```
    Specify the file access pattern once a compaction is started. It will be applied to all input files of a compaction. Default: AccessHint.NORMAL
    
    Returns:
    
    The access hint
  - setNewTableReaderForCompactionInputs
```
T setNewTableReaderForCompactionInputs(boolean newTableReaderForCompactionInputs)
```
    If true, always create a new file descriptor and new table reader for compaction inputs. Turn this parameter on may introduce extra memory usage in the table reader, if it allocates extra memory for indexes. This will allow file descriptor prefetch options to be set for compaction input files and not to impact file descriptors for the same file used by user queries. Suggest to enable BlockBasedTableConfig.cacheIndexAndFilterBlocks() for this mode if using block-based table. Default: false
    
    Parameters:
    
    newTableReaderForCompactionInputs - true if a new file descriptor and table reader should be created for compaction inputs
    
    Returns:
    
    the reference to the current options.
  - newTableReaderForCompactionInputs
```
boolean newTableReaderForCompactionInputs()
```
    If true, always create a new file descriptor and new table reader for compaction inputs. Turn this parameter on may introduce extra memory usage in the table reader, if it allocates extra memory for indexes. This will allow file descriptor prefetch options to be set for compaction input files and not to impact file descriptors for the same file used by user queries. Suggest to enable BlockBasedTableConfig.cacheIndexAndFilterBlocks() for this mode if using block-based table. Default: false
    
    Returns:
    
    true if a new file descriptor and table reader are created for compaction inputs
  - setCompactionReadaheadSize
```
T setCompactionReadaheadSize(long compactionReadaheadSize)
```
    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. When non-zero, we also force newTableReaderForCompactionInputs() to true. Default: 0
    
    Parameters:
    
    compactionReadaheadSize - The compaction read-ahead size
    
    Returns:
    
    the reference to the current options.
  - compactionReadaheadSize
```
long compactionReadaheadSize()
```
    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. When non-zero, we also force newTableReaderForCompactionInputs() to true. Default: 0
    
    Returns:
    
    The compaction read-ahead size
  - setRandomAccessMaxBufferSize
```
T setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize)
```
    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 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.
    
    Parameters:
    
    randomAccessMaxBufferSize - the maximum size of the random access buffer
    
    Returns:
    
    the reference to the current options.
  - randomAccessMaxBufferSize
```
long randomAccessMaxBufferSize()
```
    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 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.
    
    Returns:
    
    the maximum size of the random access buffer
  - setWritableFileMaxBufferSize
```
T setWritableFileMaxBufferSize(long writableFileMaxBufferSize)
```
    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)
    
    Parameters:
    
    writableFileMaxBufferSize - the maximum buffer size
    
    Returns:
    
    the reference to the current options.
  - writableFileMaxBufferSize
```
long writableFileMaxBufferSize()
```
    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)
    
    Returns:
    
    the maximum buffer size
  - setUseAdaptiveMutex
```
T setUseAdaptiveMutex(boolean useAdaptiveMutex)
```
    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
    
    Parameters:
    
    useAdaptiveMutex - true if adaptive mutex is used.
    
    Returns:
    
    the instance of the current object.
  - useAdaptiveMutex
```
boolean useAdaptiveMutex()
```
    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
    
    Returns:
    
    true if adaptive mutex is used.
  - setBytesPerSync
```
T setBytesPerSync(long bytesPerSync)
```
    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
    
    Parameters:
    
    bytesPerSync - size in bytes
    
    Returns:
    
    the instance of the current object.
  - bytesPerSync
```
long bytesPerSync()
```
    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
    
    Returns:
    
    size in bytes
  - setWalBytesPerSync
```
T setWalBytesPerSync(long walBytesPerSync)
```
    Same as setBytesPerSync(long) , but applies to WAL files Default: 0, turned off
    
    Parameters:
    
    walBytesPerSync - size in bytes
    
    Returns:
    
    the instance of the current object.
  - walBytesPerSync
```
long walBytesPerSync()
```
    Same as bytesPerSync() , but applies to WAL files Default: 0, turned off
    
    Returns:
    
    size in bytes
  - setEnableThreadTracking
```
T setEnableThreadTracking(boolean enableThreadTracking)
```
    If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API. Default: false
    
    Parameters:
    
    enableThreadTracking - true to enable tracking
    
    Returns:
    
    the reference to the current options.
  - enableThreadTracking
```
boolean enableThreadTracking()
```
    If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API. Default: false
    
    Returns:
    
    true if tracking is enabled
  - setDelayedWriteRate
```
T 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. 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. Unit: bytes per second. Default: 16MB/s
    
    Parameters:
    
    delayedWriteRate - the rate in bytes per second
    
    Returns:
    
    the reference to the current options.
  - delayedWriteRate
```
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. 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. Unit: bytes per second. Default: 16MB/s
    
    Returns:
    
    the rate in bytes per second
  - setAllowConcurrentMemtableWrite
```
T setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)
```
    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 setEnableWriteThreadAdaptiveYield(boolean) if you are going to use this feature. Default: false
    
    Parameters:
    
    allowConcurrentMemtableWrite - true to enable concurrent writes for the memtable
    
    Returns:
    
    the reference to the current options.
  - allowConcurrentMemtableWrite
```
boolean allowConcurrentMemtableWrite()
```
    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 setEnableWriteThreadAdaptiveYield(boolean) if you are going to use this feature. Default: false
    
    Returns:
    
    true if concurrent writes are enabled for the memtable
  - setEnableWriteThreadAdaptiveYield
```
T setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)
```
    If true, threads synchronizing with the write batch group leader will wait for up to writeThreadMaxYieldUsec() before blocking on a mutex. This can substantially improve throughput for concurrent workloads, regardless of whether allowConcurrentMemtableWrite() is enabled. Default: false
    
    Parameters:
    
    enableWriteThreadAdaptiveYield - true to enable adaptive yield for the write threads
    
    Returns:
    
    the reference to the current options.
  - enableWriteThreadAdaptiveYield
```
boolean enableWriteThreadAdaptiveYield()
```
    If true, threads synchronizing with the write batch group leader will wait for up to writeThreadMaxYieldUsec() before blocking on a mutex. This can substantially improve throughput for concurrent workloads, regardless of whether allowConcurrentMemtableWrite() is enabled. Default: false
    
    Returns:
    
    true if adaptive yield is enabled for the writing threads
  - setWriteThreadMaxYieldUsec
```
T 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. (Assuming writeThreadSlowYieldUsec() is set properly) increasing this value is likely to increase RocksDB throughput at the expense of increased CPU usage. Default: 100
    
    Parameters:
    
    writeThreadMaxYieldUsec - maximum number of microseconds
    
    Returns:
    
    the reference to the current options.
  - writeThreadMaxYieldUsec
```
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. (Assuming writeThreadSlowYieldUsec() is set properly) increasing this value is likely to increase RocksDB throughput at the expense of increased CPU usage. Default: 100
    
    Returns:
    
    the maximum number of microseconds
  - setWriteThreadSlowYieldUsec
```
T 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. 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
    
    Parameters:
    
    writeThreadSlowYieldUsec - the latency in microseconds
    
    Returns:
    
    the reference to the current options.
  - writeThreadSlowYieldUsec
```
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. 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
    
    Returns:
    
    writeThreadSlowYieldUsec the latency in microseconds
  - setSkipStatsUpdateOnDbOpen
```
T 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. Turning off this feature will improve DBOpen time especially in disk environment. Default: false
    
    Parameters:
    
    skipStatsUpdateOnDbOpen - true if updating stats will be skipped
    
    Returns:
    
    the reference to the current options.
  - skipStatsUpdateOnDbOpen
```
boolean skipStatsUpdateOnDbOpen()
```
    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
    
    Returns:
    
    true if updating stats will be skipped
  - setWalRecoveryMode
```
T setWalRecoveryMode(WALRecoveryMode walRecoveryMode)
```
    Recovery mode to control the consistency while replaying WAL Default: WALRecoveryMode.PointInTimeRecovery
    
    Parameters:
    
    walRecoveryMode - The WAL recover mode
    
    Returns:
    
    the reference to the current options.
  - walRecoveryMode
```
WALRecoveryMode walRecoveryMode()
```
    Recovery mode to control the consistency while replaying WAL Default: WALRecoveryMode.PointInTimeRecovery
    
    Returns:
    
    The WAL recover mode
  - setAllow2pc
```
T setAllow2pc(boolean allow2pc)
```
    if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
    
    Parameters:
    
    allow2pc - true if two-phase-commit is enabled
    
    Returns:
    
    the reference to the current options.
  - allow2pc
```
boolean allow2pc()
```
    if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
    
    Returns:
    
    true if two-phase-commit is enabled
  - setRowCache
```
T setRowCache(Cache rowCache)
```
    A global cache for table-level rows. Default: null (disabled)
    
    Parameters:
    
    rowCache - The global row cache
    
    Returns:
    
    the reference to the current options.
  - rowCache
```
Cache rowCache()
```
    A global cache for table-level rows. Default: null (disabled)
    
    Returns:
    
    The global row cache
  - setFailIfOptionsFileError
```
T setFailIfOptionsFileError(boolean failIfOptionsFileError)
```
    If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted. DEFAULT: false
    
    Parameters:
    
    failIfOptionsFileError - true if we should fail if there is an error in the options file
    
    Returns:
    
    the reference to the current options.
  - failIfOptionsFileError
```
boolean failIfOptionsFileError()
```
    If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted. DEFAULT: false
    
    Returns:
    
    true if we should fail if there is an error in the options file
  - setDumpMallocStats
```
T setDumpMallocStats(boolean dumpMallocStats)
```
    If true, then print malloc stats together with rocksdb.stats when printing to LOG. DEFAULT: false
    
    Parameters:
    
    dumpMallocStats - true if malloc stats should be printed to LOG
    
    Returns:
    
    the reference to the current options.
  - dumpMallocStats
```
boolean dumpMallocStats()
```
    If true, then print malloc stats together with rocksdb.stats when printing to LOG. DEFAULT: false
    
    Returns:
    
    true if malloc stats should be printed to LOG
  - setAvoidFlushDuringRecovery
```
T setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery)
```
    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
    
    Parameters:
    
    avoidFlushDuringRecovery - true to try to avoid (but not guarantee not to) flush during recovery
    
    Returns:
    
    the reference to the current options.
  - avoidFlushDuringRecovery
```
boolean avoidFlushDuringRecovery()
```
    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
    
    Returns:
    
    true to try to avoid (but not guarantee not to) flush during recovery
  - setAvoidFlushDuringShutdown
```
T 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. Unpersisted data WILL BE LOST. DEFAULT: false Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions) API.
    
    Parameters:
    
    avoidFlushDuringShutdown - true if we should avoid flush during shutdown
    
    Returns:
    
    the reference to the current options.
  - avoidFlushDuringShutdown
```
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. Unpersisted data WILL BE LOST. DEFAULT: false Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions) API.
    
    Returns:
    
    true if we should avoid flush during shutdown

Interface DBOptionsInterface<T extends DBOptionsInterface>

Method Summary

Method Detail

optimizeForSmallDb

setEnv

getEnv

setIncreaseParallelism

setCreateIfMissing

createIfMissing

setCreateMissingColumnFamilies

createMissingColumnFamilies

setErrorIfExists

errorIfExists

setParanoidChecks

paranoidChecks

setRateLimiter

setLogger

setInfoLogLevel

infoLogLevel

setMaxOpenFiles

maxOpenFiles

setMaxFileOpeningThreads

maxFileOpeningThreads

setMaxTotalWalSize

maxTotalWalSize

setStatistics

statistics

setUseFsync

useFsync

setDbPaths

dbPaths

setDbLogDir

dbLogDir

setWalDir

walDir

setDeleteObsoleteFilesPeriodMicros

deleteObsoleteFilesPeriodMicros

setBaseBackgroundCompactions

baseBackgroundCompactions

setMaxBackgroundCompactions

maxBackgroundCompactions

setMaxSubcompactions

maxSubcompactions

setMaxBackgroundFlushes

maxBackgroundFlushes

setMaxBackgroundJobs

maxBackgroundJobs

setMaxLogFileSize

maxLogFileSize

setLogFileTimeToRoll

logFileTimeToRoll

setKeepLogFileNum

keepLogFileNum

setRecycleLogFileNum

recycleLogFileNum

setMaxManifestFileSize

maxManifestFileSize

setTableCacheNumshardbits

tableCacheNumshardbits

setWalTtlSeconds

walTtlSeconds

setWalSizeLimitMB

walSizeLimitMB

setManifestPreallocationSize

manifestPreallocationSize

setUseDirectReads

useDirectReads

setUseDirectIoForFlushAndCompaction

useDirectIoForFlushAndCompaction

setAllowFAllocate

allowFAllocate

setAllowMmapReads

allowMmapReads

setAllowMmapWrites

allowMmapWrites

setIsFdCloseOnExec

isFdCloseOnExec

setStatsDumpPeriodSec

statsDumpPeriodSec

setAdviseRandomOnOpen