org.rocksdb.PlainTableConfig Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rocksdbjni Show documentation
RocksDB fat jar that contains .so files for linux32 and linux64 (glibc and musl-libc), jnilib files for Mac OSX, and a .dll for Windows x64.
The newest version!
// 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;

/**
 * The config for plain table sst format.
 *
 * PlainTable is a RocksDB's SST file format optimized for low query
 * latency on pure-memory or really low-latency media.
 *
 * It also support prefix hash feature.
 */
public class PlainTableConfig extends TableFormatConfig {
  public static final int VARIABLE_LENGTH = 0;
  public static final int DEFAULT_BLOOM_BITS_PER_KEY = 10;
  public static final double DEFAULT_HASH_TABLE_RATIO = 0.75;
  public static final int DEFAULT_INDEX_SPARSENESS = 16;
  public static final int DEFAULT_HUGE_TLB_SIZE = 0;
  public static final EncodingType DEFAULT_ENCODING_TYPE =
      EncodingType.kPlain;
  public static final boolean DEFAULT_FULL_SCAN_MODE = false;
  public static final boolean DEFAULT_STORE_INDEX_IN_FILE
      = false;

  public PlainTableConfig() {
    keySize_ = VARIABLE_LENGTH;
    bloomBitsPerKey_ = DEFAULT_BLOOM_BITS_PER_KEY;
    hashTableRatio_ = DEFAULT_HASH_TABLE_RATIO;
    indexSparseness_ = DEFAULT_INDEX_SPARSENESS;
    hugePageTlbSize_ = DEFAULT_HUGE_TLB_SIZE;
    encodingType_ = DEFAULT_ENCODING_TYPE;
    fullScanMode_ = DEFAULT_FULL_SCAN_MODE;
    storeIndexInFile_ = DEFAULT_STORE_INDEX_IN_FILE;
  }

  /**
   * Set the length of the user key. If it is set to be
   * VARIABLE_LENGTH, then it indicates the user keys are
   * of variable length.
   *
   * Otherwise,all the keys need to have the same length
   * in byte.
   *
   * DEFAULT: VARIABLE_LENGTH
   *
   * @param keySize the length of the user key.
   * @return the reference to the current config.
   */
  public PlainTableConfig setKeySize(int keySize) {
    keySize_ = keySize;
    return this;
  }

  /**
   * @return the specified size of the user key.  If VARIABLE_LENGTH,
   *     then it indicates variable-length key.
   */
  public int keySize() {
    return keySize_;
  }

  /**
   * Set the number of bits per key used by the internal bloom filter
   * in the plain table sst format.
   *
   * @param bitsPerKey the number of bits per key for bloom filer.
   * @return the reference to the current config.
   */
  public PlainTableConfig setBloomBitsPerKey(int bitsPerKey) {
    bloomBitsPerKey_ = bitsPerKey;
    return this;
  }

  /**
   * @return the number of bits per key used for the bloom filter.
   */
  public int bloomBitsPerKey() {
    return bloomBitsPerKey_;
  }

  /**
   * hashTableRatio is the desired utilization of the hash table used
   * for prefix hashing.  The ideal ratio would be the number of
   * prefixes / the number of hash buckets.  If this value is set to
   * zero, then hash table will not be used.
   *
   * @param ratio the hash table ratio.
   * @return the reference to the current config.
   */
  public PlainTableConfig setHashTableRatio(double ratio) {
    hashTableRatio_ = ratio;
    return this;
  }

  /**
   * @return the hash table ratio.
   */
  public double hashTableRatio() {
    return hashTableRatio_;
  }

  /**
   * Index sparseness determines the index interval for keys inside the
   * same prefix.  This number is equal to the maximum number of linear
   * search required after hash and binary search.  If it's set to 0,
   * then each key will be indexed.
   *
   * @param sparseness the index sparseness.
   * @return the reference to the current config.
   */
  public PlainTableConfig setIndexSparseness(int sparseness) {
    indexSparseness_ = sparseness;
    return this;
  }

  /**
   * @return the index sparseness.
   */
  public long indexSparseness() {
    return indexSparseness_;
  }

  /**
   * huge_page_tlb_size: if ≤0, allocate hash indexes and blooms
   * from malloc otherwise from huge page TLB.
   *
   * The user needs to reserve huge pages for it to be allocated,
   * like: {@code sysctl -w vm.nr_hugepages=20}
   *
   * See linux doc Documentation/vm/hugetlbpage.txt
   *
   * @param hugePageTlbSize huge page tlb size
   * @return the reference to the current config.
   */
  public PlainTableConfig setHugePageTlbSize(int hugePageTlbSize) {
    this.hugePageTlbSize_ = hugePageTlbSize;
    return this;
  }

  /**
   * Returns the value for huge page tlb size
   *
   * @return hugePageTlbSize
   */
  public int hugePageTlbSize() {
    return hugePageTlbSize_;
  }

  /**
   * Sets the encoding type.
   *
   * This setting determines how to encode
   * the keys. See enum {@link EncodingType} for
   * the choices.
   *
   * The value will determine how to encode keys
   * when writing to a new SST file. This value will be stored
   * inside the SST file which will be used when reading from
   * the file, which makes it possible for users to choose
   * different encoding type when reopening a DB. Files with
   * different encoding types can co-exist in the same DB and
   * can be read.
   *
   * @param encodingType {@link org.rocksdb.EncodingType} value.
   * @return the reference to the current config.
   */
  public PlainTableConfig setEncodingType(EncodingType encodingType) {
    this.encodingType_ = encodingType;
    return this;
  }

  /**
   * Returns the active EncodingType
   *
   * @return currently set encoding type
   */
  public EncodingType encodingType() {
    return encodingType_;
  }

  /**
   * Set full scan mode, if true the whole file will be read
   * one record by one without using the index.
   *
   * @param fullScanMode boolean value indicating if full
   *     scan mode shall be enabled.
   * @return the reference to the current config.
   */
  public PlainTableConfig setFullScanMode(boolean fullScanMode) {
    this.fullScanMode_ = fullScanMode;
    return this;
  }

  /**
   * Return if full scan mode is active
   * @return boolean value indicating if the full scan mode is
   *     enabled.
   */
  public boolean fullScanMode() {
    return fullScanMode_;
  }

  /**
   * If set to true: compute plain table index and bloom
   * filter during file building and store it in file.
   * When reading file, index will be mmaped instead
   * of doing recomputation.
   *
   * @param storeIndexInFile value indicating if index shall
   *     be stored in a file
   * @return the reference to the current config.
   */
  public PlainTableConfig setStoreIndexInFile(boolean storeIndexInFile) {
    this.storeIndexInFile_ = storeIndexInFile;
    return this;
  }

  /**
   * Return a boolean value indicating if index shall be stored
   * in a file.
   *
   * @return currently set value for store index in file.
   */
  public boolean storeIndexInFile() {
    return storeIndexInFile_;
  }

  @Override protected long newTableFactoryHandle() {
    return newTableFactoryHandle(keySize_, bloomBitsPerKey_,
        hashTableRatio_, indexSparseness_, hugePageTlbSize_,
        encodingType_.getValue(), fullScanMode_,
        storeIndexInFile_);
  }

  private native long newTableFactoryHandle(
      int keySize, int bloomBitsPerKey,
      double hashTableRatio, int indexSparseness,
      int hugePageTlbSize, byte encodingType,
      boolean fullScanMode, boolean storeIndexInFile);

  private int keySize_;
  private int bloomBitsPerKey_;
  private double hashTableRatio_;
  private int indexSparseness_;
  private int hugePageTlbSize_;
  private EncodingType encodingType_;
  private boolean fullScanMode_;
  private boolean storeIndexInFile_;
}