[Java] Add Java bindings for 30 options for rocksdb::DBOptions.

Summary:
1. Add Java bindings for 30 options for rocksdb::DBOptions.
2. Add org.rocksdb.test.OptionsTest
3. Codes are semi-auto generated, JavaDocs are manually polished.

Test Plan:
make rocksdbjava
make jtest

Reviewers: haobo, ankgup87, sdong, dhruba

Reviewed By: dhruba

CC: leveldb

Differential Revision: https://reviews.facebook.net/D18015

java/Makefile

@@ -24,6 +24,7 @@ test: java
 	javac org/rocksdb/test/*.java
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.WriteBatchTest
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.BackupableDBTest
+	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.OptionsTest
 
 db_bench: java
 	javac org/rocksdb/benchmark/*.java

java/org/rocksdb/Options.java

@@ -173,50 +173,931 @@ public class Options {
     return disableSeekCompaction(nativeHandle_);
   }
 
-  /*
-   * Maximum number of concurrent background jobs, submitted to
-   * the default LOW priority thread pool.
-   * Default: 1
+  /**
+   * Set the amount of cache in bytes that will be used by RocksDB.
+   * If cacheSize is non-positive, then cache will not be used.
    *
-   * @param maxBackgroundCompactions the maximum number of concurrent
-   *     background jobs.
-   * @return the instance of the current Options.
+   * DEFAULT: 8M
+   */
+  public Options setCacheSize(long cacheSize) {
+    cacheSize_ = cacheSize;
+    return this;
+  }
+
+  /**
+   * @return the amount of cache in bytes that will be used by RocksDB.
+   */
+  public long cacheSize() {
+    return cacheSize_;
+  }
+
+  /**
+   * If true, an error will be thrown during RocksDB.open() if the
+   * database already exists.
+   *
+   * @return if true, an error is raised when the specified database
+   *    already exists before open.
+   */
+  public boolean errorIfExists() {
+    assert(isInitialized());
+    return errorIfExists(nativeHandle_);
+  }
+  private native boolean errorIfExists(long handle);
+
+  /**
+   * If true, an error will be thrown during RocksDB.open() if the
+   * database already exists.
+   * Default: false
+   *
+   * @param errorIfExists if true, an exception will be thrown
+   *     during RocksDB.open() if the database already exists.
+   * @return the reference to the current option.
    * @see RocksDB.open()
    */
-  public Options setMaxBackgroundCompactions(int maxBackgroundCompactions) {
+  public Options setErrorIfExists(boolean errorIfExists) {
     assert(isInitialized());
-    setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions);
+    setErrorIfExists(nativeHandle_, errorIfExists);
     return this;
   }
+  private native void setErrorIfExists(long handle, boolean errorIfExists);
 
-  /*
-   * Returns maximum number of background concurrent jobs.
+  /**
+   * If true, the implementation will do aggressive checking of the
+   * data it is processing and will stop early if it detects any
+   * errors.  This may have unforeseen ramifications: for example, a
+   * corruption of one DB entry may cause a large number of entries to
+   * become unreadable or for the entire DB to become unopenable.
+   * If any of the  writes to the database fails (Put, Delete, Merge, Write),
+   * the database will switch to read-only mode and fail all other
+   * Write operations.
+   *
+   * @return a boolean indicating whether paranoid-check is on.
+   */
+  public boolean paranoidChecks() {
+    assert(isInitialized());
+    return paranoidChecks(nativeHandle_);
+  }
+  private native boolean paranoidChecks(long handle);
+
+  /**
+   * If true, the implementation will do aggressive checking of the
+   * data it is processing and will stop early if it detects any
+   * errors.  This may have unforeseen ramifications: for example, a
+   * corruption of one DB entry may cause a large number of entries to
+   * become unreadable or for the entire DB to become unopenable.
+   * If any of the  writes to the database fails (Put, Delete, Merge, Write),
+   * the database will switch to read-only mode and fail all other
+   * Write operations.
+   * Default: true
+   *
+   * @param paranoidChecks a flag to indicate whether paranoid-check
+   *     is on.
+   * @return the reference to the current option.
+   */
+  public Options setParanoidChecks(boolean paranoidChecks) {
+    assert(isInitialized());
+    setParanoidChecks(nativeHandle_, paranoidChecks);
+    return this;
+  }
+  private native void setParanoidChecks(
+      long handle, boolean paranoidChecks);
+
+  /**
+   * Number of open files that can be used by the DB.  You may need to
+   * increase this if your database has a large working set. Value -1 means
+   * files opened are always kept open. You can estimate number of files based
+   * on target_file_size_base and target_file_size_multiplier for level-based
+   * compaction. For universal-style compaction, you can usually set it to -1.
+   *
+   * @return the maximum number of open files.
+   */
+  public int maxOpenFiles() {
+    assert(isInitialized());
+    return maxOpenFiles(nativeHandle_);
+  }
+  private native int maxOpenFiles(long handle);
+
+  /**
+   * Number of open files that can be used by the DB.  You may need to
+   * increase this if your database has a large working set. Value -1 means
+   * files opened are always kept open. You can estimate number of files based
+   * on target_file_size_base and target_file_size_multiplier for level-based
+   * compaction. For universal-style compaction, you can usually set it to -1.
+   * Default: 5000
    *
-   * @return maximum number of background concurrent jobs.
-   * @see setMaxBackgroundCompactions
+   * @param maxOpenFiles the maximum number of open files.
+   * @return the reference to the current option.
+   */
+  public Options setMaxOpenFiles(int maxOpenFiles) {
+    assert(isInitialized());
+    setMaxOpenFiles(nativeHandle_, maxOpenFiles);
+    return this;
+  }
+  private native void setMaxOpenFiles(long handle, int maxOpenFiles);
+
+  /**
+   * If true, then the contents of data files are not synced
+   * to stable storage. Their contents remain in the OS buffers till the
+   * OS decides to flush them. This option is good for bulk-loading
+   * of data. Once the bulk-loading is complete, please issue a
+   * sync to the OS to flush all dirty buffesrs to stable storage.
+   *
+   * @return if true, then data-sync is disabled.
+   */
+  public boolean disableDataSync() {
+    assert(isInitialized());
+    return disableDataSync(nativeHandle_);
+  }
+  private native boolean disableDataSync(long handle);
+
+  /**
+   * If true, then the contents of data files are not synced
+   * to stable storage. Their contents remain in the OS buffers till the
+   * OS decides to flush them. This option is good for bulk-loading
+   * of data. Once the bulk-loading is complete, please issue a
+   * sync to the OS to flush all dirty buffesrs to stable storage.
+   * Default: false
+   *
+   * @param disableDataSync a boolean flag to specify whether to
+   *     disable data sync.
+   * @return the reference to the current option.
+   */
+  public Options setDisableDataSync(boolean disableDataSync) {
+    assert(isInitialized());
+    setDisableDataSync(nativeHandle_, disableDataSync);
+    return this;
+  }
+  private native void setDisableDataSync(long handle, boolean disableDataSync);
+
+  /**
+   * If true, then every store to stable storage will issue a fsync.
+   * If false, then every store to stable storage will issue a fdatasync.
+   * This parameter should be set to true while storing data to
+   * filesystem like ext3 that can lose files after a reboot.
+   *
+   * @return true if fsync is used.
+   */
+  public boolean useFsync() {
+    assert(isInitialized());
+    return useFsync(nativeHandle_);
+  }
+  private native boolean useFsync(long handle);
+
+  /**
+   * If true, then every store to stable storage will issue a fsync.
+   * If false, then every store to stable storage will issue a fdatasync.
+   * This parameter should be set to true while storing data to
+   * filesystem like ext3 that can lose files after a reboot.
+   * Default: false
+   *
+   * @param useFsync a boolean flag to specify whether to use fsync
+   * @return the reference to the current option.
+   */
+  public Options setUseFsync(boolean useFsync) {
+    assert(isInitialized());
+    setUseFsync(nativeHandle_, useFsync);
+    return this;
+  }
+  private native void setUseFsync(long handle, boolean useFsync);
+
+  /**
+   * The time interval in seconds between each two consecutive stats logs.
+   * This number controls how often a new scribe log about
+   * db deploy stats is written out.
+   * -1 indicates no logging at all.
+   *
+   * @return the time interval in seconds between each two consecutive
+   *     stats logs.
+   */
+  public int dbStatsLogInterval() {
+    assert(isInitialized());
+    return dbStatsLogInterval(nativeHandle_);
+  }
+  private native int dbStatsLogInterval(long handle);
+
+  /**
+   * The time interval in seconds between each two consecutive stats logs.
+   * This number controls how often a new scribe log about
+   * db deploy stats is written out.
+   * -1 indicates no logging at all.
+   * Default value is 1800 (half an hour).
+   *
+   * @param dbStatsLogInterval the time interval in seconds between each
+   *     two consecutive stats logs.
+   * @return the reference to the current option.
+   */
+  public Options setDbStatsLogInterval(int dbStatsLogInterval) {
+    assert(isInitialized());
+    setDbStatsLogInterval(nativeHandle_, dbStatsLogInterval);
+    return this;
+  }
+  private native void setDbStatsLogInterval(
+      long handle, int dbStatsLogInterval);
+
+  /**
+   * Returns the directory of info log.
+   *
+   * If it is empty, the log files will be in the same dir as data.
+   * If it is non empty, the log files will be in the specified dir,
+   * and the db data dir's absolute path will be used as the log file
+   * name's prefix.
+   *
+   * @return the path to the info log directory
+   */
+  public String dbLogDir() {
+    assert(isInitialized());
+    return dbLogDir(nativeHandle_);
+  }
+  private native String dbLogDir(long handle);
+
+  /**
+   * This specifies the info LOG dir.
+   * If it is empty, the log files will be in the same dir as data.
+   * If it is non empty, the log files will be in the specified dir,
+   * and the db data dir's absolute path will be used as the log file
+   * name's prefix.
+   *
+   * @param dbLogDir the path to the info log directory
+   * @return the reference to the current option.
+   */
+  public Options setDbLogDir(String dbLogDir) {
+    assert(isInitialized());
+    setDbLogDir(nativeHandle_, dbLogDir);
+    return this;
+  }
+  private native void setDbLogDir(long handle, String dbLogDir);
+
+  /**
+   * Returns the path to the write-ahead-logs (WAL) directory.
+   *
+   * If it is empty, the log files will be in the same dir as data,
+   *   dbname is used as the data dir by default
+   * If it is non empty, the log files will be in kept the specified dir.
+   * When destroying the db,
+   *   all log files in wal_dir and the dir itself is deleted
+   *
+   * @return the path to the write-ahead-logs (WAL) directory.
+   */
+  public String walDir() {
+    assert(isInitialized());
+    return walDir(nativeHandle_);
+  }
+  private native String walDir(long handle);
+
+  /**
+   * This specifies the absolute dir path for write-ahead logs (WAL).
+   * If it is empty, the log files will be in the same dir as data,
+   *   dbname is used as the data dir by default
+   * If it is non empty, the log files will be in kept the specified dir.
+   * When destroying the db,
+   *   all log files in wal_dir and the dir itself is deleted
+   *
+   * @param walDir the path to the write-ahead-log directory.
+   * @return the reference to the current option.
+   */
+  public Options setWalDir(String walDir) {
+    assert(isInitialized());
+    setWalDir(nativeHandle_, walDir);
+    return this;
+  }
+  private native void setWalDir(long handle, String walDir);
+
+  /**
+   * The periodicity when obsolete files get deleted. The default
+   * value is 6 hours. The files that get out of scope by compaction
+   * process will still get automatically delete on every compaction,
+   * regardless of this setting
+   *
+   * @return the time interval in micros when obsolete files will be deleted.
+   */
+  public long deleteObsoleteFilesPeriodMicros() {
+    assert(isInitialized());
+    return deleteObsoleteFilesPeriodMicros(nativeHandle_);
+  }
+  private native long deleteObsoleteFilesPeriodMicros(long handle);
+
+  /**
+   * The periodicity when obsolete files get deleted. The default
+   * value is 6 hours. The files that get out of scope by compaction
+   * process will still get automatically delete on every compaction,
+   * regardless of this setting
+   *
+   * @param micros the time interval in micros
+   * @return the reference to the current option.
+   */
+  public Options setDeleteObsoleteFilesPeriodMicros(long micros) {
+    assert(isInitialized());
+    setDeleteObsoleteFilesPeriodMicros(nativeHandle_, micros);
+    return this;
+  }
+  private native void setDeleteObsoleteFilesPeriodMicros(
+      long handle, long micros);
+
+  /**
+   * Returns the maximum number of concurrent background compaction jobs,
+   * submitted to the default LOW priority thread pool.
+   * When increasing this number, we may also want to consider increasing
+   * number of threads in LOW priority thread pool.
+   * Default: 1
+   *
+   * @return the maximum number of concurrent background compaction jobs.
+   * @see Env.setBackgroundThreads()
    */
   public int maxBackgroundCompactions() {
     assert(isInitialized());
     return maxBackgroundCompactions(nativeHandle_);
   }
+  private native int maxBackgroundCompactions(long handle);
 
   /**
-   * Set the amount of cache in bytes that will be used by RocksDB.
-   * If cacheSize is non-positive, then cache will not be used.
+   * Specifies the maximum number of concurrent background compaction jobs,
+   * submitted to the default LOW priority thread pool.
+   * If you're increasing this, also consider increasing number of threads in
+   * LOW priority thread pool. For more information, see
+   * Default: 1
    *
-   * DEFAULT: 8M
+   * @param maxBackgroundCompactions the maximum number of background
+   *     compaction jobs.
+   * @return the reference to the current option.
+   *
+   * @see Env.setBackgroundThreads()
+   * @see maxBackgroundFlushes()
    */
-  public Options setCacheSize(long cacheSize) {
-    cacheSize_ = cacheSize;
+  public Options setMaxBackgroundCompactions(int maxBackgroundCompactions) {
+    assert(isInitialized());
+    setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions);
     return this;
   }
+  private native void setMaxBackgroundCompactions(
+      long handle, int maxBackgroundCompactions);
 
   /**
-   * @return the amount of cache in bytes that will be used by RocksDB.
+   * Returns the maximum number of concurrent background flush jobs.
+   * If you're increasing this, also consider increasing number of threads in
+   * HIGH priority thread pool. For more information, see
+   * Default: 1
+   *
+   * @return the maximum number of concurrent background flush jobs.
+   * @see Env.setBackgroundThreads()
    */
-  public long cacheSize() {
-    return cacheSize_;
+  public int maxBackgroundFlushes() {
+    assert(isInitialized());
+    return maxBackgroundFlushes(nativeHandle_);
+  }
+  private native int maxBackgroundFlushes(long handle);
+
+  /**
+   * Specifies the maximum number of concurrent background flush jobs.
+   * If you're increasing this, also consider increasing number of threads in
+   * HIGH priority thread pool. For more information, see
+   * Default: 1
+   *
+   * @param maxBackgroundFlushes
+   * @return the reference to the current option.
+   *
+   * @see Env.setBackgroundThreads()
+   * @see maxBackgroundCompactions()
+   */
+  public Options setMaxBackgroundFlushes(int maxBackgroundFlushes) {
+    assert(isInitialized());
+    setMaxBackgroundFlushes(nativeHandle_, maxBackgroundFlushes);
+    return this;
+  }
+  private native void setMaxBackgroundFlushes(
+      long handle, int maxBackgroundFlushes);
+
+  /**
+   * Returns the maximum size of a info log file. If the current log file
+   * is larger than this size, a new info log file will be created.
+   * If 0, all logs will be written to one log file.
+   *
+   * @return the maximum size of the info log file.
+   */
+  public long maxLogFileSize() {
+    assert(isInitialized());
+    return maxLogFileSize(nativeHandle_);
+  }
+  private native long maxLogFileSize(long handle);
+
+  /**
+   * Specifies the maximum size of a info log file. If the current log file
+   * is larger than `max_log_file_size`, a new info log file will
+   * be created.
+   * If 0, all logs will be written to one log file.
+   *
+   * @param maxLogFileSize the maximum size of a info log file.
+   * @return the reference to the current option.
+   */
+  public Options setMaxLogFileSize(long maxLogFileSize) {
+    assert(isInitialized());
+    setMaxLogFileSize(nativeHandle_, maxLogFileSize);
+    return this;
+  }
+  private native void setMaxLogFileSize(long handle, long maxLogFileSize);
+
+  /**
+   * Returns the time interval for the info log file to roll (in seconds).
+   * If specified with non-zero value, log file will be rolled
+   * if it has been active longer than `log_file_time_to_roll`.
+   * Default: 0 (disabled)
+   *
+   * @return the time interval in seconds.
+   */
+  public long logFileTimeToRoll() {
+    assert(isInitialized());
+    return logFileTimeToRoll(nativeHandle_);
+  }
+  private native long logFileTimeToRoll(long handle);
+
+  /**
+   * Specifies the time interval for the info log file to roll (in seconds).
+   * If specified with non-zero value, log file will be rolled
+   * if it has been active longer than `log_file_time_to_roll`.
+   * Default: 0 (disabled)
+   *
+   * @param logFileTimeToRoll the time interval in seconds.
+   * @return the reference to the current option.
+   */
+  public Options setLogFileTimeToRoll(long logFileTimeToRoll) {
+    assert(isInitialized());
+    setLogFileTimeToRoll(nativeHandle_, logFileTimeToRoll);
+    return this;
+  }
+  private native void setLogFileTimeToRoll(
+      long handle, long logFileTimeToRoll);
+
+  /**
+   * Returns the maximum number of info log files to be kept.
+   * Default: 1000
+   *
+   * @return the maximum number of info log files to be kept.
+   */
+  public long keepLogFileNum() {
+    assert(isInitialized());
+    return keepLogFileNum(nativeHandle_);
+  }
+  private native long keepLogFileNum(long handle);
+
+  /**
+   * Specifies the maximum number of info log files to be kept.
+   * Default: 1000
+   *
+   * @param keepLogFileNum the maximum number of info log files to be kept.
+   * @return the reference to the current option.
+   */
+  public Options setKeepLogFileNum(long keepLogFileNum) {
+    assert(isInitialized());
+    setKeepLogFileNum(nativeHandle_, keepLogFileNum);
+    return this;
+  }
+  private native void setKeepLogFileNum(long handle, long keepLogFileNum);
+
+  /**
+   * Manifest file is rolled over on reaching this limit.
+   * The older manifest file be deleted.
+   * The default value is MAX_INT so that roll-over does not take place.
+   *
+   * @return the size limit of a manifest file.
+   */
+  public long maxManifestFileSize() {
+    assert(isInitialized());
+    return maxManifestFileSize(nativeHandle_);
+  }
+  private native long maxManifestFileSize(long handle);
+
+  /**
+   * Manifest file is rolled over on reaching this limit.
+   * The older manifest file be deleted.
+   * The default value is MAX_INT so that roll-over does not take place.
+   *
+   * @param maxManifestFileSize the size limit of a manifest file.
+   * @return the reference to the current option.
+   */
+  public Options setMaxManifestFileSize(long maxManifestFileSize) {
+    assert(isInitialized());
+    setMaxManifestFileSize(nativeHandle_, maxManifestFileSize);
+    return this;
+  }
+  private native void setMaxManifestFileSize(
+      long handle, long maxManifestFileSize);
+
+  /**
+   * Number of shards used for table cache.
+   *
+   * @return the number of shards used for table cache.
+   */
+  public int tableCacheNumshardbits() {
+    assert(isInitialized());
+    return tableCacheNumshardbits(nativeHandle_);
+  }
+  private native int tableCacheNumshardbits(long handle);
+
+  /**
+   * Number of shards used for table cache.
+   *
+   * @param tableCacheNumshardbits the number of chards
+   * @return the reference to the current option.
+   */
+  public Options setTableCacheNumshardbits(int tableCacheNumshardbits) {
+    assert(isInitialized());
+    setTableCacheNumshardbits(nativeHandle_, tableCacheNumshardbits);
+    return this;
+  }
+  private native void setTableCacheNumshardbits(
+      long handle, int tableCacheNumshardbits);
+
+  /**
+   * During data eviction of table's LRU cache, it would be inefficient
+   * to strictly follow LRU because this piece of memory will not really
+   * be released unless its refcount falls to zero. Instead, make two
+   * passes: the first pass will release items with refcount = 1,
+   * and if not enough space releases after scanning the number of
+   * elements specified by this parameter, we will remove items in LRU
+   * order.
+   *
+   * @return scan count limit
+   */
+  public int tableCacheRemoveScanCountLimit() {
+    assert(isInitialized());
+    return tableCacheRemoveScanCountLimit(nativeHandle_);
+  }
+  private native int tableCacheRemoveScanCountLimit(long handle);
+
+  /**
+   * During data eviction of table's LRU cache, it would be inefficient
+   * to strictly follow LRU because this piece of memory will not really
+   * be released unless its refcount falls to zero. Instead, make two
+   * passes: the first pass will release items with refcount = 1,
+   * and if not enough space releases after scanning the number of
+   * elements specified by this parameter, we will remove items in LRU
+   * order.
+   *
+   * @param limit scan count limit
+   * @return the reference to the current option.
+   */
+  public Options setTableCacheRemoveScanCountLimit(int limit) {
+    assert(isInitialized());
+    setTableCacheRemoveScanCountLimit(nativeHandle_, limit);
+    return this;
+  }
+  private native void setTableCacheRemoveScanCountLimit(
+      long handle, int limit);
+
+  /**
+   * The following two fields affect how archived logs will be deleted.
+   * 1. If both set to 0, logs will be deleted asap and will not get into
+   *    the archive.
+   * 2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0,
+   *    WAL files will be checked every 10 min and if total size is greater
+   *    then WAL_size_limit_MB, they will be deleted starting with the
+   *    earliest until size_limit is met. All empty files will be deleted.
+   * 3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then
+   *    WAL files will be checked every WAL_ttl_secondsi / 2 and those that
+   *    are older than WAL_ttl_seconds will be deleted.
+   * 4. If both are not 0, WAL files will be checked every 10 min and both
+   *    checks will be performed with ttl being first.
+   *
+   * @return the wal-ttl seconds
+   */
+  public long walTtlSeconds() {
+    assert(isInitialized());
+    return walTtlSeconds(nativeHandle_);
+  }
+  private native long walTtlSeconds(long handle);
+
+  /**
+   * The following two fields affect how archived logs will be deleted.
+   * 1. If both set to 0, logs will be deleted asap and will not get into
+   *    the archive.
+   * 2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0,
+   *    WAL files will be checked every 10 min and if total size is greater
+   *    then WAL_size_limit_MB, they will be deleted starting with the
+   *    earliest until size_limit is met. All empty files will be deleted.
+   * 3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then
+   *    WAL files will be checked every WAL_ttl_secondsi / 2 and those that
+   *    are older than WAL_ttl_seconds will be deleted.
+   * 4. If both are not 0, WAL files will be checked every 10 min and both
+   *    checks will be performed with ttl being first.
+   *
+   * @param walTtlSeconds the ttl seconds
+   * @return the reference to the current option.
+   */
+  public Options setWALTtlSeconds(long walTtlSeconds) {
+    assert(isInitialized());
+    setWALTtlSeconds(nativeHandle_, walTtlSeconds);
+    return this;
   }
+  private native void setWALTtlSeconds(long handle, long walTtlSeconds);
+
+  /**
+   * Number of bytes to preallocate (via fallocate) the manifest
+   * files.  Default is 4mb, which is reasonable to reduce random IO
+   * as well as prevent overallocation for mounts that preallocate
+   * large amounts of data (such as xfs's allocsize option).
+   *
+   * @return size in bytes.
+   */
+  public long manifestPreallocationSize() {
+    assert(isInitialized());
+    return manifestPreallocationSize(nativeHandle_);
+  }
+  private native long manifestPreallocationSize(long handle);
+
+  /**
+   * Number of bytes to preallocate (via fallocate) the manifest
+   * files.  Default is 4mb, which is reasonable to reduce random IO
+   * as well as prevent overallocation for mounts that preallocate
+   * large amounts of data (such as xfs's allocsize option).
+   *
+   * @param size the size in byte
+   * @return the reference to the current option.
+   */
+  public Options setManifestPreallocationSize(long size) {
+    assert(isInitialized());
+    setManifestPreallocationSize(nativeHandle_, size);
+    return this;
+  }
+  private native void setManifestPreallocationSize(
+      long handle, long size);
+
+  /**
+   * Data being read from file storage may be buffered in the OS
+   * Default: true
+   *
+   * @return if true, then OS buffering is allowed.
+   */
+  public boolean allowOsBuffer() {
+    assert(isInitialized());
+    return allowOsBuffer(nativeHandle_);
+  }
+  private native boolean allowOsBuffer(long handle);
+
+  /**
+   * Data being read from file storage may be buffered in the OS
+   * Default: true
+   *
+   * @param allowOsBufferif true, then OS buffering is allowed.
+   * @return the reference to the current option.
+   */
+  public Options setAllowOsBuffer(boolean allowOsBuffer) {
+    assert(isInitialized());
+    setAllowOsBuffer(nativeHandle_, allowOsBuffer);
+    return this;
+  }
+  private native void setAllowOsBuffer(
+      long handle, boolean allowOsBuffer);
+
+  /**
+   * Allow the OS to mmap file for reading sst tables.
+   * Default: false
+   *
+   * @return true if mmap reads are allowed.
+   */
+  public boolean allowMmapReads() {
+    assert(isInitialized());
+    return allowMmapReads(nativeHandle_);
+  }
+  private native boolean allowMmapReads(long handle);
+
+  /**
+   * Allow the OS to mmap file for reading sst tables.
+   * Default: false
+   *
+   * @param allowMmapReads true if mmap reads are allowed.
+   * @return the reference to the current option.
+   */
+  public Options setAllowMmapReads(boolean allowMmapReads) {
+    assert(isInitialized());
+    setAllowMmapReads(nativeHandle_, allowMmapReads);
+    return this;
+  }
+  private native void setAllowMmapReads(
+      long handle, boolean allowMmapReads);
+
+  /**
+   * Allow the OS to mmap file for writing. Default: false
+   *
+   * @return true if mmap writes are allowed.
+   */
+  public boolean allowMmapWrites() {
+    assert(isInitialized());
+    return allowMmapWrites(nativeHandle_);
+  }
+  private native boolean allowMmapWrites(long handle);
+
+  /**
+   * Allow the OS to mmap file for writing. Default: false
+   *
+   * @param allowMmapWrites true if mmap writes are allowd.
+   * @return the reference to the current option.
+   */
+  public Options setAllowMmapWrites(boolean allowMmapWrites) {
+    assert(isInitialized());
+    setAllowMmapWrites(nativeHandle_, allowMmapWrites);
+    return this;
+  }
+  private native void setAllowMmapWrites(
+      long handle, boolean allowMmapWrites);
+
+  /**
+   * Disable child process inherit open files. Default: true
+   *
+   * @return true if child process inheriting open files is disabled.
+   */
+  public boolean isFdCloseOnExec() {
+    assert(isInitialized());
+    return isFdCloseOnExec(nativeHandle_);
+  }
+  private native boolean isFdCloseOnExec(long handle);
+
+  /**
+   * Disable child process inherit open files. Default: true
+   *
+   * @param isFdCloseOnExec true if child process inheriting open
+   *     files is disabled.
+   * @return the reference to the current option.
+   */
+  public Options setIsFdCloseOnExec(boolean isFdCloseOnExec) {
+    assert(isInitialized());
+    setIsFdCloseOnExec(nativeHandle_, isFdCloseOnExec);
+    return this;
+  }
+  private native void setIsFdCloseOnExec(
+      long handle, boolean isFdCloseOnExec);
+
+  /**
+   * Skip log corruption error on recovery (If client is ok with
+   * losing most recent changes)
+   * Default: false
+   *
+   * @return true if log corruption errors are skipped during recovery.
+   */
+  public boolean skipLogErrorOnRecovery() {
+    assert(isInitialized());
+    return skipLogErrorOnRecovery(nativeHandle_);
+  }
+  private native boolean skipLogErrorOnRecovery(long handle);
+
+  /**
+   * Skip log corruption error on recovery (If client is ok with
+   * losing most recent changes)
+   * Default: false
+   *
+   * @param skip true if log corruption errors are skipped during recovery.
+   * @return the reference to the current option.
+   */
+  public Options setSkipLogErrorOnRecovery(boolean skip) {
+    assert(isInitialized());
+    setSkipLogErrorOnRecovery(nativeHandle_, skip);
+    return this;
+  }
+  private native void setSkipLogErrorOnRecovery(
+      long handle, boolean skip);
+
+  /**
+   * If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec
+   * Default: 3600 (1 hour)
+   *
+   * @return time interval in seconds.
+   */
+  public int statsDumpPeriodSec() {
+    assert(isInitialized());
+    return statsDumpPeriodSec(nativeHandle_);
+  }
+  private native int statsDumpPeriodSec(long handle);
+
+  /**
+   * if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec
+   * Default: 3600 (1 hour)
+   *
+   * @param statsDumpPeriodSec time interval in seconds.
+   * @return the reference to the current option.
+   */
+  public Options setStatsDumpPeriodSec(int statsDumpPeriodSec) {
+    assert(isInitialized());
+    setStatsDumpPeriodSec(nativeHandle_, statsDumpPeriodSec);
+    return this;
+  }
+  private native void setStatsDumpPeriodSec(
+      long handle, int statsDumpPeriodSec);
+
+  /**
+   * If set true, will hint the underlying file system that the file
+   * access pattern is random, when a sst file is opened.
+   * Default: true
+   *
+   * @return true if hinting random access is on.
+   */
+  public boolean adviseRandomOnOpen() {
+    return adviseRandomOnOpen(nativeHandle_);
+  }
+  private native boolean adviseRandomOnOpen(long handle);
+
+  /**
+   * If set true, will hint the underlying file system that the file
+   * access pattern is random, when a sst file is opened.
+   * Default: true
+   *
+   * @param adviseRandomOnOpen true if hinting random access is on.
+   * @return the reference to the current option.
+   */
+  public Options setAdviseRandomOnOpen(boolean adviseRandomOnOpen) {
+    assert(isInitialized());
+    setAdviseRandomOnOpen(nativeHandle_, adviseRandomOnOpen);
+    return this;
+  }
+  private native void setAdviseRandomOnOpen(
+      long handle, boolean adviseRandomOnOpen);
+
+  /**
+   * Use adaptive mutex, which spins in the user space before resorting
+   * to kernel. This could reduce context switch when the mutex is not
+   * heavily contended. However, if the mutex is hot, we could end up
+   * wasting spin time.
+   * Default: false
+   *
+   * @return true if adaptive mutex is used.
+   */
+  public boolean useAdaptiveMutex() {
+    assert(isInitialized());
+    return useAdaptiveMutex(nativeHandle_);
+  }
+  private native boolean useAdaptiveMutex(long handle);
+
+  /**
+   * Use adaptive mutex, which spins in the user space before resorting
+   * to kernel. This could reduce context switch when the mutex is not
+   * heavily contended. However, if the mutex is hot, we could end up
+   * wasting spin time.
+   * Default: false
+   *
+   * @param useAdaptiveMutex true if adaptive mutex is used.
+   * @return the reference to the current option.
+   */
+  public Options setUseAdaptiveMutex(boolean useAdaptiveMutex) {
+    assert(isInitialized());
+    setUseAdaptiveMutex(nativeHandle_, useAdaptiveMutex);
+    return this;
+  }
+  private native void setUseAdaptiveMutex(
+      long handle, boolean useAdaptiveMutex);
+
+  /**
+   * Allows OS to incrementally sync files to disk while they are being
+   * written, asynchronously, in the background.
+   * Issue one request for every bytes_per_sync written. 0 turns it off.
+   * Default: 0
+   *
+   * @return size in bytes
+   */
+  public long bytesPerSync() {
+    return bytesPerSync(nativeHandle_);
+  }
+  private native long bytesPerSync(long handle);
+
+  /**
+   * Allows OS to incrementally sync files to disk while they are being
+   * written, asynchronously, in the background.
+   * Issue one request for every bytes_per_sync written. 0 turns it off.
+   * Default: 0
+   *
+   * @param bytesPerSync size in bytes
+   * @return the reference to the current option.
+   */
+  public Options setBytesPerSync(long bytesPerSync) {
+    assert(isInitialized());
+    setBytesPerSync(nativeHandle_, bytesPerSync);
+    return this;
+  }
+  private native void setBytesPerSync(
+      long handle, long bytesPerSync);
+
+  /**
+   * Allow RocksDB to use thread local storage to optimize performance.
+   * Default: true
+   *
+   * @return true if thread-local storage is allowed
+   */
+  public boolean allowThreadLocal() {
+    assert(isInitialized());
+    return allowThreadLocal(nativeHandle_);
+  }
+  private native boolean allowThreadLocal(long handle);
+
+  /**
+   * Allow RocksDB to use thread local storage to optimize performance.
+   * Default: true
+   *
+   * @param allowThreadLocal true if thread-local storage is allowed.
+   * @return the reference to the current option.
+   */
+  public Options setAllowThreadLocal(boolean allowThreadLocal) {
+    assert(isInitialized());
+    setAllowThreadLocal(nativeHandle_, allowThreadLocal);
+    return this;
+  }
+  private native void setAllowThreadLocal(
+      long handle, boolean allowThreadLocal);
 
   /**
    * Release the memory allocated for the current instance
@@ -250,9 +1131,6 @@ public class Options {
   private native void setDisableSeekCompaction(
       long handle, boolean disableSeekCompaction);
   private native boolean disableSeekCompaction(long handle);
-  private native void setMaxBackgroundCompactions(
-      long handle, int maxBackgroundCompactions);
-  private native int maxBackgroundCompactions(long handle);
 
   long nativeHandle_;
   long cacheSize_;

java/org/rocksdb/test/OptionsTest.java

@@ -0,0 +1,201 @@
+// Copyright (c) 2014, Facebook, Inc.  All rights reserved.
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree. An additional grant
+// of patent rights can be found in the PATENTS file in the same directory.
+
+package org.rocksdb.test;
+
+import java.util.Random;
+import org.rocksdb.Options;
+
+public class OptionsTest {
+  static {
+    System.loadLibrary("rocksdbjni");
+  }
+  public static void main(String[] args) {
+    Options opt = new Options();
+    Random rand = new Random();
+    { // CreateIfMissing test
+      boolean boolValue = rand.nextBoolean();
+      opt.setCreateIfMissing(boolValue);
+      assert(opt.createIfMissing() == boolValue);
+    }
+
+    { // ErrorIfExists test
+      boolean boolValue = rand.nextBoolean();
+      opt.setErrorIfExists(boolValue);
+      assert(opt.errorIfExists() == boolValue);
+    }
+
+    { // ParanoidChecks test
+      boolean boolValue = rand.nextBoolean();
+      opt.setParanoidChecks(boolValue);
+      assert(opt.paranoidChecks() == boolValue);
+    }
+
+    { // MaxOpenFiles test
+      int intValue = rand.nextInt();
+      opt.setMaxOpenFiles(intValue);
+      assert(opt.maxOpenFiles() == intValue);
+    }
+
+    { // DisableDataSync test
+      boolean boolValue = rand.nextBoolean();
+      opt.setDisableDataSync(boolValue);
+      assert(opt.disableDataSync() == boolValue);
+    }
+
+    { // UseFsync test
+      boolean boolValue = rand.nextBoolean();
+      opt.setUseFsync(boolValue);
+      assert(opt.useFsync() == boolValue);
+    }
+
+    { // DbStatsLogInterval test
+      int intValue = rand.nextInt();
+      opt.setDbStatsLogInterval(intValue);
+      assert(opt.dbStatsLogInterval() == intValue);
+    }
+
+    { // DbLogDir test
+      String str = "path/to/DbLogDir";
+      opt.setDbLogDir(str);
+      assert(opt.dbLogDir().equals(str));
+    }
+
+    { // WalDir test
+      String str = "path/to/WalDir";
+      opt.setWalDir(str);
+      assert(opt.walDir().equals(str));
+    }
+
+    { // DeleteObsoleteFilesPeriodMicros test
+      long longValue = rand.nextLong();
+      opt.setDeleteObsoleteFilesPeriodMicros(longValue);
+      assert(opt.deleteObsoleteFilesPeriodMicros() == longValue);
+    }
+
+    { // MaxBackgroundCompactions test
+      int intValue = rand.nextInt();
+      opt.setMaxBackgroundCompactions(intValue);
+      assert(opt.maxBackgroundCompactions() == intValue);
+    }
+
+    { // MaxBackgroundFlushes test
+      int intValue = rand.nextInt();
+      opt.setMaxBackgroundFlushes(intValue);
+      assert(opt.maxBackgroundFlushes() == intValue);
+    }
+
+    { // MaxLogFileSize test
+      long longValue = rand.nextLong();
+      opt.setMaxLogFileSize(longValue);
+      assert(opt.maxLogFileSize() == longValue);
+    }
+
+    { // LogFileTimeToRoll test
+      long longValue = rand.nextLong();
+      opt.setLogFileTimeToRoll(longValue);
+      assert(opt.logFileTimeToRoll() == longValue);
+    }
+
+    { // KeepLogFileNum test
+      long longValue = rand.nextLong();
+      opt.setKeepLogFileNum(longValue);
+      assert(opt.keepLogFileNum() == longValue);
+    }
+
+    { // MaxManifestFileSize test
+      long longValue = rand.nextLong();
+      opt.setMaxManifestFileSize(longValue);
+      assert(opt.maxManifestFileSize() == longValue);
+    }
+
+    { // TableCacheNumshardbits test
+      int intValue = rand.nextInt();
+      opt.setTableCacheNumshardbits(intValue);
+      assert(opt.tableCacheNumshardbits() == intValue);
+    }
+
+    { // TableCacheRemoveScanCountLimit test
+      int intValue = rand.nextInt();
+      opt.setTableCacheRemoveScanCountLimit(intValue);
+      assert(opt.tableCacheRemoveScanCountLimit() == intValue);
+    }
+
+    { // WALTtlSeconds test
+      long longValue = rand.nextLong();
+      opt.setWALTtlSeconds(longValue);
+      assert(opt.walTtlSeconds() == longValue);
+    }
+
+    { // ManifestPreallocationSize test
+      long longValue = rand.nextLong();
+      opt.setManifestPreallocationSize(longValue);
+      assert(opt.manifestPreallocationSize() == longValue);
+    }
+
+    { // AllowOsBuffer test
+      boolean boolValue = rand.nextBoolean();
+      opt.setAllowOsBuffer(boolValue);
+      assert(opt.allowOsBuffer() == boolValue);
+    }
+
+    { // AllowMmapReads test
+      boolean boolValue = rand.nextBoolean();
+      opt.setAllowMmapReads(boolValue);
+      assert(opt.allowMmapReads() == boolValue);
+    }
+
+    { // AllowMmapWrites test
+      boolean boolValue = rand.nextBoolean();
+      opt.setAllowMmapWrites(boolValue);
+      assert(opt.allowMmapWrites() == boolValue);
+    }
+
+    { // IsFdCloseOnExec test
+      boolean boolValue = rand.nextBoolean();
+      opt.setIsFdCloseOnExec(boolValue);
+      assert(opt.isFdCloseOnExec() == boolValue);
+    }
+
+    { // SkipLogErrorOnRecovery test
+      boolean boolValue = rand.nextBoolean();
+      opt.setSkipLogErrorOnRecovery(boolValue);
+      assert(opt.skipLogErrorOnRecovery() == boolValue);
+    }
+
+    { // StatsDumpPeriodSec test
+      int intValue = rand.nextInt();
+      opt.setStatsDumpPeriodSec(intValue);
+      assert(opt.statsDumpPeriodSec() == intValue);
+    }
+
+    { // AdviseRandomOnOpen test
+      boolean boolValue = rand.nextBoolean();
+      opt.setAdviseRandomOnOpen(boolValue);
+      assert(opt.adviseRandomOnOpen() == boolValue);
+    }
+
+    { // UseAdaptiveMutex test
+      boolean boolValue = rand.nextBoolean();
+      opt.setUseAdaptiveMutex(boolValue);
+      assert(opt.useAdaptiveMutex() == boolValue);
+    }
+
+    { // BytesPerSync test
+      long longValue = rand.nextLong();
+      opt.setBytesPerSync(longValue);
+      assert(opt.bytesPerSync() == longValue);
+    }
+
+    { // AllowThreadLocal test
+      boolean boolValue = rand.nextBoolean();
+      opt.setAllowThreadLocal(boolValue);
+      assert(opt.allowThreadLocal() == boolValue);
+    }
+
+    opt.dispose();
+    System.out.println("Passed OptionsTest");
+  }
+}

java/rocksjni/options.cc

@@ -147,14 +147,197 @@ jboolean Java_org_rocksdb_Options_disableSeekCompaction(
 
 /*
  * Class:     org_rocksdb_Options
- * Method:    setMaxBackgroundCompactions
+ * Method:    errorIfExists
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_errorIfExists(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->error_if_exists;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setErrorIfExists
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setErrorIfExists(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean error_if_exists) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->error_if_exists =
+      static_cast<bool>(error_if_exists);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    paranoidChecks
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_paranoidChecks(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->paranoid_checks;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setParanoidChecks
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setParanoidChecks(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean paranoid_checks) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->paranoid_checks =
+      static_cast<bool>(paranoid_checks);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    maxOpenFiles
+ * Signature: (J)I
+ */
+jint Java_org_rocksdb_Options_maxOpenFiles(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->max_open_files;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setMaxOpenFiles
  * Signature: (JI)V
  */
-void Java_org_rocksdb_Options_setMaxBackgroundCompactions(
-    JNIEnv* env, jobject jobj, jlong jhandle,
-    jint jmax_background_compactions) {
-  reinterpret_cast<rocksdb::Options*>(jhandle)->max_background_compactions =
-         jmax_background_compactions;
+void Java_org_rocksdb_Options_setMaxOpenFiles(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint max_open_files) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->max_open_files =
+      static_cast<int>(max_open_files);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    disableDataSync
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_disableDataSync(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->disableDataSync;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setDisableDataSync
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setDisableDataSync(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean disableDataSync) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->disableDataSync =
+      static_cast<bool>(disableDataSync);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    useFsync
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_useFsync(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->use_fsync;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setUseFsync
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setUseFsync(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean use_fsync) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->use_fsync =
+      static_cast<bool>(use_fsync);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    dbStatsLogInterval
+ * Signature: (J)I
+ */
+jint Java_org_rocksdb_Options_dbStatsLogInterval(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->db_stats_log_interval;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setDbStatsLogInterval
+ * Signature: (JI)V
+ */
+void Java_org_rocksdb_Options_setDbStatsLogInterval(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint db_stats_log_interval) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->db_stats_log_interval =
+      static_cast<int>(db_stats_log_interval);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    dbLogDir
+ * Signature: (J)Ljava/lang/String
+ */
+jstring Java_org_rocksdb_Options_dbLogDir(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return env->NewStringUTF(
+      reinterpret_cast<rocksdb::Options*>(jhandle)->db_log_dir.c_str());
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setDbLogDir
+ * Signature: (JLjava/lang/String)V
+ */
+void Java_org_rocksdb_Options_setDbLogDir(
+    JNIEnv* env, jobject jobj, jlong jhandle, jstring jdb_log_dir) {
+  const char* log_dir = env->GetStringUTFChars(jdb_log_dir, 0);
+  reinterpret_cast<rocksdb::Options*>(jhandle)->db_log_dir.assign(log_dir);
+  env->ReleaseStringUTFChars(jdb_log_dir, log_dir);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    walDir
+ * Signature: (J)Ljava/lang/String
+ */
+jstring Java_org_rocksdb_Options_walDir(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return env->NewStringUTF(
+      reinterpret_cast<rocksdb::Options*>(jhandle)->wal_dir.c_str());
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setWalDir
+ * Signature: (JLjava/lang/String)V
+ */
+void Java_org_rocksdb_Options_setWalDir(
+    JNIEnv* env, jobject jobj, jlong jhandle, jstring jwal_dir) {
+  const char* wal_dir = env->GetStringUTFChars(jwal_dir, 0);
+  reinterpret_cast<rocksdb::Options*>(jhandle)->wal_dir.assign(wal_dir);
+  env->ReleaseStringUTFChars(jwal_dir, wal_dir);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    deleteObsoleteFilesPeriodMicros
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_deleteObsoleteFilesPeriodMicros(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)
+      ->delete_obsolete_files_period_micros;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setDeleteObsoleteFilesPeriodMicros
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setDeleteObsoleteFilesPeriodMicros(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong micros) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)
+      ->delete_obsolete_files_period_micros =
+          static_cast<int64_t>(micros);
 }
 
 /*
@@ -164,10 +347,422 @@ void Java_org_rocksdb_Options_setMaxBackgroundCompactions(
  */
 jint Java_org_rocksdb_Options_maxBackgroundCompactions(
     JNIEnv* env, jobject jobj, jlong jhandle) {
-  return
-    reinterpret_cast<rocksdb::Options*>(jhandle)->max_background_compactions;
+  return reinterpret_cast<rocksdb::Options*>(
+      jhandle)->max_background_compactions;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setMaxBackgroundCompactions
+ * Signature: (JI)V
+ */
+void Java_org_rocksdb_Options_setMaxBackgroundCompactions(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint max) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)
+      ->max_background_compactions = static_cast<int>(max);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    maxBackgroundFlushes
+ * Signature: (J)I
+ */
+jint Java_org_rocksdb_Options_maxBackgroundFlushes(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->max_background_flushes;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setMaxBackgroundFlushes
+ * Signature: (JI)V
+ */
+void Java_org_rocksdb_Options_setMaxBackgroundFlushes(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint max_background_flushes) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->max_background_flushes =
+      static_cast<int>(max_background_flushes);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    maxLogFileSize
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_maxLogFileSize(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->max_log_file_size;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setMaxLogFileSize
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setMaxLogFileSize(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong max_log_file_size) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->max_log_file_size =
+      static_cast<size_t>(max_log_file_size);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    logFileTimeToRoll
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_logFileTimeToRoll(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->log_file_time_to_roll;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setLogFileTimeToRoll
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setLogFileTimeToRoll(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong log_file_time_to_roll) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->log_file_time_to_roll =
+      static_cast<size_t>(log_file_time_to_roll);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    keepLogFileNum
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_keepLogFileNum(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->keep_log_file_num;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setKeepLogFileNum
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setKeepLogFileNum(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong keep_log_file_num) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->keep_log_file_num =
+      static_cast<size_t>(keep_log_file_num);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    maxManifestFileSize
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_maxManifestFileSize(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->max_manifest_file_size;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setMaxManifestFileSize
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setMaxManifestFileSize(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong max_manifest_file_size) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->max_manifest_file_size =
+      static_cast<int64_t>(max_manifest_file_size);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    tableCacheNumshardbits
+ * Signature: (J)I
+ */
+jint Java_org_rocksdb_Options_tableCacheNumshardbits(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->table_cache_numshardbits;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setTableCacheNumshardbits
+ * Signature: (JI)V
+ */
+void Java_org_rocksdb_Options_setTableCacheNumshardbits(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint table_cache_numshardbits) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->table_cache_numshardbits =
+      static_cast<int>(table_cache_numshardbits);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    tableCacheRemoveScanCountLimit
+ * Signature: (J)I
+ */
+jint Java_org_rocksdb_Options_tableCacheRemoveScanCountLimit(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(
+      jhandle)->table_cache_remove_scan_count_limit;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setTableCacheRemoveScanCountLimit
+ * Signature: (JI)V
+ */
+void Java_org_rocksdb_Options_setTableCacheRemoveScanCountLimit(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint limit) {
+  reinterpret_cast<rocksdb::Options*>(
+      jhandle)->table_cache_remove_scan_count_limit = static_cast<int>(limit);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    walTtlSeconds
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_walTtlSeconds(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->WAL_ttl_seconds;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setWALTtlSeconds
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setWALTtlSeconds(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong WAL_ttl_seconds) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->WAL_ttl_seconds =
+      static_cast<int64_t>(WAL_ttl_seconds);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    manifestPreallocationSize
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_manifestPreallocationSize(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)
+      ->manifest_preallocation_size;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setManifestPreallocationSize
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setManifestPreallocationSize(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong preallocation_size) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->manifest_preallocation_size =
+      static_cast<size_t>(preallocation_size);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    allowOsBuffer
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_allowOsBuffer(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->allow_os_buffer;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setAllowOsBuffer
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setAllowOsBuffer(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean allow_os_buffer) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->allow_os_buffer =
+      static_cast<bool>(allow_os_buffer);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    allowMmapReads
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_allowMmapReads(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->allow_mmap_reads;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setAllowMmapReads
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setAllowMmapReads(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean allow_mmap_reads) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->allow_mmap_reads =
+      static_cast<bool>(allow_mmap_reads);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    allowMmapWrites
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_allowMmapWrites(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->allow_mmap_writes;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setAllowMmapWrites
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setAllowMmapWrites(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean allow_mmap_writes) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->allow_mmap_writes =
+      static_cast<bool>(allow_mmap_writes);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    isFdCloseOnExec
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_isFdCloseOnExec(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->is_fd_close_on_exec;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setIsFdCloseOnExec
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setIsFdCloseOnExec(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean is_fd_close_on_exec) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->is_fd_close_on_exec =
+      static_cast<bool>(is_fd_close_on_exec);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    skipLogErrorOnRecovery
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_skipLogErrorOnRecovery(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)
+      ->skip_log_error_on_recovery;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setSkipLogErrorOnRecovery
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setSkipLogErrorOnRecovery(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean skip) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->skip_log_error_on_recovery =
+      static_cast<bool>(skip);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    statsDumpPeriodSec
+ * Signature: (J)I
+ */
+jint Java_org_rocksdb_Options_statsDumpPeriodSec(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->stats_dump_period_sec;
 }
 
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setStatsDumpPeriodSec
+ * Signature: (JI)V
+ */
+void Java_org_rocksdb_Options_setStatsDumpPeriodSec(
+    JNIEnv* env, jobject jobj, jlong jhandle, jint stats_dump_period_sec) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->stats_dump_period_sec =
+      static_cast<int>(stats_dump_period_sec);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    adviseRandomOnOpen
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_adviseRandomOnOpen(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->advise_random_on_open;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setAdviseRandomOnOpen
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setAdviseRandomOnOpen(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean advise_random_on_open) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->advise_random_on_open =
+      static_cast<bool>(advise_random_on_open);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    useAdaptiveMutex
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_useAdaptiveMutex(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->use_adaptive_mutex;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setUseAdaptiveMutex
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setUseAdaptiveMutex(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean use_adaptive_mutex) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->use_adaptive_mutex =
+      static_cast<bool>(use_adaptive_mutex);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    bytesPerSync
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_bytesPerSync(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->bytes_per_sync;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setBytesPerSync
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setBytesPerSync(
+    JNIEnv* env, jobject jobj, jlong jhandle, jlong bytes_per_sync) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->bytes_per_sync =
+      static_cast<int64_t>(bytes_per_sync);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    allowThreadLocal
+ * Signature: (J)Z
+ */
+jboolean Java_org_rocksdb_Options_allowThreadLocal(
+    JNIEnv* env, jobject jobj, jlong jhandle) {
+  return reinterpret_cast<rocksdb::Options*>(jhandle)->allow_thread_local;
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setAllowThreadLocal
+ * Signature: (JZ)V
+ */
+void Java_org_rocksdb_Options_setAllowThreadLocal(
+    JNIEnv* env, jobject jobj, jlong jhandle, jboolean allow_thread_local) {
+  reinterpret_cast<rocksdb::Options*>(jhandle)->allow_thread_local =
+      static_cast<bool>(allow_thread_local);
+}
 
 //////////////////////////////////////////////////////////////////////////////
 // WriteOptions