R
- The generic type of the [R]elation elements of the
IRelation
.public interface IAccessPath<R> extends IAbstractAccessPath<R>
IElement
s from a
IRelation
using the index selected by an IPredicate
constraint. Like their iterator()
, implementations of this interface
are NOT required to be thread-safe. They are designed for a single-threaded
consumer.Modifier and Type | Method and Description |
---|---|
IIndex |
getIndex()
The index selected for the access path.
|
IKeyOrder<R> |
getKeyOrder()
The order in which the elements will be visited.
|
IChunkedOrderedIterator<R> |
iterator()
An iterator visiting elements using the natural order of the index
selected for the
IPredicate . |
IChunkedOrderedIterator<R> |
iterator(long offset,
long limit,
int capacity)
An iterator visiting elements using the natural order of the index
selected for the
IPredicate . |
getPredicate, isEmpty, rangeCount, removeAll
IIndex getIndex()
Note: The access path may incorporate additional constraints from the
specified IPredicate
that are not present on the IIndex
returned by this method.
IChunkedOrderedIterator<R> iterator()
IPredicate
. This is equivalent to
iterator(0L, 0L, 0)since an offset of ZERO (0L) means no offset, a limit of ZERO (0L) means no limit and a capacity of ZERO (0) means whatever is the default capacity.
Note: Filters should be specified when the IAccessPath
is
constructed so that they will be evaluated on the IDataService
rather than materializing the elements and then filtering then. This can
be accomplished by adding the filter as an IElementFilter
on the
IPredicate
when requesting IAccessPath
.
IRelation.getAccessPath(IPredicate)
IChunkedOrderedIterator<R> iterator(long offset, long limit, int capacity)
IPredicate
.
The offset and limit together describe an optional
slice that will be visited by the iterator. When a slice is
specified, the iterator will count off the elements accepted by the
IPredicate
up to the offset, but not materialize them.
Elements by the IPredicate
starting with the offset and up
to (but not including) offset+limit will be materialized for the
client. The iterator will halt processing after observing
offset+limit accepted elements. Note that slices for JOINs (vs a
simple IAccessPath
scan) are handled by IQueryOptions
for
an IRule
.
The meaning of "accepted" is that: (a) the elements lie in the key-range
constraint implied by the IPredicate
; and (b) the elements pass
any optional constraints that the IPredicate
imposes.
offset
- The first element accepted by the iterator that it will visit
(materialize for the client). The offset must be non-negative.
This is ZERO (0L) to visit all accepted elements.limit
- The last element accepted by the iterator that it will visit
(materialize for the client). The limit must be non-negative.
This is ZERO (0L) to visit all accepted elements (the value
Long.MAX_VALUE
is interpreted exactly like ZERO(0L)).capacity
- The maximum capacity for the buffer used by the iterator. When
ZERO(0), a default capacity will be used. When a limit
is specified, the capacity will never exceed the limit.IAccessPath
. This way they
will be correctly applied when IAbstractAccessPath.isEmpty()
is implemented
using the iterator()
to determine if any elements can be
visited.Copyright © 2006–2019 SYSTAP, LLC DBA Blazegraph. All rights reserved.