com.bigdata.relation.accesspath

Class ArrayAccessPath<E>

java.lang.Object

com.bigdata.relation.accesspath.ArrayAccessPath<E>

All Implemented Interfaces:

IAbstractAccessPath<E>, IAccessPath<E>

public class ArrayAccessPath<E>
extends Object
implements IAccessPath<E>

An access path over an array of elements.

Constructor Summary

Constructors

Constructor and Description
ArrayAccessPath(E[] e) Ctor variant does not specify the getPredicate() or the getKeyOrder() and those methods will throw an UnsupportedOperationException if invoked.
ArrayAccessPath(E[] e, IPredicate<E> predicate, IKeyOrder<E> keyOrder) Note: the getPredicate() and getKeyOrder() and methods will throw an UnsupportedOperationException if the corresponding argument is null.

Method Summary

Methods

Modifier and Type	Method and Description
IIndex	getIndex() The index selected for the access path.
IKeyOrder<E>	getKeyOrder() The order in which the elements will be visited.
IPredicate<E>	getPredicate() The constraints on the IAccessPath.
boolean	isEmpty() True iff the access path is empty (there are no matches for the IPredicate) This is more conclusive than #rangeCount() since you MAY have a non-zero range count when the key range is in fact empty (there may be "deleted" index entries within the key range).
IChunkedOrderedIterator<E>	iterator() An iterator visiting elements using the natural order of the index selected for the IPredicate.
IChunkedOrderedIterator<E>	iterator(long offset, long limit, int capacity) An iterator visiting elements using the natural order of the index selected for the IPredicate.
long	rangeCount(boolean exact) Return the maximum #of elements spanned by the IPredicate.
long	removeAll() Remove all elements selected by the IPredicate (optional operation).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ArrayAccessPath

public ArrayAccessPath(E[] e)

Ctor variant does not specify the getPredicate() or the getKeyOrder() and those methods will throw an UnsupportedOperationException if invoked.

ArrayAccessPath

public ArrayAccessPath(E[] e,
               IPredicate<E> predicate,
               IKeyOrder<E> keyOrder)

Note: the getPredicate() and getKeyOrder() and methods will throw an UnsupportedOperationException if the corresponding argument is null.

Method Detail

getPredicate

public IPredicate<E> getPredicate()

The constraints on the IAccessPath.

Specified by:

getPredicate in interface IAbstractAccessPath<E>

Throws:

UnsupportedOperationException - unless the caller specified an IPredicate to the ctor.

getKeyOrder

public IKeyOrder<E> getKeyOrder()

The order in which the elements will be visited.

Specified by:

getKeyOrder in interface IAccessPath<E>

Throws:

UnsupportedOperationException - unless the caller specified an IKeyOrder to the ctor.

getIndex

public 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.

Specified by:

getIndex in interface IAccessPath<E>

Throws:

UnsupportedOperationException - since no index is associated with this array

isEmpty

public boolean isEmpty()

True iff the access path is empty (there are no matches for the IPredicate) This is more conclusive than #rangeCount() since you MAY have a non-zero range count when the key range is in fact empty (there may be "deleted" index entries within the key range).

Returns true when the array of elements is empty.

Specified by:

isEmpty in interface IAbstractAccessPath<E>

rangeCount

public long rangeCount(boolean exact)

Return the maximum #of elements spanned by the IPredicate.

Note: When there is an IFilter on the IPredicate the exact range count MUST apply that IFilter, which means that it will be required to traverse the index counting tuples which pass the IFilter. However, IFilters are ignored for the fast range count.

Returns the size of the array of elements.

Specified by:

rangeCount in interface IAbstractAccessPath<E>

Parameters:

exact - When true, the result will be an exact count and may require a key-range scan. When false, the result will be an upper bound IFF delete markers are provisioned for the backing index (delete markers are required for transactions and for scale-out indices).

See Also:

IRangeQuery

iterator

public IChunkedOrderedIterator<E> 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.

Visits the entire array of elements.

Specified by:

iterator in interface IAccessPath<E>

Returns:

The iterator.

See Also:

IRelation.getAccessPath(IPredicate)

iterator

public IChunkedOrderedIterator<E> 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.

Visits the array of elements from the specified offset up to the specified limit.

Specified by:

iterator in interface IAccessPath<E>

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 IAccessPath.iterator() to determine if any elements can be visited.

removeAll

public long removeAll()

Remove all elements selected by the IPredicate (optional operation).

Does nothing and always returns ZERO(0).

Specified by:

removeAll in interface IAbstractAccessPath<E>

Returns:

The #of elements that were removed.