| // 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.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| |
| /** |
| * Options 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 |
| * automaticallyand native resources will be released as part of the process. |
| */ |
| public class Options extends RocksObject |
| implements DBOptionsInterface<Options>, ColumnFamilyOptionsInterface<Options>, |
| MutableColumnFamilyOptionsInterface<Options> { |
| static { |
| RocksDB.loadLibrary(); |
| } |
| |
| /** |
| * Construct options for opening a RocksDB. |
| * |
| * This constructor will create (by allocating a block of memory) |
| * an {@code rocksdb::Options} in the c++ side. |
| */ |
| public Options() { |
| super(newOptions()); |
| env_ = Env.getDefault(); |
| } |
| |
| /** |
| * Construct options for opening a RocksDB. Reusing database options |
| * and column family options. |
| * |
| * @param dbOptions {@link org.rocksdb.DBOptions} instance |
| * @param columnFamilyOptions {@link org.rocksdb.ColumnFamilyOptions} |
| * instance |
| */ |
| public Options(final DBOptions dbOptions, |
| final ColumnFamilyOptions columnFamilyOptions) { |
| super(newOptions(dbOptions.nativeHandle_, |
| columnFamilyOptions.nativeHandle_)); |
| env_ = Env.getDefault(); |
| } |
| |
| @Override |
| public Options setIncreaseParallelism(final int totalThreads) { |
| assert(isOwningHandle()); |
| setIncreaseParallelism(nativeHandle_, totalThreads); |
| return this; |
| } |
| |
| @Override |
| public Options setCreateIfMissing(final boolean flag) { |
| assert(isOwningHandle()); |
| setCreateIfMissing(nativeHandle_, flag); |
| return this; |
| } |
| |
| @Override |
| public Options setCreateMissingColumnFamilies(final boolean flag) { |
| assert(isOwningHandle()); |
| setCreateMissingColumnFamilies(nativeHandle_, flag); |
| return this; |
| } |
| |
| @Override |
| public Options setEnv(final Env env) { |
| assert(isOwningHandle()); |
| setEnv(nativeHandle_, env.nativeHandle_); |
| env_ = env; |
| return this; |
| } |
| |
| @Override |
| public Env getEnv() { |
| return env_; |
| } |
| |
| /** |
| * <p>Set appropriate parameters for bulk loading. |
| * The reason that this is a function that returns "this" instead of a |
| * constructor is to enable chaining of multiple similar calls in the future. |
| * </p> |
| * |
| * <p>All data will be in level 0 without any automatic compaction. |
| * It's recommended to manually call CompactRange(NULL, NULL) before reading |
| * from the database, because otherwise the read can be very slow.</p> |
| * |
| * @return the instance of the current Options. |
| */ |
| public Options prepareForBulkLoad() { |
| prepareForBulkLoad(nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public boolean createIfMissing() { |
| assert(isOwningHandle()); |
| return createIfMissing(nativeHandle_); |
| } |
| |
| @Override |
| public boolean createMissingColumnFamilies() { |
| assert(isOwningHandle()); |
| return createMissingColumnFamilies(nativeHandle_); |
| } |
| |
| @Override |
| public Options optimizeForSmallDb() { |
| optimizeForSmallDb(nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public Options optimizeForPointLookup( |
| long blockCacheSizeMb) { |
| optimizeForPointLookup(nativeHandle_, |
| blockCacheSizeMb); |
| return this; |
| } |
| |
| @Override |
| public Options optimizeLevelStyleCompaction() { |
| optimizeLevelStyleCompaction(nativeHandle_, |
| DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET); |
| return this; |
| } |
| |
| @Override |
| public Options optimizeLevelStyleCompaction( |
| long memtableMemoryBudget) { |
| optimizeLevelStyleCompaction(nativeHandle_, |
| memtableMemoryBudget); |
| return this; |
| } |
| |
| @Override |
| public Options optimizeUniversalStyleCompaction() { |
| optimizeUniversalStyleCompaction(nativeHandle_, |
| DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET); |
| return this; |
| } |
| |
| @Override |
| public Options optimizeUniversalStyleCompaction( |
| final long memtableMemoryBudget) { |
| optimizeUniversalStyleCompaction(nativeHandle_, |
| memtableMemoryBudget); |
| return this; |
| } |
| |
| @Override |
| public Options setComparator(final BuiltinComparator builtinComparator) { |
| assert(isOwningHandle()); |
| setComparatorHandle(nativeHandle_, builtinComparator.ordinal()); |
| return this; |
| } |
| |
| @Override |
| public Options setComparator( |
| final AbstractComparator<? extends AbstractSlice<?>> comparator) { |
| assert(isOwningHandle()); |
| setComparatorHandle(nativeHandle_, comparator.getNativeHandle()); |
| comparator_ = comparator; |
| return this; |
| } |
| |
| @Override |
| public Options setMergeOperatorName(final String name) { |
| assert(isOwningHandle()); |
| if (name == null) { |
| throw new IllegalArgumentException( |
| "Merge operator name must not be null."); |
| } |
| setMergeOperatorName(nativeHandle_, name); |
| return this; |
| } |
| |
| @Override |
| public Options setMergeOperator(final MergeOperator mergeOperator) { |
| setMergeOperator(nativeHandle_, mergeOperator.nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public Options setWriteBufferSize(final long writeBufferSize) { |
| assert(isOwningHandle()); |
| setWriteBufferSize(nativeHandle_, writeBufferSize); |
| return this; |
| } |
| |
| @Override |
| public long writeBufferSize() { |
| assert(isOwningHandle()); |
| return writeBufferSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxWriteBufferNumber(final int maxWriteBufferNumber) { |
| assert(isOwningHandle()); |
| setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber); |
| return this; |
| } |
| |
| @Override |
| public int maxWriteBufferNumber() { |
| assert(isOwningHandle()); |
| return maxWriteBufferNumber(nativeHandle_); |
| } |
| |
| @Override |
| public boolean errorIfExists() { |
| assert(isOwningHandle()); |
| return errorIfExists(nativeHandle_); |
| } |
| |
| @Override |
| public Options setErrorIfExists(final boolean errorIfExists) { |
| assert(isOwningHandle()); |
| setErrorIfExists(nativeHandle_, errorIfExists); |
| return this; |
| } |
| |
| @Override |
| public boolean paranoidChecks() { |
| assert(isOwningHandle()); |
| return paranoidChecks(nativeHandle_); |
| } |
| |
| @Override |
| public Options setParanoidChecks(final boolean paranoidChecks) { |
| assert(isOwningHandle()); |
| setParanoidChecks(nativeHandle_, paranoidChecks); |
| return this; |
| } |
| |
| @Override |
| public int maxOpenFiles() { |
| assert(isOwningHandle()); |
| return maxOpenFiles(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxFileOpeningThreads(final int maxFileOpeningThreads) { |
| assert(isOwningHandle()); |
| setMaxFileOpeningThreads(nativeHandle_, maxFileOpeningThreads); |
| return this; |
| } |
| |
| @Override |
| public int maxFileOpeningThreads() { |
| assert(isOwningHandle()); |
| return maxFileOpeningThreads(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxTotalWalSize(final long maxTotalWalSize) { |
| assert(isOwningHandle()); |
| setMaxTotalWalSize(nativeHandle_, maxTotalWalSize); |
| return this; |
| } |
| |
| @Override |
| public long maxTotalWalSize() { |
| assert(isOwningHandle()); |
| return maxTotalWalSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxOpenFiles(final int maxOpenFiles) { |
| assert(isOwningHandle()); |
| setMaxOpenFiles(nativeHandle_, maxOpenFiles); |
| return this; |
| } |
| |
| @Override |
| public boolean useFsync() { |
| assert(isOwningHandle()); |
| return useFsync(nativeHandle_); |
| } |
| |
| @Override |
| public Options setUseFsync(final boolean useFsync) { |
| assert(isOwningHandle()); |
| setUseFsync(nativeHandle_, useFsync); |
| return this; |
| } |
| |
| @Override |
| public Options 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 String dbLogDir() { |
| assert(isOwningHandle()); |
| return dbLogDir(nativeHandle_); |
| } |
| |
| @Override |
| public Options setDbLogDir(final String dbLogDir) { |
| assert(isOwningHandle()); |
| setDbLogDir(nativeHandle_, dbLogDir); |
| return this; |
| } |
| |
| @Override |
| public String walDir() { |
| assert(isOwningHandle()); |
| return walDir(nativeHandle_); |
| } |
| |
| @Override |
| public Options setWalDir(final String walDir) { |
| assert(isOwningHandle()); |
| setWalDir(nativeHandle_, walDir); |
| return this; |
| } |
| |
| @Override |
| public long deleteObsoleteFilesPeriodMicros() { |
| assert(isOwningHandle()); |
| return deleteObsoleteFilesPeriodMicros(nativeHandle_); |
| } |
| |
| @Override |
| public Options setDeleteObsoleteFilesPeriodMicros( |
| final long micros) { |
| assert(isOwningHandle()); |
| setDeleteObsoleteFilesPeriodMicros(nativeHandle_, micros); |
| return this; |
| } |
| |
| @Override |
| public int maxBackgroundCompactions() { |
| assert(isOwningHandle()); |
| return maxBackgroundCompactions(nativeHandle_); |
| } |
| |
| @Override |
| public Options 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 void setBaseBackgroundCompactions( |
| final int baseBackgroundCompactions) { |
| assert(isOwningHandle()); |
| setBaseBackgroundCompactions(nativeHandle_, baseBackgroundCompactions); |
| } |
| |
| @Override |
| public int baseBackgroundCompactions() { |
| assert(isOwningHandle()); |
| return baseBackgroundCompactions(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxBackgroundCompactions( |
| final int maxBackgroundCompactions) { |
| assert(isOwningHandle()); |
| setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions); |
| return this; |
| } |
| |
| @Override |
| public void setMaxSubcompactions(final int maxSubcompactions) { |
| assert(isOwningHandle()); |
| setMaxSubcompactions(nativeHandle_, maxSubcompactions); |
| } |
| |
| @Override |
| public int maxSubcompactions() { |
| assert(isOwningHandle()); |
| return maxSubcompactions(nativeHandle_); |
| } |
| |
| @Override |
| public int maxBackgroundFlushes() { |
| assert(isOwningHandle()); |
| return maxBackgroundFlushes(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxBackgroundFlushes( |
| final int maxBackgroundFlushes) { |
| assert(isOwningHandle()); |
| setMaxBackgroundFlushes(nativeHandle_, maxBackgroundFlushes); |
| return this; |
| } |
| |
| @Override |
| public long maxLogFileSize() { |
| assert(isOwningHandle()); |
| return maxLogFileSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxLogFileSize(final long maxLogFileSize) { |
| assert(isOwningHandle()); |
| setMaxLogFileSize(nativeHandle_, maxLogFileSize); |
| return this; |
| } |
| |
| @Override |
| public long logFileTimeToRoll() { |
| assert(isOwningHandle()); |
| return logFileTimeToRoll(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLogFileTimeToRoll(final long logFileTimeToRoll) { |
| assert(isOwningHandle()); |
| setLogFileTimeToRoll(nativeHandle_, logFileTimeToRoll); |
| return this; |
| } |
| |
| @Override |
| public long keepLogFileNum() { |
| assert(isOwningHandle()); |
| return keepLogFileNum(nativeHandle_); |
| } |
| |
| @Override |
| public Options setKeepLogFileNum(final long keepLogFileNum) { |
| assert(isOwningHandle()); |
| setKeepLogFileNum(nativeHandle_, keepLogFileNum); |
| return this; |
| } |
| |
| |
| @Override |
| public Options setRecycleLogFileNum(final long recycleLogFileNum) { |
| assert(isOwningHandle()); |
| setRecycleLogFileNum(nativeHandle_, recycleLogFileNum); |
| return this; |
| } |
| |
| @Override |
| public long recycleLogFileNum() { |
| assert(isOwningHandle()); |
| return recycleLogFileNum(nativeHandle_); |
| } |
| |
| @Override |
| public long maxManifestFileSize() { |
| assert(isOwningHandle()); |
| return maxManifestFileSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxManifestFileSize( |
| final long maxManifestFileSize) { |
| assert(isOwningHandle()); |
| setMaxManifestFileSize(nativeHandle_, maxManifestFileSize); |
| return this; |
| } |
| |
| @Override |
| public Options setMaxTableFilesSizeFIFO( |
| final long maxTableFilesSize) { |
| assert(maxTableFilesSize > 0); // unsigned native type |
| assert(isOwningHandle()); |
| setMaxTableFilesSizeFIFO(nativeHandle_, maxTableFilesSize); |
| return this; |
| } |
| |
| @Override |
| public long maxTableFilesSizeFIFO() { |
| return maxTableFilesSizeFIFO(nativeHandle_); |
| } |
| |
| @Override |
| public int tableCacheNumshardbits() { |
| assert(isOwningHandle()); |
| return tableCacheNumshardbits(nativeHandle_); |
| } |
| |
| @Override |
| public Options setTableCacheNumshardbits( |
| final int tableCacheNumshardbits) { |
| assert(isOwningHandle()); |
| setTableCacheNumshardbits(nativeHandle_, tableCacheNumshardbits); |
| return this; |
| } |
| |
| @Override |
| public long walTtlSeconds() { |
| assert(isOwningHandle()); |
| return walTtlSeconds(nativeHandle_); |
| } |
| |
| @Override |
| public Options setWalTtlSeconds(final long walTtlSeconds) { |
| assert(isOwningHandle()); |
| setWalTtlSeconds(nativeHandle_, walTtlSeconds); |
| return this; |
| } |
| |
| @Override |
| public long walSizeLimitMB() { |
| assert(isOwningHandle()); |
| return walSizeLimitMB(nativeHandle_); |
| } |
| |
| @Override |
| public Options setWalSizeLimitMB(final long sizeLimitMB) { |
| assert(isOwningHandle()); |
| setWalSizeLimitMB(nativeHandle_, sizeLimitMB); |
| return this; |
| } |
| |
| @Override |
| public long manifestPreallocationSize() { |
| assert(isOwningHandle()); |
| return manifestPreallocationSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setManifestPreallocationSize(final long size) { |
| assert(isOwningHandle()); |
| setManifestPreallocationSize(nativeHandle_, size); |
| return this; |
| } |
| |
| @Override |
| public Options setUseDirectReads(final boolean useDirectReads) { |
| assert(isOwningHandle()); |
| setUseDirectReads(nativeHandle_, useDirectReads); |
| return this; |
| } |
| |
| @Override |
| public boolean useDirectReads() { |
| assert(isOwningHandle()); |
| return useDirectReads(nativeHandle_); |
| } |
| |
| @Override |
| public Options setUseDirectIoForFlushAndCompaction( |
| final boolean useDirectIoForFlushAndCompaction) { |
| assert(isOwningHandle()); |
| setUseDirectIoForFlushAndCompaction(nativeHandle_, useDirectIoForFlushAndCompaction); |
| return this; |
| } |
| |
| @Override |
| public boolean useDirectIoForFlushAndCompaction() { |
| assert(isOwningHandle()); |
| return useDirectIoForFlushAndCompaction(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAllowFAllocate(final boolean allowFAllocate) { |
| assert(isOwningHandle()); |
| setAllowFAllocate(nativeHandle_, allowFAllocate); |
| return this; |
| } |
| |
| @Override |
| public boolean allowFAllocate() { |
| assert(isOwningHandle()); |
| return allowFAllocate(nativeHandle_); |
| } |
| |
| @Override |
| public boolean allowMmapReads() { |
| assert(isOwningHandle()); |
| return allowMmapReads(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAllowMmapReads(final boolean allowMmapReads) { |
| assert(isOwningHandle()); |
| setAllowMmapReads(nativeHandle_, allowMmapReads); |
| return this; |
| } |
| |
| @Override |
| public boolean allowMmapWrites() { |
| assert(isOwningHandle()); |
| return allowMmapWrites(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAllowMmapWrites(final boolean allowMmapWrites) { |
| assert(isOwningHandle()); |
| setAllowMmapWrites(nativeHandle_, allowMmapWrites); |
| return this; |
| } |
| |
| @Override |
| public boolean isFdCloseOnExec() { |
| assert(isOwningHandle()); |
| return isFdCloseOnExec(nativeHandle_); |
| } |
| |
| @Override |
| public Options setIsFdCloseOnExec(final boolean isFdCloseOnExec) { |
| assert(isOwningHandle()); |
| setIsFdCloseOnExec(nativeHandle_, isFdCloseOnExec); |
| return this; |
| } |
| |
| @Override |
| public int statsDumpPeriodSec() { |
| assert(isOwningHandle()); |
| return statsDumpPeriodSec(nativeHandle_); |
| } |
| |
| @Override |
| public Options setStatsDumpPeriodSec(final int statsDumpPeriodSec) { |
| assert(isOwningHandle()); |
| setStatsDumpPeriodSec(nativeHandle_, statsDumpPeriodSec); |
| return this; |
| } |
| |
| @Override |
| public boolean adviseRandomOnOpen() { |
| return adviseRandomOnOpen(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAdviseRandomOnOpen(final boolean adviseRandomOnOpen) { |
| assert(isOwningHandle()); |
| setAdviseRandomOnOpen(nativeHandle_, adviseRandomOnOpen); |
| return this; |
| } |
| |
| @Override |
| public Options setDbWriteBufferSize(final long dbWriteBufferSize) { |
| assert(isOwningHandle()); |
| setDbWriteBufferSize(nativeHandle_, dbWriteBufferSize); |
| return this; |
| } |
| |
| @Override |
| public long dbWriteBufferSize() { |
| assert(isOwningHandle()); |
| return dbWriteBufferSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options 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 Options setNewTableReaderForCompactionInputs( |
| final boolean newTableReaderForCompactionInputs) { |
| assert(isOwningHandle()); |
| setNewTableReaderForCompactionInputs(nativeHandle_, |
| newTableReaderForCompactionInputs); |
| return this; |
| } |
| |
| @Override |
| public boolean newTableReaderForCompactionInputs() { |
| assert(isOwningHandle()); |
| return newTableReaderForCompactionInputs(nativeHandle_); |
| } |
| |
| @Override |
| public Options setCompactionReadaheadSize(final long compactionReadaheadSize) { |
| assert(isOwningHandle()); |
| setCompactionReadaheadSize(nativeHandle_, compactionReadaheadSize); |
| return this; |
| } |
| |
| @Override |
| public long compactionReadaheadSize() { |
| assert(isOwningHandle()); |
| return compactionReadaheadSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) { |
| assert(isOwningHandle()); |
| setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize); |
| return this; |
| } |
| |
| @Override |
| public long randomAccessMaxBufferSize() { |
| assert(isOwningHandle()); |
| return randomAccessMaxBufferSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) { |
| assert(isOwningHandle()); |
| setWritableFileMaxBufferSize(nativeHandle_, writableFileMaxBufferSize); |
| return this; |
| } |
| |
| @Override |
| public long writableFileMaxBufferSize() { |
| assert(isOwningHandle()); |
| return writableFileMaxBufferSize(nativeHandle_); |
| } |
| |
| @Override |
| public boolean useAdaptiveMutex() { |
| assert(isOwningHandle()); |
| return useAdaptiveMutex(nativeHandle_); |
| } |
| |
| @Override |
| public Options setUseAdaptiveMutex(final boolean useAdaptiveMutex) { |
| assert(isOwningHandle()); |
| setUseAdaptiveMutex(nativeHandle_, useAdaptiveMutex); |
| return this; |
| } |
| |
| @Override |
| public long bytesPerSync() { |
| return bytesPerSync(nativeHandle_); |
| } |
| |
| @Override |
| public Options setBytesPerSync(final long bytesPerSync) { |
| assert(isOwningHandle()); |
| setBytesPerSync(nativeHandle_, bytesPerSync); |
| return this; |
| } |
| |
| @Override |
| public Options setWalBytesPerSync(final long walBytesPerSync) { |
| assert(isOwningHandle()); |
| setWalBytesPerSync(nativeHandle_, walBytesPerSync); |
| return this; |
| } |
| |
| @Override |
| public long walBytesPerSync() { |
| assert(isOwningHandle()); |
| return walBytesPerSync(nativeHandle_); |
| } |
| |
| @Override |
| public Options setEnableThreadTracking(final boolean enableThreadTracking) { |
| assert(isOwningHandle()); |
| setEnableThreadTracking(nativeHandle_, enableThreadTracking); |
| return this; |
| } |
| |
| @Override |
| public boolean enableThreadTracking() { |
| assert(isOwningHandle()); |
| return enableThreadTracking(nativeHandle_); |
| } |
| |
| @Override |
| public Options setDelayedWriteRate(final long delayedWriteRate) { |
| assert(isOwningHandle()); |
| setDelayedWriteRate(nativeHandle_, delayedWriteRate); |
| return this; |
| } |
| |
| @Override |
| public long delayedWriteRate(){ |
| return delayedWriteRate(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAllowConcurrentMemtableWrite( |
| final boolean allowConcurrentMemtableWrite) { |
| setAllowConcurrentMemtableWrite(nativeHandle_, |
| allowConcurrentMemtableWrite); |
| return this; |
| } |
| |
| @Override |
| public boolean allowConcurrentMemtableWrite() { |
| return allowConcurrentMemtableWrite(nativeHandle_); |
| } |
| |
| @Override |
| public Options setEnableWriteThreadAdaptiveYield( |
| final boolean enableWriteThreadAdaptiveYield) { |
| setEnableWriteThreadAdaptiveYield(nativeHandle_, |
| enableWriteThreadAdaptiveYield); |
| return this; |
| } |
| |
| @Override |
| public boolean enableWriteThreadAdaptiveYield() { |
| return enableWriteThreadAdaptiveYield(nativeHandle_); |
| } |
| |
| @Override |
| public Options setWriteThreadMaxYieldUsec(final long writeThreadMaxYieldUsec) { |
| setWriteThreadMaxYieldUsec(nativeHandle_, writeThreadMaxYieldUsec); |
| return this; |
| } |
| |
| @Override |
| public long writeThreadMaxYieldUsec() { |
| return writeThreadMaxYieldUsec(nativeHandle_); |
| } |
| |
| @Override |
| public Options setWriteThreadSlowYieldUsec(final long writeThreadSlowYieldUsec) { |
| setWriteThreadSlowYieldUsec(nativeHandle_, writeThreadSlowYieldUsec); |
| return this; |
| } |
| |
| @Override |
| public long writeThreadSlowYieldUsec() { |
| return writeThreadSlowYieldUsec(nativeHandle_); |
| } |
| |
| @Override |
| public Options setSkipStatsUpdateOnDbOpen(final boolean skipStatsUpdateOnDbOpen) { |
| assert(isOwningHandle()); |
| setSkipStatsUpdateOnDbOpen(nativeHandle_, skipStatsUpdateOnDbOpen); |
| return this; |
| } |
| |
| @Override |
| public boolean skipStatsUpdateOnDbOpen() { |
| assert(isOwningHandle()); |
| return skipStatsUpdateOnDbOpen(nativeHandle_); |
| } |
| |
| @Override |
| public Options 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 Options setAllow2pc(final boolean allow2pc) { |
| assert(isOwningHandle()); |
| setAllow2pc(nativeHandle_, allow2pc); |
| return this; |
| } |
| |
| @Override |
| public boolean allow2pc() { |
| assert(isOwningHandle()); |
| return allow2pc(nativeHandle_); |
| } |
| |
| @Override |
| public Options 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 Options setFailIfOptionsFileError(final boolean failIfOptionsFileError) { |
| assert(isOwningHandle()); |
| setFailIfOptionsFileError(nativeHandle_, failIfOptionsFileError); |
| return this; |
| } |
| |
| @Override |
| public boolean failIfOptionsFileError() { |
| assert(isOwningHandle()); |
| return failIfOptionsFileError(nativeHandle_); |
| } |
| |
| @Override |
| public Options setDumpMallocStats(final boolean dumpMallocStats) { |
| assert(isOwningHandle()); |
| setDumpMallocStats(nativeHandle_, dumpMallocStats); |
| return this; |
| } |
| |
| @Override |
| public boolean dumpMallocStats() { |
| assert(isOwningHandle()); |
| return dumpMallocStats(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAvoidFlushDuringRecovery(final boolean avoidFlushDuringRecovery) { |
| assert(isOwningHandle()); |
| setAvoidFlushDuringRecovery(nativeHandle_, avoidFlushDuringRecovery); |
| return this; |
| } |
| |
| @Override |
| public boolean avoidFlushDuringRecovery() { |
| assert(isOwningHandle()); |
| return avoidFlushDuringRecovery(nativeHandle_); |
| } |
| |
| @Override |
| public Options setAvoidFlushDuringShutdown(final boolean avoidFlushDuringShutdown) { |
| assert(isOwningHandle()); |
| setAvoidFlushDuringShutdown(nativeHandle_, avoidFlushDuringShutdown); |
| return this; |
| } |
| |
| @Override |
| public boolean avoidFlushDuringShutdown() { |
| assert(isOwningHandle()); |
| return avoidFlushDuringShutdown(nativeHandle_); |
| } |
| |
| @Override |
| public MemTableConfig memTableConfig() { |
| return this.memTableConfig_; |
| } |
| |
| @Override |
| public Options setMemTableConfig(final MemTableConfig config) { |
| memTableConfig_ = config; |
| setMemTableFactory(nativeHandle_, config.newMemTableFactoryHandle()); |
| return this; |
| } |
| |
| @Override |
| public Options setRateLimiter(final RateLimiter rateLimiter) { |
| assert(isOwningHandle()); |
| rateLimiter_ = rateLimiter; |
| setRateLimiter(nativeHandle_, rateLimiter.nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public Options setLogger(final Logger logger) { |
| assert(isOwningHandle()); |
| setLogger(nativeHandle_, logger.nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public Options 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 String memTableFactoryName() { |
| assert(isOwningHandle()); |
| return memTableFactoryName(nativeHandle_); |
| } |
| |
| @Override |
| public TableFormatConfig tableFormatConfig() { |
| return this.tableFormatConfig_; |
| } |
| |
| @Override |
| public Options setTableFormatConfig(final TableFormatConfig config) { |
| tableFormatConfig_ = config; |
| setTableFactory(nativeHandle_, config.newTableFactoryHandle()); |
| return this; |
| } |
| |
| @Override |
| public String tableFactoryName() { |
| assert(isOwningHandle()); |
| return tableFactoryName(nativeHandle_); |
| } |
| |
| @Override |
| public Options useFixedLengthPrefixExtractor(final int n) { |
| assert(isOwningHandle()); |
| useFixedLengthPrefixExtractor(nativeHandle_, n); |
| return this; |
| } |
| |
| @Override |
| public Options useCappedPrefixExtractor(final int n) { |
| assert(isOwningHandle()); |
| useCappedPrefixExtractor(nativeHandle_, n); |
| return this; |
| } |
| |
| @Override |
| public CompressionType compressionType() { |
| return CompressionType.getCompressionType(compressionType(nativeHandle_)); |
| } |
| |
| @Override |
| public Options setCompressionPerLevel( |
| final List<CompressionType> compressionLevels) { |
| final byte[] byteCompressionTypes = new byte[ |
| compressionLevels.size()]; |
| for (int i = 0; i < compressionLevels.size(); i++) { |
| byteCompressionTypes[i] = compressionLevels.get(i).getValue(); |
| } |
| setCompressionPerLevel(nativeHandle_, byteCompressionTypes); |
| return this; |
| } |
| |
| @Override |
| public List<CompressionType> compressionPerLevel() { |
| final byte[] byteCompressionTypes = |
| compressionPerLevel(nativeHandle_); |
| final List<CompressionType> compressionLevels = new ArrayList<>(); |
| for (final Byte byteCompressionType : byteCompressionTypes) { |
| compressionLevels.add(CompressionType.getCompressionType( |
| byteCompressionType)); |
| } |
| return compressionLevels; |
| } |
| |
| @Override |
| public Options setCompressionType(CompressionType compressionType) { |
| setCompressionType(nativeHandle_, compressionType.getValue()); |
| return this; |
| } |
| |
| |
| @Override |
| public Options setBottommostCompressionType( |
| final CompressionType bottommostCompressionType) { |
| setBottommostCompressionType(nativeHandle_, |
| bottommostCompressionType.getValue()); |
| return this; |
| } |
| |
| @Override |
| public CompressionType bottommostCompressionType() { |
| return CompressionType.getCompressionType( |
| bottommostCompressionType(nativeHandle_)); |
| } |
| |
| @Override |
| public Options setCompressionOptions( |
| final CompressionOptions compressionOptions) { |
| setCompressionOptions(nativeHandle_, compressionOptions.nativeHandle_); |
| this.compressionOptions_ = compressionOptions; |
| return this; |
| } |
| |
| @Override |
| public CompressionOptions compressionOptions() { |
| return this.compressionOptions_; |
| } |
| |
| @Override |
| public CompactionStyle compactionStyle() { |
| return CompactionStyle.values()[compactionStyle(nativeHandle_)]; |
| } |
| |
| @Override |
| public Options setCompactionStyle( |
| final CompactionStyle compactionStyle) { |
| setCompactionStyle(nativeHandle_, compactionStyle.getValue()); |
| return this; |
| } |
| |
| @Override |
| public int numLevels() { |
| return numLevels(nativeHandle_); |
| } |
| |
| @Override |
| public Options setNumLevels(int numLevels) { |
| setNumLevels(nativeHandle_, numLevels); |
| return this; |
| } |
| |
| @Override |
| public int levelZeroFileNumCompactionTrigger() { |
| return levelZeroFileNumCompactionTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevelZeroFileNumCompactionTrigger( |
| final int numFiles) { |
| setLevelZeroFileNumCompactionTrigger( |
| nativeHandle_, numFiles); |
| return this; |
| } |
| |
| @Override |
| public int levelZeroSlowdownWritesTrigger() { |
| return levelZeroSlowdownWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevelZeroSlowdownWritesTrigger( |
| final int numFiles) { |
| setLevelZeroSlowdownWritesTrigger(nativeHandle_, numFiles); |
| return this; |
| } |
| |
| @Override |
| public int levelZeroStopWritesTrigger() { |
| return levelZeroStopWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevelZeroStopWritesTrigger( |
| final int numFiles) { |
| setLevelZeroStopWritesTrigger(nativeHandle_, numFiles); |
| return this; |
| } |
| |
| @Override |
| public long targetFileSizeBase() { |
| return targetFileSizeBase(nativeHandle_); |
| } |
| |
| @Override |
| public Options setTargetFileSizeBase(long targetFileSizeBase) { |
| setTargetFileSizeBase(nativeHandle_, targetFileSizeBase); |
| return this; |
| } |
| |
| @Override |
| public int targetFileSizeMultiplier() { |
| return targetFileSizeMultiplier(nativeHandle_); |
| } |
| |
| @Override |
| public Options setTargetFileSizeMultiplier(int multiplier) { |
| setTargetFileSizeMultiplier(nativeHandle_, multiplier); |
| return this; |
| } |
| |
| @Override |
| public Options setMaxBytesForLevelBase(final long maxBytesForLevelBase) { |
| setMaxBytesForLevelBase(nativeHandle_, maxBytesForLevelBase); |
| return this; |
| } |
| |
| @Override |
| public long maxBytesForLevelBase() { |
| return maxBytesForLevelBase(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevelCompactionDynamicLevelBytes( |
| final boolean enableLevelCompactionDynamicLevelBytes) { |
| setLevelCompactionDynamicLevelBytes(nativeHandle_, |
| enableLevelCompactionDynamicLevelBytes); |
| return this; |
| } |
| |
| @Override |
| public boolean levelCompactionDynamicLevelBytes() { |
| return levelCompactionDynamicLevelBytes(nativeHandle_); |
| } |
| |
| @Override |
| public double maxBytesForLevelMultiplier() { |
| return maxBytesForLevelMultiplier(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxBytesForLevelMultiplier(final double multiplier) { |
| setMaxBytesForLevelMultiplier(nativeHandle_, multiplier); |
| return this; |
| } |
| |
| @Override |
| public long maxCompactionBytes() { |
| return maxCompactionBytes(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxCompactionBytes(final long maxCompactionBytes) { |
| setMaxCompactionBytes(nativeHandle_, maxCompactionBytes); |
| return this; |
| } |
| |
| @Override |
| public long arenaBlockSize() { |
| return arenaBlockSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setArenaBlockSize(final long arenaBlockSize) { |
| setArenaBlockSize(nativeHandle_, arenaBlockSize); |
| return this; |
| } |
| |
| @Override |
| public boolean disableAutoCompactions() { |
| return disableAutoCompactions(nativeHandle_); |
| } |
| |
| @Override |
| public Options setDisableAutoCompactions( |
| final boolean disableAutoCompactions) { |
| setDisableAutoCompactions(nativeHandle_, disableAutoCompactions); |
| return this; |
| } |
| |
| @Override |
| public long maxSequentialSkipInIterations() { |
| return maxSequentialSkipInIterations(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxSequentialSkipInIterations( |
| final long maxSequentialSkipInIterations) { |
| setMaxSequentialSkipInIterations(nativeHandle_, |
| maxSequentialSkipInIterations); |
| return this; |
| } |
| |
| @Override |
| public boolean inplaceUpdateSupport() { |
| return inplaceUpdateSupport(nativeHandle_); |
| } |
| |
| @Override |
| public Options setInplaceUpdateSupport( |
| final boolean inplaceUpdateSupport) { |
| setInplaceUpdateSupport(nativeHandle_, inplaceUpdateSupport); |
| return this; |
| } |
| |
| @Override |
| public long inplaceUpdateNumLocks() { |
| return inplaceUpdateNumLocks(nativeHandle_); |
| } |
| |
| @Override |
| public Options setInplaceUpdateNumLocks( |
| final long inplaceUpdateNumLocks) { |
| setInplaceUpdateNumLocks(nativeHandle_, inplaceUpdateNumLocks); |
| return this; |
| } |
| |
| @Override |
| public double memtablePrefixBloomSizeRatio() { |
| return memtablePrefixBloomSizeRatio(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMemtablePrefixBloomSizeRatio(final double memtablePrefixBloomSizeRatio) { |
| setMemtablePrefixBloomSizeRatio(nativeHandle_, memtablePrefixBloomSizeRatio); |
| return this; |
| } |
| |
| @Override |
| public int bloomLocality() { |
| return bloomLocality(nativeHandle_); |
| } |
| |
| @Override |
| public Options setBloomLocality(final int bloomLocality) { |
| setBloomLocality(nativeHandle_, bloomLocality); |
| return this; |
| } |
| |
| @Override |
| public long maxSuccessiveMerges() { |
| return maxSuccessiveMerges(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxSuccessiveMerges(long maxSuccessiveMerges) { |
| setMaxSuccessiveMerges(nativeHandle_, maxSuccessiveMerges); |
| return this; |
| } |
| |
| @Override |
| public int minWriteBufferNumberToMerge() { |
| return minWriteBufferNumberToMerge(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMinWriteBufferNumberToMerge( |
| final int minWriteBufferNumberToMerge) { |
| setMinWriteBufferNumberToMerge(nativeHandle_, minWriteBufferNumberToMerge); |
| return this; |
| } |
| |
| @Override |
| public Options setOptimizeFiltersForHits( |
| final boolean optimizeFiltersForHits) { |
| setOptimizeFiltersForHits(nativeHandle_, optimizeFiltersForHits); |
| return this; |
| } |
| |
| @Override |
| public boolean optimizeFiltersForHits() { |
| return optimizeFiltersForHits(nativeHandle_); |
| } |
| |
| @Override |
| public Options |
| setMemtableHugePageSize( |
| long memtableHugePageSize) { |
| setMemtableHugePageSize(nativeHandle_, |
| memtableHugePageSize); |
| return this; |
| } |
| |
| @Override |
| public long memtableHugePageSize() { |
| return memtableHugePageSize(nativeHandle_); |
| } |
| |
| @Override |
| public Options setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit) { |
| setSoftPendingCompactionBytesLimit(nativeHandle_, |
| softPendingCompactionBytesLimit); |
| return this; |
| } |
| |
| @Override |
| public long softPendingCompactionBytesLimit() { |
| return softPendingCompactionBytesLimit(nativeHandle_); |
| } |
| |
| @Override |
| public Options setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit) { |
| setHardPendingCompactionBytesLimit(nativeHandle_, hardPendingCompactionBytesLimit); |
| return this; |
| } |
| |
| @Override |
| public long hardPendingCompactionBytesLimit() { |
| return hardPendingCompactionBytesLimit(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger) { |
| setLevel0FileNumCompactionTrigger(nativeHandle_, level0FileNumCompactionTrigger); |
| return this; |
| } |
| |
| @Override |
| public int level0FileNumCompactionTrigger() { |
| return level0FileNumCompactionTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger) { |
| setLevel0SlowdownWritesTrigger(nativeHandle_, level0SlowdownWritesTrigger); |
| return this; |
| } |
| |
| @Override |
| public int level0SlowdownWritesTrigger() { |
| return level0SlowdownWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public Options setLevel0StopWritesTrigger(int level0StopWritesTrigger) { |
| setLevel0StopWritesTrigger(nativeHandle_, level0StopWritesTrigger); |
| return this; |
| } |
| |
| @Override |
| public int level0StopWritesTrigger() { |
| return level0StopWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional) { |
| setMaxBytesForLevelMultiplierAdditional(nativeHandle_, maxBytesForLevelMultiplierAdditional); |
| return this; |
| } |
| |
| @Override |
| public int[] maxBytesForLevelMultiplierAdditional() { |
| return maxBytesForLevelMultiplierAdditional(nativeHandle_); |
| } |
| |
| @Override |
| public Options setParanoidFileChecks(boolean paranoidFileChecks) { |
| setParanoidFileChecks(nativeHandle_, paranoidFileChecks); |
| return this; |
| } |
| |
| @Override |
| public boolean paranoidFileChecks() { |
| return paranoidFileChecks(nativeHandle_); |
| } |
| |
| @Override |
| public Options setMaxWriteBufferNumberToMaintain( |
| final int maxWriteBufferNumberToMaintain) { |
| setMaxWriteBufferNumberToMaintain( |
| nativeHandle_, maxWriteBufferNumberToMaintain); |
| return this; |
| } |
| |
| @Override |
| public int maxWriteBufferNumberToMaintain() { |
| return maxWriteBufferNumberToMaintain(nativeHandle_); |
| } |
| |
| @Override |
| public Options setCompactionPriority( |
| final CompactionPriority compactionPriority) { |
| setCompactionPriority(nativeHandle_, compactionPriority.getValue()); |
| return this; |
| } |
| |
| @Override |
| public CompactionPriority compactionPriority() { |
| return CompactionPriority.getCompactionPriority( |
| compactionPriority(nativeHandle_)); |
| } |
| |
| @Override |
| public Options setReportBgIoStats(final boolean reportBgIoStats) { |
| setReportBgIoStats(nativeHandle_, reportBgIoStats); |
| return this; |
| } |
| |
| @Override |
| public boolean reportBgIoStats() { |
| return reportBgIoStats(nativeHandle_); |
| } |
| |
| @Override |
| public Options setCompactionOptionsUniversal( |
| final CompactionOptionsUniversal compactionOptionsUniversal) { |
| setCompactionOptionsUniversal(nativeHandle_, |
| compactionOptionsUniversal.nativeHandle_); |
| this.compactionOptionsUniversal_ = compactionOptionsUniversal; |
| return this; |
| } |
| |
| @Override |
| public CompactionOptionsUniversal compactionOptionsUniversal() { |
| return this.compactionOptionsUniversal_; |
| } |
| |
| @Override |
| public Options setCompactionOptionsFIFO(final CompactionOptionsFIFO compactionOptionsFIFO) { |
| setCompactionOptionsFIFO(nativeHandle_, |
| compactionOptionsFIFO.nativeHandle_); |
| this.compactionOptionsFIFO_ = compactionOptionsFIFO; |
| return this; |
| } |
| |
| @Override |
| public CompactionOptionsFIFO compactionOptionsFIFO() { |
| return this.compactionOptionsFIFO_; |
| } |
| |
| @Override |
| public Options setForceConsistencyChecks(final boolean forceConsistencyChecks) { |
| setForceConsistencyChecks(nativeHandle_, forceConsistencyChecks); |
| return this; |
| } |
| |
| @Override |
| public boolean forceConsistencyChecks() { |
| return forceConsistencyChecks(nativeHandle_); |
| } |
| |
| private native static long newOptions(); |
| private native static long newOptions(long dbOptHandle, |
| long cfOptHandle); |
| @Override protected final native void disposeInternal(final long handle); |
| private native void setEnv(long optHandle, long envHandle); |
| private native void prepareForBulkLoad(long handle); |
| |
| // DB native handles |
| 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 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 setMaxTotalWalSize(long handle, |
| long maxTotalWalSize); |
| private native void setMaxFileOpeningThreads(final long handle, |
| final int maxFileOpeningThreads); |
| private native int maxFileOpeningThreads(final long handle); |
| 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 setMaxTableFilesSizeFIFO( |
| long handle, long maxTableFilesSize); |
| private native long maxTableFilesSizeFIFO(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); |
| |
| // CF native handles |
| private native void optimizeForSmallDb(final long handle); |
| private native void optimizeForPointLookup(long handle, |
| long blockCacheSizeMb); |
| private native void optimizeLevelStyleCompaction(long handle, |
| long memtableMemoryBudget); |
| private native void optimizeUniversalStyleCompaction(long handle, |
| long memtableMemoryBudget); |
| private native void setComparatorHandle(long handle, int builtinComparator); |
| private native void setComparatorHandle(long optHandle, |
| long comparatorHandle); |
| private native void setMergeOperatorName( |
| long handle, String name); |
| private native void setMergeOperator( |
| long handle, long mergeOperatorHandle); |
| private native void setWriteBufferSize(long handle, long writeBufferSize) |
| throws IllegalArgumentException; |
| private native long writeBufferSize(long handle); |
| private native void setMaxWriteBufferNumber( |
| long handle, int maxWriteBufferNumber); |
| private native int maxWriteBufferNumber(long handle); |
| private native void setMinWriteBufferNumberToMerge( |
| long handle, int minWriteBufferNumberToMerge); |
| private native int minWriteBufferNumberToMerge(long handle); |
| private native void setCompressionType(long handle, byte compressionType); |
| private native byte compressionType(long handle); |
| private native void setCompressionPerLevel(long handle, |
| byte[] compressionLevels); |
| private native byte[] compressionPerLevel(long handle); |
| private native void setBottommostCompressionType(long handle, |
| byte bottommostCompressionType); |
| private native byte bottommostCompressionType(long handle); |
| private native void setCompressionOptions(long handle, |
| long compressionOptionsHandle); |
| private native void useFixedLengthPrefixExtractor( |
| long handle, int prefixLength); |
| private native void useCappedPrefixExtractor( |
| long handle, int prefixLength); |
| private native void setNumLevels( |
| long handle, int numLevels); |
| private native int numLevels(long handle); |
| private native void setLevelZeroFileNumCompactionTrigger( |
| long handle, int numFiles); |
| private native int levelZeroFileNumCompactionTrigger(long handle); |
| private native void setLevelZeroSlowdownWritesTrigger( |
| long handle, int numFiles); |
| private native int levelZeroSlowdownWritesTrigger(long handle); |
| private native void setLevelZeroStopWritesTrigger( |
| long handle, int numFiles); |
| private native int levelZeroStopWritesTrigger(long handle); |
| private native void setTargetFileSizeBase( |
| long handle, long targetFileSizeBase); |
| private native long targetFileSizeBase(long handle); |
| private native void setTargetFileSizeMultiplier( |
| long handle, int multiplier); |
| private native int targetFileSizeMultiplier(long handle); |
| private native void setMaxBytesForLevelBase( |
| long handle, long maxBytesForLevelBase); |
| private native long maxBytesForLevelBase(long handle); |
| private native void setLevelCompactionDynamicLevelBytes( |
| long handle, boolean enableLevelCompactionDynamicLevelBytes); |
| private native boolean levelCompactionDynamicLevelBytes( |
| long handle); |
| private native void setMaxBytesForLevelMultiplier(long handle, double multiplier); |
| private native double maxBytesForLevelMultiplier(long handle); |
| private native void setMaxCompactionBytes(long handle, long maxCompactionBytes); |
| private native long maxCompactionBytes(long handle); |
| private native void setArenaBlockSize( |
| long handle, long arenaBlockSize) throws IllegalArgumentException; |
| private native long arenaBlockSize(long handle); |
| private native void setDisableAutoCompactions( |
| long handle, boolean disableAutoCompactions); |
| private native boolean disableAutoCompactions(long handle); |
| private native void setCompactionStyle(long handle, byte compactionStyle); |
| private native byte compactionStyle(long handle); |
| private native void setMaxSequentialSkipInIterations( |
| long handle, long maxSequentialSkipInIterations); |
| private native long maxSequentialSkipInIterations(long handle); |
| private native void setMemTableFactory(long handle, long factoryHandle); |
| private native String memTableFactoryName(long handle); |
| private native void setTableFactory(long handle, long factoryHandle); |
| private native String tableFactoryName(long handle); |
| private native void setInplaceUpdateSupport( |
| long handle, boolean inplaceUpdateSupport); |
| private native boolean inplaceUpdateSupport(long handle); |
| private native void setInplaceUpdateNumLocks( |
| long handle, long inplaceUpdateNumLocks) |
| throws IllegalArgumentException; |
| private native long inplaceUpdateNumLocks(long handle); |
| private native void setMemtablePrefixBloomSizeRatio( |
| long handle, double memtablePrefixBloomSizeRatio); |
| private native double memtablePrefixBloomSizeRatio(long handle); |
| private native void setBloomLocality( |
| long handle, int bloomLocality); |
| private native int bloomLocality(long handle); |
| private native void setMaxSuccessiveMerges( |
| long handle, long maxSuccessiveMerges) |
| throws IllegalArgumentException; |
| private native long maxSuccessiveMerges(long handle); |
| private native void setOptimizeFiltersForHits(long handle, |
| boolean optimizeFiltersForHits); |
| private native boolean optimizeFiltersForHits(long handle); |
| private native void setMemtableHugePageSize(long handle, |
| long memtableHugePageSize); |
| private native long memtableHugePageSize(long handle); |
| private native void setSoftPendingCompactionBytesLimit(long handle, |
| long softPendingCompactionBytesLimit); |
| private native long softPendingCompactionBytesLimit(long handle); |
| private native void setHardPendingCompactionBytesLimit(long handle, |
| long hardPendingCompactionBytesLimit); |
| private native long hardPendingCompactionBytesLimit(long handle); |
| private native void setLevel0FileNumCompactionTrigger(long handle, |
| int level0FileNumCompactionTrigger); |
| private native int level0FileNumCompactionTrigger(long handle); |
| private native void setLevel0SlowdownWritesTrigger(long handle, |
| int level0SlowdownWritesTrigger); |
| private native int level0SlowdownWritesTrigger(long handle); |
| private native void setLevel0StopWritesTrigger(long handle, |
| int level0StopWritesTrigger); |
| private native int level0StopWritesTrigger(long handle); |
| private native void setMaxBytesForLevelMultiplierAdditional(long handle, |
| int[] maxBytesForLevelMultiplierAdditional); |
| private native int[] maxBytesForLevelMultiplierAdditional(long handle); |
| private native void setParanoidFileChecks(long handle, |
| boolean paranoidFileChecks); |
| private native boolean paranoidFileChecks(long handle); |
| private native void setMaxWriteBufferNumberToMaintain(final long handle, |
| final int maxWriteBufferNumberToMaintain); |
| private native int maxWriteBufferNumberToMaintain(final long handle); |
| private native void setCompactionPriority(final long handle, |
| final byte compactionPriority); |
| private native byte compactionPriority(final long handle); |
| private native void setReportBgIoStats(final long handle, |
| final boolean reportBgIoStats); |
| private native boolean reportBgIoStats(final long handle); |
| private native void setCompactionOptionsUniversal(final long handle, |
| final long compactionOptionsUniversalHandle); |
| private native void setCompactionOptionsFIFO(final long handle, |
| final long compactionOptionsFIFOHandle); |
| private native void setForceConsistencyChecks(final long handle, |
| final boolean forceConsistencyChecks); |
| private native boolean forceConsistencyChecks(final long handle); |
| |
| // instance variables |
| private Env env_; |
| private MemTableConfig memTableConfig_; |
| private TableFormatConfig tableFormatConfig_; |
| private RateLimiter rateLimiter_; |
| private AbstractComparator<? extends AbstractSlice<?>> comparator_; |
| private CompactionOptionsUniversal compactionOptionsUniversal_; |
| private CompactionOptionsFIFO compactionOptionsFIFO_; |
| private CompressionOptions compressionOptions_; |
| private Cache rowCache_; |
| } |