CompressionType：壓縮類型
kNoCompression = 0x0,
kSnappyCompression = 0x1,
kZlibCompression = 0x2,
kBZip2Compression = 0x3,
kLZ4Compression = 0x4,
kLZ4HCCompression = 0x5,
kXpressCompression = 0x6,
kZSTD = 0x7,
//用ZSTD lib的時候版本比0.8.0還老，或者考慮降級服務或將數據庫文件複製到另一個使用沒有kZSTD的舊版RocksDB上運行。
kZSTDNotFinalCompression = 0x40,
// kDisableCompressionOption is used to disable some compression options.
kDisableCompressionOption = 0xff,
comparator：比較，用來定義table中key的順序，默認使用使用字典順序排序。
const Comparator* comparator = BytewiseComparator();
還是直接上中文註釋過的rocksdb的options.h文件，供以後參數優化參考。
#pragma once
#include <stddef.h>
#include <stdint.h>
#include <limits>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "rocksdb/advanced_options.h"
#include "rocksdb/comparator.h"
#include "rocksdb/env.h"
#include "rocksdb/listener.h"
#include "rocksdb/universal_compaction.h"
#include "rocksdb/version.h"
#include "rocksdb/write_buffer_manager.h"
#ifdef max
#undef max
#endif
namespace rocksdb {
class Cache;
class CompactionFilter;
class CompactionFilterFactory;
class Comparator;
class ConcurrentTaskLimiter;
class Env;
enum InfoLogLevel : unsigned char;
class SstFileManager;
class FilterPolicy;
class Logger;
class MergeOperator;
class Snapshot;
class MemTableRepFactory;
class RateLimiter;
class Slice;
class Statistics;
class InternalKeyComparator;
class WalFilter;
enum CompressionType : unsigned char {
kNoCompression = 0x0,
kSnappyCompression = 0x1,
kZlibCompression = 0x2,
kBZip2Compression = 0x3,
kLZ4Compression = 0x4,
kLZ4HCCompression = 0x5,
kXpressCompression = 0x6,
kZSTD = 0x7,
kZSTDNotFinalCompression = 0x40,
kDisableCompressionOption = 0xff,
};
struct ColumnFamilyOptions : public AdvancedColumnFamilyOptions {
// The function recovers options to a previous version. Only 4.6 or later
// versions are supported.
ColumnFamilyOptions* OldDefaults(int rocksdb_major_version = 4,
int rocksdb_minor_version = 6);
// 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.
// An optional cache object is passed in to be used as the block cache
ColumnFamilyOptions* OptimizeForSmallDb(
std::shared_ptr<Cache>* cache = nullptr);
// 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
//
// Not supported in ROCKSDB_LITE
ColumnFamilyOptions* OptimizeForPointLookup(uint64_t block_cache_size_mb);
// 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 two functions:
// * OptimizeLevelStyleCompaction -- optimizes level style compaction
// * OptimizeUniversalStyleCompaction -- optimizes universal style compaction
// Universal style compaction is focused on reducing Write Amplification
// Factor for big data sets, but increases Space Amplification. You can learn
// more about the different styles here:
// https://github.com/facebook/rocksdb/wiki/Rocksdb-Architecture-Guide
// 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 is not supported in ROCKSDB_LITE
ColumnFamilyOptions* OptimizeLevelStyleCompaction(
uint64_t memtable_memory_budget = 512 * 1024 * 1024);
ColumnFamilyOptions* OptimizeUniversalStyleCompaction(
uint64_t memtable_memory_budget = 512 * 1024 * 1024);
// -------------------
// Parameters that affect behavior
// Comparator used to define the order of keys in the table.
// Default: a comparator that uses lexicographic byte-wise ordering
//
// REQUIRES: The client must ensure that the comparator supplied
// here has the same name and orders keys *exactly* the same as the
// comparator provided to previous open calls on the same DB.
const Comparator* comparator = BytewiseComparator();
// REQUIRES: The client must provide a merge operator if Merge operation
// needs to be accessed. Calling Merge on a DB without a merge operator
// would result in Status::NotSupported. The client must ensure that the
// merge operator supplied here has the same name and *exactly* the same
// semantics as the merge operator provided to previous open calls on
// the same DB. The only exception is reserved for upgrade, where a DB
// previously without a merge operator is introduced to Merge operation
// for the first time. It's necessary to specify a merge operator when
// opening the DB in this case.
// Default: nullptr
std::shared_ptr<MergeOperator> merge_operator = nullptr;
const CompactionFilter* compaction_filter = nullptr;
std::shared_ptr<CompactionFilterFactory> compaction_filter_factory = nullptr;
//write buffer的大小
size_t write_buffer_size = 64 << 20;
//壓縮類型
CompressionType compression;
//壓縮算法將用於包含文件的最底層
// Default: kDisableCompressionOption (Disabled)
CompressionType bottommost_compression = kDisableCompressionOption;
// bottommost_compression使用壓縮算法的不同選項（如果已啓用）
// 啓用它的話參考CompressionOptions參數
CompressionOptions bottommost_compression_opts;
// 壓縮算法的不同選項
CompressionOptions compression_opts;
// 觸發0級壓縮的文件數。 value<0表示不會由文件數觸發0級壓縮。
// Default: 4
// 通過SetOptions() API動態改變
int level0_file_num_compaction_trigger = 4;
// 如果不是nullptr，使用特定的函數來確定鍵的前綴，這些前綴將放在過濾器中。根據工作負載，
// 通過ReadOptions將前綴傳遞給db.NewIterator*()時，這可以減少掃描的讀取IOP成本。
// 要使前綴過濾正常工作，"prefix_extractor" and "comparator"必須是持有以下的屬性：
// 1) key.starts_with(prefix(key))
// 2) Compare(prefix(key), key) <= 0.
// 3) If Compare(k1, k2) <= 0, then Compare(prefix(k1), prefix(k2)) <= 0
// 4) prefix(prefix(key)) == prefix(key)
// Default: nullptr
std::shared_ptr<const SliceTransform> prefix_extractor = nullptr;
// 控制一個級別最大的總數據大小。max_bytes_for_level_base是level-1的最大總數
//level L的byte最大總數可以通過以下公式計算
// (max_bytes_for_level_base) * (max_bytes_for_level_multiplier ^ (L-1))
// 比如 max_bytes_for_level_base = 200MB 同時 max_bytes_for_level_multiplier = 10,
// level-1的最大總數是200MB, level-2的總文件數是2GB, level-3的總文件數是20GB.
// Default: 256MB.
// 通過SetOptions() API動態改變
uint64_t max_bytes_for_level_base = 256 * 1048576;
// 如果不是0, 壓縮將定期刷新快照的列表。第一次刷新的延遲是snap_refresh_nanos納秒，之後呈現指數增長。
// NOTE: 此功能目前與RangeDeletes不兼容。
// Default: 0
// 通過SetOptions() API動態改變
uint64_t snap_refresh_nanos = 0;
// 禁用自動壓縮，仍可以在此列上發佈手動壓縮
// 通過SetOptions() API動態改變
bool disable_auto_compactions = false;
// 這是一個提供TableFactory對象的factory
// Default: BlockBasedTableOptions.
//BlockBasedTableOptions基於塊的table factory，提供一個默認的TableBuilder和TableReader實現
std::shared_ptr<TableFactory> table_factory;
//這個cloumn family的SST文件可以放進的目標大小的一個路徑列表
// 和db_paths相似，較新的數據更早的被放置在具體的路徑下的向量中，而較舊的數據逐漸的移動到later指定的路徑下的向量中
// 注意，如果路徑提供給多個cloumn families，則將所有的cloumn families文件合併起來
// 如果是empty, 將使用db_paths
// Default: empty
std::vector<DbPath> cf_paths;
// column family的壓縮併發線程限制器
// 如果不是nullptr, 使用給定的併發線程限制器來控制最大未完成的壓縮任務。
// 可以跨數據庫實例與多個column families共享限制器。
// Default: nullptr
std::shared_ptr<ConcurrentTaskLimiter> compaction_thread_limiter = nullptr;
// 在全域創建一個默認值的ColumnFamilyOptions
ColumnFamilyOptions();
// 用Options創建ColumnFamilyOptions
explicit ColumnFamilyOptions(const Options& options);
void Dump(Logger* log) const;
};
enum class WALRecoveryMode : char {
// 原始levelDB恢復
// 我們容忍所有日誌trailing數據中的不完整記錄
// 使用情況 : 這是一個legacy行爲
kTolerateCorruptedTailRecords = 0x00,
// 在clean shutdown中恢復
// 不希望在WAL中發現任何損壞
// 使用情況 : 這對於單元測試和可能需要高一致性保證的稀有應用程序非常理想
kAbsoluteConsistency = 0x01,
// point-in-time consistency(default)恢復
// 我們在發現WAL不一致時停止WAL playback
// 使用情況 :適用於具有磁盤控制器緩存的系統，如硬盤，沒有存儲相關數據的超級電容的SSD
kPointInTimeRecovery = 0x02,
// 異常中斷時恢復
// 我們忽略WAL中的任何損壞，並試圖儘可能多地挽救數據
// 使用情況 : 理想情況下儘可能恢復使用低級無關數據運行的數據和系統
kSkipAnyCorruptedRecords = 0x03,
};
struct DbPath {
std::string path;
uint64_t target_size; // 在路徑下所有文件的目標大小, in byte.
DbPath() : target_size(0) {}
DbPath(const std::string& p, uint64_t t) : path(p), target_size(t) {}
};
struct DBOptions {
// 該功能恢復選項的選項，如4.6版所示。
DBOptions* OldDefaults(int rocksdb_major_version = 4,
int rocksdb_minor_version = 6);
// 使用一些函數會使rocksdb優化效果更加明顯
// 如果您的數據庫非常小（如1GB以下）並不想爲memtables花費大量內存，請使用此選項。
// 傳遞一個可選的緩存對象，以便將memtable的內存使用
DBOptions* OptimizeForSmallDb(std::shared_ptr<Cache>* cache = nullptr);
#ifndef ROCKSDB_LITE
// 默認情況下，Rocksdb僅使用一個後臺進程刷新和壓縮，調用此函數會將其設置爲使用的“total_threads”總數，
//`total_threads`設置爲好的參數是核心數量。
DBOptions* IncreaseParallelism(int total_threads = 16);
#endif // ROCKSDB_LITE
// 如果是true, 數據庫如果missing的時候將會被創建.
// Default: false
bool create_if_missing = false;
// 如果是true, column families missing的時候將會自動被創建.
// Default: false
bool create_missing_column_families = false;
// 如果是true, an error is raised if the database already exists.
// Default: false
bool error_if_exists = false;
// 如果爲true，RocksDB將積極檢查數據的一致性。
// 此外，如果對數據庫的任何寫入失敗（Put, Delete, Merge, Write),
//數據庫將切換到只讀模式並讓所有其他模式寫操作失敗
// 大多數情況下設置爲true
// Default: true
bool paranoid_checks = true;
// 使用指定的對象與環境進行交互，例如讀/寫文件，安排後臺工作等
// Default: Env::Default()
Env* env = Env::Default();
// 用於控制刷新和壓縮的寫入速率，flush比壓縮具有更高的優先級，
//如果使用nullptr會啓用速率限制器。如果禁用rate limiting則在默認情況下設置的bytes_per_sync爲1MB
// Default: nullptr
std::shared_ptr<RateLimiter> rate_limiter = nullptr;
// 用來追蹤SST文件並且控制他們的文件刪除速率
// 特徵:
// - 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).
// Default: nullptr
std::shared_ptr<SstFileManager> sst_file_manager = nullptr;
//如果不是nullptr時，任何內部進度/錯誤信息將會被寫進info_log,如果nullptr，則寫入與db內容存儲在同一個目錄的文件中
// Default: nullptr
std::shared_ptr<Logger> info_log = nullptr;
#ifdef NDEBUG
InfoLogLevel info_log_level = INFO_LEVEL;
#else
InfoLogLevel info_log_level = DEBUG_LEVEL;
#endif // NDEBUG
// db可用的打開文件數. 你可能需要增加這個參數，如果你的數據庫有一個很大的工作集
// 值 = -1 表示被打開的文件總是保持一個打開的狀態，可以通過level-base的壓縮中target_file_size_base和
// target_file_size_multiplier參數估計文件的數量，對於universal-style compaction, 通常設置爲-1
// Default: -1
// 通過SetDBOptions() API動態變化
int max_open_files = -1;
// 如果 max_open_files = -1, DB 將使用 DB::Open()打開所有文件. 可以使用這個參數去增加打開文件的線程數
// Default: 16
int max_file_opening_threads = 16;
// 一旦預寫日誌超過此大小，我們將開始強制刷新memtables由最早的實時WAL文件（即導致所有空間放大的文件）
// 支持的cloumn family。 如果設置爲0，我們將會動態的選擇WAL文件的大小通過
// [sum of all write_buffer_size * max_write_buffer_number] * 4
// 此選項僅在存在多個列族時生效，否則wal大小由write_buffer_size指定。
// Default: 0
// 通過SetDBOptions() API動態變化
uint64_t max_total_wal_size = 0;
// 如果不是nullptr，則收集有關數據庫操作的指標
std::shared_ptr<Statistics> statistics = nullptr;
// 在默認的情況下，用fdatasync寫到一個穩定的存儲（在此功能可用的平臺上）
// 如果參數爲true, 將使用fsync.
// fsync和fdatasync對我們來說同等安全，並且fdatasync更快,
// 所以很少有設置這個參數的必要. 它是作爲內核/文件系統錯誤的解決方法提供的，
// 例如在3.7之前的內核版本中的ext4影響fdatasync會導致錯誤。
bool use_fsync = false;
// 可以放入目標大小SST文件的路徑列表
// 較新的數據被放置在向量中較早指定的路徑中，而較舊的數據逐漸移動到向量中稍後指定的路徑。
// 例如，您有一個爲DB分配10GB的閃存設備，以及2TB的硬盤驅動器，您應將其配置爲：
// [{"/flash_path", 10GB}, {"/hard_drive", 2TB}]
// 系統將嘗試保證每條路徑下的數據接近但不大於目標大小。但是，通過確定放置文件的位置而使用的
// 當前和未來文件大小基於盡力而爲估計，這意味着在某些工作負載下，目錄下的實際大小可能略高於目標大小。
// 用戶應該爲這些案件提供一些緩衝空間。
//
// 如果沒有任何路徑有足夠的空間放置文件，則無論如何，文件都將被放置到最後一個路徑，儘管目標大小。
// 將更新的數據放置到早期路徑也是最好的努力。 在某些極端情況下，用戶應該期望用戶文件處於更高級別。
//
// 如果保留爲空，則只使用一個路徑，即打開數據庫時傳遞的db_name。
// Default: empty
std::vector<DbPath> db_paths;
// 這指定了Info LOG目錄
// 如果是empty, log文件和data存在一個路徑下；如果不是empty, log文件會放在特定的路徑下,
// 數據庫的data路徑的絕對路徑將用作log文件名的前綴
std::string db_log_dir = "";
// 指定預寫log(WAL)的絕對路徑.
// 如果是empty, log文件和data存在一個路徑下；dbname是默認的data路徑。
// 如果不是empty, log文件會放在特定的路徑下,
// 當銷燬db時,所有的wal_dir和dir/目錄下的所有log文件將會被刪除
std::string wal_dir = "";
// 刪除過時文件時的週期。默認值爲6小時。無論此設置如何，通過壓縮過程超出範圍的文件仍會在每次壓縮時自動刪除。
// Default: 6 hours
// 通過SetDBOptions() API動態改變.
uint64_t delete_obsolete_files_period_micros = 6ULL * 60 * 60 * 1000000;
// 最大併發後臺作業數（壓縮和刷新）
// Default: 2
// 通過SetDBOptions() API動態改變.
int max_background_jobs = 2;
// 不再支持這個參數，可以忽略。
// 通過SetDBOptions() API動態改變.
int base_background_compactions = -1;
// 不再支持這個參數，RocksDB自動通過max_background_jobs參數確定。爲了向後兼容，將在以下情況下
// `max_background_jobs = max_background_compactions + max_background_flushes`
// 至少設置`max_background_compactions`或者是`max_background_flushes` (如果未設置一個選項，我們將-1替換爲1).
// 提交到默認LOW優先級線程池的最大併發後臺壓縮作業數。
// 如果您正在增加此值，還應考慮增加LOW優先級線程池中的線程數。有關更多信息，請參閱Env::SetBackgroundThreads
// Default: -1
// 通過SetDBOptions() API動態改變.
int max_background_compactions = -1;
// 此值表示將同時執行壓縮作業的最大線程數，將其分解爲同時運行的多個較小的線程。
// Default: 1 (i.e. no subcompactions)
uint32_t max_subcompactions = 1;
// 不再支持這個參數，RocksDB自動通過max_background_jobs參數確定。爲了向後兼容，將在以下情況下
// `max_background_jobs = max_background_compactions + max_background_flushes`
// 至少設置`max_background_compactions`或者是`max_background_flushes`
// 默認情況下提交給HIGH優先級線程池的最大併發後臺可記憶刷新作業數。
// 如果HIGH優先級線程池配置爲零線程，則flush作業將與壓縮作業共享LOW優先級線程池。
// 當多個數據庫實例共享同一個Env時，使用兩個線程池非常重要。 如果沒有單獨的池，
// 長時間運行的壓縮作業可能會阻止其他數據庫實例的可記憶刷新作業，從而導致不必要的Put停頓。
// 如果正在增加此值，還應考慮增加HIGH優先級線程池中的線程數。有關更多信息請參閱Env::SetBackgroundThreads
// Default: -1
int max_background_flushes = -1;
// 指定info log文件的size大小. 如果log文件大於`max_log_file_size`, 會新建一個log文件
// 如果max_log_file_size == 0,所有的logs將寫在一個log文件中
size_t max_log_file_size = 0;
// info log文件的輪詢時間（秒）.
// 如果指定是一個非0的值, 日誌文件將會被輪詢。
// 如果它的活躍時間長於`log_file_time_to_roll`.
// Default: 0 (disabled)， ROCKSDB_LITE模式不支持！
size_t log_file_time_to_roll = 0;
// 要保留的最大信息日誌文件。
// Default: 1000
size_t keep_log_file_num = 1000;
// 回收日誌文件.
// 如果不是0, 我們將重新使用之前寫過的log文件，用新的log覆蓋久的數據。該值表示我們將在任何
// 時間點保留多少這樣的文件供以後使用。這樣更有效，因爲已經分配了塊，並且fdatasync在每次寫入後不需要更新inode。
// Default: 0
size_t recycle_log_file_num = 0;
// manifest文件在達到此限制時翻轉。舊的清單文件將被刪除。 默認值爲1GB，
// 因此清單文件可以增長，但不會達到存儲容量的限制。
uint64_t max_manifest_file_size = 1024 * 1024 * 1024;
// 用於表緩存的分片數。
int table_cache_numshardbits = 6;
// 不再支持
// int table_cache_remove_scan_count_limit;
// 以下兩個字段會影響歸檔日誌的刪除方式。
// 1. 如果兩者都設置爲0，則將盡快刪除日誌，並且不會進入存檔。
// 2. 如果WAL_ttl_seconds爲0且WAL_size_limit_MB不爲0，則每10分鐘檢查一次WAL文件，如果總大小大
// 於WAL_size_limit_MB，則從最早開始刪除它們直到滿足size_limit。 所有空文件都將被刪除。
// 3. 如果WAL_ttl_seconds不爲0且WAL_size_limit_MB爲0，則每個WAL_ttl_seconds / 2將檢查WAL
// 文件，並且將刪除早於WAL_ttl_seconds的WAL文件。
// 4. 如果兩者都不爲0，則每隔10分鐘檢查一次WAL文件，並且在ttl爲第一個的情況下執行兩個檢查。
uint64_t WAL_ttl_seconds = 0;
uint64_t WAL_size_limit_MB = 0;
// 要預分配（通過fallocate）清單文件的字節數。 默認值爲4mb，這對於減少隨機IO以及防止預分配大量
// 數據（例如xfs的allocsize選項）的掛載進行過度分配是合理的。
size_t manifest_preallocation_size = 4 * 1024 * 1024;
// 允許OS去mmap文件爲了讀取sst table，Default: false
bool allow_mmap_reads = false;
// 允許OS去mmap文件爲了writing
// DB::SyncWAL() 只有在false時才工作
// Default: false
bool allow_mmap_writes = false;
// 啓用直接I/O模式進行讀/寫；根據用例，它們可能會也可能不會提高性能
// 在直接I/O模式下，文件將會打開。這意味着數據從磁盤讀/寫將不會被cache或者緩存
// 然而，仍然可以使用設備的硬件緩衝器。內存映射文件不受這些參數的影響。
// 使用O_DIRECT進行用戶和壓縮讀取。
// 如果爲true，還會強制new_table_reader_for_compaction_inputs爲true。
// Default: false
// ROCKSDB_LITE模式不支持！
bool use_direct_reads = false;
// 在後臺刷新和壓縮中使用O_DIRECT進行寫入
// Default: false
// ROCKSDB_LITE模式不支持！
bool use_direct_io_for_flush_and_compaction = false;
// 如果爲false，則會繞過fallocate()調用
bool allow_fallocate = true;
// 禁用子進程繼承打開的文件. Default: true
bool is_fd_close_on_exec = true;
// 這個參數不再被使用
bool skip_log_error_on_recovery = false;
// 如果不是zero，每stats_dump_period_sec則會轉儲rocksdb.stats到LOG中一次。
// Default: 600 (10 min)
// 通過SetDBOptions() API動態改變.
unsigned int stats_dump_period_sec = 600;
// 如果不是zero，每stats_persist_period_sec則會轉儲rocksdb.stats到Rocksdb中一次。
// Default: 600
unsigned int stats_persist_period_sec = 600;
// 如果爲true，則每stats_persist_period_sec自動將統計信息保存到隱藏列族（column family：___ rocksdb_stats_history___）every
// 否則, 寫入內存中的結構。 用戶可以通過`GetStatsHistory` API進行查詢。
// 如果用戶企圖在一個已經設置persist_stats_to_disk=true的DB中新建一個cloumn family用相同的名字，
// 新建column family操作將失敗，但是隱藏的column family將繼續存活，同時之前的統計數據將保存
// 將統計信息存儲到磁盤時，統計信息名稱將限制爲100個字節。
// Default: false
bool persist_stats_to_disk = false;
// 如果不爲零，則定期獲取統計信息快照並存儲在內存中，統計信息快照的內存大小上限爲stats_history_buffer_size
// Default: 1MB
size_t stats_history_buffer_size = 1024 * 1024;
// 如果設置的是true，則會在打開一個SST文件的時候提示基礎文件系統“文件訪問的模式是隨機的”
// Default: true
bool advise_random_on_open = true;
// 在寫入磁盤之前，在所有column families的memtables中構建的數據量。
// 這與write_buffer_size不同，後者強制限制單個memtable。
// 默認情況下禁用此功能。指定非零值以啓用它。
// Default: 0 (disabled)
size_t db_write_buffer_size = 0;
// memtable的內存使用情況將報告給該對象。 同一個對象可以傳遞到多個DB中，它將跟蹤所有DB的大小總和。
// 如果所有DB的所有實時memtables的總大小超過限制，則將在發出下一個寫入的下一個DB中觸發刷新。
// 默認情況下禁用此功能。指定非零值以啓用它。
// Default: null
std::shared_ptr<WriteBufferManager> write_buffer_manager = nullptr;
// 一旦壓縮開始，請指定文件訪問模式。它將應用於壓縮的所有輸入文件。
// Default: NORMAL
enum AccessHint { NONE, NORMAL, SEQUENTIAL, WILLNEED };
AccessHint access_hint_on_compaction_start = NORMAL;
// 如果是true，則始終爲壓縮輸入創建一個新的文件描述符和新的表讀取器。如果爲參數分配額外的內存，
// 打開此參數可能會在表讀取器中引入額外的內存使用量。 這將允許爲壓縮輸入文件設置文件描述符預取選項，
// 而不影響用戶查詢使用的同一文件的文件描述符。 如果使用基於塊的表，建議爲此模式啓用BlockBasedTableOptions.cache_index_and_filter_blocks。
// Default: false
// 這個標誌福慧影響壓縮行爲，有可能在之後被刪除
bool new_table_reader_for_compaction_inputs = false;
// 如果非零，我們在執行壓縮時執行更大的讀取。如果您在旋轉磁盤上運行RocksDB，
// 則應將其設置爲至少2MB。這樣，RocksDB的壓縮就是順序而不是隨機讀取。
// 如果是非零，則會強制new_table_reader_for_compaction_inputs=true
// Default: 0
// 通過SetDBOptions() API動態變化.
size_t compaction_readahead_size = 0;
// 在無緩存磁盤I/O模式下由WinMmapReadableFile使用表示最大的buffer大小
// 需要維護一個對齊的讀取緩衝區，同時允許緩衝區增長到指定值，然後對於一個更大的請求分配一個緩衝區。
// 在無緩衝區的模式下我們始終繞過ReadaheadRandomAccessFile的預讀緩衝區。當需要預讀的時候我們會使用
// compaction_readahead_size值並始終嘗試提前讀取。通過預讀我們始終將預先分配緩衝區大小，而不是將其增加到極限
// 此選項目前僅在Windows上受到尊重
// Default: 1 Mb
// Special value: 0 - 表示不維護每個實例緩衝區。每一個請求緩衝區分配並避免死鎖
size_t random_access_max_buffer_size = 1024 * 1024;
// 這是WritableFileWriter使用的最大緩衝區大小
// 在windows上，需要維護一個對齊的寫緩衝區。允許緩衝區增長，直到他的大小達到緩衝區的限制
// 如果邏輯扇區的大小異常時，IO和使用直接IO修復緩衝區的大小會使得寫
// Default: 1024 * 1024 (1 MB)
// 通過SetDBOptions() API動態改變.
size_t writable_file_max_buffer_size = 1024 * 1024;
// 使用自適應的互斥鎖，他在使用之前在用戶空間中重排序到內核。當互斥鎖沒有嚴重爭用時，這可能會減少上下文切換。
// 但是，如果互斥鎖很熱，我們最終可能會浪費旋轉時間。
// Default: false
bool use_adaptive_mutex = false;
// Create DBOptions with default values for all fields
DBOptions();
// Create DBOptions from Options
explicit DBOptions(const Options& options);
void Dump(Logger* log) const;
// 允許操作系統在後臺異步寫入文件時將文件逐步同步到磁盤。此操作可以用於平滑寫入I/O歲隨時間進行變化。
// 用戶不應該依賴它來保證持久性。爲每個寫入的byte_per_sync發出一個請求。0將表示關閉
// 可以考慮用rate_limiter來調節設備的寫入速率。當啓用rate limiter之後將會自動啓用bytes_per_sync = 1MB.
// 這個選項適用於表文件 Default: 0, 關閉
// Note: 不使用在WAL文件中. 可參閱wal_bytes_per_sync
// 通過SetDBOptions() API動態變化
uint64_t bytes_per_sync = 0;
// 和bytes_per_sync相同, 但是是用在WAL文件中
// Default: 0, 表示關閉
// 通過SetDBOptions() API動態變化
uint64_t wal_bytes_per_sync = 0;
// 如果是true，則保證WAL文件在任何給定時間儘可能多的提交用於回寫的“wal_bytes_per_sync”字節
// 如果支持'sync_file_range'，可以實現通過等待先前的‘sync_file_range’都完成
// - 通過這種方式，處理（壓縮等）可以在`sync_file_range`s之間的間隙中不受限制地進行，並且僅當I / O落後時我們纔會阻塞。
// - 否則使用`WritableFile :: Sync`方法。 請注意，此機制始終阻塞，從而防止I/O和處理的交互。
// Note:啓用此選項不會提供任何其他持久性保證，因爲它可能使用`sync_file_range`，它不會寫出元數據。
// Default: false
bool strict_bytes_per_sync = false;
// EventListeners的向量，其特定RocksDB事件發生時將調用其回調函數。
std::vector<std::shared_ptr<EventListener>> listeners;
// 如果爲true，則將跟蹤此DB中涉及的線程的狀態，並通過GetThreadList() API提供。
// Default: false
bool enable_thread_tracking = false;
// 如果觸發soft_pending_compaction_bytes_limit或level0_slowdown_writes_trigger，則對DB的寫入速率有限制，
// 或者我們正在寫入允許的最後一個mem表，並且我們允許超過3個mem表。 它是在壓縮之前用用戶寫入請求的大小來計算的。
// 如果壓縮仍然進一步落後，RocksDB可能決定減速更多。
// 如果value = 0, 如果它不爲空我們將從`rater_limiter`值推斷出一個值
// 或者`rater_limiter`爲空，我們將推斷爲16MB。
// 如果用戶在打開DB後更改`rate_limiter`中的速率，則不會調整`delayed_write_rate`。
// Unit: byte per second.
// Default: 0
// 通過SetDBOptions() API動態變化.
uint64_t delayed_write_rate = 0;
// 默認情況下維護單個寫線程隊列。線程到達隊列的頭部成爲寫批處理組leader，負責寫入批處理組的WAL和memtable中。
// 如果enable_pipelined_write = true, 爲WAL寫和memtable寫維護單獨的寫線程隊列。寫線程首先進入WAL編寫器隊列，
// 然後進入memtable的編寫器隊列。因此，WAL編寫器隊列上的待處理線程只需要等待以前的編寫器完成他們的WAL寫入，而不是等待memtable寫入。
// 啓用該功能可以提高寫入吞吐量並減少兩階段提交準備階段的延遲。
// Default: false
bool enable_pipelined_write = false;
// unordered_write = true可以提高寫入吞吐量，同時放寬快照的不變性保證。這違反了人們期望的重複從快照中::get，以及
// :: MultiGet和Iterator的一致時間點視圖屬性。如果應用程序無法容忍relaxed保證，它可以實現自己的機制來解決這個問題，並從更高的吞吐量中受益。
// 將TransactionDB與WRITE_PREPARED一起使用寫策略和two_write_queues = true是實現不可變快照的一種方法，儘管是unordered_write。
//
// 默認情況下，當它爲false時，除非所有具有較低序列號的寫入都已完成，否則rocksdb不會提前新快照的序列號。
// 這提供了我們除了快照之外的不變性。此外，由於Iterator和MultiGet內部依賴於快照，因此快照不變性導致Iterator和MultiGet提供一致的時間點視圖。
// 如果設置爲true，儘管仍提供了Read-Your-Own-Write屬性，但放寬了snapshot immutability屬性：獲取快照後發出的寫入（序列號較大）仍然對該快照
// 的讀取不可見。但仍然可能存在掛起的寫入（序列號較低），這些寫入將在快照到達memtable後更改快照可見的狀態。
// Default: false
bool unordered_write = false;
// 如果爲true，則允許多個寫入器並行更新mem表。只有一些memtable_factory-s支持併發寫入;
// 目前它僅針對SkipListFactory實現。併發memtable寫入與inplace_update_support或filter_deletes不兼容。
// 如果要使用此功能，強烈建議設置enable_write_thread_adaptive_yield。
// Default: true
bool allow_concurrent_memtable_write = true;
// 如果爲true，則與寫批處理組leader同步的線程將在阻塞互斥鎖之前等待最多write_thread_max_yield_usec。
// 無論是否啓用allow_concurrent_memtable_write，這都可以顯着提高併發工作負載的吞吐量。
// Default: true
bool enable_write_thread_adaptive_yield = true;
// 寫入操作在阻塞互斥鎖之前使用產生旋轉循環與其他寫入線程協調的最大微秒數。
//（假設正確設置了write_thread_slow_yield_usec）增加此值可能會增加RocksDB吞吐量，但會增加CPU使用率
// Default: 100
uint64_t write_thread_max_yield_usec = 100;
// std::this_thread::yield調用(Linux上的sched_yield)之後的延遲（以微秒爲單位）被視爲其他進程或線程希望使用當前內核的信號。
// 增加這一點會使編寫器線程更有可能通過旋轉來佔用CPU，這將顯示爲非自願上下文切換次數的增加。
// Default: 3
uint64_t write_thread_slow_yield_usec = 3;
// 如果爲true，那麼DB::Open()將不會通過從許多文件加載表屬性來更新用於優化壓縮決策的統計信息。
// 關閉此功能將改善DBOpen時間，尤其是在磁盤環境中。
// Default: false
bool skip_stats_update_on_db_open = false;
// 恢復模式以在重放WAL時控制一致性
// Default: kPointInTimeRecovery
WALRecoveryMode wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
// 如果設置爲false，則在WAL中遇到準備好的事務時恢復將失敗
bool allow_2pc = false;
// table-level行間的全局緩存.
// Default: nullptr (disabled)
// ROCKSDB_LITE模式不支持!
std::shared_ptr<Cache> row_cache = nullptr;
#ifndef ROCKSDB_LITE
// 提供在處理恢復期間的預寫日誌（WAL）時調用的過濾器對象。過濾器提供了一種檢查日誌記錄，忽略特定記錄或跳過重放的方法。
// 過濾器在啓動時調用，並且當前從單線程調用。
WalFilter* wal_filter = nullptr;
#endif // ROCKSDB_LITE
// 如果fail_if_options_file_error = true, 如果未檢測到選項文件或未正確保留選項文件，則DB::Open
// / CreateColumnFamily / DropColumnFamily / SetOptions會失敗
// DEFAULT: false
bool fail_if_options_file_error = false;
// 如果爲true，則在打印到LOG時將malloc stats與rocksdb.stats一起打印。
// DEFAULT: false
bool dump_malloc_stats = false;
// 默認情況下，RocksDB重寫WAL日誌並在打開數據庫時刷新它們，這可能會創建非常小的SST文件。
// 如果啓用此選項，RocksDB將嘗試避免（但不保證不會）在恢復期間刷新。此外，將保留現有的WAL日誌，
// 因此如果在刷新之前發生崩潰，我們仍然有要從中恢復的日誌
// DEFAULT: false
bool avoid_flush_during_recovery = false;
// 默認情況下，如果存在，RocksDB將刷新DB關閉的所有memtables未加載的數據（即禁用WAL）可以跳過刷新以加速DB關閉。 未經加載的數據將會丟失。
// DEFAULT: false
// 通過SetDBOptions() API動態改變.
bool avoid_flush_during_shutdown = false;
// 如果您希望能夠在後面獲取（調用IngestExternalFile()跳過已存在的鍵而不是覆蓋匹配鍵，則在創建數據庫期間將此選項設置爲true)
// 將此選項設置爲true將影響兩件事:
// 1) 禁用圍繞SST文件壓縮的一些內部優化
// 2) ingested文件值保留bottom-most級別
// 3) 如果這個選項打開則設置num_levels >= 3.
// DEFAULT: false
// Immutable.
bool allow_ingest_behind = false;
// 需支持差異快照。如果設爲true，則DB將僅處理序列號小於SetPreserveDeletesSequenceNumber(uint64_t ts)設置的刪除。
// 客戶有責任定期調用此方法以延長截止時間。 如果從未調用此方法並且preserve_deletes設置爲true，
// 則將不會處理任何刪除操作。 目前只保留正常刪除，不會保留SingleDeletes。
// DEFAULT: false
// Immutable (TODO: make it dynamically changeable)
bool preserve_deletes = false;
// 如果啓用它，將使用兩個隊列進行寫入，一個用於具有disable_memtable的隊列，另一個用於也用於寫入memtable的隊列。
// 這使得memtable寫入不會落後於其他寫入。它可用於優化MySQL 2PC，其中只有串行的提交寫入memtable。
bool two_write_queues = false;
// 如果在每次寫入後都沒有自動刷新真正的WAL。相反，它依賴於手動調用FlushWAL來將WAL緩衝區寫入其文件。
bool manual_wal_flush = false;
// 如果爲true，RocksDB支持刷新多個列族並以原子方式將其結果提交給MANIFEST。請注意，如果始終啓用WAL，
// 則無需將atomic_flush設置爲true，因爲WAL允許數據庫恢復到WAL中的最後一個持久狀態。
// 當存在不受WAL保護的寫入列族時，此選項很有用。
// 對於手動刷新，應用程序必須指定要列的族列並用DB :: Flush中以原子方式刷新。
// 對於自動觸發的刷新，RocksDB以原子方式刷新所有列族。
// 目前可以啓用WAL-enabled寫入在進行原子flush之後可以replay
// 如果進程崩潰並嘗試恢復，則獨立進行。
bool atomic_flush = false;
// 如果爲true，則ColumnFamilyHandle和Iterator的析構函數不會直接刪除過時的文件，
// 而是安排後臺作業來執行此操作。 如果從延遲敏感的線程中銷燬Iterator或ColumnFamilyHandle-s，請使用它。
// 如果設置爲true，則優先於ReadOptions::background_purge_on_iterator_cleanup。
bool avoid_unnecessary_blocking_io = false;
// 讀取日誌時預取的字節數。 這對於讀取遠程日誌非常有用，因爲它可以節省往返次數。如果爲0，則禁用預取。
// Default: 0
size_t log_readahead_size = 0;
};
// 控制數據庫行爲的選項(傳遞給DB::Open)
struct Options : public DBOptions, public ColumnFamilyOptions {
// Create an Options object with default values for all fields.
Options() : DBOptions(), ColumnFamilyOptions() {}
Options(const DBOptions& db_options,
const ColumnFamilyOptions& column_family_options)
: DBOptions(db_options), ColumnFamilyOptions(column_family_options) {}
// The function recovers options to the option as in version 4.6.
Options* OldDefaults(int rocksdb_major_version = 4,
int rocksdb_minor_version = 6);
void Dump(Logger* log) const;
void DumpCFOptions(Logger* log) const;
// 一些功能可以更容易地優化RocksDB
// 爲批量加載設置適當的參數。這是一個返回“this”而不是構造函數的函數的原因是爲了在將來啓用多個類似調用的鏈接。
// 所有數據都將在0級，沒有任何自動壓縮。建議在從數據庫讀取之前手動調用CompactRange（NULL，NULL），否則讀取可能會非常慢。
Options* PrepareForBulkLoad();
// 如果您的數據庫非常小（如1GB以下）並且您不想爲memtables花費大量內存，請使用此選項
Options* OptimizeForSmallDb();
};
// 應用程序可以發出讀取請求（通過Get / Iterators）並指定該讀取是否應該處理ALREADY駐留在指定緩存級別的數據。
// 例如，如果應用程序指定kBlockCacheTier，則Get調用將處理已在memtable或塊緩存中處理的數據。
// 它不會分頁來自OS緩存中的數據或駐留在存儲中的數據。
enum ReadTier {
kReadAllTier = 0x0, // 在memtable, block cache, OS cache or storage中的數據
kBlockCacheTier = 0x1, // 在memtable， block cache的數據
kPersistedTier = 0x2, // 持久性數據。當禁用WAL的時候，將跳過memtable中的數據
// 請注意，此ReadTier當前僅支持Get和MultiGet，並且不支持iterators.
kMemtableTier = 0x3 // 在memtable中的數據. 只用在memtable-only迭代器中
};
// 控制寫操作的參數
struct ReadOptions {
// 如果“snapshot”不是nullptr，從提供的快照中讀取(它必須屬於正在讀取且不得釋放的DB)
// 如果“snapshot”是nullptr, 在此讀取操作開始時使用狀態的隱式快照。
// Default: nullptr
const Snapshot* snapshot;
// `iterate_lower_bound`定義了後向迭代器可以返回條目的最小鍵。定義了bound後，Valid()將爲false。
// `iterate_lower_bound` 是包容性的，即bound是有效的條目。
// 如果prefix_extractor不爲null，則Seek目標和`iterate_lower_bound`需要具有相同的前綴。這是因爲在前綴域之外不能保證排序。
// Default: nullptr
const Slice* iterate_lower_bound;
// “iterate_upper_bound”定義了前向迭代器可以返回條目的範圍。達到綁定後，Valid()將爲false。
// “iterate_upper_bound”是獨佔的，即bound值不是有效條目。如果iterator_extractor不爲null，
// 則Seek目標和iterate_upper_bound需要具有相同的前綴。這是因爲在前綴域之外不能保證排序。
// Default: nullptr
const Slice* iterate_upper_bound;
// 在讀取表文件的兩次以上讀取時，RocksDB會爲迭代器執行自動預讀。readahead從8KB開始，
// 每讀取一次256KB的讀取數量翻倍。 如果大多數範圍掃描很大，並且確定需要比自動預讀啓用的預讀更大的預讀，
// 則此選項可以提供幫助。使用較大的預讀大小（> 2MB）通常可以提高旋轉磁盤上的前向迭代性能。
// Default: 0
size_t readahead_size;
// 在迭代器失敗之前可以跳過的鍵數的閾值。
// 默認值0表示用於永不丟失請求，即使在跳過太多密鑰時也是如此。
// Default: 0
uint64_t max_skippable_internal_keys;
// 指定此讀取請求是否應處理ALREADY駐留在特定高速緩存上的數據。
// 如果在指定的緩存中找不到所需的數據，則返回Status::Incomplete。
// Default: kReadAllTier
ReadTier read_tier;
// 如果爲true，則將根據相應的校驗和驗證從底層存儲讀取的所有數據。
// Default: true
bool verify_checksums;
// 這次迭代的“數據塊”還是“索引塊”“應讀取放在塊緩存中？
// 調用者可能希望將此字段設置爲false以進行批量掃描。
// 這將有助於不更改塊緩存中現有項目的逐出順序。Default: true
bool fill_cache;
// 指定創建一個尾部迭代器 - 一個特殊的迭代器，它具有完整數據庫的視圖（即它也可以用於讀取新添加的數據），
// 並針對順序讀取進行了優化。 它將返回在創建迭代器後插入到數據庫中的記錄。
// Default: false
// ROCKSDB_LITE模式不支持!
bool tailing;
// 此選項不再使用。 它打開的一個功能已被刪除。
bool managed;
// 無論表中使用的索引格式（例如哈希索引），都啓用總順序查找。某些表格式（例如普通表格）可能不支持此選項。
// 如果是true在調用Get()時, 將在從基於塊的表中讀取時跳過前綴bloom。它提供了一種在更改前綴提取器的實現後讀取現有數據的方法。
bool total_order_seek;
// 強制迭代器僅迭代與搜索相同的前綴。
// 此選項僅對前綴搜索有效，即對於列族，prefix_extractor爲非null，而total_order_seek爲false。
// 與iterate_upper_bound不同，prefix_same_as_start僅在前綴內但在兩個方向上都有效。
// Default: false
bool prefix_same_as_start;
// 只要未刪除迭代器，就將迭代器加載的塊保存在內存中。如果在從使用
// BlockBasedTableOptions::use_delta_encoding = false創建的表中讀取時使用，
// 則Iterator的屬性“rocksdb.iterator.is-key-pinned”保證返回1。
// Default: false
bool pin_data;
// 如果爲true，則在CleanupIteratorState中調用PurgeObsoleteFile時，
// 我們會在刷新作業隊列中計劃後臺作業，並在後臺刪除過時的文件。
// Default: false
bool background_purge_on_iterator_cleanup;
// 如果爲true，則使用DeleteRange() API刪除的密鑰將對讀者可見，直到它們在壓縮過程中被自然刪除。
// 這改善了具有許多範圍刪除的DB中的讀取性能。
// Default: false
bool ignore_range_deletions;
// 一個回調，用於根據表的屬性確定給定表中是否存在此掃描的相關鍵。
// 回調在迭代期間傳遞每個表的屬性。如果回調返回false，則不掃描該表。此選項僅影響迭代器，對點查找沒有影響。
// Default: empty (每一個表對會被掃描)
std::function<bool(const TableProperties&)> table_filter;
// 需要支持差異快照. 有兩個影響:
// 1) 迭代器將跳過所有seqnum < iter_start_seqnum的內部密鑰
// 2) 如果這個param > 0迭代器將返回INTERNAL鍵而不是用戶鍵; 例如返回tombstones.
// Default: 0 (不要通過seqnum過濾，返回用戶密鑰)
SequenceNumber iter_start_seqnum;
// 迭代的時間戳. Read應該返回指定時間戳可見的最新數據。 同一數據庫的所有時間戳必須具有相同的長度和格式。
// 用戶負責通過Comparator提供定製的比較功能，以排序<key，timestamp>元組。
// 用戶指定的時間戳功能仍處於活動開發階段，API可能會發生變化。
const Slice* timestamp;
ReadOptions();
ReadOptions(bool cksum, bool cache);
};
// 控制寫操作的選項
struct WriteOptions {
// 如果爲true，則在認爲寫入完成之前，將從操作系統緩衝區高速緩存中刷新寫入（通過調用WritableFile::Sync()）。
// 如果此標誌爲true，則寫入速度會變慢。如果此標誌爲false，並且計算機崩潰，則可能會丟失一些最近的寫入。
// 請注意，如果它只是崩潰的進程（即，機器不重啓），即使sync == false也不會丟失寫入。
// 使用sync == false的DB寫入與“write()”系統調用具有類似的崩潰語義。
// 使用sync == true的DB寫入與“fdatasync()”後跟的“write()”系統調用具有類似的崩潰語義。.
// Default: false
bool sync;
// 如果爲true，則寫入將不會首先進入提前寫入日誌，並且寫入可能會在崩潰後丟失。備份引擎依賴預寫日誌來備份memtable，
// 因此如果禁用預寫日誌，則必須使用flush_before_backup = true創建備份，以避免丟失未刷新的可記錄數據。
// Default: false
bool disableWAL;
// 如果是true並且如果用戶想要寫成沒有存在的列組(他們已經dropped)，
// 忽略寫(不返回一個錯誤). 如果在一個WriteBatch中有多次讀寫, 其他的寫將會成功.
// Default: false
bool ignore_missing_column_families;
//如果是true，我們需要等待或者睡眠寫請求，使用Status::Incomplete()就會馬上fail
// Default: false
bool no_slowdown;
// 如果是true，如果壓縮是落後的，寫請求就是低的優先級。在這種情況下no_slowdown = true，
// 返回Status::Incomplete()後，請求將立即取消。否則，它將減慢速度。 RocksDB確定減速
// 值，以確保它對高優先級寫入產生最小影響。
// Default: false
bool low_pri;
// 寫操作的時間戳, 例如:Put. 相同數據庫的所有時間戳必須共享相同的長度和格式，用戶也可以負責提供一個定製的比較功能，
// 通過Comparator排序<key，timestamp>元組。如果用戶想要啓用時間戳，那麼所有寫操作都必須與時間戳相關聯，
// 因爲作爲單節點存儲引擎的RocksDB目前不瞭解全局時間，因此必須依賴於應用程序。用戶指定的時間戳功能仍處於活動
// 開發階段，API可能會發生變化。
const Slice* timestamp;
WriteOptions()
: sync(false),
disableWAL(false),
ignore_missing_column_families(false),
no_slowdown(false),
low_pri(false),
timestamp(nullptr) {}
};
// 控制刷新操作的選項
struct FlushOptions {
// 如果是true，刷新操作將會等待，直到刷新操作完成
// Default: true
bool wait;
// 如果爲true，則刷新將立即進行，即使這意味着寫入也會在flush期間stall。
// 如果是false，則操作將等待，直到可以執行刷新w/o導致停頓或直到其他人執行所需的刷新(前端調用後端線程)。
// Default: false
bool allow_write_stall;
FlushOptions() : wait(true), allow_write_stall(false) {}
};
// 從已經提供的DBOptions新建一個Logger
extern Status CreateLoggerFromOptions(const std::string& dbname,
const DBOptions& options,
std::shared_ptr<Logger>* logger);
// 壓縮參數在調用CompactFiles()的時候被使用.
struct CompactionOptions {
// Compaction輸出壓縮類型
// Default: snappy
// 如果設置成`kDisableCompressionOption`, RocksDB將通過`ColumnFamilyOptions`選擇壓縮類型,
// 如果指定了“compression_per_level”，則考慮輸出級別。
CompressionType compression;
// Compaction將創建`output_file_size_limit`大小的文件
// Default: MAX, 這意味着Compaction只創建一個單獨的文件
uint64_t output_file_size_limit;
// 如果 > 0,compaction將取代DBOption中的參數
uint32_t max_subcompactions;
CompactionOptions()
: compression(kSnappyCompression),
output_file_size_limit(std::numeric_limits<uint64_t>::max()),
max_subcompactions(0) {}
};
// 對於基於級的壓縮，我們可以配置如果想跳過或者是強制最底層壓縮
enum class BottommostLevelCompaction {
// 跳過最底層的壓縮
kSkip,
// 如果有壓縮過濾，只會壓縮最底層的級別。這是一個默認的選項
kIfHaveCompactionFilter,
//通常壓縮最底層級別
kForce,
// 通常壓縮最底層級別，但是在最底層級別就避免壓縮。在相同的壓縮中創建double-compact文件
kForceOptimized,
};
// CompactRange()調用的時候會用到CompactRangeOptions.
struct CompactRangeOptions {
// 如果是true，將不會有其他的壓縮和這個手動壓縮同時進行
bool exclusive_manual_compaction = true;
// 如果爲true，則壓縮文件將移動到能夠保存數據或給定級別的最小級別（指定的非負target_level）。
bool change_level = false;
// 如果change_level = true並且target_level不是一個負數, 已經壓縮的文件將會移動到target_level
int target_level = -1;
// 壓縮輸出將放在options.db_paths [target_path_id]中。
// 如果target_path_id超出範圍則行爲未定義.
uint32_t target_path_id = 0;
// 如果有一個壓縮過濾器的話，默認的基於級別的壓縮只會壓縮最底層的級別
BottommostLevelCompaction bottommost_level_compaction =
BottommostLevelCompaction::kIfHaveCompactionFilter;
// 如果爲true，即使這樣做會導致DB進入寫停止模式，也會立即執行。否則，它將睡眠直到負載足夠低。
bool allow_write_stall = false;
// 如果>0，它將替換此壓縮的DBOptions中的選項。
uint32_t max_subcompactions = 0;
};
// IngestExternalFile()可以通過調用使用IngestExternalFileOptions
struct IngestExternalFileOptions {
// 可以設置爲true以移動文件而不是複製它們。
bool move_files = false;
// 如果設置爲true，則在移動失敗時，攝取將返回到複製。
bool failed_move_fall_back_to_copy = true;
// 如果設置爲false，則在攝取文件之前創建的現有快照中可能會顯示已攝取的文件密鑰。
bool snapshot_consistency = true;
// 如果設置爲false，如果文件key範圍與DB中的現有key或tombstones重疊，則IngestExternalFile()將失敗。
bool allow_global_seqno = true;
// 如果設置爲false並且文件key範圍與memtable key範圍重疊（需要memtable flush），則IngestExternalFile()將失敗。
bool allow_blocking_flush = true;
// 如果希望跳過要提取的文件中的重複鍵而不是覆蓋該鍵下的現有數據，則設置爲true。
// 用例：回填數據庫中的一些歷史數據，而不會覆蓋現有的較新版本的數據。此選項只能在數據庫
// 自從時間開始以及allow_ingest_behind = true運行時使用。所有文件都將在seqno = 0的最底層攝取。
bool ingest_behind = false;
// 如果要將global_seqno寫入外部SST文件中的給定偏移量以便向後兼容，則設置爲true。
// 早期版本的RocksDB將global_seqno寫入攝取的SST文件中的給定偏移量，而新版本的RocksDB則不會。
// 如果您使用新版本的RocksDB攝取外部SST並希望能夠降級到RocksDB的舊版本，則應將“write_global_seqno”
// 設置爲true。 如果您的服務剛剛開始使用新的RocksDB，我們建議您將此選項設置爲false，這會帶來兩個好處：
// 1.在攝取過程中沒有額外的隨機寫入global_seqno。
// 2.無需編寫外部SST文件，就可以進行校驗和。
// 我們計劃將來默認將此選項設置爲false。
bool write_global_seqno = true;
// 如果要在攝取之前驗證外部SST文件的每個塊的校驗和，則設置爲true。
// 警告：將此設置爲true會導致文件攝取速度變慢，因爲必須讀取外部SST文件。
bool verify_checksums_before_ingest = false;
//當verify_checksums_before_ingest = true時，RocksDB使用默認的預讀設置掃描文件，同時在攝取前驗證校驗和。
// 用戶可以使用此選項覆蓋默認值。使用較大的預讀大小(>2MB)通常可以提高旋轉磁盤上的前向迭代性能。
size_t verify_checksums_readahead_size = 0;
};
enum TraceFilterType : uint64_t {
// 追蹤所有的參數
kTraceFilterNone = 0x0,
// 不追蹤get操作
kTraceFilterGet = 0x1 << 0,
// 不追蹤寫操作
kTraceFilterWrite = 0x1 << 1
};
// 用於StartTrace的TraceOptions
struct TraceOptions {
// 爲避免跟蹤文件大小比存儲空間大，用戶可以設置以byte爲單位的最大跟蹤文件大小。 默認值爲64GB
uint64_t max_trace_file_size = uint64_t{64} * 1024 * 1024 * 1024;
// 指定跟蹤採樣選項，即每個請求捕獲一個。默認爲1（捕獲每個請求）。
uint64_t sampling_frequency = 1;
// Note: 在取樣之前過濾發生
uint64_t filter = kTraceFilterNone;
};
// ImportColumnFamily()使用ImportColumnFamilyOptions
struct ImportColumnFamilyOptions {
// 可以設置爲true以移動文件而不是複製它們。
bool move_files = false;
};
// 用在DB::GetApproximateSizes()的參數
struct SizeApproximationOptions {
// 定義返回的大小是否應包含mem表中最近寫入的數據。如果設置爲false，則include_files必須爲true。
bool include_memtabtles = false;
// 定義返回的大小是否應包括序列化到磁盤的數據。
// 如果設置爲false，則include_memtabtles必須爲true。
bool include_files = true;
// 當使用DB :: GetApproximateSizes近似用於存儲鍵範圍的文件總大小時，允許使用高達
// total_files_size * files_size_error_margin的誤差範圍進行近似。 這允許在文件大小近似中採用一些快捷方式，
// 從而產生更好的性能，同時保證產生的錯誤在合理的範圍內。
// 例如，如果值爲0.1，則返回文件大小近似的誤差範圍將在10％以內。
//如果值爲非正值 - 則執行更精確但更加CPU密集的估計。
double files_size_error_margin = -1.0;
};
} // namespace rocksdb