| // 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.Collection; |
| import java.util.List; |
| |
| public interface DBOptionsInterface<T extends DBOptionsInterface> { |
| |
| /** |
| * Use this if your DB is very small (like under 1GB) and you don't want to |
| * spend lots of memory for memtables. |
| * |
| * @return the instance of the current object. |
| */ |
| T optimizeForSmallDb(); |
| |
| /** |
| * Use the specified object to interact with the environment, |
| * e.g. to read/write files, schedule background work, etc. |
| * Default: {@link Env#getDefault()} |
| * |
| * @param env {@link Env} instance. |
| * @return the instance of the current Options. |
| */ |
| T setEnv(final Env env); |
| |
| /** |
| * Returns the set RocksEnv instance. |
| * |
| * @return {@link RocksEnv} instance set in the options. |
| */ |
| Env getEnv(); |
| |
| /** |
| * <p>By default, RocksDB uses only one background thread for flush and |
| * compaction. Calling this function will set it up such that total of |
| * `total_threads` is used.</p> |
| * |
| * <p>You almost definitely want to call this function if your system is |
| * bottlenecked by RocksDB.</p> |
| * |
| * @param totalThreads The total number of threads to be used by RocksDB. |
| * A good value is the number of cores. |
| * |
| * @return the instance of the current Options |
| */ |
| T setIncreaseParallelism(int totalThreads); |
| |
| /** |
| * If this value is set to true, then the database will be created |
| * if it is missing during {@code RocksDB.open()}. |
| * Default: false |
| * |
| * @param flag a flag indicating whether to create a database the |
| * specified database in {@link RocksDB#open(org.rocksdb.Options, String)} operation |
| * is missing. |
| * @return the instance of the current Options |
| * @see RocksDB#open(org.rocksdb.Options, String) |
| */ |
| T setCreateIfMissing(boolean flag); |
| |
| /** |
| * Return true if the create_if_missing flag is set to true. |
| * If true, the database will be created if it is missing. |
| * |
| * @return true if the createIfMissing option is set to true. |
| * @see #setCreateIfMissing(boolean) |
| */ |
| boolean createIfMissing(); |
| |
| /** |
| * <p>If true, missing column families will be automatically created</p> |
| * |
| * <p>Default: false</p> |
| * |
| * @param flag a flag indicating if missing column families shall be |
| * created automatically. |
| * @return true if missing column families shall be created automatically |
| * on open. |
| */ |
| T setCreateMissingColumnFamilies(boolean flag); |
| |
| /** |
| * Return true if the create_missing_column_families flag is set |
| * to true. If true column families be created if missing. |
| * |
| * @return true if the createMissingColumnFamilies is set to |
| * true. |
| * @see #setCreateMissingColumnFamilies(boolean) |
| */ |
| boolean createMissingColumnFamilies(); |
| |
| /** |
| * 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 {@code RocksDB.open()} if the database already exists. |
| * @return the reference to the current option. |
| * @see RocksDB#open(org.rocksdb.Options, String) |
| */ |
| T setErrorIfExists(boolean errorIfExists); |
| |
| /** |
| * 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. |
| */ |
| boolean errorIfExists(); |
| |
| /** |
| * 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. |
| */ |
| T setParanoidChecks(boolean paranoidChecks); |
| |
| /** |
| * 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. |
| */ |
| boolean paranoidChecks(); |
| |
| /** |
| * Use to control write rate of flush and compaction. Flush has higher |
| * priority than compaction. Rate limiting is disabled if nullptr. |
| * Default: nullptr |
| * |
| * @param rateLimiter {@link org.rocksdb.RateLimiter} instance. |
| * @return the instance of the current object. |
| * |
| * @since 3.10.0 |
| */ |
| T setRateLimiter(RateLimiter rateLimiter); |
| |
| /** |
| * <p>Any internal progress/error information generated by |
| * the db will be written to the Logger if it is non-nullptr, |
| * or to a file stored in the same directory as the DB |
| * contents if info_log is nullptr.</p> |
| * |
| * <p>Default: nullptr</p> |
| * |
| * @param logger {@link Logger} instance. |
| * @return the instance of the current object. |
| */ |
| T setLogger(Logger logger); |
| |
| /** |
| * <p>Sets the RocksDB log level. Default level is INFO</p> |
| * |
| * @param infoLogLevel log level to set. |
| * @return the instance of the current object. |
| */ |
| T setInfoLogLevel(InfoLogLevel infoLogLevel); |
| |
| /** |
| * <p>Returns currently set log level.</p> |
| * @return {@link org.rocksdb.InfoLogLevel} instance. |
| */ |
| InfoLogLevel infoLogLevel(); |
| |
| /** |
| * 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 {@code target_file_size_base} and {@code target_file_size_multiplier} |
| * for level-based compaction. For universal-style compaction, you can usually |
| * set it to -1. |
| * Default: 5000 |
| * |
| * @param maxOpenFiles the maximum number of open files. |
| * @return the instance of the current object. |
| */ |
| T setMaxOpenFiles(int maxOpenFiles); |
| |
| /** |
| * 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 {@code target_file_size_base} and {@code 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. |
| */ |
| int maxOpenFiles(); |
| |
| /** |
| * If {@link #maxOpenFiles()} is -1, DB will open all files on DB::Open(). You |
| * can use this option to increase the number of threads used to open the |
| * files. |
| * |
| * Default: 16 |
| * |
| * @param maxFileOpeningThreads the maximum number of threads to use to |
| * open files |
| * |
| * @return the reference to the current options. |
| */ |
| T setMaxFileOpeningThreads(int maxFileOpeningThreads); |
| |
| /** |
| * If {@link #maxOpenFiles()} is -1, DB will open all files on DB::Open(). You |
| * can use this option to increase the number of threads used to open the |
| * files. |
| * |
| * Default: 16 |
| * |
| * @return the maximum number of threads to use to open files |
| */ |
| int maxFileOpeningThreads(); |
| |
| /** |
| * <p>Once write-ahead logs exceed this size, we will start forcing the |
| * flush of column families whose memtables are backed by the oldest live |
| * WAL file (i.e. the ones that are causing all the space amplification). |
| * </p> |
| * <p>If set to 0 (default), we will dynamically choose the WAL size limit to |
| * be [sum of all write_buffer_size * max_write_buffer_number] * 2</p> |
| * <p>Default: 0</p> |
| * |
| * @param maxTotalWalSize max total wal size. |
| * @return the instance of the current object. |
| */ |
| T setMaxTotalWalSize(long maxTotalWalSize); |
| |
| /** |
| * <p>Returns the max total wal size. Once write-ahead logs exceed this size, |
| * we will start forcing the flush of column families whose memtables are |
| * backed by the oldest live WAL file (i.e. the ones that are causing all |
| * the space amplification).</p> |
| * |
| * <p>If set to 0 (default), we will dynamically choose the WAL size limit |
| * to be [sum of all write_buffer_size * max_write_buffer_number] * 2 |
| * </p> |
| * |
| * @return max total wal size |
| */ |
| long maxTotalWalSize(); |
| |
| /** |
| * <p>Sets the statistics object which collects metrics about database operations. |
| * Statistics objects should not be shared between DB instances as |
| * it does not use any locks to prevent concurrent updates.</p> |
| * |
| * @return the instance of the current object. |
| * @see RocksDB#open(org.rocksdb.Options, String) |
| */ |
| T setStatistics(final Statistics statistics); |
| |
| /** |
| * <p>Returns statistics object.</p> |
| * |
| * @return the instance of the statistics object or null if there is no statistics object. |
| * @see #setStatistics(Statistics) |
| */ |
| Statistics statistics(); |
| |
| /** |
| * <p>If true, then every store to stable storage will issue a fsync.</p> |
| * <p>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.</p> |
| * <p>Default: false</p> |
| * |
| * @param useFsync a boolean flag to specify whether to use fsync |
| * @return the instance of the current object. |
| */ |
| T setUseFsync(boolean useFsync); |
| |
| /** |
| * <p>If true, then every store to stable storage will issue a fsync.</p> |
| * <p>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.</p> |
| * |
| * @return boolean value indicating if fsync is used. |
| */ |
| boolean useFsync(); |
| |
| /** |
| * A list of paths where SST files can be put into, with its target size. |
| * Newer data is placed into paths specified earlier in the vector while |
| * older data gradually moves to paths specified later in the vector. |
| * |
| * For example, you have a flash device with 10GB allocated for the DB, |
| * as well as a hard drive of 2TB, you should config it to be: |
| * [{"/flash_path", 10GB}, {"/hard_drive", 2TB}] |
| * |
| * The system will try to guarantee data under each path is close to but |
| * not larger than the target size. But current and future file sizes used |
| * by determining where to place a file are based on best-effort estimation, |
| * which means there is a chance that the actual size under the directory |
| * is slightly more than target size under some workloads. User should give |
| * some buffer room for those cases. |
| * |
| * If none of the paths has sufficient room to place a file, the file will |
| * be placed to the last path anyway, despite to the target size. |
| * |
| * Placing newer data to earlier paths is also best-efforts. User should |
| * expect user files to be placed in higher levels in some extreme cases. |
| * |
| * If left empty, only one path will be used, which is db_name passed when |
| * opening the DB. |
| * |
| * Default: empty |
| * |
| * @param dbPaths the paths and target sizes |
| * |
| * @return the reference to the current options |
| */ |
| T setDbPaths(final Collection<DbPath> dbPaths); |
| |
| /** |
| * A list of paths where SST files can be put into, with its target size. |
| * Newer data is placed into paths specified earlier in the vector while |
| * older data gradually moves to paths specified later in the vector. |
| * |
| * For example, you have a flash device with 10GB allocated for the DB, |
| * as well as a hard drive of 2TB, you should config it to be: |
| * [{"/flash_path", 10GB}, {"/hard_drive", 2TB}] |
| * |
| * The system will try to guarantee data under each path is close to but |
| * not larger than the target size. But current and future file sizes used |
| * by determining where to place a file are based on best-effort estimation, |
| * which means there is a chance that the actual size under the directory |
| * is slightly more than target size under some workloads. User should give |
| * some buffer room for those cases. |
| * |
| * If none of the paths has sufficient room to place a file, the file will |
| * be placed to the last path anyway, despite to the target size. |
| * |
| * Placing newer data to earlier paths is also best-efforts. User should |
| * expect user files to be placed in higher levels in some extreme cases. |
| * |
| * If left empty, only one path will be used, which is db_name passed when |
| * opening the DB. |
| * |
| * Default: {@link java.util.Collections#emptyList()} |
| * |
| * @return dbPaths the paths and target sizes |
| */ |
| List<DbPath> dbPaths(); |
| |
| /** |
| * 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 instance of the current object. |
| */ |
| T setDbLogDir(String dbLogDir); |
| |
| /** |
| * 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 |
| */ |
| String dbLogDir(); |
| |
| /** |
| * 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 instance of the current object. |
| */ |
| T setWalDir(String walDir); |
| |
| /** |
| * 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. |
| */ |
| 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 |
| * |
| * @param micros the time interval in micros |
| * @return the instance of the current object. |
| */ |
| T setDeleteObsoleteFilesPeriodMicros(long micros); |
| |
| /** |
| * 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. |
| */ |
| long deleteObsoleteFilesPeriodMicros(); |
| |
| /** |
| * Suggested number of concurrent background compaction jobs, submitted to |
| * the default LOW priority thread pool. |
| * Default: 1 |
| * |
| * @param baseBackgroundCompactions Suggested number of background compaction |
| * jobs |
| */ |
| void setBaseBackgroundCompactions(int baseBackgroundCompactions); |
| |
| /** |
| * Suggested number of concurrent background compaction jobs, submitted to |
| * the default LOW priority thread pool. |
| * Default: 1 |
| * |
| * @return Suggested number of background compaction jobs |
| */ |
| int baseBackgroundCompactions(); |
| |
| /** |
| * 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 |
| * |
| * @param maxBackgroundCompactions the maximum number of background |
| * compaction jobs. |
| * @return the instance of the current object. |
| * |
| * @see RocksEnv#setBackgroundThreads(int) |
| * @see RocksEnv#setBackgroundThreads(int, int) |
| * @see #maxBackgroundFlushes() |
| */ |
| T setMaxBackgroundCompactions(int maxBackgroundCompactions); |
| |
| /** |
| * 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 RocksEnv#setBackgroundThreads(int) |
| * @see RocksEnv#setBackgroundThreads(int, int) |
| */ |
| int maxBackgroundCompactions(); |
| |
| /** |
| * 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: 1 (i.e. no subcompactions) |
| * |
| * @param maxSubcompactions The maximum number of threads that will |
| * concurrently perform a compaction job |
| */ |
| void setMaxSubcompactions(int maxSubcompactions); |
| |
| /** |
| * 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: 1 (i.e. no subcompactions) |
| * |
| * @return The maximum number of threads that will concurrently perform a |
| * compaction job |
| */ |
| int maxSubcompactions(); |
| |
| /** |
| * 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 number of max concurrent flush jobs |
| * @return the instance of the current object. |
| * |
| * @see RocksEnv#setBackgroundThreads(int) |
| * @see RocksEnv#setBackgroundThreads(int, int) |
| * @see #maxBackgroundCompactions() |
| */ |
| T setMaxBackgroundFlushes(int maxBackgroundFlushes); |
| |
| /** |
| * 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 RocksEnv#setBackgroundThreads(int) |
| * @see RocksEnv#setBackgroundThreads(int, int) |
| */ |
| int maxBackgroundFlushes(); |
| |
| /** |
| * 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 instance of the current object. |
| * @throws java.lang.IllegalArgumentException thrown on 32-Bit platforms |
| * while overflowing the underlying platform specific value. |
| */ |
| T setMaxLogFileSize(long maxLogFileSize); |
| |
| /** |
| * 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. |
| */ |
| long maxLogFileSize(); |
| |
| /** |
| * 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 instance of the current object. |
| * @throws java.lang.IllegalArgumentException thrown on 32-Bit platforms |
| * while overflowing the underlying platform specific value. |
| */ |
| T setLogFileTimeToRoll(long logFileTimeToRoll); |
| |
| /** |
| * 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. |
| */ |
| long logFileTimeToRoll(); |
| |
| /** |
| * 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 instance of the current object. |
| * @throws java.lang.IllegalArgumentException thrown on 32-Bit platforms |
| * while overflowing the underlying platform specific value. |
| */ |
| T setKeepLogFileNum(long keepLogFileNum); |
| |
| /** |
| * Returns the maximum number of info log files to be kept. |
| * Default: 1000 |
| * |
| * @return the maximum number of info log files to be kept. |
| */ |
| long keepLogFileNum(); |
| |
| /** |
| * Recycle log files. |
| * |
| * If non-zero, we will reuse previously written log files for new |
| * logs, overwriting the old data. The value indicates how many |
| * such files we will keep around at any point in time for later |
| * use. |
| * |
| * This is more efficient because the blocks are already |
| * allocated and fdatasync does not need to update the inode after |
| * each write. |
| * |
| * Default: 0 |
| * |
| * @param recycleLogFileNum the number of log files to keep for recycling |
| * |
| * @return the reference to the current options |
| */ |
| T setRecycleLogFileNum(long recycleLogFileNum); |
| |
| /** |
| * Recycle log files. |
| * |
| * If non-zero, we will reuse previously written log files for new |
| * logs, overwriting the old data. The value indicates how many |
| * such files we will keep around at any point in time for later |
| * use. |
| * |
| * This is more efficient because the blocks are already |
| * allocated and fdatasync does not need to update the inode after |
| * each write. |
| * |
| * Default: 0 |
| * |
| * @return the number of log files kept for recycling |
| */ |
| long recycleLogFileNum(); |
| |
| /** |
| * 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 instance of the current object. |
| */ |
| T setMaxManifestFileSize(long maxManifestFileSize); |
| |
| /** |
| * 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. |
| */ |
| long maxManifestFileSize(); |
| |
| /** |
| * Number of shards used for table cache. |
| * |
| * @param tableCacheNumshardbits the number of chards |
| * @return the instance of the current object. |
| */ |
| T setTableCacheNumshardbits(int tableCacheNumshardbits); |
| |
| /** |
| * Number of shards used for table cache. |
| * |
| * @return the number of shards used for table cache. |
| */ |
| int tableCacheNumshardbits(); |
| |
| /** |
| * {@link #walTtlSeconds()} and {@link #walSizeLimitMB()} affect how archived logs |
| * will be deleted. |
| * <ol> |
| * <li>If both set to 0, logs will be deleted asap and will not get into |
| * the archive.</li> |
| * <li>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.</li> |
| * <li>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.</li> |
| * <li>If both are not 0, WAL files will be checked every 10 min and both |
| * checks will be performed with ttl being first.</li> |
| * </ol> |
| * |
| * @param walTtlSeconds the ttl seconds |
| * @return the instance of the current object. |
| * @see #setWalSizeLimitMB(long) |
| */ |
| T setWalTtlSeconds(long walTtlSeconds); |
| |
| /** |
| * WalTtlSeconds() and walSizeLimitMB() affect how archived logs |
| * will be deleted. |
| * <ol> |
| * <li>If both set to 0, logs will be deleted asap and will not get into |
| * the archive.</li> |
| * <li>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.</li> |
| * <li>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.</li> |
| * <li>If both are not 0, WAL files will be checked every 10 min and both |
| * checks will be performed with ttl being first.</li> |
| * </ol> |
| * |
| * @return the wal-ttl seconds |
| * @see #walSizeLimitMB() |
| */ |
| long walTtlSeconds(); |
| |
| /** |
| * WalTtlSeconds() and walSizeLimitMB() affect how archived logs |
| * will be deleted. |
| * <ol> |
| * <li>If both set to 0, logs will be deleted asap and will not get into |
| * the archive.</li> |
| * <li>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.</li> |
| * <li>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.</li> |
| * <li>If both are not 0, WAL files will be checked every 10 min and both |
| * checks will be performed with ttl being first.</li> |
| * </ol> |
| * |
| * @param sizeLimitMB size limit in mega-bytes. |
| * @return the instance of the current object. |
| * @see #setWalSizeLimitMB(long) |
| */ |
| T setWalSizeLimitMB(long sizeLimitMB); |
| |
| /** |
| * {@link #walTtlSeconds()} and {@code #walSizeLimitMB()} affect how archived logs |
| * will be deleted. |
| * <ol> |
| * <li>If both set to 0, logs will be deleted asap and will not get into |
| * the archive.</li> |
| * <li>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.</li> |
| * <li>If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then |
| * WAL files will be checked every WAL_ttl_seconds i / 2 and those that |
| * are older than WAL_ttl_seconds will be deleted.</li> |
| * <li>If both are not 0, WAL files will be checked every 10 min and both |
| * checks will be performed with ttl being first.</li> |
| * </ol> |
| * @return size limit in mega-bytes. |
| * @see #walSizeLimitMB() |
| */ |
| long walSizeLimitMB(); |
| |
| /** |
| * 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 instance of the current object. |
| * @throws java.lang.IllegalArgumentException thrown on 32-Bit platforms |
| * while overflowing the underlying platform specific value. |
| */ |
| T setManifestPreallocationSize(long size); |
| |
| /** |
| * 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. |
| */ |
| long manifestPreallocationSize(); |
| |
| /** |
| * Enable the OS to use direct I/O for reading sst tables. |
| * Default: false |
| * |
| * @param useDirectReads if true, then direct read is enabled |
| * @return the instance of the current object. |
| */ |
| T setUseDirectReads(boolean useDirectReads); |
| |
| /** |
| * Enable the OS to use direct I/O for reading sst tables. |
| * Default: false |
| * |
| * @return if true, then direct reads are enabled |
| */ |
| boolean useDirectReads(); |
| |
| /** |
| * Enable the OS to use direct reads and writes in flush and |
| * compaction |
| * Default: false |
| * |
| * @param useDirectIoForFlushAndCompaction if true, then direct |
| * I/O will be enabled for background flush and compactions |
| * @return the instance of the current object. |
| */ |
| T setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction); |
| |
| /** |
| * Enable the OS to use direct reads and writes in flush and |
| * compaction |
| * |
| * @return if true, then direct I/O is enabled for flush and |
| * compaction |
| */ |
| boolean useDirectIoForFlushAndCompaction(); |
| |
| /** |
| * Whether fallocate calls are allowed |
| * |
| * @param allowFAllocate false if fallocate() calls are bypassed |
| * |
| * @return the reference to the current options. |
| */ |
| T setAllowFAllocate(boolean allowFAllocate); |
| |
| /** |
| * Whether fallocate calls are allowed |
| * |
| * @return false if fallocate() calls are bypassed |
| */ |
| boolean allowFAllocate(); |
| |
| /** |
| * Allow the OS to mmap file for reading sst tables. |
| * Default: false |
| * |
| * @param allowMmapReads true if mmap reads are allowed. |
| * @return the instance of the current object. |
| */ |
| T setAllowMmapReads(boolean allowMmapReads); |
| |
| /** |
| * Allow the OS to mmap file for reading sst tables. |
| * Default: false |
| * |
| * @return true if mmap reads are allowed. |
| */ |
| boolean allowMmapReads(); |
| |
| /** |
| * Allow the OS to mmap file for writing. Default: false |
| * |
| * @param allowMmapWrites true if mmap writes are allowd. |
| * @return the instance of the current object. |
| */ |
| T setAllowMmapWrites(boolean allowMmapWrites); |
| |
| /** |
| * Allow the OS to mmap file for writing. Default: false |
| * |
| * @return true if mmap writes are allowed. |
| */ |
| boolean allowMmapWrites(); |
| |
| /** |
| * Disable child process inherit open files. Default: true |
| * |
| * @param isFdCloseOnExec true if child process inheriting open |
| * files is disabled. |
| * @return the instance of the current object. |
| */ |
| T setIsFdCloseOnExec(boolean isFdCloseOnExec); |
| |
| /** |
| * Disable child process inherit open files. Default: true |
| * |
| * @return true if child process inheriting open files is disabled. |
| */ |
| boolean isFdCloseOnExec(); |
| |
| /** |
| * if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec |
| * Default: 600 (10 minutes) |
| * |
| * @param statsDumpPeriodSec time interval in seconds. |
| * @return the instance of the current object. |
| */ |
| T setStatsDumpPeriodSec(int statsDumpPeriodSec); |
| |
| /** |
| * If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec |
| * Default: 600 (10 minutes) |
| * |
| * @return time interval in seconds. |
| */ |
| 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 |
| * |
| * @param adviseRandomOnOpen true if hinting random access is on. |
| * @return the instance of the current object. |
| */ |
| T setAdviseRandomOnOpen(boolean adviseRandomOnOpen); |
| |
| /** |
| * 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. |
| */ |
| boolean adviseRandomOnOpen(); |
| |
| /** |
| * Amount of data to build up in memtables across all column |
| * families before writing to disk. |
| * |
| * This is distinct from {@link ColumnFamilyOptions#writeBufferSize()}, |
| * which enforces a limit for a single memtable. |
| * |
| * This feature is disabled by default. Specify a non-zero value |
| * to enable it. |
| * |
| * Default: 0 (disabled) |
| * |
| * @param dbWriteBufferSize the size of the write buffer |
| * |
| * @return the reference to the current options. |
| */ |
| T setDbWriteBufferSize(long dbWriteBufferSize); |
| |
| /** |
| * Amount of data to build up in memtables across all column |
| * families before writing to disk. |
| * |
| * This is distinct from {@link ColumnFamilyOptions#writeBufferSize()}, |
| * which enforces a limit for a single memtable. |
| * |
| * This feature is disabled by default. Specify a non-zero value |
| * to enable it. |
| * |
| * Default: 0 (disabled) |
| * |
| * @return the size of the write buffer |
| */ |
| long dbWriteBufferSize(); |
| |
| /** |
| * Specify the file access pattern once a compaction is started. |
| * It will be applied to all input files of a compaction. |
| * |
| * Default: {@link AccessHint#NORMAL} |
| * |
| * @param accessHint The access hint |
| * |
| * @return the reference to the current options. |
| */ |
| T setAccessHintOnCompactionStart(final AccessHint accessHint); |
| |
| /** |
| * Specify the file access pattern once a compaction is started. |
| * It will be applied to all input files of a compaction. |
| * |
| * Default: {@link AccessHint#NORMAL} |
| * |
| * @return The access hint |
| */ |
| AccessHint accessHintOnCompactionStart(); |
| |
| /** |
| * If true, always create a new file descriptor and new table reader |
| * for compaction inputs. Turn this parameter on may introduce extra |
| * memory usage in the table reader, if it allocates extra memory |
| * for indexes. This will allow file descriptor prefetch options |
| * to be set for compaction input files and not to impact file |
| * descriptors for the same file used by user queries. |
| * Suggest to enable {@link BlockBasedTableConfig#cacheIndexAndFilterBlocks()} |
| * for this mode if using block-based table. |
| * |
| * Default: false |
| * |
| * @param newTableReaderForCompactionInputs true if a new file descriptor and |
| * table reader should be created for compaction inputs |
| * |
| * @return the reference to the current options. |
| */ |
| T setNewTableReaderForCompactionInputs( |
| boolean newTableReaderForCompactionInputs); |
| |
| /** |
| * If true, always create a new file descriptor and new table reader |
| * for compaction inputs. Turn this parameter on may introduce extra |
| * memory usage in the table reader, if it allocates extra memory |
| * for indexes. This will allow file descriptor prefetch options |
| * to be set for compaction input files and not to impact file |
| * descriptors for the same file used by user queries. |
| * Suggest to enable {@link BlockBasedTableConfig#cacheIndexAndFilterBlocks()} |
| * for this mode if using block-based table. |
| * |
| * Default: false |
| * |
| * @return true if a new file descriptor and table reader are created for |
| * compaction inputs |
| */ |
| boolean newTableReaderForCompactionInputs(); |
| |
| /** |
| * If non-zero, we perform bigger reads when doing compaction. If you're |
| * running RocksDB on spinning disks, you should set this to at least 2MB. |
| * |
| * That way RocksDB's compaction is doing sequential instead of random reads. |
| * When non-zero, we also force {@link #newTableReaderForCompactionInputs()} |
| * to true. |
| * |
| * Default: 0 |
| * |
| * @param compactionReadaheadSize The compaction read-ahead size |
| * |
| * @return the reference to the current options. |
| */ |
| T setCompactionReadaheadSize(final long compactionReadaheadSize); |
| |
| /** |
| * If non-zero, we perform bigger reads when doing compaction. If you're |
| * running RocksDB on spinning disks, you should set this to at least 2MB. |
| * |
| * That way RocksDB's compaction is doing sequential instead of random reads. |
| * When non-zero, we also force {@link #newTableReaderForCompactionInputs()} |
| * to true. |
| * |
| * Default: 0 |
| * |
| * @return The compaction read-ahead size |
| */ |
| long compactionReadaheadSize(); |
| |
| /** |
| * This is a maximum buffer size that is used by WinMmapReadableFile in |
| * unbuffered disk I/O mode. We need to maintain an aligned buffer for |
| * reads. We allow the buffer to grow until the specified value and then |
| * for bigger requests allocate one shot buffers. In unbuffered mode we |
| * always bypass read-ahead buffer at ReadaheadRandomAccessFile |
| * When read-ahead is required we then make use of |
| * {@link #compactionReadaheadSize()} value and always try to read ahead. |
| * With read-ahead we always pre-allocate buffer to the size instead of |
| * growing it up to a limit. |
| * |
| * This option is currently honored only on Windows |
| * |
| * Default: 1 Mb |
| * |
| * Special value: 0 - means do not maintain per instance buffer. Allocate |
| * per request buffer and avoid locking. |
| * |
| * @param randomAccessMaxBufferSize the maximum size of the random access |
| * buffer |
| * |
| * @return the reference to the current options. |
| */ |
| T setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize); |
| |
| /** |
| * This is a maximum buffer size that is used by WinMmapReadableFile in |
| * unbuffered disk I/O mode. We need to maintain an aligned buffer for |
| * reads. We allow the buffer to grow until the specified value and then |
| * for bigger requests allocate one shot buffers. In unbuffered mode we |
| * always bypass read-ahead buffer at ReadaheadRandomAccessFile |
| * When read-ahead is required we then make use of |
| * {@link #compactionReadaheadSize()} value and always try to read ahead. |
| * With read-ahead we always pre-allocate buffer to the size instead of |
| * growing it up to a limit. |
| * |
| * This option is currently honored only on Windows |
| * |
| * Default: 1 Mb |
| * |
| * Special value: 0 - means do not maintain per instance buffer. Allocate |
| * per request buffer and avoid locking. |
| * |
| * @return the maximum size of the random access buffer |
| */ |
| long randomAccessMaxBufferSize(); |
| |
| /** |
| * This is the maximum buffer size that is used by WritableFileWriter. |
| * On Windows, we need to maintain an aligned buffer for writes. |
| * We allow the buffer to grow until it's size hits the limit. |
| * |
| * Default: 1024 * 1024 (1 MB) |
| * |
| * @param writableFileMaxBufferSize the maximum buffer size |
| * |
| * @return the reference to the current options. |
| */ |
| T setWritableFileMaxBufferSize(long writableFileMaxBufferSize); |
| |
| /** |
| * This is the maximum buffer size that is used by WritableFileWriter. |
| * On Windows, we need to maintain an aligned buffer for writes. |
| * We allow the buffer to grow until it's size hits the limit. |
| * |
| * Default: 1024 * 1024 (1 MB) |
| * |
| * @return the maximum buffer size |
| */ |
| long writableFileMaxBufferSize(); |
| |
| /** |
| * 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 instance of the current object. |
| */ |
| T setUseAdaptiveMutex(boolean useAdaptiveMutex); |
| |
| /** |
| * 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. |
| */ |
| 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 |
| * |
| * @param bytesPerSync size in bytes |
| * @return the instance of the current object. |
| */ |
| T setBytesPerSync(long bytesPerSync); |
| |
| /** |
| * 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 |
| */ |
| long bytesPerSync(); |
| |
| /** |
| * Same as {@link #setBytesPerSync(long)} , but applies to WAL files |
| * |
| * Default: 0, turned off |
| * |
| * @param walBytesPerSync size in bytes |
| * @return the instance of the current object. |
| */ |
| T setWalBytesPerSync(long walBytesPerSync); |
| |
| /** |
| * Same as {@link #bytesPerSync()} , but applies to WAL files |
| * |
| * Default: 0, turned off |
| * |
| * @return size in bytes |
| */ |
| long walBytesPerSync(); |
| |
| /** |
| * If true, then the status of the threads involved in this DB will |
| * be tracked and available via GetThreadList() API. |
| * |
| * Default: false |
| * |
| * @param enableThreadTracking true to enable tracking |
| * |
| * @return the reference to the current options. |
| */ |
| T setEnableThreadTracking(boolean enableThreadTracking); |
| |
| /** |
| * If true, then the status of the threads involved in this DB will |
| * be tracked and available via GetThreadList() API. |
| * |
| * Default: false |
| * |
| * @return true if tracking is enabled |
| */ |
| boolean enableThreadTracking(); |
| |
| /** |
| * The limited write rate to DB if |
| * {@link ColumnFamilyOptions#softPendingCompactionBytesLimit()} or |
| * {@link ColumnFamilyOptions#level0SlowdownWritesTrigger()} is triggered, |
| * or we are writing to the last mem table allowed and we allow more than 3 |
| * mem tables. It is calculated using size of user write requests before |
| * compression. RocksDB may decide to slow down more if the compaction still |
| * gets behind further. |
| * |
| * Unit: bytes per second. |
| * |
| * Default: 16MB/s |
| * |
| * @param delayedWriteRate the rate in bytes per second |
| * |
| * @return the reference to the current options. |
| */ |
| T setDelayedWriteRate(long delayedWriteRate); |
| |
| /** |
| * The limited write rate to DB if |
| * {@link ColumnFamilyOptions#softPendingCompactionBytesLimit()} or |
| * {@link ColumnFamilyOptions#level0SlowdownWritesTrigger()} is triggered, |
| * or we are writing to the last mem table allowed and we allow more than 3 |
| * mem tables. It is calculated using size of user write requests before |
| * compression. RocksDB may decide to slow down more if the compaction still |
| * gets behind further. |
| * |
| * Unit: bytes per second. |
| * |
| * Default: 16MB/s |
| * |
| * @return the rate in bytes per second |
| */ |
| long delayedWriteRate(); |
| |
| /** |
| * If true, allow multi-writers to update mem tables in parallel. |
| * Only some memtable factorys support concurrent writes; currently it |
| * is implemented only for SkipListFactory. Concurrent memtable writes |
| * are not compatible with inplace_update_support or filter_deletes. |
| * It is strongly recommended to set |
| * {@link #setEnableWriteThreadAdaptiveYield(boolean)} if you are going to use |
| * this feature. |
| * Default: false |
| * |
| * @param allowConcurrentMemtableWrite true to enable concurrent writes |
| * for the memtable |
| * |
| * @return the reference to the current options. |
| */ |
| T setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite); |
| |
| /** |
| * If true, allow multi-writers to update mem tables in parallel. |
| * Only some memtable factorys support concurrent writes; currently it |
| * is implemented only for SkipListFactory. Concurrent memtable writes |
| * are not compatible with inplace_update_support or filter_deletes. |
| * It is strongly recommended to set |
| * {@link #setEnableWriteThreadAdaptiveYield(boolean)} if you are going to use |
| * this feature. |
| * Default: false |
| * |
| * @return true if concurrent writes are enabled for the memtable |
| */ |
| boolean allowConcurrentMemtableWrite(); |
| |
| /** |
| * If true, threads synchronizing with the write batch group leader will |
| * wait for up to {@link #writeThreadMaxYieldUsec()} before blocking on a |
| * mutex. This can substantially improve throughput for concurrent workloads, |
| * regardless of whether {@link #allowConcurrentMemtableWrite()} is enabled. |
| * Default: false |
| * |
| * @param enableWriteThreadAdaptiveYield true to enable adaptive yield for the |
| * write threads |
| * |
| * @return the reference to the current options. |
| */ |
| T setEnableWriteThreadAdaptiveYield( |
| boolean enableWriteThreadAdaptiveYield); |
| |
| /** |
| * If true, threads synchronizing with the write batch group leader will |
| * wait for up to {@link #writeThreadMaxYieldUsec()} before blocking on a |
| * mutex. This can substantially improve throughput for concurrent workloads, |
| * regardless of whether {@link #allowConcurrentMemtableWrite()} is enabled. |
| * Default: false |
| * |
| * @return true if adaptive yield is enabled |
| * for the writing threads |
| */ |
| boolean enableWriteThreadAdaptiveYield(); |
| |
| /** |
| * The maximum number of microseconds that a write operation will use |
| * a yielding spin loop to coordinate with other write threads before |
| * blocking on a mutex. (Assuming {@link #writeThreadSlowYieldUsec()} is |
| * set properly) increasing this value is likely to increase RocksDB |
| * throughput at the expense of increased CPU usage. |
| * Default: 100 |
| * |
| * @param writeThreadMaxYieldUsec maximum number of microseconds |
| * |
| * @return the reference to the current options. |
| */ |
| T setWriteThreadMaxYieldUsec(long writeThreadMaxYieldUsec); |
| |
| /** |
| * The maximum number of microseconds that a write operation will use |
| * a yielding spin loop to coordinate with other write threads before |
| * blocking on a mutex. (Assuming {@link #writeThreadSlowYieldUsec()} is |
| * set properly) increasing this value is likely to increase RocksDB |
| * throughput at the expense of increased CPU usage. |
| * Default: 100 |
| * |
| * @return the maximum number of microseconds |
| */ |
| long writeThreadMaxYieldUsec(); |
| |
| /** |
| * The latency in microseconds after which a std::this_thread::yield |
| * call (sched_yield on Linux) is considered to be a signal that |
| * other processes or threads would like to use the current core. |
| * Increasing this makes writer threads more likely to take CPU |
| * by spinning, which will show up as an increase in the number of |
| * involuntary context switches. |
| * Default: 3 |
| * |
| * @param writeThreadSlowYieldUsec the latency in microseconds |
| * |
| * @return the reference to the current options. |
| */ |
| T setWriteThreadSlowYieldUsec(long writeThreadSlowYieldUsec); |
| |
| /** |
| * The latency in microseconds after which a std::this_thread::yield |
| * call (sched_yield on Linux) is considered to be a signal that |
| * other processes or threads would like to use the current core. |
| * Increasing this makes writer threads more likely to take CPU |
| * by spinning, which will show up as an increase in the number of |
| * involuntary context switches. |
| * Default: 3 |
| * |
| * @return writeThreadSlowYieldUsec the latency in microseconds |
| */ |
| long writeThreadSlowYieldUsec(); |
| |
| /** |
| * If true, then DB::Open() will not update the statistics used to optimize |
| * compaction decision by loading table properties from many files. |
| * Turning off this feature will improve DBOpen time especially in |
| * disk environment. |
| * |
| * Default: false |
| * |
| * @param skipStatsUpdateOnDbOpen true if updating stats will be skipped |
| * |
| * @return the reference to the current options. |
| */ |
| T setSkipStatsUpdateOnDbOpen(boolean skipStatsUpdateOnDbOpen); |
| |
| /** |
| * If true, then DB::Open() will not update the statistics used to optimize |
| * compaction decision by loading table properties from many files. |
| * Turning off this feature will improve DBOpen time especially in |
| * disk environment. |
| * |
| * Default: false |
| * |
| * @return true if updating stats will be skipped |
| */ |
| boolean skipStatsUpdateOnDbOpen(); |
| |
| /** |
| * Recovery mode to control the consistency while replaying WAL |
| * |
| * Default: {@link WALRecoveryMode#PointInTimeRecovery} |
| * |
| * @param walRecoveryMode The WAL recover mode |
| * |
| * @return the reference to the current options. |
| */ |
| T setWalRecoveryMode(WALRecoveryMode walRecoveryMode); |
| |
| /** |
| * Recovery mode to control the consistency while replaying WAL |
| * |
| * Default: {@link WALRecoveryMode#PointInTimeRecovery} |
| * |
| * @return The WAL recover mode |
| */ |
| WALRecoveryMode walRecoveryMode(); |
| |
| /** |
| * if set to false then recovery will fail when a prepared |
| * transaction is encountered in the WAL |
| * |
| * Default: false |
| * |
| * @param allow2pc true if two-phase-commit is enabled |
| * |
| * @return the reference to the current options. |
| */ |
| T setAllow2pc(boolean allow2pc); |
| |
| /** |
| * if set to false then recovery will fail when a prepared |
| * transaction is encountered in the WAL |
| * |
| * Default: false |
| * |
| * @return true if two-phase-commit is enabled |
| */ |
| boolean allow2pc(); |
| |
| /** |
| * A global cache for table-level rows. |
| * |
| * Default: null (disabled) |
| * |
| * @param rowCache The global row cache |
| * |
| * @return the reference to the current options. |
| */ |
| T setRowCache(final Cache rowCache); |
| |
| /** |
| * A global cache for table-level rows. |
| * |
| * Default: null (disabled) |
| * |
| * @return The global row cache |
| */ |
| Cache rowCache(); |
| |
| /** |
| * If true, then DB::Open / CreateColumnFamily / DropColumnFamily |
| * / SetOptions will fail if options file is not detected or properly |
| * persisted. |
| * |
| * DEFAULT: false |
| * |
| * @param failIfOptionsFileError true if we should fail if there is an error |
| * in the options file |
| * |
| * @return the reference to the current options. |
| */ |
| T setFailIfOptionsFileError(boolean failIfOptionsFileError); |
| |
| /** |
| * If true, then DB::Open / CreateColumnFamily / DropColumnFamily |
| * / SetOptions will fail if options file is not detected or properly |
| * persisted. |
| * |
| * DEFAULT: false |
| * |
| * @return true if we should fail if there is an error in the options file |
| */ |
| boolean failIfOptionsFileError(); |
| |
| /** |
| * If true, then print malloc stats together with rocksdb.stats |
| * when printing to LOG. |
| * |
| * DEFAULT: false |
| * |
| * @param dumpMallocStats true if malloc stats should be printed to LOG |
| * |
| * @return the reference to the current options. |
| */ |
| T setDumpMallocStats(boolean dumpMallocStats); |
| |
| /** |
| * If true, then print malloc stats together with rocksdb.stats |
| * when printing to LOG. |
| * |
| * DEFAULT: false |
| * |
| * @return true if malloc stats should be printed to LOG |
| */ |
| boolean dumpMallocStats(); |
| |
| /** |
| * By default RocksDB replay WAL logs and flush them on DB open, which may |
| * create very small SST files. If this option is enabled, RocksDB will try |
| * to avoid (but not guarantee not to) flush during recovery. Also, existing |
| * WAL logs will be kept, so that if crash happened before flush, we still |
| * have logs to recover from. |
| * |
| * DEFAULT: false |
| * |
| * @param avoidFlushDuringRecovery true to try to avoid (but not guarantee |
| * not to) flush during recovery |
| * |
| * @return the reference to the current options. |
| */ |
| T setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery); |
| |
| /** |
| * By default RocksDB replay WAL logs and flush them on DB open, which may |
| * create very small SST files. If this option is enabled, RocksDB will try |
| * to avoid (but not guarantee not to) flush during recovery. Also, existing |
| * WAL logs will be kept, so that if crash happened before flush, we still |
| * have logs to recover from. |
| * |
| * DEFAULT: false |
| * |
| * @return true to try to avoid (but not guarantee not to) flush during |
| * recovery |
| */ |
| boolean avoidFlushDuringRecovery(); |
| |
| /** |
| * By default RocksDB will flush all memtables on DB close if there are |
| * unpersisted data (i.e. with WAL disabled) The flush can be skip to speedup |
| * DB close. Unpersisted data WILL BE LOST. |
| * |
| * DEFAULT: false |
| * |
| * Dynamically changeable through |
| * {@link RocksDB#setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions)} |
| * API. |
| * |
| * @param avoidFlushDuringShutdown true if we should avoid flush during |
| * shutdown |
| * |
| * @return the reference to the current options. |
| */ |
| T setAvoidFlushDuringShutdown(boolean avoidFlushDuringShutdown); |
| |
| /** |
| * By default RocksDB will flush all memtables on DB close if there are |
| * unpersisted data (i.e. with WAL disabled) The flush can be skip to speedup |
| * DB close. Unpersisted data WILL BE LOST. |
| * |
| * DEFAULT: false |
| * |
| * Dynamically changeable through |
| * {@link RocksDB#setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions)} |
| * API. |
| * |
| * @return true if we should avoid flush during shutdown |
| */ |
| boolean avoidFlushDuringShutdown(); |
| } |