| // 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; |
| |
| /** |
| * Options for Universal Compaction |
| */ |
| public class CompactionOptionsUniversal extends RocksObject { |
| |
| public CompactionOptionsUniversal() { |
| super(newCompactionOptionsUniversal()); |
| } |
| |
| /** |
| * Percentage flexibility while comparing file size. If the candidate file(s) |
| * size is 1% smaller than the next file's size, then include next file into |
| * this candidate set. |
| * |
| * Default: 1 |
| * |
| * @param sizeRatio The size ratio to use |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setSizeRatio(final int sizeRatio) { |
| setSizeRatio(nativeHandle_, sizeRatio); |
| return this; |
| } |
| |
| /** |
| * Percentage flexibility while comparing file size. If the candidate file(s) |
| * size is 1% smaller than the next file's size, then include next file into |
| * this candidate set. |
| * |
| * Default: 1 |
| * |
| * @return The size ratio in use |
| */ |
| public int sizeRatio() { |
| return sizeRatio(nativeHandle_); |
| } |
| |
| /** |
| * The minimum number of files in a single compaction run. |
| * |
| * Default: 2 |
| * |
| * @param minMergeWidth minimum number of files in a single compaction run |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setMinMergeWidth(final int minMergeWidth) { |
| setMinMergeWidth(nativeHandle_, minMergeWidth); |
| return this; |
| } |
| |
| /** |
| * The minimum number of files in a single compaction run. |
| * |
| * Default: 2 |
| * |
| * @return minimum number of files in a single compaction run |
| */ |
| public int minMergeWidth() { |
| return minMergeWidth(nativeHandle_); |
| } |
| |
| /** |
| * The maximum number of files in a single compaction run. |
| * |
| * Default: {@link Long#MAX_VALUE} |
| * |
| * @param maxMergeWidth maximum number of files in a single compaction run |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setMaxMergeWidth(final int maxMergeWidth) { |
| setMaxMergeWidth(nativeHandle_, maxMergeWidth); |
| return this; |
| } |
| |
| /** |
| * The maximum number of files in a single compaction run. |
| * |
| * Default: {@link Long#MAX_VALUE} |
| * |
| * @return maximum number of files in a single compaction run |
| */ |
| public int maxMergeWidth() { |
| return maxMergeWidth(nativeHandle_); |
| } |
| |
| /** |
| * The size amplification is defined as the amount (in percentage) of |
| * additional storage needed to store a single byte of data in the database. |
| * For example, a size amplification of 2% means that a database that |
| * contains 100 bytes of user-data may occupy upto 102 bytes of |
| * physical storage. By this definition, a fully compacted database has |
| * a size amplification of 0%. Rocksdb uses the following heuristic |
| * to calculate size amplification: it assumes that all files excluding |
| * the earliest file contribute to the size amplification. |
| * |
| * Default: 200, which means that a 100 byte database could require upto |
| * 300 bytes of storage. |
| * |
| * @param maxSizeAmplificationPercent the amount of additional storage needed |
| * (as a percentage) to store a single byte in the database |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setMaxSizeAmplificationPercent( |
| final int maxSizeAmplificationPercent) { |
| setMaxSizeAmplificationPercent(nativeHandle_, maxSizeAmplificationPercent); |
| return this; |
| } |
| |
| /** |
| * The size amplification is defined as the amount (in percentage) of |
| * additional storage needed to store a single byte of data in the database. |
| * For example, a size amplification of 2% means that a database that |
| * contains 100 bytes of user-data may occupy upto 102 bytes of |
| * physical storage. By this definition, a fully compacted database has |
| * a size amplification of 0%. Rocksdb uses the following heuristic |
| * to calculate size amplification: it assumes that all files excluding |
| * the earliest file contribute to the size amplification. |
| * |
| * Default: 200, which means that a 100 byte database could require upto |
| * 300 bytes of storage. |
| * |
| * @return the amount of additional storage needed (as a percentage) to store |
| * a single byte in the database |
| */ |
| public int maxSizeAmplificationPercent() { |
| return maxSizeAmplificationPercent(nativeHandle_); |
| } |
| |
| /** |
| * If this option is set to be -1 (the default value), all the output files |
| * will follow compression type specified. |
| * |
| * If this option is not negative, we will try to make sure compressed |
| * size is just above this value. In normal cases, at least this percentage |
| * of data will be compressed. |
| * |
| * When we are compacting to a new file, here is the criteria whether |
| * it needs to be compressed: assuming here are the list of files sorted |
| * by generation time: |
| * A1...An B1...Bm C1...Ct |
| * where A1 is the newest and Ct is the oldest, and we are going to compact |
| * B1...Bm, we calculate the total size of all the files as total_size, as |
| * well as the total size of C1...Ct as total_C, the compaction output file |
| * will be compressed iff |
| * total_C / total_size < this percentage |
| * |
| * Default: -1 |
| * |
| * @param compressionSizePercent percentage of size for compression |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setCompressionSizePercent( |
| final int compressionSizePercent) { |
| setCompressionSizePercent(nativeHandle_, compressionSizePercent); |
| return this; |
| } |
| |
| /** |
| * If this option is set to be -1 (the default value), all the output files |
| * will follow compression type specified. |
| * |
| * If this option is not negative, we will try to make sure compressed |
| * size is just above this value. In normal cases, at least this percentage |
| * of data will be compressed. |
| * |
| * When we are compacting to a new file, here is the criteria whether |
| * it needs to be compressed: assuming here are the list of files sorted |
| * by generation time: |
| * A1...An B1...Bm C1...Ct |
| * where A1 is the newest and Ct is the oldest, and we are going to compact |
| * B1...Bm, we calculate the total size of all the files as total_size, as |
| * well as the total size of C1...Ct as total_C, the compaction output file |
| * will be compressed iff |
| * total_C / total_size < this percentage |
| * |
| * Default: -1 |
| * |
| * @return percentage of size for compression |
| */ |
| public int compressionSizePercent() { |
| return compressionSizePercent(nativeHandle_); |
| } |
| |
| /** |
| * The algorithm used to stop picking files into a single compaction run |
| * |
| * Default: {@link CompactionStopStyle#CompactionStopStyleTotalSize} |
| * |
| * @param compactionStopStyle The compaction algorithm |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setStopStyle( |
| final CompactionStopStyle compactionStopStyle) { |
| setStopStyle(nativeHandle_, compactionStopStyle.getValue()); |
| return this; |
| } |
| |
| /** |
| * The algorithm used to stop picking files into a single compaction run |
| * |
| * Default: {@link CompactionStopStyle#CompactionStopStyleTotalSize} |
| * |
| * @return The compaction algorithm |
| */ |
| public CompactionStopStyle stopStyle() { |
| return CompactionStopStyle.getCompactionStopStyle(stopStyle(nativeHandle_)); |
| } |
| |
| /** |
| * Option to optimize the universal multi level compaction by enabling |
| * trivial move for non overlapping files. |
| * |
| * Default: false |
| * |
| * @param allowTrivialMove true if trivial move is allowed |
| * |
| * @return the reference to the current options. |
| */ |
| public CompactionOptionsUniversal setAllowTrivialMove( |
| final boolean allowTrivialMove) { |
| setAllowTrivialMove(nativeHandle_, allowTrivialMove); |
| return this; |
| } |
| |
| /** |
| * Option to optimize the universal multi level compaction by enabling |
| * trivial move for non overlapping files. |
| * |
| * Default: false |
| * |
| * @return true if trivial move is allowed |
| */ |
| public boolean allowTrivialMove() { |
| return allowTrivialMove(nativeHandle_); |
| } |
| |
| private native static long newCompactionOptionsUniversal(); |
| @Override protected final native void disposeInternal(final long handle); |
| |
| private native void setSizeRatio(final long handle, final int sizeRatio); |
| private native int sizeRatio(final long handle); |
| private native void setMinMergeWidth( |
| final long handle, final int minMergeWidth); |
| private native int minMergeWidth(final long handle); |
| private native void setMaxMergeWidth( |
| final long handle, final int maxMergeWidth); |
| private native int maxMergeWidth(final long handle); |
| private native void setMaxSizeAmplificationPercent( |
| final long handle, final int maxSizeAmplificationPercent); |
| private native int maxSizeAmplificationPercent(final long handle); |
| private native void setCompressionSizePercent( |
| final long handle, final int compressionSizePercent); |
| private native int compressionSizePercent(final long handle); |
| private native void setStopStyle( |
| final long handle, final byte stopStyle); |
| private native byte stopStyle(final long handle); |
| private native void setAllowTrivialMove( |
| final long handle, final boolean allowTrivialMove); |
| private native boolean allowTrivialMove(final long handle); |
| } |