Documentation

Overview

    Package store is an interface for distributed data storage. The design document is located at https://github.com/micro/development/blob/master/design/store.md

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type DeleteOption

    type DeleteOption func(d *DeleteOptions)

      DeleteOption sets values in DeleteOptions

      func DeleteFrom

      func DeleteFrom(database, table string) DeleteOption

        DeleteFrom the database and table

        type DeleteOptions

        type DeleteOptions struct {
        	Database, Table string
        }

          DeleteOptions configures an individual Delete operation

          type ListOption

          type ListOption func(l *ListOptions)

            ListOption sets values in ListOptions

            func ListFrom

            func ListFrom(database, table string) ListOption

              ListFrom the database and table

              func ListLimit

              func ListLimit(l uint) ListOption

                ListLimit limits the number of returned keys to l

                func ListOffset

                func ListOffset(o uint) ListOption

                  ListOffset starts returning responses from o. Use in conjunction with Limit for pagination.

                  func ListPrefix

                  func ListPrefix(p string) ListOption

                    ListPrefix returns all keys that are prefixed with key

                    func ListSuffix

                    func ListSuffix(s string) ListOption

                      ListSuffix returns all keys that end with key

                      type ListOptions

                      type ListOptions struct {
                      	// List from the following
                      	Database, Table string
                      	// Prefix returns all keys that are prefixed with key
                      	Prefix string
                      	// Suffix returns all keys that end with key
                      	Suffix string
                      	// Limit limits the number of returned keys
                      	Limit uint
                      	// Offset when combined with Limit supports pagination
                      	Offset uint
                      }

                        ListOptions configures an individual List operation

                        type Option

                        type Option func(o *Options)

                          Option sets values in Options

                          func Database

                          func Database(db string) Option

                            Database allows multiple isolated stores to be kept in one backend, if supported.

                            func Nodes

                            func Nodes(a ...string) Option

                              Nodes contains the addresses or other connection information of the backing storage. For example, an etcd implementation would contain the nodes of the cluster. A SQL implementation could contain one or more connection strings.

                              func Table

                              func Table(t string) Option

                                Table is analagous to a table in database backends or a key prefix in KV backends

                                func WithClient

                                func WithClient(c client.Client) Option

                                  WithClient sets the stores client to use for RPC

                                  func WithContext

                                  func WithContext(c context.Context) Option

                                    WithContext sets the stores context, for any extra configuration

                                    type Options

                                    type Options struct {
                                    	// Nodes contains the addresses or other connection information of the backing storage.
                                    	// For example, an etcd implementation would contain the nodes of the cluster.
                                    	// A SQL implementation could contain one or more connection strings.
                                    	Nodes []string
                                    	// Database allows multiple isolated stores to be kept in one backend, if supported.
                                    	Database string
                                    	// Table is analagous to a table in database backends or a key prefix in KV backends
                                    	Table string
                                    	// Context should contain all implementation specific options, using context.WithValue.
                                    	Context context.Context
                                    	// Client to use for RPC
                                    	Client client.Client
                                    }

                                      Options contains configuration for the Store

                                      type ReadOption

                                      type ReadOption func(r *ReadOptions)

                                        ReadOption sets values in ReadOptions

                                        func ReadFrom

                                        func ReadFrom(database, table string) ReadOption

                                          ReadFrom the database and table

                                          func ReadLimit

                                          func ReadLimit(l uint) ReadOption

                                            ReadLimit limits the number of responses to l

                                            func ReadOffset

                                            func ReadOffset(o uint) ReadOption

                                              ReadOffset starts returning responses from o. Use in conjunction with Limit for pagination

                                              func ReadPrefix

                                              func ReadPrefix() ReadOption

                                                ReadPrefix returns all records that are prefixed with key

                                                func ReadSuffix

                                                func ReadSuffix() ReadOption

                                                  ReadSuffix returns all records that have the suffix key

                                                  type ReadOptions

                                                  type ReadOptions struct {
                                                  	Database, Table string
                                                  	// Prefix returns all records that are prefixed with key
                                                  	Prefix bool
                                                  	// Suffix returns all records that have the suffix key
                                                  	Suffix bool
                                                  	// Limit limits the number of returned records
                                                  	Limit uint
                                                  	// Offset when combined with Limit supports pagination
                                                  	Offset uint
                                                  }

                                                    ReadOptions configures an individual Read operation

                                                    type Record

                                                    type Record struct {
                                                    	// The key to store the record
                                                    	Key string `json:"key"`
                                                    	// The value within the record
                                                    	Value []byte `json:"value"`
                                                    	// Any associated metadata for indexing
                                                    	Metadata map[string]interface{} `json:"metadata"`
                                                    	// Time to expire a record: TODO: change to timestamp
                                                    	Expiry time.Duration `json:"expiry,omitempty"`
                                                    }

                                                      Record is an item stored or retrieved from a Store

                                                      type Store

                                                      type Store interface {
                                                      	// Init initialises the store. It must perform any required setup on the backing storage implementation and check that it is ready for use, returning any errors.
                                                      	Init(...Option) error
                                                      	// Options allows you to view the current options.
                                                      	Options() Options
                                                      	// Read takes a single key name and optional ReadOptions. It returns matching []*Record or an error.
                                                      	Read(key string, opts ...ReadOption) ([]*Record, error)
                                                      	// Write() writes a record to the store, and returns an error if the record was not written.
                                                      	Write(r *Record, opts ...WriteOption) error
                                                      	// Delete removes the record with the corresponding key from the store.
                                                      	Delete(key string, opts ...DeleteOption) error
                                                      	// List returns any keys that match, or an empty list with no error if none matched.
                                                      	List(opts ...ListOption) ([]string, error)
                                                      	// Close the store
                                                      	Close() error
                                                      	// String returns the name of the implementation.
                                                      	String() string
                                                      }

                                                        Store is a data storage interface

                                                        var (
                                                        	// ErrNotFound is returned when a key doesn't exist
                                                        	ErrNotFound = errors.New("not found")
                                                        	// DefaultStore is the memory store.
                                                        	DefaultStore Store = new(noopStore)
                                                        )

                                                        type WriteOption

                                                        type WriteOption func(w *WriteOptions)

                                                          WriteOption sets values in WriteOptions

                                                          func WriteExpiry

                                                          func WriteExpiry(t time.Time) WriteOption

                                                            WriteExpiry is the time the record expires

                                                            func WriteTTL

                                                            func WriteTTL(d time.Duration) WriteOption

                                                              WriteTTL is the time the record expires

                                                              func WriteTo

                                                              func WriteTo(database, table string) WriteOption

                                                                WriteTo the database and table

                                                                type WriteOptions

                                                                type WriteOptions struct {
                                                                	Database, Table string
                                                                	// Expiry is the time the record expires
                                                                	Expiry time.Time
                                                                	// TTL is the time until the record expires
                                                                	TTL time.Duration
                                                                }

                                                                  WriteOptions configures an individual Write operation If Expiry and TTL are set TTL takes precedence

                                                                  Directories

                                                                  Path Synopsis
                                                                  Package cache implements a faulting style read cache on top of multiple micro stores
                                                                  Package cache implements a faulting style read cache on top of multiple micro stores
                                                                  Package cockroach implements the cockroach store
                                                                  Package cockroach implements the cockroach store
                                                                  Package local is a file system backed store
                                                                  Package local is a file system backed store
                                                                  Package memory is a in-memory store store
                                                                  Package memory is a in-memory store store
                                                                  Package service implements the store service interface
                                                                  Package service implements the store service interface