shape

type AllNodes ¶

type AllNodes struct{}

AllNodes represents all nodes in QuadStore.

func (s AllNodes) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s AllNodes) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Comparison ¶

type Comparison struct {
	Op  iterator.Operator
	Val quad.Value
}

Comparison is a value filter that evaluates binary operation in reference to a fixed value.

func (f Comparison) BuildIterator(qs graph.QuadStore, it iterator.Shape) iterator.Shape

type Composite ¶

type Composite interface {
	Simplify() Shape
}

Composite shape can be simplified to a tree of more basic shapes.

type Count ¶

type Count struct {
	Values Shape
}

Count returns a count of objects in source as a single value. It always returns exactly one value.

func (s Count) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Count) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Except ¶

type Except struct {
	Exclude Shape // nodes to exclude
	From    Shape // a set of all nodes to exclude from; nil means AllNodes
}

Except excludes a set on nodes from a source. If source is nil, AllNodes is assumed.

func (s Except) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Except) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Filter ¶

type Filter struct {
	From    Shape         // source that will be filtered
	Filters []ValueFilter // filters to apply
}

Filter filters all values from the source using a list of operations.

func (s Filter) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Filter) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Fixed ¶

type Fixed []refs.Ref

Fixed is a static set of nodes. Defined only for a particular QuadStore.

func (s *Fixed) Add(v ...refs.Ref)

func (s Fixed) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Fixed) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type FixedTags ¶

type FixedTags struct {
	Tags map[string]refs.Ref
	On   Shape
}

FixedTags adds a set of fixed tag values to query results. It does not affect query execution in any other way.

Shape implementations should try to push these objects up the tree during optimization process.

func (s FixedTags) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s FixedTags) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type InternalQuad ¶

type InternalQuad struct {
	Subject   refs.Ref
	Predicate refs.Ref
	Object    refs.Ref
	Label     refs.Ref
}

InternalQuad is an internal representation of quad index in QuadStore.

func (q InternalQuad) Get(d quad.Direction) refs.Ref

func (q *InternalQuad) Set(d quad.Direction, v refs.Ref)

type Intersect ¶

type Intersect []Shape

Intersect computes an intersection of nodes between multiple queries. Similar to And iterator.

func (s Intersect) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Intersect) Optimize(ctx context.Context, r Optimizer) (sout Shape, opt bool)

type IntersectOpt ¶

type IntersectOpt struct {
	Sub Intersect
	Opt []Shape
}

IntersectOpt is like Intersect but it also joins optional query shapes to the main query.

func (s *IntersectOpt) Add(arr ...Shape)

func (s *IntersectOpt) AddOptional(arr ...Shape)

func (s IntersectOpt) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s IntersectOpt) Optimize(ctx context.Context, r Optimizer) (_ Shape, opt bool)

type Lookup ¶

type Lookup []quad.Value

Lookup is a static set of values that must be resolved to nodes by QuadStore.

func (s *Lookup) Add(v ...quad.Value)

func (s Lookup) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Lookup) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Materialize ¶

type Materialize struct {
	Size   int // approximate size; zero means undefined
	Values Shape
}

Materialize loads results of sub-query into memory during execution to speedup iteration.

func (s Materialize) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Materialize) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type NodesFrom ¶

type NodesFrom struct {
	Dir   quad.Direction
	Quads Shape
}

NodesFrom extracts nodes on a given direction from source quads. Similar to HasA iterator.

func (s NodesFrom) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s NodesFrom) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Null ¶

type Null struct{}

Null represent an empty set. Mostly used as a safe alias for nil shape.

func (Null) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Null) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Optimizer ¶

type Optimizer interface {
	OptimizeShape(ctx context.Context, s Shape) (Shape, bool)
}

type Page ¶

type Page struct {
	From  Shape
	Skip  int64
	Limit int64 // zero means unlimited
}

Page provides a simple form of pagination. Can be used to skip or limit results.

func (s Page) ApplyPage(p Page) *Page

func (s Page) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Page) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type QuadFilter ¶

type QuadFilter struct {
	Dir    quad.Direction
	Values Shape
}

QuadFilter is a constraint used to filter quads that have a certain set of values on a given direction. Analog of LinksTo iterator.

type QuadIndexer ¶

type QuadIndexer interface {
	// SizeOfIndex returns a size of a quad index with given constraints.
	SizeOfIndex(c map[quad.Direction]refs.Ref) (int64, bool)
	// LookupQuadIndex finds a quad that matches a given constraint.
	// It returns false if quad was not found, or there are multiple quads matching constraint.
	LookupQuadIndex(c map[quad.Direction]refs.Ref) (InternalQuad, bool)
}

QuadIndexer is an optional interface for quad stores that keep an index of quad directions.

It is used to optimize shapes based on stats from these indexes.

type Quads ¶

type Quads []QuadFilter

Quads is a selector of quads with a given set of node constraints. Empty or nil Quads is equivalent to AllQuads. Equivalent to And(AllQuads,LinksTo*) iterator tree.

func (s Quads) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s *Quads) Intersect(q ...QuadFilter)

func (s Quads) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type QuadsAction ¶

type QuadsAction struct {
	Size   int64 // approximate size; zero means undefined
	Result quad.Direction
	Save   map[quad.Direction][]string
	Filter map[quad.Direction]refs.Ref
}

QuadsAction represents a set of actions that can be done to a set of quads in a single scan pass. It filters quads according to Filter constraints (equivalent of LinksTo), tags directions using tags in Save field and returns a specified quad direction as result of the iterator (equivalent of HasA). Optionally, Size field may be set to indicate an approximate number of quads that will be returned by this query.

func (s QuadsAction) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s QuadsAction) Clone() QuadsAction

func (s QuadsAction) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

func (s *QuadsAction) SetFilter(d quad.Direction, v refs.Ref)

func (s QuadsAction) Simplify() Shape

func (s QuadsAction) SimplifyFrom(quads Shape) Shape

type Regexp ¶

type Regexp struct {
	Re   *regexp.Regexp
	Refs bool // allow to match IRIs
}

Regexp filters values using regular expression.

Since regexp patterns can not be optimized in most cases, Wildcard should be used if possible.

func (f Regexp) BuildIterator(qs graph.QuadStore, it iterator.Shape) iterator.Shape

type Save ¶

type Save struct {
	Tags []string
	From Shape
}

Save tags a results of query with provided tags.

func (s Save) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Save) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Shape ¶

type Shape interface {
	// BuildIterator constructs an iterator tree from a given shapes and binds it to QuadStore.
	BuildIterator(qs graph.QuadStore) iterator.Shape
	// Optimize runs an optimization pass over a query shape.
	//
	// It returns a bool that indicates if shape was replaced and should always return a copy of shape in this case.
	// In case no optimizations were made, it returns the same unmodified shape.
	//
	// If Optimizer is specified, it will be used instead of default optimizations.
	Optimize(ctx context.Context, r Optimizer) (Shape, bool)
}

Shape represent a query tree shape.

func AddFilters(nodes Shape, filters ...ValueFilter) Shape

func Compare(nodes Shape, op iterator.Operator, v quad.Value) Shape

func FilterQuads(subject, predicate, object, label []quad.Value) Shape

func Has(from, via, nodes Shape, rev bool) Shape

func HasLabels(from, via, nodes, labels Shape, rev bool) Shape

func In(from, via, labels Shape, tags ...string) Shape

func IntersectOptional(s, opt Shape) Shape

func IntersectShapes(s1, s2 Shape) Shape

func Labels(from Shape) Shape

func Optimize(ctx context.Context, s Shape, qs graph.QuadStore) (Shape, bool)

func Out(from, via, labels Shape, tags ...string) Shape

func Predicates(from Shape, in bool) Shape

func SavePredicates(from Shape, in bool, tag string) Shape

func SaveVia(from, via Shape, tag string, rev, opt bool) Shape

func SaveViaLabels(from, via, labels Shape, tag string, rev, opt bool) Shape

type Sort ¶

type Sort struct {
	From Shape
}

func (s Sort) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Sort) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Union ¶

type Union []Shape

Union joins results of multiple queries together. It does not make results unique.

func UnionShapes(s1, s2 Shape) Union

func (s Union) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Union) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type Unique ¶

type Unique struct {
	From Shape
}

Unique makes query results unique.

func (s Unique) BuildIterator(qs graph.QuadStore) iterator.Shape

func (s Unique) Optimize(ctx context.Context, r Optimizer) (Shape, bool)

type ValueFilter ¶

type ValueFilter interface {
	BuildIterator(qs graph.QuadStore, it iterator.Shape) iterator.Shape
}

ValueFilter is an interface for iterator wrappers that can filter node values.

type WalkFunc ¶

type WalkFunc func(Shape) bool

WalkFunc is used to visit all shapes in the tree. If false is returned, branch will not be traversed further.

type Wildcard ¶

type Wildcard struct {
	Pattern string // allowed wildcards are: % and ?
}

Wildcard is a filter for string patterns.

% - zero or more characters
? - exactly one character

func (f Wildcard) BuildIterator(qs graph.QuadStore, it iterator.Shape) iterator.Shape

func (f Wildcard) Regexp() string