datastore

package module
v0.6.0 Latest Latest
Warning

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

 Go to latest Published: Aug 17, 2022 License: MIT Imports: 11 Imported by: 1,828

README

go-datastore

standard-readme compliant GoDoc

key-value datastore interfaces

Lead Maintainer

Steven Allen

Table of Contents

Background

Datastore is a generic layer of abstraction for data store and database access. It is a simple API with the aim to enable application development in a datastore-agnostic way, allowing datastores to be swapped seamlessly without changing application code. Thus, one can leverage different datastores with different strengths without committing the application to one datastore throughout its lifetime.

In addition, grouped datastores significantly simplify interesting data access patterns (such as caching and sharding).

Based on datastore.py.

Documentation

https://godoc.org/github.com/ipfs/go-datastore

Contribute

Feel free to join in. All welcome. Open an issue!

This repository falls under the IPFS Code of Conduct.

Want to hack on IPFS?

License

MIT

Documentation

Index

Constants

View Source 
const (
	FeatureNameBatching    = "Batching"
	FeatureNameChecked     = "Checked"
	FeatureNameGC          = "GC"
	FeatureNamePersistent  = "Persistent"
	FeatureNameScrubbed    = "Scrubbed"
	FeatureNameTTL         = "TTL"
	FeatureNameTransaction = "Transaction"
)

Variables

View Source 
var ErrBatchUnsupported = errors.New("this datastore does not support batching")

ErrBatchUnsupported is returned if the by Batch if the Datastore doesn't actually support batching.

View Source 
var ErrNotFound error = &dsError{error: errors.New("datastore: key not found"), isNotFound: true}

ErrNotFound is returned by Get and GetSize when a datastore does not map the given key to a value.

Functions

func DiskUsage 

func DiskUsage(ctx context.Context, d Datastore) (uint64, error)

DiskUsage checks if a Datastore is a PersistentDatastore and returns its DiskUsage(), otherwise returns 0.

func GetBackedHas 

func GetBackedHas(ctx context.Context, ds Read, key Key) (bool, error)

GetBackedHas provides a default Datastore.Has implementation. It exists so Datastore.Has implementations can use it, like so: 

func (*d SomeDatastore) Has(key Key) (exists bool, err error) {
  return GetBackedHas(d, key)
}

func GetBackedSize 

func GetBackedSize(ctx context.Context, ds Read, key Key) (int, error)

GetBackedSize provides a default Datastore.GetSize implementation. It exists so Datastore.GetSize implementations can use it, like so: 

func (*d SomeDatastore) GetSize(key Key) (size int, err error) {
  return GetBackedSize(d, key)
}

func NamespaceType 

func NamespaceType(namespace string) string

NamespaceType is the first component of a namespace. `foo` in `foo:bar`

func NamespaceValue 

func NamespaceValue(namespace string) string

NamespaceValue returns the last component of a namespace. `baz` in `f:b:baz`

Types

type Batch 

type Batch interface {
	Write

	Commit(ctx context.Context) error
}

func NewBasicBatch 

func NewBasicBatch(ds Datastore) Batch

type Batching 

type Batching interface {
	Datastore
	BatchingFeature
}

Batching datastores support deferred, grouped updates to the database. `Batch`es do NOT have transactional semantics: updates to the underlying datastore are not guaranteed to occur in the same iota of time. Similarly, batched updates will not be flushed to the underlying datastore until `Commit` has been called. `Txn`s from a `TxnDatastore` have all the capabilities of a `Batch`, but the reverse is NOT true.

type BatchingFeature added in v0.6.0 

type BatchingFeature interface {
	Batch(ctx context.Context) (Batch, error)
}

type CheckedDatastore 

type CheckedDatastore interface {
	Datastore
	CheckedFeature
}

CheckedDatastore is an interface that should be implemented by datastores which may need checking on-disk data integrity.

type CheckedFeature added in v0.6.0 

type CheckedFeature interface {
	Check(ctx context.Context) error
}

type Datastore 

type Datastore interface {
	Read
	Write
	// Sync guarantees that any Put or Delete calls under prefix that returned
	// before Sync(prefix) was called will be observed after Sync(prefix)
	// returns, even if the program crashes. If Put/Delete operations already
	// satisfy these requirements then Sync may be a no-op.
	//
	// If the prefix fails to Sync this method returns an error.
	Sync(ctx context.Context, prefix Key) error
	io.Closer
}

Datastore represents storage for any key-value pair.

Datastores are general enough to be backed by all kinds of different storage: in-memory caches, databases, a remote datastore, flat files on disk, etc.

The general idea is to wrap a more complicated storage facility in a simple, uniform interface, keeping the freedom of using the right tools for the job. In particular, a Datastore can aggregate other datastores in interesting ways, like sharded (to distribute load) or tiered access (caches before databases).

While Datastores should be written general enough to accept all sorts of values, some implementations will undoubtedly have to be specific (e.g. SQL databases where fields should be decomposed into columns), particularly to support queries efficiently. Moreover, certain datastores may enforce certain types of values (e.g. requiring an io.Reader, a specific struct, etc) or serialization formats (JSON, Protobufs, etc).

IMPORTANT: No Datastore should ever Panic! This is a cross-module interface, and thus it should behave predictably and handle exceptional conditions with proper error reporting. Thus, all Datastore calls may return errors, which should be checked by callers.

type Feature added in v0.6.0 

type Feature struct {
	Name string
	// Interface is the nil interface of the feature.
	Interface interface{}
	// DatastoreInterface is the nil interface of the feature's corresponding datastore interface.
	DatastoreInterface interface{}
}

Feature contains metadata about a datastore Feature.

func FeatureByName added in v0.6.0 

func FeatureByName(name string) (Feature, bool)

FeatureByName returns the feature with the given name, if known.

func Features added in v0.6.0 

func Features() []Feature

Features returns a list of all known datastore features. This serves both to provide an authoritative list of features, and to define a canonical ordering of features.

func FeaturesForDatastore added in v0.6.0 

func FeaturesForDatastore(dstore Datastore) (features []Feature)

FeaturesForDatastore returns the features supported by the given datastore.

type GCDatastore 

type GCDatastore interface {
	Datastore
	GCFeature
}

GCDatastore is an interface that should be implemented by datastores which don't free disk space by just removing data from them.

type GCFeature added in v0.6.0 

type GCFeature interface {
	CollectGarbage(ctx context.Context) error
}

type Key 

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

A Key represents the unique identifier of an object. Our Key scheme is inspired by file systems and Google App Engine key model.

Keys are meant to be unique across a system. Keys are hierarchical, incorporating more and more specific namespaces. Thus keys can be deemed 'children' or 'ancestors' of other keys:: 

Key("/Comedy")
Key("/Comedy/MontyPython")

Also, every namespace can be parametrized to embed relevant object information. For example, the Key `name` (most specific namespace) could include the object type:: 

Key("/Comedy/MontyPython/Actor:JohnCleese")
Key("/Comedy/MontyPython/Sketch:CheeseShop")
Key("/Comedy/MontyPython/Sketch:CheeseShop/Character:Mousebender")

func EntryKeys 

func EntryKeys(e []dsq.Entry) []Key

EntryKeys

func KeyWithNamespaces 

func KeyWithNamespaces(ns []string) Key

KeyWithNamespaces constructs a key out of a namespace slice.

func NewKey 

func NewKey(s string) Key

NewKey constructs a key from string. it will clean the value.

func RandomKey 

func RandomKey() Key

RandomKey returns a randomly (uuid) generated key. 

RandomKey()
NewKey("/f98719ea086343f7b71f32ea9d9d521d")

func RawKey 

func RawKey(s string) Key

RawKey creates a new Key without safety checking the input. Use with care.

func (Key) BaseNamespace 

func (k Key) BaseNamespace() string

BaseNamespace returns the "base" namespace of this key (path.Base(filename)) 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").BaseNamespace()
"Actor:JohnCleese"

func (Key) Bytes 

func (k Key) Bytes() []byte

Bytes returns the string value of Key as a []byte

func (Key) Child 

func (k Key) Child(k2 Key) Key

Child returns the `child` Key of this Key. 

NewKey("/Comedy/MontyPython").Child(NewKey("Actor:JohnCleese"))
NewKey("/Comedy/MontyPython/Actor:JohnCleese")

func (Key) ChildString 

func (k Key) ChildString(s string) Key

ChildString returns the `child` Key of this Key -- string helper. 

NewKey("/Comedy/MontyPython").ChildString("Actor:JohnCleese")
NewKey("/Comedy/MontyPython/Actor:JohnCleese")

func (*Key) Clean 

func (k *Key) Clean()

Clean up a Key, using path.Clean.

func (Key) Equal 

func (k Key) Equal(k2 Key) bool

Equal checks equality of two keys

func (Key) Instance 

func (k Key) Instance(s string) Key

Instance returns an "instance" of this type key (appends value to namespace). 

NewKey("/Comedy/MontyPython/Actor").Instance("JohnClesse")
NewKey("/Comedy/MontyPython/Actor:JohnCleese")

func (Key) IsAncestorOf 

func (k Key) IsAncestorOf(other Key) bool

IsAncestorOf returns whether this key is a prefix of `other` 

NewKey("/Comedy").IsAncestorOf("/Comedy/MontyPython")
true

func (Key) IsDescendantOf 

func (k Key) IsDescendantOf(other Key) bool

IsDescendantOf returns whether this key contains another as a prefix. 

NewKey("/Comedy/MontyPython").IsDescendantOf("/Comedy")
true

func (Key) IsTopLevel 

func (k Key) IsTopLevel() bool

IsTopLevel returns whether this key has only one namespace.

func (Key) Less 

func (k Key) Less(k2 Key) bool

Less checks whether this key is sorted lower than another.

func (Key) List 

func (k Key) List() []string

List returns the `list` representation of this Key. 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").List()
["Comedy", "MontyPythong", "Actor:JohnCleese"]

func (Key) MarshalJSON 

func (k Key) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface, keys are represented as JSON strings

func (Key) Name 

func (k Key) Name() string

Name returns the "name" of this key (field of last namespace). 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").Name()
"JohnCleese"

func (Key) Namespaces 

func (k Key) Namespaces() []string

Namespaces returns the `namespaces` making up this Key. 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").Namespaces()
["Comedy", "MontyPython", "Actor:JohnCleese"]

func (Key) Parent 

func (k Key) Parent() Key

Parent returns the `parent` Key of this Key. 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").Parent()
NewKey("/Comedy/MontyPython")

func (Key) Path 

func (k Key) Path() Key

Path returns the "path" of this key (parent + type). 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").Path()
NewKey("/Comedy/MontyPython/Actor")

func (Key) Reverse 

func (k Key) Reverse() Key

Reverse returns the reverse of this Key. 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").Reverse()
NewKey("/Actor:JohnCleese/MontyPython/Comedy")

func (Key) String 

func (k Key) String() string

Strings is the string value of Key

func (Key) Type 

func (k Key) Type() string

Type returns the "type" of this key (value of last namespace). 

NewKey("/Comedy/MontyPython/Actor:JohnCleese").Type()
"Actor"

func (*Key) UnmarshalJSON 

func (k *Key) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface, keys will parse any value specified as a key to a string

type KeySlice 

type KeySlice []Key

KeySlice attaches the methods of sort.Interface to []Key, sorting in increasing order.

func (KeySlice) Len 

func (p KeySlice) Len() int

func (KeySlice) Less 

func (p KeySlice) Less(i, j int) bool

func (KeySlice) Swap 

func (p KeySlice) Swap(i, j int)

type LogBatch 

type LogBatch struct {
	Name string
	// contains filtered or unexported fields
}

LogBatch logs all accesses through the batch.

func (*LogBatch) Commit 

func (d *LogBatch) Commit(ctx context.Context) (err error)

Commit implements Batch.Commit

func (*LogBatch) Delete 

func (d *LogBatch) Delete(ctx context.Context, key Key) (err error)

Delete implements Batch.Delete

func (*LogBatch) Put 

func (d *LogBatch) Put(ctx context.Context, key Key, value []byte) (err error)

Put implements Batch.Put

type LogDatastore 

type LogDatastore struct {
	Name string
	// contains filtered or unexported fields
}

LogDatastore logs all accesses through the datastore.

func NewLogDatastore 

func NewLogDatastore(ds Datastore, name string) *LogDatastore

NewLogDatastore constructs a log datastore.

func (*LogDatastore) Batch 

func (d *LogDatastore) Batch(ctx context.Context) (Batch, error)

func (*LogDatastore) Check 

func (d *LogDatastore) Check(ctx context.Context) error

func (*LogDatastore) Children 

func (d *LogDatastore) Children() []Datastore

Children implements Shim

func (*LogDatastore) Close 

func (d *LogDatastore) Close() error

func (*LogDatastore) CollectGarbage 

func (d *LogDatastore) CollectGarbage(ctx context.Context) error

func (*LogDatastore) Delete 

func (d *LogDatastore) Delete(ctx context.Context, key Key) (err error)

Delete implements Datastore.Delete

func (*LogDatastore) DiskUsage 

func (d *LogDatastore) DiskUsage(ctx context.Context) (uint64, error)

DiskUsage implements the PersistentDatastore interface.

func (*LogDatastore) Get 

func (d *LogDatastore) Get(ctx context.Context, key Key) (value []byte, err error)

Get implements Datastore.Get

func (*LogDatastore) GetSize 

func (d *LogDatastore) GetSize(ctx context.Context, key Key) (size int, err error)

GetSize implements Datastore.GetSize

func (*LogDatastore) Has 

func (d *LogDatastore) Has(ctx context.Context, key Key) (exists bool, err error)

Has implements Datastore.Has

func (*LogDatastore) Put 

func (d *LogDatastore) Put(ctx context.Context, key Key, value []byte) (err error)

Put implements Datastore.Put

func (*LogDatastore) Query 

func (d *LogDatastore) Query(ctx context.Context, q dsq.Query) (dsq.Results, error)

Query implements Datastore.Query

func (*LogDatastore) Scrub 

func (d *LogDatastore) Scrub(ctx context.Context) error

func (*LogDatastore) Sync added in v0.3.1 

func (d *LogDatastore) Sync(ctx context.Context, prefix Key) error

Sync implements Datastore.Sync

type MapDatastore 

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

MapDatastore uses a standard Go map for internal storage.

func NewMapDatastore 

func NewMapDatastore() (d *MapDatastore)

NewMapDatastore constructs a MapDatastore. It is _not_ thread-safe by default, wrap using sync.MutexWrap if you need thread safety (the answer here is usually yes).

func (*MapDatastore) Batch 

func (d *MapDatastore) Batch(ctx context.Context) (Batch, error)

func (*MapDatastore) Close 

func (d *MapDatastore) Close() error

func (*MapDatastore) Delete 

func (d *MapDatastore) Delete(ctx context.Context, key Key) (err error)

Delete implements Datastore.Delete

func (*MapDatastore) Get 

func (d *MapDatastore) Get(ctx context.Context, key Key) (value []byte, err error)

Get implements Datastore.Get

func (*MapDatastore) GetSize 

func (d *MapDatastore) GetSize(ctx context.Context, key Key) (size int, err error)

GetSize implements Datastore.GetSize

func (*MapDatastore) Has 

func (d *MapDatastore) Has(ctx context.Context, key Key) (exists bool, err error)

Has implements Datastore.Has

func (*MapDatastore) Put 

func (d *MapDatastore) Put(ctx context.Context, key Key, value []byte) (err error)

Put implements Datastore.Put

func (*MapDatastore) Query 

func (d *MapDatastore) Query(ctx context.Context, q dsq.Query) (dsq.Results, error)

Query implements Datastore.Query

func (*MapDatastore) Sync added in v0.3.0 

func (d *MapDatastore) Sync(ctx context.Context, prefix Key) error

Sync implements Datastore.Sync

type NullDatastore 

type NullDatastore struct {
}

NullDatastore stores nothing, but conforms to the API. Useful to test with.

func NewNullDatastore 

func NewNullDatastore() *NullDatastore

NewNullDatastore constructs a null datastoe

func (*NullDatastore) Batch 

func (d *NullDatastore) Batch(ctx context.Context) (Batch, error)

func (*NullDatastore) Check added in v0.6.0 

func (d *NullDatastore) Check(ctx context.Context) error

func (*NullDatastore) Close 

func (d *NullDatastore) Close() error

func (*NullDatastore) CollectGarbage added in v0.6.0 

func (d *NullDatastore) CollectGarbage(ctx context.Context) error

func (*NullDatastore) Delete 

func (d *NullDatastore) Delete(ctx context.Context, key Key) (err error)

Delete implements Datastore.Delete

func (*NullDatastore) DiskUsage added in v0.6.0 

func (d *NullDatastore) DiskUsage(ctx context.Context) (uint64, error)

func (*NullDatastore) Get 

func (d *NullDatastore) Get(ctx context.Context, key Key) (value []byte, err error)

Get implements Datastore.Get

func (*NullDatastore) GetSize 

func (d *NullDatastore) GetSize(ctx context.Context, key Key) (size int, err error)

Has implements Datastore.GetSize

func (*NullDatastore) Has 

func (d *NullDatastore) Has(ctx context.Context, key Key) (exists bool, err error)

Has implements Datastore.Has

func (*NullDatastore) NewTransaction added in v0.6.0 

func (d *NullDatastore) NewTransaction(ctx context.Context, readOnly bool) (Txn, error)

func (*NullDatastore) Put 

func (d *NullDatastore) Put(ctx context.Context, key Key, value []byte) (err error)

Put implements Datastore.Put

func (*NullDatastore) Query 

func (d *NullDatastore) Query(ctx context.Context, q dsq.Query) (dsq.Results, error)

Query implements Datastore.Query

func (*NullDatastore) Scrub added in v0.6.0 

func (d *NullDatastore) Scrub(ctx context.Context) error

func (*NullDatastore) Sync added in v0.3.0 

func (d *NullDatastore) Sync(ctx context.Context, prefix Key) error

Sync implements Datastore.Sync

type PersistentDatastore 

type PersistentDatastore interface {
	Datastore
	PersistentFeature
}

PersistentDatastore is an interface that should be implemented by datastores which can report disk usage.

type PersistentFeature added in v0.6.0 

type PersistentFeature interface {
	// DiskUsage returns the space used by a datastore, in bytes.
	DiskUsage(ctx context.Context) (uint64, error)
}

type Read 

type Read interface {
	// Get retrieves the object `value` named by `key`.
	// Get will return ErrNotFound if the key is not mapped to a value.
	Get(ctx context.Context, key Key) (value []byte, err error)

	// Has returns whether the `key` is mapped to a `value`.
	// In some contexts, it may be much cheaper only to check for existence of
	// a value, rather than retrieving the value itself. (e.g. HTTP HEAD).
	// The default implementation is found in `GetBackedHas`.
	Has(ctx context.Context, key Key) (exists bool, err error)

	// GetSize returns the size of the `value` named by `key`.
	// In some contexts, it may be much cheaper to only get the size of the
	// value rather than retrieving the value itself.
	GetSize(ctx context.Context, key Key) (size int, err error)

	// Query searches the datastore and returns a query result. This function
	// may return before the query actually runs. To wait for the query:
	//
	//   result, _ := ds.Query(q)
	//
	//   // use the channel interface; result may come in at different times
	//   for entry := range result.Next() { ... }
	//
	//   // or wait for the query to be completely done
	//   entries, _ := result.Rest()
	//   for entry := range entries { ... }
	//
	Query(ctx context.Context, q query.Query) (query.Results, error)
}

Read is the read-side of the Datastore interface.

type ScrubbedDatastore 

type ScrubbedDatastore interface {
	Datastore
	ScrubbedFeature
}

ScrubbedDatastore is an interface that should be implemented by datastores which want to provide a mechanism to check data integrity and/or error correction.

type ScrubbedFeature added in v0.6.0 

type ScrubbedFeature interface {
	Scrub(ctx context.Context) error
}

type Shim 

type Shim interface {
	Datastore

	Children() []Datastore
}

Shim is a datastore which has a child.

type TTL 

type TTL interface {
	PutWithTTL(ctx context.Context, key Key, value []byte, ttl time.Duration) error
	SetTTL(ctx context.Context, key Key, ttl time.Duration) error
	GetExpiration(ctx context.Context, key Key) (time.Time, error)
}

TTL encapulates the methods that deal with entries with time-to-live.

type TTLDatastore 

type TTLDatastore interface {
	Datastore
	TTL
}

TTLDatastore is an interface that should be implemented by datastores that support expiring entries.

type Txn 

type Txn interface {
	Read
	Write

	// Commit finalizes a transaction, attempting to commit it to the Datastore.
	// May return an error if the transaction has gone stale. The presence of an
	// error is an indication that the data was not committed to the Datastore.
	Commit(ctx context.Context) error
	// Discard throws away changes recorded in a transaction without committing
	// them to the underlying Datastore. Any calls made to Discard after Commit
	// has been successfully called will have no effect on the transaction and
	// state of the Datastore, making it safe to defer.
	Discard(ctx context.Context)
}

Txn extends the Datastore type. Txns allow users to batch queries and mutations to the Datastore into atomic groups, or transactions. Actions performed on a transaction will not take hold until a successful call to Commit has been made. Likewise, transactions can be aborted by calling Discard before a successful Commit has been made.

type TxnDatastore 

type TxnDatastore interface {
	Datastore
	TxnFeature
}

TxnDatastore is an interface that should be implemented by datastores that support transactions.

type TxnFeature added in v0.6.0 

type TxnFeature interface {
	NewTransaction(ctx context.Context, readOnly bool) (Txn, error)
}

type Write 

type Write interface {
	// Put stores the object `value` named by `key`.
	//
	// The generalized Datastore interface does not impose a value type,
	// allowing various datastore middleware implementations (which do not
	// handle the values directly) to be composed together.
	//
	// Ultimately, the lowest-level datastore will need to do some value checking
	// or risk getting incorrect values. It may also be useful to expose a more
	// type-safe interface to your application, and do the checking up-front.
	Put(ctx context.Context, key Key, value []byte) error

	// Delete removes the value for given `key`. If the key is not in the
	// datastore, this method returns no error.
	Delete(ctx context.Context, key Key) error
}

Write is the write-side of the Datastore interface.

Source Files

View all Source files

Directories

Path Synopsis
Package autobatch provides a go-datastore implementation that automatically batches together writes by holding puts in memory until a certain threshold is met.
 Package autobatch provides a go-datastore implementation that automatically batches together writes by holding puts in memory until a certain threshold is met.
Package delayed wraps a datastore allowing to artificially delay all operations.
 Package delayed wraps a datastore allowing to artificially delay all operations.
Package fs is a simple Datastore implementation that stores keys as directories and files, mirroring the key.
 Package fs is a simple Datastore implementation that stores keys as directories and files, mirroring the key.
Package failstore implements a datastore which can produce custom failures on operations by calling a user-provided error function.
 Package failstore implements a datastore which can produce custom failures on operations by calling a user-provided error function.
fuzz module
Package keytransform introduces a Datastore Shim that transforms keys before passing them to its child.
 Package keytransform introduces a Datastore Shim that transforms keys before passing them to its child.
Package mount provides a Datastore that has other Datastores mounted at various key prefixes and is threadsafe
 Package mount provides a Datastore that has other Datastores mounted at various key prefixes and is threadsafe
Package namespace introduces a namespace Datastore Shim, which basically mounts the entire child datastore under a prefix.
 Package namespace introduces a namespace Datastore Shim, which basically mounts the entire child datastore under a prefix.
Package retrystore provides a datastore wrapper which allows to retry operations.
 Package retrystore provides a datastore wrapper which allows to retry operations.

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.