Interface Table

All Superinterfaces:
DynamicNode, LivenessManager, LivenessNode, LivenessReferent, LogOutputAppendable, LongSizedDataStructure, NotificationQueue.Dependency, SystemicObject, TableOperations<Table,​Table>
All Known Subinterfaces:
LazySnapshotTable, TableWithDefaults
All Known Implementing Classes:
AppendOnlyArrayBackedMutableTable, BarrageRedirectedTable, BarrageStreamTable, BarrageTable, BaseTable, DeferredViewTable, HierarchicalTable, 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, TableOperations<Table,​Table>
A Deephaven table.
  • Field Details

  • 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

      @ConcurrentMethod String getDescription()
    • numColumns

      @ConcurrentMethod int numColumns()
      Get the number of columns defined for this table. Equivalent to getDefinition().getColumns().length.
      Returns:
      The number of columns defined for this table
    • hasColumns

      @ConcurrentMethod 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

      @ConcurrentMethod 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
    • isRefreshing

      @ConcurrentMethod boolean isRefreshing()
      Description copied from interface: DynamicNode
      Is the node updating?
      Specified by:
      isRefreshing in interface DynamicNode
      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()
      Returns:
      Size if it is currently known without subsequent steps to coalesce the Table, else null
    • isEmpty

      boolean isEmpty()
      Returns true if this table has no rows (i.e. size() == 0).
      Returns:
      true if this table has no rows
    • isFlat

      @ConcurrentMethod boolean isFlat()
      Return true if this table is guaranteed to be flat. The RowSet of a flat table will be from 0...numRows-1.
    • setAttribute

      @ConcurrentMethod void setAttribute​(@NotNull String key, @NotNull Object object)
      Set the value of an attribute.
      Parameters:
      key - The name of the attribute; must not be null
      object - The value to be assigned; must not be null
    • getAttribute

      @ConcurrentMethod @Nullable Object getAttribute​(@NotNull String key)
      Get the value of the specified attribute.
      Parameters:
      key - the name of the attribute
      Returns:
      the value, or null if there was none.
    • getAttributeNames

      @ConcurrentMethod @NotNull Set<String> getAttributeNames()
      Get a set of all the attributes that have values for this table.
      Returns:
      a set of names
    • hasAttribute

      @ConcurrentMethod boolean hasAttribute​(@NotNull String name)
      Check if the specified attribute exists in this table.
      Parameters:
      name - the name of the attribute
      Returns:
      true if the attribute exists
    • getAttributes

      @ConcurrentMethod Map<String,​Object> getAttributes()
      Get all attributes from this Table.
      Returns:
      An unmodifiable map containing all attributes from this Table
    • getAttributes

      @ConcurrentMethod Map<String,​Object> getAttributes​(Collection<String> excluded)
      Get all attributes from this Table except the items that appear in excluded.
      Parameters:
      excluded - A set of attributes to exclude from the result
      Returns:
      An unmodifiable map containing Table's attributes, except the ones present in excluded
    • getColumnSource

      <T> ColumnSource<T> getColumnSource​(String sourceName)
      Retrieves a ColumnSource. It is conveniently cast to @{code ColumnSource} using the type that caller expects. This differs from getColumnSource(String, Class) which uses the provided Class 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 by T
    • getColumnSource

      <T> ColumnSource<T> getColumnSource​(String sourceName, Class<? extends T> clazz)
      Retrieves a ColumnSource and casts it to the target class clazz.
      Type Parameters:
      T - The target type, as a type parameter. Intended to be inferred from clazz.
      Parameters:
      sourceName - The name of the column
      clazz - The target type
      Returns:
      The column source for sourceName, parameterized by T
    • getColumnSourceMap

      Map<String,​? extends ColumnSource<?>> getColumnSourceMap()
    • getColumnSources

      Collection<? extends ColumnSource<?>> getColumnSources()
    • getColumns

      DataColumn[] getColumns()
    • getColumn

      DataColumn getColumn​(int columnIndex)
    • getColumn

      DataColumn getColumn​(String columnName)
    • columnIterator

      <TYPE> Iterator<TYPE> columnIterator​(@NotNull String columnName)
    • characterColumnIterator

      CharacterColumnIterator characterColumnIterator​(@NotNull String columnName)
    • byteColumnIterator

      ByteColumnIterator byteColumnIterator​(@NotNull String columnName)
    • shortColumnIterator

      ShortColumnIterator shortColumnIterator​(@NotNull String columnName)
    • integerColumnIterator

      IntegerColumnIterator integerColumnIterator​(@NotNull String columnName)
    • longColumnIterator

      LongColumnIterator longColumnIterator​(@NotNull String columnName)
    • floatColumnIterator

      FloatColumnIterator floatColumnIterator​(@NotNull String columnName)
    • doubleColumnIterator

      DoubleColumnIterator doubleColumnIterator​(@NotNull String columnName)
    • objectColumnIterator

      <DATA_TYPE> ObjectColumnIterator<DATA_TYPE> objectColumnIterator​(@NotNull String columnName)
    • getRecord

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

      @ConcurrentMethod Table where​(Collection<? extends Filter> filters)
      Specified by:
      where in interface TableOperations<Table,​Table>
    • where

      @ConcurrentMethod Table where​(Filter... filters)
    • where

      @ConcurrentMethod Table where​(String... filters)
      Specified by:
      where in interface TableOperations<Table,​Table>
    • wouldMatch

      @ConcurrentMethod 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. This is similar to 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

      @ConcurrentMethod Table wouldMatch​(String... expressions)
    • whereIn

      Table whereIn​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch)
      Description copied from interface: TableOperations
      Filters this table based on the set of values in the rightTable.

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

      Specified by:
      whereIn in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • whereIn

      Table whereIn​(Table rightTable, String... columnsToMatch)
      Description copied from interface: TableOperations
      Filters this table based on the set of values in the rightTable.

      Delegates to TableOperations.whereIn(Object, Collection).

      Specified by:
      whereIn in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • whereNotIn

      Table whereNotIn​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch)
      Description copied from interface: TableOperations
      Filters this table based on the set of values not in the rightTable.

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

      Specified by:
      whereNotIn in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • whereNotIn

      Table whereNotIn​(Table rightTable, String... columnsToMatch)
      Description copied from interface: TableOperations
      Filters this table based on the set of values not in the rightTable.

      Delegates to TableOperations.whereNotIn(Object, Collection).

      Specified by:
      whereNotIn in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • select

      Table select​(Collection<? extends Selectable> columns)
      Specified by:
      select in interface TableOperations<Table,​Table>
    • select

      Table select​(Selectable... columns)
    • select

      Table select​(String... columns)
      Specified by:
      select in interface TableOperations<Table,​Table>
    • select

      Table select()
    • selectDistinct

      @ConcurrentMethod Table selectDistinct​(Collection<? extends Selectable> columns)
      Specified by:
      selectDistinct in interface TableOperations<Table,​Table>
    • selectDistinct

      @ConcurrentMethod Table selectDistinct​(Selectable... columns)
      Specified by:
      selectDistinct in interface TableOperations<Table,​Table>
    • selectDistinct

      @ConcurrentMethod Table selectDistinct​(String... columns)
      Specified by:
      selectDistinct in interface TableOperations<Table,​Table>
    • selectDistinct

      @ConcurrentMethod Table selectDistinct()
      Specified by:
      selectDistinct in interface TableOperations<Table,​Table>
    • update

      Table update​(Collection<? extends Selectable> newColumns)
      Specified by:
      update in interface TableOperations<Table,​Table>
    • update

      Table update​(Selectable... newColumns)
    • update

      Table update​(String... newColumns)
      Specified by:
      update in interface TableOperations<Table,​Table>
    • lazyUpdate

      Table lazyUpdate​(Collection<? extends Selectable> 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 results 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

      Table lazyUpdate​(Selectable... newColumns)
    • lazyUpdate

      Table lazyUpdate​(String... newColumns)
    • view

      @ConcurrentMethod Table view​(Collection<? extends Selectable> columns)
      Specified by:
      view in interface TableOperations<Table,​Table>
    • view

      @ConcurrentMethod Table view​(Selectable... columns)
    • view

      @ConcurrentMethod Table view​(String... columns)
      Specified by:
      view in interface TableOperations<Table,​Table>
    • updateView

      @ConcurrentMethod Table updateView​(Collection<? extends Selectable> newColumns)
      Specified by:
      updateView in interface TableOperations<Table,​Table>
    • updateView

      @ConcurrentMethod Table updateView​(Selectable... newColumns)
    • updateView

      @ConcurrentMethod Table updateView​(String... newColumns)
      Specified by:
      updateView in interface TableOperations<Table,​Table>
    • dropColumns

      @ConcurrentMethod Table dropColumns​(Collection<String> columnNames)
    • dropColumns

      @ConcurrentMethod Table dropColumns​(String... columnNames)
    • dropColumnFormats

      @ConcurrentMethod Table dropColumnFormats()
    • renameColumns

      Table renameColumns​(MatchPair... pairs)
    • renameColumns

      Table renameColumns​(Collection<String> columns)
    • renameColumns

      Table renameColumns​(String... columns)
    • renameAllColumns

      Table renameAllColumns​(UnaryOperator<String> renameFunction)
    • formatColumns

      @ConcurrentMethod Table formatColumns​(String... columnFormats)
    • formatRowWhere

      @ConcurrentMethod Table formatRowWhere​(String condition, String formula)
    • formatColumnWhere

      @ConcurrentMethod Table formatColumnWhere​(String columnName, String condition, String formula)
    • moveColumnsUp

      @ConcurrentMethod Table moveColumnsUp​(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 moveColumns(int, String...)
    • moveColumnsDown

      @ConcurrentMethod Table moveColumnsDown​(String... columnsToMove)
      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

      @ConcurrentMethod 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
    • moveColumns

      @ConcurrentMethod Table moveColumns​(int index, boolean moveToEnd, String... columnsToMove)
    • dateTimeColumnAsNanos

      @ConcurrentMethod 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).

      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 column
      nanosColumnName - Name of nanos column
      Returns:
      The new table, constructed as explained above.
    • dateTimeColumnAsNanos

      @ConcurrentMethod Table dateTimeColumnAsNanos​(String columnName)
      Parameters:
      columnName - name of column to convert from DateTime to nanos
      Returns:
      The result of dateTimeColumnAsNanos(columnName, columnName).
    • head

      @ConcurrentMethod Table head​(long size)
      Specified by:
      head in interface TableOperations<Table,​Table>
    • tail

      @ConcurrentMethod Table tail​(long size)
      Specified by:
      tail in interface TableOperations<Table,​Table>
    • slice

      @ConcurrentMethod Table slice​(long firstPositionInclusive, long lastPositionExclusive)
      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 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 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 result
      lastPositionExclusive - the last position to include in the result
      Returns:
      a new Table, which is the request subset of rows from the original table
    • headPct

      @ConcurrentMethod 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

      @ConcurrentMethod Table tailPct​(double percent)
    • exactJoin

      Table exactJoin​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
    • exactJoin

      Table exactJoin​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Description copied from interface: TableOperations
      Perform an exact-join with the rightTable.

      Similar to TableOperations.naturalJoin(Object, Collection, Collection), but requires that exactly one match from the rightTable.

      Specified by:
      exactJoin in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - The columns from the right side that need to be added to the left side as a result of the match.
      Returns:
      the exact-joined table
    • exactJoin

      Table exactJoin​(Table rightTable, String columnsToMatch, String columnsToAdd)
      Description copied from interface: TableOperations
      Perform an exact-join with the rightTable.

      Delegates to TableOperations.exactJoin(Object, Collection, Collection).

      Specified by:
      exactJoin in interface TableOperations<Table,​Table>
      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.
      Returns:
      the exact-joined table
    • exactJoin

      Table exactJoin​(Table rightTable, String columnsToMatch)
      Description copied from interface: TableOperations
      Perform an exact-join with the rightTable.

      Delegates to TableOperations.exactJoin(Object, Collection, Collection).

      Specified by:
      exactJoin in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      Returns:
      the exact-joined table
    • 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

      Table aj​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] 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

      Table aj​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Description copied from interface: TableOperations
      Perform an as-of join with the rightTable.

      Delegates to TableOperations.aj(Object, Collection, Collection, AsOfJoinRule).

      Specified by:
      aj in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - 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
    • aj

      Table aj​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd, AsOfJoinRule asOfJoinRule)
      Description copied from interface: TableOperations
      Perform an as-of join with the rightTable.

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

      Specified by:
      aj in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - The columns from the right side that need to be added to the left side as a result of the match.
      asOfJoinRule - The binary search operator for the last match pair.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd
    • aj

      Table aj​(Table rightTable, Collection<String> columnsToMatch)
      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
    • aj

      Table aj​(Table rightTable, String columnsToMatch, String columnsToAdd)
      Description copied from interface: TableOperations
      Perform an as-of join with the rightTable.

      Delegates to TableOperations.aj(Object, Collection, Collection, AsOfJoinRule).

      Specified by:
      aj in interface TableOperations<Table,​Table>
      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

      Table aj​(Table rightTable, String columnsToMatch)
      Description copied from interface: TableOperations
      Perform an as-of join with the rightTable.

      Delegates to TableOperations.aj(Object, Collection, Collection, AsOfJoinRule).

      Specified by:
      aj in interface TableOperations<Table,​Table>
      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
    • 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

      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.

      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

      Table raj​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Description copied from interface: TableOperations
      Perform a reverse-as-of join with the rightTable.

      Delegates to TableOperations.raj(Object, Collection, Collection, ReverseAsOfJoinRule).

      Specified by:
      raj in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - 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
    • raj

      Table raj​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd, ReverseAsOfJoinRule reverseAsOfJoinRule)
      Description copied from interface: TableOperations
      Perform a reverse-as-of join with the rightTable.

      Just like TableOperations.aj(Object, Collection, Collection, AsOfJoinRule), 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 columnsToMatch. Matching is done exactly for the first n-1 columns and via a binary search for the last match pair. The columns of this table are returned intact, together with the columns from rightTable defined in columnsToAdd.

      Specified by:
      raj in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - The columns from the right side that need to be added to the left side as a result of the match.
      reverseAsOfJoinRule - The binary search operator for the last match pair.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd
    • raj

      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.

      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
    • raj

      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"

      Specified by:
      raj in interface TableOperations<Table,​Table>
      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

      Table raj​(Table rightTable, String columnsToMatch)
      Description copied from interface: TableOperations
      Perform an reverse-as-of join with the rightTable.

      Delegates to TableOperations.raj(Object, Collection, Collection, ReverseAsOfJoinRule).

      Specified by:
      raj in interface TableOperations<Table,​Table>
      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
    • naturalJoin

      Table naturalJoin​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
    • naturalJoin

      Table naturalJoin​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Description copied from interface: TableOperations
      Perform an exact-join with the rightTable.

      Requires zero or one match from the rightTable.

      Specified by:
      naturalJoin in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - The columns from the right side that need to be added to the left side as a result of the match.
      Returns:
      the natural-joined table
    • naturalJoin

      Table naturalJoin​(Table rightTable, String columnsToMatch, String columnsToAdd)
      Description copied from interface: TableOperations
      Perform a natural-join with the rightTable.

      Delegates to TableOperations.naturalJoin(Object, Collection, Collection).

      Specified by:
      naturalJoin in interface TableOperations<Table,​Table>
      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.
      Returns:
      the natural-joined table
    • naturalJoin

      Table naturalJoin​(Table rightTable, String columnsToMatch)
      Description copied from interface: TableOperations
      Perform an natural-join with the rightTable.

      Delegates to TableOperations.naturalJoin(Object, Collection, Collection).

      Specified by:
      naturalJoin in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn=rightColumn" or "columnFoundInBoth")
      Returns:
      the natural-joined table
    • join

      Table join​(Table rightTable)
      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

      Table join​(Table rightTable, 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. 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

      Table join​(Table rightTable, String columnsToMatch)
      Description copied from interface: TableOperations
      Perform a cross join with the rightTable.

      Delegates to TableOperations.join(Object, Collection, Collection, int).

      Specified by:
      join in interface TableOperations<Table,​Table>
      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 includes all non-key-columns from the right table
      See Also:
      TableOperations.join(Object, Collection, Collection, int)
    • join

      Table join​(Table rightTable, String columnsToMatch, 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 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)
      Description copied from interface: TableOperations
      Perform a cross join with the rightTable.

      Delegates to TableOperations.join(Object, Collection, Collection, int).

      Specified by:
      join in interface TableOperations<Table,​Table>
      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.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd
      See Also:
      TableOperations.join(Object, Collection, Collection, int)
    • 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

      Table join​(Table rightTable, MatchPair[] columnsToMatch, MatchPair[] columnsToAdd)
      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
    • join

      Table join​(Table rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Description copied from interface: TableOperations
      Perform a cross join with the rightTable.

      Delegates to TableOperations.join(Object, Collection, Collection, int).

      Specified by:
      join in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - 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, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd, int numRightBitsToReserve)
      Description copied from interface: TableOperations
      Perform a cross join with the rightTable.

      Returns a table that is the cartesian product of left rows X right rows, with one column for each of this table's columns, and one column corresponding to each of the rightTable's columns that are included in the columnsToAdd argument. The rows are ordered first by the this table then by the rightTable. 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 io.deephaven.engine.table.impl.util.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 reserveBits on initialization.

      Note: If you know that a given group has at most one right-row then you should prefer using TableOperations.naturalJoin(Object, Collection, Collection).

      Specified by:
      join in interface TableOperations<Table,​Table>
      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - The match pair conditions.
      columnsToAdd - 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
    • groupBy

      @ConcurrentMethod Table groupBy​(Collection<? extends Selectable> groupByColumns)
      Specified by:
      groupBy in interface TableOperations<Table,​Table>
    • groupBy

      @ConcurrentMethod Table groupBy​(String... groupByColumns)
      Specified by:
      groupBy in interface TableOperations<Table,​Table>
    • groupBy

      Specified by:
      groupBy in interface TableOperations<Table,​Table>
    • aggAllBy

      @ConcurrentMethod Table aggAllBy​(AggSpec spec)
      Specified by:
      aggAllBy in interface TableOperations<Table,​Table>
    • aggAllBy

      @ConcurrentMethod Table aggAllBy​(AggSpec spec, String... groupByColumns)
      Specified by:
      aggAllBy in interface TableOperations<Table,​Table>
    • aggAllBy

      @ConcurrentMethod Table aggAllBy​(AggSpec spec, Selectable... groupByColumns)
      Specified by:
      aggAllBy in interface TableOperations<Table,​Table>
    • aggAllBy

      @ConcurrentMethod Table aggAllBy​(AggSpec spec, Collection<String> groupByColumns)
      Specified by:
      aggAllBy in interface TableOperations<Table,​Table>
    • aggBy

      @ConcurrentMethod Table aggBy​(Aggregation aggregation)
      Specified by:
      aggBy in interface TableOperations<Table,​Table>
    • aggBy

      @ConcurrentMethod Table aggBy​(Aggregation aggregation, String... groupByColumns)
      Specified by:
      aggBy in interface TableOperations<Table,​Table>
    • aggBy

      @ConcurrentMethod Table aggBy​(Aggregation aggregation, Collection<? extends Selectable> groupByColumns)
      Specified by:
      aggBy in interface TableOperations<Table,​Table>
    • aggBy

      @ConcurrentMethod Table aggBy​(Collection<? extends Aggregation> aggregations, Collection<? extends Selectable> groupByColumns)
      Specified by:
      aggBy in interface TableOperations<Table,​Table>
    • aggBy

      @ConcurrentMethod Table aggBy​(Collection<? extends Aggregation> aggregations, String... groupByColumns)
      Specified by:
      aggBy in interface TableOperations<Table,​Table>
    • aggBy

      @ConcurrentMethod Table aggBy​(Collection<? extends Aggregation> aggregations)
      Specified by:
      aggBy in interface TableOperations<Table,​Table>
    • headBy

      Table headBy​(long nRows, Collection<String> groupByColumnNames)
    • headBy

      Table headBy​(long nRows, String... groupByColumnNames)
    • tailBy

      Table tailBy​(long nRows, Collection<String> groupByColumnNames)
    • tailBy

      Table tailBy​(long nRows, String... groupByColumnNames)
    • applyToAllBy

      @ConcurrentMethod Table applyToAllBy​(String formulaColumn, String columnParamName, Collection<? extends Selectable> 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 as in groupBy(Collection)
    • applyToAllBy

      @ConcurrentMethod Table applyToAllBy​(String formulaColumn, Collection<? extends Selectable> 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 as in groupBy(Collection)
    • applyToAllBy

      @ConcurrentMethod 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 as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • sumBy

      @ConcurrentMethod Table sumBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Specified by:
      sumBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • sumBy

      @ConcurrentMethod Table sumBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Specified by:
      sumBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • sumBy

      @ConcurrentMethod Table sumBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Specified by:
      sumBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • sumBy

      Produces a single row table with the sum of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      sumBy in interface TableOperations<Table,​Table>
    • absSumBy

      @ConcurrentMethod Table absSumBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields
      Specified by:
      absSumBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • absSumBy

      @ConcurrentMethod 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
      Specified by:
      absSumBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • absSumBy

      @ConcurrentMethod Table absSumBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields
      Specified by:
      absSumBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • absSumBy

      Produces a single row table with the absolute sum of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      absSumBy in interface TableOperations<Table,​Table>
    • avgBy

      @ConcurrentMethod Table avgBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Specified by:
      avgBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • avgBy

      @ConcurrentMethod Table avgBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Specified by:
      avgBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • avgBy

      @ConcurrentMethod Table avgBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Specified by:
      avgBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • avgBy

      Produces a single row table with the average of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      avgBy in interface TableOperations<Table,​Table>
    • wavgBy

      @ConcurrentMethod Table wavgBy​(String weightColumn, Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
      Specified by:
      wavgBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • wavgBy

      @ConcurrentMethod 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
      Specified by:
      wavgBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • wavgBy

      @ConcurrentMethod Table wavgBy​(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
      Specified by:
      wavgBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • wavgBy

      @ConcurrentMethod Table wavgBy​(String weightColumn)
      Produces a single row table with the weighted average using weightColumn for the rest of the fields

      When the input table is empty, zero output rows are produced.

      Specified by:
      wavgBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
    • wsumBy

      @ConcurrentMethod Table wsumBy​(String weightColumn, Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the weighted sum using weightColumn for the rest of the fields

      If the weight column is a floating point type, all result columns will be doubles. If the weight column is an integral type, all integral input columns will have long results and all floating point input columns will have double results.

      Specified by:
      wsumBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • wsumBy

      @ConcurrentMethod Table wsumBy​(String weightColumn)
      Computes the weighted sum for all rows in the table using weightColumn for the rest of the fields

      If the weight column is a floating point type, all result columns will be doubles. If the weight column is an integral type, all integral input columns will have long results and all floating point input columns will have double results.

      Specified by:
      wsumBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
    • wsumBy

      @ConcurrentMethod Table wsumBy​(String weightColumn, String... groupByColumns)
      Groups the data column according to groupByColumns and computes the weighted sum using weightColumn for the rest of the fields

      If the weight column is a floating point type, all result columns will be doubles. If the weight column is an integral type, all integral input columns will have long results and all floating point input columns will have double results.

      Specified by:
      wsumBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • wsumBy

      @ConcurrentMethod Table wsumBy​(String weightColumn, Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the weighted sum using weightColumn for the rest of the fields

      If the weight column is a floating point type, all result columns will be doubles. If the weight column is an integral type, all integral input columns will have long results and all floating point input columns will have double results.

      Specified by:
      wsumBy in interface TableOperations<Table,​Table>
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • stdBy

      @ConcurrentMethod Table stdBy​(Selectable... groupByColumns)
      Specified by:
      stdBy in interface TableOperations<Table,​Table>
    • stdBy

      @ConcurrentMethod Table stdBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the standard deviation for the rest of the fields
      Specified by:
      stdBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • stdBy

      @ConcurrentMethod Table stdBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the standard deviation for the rest of the fields
      Specified by:
      stdBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • stdBy

      Produces a single row table with the standard deviation of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      stdBy in interface TableOperations<Table,​Table>
    • varBy

      @ConcurrentMethod Table varBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the variance for the rest of the fields
      Specified by:
      varBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • varBy

      @ConcurrentMethod Table varBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the variance for the rest of the fields
      Specified by:
      varBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • varBy

      @ConcurrentMethod Table varBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the variance for the rest of the fields
      Specified by:
      varBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • varBy

      Produces a single row table with the variance of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      varBy in interface TableOperations<Table,​Table>
    • lastBy

      @ConcurrentMethod Table lastBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Specified by:
      lastBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • lastBy

      @ConcurrentMethod Table lastBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Specified by:
      lastBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • lastBy

      @ConcurrentMethod Table lastBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Specified by:
      lastBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • lastBy

      Returns the last row of the given table.
      Specified by:
      lastBy in interface TableOperations<Table,​Table>
    • firstBy

      @ConcurrentMethod Table firstBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Specified by:
      firstBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • firstBy

      @ConcurrentMethod Table firstBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Specified by:
      firstBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • firstBy

      @ConcurrentMethod Table firstBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Specified by:
      firstBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • firstBy

      Returns the first row of the given table.
      Specified by:
      firstBy in interface TableOperations<Table,​Table>
    • minBy

      @ConcurrentMethod Table minBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Specified by:
      minBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • minBy

      @ConcurrentMethod Table minBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Specified by:
      minBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • minBy

      @ConcurrentMethod Table minBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Specified by:
      minBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>)
    • minBy

      Produces a single row table with the minimum of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      minBy in interface TableOperations<Table,​Table>
    • maxBy

      @ConcurrentMethod Table maxBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Specified by:
      maxBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>) }
    • maxBy

      @ConcurrentMethod Table maxBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Specified by:
      maxBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>) }
    • maxBy

      @ConcurrentMethod Table maxBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Specified by:
      maxBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>) }
    • maxBy

      Produces a single row table with the maximum of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      maxBy in interface TableOperations<Table,​Table>
    • medianBy

      @ConcurrentMethod Table medianBy​(Selectable... groupByColumns)
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Specified by:
      medianBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>) }
    • medianBy

      @ConcurrentMethod Table medianBy​(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Specified by:
      medianBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>) }
    • medianBy

      @ConcurrentMethod Table medianBy​(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Specified by:
      medianBy in interface TableOperations<Table,​Table>
      Parameters:
      groupByColumns - The grouping columns as in groupBy(java.util.Collection<? extends io.deephaven.api.Selectable>) }
    • medianBy

      Produces a single row table with the median of each column.

      When the input table is empty, zero output rows are produced.

      Specified by:
      medianBy in interface TableOperations<Table,​Table>
    • countBy

      @ConcurrentMethod Table countBy​(String countColumnName, Selectable... groupByColumns)
      Specified by:
      countBy in interface TableOperations<Table,​Table>
    • countBy

      @ConcurrentMethod Table countBy​(String countColumnName, String... groupByColumns)
      Specified by:
      countBy in interface TableOperations<Table,​Table>
    • countBy

      @ConcurrentMethod Table countBy​(String countColumnName, Collection<String> groupByColumns)
      Specified by:
      countBy in interface TableOperations<Table,​Table>
    • countBy

      @ConcurrentMethod Table countBy​(String countColumnName)
      Specified by:
      countBy in interface TableOperations<Table,​Table>
    • dropStream

      @ConcurrentMethod Table dropStream()
      If this table is a stream table, i.e. it has STREAM_TABLE_ATTRIBUTE set to true, 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
    • ungroup

      Table ungroup​(boolean nullFill, String... columnsToUngroup)
      Ungroups a table by converting arrays into columns.
      Parameters:
      nullFill - indicates if the ungrouped table should allow disparate sized arrays filling shorter columns with null values. If set to false, then all arrays should be the same length.
      columnsToUngroup - the columns to ungroup
      Returns:
      the ungrouped table
    • ungroup

      Table ungroup​(String... columnsToUngroup)
    • ungroupAllBut

      Table ungroupAllBut​(String... columnsNotToUngroup)
    • ungroup

      Table ungroup()
    • ungroup

      Table ungroup​(boolean nullFill)
    • partitionBy

      @ConcurrentMethod PartitionedTable partitionBy​(boolean dropKeys, String... keyColumnNames)
      Create a PartitionedTable 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 tables
      keyColumnNames - The name of the key columns to partition by
      Returns:
      A PartitionedTable keyed by keyColumnNames
    • partitionBy

      @ConcurrentMethod PartitionedTable partitionBy​(String... keyColumnNames)
      Equivalent to partitionBy(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 by keyColumnNames
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations, 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:
      aggregations - The aggregations to perform
      columns - the columns to group by
      Returns:
      a hierarchical table with the rollup applied
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations, boolean includeConstituents, 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:
      aggregations - The aggregations to perform
      includeConstituents - set to true to include the constituent rows at the leaf level
      columns - the columns to group by
      Returns:
      a hierarchical table with the rollup applied
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations, 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:
      aggregations - The aggregations to perform
      columns - the columns to group by
      Returns:
      a hierarchical table with the rollup applied
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations, boolean includeConstituents, 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:
      aggregations - The aggregations to perform
      columns - the columns to group by
      includeConstituents - set to true to include the constituent rows at the leaf level
      Returns:
      a hierarchical table with the rollup applied
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations, Selectable... 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:
      aggregations - The aggregations to perform
      columns - the columns to group by
      Returns:
      a hierarchical table with the rollup applied
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations)
      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 Table 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 perform
      includeConstituents - set to true to include the constituent rows at the leaf level
      Returns:
      a hierarchical table with the rollup applied
    • rollup

      @ConcurrentMethod Table rollup​(Collection<? extends Aggregation> aggregations, boolean includeConstituents, Selectable... columns)
    • treeTable

      @ConcurrentMethod 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
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull UpdateByClause operation)
      Create a table with the same rowSet as its parent that will perform the specified set of row based operation to it.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      operation - the operation to apply to the table.
      Returns:
      a table with the same index, with the specified operations applied to the entire table
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull Collection<? extends UpdateByClause> operations)
      Create a table with the same rowSet as its parent that will perform the specified set of row based operations to it. As opposed to update(String...) these operations are more restricted but are capable of processing state between rows.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      operations - the operations to apply to the table.
      Returns:
      a table with the same index, with the specified operations applied to the entire table.
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull UpdateByControl control, @NotNull Collection<? extends UpdateByClause> operations)
      Create a table with the same rowSet as its parent that will perform the specified set of row based operations to it. As opposed to update(String...) these operations are more restricted but are capable of processing state between rows. This operation will group the table by the specified set of keys if provided before applying the operation.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      control - the control to use when updating the table.
      operations - the operations to apply to the table.
      Returns:
      a table with the same index, with the specified operations applied to each group defined by the byColumns
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull UpdateByClause operation, String... byColumns)
      Create a table with the same rowSet as its parent that will perform the specified row based operation to it. This operation will group the table by the specified set of keys if provided before applying the operation.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      operation - the operation to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same index, with the specified operations applied to each group defined by the byColumns
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull Collection<? extends UpdateByClause> operations, String... byColumns)
      Create a table with the same rowSet as its parent that will perform the specified set of row based operations to it. As opposed to update(String...) these operations are more restricted but are capable of processing state between rows. This operation will group the table by the specified set of keys if provided before applying the operation.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      operations - the operations to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same index, with the specified operations applied to each group defined by the byColumns
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull Collection<? extends UpdateByClause> operations, @NotNull Collection<? extends Selectable> byColumns)
      Create a table with the same rowSet as its parent that will perform the specified set of row based operations to it. As opposed to update(String...) these operations are more restricted but are capable of processing state between rows. This operation will group the table by the specified set of keys if provided before applying the operation.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      operations - the operations to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same index, with the specified operations applied to each group defined by the byColumns
    • updateBy

      @ConcurrentMethod Table updateBy​(@NotNull UpdateByControl control, @NotNull Collection<? extends UpdateByClause> operations, @NotNull Collection<? extends Selectable> byColumns)
      Create a table with the same rowSet as its parent that will perform the specified set of row based operations to it. As opposed to update(String...) these operations are more restricted but are capable of processing state between rows. This operation will group the table by the specified set of keys if provided before applying the operation.
      Specified by:
      updateBy in interface TableOperations<Table,​Table>
      Parameters:
      control - the control to use when updating the table.
      operations - the operations to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same index, with the specified operations applied to each group defined by the byColumns
    • sort

      @ConcurrentMethod Table sort​(String... columnsToSortBy)
      Specified by:
      sort in interface TableOperations<Table,​Table>
    • sortDescending

      @ConcurrentMethod Table sortDescending​(String... columnsToSortBy)
      Specified by:
      sortDescending in interface TableOperations<Table,​Table>
    • sort

      @ConcurrentMethod Table sort​(Collection<SortColumn> columnsToSortBy)
      Specified by:
      sort in interface TableOperations<Table,​Table>
    • reverse

      Specified by:
      reverse in interface TableOperations<Table,​Table>
    • restrictSortTo

      @ConcurrentMethod 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

      @ConcurrentMethod 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 baseTable, boolean doInitialSnapshot, String... stampColumns)
      Description copied from interface: TableOperations
      Snapshot baseTable, triggered by this table, and return a new table as a result.

      Delegates to TableOperations.snapshot(Object, boolean, Collection).

      Specified by:
      snapshot in interface TableOperations<Table,​Table>
      Parameters:
      baseTable - The table to be snapshotted
      doInitialSnapshot - Take the first snapshot now (otherwise wait for a change event)
      stampColumns - The columns forming the "snapshot key", i.e. some subset of this Table's columns to be included in the result at snapshot time. As a special case, an empty stampColumns is taken to mean "include all columns".
      Returns:
      The result table
    • snapshot

      Table snapshot​(Table baseTable, String... stampColumns)
      Description copied from interface: TableOperations
      Snapshot baseTable, triggered by this table, and return a new table as a result. The returned table will include an initial snapshot.

      Delegates to TableOperations.snapshot(Object, boolean, Collection).

      Specified by:
      snapshot in interface TableOperations<Table,​Table>
      Parameters:
      baseTable - The table to be snapshotted
      stampColumns - The columns forming the "snapshot key", i.e. some subset of this Table's columns to be included in the result at snapshot time. As a special case, an empty stampColumns is taken to mean "include all columns".
      Returns:
      The result table
    • snapshotIncremental

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

      Table snapshotIncremental​(Table rightTable, String... stampColumns)
    • snapshotHistory

      Table snapshotHistory​(Table rightTable)
    • snapshot

      Table snapshot​(Table baseTable, boolean doInitialSnapshot, Collection<ColumnName> stampColumns)
      Description copied from interface: TableOperations
      Snapshot baseTable, triggered by this table, and return a new table as a result.

      this table is the triggering table, i.e. the table whose change events cause a new snapshot to be taken. The result table includes a "snapshot key" which is a subset (possibly all) of this table's columns. The remaining columns in the result table come from baseTable, the table being snapshotted.

      Specified by:
      snapshot in interface TableOperations<Table,​Table>
      Parameters:
      baseTable - The table to be snapshotted
      doInitialSnapshot - Take the first snapshot now (otherwise wait for a change event)
      stampColumns - The columns forming the "snapshot key", i.e. some subset of this Table's columns to be included in the result at snapshot time. As a special case, an empty stampColumns is taken to mean "include all columns".
      Returns:
      The result table
    • mergeBefore

      Table mergeBefore​(Table... others)
      Merge this Table with others. All rows in this Table will appear before all rows in others. If Tables in others 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...) and mergeAfter(Table...), as this may result in deeply-nested data structures, See TableTools.merge(Table...)
    • mergeAfter

      Table mergeAfter​(Table... others)
      Merge this Table with others. All rows in this Table will appear after all rows in others. If Tables in others 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...) and mergeAfter(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

      Table getSubTable​(TrackingRowSet rowSet)
      Get a Table that contains a sub-set of the rows from this. The result will share the same column sources and definition as this table. The result will not update on its own. The caller must also establish an appropriate listener to update rowSet and propagate updates.
      Parameters:
      rowSet - The row set for the result
      Returns:
      A new sub-table
    • apply

      <R> R apply​(Function<Table,​R> function)
      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 with ConcurrentMethod.
    • flatten

      Creates a version of this table with a flat RowSet.
    • withKeys

      @ConcurrentMethod 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

      @ConcurrentMethod 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
    • withTableDescription

      @ConcurrentMethod Table withTableDescription​(String description)
    • withColumnDescription

      @ConcurrentMethod Table withColumnDescription​(String column, String description)
      Add a description for a specific column. You may use withColumnDescription(Map) to set several descriptions at once.
      Parameters:
      column - the name of the column
      description - the column description
      Returns:
      a copy of the source table with the description applied
    • withColumnDescription

      @ConcurrentMethod Table withColumnDescription​(Map<String,​String> descriptions)
      Add a set of column descriptions to the table.
      Parameters:
      descriptions - a map of Column name to Column description.
      Returns:
      a copy of the table with the descriptions applied.
    • setLayoutHints

      @ConcurrentMethod Table setLayoutHints​(String hints)
      Set layout hints.
      Parameters:
      hints - A packed string of layout hints
      Returns:
      A copy of this Table with the layout hints attribute set
    • setTotalsTable

      @ConcurrentMethod Table setTotalsTable​(String directive)
      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
    • setColumnRenderers

      @ConcurrentMethod Table setColumnRenderers​(String directive)
      Set renderers for columns.
      Parameters:
      directive - A packed string of column rendering instructions
      Returns:
      A copy of this Table with the column renderers 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. Unlike close(), this must not render the table unusable for subsequent read operations. Implementations should be sure to call super.releaseCachedResources().
    • awaitUpdate

      void awaitUpdate() throws InterruptedException

      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

      boolean awaitUpdate​(long timeout) throws InterruptedException

      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
    • listenForUpdates

      void listenForUpdates​(ShiftObliviousListener listener)
      Subscribe for updates to this table. listener will be invoked via the NotificationQueue associated with this Table.
      Parameters:
      listener - listener for updates
    • listenForUpdates

      void listenForUpdates​(ShiftObliviousListener listener, boolean replayInitialImage)
      Subscribe for updates to this table. After the optional initial image, listener will be invoked via the NotificationQueue associated with this Table.
      Parameters:
      listener - listener for updates
      replayInitialImage - true to process updates for all initial rows in the table plus all changes; false to only process changes
    • listenForUpdates

      void listenForUpdates​(TableUpdateListener listener)
      Subscribe for updates to this table. listener will be invoked via the NotificationQueue associated with this Table.
      Parameters:
      listener - listener for updates
    • removeUpdateListener

      void removeUpdateListener​(ShiftObliviousListener listener)
      Unsubscribe the supplied listener.
      Parameters:
      listener - listener for updates
    • removeUpdateListener

      void removeUpdateListener​(TableUpdateListener listener)
      Unsubscribe the supplied listener.
      Parameters:
      listener - listener for updates
    • isFailed

      boolean isFailed()
      Returns:
      true if this table is in a failure state.