com.bigdata.relation.accesspath

Interface IAccessPath<R>

Type Parameters:

R - The generic type of the [R]elation elements of the IRelation.

All Superinterfaces:

IAbstractAccessPath<R>

All Known Implementing Classes:

AccessPath, AccessPathFusedView, ArrayAccessPath, BackchainAccessPath, EmptyAccessPath, SPOAccessPath

public interface IAccessPath<R>
extends IAbstractAccessPath<R>

An abstraction for efficient reads of IElements 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.

Version:

$Id$

Author:

Bryan Thompson

Method Summary

Methods

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.

Methods inherited from interface com.bigdata.relation.accesspath.IAbstractAccessPath

getPredicate, isEmpty, rangeCount, removeAll

Method Detail

getKeyOrder

IKeyOrder<R> getKeyOrder()

The order in which the elements will be visited.

getIndex

IIndex getIndex()

The index selected for the access path.

Note: The access path may incorporate additional constraints from the specified IPredicate that are not present on the IIndex returned by this method.

iterator

IChunkedOrderedIterator<R> iterator()

An iterator visiting elements using the natural order of the index selected for the 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.

Returns:

The iterator.

See Also:

IRelation.getAccessPath(IPredicate)

iterator

IChunkedOrderedIterator<R> iterator(long offset,
                                  long limit,
                                  int capacity)

An iterator visiting elements using the natural order of the index selected for the 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.

Parameters:

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.

Returns:

The iterator. FIXME The offset and limit should probably be rolled into the predicate and removed from the IAccessPath. This way they will be correctly applied when IAbstractAccessPath.isEmpty() is implemented using the iterator() to determine if any elements can be visited.