Lux ZapDB - Embeddable Key-Value Store

luxfi/zapdb/
  db.go                    -- DB type: Open, Close, transaction management
  txn.go                   -- Transaction: Get, Set, Delete, Commit, Discard
  iterator.go              -- Iterator: prefix scan, seek, key-value access
  batch.go                 -- WriteBatch for bulk writes
  stream.go                -- Concurrent key-range streaming
  merge.go                 -- MergeOperator for read-modify-write
  backup.go                -- Protobuf backup/restore
  errors.go                -- All exported error sentinels
  options.go               -- Options with builder pattern (WithX methods)
  compaction.go            -- LSM compaction logic
  value.go                 -- Value log management
  levels.go                -- LSM level management
  memtable.go              -- In-memory table (skiplist-backed)
  key_registry.go          -- Encryption key rotation
  options/                 -- CompressionType, ChecksumVerificationMode
  table/                   -- SSTable implementation
  skl/                     -- Skiplist (memtable backend)
  pb/                      -- Protobuf definitions
  fb/                      -- FlatBuffers definitions
  y/                       -- Internal utilities (WaterMark, Slice)
  trie/                    -- Trie data structure
  badger/                  -- CLI tool
    main.go                -- CLI entry point (jemalloc, pprof)
    cmd/                   -- CLI subcommands
      backup.go, restore.go, info.go, flatten.go,
      bench.go, stream.go, rotate.go, bank.go

// Open database
opts := badger.DefaultOptions("/tmp/zapdb")
db, err := badger.Open(opts)
if err != nil {
    return err
}
defer db.Close()

// Write
err = db.Update(func(txn *badger.Txn) error {
    return txn.Set([]byte("key"), []byte("value"))
})

// Read
err = db.View(func(txn *badger.Txn) error {
    item, err := txn.Get([]byte("key"))
    if err != nil {
        return err
    }
    return item.Value(func(val []byte) error {
        fmt.Printf("value: %s\n", val)
        return nil
    })
})

// Default: good for most use cases
opts := badger.DefaultOptions("/path/to/data")

// LSM-only mode (values collocated with keys, less disk usage)
opts := badger.LSMOnlyOptions("/path/to/data")

// In-memory mode (no persistence)
opts := badger.DefaultOptions("").WithInMemory(true)

// Common tuning
opts = opts.
    WithSyncWrites(true).           // Durability on hard reboot
    WithCompression(options.ZSTD).  // ZSTD compression
    WithBlockCacheSize(512 << 20).  // 512MB block cache
    WithNumCompactors(4).           // Compaction workers
    WithEncryptionKey(key).         // AES encryption (16/24/32 bytes)
    WithReadOnly(true)              // Read-only mode

cd badger && go install .

badger backup --dir /path/to/db         # Create backup
badger restore --dir /path/to/db        # Restore from backup
badger info --dir /path/to/db           # Show DB info
badger flatten --dir /path/to/db        # Flatten LSM tree
badger stream --dir /path/to/db         # Stream keys
badger rotate --dir /path/to/db         # Rotate encryption key
badger bench read --dir /path/to/db     # Read benchmark
badger bench write --dir /path/to/db    # Write benchmark

# Build
go build ./...

# Run tests (requires jemalloc for full test suite on some platforms)
make test            # Runs test.sh
go test ./...        # Without jemalloc

# Build CLI
make badger          # Compiles badger binary (downloads jemalloc if needed)

# Dependencies
make dependency      # Install build deps (apt-based)