com.illumon.iris.db.v2.sources

Interface ColumnSource<T>

All Superinterfaces:

TupleExporter<T>, TupleSource<T>

All Known Implementing Classes:

AbstractColumnSource, NullValueColumnSource

public interface ColumnSource<T>
extends TupleSource<T>

A "source" for column data - allows cell values to be looked up by (long) keys.

Note for implementors: All ColumnSource implementations must map Index.NULL_KEY to a null value for all get and getPrev methods.

Field Summary

Fields

Modifier and Type	Field and Description
static ColumnSource[]	ZERO_LENGTH_COLUMN_SOURCE_ARRAY

Method Summary

Modifier and Type	Method and Description
<ALTERNATE_DATA_TYPE> boolean	allowsReinterpret(Class<ALTERNATE_DATA_TYPE> alternateDataType) Test if a reinterpret call will succeed.
default T	createPreviousTuple(long indexKey) Create a tuple for previous key column values at the supplied index key.
default T	createTuple(long indexKey) Create a tuple for key column values at the supplied index key.
default T	createTupleFromValues(Object... values) Create a tuple for the supplied (boxed) values.
default Object	exportElement(T tuple, int elementIndex) Export a single element from the tuple, identified by its element index, to an Object
default <ELEMENT_TYPE> void	exportElement(T tuple, int elementIndex, WritableSource<ELEMENT_TYPE> writableSource, long destinationIndexKey) Export a single element from the tuple, identified by its element index, to the destination index key of the supplied writable source.
default Object	exportToExternalKey(T tuple) Export this tuple's element list as a key suitable for the TableMaps resulting from Table.byExternal(com.illumon.iris.db.tables.Table.ByStrategy, boolean, java.lang.String...).
T	get(long index)
Boolean	getBoolean(long index)
byte	getByte(long index)
byte[]	getBytes(long index, int length, byte[] dest)
char	getChar(long index)
default List<ColumnSource>	getColumnSources() Get the ColumnSources backing this tuple source.
Class<?>	getComponentType()
double	getDouble(long index)
float	getFloat(long index)
Map<T,Index>	getGroupToRange() Compute grouping information for all keys present in this column source.
Map<T,Index>	getGroupToRange(Index index) Compute grouping information for (at least) all keys present in index.
int	getInt(long index)
long	getLong(long index)
T	getPrev(long index)
Boolean	getPrevBoolean(long index)
byte	getPrevByte(long index)
char	getPrevChar(long index)
double	getPrevDouble(long index)
float	getPrevFloat(long index)
int	getPrevInt(long index)
long	getPrevLong(long index)
short	getPrevShort(long index)
long[]	getPrevSortMapping(Index sourceIndex, SortingOrder sortingOrder)
short	getShort(long index)
long[]	getSortMapping(Index sourceIndex, SortingOrder sortingOrder)
Class<T>	getType()
Map<T,Index>	getValuesMapping(Index subRange)
boolean	isImmutable()
Index	match(boolean invertMatch, boolean usePrev, boolean caseInsensitive, Index mapper, Object... keys)
<ALTERNATE_DATA_TYPE> ColumnSource<ALTERNATE_DATA_TYPE>	reinterpret(Class<ALTERNATE_DATA_TYPE> alternateDataType) Provide an alternative view into the data underlying this column source.
void	releaseCachedResources() Release any resources held for caching purposes.
default void	startTrackingPrevValues() ColumnSource implementations that track previous values have the option to not actually start tracking previous values until this method is called.

Field Detail

ZERO_LENGTH_COLUMN_SOURCE_ARRAY

static final ColumnSource[] ZERO_LENGTH_COLUMN_SOURCE_ARRAY

Method Detail

get

T get(long index)

getBoolean

Boolean getBoolean(long index)

getByte

byte getByte(long index)

getBytes

byte[] getBytes(long index,
                int length,
                byte[] dest)

getChar

char getChar(long index)

getDouble

double getDouble(long index)

getFloat

float getFloat(long index)

getInt

int getInt(long index)

getLong

long getLong(long index)

getShort

short getShort(long index)

getPrev

T getPrev(long index)

getPrevBoolean

Boolean getPrevBoolean(long index)

getPrevByte

byte getPrevByte(long index)

getPrevChar

char getPrevChar(long index)

getPrevDouble

double getPrevDouble(long index)

getPrevFloat

float getPrevFloat(long index)

getPrevInt

int getPrevInt(long index)

getPrevLong

long getPrevLong(long index)

getPrevShort

short getPrevShort(long index)

getType

Class<T> getType()

getComponentType

Class<?> getComponentType()

match

Index match(boolean invertMatch,
            boolean usePrev,
            boolean caseInsensitive,
            Index mapper,
            Object... keys)

getValuesMapping

Map<T,Index> getValuesMapping(Index subRange)

getSortMapping

long[] getSortMapping(Index sourceIndex,
                      SortingOrder sortingOrder)

getPrevSortMapping

long[] getPrevSortMapping(Index sourceIndex,
                          SortingOrder sortingOrder)

startTrackingPrevValues

default void startTrackingPrevValues()

ColumnSource implementations that track previous values have the option to not actually start tracking previous values until this method is called. This is an option, not an obligation: some simple ColumnSource implementations (like TSingleValueSource for various T) always track previous values; other implementations (like PrevColumnSource) never do; some (like TArrayColumnSource) only start tracking once this method is called. An immutable column source can not have distinct prev values; therefore it is implemented as a no-op.

getGroupToRange

Map<T,Index> getGroupToRange()

Compute grouping information for all keys present in this column source.

Returns:

A map from distinct data values to an index that contains those values

getGroupToRange

Map<T,Index> getGroupToRange(Index index)

Compute grouping information for (at least) all keys present in index.

Parameters:

index - The index to consider

Returns:

A map from distinct data values to an index that contains those values

isImmutable

boolean isImmutable()

Returns:

true if the values at a given index of the column source never change, false otherwise

releaseCachedResources

void releaseCachedResources()

Release any resources held for caching purposes. Implementations need not guarantee that concurrent accesses are correct, as the purpose of this method is to ensure cleanup for column sources that will no longer be used.

allowsReinterpret

<ALTERNATE_DATA_TYPE> boolean allowsReinterpret(@NotNull
                                                Class<ALTERNATE_DATA_TYPE> alternateDataType)

Test if a reinterpret call will succeed.

Parameters:

alternateDataType - The alternative type to consider

Returns:

If a reinterpret on this column source with the supplied alternateDataType will succeed.

reinterpret

<ALTERNATE_DATA_TYPE> ColumnSource<ALTERNATE_DATA_TYPE> reinterpret(@NotNull
                                                                    Class<ALTERNATE_DATA_TYPE> alternateDataType)
                                                             throws IllegalArgumentException

Provide an alternative view into the data underlying this column source.

Parameters:

alternateDataType - The alternative type to expose

Returns:

A column source of the alternate data type, backed by the same underlying data.

Throws:

IllegalArgumentException - If the alternativeDataType supplied is not supported

getColumnSources

default List<ColumnSource> getColumnSources()

Description copied from interface: TupleSource

Get the ColumnSources backing this tuple source.

Specified by:

getColumnSources in interface TupleSource<T>

Returns:

The column sources

createTuple

default T createTuple(long indexKey)

Description copied from interface: TupleSource

Create a tuple for key column values at the supplied index key.

Specified by:

createTuple in interface TupleSource<T>

Parameters:

indexKey - The index key

Returns:

The resulting tuple

createPreviousTuple

default T createPreviousTuple(long indexKey)

Description copied from interface: TupleSource

Create a tuple for previous key column values at the supplied index key.

Specified by:

createPreviousTuple in interface TupleSource<T>

Parameters:

indexKey - The index key

Returns:

The resulting tuple

createTupleFromValues

default T createTupleFromValues(@NotNull
                                Object... values)

Description copied from interface: TupleSource

Create a tuple for the supplied (boxed) values.

Specified by:

createTupleFromValues in interface TupleSource<T>

Parameters:

values - The values

Returns:

The resulting tuple

exportElement

default <ELEMENT_TYPE> void exportElement(T tuple,
                                          int elementIndex,
                                          @NotNull
                                          WritableSource<ELEMENT_TYPE> writableSource,
                                          long destinationIndexKey)

Description copied from interface: TupleExporter

Export a single element from the tuple, identified by its element index, to the destination index key of the supplied writable source.

For the empty tuple, this is unsupported.

For singles, this will copy the sole element, possibly in boxed form.

For doubles and longer, this will copy the specified element without any unnecessary boxing.

Specified by:

exportElement in interface TupleExporter<T>

Parameters:

tuple - The tuple to export an element from

elementIndex - The element index to export

writableSource - The destination

destinationIndexKey - The destination index key

exportElement

default Object exportElement(T tuple,
                             int elementIndex)

Description copied from interface: TupleExporter

Export a single element from the tuple, identified by its element index, to an Object

For the empty tuple, this is unsupported.

For singles, this will copy the sole element, possibly in boxed form.

For doubles and longer, this will copy the specified element without any unnecessary boxing.

Specified by:

exportElement in interface TupleExporter<T>

Parameters:

tuple - The tuple to export an element from

elementIndex - The element index to export

exportToExternalKey

default Object exportToExternalKey(T tuple)

Description copied from interface: TupleExporter

Export this tuple's element list as a key suitable for the TableMaps resulting from Table.byExternal(com.illumon.iris.db.tables.Table.ByStrategy, boolean, java.lang.String...).

For the empty tuple this is a unsupported.

For singles, this is the (boxed) sole element itself.

For doubles and longer, this is a newly-allocated "SmartKey".

Specified by:

exportToExternalKey in interface TupleExporter<T>

Parameters:

tuple - The tuple to export all elements from

Returns:

The new smart key