bdb

package
v1.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 1, 2024 License: Apache-2.0 Imports: 22 Imported by: 0

Documentation

Index

Examples

Constants

View Source 
const (
	MaxKeySize   = 10 << 10
	MaxValueSize = (1 << 31) - 2
)
View Source 
const (
	DefaultMaxBatchSize  int = 1000
	DefaultMaxBatchDelay     = 10 * time.Millisecond
)
View Source 
const DefaultFillPercent = 1.0
View Source 
const IgnoreNoSync = runtime.GOOS == "openbsd"

Variables

View Source 
var (
	ErrDatabaseNotOpen = errors.New("database not open")
	ErrDatabaseOpen    = errors.New("database already open")
	ErrInvalid         = errors.New("invalid database")
	ErrVersionMismatch = errors.New("version mismatch")
	ErrChecksum        = errors.New("checksum error")
	ErrTimeout         = errors.New("timeout")
)
View Source 
var (
	ErrTxNotWritable    = errors.New("tx not writable")
	ErrTxClosed         = errors.New("tx closed")
	ErrDatabaseReadOnly = errors.New("database is in read-only mode")
)
View Source 
var (
	ErrBucketNotFound     = errors.New("bucket not found")
	ErrBucketExists       = errors.New("bucket already exists")
	ErrBucketNameRequired = errors.New("bucket name required")
	ErrKeyRequired        = errors.New("key required")
	ErrKeyTooLarge        = errors.New("key too large")
	ErrValueTooLarge      = errors.New("value too large")
	ErrIncompatibleValue  = errors.New("incompatible value")
)

Functions

func Compact 

func Compact(dst, src *DB, ciMaxSize int64) error

Types

type BdbIterator 

type BdbIterator struct {
	// contains filtered or unexported fields
}

func (*BdbIterator) Close 

func (i *BdbIterator) Close() error

func (*BdbIterator) Error 

func (i *BdbIterator) Error() error

func (*BdbIterator) First 

func (i *BdbIterator) First() (*base.InternalKey, []byte)

func (*BdbIterator) Ikey 

func (i *BdbIterator) Ikey() *base.InternalKey

func (*BdbIterator) Last 

func (i *BdbIterator) Last() (*base.InternalKey, []byte)

func (*BdbIterator) Next 

func (i *BdbIterator) Next() (*base.InternalKey, []byte)

func (*BdbIterator) Prev 

func (i *BdbIterator) Prev() (*base.InternalKey, []byte)

func (*BdbIterator) SeekGE 

func (i *BdbIterator) SeekGE(key []byte) (*base.InternalKey, []byte)

func (*BdbIterator) SeekLT 

func (i *BdbIterator) SeekLT(key []byte) (*base.InternalKey, []byte)

func (*BdbIterator) SeekPrefixGE 

func (i *BdbIterator) SeekPrefixGE(
	prefix, key []byte, trySeekUsingNext bool,
) (ikey *base.InternalKey, value []byte)

func (*BdbIterator) SetBounds 

func (i *BdbIterator) SetBounds(lower, upper []byte)

func (*BdbIterator) String 

func (i *BdbIterator) String() string

func (*BdbIterator) Value 

func (i *BdbIterator) Value() []byte

type Bucket 

type Bucket struct {
	FillPercent float64
	// contains filtered or unexported fields
}

func (*Bucket) Bucket 

func (b *Bucket) Bucket(name []byte) *Bucket

func (*Bucket) CreateBucket 

func (b *Bucket) CreateBucket(key []byte) (*Bucket, error)

func (*Bucket) CreateBucketIfNotExists 

func (b *Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error)

func (*Bucket) Cursor 

func (b *Bucket) Cursor() *Cursor

func (*Bucket) Delete 

func (b *Bucket) Delete(key []byte) error
Example 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	b, err := tx.CreateBucket([]byte("widgets"))
	if err != nil {
		return err
	}

	if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
		return err
	}

	value := b.Get([]byte("foo"))
	fmt.Printf("The value of 'foo' was: %s\n", value)

	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Update(func(tx *bdb.Tx) error {
	return tx.Bucket([]byte("widgets")).Delete([]byte("foo"))
}); err != nil {
	log.Fatal(err)
}

if err := db.View(func(tx *bdb.Tx) error {
	value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
	if value == nil {
		fmt.Printf("The value of 'foo' is now: nil\n")
	}
	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

func (*Bucket) DeleteBucket 

func (b *Bucket) DeleteBucket(key []byte) error

func (*Bucket) ForEach 

func (b *Bucket) ForEach(fn func(k, v []byte) error) error
Example 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	b, err := tx.CreateBucket([]byte("animals"))
	if err != nil {
		return err
	}

	if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
		return err
	}
	if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
		return err
	}
	if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
		return err
	}

	if err := b.ForEach(func(k, v []byte) error {
		fmt.Printf("A %s is %s.\n", k, v)
		return nil
	}); err != nil {
		return err
	}

	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

func (*Bucket) Get 

func (b *Bucket) Get(key []byte) []byte

func (*Bucket) NextSequence 

func (b *Bucket) NextSequence() (uint64, error)

func (*Bucket) Put 

func (b *Bucket) Put(key []byte, value []byte) error
Example 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	b, err := tx.CreateBucket([]byte("widgets"))
	if err != nil {
		return err
	}

	if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
		return err
	}
	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.View(func(tx *bdb.Tx) error {
	value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
	fmt.Printf("The value of 'foo' is: %s\n", value)
	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

func (*Bucket) Root 

func (b *Bucket) Root() pgid

func (*Bucket) Seek 

func (b *Bucket) Seek(key []byte) ([]byte, []byte)

func (*Bucket) Sequence 

func (b *Bucket) Sequence() uint64

func (*Bucket) SetSequence 

func (b *Bucket) SetSequence(v uint64) error

func (*Bucket) Stats 

func (b *Bucket) Stats() BucketStats

func (*Bucket) Tx 

func (b *Bucket) Tx() *Tx

func (*Bucket) Writable 

func (b *Bucket) Writable() bool

type BucketStats 

type BucketStats struct {
	BranchPageN       int
	BranchOverflowN   int
	LeafPageN         int
	LeafOverflowN     int
	KeyN              int
	Depth             int
	BranchAlloc       int
	BranchInuse       int
	LeafAlloc         int
	LeafInuse         int
	BucketN           int
	InlineBucketN     int
	InlineBucketInuse int
}

func (*BucketStats) Add 

func (s *BucketStats) Add(other BucketStats)

type Cursor 

type Cursor struct {
	// contains filtered or unexported fields
}
Example 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	b, err := tx.CreateBucket([]byte("animals"))
	if err != nil {
		return err
	}

	if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
		log.Fatal(err)
	}

	c := b.Cursor()

	for k, v := c.First(); k != nil; k, v = c.Next() {
		fmt.Printf("A %s is %s.\n", k, v)
	}

	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:
Example (Reverse) 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	b, err := tx.CreateBucket([]byte("animals"))
	if err != nil {
		return err
	}

	if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
		log.Fatal(err)
	}
	if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
		log.Fatal(err)
	}

	c := b.Cursor()

	for k, v := c.Last(); k != nil; k, v = c.Prev() {
		fmt.Printf("A %s is %s.\n", k, v)
	}

	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

func (*Cursor) Bucket 

func (c *Cursor) Bucket() *Bucket

func (*Cursor) Delete 

func (c *Cursor) Delete() error

func (*Cursor) First 

func (c *Cursor) First() (key []byte, value []byte)

func (*Cursor) Last 

func (c *Cursor) Last() (key []byte, value []byte)

func (*Cursor) Next 

func (c *Cursor) Next() (key []byte, value []byte)

func (*Cursor) Prev 

func (c *Cursor) Prev() (key []byte, value []byte)

func (*Cursor) Seek 

func (c *Cursor) Seek(seek []byte) (key []byte, value []byte)

type DB 

type DB struct {
	StrictMode     bool
	NoSync         bool
	NoFreelistSync bool
	FreelistType   string
	NoGrowSync     bool
	MmapFlags      int
	MaxBatchSize   int
	MaxBatchDelay  time.Duration
	AllocSize      int
	Mlock          bool
	// contains filtered or unexported fields
}

func Open 

func Open(path string, options *base.BdbOptions) (*DB, error)

func (*DB) Batch 

func (db *DB) Batch(fn func(*Tx) error) error

func (*DB) Begin 

func (db *DB) Begin(writable bool) (*Tx, error)
Example 
package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"

	"github.com/zuoyebang/bitalosdb/bitree/bdb"
)

func main() {
	db, err := bdb.Open(tempfile(), nil)
	if err != nil {
		log.Fatal(err)
	}
	defer os.Remove(db.Path())

	if err = db.Update(func(tx *bdb.Tx) error {
		_, err := tx.CreateBucket([]byte("widgets"))
		return err
	}); err != nil {
		log.Fatal(err)
	}

	tx, err := db.Begin(true)
	if err != nil {
		log.Fatal(err)
	}
	b := tx.Bucket([]byte("widgets"))
	if err = b.Put([]byte("john"), []byte("blue")); err != nil {
		log.Fatal(err)
	}
	if err = b.Put([]byte("abby"), []byte("red")); err != nil {
		log.Fatal(err)
	}
	if err = b.Put([]byte("zephyr"), []byte("purple")); err != nil {
		log.Fatal(err)
	}
	if err = tx.Commit(); err != nil {
		log.Fatal(err)
	}

	tx, err = db.Begin(false)
	if err != nil {
		log.Fatal(err)
	}
	c := tx.Bucket([]byte("widgets")).Cursor()
	for k, v := c.First(); k != nil; k, v = c.Next() {
		fmt.Printf("%s likes %s\n", k, v)
	}

	if err = tx.Rollback(); err != nil {
		log.Fatal(err)
	}

	if err = db.Close(); err != nil {
		log.Fatal(err)
	}
}

func tempfile() string {
	f, err := ioutil.TempFile("", "bdb-")
	if err != nil {
		panic(err)
	}
	if err := f.Close(); err != nil {
		panic(err)
	}
	if err := os.Remove(f.Name()); err != nil {
		panic(err)
	}
	return f.Name()
}

Output:

func (*DB) Close 

func (db *DB) Close() error

func (*DB) DiskSize 

func (db *DB) DiskSize() int64

func (*DB) FreePage 

func (db *DB) FreePage() int

func (*DB) GetPageSize 

func (db *DB) GetPageSize() int

func (*DB) GoString 

func (db *DB) GoString() string

func (*DB) Info 

func (db *DB) Info() *Info

func (*DB) IsReadOnly 

func (db *DB) IsReadOnly() bool

func (*DB) NewIter 

func (db *DB) NewIter(rtx *ReadTx) *BdbIterator

func (*DB) Path 

func (db *DB) Path() string

func (*DB) Stats 

func (db *DB) Stats() Stats

func (*DB) String 

func (db *DB) String() string

func (*DB) Sync 

func (db *DB) Sync() error

func (*DB) TotalPage 

func (db *DB) TotalPage() int

func (*DB) Update 

func (db *DB) Update(fn func(*Tx) error) error
Example 
package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"

	"github.com/zuoyebang/bitalosdb/bitree/bdb"
)

func main() {
	db, err := bdb.Open(tempfile(), nil)
	if err != nil {
		log.Fatal(err)
	}
	defer os.Remove(db.Path())

	if err := db.Update(func(tx *bdb.Tx) error {
		b, err := tx.CreateBucket([]byte("widgets"))
		if err != nil {
			return err
		}
		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
			return err
		}
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	if err := db.View(func(tx *bdb.Tx) error {
		value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
		fmt.Printf("The value of 'foo' is: %s\n", value)
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	if err := db.Close(); err != nil {
		log.Fatal(err)
	}
}

func tempfile() string {
	f, err := ioutil.TempFile("", "bdb-")
	if err != nil {
		panic(err)
	}
	if err := f.Close(); err != nil {
		panic(err)
	}
	if err := os.Remove(f.Name()); err != nil {
		panic(err)
	}
	return f.Name()
}

Output:

func (*DB) View 

func (db *DB) View(fn func(*Tx) error) error
Example 
package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"

	"github.com/zuoyebang/bitalosdb/bitree/bdb"
)

func main() {
	db, err := bdb.Open(tempfile(), nil)
	if err != nil {
		log.Fatal(err)
	}
	defer os.Remove(db.Path())

	if err := db.Update(func(tx *bdb.Tx) error {
		b, err := tx.CreateBucket([]byte("people"))
		if err != nil {
			return err
		}
		if err := b.Put([]byte("john"), []byte("doe")); err != nil {
			return err
		}
		if err := b.Put([]byte("susy"), []byte("que")); err != nil {
			return err
		}
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	if err := db.View(func(tx *bdb.Tx) error {
		v := tx.Bucket([]byte("people")).Get([]byte("john"))
		fmt.Printf("John's last name is %s.\n", v)
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	if err := db.Close(); err != nil {
		log.Fatal(err)
	}
}

func tempfile() string {
	f, err := ioutil.TempFile("", "bdb-")
	if err != nil {
		panic(err)
	}
	if err := f.Close(); err != nil {
		panic(err)
	}
	if err := os.Remove(f.Name()); err != nil {
		panic(err)
	}
	return f.Name()
}

Output:

type Info 

type Info struct {
	Data     uintptr
	PageSize int
}

type PageInfo 

type PageInfo struct {
	ID            int
	Type          string
	Count         int
	OverflowCount int
}

type ReadTx 

type ReadTx struct {
	// contains filtered or unexported fields
}

func (*ReadTx) Bucket 

func (rt *ReadTx) Bucket() *Bucket

func (*ReadTx) Init 

func (rt *ReadTx) Init(tx *Tx, bkt *Bucket, bdb *DB)

func (*ReadTx) Ref 

func (rt *ReadTx) Ref()

func (*ReadTx) Unref 

func (rt *ReadTx) Unref(update bool) (err error)

type Stats 

type Stats struct {
	FreePageN     int
	PendingPageN  int
	FreeAlloc     int
	FreelistInuse int
	TxN           int
	OpenTxN       int
	TxStats       TxStats
}

func (*Stats) Sub 

func (s *Stats) Sub(other *Stats) Stats

type Tx 

type Tx struct {
	WriteFlag int
	// contains filtered or unexported fields
}

func (*Tx) Bucket 

func (tx *Tx) Bucket(name []byte) *Bucket

func (*Tx) Check 

func (tx *Tx) Check() <-chan error

func (*Tx) Commit 

func (tx *Tx) Commit() error

func (*Tx) Copy 

func (tx *Tx) Copy(w io.Writer) error

func (*Tx) CopyFile 

func (tx *Tx) CopyFile(path string, mode os.FileMode) error
Example 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	b, err := tx.CreateBucket([]byte("widgets"))
	if err != nil {
		return err
	}
	if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
		return err
	}
	return nil
}); err != nil {
	log.Fatal(err)
}

toFile := tempfile()
if err := db.View(func(tx *bdb.Tx) error {
	return tx.CopyFile(toFile, 0666)
}); err != nil {
	log.Fatal(err)
}
defer os.Remove(toFile)

db2, err := bdb.Open(toFile, nil)
if err != nil {
	log.Fatal(err)
}

if err := db2.View(func(tx *bdb.Tx) error {
	value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
	fmt.Printf("The value for 'foo' in the clone is: %s\n", value)
	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

if err := db2.Close(); err != nil {
	log.Fatal(err)
}

Output:

func (*Tx) CreateBucket 

func (tx *Tx) CreateBucket(name []byte) (*Bucket, error)

func (*Tx) CreateBucketIfNotExists 

func (tx *Tx) CreateBucketIfNotExists(name []byte) (*Bucket, error)

func (*Tx) Cursor 

func (tx *Tx) Cursor() *Cursor

func (*Tx) DB 

func (tx *Tx) DB() *DB

func (*Tx) DeleteBucket 

func (tx *Tx) DeleteBucket(name []byte) error

func (*Tx) ForEach 

func (tx *Tx) ForEach(fn func(name []byte, b *Bucket) error) error

func (*Tx) ID 

func (tx *Tx) ID() int

func (*Tx) OnCommit 

func (tx *Tx) OnCommit(fn func())

func (*Tx) Page 

func (tx *Tx) Page(id int) (*PageInfo, error)

func (*Tx) Rollback 

func (tx *Tx) Rollback() error
Example 
db, err := bdb.Open(tempfile(), nil)
if err != nil {
	log.Fatal(err)
}
defer os.Remove(db.Path())

if err := db.Update(func(tx *bdb.Tx) error {
	_, err := tx.CreateBucket([]byte("widgets"))
	return err
}); err != nil {
	log.Fatal(err)
}

if err := db.Update(func(tx *bdb.Tx) error {
	return tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))
}); err != nil {
	log.Fatal(err)
}

tx, err := db.Begin(true)
if err != nil {
	log.Fatal(err)
}
b := tx.Bucket([]byte("widgets"))
if err := b.Put([]byte("foo"), []byte("baz")); err != nil {
	log.Fatal(err)
}
if err := tx.Rollback(); err != nil {
	log.Fatal(err)
}

if err := db.View(func(tx *bdb.Tx) error {
	value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
	fmt.Printf("The value for 'foo' is still: %s\n", value)
	return nil
}); err != nil {
	log.Fatal(err)
}

if err := db.Close(); err != nil {
	log.Fatal(err)
}

Output:

func (*Tx) Size 

func (tx *Tx) Size() int64

func (*Tx) Stats 

func (tx *Tx) Stats() TxStats

func (*Tx) Writable 

func (tx *Tx) Writable() bool

func (*Tx) WriteTo 

func (tx *Tx) WriteTo(w io.Writer) (n int64, err error)

type TxStats 

type TxStats struct {
	PageCount     int
	PageAlloc     int
	CursorCount   int
	NodeCount     int
	NodeDeref     int
	Rebalance     int
	RebalanceTime time.Duration
	Split         int
	Spill         int
	SpillTime     time.Duration
	Write         int
	WriteTime     time.Duration
}

func (*TxStats) Sub 

func (s *TxStats) Sub(other *TxStats) TxStats

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.