com.bigdata.resources

Class AbstractTestSegSplitter.RejectSplitsAfterKey

java.lang.Object

com.bigdata.resources.AbstractTestSegSplitter.RejectSplitsAfterKey

All Implemented Interfaces:

ISimpleSplitHandler

Enclosing class:

AbstractTestSegSplitter

protected static class AbstractTestSegSplitter.RejectSplitsAfterKey
extends Object
implements ISimpleSplitHandler

Accepts the recommended separator key unless it is GTE the key given to the constructor, in which case it refuses to accept any splits.

Constructor Summary

Constructors

Constructor and Description
AbstractTestSegSplitter.RejectSplitsAfterKey(byte[] rejectKey)

Method Summary

Methods

Modifier and Type	Method and Description
byte[]	getSeparatorKey(IndexSegment seg, int fromIndex, int toIndex, int splitAt) Return a separator key close to the recommended separator key (splitAt) which is acceptable to the constraints imposed by the application on the index.

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractTestSegSplitter.RejectSplitsAfterKey

public AbstractTestSegSplitter.RejectSplitsAfterKey(byte[] rejectKey)

Method Detail

getSeparatorKey

public byte[] getSeparatorKey(IndexSegment seg,
                     int fromIndex,
                     int toIndex,
                     int splitAt)

Description copied from interface: ISimpleSplitHandler

Return a separator key close to the recommended separator key (splitAt) which is acceptable to the constraints imposed by the application on the index. This method is invoked iteratively starting with the index of first addressable tuple in the index segment as the fromIndex and the index of the last addressable tuple as the toIndex. Each time a non-null separator key is returned, the fromIndex is advanced to the first key GTE the separator key. This process continues until no more splits may be formed, whether because there are not enough tuples remaining to justify a split or because the application has refused a split for the key range by returning null from this method. To accept the recommended separator key, the application should do return seg.keyAt(splitAt)

An application may apply a constraint when it provides some guarantee which would otherwise not be obtained. For example, the SparseRowStore uses this mechanism to constrain splits such that a logical row is never split, which gives the SparseRowStore the ability to offer ACID operations on logical rows using only local locking.

Applications can implement this constraint in many different ways. For example: (A) applications can scan forward or backward using an ITupleCursor looking for an acceptable separatorKey near to the recommended separatorKey; (B) applications can use the ILinearList API to probe for a suitable key; or (C) applications can truncate the recommended separator key in order to obtain a prefix which will respect some application constraint such as all RDF statements sharing a common subject.

If the implementation returns null then it is asserting that there is no separator key in the half-open range which is acceptable and therefore that the key-range CAN NOT be split. All tuples in that key range will therefore go into a single split.

Specified by:

getSeparatorKey in interface ISimpleSplitHandler

Parameters:

seg - The IndexSegment containing the data to be split.

fromIndex - The index of the first tuple which may be considered (inclusive lower bound).

toIndex - The index of the last tuple which may be considered (exclusive upper bound).

splitAt - The index of the recommended separator key.

Returns:

The desired separator key. If no acceptable separator key could be found or constructed then return null.