rocksdb-native 0.0.0 → 0.0.1

package/vendor/rocksdb/java/src/main/java/org/rocksdb/CompactionOptions.java

@@ -1,121 +0,0 @@
-// 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.List;
-
-/**
- * CompactionOptions are used in
- * {@link RocksDB#compactFiles(CompactionOptions, ColumnFamilyHandle, List, int, int, CompactionJobInfo)}
- * calls.
- */
-public class CompactionOptions extends RocksObject {
-
-  public CompactionOptions() {
-    super(newCompactionOptions());
-  }
-
-  /**
-   * Get the compaction output compression type.
-   *
-   * See {@link #setCompression(CompressionType)}.
-   *
-   * @return the compression type.
-   */
-  public CompressionType compression() {
-    return CompressionType.getCompressionType(
-        compression(nativeHandle_));
-  }
-
-  /**
-   * Set the compaction output compression type.
-   *
-   * Default: snappy
-   *
-   * If set to {@link CompressionType#DISABLE_COMPRESSION_OPTION},
-   * RocksDB will choose compression type according to the
-   * {@link ColumnFamilyOptions#compressionType()}, taking into account
-   * the output level if {@link ColumnFamilyOptions#compressionPerLevel()}
-   * is specified.
-   *
-   * @param compression the compression type to use for compaction output.
-   *
-   * @return the instance of the current Options.
-   */
-  public CompactionOptions setCompression(final CompressionType compression) {
-    setCompression(nativeHandle_, compression.getValue());
-    return this;
-  }
-
-  /**
-   * Get the compaction output file size limit.
-   *
-   * See {@link #setOutputFileSizeLimit(long)}.
-   *
-   * @return the file size limit.
-   */
-  public long outputFileSizeLimit() {
-    return outputFileSizeLimit(nativeHandle_);
-  }
-
-  /**
-   * Compaction will create files of size {@link #outputFileSizeLimit()}.
-   *
-   * Default: 2^64-1, which means that compaction will create a single file
-   *
-   * @param outputFileSizeLimit the size limit
-   *
-   * @return the instance of the current Options.
-   */
-  public CompactionOptions setOutputFileSizeLimit(
-      final long outputFileSizeLimit) {
-    setOutputFileSizeLimit(nativeHandle_, outputFileSizeLimit);
-    return this;
-  }
-
-  /**
-   * Get the maximum number of threads that will concurrently perform a
-   * compaction job.
-   *
-   * @return the maximum number of threads.
-   */
-  public int maxSubcompactions() {
-    return maxSubcompactions(nativeHandle_);
-  }
-
-  /**
-   * This value represents the maximum number of threads that will
-   * concurrently perform a compaction job by breaking it into multiple,
-   * smaller ones that are run simultaneously.
-   *
-   * Default: 0 (i.e. no subcompactions)
-   *
-   * If > 0, it will replace the option in
-   * {@link DBOptions#maxSubcompactions()} for this compaction.
-   *
-   * @param maxSubcompactions The maximum number of threads that will
-   *     concurrently perform a compaction job
-   *
-   * @return the instance of the current Options.
-   */
-  public CompactionOptions setMaxSubcompactions(final int maxSubcompactions) {
-    setMaxSubcompactions(nativeHandle_, maxSubcompactions);
-    return this;
-  }
-
-  private static native long newCompactionOptions();
-  @Override protected final native void disposeInternal(final long handle);
-
-  private static native byte compression(final long handle);
-  private static native void setCompression(final long handle,
-      final byte compressionTypeValue);
-  private static native long outputFileSizeLimit(final long handle);
-  private static native void setOutputFileSizeLimit(final long handle,
-      final long outputFileSizeLimit);
-  private static native int maxSubcompactions(final long handle);
-  private static native void setMaxSubcompactions(final long handle,
-      final int maxSubcompactions);
-}

package/vendor/rocksdb/java/src/main/java/org/rocksdb/CompactionOptionsFIFO.java

@@ -1,87 +0,0 @@
-// 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 FIFO Compaction
- */
-public class CompactionOptionsFIFO extends RocksObject {
-
-  public CompactionOptionsFIFO() {
-    super(newCompactionOptionsFIFO());
-  }
-
-  /**
-   * Once the total sum of table files reaches this, we will delete the oldest
-   * table file
-   * <p>
-   * Default: 1GB
-   *
-   * @param maxTableFilesSize The maximum size of the table files
-   *
-   * @return the reference to the current options.
-   */
-  public CompactionOptionsFIFO setMaxTableFilesSize(
-      final long maxTableFilesSize) {
-    setMaxTableFilesSize(nativeHandle_, maxTableFilesSize);
-    return this;
-  }
-
-  /**
-   * Once the total sum of table files reaches this, we will delete the oldest
-   * table file
-   * <p>
-   * Default: 1GB
-   *
-   * @return max table file size in bytes
-   */
-  public long maxTableFilesSize() {
-    return maxTableFilesSize(nativeHandle_);
-  }
-
-  /**
-   * If true, try to do compaction to compact smaller files into larger ones.
-   * Minimum files to compact follows options.level0_file_num_compaction_trigger
-   * and compaction won't trigger if average compact bytes per del file is
-   * larger than options.write_buffer_size. This is to protect large files
-   * from being compacted again.
-   * <p>
-   * Default: false
-   *
-   * @param allowCompaction true to allow intra-L0 compaction
-   *
-   * @return the reference to the current options.
-   */
-  public CompactionOptionsFIFO setAllowCompaction(
-      final boolean allowCompaction) {
-    setAllowCompaction(nativeHandle_, allowCompaction);
-    return this;
-  }
-
-  /**
-   * Check if intra-L0 compaction is enabled.
-   * When enabled, we try to compact smaller files into larger ones.
-   * <p>
-   * See {@link #setAllowCompaction(boolean)}.
-   * <p>
-   * Default: false
-   *
-   * @return true if intra-L0 compaction is enabled, false otherwise.
-   */
-  public boolean allowCompaction() {
-    return allowCompaction(nativeHandle_);
-  }
-
-  private static native long newCompactionOptionsFIFO();
-  @Override protected final native void disposeInternal(final long handle);
-
-  private native void setMaxTableFilesSize(final long handle,
-      final long maxTableFilesSize);
-  private native long maxTableFilesSize(final long handle);
-  private native void setAllowCompaction(final long handle,
-      final boolean allowCompaction);
-  private native boolean allowCompaction(final long handle);
-}

package/vendor/rocksdb/java/src/main/java/org/rocksdb/CompactionOptionsUniversal.java

@@ -1,273 +0,0 @@
-// 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.
-   * <p>
-   * 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.
-   * <p>
-   * Default: 1
-   *
-   * @return The size ratio in use
-   */
-  public int sizeRatio() {
-    return sizeRatio(nativeHandle_);
-  }
-
-  /**
-   * The minimum number of files in a single compaction run.
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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 &lt; this percentage
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * 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 &lt; this percentage
-   * <p>
-   * 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
-   * <p>
-   * 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
-   * <p>
-   * 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.
-   * <p>
-   * 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.
-   * <p>
-   * Default: false
-   *
-   * @return true if trivial move is allowed
-   */
-  public boolean allowTrivialMove() {
-    return allowTrivialMove(nativeHandle_);
-  }
-
-  private static native 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);
-}

package/vendor/rocksdb/java/src/main/java/org/rocksdb/CompactionPriority.java

@@ -1,81 +0,0 @@
-// 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;
-
-/**
- * Compaction Priorities
- */
-public enum CompactionPriority {
-
-  /**
-   * Slightly Prioritize larger files by size compensated by #deletes
-   */
-  ByCompensatedSize((byte)0x0),
-
-  /**
-   * First compact files whose data's latest update time is oldest.
-   * Try this if you only update some hot keys in small ranges.
-   */
-  OldestLargestSeqFirst((byte)0x1),
-
-  /**
-   * First compact files whose range hasn't been compacted to the next level
-   * for the longest. If your updates are random across the key space,
-   * write amplification is slightly better with this option.
-   */
-  OldestSmallestSeqFirst((byte)0x2),
-
-  /**
-   * First compact files whose ratio between overlapping size in next level
-   * and its size is the smallest. It in many cases can optimize write
-   * amplification.
-   */
-  MinOverlappingRatio((byte)0x3),
-
-  /**
-   * Keeps a cursor(s) of the successor of the file (key range) was/were
-   * compacted before, and always picks the next files (key range) in that
-   * level. The file picking process will cycle through all the files in a
-   * round-robin manner.
-   */
-  RoundRobin((byte)0x4);
-
-
-  private final byte value;
-
-  CompactionPriority(final byte value) {
-    this.value = value;
-  }
-
-  /**
-   * Returns the byte value of the enumerations value
-   *
-   * @return byte representation
-   */
-  public byte getValue() {
-    return value;
-  }
-
-  /**
-   * Get CompactionPriority by byte value.
-   *
-   * @param value byte representation of CompactionPriority.
-   *
-   * @return {@link org.rocksdb.CompactionPriority} instance or null.
-   * @throws java.lang.IllegalArgumentException if an invalid
-   *     value is provided.
-   */
-  public static CompactionPriority getCompactionPriority(final byte value) {
-    for (final CompactionPriority compactionPriority :
-        CompactionPriority.values()) {
-      if (compactionPriority.getValue() == value){
-        return compactionPriority;
-      }
-    }
-    throw new IllegalArgumentException(
-        "Illegal value provided for CompactionPriority.");
-  }
-}

package/vendor/rocksdb/java/src/main/java/org/rocksdb/CompactionReason.java

@@ -1,141 +0,0 @@
-// 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;
-
-public enum CompactionReason {
-  kUnknown((byte)0x0),
-
-  /**
-   * [Level] number of L0 files > level0_file_num_compaction_trigger
-   */
-  kLevelL0FilesNum((byte)0x1),
-
-  /**
-   * [Level] total size of level > MaxBytesForLevel()
-   */
-  kLevelMaxLevelSize((byte)0x2),
-
-  /**
-   * [Universal] Compacting for size amplification
-   */
-  kUniversalSizeAmplification((byte)0x3),
-
-  /**
-   * [Universal] Compacting for size ratio
-   */
-  kUniversalSizeRatio((byte)0x4),
-
-  /**
-   * [Universal] number of sorted runs > level0_file_num_compaction_trigger
-   */
-  kUniversalSortedRunNum((byte)0x5),
-
-  /**
-   * [FIFO] total size > max_table_files_size
-   */
-  kFIFOMaxSize((byte)0x6),
-
-  /**
-   * [FIFO] reduce number of files.
-   */
-  kFIFOReduceNumFiles((byte)0x7),
-
-  /**
-   * [FIFO] files with creation time < (current_time - interval)
-   */
-  kFIFOTtl((byte)0x8),
-
-  /**
-   * Manual compaction
-   */
-  kManualCompaction((byte)0x9),
-
-  /**
-   * DB::SuggestCompactRange() marked files for compaction
-   */
-  kFilesMarkedForCompaction((byte)0x10),
-
-  /**
-   * [Level] Automatic compaction within bottommost level to cleanup duplicate
-   * versions of same user key, usually due to a released snapshot.
-   */
-  kBottommostFiles((byte)0x0A),
-
-  /**
-   * Compaction based on TTL
-   */
-  kTtl((byte)0x0B),
-
-  /**
-   * According to the comments in flush_job.cc, RocksDB treats flush as
-   * a level 0 compaction in internal stats.
-   */
-  kFlush((byte)0x0C),
-
-  /**
-   * Compaction caused by external sst file ingestion
-   */
-  kExternalSstIngestion((byte) 0x0D),
-
-  /**
-   * Compaction due to SST file being too old
-   */
-  kPeriodicCompaction((byte) 0x0E),
-
-  /**
-   * Compaction in order to move files to temperature
-   */
-  kChangeTemperature((byte) 0x0F),
-
-  /**
-   * Compaction scheduled to force garbage collection of blob files
-   */
-  kForcedBlobGC((byte) 0x11),
-
-  /**
-   * A special TTL compaction for RoundRobin policy, which basically the same as
-   * kLevelMaxLevelSize, but the goal is to compact TTLed files.
-   */
-  kRoundRobinTtl((byte) 0x12),
-
-  /**
-   * Compaction by calling DBImpl::ReFitLevel
-   */
-  kRefitLevel((byte) 0x13);
-
-  private final byte value;
-
-  CompactionReason(final byte value) {
-    this.value = value;
-  }
-
-  /**
-   * Get the internal representation value.
-   *
-   * @return the internal representation value
-   */
-  byte getValue() {
-    return value;
-  }
-
-  /**
-   * Get the CompactionReason from the internal representation value.
-   *
-   * @return the compaction reason.
-   *
-   * @throws IllegalArgumentException if the value is unknown.
-   */
-  static CompactionReason fromValue(final byte value) {
-    for (final CompactionReason compactionReason : CompactionReason.values()) {
-      if(compactionReason.value == value) {
-        return compactionReason;
-      }
-    }
-
-    throw new IllegalArgumentException(
-        "Illegal value provided for CompactionReason: " + value);
-  }
-}