bleve: github.com/blevesearch/bleve/index/store Index | Files | Directories

package store

import "github.com/blevesearch/bleve/index/store"

Index

Package Files

batch.go kvstore.go merge.go multiget.go

func MultiGet Uses

func MultiGet(kvreader KVReader, keys [][]byte) ([][]byte, error)

MultiGet is a helper function to retrieve mutiple keys from a KVReader, and might be used by KVStore implementations that don't have a native multi-get facility.

type EmulatedBatch Uses

type EmulatedBatch struct {
    Ops    []*op
    Merger *EmulatedMerge
}

func NewEmulatedBatch Uses

func NewEmulatedBatch(mo MergeOperator) *EmulatedBatch

func (*EmulatedBatch) Close Uses

func (b *EmulatedBatch) Close() error

func (*EmulatedBatch) Delete Uses

func (b *EmulatedBatch) Delete(key []byte)

func (*EmulatedBatch) Merge Uses

func (b *EmulatedBatch) Merge(key, val []byte)

func (*EmulatedBatch) Reset Uses

func (b *EmulatedBatch) Reset()

func (*EmulatedBatch) Set Uses

func (b *EmulatedBatch) Set(key, val []byte)

type EmulatedMerge Uses

type EmulatedMerge struct {
    Merges map[string][][]byte
    // contains filtered or unexported fields
}

func NewEmulatedMerge Uses

func NewEmulatedMerge(mo MergeOperator) *EmulatedMerge

func (*EmulatedMerge) Merge Uses

func (m *EmulatedMerge) Merge(key, val []byte)

type KVBatch Uses

type KVBatch interface {

    // Set updates the key with the specified value
    // both key and value []byte may be reused as soon as this call returns
    Set(key, val []byte)

    // Delete removes the specified key
    // the key []byte may be reused as soon as this call returns
    Delete(key []byte)

    // Merge merges old value with the new value at the specified key
    // as prescribed by the KVStores merge operator
    // both key and value []byte may be reused as soon as this call returns
    Merge(key, val []byte)

    // Reset frees resources for this batch and allows reuse
    Reset()

    // Close frees resources
    Close() error
}

KVBatch is an abstraction for making multiple KV mutations at once

type KVBatchOptions Uses

type KVBatchOptions struct {
    // TotalBytes is the sum of key and value bytes needed by the
    // caller for the entire batch.  It affects the size of the
    // returned byte array of KVWrite.NewBatchEx().
    TotalBytes int

    // NumSets is the number of Set() calls the caller will invoke on
    // the KVBatch.
    NumSets int

    // NumDeletes is the number of Delete() calls the caller will invoke
    // on the KVBatch.
    NumDeletes int

    // NumMerges is the number of Merge() calls the caller will invoke
    // on the KVBatch.
    NumMerges int
}

KVBatchOptions provides the KVWriter.NewBatchEx() method with batch preparation and preallocation information.

type KVIterator Uses

type KVIterator interface {

    // Seek will advance the iterator to the specified key
    Seek(key []byte)

    // Next will advance the iterator to the next key
    Next()

    // Key returns the key pointed to by the iterator
    // The bytes returned are **ONLY** valid until the next call to Seek/Next/Close
    // Continued use after that requires that they be copied.
    Key() []byte

    // Value returns the value pointed to by the iterator
    // The bytes returned are **ONLY** valid until the next call to Seek/Next/Close
    // Continued use after that requires that they be copied.
    Value() []byte

    // Valid returns whether or not the iterator is in a valid state
    Valid() bool

    // Current returns Key(),Value(),Valid() in a single operation
    Current() ([]byte, []byte, bool)

    // Close closes the iterator
    Close() error
}

KVIterator is an abstraction around key iteration

type KVReader Uses

type KVReader interface {

    // Get returns the value associated with the key
    // If the key does not exist, nil is returned.
    // The caller owns the bytes returned.
    Get(key []byte) ([]byte, error)

    // MultiGet retrieves multiple values in one call.
    MultiGet(keys [][]byte) ([][]byte, error)

    // PrefixIterator returns a KVIterator that will
    // visit all K/V pairs with the provided prefix
    PrefixIterator(prefix []byte) KVIterator

    // RangeIterator returns a KVIterator that will
    // visit all K/V pairs >= start AND < end
    RangeIterator(start, end []byte) KVIterator

    // Close closes the iterator
    Close() error
}

KVReader is an abstraction of an **ISOLATED** reader In this context isolated is defined to mean that writes/deletes made after the KVReader is opened are not observed. Because there is usually a cost associated with keeping isolated readers active, users should close them as soon as they are no longer needed.

type KVStore Uses

type KVStore interface {

    // Writer returns a KVWriter which can be used to
    // make changes to the KVStore.  If a writer cannot
    // be obtained a non-nil error is returned.
    Writer() (KVWriter, error)

    // Reader returns a KVReader which can be used to
    // read data from the KVStore.  If a reader cannot
    // be obtained a non-nil error is returned.
    Reader() (KVReader, error)

    // Close closes the KVStore
    Close() error
}

KVStore is an abstraction for working with KV stores. Note that in order to be used with the bleve.registry, it must also implement a constructor function of the registry.KVStoreConstructor type.

type KVStoreStats Uses

type KVStoreStats interface {
    // Stats returns a JSON serializable object representing stats for this KVStore
    Stats() json.Marshaler

    StatsMap() map[string]interface{}
}

KVStoreStats is an optional interface that KVStores can implement if they're able to report any useful stats

type KVWriter Uses

type KVWriter interface {

    // NewBatch returns a KVBatch for performing batch operations on this kvstore
    NewBatch() KVBatch

    // NewBatchEx returns a KVBatch and an associated byte array
    // that's pre-sized based on the KVBatchOptions.  The caller can
    // use the returned byte array for keys and values associated with
    // the batch.  Once the batch is either executed or closed, the
    // associated byte array should no longer be accessed by the
    // caller.
    NewBatchEx(KVBatchOptions) ([]byte, KVBatch, error)

    // ExecuteBatch will execute the KVBatch, the provided KVBatch **MUST** have
    // been created by the same KVStore (though not necessarily the same KVWriter)
    // Batch execution is atomic, either all the operations or none will be performed
    ExecuteBatch(batch KVBatch) error

    // Close closes the writer
    Close() error
}

KVWriter is an abstraction for mutating the KVStore KVWriter does **NOT** enforce restrictions of a single writer if the underlying KVStore allows concurrent writes, the KVWriter interface should also do so, it is up to the caller to do this in a way that is safe and makes sense

type MergeOperator Uses

type MergeOperator interface {

    // FullMerge the full sequence of operands on top of the existingValue
    // if no value currently exists, existingValue is nil
    // return the merged value, and success/failure
    FullMerge(key, existingValue []byte, operands [][]byte) ([]byte, bool)

    // Partially merge these two operands.
    // If partial merge cannot be done, return nil,false, which will defer
    // all processing until the FullMerge is done.
    PartialMerge(key, leftOperand, rightOperand []byte) ([]byte, bool)

    // Name returns an identifier for the operator
    Name() string
}

Directories

PathSynopsis
boltdbPackage boltdb implements a store.KVStore on top of BoltDB.
goleveldb
gtreapPackage gtreap provides an in-memory implementation of the KVStore interfaces using the gtreap balanced-binary treap, copy-on-write data structure.
metricsPackage metrics provides a bleve.store.KVStore implementation that wraps another, real KVStore implementation, and uses go-metrics to track runtime performance metrics.
moss
null
test

Package store imports 1 packages (graph) and is imported by 245 packages. Updated 2017-06-10. Refresh now. Tools for package owners.