Rocksdb参数总结

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