com.illumon.iris.db.tables

Interface Table

All Superinterfaces:

Deflatable<Table>, LivenessManager, LivenessNode, LivenessReferent, LongSizedDataStructure

All Known Subinterfaces:

DynamicTable

public interface Table
extends Deflatable<Table>, LongSizedDataStructure, LivenessNode

A Deephaven table.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Table.AsOfMatchRule
static class	Table.ByStrategy
static class	Table.GroupStrategy GroupStrategy is used for joins and other operations that can choose one of several ways to make use of grouping information.
static class	Table.JoinStrategy
static interface	Table.RenameFunction

Field Summary

Fields

Modifier and Type	Field and Description
static String	ACL_ATTRIBUTE
static String	COLUMN_RENDERERS_ATTRIBUTE
static String	CUSTOM_ACTIONS_ATTRIBUTE
static String	DO_NOT_MAKE_REMOTE_ATTRIBUTE
static String	EMPTY_SOURCE_TABLE_ATTRIBUTE This attribute is applied to source tables, and takes on Boolean values.
static String	HIERARCHICAL_CHILDREN_TABLE_MAP_ATTRIBUTE
static String	HIERARCHICAL_SOURCE_INFO_ATTRIBUTE
static String	HIERARCHICAL_SOURCE_TABLE_ATTRIBUTE
static String	INPUT_TABLE_ATTRIBUTE
static String	KEY_COLUMNS_ATTRIBUTE
static String	LAYOUT_HINTS_ATTRIBUTE
static String	MERGED_TABLE_ATTRIBUTE This attribute is used internally by TableTools.merge to detect successive merges.
static String	PREPARED_RLL_ATTRIBUTE
static String	REVERSE_LOOKUP_ATTRIBUTE
static String	ROLLUP_LEAF_ATTRIBUTE
static String	SORTABLE_COLUMNS_ATTRIBUTE
static String	TOTALS_TABLE_ATTRIBUTE
static String	TREE_TABLE_FILTER_REVERSE_LOOKUP_ATTRIBUTE
static String	UNIQUE_KEYS_ATTRIBUTE

Method Summary

Modifier and Type	Method and Description
default Table	absSumBy(Collection<String> groupByColumns)
default Table	absSumBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields
default Table	absSumBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	absSumBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	absSumBy(Table.ByStrategy byStrategy, String... groupByColumns)
void	addColumnGrouping(String columnName) Deprecated.
default Table	aj(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch)
default Table	aj(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch, Collection<String> columnsToAdd)
default Table	aj(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
Table	aj(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)
default Table	aj(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch)
default Table	aj(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	aj(Table rightTable, String columnsToMatch)
default Table	aj(Table rightTable, String columnsToMatch, String columnsToAdd) Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list.
default <R> R	apply(com.fishlib.base.Function.Unary<R,Table> function) Applies a function to this table.
default Table	applyToAllBy(String formulaColumn, SelectColumn... groupByColumns) Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.
default Table	applyToAllBy(String formulaColumn, String... groupByColumns) Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.
default Table	applyToAllBy(String formulaColumn, String groupByColumn)
Table	applyToAllBy(String formulaColumn, String columnParamName, SelectColumn... groupByColumns) Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.
default Table	avgBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the average for the rest of the fields
default Table	avgBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	avgBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	avgBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	by()
default Table	by(AggregationStateFactory aggregationStateFactory)
default Table	by(AggregationStateFactory aggregationStateFactory, SelectColumn... groupByColumns)
default Table	by(AggregationStateFactory aggregationStateFactory, String... groupByColumns)
default Table	by(Collection<String> groupByColumns)
default Table	by(SelectColumn... groupByColumns)
default Table	by(String... groupByColumns)
default Table	by(Table.ByStrategy byStrategy)
default Table	by(Table.ByStrategy byStrategy, AggregationStateFactory aggregationStateFactory)
Table	by(Table.ByStrategy byStrategy, AggregationStateFactory aggregationStateFactory, SelectColumn... groupByColumns)
default Table	by(Table.ByStrategy byStrategy, AggregationStateFactory aggregationStateFactory, String... groupByColumns)
default Table	by(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
default Table	by(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	by(Table.ByStrategy byStrategy, String... groupByColumns)
default TableMap	byExternal(boolean dropKeys, String... columnNames)
default TableMap	byExternal(String... columnNames)
TableMap	byExternal(Table.ByStrategy byStrategy, boolean dropKeys, String... columnNames)
default TableMap	byExternal(Table.ByStrategy byStrategy, String... columnNames)
default ByteColumnIterator	byteColumnIterator(String columnName)
default CharacterColumnIterator	characterColumnIterator(String columnName)
Table	clearSortingRestrictions() Clear all sorting restrictions that was applied to the current table.
default void	close() Release resources held by this table, possibly destructively.
default Table	coalesce() Explicitly ensure that any work needed to make a table indexable, iterable, or queryable has been done, and return the coalesced child table if appropriate.
default <TYPE> Iterator<TYPE>	columnIterator(String columnName)
default Table	countBy(String countColumnName)
default Table	countBy(String countColumnName, Collection<String> groupByColumns)
default Table	countBy(String countColumnName, SelectColumn... groupByColumns)
default Table	countBy(String countColumnName, String... groupByColumns)
default Table	countBy(Table.ByStrategy byStrategy, String countColumnName)
default Table	countBy(Table.ByStrategy byStrategy, String countColumnName, Collection<String> groupByColumns)
Table	countBy(Table.ByStrategy byStrategy, String countColumnName, SelectColumn... groupByColumns)
default Table	countBy(Table.ByStrategy byStrategy, String countColumnName, String... groupByColumns)
default Table	dateTimeColumnAsNanos(String columnName)
default Table	dateTimeColumnAsNanos(String dateTimeColumnName, String nanosColumnName) Produce a new table with the same columns as this table, but with a new column presenting the specified DBDateTime column as a Long column (with each DBDateTime represented instead as the corresponding number of nanos since the epoch).
default Inflatable<Table>	deflate(ExportedObjectClient client)
default Inflatable<Table>	deflate(ExportedObjectClient client, boolean preSubscribed, boolean preSubscribedViewport) Deflate, but provide an extra boolean telling us whether we are presubscribing this preemptive table.
default DoubleColumnIterator	doubleColumnIterator(String columnName)
default Table	dropColumnFormats()
default Table	dropColumns(Collection<String> columnNames)
Table	dropColumns(String... columnNames)
default Table	exactJoin(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch)
default Table	exactJoin(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch, Collection<String> columnsToAdd)
Table	exactJoin(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
default Table	exactJoin(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch)
default Table	exactJoin(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	exactJoin(Table rightTable, String columnsToMatch)
default Table	exactJoin(Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	firstBy()
default Table	firstBy(Collection<String> groupByColumns)
default Table	firstBy(SelectColumn... groupByColumns)
default Table	firstBy(String... groupByColumns) Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
default Table	firstBy(Table.ByStrategy byStrategy)
default Table	firstBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	firstBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	firstBy(Table.ByStrategy byStrategy, String... groupByColumns)
Table	flatten() Creates a version of this table with a flat index (V2 only).
default FloatColumnIterator	floatColumnIterator(String columnName)
default Table	formatColumns(String... columnFormats)
default Table	formatColumnWhere(String columnName, String condition, String formula)
default Table	formatRowWhere(String condition, String formula)
Object	getAttribute(String key)
Set<String>	getAttributeNames()
default Map<String,Object>	getAttributes() Get all of the attributes from the table.
Map<String,Object>	getAttributes(Collection<String> excluded) Get all attributes from the desired table except the items that appear in excluded.
default DataColumn	getColumn(int columnIndex)
DataColumn	getColumn(String columnName)
default DataColumn[]	getColumns()
ColumnSource	getColumnSource(String sourceName)
Map<String,? extends ColumnSource>	getColumnSourceMap()
Collection<? extends ColumnSource>	getColumnSources()
TableDefinition	getDefinition()
String	getDescription()
Index	getIndex()
default Table	getMeta() Provides column metadata in Table form.
Object[]	getRecord(long rowNo, String... columnNames)
Table	getSubTable(Index index)
default Table	getViewPort() Called on client side of a preemptive table to create the replicated table which represents the server side preemptive table, but instead of looking at the whole table, we're just interested in the slice we can see on the screen.
boolean	hasAttribute(String name)
default boolean	hasColumns(Collection<String> columnNames) Determines whether this Table contains a column for each string in the specified collection of columnNames.
default boolean	hasColumns(String... columnNames) Determines whether this Table contains a column for each string in the specified array of columnNames.
Table	head(long size)
default Table	headBy(long nRows, Collection<String> groupByColumns)
default Table	headBy(long nRows, SelectColumn... groupByColumns)
Table	headBy(long nRows, String... groupByColumns)
Table	headPct(double percent) Provides a head that selects a dynamic number of rows based on a percent.
default IntegerColumnIterator	integerColumnIterator(String columnName)
default boolean	isEmpty() Returns true if this table has no rows (i.e.
boolean	isFlat() Return true if this table is guaranteed to be flat.
default boolean	isLive()
default Table	join(Table.JoinStrategy joinStrategy, Table rightTable)
default Table	join(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch)
default Table	join(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch, Collection<String> columnsToAdd)
Table	join(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
default Table	join(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch)
default Table	join(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	join(Table rightTable)
default Table	join(Table rightTable, String columnsToMatch)
default Table	join(Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	lastBy()
default Table	lastBy(Collection<String> groupByColumns)
default Table	lastBy(SelectColumn... groupByColumns)
default Table	lastBy(String... groupByColumns) Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
default Table	lastBy(Table.ByStrategy byStrategy)
default Table	lastBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	lastBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	lastBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	layoutHints(LayoutHintBuilder builder)
Table	layoutHints(String hints)
default Table	lazyUpdate(Collection<String> newColumns)
Table	lazyUpdate(SelectColumn... newColumns) Compute column formulas on demand.
default Table	lazyUpdate(String... newColumns)
default Table	leftJoin(Table.JoinStrategy joinStrategy, Table rightTable)
default Table	leftJoin(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch)
default Table	leftJoin(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch, Collection<String> columnsToAdd)
Table	leftJoin(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd) Returns a table that has one column for each original table's columns, and one column corresponding to each of the input table (right table) columns listed in the columns to add (or all the columns whose names don't overlap with the name of a column from the source table if the columnsToAdd is length zero).
default Table	leftJoin(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch)
default Table	leftJoin(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	leftJoin(Table rightTable)
default Table	leftJoin(Table rightTable, String columnsToMatch)
default Table	leftJoin(Table rightTable, String columnsToMatch, String columnsToAdd)
default LongColumnIterator	longColumnIterator(String columnName)
default Table	maxBy(Collection<String> groupByColumns)
default Table	maxBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the max for the rest of the fields
default Table	maxBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	maxBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	maxBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	medianBy(Collection<String> groupByColumns)
default Table	medianBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the median for the rest of the fields
default Table	medianBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	medianBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	medianBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	minBy(Collection<String> groupByColumns)
default Table	minBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the min for the rest of the fields
default Table	minBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	minBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	minBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	moveColumns(int index, String... columnsToMove) Produce a new table with the specified columns moved to the specified index.
default Table	moveUpColumns(String... columnsToMove) Produce a new table with the specified columns moved to the leftmost position.
default Table	naturalJoin(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch)
default Table	naturalJoin(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch, Collection<String> columnsToAdd)
Table	naturalJoin(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
default Table	naturalJoin(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch)
default Table	naturalJoin(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	naturalJoin(Table rightTable, String columnsToMatch)
default Table	naturalJoin(Table rightTable, String columnsToMatch, String columnsToAdd)
Table	preemptiveUpdatesTable(long updateInterval)
default Table	raj(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch)
default Table	raj(Table.JoinStrategy joinStrategy, Table rightTable, Collection<String> columnsToMatch, Collection<String> columnsToAdd)
default Table	raj(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
Table	raj(Table.JoinStrategy joinStrategy, Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)
default Table	raj(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch)
default Table	raj(Table.JoinStrategy joinStrategy, Table rightTable, String columnsToMatch, String columnsToAdd)
default Table	raj(Table rightTable, String columnsToMatch)
default Table	raj(Table rightTable, String columnsToMatch, String columnsToAdd) Just like .aj(), but the matching on the last column is in reverse order, so that you find the row after the given timestamp instead of the row before.
default void	releaseCachedResources() Attempt to release cached resources held by this table.
default Table	renameAllColumns(Table.RenameFunction renameFunction)
default Table	renameColumns(Collection<String> columns)
Table	renameColumns(MatchPair... pairs)
default Table	renameColumns(String... columns)
Table	restrictSortTo(String... allowedSortingColumns) Disallow sorting on all but the specified columns.
Table	reverse()
default Table	rollup(ComboAggregateFactory comboAggregateFactory, Collection<String> columns) Create a rollup table.
default Table	rollup(ComboAggregateFactory comboAggregateFactory, String... columns) Create a rollup table.
default Table	rollup(Table.ByStrategy byStrategy, ComboAggregateFactory comboAggregateFactory, Collection<String> columns) Create a rollup table.
Table	rollup(Table.ByStrategy byStrategy, ComboAggregateFactory comboAggregateFactory, SelectColumn... columns) Create a rollup table.
default Table	select()
default Table	select(Collection<String> columns)
Table	select(SelectColumn... columns)
default Table	select(String... columns)
default Table	selectDistinct()
default Table	selectDistinct(Collection<String> columns)
Table	selectDistinct(SelectColumn... columns)
default Table	selectDistinct(String... columns)
void	setAttribute(String key, Object object)
Table	setColumnRenderers(ColumnRenderersBuilder builder) Sets renderers for columns.
Table	setTotalsTable(TotalsTableBuilder builder) Sets parameters for the default totals table display.
default ShortColumnIterator	shortColumnIterator(String columnName)
default long	sizeForInstrumentation()
Table	snapshot(Table rightTable, boolean doInitialSnapshot, String... stampColumns)
default Table	snapshot(Table rightTable, String... stampColumns)
Table	snapshotHistory(Table rightTable)
Table	snapshotIncremental(Table rightTable, boolean doInitialSnapshot, String... stampColumns)
default Table	snapshotIncremental(Table rightTable, String... stampColumns)
default Table	sort(List<String> columnsToSortBy)
Table	sort(String... columnsToSortBy)
default Table	sortDescending(List<String> columnsToSortBy)
Table	sortDescending(String... columnToSortBy)
default Table	stdBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the standard deviation for the rest of the fields
default Table	stdBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	stdBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	stdBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	subscribeToPreemptiveUpdates() Called on client side of a preemptive table to create the replicated table which represents the server side preemptive table.
default Table	sumBy(Collection<String> groupByColumns)
default Table	sumBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the sum for the rest of the fields
default Table	sumBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	sumBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	sumBy(Table.ByStrategy byStrategy, String... groupByColumns)
default boolean	supportsPreemptiveSubscription() Returns true for client side tables where subscribeToPreemptiveUpdates should return a ReplicatedTable.
Table	tail(long size)
default Table	tailBy(long nRows, Collection<String> groupByColumns)
default Table	tailBy(long nRows, SelectColumn... groupByColumns)
Table	tailBy(long nRows, String... groupByColumns)
Table	tailPct(double percent)
default Table	treeTable(String idColumn, String parentColumn) Create a hierarchical tree table.
Table	treeTable(Table.ByStrategy byStrategy, String idColumn, String parentColumn) Create a hierarchical tree table.
default Table	ungroup()
Table	ungroup(String... columnsToUngroup)
default Table	ungroupAllBut(String... columnsNotToUngroup)
default Table	update(Collection<String> newColumns)
Table	update(SelectColumn... newColumns)
default Table	update(String... newColumns)
default Table	updateView(Collection<String> newColumns)
Table	updateView(SelectColumn... newColumns)
default Table	updateView(String... newColumns)
default Table	varBy(Collection<String> groupByColumns)
default Table	varBy(String... groupByColumns) Groups the data column according to groupByColumns and computes the variance for the rest of the fields
default Table	varBy(Table.ByStrategy byStrategy, Collection<String> groupByColumns)
Table	varBy(Table.ByStrategy byStrategy, SelectColumn... groupByColumns)
default Table	varBy(Table.ByStrategy byStrategy, String... groupByColumns)
default Table	view(Collection<String> columns)
Table	view(SelectColumn... columns)
default Table	view(String... columns)
default Table	wavgBy(String weightColumn, String... groupByColumns) Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
default Table	wavgBy(Table.ByStrategy byStrategy, String weightColumn, Collection<String> groupByColumns) Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
Table	wavgBy(Table.ByStrategy byStrategy, String weightColumn, SelectColumn... groupByColumns) Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
default Table	wavgBy(Table.ByStrategy byStrategy, String weightColumn, String... groupByColumns) Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
default Table	where()
default Table	where(Collection<String> filters)
Table	where(SelectFilter... filters)
default Table	where(String... filters)
default Table	whereDynamic(Table rightTable, boolean inclusion, MatchPair... columnsToMatch) Deprecated.
default Table	whereDynamicIn(Table rightTable, MatchPair... columnsToMatch) Deprecated.
default Table	whereDynamicIn(Table rightTable, String... columnsToMatch) Deprecated.
default Table	whereDynamicNotIn(Table rightTable, MatchPair... columnsToMatch) Deprecated.
default Table	whereDynamicNotIn(Table rightTable, String... columnsToMatch) Deprecated.
Table	whereIn(Table.GroupStrategy groupStrategy, Table rightTable, boolean inclusion, MatchPair... columnsToMatch) Filters this table based on the set of values in the rightTable.
default Table	whereIn(Table.GroupStrategy groupStrategy, Table rightTable, boolean inclusion, String... columnsToMatch)
default Table	whereIn(Table.GroupStrategy groupStrategy, Table rightTable, MatchPair... columnsToMatch)
default Table	whereIn(Table.GroupStrategy groupStrategy, Table rightTable, String... columnsToMatch)
default Table	whereIn(Table rightTable, boolean inclusion, MatchPair... columnsToMatch)
default Table	whereIn(Table rightTable, boolean inclusion, String... columnsToMatch)
default Table	whereIn(Table rightTable, MatchPair... columnsToMatch)
default Table	whereIn(Table rightTable, String... columnsToMatch)
default Table	whereNotIn(Table.GroupStrategy groupStrategy, Table rightTable, MatchPair... columnsToMatch)
default Table	whereNotIn(Table.GroupStrategy groupStrategy, Table rightTable, String... columnsToMatch)
default Table	whereNotIn(Table rightTable, MatchPair... columnsToMatch)
default Table	whereNotIn(Table rightTable, String... columnsToMatch)
default Table	whereOneOf()
default Table	whereOneOf(Collection<SelectFilter>... filtersToApply) Filters according to an expression in disjunctive normal form.
default Table	whereOneOf(String... filtersToApplyStrings) Applies the provided filters to the table disjunctively.
Table	withKeys(String... columns) Set the table's key columns.
Table	withUniqueKeys(String... columns) Set the table's key columns and indicate that each key set will be unique.

Methods inherited from interface com.illumon.iris.db.tables.remote.Deflatable

maybeDeflate

Methods inherited from interface com.illumon.iris.db.util.LongSizedDataStructure

intSize, intSize, intSize, size

Methods inherited from interface com.illumon.iris.db.util.liveness.LivenessReferent

dropReference, getReferentDescription, getWeakReference, retainReference, tryRetainReference

Methods inherited from interface com.illumon.iris.db.util.liveness.LivenessManager

manage, tryManage

Field Detail

ACL_ATTRIBUTE

static final String ACL_ATTRIBUTE

See Also:

Constant Field Values

DO_NOT_MAKE_REMOTE_ATTRIBUTE

static final String DO_NOT_MAKE_REMOTE_ATTRIBUTE

See Also:

Constant Field Values

CUSTOM_ACTIONS_ATTRIBUTE

static final String CUSTOM_ACTIONS_ATTRIBUTE

See Also:

Constant Field Values

INPUT_TABLE_ATTRIBUTE

static final String INPUT_TABLE_ATTRIBUTE

See Also:

Constant Field Values

KEY_COLUMNS_ATTRIBUTE

static final String KEY_COLUMNS_ATTRIBUTE

See Also:

Constant Field Values

UNIQUE_KEYS_ATTRIBUTE

static final String UNIQUE_KEYS_ATTRIBUTE

See Also:

Constant Field Values

SORTABLE_COLUMNS_ATTRIBUTE

static final String SORTABLE_COLUMNS_ATTRIBUTE

See Also:

Constant Field Values

LAYOUT_HINTS_ATTRIBUTE

static final String LAYOUT_HINTS_ATTRIBUTE

See Also:

Constant Field Values

TOTALS_TABLE_ATTRIBUTE

static final String TOTALS_TABLE_ATTRIBUTE

See Also:

Constant Field Values

COLUMN_RENDERERS_ATTRIBUTE

static final String COLUMN_RENDERERS_ATTRIBUTE

See Also:

Constant Field Values

ROLLUP_LEAF_ATTRIBUTE

static final String ROLLUP_LEAF_ATTRIBUTE

See Also:

Constant Field Values

HIERARCHICAL_CHILDREN_TABLE_MAP_ATTRIBUTE

static final String HIERARCHICAL_CHILDREN_TABLE_MAP_ATTRIBUTE

See Also:

Constant Field Values

HIERARCHICAL_SOURCE_TABLE_ATTRIBUTE

static final String HIERARCHICAL_SOURCE_TABLE_ATTRIBUTE

See Also:

Constant Field Values

TREE_TABLE_FILTER_REVERSE_LOOKUP_ATTRIBUTE

static final String TREE_TABLE_FILTER_REVERSE_LOOKUP_ATTRIBUTE

See Also:

Constant Field Values

HIERARCHICAL_SOURCE_INFO_ATTRIBUTE

static final String HIERARCHICAL_SOURCE_INFO_ATTRIBUTE

See Also:

Constant Field Values

REVERSE_LOOKUP_ATTRIBUTE

static final String REVERSE_LOOKUP_ATTRIBUTE

See Also:

Constant Field Values

PREPARED_RLL_ATTRIBUTE

static final String PREPARED_RLL_ATTRIBUTE

See Also:

Constant Field Values

MERGED_TABLE_ATTRIBUTE

static final String MERGED_TABLE_ATTRIBUTE

This attribute is used internally by TableTools.merge to detect successive merges. Its presence indicates that it is safe to decompose the table into its multiple constituent parts.

See Also:

Constant Field Values

EMPTY_SOURCE_TABLE_ATTRIBUTE

static final String EMPTY_SOURCE_TABLE_ATTRIBUTE

This attribute is applied to source tables, and takes on Boolean values.

• True for post-Table.coalesce() source tables and their children if the source table is empty.
• False for post-Table.coalesce() source tables and their children if the source table is non-empty.
• Missing for all other tables.

See Also:

Constant Field Values

Method Detail

getDefinition

TableDefinition getDefinition()

getMeta

default Table getMeta()

Provides column metadata in Table form. Convenience method, behaves exactly the same as getDefinition().getColumnDefinitionsTable().

Returns:

A Table of metadata about this Table's columns.

getDescription

String getDescription()

hasColumns

default boolean hasColumns(String... columnNames)

Determines whether this Table contains a column for each string in the specified array of columnNames.

Parameters:

columnNames - The array of column names to be checked for inclusion in this table. Must not be null.

Returns:

true if this Table contains a column for each and every string in the columnNames array; false if any element of columnNames is not the name of a column in this table

hasColumns

default boolean hasColumns(Collection<String> columnNames)

Determines whether this Table contains a column for each string in the specified collection of columnNames.

Parameters:

columnNames - The collection of column names to be checked for inclusion in this table. Must not be null.

Returns:

true if this Table contains a column for each and every string in the columnNames collection; false if any element of columnNames is not the name of a column in this table

setAttribute

void setAttribute(String key,
                  Object object)

getAttribute

Object getAttribute(String key)

getAttributeNames

@NotNull
Set<String> getAttributeNames()

hasAttribute

boolean hasAttribute(String name)

getAttributes

default Map<String,Object> getAttributes()

Get all of the attributes from the table.

Returns:

A map containing all of the attributes.

getAttributes

Map<String,Object> getAttributes(Collection<String> excluded)

Get all attributes from the desired table except the items that appear in excluded.

Parameters:

excluded - A set of attributes to exclude from the result

Returns:

All of the table's attributes except the ones present in excluded

isLive

default boolean isLive()

coalesce

default Table coalesce()

Explicitly ensure that any work needed to make a table indexable, iterable, or queryable has been done, and return the coalesced child table if appropriate.

Returns:

This table, or a fully-coalesced child

getIndex

Index getIndex()

sizeForInstrumentation

default long sizeForInstrumentation()

isEmpty

default boolean isEmpty()

Returns true if this table has no rows (i.e. size() == 0).

Returns:

true if this table has no rows

getColumnSource

ColumnSource getColumnSource(String sourceName)

getColumnSourceMap

Map<String,? extends ColumnSource> getColumnSourceMap()

getColumnSources

Collection<? extends ColumnSource> getColumnSources()

getColumns

default DataColumn[] getColumns()

getColumn

default DataColumn getColumn(int columnIndex)

getColumn

DataColumn getColumn(String columnName)

columnIterator

default <TYPE> Iterator<TYPE> columnIterator(@NotNull
                                             String columnName)

byteColumnIterator

default ByteColumnIterator byteColumnIterator(@NotNull
                                              String columnName)

characterColumnIterator

default CharacterColumnIterator characterColumnIterator(@NotNull
                                                        String columnName)

doubleColumnIterator

default DoubleColumnIterator doubleColumnIterator(@NotNull
                                                  String columnName)

floatColumnIterator

default FloatColumnIterator floatColumnIterator(@NotNull
                                                String columnName)

integerColumnIterator

default IntegerColumnIterator integerColumnIterator(@NotNull
                                                    String columnName)

longColumnIterator

default LongColumnIterator longColumnIterator(@NotNull
                                              String columnName)

shortColumnIterator

default ShortColumnIterator shortColumnIterator(@NotNull
                                                String columnName)

getRecord

Object[] getRecord(long rowNo,
                   String... columnNames)

where

Table where(SelectFilter... filters)

where

default Table where(String... filters)

where

default Table where(Collection<String> filters)

where

default Table where()

whereIn

Table whereIn(Table.GroupStrategy groupStrategy,
              Table rightTable,
              boolean inclusion,
              MatchPair... columnsToMatch)

Filters this table based on the set of values in the rightTable. Note that when the right table ticks, all of the rows in the left table are going to be re-evaluated, thus the intention is that the right table is fairly slow moving compared with the left table.

Parameters:

rightTable - the filtering table.

inclusion - whether things included in rightTable should be passed through (they are exluded if false)

columnsToMatch - the columns to match between the two tables

Returns:

a new table filtered on right table

whereIn

default Table whereIn(Table rightTable,
                      boolean inclusion,
                      MatchPair... columnsToMatch)

whereIn

default Table whereIn(Table rightTable,
                      boolean inclusion,
                      String... columnsToMatch)

whereIn

default Table whereIn(Table rightTable,
                      String... columnsToMatch)

whereIn

default Table whereIn(Table rightTable,
                      MatchPair... columnsToMatch)

whereNotIn

default Table whereNotIn(Table rightTable,
                         String... columnsToMatch)

whereNotIn

default Table whereNotIn(Table rightTable,
                         MatchPair... columnsToMatch)

whereIn

default Table whereIn(Table.GroupStrategy groupStrategy,
                      Table rightTable,
                      String... columnsToMatch)

whereIn

default Table whereIn(Table.GroupStrategy groupStrategy,
                      Table rightTable,
                      MatchPair... columnsToMatch)

whereNotIn

default Table whereNotIn(Table.GroupStrategy groupStrategy,
                         Table rightTable,
                         String... columnsToMatch)

whereNotIn

default Table whereNotIn(Table.GroupStrategy groupStrategy,
                         Table rightTable,
                         MatchPair... columnsToMatch)

whereIn

default Table whereIn(Table.GroupStrategy groupStrategy,
                      Table rightTable,
                      boolean inclusion,
                      String... columnsToMatch)

whereDynamic

@Deprecated
default Table whereDynamic(Table rightTable,
                                       boolean inclusion,
                                       MatchPair... columnsToMatch)

Deprecated.

Use the whereIn method call instead.

whereDynamicIn

@Deprecated
default Table whereDynamicIn(Table rightTable,
                                         MatchPair... columnsToMatch)

Deprecated.

whereDynamicNotIn

@Deprecated
default Table whereDynamicNotIn(Table rightTable,
                                            MatchPair... columnsToMatch)

Deprecated.

whereDynamicIn

@Deprecated
default Table whereDynamicIn(Table rightTable,
                                         String... columnsToMatch)

Deprecated.

whereDynamicNotIn

@Deprecated
default Table whereDynamicNotIn(Table rightTable,
                                            String... columnsToMatch)

Deprecated.

whereOneOf

default Table whereOneOf(Collection<SelectFilter>... filtersToApply)

Filters according to an expression in disjunctive normal form.

The input is an array of clauses, which in turn are a collection of filters.

Parameters:

filtersToApply - each inner collection is a set of filters, all of must which match for the clause to be true. If any one of the collections in the array evaluates to true, the row is part of the output table.

Returns:

a new table, with the filters applied.

whereOneOf

default Table whereOneOf(String... filtersToApplyStrings)

Applies the provided filters to the table disjunctively.

Parameters:

filtersToApplyStrings - an Array of filters to apply

Returns:

a new table, with the filters applied

whereOneOf

default Table whereOneOf()

getSubTable

Table getSubTable(Index index)

select

Table select(SelectColumn... columns)

select

default Table select(String... columns)

select

default Table select(Collection<String> columns)

select

default Table select()

selectDistinct

Table selectDistinct(SelectColumn... columns)

selectDistinct

default Table selectDistinct(String... columns)

selectDistinct

default Table selectDistinct(Collection<String> columns)

selectDistinct

default Table selectDistinct()

update

Table update(SelectColumn... newColumns)

update

default Table update(String... newColumns)

update

default Table update(Collection<String> newColumns)

lazyUpdate

Table lazyUpdate(SelectColumn... newColumns)

Compute column formulas on demand.

Lazy update defers computation until required for a set of values, and caches the results for a set of input values. This uses less RAM than an update statement when you have a smaller set of unique values. Less computation than an updateView is needed, because the resutls are saved in a cache.

If you have many unique values, you should instead use an update statement, which will have more memory efficient structures. Values are never removed from the lazyUpdate cache, so it should be used judiciously on a ticking table.

Parameters:

newColumns - the columns to add

Returns:

a new Table with the columns added; to be computed on demand

lazyUpdate

default Table lazyUpdate(String... newColumns)

lazyUpdate

default Table lazyUpdate(Collection<String> newColumns)

view

Table view(SelectColumn... columns)

view

default Table view(String... columns)

view

default Table view(Collection<String> columns)

updateView

Table updateView(SelectColumn... newColumns)

updateView

default Table updateView(String... newColumns)

updateView

default Table updateView(Collection<String> newColumns)

dropColumns

Table dropColumns(String... columnNames)

dropColumnFormats

default Table dropColumnFormats()

dropColumns

default Table dropColumns(Collection<String> columnNames)

renameColumns

Table renameColumns(MatchPair... pairs)

renameColumns

default Table renameColumns(String... columns)

renameColumns

default Table renameColumns(Collection<String> columns)

renameAllColumns

default Table renameAllColumns(Table.RenameFunction renameFunction)

formatColumns

default Table formatColumns(String... columnFormats)

formatRowWhere

default Table formatRowWhere(String condition,
                             String formula)

formatColumnWhere

default Table formatColumnWhere(String columnName,
                                String condition,
                                String formula)

moveUpColumns

default Table moveUpColumns(String... columnsToMove)

Produce a new table with the specified columns moved to the leftmost position. Columns can be renamed with the usual syntax, i.e. "NewColumnName=OldColumnName").

Parameters:

columnsToMove - The columns to move to the left (and, optionally, to rename)

Returns:

The new table, with the columns rearranged as explained above Table.moveColumns(int, String...)

moveColumns

default Table moveColumns(int index,
                          String... columnsToMove)

Produce a new table with the specified columns moved to the specified index. Column indices begin at 0. Columns can be renamed with the usual syntax, i.e. "NewColumnName=OldColumnName").

Parameters:

index - The index to which the specified columns should be moved

columnsToMove - The columns to move to the specified index (and, optionally, to rename)

Returns:

The new table, with the columns rearranged as explained above

dateTimeColumnAsNanos

default Table dateTimeColumnAsNanos(String dateTimeColumnName,
                                    String nanosColumnName)

Produce a new table with the same columns as this table, but with a new column presenting the specified DBDateTime column as a Long column (with each DBDateTime represented instead as the corresponding number of nanos since the epoch).

NOTE: This is a really just an updateView(), and behaves accordingly for column ordering and (re)placement. This doesn't work on data that has been brought fully into memory (e.g. via select()). Use a view instead.

Parameters:

dateTimeColumnName -

nanosColumnName -

Returns:

The new table, constructed as explained above.

dateTimeColumnAsNanos

default Table dateTimeColumnAsNanos(String columnName)

Parameters:

columnName -

Returns:

The result of dateTimeColumnAsNanos(columnName, columnName).

head

Table head(long size)

tail

Table tail(long size)

headPct

Table headPct(double percent)

Provides a head that selects a dynamic number of rows based on a percent.

Parameters:

percent - the fraction of the table to return (0..1), the number of rows will be rounded up. For example if there are 3 rows, headPct(50) returns the first two rows.

tailPct

Table tailPct(double percent)

leftJoin

Table leftJoin(Table.JoinStrategy joinStrategy,
               Table rightTable,
               MatchPair[] columnsToMatch,
               MatchPair[] columnsToAdd)

Returns a table that has one column for each original table's columns, and one column corresponding to each of the input table (right table) columns listed in the columns to add (or all the columns whose names don't overlap with the name of a column from the source table if the columnsToAdd is length zero). The new columns (those corresponding to the input table) contain an aggregation of all values from the left side that match the join criteria. Consequently the types of all right side columns not involved in a join criteria, is an array of the original column type. If the two tables have columns with matching names then the method will fail with an exception unless the columns with corresponding names are found in one of the matching criteria.

NOTE: leftJoin operation does not involve an actual data copy, or an in-memory table creation. In order to produce an actual in memory table you need to apply a select call on the join result.

Parameters:

rightTable - input table

columnsToMatch - match criteria

columnsToAdd - columns to add

Returns:

a table that has one column for each original table's columns, and one column corresponding to each column listed in columnsToAdd. If columnsToAdd.length==0 one column corresponding to each column of the input table (right table) columns whose names don't overlap with the name of a column from the source table is added. The new columns (those corresponding to the input table) contain an aggregation of all values from the left side that match the join criteria.

leftJoin

default Table leftJoin(Table.JoinStrategy joinStrategy,
                       Table rightTable,
                       Collection<String> columnsToMatch,
                       Collection<String> columnsToAdd)

leftJoin

default Table leftJoin(Table.JoinStrategy joinStrategy,
                       Table rightTable,
                       Collection<String> columnsToMatch)

leftJoin

default Table leftJoin(Table.JoinStrategy joinStrategy,
                       Table rightTable,
                       String columnsToMatch,
                       String columnsToAdd)

leftJoin

default Table leftJoin(Table.JoinStrategy joinStrategy,
                       Table rightTable,
                       String columnsToMatch)

leftJoin

default Table leftJoin(Table.JoinStrategy joinStrategy,
                       Table rightTable)

leftJoin

default Table leftJoin(Table rightTable,
                       String columnsToMatch,
                       String columnsToAdd)

leftJoin

default Table leftJoin(Table rightTable,
                       String columnsToMatch)

leftJoin

default Table leftJoin(Table rightTable)

exactJoin

Table exactJoin(Table.JoinStrategy joinStrategy,
                Table rightTable,
                MatchPair[] columnsToMatch,
                MatchPair[] columnsToAdd)

exactJoin

default Table exactJoin(Table.JoinStrategy joinStrategy,
                        Table rightTable,
                        Collection<String> columnsToMatch,
                        Collection<String> columnsToAdd)

exactJoin

default Table exactJoin(Table.JoinStrategy joinStrategy,
                        Table rightTable,
                        Collection<String> columnsToMatch)

exactJoin

default Table exactJoin(Table.JoinStrategy joinStrategy,
                        Table rightTable,
                        String columnsToMatch,
                        String columnsToAdd)

exactJoin

default Table exactJoin(Table.JoinStrategy joinStrategy,
                        Table rightTable,
                        String columnsToMatch)

exactJoin

default Table exactJoin(Table rightTable,
                        String columnsToMatch,
                        String columnsToAdd)

exactJoin

default Table exactJoin(Table rightTable,
                        String columnsToMatch)

aj

Table aj(Table.JoinStrategy joinStrategy,
         Table rightTable,
         MatchPair[] columnsToMatch,
         MatchPair[] columnsToAdd,
         Table.AsOfMatchRule asOfMatchRule)

aj

default Table aj(Table.JoinStrategy joinStrategy,
                 Table rightTable,
                 MatchPair[] columnsToMatch,
                 MatchPair[] columnsToAdd)

aj

default Table aj(Table.JoinStrategy joinStrategy,
                 Table rightTable,
                 Collection<String> columnsToMatch,
                 Collection<String> columnsToAdd)

aj

default Table aj(Table.JoinStrategy joinStrategy,
                 Table rightTable,
                 Collection<String> columnsToMatch)

aj

default Table aj(Table.JoinStrategy joinStrategy,
                 Table rightTable,
                 String columnsToMatch,
                 String columnsToAdd)

aj

default Table aj(Table.JoinStrategy joinStrategy,
                 Table rightTable,
                 String columnsToMatch)

aj

default Table aj(Table rightTable,
                 String columnsToMatch,
                 String columnsToAdd)

Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list. Matching is done exactly for the first n-1 columns and via a binary search for the last match pair. The columns of the original table are returned intact, together with the columns from rightTable defined in a comma separated list "columnsToAdd"

Parameters:

rightTable - The right side table on the join.

columnsToMatch - A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")

columnsToAdd - A comma separated list with the columns from the left side that need to be added to the right side as a result of the match.

Returns:

a new table joined according to the specification in columnsToMatch and columnsToAdd

aj

default Table aj(Table rightTable,
                 String columnsToMatch)

raj

Table raj(Table.JoinStrategy joinStrategy,
          Table rightTable,
          MatchPair[] columnsToMatch,
          MatchPair[] columnsToAdd,
          Table.AsOfMatchRule asOfMatchRule)

raj

default Table raj(Table.JoinStrategy joinStrategy,
                  Table rightTable,
                  MatchPair[] columnsToMatch,
                  MatchPair[] columnsToAdd)

raj

default Table raj(Table.JoinStrategy joinStrategy,
                  Table rightTable,
                  Collection<String> columnsToMatch,
                  Collection<String> columnsToAdd)

raj

default Table raj(Table.JoinStrategy joinStrategy,
                  Table rightTable,
                  Collection<String> columnsToMatch)

raj

default Table raj(Table.JoinStrategy joinStrategy,
                  Table rightTable,
                  String columnsToMatch,
                  String columnsToAdd)

raj

default Table raj(Table.JoinStrategy joinStrategy,
                  Table rightTable,
                  String columnsToMatch)

raj

default Table raj(Table rightTable,
                  String columnsToMatch,
                  String columnsToAdd)

Just like .aj(), but the matching on the last column is in reverse order, so that you find the row after the given timestamp instead of the row before.

Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list. Matching is done exactly for the first n-1 columns and via a binary search for the last match pair. The columns of the original table are returned intact, together with the columns from rightTable defined in a comma separated list "columnsToAdd"

Parameters:

rightTable - The right side table on the join.

columnsToMatch - A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")

columnsToAdd - A comma separated list with the columns from the left side that need to be added to the right side as a result of the match.

Returns:

a new table joined according to the specification in columnsToMatch and columnsToAdd

raj

default Table raj(Table rightTable,
                  String columnsToMatch)

naturalJoin

Table naturalJoin(Table.JoinStrategy joinStrategy,
                  Table rightTable,
                  MatchPair[] columnsToMatch,
                  MatchPair[] columnsToAdd)

naturalJoin

default Table naturalJoin(Table.JoinStrategy joinStrategy,
                          Table rightTable,
                          Collection<String> columnsToMatch,
                          Collection<String> columnsToAdd)

naturalJoin

default Table naturalJoin(Table.JoinStrategy joinStrategy,
                          Table rightTable,
                          Collection<String> columnsToMatch)

naturalJoin

default Table naturalJoin(Table.JoinStrategy joinStrategy,
                          Table rightTable,
                          String columnsToMatch,
                          String columnsToAdd)

naturalJoin

default Table naturalJoin(Table.JoinStrategy joinStrategy,
                          Table rightTable,
                          String columnsToMatch)

naturalJoin

default Table naturalJoin(Table rightTable,
                          String columnsToMatch,
                          String columnsToAdd)

naturalJoin

default Table naturalJoin(Table rightTable,
                          String columnsToMatch)

join

Table join(Table.JoinStrategy joinStrategy,
           Table rightTable,
           MatchPair[] columnsToMatch,
           MatchPair[] columnsToAdd)

join

default Table join(Table.JoinStrategy joinStrategy,
                   Table rightTable,
                   Collection<String> columnsToMatch,
                   Collection<String> columnsToAdd)

join

default Table join(Table.JoinStrategy joinStrategy,
                   Table rightTable,
                   Collection<String> columnsToMatch)

join

default Table join(Table.JoinStrategy joinStrategy,
                   Table rightTable,
                   String columnsToMatch,
                   String columnsToAdd)

join

default Table join(Table.JoinStrategy joinStrategy,
                   Table rightTable,
                   String columnsToMatch)

join

default Table join(Table.JoinStrategy joinStrategy,
                   Table rightTable)

join

default Table join(Table rightTable,
                   String columnsToMatch,
                   String columnsToAdd)

join

default Table join(Table rightTable,
                   String columnsToMatch)

join

default Table join(Table rightTable)

by

Table by(Table.ByStrategy byStrategy,
         AggregationStateFactory aggregationStateFactory,
         SelectColumn... groupByColumns)

by

default Table by(Table.ByStrategy byStrategy,
                 AggregationStateFactory aggregationStateFactory,
                 String... groupByColumns)

by

default Table by(Table.ByStrategy byStrategy,
                 AggregationStateFactory aggregationStateFactory)

by

default Table by(AggregationStateFactory aggregationStateFactory,
                 SelectColumn... groupByColumns)

by

default Table by(AggregationStateFactory aggregationStateFactory,
                 String... groupByColumns)

by

default Table by(AggregationStateFactory aggregationStateFactory)

by

default Table by(Table.ByStrategy byStrategy,
                 SelectColumn... groupByColumns)

by

default Table by(Table.ByStrategy byStrategy,
                 String... groupByColumns)

by

default Table by(Table.ByStrategy byStrategy,
                 Collection<String> groupByColumns)

by

default Table by(Table.ByStrategy byStrategy)

by

default Table by(SelectColumn... groupByColumns)

by

default Table by(String... groupByColumns)

by

default Table by(Collection<String> groupByColumns)

by

default Table by()

headBy

default Table headBy(long nRows,
                     SelectColumn... groupByColumns)

headBy

Table headBy(long nRows,
             String... groupByColumns)

headBy

default Table headBy(long nRows,
                     Collection<String> groupByColumns)

tailBy

default Table tailBy(long nRows,
                     SelectColumn... groupByColumns)

tailBy

Table tailBy(long nRows,
             String... groupByColumns)

tailBy

default Table tailBy(long nRows,
                     Collection<String> groupByColumns)

applyToAllBy

Table applyToAllBy(String formulaColumn,
                   String columnParamName,
                   SelectColumn... groupByColumns)

Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation. columnParamName is used as place-holder for the name of each column inside formulaColumn.

Parameters:

formulaColumn - Formula applied to each column

columnParamName - The parameter name used as a placeholder for each column

groupByColumns - The grouping columns Table.by(SelectColumn[])

applyToAllBy

default Table applyToAllBy(String formulaColumn,
                           SelectColumn... groupByColumns)

Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.

Parameters:

formulaColumn - Formula applied to each column, uses parameter each to refer to each colum it being applied to

groupByColumns - The grouping columns Table.by(SelectColumn...)

applyToAllBy

default Table applyToAllBy(String formulaColumn,
                           String... groupByColumns)

Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.

Parameters:

formulaColumn - Formula applied to each column, uses parameter each to refer to each colum it being applied to

groupByColumns - The grouping columns Table.by(String...)

applyToAllBy

default Table applyToAllBy(String formulaColumn,
                           String groupByColumn)

sumBy

Table sumBy(Table.ByStrategy byStrategy,
            SelectColumn... groupByColumns)

sumBy

default Table sumBy(Table.ByStrategy byStrategy,
                    String... groupByColumns)

sumBy

default Table sumBy(Table.ByStrategy byStrategy,
                    Collection<String> groupByColumns)

sumBy

default Table sumBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the sum for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

sumBy

default Table sumBy(Collection<String> groupByColumns)

absSumBy

Table absSumBy(Table.ByStrategy byStrategy,
               SelectColumn... groupByColumns)

absSumBy

default Table absSumBy(Table.ByStrategy byStrategy,
                       String... groupByColumns)

absSumBy

default Table absSumBy(Table.ByStrategy byStrategy,
                       Collection<String> groupByColumns)

absSumBy

default Table absSumBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

absSumBy

default Table absSumBy(Collection<String> groupByColumns)

avgBy

Table avgBy(Table.ByStrategy byStrategy,
            SelectColumn... groupByColumns)

avgBy

default Table avgBy(Table.ByStrategy byStrategy,
                    String... groupByColumns)

avgBy

default Table avgBy(Table.ByStrategy byStrategy,
                    Collection<String> groupByColumns)

avgBy

default Table avgBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the average for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

wavgBy

Table wavgBy(Table.ByStrategy byStrategy,
             String weightColumn,
             SelectColumn... groupByColumns)

Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields

Parameters:

byStrategy - a hint to the query engine as to what strategy should be used for performing the by operation

weightColumn - the column to use for the weight

groupByColumns - The grouping columns Table.by(String...)

wavgBy

default Table wavgBy(Table.ByStrategy byStrategy,
                     String weightColumn,
                     String... groupByColumns)

Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields

Parameters:

byStrategy - a hint to the query engine as to what strategy should be used for performing the by operation

weightColumn - the column to use for the weight

groupByColumns - The grouping columns Table.by(String...)

wavgBy

default Table wavgBy(Table.ByStrategy byStrategy,
                     String weightColumn,
                     Collection<String> groupByColumns)

Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields

Parameters:

byStrategy - a hint to the query engine as to what strategy should be used for performing the by operation

weightColumn - the column to use for the weight

groupByColumns - The grouping columns Table.by(String...)

wavgBy

default Table wavgBy(String weightColumn,
                     String... groupByColumns)

Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields

Parameters:

weightColumn - the column to use for the weight

groupByColumns - The grouping columns Table.by(String...)

stdBy

Table stdBy(Table.ByStrategy byStrategy,
            SelectColumn... groupByColumns)

stdBy

default Table stdBy(Table.ByStrategy byStrategy,
                    String... groupByColumns)

stdBy

default Table stdBy(Table.ByStrategy byStrategy,
                    Collection<String> groupByColumns)

stdBy

default Table stdBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the standard deviation for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

varBy

Table varBy(Table.ByStrategy byStrategy,
            SelectColumn... groupByColumns)

varBy

default Table varBy(Table.ByStrategy byStrategy,
                    String... groupByColumns)

varBy

default Table varBy(Table.ByStrategy byStrategy,
                    Collection<String> groupByColumns)

varBy

default Table varBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the variance for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

varBy

default Table varBy(Collection<String> groupByColumns)

lastBy

Table lastBy(Table.ByStrategy byStrategy,
             SelectColumn... groupByColumns)

lastBy

default Table lastBy(Table.ByStrategy byStrategy,
                     String... groupByColumns)

lastBy

default Table lastBy(Table.ByStrategy byStrategy,
                     Collection<String> groupByColumns)

lastBy

default Table lastBy(SelectColumn... groupByColumns)

lastBy

default Table lastBy(String... groupByColumns)

Groups the data column according to groupByColumns and retrieves the last for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

lastBy

default Table lastBy(Collection<String> groupByColumns)

lastBy

default Table lastBy(Table.ByStrategy byStrategy)

lastBy

default Table lastBy()

firstBy

Table firstBy(Table.ByStrategy byStrategy,
              SelectColumn... groupByColumns)

firstBy

default Table firstBy(Table.ByStrategy byStrategy,
                      String... groupByColumns)

firstBy

default Table firstBy(Table.ByStrategy byStrategy,
                      Collection<String> groupByColumns)

firstBy

default Table firstBy(SelectColumn... groupByColumns)

firstBy

default Table firstBy(String... groupByColumns)

Groups the data column according to groupByColumns and retrieves the first for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

firstBy

default Table firstBy(Collection<String> groupByColumns)

firstBy

default Table firstBy(Table.ByStrategy byStrategy)

firstBy

default Table firstBy()

minBy

Table minBy(Table.ByStrategy byStrategy,
            SelectColumn... groupByColumns)

minBy

default Table minBy(Table.ByStrategy byStrategy,
                    String... groupByColumns)

minBy

default Table minBy(Table.ByStrategy byStrategy,
                    Collection<String> groupByColumns)

minBy

default Table minBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the min for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...)

minBy

default Table minBy(Collection<String> groupByColumns)

maxBy

Table maxBy(Table.ByStrategy byStrategy,
            SelectColumn... groupByColumns)

maxBy

default Table maxBy(Table.ByStrategy byStrategy,
                    String... groupByColumns)

maxBy

default Table maxBy(Table.ByStrategy byStrategy,
                    Collection<String> groupByColumns)

maxBy

default Table maxBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the max for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...) }

maxBy

default Table maxBy(Collection<String> groupByColumns)

medianBy

Table medianBy(Table.ByStrategy byStrategy,
               SelectColumn... groupByColumns)

medianBy

default Table medianBy(Table.ByStrategy byStrategy,
                       String... groupByColumns)

medianBy

default Table medianBy(Table.ByStrategy byStrategy,
                       Collection<String> groupByColumns)

medianBy

default Table medianBy(String... groupByColumns)

Groups the data column according to groupByColumns and computes the median for the rest of the fields

Parameters:

groupByColumns - The grouping columns Table.by(String...) }

medianBy

default Table medianBy(Collection<String> groupByColumns)

countBy

Table countBy(Table.ByStrategy byStrategy,
              String countColumnName,
              SelectColumn... groupByColumns)

countBy

default Table countBy(Table.ByStrategy byStrategy,
                      String countColumnName,
                      String... groupByColumns)

countBy

default Table countBy(Table.ByStrategy byStrategy,
                      String countColumnName,
                      Collection<String> groupByColumns)

countBy

default Table countBy(Table.ByStrategy byStrategy,
                      String countColumnName)

countBy

default Table countBy(String countColumnName,
                      SelectColumn... groupByColumns)

countBy

default Table countBy(String countColumnName,
                      String... groupByColumns)

countBy

default Table countBy(String countColumnName,
                      Collection<String> groupByColumns)

countBy

default Table countBy(String countColumnName)

ungroup

Table ungroup(String... columnsToUngroup)

ungroupAllBut

default Table ungroupAllBut(String... columnsNotToUngroup)

ungroup

default Table ungroup()

byExternal

TableMap byExternal(Table.ByStrategy byStrategy,
                    boolean dropKeys,
                    String... columnNames)

byExternal

default TableMap byExternal(Table.ByStrategy byStrategy,
                            String... columnNames)

byExternal

default TableMap byExternal(boolean dropKeys,
                            String... columnNames)

byExternal

default TableMap byExternal(String... columnNames)

rollup

default Table rollup(ComboAggregateFactory comboAggregateFactory,
                     Collection<String> columns)

Create a rollup table. A rollup table aggregates by the specified columns, and then creates a hierarchical table which re-aggregates using one less aggregation column on each level. The column that is no longer part of the aggregation key is replaced with null on each level.

Parameters:

comboAggregateFactory - the ComboAggregateFactory describing the aggregation

columns - the columns to group by

Returns:

a hierarchical table with the rollup applied

rollup

default Table rollup(ComboAggregateFactory comboAggregateFactory,
                     String... columns)

Create a rollup table. A rollup table aggregates by the specified columns, and then creates a hierarchical table which re-aggregates using one less aggregation column on each level. The column that is no longer part of the aggregation key is replaced with null on each level.

Parameters:

comboAggregateFactory - the ComboAggregateFactory describing the aggregation

columns - the columns to group by

Returns:

a hierarchical table with the rollup applied

rollup

default Table rollup(Table.ByStrategy byStrategy,
                     ComboAggregateFactory comboAggregateFactory,
                     Collection<String> columns)

Create a rollup table. A rollup table aggregates by the specified columns, and then creates a hierarchical table which re-aggregates using one less aggregation column on each level. The column that is no longer part of the aggregation key is replaced with null on each level. x

Parameters:

byStrategy - a hint to the query engine as to what strategy should be used for performing the by operation

comboAggregateFactory - the ComboAggregateFactory describing the aggregation

columns - the columns to group by

Returns:

a hierarchical table with the rollup applied

rollup

Table rollup(Table.ByStrategy byStrategy,
             ComboAggregateFactory comboAggregateFactory,
             SelectColumn... columns)

Create a rollup table. A rollup table aggregates by the specified columns, and then creates a hierarchical table which re-aggregates using one less aggregation column on each level. The column that is no longer part of the aggregation key is replaced with null on each level.

Parameters:

byStrategy - a hint to the query engine as to what strategy should be used for performing the by operation

comboAggregateFactory - the ComboAggregateFactory describing the aggregation

columns - the columns to group by

Returns:

a hierarchical table with the rollup applied

treeTable

default Table treeTable(String idColumn,
                        String parentColumn)

Create a hierarchical tree table. The structure of the table is encoded by an "id" and a "parent" column. The id column should represent a unique identifier for a given row, and the parent column indicates which row is the parent for a given row. Rows that have a null parent, are shown in the main table. It is possible for rows to be "orphaned", if their parent reference is non-null and does not exist in the table.

Parameters:

idColumn - the name of a column containing a unique identifier for a particular row in the table

parentColumn - the name of a column containing the parent's identifier, null for elements that are part of the root table

Returns:

a hierarchical table grouped according to the parentColumn

treeTable

Table treeTable(Table.ByStrategy byStrategy,
                String idColumn,
                String parentColumn)

Create a hierarchical tree table. The structure of the table is encoded by an "id" and a "parent" column. The id column should represent a unique identifier for a given row, and the parent column indicates which row is the parent for a given row. Rows that have a null parent, are shown in the main table. It is possible for rows to be "orphaned", if their parent reference is non-null and does not exist in the table.

Parameters:

byStrategy - a hint to the query engine as to what strategy should be used for performing the by operation

idColumn - the name of a column containing a unique identifier for a particular row in the table

parentColumn - the name of a column containing the parent's identifier, null for elements that are part of the root table

Returns:

a hierarchical table grouped according to the parentColumn

sort

Table sort(String... columnsToSortBy)

sort

default Table sort(List<String> columnsToSortBy)

sortDescending

Table sortDescending(String... columnToSortBy)

sortDescending

default Table sortDescending(List<String> columnsToSortBy)

reverse

Table reverse()

restrictSortTo

Table restrictSortTo(String... allowedSortingColumns)

Disallow sorting on all but the specified columns.

Parameters:

allowedSortingColumns - The columns on which sorting is allowed.

Returns:

The same table this was invoked on.

clearSortingRestrictions

Table clearSortingRestrictions()

Clear all sorting restrictions that was applied to the current table.

Note that this table operates on the table it was invoked on and does not create a new table. So in the following code T1 = baseTable.where(...) T2 = T1.restrictSortTo("C1") T3 = T2.clearSortingRestrictions() T1 == T2 == T3 and the result has no restrictions on sorting.

Returns:

The same table this was invoked on.

snapshot

Table snapshot(Table rightTable,
               boolean doInitialSnapshot,
               String... stampColumns)

snapshot

default Table snapshot(Table rightTable,
                       String... stampColumns)

snapshotIncremental

Table snapshotIncremental(Table rightTable,
                          boolean doInitialSnapshot,
                          String... stampColumns)

snapshotIncremental

default Table snapshotIncremental(Table rightTable,
                                  String... stampColumns)

snapshotHistory

Table snapshotHistory(Table rightTable)

apply

default <R> R apply(com.fishlib.base.Function.Unary<R,Table> function)

Applies a function to this table.

This is useful if you have a reference to a table, or a proxy; but not the database and want to run a series of operations against the table without each individual operation resulting in an RMI.

Type Parameters:

R - the return type of function

Parameters:

function - the function to run, its single argument will be this table

Returns:

the return value of function

ImplNote:

If the LTM is not required the Function.Unary#call(Object) method should be annotated with AsyncMethod.

isFlat

boolean isFlat()

Return true if this table is guaranteed to be flat. The index of a flat table will be from 0...numRows-1.

flatten

Table flatten()

Creates a version of this table with a flat index (V2 only).

withKeys

Table withKeys(String... columns)

Set the table's key columns.

Returns:

The same table this method was invoked on, with the keyColumns attribute set

withUniqueKeys

Table withUniqueKeys(String... columns)

Set the table's key columns and indicate that each key set will be unique.

Returns:

The same table this method was invoked on, with the keyColumns and unique attributes set

layoutHints

Table layoutHints(String hints)

layoutHints

default Table layoutHints(LayoutHintBuilder builder)

setTotalsTable

Table setTotalsTable(TotalsTableBuilder builder)

Sets parameters for the default totals table display.

Parameters:

builder - a TotalsTableBuilder object

Returns:

a table with the totals applied

setColumnRenderers

Table setColumnRenderers(ColumnRenderersBuilder builder)

Sets renderers for columns.

Parameters:

builder - a builder that creates the packed string for the attribute

Returns:

The same table with the ColumnRenderes attribute set

close

default void close()

Release resources held by this table, possibly destructively. This may render the table unsuitable or unsafe for further use.

ApiNote:

In practice, implementations usually just invoke Table.releaseCachedResources().

releaseCachedResources

default void releaseCachedResources()

Attempt to release cached resources held by this table. Unlike Table.close(), this must not render the table unusable for subsequent read operations. Implementations should be sure to call super.releaseCachedResources().

addColumnGrouping

@Deprecated
void addColumnGrouping(String columnName)

Deprecated.

preemptiveUpdatesTable

Table preemptiveUpdatesTable(long updateInterval)

subscribeToPreemptiveUpdates

default Table subscribeToPreemptiveUpdates()

Called on client side of a preemptive table to create the replicated table which represents the server side preemptive table.

getViewPort

default Table getViewPort()

Called on client side of a preemptive table to create the replicated table which represents the server side preemptive table, but instead of looking at the whole table, we're just interested in the slice we can see on the screen.

supportsPreemptiveSubscription

default boolean supportsPreemptiveSubscription()

Returns true for client side tables where subscribeToPreemptiveUpdates should return a ReplicatedTable.

deflate

default Inflatable<Table> deflate(@NotNull
                                  ExportedObjectClient client)

Specified by:

deflate in interface Deflatable<Table>

deflate

default Inflatable<Table> deflate(@NotNull
                                  ExportedObjectClient client,
                                  boolean preSubscribed,
                                  boolean preSubscribedViewport)

Deflate, but provide an extra boolean telling us whether we are presubscribing this preemptive table.

Parameters:

client - the client that we are deflating for

preSubscribed - if the resultant table will have a preemptive subscription right off the bat

preSubscribedViewport - if the pre-subscription is a viewport (otherwise it is a full subscription)

Returns:

an inflatable that maybe be presubscribed