| // 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.util.ArrayList; |
| import java.util.List; |
| import java.util.Properties; |
| |
| /** |
| * ColumnFamilyOptions to control the behavior of a database. It will be used |
| * during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()). |
| * |
| * If {@link #dispose()} function is not called, then it will be GC'd |
| * automatically and native resources will be released as part of the process. |
| */ |
| public class ColumnFamilyOptions extends RocksObject |
| implements ColumnFamilyOptionsInterface<ColumnFamilyOptions>, |
| MutableColumnFamilyOptionsInterface<ColumnFamilyOptions> { |
| static { |
| RocksDB.loadLibrary(); |
| } |
| |
| /** |
| * Construct ColumnFamilyOptions. |
| * |
| * This constructor will create (by allocating a block of memory) |
| * an {@code rocksdb::DBOptions} in the c++ side. |
| */ |
| public ColumnFamilyOptions() { |
| super(newColumnFamilyOptions()); |
| } |
| |
| /** |
| * <p>Method to get a options instance by using pre-configured |
| * property values. If one or many values are undefined in |
| * the context of RocksDB the method will return a null |
| * value.</p> |
| * |
| * <p><strong>Note</strong>: Property keys can be derived from |
| * getter methods within the options class. Example: the method |
| * {@code writeBufferSize()} has a property key: |
| * {@code write_buffer_size}.</p> |
| * |
| * @param properties {@link java.util.Properties} instance. |
| * |
| * @return {@link org.rocksdb.ColumnFamilyOptions instance} |
| * or null. |
| * |
| * @throws java.lang.IllegalArgumentException if null or empty |
| * {@link Properties} instance is passed to the method call. |
| */ |
| public static ColumnFamilyOptions getColumnFamilyOptionsFromProps( |
| final Properties properties) { |
| if (properties == null || properties.size() == 0) { |
| throw new IllegalArgumentException( |
| "Properties value must contain at least one value."); |
| } |
| ColumnFamilyOptions columnFamilyOptions = null; |
| StringBuilder stringBuilder = new StringBuilder(); |
| for (final String name : properties.stringPropertyNames()){ |
| stringBuilder.append(name); |
| stringBuilder.append("="); |
| stringBuilder.append(properties.getProperty(name)); |
| stringBuilder.append(";"); |
| } |
| long handle = getColumnFamilyOptionsFromProps( |
| stringBuilder.toString()); |
| if (handle != 0){ |
| columnFamilyOptions = new ColumnFamilyOptions(handle); |
| } |
| return columnFamilyOptions; |
| } |
| |
| @Override |
| public ColumnFamilyOptions optimizeForSmallDb() { |
| optimizeForSmallDb(nativeHandle_); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions optimizeForPointLookup( |
| final long blockCacheSizeMb) { |
| optimizeForPointLookup(nativeHandle_, |
| blockCacheSizeMb); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions optimizeLevelStyleCompaction() { |
| optimizeLevelStyleCompaction(nativeHandle_, |
| DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions optimizeLevelStyleCompaction( |
| final long memtableMemoryBudget) { |
| optimizeLevelStyleCompaction(nativeHandle_, |
| memtableMemoryBudget); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions optimizeUniversalStyleCompaction() { |
| optimizeUniversalStyleCompaction(nativeHandle_, |
| DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions optimizeUniversalStyleCompaction( |
| final long memtableMemoryBudget) { |
| optimizeUniversalStyleCompaction(nativeHandle_, |
| memtableMemoryBudget); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setComparator( |
| final BuiltinComparator builtinComparator) { |
| assert(isOwningHandle()); |
| setComparatorHandle(nativeHandle_, builtinComparator.ordinal()); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setComparator( |
| final AbstractComparator<? extends AbstractSlice<?>> comparator) { |
| assert (isOwningHandle()); |
| setComparatorHandle(nativeHandle_, comparator.getNativeHandle()); |
| comparator_ = comparator; |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions 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 ColumnFamilyOptions setMergeOperator( |
| final MergeOperator mergeOperator) { |
| setMergeOperator(nativeHandle_, mergeOperator.nativeHandle_); |
| return this; |
| } |
| |
| public ColumnFamilyOptions setCompactionFilter( |
| final AbstractCompactionFilter<? extends AbstractSlice<?>> |
| compactionFilter) { |
| setCompactionFilterHandle(nativeHandle_, compactionFilter.nativeHandle_); |
| compactionFilter_ = compactionFilter; |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setWriteBufferSize(final long writeBufferSize) { |
| assert(isOwningHandle()); |
| setWriteBufferSize(nativeHandle_, writeBufferSize); |
| return this; |
| } |
| |
| @Override |
| public long writeBufferSize() { |
| assert(isOwningHandle()); |
| return writeBufferSize(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxWriteBufferNumber( |
| final int maxWriteBufferNumber) { |
| assert(isOwningHandle()); |
| setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber); |
| return this; |
| } |
| |
| @Override |
| public int maxWriteBufferNumber() { |
| assert(isOwningHandle()); |
| return maxWriteBufferNumber(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMinWriteBufferNumberToMerge( |
| final int minWriteBufferNumberToMerge) { |
| setMinWriteBufferNumberToMerge(nativeHandle_, minWriteBufferNumberToMerge); |
| return this; |
| } |
| |
| @Override |
| public int minWriteBufferNumberToMerge() { |
| return minWriteBufferNumberToMerge(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions useFixedLengthPrefixExtractor(final int n) { |
| assert(isOwningHandle()); |
| useFixedLengthPrefixExtractor(nativeHandle_, n); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions useCappedPrefixExtractor(final int n) { |
| assert(isOwningHandle()); |
| useCappedPrefixExtractor(nativeHandle_, n); |
| return this; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setCompressionType( |
| final CompressionType compressionType) { |
| setCompressionType(nativeHandle_, compressionType.getValue()); |
| return this; |
| } |
| |
| @Override |
| public CompressionType compressionType() { |
| return CompressionType.getCompressionType(compressionType(nativeHandle_)); |
| } |
| |
| @Override |
| public ColumnFamilyOptions 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 ColumnFamilyOptions setBottommostCompressionType( |
| final CompressionType bottommostCompressionType) { |
| setBottommostCompressionType(nativeHandle_, |
| bottommostCompressionType.getValue()); |
| return this; |
| } |
| |
| @Override |
| public CompressionType bottommostCompressionType() { |
| return CompressionType.getCompressionType( |
| bottommostCompressionType(nativeHandle_)); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setCompressionOptions( |
| final CompressionOptions compressionOptions) { |
| setCompressionOptions(nativeHandle_, compressionOptions.nativeHandle_); |
| this.compressionOptions_ = compressionOptions; |
| return this; |
| } |
| |
| @Override |
| public CompressionOptions compressionOptions() { |
| return this.compressionOptions_; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setNumLevels(final int numLevels) { |
| setNumLevels(nativeHandle_, numLevels); |
| return this; |
| } |
| |
| @Override |
| public int numLevels() { |
| return numLevels(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevelZeroFileNumCompactionTrigger( |
| final int numFiles) { |
| setLevelZeroFileNumCompactionTrigger( |
| nativeHandle_, numFiles); |
| return this; |
| } |
| |
| @Override |
| public int levelZeroFileNumCompactionTrigger() { |
| return levelZeroFileNumCompactionTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevelZeroSlowdownWritesTrigger( |
| final int numFiles) { |
| setLevelZeroSlowdownWritesTrigger(nativeHandle_, numFiles); |
| return this; |
| } |
| |
| @Override |
| public int levelZeroSlowdownWritesTrigger() { |
| return levelZeroSlowdownWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevelZeroStopWritesTrigger(final int numFiles) { |
| setLevelZeroStopWritesTrigger(nativeHandle_, numFiles); |
| return this; |
| } |
| |
| @Override |
| public int levelZeroStopWritesTrigger() { |
| return levelZeroStopWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setTargetFileSizeBase( |
| final long targetFileSizeBase) { |
| setTargetFileSizeBase(nativeHandle_, targetFileSizeBase); |
| return this; |
| } |
| |
| @Override |
| public long targetFileSizeBase() { |
| return targetFileSizeBase(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setTargetFileSizeMultiplier( |
| final int multiplier) { |
| setTargetFileSizeMultiplier(nativeHandle_, multiplier); |
| return this; |
| } |
| |
| @Override |
| public int targetFileSizeMultiplier() { |
| return targetFileSizeMultiplier(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxBytesForLevelBase( |
| final long maxBytesForLevelBase) { |
| setMaxBytesForLevelBase(nativeHandle_, maxBytesForLevelBase); |
| return this; |
| } |
| |
| @Override |
| public long maxBytesForLevelBase() { |
| return maxBytesForLevelBase(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevelCompactionDynamicLevelBytes( |
| final boolean enableLevelCompactionDynamicLevelBytes) { |
| setLevelCompactionDynamicLevelBytes(nativeHandle_, |
| enableLevelCompactionDynamicLevelBytes); |
| return this; |
| } |
| |
| @Override |
| public boolean levelCompactionDynamicLevelBytes() { |
| return levelCompactionDynamicLevelBytes(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxBytesForLevelMultiplier(final double multiplier) { |
| setMaxBytesForLevelMultiplier(nativeHandle_, multiplier); |
| return this; |
| } |
| |
| @Override |
| public double maxBytesForLevelMultiplier() { |
| return maxBytesForLevelMultiplier(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxCompactionBytes(final long maxCompactionBytes) { |
| setMaxCompactionBytes(nativeHandle_, maxCompactionBytes); |
| return this; |
| } |
| |
| @Override |
| public long maxCompactionBytes() { |
| return maxCompactionBytes(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setArenaBlockSize( |
| final long arenaBlockSize) { |
| setArenaBlockSize(nativeHandle_, arenaBlockSize); |
| return this; |
| } |
| |
| @Override |
| public long arenaBlockSize() { |
| return arenaBlockSize(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setDisableAutoCompactions( |
| final boolean disableAutoCompactions) { |
| setDisableAutoCompactions(nativeHandle_, disableAutoCompactions); |
| return this; |
| } |
| |
| @Override |
| public boolean disableAutoCompactions() { |
| return disableAutoCompactions(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setCompactionStyle( |
| final CompactionStyle compactionStyle) { |
| setCompactionStyle(nativeHandle_, compactionStyle.getValue()); |
| return this; |
| } |
| |
| @Override |
| public CompactionStyle compactionStyle() { |
| return CompactionStyle.values()[compactionStyle(nativeHandle_)]; |
| } |
| |
| @Override |
| public ColumnFamilyOptions 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 ColumnFamilyOptions setMaxSequentialSkipInIterations( |
| final long maxSequentialSkipInIterations) { |
| setMaxSequentialSkipInIterations(nativeHandle_, |
| maxSequentialSkipInIterations); |
| return this; |
| } |
| |
| @Override |
| public long maxSequentialSkipInIterations() { |
| return maxSequentialSkipInIterations(nativeHandle_); |
| } |
| |
| @Override |
| public MemTableConfig memTableConfig() { |
| return this.memTableConfig_; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMemTableConfig( |
| final MemTableConfig memTableConfig) { |
| setMemTableFactory( |
| nativeHandle_, memTableConfig.newMemTableFactoryHandle()); |
| this.memTableConfig_ = memTableConfig; |
| return this; |
| } |
| |
| @Override |
| public String memTableFactoryName() { |
| assert(isOwningHandle()); |
| return memTableFactoryName(nativeHandle_); |
| } |
| |
| @Override |
| public TableFormatConfig tableFormatConfig() { |
| return this.tableFormatConfig_; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setTableFormatConfig( |
| final TableFormatConfig tableFormatConfig) { |
| setTableFactory(nativeHandle_, tableFormatConfig.newTableFactoryHandle()); |
| this.tableFormatConfig_ = tableFormatConfig; |
| return this; |
| } |
| |
| @Override |
| public String tableFactoryName() { |
| assert(isOwningHandle()); |
| return tableFactoryName(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setInplaceUpdateSupport( |
| final boolean inplaceUpdateSupport) { |
| setInplaceUpdateSupport(nativeHandle_, inplaceUpdateSupport); |
| return this; |
| } |
| |
| @Override |
| public boolean inplaceUpdateSupport() { |
| return inplaceUpdateSupport(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setInplaceUpdateNumLocks( |
| final long inplaceUpdateNumLocks) { |
| setInplaceUpdateNumLocks(nativeHandle_, inplaceUpdateNumLocks); |
| return this; |
| } |
| |
| @Override |
| public long inplaceUpdateNumLocks() { |
| return inplaceUpdateNumLocks(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMemtablePrefixBloomSizeRatio( |
| final double memtablePrefixBloomSizeRatio) { |
| setMemtablePrefixBloomSizeRatio(nativeHandle_, memtablePrefixBloomSizeRatio); |
| return this; |
| } |
| |
| @Override |
| public double memtablePrefixBloomSizeRatio() { |
| return memtablePrefixBloomSizeRatio(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setBloomLocality(int bloomLocality) { |
| setBloomLocality(nativeHandle_, bloomLocality); |
| return this; |
| } |
| |
| @Override |
| public int bloomLocality() { |
| return bloomLocality(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxSuccessiveMerges( |
| final long maxSuccessiveMerges) { |
| setMaxSuccessiveMerges(nativeHandle_, maxSuccessiveMerges); |
| return this; |
| } |
| |
| @Override |
| public long maxSuccessiveMerges() { |
| return maxSuccessiveMerges(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setOptimizeFiltersForHits( |
| final boolean optimizeFiltersForHits) { |
| setOptimizeFiltersForHits(nativeHandle_, optimizeFiltersForHits); |
| return this; |
| } |
| |
| @Override |
| public boolean optimizeFiltersForHits() { |
| return optimizeFiltersForHits(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions |
| setMemtableHugePageSize( |
| long memtableHugePageSize) { |
| setMemtableHugePageSize(nativeHandle_, |
| memtableHugePageSize); |
| return this; |
| } |
| |
| @Override |
| public long memtableHugePageSize() { |
| return memtableHugePageSize(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit) { |
| setSoftPendingCompactionBytesLimit(nativeHandle_, |
| softPendingCompactionBytesLimit); |
| return this; |
| } |
| |
| @Override |
| public long softPendingCompactionBytesLimit() { |
| return softPendingCompactionBytesLimit(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit) { |
| setHardPendingCompactionBytesLimit(nativeHandle_, hardPendingCompactionBytesLimit); |
| return this; |
| } |
| |
| @Override |
| public long hardPendingCompactionBytesLimit() { |
| return hardPendingCompactionBytesLimit(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger) { |
| setLevel0FileNumCompactionTrigger(nativeHandle_, level0FileNumCompactionTrigger); |
| return this; |
| } |
| |
| @Override |
| public int level0FileNumCompactionTrigger() { |
| return level0FileNumCompactionTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger) { |
| setLevel0SlowdownWritesTrigger(nativeHandle_, level0SlowdownWritesTrigger); |
| return this; |
| } |
| |
| @Override |
| public int level0SlowdownWritesTrigger() { |
| return level0SlowdownWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setLevel0StopWritesTrigger(int level0StopWritesTrigger) { |
| setLevel0StopWritesTrigger(nativeHandle_, level0StopWritesTrigger); |
| return this; |
| } |
| |
| @Override |
| public int level0StopWritesTrigger() { |
| return level0StopWritesTrigger(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional) { |
| setMaxBytesForLevelMultiplierAdditional(nativeHandle_, maxBytesForLevelMultiplierAdditional); |
| return this; |
| } |
| |
| @Override |
| public int[] maxBytesForLevelMultiplierAdditional() { |
| return maxBytesForLevelMultiplierAdditional(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setParanoidFileChecks(boolean paranoidFileChecks) { |
| setParanoidFileChecks(nativeHandle_, paranoidFileChecks); |
| return this; |
| } |
| |
| @Override |
| public boolean paranoidFileChecks() { |
| return paranoidFileChecks(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setMaxWriteBufferNumberToMaintain( |
| final int maxWriteBufferNumberToMaintain) { |
| setMaxWriteBufferNumberToMaintain( |
| nativeHandle_, maxWriteBufferNumberToMaintain); |
| return this; |
| } |
| |
| @Override |
| public int maxWriteBufferNumberToMaintain() { |
| return maxWriteBufferNumberToMaintain(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setCompactionPriority( |
| final CompactionPriority compactionPriority) { |
| setCompactionPriority(nativeHandle_, compactionPriority.getValue()); |
| return this; |
| } |
| |
| @Override |
| public CompactionPriority compactionPriority() { |
| return CompactionPriority.getCompactionPriority( |
| compactionPriority(nativeHandle_)); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setReportBgIoStats(final boolean reportBgIoStats) { |
| setReportBgIoStats(nativeHandle_, reportBgIoStats); |
| return this; |
| } |
| |
| @Override |
| public boolean reportBgIoStats() { |
| return reportBgIoStats(nativeHandle_); |
| } |
| |
| @Override |
| public ColumnFamilyOptions setCompactionOptionsUniversal( |
| final CompactionOptionsUniversal compactionOptionsUniversal) { |
| setCompactionOptionsUniversal(nativeHandle_, |
| compactionOptionsUniversal.nativeHandle_); |
| this.compactionOptionsUniversal_ = compactionOptionsUniversal; |
| return this; |
| } |
| |
| @Override |
| public CompactionOptionsUniversal compactionOptionsUniversal() { |
| return this.compactionOptionsUniversal_; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setCompactionOptionsFIFO(final CompactionOptionsFIFO compactionOptionsFIFO) { |
| setCompactionOptionsFIFO(nativeHandle_, |
| compactionOptionsFIFO.nativeHandle_); |
| this.compactionOptionsFIFO_ = compactionOptionsFIFO; |
| return this; |
| } |
| |
| @Override |
| public CompactionOptionsFIFO compactionOptionsFIFO() { |
| return this.compactionOptionsFIFO_; |
| } |
| |
| @Override |
| public ColumnFamilyOptions setForceConsistencyChecks(final boolean forceConsistencyChecks) { |
| setForceConsistencyChecks(nativeHandle_, forceConsistencyChecks); |
| return this; |
| } |
| |
| @Override |
| public boolean forceConsistencyChecks() { |
| return forceConsistencyChecks(nativeHandle_); |
| } |
| |
| /** |
| * <p>Private constructor to be used by |
| * {@link #getColumnFamilyOptionsFromProps(java.util.Properties)}</p> |
| * |
| * @param handle native handle to ColumnFamilyOptions instance. |
| */ |
| private ColumnFamilyOptions(final long handle) { |
| super(handle); |
| } |
| |
| private static native long getColumnFamilyOptionsFromProps( |
| String optString); |
| |
| private static native long newColumnFamilyOptions(); |
| @Override protected final native void disposeInternal(final long handle); |
| |
| 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 setCompactionFilterHandle(long handle, |
| long compactionFilterHandle); |
| 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 setMaxTableFilesSizeFIFO( |
| long handle, long max_table_files_size); |
| private native long maxTableFilesSizeFIFO(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 MemTableConfig memTableConfig_; |
| private TableFormatConfig tableFormatConfig_; |
| private AbstractComparator<? extends AbstractSlice<?>> comparator_; |
| private AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter_; |
| private CompactionOptionsUniversal compactionOptionsUniversal_; |
| private CompactionOptionsFIFO compactionOptionsFIFO_; |
| private CompressionOptions compressionOptions_; |
| |
| } |