1
// LevelDB: Need separate database instances
2
leveldb::DB* users_db;
3
leveldb::DB* posts_db;
4
leveldb::DB* likes_db;
5
// Each with its own WAL, compaction, memory overhead!
6
 
7
// RocksDB: Single instance, multiple column families
8
rocksdb::DB* db;
9
std::vector handles;
10
 
11
rocksdb::Status s = rocksdb::DB::Open(options, path, column_families, &handles, &db);
12
 
13
// Write to different column families atomically
14
rocksdb::WriteBatch batch;
15
batch.Put(handles[0], "user:123", user_data);
16
batch.Put(handles[1], "post:456", post_data);
17
batch.Put(handles[2], "like:789", like_data);
18
db->Write(rocksdb::WriteOptions(), &batch);  // Atomic across all CFs!

1
# Different compaction strategies for different workloads
2
class CompactionStrategy:
3
    # Level Compaction (default) - Minimize read amplification
4
    def level_compaction_options():
5
        return {
6
            'compaction_style': rocksdb.CompactionStyle.level,
7
            'level0_file_num_compaction_trigger': 4,
8
            'max_bytes_for_level_base': 256 * 1024 * 1024,  # 256MB
9
            'max_bytes_for_level_multiplier': 10,
10
        }
11
    
12
    # Universal Compaction - Minimize write amplification
13
    def universal_compaction_options():
14
        return {
15
            'compaction_style': rocksdb.CompactionStyle.universal,
16
            'compaction_options_universal': {
17
                'size_ratio': 1,
18
                'min_merge_width': 2,
19
                'max_merge_width': UINT32_MAX,
20
            }
21
        }
22
    
23
    # FIFO Compaction - For cache-like workloads
24
    def fifo_compaction_options():
25
        return {
26
            'compaction_style': rocksdb.CompactionStyle.fifo,
27
            'compaction_options_fifo': {
28
                'max_table_files_size': 1024 * 1024 * 1024,  # 1GB
29
                'allow_compaction': False,  # Just drop old files!
30
            }
31
        }

1
// Configure bloom filters per column family
2
rocksdb::BlockBasedTableOptions table_options;
3
table_options.filter_policy.reset(
4
    rocksdb::NewBloomFilterPolicy(10, false));  // 10 bits per key
5
table_options.whole_key_filtering = true;
6
table_options.cache_index_and_filter_blocks = true;
7
options.table_factory.reset(
8
    rocksdb::NewBlockBasedTableFactory(table_options));

1
options.max_background_compactions = 4;  // 4 parallel compactions
2
options.max_background_flushes = 2;      // 2 parallel flushes
3
options.max_subcompactions = 4;          // Split large compactions

1
options.use_direct_reads = true;
2
options.use_direct_io_for_flush_and_compaction = true;
3
options.enable_pipelined_write = true;  // Pipeline WAL writes

1
// ACID transactions across keys
2
rocksdb::TransactionDB* txn_db;
3
rocksdb::Transaction* txn = txn_db->BeginTransaction(write_options);
4
 
5
txn->Put("account:123", "balance:100");
6
txn->Put("account:456", "balance:200");
7
 
8
// Atomic transfer
9
txn->Get("account:123", &value1);
10
txn->Get("account:456", &value2);
11
// ... modify values ...
12
txn->Put("account:123", new_value1);
13
txn->Put("account:456", new_value2);
14
 
15
txn->Commit();  // All or nothing!

1
// Traditional approach: read-modify-write
2
std::string value;
3
db->Get(options, "counter", &value);
4
int count = std::stoi(value) + 1;
5
db->Put(options, "counter", std::to_string(count));
6
 
7
// RocksDB merge operator: atomic increment
8
class CounterMergeOperator : public rocksdb::MergeOperator {
9
    // ... implementation ...
10
};
11
options.merge_operator.reset(new CounterMergeOperator);
12
db->Merge(options, "counter", "1");  // Atomic, no read needed!

1
// Hot backups without stopping writes
2
rocksdb::BackupEngine* backup_engine;
3
backup_engine->CreateNewBackup(db);
4
 
5
// Checkpoints for point-in-time snapshots
6
rocksdb::Checkpoint* checkpoint;
7
checkpoint->CreateCheckpoint("/path/to/checkpoint");

1
-- Creating a MyRocks table
2
CREATE TABLE users (
3
    id BIGINT PRIMARY KEY,
4
    name VARCHAR(255),
5
    data JSON
6
) ENGINE=ROCKSDB;
7
 
8
-- MyRocks specific optimizations
9
SET GLOBAL rocksdb_bulk_load=1;  -- Fast bulk loading
10
-- Load millions of rows...
11
SET GLOBAL rocksdb_bulk_load=0;

1
// Kafka Streams with RocksDB state store
2
StreamsBuilder builder = new StreamsBuilder();
3
 
4
StoreBuilder> storeBuilder = 
5
    Stores.keyValueStoreBuilder(
6
        Stores.persistentKeyValueStore("user-counts"),  // RocksDB backed!
7
        Serdes.String(),
8
        Serdes.Long()
9
    );
10
 
11
builder.addStateStore(storeBuilder);
12
 
13
KStream events = builder.stream("events");
14
events.groupByKey()
15
    .aggregate(
16
        () -> 0L,
17
        (key, event, count) -> count + 1,
18
        Materialized.with(Serdes.String(), Serdes.Long())
19
            .withLoggingEnabled(Map.of("segment.bytes", "100000000"))
20
    );

1
// Ethereum's use of RocksDB (via LevelDB interface)
2
type Database struct {
3
    fn string
4
    db *leveldb.DB  // Actually RocksDB in many implementations
5
}
6
 
7
// Storing blockchain data
8
func (db *Database) Put(key []byte, value []byte) error {
9
    return db.db.Put(key, value, nil)
10
}
11
 
12
// Key structure for blockchain data
13
// Block: "B" + blockHash
14
// Transaction: "T" + txHash  
15
// State: "S" + address + key

1
# Discord's usage pattern
2
class MessageStore:
3
    def __init__(self):
4
        options = rocksdb.Options()
5
        options.create_if_missing = True
6
        
7
        # Optimize for Discord's access pattern
8
        options.compaction_style = rocksdb.CompactionStyle.level
9
        options.write_buffer_size = 64 * 1024 * 1024  # 64MB
10
        options.target_file_size_base = 64 * 1024 * 1024
11
        
12
        # Column families for different data
13
        self.db = rocksdb.DB("messages.db", options, column_families={
14
            "messages": rocksdb.ColumnFamilyOptions(),
15
            "users": rocksdb.ColumnFamilyOptions(),
16
            "channels": rocksdb.ColumnFamilyOptions(),
17
        })
18
    
19
    def store_message(self, message):
20
        # Messages keyed by channel_id + timestamp
21
        key = f"{message.channel_id}:{message.timestamp}"
22
        self.db.put(b"messages", key.encode(), message.serialize())

1
# Python
2
import rocksdb
3
 
4
db = rocksdb.DB("test.db", rocksdb.Options(create_if_missing=True))
5
db.put(b"key", b"value")
6
print(db.get(b"key"))  # b"value"

1
// Java
2
RocksDB.loadLibrary();
3
try (final Options options = new Options().setCreateIfMissing(true);
4
     final RocksDB db = RocksDB.open(options, "test.db")) {
5
    db.put("key".getBytes(), "value".getBytes());
6
    byte[] value = db.get("key".getBytes());
7
}

1
// Rust
2
use rocksdb::{DB, Options};
3
 
4
let mut opts = Options::default();
5
opts.create_if_missing(true);
6
let db = DB::open(&opts, "test.db").unwrap();
7
db.put(b"key", b"value").unwrap();
8
match db.get(b"key") {
9
    Ok(Some(value)) => println!("Found: {:?}", value),
10
    Ok(None) => println!("Not found"),
11
    Err(e) => println!("Error: {}", e),
12
}

1
int ttl_seconds = 86400;  // 24 hours
2
rocksdb::DBWithTTL* db;
3
rocksdb::DBWithTTL::Open(options, path, &db, ttl_seconds);
4
// Old data automatically deleted!

1
class ReverseComparator : public rocksdb::Comparator {
2
    int Compare(const rocksdb::Slice& a, const rocksdb::Slice& b) const {
3
        return -a.compare(b);  // Reverse order
4
    }
5
};
6
options.comparator = new ReverseComparator();

1
options.statistics = rocksdb::CreateDBStatistics();
2
// Later...
3
std::string stats;
4
db->GetProperty("rocksdb.stats", &stats);
5
// Detailed performance metrics!

1
-- This is painful in RocksDB
2
SELECT users.name, COUNT(orders.id) 
3
FROM users 
4
JOIN orders ON users.id = orders.user_id 
5
WHERE orders.created_at > '2023-01-01'
6
GROUP BY users.name;

1
rocksdb::BlobDBOptions blob_options;
2
blob_options.min_blob_size = 1024;  // Store values >1KB as blobs
3
blob_options.compression = rocksdb::kZSTD;
4
blob_options.enable_garbage_collection = true;
5
 
6
rocksdb::BlobDB* blob_db;
7
rocksdb::BlobDB::Open(options, blob_options, path, &blob_db);

1
# Future: ML-optimized storage
2
class LearnedRocksDB:
3
    def __init__(self):
4
        self.model = self.train_access_pattern_model()
5
        
6
    def optimize_for_workload(self):
7
        # Predict hot keys
8
        hot_keys = self.model.predict_hot_keys()
9
        
10
        # Pre-load into block cache
11
        for key in hot_keys:
12
            self.db.prefetch(key)
13
            
14
        # Adjust compaction based on patterns
15
        if self.model.is_write_heavy():
16
            self.options.compaction_style = 'universal'
17
        else:
18
            self.options.compaction_style = 'level'