// ❌ 错误：变长数字
std::string key = "user:" + std::to_string(user_id);
// "user:1" < "user:10" < "user:9"  ← 字典序 ≠ 数值序

// ✅ 正确：补零到固定长度
char key[32];
snprintf(key, sizeof(key), "user:%010d", user_id);
// "user:0000000001" < "user:0000000009" < "user:0000000010"

// ✅ 二进制编码（更高效）
std::string key = "user:";
key.resize(key.size() + 4);
uint32_t id = htonl(user_id);
memcpy(&key[key.size() - 4], &id, 4);

// 正向时间序（从旧到新）
std::string MakeTimeKey(uint64_t timestamp, uint64_t id) {
    char buf[32];
    snprintf(buf, sizeof(buf), "log:%020lu:%020lu", timestamp, id);
    return buf;
}

// 反向时间序（从新到旧，适合查询最新数据）
std::string MakeReverseTimeKey(uint64_t timestamp, uint64_t id) {
    char buf[32];
    uint64_t reverse_ts = UINT64_MAX - timestamp;
    snprintf(buf, sizeof(buf), "rtlog:%020lu:%020lu", reverse_ts, id);
    return buf;
}

// 通用场景：Snappy（默认）
options.compression = leveldb::kSnappyCompression;

// 存储成本敏感：ZSTD（RocksDB 支持）
// LevelDB 不支持 ZSTD，需要迁移到 RocksDB

// 高写入吞吐：禁用压缩
options.compression = leveldb::kNoCompression;

// 混合策略（RocksDB）：
// Level 0-1: 无压缩（快速写入）
// Level 2-6: ZSTD（节省空间）

struct MemoryBudget {
    // 配置参数
    size_t memtable_size = 64 * 1024 * 1024;        // 64MB
    int max_memtables = 2;
    size_t block_cache_size = 512 * 1024 * 1024;     // 512MB
    int max_open_files = 500;
    int bloom_bits_per_key = 10;
    size_t db_size = 10ULL * 1024 * 1024 * 1024;     // 10GB
    uint64_t num_keys = 10000000;                     // 1000万

    // 计算内存占用
    size_t CalcMemtable() {
        return memtable_size * max_memtables;
    }
    size_t CalcBlockCache() {
        return block_cache_size;
    }
    size_t CalcTableCache() {
        return max_open_files * 10 * 1024;  // 约 10KB/文件
    }
    size_t CalcBloomFilter() {
        return num_keys * bloom_bits_per_key / 8;
    }
    size_t Total() {
        return CalcMemtable() + CalcBlockCache()
             + CalcTableCache() + CalcBloomFilter();
    }
};

// 逐条写入：慢
for (const auto& kv : data) {
    db->Put(wopts, kv.key, kv.value);
}

// 批量写入：快 2-10x
leveldb::WriteBatch batch;
for (const auto& kv : data) {
    batch.Put(kv.key, kv.value);
}
db->Write(wopts, &batch);

// 模式 1：完全异步（最快，可能丢数据）
wopts.sync = false;

// 模式 2：定期同步（推荐）
if (++write_count % 1000 == 0) {
    wopts.sync = true;
}

// 模式 3：关键数据同步
if (is_critical_data) {
    wopts.sync = true;
}

// 模式 4：WAL 分组同步（RocksDB 支持）
// 每 100ms 或累积 1MB 数据后同步一次

// 始终开启 Bloom Filter
options.filter_policy = leveldb::NewBloomFilterPolicy(10);

// 高读取场景：增大 Bloom Filter 位数
options.filter_policy = leveldb::NewBloomFilterPolicy(14);

// 范围扫描使用 Seek + 限制，避免全表扫描
leveldb::Iterator* it = db->NewIterator(leveldb::ReadOptions());
std::string prefix = "user:";
int count = 0;
for (it->Seek(prefix);
     it->Valid() && it->key().starts_with(prefix) && count < 100;
     it->Next()) {
    // 处理数据
    count++;
}
delete it;

// LevelDB 支持多线程并发读取
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
    threads.emplace_back([db, i]() {
        std::string key = "key:" + std::to_string(i);
        std::string value;
        db->Get(leveldb::ReadOptions(), key, &value);
    });
}
for (auto& t : threads) t.join();

class LevelDBMonitor {
public:
    LevelDBMonitor(leveldb::DB* db, leveldb::Statistics* stats)
        : db_(db), stats_(stats) {}

    void ReportMetrics() {
        uint64_t cache_hit = stats_->getTickerCount(leveldb::BLOCK_CACHE_HIT);
        uint64_t cache_miss = stats_->getTickerCount(leveldb::BLOCK_CACHE_MISS);
        double hit_rate = (double)cache_hit / (cache_hit + cache_miss);

        LOG(INFO) << "Block Cache Hit Rate: " << (hit_rate * 100) << "%";

        if (hit_rate < 0.9) {
            LOG(WARNING) << "Block Cache hit rate below 90%";
        }
    }

    std::string GetProperty(const std::string& prop) {
        std::string value;
        db_->GetProperty(prop, &value);
        return value;
    }

private:
    leveldb::DB* db_;
    leveldb::Statistics* stats_;
};

#!/bin/bash
# backup_leveldb.sh

BACKUP_DIR="/opt/backups/leveldb"
DB_PATH="/data/leveldb"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_PATH="${BACKUP_DIR}/${TIMESTAMP}"

# 创建备份目录
mkdir -p "${BACKUP_PATH}"

# 暂停写入（可选）
# kill -SIGSTOP $(pgrep -f leveldb-server)

# 复制数据文件
cp -r "${DB_PATH}" "${BACKUP_PATH}/data"

# 恢复写入
# kill -SIGCONT $(pgrep -f leveldb-server)

# 压缩备份
tar czf "${BACKUP_PATH}.tar.gz" -C "${BACKUP_DIR}" "${TIMESTAMP}"
rm -rf "${BACKUP_PATH}"

# 清理 7 天前的备份
find "${BACKUP_DIR}" -name "*.tar.gz" -mtime +7 -delete

echo "Backup completed: ${BACKUP_PATH}.tar.gz"

# 数据目录权限
chmod 700 /data/leveldb
chown app:app /data/leveldb

# 备份文件权限
chmod 600 /opt/backups/leveldb/*.tar.gz

// LevelDB 没有内置权限控制，需要在应用层实现

class AuthDB {
public:
    bool Get(const std::string& user, const std::string& key,
             std::string* value) {
        if (!CheckPermission(user, key, Permission::READ)) {
            return false;  // 权限不足
        }
        return db_->Get(leveldb::ReadOptions(), key, value).ok();
    }

    bool Put(const std::string& user, const std::string& key,
             const std::string& value) {
        if (!CheckPermission(user, key, Permission::WRITE)) {
            return false;
        }
        return db_->Put(leveldb::WriteOptions(), key, value).ok();
    }

private:
    bool CheckPermission(const std::string& user, const std::string& key,
                         Permission perm) {
        // 实现权限检查逻辑
        return true;
    }
    leveldb::DB* db_;
};