DBOptionsInterface

All Known Implementing Classes:

DBOptions, Options
```
public interface DBOptionsInterface
```

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`adviseRandomOnOpen()` If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened.
`boolean`	`allowConcurrentMemtableWrite()` If true, allow multi-writers to update mem tables in parallel.
`boolean`	`allowMmapReads()` Allow the OS to mmap file for reading sst tables.
`boolean`	`allowMmapWrites()` Allow the OS to mmap file for writing.
`boolean`	`allowOsBuffer()` Data being read from file storage may be buffered in the OS Default: true
`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.
`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.Object`	`createStatistics()` Creates statistics object which collects metrics about database operations.
`java.lang.String`	`dbLogDir()` Returns the directory of info log.
`long`	`deleteObsoleteFilesPeriodMicros()` The periodicity when obsolete files get deleted.
`boolean`	`disableDataSync()` If true, then the contents of data files are not synced to stable storage.
`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.
`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()` Returns the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`int`	`maxBackgroundFlushes()` Returns the maximum number of concurrent background flush jobs.
`long`	`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`	`paranoidChecks()` If true, the implementation will do aggressive checking of the data it is processing and will stop early if it detects any errors.
`java.lang.Object`	`setAdviseRandomOnOpen(boolean adviseRandomOnOpen)` If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened.
`void`	`setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)` If true, allow multi-writers to update mem tables in parallel.
`java.lang.Object`	`setAllowMmapReads(boolean allowMmapReads)` Allow the OS to mmap file for reading sst tables.
`java.lang.Object`	`setAllowMmapWrites(boolean allowMmapWrites)` Allow the OS to mmap file for writing.
`java.lang.Object`	`setAllowOsBuffer(boolean allowOsBuffer)` Data being read from file storage may be buffered in the OS Default: true
`void`	`setBaseBackgroundCompactions(int baseBackgroundCompactions)` Suggested number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`java.lang.Object`	`setBytesPerSync(long bytesPerSync)` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`java.lang.Object`	`setCreateIfMissing(boolean flag)` If this value is set to true, then the database will be created if it is missing during `RocksDB.open()`.
`java.lang.Object`	`setCreateMissingColumnFamilies(boolean flag)` If true, missing column families will be automatically created
`java.lang.Object`	`setDbLogDir(java.lang.String dbLogDir)` This specifies the info LOG dir.
`java.lang.Object`	`setDeleteObsoleteFilesPeriodMicros(long micros)` The periodicity when obsolete files get deleted.
`java.lang.Object`	`setDisableDataSync(boolean disableDataSync)` If true, then the contents of manifest and data files are not synced to stable storage.
`void`	`setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)` If true, threads synchronizing with the write batch group leader will wait for up to `writeThreadMaxYieldUsec()` before blocking on a mutex.
`java.lang.Object`	`setErrorIfExists(boolean errorIfExists)` If true, an error will be thrown during RocksDB.open() if the database already exists.
`java.lang.Object`	`setIncreaseParallelism(int totalThreads)` By default, RocksDB uses only one background thread for flush and compaction.
`java.lang.Object`	`setInfoLogLevel(InfoLogLevel infoLogLevel)` Sets the RocksDB log level.
`java.lang.Object`	`setIsFdCloseOnExec(boolean isFdCloseOnExec)` Disable child process inherit open files.
`java.lang.Object`	`setKeepLogFileNum(long keepLogFileNum)` Specifies the maximum number of info log files to be kept.
`java.lang.Object`	`setLogFileTimeToRoll(long logFileTimeToRoll)` Specifies the time interval for the info log file to roll (in seconds).
`java.lang.Object`	`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.
`java.lang.Object`	`setManifestPreallocationSize(long size)` Number of bytes to preallocate (via fallocate) the manifest files.
`java.lang.Object`	`setMaxBackgroundCompactions(int maxBackgroundCompactions)` Specifies the maximum number of concurrent background compaction jobs, submitted to the default LOW priority thread pool.
`java.lang.Object`	`setMaxBackgroundFlushes(int maxBackgroundFlushes)` Specifies the maximum number of concurrent background flush jobs.
`java.lang.Object`	`setMaxLogFileSize(long maxLogFileSize)` Specifies the maximum size of a info log file.
`java.lang.Object`	`setMaxManifestFileSize(long maxManifestFileSize)` Manifest file is rolled over on reaching this limit.
`java.lang.Object`	`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.
`java.lang.Object`	`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.
`java.lang.Object`	`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.
`java.lang.Object`	`setRateLimiter(RateLimiter rateLimiter)` Use to control write rate of flush and compaction.
`java.lang.Object`	`setRateLimiterConfig(RateLimiterConfig config)` Deprecated. See: `setRateLimiter(RateLimiter)`.
`java.lang.Object`	`setStatsDumpPeriodSec(int statsDumpPeriodSec)` if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
`java.lang.Object`	`setTableCacheNumshardbits(int tableCacheNumshardbits)` Number of shards used for table cache.
`java.lang.Object`	`setUseAdaptiveMutex(boolean useAdaptiveMutex)` Use adaptive mutex, which spins in the user space before resorting to kernel.
`java.lang.Object`	`setUseFsync(boolean useFsync)` If true, then every store to stable storage will issue a fsync.
`java.lang.Object`	`setWalDir(java.lang.String walDir)` This specifies the absolute dir path for write-ahead logs (WAL).
`java.lang.Object`	`setWalSizeLimitMB(long sizeLimitMB)` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`java.lang.Object`	`setWalTtlSeconds(long walTtlSeconds)` `walTtlSeconds()` and `walSizeLimitMB()` affect how archived logs will be deleted.
`void`	`setWriteThreadMaxYieldUsec(long writeThreadMaxYieldUsec)` The maximum number of microseconds that a write operation will use a yielding spin loop to coordinate with other write threads before blocking on a mutex.
`void`	`setWriteThreadSlowYieldUsec(long writeThreadSlowYieldUsec)` The latency in microseconds after which a std::this_thread::yield call (sched_yield on Linux) is considered to be a signal that other processes or threads would like to use the current core.
`Statistics`	`statisticsPtr()` Returns statistics object.
`int`	`statsDumpPeriodSec()` If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
`int`	`tableCacheNumshardbits()` Number of shards used for table cache.
`boolean`	`useAdaptiveMutex()` Use adaptive mutex, which spins in the user space before resorting to kernel.
`boolean`	`useFsync()` If true, then every store to stable storage will issue a fsync.
`java.lang.String`	`walDir()` Returns the path to the write-ahead-logs (WAL) directory.
`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`	`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
  - setIncreaseParallelism
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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.
  - setRateLimiterConfig
```
@Deprecated
java.lang.Object setRateLimiterConfig(RateLimiterConfig config)
```
    Deprecated. See: setRateLimiter(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:
    config - rate limiter config.
    
    Returns:
    the instance of the current Object.
  - setRateLimiter
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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.
  - setMaxTotalWalSize
```
java.lang.Object 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
  - createStatistics
```
java.lang.Object createStatistics()
```
    Creates statistics object which collects metrics about database operations. Statistics objects should not be shared between DB instances as it does not use any locks to prevent concurrent updates.
    
    Returns:
    the instance of the current Object.
    See Also:
    RocksDB.open(org.rocksdb.Options, String)
  - statisticsPtr
```
Statistics statisticsPtr()
```
    Returns statistics object. Calls createStatistics() if C++ returns nullptr for statistics.
    
    Returns:
    the instance of the statistics object.
    See Also:
    createStatistics()
  - setDisableDataSync
```
java.lang.Object setDisableDataSync(boolean disableDataSync)
```
    If true, then the contents of manifest and data files are not synced to stable storage. Their contents remain in the OS buffers till theOS decides to flush them.
    
    This option is good for bulk-loading of data.
    
    Once the bulk-loading is complete, please issue a sync to the OS to flush all dirty buffers to stable storage.
    
    Default: false
    
    Parameters:
    disableDataSync - a boolean flag to specify whether to disable data sync.
    
    Returns:
    the instance of the current Object.
  - disableDataSync
```
boolean disableDataSync()
```
    If true, then the contents of data files are not synced to stable storage. Their contents remain in the OS buffers till the OS decides to flush them. This option is good for bulk-loading of data. Once the bulk-loading is complete, please issue a sync to the OS to flush all dirty buffers to stable storage.
    
    Returns:
    if true, then data-sync is disabled.
  - setUseFsync
```
java.lang.Object 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.
  - setDbLogDir
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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)
```
    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
```
java.lang.Object 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()
```
    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
```
java.lang.Object setMaxBackgroundFlushes(int maxBackgroundFlushes)
```
    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)
  - setMaxLogFileSize
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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.
  - setMaxManifestFileSize
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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.
  - setAllowOsBuffer
```
java.lang.Object setAllowOsBuffer(boolean allowOsBuffer)
```
    Data being read from file storage may be buffered in the OS Default: true
    
    Parameters:
    allowOsBuffer - if true, then OS buffering is allowed.
    
    Returns:
    the instance of the current Object.
  - allowOsBuffer
```
boolean allowOsBuffer()
```
    Data being read from file storage may be buffered in the OS Default: true
    
    Returns:
    if true, then OS buffering is allowed.
  - setAllowMmapReads
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object 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
```
java.lang.Object setStatsDumpPeriodSec(int statsDumpPeriodSec)
```
    if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 3600 (1 hour)
    
    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: 3600 (1 hour)
    
    Returns:
    time interval in seconds.
  - setAdviseRandomOnOpen
```
java.lang.Object 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.
  - setUseAdaptiveMutex
```
java.lang.Object 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
```
java.lang.Object 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
  - setAllowConcurrentMemtableWrite
```
void 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
  - 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
```
void 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
  - 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
```
void setWriteThreadMaxYieldUsec(long writeThreadMaxYieldUsec)
```
    The maximum number of microseconds that a write operation will use a yielding spin loop to coordinate with other write threads before blocking on a mutex. (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
  - 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
```
void setWriteThreadSlowYieldUsec(long writeThreadSlowYieldUsec)
```
    The latency in microseconds after which a std::this_thread::yield call (sched_yield on Linux) is considered to be a signal that other processes or threads would like to use the current core. 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
  - 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

Interface DBOptionsInterface

Method Summary

Method Detail

setIncreaseParallelism

setCreateIfMissing

createIfMissing

setCreateMissingColumnFamilies

createMissingColumnFamilies

setErrorIfExists

errorIfExists

setParanoidChecks

paranoidChecks

setRateLimiterConfig

setRateLimiter

setLogger

setInfoLogLevel

infoLogLevel

setMaxOpenFiles

maxOpenFiles

setMaxTotalWalSize

maxTotalWalSize

createStatistics

statisticsPtr

setDisableDataSync

disableDataSync

setUseFsync

useFsync

setDbLogDir

dbLogDir

setWalDir

walDir

setDeleteObsoleteFilesPeriodMicros

deleteObsoleteFilesPeriodMicros

setBaseBackgroundCompactions

baseBackgroundCompactions

setMaxBackgroundCompactions

maxBackgroundCompactions

setMaxSubcompactions

maxSubcompactions

setMaxBackgroundFlushes

maxBackgroundFlushes

setMaxLogFileSize

maxLogFileSize

setLogFileTimeToRoll

logFileTimeToRoll

setKeepLogFileNum

keepLogFileNum

setMaxManifestFileSize

maxManifestFileSize

setTableCacheNumshardbits

tableCacheNumshardbits

setWalTtlSeconds

walTtlSeconds

setWalSizeLimitMB

walSizeLimitMB

setManifestPreallocationSize

manifestPreallocationSize

setAllowOsBuffer

allowOsBuffer

setAllowMmapReads

allowMmapReads

setAllowMmapWrites

allowMmapWrites

setIsFdCloseOnExec

isFdCloseOnExec

setStatsDumpPeriodSec

statsDumpPeriodSec

setAdviseRandomOnOpen

adviseRandomOnOpen

setUseAdaptiveMutex

useAdaptiveMutex

setBytesPerSync

bytesPerSync

setAllowConcurrentMemtableWrite

allowConcurrentMemtableWrite

setEnableWriteThreadAdaptiveYield

enableWriteThreadAdaptiveYield

setWriteThreadMaxYieldUsec

writeThreadMaxYieldUsec

setWriteThreadSlowYieldUsec