flowchart TB
    subgraph "DB Module Architecture"
        subgraph "API Layer"
            DBAPI[DB API Interface]
            CFAPI[Column Family API]
            TxnAPI[Transaction API]
            IterAPI[Iterator API]
        end
        
        subgraph "Core Implementation"
            DBImpl[DBImpl Core]
            subgraph "Write Path"
                WriteBatch[Write Batch]
                WriteThread[Write Thread]
                WALWriter[WAL Writer]
            end
            
            subgraph "Read Path"
                GetImpl[Get Implementation]
                IterImpl[Iterator Implementation]
                SnapshotMgr[Snapshot Manager]
            end
            
            subgraph "Background Tasks"
                FlushScheduler[Flush Scheduler]
                CompactionScheduler[Compaction Scheduler]
                PeriodicTasks[Periodic Tasks]
            end
        end
        
        subgraph "Storage Management"
            VersionSet[Version Set]
            ColumnFamilySet[Column Family Set]
            MemTableList[MemTable List]
            TableCache[Table Cache]
        end
        
        subgraph "System Integration"
            ErrorHandler[Error Handler]
            EventLogger[Event Logger]
            Statistics[Statistics]
            InfoLog[Info Log]
        end
    end
    
    subgraph "External Dependencies"
        MemTable[MemTable Module]
        Table[Table Module]
        Cache[Cache Module]
        FileSystem[File System]
        Environment[Environment]
    end
    
    %% API to Implementation
    DBAPI --> DBImpl
    CFAPI --> DBImpl
    TxnAPI --> DBImpl
    IterAPI --> DBImpl
    
    %% Core Implementation Connections
    DBImpl --> WriteBatch
    DBImpl --> GetImpl
    DBImpl --> FlushScheduler
    WriteBatch --> WriteThread
    WriteThread --> WALWriter
    GetImpl --> SnapshotMgr
    
    %% Storage Management
    DBImpl --> VersionSet
    DBImpl --> ColumnFamilySet
    VersionSet --> MemTableList
    VersionSet --> TableCache
    
    %% System Integration
    DBImpl --> ErrorHandler
    DBImpl --> EventLogger
    DBImpl --> Statistics
    DBImpl --> InfoLog
    
    %% External Dependencies
    DBImpl --> MemTable
    DBImpl --> Table
    DBImpl --> Cache
    DBImpl --> FileSystem
    DBImpl --> Environment
    
    classDef apiClass fill:#e3f2fd
    classDef coreClass fill:#f3e5f5
    classDef storageClass fill:#e8f5e8
    classDef systemClass fill:#fff3e0
    classDef externalClass fill:#fce4ec
    
    class DBAPI,CFAPI,TxnAPI,IterAPI apiClass
    class DBImpl,WriteBatch,WriteThread,WALWriter,GetImpl,IterImpl,SnapshotMgr,FlushScheduler,CompactionScheduler,PeriodicTasks coreClass
    class VersionSet,ColumnFamilySet,MemTableList,TableCache storageClass
    class ErrorHandler,EventLogger,Statistics,InfoLog systemClass
    class MemTable,Table,Cache,FileSystem,Environment externalClass

// 写入操作的核心流程
Status DBImpl::WriteImpl(const WriteOptions& write_options,
                        WriteBatch* my_batch, WriteCallback* callback) {
    // 1. 预处理：检查参数有效性和数据库状态
    if (my_batch == nullptr) {
        return Status::InvalidArgument("Batch is nullptr");
    }
    
    // 2. 加入写入组：通过Write Thread实现批量写入优化
    WriteThread::Writer w(write_options, my_batch, callback);
    write_thread_.JoinBatchGroup(&w);
    
    if (w.state == WriteThread::STATE_GROUP_LEADER) {
        // 3. 作为组长执行批量写入
        WriteThread::WriteGroup write_group;
        write_thread_.EnterAsBatchGroupLeader(&w, &write_group);
        
        // 4. 预写日志：保证持久性
        Status status = WriteToWAL(write_group);
        if (!status.ok()) {
            write_thread_.ExitAsBatchGroupLeader(write_group, status);
            return status;
        }
        
        // 5. 写入MemTable：更新内存数据
        status = WriteBatchInternal::InsertInto(
            write_group, sequence_, column_family_memtables_.get());
        
        // 6. 完成写入组
        write_thread_.ExitAsBatchGroupLeader(write_group, status);
        return status;
    } else {
        // 7. 等待组长完成写入
        return w.FinalStatus();
    }
}

// 读取操作的核心流程
Status DBImpl::GetImpl(const ReadOptions& read_options,
                      ColumnFamilyHandle* column_family,
                      const Slice& key, PinnableSlice* value) {
    // 1. 获取读取快照：确定读取的数据版本
    SequenceNumber snapshot_seq = GetSequenceNumber(read_options);
    
    // 2. 构建LookupKey：包含用户键和序列号
    LookupKey lkey(key, snapshot_seq);
    
    // 3. 查找MemTable：优先查找内存中的最新数据
    bool found_final_value = false;
    Status s = mem_->Get(lkey, value, &found_final_value);
    if (found_final_value) {
        return s;
    }
    
    // 4. 查找Immutable MemTable：查找正在Flush的内存表
    for (auto* imm_mem : imm_memtables) {
        s = imm_mem->Get(lkey, value, &found_final_value);
        if (found_final_value) {
            return s;
        }
    }
    
    // 5. 查找SST文件：按层级顺序查找磁盘文件
    Version* current = versions_->current();
    s = current->Get(read_options, lkey, value, &found_final_value);
    
    return s;
}

// Compaction调度的核心逻辑
void DBImpl::MaybeScheduleFlushOrCompaction() {
    // 1. 检查是否需要Flush
    for (auto cfd : *versions_->GetColumnFamilySet()) {
        if (cfd->imm()->IsFlushPending()) {
            ScheduleFlushJob(cfd);
        }
    }
    
    // 2. 检查是否需要Compaction
    for (auto cfd : *versions_->GetColumnFamilySet()) {
        if (cfd->NeedsCompaction()) {
            Compaction* c = cfd->PickCompaction();
            if (c != nullptr) {
                ScheduleCompactionJob(cfd, c);
            }
        }
    }
}

// Compaction选择策略
Compaction* LevelCompactionPicker::PickCompaction() {
    // 1. 计算每层的得分
    for (int level = 0; level < num_levels_; level++) {
        double score = ComputeCompactionScore(level);
        if (score > 1.0) {
            // 2. 选择得分最高的层进行Compaction
            return PickCompactionBySize(level);
        }
    }
    return nullptr;
}

struct DBOptions {
    // 基础配置
    bool create_if_missing = false;           // 数据库不存在时是否创建
    bool error_if_exists = false;             // 数据库已存在时是否报错
    
    // 并发控制
    int max_background_jobs = 2;              // 后台任务线程数
    int max_subcompactions = 1;               // 子压缩任务数
    bool allow_concurrent_memtable_write = true; // 并发MemTable写入
    
    // 内存管理
    std::shared_ptr<WriteBufferManager> write_buffer_manager; // 统一内存管理
    size_t db_write_buffer_size = 0;          // 数据库总写缓冲区大小
    
    // WAL配置
    bool avoid_flush_during_recovery = false; // 恢复时避免Flush
    bool avoid_flush_during_shutdown = false; // 关闭时避免Flush
    size_t wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
    
    // 文件管理
    int max_open_files = -1;                  // 最大打开文件数
    uint64_t max_file_opening_threads = 16;   // 文件打开线程数
    
    // 统计与监控
    bool enable_statistics = false;           // 启用统计收集
    std::shared_ptr<Statistics> statistics;   // 统计信息收集器
    std::vector<std::shared_ptr<EventListener>> listeners; // 事件监听器
};

struct ColumnFamilyOptions {
    // MemTable配置
    size_t write_buffer_size = 64 << 20;      // MemTable大小（64MB）
    int max_write_buffer_number = 2;          // 最大MemTable数量
    int min_write_buffer_number_to_merge = 1; // 最小合并MemTable数量
    
    // Compaction配置
    int level0_file_num_compaction_trigger = 4;    // L0文件数触发压缩
    int level0_slowdown_writes_trigger = 20;       // L0文件数减缓写入
    int level0_stop_writes_trigger = 36;           // L0文件数停止写入
    uint64_t target_file_size_base = 64 << 20;     // 目标文件大小
    uint64_t max_bytes_for_level_base = 256 << 20; // L1层最大大小
    
    // 缓存配置
    std::shared_ptr<Cache> block_cache;            // 数据块缓存
    size_t block_cache_compressed_size = 0;        // 压缩块缓存大小
    
    // 过滤器配置
    std::shared_ptr<const FilterPolicy> filter_policy; // 过滤器策略
    bool optimize_filters_for_hits = false;       // 为命中优化过滤器
};

// 核心性能指标
enum Tickers : uint32_t {
    // 基础操作统计
    NUMBER_DB_SEEK,                    // Seek操作次数
    NUMBER_DB_NEXT,                    // Next操作次数
    NUMBER_DB_PREV,                    // Prev操作次数
    NUMBER_DB_SEEK_FOUND,              // Seek命中次数
    NUMBER_DB_NEXT_FOUND,              // Next命中次数
    
    // 读写统计
    BYTES_READ,                        // 读取字节数
    BYTES_WRITTEN,                     // 写入字节数
    NUMBER_KEYS_WRITTEN,               // 写入键数量
    NUMBER_KEYS_READ,                  // 读取键数量
    NUMBER_KEYS_UPDATED,               // 更新键数量
    
    // Compaction统计
    COMPACT_READ_BYTES,                // Compaction读取字节数
    COMPACT_WRITE_BYTES,               // Compaction写入字节数
    NUMBER_SUPERVERSION_ACQUIRES,      // SuperVersion获取次数
    NUMBER_SUPERVERSION_RELEASES,      // SuperVersion释放次数
    
    // 缓存统计
    BLOCK_CACHE_HIT,                   // 块缓存命中次数
    BLOCK_CACHE_MISS,                  // 块缓存未命中次数
    BLOCK_CACHE_ADD,                   // 块缓存添加次数
    BLOCK_CACHE_INDEX_HIT,             // 索引缓存命中次数
    BLOCK_CACHE_FILTER_HIT,            // 过滤器缓存命中次数
    
    // WAL统计
    WAL_FILE_SYNCED,                   // WAL文件同步次数
    WAL_FILE_BYTES,                    // WAL文件字节数
    
    // 错误统计
    NUMBER_DB_SEEK_ERROR,              // Seek错误次数
    NUMBER_DB_NEXT_ERROR,              // Next错误次数
    NUMBER_DB_PREV_ERROR,              // Prev错误次数
};

// 延迟统计
enum Histograms : uint32_t {
    DB_GET,                            // Get操作延迟
    DB_WRITE,                          // Write操作延迟
    COMPACTION_TIME,                   // Compaction耗时
    SUBCOMPACTION_SETUP_TIME,          // 子压缩设置耗时
    TABLE_SYNC_MICROS,                 // 表同步延迟
    COMPACTION_OUTFILE_SYNC_MICROS,    // Compaction输出文件同步延迟
    WAL_FILE_SYNC_MICROS,              // WAL文件同步延迟
    MANIFEST_FILE_SYNC_MICROS,         // Manifest文件同步延迟
    
    // 读取路径延迟
    TABLE_OPEN_IO_MICROS,              // 表文件打开IO延迟
    DB_MULTIGET,                       // MultiGet操作延迟
    READ_BLOCK_COMPACTION_MICROS,      // 读取块压缩延迟
    READ_BLOCK_GET_MICROS,             // 读取块Get延迟
    
    // 写入路径延迟
    WRITE_RAW_BLOCK_MICROS,            // 写入原始块延迟
    NUM_FILES_IN_SINGLE_COMPACTION,    // 单次压缩文件数
    DB_SEEK,                           // Seek操作延迟
    WRITE_STALL,                       // 写入停顿时间
};

// 统计信息收集示例
void MonitorDBPerformance(DB* db) {
    std::string stats_string;
    
    // 1. 获取基础统计信息
    db->GetProperty("rocksdb.stats", &stats_string);
    
    // 2. 获取特定指标
    uint64_t cache_hit = db->GetOptions().statistics->getTickerCount(BLOCK_CACHE_HIT);
    uint64_t cache_miss = db->GetOptions().statistics->getTickerCount(BLOCK_CACHE_MISS);
    double cache_hit_rate = static_cast<double>(cache_hit) / (cache_hit + cache_miss);
    
    // 3. 获取延迟分布
    HistogramData get_latency;
    db->GetOptions().statistics->histogramData(DB_GET, &get_latency);
    
    // 4. 输出关键指标
    printf("Cache Hit Rate: %.2f%%\n", cache_hit_rate * 100);
    printf("Get P99 Latency: %.2f ms\n", get_latency.percentile99 / 1000.0);
    printf("Get Average Latency: %.2f ms\n", get_latency.average / 1000.0);
}

// Put操作的输入参数
struct PutRequest {
    WriteOptions write_options;        // 写入选项
    ColumnFamilyHandle* column_family; // 列族句柄，nullptr表示默认列族
    Slice key;                        // 键，任意字节序列
    Slice value;                      // 值，任意字节序列
};

// WriteOptions结构体定义
struct WriteOptions {
    bool sync = false;                // 是否同步写入WAL
    bool disableWAL = false;          // 是否禁用WAL
    bool ignore_missing_column_families = false; // 忽略不存在的列族
    bool no_slowdown = false;         // 不因写入停顿而阻塞
    bool low_pri = false;             // 低优先级写入
    uint64_t memtable_insert_hint_per_batch = 0; // MemTable插入提示
    Env::IOPriority rate_limiter_priority = Env::IO_TOTAL; // 限流优先级
    uint8_t protection_bytes_per_key = 0; // 每个键的保护字节数
};

// Put操作的返回结果
class Status {
public:
    bool ok() const;                  // 操作是否成功
    bool IsNotFound() const;          // 是否未找到
    bool IsCorruption() const;        // 是否数据损坏
    bool IsNotSupported() const;      // 是否不支持
    bool IsInvalidArgument() const;   // 是否参数无效
    bool IsIOError() const;           // 是否IO错误
    std::string ToString() const;     // 获取错误描述
    
private:
    Code code_;                       // 错误码
    SubCode subcode_;                 // 子错误码
    std::unique_ptr<Slice> msg_;      // 错误消息
};

// DBImpl中Put操作的入口函数
Status DBImpl::Put(const WriteOptions& o, ColumnFamilyHandle* column_family,
                   const Slice& key, const Slice& val) {
    // 1. 时间戳检查：验证列族是否配置了时间戳
    const Status s = FailIfCfHasTs(column_family);
    if (!s.ok()) {
        return s;
    }
    
    // 2. 调用基类Put方法，创建WriteBatch并执行写入
    return DB::Put(o, column_family, key, val);
}

// DB基类中的Put实现
Status DB::Put(const WriteOptions& opt, ColumnFamilyHandle* column_family,
               const Slice& key, const Slice& value) {
    // 1. 创建WriteBatch：聚合单个Put操作
    WriteBatch batch(0 /* reserved_bytes */, 0 /* max_bytes */,
                     opt.protection_bytes_per_key, 0 /* default_cf_ts_sz */);
    
    // 2. 添加Put操作到批次中
    Status s = batch.Put(column_family, key, value);
    if (!s.ok()) {
        return s;
    }
    
    // 3. 执行批量写入
    return Write(opt, &batch);
}

// Write方法的核心实现
Status DBImpl::Write(const WriteOptions& write_options, WriteBatch* my_batch) {
    Status s;
    
    // 1. 数据保护：更新保护信息
    if (write_options.protection_bytes_per_key > 0) {
        s = WriteBatchInternal::UpdateProtectionInfo(
            my_batch, write_options.protection_bytes_per_key);
    }
    
    // 2. 执行写入实现
    if (s.ok()) {
        s = WriteImpl(write_options, my_batch, /*callback=*/nullptr,
                      /*user_write_cb=*/nullptr, /*wal_used=*/nullptr);
    }
    
    return s;
}

// WriteImpl的核心逻辑（简化版）
Status DBImpl::WriteImpl(const WriteOptions& write_options, WriteBatch* my_batch,
                        WriteCallback* callback, UserWriteCallback* user_write_cb) {
    // 1. 参数验证
    if (my_batch == nullptr) {
        return Status::InvalidArgument("Batch is nullptr");
    }
    
    // 2. 创建Writer并加入写入组
    WriteThread::Writer w(write_options, my_batch, callback, user_write_cb);
    write_thread_.JoinBatchGroup(&w);
    
    // 3. 如果是组长，执行批量写入
    if (w.state == WriteThread::STATE_GROUP_LEADER) {
        WriteThread::WriteGroup write_group;
        write_thread_.EnterAsBatchGroupLeader(&w, &write_group);
        
        // 4. 写入WAL：保证持久性
        Status status = WriteToWAL(write_group, log_writer_.get());
        if (!status.ok()) {
            write_thread_.ExitAsBatchGroupLeader(write_group, status);
            return status;
        }
        
        // 5. 写入MemTable：更新内存数据
        status = WriteBatchInternal::InsertInto(
            write_group, sequence_, column_family_memtables_.get());
        
        // 6. 完成写入组
        write_thread_.ExitAsBatchGroupLeader(write_group, status);
        return status;
    } else {
        // 7. 等待组长完成写入
        return w.FinalStatus();
    }
}

sequenceDiagram
    autonumber
    participant Client
    participant DBImpl
    participant WriteBatch
    participant WriteThread
    participant WAL
    participant MemTable
    
    Client->>DBImpl: Put(options, cf, key, value)
    DBImpl->>DBImpl: FailIfCfHasTs(cf)
    DBImpl->>WriteBatch: Create batch
    WriteBatch->>WriteBatch: Put(cf, key, value)
    DBImpl->>WriteThread: JoinBatchGroup(writer)
    
    alt Group Leader
        WriteThread->>WriteThread: EnterAsBatchGroupLeader()
        WriteThread->>WAL: WriteToWAL(write_group)
        WAL-->>WriteThread: WAL Write Complete
        WriteThread->>MemTable: InsertInto(write_group)
        MemTable-->>WriteThread: MemTable Insert Complete
        WriteThread->>WriteThread: ExitAsBatchGroupLeader()
        WriteThread-->>DBImpl: Status OK
    else Group Follower
        WriteThread->>WriteThread: Wait for leader
        WriteThread-->>DBImpl: Status from leader
    end
    
    DBImpl-->>Client: Status

// Get操作的输入参数
struct GetRequest {
    ReadOptions read_options;          // 读取选项
    ColumnFamilyHandle* column_family; // 列族句柄
    Slice key;                        // 要查找的键
};

// ReadOptions结构体定义
struct ReadOptions {
    bool verify_checksums = true;      // 验证校验和
    bool fill_cache = true;           // 是否填充缓存
    const Snapshot* snapshot = nullptr; // 读取快照
    ReadTier read_tier = kReadAllTier; // 读取层级
    bool tailing = false;             // 尾部读取模式
    bool managed = false;             // 托管迭代器
    bool total_order_seek = false;    // 全序Seek
    bool prefix_same_as_start = false; // 前缀优化
    bool pin_data = false;            // 固定数据
    bool background_purge_on_iterator_cleanup = false; // 后台清理
    uint64_t max_skippable_internal_keys = 0; // 最大可跳过内部键数
    bool ignore_range_deletions = false; // 忽略范围删除
    Env::IOActivity io_activity = Env::IOActivity::kUnknown; // IO活动类型
    std::shared_ptr<const Slice> timestamp; // 时间戳
    const Slice* iterate_lower_bound = nullptr; // 迭代下界
    const Slice* iterate_upper_bound = nullptr; // 迭代上界
};

// Get操作的返回结果
struct GetResponse {
    Status status;                    // 操作状态
    PinnableSlice value;             // 查找到的值
    std::string timestamp;           // 时间戳（如果启用）
};

// PinnableSlice：支持零拷贝的值容器
class PinnableSlice : public Slice {
public:
    void Reset();                    // 重置内容
    void PinSlice(const Slice& slice, CleanupFunction cleanup); // 固定切片
    void PinSelf(const Slice& slice); // 固定自身
    bool IsPinned() const;           // 是否已固定
    
private:
    std::string buf_;                // 内部缓冲区
    void* pinned_ptr_;              // 固定指针
    size_t pinned_size_;            // 固定大小
    CleanupFunction cleanup_func_;   // 清理函数
};

// DBImpl中Get操作的入口函数
Status DBImpl::Get(const ReadOptions& _read_options,
                   ColumnFamilyHandle* column_family, const Slice& key,
                   PinnableSlice* value, std::string* timestamp) {
    // 1. 参数验证：检查value指针有效性
    assert(value != nullptr);
    value->Reset();
    
    // 2. IO活动类型检查
    if (_read_options.io_activity != Env::IOActivity::kUnknown &&
        _read_options.io_activity != Env::IOActivity::kGet) {
        return Status::InvalidArgument(
            "Can only call Get with io_activity kUnknown or kGet");
    }
    
    // 3. 设置默认IO活动类型
    ReadOptions read_options(_read_options);
    if (read_options.io_activity == Env::IOActivity::kUnknown) {
        read_options.io_activity = Env::IOActivity::kGet;
    }
    
    // 4. 调用内部Get实现
    Status s = GetImpl(read_options, column_family, key, value, timestamp);
    return s;
}

// GetImpl的核心实现
Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
                      GetImplOptions& get_impl_options) {
    // 1. 获取列族数据
    auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(
        get_impl_options.column_family);
    auto cfd = cfh->cfd();
    
    // 2. 获取SuperVersion：包含当前版本的所有组件
    SuperVersion* sv = GetAndRefSuperVersion(cfd);
    
    // 3. 确定读取快照
    SequenceNumber snapshot;
    if (read_options.snapshot != nullptr) {
        snapshot = read_options.snapshot->GetSequenceNumber();
    } else {
        snapshot = versions_->LastSequence();
    }
    
    // 4. 构建查找键
    LookupKey lkey(key, snapshot, read_options.timestamp);
    
    // 5. 查找MemTable
    bool skip_memtable = (read_options.read_tier == kPersistedTier &&
                         has_unpersisted_data_.load(std::memory_order_relaxed));
    bool done = false;
    Status s;
    
    if (!skip_memtable) {
        // 5.1 查找活跃MemTable
        if (sv->mem->Get(lkey, get_impl_options.value, /*columns=*/nullptr,
                        get_impl_options.timestamp, &s, &merge_context,
                        &max_covering_tombstone_seq, read_options)) {
            done = true;
            RecordTick(stats_, MEMTABLE_HIT);
        }
        // 5.2 查找不可变MemTable
        else if ((s.ok() || s.IsMergeInProgress()) &&
                 sv->imm->Get(lkey, get_impl_options.value, /*columns=*/nullptr,
                             get_impl_options.timestamp, &s, &merge_context,
                             &max_covering_tombstone_seq, read_options)) {
            done = true;
            RecordTick(stats_, MEMTABLE_HIT);
        }
    }
    
    // 6. 查找SST文件
    if (!done) {
        sv->current->Get(read_options, lkey, get_impl_options.value,
                        /*columns=*/nullptr, get_impl_options.timestamp, &s,
                        &merge_context, &max_covering_tombstone_seq,
                        &pinned_iters_mgr);
        RecordTick(stats_, MEMTABLE_MISS);
    }
    
    // 7. 清理SuperVersion引用
    ReturnAndCleanupSuperVersion(cfd, sv);
    return s;
}

// Version::Get的核心实现（SST文件查找）
void Version::Get(const ReadOptions& read_options, const LookupKey& k,
                 PinnableSlice* value, std::string* timestamp, Status* status,
                 MergeContext* merge_context, SequenceNumber* max_covering_tombstone_seq,
                 PinnedIteratorsManager* pinned_iters_mgr) {
    
    // 1. 按层级顺序查找
    for (int level = 0; level < storage_info_.num_levels_; level++) {
        size_t num_files = storage_info_.files_[level].size();
        if (num_files == 0) continue;
        
        // 2. Level 0特殊处理：文件间可能重叠
        if (level == 0) {
            for (size_t i = 0; i < num_files; ++i) {
                FileMetaData* f = storage_info_.files_[level][i];
                if (AfterFile(ucmp, &k, f) || BeforeFile(ucmp, &k, f)) {
                    continue;
                }
                
                // 查找单个文件
                *status = table_cache_->Get(
                    read_options, *internal_comparator_, *f, ikey, value,
                    timestamp, merge_context, max_covering_tombstone_seq,
                    pinned_iters_mgr);
                    
                if (!status->ok()) {
                    return;
                }
            }
        } else {
            // 3. Level 1+：文件不重叠，二分查找
            uint32_t index = FindFile(*internal_comparator_,
                                     storage_info_.files_[level], ikey);
            if (index < num_files) {
                FileMetaData* f = storage_info_.files_[level][index];
                if (ucmp->Compare(user_key, f->smallest.user_key()) >= 0) {
                    *status = table_cache_->Get(
                        read_options, *internal_comparator_, *f, ikey, value,
                        timestamp, merge_context, max_covering_tombstone_seq,
                        pinned_iters_mgr);
                }
            }
        }
    }
}

sequenceDiagram
    autonumber
    participant Client
    participant DBImpl
    participant SuperVersion
    participant MemTable
    participant ImmMemTable
    participant Version
    participant TableCache
    participant SST
    
    Client->>DBImpl: Get(options, cf, key, value)
    DBImpl->>DBImpl: Parameter validation
    DBImpl->>SuperVersion: GetAndRefSuperVersion(cfd)
    SuperVersion-->>DBImpl: sv
    DBImpl->>DBImpl: Determine snapshot sequence
    
    alt MemTable Lookup
        DBImpl->>MemTable: Get(lkey, value, ...)
        alt Found in MemTable
            MemTable-->>DBImpl: Found + value
            DBImpl->>DBImpl: RecordTick(MEMTABLE_HIT)
        else Not Found
            MemTable-->>DBImpl: Not Found
            DBImpl->>ImmMemTable: Get(lkey, value, ...)
            alt Found in ImmMemTable
                ImmMemTable-->>DBImpl: Found + value
                DBImpl->>DBImpl: RecordTick(MEMTABLE_HIT)
            else Not Found
                ImmMemTable-->>DBImpl: Not Found
            end
        end
    end
    
    alt SST Lookup (if not found in MemTable)
        DBImpl->>Version: Get(lkey, value, ...)
        Version->>Version: Search Level 0 files
        Version->>TableCache: Get(file, key, ...)
        TableCache->>SST: Read data block
        SST-->>TableCache: Block data
        TableCache-->>Version: Found/NotFound + value
        Version-->>DBImpl: Final result
        DBImpl->>DBImpl: RecordTick(MEMTABLE_MISS)
    end
    
    DBImpl->>SuperVersion: ReturnAndCleanupSuperVersion(sv)
    DBImpl-->>Client: Status + value

// Delete操作的输入参数
struct DeleteRequest {
    WriteOptions write_options;        // 写入选项（同Put操作）
    ColumnFamilyHandle* column_family; // 列族句柄
    Slice key;                        // 要删除的键
};

// Delete操作返回Status，无额外数据
// Status结构体定义同Put操作

// DBImpl中Delete操作的入口函数
Status DBImpl::Delete(const WriteOptions& write_options,
                      ColumnFamilyHandle* column_family, const Slice& key) {
    // 1. 时间戳检查
    const Status s = FailIfCfHasTs(column_family);
    if (!s.ok()) {
        return s;
    }
    
    // 2. 调用基类Delete方法
    return DB::Delete(write_options, column_family, key);
}

// DB基类中的Delete实现
Status DB::Delete(const WriteOptions& opt, ColumnFamilyHandle* column_family,
                  const Slice& key) {
    // 1. 创建WriteBatch
    WriteBatch batch(0 /* reserved_bytes */, 0 /* max_bytes */,
                     opt.protection_bytes_per_key, 0 /* default_cf_ts_sz */);
    
    // 2. 添加Delete操作到批次中
    Status s = batch.Delete(column_family, key);
    if (!s.ok()) {
        return s;
    }
    
    // 3. 执行批量写入
    return Write(opt, &batch);
}

// WriteBatch：批量操作容器
class WriteBatch {
public:
    WriteBatch();
    explicit WriteBatch(size_t reserved_bytes);
    
    // 添加操作到批次
    Status Put(ColumnFamilyHandle* column_family, const Slice& key, const Slice& value);
    Status Delete(ColumnFamilyHandle* column_family, const Slice& key);
    Status Merge(ColumnFamilyHandle* column_family, const Slice& key, const Slice& value);
    Status DeleteRange(ColumnFamilyHandle* column_family,
                      const Slice& begin_key, const Slice& end_key);
    
    // 批次信息
    int Count() const;                // 操作数量
    size_t GetDataSize() const;       // 数据大小
    void Clear();                     // 清空批次
    std::string Data() const;         // 获取序列化数据
    
private:
    std::string rep_;                 // 内部表示
    size_t content_flags_;           // 内容标志
};

// WriteBatch的核心写入逻辑
Status DBImpl::Write(const WriteOptions& write_options, WriteBatch* my_batch) {
    Status s;
    
    // 1. 数据保护：如果启用了保护机制
    if (write_options.protection_bytes_per_key > 0) {
        s = WriteBatchInternal::UpdateProtectionInfo(
            my_batch, write_options.protection_bytes_per_key);
    }
    
    // 2. 执行写入
    if (s.ok()) {
        s = WriteImpl(write_options, my_batch, /*callback=*/nullptr,
                      /*user_write_cb=*/nullptr, /*wal_used=*/nullptr);
    }
    
    return s;
}

// WriteBatch内部操作添加
Status WriteBatch::Put(ColumnFamilyHandle* column_family,
                      const Slice& key, const Slice& value) {
    // 1. 获取列族ID
    uint32_t cf_id = GetColumnFamilyID(column_family);
    
    // 2. 序列化操作到内部表示
    WriteBatchInternal::Put(this, cf_id, key, value);
    
    // 3. 更新内容标志
    content_flags_.store(content_flags_.load(std::memory_order_relaxed) |
                        ContentFlags::HAS_PUT, std::memory_order_relaxed);
    
    return Status::OK();
}

sequenceDiagram
    autonumber
    participant Client
    participant WriteBatch
    participant DBImpl
    participant WriteThread
    participant WAL
    participant MemTable
    
    Client->>WriteBatch: Create WriteBatch
    Client->>WriteBatch: Put(cf1, key1, value1)
    Client->>WriteBatch: Put(cf2, key2, value2)
    Client->>WriteBatch: Delete(cf1, key3)
    Client->>DBImpl: Write(options, batch)
    
    DBImpl->>WriteThread: JoinBatchGroup(writer)
    WriteThread->>WriteThread: Group multiple writers
    
    alt Group Leader
        WriteThread->>WAL: WriteToWAL(write_group)
        Note over WAL: Single WAL sync for entire group
        WAL-->>WriteThread: WAL Complete
        
        WriteThread->>MemTable: InsertInto(write_group)
        Note over MemTable: Apply all operations atomically
        MemTable-->>WriteThread: MemTable Complete
        
        WriteThread->>WriteThread: Update sequence numbers
        WriteThread-->>DBImpl: Group Status
    end
    
    DBImpl-->>Client: Status

// MultiGet操作的输入参数
struct MultiGetRequest {
    ReadOptions read_options;                      // 读取选项
    std::vector<ColumnFamilyHandle*> column_families; // 列族句柄数组
    std::vector<Slice> keys;                      // 键数组
};

// MultiGet操作的返回结果
struct MultiGetResponse {
    std::vector<Status> statuses;                 // 每个键的查找状态
    std::vector<std::string> values;              // 查找到的值数组
};

// MultiGet的核心实现
std::vector<Status> DBImpl::MultiGet(
    const ReadOptions& read_options,
    const std::vector<ColumnFamilyHandle*>& column_families,
    const std::vector<Slice>& keys,
    std::vector<std::string>* values) {
    
    StopWatch sw(immutable_db_options_.clock, stats_, DB_MULTIGET);
    
    // 1. 参数验证
    size_t num_keys = keys.size();
    std::vector<Status> stat_list(num_keys);
    values->resize(num_keys);
    
    // 2. 按列族分组键
    std::unordered_map<uint32_t, std::vector<size_t>> cf_to_keys;
    for (size_t i = 0; i < num_keys; ++i) {
        auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(column_families[i]);
        cf_to_keys[cfh->GetID()].push_back(i);
    }
    
    // 3. 按列族批量查找
    for (auto& cf_keys : cf_to_keys) {
        uint32_t cf_id = cf_keys.first;
        auto& key_indices = cf_keys.second;
        
        // 获取SuperVersion
        ColumnFamilyData* cfd = GetColumnFamilySet()->GetColumnFamily(cf_id);
        SuperVersion* sv = GetAndRefSuperVersion(cfd);
        
        // 批量查找当前列族的所有键
        MultiGetImpl(read_options, key_indices, keys, values, stat_list, sv);
        
        // 清理SuperVersion引用
        ReturnAndCleanupSuperVersion(cfd, sv);
    }
    
    return stat_list;
}

// MultiGetImpl的优化实现
void DBImpl::MultiGetImpl(const ReadOptions& read_options,
                         const std::vector<size_t>& key_indices,
                         const std::vector<Slice>& keys,
                         std::vector<std::string>* values,
                         std::vector<Status>& stat_list,
                         SuperVersion* sv) {
    
    // 1. 构建查找上下文
    std::vector<LookupKey> lookup_keys;
    SequenceNumber snapshot = GetSnapshot(read_options);
    
    for (size_t idx : key_indices) {
        lookup_keys.emplace_back(keys[idx], snapshot, read_options.timestamp);
    }
    
    // 2. 批量查找MemTable
    std::vector<bool> found_in_mem(key_indices.size(), false);
    for (size_t i = 0; i < key_indices.size(); ++i) {
        size_t idx = key_indices[i];
        if (sv->mem->Get(lookup_keys[i], &(*values)[idx], /*columns=*/nullptr,
                        /*timestamp=*/nullptr, &stat_list[idx], &merge_context,
                        &max_covering_tombstone_seq, read_options)) {
            found_in_mem[i] = true;
            RecordTick(stats_, MEMTABLE_HIT);
        }
    }
    
    // 3. 批量查找SST文件（未在MemTable中找到的键）
    std::vector<size_t> sst_keys;
    for (size_t i = 0; i < key_indices.size(); ++i) {
        if (!found_in_mem[i]) {
            sst_keys.push_back(key_indices[i]);
        }
    }
    
    if (!sst_keys.empty()) {
        sv->current->MultiGet(read_options, sst_keys, keys, values, stat_list);
        RecordTick(stats_, MEMTABLE_MISS);
    }
}

// NewIterator操作的输入参数
struct NewIteratorRequest {
    ReadOptions read_options;          // 读取选项
    ColumnFamilyHandle* column_family; // 列族句柄
};

// Iterator接口定义
class Iterator {
public:
    virtual ~Iterator() {}
    
    // 迭代器控制
    virtual bool Valid() const = 0;           // 当前位置是否有效
    virtual void SeekToFirst() = 0;           // 定位到第一个元素
    virtual void SeekToLast() = 0;            // 定位到最后一个元素
    virtual void Seek(const Slice& target) = 0; // 定位到指定键
    virtual void SeekForPrev(const Slice& target) = 0; // 反向定位
    virtual void Next() = 0;                  // 移动到下一个元素
    virtual void Prev() = 0;                  // 移动到上一个元素
    
    // 数据访问
    virtual Slice key() const = 0;            // 获取当前键
    virtual Slice value() const = 0;          // 获取当前值
    virtual Status status() const = 0;        // 获取迭代器状态
    
    // 高级功能
    virtual void Refresh() {}                 // 刷新迭代器
    virtual bool IsKeyPinned() const { return false; }  // 键是否固定
    virtual bool IsValuePinned() const { return false; } // 值是否固定
};

// DBImpl中NewIterator的实现
Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
                             ColumnFamilyHandle* column_family) {
    // 1. 参数验证
    if (read_options.io_activity != Env::IOActivity::kUnknown &&
        read_options.io_activity != Env::IOActivity::kIterator) {
        return NewErrorIterator(Status::InvalidArgument(
            "Can only call NewIterator with io_activity kUnknown or kIterator"));
    }
    
    // 2. 设置默认IO活动类型
    ReadOptions roptions(read_options);
    if (roptions.io_activity == Env::IOActivity::kUnknown) {
        roptions.io_activity = Env::IOActivity::kIterator;
    }
    
    // 3. 获取列族数据
    auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(column_family);
    auto cfd = cfh->cfd();
    
    // 4. 获取SuperVersion
    SuperVersion* sv = GetAndRefSuperVersion(cfd);
    
    // 5. 创建合并迭代器
    auto* internal_iter = NewInternalIterator(roptions, cfd, sv);
    
    // 6. 包装为用户迭代器
    auto* user_iter = NewDBIterator(
        env_, roptions, *cfd->ioptions(), cfd->user_comparator(),
        internal_iter, kMaxSequenceNumber, sv->mutable_cf_options.max_sequential_skip_in_iterations,
        sv->version_number);
    
    return user_iter;
}

// 创建内部迭代器
InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
                                             ColumnFamilyData* cfd,
                                             SuperVersion* super_version) {
    // 1. 创建迭代器列表
    std::vector<InternalIterator*> iterator_list;
    
    // 2. 添加MemTable迭代器
    iterator_list.push_back(super_version->mem->NewIterator(read_options));
    
    // 3. 添加Immutable MemTable迭代器
    super_version->imm->AddIterators(read_options, &iterator_list);
    
    // 4. 添加SST文件迭代器
    super_version->current->AddIterators(read_options, &iterator_list);
    
    // 5. 创建合并迭代器
    InternalIterator* internal_iter = nullptr;
    if (iterator_list.size() == 0) {
        internal_iter = NewEmptyInternalIterator();
    } else if (iterator_list.size() == 1) {
        internal_iter = iterator_list[0];
    } else {
        internal_iter = NewMergingIterator(
            &cfd->internal_comparator(), &iterator_list[0], iterator_list.size());
    }
    
    return internal_iter;
}

// 主要错误类型
enum Code : unsigned char {
    kOk = 0,                    // 成功
    kNotFound = 1,              // 未找到
    kCorruption = 2,            // 数据损坏
    kNotSupported = 3,          // 不支持
    kInvalidArgument = 4,       // 参数无效
    kIOError = 5,               // IO错误
    kMergeInProgress = 6,       // 合并进行中
    kIncomplete = 7,            // 不完整
    kShutdownInProgress = 8,    // 关闭进行中
    kTimedOut = 9,              // 超时
    kAborted = 10,              // 中止
    kBusy = 11,                 // 忙碌
    kExpired = 12,              // 过期
    kTryAgain = 13,             // 重试
    kCompactionTooLarge = 14,   // 压缩过大
    kColumnFamilyDropped = 15,  // 列族已删除
    kMaxCode                    // 最大错误码
};

// 子错误类型（提供更详细的错误信息）
enum SubCode : unsigned char {
    kNone = 0,                  // 无子错误
    kMutexTimeout = 1,          // 互斥锁超时
    kLockTimeout = 2,           // 锁超时
    kLockLimit = 3,             // 锁限制
    kNoSpace = 4,               // 空间不足
    kDeadlock = 5,              // 死锁
    kStaleFile = 6,             // 文件过期
    kMemoryLimit = 7,           // 内存限制
    kSpaceLimit = 8,            // 空间限制
    kPathNotFound = 9,          // 路径不存在
    kMaxSubCode                 // 最大子错误码
};

// 错误处理示例
Status HandleDatabaseError(Status s) {
    if (s.ok()) {
        return s;
    }
    
    // 1. 可重试错误
    if (s.IsTryAgain() || s.IsTimedOut()) {
        // 实现指数退避重试
        return RetryWithBackoff(s);
    }
    
    // 2. 资源不足错误
    if (s.IsIOError() && s.subcode() == Status::kNoSpace) {
        // 触发紧急压缩，释放空间
        TriggerEmergencyCompaction();
        return s;
    }
    
    // 3. 数据损坏错误
    if (s.IsCorruption()) {
        // 记录损坏信息，可能需要修复
        LogCorruptionInfo(s);
        return s;
    }
    
    // 4. 不可恢复错误
    if (s.IsShutdownInProgress()) {
        // 数据库正在关闭，停止操作
        return s;
    }
    
    return s;
}

// 写入性能优化配置
void OptimizeWritePerformance(Options& options) {
    // 1. 增大写缓冲区
    options.write_buffer_size = 256 << 20;  // 256MB
    options.max_write_buffer_number = 6;
    options.min_write_buffer_number_to_merge = 2;
    
    // 2. 优化WAL设置
    options.use_fsync = false;  // 使用fdatasync而不是fsync
    options.bytes_per_sync = 1 << 20;  // 1MB同步间隔
    
    // 3. 启用并发写入
    options.allow_concurrent_memtable_write = true;
    options.enable_write_thread_adaptive_yield = true;
    
    // 4. 优化压缩触发
    options.level0_file_num_compaction_trigger = 8;
    options.level0_slowdown_writes_trigger = 17;
    options.level0_stop_writes_trigger = 24;
    
    // 5. 增加后台线程
    options.max_background_jobs = 8;
    options.max_subcompactions = 4;
}

// 读取性能优化配置
void OptimizeReadPerformance(Options& options) {
    // 1. 配置Block Cache
    options.block_cache = NewLRUCache(2ULL << 30);  // 2GB缓存
    options.cache_index_and_filter_blocks = true;
    options.pin_top_level_index_and_filter = true;
    
    // 2. 启用Bloom Filter
    options.filter_policy.reset(NewBloomFilterPolicy(10));
    options.optimize_filters_for_hits = true;
    
    // 3. 配置预取
    options.compaction_readahead_size = 2 << 20;  // 2MB预读
    
    // 4. 优化迭代器
    options.max_sequential_skip_in_iterations = 8;
    
    // 5. 启用统计
    options.statistics = CreateDBStatistics();
}

// 内存使用优化
void OptimizeMemoryUsage(Options& options) {
    // 1. 统一内存管理
    size_t total_memory = 4ULL << 30;  // 4GB总内存限制
    
    auto cache = NewLRUCache(total_memory * 0.6);  // 60%用于Block Cache
    options.block_cache = cache;
    
    options.write_buffer_manager = std::make_shared<WriteBufferManager>(
        total_memory * 0.3, cache);  // 30%用于写缓冲区
    
    // 2. 控制Table Cache
    options.max_open_files = 1000;
    options.table_cache_numshardbits = 4;
    
    // 3. 优化MemTable
    options.memtable_factory = std::make_shared<SkipListFactory>();
    options.allow_mmap_reads = true;
    
    // 4. 压缩配置
    options.compression = kSnappyCompression;
    options.compression_opts.level = 1;
    options.compression_opts.parallel_threads = 4;
}