AVLBerry

package main

import (
    "fmt"

    "github.com/blockberries/avlberry"
    "github.com/blockberries/avlberry/db"
)

func main() {
    // Open a persistent database
    ldb, err := db.NewGoLevelDB("myapp", "/tmp/avlberry-example")
    if err != nil {
        panic(err)
    }
    defer ldb.Close()

    // Create a tree with LRU cache of 10,000 nodes
    tree := avlberry.NewMutableTree(ldb, 10000, false, avlberry.NewNopLogger())

    // Load the latest version (no-op for a new database)
    version, err := tree.Load()
    if err != nil {
        panic(err)
    }
    fmt.Println("Loaded version:", version)

    // Write some data
    tree.Set([]byte("alice"), []byte("100"))
    tree.Set([]byte("bob"), []byte("200"))

    // Persist as a new version
    hash, ver, err := tree.SaveVersion()
    if err != nil {
        panic(err)
    }
    fmt.Printf("Saved version %d, root hash: %x\n", ver, hash)

    // Read back
    val, err := tree.Get([]byte("alice"))
    if err != nil {
        panic(err)
    }
    fmt.Println("alice =", string(val))
}

tree := avlberry.NewMutableTree(db, cacheSize, skipFastStorageUpgrade, logger, options...)

// Write (accumulates in working tree)
updated, err := tree.Set([]byte("key"), []byte("value"))
value, removed, err := tree.Remove([]byte("key"))

// Read (checks unsaved changes, then FastNode cache, then tree)
val, err := tree.Get([]byte("key"))
exists, err := tree.Has([]byte("key"))

// Persist working tree as new version
rootHash, version, err := tree.SaveVersion()

// Discard unsaved changes
tree.Rollback()

// Load latest version from DB
latestVersion, err := tree.Load()

// Load a specific version
version, err := tree.LoadVersion(42)

// Check if version exists
exists, err := tree.VersionExists(42)

// Delete old versions (pruning)
err := tree.DeleteVersionsTo(40)

// Load and discard all versions after target
err := tree.LoadVersionForOverwriting(42)

// Forward iterator over [start, end)
iter, err := tree.Iterator([]byte("a"), []byte("z"), true)
defer iter.Close()
for ; iter.Valid(); iter.Next() {
    fmt.Printf("%s = %s\n", iter.Key(), iter.Value())
}

// Callback-based
tree.Iterate(func(key, value []byte) bool {
    fmt.Printf("%s = %s\n", key, value)
    return false // return true to stop
})

// Generate proof for a key
proof, err := tree.GetProof([]byte("alice"))

// Verify membership
ok, err := tree.VerifyMembership(proof, []byte("alice"))

// Verify non-membership
proof, err := tree.GetNonMembershipProof([]byte("missing"))
ok, err := tree.VerifyNonMembership(proof, []byte("missing"))

// Proof for a specific version
proof, err := tree.GetVersionedProof([]byte("alice"), 42)

// Export: stream all nodes from a saved version
exporter, err := tree.Export()
defer exporter.Close()
for {
    node, err := exporter.Next()
    if err == avlberry.ErrExportDone {
        break
    }
    // send node over network...
}

// Import: reconstruct tree from exported nodes
importer, err := tree.Import(targetVersion)
for _, node := range receivedNodes {
    if err := importer.Add(node); err != nil {
        panic(err)
    }
}
if err := importer.Commit(); err != nil {
    panic(err)
}

// Apply a batch of changes atomically
cs := &avlberry.ChangeSet{
    Pairs: []avlberry.KVPair{
        {Key: []byte("a"), Value: []byte("1")},
        {Key: []byte("b"), Value: []byte("2")},
        {Delete: true, Key: []byte("old")},
    },
}
version, err := tree.SaveChangeSet(cs)

// Traverse state changes between versions
tree.TraverseStateChanges(1, 10, func(version int64, cs *avlberry.ChangeSet) error {
    fmt.Printf("Version %d: %d changes\n", version, len(cs.Pairs))
    return nil
})

import "github.com/blockberries/avlberry/db"

// GoLevelDB: persistent storage with bloom filters
ldb, err := db.NewGoLevelDB("name", "/path/to/dir")
ldb, err := db.NewGoLevelDBWithOpts("name", "/path/to/dir", &opt.Options{...})

// MemDB: in-memory (testing, ephemeral state)
mdb := db.NewMemDB()

// PrefixDB: key namespace isolation
pdb := db.NewPrefixDB(ldb, []byte("myapp/"))

// IteratePrefix: convenience for prefix scans
iter, err := db.IteratePrefix(ldb, []byte("users/"))

type DB interface {
    Get(key []byte) ([]byte, error)
    Has(key []byte) (bool, error)
    Iterator(start, end []byte) (Iterator, error)
    ReverseIterator(start, end []byte) (Iterator, error)
    Close() error
    NewBatch() Batch
    NewBatchWithSize(sizeHint int) Batch
}