GoLevelDB

https://github.com/syndtr/goleveldb
Admin
GoLevelDB is an implementation of the LevelDB key/value database written entirely in the Go...
Tokens:65,378
Snippets:522
Trust Score:8
License:BSD-2-Clause
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Get usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Example of calling Get and handling ErrNotFound and other errors.

```go
data, err := db.Get([]byte("key"), nil)
if err == leveldb.ErrNotFound {
	// Key does not exist.
} else if err != nil {
	panic(err)
}
```

--------------------------------

### BufferPool usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/util.md

Shows how to create a pool, get a buffer, fill it, and return it to the pool.

```go
pool := util.NewBufferPool(4096)
b := pool.Get(256)
// fill b ...
pool.Put(b)
```

--------------------------------

### Install goleveldb with go get

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Install the goleveldb package using the go get command. Requires Go 1.14 or newer.

```bash
go get github.com/syndtr/goleveldb/leveldb
```

--------------------------------

### Usage Example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/options.md

Example of configuring a database with Options and using WriteOptions for a Put operation.

```APIDOC
## Usage Example

### Description
Example of configuring a database with Options and using WriteOptions for a Put operation.

### Code
```go
import "github.com/syndtr/goleveldb/leveldb"
import "github.com/syndtr/goleveldb/leveldb/filter"
import "github.com/syndtr/goleveldb/leveldb/opt"

o := &opt.Options{
    Filter:        filter.NewBloomFilter(10),
    WriteBuffer:   8 * opt.MiB,
    BlockSize:     4 * opt.KiB,
    BlockRestartInterval: 16,
    Compression:   opt.SnappyCompression,
    Strict:        opt.StrictAll,
    ReadOnly:      false,
}

db, err := leveldb.OpenFile("path/to/db", o)
if err != nil {
    panic(err)
}
defer db.Close()

// Sync is a WriteOptions concern, not an Options field:
wo := &opt.WriteOptions{Sync: true}
err = db.Put([]byte("key"), []byte("value"), wo)
```

### Notes
Getters serve as documentation of zero-values: any field left at 0/nil/false selects the default documented in configuration.md (with BlockCacheCapacity/OpenFilesCacheCapacity negative meaning "zero capacity").
```

--------------------------------

### Usage example (block caching pattern)

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/cache.md

Example showing how to use the cache package for block caching, including getting a handle, using the value, releasing, and deleting.

```APIDOC
## Usage example (block caching pattern)

### Description
Example showing how to use the cache package for block caching, including getting a handle, using the value, releasing, and deleting.

### Code
```go
import "github.com/syndtr/goleveldb/leveldb/cache"

mc := cache.NewCache(cache.NewLRU(1 << 20))
handle := mc.Get(0, fileNum, func() (int, cache.Value) {
	block := loadBlock(fileNum)
	return len(block), block
})
if handle != nil {
	block := handle.Value()
	// ... use block ...
	handle.Release()
}
// Force removal once the last user releases:
mc.Delete(0, fileNum, func() {
	removeFile(fileNum)
})
mc.Close(false)
```
```

--------------------------------

### MakeBatchWithConfig usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Creates a batch with InitialCapacity 1024 and GrowLimit 1000.

```go
batch := leveldb.MakeBatchWithConfig(&leveldb.BatchConfig{
	InitialCapacity: 1024,
	GrowLimit: 1000,
})
```

--------------------------------

### writeJournals example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/journal.md

Example from the package doc: writes each string as a separate journal and closes the writer.

```go
// Example from the package doc.
func writeJournals(w io.Writer, ss []string) error {
	journals := journal.NewWriter(w)
	for _, s := range ss {
		j, err := journals.Next()
		if err != nil {
			return err
		}
		if _, err := j.Write([]byte(s)); err != nil {
			return err
		}
	}
	return journals.Close()
}
```

--------------------------------

### Using Snapshot.Get

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/snapshot.md

Example usage of Snapshot.Get: acquire a snapshot, get a value, handle ErrNotFound, and release the snapshot.

```go
snap, err := db.GetSnapshot()
if err != nil {
	panic(err)
}
value, err := snap.Get([]byte("key"), nil)
if err != nil && err != leveldb.ErrNotFound {
	panic(err)
}
snap.Release()
```

--------------------------------

### Write usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Example of creating a batch, adding Put and Delete operations, and writing it. The batch is not modified by Write.

```go
batch := new(leveldb.Batch)
batch.Put([]byte("foo"), []byte("value"))
batch.Delete([]byte("baz"))
err = db.Write(batch, nil)
```

--------------------------------

### Custom comparer example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/comparer.md

Shows a minimal custom comparer that reverses byte order. It must satisfy the documented contract, and the name must change if ordering changes. The example also shows how to set it via `opt.Options.Comparer` and open a database.

```go
type reverseComparer struct{}

func (reverseComparer) Compare(a, b []byte) int {
	return -bytes.Compare(a, b) // note: must still satisfy the documented contract
}
func (reverseComparer) Name() string          { return "example.ReverseComparer" }
func (reverseComparer) Separator(dst, a, b []byte) []byte { return nil }
func (reverseComparer) Successor(dst, b []byte) []byte     { return nil }

o := &opt.Options{Comparer: reverseComparer{}}
db, err := leveldb.OpenFile("path/to/db", o)
```

--------------------------------

### Example: supplying a custom comparer

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/comparer.md

Shows how to implement a custom comparer and use it with opt.Options.Comparer when opening a database.

```APIDOC
## Example: supplying a custom comparer

### Description
Shows how to implement a custom comparer and use it with opt.Options.Comparer when opening a database.

### Usage

```go
type reverseComparer struct{}

func (reverseComparer) Compare(a, b []byte) int {
	return -bytes.Compare(a, b) // note: must still satisfy the documented contract
}
func (reverseComparer) Name() string          { return "example.ReverseComparer" }
func (reverseComparer) Separator(dst, a, b []byte) []byte { return nil }
func (reverseComparer) Successor(dst, b []byte) []byte     { return nil }

o := &opt.Options{Comparer: reverseComparer{}}
db, err := leveldb.OpenFile("path/to/db", o)
```

### Notes
- The name must change whenever the implementation changes in a way that alters the relative ordering of any two keys.
- Names starting with `leveldb.` are reserved.
- The empty slice must sort before every non-empty slice.
- Returning nil from Separator/Successor disables key shortening for that step.
```

--------------------------------

### Put usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Example of calling Put and panicking on error. The arguments must not be modified before Put returns.

```go
err = db.Put([]byte("key"), []byte("value"), nil)
if err != nil {
	panic(err)
}
```

--------------------------------

### readJournals example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/journal.md

Example from the package doc: reads all journals from a reader, returning their contents as strings. Uses strict and checksum modes (true, true).

```go
// Example from the package doc.
func readJournals(r io.Reader) ([]string, error) {
	var ss []string
	journals := journal.NewReader(r, nil, true, true)
	for {
		j, err := journals.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		s, err := ioutil.ReadAll(j)
		if err != nil {
			return nil, err
		}
		ss = append(ss, string(s))
	}
	return ss, nil
}
```

--------------------------------

### Usage example: opening a database with custom options

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/options.md

Demonstrates opening a database with custom options including a Bloom filter, write buffer, block size, compression, and strict mode. Also shows using WriteOptions with Sync=true for a Put operation.

```go
import "github.com/syndtr/goleveldb/leveldb"
import "github.com/syndtr/goleveldb/leveldb/filter"
import "github.com/syndtr/goleveldb/leveldb/opt"

o := &opt.Options{
	Filter:        filter.NewBloomFilter(10),
	WriteBuffer:   8 * opt.MiB,
	BlockSize:     4 * opt.KiB,
	BlockRestartInterval: 16,
	Compression:   opt.SnappyCompression,
	Strict:        opt.StrictAll,
	ReadOnly:      false,
}

db, err := leveldb.OpenFile("path/to/db", o)
if err != nil {
	panic(err)
}
defer db.Close()

// Sync is a WriteOptions concern, not an Options field:
wo := &opt.WriteOptions{Sync: true}
err = db.Put([]byte("key"), []byte("value"), wo)
```

--------------------------------

### SizeOf usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Shows how to call SizeOf with a slice of ranges, handle the error, and print the sizes. The example uses a nil limit for an unbounded range and prints the size of the first range and the total sum.

```go
ranges := []util.Range{
	util.Range{Start: []byte("a"), Limit: []byte("b")},
	util.Range{Start: []byte("x"), Limit: nil},
}
sizes, err := db.SizeOf(ranges)
if err != nil {
	panic(err)
}
fmt.Printf("size range 0: %d, total: %d\n", sizes[0], sizes.Sum())
```

--------------------------------

### Using storage.NewMemStorage with leveldb.Open

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/storage.md

Example of opening a leveldb database with an in-memory storage and putting a key-value pair. Panics on error.

```go
import "github.com/syndtr/goleveldb/leveldb"
import "github.com/syndtr/goleveldb/leveldb/storage"

stor := storage.NewMemStorage()
db, err := leveldb.Open(stor, nil)
if err != nil {
	panic(err)
}
err = db.Put([]byte("k"), []byte("v"), nil)
```

--------------------------------

### Replay usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Replays the batch into a custom sink that implements leveldb.BatchReplay. Panics on error.

```go
sink := &mySink{}   // implements leveldb.BatchReplay
err := batch.Replay(sink)
if err != nil {
	panic(err)
}
```

--------------------------------

### Creating a memdb instance

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/memdb.md

Example of creating a new memdb with the default comparer and an initial capacity of 4096 bytes. Requires importing the comparer and memdb packages.

```go
import "github.com/syndtr/goleveldb/leveldb/comparer"
import "github.com/syndtr/goleveldb/leveldb/memdb"

m := memdb.New(comparer.DefaultComparer, 4096)
```

--------------------------------

### Write a batch to a transaction

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/transaction.md

Example of creating a batch, adding a put and a delete, and writing it to the transaction.

```go
batch := leveldb.MakeBatch(0)
batch.Put([]byte("a"), []byte("1"))
batch.Delete([]byte("b"))
err = tr.Write(batch, nil)
```

--------------------------------

### Read, write, and delete database entries

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Shows how to read, write, and delete key-value pairs. The slice returned by Get must not be modified.

```go
// Remember that the contents of the returned slice should not be modified.
data, err := db.Get([]byte("key"), nil)
...
err = db.Put([]byte("key"), []byte("value"), nil)
...
err = db.Delete([]byte("key"), nil)
...
```

--------------------------------

### Iterate over keys with a prefix using util.BytesPrefix

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Iterates over all keys that start with the given prefix using util.BytesPrefix.

```go
iter := db.NewIterator(util.BytesPrefix([]byte("foo-")), nil)
for iter.Next() {
	// Use key/value.
	...
}
iter.Release()
err = iter.Error()
...
```

--------------------------------

### Open, Put, and Commit a transaction

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/transaction.md

Example of opening a transaction, putting a key-value pair, and committing. On error, the transaction is discarded. This pattern ensures the transaction is properly closed.

```go
tr, err := db.OpenTransaction()
if err != nil {
	panic(err)
}
if err := tr.Put([]byte("a"), []byte("1"), nil); err != nil {
	tr.Discard()
	return
}
if err := tr.Commit(); err != nil {
	tr.Discard()
	return
}
```

--------------------------------

### Usage example: composing iterators

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/iterator.md

Shows how to create an iterator over an in-memory array and iterate through its pairs. Always call `Release()` and check `Error()` after iteration. The example assumes `myArray` implements `iterator.Array`.

```go
import "github.com/syndtr/goleveldb/leveldb/iterator"
import "github.com/syndtr/goleveldb/leveldb/iterator/array_iter"  // factory in same package

array := myArray{} // implements iterator.Array (Len, Search, Index)
it := iterator.NewArrayIterator(array)
for it.First(); it.Next() {
	print(it.Key(), it.Value())
}
it.Release()
err := it.Error()
```

--------------------------------

### leveldb.DB Methods

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Documentation for the Get and Has methods of the leveldb.DB type.

```APIDOC
## Get

### Description
Gets the value for the given key. Returns `ErrNotFound` if the DB does not contain the key. The returned slice is its own copy — safe to modify. The argument may be modified after `Get` returns. `ro` may be `nil`. Reads are served from the memdb(s) first, then the sorted table version tree.

### Method
Get

### Signature
`func (db *DB) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)`

### Parameters
- **key** ([]byte) - Required - The key to look up.
- **ro** (*opt.ReadOptions) - Optional - Read options; may be nil.

### Returns
- **value** ([]byte) - The value associated with the key, or nil if not found.
- **err** (error) - `ErrNotFound` if the key is absent; otherwise any other error.

### Example
```go
data, err := db.Get([]byte("key"), nil)
if err == leveldb.ErrNotFound {
	// Key does not exist.
} else if err != nil {
	panic(err)
}
```
```

```APIDOC
## Has

### Description
Returns whether the DB contains the key. Differs from `Get` in that a deletion marker or missing key yields `ret=false, err=nil`; any other error is still reported.

### Method
Has

### Signature
`func (db *DB) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error)`

### Parameters
- **key** ([]byte) - Required - The key to check.
- **ro** (*opt.ReadOptions) - Optional - Read options; may be nil.

### Returns
- **ret** (bool) - `true` if the key exists, `false` otherwise.
- **err** (error) - Any error other than `ErrNotFound`; `nil` if the key is missing or deleted.
```

--------------------------------

### Minimal full-table write

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/table.md

Example of writing a complete table: create a writer, append two key-value pairs, and close. Used internally by leveldb.

```go
// Minimal full-table write (as used by leveldb internally).
w := table.NewWriter(file, o, nil, 4 * opt.KiB)
w.Append([]byte("key1"), []byte("value1"))
w.Append([]byte("key2"), []byte("value2"))
err = w.Close()
```

--------------------------------

### Iterate over a key range with util.Range

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Iterates over a subset of the database using a util.Range with Start and Limit keys.

```go
iter := db.NewIterator(&util.Range{Start: []byte("foo"), Limit: []byte("xoo")}, nil)
for iter.Next() {
	// Use key/value.
	...
}
iter.Release()
err = iter.Error()
...
```

--------------------------------

### Block caching usage example

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/cache.md

Shows how to use the cache for block caching in table operations. It creates a cache with an LRU of 1 MiB, retrieves a block, uses it, and releases the handle. It also demonstrates forced removal via Delete when the last user releases.

```go
import "github.com/syndtr/goleveldb/leveldb/cache"

mc := cache.NewCache(cache.NewLRU(1 << 20))
handle := mc.Get(0, fileNum, func() (int, cache.Value) {
	block := loadBlock(fileNum)
	return len(block), block
})
if handle != nil {
	block := handle.Value()
	// ... use block ...
	handle.Release()
}
// Force removal once the last user releases:
mc.Delete(0, fileNum, func() {
	removeFile(fileNum)
})
mc.Close(false)
```

--------------------------------

### GetProperty example: leveldb.num-files-at-level0

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Retrieves the number of files at level 0 using the property name `leveldb.num-files-at-level0`. Prints the value if no error occurs.

```go
value, err := db.GetProperty("leveldb.num-files-at-level0")
if err == nil {
	print(value)
}
```

--------------------------------

### Sharing caches across multiple DB instances

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/options.md

Shows how to share a single cache across multiple DB instances using PassthroughCacher or NewLRU. The example creates file and block caches, then opens two databases with the same options.

```go
fileCache := opt.NewLRU(500)
blockCache := opt.NewLRU(8 * opt.MiB)
options := &opt.Options{
	OpenFilesCacher: fileCache,
	BlockCacher:     blockCache,
}
db1, err1 := leveldb.OpenFile("path/to/db1", options)
db2, err2 := leveldb.OpenFile("path/to/db2", options)
```

--------------------------------

### Writer length and close methods

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/table.md

Methods to get block, entry, and byte counts, and to finalize the table. After `Close`, `Append` fails.

```go
func (w *Writer) BlocksLen() int      // writer.go:204 — blocks written so far
func (w *Writer) EntriesLen() int     // writer.go:211 — entries added so far
func (w *Writer) BytesLen() int       // writer.go:218 — bytes written so far
func (w *Writer) Close() error
```

--------------------------------

### Options struct definition

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/options.md

Defines the Options struct with all configuration fields for goleveldb. Each field has a corresponding Get* accessor that applies defaults when the field is zero or nil.

```go
type Options struct { AltFilters []filter.Filter; BlockCacher Cacher; BlockCacheCapacity int; BlockCacheEvictRemoved bool; BlockRestartInterval int; BlockSize int; CompactionExpandLimitFactor int; CompactionGPOverlapsFactor int; CompactionL0Trigger int; CompactionSourceLimitFactor int; CompactionTableSize int; CompactionTableSizeMultiplier float64; CompactionTableSizeMultiplierPerLevel []float64; CompactionTotalSize int; CompactionTotalSizeMultiplier float64; CompactionTotalSizeMultiplierPerLevel []float64; Comparer comparer.Comparer; Compression Compression; DisableBufferPool bool; DisableBlockCache bool; DisableCompactionBackoff bool; DisableLargeBatchTransaction bool; DisableSeeksCompaction bool; ErrorIfExist bool; ErrorIfMissing bool; Filter filter.Filter; IteratorSamplingRate int; NoSync bool; NoWriteMerge bool; OpenFilesCacher Cacher; OpenFilesCacheCapacity int; ReadOnly bool; Strict Strict; WriteBuffer int; WriteL0PauseTrigger int; WriteL0SlowdownTrigger int; FilterBaseLg int; MaxManifestFileSize int64 }
```

--------------------------------

### BufferPool methods

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/util.md

Methods for getting and returning buffers from the pool. All methods are nil-safe (p == nil behaves like bypass). Stats are atomic counters surfaced via DB.GetProperty("leveldb.blockpool").

```go
func (p *BufferPool) Get(n int) []byte   // buffer of length n from the pool
func (p *BufferPool) Put(b []byte)       // return the buffer
func (p *BufferPool) String() string
```

--------------------------------

### Open or create a database with leveldb.OpenFile

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Opens or creates a LevelDB database at the given path. The returned DB instance is safe for concurrent use, and the database should be closed with defer db.Close().

```go
// The returned DB instance is safe for concurrent use. Which mean that all
// DB's methods may be called concurrently from multiple goroutine.
db, err := leveldb.OpenFile("path/to/db", nil)
...
defer db.Close()
...
```

--------------------------------

### Open a database with OpenFile

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/leveldb.md

Opens or creates a database at the given path using the standard filesystem storage. Returns a *DB and an error; a nil error means the database is open and must be closed with db.Close(). The database is created if it does not exist unless Options.ErrorIfMissing is set.

```go
import "github.com/syndtr/goleveldb/leveldb"
import "github.com/syndtr/goleveldb/leveldb/opt"

db, err := leveldb.OpenFile("path/to/db", nil)
if err != nil {
	panic(err)
}
defer db.Close()
```

--------------------------------

### Get method signature

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Gets the value for a key. Returns ErrNotFound if the key is absent. The returned slice is a copy, safe to modify. ro may be nil.

```go
func (db *DB) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)
```

--------------------------------

### Open goleveldb with fully configured options

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/configuration.md

Configures a goleveldb database with custom options for write buffer, block size, cache, compression, bloom filter, strictness, and compaction settings, then opens it with leveldb.OpenFile. The options struct is from the opt package and the filter package is used for the bloom filter.

```go
o := &opt.Options{
	WriteBuffer:                     8 * opt.MiB,
	BlockSize:                       4 * opt.KiB,
	BlockCacheCapacity:              32 * opt.MiB,
	BlockCacheEvictRemoved:          true,
	OpenFilesCacheCapacity:          1000,
	Compression:                     opt.SnappyCompression,
	Filter:                          filter.NewBloomFilter(10),
	Strict:                          opt.StrictAll,
	ErrorIfMissing:                  true,
	ErrorIfExist:                    false,
	ReadOnly:                        false,
	CompactionTableSize:             4 * opt.MiB,
	CompactionTotalSizeMultiplierPerLevel: []float64{10, 100, 1000, 10000, 100000},
	MaxManifestFileSize:             int64(256 * opt.MiB),
}
db, err := leveldb.OpenFile("path/to/db", o)
```

--------------------------------

### NamespaceGetter type and Get method

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/cache.md

Defines the NamespaceGetter struct and its Get method. It is a convenience wrapper pinning a namespace for block-cache lookups, used by table.Reader and tOps.open.

```go
type NamespaceGetter struct {
	Cache *Cache
	NS    uint64
}
func (g *NamespaceGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle
```

--------------------------------

### MakeBatchWithConfig constructor

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Initializes a batch honoring InitialCapacity (preallocation) and GrowLimit (entry-count threshold above which the buffer grows by at most GrowLimit entries per cycle instead of doubling).

```go
func MakeBatchWithConfig(config *BatchConfig) *Batch
```

--------------------------------

### Reader interface definition

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/leveldb.md

Defines the Reader interface with Get and NewIterator methods. Get returns errors.ErrNotFound when the key is absent, and the returned value is a private copy safe to modify.

```go
type Reader interface {
	Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)
	NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator
}
```

--------------------------------

### Writer.Flush method

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/journal.md

Finishes the current journal, writes it, and flushes the underlying writer if it implements interface{ Flush() error } — without starting a new journal (call Next to start one).

```go
func (w *Writer) Flush() error
```

--------------------------------

### Open(storage.Storage, *opt.Options) (*DB, error)

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/leveldb.md

Opens or creates a database on an arbitrary storage.Storage implementation. The database is created if it does not exist unless Options.ErrorIfMissing is true; if Options.ErrorIfExist is true and the database exists, os.ErrExist is returned. Corruption during open surfaces as an error wrapped as errors.ErrCorrupted.

```APIDOC
## Open(storage.Storage, *opt.Options) (*DB, error)

### Description
Opens or creates a database on an arbitrary storage.Storage implementation. The database is created if it does not exist unless Options.ErrorIfMissing is true; if Options.ErrorIfExist is true and the database exists, os.ErrExist is returned. Corruption during open surfaces as an error wrapped as errors.ErrCorrupted.

### Function Signature
```go
func Open(stor storage.Storage, o *opt.Options) (db *DB, err error)
```

### Parameters
- **stor** (storage.Storage) - Required - The storage backend to use.
- **o** (*opt.Options) - Optional - Options for opening the database. Pass nil for defaults.

### Return Values
- **db** (*DB) - The opened database handle.
- **err** (error) - nil on success, otherwise an error.

### Usage Example
```go
db, err := leveldb.Open(storage, nil)
if err != nil {
    panic(err)
}
defer db.Close()
```

### Notes
- The returned DB is safe for concurrent use.
- Must be closed with db.Close() when done.
```

--------------------------------

### Contains and Get method signatures

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/memdb.md

Method signatures for checking key existence and retrieving a value. Get returns ErrNotFound for missing keys, and the returned slice aliases the internal buffer—do not modify it.

```go
func (p *DB) Contains(key []byte) bool
func (p *DB) Get(key []byte) (value []byte, err error)
```

--------------------------------

### Usage pattern: Put, Get, and iterate

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/memdb.md

Usage pattern inside goleveldb: put a key/value, get it (noting the aliased slice), and iterate over keys with a prefix. The iterator must be released, and slices from Key()/Value() alias the buffer.

```go
err := m.Put([]byte("key"), []byte("value"))
if err != nil {
	panic(err)
}
value, err := m.Get([]byte("key"))
if err == nil {
	print(value) // aliased slice — copy before next op if needed
}
iter := m.NewIterator(util.BytesPrefix([]byte("k")))
defer iter.Release()
for iter.Next() {
	print(iter.Key(), iter.Value())
}
```

--------------------------------

### Range struct definition

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/util.md

Defines a key range with inclusive Start and exclusive Limit. A nil Start means a key before all keys, and a nil Limit means a key after all keys. This type is accepted by methods like DB.NewIterator, DB.CompactRange, and DB.SizeOf.

```go
type Range struct {
	// Start of the key range, include in the range.
	Start []byte
	// Limit of the key range, not include in the range.
	Limit []byte
}
```

--------------------------------

### BatchConfig struct

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Configuration for MakeBatchWithConfig. InitialCapacity defaults to 0, GrowLimit defaults to 3000.

```go
type BatchConfig struct {
	InitialCapacity int  // The default value is 0.
	GrowLimit int        // The default value is 3000.
}
```

--------------------------------

### Cache.Get

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/cache.md

Get returns a handle for a cache entry, creating it if absent.

```APIDOC
## Cache.Get

### Description
Returns a handle for the given namespace and key, atomically creating the node if absent. The handle must be released with Handle.Release() after use.

### Method Signature
```go
func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle
```

### Parameters
- **ns** (uint64) - Required - The namespace.
- **key** (uint64) - Required - The key.
- **setFunc** (func() (size int, value Value)) - Optional - Called to create the node if absent. May be nil.

### Returns
- **\*Handle** - The handle for the node, or nil if the map is closed, setFunc is nil and node absent, or setFunc returns nil value.

### Source
`leveldb/cache/cache.go:470`
```

--------------------------------

### Storage interface

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/storage.md

Defines the full storage abstraction with methods for locking, logging, metadata, listing, opening, creating, removing, renaming, and closing files.

```go
type Storage interface {
	Lock() (Locker, error)
	Log(str string)
	SetMeta(fd FileDesc) error
	GetMeta() (FileDesc, error)
	List(ft FileType) ([]FileDesc, error)
	Open(fd FileDesc) (Reader, error)
	Create(fd FileDesc) (Writer, error)
	Remove(fd FileDesc) error
	Rename(oldfd, newfd FileDesc) error
	Close() error
}
```

--------------------------------

### Capacity, Size, Free, Len method signatures

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/memdb.md

Method signatures for capacity, size, free space, and entry count. Size excludes deleted entries, while Capacity and Free report the buffer state.

```go
func (p *DB) Capacity() int   // memdb.go:412 — key/value buffer capacity
func (p *DB) Size() int       // memdb.go:421 — sum of live key+value lengths
func (p *DB) Free() int       // memdb.go:428 — free capacity before growth
func (p *DB) Len() int        // memdb.go:435 — number of live entries
```

--------------------------------

### Comparer.Name

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/comparer.md

Returns the name of the comparer. Names starting with 'leveldb.' are reserved and should not be used by users of this package.

```APIDOC
## Comparer.Name

### Description
Returns the name of the comparer. The name must change whenever the implementation changes in a way that alters the relative ordering of any two keys. Names starting with 'leveldb.' are reserved.

### Method
Name

### Signature
Name() string

### Returns
- **string** - The name of the comparer

### Source
`leveldb/comparer/comparer.go:20`
```

--------------------------------

### Transaction.Has method signature

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/transaction.md

Method signature for existence check with the same semantics as Get, returning errTransactionDone when closed.

```go
func (tr *Transaction) Has(key []byte, ro *opt.ReadOptions) (bool, error)
```

--------------------------------

### GetProperty

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Returns an informational property about the DB. Unknown names (and any name not starting with `leveldb.`) return `ErrNotFound`.

```APIDOC
## `GetProperty`

```go
func (db *DB) GetProperty(name string) (value string, err error)
```

### Description
Returns an informational property. Unknown names (and any name not starting with `leveldb.`) return `ErrNotFound`. Supported names:

| Property | Output |
|---|---|
| `leveldb.num-files-at-level{n}` | Number of files at level `n` |
| `leveldb.stats` | Per-level compaction table (tables, size, time, read, write) |
| `leveldb.compcount` | `MemComp:<n> Level0Comp:<n> NonLevel0Comp:<n> SeekComp:<n>` |
| `leveldb.iostats` | `Read(MB):<r> Write(MB):<w>` |
| `leveldb.writedelay` | `DelayN:<n> Delay:<d> Paused:<bool>` |
| `leveldb.sstables` | `--- level n ---` then `num:size[imin .. imax]` per table |
| `leveldb.blockpool` | Buffer pool stats |
| `leveldb.cachedblock` | Bytes held by the block cache (`<nil>`, `0`, or a size) |
| `leveldb.openedtables` | Number of open table files |
| `leveldb.alivesnaps` | Number of alive snapshots |
| `leveldb.aliveiters` | Number of alive iterators |

### Parameters
- `name` (string) - Required - The property name to query.

### Returns
- `value` (string) - The property value.
- `err` (error) - An error if the property is unknown or not starting with `leveldb.`.

### Example
```go
value, err := db.GetProperty("leveldb.num-files-at-level0")
if err == nil {
	print(value)
}
```
```

--------------------------------

### OpenFile(string, *opt.Options) (*DB, error)

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/leveldb.md

Opens or creates a database backed by the standard filesystem storage. The storage is closed automatically with the DB. Same semantics as Open but uses the filesystem.

```APIDOC
## OpenFile(string, *opt.Options) (*DB, error)

### Description
Opens or creates a database backed by the standard filesystem storage. The storage is closed automatically with the DB. Same semantics as Open but uses the filesystem.

### Function Signature
```go
func OpenFile(path string, o *opt.Options) (db *DB, err error)
```

### Parameters
- **path** (string) - Required - The filesystem path to the database directory.
- **o** (*opt.Options) - Optional - Options for opening the database. Pass nil for defaults.

### Return Values
- **db** (*DB) - The opened database handle.
- **err** (error) - nil on success, otherwise an error.

### Usage Example
```go
db, err := leveldb.OpenFile("path/to/db", nil)
if err != nil {
    panic(err)
}
defer db.Close()
```

### Notes
- The returned DB is safe for concurrent use.
- Must be closed with db.Close() when done.
```

--------------------------------

### Using Snapshot.NewIterator

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/snapshot.md

Example usage of Snapshot.NewIterator: acquire a snapshot, create an iterator over a range, and iterate while the snapshot is held.

```go
snap, err := db.GetSnapshot()
defer snap.Release()
iter := snap.NewIterator(&util.Range{Start: []byte("a"), Limit: []byte("z")}, nil)
defer iter.Release()
for iter.Next() {
	// Consistent view; underlying db writes are invisible here.
}
```

--------------------------------

### Use a Bloom filter with opt.Options

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Opens a database with a Bloom filter to improve read performance. The filter is created with filter.NewBloomFilter(10).

```go
o := &opt.Options{
	Filter: filter.NewBloomFilter(10),
}
db, err := leveldb.OpenFile("path/to/db", o)
...
defer db.Close()
...
```

--------------------------------

### NamespaceGetter

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/cache.md

Convenience wrapper that pins a namespace for cache lookups. Provides a Get method to retrieve or create a cache entry.

```APIDOC
## NamespaceGetter

### Description
Convenience wrapper that pins a namespace for cache lookups. Provides a Get method to retrieve or create a cache entry.

### Fields
- **Cache** (*Cache) - The underlying cache.
- **NS** (uint64) - The namespace ID.

### Methods

#### Get(key uint64, setFunc func() (size int, value Value)) *Handle
Retrieves the handle for the given key in the pinned namespace. If the key is not present, `setFunc` is called to create the value, and the result is stored in the cache.
```

--------------------------------

### MakeBatchWithConfig

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Constructor for creating a batch with custom configuration for initial capacity and growth limit.

```APIDOC
## `MakeBatchWithConfig`

### Description
Initializes a batch honoring `InitialCapacity` (preallocation) and `GrowLimit` (entry-count threshold above which the buffer grows by at most `GrowLimit` entries per cycle instead of doubling).

### Signature
```go
func MakeBatchWithConfig(config *BatchConfig) *Batch
```

### Parameters
- **config** (\*BatchConfig) - Required - Configuration for the batch.

### Returns
- **\*Batch** - A new empty batch with the specified configuration.

### Example
```go
batch := leveldb.MakeBatchWithConfig(&leveldb.BatchConfig{
	InitialCapacity: 1024,
	GrowLimit: 1000,
})
```

```

--------------------------------

### Seek-then-Iterate with db.NewIterator

Source: https://github.com/syndtr/goleveldb/blob/master/README.md

Iterates starting from a specific key using Seek. The loop continues while Seek or Next returns true.

```go
iter := db.NewIterator(nil, nil)
for ok := iter.Seek(key); ok; ok = iter.Next() {
	// Use key/value.
	...
}
iter.Release()
err = iter.Error()
...
```

--------------------------------

### Compression

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/options.md

The Compression type defines the compression algorithm used for data blocks. It provides a String method to get a human-readable name.

```APIDOC
## Compression

### Description
The Compression type specifies the compression algorithm used for data blocks in goleveldb. The default compression is snappy.

### Type
`type Compression uint`

### Constants
- `DefaultCompression` - Default compression, maps to snappy.
- `NoCompression` - No compression.
- `SnappyCompression` - Snappy compression.
- `nCompression` - Internal sentinel value.

### Methods
#### String() string
Returns a string representation of the compression: "default", "none", "snappy", or "invalid".

### Source
`leveldb/opt/options.go:109-128`
```

--------------------------------

### MakeBatch constructor

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Returns an empty batch with a preallocated buffer of capacity n.

```go
func MakeBatch(n int) *Batch
```

--------------------------------

### Replay method

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Replays every record against r in order. Returns nil (replay callbacks return nothing in this interface).

```go
func (b *Batch) Replay(r BatchReplay) error
```

--------------------------------

### Writer.Size method

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/journal.md

Current file size in bytes.

```go
func (w *Writer) Size() int64
```

--------------------------------

### storage.OpenFile

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/storage.md

Opens a filesystem-backed storage at the given path. It verifies the path is a directory (or creates it with mode 0755 unless read-only), acquires an exclusive lock, and manages the LOG, CURRENT, and meta files. Returns a Storage interface for reading and writing data.

```APIDOC
## `storage.OpenFile` (filesystem storage)

### Description
Opens a filesystem-backed storage at the given path. It verifies the path is a directory (or creates it with mode 0755 unless read-only), acquires an exclusive lock, and manages the LOG, CURRENT, and meta files. Returns a Storage interface for reading and writing data.

### Method
OpenFile

### Signature
```go
func OpenFile(path string, readOnly bool) (Storage, error)
```

### Parameters
- **path** (string) - Required - The directory path for the storage.
- **readOnly** (bool) - Required - If true, the storage is opened read-only; write operations will return an error.

### Returns
- **Storage** - The storage interface for file operations.
- **error** - An error if the storage cannot be opened.

### Behavior
- Verifies `path` is a directory (or creates it with mode `0755` unless read-only).
- Acquires an exclusive `LOCK` file lock — a second `OpenFile` on the same path fails while locked.
- Opens/rotates `LOG` (rotated at 1 MiB into `LOG.old`).
- `CURRENT` meta file handling: writes are staged via `CURRENT.<num>` then atomically renamed; `GetMeta` prefers pending `CURRENT.<n>` files, then `CURRENT`, then `CURRENT.bak`, repairing when possible.
- A finalizer closes the storage on GC.

### Error Handling
- The readable/writable methods (`SetMeta`, `Create`, `Remove`, `Rename`, `Log`) return `errReadOnly` (`leveldb/storage: storage is read-only`) when opened read-only.
- Each of `Open`/`Create`/`Remove`/`Rename`/`List`/`Lock` returns `storage.ErrClosed` after close, and `ErrInvalidFile` for invalid descriptors.
```

--------------------------------

### Options struct

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/options.md

Configuration options for opening a LevelDB database, including all fields and their accessors.

```APIDOC
## `Options` struct

### Description
Configuration options for opening a LevelDB database. All fields have matching `Get*(...)` accessors that apply defaults when the field is zero/nil.

### Fields
- `AltFilters []filter.Filter` - Alternative filters.
- `BlockCacher Cacher` - Block cache implementation.
- `BlockCacheCapacity int` - Block cache capacity.
- `BlockCacheEvictRemoved bool` - Whether to evict removed blocks from cache.
- `BlockRestartInterval int` - Block restart interval.
- `BlockSize int` - Block size.
- `CompactionExpandLimitFactor int` - Compaction expand limit factor.
- `CompactionGPOverlapsFactor int` - Compaction grandparent overlaps factor.
- `CompactionL0Trigger int` - Compaction L0 trigger.
- `CompactionSourceLimitFactor int` - Compaction source limit factor.
- `CompactionTableSize int` - Compaction table size.
- `CompactionTableSizeMultiplier float64` - Compaction table size multiplier.
- `CompactionTableSizeMultiplierPerLevel []float64` - Per-level compaction table size multiplier.
- `CompactionTotalSize int` - Compaction total size.
- `CompactionTotalSizeMultiplier float64` - Compaction total size multiplier.
- `CompactionTotalSizeMultiplierPerLevel []float64` - Per-level compaction total size multiplier.
- `Comparer comparer.Comparer` - Comparer for key ordering.
- `Compression Compression` - Compression type.
- `DisableBufferPool bool` - Disable buffer pool.
- `DisableBlockCache bool` - Disable block cache.
- `DisableCompactionBackoff bool` - Disable compaction backoff.
- `DisableLargeBatchTransaction bool` - Disable large batch transaction.
- `DisableSeeksCompaction bool` - Disable seeks compaction.
- `ErrorIfExist bool` - Return error if database already exists.
- `ErrorIfMissing bool` - Return error if database is missing.
- `Filter filter.Filter` - Filter policy.
- `IteratorSamplingRate int` - Iterator sampling rate.
- `NoSync bool` - Disable fsync.
- `NoWriteMerge bool` - Disable write merge.
- `OpenFilesCacher Cacher` - Open files cache implementation.
- `OpenFilesCacheCapacity int` - Open files cache capacity.
- `ReadOnly bool` - Open database read-only.
- `Strict Strict` - Strict level.
- `WriteBuffer int` - Write buffer size.
- `WriteL0PauseTrigger int` - Write L0 pause trigger.
- `WriteL0SlowdownTrigger int` - Write L0 slowdown trigger.
- `FilterBaseLg int` - Filter base log.
- `MaxManifestFileSize int64` - Maximum manifest file size.

### Accessors
- `GetWriteBuffer()` - Returns write buffer size with default.
- `GetBlockCacheCapacity()` - Returns block cache capacity; negative returns 0.
- `GetStrict(strict)` - Returns strict level with default.
- `GetCompactionTableSize(level)` - Returns compaction table size for level.
- `GetCompactionTotalSize(level)` - Returns compaction total size for level.
```

--------------------------------

### GetProperty method signature

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Declares the GetProperty method on *DB. Returns an informational property. Unknown names (and any name not starting with `leveldb.`) return ErrNotFound.

```go
func (db *DB) GetProperty(name string) (value string, err error)
```

--------------------------------

### Has method signature

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/db.md

Returns whether the DB contains the key. Differs from Get: a deletion marker or missing key yields ret=false, err=nil; other errors are reported.

```go
func (db *DB) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error)
```

--------------------------------

### Persist and restore batch

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/batch.md

Dumps the batch, loads it into a new batch, and writes it to the database. Panics on load error.

```go
// Persist / restore
data := batch.Dump()
loaded := leveldb.MakeBatch(0)
err := loaded.Load(data)
if err != nil {
	panic(err)
}
err = db.Write(loaded, nil)
```

--------------------------------

### New constructor signature

Source: https://github.com/syndtr/goleveldb/blob/master/_autodocs/api-reference/memdb.md

Constructor for creating a new memdb. The capacity parameter is the initial key/value buffer capacity and is advisory, not enforced.

```go
func New(cmp comparer.BasicComparer, capacity int) *DB
```
Tokens:
Raw