iterator

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: 9 Imported by: 0

Documentation

Index

Constants

View Source
const MaterializeLimit = 1000

Variables

View Source
var DefaultMaxRecursiveSteps = 50

Functions

func Height

func Height(it Shape, filter func(Shape) bool) int

Height is a convienence function to measure the height of an iterator tree.

func IsNull

func IsNull(it Shape) bool

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(sub ...Shape) *And

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

func (*And) AddOptionalIterator

func (it *And) AddOptionalIterator(sub Shape) *And

AddOptionalIterator adds an iterator that will only be Contain'ed and will not affect iteration results. Only tags will be propagated from this iterator.

func (*And) AddSubIterator

func (it *And) AddSubIterator(sub Shape)

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

func (it *And) Iterate() Scanner

func (*And) Lookup

func (it *And) Lookup() Index

func (*And) Optimize

func (it *And) Optimize(ctx context.Context) (Shape, 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) Stats

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

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.

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

func (it *And) String() string

func (*And) SubIterators

func (it *And) SubIterators() []Shape

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

type Base

type Base interface {
	// String returns a short textual representation of an iterator.
	String() string

	// Fills a tag-to-result-value map.
	TagResults(map[string]refs.Ref)

	// Returns the current result.
	Result() refs.Ref

	// These methods are the heart and soul of the iterator, as they constitute
	// the iteration interface.
	//
	// To get the full results of iteration, do the following:
	//
	//  for it.Next(ctx) {
	//  	val := it.Result()
	//  	... do things with val.
	//  	for it.NextPath(ctx) {
	//  		... find other paths to iterate
	//  	}
	//  }
	//
	// All of them should set iterator.result to be the last returned value, to
	// make results work.
	//
	// NextPath() advances iterators that may have more than one valid result,
	// from the bottom up.
	NextPath(ctx context.Context) bool

	// Err returns any error that was encountered by the Iterator.
	Err() error

	// Close the iterator and do internal cleanup.
	Close() error
}

Base is a set of common methods for Scanner and Index iterators.

type Chain

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

Chain is a chain-enabled helper to setup iterator execution.

func Iterate

func Iterate(ctx context.Context, it Shape) *Chain

Iterate is a set of helpers for iteration. Context may be used to cancel execution. Iterator will be optimized and closed after execution.

By default, iteration has no limit and includes sub-paths.

func (*Chain) All

func (c *Chain) All() ([]refs.Ref, error)

All will return all results of an iterator.

func (*Chain) AllValues

func (c *Chain) AllValues(qs refs.Namer) ([]quad.Value, error)

AllValues is an analog of All, but it will additionally call NameOf for each graph.Ref before returning the results slice.

func (*Chain) Count

func (c *Chain) Count() (int64, error)

All will return all results of an iterator.

func (*Chain) Each

func (c *Chain) Each(fnc func(refs.Ref) error) error

Each will run a provided callback for each result of the iterator.

func (*Chain) EachValue

func (c *Chain) EachValue(qs refs.Namer, fnc func(quad.Value) error) error

EachValue is an analog of Each, but it will additionally call NameOf for each graph.Ref before passing it to a callback.

func (*Chain) EachValuePair

func (c *Chain) EachValuePair(qs refs.Namer, fnc func(refs.Ref, quad.Value) error) error

EachValuePair is an analog of Each, but it will additionally call NameOf for each graph.Ref before passing it to a callback. Original value will be passed as well.

func (*Chain) First

func (c *Chain) First() (refs.Ref, error)

First will return a first result of an iterator. It returns nil if iterator is empty.

func (*Chain) FirstValue

func (c *Chain) FirstValue(qs refs.Namer) (quad.Value, error)

FirstValue is an analog of First, but it does lookup of a value in QuadStore.

func (*Chain) Limit

func (c *Chain) Limit(n int) *Chain

Limit limits a total number of results returned.

func (*Chain) On

func (c *Chain) On(qs refs.Namer) *Chain

On sets a default quad store for iteration. If qs was set, it may be omitted in other functions.

func (*Chain) Paths

func (c *Chain) Paths(enable bool) *Chain

Paths switches iteration over sub-paths (with it.NextPath). Defaults to true.

func (*Chain) Send

func (c *Chain) Send(out chan<- refs.Ref) error

Send will send each result of the iterator to the provided channel.

Channel will NOT be closed when function returns.

func (*Chain) SendValues

func (c *Chain) SendValues(qs refs.Namer, out chan<- quad.Value) error

SendValues is an analog of Send, but it will additionally call NameOf for each graph.Ref before sending it to a channel.

func (*Chain) TagEach

func (c *Chain) TagEach(fnc func(map[string]refs.Ref) error) error

TagEach will run a provided tag map callback for each result of the iterator.

func (*Chain) TagValues

func (c *Chain) TagValues(qs refs.Namer, fnc func(map[string]quad.Value) error) error

TagValues is an analog of TagEach, but it will additionally call NameOf for each graph.Ref before passing the map to a callback.

func (*Chain) UnOptimized

func (c *Chain) UnOptimized() *Chain

UnOptimized disables iterator optimization.

type Costs

type Costs struct {
	ContainsCost int64
	NextCost     int64
	Size         refs.Size
}

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 Shape, qs refs.Namer) *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) Iterate

func (it *Count) Iterate() Scanner

func (*Count) Lookup

func (it *Count) Lookup() Index

func (*Count) Optimize

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

func (*Count) Stats

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

func (*Count) String

func (it *Count) String() string

func (*Count) SubIterators

func (it *Count) SubIterators() []Shape

SubIterators returns a slice of the sub iterators.

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

func (it *Error) Close() error

func (*Error) Contains

func (it *Error) Contains(ctx context.Context, v refs.Ref) bool

func (*Error) Err

func (it *Error) Err() error

func (*Error) Iterate

func (it *Error) Iterate() Scanner

func (*Error) Lookup

func (it *Error) Lookup() Index

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(ctx context.Context) (Shape, bool)

func (*Error) Reset

func (it *Error) Reset()

func (*Error) Result

func (it *Error) Result() refs.Ref

func (*Error) Stats

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

func (*Error) String

func (it *Error) String() string

func (*Error) SubIterators

func (it *Error) SubIterators() []Shape

func (*Error) TagResults

func (it *Error) TagResults(dst map[string]refs.Ref)

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

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 ...refs.Ref) *Fixed

NewFixed creates a new Fixed iterator with a custom comparator.

func (*Fixed) Add

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

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

func (it *Fixed) Iterate() Scanner

func (*Fixed) Lookup

func (it *Fixed) Lookup() Index

func (*Fixed) Optimize

func (it *Fixed) Optimize(ctx context.Context) (Shape, 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) Stats

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

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() []Shape

No sub-iterators.

func (*Fixed) Values

func (it *Fixed) Values() []refs.Ref

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

type Index

type Index interface {
	Base

	// Contains returns whether the value is within the set held by the iterator.
	//
	// It will set Result to the matching subtree. TagResults can be used to collect values from tree branches.
	Contains(ctx context.Context, v refs.Ref) bool
}

Index is an index lookup iterator. It allows to check if an index contains a specific value.

type Int64Node

type Int64Node int64

func (Int64Node) IsNode

func (Int64Node) IsNode() bool

func (Int64Node) Key

func (v Int64Node) 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(it Shape, max int64) *Limit

func (*Limit) Iterate

func (it *Limit) Iterate() Scanner

func (*Limit) Lookup

func (it *Limit) Lookup() Index

func (*Limit) Optimize

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

func (*Limit) Stats

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

func (*Limit) String

func (it *Limit) String() string

func (*Limit) SubIterators

func (it *Limit) SubIterators() []Shape

SubIterators returns a slice of the sub iterators.

type Materialize

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

func NewMaterialize

func NewMaterialize(sub Shape) *Materialize

func NewMaterializeWithSize

func NewMaterializeWithSize(sub Shape, size int64) *Materialize

func (*Materialize) Iterate

func (it *Materialize) Iterate() Scanner

func (*Materialize) Lookup

func (it *Materialize) Lookup() Index

func (*Materialize) Optimize

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

func (*Materialize) Stats

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

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() []Shape

type Morphism

type Morphism func(Shape) Shape

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 Shape) *Not

func (*Not) Iterate

func (it *Not) Iterate() Scanner

func (*Not) Lookup

func (it *Not) Lookup() Index

func (*Not) Optimize

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

func (*Not) Stats

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

func (*Not) String

func (it *Not) String() string

func (*Not) SubIterators

func (it *Not) SubIterators() []Shape

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

type Null

type Null struct{}

Null is 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

NewNull creates a new Null iterator Fairly useless New function.

func (*Null) Close

func (it *Null) Close() error

func (*Null) Contains

func (it *Null) Contains(ctx context.Context, v refs.Ref) bool

func (*Null) Err

func (it *Null) Err() error

func (*Null) Iterate

func (it *Null) Iterate() Scanner

Iterate implements Iterator

func (*Null) Lookup

func (it *Null) Lookup() Index

Lookup implements Iterator

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(ctx context.Context) (Shape, 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() refs.Ref

func (*Null) Stats

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

A null iterator costs nothing. Use it!

func (*Null) String

func (it *Null) String() string

func (*Null) SubIterators

func (it *Null) SubIterators() []Shape

func (*Null) TagResults

func (it *Null) TagResults(dst map[string]refs.Ref)

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

type Operator

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

func (Operator) String

func (op Operator) String() string

type Or

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

func NewOr

func NewOr(sub ...Shape) *Or

func NewShortCircuitOr

func NewShortCircuitOr(sub ...Shape) *Or

func (*Or) AddSubIterator

func (it *Or) AddSubIterator(sub Shape)

Add a subiterator to this Or iterator. Order matters.

func (*Or) Iterate

func (it *Or) Iterate() Scanner

func (*Or) Lookup

func (it *Or) Lookup() Index

func (*Or) Optimize

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

func (*Or) Stats

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

Returns the approximate size of the Or 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) String

func (it *Or) String() string

func (*Or) SubIterators

func (it *Or) SubIterators() []Shape

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

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(it Shape, morphism Morphism, maxDepth int) *Recursive

func (*Recursive) AddDepthTag

func (it *Recursive) AddDepthTag(s string)

func (*Recursive) Iterate

func (it *Recursive) Iterate() Scanner

func (*Recursive) Lookup

func (it *Recursive) Lookup() Index

func (*Recursive) Optimize

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

func (*Recursive) Stats

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

func (*Recursive) String

func (it *Recursive) String() string

func (*Recursive) SubIterators

func (it *Recursive) SubIterators() []Shape

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 refs.Namer, nodes ...quad.Value) *Resolver

NewResolver creates a new Resolver iterator.

func (*Resolver) Iterate

func (it *Resolver) Iterate() Scanner

func (*Resolver) Lookup

func (it *Resolver) Lookup() Index

func (*Resolver) Optimize

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

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

func (*Resolver) Stats

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

func (*Resolver) String

func (it *Resolver) String() string

func (*Resolver) SubIterators

func (it *Resolver) SubIterators() []Shape

type Save

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

func NewSave

func NewSave(on Shape, tags ...string) *Save

func (*Save) AddFixedTag

func (it *Save) AddFixedTag(tag string, value refs.Ref)

func (*Save) AddTags

func (it *Save) AddTags(tag ...string)

Add a tag to the iterator.

func (*Save) CopyFromTagger

func (it *Save) CopyFromTagger(st TaggerBase)

func (*Save) FixedTags

func (it *Save) FixedTags() map[string]refs.Ref

Fixed returns the fixed tags held in the tagger. The returned value must not be mutated.

func (*Save) Iterate

func (it *Save) Iterate() Scanner

func (*Save) Lookup

func (it *Save) Lookup() Index

func (*Save) Optimize

func (it *Save) Optimize(ctx context.Context) (nit Shape, no bool)

func (*Save) Stats

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

func (*Save) String

func (it *Save) String() string

func (*Save) SubIterators

func (it *Save) SubIterators() []Shape

func (*Save) Tags

func (it *Save) Tags() []string

Tags returns the tags held in the tagger. The returned value must not be mutated.

type Scanner

type Scanner interface {
	Base

	// Next advances the iterator to the next value, which will then be available through
	// the Result method. It returns false if no further advancement is possible, or if an
	// error was encountered during iteration.  Err should be consulted to distinguish
	// between the two cases.
	Next(ctx context.Context) bool
}

Scanner is an iterator that lists all results sequentially, but not necessarily in a sorted order.

func NewLimitNext

func NewLimitNext(it Scanner, limit int64) Scanner

type Shape

type Shape interface {

	// String returns a short textual representation of an iterator.
	String() string

	// Iterate starts this iterator in scanning mode. Resulting iterator will list all
	// results sequentially, but not necessary in the sorted order. Caller must close
	// the iterator.
	Iterate() Scanner

	// Lookup starts this iterator in an index lookup mode. Depending on the iterator type,
	// this may still involve database scans. Resulting iterator allows to check an index
	// contains a specified value. Caller must close the iterator.
	Lookup() Index

	// These methods relate to choosing the right iterator, or optimizing an
	// iterator tree
	//
	// Stats() returns the relative costs of calling the iteration methods for
	// this iterator, as well as the size. Roughly, it will take NextCost * Size
	// "cost units" to get everything out of the iterator. This is a wibbly-wobbly
	// thing, and not exact, but a useful heuristic.
	Stats(ctx context.Context) (Costs, error)

	// Optimizes an iterator. Can replace the iterator, or merely move things
	// around internally. if it chooses to replace it with a better iterator,
	// returns (the new iterator, true), if not, it returns (self, false).
	Optimize(ctx context.Context) (Shape, bool)

	// Return a slice of the subiterators for this iterator.
	SubIterators() []Shape
}

Shape is an iterator shape, similar to a query plan. But the plan is not specific in this case - it is used to reorder query branches, and the decide what branches will be scanned and what branches will lookup values (hopefully from the index, but not necessarily).

func NewComparison

func NewComparison(sub Shape, op Operator, val quad.Value, qs refs.Namer) Shape

func NewRegex

func NewRegex(sub Shape, re *regexp.Regexp, qs refs.Namer) Shape

NewRegex returns an 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 NewRegexWithRefs

func NewRegexWithRefs(sub Shape, re *regexp.Regexp, qs refs.Namer) Shape

NewRegexWithRefs is like NewRegex but 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 Tag

func Tag(it Shape, tag string) Shape

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 Shape, off int64) *Skip

func (*Skip) Iterate

func (it *Skip) Iterate() Scanner

func (*Skip) Lookup

func (it *Skip) Lookup() Index

func (*Skip) Optimize

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

func (*Skip) Stats

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

func (*Skip) String

func (it *Skip) String() string

func (*Skip) SubIterators

func (it *Skip) SubIterators() []Shape

SubIterators returns a slice of the sub iterators.

type Sort

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

Sort iterator orders values from it's subiterator.

func NewSort

func NewSort(namer refs.Namer, subIt Shape) *Sort

NewSort creates a new Sort iterator. TODO(dennwc): This iterator must not be used inside And: it may be moved to a Contains branch and won't do anything.

We should make And/Intersect account for this.

func (*Sort) Iterate

func (it *Sort) Iterate() Scanner

func (*Sort) Lookup

func (it *Sort) Lookup() Index

func (*Sort) Optimize

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

func (*Sort) Stats

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

func (*Sort) String

func (it *Sort) String() string

func (*Sort) SubIterators

func (it *Sort) SubIterators() []Shape

SubIterators returns a slice of the sub iterators.

type TaggerBase

type TaggerBase interface {
	Tags() []string
	FixedTags() map[string]refs.Ref
	AddTags(tag ...string)
	AddFixedTag(tag string, value refs.Ref)
}

TaggerBase is a base interface for Tagger and TaggerShape.

type TaggerShape

type TaggerShape interface {
	Shape
	TaggerBase
	CopyFromTagger(st TaggerBase)
}

TaggerShape is an interface for iterators that can tag values. Tags are returned as a part of TagResults call.

type Unique

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

Unique iterator removes duplicate values from it's subiterator.

func NewUnique

func NewUnique(subIt Shape) *Unique

func (*Unique) Iterate

func (it *Unique) Iterate() Scanner

func (*Unique) Lookup

func (it *Unique) Lookup() Index

func (*Unique) Optimize

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

func (*Unique) Stats

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

func (*Unique) String

func (it *Unique) String() string

func (*Unique) SubIterators

func (it *Unique) SubIterators() []Shape

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

type ValueFilter

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

func NewValueFilter

func NewValueFilter(qs refs.Namer, sub Shape, filter ValueFilterFunc) *ValueFilter

func (*ValueFilter) Iterate

func (it *ValueFilter) Iterate() Scanner

func (*ValueFilter) Lookup

func (it *ValueFilter) Lookup() Index

func (*ValueFilter) Optimize

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

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

func (*ValueFilter) Stats

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

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

func (*ValueFilter) String

func (it *ValueFilter) String() string

func (*ValueFilter) SubIterators

func (it *ValueFilter) SubIterators() []Shape

type ValueFilterFunc

type ValueFilterFunc func(quad.Value) (bool, error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL