iterator

package
v0.7.5 Latest Latest
Warning

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

 Go to latest Published: Nov 26, 2018 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const MaterializeLimit = 1000

Variables

View Source 
var DefaultMaxRecursiveSteps = 50

Functions

func NextUID 

func NextUID() uint64

func OutputQueryShapeForIterator 

func OutputQueryShapeForIterator(it graph.Iterator, qs graph.QuadStore, outputMap map[string]interface{})

func RunFloatOp 

func RunFloatOp(a quad.Float, op Operator, b quad.Float) bool

func RunIntOp 

func RunIntOp(a quad.Int, op Operator, b quad.Int) bool

func RunStrOp 

func RunStrOp(a string, op Operator, b string) bool

func RunTimeOp 

func RunTimeOp(a time.Time, op Operator, b time.Time) bool

Types

type And 

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

The And iterator. Consists of a number of subiterators, the primary of which will be Next()ed if next is called.

func NewAnd 

func NewAnd(qs graph.QuadStore, sub ...graph.Iterator) *And

NewAnd creates an And iterator. `qs` is only required when needing a handle for QuadStore-specific optimizations, otherwise nil is acceptable.

func (*And) AddSubIterator 

func (it *And) AddSubIterator(sub graph.Iterator)

Add a subiterator to this And iterator.

The first iterator that is added becomes the primary iterator. This is important. Calling Optimize() is the way to change the order based on subiterator statistics. Without Optimize(), the order added is the order used.

func (*And) Clone 

func (it *And) Clone() graph.Iterator

func (*And) Close 

func (it *And) Close() error

Close this iterator, and, by extension, close the subiterators. Close should be idempotent, and it follows that if it's subiterators follow this contract, the And follows the contract. It closes all subiterators it can, but returns the first error it encounters.

func (*And) Contains 

func (it *And) Contains(ctx context.Context, val graph.Value) bool

Check a value against the entire iterator, in order.

func (*And) Err 

func (it *And) Err() error

func (*And) Next 

func (it *And) Next(ctx context.Context) bool

Returns advances the And iterator. Because the And is the intersection of its subiterators, it must choose one subiterator to produce a candidate, and check this value against the subiterators. A productive choice of primary iterator is therefore very important.

func (*And) NextPath 

func (it *And) NextPath(ctx context.Context) bool

An And has no NextPath of its own -- that is, there are no other values which satisfy our previous result that are not the result itself. Our subiterators might, however, so just pass the call recursively.

func (*And) Optimize 

func (it *And) Optimize() (graph.Iterator, bool)

Optimizes the And, by picking the most efficient way to Next() and Contains() its subiterators. For SQL fans, this is equivalent to JOIN.

func (*And) Reset 

func (it *And) Reset()

Reset all internal iterators

func (*And) Result 

func (it *And) Result() graph.Value

func (*And) Size 

func (it *And) Size() (int64, bool)

Returns the approximate size of the And iterator. Because we're dealing with an intersection, we know that the largest we can be is the size of the smallest iterator. This is the heuristic we shall follow. Better heuristics welcome.

func (*And) Stats 

func (it *And) Stats() graph.IteratorStats

and.Stats() lives here in and-iterator-optimize.go because it may in the future return different statistics based on how it is optimized. For now, however, it's pretty static.

func (*And) String 

func (it *And) String() string

func (*And) SubIterators 

func (it *And) SubIterators() []graph.Iterator

Returns a slice of the subiterators, in order (primary iterator first).

func (*And) TagResults 

func (it *And) TagResults(dst map[string]graph.Value)

An extended TagResults, as it needs to add it's own results and recurse down it's subiterators.

func (*And) Tagger 

func (it *And) Tagger() *graph.Tagger

func (*And) Type 

func (it *And) Type() graph.Type

Register this as an "and" iterator.

func (*And) UID 

func (it *And) UID() uint64

type Comparison 

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

func NewComparison 

func NewComparison(sub graph.Iterator, op Operator, val quad.Value, qs graph.QuadStore) *Comparison

func (*Comparison) Clone 

func (it *Comparison) Clone() graph.Iterator

func (*Comparison) Close 

func (it *Comparison) Close() error

func (*Comparison) Contains 

func (it *Comparison) Contains(ctx context.Context, val graph.Value) bool

func (*Comparison) Err 

func (it *Comparison) Err() error

func (*Comparison) Next 

func (it *Comparison) Next(ctx context.Context) bool

func (*Comparison) NextPath 

func (it *Comparison) NextPath(ctx context.Context) bool

func (*Comparison) Operator 

func (it *Comparison) Operator() Operator

func (*Comparison) Optimize 

func (it *Comparison) Optimize() (graph.Iterator, bool)

There's nothing to optimize, locally, for a value-comparison iterator. Replace the underlying iterator if need be. potentially replace it.

func (*Comparison) Reset 

func (it *Comparison) Reset()

func (*Comparison) Result 

func (it *Comparison) Result() graph.Value

func (*Comparison) Size 

func (it *Comparison) Size() (int64, bool)

func (*Comparison) Stats 

func (it *Comparison) Stats() graph.IteratorStats

We're only as expensive as our subiterator. Again, optimized value comparison iterators should do better.

func (*Comparison) String 

func (it *Comparison) String() string

func (*Comparison) SubIterators 

func (it *Comparison) SubIterators() []graph.Iterator

func (*Comparison) TagResults 

func (it *Comparison) TagResults(dst map[string]graph.Value)

If we failed the check, then the subiterator should not contribute to the result set. Otherwise, go ahead and tag it.

func (*Comparison) Tagger 

func (it *Comparison) Tagger() *graph.Tagger

func (*Comparison) Type 

func (it *Comparison) Type() graph.Type

Registers the value-comparison iterator.

func (*Comparison) UID 

func (it *Comparison) UID() uint64

func (*Comparison) Value 

func (it *Comparison) Value() quad.Value

type Count 

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

Count iterator returns one element with size of underlying iterator.

func NewCount 

func NewCount(it graph.Iterator, qs graph.QuadStore) *Count

NewCount creates a new iterator to count a number of results from a provided subiterator. qs may be nil - it's used to check if count Contains (is) a given value.

func (*Count) Clone 

func (it *Count) Clone() graph.Iterator

func (*Count) Close 

func (it *Count) Close() error

func (*Count) Contains 

func (it *Count) Contains(ctx context.Context, val graph.Value) bool

func (*Count) Err 

func (it *Count) Err() error

func (*Count) Next 

func (it *Count) Next(ctx context.Context) bool

Next counts a number of results in underlying iterator.

func (*Count) NextPath 

func (it *Count) NextPath(ctx context.Context) bool

func (*Count) Optimize 

func (it *Count) Optimize() (graph.Iterator, bool)

func (*Count) Reset 

func (it *Count) Reset()

Reset resets the internal iterators and the iterator itself.

func (*Count) Result 

func (it *Count) Result() graph.Value

func (*Count) Size 

func (it *Count) Size() (int64, bool)

func (*Count) Stats 

func (it *Count) Stats() graph.IteratorStats

func (*Count) String 

func (it *Count) String() string

func (*Count) SubIterators 

func (it *Count) SubIterators() []graph.Iterator

SubIterators returns a slice of the sub iterators.

func (*Count) TagResults 

func (it *Count) TagResults(dst map[string]graph.Value)

func (*Count) Tagger 

func (it *Count) Tagger() *graph.Tagger

func (*Count) Type 

func (it *Count) Type() graph.Type

func (*Count) UID 

func (it *Count) UID() uint64

type Error 

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

Error iterator always returns a single error with no other results.

func NewError 

func NewError(err error) *Error

func (*Error) Clone 

func (it *Error) Clone() graph.Iterator

func (*Error) Close 

func (it *Error) Close() error

func (*Error) Contains 

func (it *Error) Contains(ctx context.Context, v graph.Value) bool

func (*Error) Err 

func (it *Error) Err() error

func (*Error) Next 

func (it *Error) Next(ctx context.Context) bool

func (*Error) NextPath 

func (it *Error) NextPath(ctx context.Context) bool

func (*Error) Optimize 

func (it *Error) Optimize() (graph.Iterator, bool)

func (*Error) Reset 

func (it *Error) Reset()

func (*Error) Result 

func (it *Error) Result() graph.Value

func (*Error) Size 

func (it *Error) Size() (int64, bool)

func (*Error) Stats 

func (it *Error) Stats() graph.IteratorStats

func (*Error) String 

func (it *Error) String() string

func (*Error) SubIterators 

func (it *Error) SubIterators() []graph.Iterator

func (*Error) TagResults 

func (it *Error) TagResults(dst map[string]graph.Value)

Fill the map based on the tags assigned to this iterator.

func (*Error) Tagger 

func (it *Error) Tagger() *graph.Tagger

func (*Error) Type 

func (it *Error) Type() graph.Type

func (*Error) UID 

func (it *Error) UID() uint64

type Fixed 

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

A Fixed iterator consists of it's values, an index (where it is in the process of Next()ing) and an equality function.

func NewFixed 

func NewFixed(vals ...graph.Value) *Fixed

Creates a new Fixed iterator with a custom comparator.

func (*Fixed) Add 

func (it *Fixed) Add(v graph.Value)

Add a value to the iterator. The array now contains this value. TODO(barakmich): This ought to be a set someday, disallowing repeated values.

func (*Fixed) Clone 

func (it *Fixed) Clone() graph.Iterator

func (*Fixed) Close 

func (it *Fixed) Close() error

func (*Fixed) Contains 

func (it *Fixed) Contains(ctx context.Context, v graph.Value) bool

Check if the passed value is equal to one of the values stored in the iterator.

func (*Fixed) Err 

func (it *Fixed) Err() error

func (*Fixed) Next 

func (it *Fixed) Next(ctx context.Context) bool

Next advances the iterator.

func (*Fixed) NextPath 

func (it *Fixed) NextPath(ctx context.Context) bool

func (*Fixed) Optimize 

func (it *Fixed) Optimize() (graph.Iterator, bool)

Optimize() for a Fixed iterator is simple. Returns a Null iterator if it's empty (so that other iterators upstream can treat this as null) or there is no optimization.

func (*Fixed) Reset 

func (it *Fixed) Reset()

func (*Fixed) Result 

func (it *Fixed) Result() graph.Value

func (*Fixed) Size 

func (it *Fixed) Size() (int64, bool)

Size is the number of values stored.

func (*Fixed) Stats 

func (it *Fixed) Stats() graph.IteratorStats

As we right now have to scan the entire list, Next and Contains are linear with the size. However, a better data structure could remove these limits.

func (*Fixed) String 

func (it *Fixed) String() string

func (*Fixed) SubIterators 

func (it *Fixed) SubIterators() []graph.Iterator

No sub-iterators.

func (*Fixed) TagResults 

func (it *Fixed) TagResults(dst map[string]graph.Value)

func (*Fixed) Tagger 

func (it *Fixed) Tagger() *graph.Tagger

func (*Fixed) Type 

func (it *Fixed) Type() graph.Type

Register this iterator as a Fixed iterator.

func (*Fixed) UID 

func (it *Fixed) UID() uint64

func (*Fixed) Values 

func (it *Fixed) Values() []graph.Value

Values returns a list of values stored in iterator. Slice should not be modified.

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 graph.QuadStore, subIt graph.Iterator, d quad.Direction) *HasA

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

func (*HasA) Clone 

func (it *HasA) Clone() graph.Iterator

func (*HasA) Close 

func (it *HasA) Close() error

Close the subiterator, the result iterator (if any) and the HasA. It closes all subiterators it can, but returns the first error it encounters.

func (*HasA) Contains 

func (it *HasA) Contains(ctx context.Context, val graph.Value) bool

Check a value against our internal iterator. In order to do this, we must first open a new iterator of "quads that have `val` in our direction", given to us by the quad store, and then Next() values out of that iterator and Contains() them against our subiterator.

func (*HasA) Direction 

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

Direction accessor.

func (*HasA) Err 

func (it *HasA) Err() error

func (*HasA) Next 

func (it *HasA) Next(ctx context.Context) bool

Next advances the iterator. This is simpler than Contains. We have a subiterator we can get a value from, and we can take that resultant quad, pull our direction out of it, and return that.

func (*HasA) NextContains 

func (it *HasA) NextContains(ctx context.Context) bool

NextContains() is shared code between Contains() and GetNextResult() -- calls next on the result iterator (a quad iterator based on the last checked value) and returns true if another match is made.

func (*HasA) NextPath 

func (it *HasA) NextPath(ctx context.Context) bool

Get the next result that matches this branch.

func (*HasA) Optimize 

func (it *HasA) Optimize() (graph.Iterator, bool)

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) Reset 

func (it *HasA) Reset()

func (*HasA) Result 

func (it *HasA) Result() graph.Value

func (*HasA) Size 

func (it *HasA) Size() (int64, bool)

func (*HasA) Stats 

func (it *HasA) Stats() graph.IteratorStats

GetStats() 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() []graph.Iterator

Return our sole subiterator.

func (*HasA) TagResults 

func (it *HasA) TagResults(dst map[string]graph.Value)

Pass the TagResults down the chain.

func (*HasA) Tagger 

func (it *HasA) Tagger() *graph.Tagger

func (*HasA) Type 

func (it *HasA) Type() graph.Type

Register this iterator as a HasA.

func (*HasA) UID 

func (it *HasA) UID() uint64

type Int64 

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

An All iterator across a range of int64 values, from `max` to `min`.

func NewInt64 

func NewInt64(min, max int64, node bool) *Int64

Creates a new Int64 with the given range.

func (*Int64) Clone 

func (it *Int64) Clone() graph.Iterator

func (*Int64) Close 

func (it *Int64) Close() error

func (*Int64) Contains 

func (it *Int64) Contains(ctx context.Context, tsv graph.Value) bool

Contains() for an Int64 is merely seeing if the passed value is within the range, assuming the value is an int64.

func (*Int64) Err 

func (it *Int64) Err() error

func (*Int64) Next 

func (it *Int64) Next(ctx context.Context) bool

Next() on an Int64 all iterator is a simple incrementing counter. Return the next integer, and mark it as the result.

func (*Int64) NextPath 

func (it *Int64) NextPath(ctx context.Context) bool

func (*Int64) Optimize 

func (it *Int64) Optimize() (graph.Iterator, bool)

There's nothing to optimize about this little iterator.

func (*Int64) Reset 

func (it *Int64) Reset()

Start back at the beginning

func (*Int64) Result 

func (it *Int64) Result() graph.Value

func (*Int64) Size 

func (it *Int64) Size() (int64, bool)

The number of elements in an Int64 is the size of the range. The size is exact.

func (*Int64) Stats 

func (it *Int64) Stats() graph.IteratorStats

Stats for an Int64 are simple. Super cheap to do any operation, and as big as the range.

func (*Int64) String 

func (it *Int64) String() string

func (*Int64) SubIterators 

func (it *Int64) SubIterators() []graph.Iterator

No sub-iterators.

func (*Int64) TagResults 

func (it *Int64) TagResults(dst map[string]graph.Value)

Fill the map based on the tags assigned to this iterator.

func (*Int64) Tagger 

func (it *Int64) Tagger() *graph.Tagger

func (*Int64) Type 

func (it *Int64) Type() graph.Type

The type of this iterator is an "all". This is important, as it puts it in the class of "all iterators.

func (*Int64) UID 

func (it *Int64) UID() uint64

type Int64Node 

type Int64Node int64

func (Int64Node) IsNode 

func (Int64Node) IsNode() bool

func (Int64Node) Key 

func (v Int64Node) Key() interface{}

type Int64Quad 

type Int64Quad int64

func (Int64Quad) IsNode 

func (Int64Quad) IsNode() bool

func (Int64Quad) Key 

func (v Int64Quad) Key() interface{}

type Limit 

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

Limit iterator will stop iterating if certain a number of values were encountered. Zero and negative limit values means no limit.

func NewLimit 

func NewLimit(primaryIt graph.Iterator, limit int64) *Limit

func (*Limit) Clone 

func (it *Limit) Clone() graph.Iterator

func (*Limit) Close 

func (it *Limit) Close() error

Close closes the primary and all iterators. It closes all subiterators it can, but returns the first error it encounters.

func (*Limit) Contains 

func (it *Limit) Contains(ctx context.Context, val graph.Value) bool

func (*Limit) Err 

func (it *Limit) Err() error

func (*Limit) Next 

func (it *Limit) Next(ctx context.Context) bool

Next advances the Limit iterator. It will stop iteration if limit was reached.

func (*Limit) NextPath 

func (it *Limit) NextPath(ctx context.Context) bool

NextPath checks whether there is another path. Will call primary iterator if limit is not reached yet.

func (*Limit) Optimize 

func (it *Limit) Optimize() (graph.Iterator, bool)

func (*Limit) Reset 

func (it *Limit) Reset()

Reset resets the internal iterators and the iterator itself.

func (*Limit) Result 

func (it *Limit) Result() graph.Value

func (*Limit) Size 

func (it *Limit) Size() (int64, bool)

func (*Limit) Stats 

func (it *Limit) Stats() graph.IteratorStats

func (*Limit) String 

func (it *Limit) String() string

func (*Limit) SubIterators 

func (it *Limit) SubIterators() []graph.Iterator

SubIterators returns a slice of the sub iterators.

func (*Limit) TagResults 

func (it *Limit) TagResults(dst map[string]graph.Value)

func (*Limit) Tagger 

func (it *Limit) Tagger() *graph.Tagger

func (*Limit) Type 

func (it *Limit) Type() graph.Type

func (*Limit) UID 

func (it *Limit) UID() uint64
type Link struct {
	Source   int `json:"source"`
	Target   int `json:"target"`
	Pred     int `json:"type"`
	LinkNode int `json:"link_node"`
}

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 graph.QuadStore, it graph.Iterator, d quad.Direction) *LinksTo

Construct a new LinksTo iterator around a direction and a subiterator of nodes.

func (*LinksTo) Clone 

func (it *LinksTo) Clone() graph.Iterator

func (*LinksTo) Close 

func (it *LinksTo) Close() error

Close closes the iterator. It closes all subiterators it can, but returns the first error it encounters.

func (*LinksTo) Contains 

func (it *LinksTo) Contains(ctx context.Context, val graph.Value) bool

If it checks in the right direction for the subiterator, it is a valid link for the LinksTo.

func (*LinksTo) Direction 

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

Return the direction under consideration.

func (*LinksTo) Err 

func (it *LinksTo) Err() error

func (*LinksTo) Next 

func (it *LinksTo) Next(ctx context.Context) bool

Next()ing a LinksTo operates as described above.

func (*LinksTo) NextPath 

func (it *LinksTo) NextPath(ctx context.Context) bool

We won't ever have a new result, but our subiterators might.

func (*LinksTo) Optimize 

func (it *LinksTo) Optimize() (graph.Iterator, bool)

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

func (*LinksTo) Reset 

func (it *LinksTo) Reset()

func (*LinksTo) Result 

func (it *LinksTo) Result() graph.Value

func (*LinksTo) Size 

func (it *LinksTo) Size() (int64, bool)

func (*LinksTo) Stats 

func (it *LinksTo) Stats() graph.IteratorStats

Return 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() []graph.Iterator

Return a list containing only our subiterator.

func (*LinksTo) TagResults 

func (it *LinksTo) TagResults(dst map[string]graph.Value)

Tag these results, and our subiterator's results.

func (*LinksTo) Tagger 

func (it *LinksTo) Tagger() *graph.Tagger

func (*LinksTo) Type 

func (it *LinksTo) Type() graph.Type

Register the LinksTo.

func (*LinksTo) UID 

func (it *LinksTo) UID() uint64

type Materialize 

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

func NewMaterialize 

func NewMaterialize(sub graph.Iterator) *Materialize

func NewMaterializeWithSize 

func NewMaterializeWithSize(sub graph.Iterator, size int64) *Materialize

func (*Materialize) Clone 

func (it *Materialize) Clone() graph.Iterator

func (*Materialize) Close 

func (it *Materialize) Close() error

func (*Materialize) Contains 

func (it *Materialize) Contains(ctx context.Context, v graph.Value) bool

func (*Materialize) Err 

func (it *Materialize) Err() error

func (*Materialize) Next 

func (it *Materialize) Next(ctx context.Context) bool

func (*Materialize) NextPath 

func (it *Materialize) NextPath(ctx context.Context) bool

func (*Materialize) Optimize 

func (it *Materialize) Optimize() (graph.Iterator, bool)

func (*Materialize) Reset 

func (it *Materialize) Reset()

func (*Materialize) Result 

func (it *Materialize) Result() graph.Value

func (*Materialize) Size 

func (it *Materialize) Size() (int64, bool)

Size is the number of values stored, if we've got them all. Otherwise, guess based on the size of the subiterator.

func (*Materialize) Stats 

func (it *Materialize) Stats() graph.IteratorStats

The entire point of Materialize is to amortize the cost by putting it all up front.

func (*Materialize) String 

func (it *Materialize) String() string

func (*Materialize) SubIterators 

func (it *Materialize) SubIterators() []graph.Iterator

func (*Materialize) TagResults 

func (it *Materialize) TagResults(dst map[string]graph.Value)

func (*Materialize) Tagger 

func (it *Materialize) Tagger() *graph.Tagger

func (*Materialize) Type 

func (it *Materialize) Type() graph.Type

Register this iterator as a Materialize iterator.

func (*Materialize) UID 

func (it *Materialize) UID() uint64

type Node 

type Node struct {
	ID         int      `json:"id"`
	Tags       []string `json:"tags,omitempty"`
	Values     []string `json:"values,omitempty"`
	IsLinkNode bool     `json:"is_link_node"`
	IsFixed    bool     `json:"is_fixed"`
}

type Not 

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

Not iterator acts like a complement for the primary iterator. It will return all the vertices which are not part of the primary iterator.

func NewNot 

func NewNot(primaryIt, allIt graph.Iterator) *Not

func (*Not) Clone 

func (it *Not) Clone() graph.Iterator

func (*Not) Close 

func (it *Not) Close() error

Close closes the primary and all iterators. It closes all subiterators it can, but returns the first error it encounters.

func (*Not) Contains 

func (it *Not) Contains(ctx context.Context, val graph.Value) bool

Contains checks whether the passed value is part of the primary iterator's complement. For a valid value, it updates the Result returned by the iterator to the value itself.

func (*Not) Err 

func (it *Not) Err() error

func (*Not) Next 

func (it *Not) Next(ctx context.Context) bool

Next advances the Not iterator. It returns whether there is another valid new value. It fetches the next value of the all iterator which is not contained by the primary iterator.

func (*Not) NextPath 

func (it *Not) NextPath(ctx context.Context) bool

NextPath checks whether there is another path. Not applicable, hence it will return false.

func (*Not) Optimize 

func (it *Not) Optimize() (graph.Iterator, bool)

func (*Not) Reset 

func (it *Not) Reset()

Reset resets the internal iterators and the iterator itself.

func (*Not) Result 

func (it *Not) Result() graph.Value

func (*Not) Size 

func (it *Not) Size() (int64, bool)

func (*Not) Stats 

func (it *Not) Stats() graph.IteratorStats

func (*Not) String 

func (it *Not) String() string

func (*Not) SubIterators 

func (it *Not) SubIterators() []graph.Iterator

SubIterators returns a slice of the sub iterators. The first iterator is the primary iterator, for which the complement is generated.

func (*Not) TagResults 

func (it *Not) TagResults(dst map[string]graph.Value)

func (*Not) Tagger 

func (it *Not) Tagger() *graph.Tagger

func (*Not) Type 

func (it *Not) Type() graph.Type

func (*Not) UID 

func (it *Not) UID() uint64

type Null 

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

Here we define the simplest iterator -- the Null iterator. It contains nothing. It is the empty set. Often times, queries that contain one of these match nothing, so it's important to give it a special iterator.

func NewNull 

func NewNull() *Null

Fairly useless New function.

func (*Null) Clone 

func (it *Null) Clone() graph.Iterator

func (*Null) Close 

func (it *Null) Close() error

func (*Null) Contains 

func (it *Null) Contains(ctx context.Context, v graph.Value) bool

func (*Null) Err 

func (it *Null) Err() error

func (*Null) Next 

func (it *Null) Next(ctx context.Context) bool

func (*Null) NextPath 

func (it *Null) NextPath(ctx context.Context) bool

func (*Null) Optimize 

func (it *Null) Optimize() (graph.Iterator, bool)

A good iterator will close itself when it returns true. Null has nothing it needs to do.

func (*Null) Reset 

func (it *Null) Reset()

func (*Null) Result 

func (it *Null) Result() graph.Value

func (*Null) Size 

func (it *Null) Size() (int64, bool)

func (*Null) Stats 

func (it *Null) Stats() graph.IteratorStats

A null iterator costs nothing. Use it!

func (*Null) String 

func (it *Null) String() string

func (*Null) SubIterators 

func (it *Null) SubIterators() []graph.Iterator

func (*Null) TagResults 

func (it *Null) TagResults(dst map[string]graph.Value)

Fill the map based on the tags assigned to this iterator.

func (*Null) Tagger 

func (it *Null) Tagger() *graph.Tagger

func (*Null) Type 

func (it *Null) Type() graph.Type

Name the null iterator.

func (*Null) UID 

func (it *Null) UID() uint64

type Operator 

type Operator int
const (
	CompareLT Operator = iota
	CompareLTE
	CompareGT
	CompareGTE
)

func (Operator) String 

func (op Operator) String() string

type Optional 

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

An optional iterator has the sub-constraint iterator we wish to be optional and whether the last check we received was true or false.

func NewOptional 

func NewOptional(it graph.Iterator) *Optional

Creates a new optional iterator.

func (*Optional) Clone 

func (it *Optional) Clone() graph.Iterator

func (*Optional) Close 

func (it *Optional) Close() error

func (*Optional) Contains 

func (it *Optional) Contains(ctx context.Context, val graph.Value) bool

Contains() is the real hack of this iterator. It always returns true, regardless of whether the subiterator matched. But we keep track of whether the subiterator matched for results purposes.

func (*Optional) Err 

func (it *Optional) Err() error

func (*Optional) Next 

func (it *Optional) Next(ctx context.Context) bool

Optional iterator cannot be Next()'ed.

func (*Optional) NextPath 

func (it *Optional) NextPath(ctx context.Context) bool

An optional iterator only has a next result if, (a) last time we checked we had any results whatsoever, and (b) there was another subresult in our optional subbranch.

func (*Optional) NoNext 

func (it *Optional) NoNext()

Optional iterator cannot be Next()'ed.

func (*Optional) Optimize 

func (it *Optional) Optimize() (graph.Iterator, bool)

There's nothing to optimize for an optional. Optimize the subiterator and potentially replace it.

func (*Optional) Reset 

func (it *Optional) Reset()

func (*Optional) Result 

func (it *Optional) Result() graph.Value

func (*Optional) Size 

func (it *Optional) Size() (int64, bool)

func (*Optional) Stats 

func (it *Optional) Stats() graph.IteratorStats

We're only as expensive as our subiterator. Except, we can't be nexted.

func (*Optional) String 

func (it *Optional) String() string

func (*Optional) SubIterators 

func (it *Optional) SubIterators() []graph.Iterator

func (*Optional) TagResults 

func (it *Optional) TagResults(dst map[string]graph.Value)

If we failed the check, then the subiterator should not contribute to the result set. Otherwise, go ahead and tag it.

func (*Optional) Tagger 

func (it *Optional) Tagger() *graph.Tagger

func (*Optional) Type 

func (it *Optional) Type() graph.Type

Registers the optional iterator.

func (*Optional) UID 

func (it *Optional) UID() uint64

type Or 

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

func NewOr 

func NewOr(sub ...graph.Iterator) *Or

func NewShortCircuitOr 

func NewShortCircuitOr() *Or

func (*Or) AddSubIterator 

func (it *Or) AddSubIterator(sub graph.Iterator)

Add a subiterator to this Or graph.iterator. Order matters.

func (*Or) Clone 

func (it *Or) Clone() graph.Iterator

func (*Or) Close 

func (it *Or) Close() error

Close this graph.iterator, and, by extension, close the subiterators. Close should be idempotent, and it follows that if it's subiterators follow this contract, the Or follows the contract. It closes all subiterators it can, but returns the first error it encounters.

func (*Or) Contains 

func (it *Or) Contains(ctx context.Context, val graph.Value) bool

Check a value against the entire graph.iterator, in order.

func (*Or) Err 

func (it *Or) Err() error

func (*Or) Next 

func (it *Or) Next(ctx context.Context) bool

Next advances the Or graph.iterator. Because the Or is the union of its subiterators, it must produce from all subiterators -- unless it it shortcircuiting, in which case, it is the first one that returns anything.

func (*Or) NextPath 

func (it *Or) NextPath(ctx context.Context) bool

An Or has no NextPath of its own -- that is, there are no other values which satisfy our previous result that are not the result itself. Our subiterators might, however, so just pass the call recursively. In the case of shortcircuiting, only allow new results from the currently checked graph.iterator

func (*Or) Optimize 

func (it *Or) Optimize() (graph.Iterator, bool)

func (*Or) Reset 

func (it *Or) Reset()

Reset all internal iterators

func (*Or) Result 

func (it *Or) Result() graph.Value

func (*Or) Size 

func (it *Or) Size() (int64, bool)

Returns the approximate size of the Or graph.iterator. Because we're dealing with a union, we know that the largest we can be is the sum of all the iterators, or in the case of short-circuiting, the longest.

func (*Or) Stats 

func (it *Or) Stats() graph.IteratorStats

func (*Or) String 

func (it *Or) String() string

func (*Or) SubIterators 

func (it *Or) SubIterators() []graph.Iterator

Returns a list.List of the subiterators, in order. The returned slice must not be modified.

func (*Or) TagResults 

func (it *Or) TagResults(dst map[string]graph.Value)

Overrides BaseIterator TagResults, as it needs to add it's own results and recurse down it's subiterators.

func (*Or) Tagger 

func (it *Or) Tagger() *graph.Tagger

func (*Or) Type 

func (it *Or) Type() graph.Type

Register this as an "or" graph.iterator.

func (*Or) UID 

func (it *Or) UID() uint64

type Recursive 

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

Recursive iterator takes a base iterator and a morphism to be applied recursively, for each result.

func NewRecursive 

func NewRecursive(qs graph.QuadStore, it graph.Iterator, morphism graph.ApplyMorphism, maxDepth int) *Recursive

func (*Recursive) AddDepthTag 

func (it *Recursive) AddDepthTag(s string)

func (*Recursive) Clone 

func (it *Recursive) Clone() graph.Iterator

func (*Recursive) Close 

func (it *Recursive) Close() error

func (*Recursive) Contains 

func (it *Recursive) Contains(ctx context.Context, val graph.Value) bool

func (*Recursive) Err 

func (it *Recursive) Err() error

func (*Recursive) Next 

func (it *Recursive) Next(ctx context.Context) bool

func (*Recursive) NextPath 

func (it *Recursive) NextPath(ctx context.Context) bool

func (*Recursive) Optimize 

func (it *Recursive) Optimize() (graph.Iterator, bool)

func (*Recursive) Reset 

func (it *Recursive) Reset()

func (*Recursive) Result 

func (it *Recursive) Result() graph.Value

func (*Recursive) Size 

func (it *Recursive) Size() (int64, bool)

func (*Recursive) Stats 

func (it *Recursive) Stats() graph.IteratorStats

func (*Recursive) String 

func (it *Recursive) String() string

func (*Recursive) SubIterators 

func (it *Recursive) SubIterators() []graph.Iterator

func (*Recursive) TagResults 

func (it *Recursive) TagResults(dst map[string]graph.Value)

func (*Recursive) Tagger 

func (it *Recursive) Tagger() *graph.Tagger

func (*Recursive) Type 

func (it *Recursive) Type() graph.Type

func (*Recursive) UID 

func (it *Recursive) UID() uint64

type Regex 

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

Regex is a unary operator -- a filter across the values in the relevant subiterator. It works similarly to gremlin's filter{it.matches('exp')}, reducing the iterator set to values whose string representation passes a regular expression test.

func NewRegex 

func NewRegex(sub graph.Iterator, re *regexp.Regexp, qs graph.QuadStore) *Regex

func (*Regex) AllowRefs 

func (it *Regex) AllowRefs(v bool)

AllowRefs allows regexp iterator to match IRIs and BNodes.

Consider using it carefully. In most cases it's better to reconsider your graph structure instead of relying on slow unoptimizable regexp.

An example of incorrect usage is to match IRIs: 

<http://example.org/page>
<http://example.org/page/foo>

Via regexp like: 

http://example.org/page.*

The right way is to explicitly link graph nodes and query them by this relation: 

<http://example.org/page/foo> <type> <http://example.org/page>

func (*Regex) Clone 

func (it *Regex) Clone() graph.Iterator

func (*Regex) Close 

func (it *Regex) Close() error

func (*Regex) Contains 

func (it *Regex) Contains(ctx context.Context, val graph.Value) bool

func (*Regex) Err 

func (it *Regex) Err() error

func (*Regex) Next 

func (it *Regex) Next(ctx context.Context) bool

func (*Regex) NextPath 

func (it *Regex) NextPath(ctx context.Context) bool

func (*Regex) Optimize 

func (it *Regex) Optimize() (graph.Iterator, bool)

There's nothing to optimize, locally, for a Regex iterator. Replace the underlying iterator if need be.

func (*Regex) Reset 

func (it *Regex) Reset()

func (*Regex) Result 

func (it *Regex) Result() graph.Value

func (*Regex) Size 

func (it *Regex) Size() (int64, bool)

func (*Regex) Stats 

func (it *Regex) Stats() graph.IteratorStats

We're only as expensive as our subiterator.

func (*Regex) String 

func (it *Regex) String() string

func (*Regex) SubIterators 

func (it *Regex) SubIterators() []graph.Iterator

func (*Regex) TagResults 

func (it *Regex) TagResults(dst map[string]graph.Value)

If we failed the check, then the subiterator should not contribute to the result set. Otherwise, go ahead and tag it.

func (*Regex) Tagger 

func (it *Regex) Tagger() *graph.Tagger

func (*Regex) Type 

func (it *Regex) Type() graph.Type

Registers the Regex iterator.

func (*Regex) UID 

func (it *Regex) UID() uint64

type Resolver 

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

A Resolver iterator consists of it's order, an index (where it is in the, process of iterating) and a store to resolve values from.

func NewResolver 

func NewResolver(qs graph.QuadStore, nodes ...quad.Value) *Resolver

Creates a new Resolver iterator.

func (*Resolver) Clone 

func (it *Resolver) Clone() graph.Iterator

func (*Resolver) Close 

func (it *Resolver) Close() error

func (*Resolver) Contains 

func (it *Resolver) Contains(ctx context.Context, value graph.Value) bool

Check if the passed value is equal to one of the order stored in the iterator.

func (*Resolver) Err 

func (it *Resolver) Err() error

func (*Resolver) Next 

func (it *Resolver) Next(ctx context.Context) bool

Next advances the iterator.

func (*Resolver) NextPath 

func (it *Resolver) NextPath(ctx context.Context) bool

func (*Resolver) Optimize 

func (it *Resolver) Optimize() (graph.Iterator, bool)

Returns a Null iterator if it's empty so that upstream iterators can optimize it away, otherwise there is no optimization.

func (*Resolver) Reset 

func (it *Resolver) Reset()

func (*Resolver) Result 

func (it *Resolver) Result() graph.Value

func (*Resolver) Size 

func (it *Resolver) Size() (int64, bool)

Size is the number of m stored.

func (*Resolver) Stats 

func (it *Resolver) Stats() graph.IteratorStats

func (*Resolver) String 

func (it *Resolver) String() string

func (*Resolver) SubIterators 

func (it *Resolver) SubIterators() []graph.Iterator

func (*Resolver) TagResults 

func (it *Resolver) TagResults(dst map[string]graph.Value)

func (*Resolver) Tagger 

func (it *Resolver) Tagger() *graph.Tagger

func (*Resolver) Type 

func (it *Resolver) Type() graph.Type

Register this iterator as a Resolver iterator.

func (*Resolver) UID 

func (it *Resolver) UID() uint64

type Skip 

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

Skip iterator will skip certain number of values from primary iterator.

func NewSkip 

func NewSkip(primaryIt graph.Iterator, skip int64) *Skip

func (*Skip) Clone 

func (it *Skip) Clone() graph.Iterator

func (*Skip) Close 

func (it *Skip) Close() error

Close closes the primary and all iterators. It closes all subiterators it can, but returns the first error it encounters.

func (*Skip) Contains 

func (it *Skip) Contains(ctx context.Context, val graph.Value) bool

func (*Skip) Err 

func (it *Skip) Err() error

func (*Skip) Next 

func (it *Skip) Next(ctx context.Context) bool

Next advances the Skip iterator. It will skip all initial values before returning actual result.

func (*Skip) NextPath 

func (it *Skip) NextPath(ctx context.Context) bool

NextPath checks whether there is another path. It will skip first paths according to iterator parameter.

func (*Skip) Optimize 

func (it *Skip) Optimize() (graph.Iterator, bool)

func (*Skip) Reset 

func (it *Skip) Reset()

Reset resets the internal iterators and the iterator itself.

func (*Skip) Result 

func (it *Skip) Result() graph.Value

func (*Skip) Size 

func (it *Skip) Size() (int64, bool)

func (*Skip) Stats 

func (it *Skip) Stats() graph.IteratorStats

func (*Skip) String 

func (it *Skip) String() string

func (*Skip) SubIterators 

func (it *Skip) SubIterators() []graph.Iterator

SubIterators returns a slice of the sub iterators.

func (*Skip) TagResults 

func (it *Skip) TagResults(dst map[string]graph.Value)

func (*Skip) Tagger 

func (it *Skip) Tagger() *graph.Tagger

func (*Skip) Type 

func (it *Skip) Type() graph.Type

func (*Skip) UID 

func (it *Skip) UID() uint64

type Unique 

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

Unique iterator removes duplicate values from it's subiterator.

func NewUnique 

func NewUnique(subIt graph.Iterator) *Unique

func (*Unique) Clone 

func (it *Unique) Clone() graph.Iterator

func (*Unique) Close 

func (it *Unique) Close() error

Close closes the primary iterators.

func (*Unique) Contains 

func (it *Unique) Contains(ctx context.Context, val graph.Value) bool

Contains checks whether the passed value is part of the primary iterator, which is irrelevant for uniqueness.

func (*Unique) Err 

func (it *Unique) Err() error

func (*Unique) Next 

func (it *Unique) Next(ctx context.Context) bool

Next advances the subiterator, continuing until it returns a value which it has not previously seen.

func (*Unique) NextPath 

func (it *Unique) NextPath(ctx context.Context) bool

NextPath for unique always returns false. If we were to return multiple paths, we'd no longer be a unique result, so we have to choose only the first path that got us here. Unique is serious on this point.

func (*Unique) Optimize 

func (it *Unique) Optimize() (graph.Iterator, bool)

func (*Unique) Reset 

func (it *Unique) Reset()

Reset resets the internal iterators and the iterator itself.

func (*Unique) Result 

func (it *Unique) Result() graph.Value

func (*Unique) Size 

func (it *Unique) Size() (int64, bool)

func (*Unique) Stats 

func (it *Unique) Stats() graph.IteratorStats

func (*Unique) String 

func (it *Unique) String() string

func (*Unique) SubIterators 

func (it *Unique) SubIterators() []graph.Iterator

SubIterators returns a slice of the sub iterators. The first iterator is the primary iterator, for which the complement is generated.

func (*Unique) TagResults 

func (it *Unique) TagResults(dst map[string]graph.Value)

func (*Unique) Tagger 

func (it *Unique) Tagger() *graph.Tagger

func (*Unique) Type 

func (it *Unique) Type() graph.Type

func (*Unique) UID 

func (it *Unique) UID() uint64

Source Files

View all Source files

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.