rocksdb-native 0.0.0

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

@@ -0,0 +1,366 @@
+// 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 while opening a file to read/write
+ */
+public class EnvOptions extends RocksObject {
+  static {
+    RocksDB.loadLibrary();
+  }
+
+  /**
+   * Construct with default Options
+   */
+  public EnvOptions() {
+    super(newEnvOptions());
+  }
+
+  /**
+   * Construct from {@link DBOptions}.
+   *
+   * @param dbOptions the database options.
+   */
+  public EnvOptions(final DBOptions dbOptions) {
+    super(newEnvOptions(dbOptions.nativeHandle_));
+  }
+
+  /**
+   * Enable/Disable memory mapped reads.
+   * <p>
+   * Default: false
+   *
+   * @param useMmapReads true to enable memory mapped reads, false to disable.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setUseMmapReads(final boolean useMmapReads) {
+    setUseMmapReads(nativeHandle_, useMmapReads);
+    return this;
+  }
+
+  /**
+   * Determine if memory mapped reads are in-use.
+   *
+   * @return true if memory mapped reads are in-use, false otherwise.
+   */
+  public boolean useMmapReads() {
+    assert(isOwningHandle());
+    return useMmapReads(nativeHandle_);
+  }
+
+  /**
+   * Enable/Disable memory mapped Writes.
+   * <p>
+   * Default: true
+   *
+   * @param useMmapWrites true to enable memory mapped writes, false to disable.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setUseMmapWrites(final boolean useMmapWrites) {
+    setUseMmapWrites(nativeHandle_, useMmapWrites);
+    return this;
+  }
+
+  /**
+   * Determine if memory mapped writes are in-use.
+   *
+   * @return true if memory mapped writes are in-use, false otherwise.
+   */
+  public boolean useMmapWrites() {
+    assert(isOwningHandle());
+    return useMmapWrites(nativeHandle_);
+  }
+
+  /**
+   * Enable/Disable direct reads, i.e. {@code O_DIRECT}.
+   * <p>
+   * Default: false
+   *
+   * @param useDirectReads true to enable direct reads, false to disable.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setUseDirectReads(final boolean useDirectReads) {
+    setUseDirectReads(nativeHandle_, useDirectReads);
+    return this;
+  }
+
+  /**
+   * Determine if direct reads are in-use.
+   *
+   * @return true if direct reads are in-use, false otherwise.
+   */
+  public boolean useDirectReads() {
+    assert(isOwningHandle());
+    return useDirectReads(nativeHandle_);
+  }
+
+  /**
+   * Enable/Disable direct writes, i.e. {@code O_DIRECT}.
+   * <p>
+   * Default: false
+   *
+   * @param useDirectWrites true to enable direct writes, false to disable.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setUseDirectWrites(final boolean useDirectWrites) {
+    setUseDirectWrites(nativeHandle_, useDirectWrites);
+    return this;
+  }
+
+  /**
+   * Determine if direct writes are in-use.
+   *
+   * @return true if direct writes are in-use, false otherwise.
+   */
+  public boolean useDirectWrites() {
+    assert(isOwningHandle());
+    return useDirectWrites(nativeHandle_);
+  }
+
+  /**
+   * Enable/Disable fallocate calls.
+   * <p>
+   * Default: true
+   * <p>
+   * If false, {@code fallocate()} calls are bypassed.
+   *
+   * @param allowFallocate true to enable fallocate calls, false to disable.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setAllowFallocate(final boolean allowFallocate) {
+    setAllowFallocate(nativeHandle_, allowFallocate);
+    return this;
+  }
+
+  /**
+   * Determine if fallocate calls are used.
+   *
+   * @return true if fallocate calls are used, false otherwise.
+   */
+  public boolean allowFallocate() {
+    assert(isOwningHandle());
+    return allowFallocate(nativeHandle_);
+  }
+
+  /**
+   * Enable/Disable the {@code FD_CLOEXEC} bit when opening file descriptors.
+   * <p>
+   * Default: true
+   *
+   * @param setFdCloexec true to enable the {@code FB_CLOEXEC} bit,
+   *     false to disable.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setSetFdCloexec(final boolean setFdCloexec) {
+    setSetFdCloexec(nativeHandle_, setFdCloexec);
+    return this;
+  }
+
+  /**
+   * Determine i fthe {@code FD_CLOEXEC} bit is set when opening file
+   * descriptors.
+   *
+   * @return true if the {@code FB_CLOEXEC} bit is enabled, false otherwise.
+   */
+  public boolean setFdCloexec() {
+    assert(isOwningHandle());
+    return setFdCloexec(nativeHandle_);
+  }
+
+  /**
+   * Allows OS to incrementally sync files to disk while they are being
+   * written, in the background. Issue one request for every
+   * {@code bytesPerSync} written.
+   * <p>
+   * Default: 0
+   *
+   * @param bytesPerSync 0 to disable, otherwise the number of bytes.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setBytesPerSync(final long bytesPerSync) {
+    setBytesPerSync(nativeHandle_, bytesPerSync);
+    return this;
+  }
+
+  /**
+   * Get the number of incremental bytes per sync written in the background.
+   *
+   * @return 0 if disabled, otherwise the number of bytes.
+   */
+  public long bytesPerSync() {
+    assert(isOwningHandle());
+    return bytesPerSync(nativeHandle_);
+  }
+
+  /**
+   * If true, we will preallocate the file with {@code FALLOC_FL_KEEP_SIZE}
+   * flag, which means that file size won't change as part of preallocation.
+   * If false, preallocation will also change the file size. This option will
+   * improve the performance in workloads where you sync the data on every
+   * write. By default, we set it to true for MANIFEST writes and false for
+   * WAL writes
+   *
+   * @param fallocateWithKeepSize true to preallocate, false otherwise.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setFallocateWithKeepSize(
+      final boolean fallocateWithKeepSize) {
+    setFallocateWithKeepSize(nativeHandle_, fallocateWithKeepSize);
+    return this;
+  }
+
+  /**
+   * Determine if file is preallocated.
+   *
+   * @return true if the file is preallocated, false otherwise.
+   */
+  public boolean fallocateWithKeepSize() {
+    assert(isOwningHandle());
+    return fallocateWithKeepSize(nativeHandle_);
+  }
+
+  /**
+   * See {@link DBOptions#setCompactionReadaheadSize(long)}.
+   *
+   * @param compactionReadaheadSize the compaction read-ahead size.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setCompactionReadaheadSize(
+      final long compactionReadaheadSize) {
+    setCompactionReadaheadSize(nativeHandle_, compactionReadaheadSize);
+    return this;
+  }
+
+  /**
+   * See {@link DBOptions#compactionReadaheadSize()}.
+   *
+   * @return the compaction read-ahead size.
+   */
+  public long compactionReadaheadSize() {
+    assert(isOwningHandle());
+    return compactionReadaheadSize(nativeHandle_);
+  }
+
+  /**
+   * See {@link DBOptions#setRandomAccessMaxBufferSize(long)}.
+   *
+   * @param randomAccessMaxBufferSize the max buffer size for random access.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setRandomAccessMaxBufferSize(
+      final long randomAccessMaxBufferSize) {
+    setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize);
+    return this;
+  }
+
+  /**
+   * See {@link DBOptions#randomAccessMaxBufferSize()}.
+   *
+   * @return the max buffer size for random access.
+   */
+  public long randomAccessMaxBufferSize() {
+    assert(isOwningHandle());
+    return randomAccessMaxBufferSize(nativeHandle_);
+  }
+
+  /**
+   * See {@link DBOptions#setWritableFileMaxBufferSize(long)}.
+   *
+   * @param writableFileMaxBufferSize the max buffer size.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setWritableFileMaxBufferSize(
+      final long writableFileMaxBufferSize) {
+    setWritableFileMaxBufferSize(nativeHandle_, writableFileMaxBufferSize);
+    return this;
+  }
+
+  /**
+   * See {@link DBOptions#writableFileMaxBufferSize()}.
+   *
+   * @return the max buffer size.
+   */
+  public long writableFileMaxBufferSize() {
+    assert(isOwningHandle());
+    return writableFileMaxBufferSize(nativeHandle_);
+  }
+
+  /**
+   * Set the write rate limiter for flush and compaction.
+   *
+   * @param rateLimiter the rate limiter.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setRateLimiter(final RateLimiter rateLimiter) {
+    this.rateLimiter = rateLimiter;
+    setRateLimiter(nativeHandle_, rateLimiter.nativeHandle_);
+    return this;
+  }
+
+  /**
+   * Get the write rate limiter for flush and compaction.
+   *
+   * @return the rate limiter.
+   */
+  public RateLimiter rateLimiter() {
+    assert(isOwningHandle());
+    return rateLimiter;
+  }
+
+  private static native long newEnvOptions();
+  private static native long newEnvOptions(final long dboptions_handle);
+  @Override protected final native void disposeInternal(final long handle);
+
+  private native void setUseMmapReads(final long handle,
+      final boolean useMmapReads);
+  private native boolean useMmapReads(final long handle);
+  private native void setUseMmapWrites(final long handle,
+      final boolean useMmapWrites);
+  private native boolean useMmapWrites(final long handle);
+  private native void setUseDirectReads(final long handle,
+      final boolean useDirectReads);
+  private native boolean useDirectReads(final long handle);
+  private native void setUseDirectWrites(final long handle,
+      final boolean useDirectWrites);
+  private native boolean useDirectWrites(final long handle);
+  private native void setAllowFallocate(final long handle,
+      final boolean allowFallocate);
+  private native boolean allowFallocate(final long handle);
+  private native void setSetFdCloexec(final long handle,
+      final boolean setFdCloexec);
+  private native boolean setFdCloexec(final long handle);
+  private native void setBytesPerSync(final long handle,
+      final long bytesPerSync);
+  private native long bytesPerSync(final long handle);
+  private native void setFallocateWithKeepSize(
+      final long handle, final boolean fallocateWithKeepSize);
+  private native boolean fallocateWithKeepSize(final long handle);
+  private native void setCompactionReadaheadSize(
+      final long handle, final long compactionReadaheadSize);
+  private native long compactionReadaheadSize(final long handle);
+  private native void setRandomAccessMaxBufferSize(
+      final long handle, final long randomAccessMaxBufferSize);
+  private native long randomAccessMaxBufferSize(final long handle);
+  private native void setWritableFileMaxBufferSize(
+      final long handle, final long writableFileMaxBufferSize);
+  private native long writableFileMaxBufferSize(final long handle);
+  private native void setRateLimiter(final long handle,
+      final long rateLimiterHandle);
+  private RateLimiter rateLimiter;
+}

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

@@ -0,0 +1,335 @@
+// 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;
+
+/**
+ * EventListener class contains a set of callback functions that will
+ * be called when specific RocksDB event happens such as flush.  It can
+ * be used as a building block for developing custom features such as
+ * stats-collector or external compaction algorithm.
+ * <p>
+ * Note that callback functions should not run for an extended period of
+ * time before the function returns, otherwise RocksDB may be blocked.
+ * For example, it is not suggested to do
+ * {@link RocksDB#compactFiles(CompactionOptions, ColumnFamilyHandle, List, int, int,
+ * CompactionJobInfo)} (as it may run for a long while) or issue many of
+ * {@link RocksDB#put(ColumnFamilyHandle, WriteOptions, byte[], byte[])}
+ * (as Put may be blocked in certain cases) in the same thread in the
+ * EventListener callback.
+ * <p>
+ * However, doing
+ * {@link RocksDB#compactFiles(CompactionOptions, ColumnFamilyHandle, List, int, int,
+ * CompactionJobInfo)} and {@link RocksDB#put(ColumnFamilyHandle, WriteOptions, byte[], byte[])} in
+ * another thread is considered safe.
+ * <p>
+ * [Threading] All EventListener callback will be called using the
+ * actual thread that involves in that specific event. For example, it
+ * is the RocksDB background flush thread that does the actual flush to
+ * call {@link #onFlushCompleted(RocksDB, FlushJobInfo)}.
+ * <p>
+ * [Locking] All EventListener callbacks are designed to be called without
+ * the current thread holding any DB mutex. This is to prevent potential
+ * deadlock and performance issue when using EventListener callback
+ * in a complex way.
+ */
+public interface EventListener {
+  /**
+   * A callback function to RocksDB which will be called before a
+   * RocksDB starts to flush memtables.
+   * <p>
+   * Note that the this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns. Otherwise, RocksDB may be blocked.
+   *
+   * @param db the database
+   * @param flushJobInfo the flush job info, contains data copied from
+   *     respective native structure.
+   */
+  void onFlushBegin(final RocksDB db, final FlushJobInfo flushJobInfo);
+
+  /**
+   * callback function to RocksDB which will be called whenever a
+   * registered RocksDB flushes a file.
+   * <p>
+   * Note that the this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns. Otherwise, RocksDB may be blocked.
+   *
+   * @param db the database
+   * @param flushJobInfo the flush job info, contains data copied from
+   *     respective native structure.
+   */
+  void onFlushCompleted(final RocksDB db, final FlushJobInfo flushJobInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever
+   * a SST file is deleted. Different from
+   * {@link #onCompactionCompleted(RocksDB, CompactionJobInfo)} and
+   * {@link #onFlushCompleted(RocksDB, FlushJobInfo)},
+   * this callback is designed for external logging
+   * service and thus only provide string parameters instead
+   * of a pointer to DB.  Applications that build logic basic based
+   * on file creations and deletions is suggested to implement
+   * {@link #onFlushCompleted(RocksDB, FlushJobInfo)} and
+   * {@link #onCompactionCompleted(RocksDB, CompactionJobInfo)}.
+   * <p>
+   * Note that if applications would like to use the passed reference
+   * outside this function call, they should make copies from the
+   * returned value.
+   *
+   * @param tableFileDeletionInfo the table file deletion info,
+   *     contains data copied from respective native structure.
+   */
+  void onTableFileDeleted(final TableFileDeletionInfo tableFileDeletionInfo);
+
+  /**
+   * A callback function to RocksDB which will be called before a
+   * RocksDB starts to compact. The default implementation is
+   * no-op.
+   * <p>
+   * Note that the this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns. Otherwise, RocksDB may be blocked.
+   *
+   * @param db a pointer to the rocksdb instance which just compacted
+   *     a file.
+   * @param compactionJobInfo a reference to a native CompactionJobInfo struct,
+   *     which is released after this function is returned, and must be copied
+   *     if it is needed outside of this function.
+   */
+  void onCompactionBegin(final RocksDB db, final CompactionJobInfo compactionJobInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever
+   * a registered RocksDB compacts a file. The default implementation
+   * is a no-op.
+   * <p>
+   * Note that this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns. Otherwise, RocksDB may be blocked.
+   *
+   * @param db a pointer to the rocksdb instance which just compacted
+   *     a file.
+   * @param compactionJobInfo a reference to a native CompactionJobInfo struct,
+   *     which is released after this function is returned, and must be copied
+   *     if it is needed outside of this function.
+   */
+  void onCompactionCompleted(final RocksDB db, final CompactionJobInfo compactionJobInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever
+   * a SST file is created.  Different from OnCompactionCompleted and
+   * OnFlushCompleted, this callback is designed for external logging
+   * service and thus only provide string parameters instead
+   * of a pointer to DB.  Applications that build logic basic based
+   * on file creations and deletions is suggested to implement
+   * OnFlushCompleted and OnCompactionCompleted.
+   * <p>
+   * Historically it will only be called if the file is successfully created.
+   * Now it will also be called on failure case. User can check info.status
+   * to see if it succeeded or not.
+   * <p>
+   * Note that if applications would like to use the passed reference
+   * outside this function call, they should make copies from these
+   * returned value.
+   *
+   * @param tableFileCreationInfo the table file creation info,
+   *     contains data copied from respective native structure.
+   */
+  void onTableFileCreated(final TableFileCreationInfo tableFileCreationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called before
+   * a SST file is being created. It will follow by OnTableFileCreated after
+   * the creation finishes.
+   * <p>
+   * Note that if applications would like to use the passed reference
+   * outside this function call, they should make copies from these
+   * returned value.
+   *
+   * @param tableFileCreationBriefInfo the table file creation brief info,
+   *     contains data copied from respective native structure.
+   */
+  void onTableFileCreationStarted(final TableFileCreationBriefInfo tableFileCreationBriefInfo);
+
+  /**
+   * A callback function for RocksDB which will be called before
+   * a memtable is made immutable.
+   * <p>
+   * Note that the this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns.  Otherwise, RocksDB may be blocked.
+   * <p>
+   * Note that if applications would like to use the passed reference
+   * outside this function call, they should make copies from these
+   * returned value.
+   *
+   * @param memTableInfo the mem table info, contains data
+   *     copied from respective native structure.
+   */
+  void onMemTableSealed(final MemTableInfo memTableInfo);
+
+  /**
+   * A callback function for RocksDB which will be called before
+   * a column family handle is deleted.
+   * <p>
+   * Note that the this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns.  Otherwise, RocksDB may be blocked.
+   *
+   * @param columnFamilyHandle is a pointer to the column family handle to be
+   *     deleted which will become a dangling pointer after the deletion.
+   */
+  void onColumnFamilyHandleDeletionStarted(final ColumnFamilyHandle columnFamilyHandle);
+
+  /**
+   * A callback function for RocksDB which will be called after an external
+   * file is ingested using IngestExternalFile.
+   * <p>
+   * Note that the this function will run on the same thread as
+   * IngestExternalFile(), if this function is blocked, IngestExternalFile()
+   * will be blocked from finishing.
+   *
+   * @param db the database
+   * @param externalFileIngestionInfo the external file ingestion info,
+   *     contains data copied from respective native structure.
+   */
+  void onExternalFileIngested(
+      final RocksDB db, final ExternalFileIngestionInfo externalFileIngestionInfo);
+
+  /**
+   * A callback function for RocksDB which will be called before setting the
+   * background error status to a non-OK value. The new background error status
+   * is provided in `bg_error` and can be modified by the callback. E.g., a
+   * callback can suppress errors by resetting it to Status::OK(), thus
+   * preventing the database from entering read-only mode. We do not provide any
+   * guarantee when failed flushes/compactions will be rescheduled if the user
+   * suppresses an error.
+   * <p>
+   * Note that this function can run on the same threads as flush, compaction,
+   * and user writes. So, it is extremely important not to perform heavy
+   * computations or blocking calls in this function.
+   *
+   * @param backgroundErrorReason background error reason code
+   * @param backgroundError background error codes
+   */
+  void onBackgroundError(
+      final BackgroundErrorReason backgroundErrorReason, final Status backgroundError);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a change
+   * of superversion triggers a change of the stall conditions.
+   * <p>
+   * Note that the this function must be implemented in a way such that
+   * it should not run for an extended period of time before the function
+   * returns. Otherwise, RocksDB may be blocked.
+   *
+   * @param writeStallInfo write stall info,
+   *     contains data copied from respective native structure.
+   */
+  void onStallConditionsChanged(final WriteStallInfo writeStallInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file read
+   * operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileReadFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file write
+   * operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileWriteFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file flush
+   * operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileFlushFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file sync
+   * operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileSyncFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file
+   * rangeSync operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileRangeSyncFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file
+   * truncate operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileTruncateFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * A callback function for RocksDB which will be called whenever a file close
+   * operation finishes.
+   *
+   * @param fileOperationInfo file operation info,
+   *     contains data copied from respective native structure.
+   */
+  void onFileCloseFinish(final FileOperationInfo fileOperationInfo);
+
+  /**
+   * If true, the {@link #onFileReadFinish(FileOperationInfo)}
+   * and {@link #onFileWriteFinish(FileOperationInfo)} will be called. If
+   * false, then they won't be called.
+   * <p>
+   * Default: false
+   *
+   * @return whether to callback when file read/write is finished
+   */
+  boolean shouldBeNotifiedOnFileIO();
+
+  /**
+   * A callback function for RocksDB which will be called just before
+   * starting the automatic recovery process for recoverable background
+   * errors, such as NoSpace(). The callback can suppress the automatic
+   * recovery by setting returning false. The database will then
+   * have to be transitioned out of read-only mode by calling
+   * RocksDB#resume().
+   *
+   * @param backgroundErrorReason background error reason code
+   * @param backgroundError background error codes
+   * @return return {@code false} if the automatic recovery should be suppressed
+   */
+  boolean onErrorRecoveryBegin(
+      final BackgroundErrorReason backgroundErrorReason, final Status backgroundError);
+
+  /**
+   * A callback function for RocksDB which will be called once the database
+   * is recovered from read-only mode after an error. When this is called, it
+   * means normal writes to the database can be issued and the user can
+   * initiate any further recovery actions needed
+   *
+   * @param oldBackgroundError old background error codes
+   */
+  void onErrorRecoveryCompleted(final Status oldBackgroundError);
+}