Interface Table
- All Superinterfaces:
AttributeMap<Table>
,DynamicNode
,GridAttributes<Table>
,LivenessManager
,LivenessNode
,LivenessReferent
,LogOutputAppendable
,LongSizedDataStructure
,NotificationQueue.Dependency
,SystemicObject<Table>
,TableOperations<Table,Table>
- All Known Subinterfaces:
LazySnapshotTable
,TableAdapter
,TableDefaults
- All Known Implementing Classes:
AppendOnlyArrayBackedMutableTable
,BarrageRedirectedTable
,BarrageStreamTable
,BarrageTable
,BaseTable
,DeferredViewTable
,InitialSnapshotTable
,InMemoryTable
,KeyedArrayBackedMutableTable
,PartitionAwareSourceTable
,QueryReplayGroupedTable
,QueryTable
,QueryTable.FilteredTable
,RedefinableTable
,ReplayGroupedFullTable
,ReplayLastByGroupedTable
,ReplayTable
,SimpleSourceTable
,SourceTable
,TimeTable
,UncoalescedTable
,UpdatableTable
,UpdateSourceQueryTable
public interface Table extends LongSizedDataStructure, LivenessNode, NotificationQueue.Dependency, DynamicNode, SystemicObject<Table>, TableOperations<Table,Table>, AttributeMap<Table>, GridAttributes<Table>
-
Nested Class Summary
Nested Classes Modifier and Type Interface Description static class
Table.AsOfMatchRule
Rules for the inexact matching performed on the final column to match by inaj(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.Table.AsOfMatchRule)
andraj(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.Table.AsOfMatchRule)
. -
Field Summary
Fields Modifier and Type Field Description static String
ADD_ONLY_TABLE_ATTRIBUTE
static String
AGGREGATION_ROW_LOOKUP_ATTRIBUTE
Attribute on aggregation results used for hierarchical table construction.static String
BARRAGE_PERFORMANCE_KEY_ATTRIBUTE
Set this attribute to enable collection of barrage performance stats.static String
FILTERABLE_COLUMNS_ATTRIBUTE
static String
INITIALLY_EMPTY_COALESCED_SOURCE_TABLE_ATTRIBUTE
This attribute is applied to the descendants of source tables, and takes on Boolean values.static String
INPUT_TABLE_ATTRIBUTE
static String
KEY_COLUMNS_ATTRIBUTE
static String
MERGED_TABLE_ATTRIBUTE
This attribute is used internally by TableTools.merge to detect successive merges.static String
NON_DISPLAY_TABLE
Set this attribute for tables that should not be displayed in the UI.static String
PLUGIN_NAME
Set this attribute to load a plugin for this table in the Web Clientstatic String
PREVIEW_PARENT_TABLE
This attribute stores a reference to a table that is the parent table for a Preview Table.static String
SNAPSHOT_VIEWPORT_TYPE
static String
SORT_REVERSE_LOOKUP_ATTRIBUTE
Attribute on sort results used for hierarchical table construction.static String
SORTED_COLUMNS_ATTRIBUTE
The query engine may set or read this attribute to determine if a table is sorted by a particular column.static String
STREAM_TABLE_ATTRIBUTE
If this attribute is present with valuetrue
, this Table is a "stream table".static String
SYSTEMIC_TABLE_ATTRIBUTE
static String
TOTALS_TABLE_ATTRIBUTE
static String
UNIQUE_KEYS_ATTRIBUTE
Fields inherited from interface io.deephaven.engine.table.GridAttributes
COLUMN_DESCRIPTIONS_ATTRIBUTE, DESCRIPTION_ATTRIBUTE, LAYOUT_HINTS_ATTRIBUTE, SORTABLE_COLUMNS_ATTRIBUTE
Fields inherited from interface io.deephaven.api.TableOperations
AGG_BY_PRESERVE_EMPTY_DEFAULT
-
Method Summary
Modifier and Type Method Description void
addUpdateListener(ShiftObliviousListener listener)
Subscribe for updates to this table.void
addUpdateListener(ShiftObliviousListener listener, boolean replayInitialImage)
Subscribe for updates to this table.void
addUpdateListener(TableUpdateListener listener)
Subscribe for updates to this table.Table
aj(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list.Table
aj(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)
Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list.Table
aj(Table rightTable, Collection<String> columnsToMatch)
Looks up the columns in the rightTable that meet the match conditions in the columnsToMatch list.<R> R
apply(Function<Table,R> function)
Applies a function to this table.Table
applyToAllBy(String formulaColumn, String... groupByColumns)
Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.Table
applyToAllBy(String formulaColumn, String columnParamName, Collection<? extends ColumnName> groupByColumns)
Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.Table
applyToAllBy(String formulaColumn, Collection<? extends ColumnName> groupByColumns)
Groups data according to groupByColumns and applies formulaColumn to each of columns not altered by the grouping operation.void
awaitUpdate()
Wait for updates to this Table.boolean
awaitUpdate(long timeout)
Wait for updates to this Table.ByteColumnIterator
byteColumnIterator(String columnName)
CharacterColumnIterator
characterColumnIterator(String columnName)
void
close()
Release resources held by this table, possibly destructively.Table
coalesce()
Explicitly ensure that any work needed to make a table addressable, iterable, or queryable has been done, and return the coalesced child table if appropriate.<TYPE> Iterator<TYPE>
columnIterator(String columnName)
Table
dateTimeColumnAsNanos(String columnName)
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 DateTime column as a Long column (with each DateTime represented instead as the corresponding number of nanos since the epoch).DoubleColumnIterator
doubleColumnIterator(String columnName)
Table
dropColumnFormats()
Table
dropColumns(String... columnNames)
Table
dropColumns(Collection<String> columnNames)
Table
dropStream()
If this table is a stream table, i.e.Table
exactJoin(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
Table
flatten()
Creates a version of this table with a flat RowSet.FloatColumnIterator
floatColumnIterator(String columnName)
Table
formatColumns(String... columnFormats)
Table
formatColumnWhere(String columnName, String condition, String formula)
Table
formatRowWhere(String condition, String formula)
DataColumn
getColumn(int columnIndex)
DataColumn
getColumn(String columnName)
DataColumn[]
getColumns()
<T> ColumnSource<T>
getColumnSource(String sourceName)
Retrieves aColumnSource
.<T> ColumnSource<T>
getColumnSource(String sourceName, Class<? extends T> clazz)
Map<String,? extends ColumnSource<?>>
getColumnSourceMap()
Collection<? extends ColumnSource<?>>
getColumnSources()
TableDefinition
getDefinition()
String
getDescription()
Table
getMeta()
Provides column metadata in Table form.Object[]
getRecord(long rowNo, String... columnNames)
TrackingRowSet
getRowSet()
Table
getSubTable(TrackingRowSet rowSet)
Get aTable
that contains a sub-set of the rows fromthis
.boolean
hasColumns(String... columnNames)
Determines whether this Table contains a column for each string in the specified array ofcolumnNames
.boolean
hasColumns(Collection<String> columnNames)
Determines whether this Table contains a column for each string in the specified collection ofcolumnNames
.Table
headBy(long nRows, String... groupByColumnNames)
Table
headBy(long nRows, Collection<String> groupByColumnNames)
Table
headPct(double percent)
Provides a head that selects a dynamic number of rows based on a percent.IntegerColumnIterator
integerColumnIterator(String columnName)
boolean
isEmpty()
Returnstrue
if this table has no rows (i.e.boolean
isFailed()
boolean
isFlat()
Return true if this table is guaranteed to be flat.boolean
isRefreshing()
Is the node updating?Table
join(Table rightTable)
Perform a cross join with the right table.Table
join(Table rightTable, int numRightBitsToReserve)
Perform a cross join with the right table.Table
join(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
Perform a cross join with the right table.Table
join(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, int numRightBitsToReserve)
Perform a cross join with the right table.Table
join(Table rightTable, String columnsToMatch, int numRightBitsToReserve)
Perform a cross join with the right table.Table
join(Table rightTable, String columnsToMatch, String columnsToAdd, int numRightBitsToReserve)
Perform a cross join with the right table.Table
lazyUpdate(Selectable... newColumns)
LongColumnIterator
longColumnIterator(String columnName)
Table
mergeAfter(Table... others)
Merge this Table withothers
.Table
mergeBefore(Table... others)
Merge this Table withothers
.Table
moveColumns(int index, boolean moveToEnd, String... columnsToMove)
Table
moveColumns(int index, String... columnsToMove)
Produce a new table with the specified columns moved to the specifiedindex
.Table
moveColumnsDown(String... columnsToMove)
Produce a new table with the specified columns moved to the rightmost position.Table
moveColumnsUp(String... columnsToMove)
Produce a new table with the specified columns moved to the leftmost position.Table
naturalJoin(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
int
numColumns()
Get the number of columns defined for this table.<DATA_TYPE>
ObjectColumnIterator<DATA_TYPE>objectColumnIterator(String columnName)
PartitionedTable
partitionBy(boolean dropKeys, String... keyColumnNames)
Create aPartitionedTable
from this table, partitioned according to the specified key columns.PartitionedTable
partitionBy(String... keyColumnNames)
Equivalent topartitionBy(false, keyColumnNames)
PartitionedTable
partitionedAggBy(Collection<? extends Aggregation> aggregations, boolean preserveEmpty, Table initialGroups, String... keyColumnNames)
Convenience method that performs anTableOperations.aggBy(io.deephaven.api.agg.Aggregation)
and wraps the result in aPartitionedTable
.Table
raj(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] 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.Table
raj(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)
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.Table
raj(Table rightTable, Collection<String> columnsToMatch)
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.void
releaseCachedResources()
Attempt to release cached resources held by this table.void
removeUpdateListener(ShiftObliviousListener listener)
Unsubscribe the supplied listener.void
removeUpdateListener(TableUpdateListener listener)
Unsubscribe the supplied listener.Table
renameAllColumns(UnaryOperator<String> renameFunction)
Table
renameColumns(MatchPair... pairs)
Table
renameColumns(String... columns)
Table
renameColumns(Collection<String> columns)
RollupTable
rollup(Collection<? extends Aggregation> aggregations)
Create a rollup table.RollupTable
rollup(Collection<? extends Aggregation> aggregations, boolean includeConstituents)
Create a rollup table.RollupTable
rollup(Collection<? extends Aggregation> aggregations, boolean includeConstituents, String... groupByColumns)
Create a rollup table.RollupTable
rollup(Collection<? extends Aggregation> aggregations, boolean includeConstituents, Collection<? extends ColumnName> groupByColumns)
Create a rollup table.RollupTable
rollup(Collection<? extends Aggregation> aggregations, String... groupByColumns)
Create a rollup table.RollupTable
rollup(Collection<? extends Aggregation> aggregations, Collection<? extends ColumnName> groupByColumns)
Create a rollup table.Table
select()
Table
select(Selectable... columns)
Table
setTotalsTable(String directive)
Set a totals table for this Table.ShortColumnIterator
shortColumnIterator(String columnName)
long
sizeForInstrumentation()
Table
slice(long firstPositionInclusive, long lastPositionExclusive)
Extracts a subset of a table by row position.Table
tailBy(long nRows, String... groupByColumnNames)
Table
tailBy(long nRows, Collection<String> groupByColumnNames)
Table
tailPct(double percent)
TreeTable
tree(String idColumn, String parentColumn)
Create a hierarchical tree table.Table
ungroupAllBut(String... columnsNotToUngroup)
Table
update(Selectable... newColumns)
Table
updateView(Selectable... newColumns)
Table
view(Selectable... columns)
Table
where(Filter... filters)
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.Table
wouldMatch(WouldMatchPair... matchers)
A table operation that applies the supplied predicate to each row in the table and produces columns containing the pass/fail result of the predicate application.Table
wouldMatch(String... expressions)
Methods inherited from interface io.deephaven.engine.table.AttributeMap
getAttribute, getAttributeKeys, getAttributes, getAttributes, hasAttribute, retainingAttributes, withAttributes, withAttributes, withoutAttributes
Methods inherited from interface io.deephaven.engine.updategraph.DynamicNode
addParentReference, setRefreshing
Methods inherited from interface io.deephaven.engine.table.GridAttributes
clearSortingRestrictions, restrictSortTo, setLayoutHints, withColumnDescription, withColumnDescriptions, withDescription
Methods inherited from interface io.deephaven.engine.liveness.LivenessManager
manage, tryManage
Methods inherited from interface io.deephaven.engine.liveness.LivenessNode
tryUnmanage, tryUnmanage, unmanage, unmanage
Methods inherited from interface io.deephaven.engine.liveness.LivenessReferent
dropReference, getReferentDescription, getWeakReference, retainReference, tryRetainReference
Methods inherited from interface io.deephaven.base.log.LogOutputAppendable
append
Methods inherited from interface io.deephaven.util.datastructures.LongSizedDataStructure
intSize, intSize, size
Methods inherited from interface io.deephaven.engine.updategraph.NotificationQueue.Dependency
satisfied
Methods inherited from interface io.deephaven.engine.util.systemicmarking.SystemicObject
isSystemicObject, markSystemic
Methods inherited from interface io.deephaven.api.TableOperations
absSumBy, absSumBy, absSumBy, absSumBy, aggAllBy, aggAllBy, aggAllBy, aggAllBy, aggBy, aggBy, aggBy, aggBy, aggBy, aggBy, aggBy, aggBy, aj, aj, aj, aj, avgBy, avgBy, avgBy, avgBy, countBy, countBy, countBy, countBy, exactJoin, exactJoin, exactJoin, firstBy, firstBy, firstBy, firstBy, groupBy, groupBy, groupBy, head, join, join, join, join, lastBy, lastBy, lastBy, lastBy, lazyUpdate, lazyUpdate, maxBy, maxBy, maxBy, maxBy, medianBy, medianBy, medianBy, medianBy, minBy, minBy, minBy, minBy, naturalJoin, naturalJoin, naturalJoin, raj, raj, raj, raj, reverse, select, select, selectDistinct, selectDistinct, selectDistinct, selectDistinct, snapshot, snapshotWhen, snapshotWhen, snapshotWhen, sort, sort, sortDescending, stdBy, stdBy, stdBy, stdBy, sumBy, sumBy, sumBy, sumBy, tail, ungroup, ungroup, ungroup, ungroup, ungroup, update, update, updateBy, updateBy, updateBy, updateBy, updateBy, updateBy, updateBy, updateView, updateView, varBy, varBy, varBy, varBy, view, view, wavgBy, wavgBy, wavgBy, wavgBy, where, where, whereIn, whereIn, whereNotIn, whereNotIn, wsumBy, wsumBy, wsumBy, wsumBy
-
Field Details
-
INPUT_TABLE_ATTRIBUTE
- See Also:
- Constant Field Values
-
KEY_COLUMNS_ATTRIBUTE
- See Also:
- Constant Field Values
-
UNIQUE_KEYS_ATTRIBUTE
- See Also:
- Constant Field Values
-
FILTERABLE_COLUMNS_ATTRIBUTE
- See Also:
- Constant Field Values
-
TOTALS_TABLE_ATTRIBUTE
- See Also:
- Constant Field Values
-
ADD_ONLY_TABLE_ATTRIBUTE
- See Also:
- Constant Field Values
-
STREAM_TABLE_ATTRIBUTE
If this attribute is present with value
true
, this Table is a "stream table".A stream table is a sequence of additions that represent rows newly received from a stream; on the cycle after the stream table is refreshed the rows are removed. Note that this means any particular row of data (not to be confused with a row key) never exists for more than one cycle.
Most operations are supported as normal on stream tables, but aggregation operations are treated specially, producing aggregate results that are valid over the entire observed stream from the time the operation is initiated. These semantics necessitate a few exclusions, i.e. unsupported operations that need to keep track of all rows:
TableOperations.groupBy()
is unsupportedpartitionBy(boolean, java.lang.String...)
is unsupportedpartitionedAggBy
is unsupportedTableOperations.aggBy(io.deephaven.api.agg.Aggregation)
is unsupported if either ofgroup
orpartition
are usedrollup()
is unsupported ifincludeConstituents == true
tree()
is unsupported
To disable these semantics, a
dropStream
method is offered.- See Also:
- Constant Field Values
-
SORTED_COLUMNS_ATTRIBUTE
The query engine may set or read this attribute to determine if a table is sorted by a particular column.- See Also:
- Constant Field Values
-
SYSTEMIC_TABLE_ATTRIBUTE
- See Also:
- Constant Field Values
-
AGGREGATION_ROW_LOOKUP_ATTRIBUTE
Attribute on aggregation results used for hierarchical table construction. Specification is left to the implementation.- See Also:
- Constant Field Values
-
SORT_REVERSE_LOOKUP_ATTRIBUTE
Attribute on sort results used for hierarchical table construction. Specification is left to the implementation.- See Also:
- Constant Field Values
-
SNAPSHOT_VIEWPORT_TYPE
- See Also:
- Constant Field Values
-
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
-
INITIALLY_EMPTY_COALESCED_SOURCE_TABLE_ATTRIBUTE
This attribute is applied to the descendants of source tables, and takes on Boolean values.
- True for the result of
coalesce()
on source tables and their children if the source table was initially empty on coalesce. - Missing for all other tables.
size() > 0
, this hint should be disregarded.- See Also:
- Constant Field Values
- True for the result of
-
PREVIEW_PARENT_TABLE
This attribute stores a reference to a table that is the parent table for a Preview Table.- See Also:
- Constant Field Values
-
NON_DISPLAY_TABLE
Set this attribute for tables that should not be displayed in the UI.- See Also:
- Constant Field Values
-
PLUGIN_NAME
Set this attribute to load a plugin for this table in the Web Client- See Also:
- Constant Field Values
-
BARRAGE_PERFORMANCE_KEY_ATTRIBUTE
Set this attribute to enable collection of barrage performance stats.- See Also:
- Constant Field Values
-
-
Method Details
-
getDefinition
-
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
-
numColumns
Get the number of columns defined for this table. Equivalent togetDefinition().getColumns().length
.- Returns:
- The number of columns defined for this table
-
hasColumns
Determines whether this Table contains a column for each string in the specified array ofcolumnNames
.- Parameters:
columnNames
- The array of column names to be checked for inclusion in this table. Must not benull
.- Returns:
true
if this Table contains a column for each and every string in thecolumnNames
array;false
if any element ofcolumnNames
is not the name of a column in this table
-
hasColumns
Determines whether this Table contains a column for each string in the specified collection ofcolumnNames
.- Parameters:
columnNames
- The collection of column names to be checked for inclusion in this table. Must not benull
.- Returns:
true
if this Table contains a column for each and every string in thecolumnNames
collection;false
if any element ofcolumnNames
is not the name of a column in this table
-
isRefreshing
Description copied from interface:DynamicNode
Is the node updating?- Specified by:
isRefreshing
in interfaceDynamicNode
- Returns:
- true if the node is updating; false otherwise.
-
getRowSet
TrackingRowSet getRowSet()- Returns:
- The
TrackingRowSet
that exposes the row keys present in this Table
-
sizeForInstrumentation
long sizeForInstrumentation() -
isEmpty
boolean isEmpty()Returnstrue
if this table has no rows (i.e.size() == 0
).- Returns:
true
if this table has no rows
-
isFlat
Return true if this table is guaranteed to be flat. The RowSet of a flat table will be from 0...numRows-1. -
getColumnSource
Retrieves aColumnSource
. It is conveniently cast to @{code ColumnSource} using the type that caller expects. This differs from getColumnSource(String, Class)
which uses the providedClass
object to verify that the data type is a subclass of the expected class.- Type Parameters:
T
- The target type, as a type parameter. Inferred from context.- Parameters:
sourceName
- The name of the column- Returns:
- The column source for
sourceName
, parameterized byT
-
getColumnSource
- Type Parameters:
T
- The target type, as a type parameter. Intended to be inferred fromclazz
.- Parameters:
sourceName
- The name of the columnclazz
- The target type- Returns:
- The column source for
sourceName
, parameterized byT
-
getColumnSourceMap
Map<String,? extends ColumnSource<?>> getColumnSourceMap() -
getColumnSources
Collection<? extends ColumnSource<?>> getColumnSources() -
getColumns
DataColumn[] getColumns() -
getColumn
-
getColumn
-
columnIterator
-
characterColumnIterator
-
byteColumnIterator
-
shortColumnIterator
-
integerColumnIterator
-
longColumnIterator
-
floatColumnIterator
-
doubleColumnIterator
-
objectColumnIterator
-
getRecord
-
where
-
wouldMatch
A table operation that applies the supplied predicate to each row in the table and produces columns containing the pass/fail result of the predicate application. This is similar toTableOperations.where(String...)
except that instead of selecting only rows that meet the criteria, new columns are added with the result of the comparison.- Returns:
- a table with new columns containing the filter result for each row.
-
wouldMatch
-
select
-
select
Table select() -
update
-
lazyUpdate
-
view
-
updateView
-
dropColumns
-
dropColumns
-
dropColumnFormats
-
renameColumns
-
renameColumns
-
renameColumns
-
renameAllColumns
-
formatColumns
-
formatRowWhere
-
formatColumnWhere
-
moveColumnsUp
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
moveColumns(int, String...)
-
moveColumnsDown
Produce a new table with the specified columns moved to the rightmost position. Columns can be renamed with the usual syntax, i.e."NewColumnName=OldColumnName")
.- Parameters:
columnsToMove
- The columns to move to the right (and, optionally, to rename)- Returns:
- The new table, with the columns rearranged as explained above
moveColumns(int, String...)
-
moveColumns
Produce a new table with the specified columns moved to the specifiedindex
. 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 movedcolumnsToMove
- The columns to move to the specified index (and, optionally, to rename)- Returns:
- The new table, with the columns rearranged as explained above
-
moveColumns
-
dateTimeColumnAsNanos
Produce a new table with the same columns as this table, but with a new column presenting the specified DateTime column as a Long column (with each DateTime 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
- Name of date time columnnanosColumnName
- Name of nanos column- Returns:
- The new table, constructed as explained above.
-
dateTimeColumnAsNanos
- Parameters:
columnName
- name of column to convert from DateTime to nanos- Returns:
- The result of dateTimeColumnAsNanos(columnName, columnName).
-
slice
Extracts a subset of a table by row position.If both firstPosition and lastPosition are positive, then the rows are counted from the beginning of the table. The firstPosition is inclusive, and the lastPosition is exclusive. The
TableOperations.head(long)
(N) call is equivalent to slice(0, N). The firstPosition must be less than or equal to the lastPosition.If firstPosition is positive and lastPosition is negative, then the firstRow is counted from the beginning of the table, inclusively. The lastPosition is counted from the end of the table. For example, slice(1, -1) includes all rows but the first and last. If the lastPosition would be before the firstRow, the result is an emptyTable.
If firstPosition is negative, and lastPosition is zero, then the firstRow is counted from the end of the table, and the end of the slice is the size of the table. slice(-N, 0) is equivalent to
TableOperations.tail(long)
(N).If the firstPosition is negative and the lastPosition is negative, they are both counted from the end of the table. For example, slice(-2, -1) returns the second to last row of the table.
- Parameters:
firstPositionInclusive
- the first position to include in the resultlastPositionExclusive
- the last position to include in the result- Returns:
- a new Table, which is the request subset of rows from the original table
-
headPct
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
-
exactJoin
-
aj
Table aj(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)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
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
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 all the columns from rightTable.- Parameters:
rightTable
- The right side table on the join.columnsToMatch
- A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")- Returns:
- a new table joined according to the specification in columnsToMatch and columnsToAdd
-
raj
Table raj(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, Table.AsOfMatchRule asOfMatchRule)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
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
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 all columns from rightTable.
- Parameters:
rightTable
- The right side table on the join.columnsToMatch
- A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")- Returns:
- a new table joined according to the specification in columnsToMatch and columnsToAdd
-
naturalJoin
-
join
Perform a cross join with the right table.Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns. The rows are ordered first by the left table then by the right table.
To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.
An
OutOfKeySpaceException
is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.Note: If you can prove that a given group has at most one right-row then you should prefer using
naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[])
.- Parameters:
rightTable
- The right side table on the join.- Returns:
- a new table joined according to the specification with zero key-columns and includes all right columns
-
join
Perform a cross join with the right table.Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns. The rows are ordered first by the left table then by the right table.
To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.
An
OutOfKeySpaceException
is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.Note: If you can prove that a given group has at most one right-row then you should prefer using
naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[])
.- Parameters:
rightTable
- The right side table on the join.numRightBitsToReserve
- The number of bits to reserve for rightTable groups.- Returns:
- a new table joined according to the specification with zero key-columns and includes all right columns
-
join
Perform a cross join with the right table.Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns that are not key-columns. The rows are ordered first by the left table then by the right table. If columnsToMatch is non-empty then the product is filtered by the supplied match conditions.
To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.
An
OutOfKeySpaceException
is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.Note: If you can prove that a given group has at most one right-row then you should prefer using
naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[])
.- Parameters:
rightTable
- The right side table on the join.columnsToMatch
- A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")numRightBitsToReserve
- The number of bits to reserve for rightTable groups.- Returns:
- a new table joined according to the specification in columnsToMatch and includes all non-key-columns from the right table
-
join
Table join(Table rightTable, String columnsToMatch, String columnsToAdd, int numRightBitsToReserve)Perform a cross join with the right table.Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns that are included in the columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is non-empty then the product is filtered by the supplied match conditions.
To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.
An
OutOfKeySpaceException
is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.Note: If you can prove that a given group has at most one right-row then you should prefer using
naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[])
.- 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 right side that need to be added to the left side as a result of the match.numRightBitsToReserve
- The number of bits to reserve for rightTable groups.- Returns:
- a new table joined according to the specification in columnsToMatch and columnsToAdd
-
join
Perform a cross join with the right table.Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns that are included in the columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is non-empty then the product is filtered by the supplied match conditions.
To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.
An
OutOfKeySpaceException
is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.Note: If you can prove that a given group has at most one right-row then you should prefer using
naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[])
.- Parameters:
rightTable
- The right side table on the join.columnsToMatch
- An array of match pair conditions ("leftColumn=rightColumn" or "columnFoundInBoth")columnsToAdd
- An array of the columns from the right side that need to be added to the left side as a result of the match.- Returns:
- a new table joined according to the specification in columnsToMatch and columnsToAdd
-
join
Table join(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd, int numRightBitsToReserve)Perform a cross join with the right table.Returns a table that is the cartesian product of left rows X right rows, with one column for each of the left table's columns, and one column corresponding to each of the right table's columns that are included in the columnsToAdd argument. The rows are ordered first by the left table then by the right table. If columnsToMatch is non-empty then the product is filtered by the supplied match conditions.
To efficiently produce updates, the bits that represent a key for a given row are split into two. Unless specified, join reserves 16 bits to represent a right row. When there are too few bits to represent all of the right rows for a given aggregation group the table will shift a bit from the left side to the right side. The default of 16 bits was carefully chosen because it results in an efficient implementation to process live updates.
An
OutOfKeySpaceException
is thrown when the total number of bits needed to express the result table exceeds that needed to represent Long.MAX_VALUE. There are a few work arounds: - If the left table is sparse, consider flattening the left table. - If there are no key-columns and the right table is sparse, consider flattening the right table. - If the maximum size of a right table's group is small, you can reserve fewer bits by setting numRightBitsToReserve on initialization.Note: If you can prove that a given group has at most one right-row then you should prefer using
naturalJoin(io.deephaven.engine.table.Table, io.deephaven.engine.table.MatchPair[], io.deephaven.engine.table.MatchPair[])
.- Parameters:
rightTable
- The right side table on the join.columnsToMatch
- An array of match pair conditions ("leftColumn=rightColumn" or "columnFoundInBoth")columnsToAdd
- An array of the columns from the right side that need to be added to the left side as a result of the match.numRightBitsToReserve
- The number of bits to reserve for rightTable groups.- Returns:
- a new table joined according to the specification in columnsToMatch and columnsToAdd
-
headBy
-
headBy
-
tailBy
-
tailBy
-
applyToAllBy
@ConcurrentMethod Table applyToAllBy(String formulaColumn, String columnParamName, Collection<? extends ColumnName> 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 insideformulaColumn
.- Parameters:
formulaColumn
- Formula applied to each columncolumnParamName
- The parameter name used as a placeholder for each columngroupByColumns
- The grouping columns as inTableOperations.groupBy(Collection)
-
applyToAllBy
@ConcurrentMethod Table applyToAllBy(String formulaColumn, Collection<? extends ColumnName> 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 togroupByColumns
- The grouping columns as inTableOperations.groupBy(Collection)
-
applyToAllBy
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 togroupByColumns
- The grouping columns as inTableOperations.groupBy()
-
dropStream
If this table is a stream table, i.e. it hasSTREAM_TABLE_ATTRIBUTE
set totrue
, return a child without the attribute, restoring standard semantics for aggregation operations.- Returns:
- A non-stream child table, or this table if it is not a stream table
-
ungroupAllBut
-
partitionBy
Create aPartitionedTable
from this table, partitioned according to the specified key columns.The underlying partitioned table backing the result contains each row in
this
table in exactly one of the result's constituent tables.- Parameters:
dropKeys
- Whether to drop key columns in the output constituent tableskeyColumnNames
- The name of the key columns to partition by- Returns:
- A
PartitionedTable
keyed bykeyColumnNames
-
partitionBy
Equivalent topartitionBy(false, keyColumnNames)
Create a
PartitionedTable
from this table, partitioned according to the specified key columns. Key columns are never dropped from the output constituent tables.The underlying partitioned table backing the result contains each row in
this
table in exactly one of the result's constituent tables.- Parameters:
keyColumnNames
- The name of the key columns to partition by- Returns:
- A
PartitionedTable
keyed bykeyColumnNames
-
partitionedAggBy
@ConcurrentMethod PartitionedTable partitionedAggBy(Collection<? extends Aggregation> aggregations, boolean preserveEmpty, Table initialGroups, String... keyColumnNames)Convenience method that performs anTableOperations.aggBy(io.deephaven.api.agg.Aggregation)
and wraps the result in aPartitionedTable
. Ifaggregations
does not include apartition
, one will be added automatically with the default constituent column name and behavior used inpartitionBy(String...)
.- Parameters:
aggregations
- Theaggregations
to applypreserveEmpty
- Whether to keep result rows for groups that are initially empty or become empty as a result of updates. Each aggregation operator defines its own value for empty groups.initialGroups
- A table whose distinct combinations of values for thegroupByColumns
should be used to create an initial set of aggregation groups. All other columns are ignored. This is useful in combination withpreserveEmpty == true
to ensure that particular groups appear in the result table, or withpreserveEmpty == false
to control the encounter order for a collection of groups and thus their relative order in the result. Changes toinitialGroups
are not expected or handled; ifinitialGroups
is a refreshing table, only its contents at instantiation time will be used. IfinitialGroups == null
, the result will be the same as if a table with no rows was supplied.keyColumnNames
- The names of the key columns to aggregate by- Returns:
- A
PartitionedTable
keyed bykeyColumnNames
-
rollup
Create a rollup table.A rollup table aggregates all rows of the table.
- Parameters:
aggregations
- The aggregations to perform- Returns:
- a hierarchical table with the rollup applied
-
rollup
@ConcurrentMethod RollupTable rollup(Collection<? extends Aggregation> aggregations, boolean includeConstituents)Create a rollup table.A rollup table aggregates all rows of the table.
- Parameters:
aggregations
- The aggregations to performincludeConstituents
- set to true to include the constituent rows at the leaf level- Returns:
- a hierarchical table with the rollup applied
-
rollup
@ConcurrentMethod RollupTable rollup(Collection<? extends Aggregation> aggregations, String... groupByColumns)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:
aggregations
- The aggregations to performgroupByColumns
- the columns to group by- Returns:
- a hierarchical table with the rollup applied
-
rollup
@ConcurrentMethod RollupTable rollup(Collection<? extends Aggregation> aggregations, boolean includeConstituents, String... groupByColumns)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:
aggregations
- The aggregations to performgroupByColumns
- the columns to group byincludeConstituents
- set to true to include the constituent rows at the leaf level- Returns:
- a hierarchical table with the rollup applied
-
rollup
@ConcurrentMethod RollupTable rollup(Collection<? extends Aggregation> aggregations, Collection<? extends ColumnName> groupByColumns)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:
aggregations
- The aggregations to performgroupByColumns
- the columns to group by- Returns:
- a hierarchical table with the rollup applied
-
rollup
@ConcurrentMethod RollupTable rollup(Collection<? extends Aggregation> aggregations, boolean includeConstituents, Collection<? extends ColumnName> groupByColumns)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:
aggregations
- The aggregations to performincludeConstituents
- set to true to include the constituent rows at the leaf levelgroupByColumns
- the columns to group by- Returns:
- a hierarchical table with the rollup applied
-
tree
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 part of the "root" table.It is possible for rows to be "orphaned" if their parent is non-
null
and does not exist in the table. SeeTreeTable.promoteOrphans(Table, String, String)
.- Parameters:
idColumn
- The name of a column containing a unique identifier for a particular row in the tableparentColumn
- The name of a column containing the parent's identifier,null
for rows that are part of the root table- Returns:
- A
TreeTable
organized according to the parent-child relationships expressed byidColumn
andparentColumn
-
mergeBefore
Merge this Table withothers
. All rows in this Table will appear before all rows inothers
. If Tables inothers
are the result of a prior merge operation, they may be expanded in an attempt to avoid deeply nested structures.- Parameters:
others
- The Tables to merge with- Returns:
- The merged Table
- ApiNote:
- It's best to avoid many chained calls to
mergeBefore(Table...)
andmergeAfter(Table...)
, as this may result in deeply-nested data structures. See TableTools.merge(Table...).
-
mergeAfter
Merge this Table withothers
. All rows in this Table will appear after all rows inothers
. If Tables inothers
are the result of a prior merge operation, they may be expanded in an attempt to avoid deeply nested structures.- Parameters:
others
- The Tables to merge with- Returns:
- The merged Table
- ApiNote:
- It's best to avoid many chained calls to
mergeBefore(Table...)
andmergeAfter(Table...)
, as this may result in deeply-nested data structures. See TableTools.merge(Table...).
-
coalesce
Explicitly ensure that any work needed to make a table addressable, iterable, or queryable has been done, and return the coalesced child table if appropriate.- Returns:
- This table, or a fully-coalesced child
-
getSubTable
Get aTable
that contains a sub-set of the rows fromthis
. The result will share the samecolumn sources
anddefinition
as this table. The result will not update on its own. The caller must also establish an appropriate listener to updaterowSet
and propagateupdates
.- Parameters:
rowSet
- Therow set
for the result- Returns:
- A new sub-table
-
apply
Applies a function to this table.This is useful if you have a reference to a table or a proxy 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 UGP is not required the
Function.apply(Object)
method should be annotated withConcurrentMethod
.
-
flatten
Creates a version of this table with a flat RowSet. -
withKeys
Set the table's key columns.- Returns:
- A copy of this table with the key columns specified, or this if no change was needed
-
withUniqueKeys
Set the table's key columns and indicate that each key set will be unique.- Returns:
- A copy of this table with the unique key columns specified, or this if no change was needed
-
setTotalsTable
Set a totals table for this Table.- Parameters:
directive
- A packed string of totals table instructions- Returns:
- A copy of this Table with the
totals table attribute
set
-
close
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
releaseCachedResources()
.
-
releaseCachedResources
void releaseCachedResources()Attempt to release cached resources held by this table. Unlikeclose()
, this must not render the table unusable for subsequent read operations. Implementations should be sure to callsuper.releaseCachedResources()
. -
awaitUpdate
Wait for updates to this Table.
In some implementations, this call may also terminate in case of interrupt or spurious wakeup (see java.util.concurrent.locks.Condition#await()).
- Throws:
InterruptedException
- In the event this thread is interrupted
-
awaitUpdate
Wait for updates to this Table.
In some implementations, this call may also terminate in case of interrupt or spurious wakeup (see java.util.concurrent.locks.Condition#await()).
- Parameters:
timeout
- The maximum time to wait in milliseconds.- Returns:
- false if the timeout elapses without notification, true otherwise.
- Throws:
InterruptedException
- In the event this thread is interrupted
-
addUpdateListener
Subscribe for updates to this table.listener
will be invoked via theNotificationQueue
associated with this Table.- Parameters:
listener
- listener for updates
-
addUpdateListener
Subscribe for updates to this table. After the optional initial image,listener
will be invoked via theNotificationQueue
associated with this Table.- Parameters:
listener
- listener for updatesreplayInitialImage
- true to process updates for all initial rows in the table plus all changes; false to only process changes
-
addUpdateListener
Subscribe for updates to this table.listener
will be invoked via theNotificationQueue
associated with this Table.- Parameters:
listener
- listener for updates
-
removeUpdateListener
Unsubscribe the supplied listener.- Parameters:
listener
- listener for updates
-
removeUpdateListener
Unsubscribe the supplied listener.- Parameters:
listener
- listener for updates
-
isFailed
boolean isFailed()- Returns:
- true if this table is in a failure state.
-