graph

package
v0.8.1 Latest Latest
Warning

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

 Go to latest Published: May 23, 2023 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrDatabaseExists = errors.New("quadstore: cannot init; database already exists")
	ErrNotInitialized = errors.New("quadstore: not initialized")
)
View Source 
var (
	ErrQuadExists    = errors.New("quad exists")
	ErrQuadNotExist  = errors.New("quad does not exist")
	ErrInvalidAction = errors.New("invalid action")
	ErrNodeNotExists = errors.New("node does not exist")
)
View Source 
var (
	// IgnoreDuplicates specifies whether duplicate quads
	// cause an error during loading or are ignored.
	IgnoreDuplicates = true

	// IgnoreMissing specifies whether missing quads
	// cause an error during deletion or are ignored.
	IgnoreMissing = false
)
View Source 
var (
	ErrQuadStoreNotRegistred  = fmt.Errorf("this QuadStore is not registered")
	ErrQuadStoreNotPersistent = fmt.Errorf("cannot specify address for non-persistent backend")
	ErrOperationNotSupported  = fmt.Errorf("this Operation is not supported")
)

Functions

func InitQuadStore 

func InitQuadStore(name string, dbpath string, opts Options) error

func IsInvalidAction 

func IsInvalidAction(err error) bool

IsInvalidAction returns whether an error is a DeltaError with the Err field equal to ErrInvalidAction.

func IsPersistent 

func IsPersistent(name string) bool

func IsQuadExist 

func IsQuadExist(err error) bool

IsQuadExist returns whether an error is a DeltaError with the Err field equal to ErrQuadExists.

func IsQuadNotExist 

func IsQuadNotExist(err error) bool

IsQuadNotExist returns whether an error is a DeltaError with the Err field equal to ErrQuadNotExist.

func IsRegistered 

func IsRegistered(name string) bool

func NewQuadStoreReader 

func NewQuadStoreReader(qs QuadStore) quad.ReadSkipCloser

NewQuadStoreReader creates a quad reader for a given QuadStore.

func NewResultReader 

func NewResultReader(qs QuadStore, it iterator.Scanner) quad.ReadSkipCloser

NewResultReader creates a quad reader for a given QuadStore and iterator. If iterator is nil QuadsAllIterator will be used.

Only quads returned by iterator's Result will be used.

Iterator will be closed with the reader.

func NewTxWriter 

func NewTxWriter(tx *Transaction, p Procedure) quad.Writer

NewTxWriter creates a writer that applies a given procedures for all quads in stream. If procedure is zero, Add operation will be used.

func QuadStores 

func QuadStores() []string

func RegisterQuadStore 

func RegisterQuadStore(name string, register QuadStoreRegistration)

func RegisterWriter 

func RegisterWriter(name string, newFunc NewQuadWriterFunc)

func UpgradeQuadStore 

func UpgradeQuadStore(name string, dbpath string, opts Options) error

func ValuesOf 

func ValuesOf(ctx context.Context, qs refs.Namer, vals []Ref) ([]quad.Value, error)

func WriterMethods 

func WriterMethods() []string

Types

type BatchWriter 

type BatchWriter interface {
	quad.WriteCloser
	Flush() error
}

func NewRemover 

func NewRemover(qs QuadWriter) BatchWriter

NewRemover creates a quad writer for a given QuadStore which removes quads instead of adding them.

func NewWriter 

func NewWriter(qs QuadWriter) BatchWriter

NewWriter creates a quad writer for a given QuadStore.

Caller must call Flush or Close to flush an internal buffer.

type Delta 

type Delta struct {
	Quad   quad.Quad
	Action Procedure
}

type DeltaError 

type DeltaError struct {
	Delta Delta
	Err   error
}

DeltaError records an error and the delta that caused it.

func (*DeltaError) Error 

func (e *DeltaError) Error() string

type Handle 

type Handle struct {
	QuadStore
	QuadWriter
}

func (*Handle) Close 

func (h *Handle) Close() error

type HasA 

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

A HasA consists of a reference back to the graph.QuadStore that it references, a primary subiterator, a direction in which the quads for that subiterator point, and a temporary holder for the iterator generated on Contains().

func NewHasA 

func NewHasA(qs QuadIndexer, subIt iterator.Shape, d quad.Direction) *HasA

NewHasA construct a new HasA iterator, given the quad subiterator, and the quad direction for which it stands.

func (*HasA) Direction 

func (it *HasA) Direction() quad.Direction

Direction accessor.

func (*HasA) Iterate 

func (it *HasA) Iterate() iterator.Scanner

func (*HasA) Lookup 

func (it *HasA) Lookup() iterator.Index

func (*HasA) Optimize 

func (it *HasA) Optimize(ctx context.Context) (iterator.Shape, bool)

Optimize pass the Optimize() call along to the subiterator. If it becomes Null, then the HasA becomes Null (there are no quads that have any directions).

func (*HasA) Stats 

func (it *HasA) Stats(ctx context.Context) (iterator.Costs, error)

Stats returns the statistics on the HasA iterator. This is curious. Next cost is easy, it's an extra call or so on top of the subiterator Next cost. ContainsCost involves going to the graph.QuadStore, iterating out values, and hoping one sticks -- potentially expensive, depending on fanout. Size, however, is potentially smaller. we know at worst it's the size of the subiterator, but if there are many repeated values, it could be much smaller in totality.

func (*HasA) String 

func (it *HasA) String() string

func (*HasA) SubIterators 

func (it *HasA) SubIterators() []iterator.Shape

SubIterators returns our sole subiterator.

type IgnoreOpts 

type IgnoreOpts struct {
	IgnoreDup, IgnoreMissing bool
}

type InitStoreFunc 

type InitStoreFunc func(string, Options) error

type LinksTo 

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

A LinksTo has a reference back to the graph.QuadStore (to create the iterators for each node) the subiterator, and the direction the iterator comes from. `next_it` is the tempoarary iterator held per result in `primary_it`.

func NewLinksTo 

func NewLinksTo(qs QuadIndexer, it iterator.Shape, d quad.Direction) *LinksTo

NewLinksTo construct a new LinksTo iterator around a direction and a subiterator of nodes.

func (*LinksTo) Direction 

func (it *LinksTo) Direction() quad.Direction

Direction returns the direction under consideration.

func (*LinksTo) Iterate 

func (it *LinksTo) Iterate() iterator.Scanner

func (*LinksTo) Lookup 

func (it *LinksTo) Lookup() iterator.Index

func (*LinksTo) Optimize 

func (it *LinksTo) Optimize(ctx context.Context) (iterator.Shape, bool)

Optimize the LinksTo, by replacing it if it can be.

func (*LinksTo) Stats 

func (it *LinksTo) Stats(ctx context.Context) (iterator.Costs, error)

Stats returns a guess as to how big or costly it is to next the iterator.

func (*LinksTo) String 

func (it *LinksTo) String() string

func (*LinksTo) SubIterators 

func (it *LinksTo) SubIterators() []iterator.Shape

SubIterators returns a list containing only our subiterator.

type NewQuadWriterFunc 

type NewQuadWriterFunc func(QuadStore, Options) (QuadWriter, error)

type NewStoreFunc 

type NewStoreFunc func(string, Options) (QuadStore, error)

type Options 

type Options map[string]interface{}

func (Options) BoolKey 

func (d Options) BoolKey(key string, def bool) (bool, error)

func (Options) IntKey 

func (d Options) IntKey(key string, def int) (int, error)

func (Options) StringKey 

func (d Options) StringKey(key string, def string) (string, error)

type Procedure 

type Procedure int8
const (
	Add    Procedure = +1
	Delete Procedure = -1
)

The different types of actions a transaction can do.

func (Procedure) String 

func (p Procedure) String() string

type QuadIndexer 

type QuadIndexer interface {
	// Given an opaque token, returns the quad for that token from the store.
	Quad(Ref) (quad.Quad, error)

	// Given a direction and a token, creates an iterator of links which have
	// that node token in that directional field.
	QuadIterator(quad.Direction, Ref) iterator.Shape

	// QuadIteratorSize returns an estimated size of an iterator.
	QuadIteratorSize(ctx context.Context, d quad.Direction, v Ref) (refs.Size, error)

	// Convenience function for speed. Given a quad token and a direction
	// return the node token for that direction. Sometimes, a QuadStore
	// can do this without going all the way to the backing store, and
	// gives the QuadStore the opportunity to make this optimization.
	//
	// Iterators will call this. At worst, a valid implementation is
	//
	//  qs.ValueOf(qs.Quad(id).Get(dir))
	//
	QuadDirection(id Ref, d quad.Direction) (Ref, error)

	// Stats returns the number of nodes and quads currently stored.
	// Exact flag controls the correctness of the value. It can be an estimation, or a precise calculation.
	// The quadstore may have a fast way of retrieving the precise stats, in this case it may ignore 'exact'
	// flag and always return correct stats (with an appropriate flags set in the output).
	Stats(ctx context.Context, exact bool) (Stats, error)
}

type QuadStore 

type QuadStore interface {
	refs.Namer
	QuadIndexer

	// The only way in is through building a transaction, which
	// is done by a replication strategy.
	ApplyDeltas(in []Delta, opts IgnoreOpts) error

	// NewQuadWriter starts a batch quad import process.
	// The order of changes is not guaranteed, neither is the order and result of concurrent ApplyDeltas.
	NewQuadWriter() (quad.WriteCloser, error)

	// Returns an iterator enumerating all nodes in the graph.
	NodesAllIterator() iterator.Shape

	// Returns an iterator enumerating all links in the graph.
	QuadsAllIterator() iterator.Shape

	// Close the quad store and clean up. (Flush to disk, cleanly
	// sever connections, etc)
	Close() error
}

func NewQuadStore 

func NewQuadStore(name string, dbpath string, opts Options) (QuadStore, error)

func Unwrap 

func Unwrap(qs QuadStore) QuadStore

Unwrap returns an original QuadStore value if it was wrapped by Handle. This prevents shadowing of optional interface implementations.

type QuadStoreRegistration 

type QuadStoreRegistration struct {
	NewFunc      NewStoreFunc
	UpgradeFunc  UpgradeStoreFunc
	InitFunc     InitStoreFunc
	IsPersistent bool
}

type QuadWriter 

type QuadWriter interface {
	// AddQuad adds a quad to the store.
	AddQuad(quad.Quad) error

	// TODO(barakmich): Deprecate in favor of transaction.
	// AddQuadSet adds a set of quads to the store, atomically if possible.
	AddQuadSet([]quad.Quad) error

	// RemoveQuad removes a quad matching the given one  from the database,
	// if it exists. Does nothing otherwise.
	RemoveQuad(quad.Quad) error

	// ApplyTransaction applies a set of quad changes.
	ApplyTransaction(*Transaction) error

	// RemoveNode removes all quads which have the given node as subject, predicate, object, or label.
	//
	// It returns ErrNodeNotExists if node is missing.
	RemoveNode(quad.Value) error

	// Close cleans up replication and closes the writing aspect of the database.
	Close() error
}

func NewQuadWriter 

func NewQuadWriter(name string, qs QuadStore, opts Options) (QuadWriter, error)

type Ref 

type Ref = refs.Ref

Ref defines an opaque "quad store reference" type. However the backend wishes to implement it, a Ref is merely a token to a quad or a node that the backing store itself understands, and the base iterators pass around.

For example, in a very traditional, graphd-style graph, these are int64s (guids of the primitives). In a very direct sort of graph, these could be pointers to structs, or merely quads, or whatever works best for the backing store.

These must be comparable, or return a comparable version on Key.

func RefsOf 

func RefsOf(ctx context.Context, qs refs.Namer, nodes []quad.Value) ([]Ref, error)

type Stats 

type Stats struct {
	Nodes refs.Size // number of nodes
	Quads refs.Size // number of quads
}

Stats of a graph.

type Transaction 

type Transaction struct {
	// Deltas stores the deltas in the right order
	Deltas []Delta
	// contains filtered or unexported fields
}

Transaction stores a bunch of Deltas to apply together in an atomic step on the database.

func NewTransaction 

func NewTransaction() *Transaction

NewTransaction initialize a new transaction.

func NewTransactionN 

func NewTransactionN(n int) *Transaction

NewTransactionN initialize a new transaction with a predefined capacity.

func (*Transaction) AddQuad 

func (t *Transaction) AddQuad(q quad.Quad)

AddQuad adds a new quad to the transaction if it is not already present in it. If there is a 'remove' delta for that quad, it will remove that delta from the transaction instead of actually adding the quad.

func (*Transaction) RemoveQuad 

func (t *Transaction) RemoveQuad(q quad.Quad)

RemoveQuad adds a quad to remove to the transaction. The quad will be removed from the database if it is not present in the transaction, otherwise it simply remove it from the transaction.

type UpgradeStoreFunc 

type UpgradeStoreFunc func(string, Options) error

Source Files

View all Source files

Directories

Path Synopsis
testutil
kv
all
badger
bolt
btree
kvtest
leveldb
Package b implements a B+tree.
 Package b implements a B+tree.
all
elastic
mongo
nosqltest
ouch
Package proto is a generated protocol buffer package.
 Package proto is a generated protocol buffer package.
sql
cockroach
mysql
postgres
sqlite
sqltest

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.