| // 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()). |
| * |
| * If {@link #dispose()} function is not called, then it will be GC'd |
| * automatically and native resources will be released as part of the process. |
| */ |
| public class DBOptions |
| extends RocksObject implements DBOptionsInterface<DBOptions> { |
| static { |
| RocksDB.loadLibrary(); |
| } |
| |
| /** |
| * Construct DBOptions. |
| * |
| * This constructor will create (by allocating a block of memory) |
| * an {@code rocksdb::DBOptions} in the c++ side. |
| */ |
| public DBOptions() { |
| super(newDBOptions()); |
| numShardBits_ = DEFAULT_NUM_SHARD_BITS; |
| } |
| |
| /** |
| * <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) { |
| if (properties == null || properties.size() == 0) { |
| throw new IllegalArgumentException( |
| "Properties value must contain at least one value."); |
| } |
| DBOptions dbOptions = null; |
| StringBuilder stringBuilder = new StringBuilder(); |
| for (final String name : properties.stringPropertyNames()){ |
| stringBuilder.append(name); |
| stringBuilder.append("="); |
| stringBuilder.append(properties.getProperty(name)); |
| stringBuilder.append(";"); |
| } |
| long handle = getDBOptionsFromProps( |
| stringBuilder.toString()); |
| 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 setEnv(final Env env) { |
| setEnv(nativeHandle_, env.nativeHandle_); |
| this.env_ = env; |
| return this; |
| } |
| |
| @Override |
| public Env getEnv() { |
| return env_; |
| } |
| |
| @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 setRateLimiter(final RateLimiter rateLimiter) { |
| assert(isOwningHandle()); |
| rateLimiter_ = rateLimiter; |
| setRateLimiter(nativeHandle_, rateLimiter.nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public DBOptions setLogger(final Logger logger) { |
| assert(isOwningHandle()); |
| setLogger(nativeHandle_, logger.nativeHandle_); |
| 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 void setBaseBackgroundCompactions( |
| final int baseBackgroundCompactions) { |
| assert(isOwningHandle()); |
| setBaseBackgroundCompactions(nativeHandle_, baseBackgroundCompactions); |
| } |
| |
| @Override |
| public int baseBackgroundCompactions() { |
| assert(isOwningHandle()); |
| return baseBackgroundCompactions(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setMaxBackgroundCompactions( |
| final int maxBackgroundCompactions) { |
| assert(isOwningHandle()); |
| setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions); |
| return this; |
| } |
| |
| @Override |
| public int maxBackgroundCompactions() { |
| assert(isOwningHandle()); |
| return maxBackgroundCompactions(nativeHandle_); |
| } |
| |
| @Override |
| public void setMaxSubcompactions(final int maxSubcompactions) { |
| assert(isOwningHandle()); |
| setMaxSubcompactions(nativeHandle_, maxSubcompactions); |
| } |
| |
| @Override |
| public int maxSubcompactions() { |
| assert(isOwningHandle()); |
| return maxSubcompactions(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setMaxBackgroundFlushes( |
| final int maxBackgroundFlushes) { |
| assert(isOwningHandle()); |
| setMaxBackgroundFlushes(nativeHandle_, maxBackgroundFlushes); |
| return this; |
| } |
| |
| @Override |
| 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 setManifestPreallocationSize( |
| final long size) { |
| assert(isOwningHandle()); |
| setManifestPreallocationSize(nativeHandle_, size); |
| return this; |
| } |
| |
| @Override |
| public long manifestPreallocationSize() { |
| assert(isOwningHandle()); |
| return manifestPreallocationSize(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 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 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 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 long dbWriteBufferSize() { |
| assert(isOwningHandle()); |
| return dbWriteBufferSize(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setAccessHintOnCompactionStart(final AccessHint accessHint) { |
| assert(isOwningHandle()); |
| setAccessHintOnCompactionStart(nativeHandle_, accessHint.getValue()); |
| return this; |
| } |
| |
| @Override |
| public AccessHint accessHintOnCompactionStart() { |
| assert(isOwningHandle()); |
| return AccessHint.getAccessHint(accessHintOnCompactionStart(nativeHandle_)); |
| } |
| |
| @Override |
| public DBOptions setNewTableReaderForCompactionInputs( |
| final boolean newTableReaderForCompactionInputs) { |
| assert(isOwningHandle()); |
| setNewTableReaderForCompactionInputs(nativeHandle_, |
| newTableReaderForCompactionInputs); |
| return this; |
| } |
| |
| @Override |
| public boolean newTableReaderForCompactionInputs() { |
| assert(isOwningHandle()); |
| return newTableReaderForCompactionInputs(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 setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) { |
| assert(isOwningHandle()); |
| setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize); |
| return this; |
| } |
| |
| @Override |
| public long randomAccessMaxBufferSize() { |
| assert(isOwningHandle()); |
| return randomAccessMaxBufferSize(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 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 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() { |
| assert(isOwningHandle()); |
| return WALRecoveryMode.getWALRecoveryMode(walRecoveryMode(nativeHandle_)); |
| } |
| |
| @Override |
| public DBOptions setAllow2pc(final boolean allow2pc) { |
| assert(isOwningHandle()); |
| setAllow2pc(nativeHandle_, allow2pc); |
| return this; |
| } |
| |
| @Override |
| public boolean allow2pc() { |
| assert(isOwningHandle()); |
| return allow2pc(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setRowCache(final Cache rowCache) { |
| assert(isOwningHandle()); |
| setRowCache(nativeHandle_, rowCache.nativeHandle_); |
| this.rowCache_ = rowCache; |
| return this; |
| } |
| |
| @Override |
| public Cache rowCache() { |
| assert(isOwningHandle()); |
| return this.rowCache_; |
| } |
| |
| @Override |
| public DBOptions setFailIfOptionsFileError(final boolean failIfOptionsFileError) { |
| assert(isOwningHandle()); |
| setFailIfOptionsFileError(nativeHandle_, failIfOptionsFileError); |
| return this; |
| } |
| |
| @Override |
| public boolean failIfOptionsFileError() { |
| assert(isOwningHandle()); |
| return failIfOptionsFileError(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setDumpMallocStats(final boolean dumpMallocStats) { |
| assert(isOwningHandle()); |
| setDumpMallocStats(nativeHandle_, dumpMallocStats); |
| return this; |
| } |
| |
| @Override |
| public boolean dumpMallocStats() { |
| assert(isOwningHandle()); |
| return dumpMallocStats(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setAvoidFlushDuringRecovery(final boolean avoidFlushDuringRecovery) { |
| assert(isOwningHandle()); |
| setAvoidFlushDuringRecovery(nativeHandle_, avoidFlushDuringRecovery); |
| return this; |
| } |
| |
| @Override |
| public boolean avoidFlushDuringRecovery() { |
| assert(isOwningHandle()); |
| return avoidFlushDuringRecovery(nativeHandle_); |
| } |
| |
| @Override |
| public DBOptions setAvoidFlushDuringShutdown(final boolean avoidFlushDuringShutdown) { |
| assert(isOwningHandle()); |
| setAvoidFlushDuringShutdown(nativeHandle_, avoidFlushDuringShutdown); |
| return this; |
| } |
| |
| @Override |
| public boolean avoidFlushDuringShutdown() { |
| assert(isOwningHandle()); |
| return avoidFlushDuringShutdown(nativeHandle_); |
| } |
| |
| static final int DEFAULT_NUM_SHARD_BITS = -1; |
| |
| |
| |
| |
| /** |
| * <p>Private constructor to be used by |
| * {@link #getDBOptionsFromProps(java.util.Properties)}</p> |
| * |
| * @param nativeHandle native handle to DBOptions instance. |
| */ |
| private DBOptions(final long nativeHandle) { |
| super(nativeHandle); |
| } |
| |
| private static native long getDBOptionsFromProps( |
| String optString); |
| |
| private native static long newDBOptions(); |
| @Override protected final native void disposeInternal(final long handle); |
| |
| private native void optimizeForSmallDb(final long handle); |
| private native void setIncreaseParallelism(long handle, int totalThreads); |
| private native void setCreateIfMissing(long handle, boolean flag); |
| private native boolean createIfMissing(long handle); |
| private native void setCreateMissingColumnFamilies( |
| long handle, boolean flag); |
| private native boolean createMissingColumnFamilies(long handle); |
| private native void setEnv(long handle, long envHandle); |
| private native void setErrorIfExists(long handle, boolean errorIfExists); |
| private native boolean errorIfExists(long handle); |
| private native void setParanoidChecks( |
| long handle, boolean paranoidChecks); |
| private native boolean paranoidChecks(long handle); |
| private native void setRateLimiter(long handle, |
| long rateLimiterHandle); |
| private native void setLogger(long handle, |
| long loggerHandle); |
| private native void setInfoLogLevel(long handle, byte logLevel); |
| private native byte infoLogLevel(long handle); |
| private native void setMaxOpenFiles(long handle, int maxOpenFiles); |
| private native int maxOpenFiles(long handle); |
| private native void setMaxFileOpeningThreads(final long handle, |
| final int maxFileOpeningThreads); |
| private native int maxFileOpeningThreads(final long handle); |
| private native void setMaxTotalWalSize(long handle, |
| long maxTotalWalSize); |
| private native long maxTotalWalSize(long handle); |
| private native void setStatistics(final long handle, final long statisticsHandle); |
| private native long statistics(final long handle); |
| private native boolean useFsync(long handle); |
| private native void setUseFsync(long handle, boolean useFsync); |
| private native void setDbPaths(final long handle, final String[] paths, |
| final long[] targetSizes); |
| private native long dbPathsLen(final long handle); |
| private native void dbPaths(final long handle, final String[] paths, |
| final long[] targetSizes); |
| private native void setDbLogDir(long handle, String dbLogDir); |
| private native String dbLogDir(long handle); |
| private native void setWalDir(long handle, String walDir); |
| private native String walDir(long handle); |
| private native void setDeleteObsoleteFilesPeriodMicros( |
| long handle, long micros); |
| private native long deleteObsoleteFilesPeriodMicros(long handle); |
| private native void setBaseBackgroundCompactions(long handle, |
| int baseBackgroundCompactions); |
| private native int baseBackgroundCompactions(long handle); |
| private native void setMaxBackgroundCompactions( |
| long handle, int maxBackgroundCompactions); |
| private native int maxBackgroundCompactions(long handle); |
| private native void setMaxSubcompactions(long handle, int maxSubcompactions); |
| private native int maxSubcompactions(long handle); |
| private native void setMaxBackgroundFlushes( |
| long handle, int maxBackgroundFlushes); |
| private native int maxBackgroundFlushes(long handle); |
| private native void setMaxLogFileSize(long handle, long maxLogFileSize) |
| throws IllegalArgumentException; |
| private native long maxLogFileSize(long handle); |
| private native void setLogFileTimeToRoll( |
| long handle, long logFileTimeToRoll) throws IllegalArgumentException; |
| private native long logFileTimeToRoll(long handle); |
| private native void setKeepLogFileNum(long handle, long keepLogFileNum) |
| throws IllegalArgumentException; |
| private native long keepLogFileNum(long handle); |
| private native void setRecycleLogFileNum(long handle, long recycleLogFileNum); |
| private native long recycleLogFileNum(long handle); |
| private native void setMaxManifestFileSize( |
| long handle, long maxManifestFileSize); |
| private native long maxManifestFileSize(long handle); |
| private native void setTableCacheNumshardbits( |
| long handle, int tableCacheNumshardbits); |
| private native int tableCacheNumshardbits(long handle); |
| private native void setWalTtlSeconds(long handle, long walTtlSeconds); |
| private native long walTtlSeconds(long handle); |
| private native void setWalSizeLimitMB(long handle, long sizeLimitMB); |
| private native long walSizeLimitMB(long handle); |
| private native void setManifestPreallocationSize( |
| long handle, long size) throws IllegalArgumentException; |
| private native long manifestPreallocationSize(long handle); |
| private native void setUseDirectReads(long handle, boolean useDirectReads); |
| private native boolean useDirectReads(long handle); |
| private native void setUseDirectIoForFlushAndCompaction( |
| long handle, boolean useDirectIoForFlushAndCompaction); |
| private native boolean useDirectIoForFlushAndCompaction(long handle); |
| private native void setAllowFAllocate(final long handle, |
| final boolean allowFAllocate); |
| private native boolean allowFAllocate(final long handle); |
| private native void setAllowMmapReads( |
| long handle, boolean allowMmapReads); |
| private native boolean allowMmapReads(long handle); |
| private native void setAllowMmapWrites( |
| long handle, boolean allowMmapWrites); |
| private native boolean allowMmapWrites(long handle); |
| private native void setIsFdCloseOnExec( |
| long handle, boolean isFdCloseOnExec); |
| private native boolean isFdCloseOnExec(long handle); |
| private native void setStatsDumpPeriodSec( |
| long handle, int statsDumpPeriodSec); |
| private native int statsDumpPeriodSec(long handle); |
| private native void setAdviseRandomOnOpen( |
| long handle, boolean adviseRandomOnOpen); |
| private native boolean adviseRandomOnOpen(long handle); |
| private native void setDbWriteBufferSize(final long handle, |
| final long dbWriteBufferSize); |
| private native long dbWriteBufferSize(final long handle); |
| private native void setAccessHintOnCompactionStart(final long handle, |
| final byte accessHintOnCompactionStart); |
| private native byte accessHintOnCompactionStart(final long handle); |
| private native void setNewTableReaderForCompactionInputs(final long handle, |
| final boolean newTableReaderForCompactionInputs); |
| private native boolean newTableReaderForCompactionInputs(final long handle); |
| private native void setCompactionReadaheadSize(final long handle, |
| final long compactionReadaheadSize); |
| private native long compactionReadaheadSize(final long handle); |
| private native void setRandomAccessMaxBufferSize(final long handle, |
| final long randomAccessMaxBufferSize); |
| private native long randomAccessMaxBufferSize(final long handle); |
| private native void setWritableFileMaxBufferSize(final long handle, |
| final long writableFileMaxBufferSize); |
| private native long writableFileMaxBufferSize(final long handle); |
| private native void setUseAdaptiveMutex( |
| long handle, boolean useAdaptiveMutex); |
| private native boolean useAdaptiveMutex(long handle); |
| private native void setBytesPerSync( |
| long handle, long bytesPerSync); |
| private native long bytesPerSync(long handle); |
| private native void setWalBytesPerSync(long handle, long walBytesPerSync); |
| private native long walBytesPerSync(long handle); |
| private native void setEnableThreadTracking(long handle, |
| boolean enableThreadTracking); |
| private native boolean enableThreadTracking(long handle); |
| private native void setDelayedWriteRate(long handle, long delayedWriteRate); |
| private native long delayedWriteRate(long handle); |
| private native void setAllowConcurrentMemtableWrite(long handle, |
| boolean allowConcurrentMemtableWrite); |
| private native boolean allowConcurrentMemtableWrite(long handle); |
| private native void setEnableWriteThreadAdaptiveYield(long handle, |
| boolean enableWriteThreadAdaptiveYield); |
| private native boolean enableWriteThreadAdaptiveYield(long handle); |
| private native void setWriteThreadMaxYieldUsec(long handle, |
| long writeThreadMaxYieldUsec); |
| private native long writeThreadMaxYieldUsec(long handle); |
| private native void setWriteThreadSlowYieldUsec(long handle, |
| long writeThreadSlowYieldUsec); |
| private native long writeThreadSlowYieldUsec(long handle); |
| private native void setSkipStatsUpdateOnDbOpen(final long handle, |
| final boolean skipStatsUpdateOnDbOpen); |
| private native boolean skipStatsUpdateOnDbOpen(final long handle); |
| private native void setWalRecoveryMode(final long handle, |
| final byte walRecoveryMode); |
| private native byte walRecoveryMode(final long handle); |
| private native void setAllow2pc(final long handle, |
| final boolean allow2pc); |
| private native boolean allow2pc(final long handle); |
| private native void setRowCache(final long handle, |
| final long row_cache_handle); |
| private native void setFailIfOptionsFileError(final long handle, |
| final boolean failIfOptionsFileError); |
| private native boolean failIfOptionsFileError(final long handle); |
| private native void setDumpMallocStats(final long handle, |
| final boolean dumpMallocStats); |
| private native boolean dumpMallocStats(final long handle); |
| private native void setAvoidFlushDuringRecovery(final long handle, |
| final boolean avoidFlushDuringRecovery); |
| private native boolean avoidFlushDuringRecovery(final long handle); |
| private native void setAvoidFlushDuringShutdown(final long handle, |
| final boolean avoidFlushDuringShutdown); |
| private native boolean avoidFlushDuringShutdown(final long handle); |
| |
| // instance variables |
| private Env env_; |
| private int numShardBits_; |
| private RateLimiter rateLimiter_; |
| private Cache rowCache_; |
| } |