Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
// 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);
}
