com.bigdata.journal

Class AbstractCommitTimeIndex<T extends ICommitTimeEntry>

java.lang.Object

com.bigdata.btree.DelegateIndex

com.bigdata.btree.DelegateBTree

com.bigdata.journal.AbstractCommitTimeIndex<T>

All Implemented Interfaces:

IAutoboxBTree, IIndex, IIndexLocalCounter, ILinearList, IRangeQuery, ISimpleBTree, ICounterSetAccess

public class AbstractCommitTimeIndex<T extends ICommitTimeEntry>
extends DelegateBTree
implements ILinearList

Abstract BTree mapping commitTime (long integers) to ICommitTimeEntry objects.

This class is thread-safe for concurrent readers and writers.

Field Summary

Fields inherited from interface com.bigdata.btree.IRangeQuery

ALL, CURSOR, DEFAULT, DELETED, FIXED_LENGTH_SUCCESSOR, KEYS, NONE, PARALLEL, READONLY, REMOVEALL, REVERSE, VALS

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractCommitTimeIndex(BTree ndx)

Method Summary

Methods

Modifier and Type	Method and Description
void	add(T entry) Add an entry under the commitTime associated with the entry.
T	find(long timestamp) Return the IRootBlock identifying the journal having the largest commitTime that is less than or equal to the given timestamp.
T	findByCommitCounter(long commitCounter) Find the oldest entry whose commit counter is LTE the specified commit counter.
long	findIndexOf(long commitTime) Find the index of the entry associated with the largest commitTime that is less than or equal to the given timestamp.
T	findNext(long timestamp) Return the first entry whose commitTime is strictly greater than the timestamp.
T	getEntryByReverseIndex(int index) Return the entry that is associated with the specified ordinal index (origin ZERO) counting backwards from the most recent entry (0) towards the earliest entry (nentries-1).
long	getEntryCount()
byte[]	getKey(long commitTime) Encodes the commit time into a key.
T	getNewestEntry() Find the the most recent entry (if any).
T	getOldestEntry() Find and return the oldest entry (if any).
Lock	readLock() Returns (but does not take) the ReentrantReadWriteLock.ReadLock.
void	removeAll()
Tuple<T>	valueAt(long index, Tuple<T> t)
Lock	writeLock() Returns (but does not take) the ReentrantReadWriteLock.WriteLock.

Methods inherited from class com.bigdata.btree.DelegateBTree

indexOf, keyAt, valueAt

Methods inherited from class com.bigdata.btree.DelegateIndex

contains, contains, getCounter, getCounters, getIndexMetadata, getResourceMetadata, insert, insert, lookup, lookup, putIfAbsent, rangeCount, rangeCount, rangeCountExact, rangeCountExactWithDeleted, rangeIterator, rangeIterator, rangeIterator, remove, remove, submit, submit, submit, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.bigdata.btree.ILinearList

indexOf, keyAt, valueAt

Constructor Detail

AbstractCommitTimeIndex

protected AbstractCommitTimeIndex(BTree ndx)

Method Detail

getKey

public byte[] getKey(long commitTime)

Encodes the commit time into a key.

Parameters:

commitTime - The commit time.

Returns:

The corresponding key.

readLock

public Lock readLock()

Returns (but does not take) the ReentrantReadWriteLock.ReadLock.

writeLock

public Lock writeLock()

Returns (but does not take) the ReentrantReadWriteLock.WriteLock.

getEntryCount

public long getEntryCount()

valueAt

public Tuple<T> valueAt(long index,
               Tuple<T> t)

find

public T find(long timestamp)

Return the IRootBlock identifying the journal having the largest commitTime that is less than or equal to the given timestamp. This is used primarily to locate the commit record that will serve as the ground state for a transaction having timestamp as its start time. In this context the LTE search identifies the most recent commit state that not later than the start time of the transaction.

Parameters:

timestamp - The given timestamp.

Returns:

The description of the relevant journal resource -or- null iff there are no journals in the index that satisify the probe.

Throws:

IllegalArgumentException - if timestamp is less than ZERO (0L).

findNext

public T findNext(long timestamp)

Return the first entry whose commitTime is strictly greater than the timestamp.

Parameters:

timestamp - The timestamp. A value of ZERO (0) may be used to find the first entry.

Returns:

The root block of that entry -or- null if there is no entry whose timestamp is strictly greater than timestamp.

Throws:

IllegalArgumentException - if timestamp is less than ZERO (0L).

findIndexOf

public long findIndexOf(long commitTime)

Find the index of the entry associated with the largest commitTime that is less than or equal to the given timestamp.

Parameters:

commitTime - The timestamp.

Returns:

The index of the entry associated with the largest commitTime that is less than or equal to the given timestamp -or- -1 iff the index is empty.

Throws:

IllegalArgumentException - if timestamp is less than ZERO (0L).

add

public void add(T entry)

Add an entry under the commitTime associated with the entry.

Parameters:

entry - The entry

Throws:

IllegalArgumentException - if commitTime is 0L.

IllegalArgumentException - if rootBLock is null.

IllegalArgumentException - if there is already an entry registered under for the given timestamp.

getOldestEntry

public T getOldestEntry()

Find and return the oldest entry (if any).

Returns:

That entry -or- null if there are no entries.

getNewestEntry

public T getNewestEntry()

Find the the most recent entry (if any).

Returns:

That entry -or- null if there are no entries.

findByCommitCounter

public T findByCommitCounter(long commitCounter)

Find the oldest entry whose commit counter is LTE the specified commit counter.

Returns:

The entry -or- null if there is no such entry.

Throws:

IllegalArgumentException - if commitCounter LT ZERO (0) TODO It is possible to improve the performance for this for large indices using a binary search. Each time we probe the index we discover a specific commit counter value. If the value is LT the target, we need to search above that probe. If GT the target, we need to search below that problem.

getEntryByReverseIndex

public T getEntryByReverseIndex(int index)

Return the entry that is associated with the specified ordinal index (origin ZERO) counting backwards from the most recent entry (0) towards the earliest entry (nentries-1).

Note: The effective index is given by (entryCount-1)-index. If the effective index is LT ZERO (0) then there is no such entry and this method will return null.

Parameters:

index - The index.

Returns:

The entry -or- null if there is no such entry.

Throws:

IllegalArgumentException - if index LT ZERO (0)

removeAll

public void removeAll()