org.apache.kafka.streams.state.internals.RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.kafka.streams.state.internals;
import org.rocksdb.AbstractCompactionFilter;
import org.rocksdb.AbstractCompactionFilterFactory;
import org.rocksdb.AbstractComparator;
import org.rocksdb.AbstractEventListener;
import org.rocksdb.AbstractSlice;
import org.rocksdb.AbstractWalFilter;
import org.rocksdb.AccessHint;
import org.rocksdb.BuiltinComparator;
import org.rocksdb.Cache;
import org.rocksdb.ColumnFamilyOptions;
import org.rocksdb.CompactionOptionsFIFO;
import org.rocksdb.CompactionOptionsUniversal;
import org.rocksdb.CompactionPriority;
import org.rocksdb.CompactionStyle;
import org.rocksdb.CompressionOptions;
import org.rocksdb.CompressionType;
import org.rocksdb.ConcurrentTaskLimiter;
import org.rocksdb.DBOptions;
import org.rocksdb.DbPath;
import org.rocksdb.Env;
import org.rocksdb.InfoLogLevel;
import org.rocksdb.MemTableConfig;
import org.rocksdb.MergeOperator;
import org.rocksdb.Options;
import org.rocksdb.PrepopulateBlobCache;
import org.rocksdb.RateLimiter;
import org.rocksdb.SstFileManager;
import org.rocksdb.SstPartitionerFactory;
import org.rocksdb.Statistics;
import org.rocksdb.TableFormatConfig;
import org.rocksdb.WALRecoveryMode;
import org.rocksdb.WalFilter;
import org.rocksdb.WriteBufferManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;
import java.util.List;
/**
* The generic {@link Options} class allows users to set all configs on one object if only default column family
* is used. Because we use multiple column families, we need to use {@link DBOptions} and {@link ColumnFamilyOptions}
* that cover a part of all options each.
*
* This class do the translation between generic {@link Options} into {@link DBOptions} and {@link ColumnFamilyOptions}.
*/
public class RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter extends Options {
private static final Logger log = LoggerFactory.getLogger(RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter.class);
private final DBOptions dbOptions;
private final ColumnFamilyOptions columnFamilyOptions;
RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter(final DBOptions dbOptions,
final ColumnFamilyOptions columnFamilyOptions) {
this.dbOptions = dbOptions;
this.columnFamilyOptions = columnFamilyOptions;
}
@Override
public Options setIncreaseParallelism(final int totalThreads) {
dbOptions.setIncreaseParallelism(totalThreads);
return this;
}
@Override
public Options setCreateIfMissing(final boolean flag) {
dbOptions.setCreateIfMissing(flag);
return this;
}
@Override
public Options setCreateMissingColumnFamilies(final boolean flag) {
dbOptions.setCreateMissingColumnFamilies(flag);
return this;
}
@Override
public Options setEnv(final Env env) {
dbOptions.setEnv(env);
return this;
}
@Override
public Env getEnv() {
return dbOptions.getEnv();
}
@Override
public Options prepareForBulkLoad() {
super.prepareForBulkLoad();
return this;
}
@Override
public boolean createIfMissing() {
return dbOptions.createIfMissing();
}
@Override
public boolean createMissingColumnFamilies() {
return dbOptions.createMissingColumnFamilies();
}
@Override
public Options optimizeForSmallDb() {
dbOptions.optimizeForSmallDb();
columnFamilyOptions.optimizeForSmallDb();
return this;
}
@Override
public Options optimizeForPointLookup(final long blockCacheSizeMb) {
columnFamilyOptions.optimizeForPointLookup(blockCacheSizeMb);
return this;
}
@Override
public Options optimizeLevelStyleCompaction() {
columnFamilyOptions.optimizeLevelStyleCompaction();
return this;
}
@Override
public Options optimizeLevelStyleCompaction(final long memtableMemoryBudget) {
columnFamilyOptions.optimizeLevelStyleCompaction(memtableMemoryBudget);
return this;
}
@Override
public Options optimizeUniversalStyleCompaction() {
columnFamilyOptions.optimizeUniversalStyleCompaction();
return this;
}
@Override
public Options optimizeUniversalStyleCompaction(final long memtableMemoryBudget) {
columnFamilyOptions.optimizeUniversalStyleCompaction(memtableMemoryBudget);
return this;
}
@Override
public Options setComparator(final BuiltinComparator builtinComparator) {
columnFamilyOptions.setComparator(builtinComparator);
return this;
}
@Override
public Options setComparator(final AbstractComparator comparator) {
columnFamilyOptions.setComparator(comparator);
return this;
}
@Override
public Options setMergeOperatorName(final String name) {
columnFamilyOptions.setMergeOperatorName(name);
return this;
}
@Override
public Options setMergeOperator(final MergeOperator mergeOperator) {
columnFamilyOptions.setMergeOperator(mergeOperator);
return this;
}
@Override
public Options setWriteBufferSize(final long writeBufferSize) {
columnFamilyOptions.setWriteBufferSize(writeBufferSize);
return this;
}
@Override
public long writeBufferSize() {
return columnFamilyOptions.writeBufferSize();
}
@Override
public Options setMaxWriteBufferNumber(final int maxWriteBufferNumber) {
columnFamilyOptions.setMaxWriteBufferNumber(maxWriteBufferNumber);
return this;
}
@Override
public int maxWriteBufferNumber() {
return columnFamilyOptions.maxWriteBufferNumber();
}
@Override
public boolean errorIfExists() {
return dbOptions.errorIfExists();
}
@Override
public Options setErrorIfExists(final boolean errorIfExists) {
dbOptions.setErrorIfExists(errorIfExists);
return this;
}
@Override
public boolean paranoidChecks() {
final boolean columnFamilyParanoidFileChecks = columnFamilyOptions.paranoidFileChecks();
final boolean dbOptionsParanoidChecks = dbOptions.paranoidChecks();
if (columnFamilyParanoidFileChecks != dbOptionsParanoidChecks) {
throw new IllegalStateException("Config for paranoid checks for RockDB and ColumnFamilies should be the same.");
}
return dbOptionsParanoidChecks;
}
@Override
public Options setParanoidChecks(final boolean paranoidChecks) {
columnFamilyOptions.paranoidFileChecks();
dbOptions.setParanoidChecks(paranoidChecks);
return this;
}
@Override
public int maxOpenFiles() {
return dbOptions.maxOpenFiles();
}
@Override
public Options setMaxFileOpeningThreads(final int maxFileOpeningThreads) {
dbOptions.setMaxFileOpeningThreads(maxFileOpeningThreads);
return this;
}
@Override
public int maxFileOpeningThreads() {
return dbOptions.maxFileOpeningThreads();
}
@Override
public Options setMaxTotalWalSize(final long maxTotalWalSize) {
logIgnoreWalOption("maxTotalWalSize");
return this;
}
@Override
public long maxTotalWalSize() {
return dbOptions.maxTotalWalSize();
}
@Override
public Options setMaxOpenFiles(final int maxOpenFiles) {
dbOptions.setMaxOpenFiles(maxOpenFiles);
return this;
}
@Override
public boolean useFsync() {
return dbOptions.useFsync();
}
@Override
public Options setUseFsync(final boolean useFsync) {
dbOptions.setUseFsync(useFsync);
return this;
}
@Override
public Options setDbPaths(final Collection dbPaths) {
dbOptions.setDbPaths(dbPaths);
return this;
}
@Override
public List dbPaths() {
return dbOptions.dbPaths();
}
@Override
public String dbLogDir() {
return dbOptions.dbLogDir();
}
@Override
public Options setDbLogDir(final String dbLogDir) {
dbOptions.setDbLogDir(dbLogDir);
return this;
}
@Override
public String walDir() {
return dbOptions.walDir();
}
@Override
public Options setWalDir(final String walDir) {
logIgnoreWalOption("walDir");
return this;
}
@Override
public long deleteObsoleteFilesPeriodMicros() {
return dbOptions.deleteObsoleteFilesPeriodMicros();
}
@Override
public Options setDeleteObsoleteFilesPeriodMicros(final long micros) {
dbOptions.setDeleteObsoleteFilesPeriodMicros(micros);
return this;
}
@Deprecated
@Override
public int maxBackgroundCompactions() {
return dbOptions.maxBackgroundCompactions();
}
@Override
public Options setStatistics(final Statistics statistics) {
dbOptions.setStatistics(statistics);
return this;
}
@Override
public Statistics statistics() {
return dbOptions.statistics();
}
@Deprecated
public void setBaseBackgroundCompactions(final int baseBackgroundCompactions) {
final String message = "This method has been removed from the underlying RocksDB. " +
"It was not affecting compaction even in earlier versions. " +
"It is currently a no-op method. " +
"RocksDB decides the number of background compactions based on the maxBackgroundJobs(...) method";
log.warn(message);
// no-op
}
@Deprecated
public int baseBackgroundCompactions() {
final String message = "This method has been removed from the underlying RocksDB. " +
"It is currently a no-op method which returns a default value of -1.";
log.warn(message);
return -1;
}
@Deprecated
@Override
public Options setMaxBackgroundCompactions(final int maxBackgroundCompactions) {
dbOptions.setMaxBackgroundCompactions(maxBackgroundCompactions);
return this;
}
@Override
public Options setMaxSubcompactions(final int maxSubcompactions) {
dbOptions.setMaxSubcompactions(maxSubcompactions);
return this;
}
@Override
public int maxSubcompactions() {
return dbOptions.maxSubcompactions();
}
@Deprecated
@Override
public int maxBackgroundFlushes() {
return dbOptions.maxBackgroundFlushes();
}
@Deprecated
@Override
public Options setMaxBackgroundFlushes(final int maxBackgroundFlushes) {
dbOptions.setMaxBackgroundFlushes(maxBackgroundFlushes);
return this;
}
@Override
public int maxBackgroundJobs() {
return dbOptions.maxBackgroundJobs();
}
@Override
public Options setMaxBackgroundJobs(final int maxBackgroundJobs) {
dbOptions.setMaxBackgroundJobs(maxBackgroundJobs);
return this;
}
@Override
public long maxLogFileSize() {
return dbOptions.maxLogFileSize();
}
@Override
public Options setMaxLogFileSize(final long maxLogFileSize) {
dbOptions.setMaxLogFileSize(maxLogFileSize);
return this;
}
@Override
public long logFileTimeToRoll() {
return dbOptions.logFileTimeToRoll();
}
@Override
public Options setLogFileTimeToRoll(final long logFileTimeToRoll) {
dbOptions.setLogFileTimeToRoll(logFileTimeToRoll);
return this;
}
@Override
public long keepLogFileNum() {
return dbOptions.keepLogFileNum();
}
@Override
public Options setKeepLogFileNum(final long keepLogFileNum) {
dbOptions.setKeepLogFileNum(keepLogFileNum);
return this;
}
@Override
public Options setRecycleLogFileNum(final long recycleLogFileNum) {
dbOptions.setRecycleLogFileNum(recycleLogFileNum);
return this;
}
@Override
public long recycleLogFileNum() {
return dbOptions.recycleLogFileNum();
}
@Override
public long maxManifestFileSize() {
return dbOptions.maxManifestFileSize();
}
@Override
public Options setMaxManifestFileSize(final long maxManifestFileSize) {
dbOptions.setMaxManifestFileSize(maxManifestFileSize);
return this;
}
@Override
public Options setMaxTableFilesSizeFIFO(final long maxTableFilesSize) {
columnFamilyOptions.setMaxTableFilesSizeFIFO(maxTableFilesSize);
return this;
}
@Override
public long maxTableFilesSizeFIFO() {
return columnFamilyOptions.maxTableFilesSizeFIFO();
}
@Override
public int tableCacheNumshardbits() {
return dbOptions.tableCacheNumshardbits();
}
@Override
public Options setTableCacheNumshardbits(final int tableCacheNumshardbits) {
dbOptions.setTableCacheNumshardbits(tableCacheNumshardbits);
return this;
}
@Override
public long walTtlSeconds() {
return dbOptions.walTtlSeconds();
}
@Override
public Options setWalTtlSeconds(final long walTtlSeconds) {
logIgnoreWalOption("walTtlSeconds");
return this;
}
@Override
public long walSizeLimitMB() {
return dbOptions.walSizeLimitMB();
}
@Override
public Options setWalSizeLimitMB(final long sizeLimitMB) {
logIgnoreWalOption("walSizeLimitMB");
return this;
}
@Override
public long manifestPreallocationSize() {
return dbOptions.manifestPreallocationSize();
}
@Override
public Options setManifestPreallocationSize(final long size) {
dbOptions.setManifestPreallocationSize(size);
return this;
}
@Override
public Options setUseDirectReads(final boolean useDirectReads) {
dbOptions.setUseDirectReads(useDirectReads);
return this;
}
@Override
public boolean useDirectReads() {
return dbOptions.useDirectReads();
}
@Override
public Options setUseDirectIoForFlushAndCompaction(final boolean useDirectIoForFlushAndCompaction) {
dbOptions.setUseDirectIoForFlushAndCompaction(useDirectIoForFlushAndCompaction);
return this;
}
@Override
public boolean useDirectIoForFlushAndCompaction() {
return dbOptions.useDirectIoForFlushAndCompaction();
}
@Override
public Options setAllowFAllocate(final boolean allowFAllocate) {
dbOptions.setAllowFAllocate(allowFAllocate);
return this;
}
@Override
public boolean allowFAllocate() {
return dbOptions.allowFAllocate();
}
@Override
public boolean allowMmapReads() {
return dbOptions.allowMmapReads();
}
@Override
public Options setAllowMmapReads(final boolean allowMmapReads) {
dbOptions.setAllowMmapReads(allowMmapReads);
return this;
}
@Override
public boolean allowMmapWrites() {
return dbOptions.allowMmapWrites();
}
@Override
public Options setAllowMmapWrites(final boolean allowMmapWrites) {
dbOptions.setAllowMmapWrites(allowMmapWrites);
return this;
}
@Override
public boolean isFdCloseOnExec() {
return dbOptions.isFdCloseOnExec();
}
@Override
public Options setIsFdCloseOnExec(final boolean isFdCloseOnExec) {
dbOptions.setIsFdCloseOnExec(isFdCloseOnExec);
return this;
}
@Override
public int statsDumpPeriodSec() {
return dbOptions.statsDumpPeriodSec();
}
@Override
public Options setStatsDumpPeriodSec(final int statsDumpPeriodSec) {
dbOptions.setStatsDumpPeriodSec(statsDumpPeriodSec);
return this;
}
@Override
public boolean adviseRandomOnOpen() {
return dbOptions.adviseRandomOnOpen();
}
@Override
public Options setAdviseRandomOnOpen(final boolean adviseRandomOnOpen) {
dbOptions.setAdviseRandomOnOpen(adviseRandomOnOpen);
return this;
}
@Override
public Options setDbWriteBufferSize(final long dbWriteBufferSize) {
dbOptions.setDbWriteBufferSize(dbWriteBufferSize);
return this;
}
@Override
public long dbWriteBufferSize() {
return dbOptions.dbWriteBufferSize();
}
@Override
public Options setAccessHintOnCompactionStart(final AccessHint accessHint) {
dbOptions.setAccessHintOnCompactionStart(accessHint);
return this;
}
@Override
public AccessHint accessHintOnCompactionStart() {
return dbOptions.accessHintOnCompactionStart();
}
@Deprecated
public Options setNewTableReaderForCompactionInputs(final boolean newTableReaderForCompactionInputs) {
final String message = "This method has been removed from the underlying RocksDB. " +
"It was not affecting compaction even in earlier versions. " +
"It is currently a no-op method.";
log.warn(message);
return this;
}
@Deprecated
public boolean newTableReaderForCompactionInputs() {
final String message = "This method has been removed from the underlying RocksDB. " +
"It is now a method which always returns false.";
log.warn(message);
return false;
}
@Override
public Options setCompactionReadaheadSize(final long compactionReadaheadSize) {
dbOptions.setCompactionReadaheadSize(compactionReadaheadSize);
return this;
}
@Override
public long compactionReadaheadSize() {
return dbOptions.compactionReadaheadSize();
}
@Override
public Options setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {
dbOptions.setRandomAccessMaxBufferSize(randomAccessMaxBufferSize);
return this;
}
@Override
public long randomAccessMaxBufferSize() {
return dbOptions.randomAccessMaxBufferSize();
}
@Override
public Options setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {
dbOptions.setWritableFileMaxBufferSize(writableFileMaxBufferSize);
return this;
}
@Override
public long writableFileMaxBufferSize() {
return dbOptions.writableFileMaxBufferSize();
}
@Override
public boolean useAdaptiveMutex() {
return dbOptions.useAdaptiveMutex();
}
@Override
public Options setUseAdaptiveMutex(final boolean useAdaptiveMutex) {
dbOptions.setUseAdaptiveMutex(useAdaptiveMutex);
return this;
}
@Override
public long bytesPerSync() {
return dbOptions.bytesPerSync();
}
@Override
public Options setBytesPerSync(final long bytesPerSync) {
dbOptions.setBytesPerSync(bytesPerSync);
return this;
}
@Override
public Options setWalBytesPerSync(final long walBytesPerSync) {
logIgnoreWalOption("walBytesPerSync");
return this;
}
@Override
public long walBytesPerSync() {
return dbOptions.walBytesPerSync();
}
@Override
public Options setEnableThreadTracking(final boolean enableThreadTracking) {
dbOptions.setEnableThreadTracking(enableThreadTracking);
return this;
}
@Override
public boolean enableThreadTracking() {
return dbOptions.enableThreadTracking();
}
@Override
public Options setDelayedWriteRate(final long delayedWriteRate) {
dbOptions.setDelayedWriteRate(delayedWriteRate);
return this;
}
@Override
public long delayedWriteRate() {
return dbOptions.delayedWriteRate();
}
@Override
public Options setAllowConcurrentMemtableWrite(final boolean allowConcurrentMemtableWrite) {
dbOptions.setAllowConcurrentMemtableWrite(allowConcurrentMemtableWrite);
return this;
}
@Override
public boolean allowConcurrentMemtableWrite() {
return dbOptions.allowConcurrentMemtableWrite();
}
@Override
public Options setEnableWriteThreadAdaptiveYield(final boolean enableWriteThreadAdaptiveYield) {
dbOptions.setEnableWriteThreadAdaptiveYield(enableWriteThreadAdaptiveYield);
return this;
}
@Override
public boolean enableWriteThreadAdaptiveYield() {
return dbOptions.enableWriteThreadAdaptiveYield();
}
@Override
public Options setWriteThreadMaxYieldUsec(final long writeThreadMaxYieldUsec) {
dbOptions.setWriteThreadMaxYieldUsec(writeThreadMaxYieldUsec);
return this;
}
@Override
public long writeThreadMaxYieldUsec() {
return dbOptions.writeThreadMaxYieldUsec();
}
@Override
public Options setWriteThreadSlowYieldUsec(final long writeThreadSlowYieldUsec) {
dbOptions.setWriteThreadSlowYieldUsec(writeThreadSlowYieldUsec);
return this;
}
@Override
public long writeThreadSlowYieldUsec() {
return dbOptions.writeThreadSlowYieldUsec();
}
@Override
public Options setSkipStatsUpdateOnDbOpen(final boolean skipStatsUpdateOnDbOpen) {
dbOptions.setSkipStatsUpdateOnDbOpen(skipStatsUpdateOnDbOpen);
return this;
}
@Override
public boolean skipStatsUpdateOnDbOpen() {
return dbOptions.skipStatsUpdateOnDbOpen();
}
@Override
public Options setWalRecoveryMode(final WALRecoveryMode walRecoveryMode) {
logIgnoreWalOption("walRecoveryMode");
return this;
}
@Override
public WALRecoveryMode walRecoveryMode() {
return dbOptions.walRecoveryMode();
}
@Override
public Options setAllow2pc(final boolean allow2pc) {
dbOptions.setAllow2pc(allow2pc);
return this;
}
@Override
public boolean allow2pc() {
return dbOptions.allow2pc();
}
@Override
public Options setRowCache(final Cache rowCache) {
dbOptions.setRowCache(rowCache);
return this;
}
@Override
public Cache rowCache() {
return dbOptions.rowCache();
}
@Override
public Options setFailIfOptionsFileError(final boolean failIfOptionsFileError) {
dbOptions.setFailIfOptionsFileError(failIfOptionsFileError);
return this;
}
@Override
public boolean failIfOptionsFileError() {
return dbOptions.failIfOptionsFileError();
}
@Override
public Options setDumpMallocStats(final boolean dumpMallocStats) {
dbOptions.setDumpMallocStats(dumpMallocStats);
return this;
}
@Override
public boolean dumpMallocStats() {
return dbOptions.dumpMallocStats();
}
@Override
public Options setAvoidFlushDuringRecovery(final boolean avoidFlushDuringRecovery) {
dbOptions.setAvoidFlushDuringRecovery(avoidFlushDuringRecovery);
return this;
}
@Override
public boolean avoidFlushDuringRecovery() {
return dbOptions.avoidFlushDuringRecovery();
}
@Override
public Options setAvoidFlushDuringShutdown(final boolean avoidFlushDuringShutdown) {
dbOptions.setAvoidFlushDuringShutdown(avoidFlushDuringShutdown);
return this;
}
@Override
public boolean avoidFlushDuringShutdown() {
return dbOptions.avoidFlushDuringShutdown();
}
@Override
public MemTableConfig memTableConfig() {
return columnFamilyOptions.memTableConfig();
}
@Override
public Options setMemTableConfig(final MemTableConfig config) {
columnFamilyOptions.setMemTableConfig(config);
return this;
}
@Override
public Options setRateLimiter(final RateLimiter rateLimiter) {
dbOptions.setRateLimiter(rateLimiter);
return this;
}
@Override
public Options setSstFileManager(final SstFileManager sstFileManager) {
dbOptions.setSstFileManager(sstFileManager);
return this;
}
@Override
public Options setLogger(final org.rocksdb.Logger logger) {
dbOptions.setLogger(logger);
return this;
}
@Override
public Options setInfoLogLevel(final InfoLogLevel infoLogLevel) {
dbOptions.setInfoLogLevel(infoLogLevel);
return this;
}
@Override
public InfoLogLevel infoLogLevel() {
return dbOptions.infoLogLevel();
}
@Override
public String memTableFactoryName() {
return columnFamilyOptions.memTableFactoryName();
}
@Override
public TableFormatConfig tableFormatConfig() {
return columnFamilyOptions.tableFormatConfig();
}
@Override
public Options setTableFormatConfig(final TableFormatConfig config) {
columnFamilyOptions.setTableFormatConfig(config);
return this;
}
@Override
public String tableFactoryName() {
return columnFamilyOptions.tableFactoryName();
}
@Override
public Options useFixedLengthPrefixExtractor(final int n) {
columnFamilyOptions.useFixedLengthPrefixExtractor(n);
return this;
}
@Override
public Options useCappedPrefixExtractor(final int n) {
columnFamilyOptions.useCappedPrefixExtractor(n);
return this;
}
@Override
public CompressionType compressionType() {
return columnFamilyOptions.compressionType();
}
@Override
public Options setCompressionPerLevel(final List compressionLevels) {
columnFamilyOptions.setCompressionPerLevel(compressionLevels);
return this;
}
@Override
public List compressionPerLevel() {
return columnFamilyOptions.compressionPerLevel();
}
@Override
public Options setCompressionType(final CompressionType compressionType) {
columnFamilyOptions.setCompressionType(compressionType);
return this;
}
@Override
public Options setBottommostCompressionType(final CompressionType bottommostCompressionType) {
columnFamilyOptions.setBottommostCompressionType(bottommostCompressionType);
return this;
}
@Override
public CompressionType bottommostCompressionType() {
return columnFamilyOptions.bottommostCompressionType();
}
@Override
public Options setCompressionOptions(final CompressionOptions compressionOptions) {
columnFamilyOptions.setCompressionOptions(compressionOptions);
return this;
}
@Override
public CompressionOptions compressionOptions() {
return columnFamilyOptions.compressionOptions();
}
@Override
public CompactionStyle compactionStyle() {
return columnFamilyOptions.compactionStyle();
}
@Override
public Options setCompactionStyle(final CompactionStyle compactionStyle) {
columnFamilyOptions.setCompactionStyle(compactionStyle);
return this;
}
@Override
public int numLevels() {
return columnFamilyOptions.numLevels();
}
@Override
public Options setNumLevels(final int numLevels) {
columnFamilyOptions.setNumLevels(numLevels);
return this;
}
@Override
public int levelZeroFileNumCompactionTrigger() {
return columnFamilyOptions.levelZeroFileNumCompactionTrigger();
}
@Override
public Options setLevelZeroFileNumCompactionTrigger(final int numFiles) {
columnFamilyOptions.setLevelZeroFileNumCompactionTrigger(numFiles);
return this;
}
@Override
public int levelZeroSlowdownWritesTrigger() {
return columnFamilyOptions.levelZeroSlowdownWritesTrigger();
}
@Override
public Options setLevelZeroSlowdownWritesTrigger(final int numFiles) {
columnFamilyOptions.setLevelZeroSlowdownWritesTrigger(numFiles);
return this;
}
@Override
public int levelZeroStopWritesTrigger() {
return columnFamilyOptions.levelZeroStopWritesTrigger();
}
@Override
public Options setLevelZeroStopWritesTrigger(final int numFiles) {
columnFamilyOptions.setLevelZeroStopWritesTrigger(numFiles);
return this;
}
@Override
public long targetFileSizeBase() {
return columnFamilyOptions.targetFileSizeBase();
}
@Override
public Options setTargetFileSizeBase(final long targetFileSizeBase) {
columnFamilyOptions.setTargetFileSizeBase(targetFileSizeBase);
return this;
}
@Override
public int targetFileSizeMultiplier() {
return columnFamilyOptions.targetFileSizeMultiplier();
}
@Override
public Options setTargetFileSizeMultiplier(final int multiplier) {
columnFamilyOptions.setTargetFileSizeMultiplier(multiplier);
return this;
}
@Override
public Options setMaxBytesForLevelBase(final long maxBytesForLevelBase) {
columnFamilyOptions.setMaxBytesForLevelBase(maxBytesForLevelBase);
return this;
}
@Override
public long maxBytesForLevelBase() {
return columnFamilyOptions.maxBytesForLevelBase();
}
@Override
public Options setLevelCompactionDynamicLevelBytes(final boolean enableLevelCompactionDynamicLevelBytes) {
columnFamilyOptions.setLevelCompactionDynamicLevelBytes(enableLevelCompactionDynamicLevelBytes);
return this;
}
@Override
public boolean levelCompactionDynamicLevelBytes() {
return columnFamilyOptions.levelCompactionDynamicLevelBytes();
}
@Override
public double maxBytesForLevelMultiplier() {
return columnFamilyOptions.maxBytesForLevelMultiplier();
}
@Override
public Options setMaxBytesForLevelMultiplier(final double multiplier) {
columnFamilyOptions.setMaxBytesForLevelMultiplier(multiplier);
return this;
}
@Override
public long maxCompactionBytes() {
return columnFamilyOptions.maxCompactionBytes();
}
@Override
public Options setMaxCompactionBytes(final long maxCompactionBytes) {
columnFamilyOptions.setMaxCompactionBytes(maxCompactionBytes);
return this;
}
@Override
public long arenaBlockSize() {
return columnFamilyOptions.arenaBlockSize();
}
@Override
public Options setArenaBlockSize(final long arenaBlockSize) {
columnFamilyOptions.setArenaBlockSize(arenaBlockSize);
return this;
}
@Override
public boolean disableAutoCompactions() {
return columnFamilyOptions.disableAutoCompactions();
}
@Override
public Options setDisableAutoCompactions(final boolean disableAutoCompactions) {
columnFamilyOptions.setDisableAutoCompactions(disableAutoCompactions);
return this;
}
@Override
public long maxSequentialSkipInIterations() {
return columnFamilyOptions.maxSequentialSkipInIterations();
}
@Override
public Options setMaxSequentialSkipInIterations(final long maxSequentialSkipInIterations) {
columnFamilyOptions.setMaxSequentialSkipInIterations(maxSequentialSkipInIterations);
return this;
}
@Override
public boolean inplaceUpdateSupport() {
return columnFamilyOptions.inplaceUpdateSupport();
}
@Override
public Options setInplaceUpdateSupport(final boolean inplaceUpdateSupport) {
columnFamilyOptions.setInplaceUpdateSupport(inplaceUpdateSupport);
return this;
}
@Override
public long inplaceUpdateNumLocks() {
return columnFamilyOptions.inplaceUpdateNumLocks();
}
@Override
public Options setInplaceUpdateNumLocks(final long inplaceUpdateNumLocks) {
columnFamilyOptions.setInplaceUpdateNumLocks(inplaceUpdateNumLocks);
return this;
}
@Override
public double memtablePrefixBloomSizeRatio() {
return columnFamilyOptions.memtablePrefixBloomSizeRatio();
}
@Override
public Options setMemtablePrefixBloomSizeRatio(final double memtablePrefixBloomSizeRatio) {
columnFamilyOptions.setMemtablePrefixBloomSizeRatio(memtablePrefixBloomSizeRatio);
return this;
}
@Override
public int bloomLocality() {
return columnFamilyOptions.bloomLocality();
}
@Override
public Options setBloomLocality(final int bloomLocality) {
columnFamilyOptions.setBloomLocality(bloomLocality);
return this;
}
@Override
public long maxSuccessiveMerges() {
return columnFamilyOptions.maxSuccessiveMerges();
}
@Override
public Options setMaxSuccessiveMerges(final long maxSuccessiveMerges) {
columnFamilyOptions.setMaxSuccessiveMerges(maxSuccessiveMerges);
return this;
}
@Override
public int minWriteBufferNumberToMerge() {
return columnFamilyOptions.minWriteBufferNumberToMerge();
}
@Override
public Options setMinWriteBufferNumberToMerge(final int minWriteBufferNumberToMerge) {
columnFamilyOptions.setMinWriteBufferNumberToMerge(minWriteBufferNumberToMerge);
return this;
}
@Override
public Options setOptimizeFiltersForHits(final boolean optimizeFiltersForHits) {
columnFamilyOptions.setOptimizeFiltersForHits(optimizeFiltersForHits);
return this;
}
@Override
public boolean optimizeFiltersForHits() {
return columnFamilyOptions.optimizeFiltersForHits();
}
@Override
public Options setMemtableHugePageSize(final long memtableHugePageSize) {
columnFamilyOptions.setMemtableHugePageSize(memtableHugePageSize);
return this;
}
@Override
public long memtableHugePageSize() {
return columnFamilyOptions.memtableHugePageSize();
}
@Override
public Options setSoftPendingCompactionBytesLimit(final long softPendingCompactionBytesLimit) {
columnFamilyOptions.setSoftPendingCompactionBytesLimit(softPendingCompactionBytesLimit);
return this;
}
@Override
public long softPendingCompactionBytesLimit() {
return columnFamilyOptions.softPendingCompactionBytesLimit();
}
@Override
public Options setHardPendingCompactionBytesLimit(final long hardPendingCompactionBytesLimit) {
columnFamilyOptions.setHardPendingCompactionBytesLimit(hardPendingCompactionBytesLimit);
return this;
}
@Override
public long hardPendingCompactionBytesLimit() {
return columnFamilyOptions.hardPendingCompactionBytesLimit();
}
@Override
public Options setLevel0FileNumCompactionTrigger(final int level0FileNumCompactionTrigger) {
columnFamilyOptions.setLevel0FileNumCompactionTrigger(level0FileNumCompactionTrigger);
return this;
}
@Override
public int level0FileNumCompactionTrigger() {
return columnFamilyOptions.level0FileNumCompactionTrigger();
}
@Override
public Options setLevel0SlowdownWritesTrigger(final int level0SlowdownWritesTrigger) {
columnFamilyOptions.setLevel0SlowdownWritesTrigger(level0SlowdownWritesTrigger);
return this;
}
@Override
public int level0SlowdownWritesTrigger() {
return columnFamilyOptions.level0SlowdownWritesTrigger();
}
@Override
public Options setLevel0StopWritesTrigger(final int level0StopWritesTrigger) {
columnFamilyOptions.setLevel0StopWritesTrigger(level0StopWritesTrigger);
return this;
}
@Override
public int level0StopWritesTrigger() {
return columnFamilyOptions.level0StopWritesTrigger();
}
@Override
public Options setMaxBytesForLevelMultiplierAdditional(final int[] maxBytesForLevelMultiplierAdditional) {
columnFamilyOptions.setMaxBytesForLevelMultiplierAdditional(maxBytesForLevelMultiplierAdditional);
return this;
}
@Override
public int[] maxBytesForLevelMultiplierAdditional() {
return columnFamilyOptions.maxBytesForLevelMultiplierAdditional();
}
@Override
public Options setParanoidFileChecks(final boolean paranoidFileChecks) {
columnFamilyOptions.setParanoidFileChecks(paranoidFileChecks);
return this;
}
@Override
public boolean paranoidFileChecks() {
return columnFamilyOptions.paranoidFileChecks();
}
@Override
public Options setMaxWriteBufferNumberToMaintain(final int maxWriteBufferNumberToMaintain) {
columnFamilyOptions.setMaxWriteBufferNumberToMaintain(maxWriteBufferNumberToMaintain);
return this;
}
@Override
public int maxWriteBufferNumberToMaintain() {
return columnFamilyOptions.maxWriteBufferNumberToMaintain();
}
@Override
public Options setCompactionPriority(final CompactionPriority compactionPriority) {
columnFamilyOptions.setCompactionPriority(compactionPriority);
return this;
}
@Override
public CompactionPriority compactionPriority() {
return columnFamilyOptions.compactionPriority();
}
@Override
public Options setReportBgIoStats(final boolean reportBgIoStats) {
columnFamilyOptions.setReportBgIoStats(reportBgIoStats);
return this;
}
@Override
public boolean reportBgIoStats() {
return columnFamilyOptions.reportBgIoStats();
}
@Override
public Options setCompactionOptionsUniversal(final CompactionOptionsUniversal compactionOptionsUniversal) {
columnFamilyOptions.setCompactionOptionsUniversal(compactionOptionsUniversal);
return this;
}
@Override
public CompactionOptionsUniversal compactionOptionsUniversal() {
return columnFamilyOptions.compactionOptionsUniversal();
}
@Override
public Options setCompactionOptionsFIFO(final CompactionOptionsFIFO compactionOptionsFIFO) {
columnFamilyOptions.setCompactionOptionsFIFO(compactionOptionsFIFO);
return this;
}
@Override
public CompactionOptionsFIFO compactionOptionsFIFO() {
return columnFamilyOptions.compactionOptionsFIFO();
}
@Override
public Options setForceConsistencyChecks(final boolean forceConsistencyChecks) {
columnFamilyOptions.setForceConsistencyChecks(forceConsistencyChecks);
return this;
}
@Override
public boolean forceConsistencyChecks() {
return columnFamilyOptions.forceConsistencyChecks();
}
@Override
public Options setWriteBufferManager(final WriteBufferManager writeBufferManager) {
dbOptions.setWriteBufferManager(writeBufferManager);
return this;
}
@Override
public WriteBufferManager writeBufferManager() {
return dbOptions.writeBufferManager();
}
@Override
public Options setMaxWriteBatchGroupSizeBytes(final long maxWriteBatchGroupSizeBytes) {
dbOptions.setMaxWriteBatchGroupSizeBytes(maxWriteBatchGroupSizeBytes);
return this;
}
@Override
public long maxWriteBatchGroupSizeBytes() {
return dbOptions.maxWriteBatchGroupSizeBytes();
}
@Override
public Options oldDefaults(final int majorVersion, final int minorVersion) {
columnFamilyOptions.oldDefaults(majorVersion, minorVersion);
return this;
}
@Override
public Options optimizeForSmallDb(final Cache cache) {
return super.optimizeForSmallDb(cache);
}
@Override
public AbstractCompactionFilter> compactionFilter() {
return columnFamilyOptions.compactionFilter();
}
@Override
public AbstractCompactionFilterFactory> compactionFilterFactory() {
return columnFamilyOptions.compactionFilterFactory();
}
@Override
public Options setStatsPersistPeriodSec(final int statsPersistPeriodSec) {
dbOptions.setStatsPersistPeriodSec(statsPersistPeriodSec);
return this;
}
@Override
public int statsPersistPeriodSec() {
return dbOptions.statsPersistPeriodSec();
}
@Override
public Options setStatsHistoryBufferSize(final long statsHistoryBufferSize) {
dbOptions.setStatsHistoryBufferSize(statsHistoryBufferSize);
return this;
}
@Override
public long statsHistoryBufferSize() {
return dbOptions.statsHistoryBufferSize();
}
@Override
public Options setStrictBytesPerSync(final boolean strictBytesPerSync) {
dbOptions.setStrictBytesPerSync(strictBytesPerSync);
return this;
}
@Override
public boolean strictBytesPerSync() {
return dbOptions.strictBytesPerSync();
}
@Override
public Options setListeners(final List listeners) {
dbOptions.setListeners(listeners);
return this;
}
@Override
public List listeners() {
return dbOptions.listeners();
}
@Override
public Options setEnablePipelinedWrite(final boolean enablePipelinedWrite) {
dbOptions.setEnablePipelinedWrite(enablePipelinedWrite);
return this;
}
@Override
public boolean enablePipelinedWrite() {
return dbOptions.enablePipelinedWrite();
}
@Override
public Options setUnorderedWrite(final boolean unorderedWrite) {
dbOptions.setUnorderedWrite(unorderedWrite);
return this;
}
@Override
public boolean unorderedWrite() {
return dbOptions.unorderedWrite();
}
@Override
public Options setSkipCheckingSstFileSizesOnDbOpen(final boolean skipCheckingSstFileSizesOnDbOpen) {
dbOptions.setSkipCheckingSstFileSizesOnDbOpen(skipCheckingSstFileSizesOnDbOpen);
return this;
}
@Override
public boolean skipCheckingSstFileSizesOnDbOpen() {
return dbOptions.skipCheckingSstFileSizesOnDbOpen();
}
@Override
public Options setWalFilter(final AbstractWalFilter walFilter) {
logIgnoreWalOption("walFilter");
return this;
}
@Override
public WalFilter walFilter() {
return dbOptions.walFilter();
}
@Override
public Options setAllowIngestBehind(final boolean allowIngestBehind) {
dbOptions.setAllowIngestBehind(allowIngestBehind);
return this;
}
@Override
public boolean allowIngestBehind() {
return dbOptions.allowIngestBehind();
}
@Deprecated
public Options setPreserveDeletes(final boolean preserveDeletes) {
final String message = "This method has been removed from the underlying RocksDB. " +
"It was marked for deprecation in earlier versions. " +
"The behaviour can be replicated by using user-defined timestamps. " +
"It is currently a no-op method.";
log.warn(message);
// no-op
return this;
}
@Deprecated
public boolean preserveDeletes() {
final String message = "This method has been removed from the underlying RocksDB. " +
"It was marked for deprecation in earlier versions. " +
"It is currently a no-op method with a default value of false.";
log.warn(message);
return false;
}
@Override
public Options setTwoWriteQueues(final boolean twoWriteQueues) {
dbOptions.setTwoWriteQueues(twoWriteQueues);
return this;
}
@Override
public boolean twoWriteQueues() {
return dbOptions.twoWriteQueues();
}
@Override
public Options setManualWalFlush(final boolean manualWalFlush) {
logIgnoreWalOption("manualWalFlush");
return this;
}
@Override
public boolean manualWalFlush() {
return dbOptions.manualWalFlush();
}
@Override
public Options setCfPaths(final Collection cfPaths) {
columnFamilyOptions.setCfPaths(cfPaths);
return this;
}
@Override
public List cfPaths() {
return columnFamilyOptions.cfPaths();
}
@Override
public Options setBottommostCompressionOptions(final CompressionOptions bottommostCompressionOptions) {
columnFamilyOptions.setBottommostCompressionOptions(bottommostCompressionOptions);
return this;
}
@Override
public CompressionOptions bottommostCompressionOptions() {
return columnFamilyOptions.bottommostCompressionOptions();
}
@Override
public Options setTtl(final long ttl) {
columnFamilyOptions.setTtl(ttl);
return this;
}
@Override
public long ttl() {
return columnFamilyOptions.ttl();
}
@Override
public Options setPeriodicCompactionSeconds(final long periodicCompactionSeconds) {
columnFamilyOptions.setPeriodicCompactionSeconds(periodicCompactionSeconds);
return this;
}
@Override
public long periodicCompactionSeconds() {
return columnFamilyOptions.periodicCompactionSeconds();
}
@Override
public Options setAtomicFlush(final boolean atomicFlush) {
dbOptions.setAtomicFlush(atomicFlush);
return this;
}
@Override
public boolean atomicFlush() {
return dbOptions.atomicFlush();
}
@Override
public Options setAvoidUnnecessaryBlockingIO(final boolean avoidUnnecessaryBlockingIO) {
dbOptions.setAvoidUnnecessaryBlockingIO(avoidUnnecessaryBlockingIO);
return this;
}
@Override
public boolean avoidUnnecessaryBlockingIO() {
return dbOptions.avoidUnnecessaryBlockingIO();
}
@Override
public Options setPersistStatsToDisk(final boolean persistStatsToDisk) {
dbOptions.setPersistStatsToDisk(persistStatsToDisk);
return this;
}
@Override
public boolean persistStatsToDisk() {
return dbOptions.persistStatsToDisk();
}
@Override
public Options setWriteDbidToManifest(final boolean writeDbidToManifest) {
dbOptions.setWriteDbidToManifest(writeDbidToManifest);
return this;
}
@Override
public boolean writeDbidToManifest() {
return dbOptions.writeDbidToManifest();
}
@Override
public Options setLogReadaheadSize(final long logReadaheadSize) {
dbOptions.setLogReadaheadSize(logReadaheadSize);
return this;
}
@Override
public long logReadaheadSize() {
return dbOptions.logReadaheadSize();
}
@Override
public Options setBestEffortsRecovery(final boolean bestEffortsRecovery) {
dbOptions.setBestEffortsRecovery(bestEffortsRecovery);
return this;
}
@Override
public boolean bestEffortsRecovery() {
return dbOptions.bestEffortsRecovery();
}
@Override
public Options setMaxBgErrorResumeCount(final int maxBgerrorResumeCount) {
dbOptions.setMaxBgErrorResumeCount(maxBgerrorResumeCount);
return this;
}
@Override
public int maxBgerrorResumeCount() {
return dbOptions.maxBgerrorResumeCount();
}
@Override
public Options setBgerrorResumeRetryInterval(final long bgerrorResumeRetryInterval) {
dbOptions.setBgerrorResumeRetryInterval(bgerrorResumeRetryInterval);
return this;
}
@Override
public long bgerrorResumeRetryInterval() {
return dbOptions.bgerrorResumeRetryInterval();
}
@Override
public Options setSstPartitionerFactory(final SstPartitionerFactory sstPartitionerFactory) {
columnFamilyOptions.setSstPartitionerFactory(sstPartitionerFactory);
return this;
}
@Override
public SstPartitionerFactory sstPartitionerFactory() {
return columnFamilyOptions.sstPartitionerFactory();
}
@Override
public Options setCompactionThreadLimiter(final ConcurrentTaskLimiter compactionThreadLimiter) {
columnFamilyOptions.setCompactionThreadLimiter(compactionThreadLimiter);
return this;
}
@Override
public ConcurrentTaskLimiter compactionThreadLimiter() {
return columnFamilyOptions.compactionThreadLimiter();
}
@Override
public Options setCompactionFilter(final AbstractCompactionFilter> compactionFilter) {
columnFamilyOptions.setCompactionFilter(compactionFilter);
return this;
}
@Override
public Options setCompactionFilterFactory(final AbstractCompactionFilterFactory> compactionFilterFactory) {
columnFamilyOptions.setCompactionFilterFactory(compactionFilterFactory);
return this;
}
@Override
public Options setBlobCompactionReadaheadSize(final long blobCompactionReadaheadSize) {
columnFamilyOptions.setBlobCompactionReadaheadSize(blobCompactionReadaheadSize);
return this;
}
@Override
public long blobCompactionReadaheadSize() {
return columnFamilyOptions.blobCompactionReadaheadSize();
}
@Override
public Options setMemtableWholeKeyFiltering(final boolean memtableWholeKeyFiltering) {
columnFamilyOptions.setMemtableWholeKeyFiltering(memtableWholeKeyFiltering);
return this;
}
@Override
public boolean memtableWholeKeyFiltering() {
return columnFamilyOptions.memtableWholeKeyFiltering();
}
@Override
public Options setExperimentalMempurgeThreshold(final double experimentalMempurgeThreshold) {
columnFamilyOptions.setExperimentalMempurgeThreshold(experimentalMempurgeThreshold);
return this;
}
@Override
public double experimentalMempurgeThreshold() {
return columnFamilyOptions.experimentalMempurgeThreshold();
}
//
// BEGIN options for blobs (integrated BlobDB)
//
@Override
public Options setEnableBlobFiles(final boolean enableBlobFiles) {
columnFamilyOptions.setEnableBlobFiles(enableBlobFiles);
return this;
}
@Override
public boolean enableBlobFiles() {
return columnFamilyOptions.enableBlobFiles();
}
@Override
public Options setMinBlobSize(final long minBlobSize) {
columnFamilyOptions.setMinBlobSize(minBlobSize);
return this;
}
@Override
public long minBlobSize() {
return columnFamilyOptions.minBlobSize();
}
@Override
public Options setBlobFileSize(final long blobFileSize) {
columnFamilyOptions.setBlobFileSize(blobFileSize);
return this;
}
@Override
public long blobFileSize() {
return columnFamilyOptions.blobFileSize();
}
@Override
public Options setBlobCompressionType(final CompressionType compressionType) {
columnFamilyOptions.setBlobCompressionType(compressionType);
return this;
}
@Override
public CompressionType blobCompressionType() {
return columnFamilyOptions.blobCompressionType();
}
@Override
public Options setEnableBlobGarbageCollection(final boolean enableBlobGarbageCollection) {
columnFamilyOptions.setEnableBlobGarbageCollection(enableBlobGarbageCollection);
return this;
}
@Override
public boolean enableBlobGarbageCollection() {
return columnFamilyOptions.enableBlobGarbageCollection();
}
@Override
public Options setBlobGarbageCollectionAgeCutoff(final double blobGarbageCollectionAgeCutoff) {
columnFamilyOptions.setBlobGarbageCollectionAgeCutoff(blobGarbageCollectionAgeCutoff);
return this;
}
@Override
public double blobGarbageCollectionAgeCutoff() {
return columnFamilyOptions.blobGarbageCollectionAgeCutoff();
}
@Override
public Options setBlobGarbageCollectionForceThreshold(final double blobGarbageCollectionForceThreshold) {
columnFamilyOptions.setBlobGarbageCollectionForceThreshold(blobGarbageCollectionForceThreshold);
return this;
}
@Override
public double blobGarbageCollectionForceThreshold() {
return columnFamilyOptions.blobGarbageCollectionForceThreshold();
}
@Override
public Options setPrepopulateBlobCache(final PrepopulateBlobCache prepopulateBlobCache) {
columnFamilyOptions.setPrepopulateBlobCache(prepopulateBlobCache);
return this;
}
@Override
public PrepopulateBlobCache prepopulateBlobCache() {
return columnFamilyOptions.prepopulateBlobCache();
}
@Override
public Options setBlobFileStartingLevel(final int blobFileStartingLevel) {
columnFamilyOptions.setBlobFileStartingLevel(blobFileStartingLevel);
return this;
}
@Override
public int blobFileStartingLevel() {
return columnFamilyOptions.blobFileStartingLevel();
}
//
// END options for blobs (integrated BlobDB)
//
@Override
public void close() {
// ColumnFamilyOptions should be closed after DBOptions
dbOptions.close();
columnFamilyOptions.close();
// close super last since we initialized it first
super.close();
}
private void logIgnoreWalOption(final String option) {
log.warn("WAL is explicitly disabled by Streams in RocksDB. Setting option '{}' will be ignored", option);
}
}