database

import "github.com/tcp-direct/database"

Warning

This package is pre-v1 and the API is NOT stable!

Documentation

varErrKeyNotFound=errors.New("key not found")

type Filer

typeFilerinterface {
// Backend returns the underlying key/value store.Backend() any// Has should return true if the given key has an associated value.Has(key []byte) bool// Get should retrieve the byte slice corresponding to the given key, and any associated errors upon failure.Get(key []byte) ([]byte, error)
// Put should insert the value data in a way that is associated and can be retrieved by the given key data.Put(key []byte, value []byte) error// Delete should delete the key and the value associated with the given key, and return an error upon failure.Delete(key []byte) error// Close should safely end any Filer operations of the given dataStore and close any relevant handlers.Close() error// Sync should take any volatile data and solidify it somehow if relevant. (ram to disk in most cases)Sync() errorKeys() [][]byteLen() int
}

Filer is is a way to implement any generic key/value store. These functions should be plug and play with most of the popular key/value store golang libraries.

NOTE: Many key/value golang libraries will already implement this interface already. This exists for more potential granular control in the case that they don't. Otherwise you'd have to build a wrapper around an existing key/value store to satisfy an overencompassing interface.

type Keeper

typeKeeperinterface {
// Path should return the base path where all stores should be stored under. (likely as subdirectories)Path() string// Init should initialize our Filer at the given path, to be referenced and called by dataStore.Init(namestring, options...any) error// With provides access to the given dataStore by providing a pointer to the related Filer.With(namestring) Filer// WithNew should initialize a new Filer at the given path and return a pointer to it.WithNew(namestring, options...any) Filer// Destroy should remove the Filer by the given name.// It is up to the implementation to decide if the data should be removed or not.Destroy(namestring) errorDiscover() ([]string, error)
AllStores() map[string]Filer// BackupAll should create a backup of all [Filer] instances in the [Keeper].BackupAll(archivePathstring) (models.Backup, error)
// RestoreAll should restore all [Filer] instances from the given archive.RestoreAll(archivePathstring) errorMeta() models.MetadataClose(namestring) errorCloseAll() errorSyncAll() errorSyncAndCloseAll() error
}

Keeper will be in charge of the more meta operations involving Filers. This includes operations like initialization, syncing to disk if applicable, and backing up.

- When opening a folder of Filers, it should be able to discover and initialize all of them.
- Additionally, it should be able to confirm the type of the underlying key/value store.

type KeeperCreator

typeKeeperCreatorfunc(pathstring) (Keeper, error)

type MockFiler

typeMockFilerstruct {
}

func (*MockFiler) Backend

func (m*MockFiler) Backend() any

func (*MockFiler) Close

func (m*MockFiler) Close() error

func (*MockFiler) Delete

func (m*MockFiler) Delete(key []byte) error

func (*MockFiler) Get

func (m*MockFiler) Get(key []byte) ([]byte, error)

func (*MockFiler) Has

func (m*MockFiler) Has(key []byte) bool

func (*MockFiler) Keys

func (m*MockFiler) Keys() [][]byte

func (*MockFiler) Len

func (m*MockFiler) Len() int

func (*MockFiler) Put

func (m*MockFiler) Put(key []byte, value []byte) error

func (*MockFiler) Sync

func (m*MockFiler) Sync() error

type MockKeeper

typeMockKeeperstruct {
}

func NewMockKeeper

funcNewMockKeeper(namestring) *MockKeeper

func (*MockKeeper) AllStores

func (m*MockKeeper) AllStores() map[string]Filer

func (*MockKeeper) BackupAll

func (m*MockKeeper) BackupAll(archivePathstring) (models.Backup, error)

func (*MockKeeper) Close

func (m*MockKeeper) Close(namestring) error

func (*MockKeeper) CloseAll

func (m*MockKeeper) CloseAll() error

func (*MockKeeper) Destroy

func (m*MockKeeper) Destroy(namestring) error

func (*MockKeeper) Discover

func (m*MockKeeper) Discover() ([]string, error)

func (*MockKeeper) Init

func (m*MockKeeper) Init(namestring, options...any) error

func (*MockKeeper) Meta

func (m*MockKeeper) Meta() models.Metadata

func (*MockKeeper) Path

func (m*MockKeeper) Path() string

func (*MockKeeper) RestoreAll

func (m*MockKeeper) RestoreAll(archivePathstring) error

func (*MockKeeper) SyncAll

func (m*MockKeeper) SyncAll() error

func (*MockKeeper) SyncAndCloseAll

func (m*MockKeeper) SyncAndCloseAll() error

func (*MockKeeper) With

func (m*MockKeeper) With(namestring) Filer

func (*MockKeeper) WithNew

func (m*MockKeeper) WithNew(namestring, options...any) Filer

type Searcher

typeSearcherinterface {
// PrefixScan must retrieve all keys in the datastore and stream them to the given channel.PrefixScan(prefixstring) (<-chan kv.KeyValue, chanerror)
// Search must be able to search through the value contents of our database and stream the results to the given channel.Search(querystring) (<-chan kv.KeyValue, chanerror)
// ValueExists searches for an exact match of the given value and returns the key that contains it.ValueExists(value []byte) (key []byte, okbool)
}

Searcher must be able to search through our datastore(s) with strings.

type Store

typeStoreinterface {
FilerSearcher
}

Store is an implementation of a Filer and a Searcher.

func ToStore

funcToStore(filerFiler) (Store, error)

func IsStore

funcIsStore(filerFiler) bool