kv

Documentation

Index

• Variables
• func Drivers() []string
• func Register(name string, driver Driver)
• func UnregisterAllDrivers()
• type Driver
• type EntriesIterator
  • func ScanPrefix(ctx context.Context, store Store, prefix []byte) (EntriesIterator, error)
• type Entry
  • func (e *Entry) String() string
• type PrefixIterator
  • func (b *PrefixIterator) Close()
  • func (b *PrefixIterator) Entry() *Entry
  • func (b *PrefixIterator) Err() error
  • func (b *PrefixIterator) Next() bool
• type Store
  • func Open(ctx context.Context, name, dsn string) (Store, error)

Variables

var (
	ErrClosedEntries       = errors.New("closed entries")
	ErrConnectFailed       = errors.New("connect failed")
	ErrDriverConfiguration = errors.New("driver configuration")
	ErrMissingKey          = errors.New("missing key")
	ErrMissingValue        = errors.New("missing value")
	ErrNotFound            = errors.New("not found")
	ErrOperationFailed     = errors.New("operation failed")
	ErrPredicateFailed     = errors.New("predicate failed")
	ErrSetupFailed         = errors.New("setup failed")
	ErrUnknownDriver       = errors.New("unknown driver")
)

Functions

func Drivers

func Drivers() []string

Drivers returns a list of registered drive names

func Register

func Register(name string, driver Driver)

Register 'driver' implementation under 'name'. Panic in case of empty name, nil driver or name already registered.

func UnregisterAllDrivers

func UnregisterAllDrivers()

UnregisterAllDrivers remove all loaded drivers, used for test code.

Types

type Driver

type Driver interface {
	// Open opens access to the database store. Implementations give access to the same storage based on the dsn.
	// Implementation can return the same Storage instance based on dsn or new one as long as it provides access to
	// the same storage.
	Open(ctx context.Context, dsn string) (Store, error)
}

Driver is the interface to access a kv database as a Store. Each kv provider implements a Driver.

type EntriesIterator

type EntriesIterator interface {
	// Next should be called first before access Entry.
	// it will process the next entry and return true if it was successful, and false when none or error.
	Next() bool

	// Entry current entry read after calling Next, set to nil in case of an error or no more entries.
	Entry() *Entry

	// Err set to last error by reading or parse the next entry.
	Err() error

	// Close should be called at the end of processing entries, required to release resources used to scan entries.
	// After calling 'Close' the instance should not be used as the behaviour will not be defined.
	Close()
}

EntriesIterator used to enumerate over Scan results

func ScanPrefix

func ScanPrefix(ctx context.Context, store Store, prefix []byte) (EntriesIterator, error)

ScanPrefix returns an iterator on store that scan the set of keys that start with prefix

type Entry

type Entry struct {
	Key   []byte
	Value []byte
}

Entry holds a pair of key/value

func (*Entry) String

func (e *Entry) String() string

type PrefixIterator

type PrefixIterator struct {
	Iterator EntriesIterator
	Prefix   []byte
	// contains filtered or unexported fields
}

func (*PrefixIterator) Close

func (b *PrefixIterator) Close()

func (*PrefixIterator) Entry

func (b *PrefixIterator) Entry() *Entry

func (*PrefixIterator) Err

func (b *PrefixIterator) Err() error

func (*PrefixIterator) Next

func (b *PrefixIterator) Next() bool

type Store

type Store interface {
	// Get returns a value for the given key, or ErrNotFound if key doesn't exist
	Get(ctx context.Context, key []byte) ([]byte, error)

	// Set stores the given value, overwriting an existing value if one exists
	Set(ctx context.Context, key, value []byte) error

	// SetIf returns an ErrPredicateFailed error if the key with valuePredicate passed
	//  doesn't match the currently stored value. SetIf is a simple compare-and-swap operator:
	//  valuePredicate is either the existing value, or nil for no previous key exists.
	//  this is intentionally simplistic: we can model a better abstraction on top, keeping this interface simple for implementors
	SetIf(ctx context.Context, key, value, valuePredicate []byte) error

	// Delete will delete the key, no error in if key doesn't exist
	Delete(ctx context.Context, key []byte) error

	// Scan returns entries that can be read by key order, starting at or after the `start` position
	Scan(ctx context.Context, start []byte) (EntriesIterator, error)

	// Close access to the database store. After calling Close the instance is unusable.
	Close()
}

func Open

func Open(ctx context.Context, name, dsn string) (Store, error)

Open lookup driver with 'name' and return Store based on 'dsn' (data source name). Failed with ErrUnknownDriver in case 'name' is not registered