// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.

// This source code is licensed under both the GPLv2 (found in the

// COPYING file in the root directory) and Apache 2.0 License

// (found in the LICENSE.Apache file in the root directory).

package org.rocksdb;

import java.nio.file.Paths;

import java.util.*;

/**

* DBOptions to control the behavior of a database. It will be used

* during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()).

* <p>

* As a descendent of {@link AbstractNativeReference}, this class is {@link AutoCloseable}

* and will be automatically released if opened in the preamble of a try with resources block.

*/

public class DBOptions extends RocksObject

implements DBOptionsInterface<DBOptions>, MutableDBOptionsInterface<DBOptions> {

/**

* Construct DBOptions.

* <p>

* This constructor will create (by allocating a block of memory)

* an {@code rocksdb::DBOptions} in the c++ side.

*/

public DBOptions() {

super(newDBOptionsInstance());

numShardBits_ = DEFAULT_NUM_SHARD_BITS;

env_ = Env.getDefault();

}

/**

* Copy constructor for DBOptions.

* <p>

* NOTE: This does a shallow copy, which means env, rate_limiter, sst_file_manager,

* info_log and other pointers will be cloned!

*

* @param other The DBOptions to copy.

*/

public DBOptions(final DBOptions other) {

super(copyDBOptions(other.nativeHandle_));

this.env_ = other.env_;

this.numShardBits_ = other.numShardBits_;

this.rateLimiter_ = other.rateLimiter_;

this.rowCache_ = other.rowCache_;

this.walFilter_ = other.walFilter_;

this.writeBufferManager_ = other.writeBufferManager_;

}

/**

* Constructor from Options

*

* @param options The options.

*/

public DBOptions(final Options options) {

super(newDBOptionsFromOptions(options.nativeHandle_));

}

/**

* <p>Method to get a options instance by using pre-configured

* property values. If one or many values are undefined in

* the context of RocksDB the method will return a null

* value.</p>

*

* <p><strong>Note</strong>: Property keys can be derived from

* getter methods within the options class. Example: the method

* {@code allowMmapReads()} has a property key:

* {@code allow_mmap_reads}.</p>

*

* @param cfgOpts The ConfigOptions to control how the string is processed.

* @param properties {@link java.util.Properties} instance.

*

* @return {@link org.rocksdb.DBOptions instance}

* or null.

*

* @throws java.lang.IllegalArgumentException if null or empty

* {@link java.util.Properties} instance is passed to the method call.

*/

public static DBOptions getDBOptionsFromProps(

final ConfigOptions cfgOpts, final Properties properties) {

DBOptions dbOptions = null;

final String optionsString = Options.getOptionStringFromProps(properties);

final long handle = getDBOptionsFromProps(cfgOpts.nativeHandle_, optionsString);

if (handle != 0) {

dbOptions = new DBOptions(handle);

}

return dbOptions;

}

/**

* <p>Method to get a options instance by using pre-configured

* property values. If one or many values are undefined in

* the context of RocksDB the method will return a null

* value.</p>

*

* <p><strong>Note</strong>: Property keys can be derived from

* getter methods within the options class. Example: the method

* {@code allowMmapReads()} has a property key:

* {@code allow_mmap_reads}.</p>

*

* @param properties {@link java.util.Properties} instance.

*

* @return {@link org.rocksdb.DBOptions instance}

* or null.

*

* @throws java.lang.IllegalArgumentException if null or empty

* {@link java.util.Properties} instance is passed to the method call.

*/

public static DBOptions getDBOptionsFromProps(final Properties properties) {

DBOptions dbOptions = null;

final String optionsString = Options.getOptionStringFromProps(properties);

final long handle = getDBOptionsFromProps(optionsString);

if (handle != 0) {

dbOptions = new DBOptions(handle);

}

return dbOptions;

}

@Override

public DBOptions optimizeForSmallDb() {

optimizeForSmallDb(nativeHandle_);

return this;

}

@Override

public DBOptions setIncreaseParallelism(

final int totalThreads) {

assert(isOwningHandle());

setIncreaseParallelism(nativeHandle_, totalThreads);

return this;

}

@Override

public DBOptions setCreateIfMissing(final boolean flag) {

assert(isOwningHandle());

setCreateIfMissing(nativeHandle_, flag);

return this;

}

@Override

public boolean createIfMissing() {

assert(isOwningHandle());

return createIfMissing(nativeHandle_);

}

@Override

public DBOptions setCreateMissingColumnFamilies(

final boolean flag) {

assert(isOwningHandle());

setCreateMissingColumnFamilies(nativeHandle_, flag);

return this;

}

@Override

public boolean createMissingColumnFamilies() {

assert(isOwningHandle());

return createMissingColumnFamilies(nativeHandle_);

}

@Override

public DBOptions setErrorIfExists(

final boolean errorIfExists) {

assert(isOwningHandle());

setErrorIfExists(nativeHandle_, errorIfExists);

return this;

}

@Override

public boolean errorIfExists() {

assert(isOwningHandle());

return errorIfExists(nativeHandle_);

}

@Override

public DBOptions setParanoidChecks(

final boolean paranoidChecks) {

assert(isOwningHandle());

setParanoidChecks(nativeHandle_, paranoidChecks);

return this;

}

@Override

public boolean paranoidChecks() {

assert(isOwningHandle());

return paranoidChecks(nativeHandle_);

}

@Override

public DBOptions setOpenFilesAsync(final boolean openFilesAsync) {

assert (isOwningHandle());

setOpenFilesAsync(nativeHandle_, openFilesAsync);

return this;

}

@Override

public boolean openFilesAsync() {

assert (isOwningHandle());

return openFilesAsync(nativeHandle_);

}

@Override

public DBOptions setEnv(final Env env) {

setEnv(nativeHandle_, env.nativeHandle_);

this.env_ = env;

return this;

}

@Override

public Env getEnv() {

return env_;

}

@Override

public DBOptions setRateLimiter(final RateLimiter rateLimiter) {

assert(isOwningHandle());

rateLimiter_ = rateLimiter;

setRateLimiter(nativeHandle_, rateLimiter.nativeHandle_);

return this;

}

@Override

public DBOptions setSstFileManager(final SstFileManager sstFileManager) {

assert(isOwningHandle());

setSstFileManager(nativeHandle_, sstFileManager.nativeHandle_);

return this;

}

@Override

public DBOptions setLogger(final LoggerInterface logger) {

assert(isOwningHandle());

setLogger(nativeHandle_, logger.getNativeHandle(), logger.getLoggerType().getValue());

return this;

}

@Override

public DBOptions setInfoLogLevel(

final InfoLogLevel infoLogLevel) {

assert(isOwningHandle());

setInfoLogLevel(nativeHandle_, infoLogLevel.getValue());

return this;

}

@Override

public InfoLogLevel infoLogLevel() {

assert(isOwningHandle());

return InfoLogLevel.getInfoLogLevel(

infoLogLevel(nativeHandle_));

}

@Override

public DBOptions setMaxOpenFiles(

final int maxOpenFiles) {

assert(isOwningHandle());

setMaxOpenFiles(nativeHandle_, maxOpenFiles);

return this;

}

@Override

public int maxOpenFiles() {

assert(isOwningHandle());

return maxOpenFiles(nativeHandle_);

}

@Override

public DBOptions setMaxFileOpeningThreads(final int maxFileOpeningThreads) {

assert(isOwningHandle());

setMaxFileOpeningThreads(nativeHandle_, maxFileOpeningThreads);

return this;

}

@Override

public int maxFileOpeningThreads() {

assert(isOwningHandle());

return maxFileOpeningThreads(nativeHandle_);

}

@Override

public DBOptions setMaxTotalWalSize(

final long maxTotalWalSize) {

assert(isOwningHandle());

setMaxTotalWalSize(nativeHandle_, maxTotalWalSize);

return this;

}

@Override

public long maxTotalWalSize() {

assert(isOwningHandle());

return maxTotalWalSize(nativeHandle_);

}

@Override

public DBOptions setStatistics(final Statistics statistics) {

assert(isOwningHandle());

setStatistics(nativeHandle_, statistics.nativeHandle_);

return this;

}

@Override

public Statistics statistics() {

assert(isOwningHandle());

final long statisticsNativeHandle = statistics(nativeHandle_);

if(statisticsNativeHandle == 0) {

return null;

} else {

return new Statistics(statisticsNativeHandle);

}

}

@Override

public DBOptions setUseFsync(

final boolean useFsync) {

assert(isOwningHandle());

setUseFsync(nativeHandle_, useFsync);

return this;

}

@Override

public boolean useFsync() {

assert(isOwningHandle());

return useFsync(nativeHandle_);

}

@Override

public DBOptions setDbPaths(final Collection<DbPath> dbPaths) {

assert(isOwningHandle());

final int len = dbPaths.size();

final String[] paths = new String[len];

final long[] targetSizes = new long[len];

int i = 0;

for(final DbPath dbPath : dbPaths) {

paths[i] = dbPath.path.toString();

targetSizes[i] = dbPath.targetSize;

i++;

}

setDbPaths(nativeHandle_, paths, targetSizes);

return this;

}

@Override

public List<DbPath> dbPaths() {

final int len = (int)dbPathsLen(nativeHandle_);

if(len == 0) {

return Collections.emptyList();

} else {

final String[] paths = new String[len];

final long[] targetSizes = new long[len];

dbPaths(nativeHandle_, paths, targetSizes);

final List<DbPath> dbPaths = new ArrayList<>();

for(int i = 0; i < len; i++) {

dbPaths.add(new DbPath(Paths.get(paths[i]), targetSizes[i]));

}

return dbPaths;

}

}

@Override

public DBOptions setDbLogDir(

final String dbLogDir) {

assert(isOwningHandle());

setDbLogDir(nativeHandle_, dbLogDir);

return this;

}

@Override

public String dbLogDir() {

assert(isOwningHandle());

return dbLogDir(nativeHandle_);

}

@Override

public DBOptions setWalDir(

final String walDir) {

assert(isOwningHandle());

setWalDir(nativeHandle_, walDir);

return this;

}

@Override

public String walDir() {

assert(isOwningHandle());

return walDir(nativeHandle_);

}

@Override

public DBOptions setDeleteObsoleteFilesPeriodMicros(

final long micros) {

assert(isOwningHandle());

setDeleteObsoleteFilesPeriodMicros(nativeHandle_, micros);

return this;

}

@Override

public long deleteObsoleteFilesPeriodMicros() {

assert(isOwningHandle());

return deleteObsoleteFilesPeriodMicros(nativeHandle_);

}

@Override

public DBOptions setMaxBackgroundJobs(final int maxBackgroundJobs) {

assert(isOwningHandle());

setMaxBackgroundJobs(nativeHandle_, maxBackgroundJobs);

return this;

}

@Override

public int maxBackgroundJobs() {

assert(isOwningHandle());

return maxBackgroundJobs(nativeHandle_);

}

@Override

@Deprecated

public DBOptions setMaxBackgroundCompactions(

final int maxBackgroundCompactions) {

assert(isOwningHandle());

setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions);

return this;

}

@Override

@Deprecated

public int maxBackgroundCompactions() {

assert(isOwningHandle());

return maxBackgroundCompactions(nativeHandle_);

}

@Override

public DBOptions setMaxSubcompactions(final int maxSubcompactions) {

assert(isOwningHandle());

setMaxSubcompactions(nativeHandle_, maxSubcompactions);

return this;

}

@Override

public int maxSubcompactions() {

assert(isOwningHandle());

return maxSubcompactions(nativeHandle_);

}

@Override

@Deprecated

public DBOptions setMaxBackgroundFlushes(

final int maxBackgroundFlushes) {

assert(isOwningHandle());

setMaxBackgroundFlushes(nativeHandle_, maxBackgroundFlushes);

return this;

}

@Override

@Deprecated

public int maxBackgroundFlushes() {

assert(isOwningHandle());

return maxBackgroundFlushes(nativeHandle_);

}

@Override

public DBOptions setMaxLogFileSize(final long maxLogFileSize) {

assert(isOwningHandle());

setMaxLogFileSize(nativeHandle_, maxLogFileSize);

return this;

}

@Override

public long maxLogFileSize() {

assert(isOwningHandle());

return maxLogFileSize(nativeHandle_);

}

@Override

public DBOptions setLogFileTimeToRoll(

final long logFileTimeToRoll) {

assert(isOwningHandle());

setLogFileTimeToRoll(nativeHandle_, logFileTimeToRoll);

return this;

}

@Override

public long logFileTimeToRoll() {

assert(isOwningHandle());

return logFileTimeToRoll(nativeHandle_);

}

@Override

public DBOptions setKeepLogFileNum(

final long keepLogFileNum) {

assert(isOwningHandle());

setKeepLogFileNum(nativeHandle_, keepLogFileNum);

return this;

}

@Override

public long keepLogFileNum() {

assert(isOwningHandle());

return keepLogFileNum(nativeHandle_);

}

@Override

public DBOptions setRecycleLogFileNum(final long recycleLogFileNum) {

assert(isOwningHandle());

setRecycleLogFileNum(nativeHandle_, recycleLogFileNum);

return this;

}

@Override

public long recycleLogFileNum() {

assert(isOwningHandle());

return recycleLogFileNum(nativeHandle_);

}

@Override

public DBOptions setMaxManifestFileSize(

final long maxManifestFileSize) {

assert(isOwningHandle());

setMaxManifestFileSize(nativeHandle_, maxManifestFileSize);

return this;

}

@Override

public long maxManifestFileSize() {

assert(isOwningHandle());

return maxManifestFileSize(nativeHandle_);

}

@Override

public DBOptions setTableCacheNumshardbits(

final int tableCacheNumshardbits) {

assert(isOwningHandle());

setTableCacheNumshardbits(nativeHandle_, tableCacheNumshardbits);

return this;

}

@Override

public int tableCacheNumshardbits() {

assert(isOwningHandle());

return tableCacheNumshardbits(nativeHandle_);

}

@Override

public DBOptions setWalTtlSeconds(

final long walTtlSeconds) {

assert(isOwningHandle());

setWalTtlSeconds(nativeHandle_, walTtlSeconds);

return this;

}

@Override

public long walTtlSeconds() {

assert(isOwningHandle());

return walTtlSeconds(nativeHandle_);

}

@Override

public DBOptions setWalSizeLimitMB(

final long sizeLimitMB) {

assert(isOwningHandle());

setWalSizeLimitMB(nativeHandle_, sizeLimitMB);

return this;

}

@Override

public long walSizeLimitMB() {

assert(isOwningHandle());

return walSizeLimitMB(nativeHandle_);

}

@Override

public DBOptions setMaxWriteBatchGroupSizeBytes(final long maxWriteBatchGroupSizeBytes) {

setMaxWriteBatchGroupSizeBytes(nativeHandle_, maxWriteBatchGroupSizeBytes);

return this;

}

@Override

public long maxWriteBatchGroupSizeBytes() {

assert (isOwningHandle());

return maxWriteBatchGroupSizeBytes(nativeHandle_);

}

@Override

public DBOptions setManifestPreallocationSize(

final long size) {

assert(isOwningHandle());

setManifestPreallocationSize(nativeHandle_, size);

return this;

}

@Override

public long manifestPreallocationSize() {

assert(isOwningHandle());

return manifestPreallocationSize(nativeHandle_);

}

@Override

public DBOptions setAllowMmapReads(

final boolean allowMmapReads) {

assert(isOwningHandle());

setAllowMmapReads(nativeHandle_, allowMmapReads);

return this;

}

@Override

public boolean allowMmapReads() {

assert(isOwningHandle());

return allowMmapReads(nativeHandle_);

}

@Override

public DBOptions setAllowMmapWrites(

final boolean allowMmapWrites) {

assert(isOwningHandle());

setAllowMmapWrites(nativeHandle_, allowMmapWrites);

return this;

}

@Override

public boolean allowMmapWrites() {

assert(isOwningHandle());

return allowMmapWrites(nativeHandle_);

}

@Override

public DBOptions setUseDirectReads(

final boolean useDirectReads) {

assert(isOwningHandle());

setUseDirectReads(nativeHandle_, useDirectReads);

return this;

}

@Override

public boolean useDirectReads() {

assert(isOwningHandle());

return useDirectReads(nativeHandle_);

}

@Override

public DBOptions setUseDirectIoForFlushAndCompaction(

final boolean useDirectIoForFlushAndCompaction) {

assert(isOwningHandle());

setUseDirectIoForFlushAndCompaction(nativeHandle_,

useDirectIoForFlushAndCompaction);

return this;

}

@Override

public boolean useDirectIoForFlushAndCompaction() {

assert(isOwningHandle());

return useDirectIoForFlushAndCompaction(nativeHandle_);

}

@Override

public DBOptions setAllowFAllocate(final boolean allowFAllocate) {

assert(isOwningHandle());

setAllowFAllocate(nativeHandle_, allowFAllocate);

return this;

}

@Override

public boolean allowFAllocate() {

assert(isOwningHandle());

return allowFAllocate(nativeHandle_);

}

@Override

public DBOptions setIsFdCloseOnExec(

final boolean isFdCloseOnExec) {

assert(isOwningHandle());

setIsFdCloseOnExec(nativeHandle_, isFdCloseOnExec);

return this;

}

@Override

public boolean isFdCloseOnExec() {

assert(isOwningHandle());

return isFdCloseOnExec(nativeHandle_);

}

@Override

public DBOptions setStatsDumpPeriodSec(

final int statsDumpPeriodSec) {

assert(isOwningHandle());

setStatsDumpPeriodSec(nativeHandle_, statsDumpPeriodSec);

return this;

}

@Override

public int statsDumpPeriodSec() {

assert(isOwningHandle());

return statsDumpPeriodSec(nativeHandle_);

}

@Override

public DBOptions setMaxCompactionTriggerWakeupSeconds(

final long maxCompactionTriggerWakeupSeconds) {

assert (isOwningHandle());

setMaxCompactionTriggerWakeupSeconds(nativeHandle_, maxCompactionTriggerWakeupSeconds);

return this;

}

@Override

public long maxCompactionTriggerWakeupSeconds() {

assert (isOwningHandle());

return maxCompactionTriggerWakeupSeconds(nativeHandle_);

}

@Override

public DBOptions setStatsPersistPeriodSec(

final int statsPersistPeriodSec) {

assert(isOwningHandle());

setStatsPersistPeriodSec(nativeHandle_, statsPersistPeriodSec);

return this;

}

@Override

public int statsPersistPeriodSec() {

assert(isOwningHandle());

return statsPersistPeriodSec(nativeHandle_);

}

@Override

public DBOptions setStatsHistoryBufferSize(

final long statsHistoryBufferSize) {

assert(isOwningHandle());

setStatsHistoryBufferSize(nativeHandle_, statsHistoryBufferSize);

return this;

}

@Override

public long statsHistoryBufferSize() {

assert(isOwningHandle());

return statsHistoryBufferSize(nativeHandle_);

}

@Override

public DBOptions setAdviseRandomOnOpen(

final boolean adviseRandomOnOpen) {

assert(isOwningHandle());

setAdviseRandomOnOpen(nativeHandle_, adviseRandomOnOpen);

return this;

}

@Override

public boolean adviseRandomOnOpen() {

return adviseRandomOnOpen(nativeHandle_);

}

@Override

public DBOptions setDbWriteBufferSize(final long dbWriteBufferSize) {

assert(isOwningHandle());

setDbWriteBufferSize(nativeHandle_, dbWriteBufferSize);

return this;

}

@Override

public DBOptions setWriteBufferManager(final WriteBufferManager writeBufferManager) {

assert(isOwningHandle());

setWriteBufferManager(nativeHandle_, writeBufferManager.nativeHandle_);

this.writeBufferManager_ = writeBufferManager;

return this;

}

@Override

public WriteBufferManager writeBufferManager() {

assert(isOwningHandle());

return this.writeBufferManager_;

}

@Override

public long dbWriteBufferSize() {

assert(isOwningHandle());

return dbWriteBufferSize(nativeHandle_);

}

@Override

public DBOptions setCompactionReadaheadSize(final long compactionReadaheadSize) {

assert(isOwningHandle());

setCompactionReadaheadSize(nativeHandle_, compactionReadaheadSize);

return this;

}

@Override

public long compactionReadaheadSize() {

assert(isOwningHandle());

return compactionReadaheadSize(nativeHandle_);

}

@Override

public DBOptions setDailyOffpeakTimeUTC(String offpeakTimeUTC) {

assert (isOwningHandle());

setDailyOffpeakTimeUTC(nativeHandle_, offpeakTimeUTC);

return this;

}

@Override

public String dailyOffpeakTimeUTC() {

assert (isOwningHandle());

return dailyOffpeakTimeUTC(nativeHandle_);

}

@Override

public DBOptions setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {

assert(isOwningHandle());

setWritableFileMaxBufferSize(nativeHandle_, writableFileMaxBufferSize);

return this;

}

@Override

public long writableFileMaxBufferSize() {

assert(isOwningHandle());

return writableFileMaxBufferSize(nativeHandle_);

}

@Override

public DBOptions setUseAdaptiveMutex(

final boolean useAdaptiveMutex) {

assert(isOwningHandle());

setUseAdaptiveMutex(nativeHandle_, useAdaptiveMutex);

return this;

}

@Override

public boolean useAdaptiveMutex() {

assert(isOwningHandle());

return useAdaptiveMutex(nativeHandle_);

}

@Override

public DBOptions setBytesPerSync(

final long bytesPerSync) {

assert(isOwningHandle());

setBytesPerSync(nativeHandle_, bytesPerSync);

return this;

}

@Override

public long bytesPerSync() {

return bytesPerSync(nativeHandle_);

}

@Override

public DBOptions setWalBytesPerSync(final long walBytesPerSync) {

assert(isOwningHandle());

setWalBytesPerSync(nativeHandle_, walBytesPerSync);

return this;

}

@Override

public long walBytesPerSync() {

assert(isOwningHandle());

return walBytesPerSync(nativeHandle_);

}

@Override

public DBOptions setStrictBytesPerSync(final boolean strictBytesPerSync) {

assert(isOwningHandle());

setStrictBytesPerSync(nativeHandle_, strictBytesPerSync);

return this;

}

@Override

public boolean strictBytesPerSync() {

assert(isOwningHandle());

return strictBytesPerSync(nativeHandle_);

}

@Override

public DBOptions setListeners(final List<AbstractEventListener> listeners) {

assert (isOwningHandle());

setEventListeners(nativeHandle_, RocksCallbackObject.toNativeHandleList(listeners));

return this;

}

@Override

public List<AbstractEventListener> listeners() {

assert (isOwningHandle());

return Arrays.asList(eventListeners(nativeHandle_));

}

@Override

public DBOptions setEnableThreadTracking(final boolean enableThreadTracking) {

assert(isOwningHandle());

setEnableThreadTracking(nativeHandle_, enableThreadTracking);

return this;

}

@Override

public boolean enableThreadTracking() {

assert(isOwningHandle());

return enableThreadTracking(nativeHandle_);

}

@Override

public DBOptions setDelayedWriteRate(final long delayedWriteRate) {

assert(isOwningHandle());

setDelayedWriteRate(nativeHandle_, delayedWriteRate);

return this;

}

@Override

public long delayedWriteRate(){

return delayedWriteRate(nativeHandle_);

}

@Override

public DBOptions setEnablePipelinedWrite(final boolean enablePipelinedWrite) {

assert(isOwningHandle());

setEnablePipelinedWrite(nativeHandle_, enablePipelinedWrite);

return this;

}

@Override

public boolean enablePipelinedWrite() {

assert(isOwningHandle());

return enablePipelinedWrite(nativeHandle_);

}

@Override

public DBOptions setUnorderedWrite(final boolean unorderedWrite) {

setUnorderedWrite(nativeHandle_, unorderedWrite);

return this;

}

@Override

public boolean unorderedWrite() {

return unorderedWrite(nativeHandle_);

}

@Override

public DBOptions setAllowConcurrentMemtableWrite(

final boolean allowConcurrentMemtableWrite) {

setAllowConcurrentMemtableWrite(nativeHandle_,

allowConcurrentMemtableWrite);

return this;

}

@Override

public boolean allowConcurrentMemtableWrite() {

return allowConcurrentMemtableWrite(nativeHandle_);

}

@Override

public DBOptions setEnableWriteThreadAdaptiveYield(

final boolean enableWriteThreadAdaptiveYield) {

setEnableWriteThreadAdaptiveYield(nativeHandle_,

enableWriteThreadAdaptiveYield);

return this;

}

@Override

public boolean enableWriteThreadAdaptiveYield() {

return enableWriteThreadAdaptiveYield(nativeHandle_);

}

@Override

public DBOptions setWriteThreadMaxYieldUsec(final long writeThreadMaxYieldUsec) {

setWriteThreadMaxYieldUsec(nativeHandle_, writeThreadMaxYieldUsec);

return this;

}

@Override

public long writeThreadMaxYieldUsec() {

return writeThreadMaxYieldUsec(nativeHandle_);

}

@Override

public DBOptions setWriteThreadSlowYieldUsec(final long writeThreadSlowYieldUsec) {

setWriteThreadSlowYieldUsec(nativeHandle_, writeThreadSlowYieldUsec);

return this;

}

@Override

public long writeThreadSlowYieldUsec() {

return writeThreadSlowYieldUsec(nativeHandle_);

}

@Override

public DBOptions setSkipStatsUpdateOnDbOpen(final boolean skipStatsUpdateOnDbOpen) {

assert(isOwningHandle());

setSkipStatsUpdateOnDbOpen(nativeHandle_, skipStatsUpdateOnDbOpen);

return this;

}

@Override

public boolean skipStatsUpdateOnDbOpen() {

assert(isOwningHandle());

return skipStatsUpdateOnDbOpen(nativeHandle_);

}

@Override

public DBOptions setWalRecoveryMode(final WALRecoveryMode walRecoveryMode) {

assert(isOwningHandle());

setWalRecoveryMode(nativeHandle_, walRecoveryMode.getValue());

return this;

}

@Override

public WALRecoveryMode walRecoveryMode() {