Configuration

#include "rocksdb/options.h"

using ROCKSDB_NAMESPACE::Options;
using ROCKSDB_NAMESPACE::DBOptions;
using ROCKSDB_NAMESPACE::ColumnFamilyOptions;

// For simple single-column-family databases
Options options;

// For multi-column-family databases
DBOptions db_options;
ColumnFamilyOptions cf_options;

options.create_if_missing = true;

// Easiest way: let RocksDB decide based on CPU cores
options.IncreaseParallelism();

// Or manually configure
options.max_background_jobs = 8;  // Total background threads

// Level-style compaction (default, recommended for most workloads)
options.OptimizeLevelStyleCompaction();

// Universal-style compaction (optimized for read-heavy workloads)
options.OptimizeUniversalStyleCompaction();

// Size of each memtable (default: 64MB)
options.write_buffer_size = 64 << 20;  // 64MB

// Maximum number of memtables (default: 2)
options.max_write_buffer_number = 3;

// Total memory across all column families
options.db_write_buffer_size = 512 << 20;  // 512MB

Total = write_buffer_size × max_write_buffer_number × num_column_families

#include "rocksdb/table.h"
#include "rocksdb/cache.h"

using ROCKSDB_NAMESPACE::BlockBasedTableOptions;
using ROCKSDB_NAMESPACE::NewLRUCache;

BlockBasedTableOptions table_options;
table_options.block_cache = NewLRUCache(512 << 20);  // 512MB cache

options.table_factory.reset(
    NewBlockBasedTableFactory(table_options));

#include "rocksdb/compression_type.h"

using ROCKSDB_NAMESPACE::CompressionType;
using ROCKSDB_NAMESPACE::kSnappyCompression;
using ROCKSDB_NAMESPACE::kZSTD;

// Default compression for most levels
options.compression = kSnappyCompression;

// Stronger compression for bottommost level
options.bottommost_compression = kZSTD;

// Per-level compression
options.compression_per_level = {
    kNoCompression,      // Level 0
    kNoCompression,      // Level 1
    kSnappyCompression,  // Level 2
    kSnappyCompression,  // Level 3
    kZSTD,               // Level 4
    kZSTD,               // Level 5
    kZSTD                // Level 6
};

using ROCKSDB_NAMESPACE::WriteOptions;

WriteOptions write_options;

// Synchronous write (durable but slower)
write_options.sync = true;
db->Put(write_options, "key", "value");

// Asynchronous write (faster but less durable)
write_options.sync = false;  // default
db->Put(write_options, "key", "value");

write_options.disableWAL = true;
db->Put(write_options, "key", "value");

using ROCKSDB_NAMESPACE::ReadOptions;

ReadOptions read_options;

// Skip block cache for this read (useful for large scans)
read_options.fill_cache = false;

// Verify checksums
read_options.verify_checksums = true;

const Snapshot* snapshot = db->GetSnapshot();
ReadOptions read_options;
read_options.snapshot = snapshot;

// Read from snapshot
std::string value;
db->Get(read_options, "key", &value);

// Release snapshot when done
db->ReleaseSnapshot(snapshot);

// Keep all files open for faster access (-1 = unlimited)
options.max_open_files = -1;

// Number of threads for opening files
options.max_file_opening_threads = 16;

// Trigger level-0 compaction when this many files exist
options.level0_file_num_compaction_trigger = 4;

// Maximum bytes for level-1
options.max_bytes_for_level_base = 256 << 20;  // 256MB

// Multiplier for each level
options.max_bytes_for_level_multiplier = 10;

#include "rocksdb/rate_limiter.h"

using ROCKSDB_NAMESPACE::NewGenericRateLimiter;

// Limit to 100 MB/s
options.rate_limiter.reset(
    NewGenericRateLimiter(
        100 << 20  // bytes_per_sec
    ));

Options GetHighWriteOptions() {
    Options options;
    
    // Large write buffers
    options.write_buffer_size = 128 << 20;  // 128MB
    options.max_write_buffer_number = 4;
    
    // More background jobs
    options.IncreaseParallelism(16);
    
    // Level compaction
    options.OptimizeLevelStyleCompaction(1024 << 20);  // 1GB memtable budget
    
    // Fast compression
    options.compression = CompressionType::kLZ4Compression;
    
    return options;
}

Options GetLowLatencyOptions() {
    Options options;
    
    // Keep all files open
    options.max_open_files = -1;
    
    // Large block cache
    BlockBasedTableOptions table_options;
    table_options.block_cache = NewLRUCache(2048 << 20);  // 2GB
    options.table_factory.reset(
        NewBlockBasedTableFactory(table_options));
    
    // Enable bloom filters
    table_options.filter_policy.reset(
        NewBloomFilterPolicy(10, false));
    
    return options;
}

Options GetSmallDbOptions() {
    Options options;
    options.OptimizeForSmallDb();
    return options;
}