Options

java.lang.Object
- org.rocksdb.AbstractNativeReference
- - org.rocksdb.AbstractImmutableNativeReference
  - - org.rocksdb.RocksObject
    - - org.rocksdb.Options

所有已实现的接口:

java.lang.AutoCloseable, AdvancedColumnFamilyOptionsInterface<Options>, AdvancedMutableColumnFamilyOptionsInterface<Options>, ColumnFamilyOptionsInterface<Options>, DBOptionsInterface<Options>, MutableColumnFamilyOptionsInterface<Options>, MutableDBOptionsInterface<Options>
```
public class Options
extends RocksObject
implements DBOptionsInterface<Options>, MutableDBOptionsInterface<Options>, ColumnFamilyOptionsInterface<Options>, MutableColumnFamilyOptionsInterface<Options>
```
Options to control the behavior of a database. It will be used during the creation of a RocksDB (i.e., RocksDB.open()).
As a descendent of AbstractNativeReference, this class is AutoCloseable and will be automatically released if opened in the preamble of a try with resources block.

字段概要
- 从类继承的字段 org.rocksdb.RocksObject
  nativeHandle_
- 从类继承的字段 org.rocksdb.AbstractImmutableNativeReference
  owningHandle_
- 从接口继承的字段 org.rocksdb.ColumnFamilyOptionsInterface
  DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET

构造器概要

构造器
构造器和说明
`Options()` Construct options for opening a RocksDB.
`Options(DBOptions dbOptions, ColumnFamilyOptions columnFamilyOptions)` Construct options for opening a RocksDB.
`Options(Options other)` Copy constructor for ColumnFamilyOptions.

方法概要

所有方法静态方法实例方法具体方法已过时的方法
限定符和类型	方法和说明
`AccessHint`	`accessHintOnCompactionStart()` Specify the file access pattern once a compaction is started.
`boolean`	`adviseRandomOnOpen()` If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened.
`boolean`	`allow2pc()` if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
`boolean`	`allowConcurrentMemtableWrite()` If true, allow multi-writers to update mem tables in parallel.
`boolean`	`allowFAllocate()` Whether fallocate calls are allowed
`boolean`	`allowIngestBehind()` Returns true if ingest behind is allowed.
`boolean`	`allowMmapReads()` Allow the OS to mmap file for reading sst tables.
`boolean`	`allowMmapWrites()` Allow the OS to mmap file for writing.
`long`	`arenaBlockSize()` The size of one block in arena memory allocation.
`boolean`	`atomicFlush()` Determine if atomic flush of multiple column families is enabled.
`boolean`	`avoidFlushDuringRecovery()` By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files.
`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.
`boolean`	`avoidUnnecessaryBlockingIO()` If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it.
`boolean`	`bestEffortsRecovery()` By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST.
`long`	`bgerrorResumeRetryInterval()` If max_bgerror_resume_count is ≥ 2, db resume is called multiple times.
`long`	`blobCompactionReadaheadSize()` Get compaction readahead for blob files.
`CompressionType`	`blobCompressionType()` Get the compression algorithm in use for large values stored in blob files.
`long`	`blobFileSize()` The size limit for blob files.
`int`	`blobFileStartingLevel()` Get the starting LSM tree level to enable blob files.
`double`	`blobGarbageCollectionAgeCutoff()` Get cutoff in terms of blob file age for garbage collection.
`double`	`blobGarbageCollectionForceThreshold()` Get the current value for the `#blobGarbageCollectionForceThreshold`
`int`	`bloomLocality()` Control locality of bloom filter probes to improve cache miss rate.
`CompressionOptions`	`bottommostCompressionOptions()` Get the bottom most compression options.
`CompressionType`	`bottommostCompressionType()` Compression algorithm that will be used for the bottommost level that contain files.
`long`	`bytesPerSync()` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`java.util.List<DbPath>`	`cfPaths()`
`AbstractCompactionFilter<? extends AbstractSlice<?>>`	`compactionFilter()` Accessor for the CompactionFilter instance in use.
`AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>>`	`compactionFilterFactory()` Accessor for the CompactionFilterFactory instance in use.
`CompactionOptionsFIFO`	`compactionOptionsFIFO()` The options for FIFO compaction style
`CompactionOptionsUniversal`	`compactionOptionsUniversal()` The options needed to support Universal Style compactions
`CompactionPriority`	`compactionPriority()` Get the Compaction priority if level compaction is used for all levels
`long`	`compactionReadaheadSize()` If non-zero, we perform bigger reads when doing compaction.
`CompactionStyle`	`compactionStyle()` Compaction style for DB.
`ConcurrentTaskLimiter`	`compactionThreadLimiter()` Get compaction thread limiter
`CompressionOptions`	`compressionOptions()` Get the different options for compression algorithms
`java.util.List<CompressionType>`	`compressionPerLevel()` Return the currently set `CompressionType` per instances.
`CompressionType`	`compressionType()` Compress blocks using the specified compression algorithm.
`boolean`	`createIfMissing()` Return true if the create_if_missing flag is set to true.
`boolean`	`createMissingColumnFamilies()` Return true if the create_missing_column_families flag is set to true.
`java.lang.String`	`dbLogDir()` Returns the directory of info log.
`java.util.List<DbPath>`	`dbPaths()` A list of paths where SST files can be put into, with its target size.
`long`	`dbWriteBufferSize()` Amount of data to build up in memtables across all column families before writing to disk.
`long`	`delayedWriteRate()` The limited write rate to DB if `ColumnFamilyOptions.softPendingCompactionBytesLimit()` or `ColumnFamilyOptions.level0SlowdownWritesTrigger()` is triggered, or we are writing to the last mem table allowed and we allow more than 3 mem tables.
`long`	`deleteObsoleteFilesPeriodMicros()` The periodicity when obsolete files get deleted.
`boolean`	`disableAutoCompactions()` Disable automatic compactions.
`protected void`	`disposeInternal(long handle)`
`boolean`	`dumpMallocStats()` If true, then print malloc stats together with rocksdb.stats when printing to LOG.
`boolean`	`enableBlobFiles()` When set, large values (blobs) are written to separate blob files, and only pointers to them are stored in SST files.
`boolean`	`enableBlobGarbageCollection()` Query whether garbage collection of blobs is enabled.Blob GC is performed as part of compaction.
`boolean`	`enablePipelinedWrite()` Returns true if pipelined writes are enabled.
`boolean`	`enableThreadTracking()` If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API.
`boolean`	`enableWriteThreadAdaptiveYield()` If true, threads synchronizing with the write batch group leader will wait for up to `DBOptionsInterface.writeThreadMaxYieldUsec()` before blocking on a mutex.
`boolean`	`errorIfExists()` If true, an error will be thrown during RocksDB.open() if the database already exists.
`double`	`experimentalMempurgeThreshold()` Threshold used in the MemPurge (memtable garbage collection) feature.
`boolean`	`failIfOptionsFileError()` If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted.
`boolean`	`forceConsistencyChecks()` By default, RocksDB runs consistency checks on the LSM every time the LSM changes (Flush, Compaction, AddFile).
`Env`	`getEnv()` Returns the set RocksEnv instance.
`static java.lang.String`	`getOptionStringFromProps(java.util.Properties properties)` Converts the input properties into a Options-style formatted string
`long`	`hardPendingCompactionBytesLimit()` All writes are stopped if estimated bytes needed to be compaction exceed this threshold.
`InfoLogLevel`	`infoLogLevel()` Returns currently set log level.
`long`	`inplaceUpdateNumLocks()` Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
`boolean`	`inplaceUpdateSupport()` Allows thread-safe inplace updates.
`boolean`	`isFdCloseOnExec()` Disable child process inherit open files.
`long`	`keepLogFileNum()` Returns the maximum number of info log files to be kept.
`int`	`level0FileNumCompactionTrigger()` Number of files to trigger level-0 compaction.
`int`	`level0SlowdownWritesTrigger()` Soft limit on number of level-0 files.
`int`	`level0StopWritesTrigger()` Maximum number of level-0 files.
`boolean`	`levelCompactionDynamicLevelBytes()` Return if `LevelCompactionDynamicLevelBytes` is enabled.
`int`	`levelZeroFileNumCompactionTrigger()` The number of files in level 0 to trigger compaction from level-0 to level-1.
`int`	`levelZeroSlowdownWritesTrigger()` Soft limit on the number of level-0 files.
`int`	`levelZeroStopWritesTrigger()` Maximum number of level-0 files.
`java.util.List<AbstractEventListener>`	`listeners()` Sets the `EventListener`s whose callback functions will be called when specific RocksDB event happens.
`long`	`logFileTimeToRoll()` Returns the time interval for the info log file to roll (in seconds).
`long`	`logReadaheadSize()` The number of bytes to prefetch when reading the log.
`long`	`manifestPreallocationSize()` Number of bytes to preallocate (via fallocate) the manifest files.
`boolean`	`manualWalFlush()` Returns true if automatic WAL flushing is disabled.
`int`	`maxBackgroundCompactions()` 已过时。
`int`	`maxBackgroundFlushes()` 已过时。
`int`	`maxBackgroundJobs()` Returns the maximum number of concurrent background jobs (both flushes and compactions combined).
`int`	`maxBgerrorResumeCount()` It defines how many times db resume is called by a separate thread when background retryable IO Error happens.
`long`	`maxBytesForLevelBase()` The upper-bound of the total size of level-1 files in bytes.
`double`	`maxBytesForLevelMultiplier()` The ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
`int[]`	`maxBytesForLevelMultiplierAdditional()` Different max-size multipliers for different levels.
`long`	`maxCompactionBytes()` Control maximum size of each compaction (not guaranteed)
`int`	`maxFileOpeningThreads()` If `MutableDBOptionsInterface.maxOpenFiles()` is -1, DB will open all files on DB::Open().
`long`	`maxLogFileSize()` Returns the maximum size of a info log file.
`long`	`maxManifestFileSize()` Manifest file is rolled over on reaching this limit.
`int`	`maxOpenFiles()` Number of open files that can be used by the DB.
`long`	`maxSequentialSkipInIterations()` An iteration->Next() sequentially skips over keys with the same user-key unless this option is set.
`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.
`long`	`maxSuccessiveMerges()` Maximum number of successive merge operations on a key in the memtable.
`long`	`maxTableFilesSizeFIFO()` FIFO compaction option.
`long`	`maxTotalWalSize()` Returns the max total write-ahead log size.
`long`	`maxWriteBatchGroupSizeBytes()` The maximum limit of number of bytes that are written in a single batch of WAL or memtable write.
`int`	`maxWriteBufferNumber()` Returns maximum number of write buffers.
`int`	`maxWriteBufferNumberToMaintain()` The total maximum number of write buffers to maintain in memory including copies of buffers that have already been flushed.
`MemTableConfig`	`memTableConfig()` Get the config for mem-table.
`java.lang.String`	`memTableFactoryName()` Returns the name of the current mem table representation.
`long`	`memtableHugePageSize()` Page size for huge page TLB for bloom in memtable.
`double`	`memtablePrefixBloomSizeRatio()` if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio.
`boolean`	`memtableWholeKeyFiltering()` Returns whether whole key bloom filter is enabled in memtable
`long`	`minBlobSize()` Get the size of the smallest value to be stored separately in a blob file.
`int`	`minWriteBufferNumberToMerge()` The minimum number of write buffers that will be merged together before writing to storage.
`int`	`numLevels()` If level-styled compaction is used, then this number determines the total number of levels.
`Options`	`oldDefaults(int majorVersion, int minorVersion)` The function recovers options to a previous version.
`boolean`	`optimizeFiltersForHits()` Returns the current state of the `optimize_filters_for_hits` setting.
`Options`	`optimizeForPointLookup(long blockCacheSizeMb)` Use this if you don't need to keep the data sorted, i.e. you'll never use an iterator, only Put() and Get() API calls
`Options`	`optimizeForSmallDb()` Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
`Options`	`optimizeForSmallDb(Cache cache)` Some functions that make it easier to optimize RocksDB Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
`Options`	`optimizeLevelStyleCompaction()` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`Options`	`optimizeLevelStyleCompaction(long memtableMemoryBudget)` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`Options`	`optimizeUniversalStyleCompaction()` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`Options`	`optimizeUniversalStyleCompaction(long memtableMemoryBudget)` Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions.
`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.
`boolean`	`paranoidFileChecks()` After writing every SST file, reopen it and read all the keys.
`long`	`periodicCompactionSeconds()` Get the periodicCompactionSeconds.
`boolean`	`persistStatsToDisk()` If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct.
`Options`	`prepareForBulkLoad()` Set appropriate parameters for bulk loading.
`PrepopulateBlobCache`	`prepopulateBlobCache()` Get the prepopulate blob cache option.
`long`	`randomAccessMaxBufferSize()` This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode.
`long`	`recycleLogFileNum()` Recycle log files.
`boolean`	`reportBgIoStats()` Determine whether IO stats in compactions and flushes are being measured
`Cache`	`rowCache()` A global cache for table-level rows.
`Options`	`setAccessHintOnCompactionStart(AccessHint accessHint)` Specify the file access pattern once a compaction is started.
`Options`	`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.
`Options`	`setAllow2pc(boolean allow2pc)` if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
`Options`	`setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)` If true, allow multi-writers to update mem tables in parallel.
`Options`	`setAllowFAllocate(boolean allowFAllocate)` Whether fallocate calls are allowed
`Options`	`setAllowIngestBehind(boolean allowIngestBehind)` Set this option to true during creation of database if you want to be able to ingest behind (call IngestExternalFile() skipping keys that already exist, rather than overwriting matching keys).
`Options`	`setAllowMmapReads(boolean allowMmapReads)` Allow the OS to mmap file for reading sst tables.
`Options`	`setAllowMmapWrites(boolean allowMmapWrites)` Allow the OS to mmap file for writing.
`Options`	`setArenaBlockSize(long arenaBlockSize)` The size of one block in arena memory allocation.
`Options`	`setAtomicFlush(boolean atomicFlush)` If true, RocksDB supports flushing multiple column families and committing their results atomically to MANIFEST.
`Options`	`setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery)` By default RocksDB replay WAL logs and flush them on DB open, which may create very small SST files.
`Options`	`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.
`Options`	`setAvoidUnnecessaryBlockingIO(boolean avoidUnnecessaryBlockingIO)` If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it.
`Options`	`setBestEffortsRecovery(boolean bestEffortsRecovery)` By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST.
`Options`	`setBgerrorResumeRetryInterval(long bgerrorResumeRetryInterval)` If max_bgerror_resume_count is ≥ 2, db resume is called multiple times.
`Options`	`setBlobCompactionReadaheadSize(long blobCompactionReadaheadSize)` Set compaction readahead for blob files.
`Options`	`setBlobCompressionType(CompressionType compressionType)` Set the compression algorithm to use for large values stored in blob files.
`Options`	`setBlobFileSize(long blobFileSize)` Set the size limit for blob files.
`Options`	`setBlobFileStartingLevel(int blobFileStartingLevel)` Set a certain LSM tree level to enable blob files.
`Options`	`setBlobGarbageCollectionAgeCutoff(double blobGarbageCollectionAgeCutoff)` Set cutoff in terms of blob file age for garbage collection.
`Options`	`setBlobGarbageCollectionForceThreshold(double blobGarbageCollectionForceThreshold)` If the ratio of garbage in the oldest blob files exceeds this threshold, targeted compactions are scheduled in order to force garbage collecting the blob files in question, assuming they are all eligible based on the value of `AdvancedMutableColumnFamilyOptionsInterface.blobGarbageCollectionAgeCutoff()` above.
`Options`	`setBloomLocality(int bloomLocality)` Control locality of bloom filter probes to improve cache miss rate.
`Options`	`setBottommostCompressionOptions(CompressionOptions bottommostCompressionOptions)` Set the options for compression algorithms used by `ColumnFamilyOptionsInterface.bottommostCompressionType()` if it is enabled.
`Options`	`setBottommostCompressionType(CompressionType bottommostCompressionType)` Compression algorithm that will be used for the bottommost level that contain files.
`Options`	`setBytesPerSync(long bytesPerSync)` Allows OS to incrementally sync files to disk while they are being written, asynchronously, in the background.
`Options`	`setCfPaths(java.util.Collection<DbPath> cfPaths)` A list of paths where SST files for this column family can be put into, with its target size.
`Options`	`setCompactionFilter(AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter)` A single CompactionFilter instance to call into during compaction.
`Options`	`setCompactionFilterFactory(AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> compactionFilterFactory)` This is a factory that provides `AbstractCompactionFilter` objects which allow an application to modify/delete a key-value during background compaction.
`Options`	`setCompactionOptionsFIFO(CompactionOptionsFIFO compactionOptionsFIFO)` The options for FIFO compaction style
`Options`	`setCompactionOptionsUniversal(CompactionOptionsUniversal compactionOptionsUniversal)` Set the options needed to support Universal Style compactions
`Options`	`setCompactionPriority(CompactionPriority compactionPriority)` If level `AdvancedColumnFamilyOptionsInterface.compactionStyle()` == `CompactionStyle.LEVEL`, for each level, which files are prioritized to be picked to compact.
`Options`	`setCompactionReadaheadSize(long compactionReadaheadSize)` If non-zero, we perform bigger reads when doing compaction.
`Options`	`setCompactionStyle(CompactionStyle compactionStyle)` Set compaction style for DB.
`Options`	`setCompactionThreadLimiter(ConcurrentTaskLimiter compactionThreadLimiter)` Compaction concurrent thread limiter for the column family.
`Options`	`setComparator(AbstractComparator comparator)` Use the specified comparator for key ordering.
`Options`	`setComparator(BuiltinComparator builtinComparator)` Set `BuiltinComparator` to be used with RocksDB.
`Options`	`setCompressionOptions(CompressionOptions compressionOptions)` Set the different options for compression algorithms
`Options`	`setCompressionPerLevel(java.util.List<CompressionType> compressionLevels)` Different levels can have different compression policies.
`Options`	`setCompressionType(CompressionType compressionType)` Compress blocks using the specified compression algorithm.
`Options`	`setCreateIfMissing(boolean flag)` If this value is set to true, then the database will be created if it is missing during `RocksDB.open()`.
`Options`	`setCreateMissingColumnFamilies(boolean flag)` If true, missing column families will be automatically created Default: false
`Options`	`setDbLogDir(java.lang.String dbLogDir)` This specifies the info LOG dir.
`Options`	`setDbPaths(java.util.Collection<DbPath> dbPaths)` A list of paths where SST files can be put into, with its target size.
`Options`	`setDbWriteBufferSize(long dbWriteBufferSize)` Amount of data to build up in memtables across all column families before writing to disk.
`Options`	`setDelayedWriteRate(long delayedWriteRate)` The limited write rate to DB if `ColumnFamilyOptions.softPendingCompactionBytesLimit()` or `ColumnFamilyOptions.level0SlowdownWritesTrigger()` is triggered, or we are writing to the last mem table allowed and we allow more than 3 mem tables.
`Options`	`setDeleteObsoleteFilesPeriodMicros(long micros)` The periodicity when obsolete files get deleted.
`Options`	`setDisableAutoCompactions(boolean disableAutoCompactions)` Disable automatic compactions.
`Options`	`setDumpMallocStats(boolean dumpMallocStats)` If true, then print malloc stats together with rocksdb.stats when printing to LOG.
`Options`	`setEnableBlobFiles(boolean enableBlobFiles)` When set, large values (blobs) are written to separate blob files, and only pointers to them are stored in SST files.
`Options`	`setEnableBlobGarbageCollection(boolean enableBlobGarbageCollection)` Enable/disable garbage collection of blobs.
`Options`	`setEnablePipelinedWrite(boolean enablePipelinedWrite)` By default, a single write thread queue is maintained.
`Options`	`setEnableThreadTracking(boolean enableThreadTracking)` If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API.
`Options`	`setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)` If true, threads synchronizing with the write batch group leader will wait for up to `DBOptionsInterface.writeThreadMaxYieldUsec()` before blocking on a mutex.
`Options`	`setEnv(Env env)` Use the specified object to interact with the environment, e.g. to read/write files, schedule background work, etc.
`Options`	`setErrorIfExists(boolean errorIfExists)` If true, an error will be thrown during RocksDB.open() if the database already exists.
`Options`	`setExperimentalMempurgeThreshold(double experimentalMempurgeThreshold)` Threshold used in the MemPurge (memtable garbage collection) feature.
`Options`	`setFailIfOptionsFileError(boolean failIfOptionsFileError)` If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted.
`Options`	`setForceConsistencyChecks(boolean forceConsistencyChecks)` By default, RocksDB runs consistency checks on the LSM every time the LSM changes (Flush, Compaction, AddFile).
`Options`	`setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit)` All writes are stopped if estimated bytes needed to be compaction exceed this threshold.
`Options`	`setIncreaseParallelism(int totalThreads)` By default, RocksDB uses only one background thread for flush and compaction.
`Options`	`setInfoLogLevel(InfoLogLevel infoLogLevel)` Sets the RocksDB log level.
`Options`	`setInplaceUpdateNumLocks(long inplaceUpdateNumLocks)` Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
`Options`	`setInplaceUpdateSupport(boolean inplaceUpdateSupport)` Allows thread-safe inplace updates.
`Options`	`setIsFdCloseOnExec(boolean isFdCloseOnExec)` Disable child process inherit open files.
`Options`	`setKeepLogFileNum(long keepLogFileNum)` Specifies the maximum number of info log files to be kept.
`Options`	`setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger)` Number of files to trigger level-0 compaction.
`Options`	`setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger)` Soft limit on number of level-0 files.
`Options`	`setLevel0StopWritesTrigger(int level0StopWritesTrigger)` Maximum number of level-0 files.
`Options`	`setLevelCompactionDynamicLevelBytes(boolean enableLevelCompactionDynamicLevelBytes)` If `true`, RocksDB will pick target size of each level dynamically.
`Options`	`setLevelZeroFileNumCompactionTrigger(int numFiles)` Number of files to trigger level-0 compaction.
`Options`	`setLevelZeroSlowdownWritesTrigger(int numFiles)` Soft limit on number of level-0 files.
`Options`	`setLevelZeroStopWritesTrigger(int numFiles)` Maximum number of level-0 files.
`Options`	`setListeners(java.util.List<AbstractEventListener> listeners)` Sets the `EventListener`s whose callback functions will be called when specific RocksDB event happens.
`Options`	`setLogFileTimeToRoll(long logFileTimeToRoll)` Specifies the time interval for the info log file to roll (in seconds).
`Options`	`setLogger(Logger logger)` 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.
`Options`	`setLogReadaheadSize(long logReadaheadSize)` The number of bytes to prefetch when reading the log.
`Options`	`setManifestPreallocationSize(long size)` Number of bytes to preallocate (via fallocate) the manifest files.
`Options`	`setManualWalFlush(boolean manualWalFlush)` If true WAL is not flushed automatically after each write.
`Options`	`setMaxBackgroundCompactions(int maxBackgroundCompactions)` 已过时。
`Options`	`setMaxBackgroundFlushes(int maxBackgroundFlushes)` 已过时。
`Options`	`setMaxBackgroundJobs(int maxBackgroundJobs)` Specifies the maximum number of concurrent background jobs (both flushes and compactions combined).
`Options`	`setMaxBgErrorResumeCount(int maxBgerrorResumeCount)` It defines how many times db resume is called by a separate thread when background retryable IO Error happens.
`Options`	`setMaxBytesForLevelBase(long maxBytesForLevelBase)` The upper-bound of the total size of level-1 files in bytes.
`Options`	`setMaxBytesForLevelMultiplier(double multiplier)` The ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
`Options`	`setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional)` Different max-size multipliers for different levels.
`Options`	`setMaxCompactionBytes(long maxCompactionBytes)` Maximum size of each compaction (not guarantee)
`Options`	`setMaxFileOpeningThreads(int maxFileOpeningThreads)` If `MutableDBOptionsInterface.maxOpenFiles()` is -1, DB will open all files on DB::Open().
`Options`	`setMaxLogFileSize(long maxLogFileSize)` Specifies the maximum size of a info log file.
`Options`	`setMaxManifestFileSize(long maxManifestFileSize)` Manifest file is rolled over on reaching this limit.
`Options`	`setMaxOpenFiles(int maxOpenFiles)` Number of open files that can be used by the DB.
`Options`	`setMaxSequentialSkipInIterations(long maxSequentialSkipInIterations)` An iteration->Next() sequentially skips over keys with the same user-key unless this option is set.
`Options`	`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.
`Options`	`setMaxSuccessiveMerges(long maxSuccessiveMerges)` Maximum number of successive merge operations on a key in the memtable.
`Options`	`setMaxTableFilesSizeFIFO(long maxTableFilesSize)` FIFO compaction option.
`Options`	`setMaxTotalWalSize(long maxTotalWalSize)` Set the max total write-ahead log size.
`Options`	`setMaxWriteBatchGroupSizeBytes(long maxWriteBatchGroupSizeBytes)` The maximum limit of number of bytes that are written in a single batch of WAL or memtable write.
`Options`	`setMaxWriteBufferNumber(int maxWriteBufferNumber)` The maximum number of write buffers that are built up in memory.
`Options`	`setMaxWriteBufferNumberToMaintain(int maxWriteBufferNumberToMaintain)` The total maximum number of write buffers to maintain in memory including copies of buffers that have already been flushed.
`Options`	`setMemTableConfig(MemTableConfig config)` Set the config for mem-table.
`Options`	`setMemtableHugePageSize(long memtableHugePageSize)` Page size for huge page TLB for bloom in memtable.
`Options`	`setMemtablePrefixBloomSizeRatio(double memtablePrefixBloomSizeRatio)` if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio.
`Options`	`setMemtableWholeKeyFiltering(boolean memtableWholeKeyFiltering)` Enable whole key bloom filter in memtable.
`Options`	`setMergeOperator(MergeOperator mergeOperator)` Set the merge operator to be used for merging two different key/value pairs that share the same key.
`Options`	`setMergeOperatorName(java.lang.String name)` Set the merge operator to be used for merging two merge operands of the same key.
`Options`	`setMinBlobSize(long minBlobSize)` Set the size of the smallest value to be stored separately in a blob file.
`Options`	`setMinWriteBufferNumberToMerge(int minWriteBufferNumberToMerge)` The minimum number of write buffers that will be merged together before writing to storage.
`Options`	`setNumLevels(int numLevels)` Set the number of levels for this database If level-styled compaction is used, then this number determines the total number of levels.
`Options`	`setOptimizeFiltersForHits(boolean optimizeFiltersForHits)` This flag specifies that the implementation should optimize the filters mainly for cases where keys are found rather than also optimize for keys missed.
`Options`	`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.
`Options`	`setParanoidFileChecks(boolean paranoidFileChecks)` After writing every SST file, reopen it and read all the keys.
`Options`	`setPeriodicCompactionSeconds(long periodicCompactionSeconds)` Files older than this value will be picked up for compaction, and re-written to the same level as they were before.
`Options`	`setPersistStatsToDisk(boolean persistStatsToDisk)` If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct.
`Options`	`setPrepopulateBlobCache(PrepopulateBlobCache prepopulateBlobCache)` Set a certain prepopulate blob cache option.
`Options`	`setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize)` This is a maximum buffer size that is used by WinMmapReadableFile in unbuffered disk I/O mode.
`Options`	`setRateLimiter(RateLimiter rateLimiter)` Use to control write rate of flush and compaction.
`Options`	`setRecycleLogFileNum(long recycleLogFileNum)` Recycle log files.
`Options`	`setReportBgIoStats(boolean reportBgIoStats)` Measure IO stats in compactions and flushes, if true.
`Options`	`setRowCache(Cache rowCache)` A global cache for table-level rows.
`Options`	`setSkipCheckingSstFileSizesOnDbOpen(boolean skipCheckingSstFileSizesOnDbOpen)` If true, then `RocksDB.open(String)` will not fetch and check sizes of all sst files.
`Options`	`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.
`Options`	`setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit)` All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold.
`Options`	`setSstFileManager(SstFileManager sstFileManager)` Use to track SST files and control their file deletion rate.
`Options`	`setSstPartitionerFactory(SstPartitionerFactory sstPartitionerFactory)` If non-nullptr, use the specified factory for a function to determine the partitioning of sst files.
`Options`	`setStatistics(Statistics statistics)` Sets the statistics object which collects metrics about database operations.
`Options`	`setStatsDumpPeriodSec(int statsDumpPeriodSec)` if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
`Options`	`setStatsHistoryBufferSize(long statsHistoryBufferSize)` If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at `statsHistoryBufferSize` Default: 1MB
`Options`	`setStatsPersistPeriodSec(int statsPersistPeriodSec)` If not zero, dump rocksdb.stats to RocksDB every `statsPersistPeriodSec` Default: 600
`Options`	`setStrictBytesPerSync(boolean strictBytesPerSync)` When true, guarantees WAL files have at most `MutableDBOptionsInterface.walBytesPerSync()` bytes submitted for writeback at any given time, and SST files have at most `MutableDBOptionsInterface.bytesPerSync()` bytes pending writeback at any given time.
`Options`	`setTableCacheNumshardbits(int tableCacheNumshardbits)` Number of shards used for table cache.
`Options`	`setTableFormatConfig(TableFormatConfig config)` Set the config for table format.
`Options`	`setTargetFileSizeBase(long targetFileSizeBase)` The target file size for compaction.
`Options`	`setTargetFileSizeMultiplier(int multiplier)` targetFileSizeMultiplier defines the size ratio between a level-L file and level-(L+1) file.
`Options`	`setTtl(long ttl)` Non-bottom-level files older than TTL will go through the compaction process.
`Options`	`setTwoWriteQueues(boolean twoWriteQueues)` If enabled it uses two queues for writes, one for the ones with disable_memtable and one for the ones that also write to memtable.
`Options`	`setUnorderedWrite(boolean unorderedWrite)` Setting `DBOptionsInterface.unorderedWrite()` to true trades higher write throughput with relaxing the immutability guarantee of snapshots.
`Options`	`setUseAdaptiveMutex(boolean useAdaptiveMutex)` Use adaptive mutex, which spins in the user space before resorting to kernel.
`Options`	`setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction)` Enable the OS to use direct reads and writes in flush and compaction Default: false
`Options`	`setUseDirectReads(boolean useDirectReads)` Enable the OS to use direct I/O for reading sst tables.
`Options`	`setUseFsync(boolean useFsync)` If true, then every store to stable storage will issue a fsync.
`Options`	`setWalBytesPerSync(long walBytesPerSync)` Same as `MutableDBOptionsInterface.setBytesPerSync(long)` , but applies to WAL files Default: 0, turned off
`Options`	`setWalDir(java.lang.String walDir)` This specifies the absolute dir path for write-ahead logs (WAL).
`Options`	`setWalFilter(AbstractWalFilter walFilter)` A filter object supplied to be invoked while processing write-ahead-logs (WALs) during recovery.
`Options`	`setWalRecoveryMode(WALRecoveryMode walRecoveryMode)` Recovery mode to control the consistency while replaying WAL Default: `WALRecoveryMode.PointInTimeRecovery`
`Options`	`setWalSizeLimitMB(long sizeLimitMB)` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`Options`	`setWalTtlSeconds(long walTtlSeconds)` `DBOptionsInterface.walTtlSeconds()` and `DBOptionsInterface.walSizeLimitMB()` affect how archived logs will be deleted.
`Options`	`setWritableFileMaxBufferSize(long writableFileMaxBufferSize)` This is the maximum buffer size that is used by WritableFileWriter.
`Options`	`setWriteBufferManager(WriteBufferManager writeBufferManager)` Use passed `WriteBufferManager` to control memory usage across multiple column families and/or DB instances.
`Options`	`setWriteBufferSize(long writeBufferSize)` Amount of data to build up in memory (backed by an unsorted log on disk) before converting to a sorted on-disk file.
`Options`	`setWriteDbidToManifest(boolean writeDbidToManifest)` Historically DB ID has always been stored in Identity File in DB folder.
`Options`	`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.
`Options`	`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.
`boolean`	`skipCheckingSstFileSizesOnDbOpen()` If true, then `RocksDB.open(String)` will not fetch and check sizes of all sst files.
`boolean`	`skipStatsUpdateOnDbOpen()` If true, then DB::Open() will not update the statistics used to optimize compaction decision by loading table properties from many files.
`long`	`softPendingCompactionBytesLimit()` All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold.
`SstPartitionerFactory`	`sstPartitionerFactory()` Get SST partitioner factory
`Statistics`	`statistics()` Returns statistics object.
`int`	`statsDumpPeriodSec()` If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
`long`	`statsHistoryBufferSize()` If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at `statsHistoryBufferSize`
`int`	`statsPersistPeriodSec()` If not zero, dump rocksdb.stats to RocksDB every `statsPersistPeriodSec`
`boolean`	`strictBytesPerSync()` Return the strict byte limit per sync.
`int`	`tableCacheNumshardbits()` Number of shards used for table cache.
`java.lang.String`	`tableFactoryName()`
`TableFormatConfig`	`tableFormatConfig()` Get the config for table format.
`long`	`targetFileSizeBase()` The target file size for compaction.
`int`	`targetFileSizeMultiplier()` targetFileSizeMultiplier defines the size ratio between a level-(L+1) file and level-L file.
`long`	`ttl()` Get the TTL for Non-bottom-level files that will go through the compaction process.
`boolean`	`twoWriteQueues()` Returns true if two write queues are enabled.
`boolean`	`unorderedWrite()` Returns true if unordered write are enabled.
`boolean`	`useAdaptiveMutex()` Use adaptive mutex, which spins in the user space before resorting to kernel.
`Options`	`useCappedPrefixExtractor(int n)` Same as fixed length prefix extractor, except that when slice is shorter than the fixed length, it will use the full key.
`boolean`	`useDirectIoForFlushAndCompaction()` Enable the OS to use direct reads and writes in flush and compaction
`boolean`	`useDirectReads()` Enable the OS to use direct I/O for reading sst tables.
`Options`	`useFixedLengthPrefixExtractor(int n)` This prefix-extractor uses the first n bytes of a key as its prefix.
`boolean`	`useFsync()` If true, then every store to stable storage will issue a fsync.
`long`	`walBytesPerSync()` Same as `MutableDBOptionsInterface.bytesPerSync()` , but applies to WAL files Default: 0, turned off
`java.lang.String`	`walDir()` Returns the path to the write-ahead-logs (WAL) directory.
`WalFilter`	`walFilter()` Get's the filter for processing WALs during recovery.
`WALRecoveryMode`	`walRecoveryMode()` Recovery mode to control the consistency while replaying WAL Default: `WALRecoveryMode.PointInTimeRecovery`
`long`	`walSizeLimitMB()` `DBOptionsInterface.walTtlSeconds()` and `#walSizeLimitMB()` affect how archived logs will be deleted.
`long`	`walTtlSeconds()` WalTtlSeconds() and walSizeLimitMB() affect how archived logs will be deleted.
`long`	`writableFileMaxBufferSize()` This is the maximum buffer size that is used by WritableFileWriter.
`WriteBufferManager`	`writeBufferManager()` Reference to `WriteBufferManager` used by it.
`long`	`writeBufferSize()` Return size of write buffer size.
`boolean`	`writeDbidToManifest()` Historically DB ID has always been stored in Identity File in DB folder.
`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.
`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.

从类继承的方法 org.rocksdb.RocksObject
disposeInternal, getNativeHandle

从类继承的方法 org.rocksdb.AbstractImmutableNativeReference
close, disOwnNativeHandle, isOwningHandle

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - Options
```
public Options()
```
    Construct options for opening a RocksDB.
    This constructor will create (by allocating a block of memory) an rocksdb::Options in the c++ side.
  - Options
```
public Options(DBOptions dbOptions,
               ColumnFamilyOptions columnFamilyOptions)
```
    Construct options for opening a RocksDB. Reusing database options and column family options.
    
    参数:
    
    dbOptions - DBOptions instance
    
    columnFamilyOptions - ColumnFamilyOptions instance
  - Options
```
public Options(Options other)
```
    Copy constructor for ColumnFamilyOptions.
    NOTE: This does a shallow copy, which means comparator, merge_operator and other pointers will be cloned!
    
    参数:
    
    other - The Options to copy.
- 方法详细资料
  - getOptionStringFromProps
```
public static java.lang.String getOptionStringFromProps(java.util.Properties properties)
```
    Converts the input properties into a Options-style formatted string
    
    参数:
    
    properties - The set of properties to convert
    
    返回:
    
    The Options-style representation of those properties.
  - setIncreaseParallelism
```
public Options setIncreaseParallelism(int totalThreads)
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    You almost definitely want to call this function if your system is bottlenecked by RocksDB.
    
    指定者:
    
    setIncreaseParallelism 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    totalThreads - The total number of threads to be used by RocksDB. A good value is the number of cores.
    
    返回:
    
    the instance of the current Options
  - setCreateIfMissing
```
public Options setCreateIfMissing(boolean flag)
```
    从接口复制的说明: DBOptionsInterface
    
    If this value is set to true, then the database will be created if it is missing during RocksDB.open(). Default: false
    
    指定者:
    
    setCreateIfMissing 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    flag - a flag indicating whether to create a database the specified database in RocksDB.open(org.rocksdb.Options, String) operation is missing.
    
    返回:
    
    the instance of the current Options
    
    另请参阅:
    
    RocksDB.open(org.rocksdb.Options, String)
  - setCreateMissingColumnFamilies
```
public Options setCreateMissingColumnFamilies(boolean flag)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, missing column families will be automatically created
    
    Default: false
    
    指定者:
    
    setCreateMissingColumnFamilies 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    flag - a flag indicating if missing column families shall be created automatically.
    
    返回:
    
    true if missing column families shall be created automatically on open.
  - setEnv
```
public Options setEnv(Env env)
```
    从接口复制的说明: DBOptionsInterface
    
    Use the specified object to interact with the environment, e.g. to read/write files, schedule background work, etc. Default: Env.getDefault()
    
    指定者:
    
    setEnv 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    env - Env instance.
    
    返回:
    
    the instance of the current Options.
  - getEnv
```
public Env getEnv()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns the set RocksEnv instance.
    
    指定者:
    
    getEnv 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    RocksEnv instance set in the options.
  - prepareForBulkLoad
```
public Options prepareForBulkLoad()
```
    Set appropriate parameters for bulk loading. The reason that this is a function that returns "this" instead of a constructor is to enable chaining of multiple similar calls in the future.
    
    All data will be in level 0 without any automatic compaction. It's recommended to manually call CompactRange(NULL, NULL) before reading from the database, because otherwise the read can be very slow.
    
    返回:
    
    the instance of the current Options.
  - createIfMissing
```
public boolean createIfMissing()
```
    从接口复制的说明: DBOptionsInterface
    
    Return true if the create_if_missing flag is set to true. If true, the database will be created if it is missing.
    
    指定者:
    
    createIfMissing 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if the createIfMissing option is set to true.
    
    另请参阅:
    
    DBOptionsInterface.setCreateIfMissing(boolean)
  - createMissingColumnFamilies
```
public boolean createMissingColumnFamilies()
```
    从接口复制的说明: DBOptionsInterface
    
    Return true if the create_missing_column_families flag is set to true. If true column families be created if missing.
    
    指定者:
    
    createMissingColumnFamilies 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if the createMissingColumnFamilies is set to true.
    
    另请参阅:
    
    DBOptionsInterface.setCreateMissingColumnFamilies(boolean)
  - oldDefaults
```
public Options oldDefaults(int majorVersion,
                           int minorVersion)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    The function recovers options to a previous version. Only 4.6 or later versions are supported.
    
    指定者:
    
    oldDefaults 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    majorVersion - The major version to recover default values of options
    
    minorVersion - The minor version to recover default values of options
    
    返回:
    
    the instance of the current object.
  - optimizeForSmallDb
```
public Options optimizeForSmallDb()
```
    从接口复制的说明: DBOptionsInterface
    
    Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
    
    指定者:
    
    optimizeForSmallDb 在接口中 ColumnFamilyOptionsInterface<Options>
    
    指定者:
    
    optimizeForSmallDb 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the instance of the current object.
  - optimizeForSmallDb
```
public Options optimizeForSmallDb(Cache cache)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Some functions that make it easier to optimize RocksDB Use this if your DB is very small (like under 1GB) and you don't want to spend lots of memory for memtables.
    
    指定者:
    
    optimizeForSmallDb 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    cache - An optional cache object is passed in to be used as the block cache
    
    返回:
    
    the instance of the current object.
  - optimizeForPointLookup
```
public Options optimizeForPointLookup(long blockCacheSizeMb)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Use this if you don't need to keep the data sorted, i.e. you'll never use an iterator, only Put() and Get() API calls
    
    指定者:
    
    optimizeForPointLookup 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    blockCacheSizeMb - Block cache size in MB
    
    返回:
    
    the instance of the current object.
  - optimizeLevelStyleCompaction
```
public Options optimizeLevelStyleCompaction()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for level style compaction.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    指定者:
    
    optimizeLevelStyleCompaction 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the instance of the current object.
  - optimizeLevelStyleCompaction
```
public Options optimizeLevelStyleCompaction(long memtableMemoryBudget)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for level style compaction.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    指定者:
    
    optimizeLevelStyleCompaction 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    memtableMemoryBudget - memory budget in bytes
    
    返回:
    
    the instance of the current object.
  - optimizeUniversalStyleCompaction
```
public Options optimizeUniversalStyleCompaction()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for universal style compaction.
    
    Universal style compaction is focused on reducing Write Amplification Factor for big data sets, but increases Space Amplification.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    指定者:
    
    optimizeUniversalStyleCompaction 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the instance of the current object.
  - optimizeUniversalStyleCompaction
```
public Options optimizeUniversalStyleCompaction(long memtableMemoryBudget)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Default values for some parameters in ColumnFamilyOptions are not optimized for heavy workloads and big datasets, which means you might observe write stalls under some conditions. As a starting point for tuning RocksDB options, use the following for universal style compaction.
    
    Universal style compaction is focused on reducing Write Amplification Factor for big data sets, but increases Space Amplification.
    
    Make sure to also call IncreaseParallelism(), which will provide the biggest performance gains.
    
    Note: we might use more memory than memtable_memory_budget during high write rate period
    
    指定者:
    
    optimizeUniversalStyleCompaction 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    memtableMemoryBudget - memory budget in bytes
    
    返回:
    
    the instance of the current object.
  - setComparator
```
public Options setComparator(BuiltinComparator builtinComparator)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set BuiltinComparator to be used with RocksDB.
    Note: Comparator can be set once upon database creation.
    Default: BytewiseComparator.
    
    指定者:
    
    setComparator 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    builtinComparator - a BuiltinComparator type.
    
    返回:
    
    the instance of the current object.
  - setComparator
```
public Options setComparator(AbstractComparator comparator)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Use the specified comparator for key ordering.
    Comparator should not be disposed before options instances using this comparator is disposed. If dispose() function is not called, then comparator object will be GC'd automatically.
    Comparator instance can be re-used in multiple options instances.
    
    指定者:
    
    setComparator 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    comparator - java instance.
    
    返回:
    
    the instance of the current object.
  - setMergeOperatorName
```
public Options setMergeOperatorName(java.lang.String name)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set the merge operator to be used for merging two merge operands of the same key. The merge function is invoked during compaction and at lookup time, if multiple key/value pairs belonging to the same key are found in the database.
    
    指定者:
    
    setMergeOperatorName 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    name - the name of the merge function, as defined by the MergeOperators factory (see utilities/MergeOperators.h) The merge function is specified by name and must be one of the standard merge operators provided by RocksDB. The available operators are "put", "uint64add", "stringappend" and "stringappendtest".
    
    返回:
    
    the instance of the current object.
  - setMergeOperator
```
public Options setMergeOperator(MergeOperator mergeOperator)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set the merge operator to be used for merging two different key/value pairs that share the same key. The merge function is invoked during compaction and at lookup time, if multiple key/value pairs belonging to the same key are found in the database.
    
    指定者:
    
    setMergeOperator 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    mergeOperator - MergeOperator instance.
    
    返回:
    
    the instance of the current object.
  - setCompactionFilter
```
public Options setCompactionFilter(AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    A single CompactionFilter instance to call into during compaction. Allows an application to modify/delete a key-value during background compaction.
    If the client requires a new compaction filter to be used for different compaction runs, it can specify call ColumnFamilyOptionsInterface.setCompactionFilterFactory(AbstractCompactionFilterFactory) instead.
    The client should specify only set one of the two. {#setCompactionFilter(AbstractCompactionFilter)} takes precedence over ColumnFamilyOptionsInterface.setCompactionFilterFactory(AbstractCompactionFilterFactory) if the client specifies both.
    If multithreaded compaction is being used, the supplied CompactionFilter instance may be used from different threads concurrently and so should be thread-safe.
    
    指定者:
    
    setCompactionFilter 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionFilter - AbstractCompactionFilter instance.
    
    返回:
    
    the instance of the current object.
  - compactionFilter
```
public AbstractCompactionFilter<? extends AbstractSlice<?>> compactionFilter()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Accessor for the CompactionFilter instance in use.
    
    指定者:
    
    compactionFilter 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    Reference to the CompactionFilter, or null if one hasn't been set.
  - setCompactionFilterFactory
```
public Options setCompactionFilterFactory(AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> compactionFilterFactory)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    This is a factory that provides AbstractCompactionFilter objects which allow an application to modify/delete a key-value during background compaction.
    A new filter will be created on each compaction run. If multithreaded compaction is being used, each created CompactionFilter will only be used from a single thread and so does not need to be thread-safe.
    
    指定者:
    
    setCompactionFilterFactory 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionFilterFactory - AbstractCompactionFilterFactory instance.
    
    返回:
    
    the instance of the current object.
  - compactionFilterFactory
```
public AbstractCompactionFilterFactory<? extends AbstractCompactionFilter<?>> compactionFilterFactory()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Accessor for the CompactionFilterFactory instance in use.
    
    指定者:
    
    compactionFilterFactory 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    Reference to the CompactionFilterFactory, or null if one hasn't been set.
  - setWriteBufferSize
```
public Options setWriteBufferSize(long writeBufferSize)
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Amount of data to build up in memory (backed by an unsorted log on disk) before converting to a sorted on-disk file.
    Larger values increase performance, especially during bulk loads. Up to max_write_buffer_number write buffers may be held in memory at the same time, so you may wish to adjust this parameter to control memory usage.
    Also, a larger write buffer will result in a longer recovery time the next time the database is opened.
    Default: 64MB
    
    指定者:
    
    setWriteBufferSize 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    writeBufferSize - the size of write buffer.
    
    返回:
    
    the instance of the current object.
  - writeBufferSize
```
public long writeBufferSize()
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Return size of write buffer size.
    
    指定者:
    
    writeBufferSize 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    size of write buffer.
    
    另请参阅:
    
    MutableColumnFamilyOptionsInterface.setWriteBufferSize(long)
  - setMaxWriteBufferNumber
```
public Options setMaxWriteBufferNumber(int maxWriteBufferNumber)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    The maximum number of write buffers that are built up in memory. The default is 2, so that when 1 write buffer is being flushed to storage, new writes can continue to the other write buffer. Default: 2
    
    指定者:
    
    setMaxWriteBufferNumber 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxWriteBufferNumber - maximum number of write buffers.
    
    返回:
    
    the instance of the current options.
  - maxWriteBufferNumber
```
public int maxWriteBufferNumber()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Returns maximum number of write buffers.
    
    指定者:
    
    maxWriteBufferNumber 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    maximum number of write buffers.
    
    另请参阅:
    
    AdvancedMutableColumnFamilyOptionsInterface.setMaxWriteBufferNumber(int)
  - errorIfExists
```
public boolean errorIfExists()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, an error will be thrown during RocksDB.open() if the database already exists.
    
    指定者:
    
    errorIfExists 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    if true, an error is raised when the specified database already exists before open.
  - setErrorIfExists
```
public Options setErrorIfExists(boolean errorIfExists)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, an error will be thrown during RocksDB.open() if the database already exists. Default: false
    
    指定者:
    
    setErrorIfExists 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    errorIfExists - if true, an exception will be thrown during RocksDB.open() if the database already exists.
    
    返回:
    
    the reference to the current option.
    
    另请参阅:
    
    RocksDB.open(org.rocksdb.Options, String)
  - paranoidChecks
```
public boolean paranoidChecks()
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    paranoidChecks 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    a boolean indicating whether paranoid-check is on.
  - setParanoidChecks
```
public Options setParanoidChecks(boolean paranoidChecks)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setParanoidChecks 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    paranoidChecks - a flag to indicate whether paranoid-check is on.
    
    返回:
    
    the reference to the current option.
  - maxOpenFiles
```
public int maxOpenFiles()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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: -1
    
    指定者:
    
    maxOpenFiles 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the maximum number of open files.
  - setMaxFileOpeningThreads
```
public Options setMaxFileOpeningThreads(int maxFileOpeningThreads)
```
    从接口复制的说明: DBOptionsInterface
    
    If MutableDBOptionsInterface.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
    
    指定者:
    
    setMaxFileOpeningThreads 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxFileOpeningThreads - the maximum number of threads to use to open files
    
    返回:
    
    the reference to the current options.
  - maxFileOpeningThreads
```
public int maxFileOpeningThreads()
```
    从接口复制的说明: DBOptionsInterface
    
    If MutableDBOptionsInterface.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
    
    指定者:
    
    maxFileOpeningThreads 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum number of threads to use to open files
  - setMaxTotalWalSize
```
public Options setMaxTotalWalSize(long maxTotalWalSize)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Set the max total write-ahead log 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
    
    The oldest WAL files are the ones that are causing all the space amplification.
    For example, with 15 column families, each with write_buffer_size = 128 MB max_write_buffer_number = 6 max_total_wal_size will be calculated to be [15 * 128MB * 6] * 4 = 45GB
    The RocksDB wiki has some discussion about how the WAL interacts with memtables and flushing of column families, at ...
    
    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] * 4
    
    This option takes effect only when there are more than one column family as otherwise the wal size is dictated by the write_buffer_size.
    
    Default: 0
    
    指定者:
    
    setMaxTotalWalSize 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    maxTotalWalSize - max total wal size.
    
    返回:
    
    the instance of the current object.
  - maxTotalWalSize
```
public long maxTotalWalSize()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Returns the max total write-ahead log 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.
    
    The oldest WAL files are the ones that are causing all the space amplification.
    For example, with 15 column families, each with write_buffer_size = 128 MB max_write_buffer_number = 6 max_total_wal_size will be calculated to be [15 * 128MB * 6] * 4 = 45GB
    The RocksDB wiki has some discussion about how the WAL interacts with memtables and flushing of column families, at ...
    
    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] * 4
    
    This option takes effect only when there are more than one column family as otherwise the wal size is dictated by the write_buffer_size.
    
    Default: 0
    
    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] * 4
    
    指定者:
    
    maxTotalWalSize 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    max total wal size
  - setMaxOpenFiles
```
public Options setMaxOpenFiles(int maxOpenFiles)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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: -1
    
    指定者:
    
    setMaxOpenFiles 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    maxOpenFiles - the maximum number of open files.
    
    返回:
    
    the instance of the current object.
  - useFsync
```
public boolean useFsync()
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    useFsync 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    boolean value indicating if fsync is used.
  - setUseFsync
```
public Options setUseFsync(boolean useFsync)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setUseFsync 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    useFsync - a boolean flag to specify whether to use fsync
    
    返回:
    
    the instance of the current object.
  - setDbPaths
```
public Options setDbPaths(java.util.Collection<DbPath> dbPaths)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setDbPaths 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    dbPaths - the paths and target sizes
    
    返回:
    
    the reference to the current options
  - dbPaths
```
public java.util.List<DbPath> dbPaths()
```
    从接口复制的说明: DBOptionsInterface
    
    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: Collections.emptyList()
    
    指定者:
    
    dbPaths 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    dbPaths the paths and target sizes
  - dbLogDir
```
public java.lang.String dbLogDir()
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    dbLogDir 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the path to the info log directory
  - setDbLogDir
```
public Options setDbLogDir(java.lang.String dbLogDir)
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    setDbLogDir 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    dbLogDir - the path to the info log directory
    
    返回:
    
    the instance of the current object.
  - walDir
```
public java.lang.String walDir()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    walDir 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the path to the write-ahead-logs (WAL) directory.
  - setWalDir
```
public Options setWalDir(java.lang.String walDir)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setWalDir 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    walDir - the path to the write-ahead-log directory.
    
    返回:
    
    the instance of the current object.
  - deleteObsoleteFilesPeriodMicros
```
public long deleteObsoleteFilesPeriodMicros()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    deleteObsoleteFilesPeriodMicros 在接口中 DBOptionsInterface<Options>
    
    指定者:
    
    deleteObsoleteFilesPeriodMicros 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the time interval in micros when obsolete files will be deleted.
  - setDeleteObsoleteFilesPeriodMicros
```
public Options setDeleteObsoleteFilesPeriodMicros(long micros)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setDeleteObsoleteFilesPeriodMicros 在接口中 DBOptionsInterface<Options>
    
    指定者:
    
    setDeleteObsoleteFilesPeriodMicros 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    micros - the time interval in micros
    
    返回:
    
    the instance of the current object.
  - maxBackgroundCompactions
```
@Deprecated
public int maxBackgroundCompactions()
```
    已过时。
    
    从接口复制的说明: MutableDBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes` (we replace -1 by 1 in case one option is unset).
    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
    
    指定者:
    
    maxBackgroundCompactions 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the maximum number of concurrent background compaction jobs.
    
    另请参阅:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority)
  - setStatistics
```
public Options setStatistics(Statistics statistics)
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    setStatistics 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    statistics - The statistics to set
    
    返回:
    
    the instance of the current object.
    
    另请参阅:
    
    RocksDB.open(org.rocksdb.Options, String)
  - statistics
```
public Statistics statistics()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns statistics object.
    
    指定者:
    
    statistics 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the instance of the statistics object or null if there is no statistics object.
    
    另请参阅:
    
    DBOptionsInterface.setStatistics(Statistics)
  - setMaxBackgroundCompactions
```
@Deprecated
public Options setMaxBackgroundCompactions(int maxBackgroundCompactions)
```
    已过时。
    
    从接口复制的说明: MutableDBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes` (we replace -1 by 1 in case one option is unset).
    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
    
    指定者:
    
    setMaxBackgroundCompactions 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    maxBackgroundCompactions - the maximum number of background compaction jobs.
    
    返回:
    
    the instance of the current object.
    
    另请参阅:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority), DBOptionsInterface.maxBackgroundFlushes()
  - setMaxSubcompactions
```
public Options setMaxSubcompactions(int maxSubcompactions)
```
    从接口复制的说明: DBOptionsInterface
    
    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)
    
    指定者:
    
    setMaxSubcompactions 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxSubcompactions - The maximum number of threads that will concurrently perform a compaction job
    
    返回:
    
    the instance of the current object.
  - maxSubcompactions
```
public int maxSubcompactions()
```
    从接口复制的说明: DBOptionsInterface
    
    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)
    
    指定者:
    
    maxSubcompactions 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    The maximum number of threads that will concurrently perform a compaction job
  - maxBackgroundFlushes
```
@Deprecated
public int maxBackgroundFlushes()
```
    已过时。
    
    从接口复制的说明: DBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes`. 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
    
    指定者:
    
    maxBackgroundFlushes 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum number of concurrent background flush jobs.
    
    另请参阅:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority)
  - setMaxBackgroundFlushes
```
@Deprecated
public Options setMaxBackgroundFlushes(int maxBackgroundFlushes)
```
    已过时。
    
    从接口复制的说明: DBOptionsInterface
    
    NOT SUPPORTED ANYMORE: RocksDB automatically decides this based on the value of max_background_jobs. For backwards compatibility we will set `max_background_jobs = max_background_compactions + max_background_flushes` in the case where user sets at least one of `max_background_compactions` or `max_background_flushes`. 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
    
    指定者:
    
    setMaxBackgroundFlushes 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxBackgroundFlushes - number of max concurrent flush jobs
    
    返回:
    
    the instance of the current object.
    
    另请参阅:
    
    Env.setBackgroundThreads(int), Env.setBackgroundThreads(int, Priority), MutableDBOptionsInterface.maxBackgroundCompactions()
  - maxBackgroundJobs
```
public int maxBackgroundJobs()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Returns the maximum number of concurrent background jobs (both flushes and compactions combined). Default: 2
    
    指定者:
    
    maxBackgroundJobs 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the maximum number of concurrent background jobs.
  - setMaxBackgroundJobs
```
public Options setMaxBackgroundJobs(int maxBackgroundJobs)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Specifies the maximum number of concurrent background jobs (both flushes and compactions combined). Default: 2
    
    指定者:
    
    setMaxBackgroundJobs 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    maxBackgroundJobs - number of max concurrent background jobs
    
    返回:
    
    the instance of the current object.
  - maxLogFileSize
```
public long maxLogFileSize()
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    maxLogFileSize 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum size of the info log file.
  - setMaxLogFileSize
```
public Options setMaxLogFileSize(long maxLogFileSize)
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    指定者:
    
    setMaxLogFileSize 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxLogFileSize - the maximum size of a info log file.
    
    返回:
    
    the instance of the current object.
  - logFileTimeToRoll
```
public long logFileTimeToRoll()
```
    从接口复制的说明: DBOptionsInterface
    
    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)
    
    指定者:
    
    logFileTimeToRoll 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the time interval in seconds.
  - setLogFileTimeToRoll
```
public Options setLogFileTimeToRoll(long logFileTimeToRoll)
```
    从接口复制的说明: DBOptionsInterface
    
    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)
    
    指定者:
    
    setLogFileTimeToRoll 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    logFileTimeToRoll - the time interval in seconds.
    
    返回:
    
    the instance of the current object.
  - keepLogFileNum
```
public long keepLogFileNum()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns the maximum number of info log files to be kept. Default: 1000
    
    指定者:
    
    keepLogFileNum 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum number of info log files to be kept.
  - setKeepLogFileNum
```
public Options setKeepLogFileNum(long keepLogFileNum)
```
    从接口复制的说明: DBOptionsInterface
    
    Specifies the maximum number of info log files to be kept. Default: 1000
    
    指定者:
    
    setKeepLogFileNum 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    keepLogFileNum - the maximum number of info log files to be kept.
    
    返回:
    
    the instance of the current object.
  - setRecycleLogFileNum
```
public Options setRecycleLogFileNum(long recycleLogFileNum)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setRecycleLogFileNum 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    recycleLogFileNum - the number of log files to keep for recycling
    
    返回:
    
    the reference to the current options
  - recycleLogFileNum
```
public long recycleLogFileNum()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    recycleLogFileNum 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the number of log files kept for recycling
  - maxManifestFileSize
```
public long maxManifestFileSize()
```
    从接口复制的说明: DBOptionsInterface
    
    Manifest file is rolled over on reaching this limit. The older manifest file be deleted. The default value is 1GB so that the manifest file can grow, but not reach the limit of storage capacity.
    
    指定者:
    
    maxManifestFileSize 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the size limit of a manifest file.
  - setMaxManifestFileSize
```
public Options setMaxManifestFileSize(long maxManifestFileSize)
```
    从接口复制的说明: DBOptionsInterface
    
    Manifest file is rolled over on reaching this limit. The older manifest file be deleted. The default value is 1GB so that the manifest file can grow, but not reach the limit of storage capacity.
    
    指定者:
    
    setMaxManifestFileSize 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxManifestFileSize - the size limit of a manifest file.
    
    返回:
    
    the instance of the current object.
  - setMaxTableFilesSizeFIFO
```
public Options setMaxTableFilesSizeFIFO(long maxTableFilesSize)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    FIFO compaction option. The oldest table file will be deleted once the sum of table files reaches this size. The default value is 1GB (1 * 1024 * 1024 * 1024).
    
    指定者:
    
    setMaxTableFilesSizeFIFO 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxTableFilesSize - the size limit of the total sum of table files.
    
    返回:
    
    the instance of the current object.
  - maxTableFilesSizeFIFO
```
public long maxTableFilesSizeFIFO()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    FIFO compaction option. The oldest table file will be deleted once the sum of table files reaches this size. The default value is 1GB (1 * 1024 * 1024 * 1024).
    
    指定者:
    
    maxTableFilesSizeFIFO 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the size limit of the total sum of table files.
  - tableCacheNumshardbits
```
public int tableCacheNumshardbits()
```
    从接口复制的说明: DBOptionsInterface
    
    Number of shards used for table cache.
    
    指定者:
    
    tableCacheNumshardbits 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the number of shards used for table cache.
  - setTableCacheNumshardbits
```
public Options setTableCacheNumshardbits(int tableCacheNumshardbits)
```
    从接口复制的说明: DBOptionsInterface
    
    Number of shards used for table cache.
    
    指定者:
    
    setTableCacheNumshardbits 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    tableCacheNumshardbits - the number of chards
    
    返回:
    
    the instance of the current object.
  - walTtlSeconds
```
public long walTtlSeconds()
```
    从接口复制的说明: DBOptionsInterface
    WalTtlSeconds() and walSizeLimitMB() 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_seconds / 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.
    指定者:
    
    walTtlSeconds 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the wal-ttl seconds
    
    另请参阅:
    
    DBOptionsInterface.walSizeLimitMB()
  - setWalTtlSeconds
```
public Options setWalTtlSeconds(long walTtlSeconds)
```
    从接口复制的说明: DBOptionsInterface
    DBOptionsInterface.walTtlSeconds() and DBOptionsInterface.walSizeLimitMB() 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_seconds / 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.
    指定者:
    
    setWalTtlSeconds 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    walTtlSeconds - the ttl seconds
    
    返回:
    
    the instance of the current object.
    
    另请参阅:
    
    DBOptionsInterface.setWalSizeLimitMB(long)
  - walSizeLimitMB
```
public long walSizeLimitMB()
```
    从接口复制的说明: DBOptionsInterface
    DBOptionsInterface.walTtlSeconds() and #walSizeLimitMB() 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_seconds i / 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.
    指定者:
    
    walSizeLimitMB 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    size limit in mega-bytes.
    
    另请参阅:
    
    DBOptionsInterface.walSizeLimitMB()
  - setMaxWriteBatchGroupSizeBytes
```
public Options setMaxWriteBatchGroupSizeBytes(long maxWriteBatchGroupSizeBytes)
```
    从接口复制的说明: DBOptionsInterface
    
    The maximum limit of number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit. Default: 1 MB
    
    指定者:
    
    setMaxWriteBatchGroupSizeBytes 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxWriteBatchGroupSizeBytes - the maximum limit of number of bytes, see description.
    
    返回:
    
    the instance of the current object.
  - maxWriteBatchGroupSizeBytes
```
public long maxWriteBatchGroupSizeBytes()
```
    从接口复制的说明: DBOptionsInterface
    
    The maximum limit of number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit. Default: 1 MB
    
    指定者:
    
    maxWriteBatchGroupSizeBytes 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum limit of number of bytes, see description.
  - setWalSizeLimitMB
```
public Options setWalSizeLimitMB(long sizeLimitMB)
```
    从接口复制的说明: DBOptionsInterface
    WalTtlSeconds() and walSizeLimitMB() 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.
    指定者:
    
    setWalSizeLimitMB 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    sizeLimitMB - size limit in mega-bytes.
    
    返回:
    
    the instance of the current object.
    
    另请参阅:
    
    DBOptionsInterface.setWalSizeLimitMB(long)
  - manifestPreallocationSize
```
public long manifestPreallocationSize()
```
    从接口复制的说明: DBOptionsInterface
    
    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).
    
    指定者:
    
    manifestPreallocationSize 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    size in bytes.
  - setManifestPreallocationSize
```
public Options setManifestPreallocationSize(long size)
```
    从接口复制的说明: DBOptionsInterface
    
    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).
    
    指定者:
    
    setManifestPreallocationSize 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    size - the size in byte
    
    返回:
    
    the instance of the current object.
  - setUseDirectReads
```
public Options setUseDirectReads(boolean useDirectReads)
```
    从接口复制的说明: DBOptionsInterface
    
    Enable the OS to use direct I/O for reading sst tables. Default: false
    
    指定者:
    
    setUseDirectReads 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    useDirectReads - if true, then direct read is enabled
    
    返回:
    
    the instance of the current object.
  - useDirectReads
```
public boolean useDirectReads()
```
    从接口复制的说明: DBOptionsInterface
    
    Enable the OS to use direct I/O for reading sst tables. Default: false
    
    指定者:
    
    useDirectReads 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    if true, then direct reads are enabled
  - setUseDirectIoForFlushAndCompaction
```
public Options setUseDirectIoForFlushAndCompaction(boolean useDirectIoForFlushAndCompaction)
```
    从接口复制的说明: DBOptionsInterface
    
    Enable the OS to use direct reads and writes in flush and compaction Default: false
    
    指定者:
    
    setUseDirectIoForFlushAndCompaction 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    useDirectIoForFlushAndCompaction - if true, then direct I/O will be enabled for background flush and compactions
    
    返回:
    
    the instance of the current object.
  - useDirectIoForFlushAndCompaction
```
public boolean useDirectIoForFlushAndCompaction()
```
    从接口复制的说明: DBOptionsInterface
    
    Enable the OS to use direct reads and writes in flush and compaction
    
    指定者:
    
    useDirectIoForFlushAndCompaction 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    if true, then direct I/O is enabled for flush and compaction
  - setAllowFAllocate
```
public Options setAllowFAllocate(boolean allowFAllocate)
```
    从接口复制的说明: DBOptionsInterface
    
    Whether fallocate calls are allowed
    
    指定者:
    
    setAllowFAllocate 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    allowFAllocate - false if fallocate() calls are bypassed
    
    返回:
    
    the reference to the current options.
  - allowFAllocate
```
public boolean allowFAllocate()
```
    从接口复制的说明: DBOptionsInterface
    
    Whether fallocate calls are allowed
    
    指定者:
    
    allowFAllocate 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    false if fallocate() calls are bypassed
  - allowMmapReads
```
public boolean allowMmapReads()
```
    从接口复制的说明: DBOptionsInterface
    
    Allow the OS to mmap file for reading sst tables. Default: false
    
    指定者:
    
    allowMmapReads 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if mmap reads are allowed.
  - setAllowMmapReads
```
public Options setAllowMmapReads(boolean allowMmapReads)
```
    从接口复制的说明: DBOptionsInterface
    
    Allow the OS to mmap file for reading sst tables. Default: false
    
    指定者:
    
    setAllowMmapReads 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    allowMmapReads - true if mmap reads are allowed.
    
    返回:
    
    the instance of the current object.
  - allowMmapWrites
```
public boolean allowMmapWrites()
```
    从接口复制的说明: DBOptionsInterface
    
    Allow the OS to mmap file for writing. Default: false
    
    指定者:
    
    allowMmapWrites 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if mmap writes are allowed.
  - setAllowMmapWrites
```
public Options setAllowMmapWrites(boolean allowMmapWrites)
```
    从接口复制的说明: DBOptionsInterface
    
    Allow the OS to mmap file for writing. Default: false
    
    指定者:
    
    setAllowMmapWrites 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    allowMmapWrites - true if mmap writes are allowd.
    
    返回:
    
    the instance of the current object.
  - isFdCloseOnExec
```
public boolean isFdCloseOnExec()
```
    从接口复制的说明: DBOptionsInterface
    
    Disable child process inherit open files. Default: true
    
    指定者:
    
    isFdCloseOnExec 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if child process inheriting open files is disabled.
  - setIsFdCloseOnExec
```
public Options setIsFdCloseOnExec(boolean isFdCloseOnExec)
```
    从接口复制的说明: DBOptionsInterface
    
    Disable child process inherit open files. Default: true
    
    指定者:
    
    setIsFdCloseOnExec 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    isFdCloseOnExec - true if child process inheriting open files is disabled.
    
    返回:
    
    the instance of the current object.
  - statsDumpPeriodSec
```
public int statsDumpPeriodSec()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
    
    指定者:
    
    statsDumpPeriodSec 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    time interval in seconds.
  - setStatsDumpPeriodSec
```
public Options setStatsDumpPeriodSec(int statsDumpPeriodSec)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec Default: 600 (10 minutes)
    
    指定者:
    
    setStatsDumpPeriodSec 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    statsDumpPeriodSec - time interval in seconds.
    
    返回:
    
    the instance of the current object.
  - setStatsPersistPeriodSec
```
public Options setStatsPersistPeriodSec(int statsPersistPeriodSec)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    If not zero, dump rocksdb.stats to RocksDB every statsPersistPeriodSec Default: 600
    
    指定者:
    
    setStatsPersistPeriodSec 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    statsPersistPeriodSec - time interval in seconds.
    
    返回:
    
    the instance of the current object.
  - statsPersistPeriodSec
```
public int statsPersistPeriodSec()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    If not zero, dump rocksdb.stats to RocksDB every statsPersistPeriodSec
    
    指定者:
    
    statsPersistPeriodSec 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    time interval in seconds.
  - setStatsHistoryBufferSize
```
public Options setStatsHistoryBufferSize(long statsHistoryBufferSize)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at statsHistoryBufferSize Default: 1MB
    
    指定者:
    
    setStatsHistoryBufferSize 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    statsHistoryBufferSize - the size of the buffer.
    
    返回:
    
    the instance of the current object.
  - statsHistoryBufferSize
```
public long statsHistoryBufferSize()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    If not zero, periodically take stats snapshots and store in memory, the memory size for stats snapshots is capped at statsHistoryBufferSize
    
    指定者:
    
    statsHistoryBufferSize 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the size of the buffer.
  - adviseRandomOnOpen
```
public boolean adviseRandomOnOpen()
```
    从接口复制的说明: DBOptionsInterface
    
    If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened. Default: true
    
    指定者:
    
    adviseRandomOnOpen 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if hinting random access is on.
  - setAdviseRandomOnOpen
```
public Options setAdviseRandomOnOpen(boolean adviseRandomOnOpen)
```
    从接口复制的说明: DBOptionsInterface
    
    If set true, will hint the underlying file system that the file access pattern is random, when a sst file is opened. Default: true
    
    指定者:
    
    setAdviseRandomOnOpen 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    adviseRandomOnOpen - true if hinting random access is on.
    
    返回:
    
    the instance of the current object.
  - setDbWriteBufferSize
```
public Options setDbWriteBufferSize(long dbWriteBufferSize)
```
    从接口复制的说明: DBOptionsInterface
    
    Amount of data to build up in memtables across all column families before writing to disk. This is distinct from 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)
    
    指定者:
    
    setDbWriteBufferSize 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    dbWriteBufferSize - the size of the write buffer
    
    返回:
    
    the reference to the current options.
  - setWriteBufferManager
```
public Options setWriteBufferManager(WriteBufferManager writeBufferManager)
```
    从接口复制的说明: DBOptionsInterface
    
    Use passed WriteBufferManager to control memory usage across multiple column families and/or DB instances. Check https://github.com/facebook/rocksdb/wiki/Write-Buffer-Manager for more details on when to use it
    
    指定者:
    
    setWriteBufferManager 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    writeBufferManager - The WriteBufferManager to use
    
    返回:
    
    the reference of the current options.
  - writeBufferManager
```
public WriteBufferManager writeBufferManager()
```
    从接口复制的说明: DBOptionsInterface
    
    Reference to WriteBufferManager used by it.
    Default: null (Disabled)
    
    指定者:
    
    writeBufferManager 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    a reference to WriteBufferManager
  - dbWriteBufferSize
```
public long dbWriteBufferSize()
```
    从接口复制的说明: DBOptionsInterface
    
    Amount of data to build up in memtables across all column families before writing to disk. This is distinct from 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)
    
    指定者:
    
    dbWriteBufferSize 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the size of the write buffer
  - setAccessHintOnCompactionStart
```
public Options setAccessHintOnCompactionStart(AccessHint accessHint)
```
    从接口复制的说明: DBOptionsInterface
    
    Specify the file access pattern once a compaction is started. It will be applied to all input files of a compaction. Default: AccessHint.NORMAL
    
    指定者:
    
    setAccessHintOnCompactionStart 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    accessHint - The access hint
    
    返回:
    
    the reference to the current options.
  - accessHintOnCompactionStart
```
public AccessHint accessHintOnCompactionStart()
```
    从接口复制的说明: DBOptionsInterface
    
    Specify the file access pattern once a compaction is started. It will be applied to all input files of a compaction. Default: AccessHint.NORMAL
    
    指定者:
    
    accessHintOnCompactionStart 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    The access hint
  - setCompactionReadaheadSize
```
public Options setCompactionReadaheadSize(long compactionReadaheadSize)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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.
    Default: 0
    
    指定者:
    
    setCompactionReadaheadSize 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    compactionReadaheadSize - The compaction read-ahead size
    
    返回:
    
    the reference to the current options.
  - compactionReadaheadSize
```
public long compactionReadaheadSize()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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.
    Default: 0
    
    指定者:
    
    compactionReadaheadSize 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    The compaction read-ahead size
  - setRandomAccessMaxBufferSize
```
public Options setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize)
```
    从接口复制的说明: DBOptionsInterface
    
    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 MutableDBOptionsInterface.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.
    
    指定者:
    
    setRandomAccessMaxBufferSize 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    randomAccessMaxBufferSize - the maximum size of the random access buffer
    
    返回:
    
    the reference to the current options.
  - randomAccessMaxBufferSize
```
public long randomAccessMaxBufferSize()
```
    从接口复制的说明: DBOptionsInterface
    
    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 MutableDBOptionsInterface.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.
    
    指定者:
    
    randomAccessMaxBufferSize 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum size of the random access buffer
  - setWritableFileMaxBufferSize
```
public Options setWritableFileMaxBufferSize(long writableFileMaxBufferSize)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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)
    
    指定者:
    
    setWritableFileMaxBufferSize 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    writableFileMaxBufferSize - the maximum buffer size
    
    返回:
    
    the reference to the current options.
  - writableFileMaxBufferSize
```
public long writableFileMaxBufferSize()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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)
    
    指定者:
    
    writableFileMaxBufferSize 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the maximum buffer size
  - useAdaptiveMutex
```
public boolean useAdaptiveMutex()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    useAdaptiveMutex 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if adaptive mutex is used.
  - setUseAdaptiveMutex
```
public Options setUseAdaptiveMutex(boolean useAdaptiveMutex)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setUseAdaptiveMutex 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    useAdaptiveMutex - true if adaptive mutex is used.
    
    返回:
    
    the instance of the current object.
  - bytesPerSync
```
public long bytesPerSync()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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
    
    指定者:
    
    bytesPerSync 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    size in bytes
  - setBytesPerSync
```
public Options setBytesPerSync(long bytesPerSync)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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
    
    指定者:
    
    setBytesPerSync 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    bytesPerSync - size in bytes
    
    返回:
    
    the instance of the current object.
  - setWalBytesPerSync
```
public Options setWalBytesPerSync(long walBytesPerSync)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Same as MutableDBOptionsInterface.setBytesPerSync(long) , but applies to WAL files
    Default: 0, turned off
    
    指定者:
    
    setWalBytesPerSync 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    walBytesPerSync - size in bytes
    
    返回:
    
    the instance of the current object.
  - walBytesPerSync
```
public long walBytesPerSync()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Same as MutableDBOptionsInterface.bytesPerSync() , but applies to WAL files
    Default: 0, turned off
    
    指定者:
    
    walBytesPerSync 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    size in bytes
  - setStrictBytesPerSync
```
public Options setStrictBytesPerSync(boolean strictBytesPerSync)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    When true, guarantees WAL files have at most MutableDBOptionsInterface.walBytesPerSync() bytes submitted for writeback at any given time, and SST files have at most MutableDBOptionsInterface.bytesPerSync() bytes pending writeback at any given time. This can be used to handle cases where processing speed exceeds I/O speed during file generation, which can lead to a huge sync when the file is finished, even with MutableDBOptionsInterface.bytesPerSync() / MutableDBOptionsInterface.walBytesPerSync() properly configured.
    - If `sync_file_range` is supported it achieves this by waiting for any prior `sync_file_range`s to finish before proceeding. In this way, processing (compression, etc.) can proceed uninhibited in the gap between `sync_file_range`s, and we block only when I/O falls behind. - Otherwise the `WritableFile::Sync` method is used. Note this mechanism always blocks, thus preventing the interleaving of I/O and processing.
    Note: Enabling this option does not provide any additional persistence guarantees, as it may use `sync_file_range`, which does not write out metadata.
    Default: false
    
    指定者:
    
    setStrictBytesPerSync 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    strictBytesPerSync - the bytes per sync
    
    返回:
    
    the instance of the current object.
  - strictBytesPerSync
```
public boolean strictBytesPerSync()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    Return the strict byte limit per sync.
    See MutableDBOptionsInterface.setStrictBytesPerSync(boolean)
    
    指定者:
    
    strictBytesPerSync 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the limit in bytes.
  - setListeners
```
public Options setListeners(java.util.List<AbstractEventListener> listeners)
```
    从接口复制的说明: DBOptionsInterface
    
    Sets the EventListeners whose callback functions will be called when specific RocksDB event happens. Note: the RocksJava API currently only supports EventListeners implemented in Java. It could be extended in future to also support adding/removing EventListeners implemented in C++.
    
    指定者:
    
    setListeners 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    listeners - the listeners who should be notified on various events.
    
    返回:
    
    the instance of the current object.
  - listeners
```
public java.util.List<AbstractEventListener> listeners()
```
    从接口复制的说明: DBOptionsInterface
    
    Sets the EventListeners whose callback functions will be called when specific RocksDB event happens. Note: the RocksJava API currently only supports EventListeners implemented in Java. It could be extended in future to also support adding/removing EventListeners implemented in C++.
    
    指定者:
    
    listeners 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the instance of the current object.
  - setEnableThreadTracking
```
public Options setEnableThreadTracking(boolean enableThreadTracking)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API. Default: false
    
    指定者:
    
    setEnableThreadTracking 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    enableThreadTracking - true to enable tracking
    
    返回:
    
    the reference to the current options.
  - enableThreadTracking
```
public boolean enableThreadTracking()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then the status of the threads involved in this DB will be tracked and available via GetThreadList() API. Default: false
    
    指定者:
    
    enableThreadTracking 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if tracking is enabled
  - setDelayedWriteRate
```
public Options setDelayedWriteRate(long delayedWriteRate)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    The limited write rate to DB if ColumnFamilyOptions.softPendingCompactionBytesLimit() or 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. If the value is 0, we will infer a value from `rater_limiter` value if it is not empty, or 16MB if `rater_limiter` is empty. Note that if users change the rate in `rate_limiter` after DB is opened, `delayed_write_rate` won't be adjusted.
    Unit: bytes per second.
    Default: 0
    Dynamically changeable through RocksDB.setDBOptions(MutableDBOptions).
    
    指定者:
    
    setDelayedWriteRate 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    delayedWriteRate - the rate in bytes per second
    
    返回:
    
    the reference to the current options.
  - delayedWriteRate
```
public long delayedWriteRate()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    The limited write rate to DB if ColumnFamilyOptions.softPendingCompactionBytesLimit() or 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. If the value is 0, we will infer a value from `rater_limiter` value if it is not empty, or 16MB if `rater_limiter` is empty. Note that if users change the rate in `rate_limiter` after DB is opened, `delayed_write_rate` won't be adjusted.
    Unit: bytes per second.
    Default: 0
    Dynamically changeable through RocksDB.setDBOptions(MutableDBOptions).
    
    指定者:
    
    delayedWriteRate 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    the rate in bytes per second
  - setEnablePipelinedWrite
```
public Options setEnablePipelinedWrite(boolean enablePipelinedWrite)
```
    从接口复制的说明: DBOptionsInterface
    
    By default, a single write thread queue is maintained. The thread gets to the head of the queue becomes write batch group leader and responsible for writing to WAL and memtable for the batch group. If DBOptionsInterface.enablePipelinedWrite() is true, separate write thread queue is maintained for WAL write and memtable write. A write thread first enter WAL writer queue and then memtable writer queue. Pending thread on the WAL writer queue thus only have to wait for previous writers to finish their WAL writing but not the memtable writing. Enabling the feature may improve write throughput and reduce latency of the prepare phase of two-phase commit. Default: false
    
    指定者:
    
    setEnablePipelinedWrite 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    enablePipelinedWrite - true to enabled pipelined writes
    
    返回:
    
    the reference to the current options.
  - enablePipelinedWrite
```
public boolean enablePipelinedWrite()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns true if pipelined writes are enabled. See DBOptionsInterface.setEnablePipelinedWrite(boolean).
    
    指定者:
    
    enablePipelinedWrite 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if pipelined writes are enabled, false otherwise.
  - setUnorderedWrite
```
public Options setUnorderedWrite(boolean unorderedWrite)
```
    从接口复制的说明: DBOptionsInterface
    
    Setting DBOptionsInterface.unorderedWrite() to true trades higher write throughput with relaxing the immutability guarantee of snapshots. This violates the repeatability one expects from ::Get from a snapshot, as well as ::MultiGet and Iterator's consistent-point-in-time view property. If the application cannot tolerate the relaxed guarantees, it can implement its own mechanisms to work around that and yet benefit from the higher throughput. Using TransactionDB with WRITE_PREPARED write policy and DBOptionsInterface.twoWriteQueues() true is one way to achieve immutable snapshots despite unordered_write. By default, i.e., when it is false, rocksdb does not advance the sequence number for new snapshots unless all the writes with lower sequence numbers are already finished. This provides the immutability that we except from snapshots. Moreover, since Iterator and MultiGet internally depend on snapshots, the snapshot immutability results into Iterator and MultiGet offering consistent-point-in-time view. If set to true, although Read-Your-Own-Write property is still provided, the snapshot immutability property is relaxed: the writes issued after the snapshot is obtained (with larger sequence numbers) will be still not visible to the reads from that snapshot, however, there still might be pending writes (with lower sequence number) that will change the state visible to the snapshot after they are landed to the memtable.
    
    指定者:
    
    setUnorderedWrite 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    unorderedWrite - true to enabled unordered write
    
    返回:
    
    the reference to the current options.
  - unorderedWrite
```
public boolean unorderedWrite()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns true if unordered write are enabled. See DBOptionsInterface.setUnorderedWrite(boolean).
    
    指定者:
    
    unorderedWrite 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if unordered write are enabled, false otherwise.
  - setAllowConcurrentMemtableWrite
```
public Options setAllowConcurrentMemtableWrite(boolean allowConcurrentMemtableWrite)
```
    从接口复制的说明: DBOptionsInterface
    
    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 DBOptionsInterface.setEnableWriteThreadAdaptiveYield(boolean) if you are going to use this feature. Default: true
    
    指定者:
    
    setAllowConcurrentMemtableWrite 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    allowConcurrentMemtableWrite - true to enable concurrent writes for the memtable
    
    返回:
    
    the reference to the current options.
  - allowConcurrentMemtableWrite
```
public boolean allowConcurrentMemtableWrite()
```
    从接口复制的说明: DBOptionsInterface
    
    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 DBOptionsInterface.setEnableWriteThreadAdaptiveYield(boolean) if you are going to use this feature. Default: true
    
    指定者:
    
    allowConcurrentMemtableWrite 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if concurrent writes are enabled for the memtable
  - setEnableWriteThreadAdaptiveYield
```
public Options setEnableWriteThreadAdaptiveYield(boolean enableWriteThreadAdaptiveYield)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, threads synchronizing with the write batch group leader will wait for up to DBOptionsInterface.writeThreadMaxYieldUsec() before blocking on a mutex. This can substantially improve throughput for concurrent workloads, regardless of whether DBOptionsInterface.allowConcurrentMemtableWrite() is enabled. Default: true
    
    指定者:
    
    setEnableWriteThreadAdaptiveYield 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    enableWriteThreadAdaptiveYield - true to enable adaptive yield for the write threads
    
    返回:
    
    the reference to the current options.
  - enableWriteThreadAdaptiveYield
```
public boolean enableWriteThreadAdaptiveYield()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, threads synchronizing with the write batch group leader will wait for up to DBOptionsInterface.writeThreadMaxYieldUsec() before blocking on a mutex. This can substantially improve throughput for concurrent workloads, regardless of whether DBOptionsInterface.allowConcurrentMemtableWrite() is enabled. Default: true
    
    指定者:
    
    enableWriteThreadAdaptiveYield 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if adaptive yield is enabled for the writing threads
  - setWriteThreadMaxYieldUsec
```
public Options setWriteThreadMaxYieldUsec(long writeThreadMaxYieldUsec)
```
    从接口复制的说明: DBOptionsInterface
    
    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 DBOptionsInterface.writeThreadSlowYieldUsec() is set properly) increasing this value is likely to increase RocksDB throughput at the expense of increased CPU usage. Default: 100
    
    指定者:
    
    setWriteThreadMaxYieldUsec 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    writeThreadMaxYieldUsec - maximum number of microseconds
    
    返回:
    
    the reference to the current options.
  - writeThreadMaxYieldUsec
```
public long writeThreadMaxYieldUsec()
```
    从接口复制的说明: DBOptionsInterface
    
    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 DBOptionsInterface.writeThreadSlowYieldUsec() is set properly) increasing this value is likely to increase RocksDB throughput at the expense of increased CPU usage. Default: 100
    
    指定者:
    
    writeThreadMaxYieldUsec 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the maximum number of microseconds
  - setWriteThreadSlowYieldUsec
```
public Options setWriteThreadSlowYieldUsec(long writeThreadSlowYieldUsec)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setWriteThreadSlowYieldUsec 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    writeThreadSlowYieldUsec - the latency in microseconds
    
    返回:
    
    the reference to the current options.
  - writeThreadSlowYieldUsec
```
public long writeThreadSlowYieldUsec()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    writeThreadSlowYieldUsec 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    writeThreadSlowYieldUsec the latency in microseconds
  - setSkipStatsUpdateOnDbOpen
```
public Options setSkipStatsUpdateOnDbOpen(boolean skipStatsUpdateOnDbOpen)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setSkipStatsUpdateOnDbOpen 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    skipStatsUpdateOnDbOpen - true if updating stats will be skipped
    
    返回:
    
    the reference to the current options.
  - skipStatsUpdateOnDbOpen
```
public boolean skipStatsUpdateOnDbOpen()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    skipStatsUpdateOnDbOpen 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if updating stats will be skipped
  - setSkipCheckingSstFileSizesOnDbOpen
```
public Options setSkipCheckingSstFileSizesOnDbOpen(boolean skipCheckingSstFileSizesOnDbOpen)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then RocksDB.open(String) will not fetch and check sizes of all sst files. This may significantly speed up startup if there are many sst files, especially when using non-default Env with expensive GetFileSize(). We'll still check that all required sst files exist. If paranoid_checks is false, this option is ignored, and sst files are not checked at all. Default: false
    
    指定者:
    
    setSkipCheckingSstFileSizesOnDbOpen 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    skipCheckingSstFileSizesOnDbOpen - if true, then SST file sizes will not be checked when calling RocksDB.open(String).
    
    返回:
    
    the reference to the current options.
  - skipCheckingSstFileSizesOnDbOpen
```
public boolean skipCheckingSstFileSizesOnDbOpen()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then RocksDB.open(String) will not fetch and check sizes of all sst files. This may significantly speed up startup if there are many sst files, especially when using non-default Env with expensive GetFileSize(). We'll still check that all required sst files exist. If paranoid_checks is false, this option is ignored, and sst files are not checked at all. Default: false
    
    指定者:
    
    skipCheckingSstFileSizesOnDbOpen 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true, if file sizes will not be checked when calling RocksDB.open(String).
  - setWalRecoveryMode
```
public Options setWalRecoveryMode(WALRecoveryMode walRecoveryMode)
```
    从接口复制的说明: DBOptionsInterface
    
    Recovery mode to control the consistency while replaying WAL Default: WALRecoveryMode.PointInTimeRecovery
    
    指定者:
    
    setWalRecoveryMode 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    walRecoveryMode - The WAL recover mode
    
    返回:
    
    the reference to the current options.
  - walRecoveryMode
```
public WALRecoveryMode walRecoveryMode()
```
    从接口复制的说明: DBOptionsInterface
    
    Recovery mode to control the consistency while replaying WAL Default: WALRecoveryMode.PointInTimeRecovery
    
    指定者:
    
    walRecoveryMode 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    The WAL recover mode
  - setAllow2pc
```
public Options setAllow2pc(boolean allow2pc)
```
    从接口复制的说明: DBOptionsInterface
    
    if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
    
    指定者:
    
    setAllow2pc 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    allow2pc - true if two-phase-commit is enabled
    
    返回:
    
    the reference to the current options.
  - allow2pc
```
public boolean allow2pc()
```
    从接口复制的说明: DBOptionsInterface
    
    if set to false then recovery will fail when a prepared transaction is encountered in the WAL Default: false
    
    指定者:
    
    allow2pc 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if two-phase-commit is enabled
  - setRowCache
```
public Options setRowCache(Cache rowCache)
```
    从接口复制的说明: DBOptionsInterface
    
    A global cache for table-level rows. Default: null (disabled)
    
    指定者:
    
    setRowCache 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    rowCache - The global row cache
    
    返回:
    
    the reference to the current options.
  - rowCache
```
public Cache rowCache()
```
    从接口复制的说明: DBOptionsInterface
    
    A global cache for table-level rows. Default: null (disabled)
    
    指定者:
    
    rowCache 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    The global row cache
  - setWalFilter
```
public Options setWalFilter(AbstractWalFilter walFilter)
```
    从接口复制的说明: DBOptionsInterface
    
    A filter object supplied to be invoked while processing write-ahead-logs (WALs) during recovery. The filter provides a way to inspect log records, ignoring a particular record or skipping replay. The filter is invoked at startup and is invoked from a single-thread currently.
    
    指定者:
    
    setWalFilter 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    walFilter - the filter for processing WALs during recovery.
    
    返回:
    
    the reference to the current options.
  - walFilter
```
public WalFilter walFilter()
```
    从接口复制的说明: DBOptionsInterface
    
    Get's the filter for processing WALs during recovery. See DBOptionsInterface.setWalFilter(AbstractWalFilter).
    
    指定者:
    
    walFilter 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the filter used for processing WALs during recovery.
  - setFailIfOptionsFileError
```
public Options setFailIfOptionsFileError(boolean failIfOptionsFileError)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted. DEFAULT: false
    
    指定者:
    
    setFailIfOptionsFileError 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    failIfOptionsFileError - true if we should fail if there is an error in the options file
    
    返回:
    
    the reference to the current options.
  - failIfOptionsFileError
```
public boolean failIfOptionsFileError()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then DB::Open / CreateColumnFamily / DropColumnFamily / SetOptions will fail if options file is not detected or properly persisted. DEFAULT: false
    
    指定者:
    
    failIfOptionsFileError 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if we should fail if there is an error in the options file
  - setDumpMallocStats
```
public Options setDumpMallocStats(boolean dumpMallocStats)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then print malloc stats together with rocksdb.stats when printing to LOG. DEFAULT: false
    
    指定者:
    
    setDumpMallocStats 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    dumpMallocStats - true if malloc stats should be printed to LOG
    
    返回:
    
    the reference to the current options.
  - dumpMallocStats
```
public boolean dumpMallocStats()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, then print malloc stats together with rocksdb.stats when printing to LOG. DEFAULT: false
    
    指定者:
    
    dumpMallocStats 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if malloc stats should be printed to LOG
  - setAvoidFlushDuringRecovery
```
public Options setAvoidFlushDuringRecovery(boolean avoidFlushDuringRecovery)
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    setAvoidFlushDuringRecovery 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    avoidFlushDuringRecovery - true to try to avoid (but not guarantee not to) flush during recovery
    
    返回:
    
    the reference to the current options.
  - avoidFlushDuringRecovery
```
public boolean avoidFlushDuringRecovery()
```
    从接口复制的说明: DBOptionsInterface
    
    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
    
    指定者:
    
    avoidFlushDuringRecovery 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true to try to avoid (but not guarantee not to) flush during recovery
  - setAvoidFlushDuringShutdown
```
public Options setAvoidFlushDuringShutdown(boolean avoidFlushDuringShutdown)
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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 RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions) API.
    
    指定者:
    
    setAvoidFlushDuringShutdown 在接口中 MutableDBOptionsInterface<Options>
    
    参数:
    
    avoidFlushDuringShutdown - true if we should avoid flush during shutdown
    
    返回:
    
    the reference to the current options.
  - avoidFlushDuringShutdown
```
public boolean avoidFlushDuringShutdown()
```
    从接口复制的说明: MutableDBOptionsInterface
    
    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 RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions) API.
    
    指定者:
    
    avoidFlushDuringShutdown 在接口中 MutableDBOptionsInterface<Options>
    
    返回:
    
    true if we should avoid flush during shutdown
  - setAllowIngestBehind
```
public Options setAllowIngestBehind(boolean allowIngestBehind)
```
    从接口复制的说明: DBOptionsInterface
    
    Set this option to true during creation of database if you want to be able to ingest behind (call IngestExternalFile() skipping keys that already exist, rather than overwriting matching keys). Setting this option to true will affect 2 things: 1) Disable some internal optimizations around SST file compression 2) Reserve bottom-most level for ingested files only. 3) Note that num_levels should be >= 3 if this option is turned on. DEFAULT: false
    
    指定者:
    
    setAllowIngestBehind 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    allowIngestBehind - true to allow ingest behind, false to disallow.
    
    返回:
    
    the reference to the current options.
  - allowIngestBehind
```
public boolean allowIngestBehind()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns true if ingest behind is allowed. See DBOptionsInterface.setAllowIngestBehind(boolean).
    
    指定者:
    
    allowIngestBehind 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if ingest behind is allowed, false otherwise.
  - setTwoWriteQueues
```
public Options setTwoWriteQueues(boolean twoWriteQueues)
```
    从接口复制的说明: DBOptionsInterface
    
    If enabled it uses two queues for writes, one for the ones with disable_memtable and one for the ones that also write to memtable. This allows the memtable writes not to lag behind other writes. It can be used to optimize MySQL 2PC in which only the commits, which are serial, write to memtable. DEFAULT: false
    
    指定者:
    
    setTwoWriteQueues 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    twoWriteQueues - true to enable two write queues, false otherwise.
    
    返回:
    
    the reference to the current options.
  - twoWriteQueues
```
public boolean twoWriteQueues()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns true if two write queues are enabled.
    
    指定者:
    
    twoWriteQueues 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if two write queues are enabled, false otherwise.
  - setManualWalFlush
```
public Options setManualWalFlush(boolean manualWalFlush)
```
    从接口复制的说明: DBOptionsInterface
    
    If true WAL is not flushed automatically after each write. Instead it relies on manual invocation of FlushWAL to write the WAL buffer to its file. DEFAULT: false
    
    指定者:
    
    setManualWalFlush 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    manualWalFlush - true to set disable automatic WAL flushing, false otherwise.
    
    返回:
    
    the reference to the current options.
  - manualWalFlush
```
public boolean manualWalFlush()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns true if automatic WAL flushing is disabled. See DBOptionsInterface.setManualWalFlush(boolean).
    
    指定者:
    
    manualWalFlush 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if automatic WAL flushing is disabled, false otherwise.
  - memTableConfig
```
public MemTableConfig memTableConfig()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Get the config for mem-table.
    
    指定者:
    
    memTableConfig 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the mem-table config.
  - setMemTableConfig
```
public Options setMemTableConfig(MemTableConfig config)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set the config for mem-table.
    
    指定者:
    
    setMemTableConfig 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    config - the mem-table config.
    
    返回:
    
    the instance of the current object.
  - setRateLimiter
```
public Options setRateLimiter(RateLimiter rateLimiter)
```
    从接口复制的说明: DBOptionsInterface
    
    Use to control write rate of flush and compaction. Flush has higher priority than compaction. Rate limiting is disabled if nullptr. Default: nullptr
    
    指定者:
    
    setRateLimiter 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    rateLimiter - RateLimiter instance.
    
    返回:
    
    the instance of the current object.
  - setSstFileManager
```
public Options setSstFileManager(SstFileManager sstFileManager)
```
    从接口复制的说明: DBOptionsInterface
    
    Use to track SST files and control their file deletion rate. Features: - Throttle the deletion rate of the SST files. - Keep track the total size of all SST files. - Set a maximum allowed space limit for SST files that when reached the DB wont do any further flushes or compactions and will set the background error. - Can be shared between multiple dbs. Limitations: - Only track and throttle deletes of SST files in first db_path (db_name if db_paths is empty).
    
    指定者:
    
    setSstFileManager 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    sstFileManager - The SST File Manager for the db.
    
    返回:
    
    the instance of the current object.
  - setLogger
```
public Options setLogger(Logger logger)
```
    从接口复制的说明: DBOptionsInterface
    
    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.
    
    Default: nullptr
    
    指定者:
    
    setLogger 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    logger - Logger instance.
    
    返回:
    
    the instance of the current object.
  - setInfoLogLevel
```
public Options setInfoLogLevel(InfoLogLevel infoLogLevel)
```
    从接口复制的说明: DBOptionsInterface
    
    Sets the RocksDB log level. Default level is INFO
    
    指定者:
    
    setInfoLogLevel 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    infoLogLevel - log level to set.
    
    返回:
    
    the instance of the current object.
  - infoLogLevel
```
public InfoLogLevel infoLogLevel()
```
    从接口复制的说明: DBOptionsInterface
    
    Returns currently set log level.
    
    指定者:
    
    infoLogLevel 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    InfoLogLevel instance.
  - memTableFactoryName
```
public java.lang.String memTableFactoryName()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Returns the name of the current mem table representation. Memtable format can be set using setTableFormatConfig.
    
    指定者:
    
    memTableFactoryName 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the name of the currently-used memtable factory.
    
    另请参阅:
    
    ColumnFamilyOptionsInterface.setTableFormatConfig(org.rocksdb.TableFormatConfig)
  - tableFormatConfig
```
public TableFormatConfig tableFormatConfig()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Get the config for table format.
    
    指定者:
    
    tableFormatConfig 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the table format config.
  - setTableFormatConfig
```
public Options setTableFormatConfig(TableFormatConfig config)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set the config for table format.
    
    指定者:
    
    setTableFormatConfig 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    config - the table format config.
    
    返回:
    
    the reference of the current options.
  - tableFactoryName
```
public java.lang.String tableFactoryName()
```
    指定者:
    
    tableFactoryName 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the name of the currently used table factory.
  - setCfPaths
```
public Options setCfPaths(java.util.Collection<DbPath> cfPaths)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    A list of paths where SST files for this column family can be put into, with its target size. Similar to db_paths, newer data is placed into paths specified earlier in the vector while older data gradually moves to paths specified later in the vector. Note that, if a path is supplied to multiple column families, it would have files and total size from all the column families combined. User should provision for the total size(from all the column families) in such cases.
    If left empty, db_paths will be used. Default: empty
    
    指定者:
    
    setCfPaths 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    cfPaths - collection of paths for SST files.
    
    返回:
    
    the reference of the current options.
  - cfPaths
```
public java.util.List<DbPath> cfPaths()
```
    指定者:
    
    cfPaths 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    collection of paths for SST files.
  - useFixedLengthPrefixExtractor
```
public Options useFixedLengthPrefixExtractor(int n)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    This prefix-extractor uses the first n bytes of a key as its prefix.
    In some hash-based memtable representation such as HashLinkedList and HashSkipList, prefixes are used to partition the keys into several buckets. Prefix extractor is used to specify how to extract the prefix given a key.
    
    指定者:
    
    useFixedLengthPrefixExtractor 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    n - use the first n bytes of a key as its prefix.
    
    返回:
    
    the reference to the current option.
  - useCappedPrefixExtractor
```
public Options useCappedPrefixExtractor(int n)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Same as fixed length prefix extractor, except that when slice is shorter than the fixed length, it will use the full key.
    
    指定者:
    
    useCappedPrefixExtractor 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    n - use the first n bytes of a key as its prefix.
    
    返回:
    
    the reference to the current option.
  - compressionType
```
public CompressionType compressionType()
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Compress blocks using the specified compression algorithm. This parameter can be changed dynamically.
    Default: SNAPPY_COMPRESSION, which gives lightweight but fast compression.
    
    指定者:
    
    compressionType 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    Compression type.
  - setCompressionPerLevel
```
public Options setCompressionPerLevel(java.util.List<CompressionType> compressionLevels)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Different levels can have different compression policies. There are cases where most lower levels would like to use quick compression algorithms while the higher levels (which have more data) use compression algorithms that have better compression but could be slower. This array, if non-empty, should have an entry for each level of the database; these override the value specified in the previous field 'compression'.
    NOTICE
    If level_compaction_dynamic_level_bytes=true, compression_per_level[0] still determines L0, but other elements of the array are based on base level (the level L0 files are merged to), and may not match the level users see from info log for metadata.
    
    If L0 files are merged to level - n, then, for i>0, compression_per_level[i] determines compaction type for level n+i-1.
    Example
    For example, if we have 5 levels, and we determine to merge L0 data to L4 (which means L1..L3 will be empty), then the new files go to L4 uses compression type compression_per_level[1].
    
    If now L0 is merged to L2. Data goes to L2 will be compressed according to compression_per_level[1], L3 using compression_per_level[2]and L4 using compression_per_level[3]. Compaction for each level can change when data grows.
    
    Default: empty
    
    指定者:
    
    setCompressionPerLevel 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compressionLevels - list of CompressionType instances.
    
    返回:
    
    the reference to the current options.
  - compressionPerLevel
```
public java.util.List<CompressionType> compressionPerLevel()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Return the currently set CompressionType per instances.
    
    See: AdvancedColumnFamilyOptionsInterface.setCompressionPerLevel(java.util.List)
    
    指定者:
    
    compressionPerLevel 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    list of CompressionType instances.
  - setCompressionType
```
public Options setCompressionType(CompressionType compressionType)
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Compress blocks using the specified compression algorithm. This parameter can be changed dynamically.
    Default: SNAPPY_COMPRESSION, which gives lightweight but fast compression.
    
    指定者:
    
    setCompressionType 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compressionType - Compression Type.
    
    返回:
    
    the reference to the current option.
  - setBottommostCompressionType
```
public Options setBottommostCompressionType(CompressionType bottommostCompressionType)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Compression algorithm that will be used for the bottommost level that contain files. If level-compaction is used, this option will only affect levels after base level.
    Default: CompressionType.DISABLE_COMPRESSION_OPTION
    
    指定者:
    
    setBottommostCompressionType 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    bottommostCompressionType - The compression type to use for the bottommost level
    
    返回:
    
    the reference of the current options.
  - bottommostCompressionType
```
public CompressionType bottommostCompressionType()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Compression algorithm that will be used for the bottommost level that contain files. If level-compaction is used, this option will only affect levels after base level.
    Default: CompressionType.DISABLE_COMPRESSION_OPTION
    
    指定者:
    
    bottommostCompressionType 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The compression type used for the bottommost level
  - setBottommostCompressionOptions
```
public Options setBottommostCompressionOptions(CompressionOptions bottommostCompressionOptions)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set the options for compression algorithms used by ColumnFamilyOptionsInterface.bottommostCompressionType() if it is enabled.
    To enable it, please see the definition of CompressionOptions.
    
    指定者:
    
    setBottommostCompressionOptions 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    bottommostCompressionOptions - the bottom most compression options.
    
    返回:
    
    the reference of the current options.
  - bottommostCompressionOptions
```
public CompressionOptions bottommostCompressionOptions()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Get the bottom most compression options.
    See ColumnFamilyOptionsInterface.setBottommostCompressionOptions(CompressionOptions).
    
    指定者:
    
    bottommostCompressionOptions 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the bottom most compression options.
  - setCompressionOptions
```
public Options setCompressionOptions(CompressionOptions compressionOptions)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Set the different options for compression algorithms
    
    指定者:
    
    setCompressionOptions 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compressionOptions - The compression options
    
    返回:
    
    the reference of the current options.
  - compressionOptions
```
public CompressionOptions compressionOptions()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Get the different options for compression algorithms
    
    指定者:
    
    compressionOptions 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The compression options
  - compactionStyle
```
public CompactionStyle compactionStyle()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Compaction style for DB.
    
    指定者:
    
    compactionStyle 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    Compaction style.
  - setCompactionStyle
```
public Options setCompactionStyle(CompactionStyle compactionStyle)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Set compaction style for DB.
    Default: LEVEL.
    
    指定者:
    
    setCompactionStyle 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionStyle - Compaction style.
    
    返回:
    
    the reference to the current options.
  - numLevels
```
public int numLevels()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    If level-styled compaction is used, then this number determines the total number of levels.
    
    指定者:
    
    numLevels 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the number of levels.
  - setNumLevels
```
public Options setNumLevels(int numLevels)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Set the number of levels for this database If level-styled compaction is used, then this number determines the total number of levels.
    
    指定者:
    
    setNumLevels 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    numLevels - the number of levels.
    
    返回:
    
    the reference to the current options.
  - levelZeroFileNumCompactionTrigger
```
public int levelZeroFileNumCompactionTrigger()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    The number of files in level 0 to trigger compaction from level-0 to level-1. A value < 0 means that level-0 compaction will not be triggered by number of files at all. Default: 4
    
    指定者:
    
    levelZeroFileNumCompactionTrigger 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the number of files in level 0 to trigger compaction.
  - setLevelZeroFileNumCompactionTrigger
```
public Options setLevelZeroFileNumCompactionTrigger(int numFiles)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Number of files to trigger level-0 compaction. A value < 0 means that level-0 compaction will not be triggered by number of files at all. Default: 4
    
    指定者:
    
    setLevelZeroFileNumCompactionTrigger 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    numFiles - the number of files in level-0 to trigger compaction.
    
    返回:
    
    the reference to the current option.
  - levelZeroSlowdownWritesTrigger
```
public int levelZeroSlowdownWritesTrigger()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Soft limit on the number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    指定者:
    
    levelZeroSlowdownWritesTrigger 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the soft limit on the number of level-0 files.
  - setLevelZeroSlowdownWritesTrigger
```
public Options setLevelZeroSlowdownWritesTrigger(int numFiles)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Soft limit on number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    指定者:
    
    setLevelZeroSlowdownWritesTrigger 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    numFiles - soft limit on number of level-0 files.
    
    返回:
    
    the reference to the current option.
  - levelZeroStopWritesTrigger
```
public int levelZeroStopWritesTrigger()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    指定者:
    
    levelZeroStopWritesTrigger 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the hard limit of the number of level-0 file.
  - setLevelZeroStopWritesTrigger
```
public Options setLevelZeroStopWritesTrigger(int numFiles)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    指定者:
    
    setLevelZeroStopWritesTrigger 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    numFiles - the hard limit of the number of level-0 files.
    
    返回:
    
    the reference to the current option.
  - targetFileSizeBase
```
public long targetFileSizeBase()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    The target file size for compaction. This targetFileSizeBase determines a level-1 file size. Target file size for level L can be calculated by targetFileSizeBase * (targetFileSizeMultiplier ^ (L-1)) For example, if targetFileSizeBase is 2MB and target_file_size_multiplier is 10, then each file on level-1 will be 2MB, and each file on level 2 will be 20MB, and each file on level-3 will be 200MB. by default targetFileSizeBase is 64MB.
    
    指定者:
    
    targetFileSizeBase 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the target size of a level-0 file.
    
    另请参阅:
    
    AdvancedMutableColumnFamilyOptionsInterface.targetFileSizeMultiplier()
  - setTargetFileSizeBase
```
public Options setTargetFileSizeBase(long targetFileSizeBase)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    The target file size for compaction. This targetFileSizeBase determines a level-1 file size. Target file size for level L can be calculated by targetFileSizeBase * (targetFileSizeMultiplier ^ (L-1)) For example, if targetFileSizeBase is 2MB and target_file_size_multiplier is 10, then each file on level-1 will be 2MB, and each file on level 2 will be 20MB, and each file on level-3 will be 200MB. by default targetFileSizeBase is 64MB.
    
    指定者:
    
    setTargetFileSizeBase 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    targetFileSizeBase - the target size of a level-0 file.
    
    返回:
    
    the reference to the current options.
    
    另请参阅:
    
    AdvancedMutableColumnFamilyOptionsInterface.setTargetFileSizeMultiplier(int)
  - targetFileSizeMultiplier
```
public int targetFileSizeMultiplier()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    targetFileSizeMultiplier defines the size ratio between a level-(L+1) file and level-L file. By default targetFileSizeMultiplier is 1, meaning files in different levels have the same target.
    
    指定者:
    
    targetFileSizeMultiplier 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the size ratio between a level-(L+1) file and level-L file.
  - setTargetFileSizeMultiplier
```
public Options setTargetFileSizeMultiplier(int multiplier)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    targetFileSizeMultiplier defines the size ratio between a level-L file and level-(L+1) file. By default target_file_size_multiplier is 1, meaning files in different levels have the same target.
    
    指定者:
    
    setTargetFileSizeMultiplier 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    multiplier - the size ratio between a level-(L+1) file and level-L file.
    
    返回:
    
    the reference to the current options.
  - setMaxBytesForLevelBase
```
public Options setMaxBytesForLevelBase(long maxBytesForLevelBase)
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    The upper-bound of the total size of level-1 files in bytes. Maximum number of bytes for level L can be calculated as (maxBytesForLevelBase) * (maxBytesForLevelMultiplier ^ (L-1)) For example, if maxBytesForLevelBase is 20MB, and if max_bytes_for_level_multiplier is 10, total data size for level-1 will be 200MB, total file size for level-2 will be 2GB, and total file size for level-3 will be 20GB. by default 'maxBytesForLevelBase' is 256MB.
    
    指定者:
    
    setMaxBytesForLevelBase 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxBytesForLevelBase - maximum bytes for level base.
    
    返回:
    
    the reference to the current option.
    See AdvancedMutableColumnFamilyOptionsInterface.setMaxBytesForLevelMultiplier(double)
  - maxBytesForLevelBase
```
public long maxBytesForLevelBase()
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    The upper-bound of the total size of level-1 files in bytes. Maximum number of bytes for level L can be calculated as (maxBytesForLevelBase) * (maxBytesForLevelMultiplier ^ (L-1)) For example, if maxBytesForLevelBase is 20MB, and if max_bytes_for_level_multiplier is 10, total data size for level-1 will be 200MB, total file size for level-2 will be 2GB, and total file size for level-3 will be 20GB. by default 'maxBytesForLevelBase' is 256MB.
    
    指定者:
    
    maxBytesForLevelBase 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the upper-bound of the total size of level-1 files in bytes.
    See AdvancedMutableColumnFamilyOptionsInterface.maxBytesForLevelMultiplier()
  - setLevelCompactionDynamicLevelBytes
```
public Options setLevelCompactionDynamicLevelBytes(boolean enableLevelCompactionDynamicLevelBytes)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    If true, RocksDB will pick target size of each level dynamically. We will pick a base level b >= 1. L0 will be directly merged into level b, instead of always into level 1. Level 1 to b-1 need to be empty. We try to pick b and its target size so that
    1. target size is in the range of (max_bytes_for_level_base / max_bytes_for_level_multiplier, max_bytes_for_level_base]
    2. target size of the last level (level num_levels-1) equals to extra size of the level.
    At the same time max_bytes_for_level_multiplier and max_bytes_for_level_multiplier_additional are still satisfied.
    
    With this option on, from an empty DB, we make last level the base level, which means merging L0 data into the last level, until it exceeds max_bytes_for_level_base. And then we make the second last level to be base level, to start to merge L0 data to second last level, with its target size to be 1/max_bytes_for_level_multiplier of the last levels extra size. After the data accumulates more so that we need to move the base level to the third last one, and so on.
    
    Example
    
    For example, assume max_bytes_for_level_multiplier=10, num_levels=6, and max_bytes_for_level_base=10MB.
    
    Target sizes of level 1 to 5 starts with:
    [- - - - 10MB]
    with base level is level. Target sizes of level 1 to 4 are not applicable because they will not be used. Until the size of Level 5 grows to more than 10MB, say 11MB, we make base target to level 4 and now the targets looks like:
    [- - - 1.1MB 11MB]
    While data are accumulated, size targets are tuned based on actual data of level 5. When level 5 has 50MB of data, the target is like:
    [- - - 5MB 50MB]
    Until level 5's actual size is more than 100MB, say 101MB. Now if we keep level 4 to be the base level, its target size needs to be 10.1MB, which doesn't satisfy the target size range. So now we make level 3 the target size and the target sizes of the levels look like:
    [- - 1.01MB 10.1MB 101MB]
    In the same way, while level 5 further grows, all levels' targets grow, like
    [- - 5MB 50MB 500MB]
    Until level 5 exceeds 1000MB and becomes 1001MB, we make level 2 the base level and make levels' target sizes like this:
    [- 1.001MB 10.01MB 100.1MB 1001MB]
    and go on...
    
    By doing it, we give max_bytes_for_level_multiplier a priority against max_bytes_for_level_base, for a more predictable LSM tree shape. It is useful to limit worse case space amplification.
    
    max_bytes_for_level_multiplier_additional is ignored with this flag on.
    
    Turning this feature on or off for an existing DB can cause unexpected LSM tree structure so it's not recommended.
    
    Caution: this option is experimental
    
    Default: false
    指定者:
    
    setLevelCompactionDynamicLevelBytes 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    enableLevelCompactionDynamicLevelBytes - boolean value indicating if LevelCompactionDynamicLevelBytes shall be enabled.
    
    返回:
    
    the reference to the current options.
  - levelCompactionDynamicLevelBytes
```
public boolean levelCompactionDynamicLevelBytes()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Return if LevelCompactionDynamicLevelBytes is enabled.
    
    For further information see AdvancedColumnFamilyOptionsInterface.setLevelCompactionDynamicLevelBytes(boolean)
    
    指定者:
    
    levelCompactionDynamicLevelBytes 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    boolean value indicating if levelCompactionDynamicLevelBytes is enabled.
  - maxBytesForLevelMultiplier
```
public double maxBytesForLevelMultiplier()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    The ratio between the total size of level-(L+1) files and the total size of level-L files for all L. DEFAULT: 10
    
    指定者:
    
    maxBytesForLevelMultiplier 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    指定者:
    
    maxBytesForLevelMultiplier 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
  - setMaxBytesForLevelMultiplier
```
public Options setMaxBytesForLevelMultiplier(double multiplier)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    The ratio between the total size of level-(L+1) files and the total size of level-L files for all L. DEFAULT: 10
    
    指定者:
    
    setMaxBytesForLevelMultiplier 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    指定者:
    
    setMaxBytesForLevelMultiplier 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    multiplier - the ratio between the total size of level-(L+1) files and the total size of level-L files for all L.
    
    返回:
    
    the reference to the current option.
  - maxCompactionBytes
```
public long maxCompactionBytes()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Control maximum size of each compaction (not guaranteed)
    
    指定者:
    
    maxCompactionBytes 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    指定者:
    
    maxCompactionBytes 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    compaction size threshold
    
    另请参阅:
    
    MutableColumnFamilyOptionsInterface.setMaxCompactionBytes(long)
  - setMaxCompactionBytes
```
public Options setMaxCompactionBytes(long maxCompactionBytes)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Maximum size of each compaction (not guarantee)
    
    指定者:
    
    setMaxCompactionBytes 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    指定者:
    
    setMaxCompactionBytes 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxCompactionBytes - the compaction size limit
    
    返回:
    
    the reference to the current options.
    
    另请参阅:
    
    MutableColumnFamilyOptionsInterface.maxCompactionBytes()
  - arenaBlockSize
```
public long arenaBlockSize()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    The size of one block in arena memory allocation. If ≤ 0, a proper value is automatically calculated (usually 1/10 of writer_buffer_size).
    There are two additional restriction of the specified size: (1) size should be in the range of [4096, 2 << 30] and (2) be the multiple of the CPU word (which helps with the memory alignment).
    We'll automatically check and adjust the size number to make sure it conforms to the restrictions. Default: 0
    
    指定者:
    
    arenaBlockSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the size of an arena block
  - setArenaBlockSize
```
public Options setArenaBlockSize(long arenaBlockSize)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    The size of one block in arena memory allocation. If ≤ 0, a proper value is automatically calculated (usually 1/10 of writer_buffer_size).
    There are two additional restriction of the specified size: (1) size should be in the range of [4096, 2 << 30] and (2) be the multiple of the CPU word (which helps with the memory alignment).
    We'll automatically check and adjust the size number to make sure it conforms to the restrictions. Default: 0
    
    指定者:
    
    setArenaBlockSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    arenaBlockSize - the size of an arena block
    
    返回:
    
    the reference to the current options.
  - disableAutoCompactions
```
public boolean disableAutoCompactions()
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Disable automatic compactions. Manual compactions can still be issued on this column family
    
    指定者:
    
    disableAutoCompactions 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if auto-compactions are disabled.
  - setDisableAutoCompactions
```
public Options setDisableAutoCompactions(boolean disableAutoCompactions)
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Disable automatic compactions. Manual compactions can still be issued on this column family
    
    指定者:
    
    setDisableAutoCompactions 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    disableAutoCompactions - true if auto-compactions are disabled.
    
    返回:
    
    the reference to the current option.
  - maxSequentialSkipInIterations
```
public long maxSequentialSkipInIterations()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    An iteration->Next() sequentially skips over keys with the same user-key unless this option is set. This number specifies the number of keys (with the same userkey) that will be sequentially skipped before a reseek is issued. Default: 8
    
    指定者:
    
    maxSequentialSkipInIterations 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the number of keys could be skipped in an iteration.
  - setMaxSequentialSkipInIterations
```
public Options setMaxSequentialSkipInIterations(long maxSequentialSkipInIterations)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    An iteration->Next() sequentially skips over keys with the same user-key unless this option is set. This number specifies the number of keys (with the same userkey) that will be sequentially skipped before a reseek is issued. Default: 8
    
    指定者:
    
    setMaxSequentialSkipInIterations 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxSequentialSkipInIterations - the number of keys could be skipped in an iteration.
    
    返回:
    
    the reference to the current options.
  - inplaceUpdateSupport
```
public boolean inplaceUpdateSupport()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Allows thread-safe inplace updates. If inplace_callback function is not set, Put(key, new_value) will update inplace the existing_value iff * key exists in current memtable * new sizeof(new_value) ≤ sizeof(existing_value) * existing_value for that key is a put i.e. kTypeValue If inplace_callback function is set, check doc for inplace_callback. Default: false.
    
    指定者:
    
    inplaceUpdateSupport 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if thread-safe inplace updates are allowed.
  - setInplaceUpdateSupport
```
public Options setInplaceUpdateSupport(boolean inplaceUpdateSupport)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Allows thread-safe inplace updates. If inplace_callback function is not set, Put(key, new_value) will update inplace the existing_value iff * key exists in current memtable * new sizeof(new_value) ≤ sizeof(existing_value) * existing_value for that key is a put i.e. kTypeValue If inplace_callback function is set, check doc for inplace_callback. Default: false.
    
    指定者:
    
    setInplaceUpdateSupport 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    inplaceUpdateSupport - true if thread-safe inplace updates are allowed.
    
    返回:
    
    the reference to the current options.
  - inplaceUpdateNumLocks
```
public long inplaceUpdateNumLocks()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
    
    指定者:
    
    inplaceUpdateNumLocks 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the number of locks used for inplace update.
  - setInplaceUpdateNumLocks
```
public Options setInplaceUpdateNumLocks(long inplaceUpdateNumLocks)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Number of locks used for inplace update Default: 10000, if inplace_update_support = true, else 0.
    
    指定者:
    
    setInplaceUpdateNumLocks 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    inplaceUpdateNumLocks - the number of locks used for inplace updates.
    
    返回:
    
    the reference to the current options.
  - memtablePrefixBloomSizeRatio
```
public double memtablePrefixBloomSizeRatio()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio. If it is larger than 0.25, it is sanitized to 0.25.
    Default: 0 (disabled)
    
    指定者:
    
    memtablePrefixBloomSizeRatio 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the ratio of memtable used by the bloom filter
  - setMemtablePrefixBloomSizeRatio
```
public Options setMemtablePrefixBloomSizeRatio(double memtablePrefixBloomSizeRatio)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0, create prefix bloom for memtable with the size of write_buffer_size * memtable_prefix_bloom_size_ratio. If it is larger than 0.25, it is sanitized to 0.25.
    Default: 0 (disabled)
    
    指定者:
    
    setMemtablePrefixBloomSizeRatio 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    memtablePrefixBloomSizeRatio - the ratio of memtable used by the bloom filter, 0 means no bloom filter
    
    返回:
    
    the reference to the current options.
  - experimentalMempurgeThreshold
```
public double experimentalMempurgeThreshold()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Threshold used in the MemPurge (memtable garbage collection) feature. A value of 0.0 corresponds to no MemPurge, a value of 1.0 will trigger a MemPurge as often as possible.
    Default: 0 (disabled)
    
    指定者:
    
    experimentalMempurgeThreshold 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the threshold used by the MemPurge decider
  - setExperimentalMempurgeThreshold
```
public Options setExperimentalMempurgeThreshold(double experimentalMempurgeThreshold)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Threshold used in the MemPurge (memtable garbage collection) feature. A value of 0.0 corresponds to no MemPurge, a value of 1.0 will trigger a MemPurge as often as possible.
    Default: 0.0 (disabled)
    
    指定者:
    
    setExperimentalMempurgeThreshold 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    experimentalMempurgeThreshold - the threshold used by the MemPurge decider.
    
    返回:
    
    the reference to the current options.
  - memtableWholeKeyFiltering
```
public boolean memtableWholeKeyFiltering()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Returns whether whole key bloom filter is enabled in memtable
    
    指定者:
    
    memtableWholeKeyFiltering 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if whole key bloom filter is enabled in memtable
  - setMemtableWholeKeyFiltering
```
public Options setMemtableWholeKeyFiltering(boolean memtableWholeKeyFiltering)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Enable whole key bloom filter in memtable. Note this will only take effect if memtable_prefix_bloom_size_ratio is not 0. Enabling whole key filtering can potentially reduce CPU usage for point-look-ups.
    Default: false (disabled)
    
    指定者:
    
    setMemtableWholeKeyFiltering 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    memtableWholeKeyFiltering - true if whole key bloom filter is enabled in memtable
    
    返回:
    
    the reference to the current options.
  - bloomLocality
```
public int bloomLocality()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Control locality of bloom filter probes to improve cache miss rate. This option only applies to memtable prefix bloom and plaintable prefix bloom. It essentially limits the max number of cache lines each bloom filter check can touch. This optimization is turned off when set to 0. The number should never be greater than number of probes. This option can boost performance for in-memory workload but should use with care since it can cause higher false positive rate. Default: 0
    
    指定者:
    
    bloomLocality 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the level of locality of bloom-filter probes.
    
    另请参阅:
    
    AdvancedColumnFamilyOptionsInterface.setBloomLocality(int)
  - setBloomLocality
```
public Options setBloomLocality(int bloomLocality)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Control locality of bloom filter probes to improve cache miss rate. This option only applies to memtable prefix bloom and plaintable prefix bloom. It essentially limits the max number of cache lines each bloom filter check can touch. This optimization is turned off when set to 0. The number should never be greater than number of probes. This option can boost performance for in-memory workload but should use with care since it can cause higher false positive rate. Default: 0
    
    指定者:
    
    setBloomLocality 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    bloomLocality - the level of locality of bloom-filter probes.
    
    返回:
    
    the reference to the current options.
  - maxSuccessiveMerges
```
public long maxSuccessiveMerges()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Maximum number of successive merge operations on a key in the memtable.
    When a merge operation is added to the memtable and the maximum number of successive merges is reached, the value of the key will be calculated and inserted into the memtable instead of the merge operation. This will ensure that there are never more than max_successive_merges merge operations in the memtable.
    Default: 0 (disabled)
    
    指定者:
    
    maxSuccessiveMerges 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the maximum number of successive merges.
  - setMaxSuccessiveMerges
```
public Options setMaxSuccessiveMerges(long maxSuccessiveMerges)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Maximum number of successive merge operations on a key in the memtable.
    When a merge operation is added to the memtable and the maximum number of successive merges is reached, the value of the key will be calculated and inserted into the memtable instead of the merge operation. This will ensure that there are never more than max_successive_merges merge operations in the memtable.
    Default: 0 (disabled)
    
    指定者:
    
    setMaxSuccessiveMerges 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxSuccessiveMerges - the maximum number of successive merges.
    
    返回:
    
    the reference to the current options.
  - minWriteBufferNumberToMerge
```
public int minWriteBufferNumberToMerge()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The minimum number of write buffers that will be merged together before writing to storage. If set to 1, then all write buffers are flushed to L0 as individual files and this increases read amplification because a get request has to check in all of these files. Also, an in-memory merge may result in writing lesser data to storage if there are duplicate records in each of these individual write buffers. Default: 1
    
    指定者:
    
    minWriteBufferNumberToMerge 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the minimum number of write buffers that will be merged together.
  - setMinWriteBufferNumberToMerge
```
public Options setMinWriteBufferNumberToMerge(int minWriteBufferNumberToMerge)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The minimum number of write buffers that will be merged together before writing to storage. If set to 1, then all write buffers are flushed to L0 as individual files and this increases read amplification because a get request has to check in all of these files. Also, an in-memory merge may result in writing lesser data to storage if there are duplicate records in each of these individual write buffers. Default: 1
    
    指定者:
    
    setMinWriteBufferNumberToMerge 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    minWriteBufferNumberToMerge - the minimum number of write buffers that will be merged together.
    
    返回:
    
    the reference to the current options.
  - setOptimizeFiltersForHits
```
public Options setOptimizeFiltersForHits(boolean optimizeFiltersForHits)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    This flag specifies that the implementation should optimize the filters mainly for cases where keys are found rather than also optimize for keys missed. This would be used in cases where the application knows that there are very few misses or the performance in the case of misses is not important.
    
    For now, this flag allows us to not store filters for the last level i.e the largest level which contains data of the LSM store. For keys which are hits, the filters in this level are not useful because we will search for the data anyway.
    
    NOTE: the filters in other levels are still useful even for key hit because they tell us whether to look in that level or go to the higher level.
    
    Default: false
    
    指定者:
    
    setOptimizeFiltersForHits 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    optimizeFiltersForHits - boolean value indicating if this flag is set.
    
    返回:
    
    the reference to the current options.
  - optimizeFiltersForHits
```
public boolean optimizeFiltersForHits()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Returns the current state of the optimize_filters_for_hits setting.
    
    指定者:
    
    optimizeFiltersForHits 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    boolean value indicating if the flag optimize_filters_for_hits was set.
  - setMemtableHugePageSize
```
public Options setMemtableHugePageSize(long memtableHugePageSize)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Page size for huge page TLB for bloom in memtable. If ≤ 0, not allocate from huge page TLB but from malloc. Need to reserve huge pages for it to be allocated. For example: sysctl -w vm.nr_hugepages=20 See linux doc Documentation/vm/hugetlbpage.txt
    
    指定者:
    
    setMemtableHugePageSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    memtableHugePageSize - The page size of the huge page tlb
    
    返回:
    
    the reference to the current options.
  - memtableHugePageSize
```
public long memtableHugePageSize()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Page size for huge page TLB for bloom in memtable. If ≤ 0, not allocate from huge page TLB but from malloc. Need to reserve huge pages for it to be allocated. For example: sysctl -w vm.nr_hugepages=20 See linux doc Documentation/vm/hugetlbpage.txt
    
    指定者:
    
    memtableHugePageSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The page size of the huge page tlb
  - setSoftPendingCompactionBytesLimit
```
public Options setSoftPendingCompactionBytesLimit(long softPendingCompactionBytesLimit)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold.
    Default: 64GB
    
    指定者:
    
    setSoftPendingCompactionBytesLimit 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    softPendingCompactionBytesLimit - The soft limit to impose on compaction
    
    返回:
    
    the reference to the current options.
  - softPendingCompactionBytesLimit
```
public long softPendingCompactionBytesLimit()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    All writes will be slowed down to at least delayed_write_rate if estimated bytes needed to be compaction exceed this threshold.
    Default: 64GB
    
    指定者:
    
    softPendingCompactionBytesLimit 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The soft limit to impose on compaction
  - setHardPendingCompactionBytesLimit
```
public Options setHardPendingCompactionBytesLimit(long hardPendingCompactionBytesLimit)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    All writes are stopped if estimated bytes needed to be compaction exceed this threshold.
    Default: 256GB
    
    指定者:
    
    setHardPendingCompactionBytesLimit 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    hardPendingCompactionBytesLimit - The hard limit to impose on compaction
    
    返回:
    
    the reference to the current options.
  - hardPendingCompactionBytesLimit
```
public long hardPendingCompactionBytesLimit()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    All writes are stopped if estimated bytes needed to be compaction exceed this threshold.
    Default: 256GB
    
    指定者:
    
    hardPendingCompactionBytesLimit 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The hard limit to impose on compaction
  - setLevel0FileNumCompactionTrigger
```
public Options setLevel0FileNumCompactionTrigger(int level0FileNumCompactionTrigger)
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Number of files to trigger level-0 compaction. A value < 0 means that level-0 compaction will not be triggered by number of files at all.
    Default: 4
    
    指定者:
    
    setLevel0FileNumCompactionTrigger 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    level0FileNumCompactionTrigger - The number of files to trigger level-0 compaction
    
    返回:
    
    the reference to the current option.
  - level0FileNumCompactionTrigger
```
public int level0FileNumCompactionTrigger()
```
    从接口复制的说明: MutableColumnFamilyOptionsInterface
    
    Number of files to trigger level-0 compaction. A value < 0 means that level-0 compaction will not be triggered by number of files at all.
    Default: 4
    
    指定者:
    
    level0FileNumCompactionTrigger 在接口中 MutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The number of files to trigger
  - setLevel0SlowdownWritesTrigger
```
public Options setLevel0SlowdownWritesTrigger(int level0SlowdownWritesTrigger)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Soft limit on number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    指定者:
    
    setLevel0SlowdownWritesTrigger 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    level0SlowdownWritesTrigger - The soft limit on the number of level-0 files
    
    返回:
    
    the reference to the current options.
  - level0SlowdownWritesTrigger
```
public int level0SlowdownWritesTrigger()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Soft limit on number of level-0 files. We start slowing down writes at this point. A value < 0 means that no writing slow down will be triggered by number of files in level-0.
    
    指定者:
    
    level0SlowdownWritesTrigger 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The soft limit on the number of level-0 files
  - setLevel0StopWritesTrigger
```
public Options setLevel0StopWritesTrigger(int level0StopWritesTrigger)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    指定者:
    
    setLevel0StopWritesTrigger 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    level0StopWritesTrigger - The maximum number of level-0 files
    
    返回:
    
    the reference to the current options.
  - level0StopWritesTrigger
```
public int level0StopWritesTrigger()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Maximum number of level-0 files. We stop writes at this point.
    
    指定者:
    
    level0StopWritesTrigger 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The maximum number of level-0 files
  - setMaxBytesForLevelMultiplierAdditional
```
public Options setMaxBytesForLevelMultiplierAdditional(int[] maxBytesForLevelMultiplierAdditional)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Different max-size multipliers for different levels. These are multiplied by max_bytes_for_level_multiplier to arrive at the max-size of each level.
    Default: 1
    
    指定者:
    
    setMaxBytesForLevelMultiplierAdditional 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxBytesForLevelMultiplierAdditional - The max-size multipliers for each level
    
    返回:
    
    the reference to the current options.
  - maxBytesForLevelMultiplierAdditional
```
public int[] maxBytesForLevelMultiplierAdditional()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Different max-size multipliers for different levels. These are multiplied by max_bytes_for_level_multiplier to arrive at the max-size of each level.
    Default: 1
    
    指定者:
    
    maxBytesForLevelMultiplierAdditional 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The max-size multipliers for each level
  - setParanoidFileChecks
```
public Options setParanoidFileChecks(boolean paranoidFileChecks)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    After writing every SST file, reopen it and read all the keys.
    Default: false
    
    指定者:
    
    setParanoidFileChecks 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    paranoidFileChecks - true to enable paranoid file checks
    
    返回:
    
    the reference to the current options.
  - paranoidFileChecks
```
public boolean paranoidFileChecks()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    After writing every SST file, reopen it and read all the keys.
    Default: false
    
    指定者:
    
    paranoidFileChecks 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if paranoid file checks are enabled
  - setMaxWriteBufferNumberToMaintain
```
public Options setMaxWriteBufferNumberToMaintain(int maxWriteBufferNumberToMaintain)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The total maximum number of write buffers to maintain in memory including copies of buffers that have already been flushed. Unlike AdvancedMutableColumnFamilyOptionsInterface.maxWriteBufferNumber(), this parameter does not affect flushing. This controls the minimum amount of write history that will be available in memory for conflict checking when Transactions are used.
    When using an OptimisticTransactionDB: If this value is too low, some transactions may fail at commit time due to not being able to determine whether there were any write conflicts.
    When using a TransactionDB: If Transaction::SetSnapshot is used, TransactionDB will read either in-memory write buffers or SST files to do write-conflict checking. Increasing this value can reduce the number of reads to SST files done for conflict detection.
    Setting this value to 0 will cause write buffers to be freed immediately after they are flushed. If this value is set to -1, AdvancedMutableColumnFamilyOptionsInterface.maxWriteBufferNumber() will be used.
    Default: If using a TransactionDB/OptimisticTransactionDB, the default value will be set to the value of AdvancedMutableColumnFamilyOptionsInterface.maxWriteBufferNumber() if it is not explicitly set by the user. Otherwise, the default is 0.
    
    指定者:
    
    setMaxWriteBufferNumberToMaintain 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    maxWriteBufferNumberToMaintain - The maximum number of write buffers to maintain
    
    返回:
    
    the reference to the current options.
  - maxWriteBufferNumberToMaintain
```
public int maxWriteBufferNumberToMaintain()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The total maximum number of write buffers to maintain in memory including copies of buffers that have already been flushed.
    
    指定者:
    
    maxWriteBufferNumberToMaintain 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    maxWriteBufferNumberToMaintain The maximum number of write buffers to maintain
  - setCompactionPriority
```
public Options setCompactionPriority(CompactionPriority compactionPriority)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    If level AdvancedColumnFamilyOptionsInterface.compactionStyle() == CompactionStyle.LEVEL, for each level, which files are prioritized to be picked to compact.
    Default: CompactionPriority.ByCompensatedSize
    
    指定者:
    
    setCompactionPriority 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionPriority - The compaction priority
    
    返回:
    
    the reference to the current options.
  - compactionPriority
```
public CompactionPriority compactionPriority()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Get the Compaction priority if level compaction is used for all levels
    
    指定者:
    
    compactionPriority 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The compaction priority
  - setReportBgIoStats
```
public Options setReportBgIoStats(boolean reportBgIoStats)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Measure IO stats in compactions and flushes, if true.
    Default: false
    
    指定者:
    
    setReportBgIoStats 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    reportBgIoStats - true to enable reporting
    
    返回:
    
    the reference to the current options.
  - reportBgIoStats
```
public boolean reportBgIoStats()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Determine whether IO stats in compactions and flushes are being measured
    
    指定者:
    
    reportBgIoStats 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if reporting is enabled
  - setTtl
```
public Options setTtl(long ttl)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Non-bottom-level files older than TTL will go through the compaction process. This needs MutableDBOptionsInterface.maxOpenFiles() to be set to -1.
    Enabled only for level compaction for now.
    Default: 0 (disabled)
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setTtl 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    ttl - the time-to-live.
    
    返回:
    
    the reference to the current options.
  - ttl
```
public long ttl()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the TTL for Non-bottom-level files that will go through the compaction process.
    See AdvancedMutableColumnFamilyOptionsInterface.setTtl(long).
    
    指定者:
    
    ttl 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the time-to-live.
  - setPeriodicCompactionSeconds
```
public Options setPeriodicCompactionSeconds(long periodicCompactionSeconds)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Files older than this value will be picked up for compaction, and re-written to the same level as they were before. One main use of the feature is to make sure a file goes through compaction filters periodically. Users can also use the feature to clear up SST files using old format.
    A file's age is computed by looking at file_creation_time or creation_time table properties in order, if they have valid non-zero values; if not, the age is based on the file's last modified time (given by the underlying Env).
    Supported in Level and FIFO compaction. In FIFO compaction, this option has the same meaning as TTL and whichever stricter will be used. Pre-req: max_open_file == -1. unit: seconds. Ex: 7 days = 7 * 24 * 60 * 60
    Values: 0: Turn off Periodic compactions. UINT64_MAX - 1 (i.e 0xfffffffffffffffe): Let RocksDB control this feature as needed. For now, RocksDB will change this value to 30 days (i.e 30 * 24 * 60 * 60) so that every file goes through the compaction process at least once every 30 days if not compacted sooner. In FIFO compaction, since the option has the same meaning as ttl, when this value is left default, and ttl is left to 0, 30 days will be used. Otherwise, min(ttl, periodic_compaction_seconds) will be used.
    Default: 0xfffffffffffffffe (allow RocksDB to auto-tune)
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setPeriodicCompactionSeconds 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    periodicCompactionSeconds - the periodic compaction in seconds.
    
    返回:
    
    the reference to the current options.
  - periodicCompactionSeconds
```
public long periodicCompactionSeconds()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the periodicCompactionSeconds.
    See AdvancedMutableColumnFamilyOptionsInterface.setPeriodicCompactionSeconds(long).
    
    指定者:
    
    periodicCompactionSeconds 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the periodic compaction in seconds.
  - setCompactionOptionsUniversal
```
public Options setCompactionOptionsUniversal(CompactionOptionsUniversal compactionOptionsUniversal)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    Set the options needed to support Universal Style compactions
    
    指定者:
    
    setCompactionOptionsUniversal 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionOptionsUniversal - The Universal Style compaction options
    
    返回:
    
    the reference to the current options.
  - compactionOptionsUniversal
```
public CompactionOptionsUniversal compactionOptionsUniversal()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The options needed to support Universal Style compactions
    
    指定者:
    
    compactionOptionsUniversal 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The Universal Style compaction options
  - setCompactionOptionsFIFO
```
public Options setCompactionOptionsFIFO(CompactionOptionsFIFO compactionOptionsFIFO)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The options for FIFO compaction style
    
    指定者:
    
    setCompactionOptionsFIFO 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionOptionsFIFO - The FIFO compaction options
    
    返回:
    
    the reference to the current options.
  - compactionOptionsFIFO
```
public CompactionOptionsFIFO compactionOptionsFIFO()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    The options for FIFO compaction style
    
    指定者:
    
    compactionOptionsFIFO 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    The FIFO compaction options
  - setForceConsistencyChecks
```
public Options setForceConsistencyChecks(boolean forceConsistencyChecks)
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    By default, RocksDB runs consistency checks on the LSM every time the LSM changes (Flush, Compaction, AddFile). Use this option if you need to disable them.
    Default: true
    
    指定者:
    
    setForceConsistencyChecks 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    参数:
    
    forceConsistencyChecks - false to disable consistency checks
    
    返回:
    
    the reference to the current options.
  - forceConsistencyChecks
```
public boolean forceConsistencyChecks()
```
    从接口复制的说明: AdvancedColumnFamilyOptionsInterface
    
    By default, RocksDB runs consistency checks on the LSM every time the LSM changes (Flush, Compaction, AddFile).
    
    指定者:
    
    forceConsistencyChecks 在接口中 AdvancedColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if consistency checks are enforced
  - setAtomicFlush
```
public Options setAtomicFlush(boolean atomicFlush)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, RocksDB supports flushing multiple column families and committing their results atomically to MANIFEST. Note that it is not necessary to set atomic_flush to true if WAL is always enabled since WAL allows the database to be restored to the last persistent state in WAL. This option is useful when there are column families with writes NOT protected by WAL. For manual flush, application has to specify which column families to flush atomically in RocksDB.flush(FlushOptions, List). For auto-triggered flush, RocksDB atomically flushes ALL column families. Currently, any WAL-enabled writes after atomic flush may be replayed independently if the process crashes later and tries to recover.
    
    指定者:
    
    setAtomicFlush 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    atomicFlush - true to enable atomic flush of multiple column families.
    
    返回:
    
    the reference to the current options.
  - atomicFlush
```
public boolean atomicFlush()
```
    从接口复制的说明: DBOptionsInterface
    
    Determine if atomic flush of multiple column families is enabled. See DBOptionsInterface.setAtomicFlush(boolean).
    
    指定者:
    
    atomicFlush 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if atomic flush is enabled.
  - setAvoidUnnecessaryBlockingIO
```
public Options setAvoidUnnecessaryBlockingIO(boolean avoidUnnecessaryBlockingIO)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it. Use it if you're latency-sensitive. If set to true, takes precedence over ReadOptions.setBackgroundPurgeOnIteratorCleanup(boolean).
    
    指定者:
    
    setAvoidUnnecessaryBlockingIO 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    avoidUnnecessaryBlockingIO - If true, working thread may avoid doing unnecessary operation.
    
    返回:
    
    the reference to the current options.
  - avoidUnnecessaryBlockingIO
```
public boolean avoidUnnecessaryBlockingIO()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, working thread may avoid doing unnecessary and long-latency operation (such as deleting obsolete files directly or deleting memtable) and will instead schedule a background job to do it. Use it if you're latency-sensitive. If set to true, takes precedence over ReadOptions.setBackgroundPurgeOnIteratorCleanup(boolean).
    
    指定者:
    
    avoidUnnecessaryBlockingIO 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true, if working thread may avoid doing unnecessary operation.
  - setPersistStatsToDisk
```
public Options setPersistStatsToDisk(boolean persistStatsToDisk)
```
    从接口复制的说明: DBOptionsInterface
    
    If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct. User can query through `GetStatsHistory` API. If user attempts to create a column family with the same name on a DB which have previously set persist_stats_to_disk to true, the column family creation will fail, but the hidden column family will survive, as well as the previously persisted statistics. When peristing stats to disk, the stat name will be limited at 100 bytes. Default: false
    
    指定者:
    
    setPersistStatsToDisk 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    persistStatsToDisk - true if stats should be persisted to hidden column family.
    
    返回:
    
    the instance of the current object.
  - persistStatsToDisk
```
public boolean persistStatsToDisk()
```
    从接口复制的说明: DBOptionsInterface
    
    If true, automatically persist stats to a hidden column family (column family name: ___rocksdb_stats_history___) every stats_persist_period_sec seconds; otherwise, write to an in-memory struct. User can query through `GetStatsHistory` API. If user attempts to create a column family with the same name on a DB which have previously set persist_stats_to_disk to true, the column family creation will fail, but the hidden column family will survive, as well as the previously persisted statistics. When peristing stats to disk, the stat name will be limited at 100 bytes. Default: false
    
    指定者:
    
    persistStatsToDisk 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true if stats should be persisted to hidden column family.
  - setWriteDbidToManifest
```
public Options setWriteDbidToManifest(boolean writeDbidToManifest)
```
    从接口复制的说明: DBOptionsInterface
    
    Historically DB ID has always been stored in Identity File in DB folder. If this flag is true, the DB ID is written to Manifest file in addition to the Identity file. By doing this 2 problems are solved 1. We don't checksum the Identity file where as Manifest file is. 2. Since the source of truth for DB is Manifest file DB ID will sit with the source of truth. Previously the Identity file could be copied independent of Manifest and that can result in wrong DB ID. We recommend setting this flag to true. Default: false
    
    指定者:
    
    setWriteDbidToManifest 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    writeDbidToManifest - if true, then DB ID will be written to Manifest file.
    
    返回:
    
    the instance of the current object.
  - writeDbidToManifest
```
public boolean writeDbidToManifest()
```
    从接口复制的说明: DBOptionsInterface
    
    Historically DB ID has always been stored in Identity File in DB folder. If this flag is true, the DB ID is written to Manifest file in addition to the Identity file. By doing this 2 problems are solved 1. We don't checksum the Identity file where as Manifest file is. 2. Since the source of truth for DB is Manifest file DB ID will sit with the source of truth. Previously the Identity file could be copied independent of Manifest and that can result in wrong DB ID. We recommend setting this flag to true. Default: false
    
    指定者:
    
    writeDbidToManifest 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true, if DB ID will be written to Manifest file.
  - setLogReadaheadSize
```
public Options setLogReadaheadSize(long logReadaheadSize)
```
    从接口复制的说明: DBOptionsInterface
    
    The number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0, then the prefetching is disabled. Default: 0
    
    指定者:
    
    setLogReadaheadSize 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    logReadaheadSize - the number of bytes to prefetch when reading the log.
    
    返回:
    
    the instance of the current object.
  - logReadaheadSize
```
public long logReadaheadSize()
```
    从接口复制的说明: DBOptionsInterface
    
    The number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0, then the prefetching is disabled. Default: 0
    
    指定者:
    
    logReadaheadSize 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the number of bytes to prefetch when reading the log.
  - setBestEffortsRecovery
```
public Options setBestEffortsRecovery(boolean bestEffortsRecovery)
```
    从接口复制的说明: DBOptionsInterface
    
    By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST. Best-efforts recovery is another recovery mode that tries to restore the database to the most recent point in time without missing file. Currently not compatible with atomic flush. Furthermore, WAL files will not be used for recovery if best_efforts_recovery is true. Default: false
    
    指定者:
    
    setBestEffortsRecovery 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    bestEffortsRecovery - if true, RocksDB will use best-efforts mode when recovering.
    
    返回:
    
    the instance of the current object.
  - bestEffortsRecovery
```
public boolean bestEffortsRecovery()
```
    从接口复制的说明: DBOptionsInterface
    
    By default, RocksDB recovery fails if any table file referenced in MANIFEST are missing after scanning the MANIFEST. Best-efforts recovery is another recovery mode that tries to restore the database to the most recent point in time without missing file. Currently not compatible with atomic flush. Furthermore, WAL files will not be used for recovery if best_efforts_recovery is true. Default: false
    
    指定者:
    
    bestEffortsRecovery 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    true, if RocksDB uses best-efforts mode when recovering.
  - setMaxBgErrorResumeCount
```
public Options setMaxBgErrorResumeCount(int maxBgerrorResumeCount)
```
    从接口复制的说明: DBOptionsInterface
    
    It defines how many times db resume is called by a separate thread when background retryable IO Error happens. When background retryable IO Error happens, SetBGError is called to deal with the error. If the error can be auto-recovered (e.g., retryable IO Error during Flush or WAL write), then db resume is called in background to recover from the error. If this value is 0 or negative, db resume will not be called. Default: INT_MAX
    
    指定者:
    
    setMaxBgErrorResumeCount 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    maxBgerrorResumeCount - maximum number of times db resume should be called when IO Error happens.
    
    返回:
    
    the instance of the current object.
  - maxBgerrorResumeCount
```
public int maxBgerrorResumeCount()
```
    从接口复制的说明: DBOptionsInterface
    
    It defines how many times db resume is called by a separate thread when background retryable IO Error happens. When background retryable IO Error happens, SetBGError is called to deal with the error. If the error can be auto-recovered (e.g., retryable IO Error during Flush or WAL write), then db resume is called in background to recover from the error. If this value is 0 or negative, db resume will not be called. Default: INT_MAX
    
    指定者:
    
    maxBgerrorResumeCount 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    maximum number of times db resume should be called when IO Error happens.
  - setBgerrorResumeRetryInterval
```
public Options setBgerrorResumeRetryInterval(long bgerrorResumeRetryInterval)
```
    从接口复制的说明: DBOptionsInterface
    
    If max_bgerror_resume_count is ≥ 2, db resume is called multiple times. This option decides how long to wait to retry the next resume if the previous resume fails and satisfy redo resume conditions. Default: 1000000 (microseconds).
    
    指定者:
    
    setBgerrorResumeRetryInterval 在接口中 DBOptionsInterface<Options>
    
    参数:
    
    bgerrorResumeRetryInterval - how many microseconds to wait between DB resume attempts.
    
    返回:
    
    the instance of the current object.
  - bgerrorResumeRetryInterval
```
public long bgerrorResumeRetryInterval()
```
    从接口复制的说明: DBOptionsInterface
    
    If max_bgerror_resume_count is ≥ 2, db resume is called multiple times. This option decides how long to wait to retry the next resume if the previous resume fails and satisfy redo resume conditions. Default: 1000000 (microseconds).
    
    指定者:
    
    bgerrorResumeRetryInterval 在接口中 DBOptionsInterface<Options>
    
    返回:
    
    the instance of the current object.
  - setSstPartitionerFactory
```
public Options setSstPartitionerFactory(SstPartitionerFactory sstPartitionerFactory)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    If non-nullptr, use the specified factory for a function to determine the partitioning of sst files. This helps compaction to split the files on interesting boundaries (key prefixes) to make propagation of sst files less write amplifying (covering the whole key space).
    Default: nullptr
    
    指定者:
    
    setSstPartitionerFactory 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    sstPartitionerFactory - The factory reference
    
    返回:
    
    the reference of the current options.
  - sstPartitionerFactory
```
public SstPartitionerFactory sstPartitionerFactory()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Get SST partitioner factory
    
    指定者:
    
    sstPartitionerFactory 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    SST partitioner factory
  - setCompactionThreadLimiter
```
public Options setCompactionThreadLimiter(ConcurrentTaskLimiter compactionThreadLimiter)
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Compaction concurrent thread limiter for the column family. If non-nullptr, use given concurrent thread limiter to control the max outstanding compaction tasks. Limiter can be shared with multiple column families across db instances.
    
    指定者:
    
    setCompactionThreadLimiter 在接口中 ColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compactionThreadLimiter - The compaction thread limiter.
    
    返回:
    
    the reference of the current options.
  - compactionThreadLimiter
```
public ConcurrentTaskLimiter compactionThreadLimiter()
```
    从接口复制的说明: ColumnFamilyOptionsInterface
    
    Get compaction thread limiter
    
    指定者:
    
    compactionThreadLimiter 在接口中 ColumnFamilyOptionsInterface<Options>
    
    返回:
    
    Compaction thread limiter
  - setEnableBlobFiles
```
public Options setEnableBlobFiles(boolean enableBlobFiles)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    When set, large values (blobs) are written to separate blob files, and only pointers to them are stored in SST files. This can reduce write amplification for large-value use cases at the cost of introducing a level of indirection for reads. See also the options min_blob_size, blob_file_size, blob_compression_type, enable_blob_garbage_collection, and blob_garbage_collection_age_cutoff below.
    Default: false
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setEnableBlobFiles 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    enableBlobFiles - true iff blob files should be enabled
    
    返回:
    
    the reference to the current options.
  - enableBlobFiles
```
public boolean enableBlobFiles()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    When set, large values (blobs) are written to separate blob files, and only pointers to them are stored in SST files. This can reduce write amplification for large-value use cases at the cost of introducing a level of indirection for reads. See also the options min_blob_size, blob_file_size, blob_compression_type, enable_blob_garbage_collection, and blob_garbage_collection_age_cutoff below.
    Default: false
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    enableBlobFiles 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if blob files are enabled
  - setMinBlobSize
```
public Options setMinBlobSize(long minBlobSize)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set the size of the smallest value to be stored separately in a blob file. Values which have an uncompressed size smaller than this threshold are stored alongside the keys in SST files in the usual fashion. A value of zero for this option means that all values are stored in blob files. Note that enable_blob_files has to be set in order for this option to have any effect.
    Default: 0
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setMinBlobSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    minBlobSize - the size of the smallest value to be stored separately in a blob file
    
    返回:
    
    the reference to the current options.
  - minBlobSize
```
public long minBlobSize()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the size of the smallest value to be stored separately in a blob file. Values which have an uncompressed size smaller than this threshold are stored alongside the keys in SST files in the usual fashion. A value of zero for this option means that all values are stored in blob files. Note that enable_blob_files has to be set in order for this option to have any effect.
    Default: 0
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    minBlobSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current minimum size of value which is stored separately in a blob
  - setBlobFileSize
```
public Options setBlobFileSize(long blobFileSize)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set the size limit for blob files. When writing blob files, a new file is opened once this limit is reached. Note that enable_blob_files has to be set in order for this option to have any effect.
    Default: 256 MB
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setBlobFileSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    blobFileSize - the size limit for blob files
    
    返回:
    
    the reference to the current options.
  - blobFileSize
```
public long blobFileSize()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    The size limit for blob files. When writing blob files, a new file is opened once this limit is reached.
    
    指定者:
    
    blobFileSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current size limit for blob files
  - setBlobCompressionType
```
public Options setBlobCompressionType(CompressionType compressionType)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set the compression algorithm to use for large values stored in blob files. Note that enable_blob_files has to be set in order for this option to have any effect.
    Default: no compression
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setBlobCompressionType 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    compressionType - the compression algorithm to use.
    
    返回:
    
    the reference to the current options.
  - blobCompressionType
```
public CompressionType blobCompressionType()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the compression algorithm in use for large values stored in blob files. Note that enable_blob_files has to be set in order for this option to have any effect.
    
    指定者:
    
    blobCompressionType 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current compression algorithm
  - setEnableBlobGarbageCollection
```
public Options setEnableBlobGarbageCollection(boolean enableBlobGarbageCollection)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Enable/disable garbage collection of blobs. Blob GC is performed as part of compaction. Valid blobs residing in blob files older than a cutoff get relocated to new files as they are encountered during compaction, which makes it possible to clean up blob files once they contain nothing but obsolete/garbage blobs. See also blob_garbage_collection_age_cutoff below.
    Default: false
    
    指定者:
    
    setEnableBlobGarbageCollection 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    enableBlobGarbageCollection - the new enabled/disabled state of blob garbage collection
    
    返回:
    
    the reference to the current options.
  - enableBlobGarbageCollection
```
public boolean enableBlobGarbageCollection()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Query whether garbage collection of blobs is enabled.Blob GC is performed as part of compaction. Valid blobs residing in blob files older than a cutoff get relocated to new files as they are encountered during compaction, which makes it possible to clean up blob files once they contain nothing but obsolete/garbage blobs. See also blob_garbage_collection_age_cutoff below.
    Default: false
    
    指定者:
    
    enableBlobGarbageCollection 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    true if blob garbage collection is currently enabled.
  - setBlobGarbageCollectionAgeCutoff
```
public Options setBlobGarbageCollectionAgeCutoff(double blobGarbageCollectionAgeCutoff)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set cutoff in terms of blob file age for garbage collection. Blobs in the oldest N blob files will be relocated when encountered during compaction, where N = garbage_collection_cutoff * number_of_blob_files. Note that enable_blob_garbage_collection has to be set in order for this option to have any effect.
    Default: 0.25
    
    指定者:
    
    setBlobGarbageCollectionAgeCutoff 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    blobGarbageCollectionAgeCutoff - the new age cutoff
    
    返回:
    
    the reference to the current options.
  - blobGarbageCollectionAgeCutoff
```
public double blobGarbageCollectionAgeCutoff()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get cutoff in terms of blob file age for garbage collection. Blobs in the oldest N blob files will be relocated when encountered during compaction, where N = garbage_collection_cutoff * number_of_blob_files. Note that enable_blob_garbage_collection has to be set in order for this option to have any effect.
    Default: 0.25
    
    指定者:
    
    blobGarbageCollectionAgeCutoff 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current age cutoff for garbage collection
  - setBlobGarbageCollectionForceThreshold
```
public Options setBlobGarbageCollectionForceThreshold(double blobGarbageCollectionForceThreshold)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    If the ratio of garbage in the oldest blob files exceeds this threshold, targeted compactions are scheduled in order to force garbage collecting the blob files in question, assuming they are all eligible based on the value of AdvancedMutableColumnFamilyOptionsInterface.blobGarbageCollectionAgeCutoff() above. This option is currently only supported with leveled compactions.
    Note that AdvancedMutableColumnFamilyOptionsInterface.enableBlobGarbageCollection() has to be set in order for this option to have any effect.
    Default: 1.0
    Dynamically changeable through the SetOptions() API
    
    指定者:
    
    setBlobGarbageCollectionForceThreshold 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    blobGarbageCollectionForceThreshold - new value for the threshold
    
    返回:
    
    the reference to the current options
  - blobGarbageCollectionForceThreshold
```
public double blobGarbageCollectionForceThreshold()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the current value for the #blobGarbageCollectionForceThreshold
    
    指定者:
    
    blobGarbageCollectionForceThreshold 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current threshold at which garbage collection of blobs is forced
  - setBlobCompactionReadaheadSize
```
public Options setBlobCompactionReadaheadSize(long blobCompactionReadaheadSize)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set compaction readahead for blob files.
    Default: 0
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setBlobCompactionReadaheadSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    blobCompactionReadaheadSize - the compaction readahead for blob files
    
    返回:
    
    the reference to the current options.
  - blobCompactionReadaheadSize
```
public long blobCompactionReadaheadSize()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get compaction readahead for blob files.
    
    指定者:
    
    blobCompactionReadaheadSize 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current compaction readahead for blob files
  - setBlobFileStartingLevel
```
public Options setBlobFileStartingLevel(int blobFileStartingLevel)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set a certain LSM tree level to enable blob files.
    Default: 0
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setBlobFileStartingLevel 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    blobFileStartingLevel - the starting level to enable blob files
    
    返回:
    
    the reference to the current options.
  - blobFileStartingLevel
```
public int blobFileStartingLevel()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the starting LSM tree level to enable blob files.
    Default: 0
    
    指定者:
    
    blobFileStartingLevel 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current LSM tree level to enable blob files.
  - setPrepopulateBlobCache
```
public Options setPrepopulateBlobCache(PrepopulateBlobCache prepopulateBlobCache)
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Set a certain prepopulate blob cache option.
    Default: 0
    Dynamically changeable through RocksDB.setOptions(ColumnFamilyHandle, MutableColumnFamilyOptions).
    
    指定者:
    
    setPrepopulateBlobCache 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    参数:
    
    prepopulateBlobCache - prepopulate the blob cache option
    
    返回:
    
    the reference to the current options.
  - prepopulateBlobCache
```
public PrepopulateBlobCache prepopulateBlobCache()
```
    从接口复制的说明: AdvancedMutableColumnFamilyOptionsInterface
    
    Get the prepopulate blob cache option.
    Default: 0
    
    指定者:
    
    prepopulateBlobCache 在接口中 AdvancedMutableColumnFamilyOptionsInterface<Options>
    
    返回:
    
    the current prepopulate blob cache option.
  - disposeInternal
```
protected final void disposeInternal(long handle)
```
    指定者:
    
    disposeInternal 在类中 RocksObject

类 Options

字段概要

从类继承的字段 org.rocksdb.RocksObject

从类继承的字段 org.rocksdb.AbstractImmutableNativeReference

从接口继承的字段 org.rocksdb.ColumnFamilyOptionsInterface

构造器概要

方法概要

从类继承的方法 org.rocksdb.RocksObject

从类继承的方法 org.rocksdb.AbstractImmutableNativeReference

从类继承的方法 java.lang.Object

构造器详细资料

Options

Options

Options

方法详细资料

getOptionStringFromProps

setIncreaseParallelism

setCreateIfMissing

setCreateMissingColumnFamilies

setEnv

getEnv

prepareForBulkLoad

createIfMissing

createMissingColumnFamilies

oldDefaults

optimizeForSmallDb

optimizeForSmallDb

optimizeForPointLookup

optimizeLevelStyleCompaction

optimizeLevelStyleCompaction

optimizeUniversalStyleCompaction

optimizeUniversalStyleCompaction

setComparator

setComparator

setMergeOperatorName

setMergeOperator

setCompactionFilter

compactionFilter

setCompactionFilterFactory

compactionFilterFactory

setWriteBufferSize

writeBufferSize

setMaxWriteBufferNumber

maxWriteBufferNumber

errorIfExists

setErrorIfExists

paranoidChecks

setParanoidChecks

maxOpenFiles

setMaxFileOpeningThreads

maxFileOpeningThreads

setMaxTotalWalSize

maxTotalWalSize

setMaxOpenFiles

useFsync

setUseFsync

setDbPaths

dbPaths

dbLogDir

setDbLogDir

walDir

setWalDir

deleteObsoleteFilesPeriodMicros

setDeleteObsoleteFilesPeriodMicros

maxBackgroundCompactions

setStatistics

statistics

setMaxBackgroundCompactions

setMaxSubcompactions

maxSubcompactions

maxBackgroundFlushes

setMaxBackgroundFlushes

maxBackgroundJobs

setMaxBackgroundJobs

maxLogFileSize

setMaxLogFileSize

logFileTimeToRoll

setLogFileTimeToRoll

keepLogFileNum

setKeepLogFileNum