com.bigdata.sparse

Class LogicalRowSplitHandler

java.lang.Object

com.bigdata.sparse.LogicalRowSplitHandler

All Implemented Interfaces:

ISimpleSplitHandler, Externalizable, Serializable

public class LogicalRowSplitHandler
extends Object
implements ISimpleSplitHandler, Externalizable

This class imposes the constraint that the separator key must not split a logical. This constraint is required in order for the logical row store to retain its row-wise ACID semantics when there is more than one shard for that row store. This is done using a linear scan forward from the recommended splitAt index until the first tuple is identified which would be part of a different logical row. The index of that tuple is returned.

Version:

$Id$

Author:

Bryan Thompson

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
static ISimpleSplitHandler	INSTANCE
protected static org.apache.log4j.Logger	log

Constructor Summary

Constructors

Constructor and Description
LogicalRowSplitHandler()

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.
void	readExternal(ObjectInput in)
void	writeExternal(ObjectOutput out)

Methods inherited from class java.lang.Object

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

Field Detail

log

protected static final transient org.apache.log4j.Logger log

INSTANCE

public static final transient ISimpleSplitHandler INSTANCE

Constructor Detail

LogicalRowSplitHandler

public LogicalRowSplitHandler()

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.

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Specified by:

readExternal in interface Externalizable

Throws:

IOException

ClassNotFoundException

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:

writeExternal in interface Externalizable

Throws:

IOException