Interface TableOperations<TOPS extends TableOperations<TOPS,TABLE>,TABLE>

Type Parameters:
TOPS - the table operations type
TABLE - the table type
All Known Subinterfaces:
InputTable, Join, LazySnapshotTable, PartitionedTable.Proxy, SelectableTable, SingleParentTable, Table, TableAdapter, TableDefaults, TableOperationsDefaults<TOPS,TABLE>, TableSpec
All Known Implementing Classes:
AggregateAllTable, AggregateTable, AppendOnlyArrayBackedInputTable, AsOfJoinTable, BarrageBlinkTable, BarrageRedirectedTable, BarrageTable, BaseTable, BlinkInputTable, ByTableBase, DeferredViewTable, DropColumnsTable, EmptyTable, ExactJoinTable, HeadTable, InitialSnapshotTable, InMemoryAppendOnlyInputTable, InMemoryKeyBackedInputTable, InMemoryTable, InputTableBase, JoinBase, JoinTable, KeyedArrayBackedInputTable, LazyUpdateTable, MergeTable, NaturalJoinTable, NewTable, PartitionAwareSourceTable, QueryReplayGroupedTable, QueryTable, QueryTable.FilteredTable, RangeJoinTable, RedefinableTable, ReplayGroupedFullTable, ReplayLastByGroupedTable, ReplayTable, ReplayTableBase, ReverseTable, SelectDistinctTable, SelectTable, SimpleSourceTable, SnapshotTable, SnapshotWhenTable, SortTable, SourceTable, StackTraceMixIn, TableBase, TableHandle, TableOperationsAdapter, TableSpecAdapter, TailTable, TicketTable, TimeTable, TimeTable, UncoalescedTable, UngroupTable, UpdatableTable, UpdateByTable, UpdateSourceQueryTable, UpdateTable, UpdateViewTable, ViewTable, WhereInTable, WhereTable

public interface TableOperations<TOPS extends TableOperations<TOPS,TABLE>,TABLE>
Table operations is a user-accessible api for modifying tables or building up table operations.
  • Field Details

    • AGG_BY_PRESERVE_EMPTY_DEFAULT

      static final boolean AGG_BY_PRESERVE_EMPTY_DEFAULT
      See Also:
  • Method Details

    • head

      @ConcurrentMethod TOPS head(long size)
    • tail

      @ConcurrentMethod TOPS tail(long size)
    • reverse

    • snapshot

      TOPS snapshot()
      Creates a table with a single static snapshot of this.
      Returns:
      the snapshot
    • snapshotWhen

      TOPS snapshotWhen(TABLE trigger, SnapshotWhenOptions.Flag... features)
      Creates a table that captures a snapshot of this whenever trigger updates.

      Equivalent to snapshotWhen(trigger, SnapshotWhenControl.of(features)).

      Parameters:
      trigger - the trigger table
      features - the snapshot features
      Returns:
      the snapshotting table
      See Also:
    • snapshotWhen

      TOPS snapshotWhen(TABLE trigger, Collection<SnapshotWhenOptions.Flag> features, String... stampColumns)
      Creates a table that captures a snapshot of this whenever trigger updates.

      Equivalent to snapshotWhen(trigger, SnapshotWhenControl.of(features, stampColumns)).

      See SnapshotWhenOptions for details on the stampColumns.

      Parameters:
      trigger - the trigger table
      features - the snapshot features
      stampColumns - the stamp columns
      Returns:
      the snapshotting table
      See Also:
    • snapshotWhen

      TOPS snapshotWhen(TABLE trigger, SnapshotWhenOptions options)
      Creates a table that captures a snapshot of this whenever trigger updates.
      Parameters:
      trigger - the trigger table
      options - the snapshot options
      Returns:
      the snapshotting table
      See Also:
    • sort

      @ConcurrentMethod TOPS sort(String... columnsToSortBy)
    • sortDescending

      @ConcurrentMethod TOPS sortDescending(String... columnsToSortBy)
    • sort

      @ConcurrentMethod TOPS sort(Collection<SortColumn> columnsToSortBy)
    • where

      @ConcurrentMethod TOPS where(String... filters)
    • where

      @ConcurrentMethod TOPS where(Filter filter)
    • whereIn

      TOPS whereIn(TABLE rightTable, String... columnsToMatch)
      Filters this table based on the set of values in the rightTable.

      Delegates to whereIn(Object, Collection).

      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • whereIn

      TOPS whereIn(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch)
      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.

      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • whereNotIn

      TOPS whereNotIn(TABLE rightTable, String... columnsToMatch)
      Filters this table based on the set of values not in the rightTable.

      Delegates to whereNotIn(Object, Collection).

      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • whereNotIn

      TOPS whereNotIn(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch)
      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.

      Parameters:
      rightTable - the filtering table.
      columnsToMatch - the columns to match between the two tables
      Returns:
      a new table filtered on right table
    • view

      @ConcurrentMethod TOPS view(String... columns)
    • view

      @ConcurrentMethod TOPS view(Collection<? extends Selectable> columns)
    • updateView

      @ConcurrentMethod TOPS updateView(String... columns)
    • updateView

      @ConcurrentMethod TOPS updateView(Collection<? extends Selectable> columns)
    • update

      TOPS update(String... columns)
    • update

      TOPS update(Collection<? extends Selectable> columns)
    • lazyUpdate

      TOPS lazyUpdate(String... columns)
      Compute column formulas on demand.

      Delegates to lazyUpdate(Collection).

      Parameters:
      columns - the columns to add
      Returns:
      a new Table with the columns added; to be computed on demand
    • lazyUpdate

      TOPS lazyUpdate(Collection<? extends Selectable> columns)
      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:
      columns - the columns to add
      Returns:
      a new Table with the columns added; to be computed on demand
    • select

      TOPS select()
    • select

      TOPS select(String... columns)
    • select

      TOPS select(Collection<? extends Selectable> columns)
    • naturalJoin

      TOPS naturalJoin(TABLE rightTable, String columnsToMatch)
      Perform an natural-join with the rightTable.

      Delegates to naturalJoin(Object, Collection, Collection).

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

      TOPS naturalJoin(TABLE rightTable, String columnsToMatch, String columnsToAdd)
      Perform a natural-join with the rightTable.

      Delegates to naturalJoin(Object, Collection, Collection).

      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

      TOPS naturalJoin(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Perform an exact-join with the rightTable.

      Requires zero or one match from the rightTable.

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

      TOPS exactJoin(TABLE rightTable, String columnsToMatch)
      Perform an exact-join with the rightTable.

      Delegates to exactJoin(Object, Collection, Collection).

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

      TOPS exactJoin(TABLE rightTable, String columnsToMatch, String columnsToAdd)
      Perform an exact-join with the rightTable.

      Delegates to exactJoin(Object, Collection, Collection).

      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

      TOPS exactJoin(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Perform an exact-join with the rightTable.

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

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

      TOPS join(TABLE rightTable)
      Perform a cross join with the rightTable.

      Equivalent to join(rightTable, emptyList(), emptyList()).

      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
      See Also:
    • join

      TOPS join(TABLE rightTable, String columnsToMatch)
      Perform a cross join with the rightTable.

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

      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:
    • join

      TOPS join(TABLE rightTable, String columnsToMatch, String columnsToAdd)
      Perform a cross join with the rightTable.

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

      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:
    • join

      TOPS join(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd)
      Perform a cross join with the rightTable.

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

      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

      TOPS join(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd, int reserveBits)
      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 naturalJoin(Object, Collection, Collection).

      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.
      reserveBits - The number of bits to reserve for rightTable groups.
      Returns:
      a new table joined according to the specification in columnsToMatch and columnsToAdd
    • aj

      TOPS aj(TABLE rightTable, String columnsToMatch)
      Perform an as-of join with the rightTable.

      Delegates to asOfJoin(Object, Collection, AsOfJoinMatch, Collection).

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn>=rightColumn", "leftColumn>rightColumn", "columnFoundInBoth").
      Returns:
      a new table joined according to the specification in columnsToMatch
    • aj

      TOPS aj(TABLE rightTable, String columnsToMatch, String columnsToAdd)
      Perform an as-of join with the rightTable.

      Delegates to asOfJoin(Object, Collection, AsOfJoinMatch, Collection).

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn>=rightColumn", "leftColumn>rightColumn", "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

      TOPS raj(TABLE rightTable, String columnsToMatch)
      Perform an reverse-as-of join with the rightTable.

      Delegates to asOfJoin(Object, Collection, AsOfJoinMatch, Collection).

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn<=rightColumn", "leftColumn<rightColumn", "columnFoundInBoth").
      Returns:
      a new table joined according to the specification in columnsToMatch
    • raj

      TOPS raj(TABLE rightTable, String columnsToMatch, String columnsToAdd)
      Perform a reverse-as-of join with the rightTable.

      Delegates to asOfJoin(Object, Collection, AsOfJoinMatch, Collection)

      Parameters:
      rightTable - The right side table on the join.
      columnsToMatch - A comma separated list of match conditions ("leftColumn<=rightColumn", "leftColumn<rightColumn", "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
    • asOfJoin

      TOPS asOfJoin(TABLE rightTable, Collection<? extends JoinMatch> exactMatches, AsOfJoinMatch asOfMatch, Collection<? extends JoinAddition> columnsToAdd)
    • rangeJoin

      TOPS rangeJoin(TABLE rightTable, Collection<? extends JoinMatch> exactMatches, RangeJoinMatch rangeMatch, Collection<? extends Aggregation> aggregations)
      Perform a range join with rightTable. For each row in this Table, this operation joins aggregations over a range of responsive rows from rightTable according to zero-or-more exact join matches and one range join match.

      Matching Rules

      The exact join matches identify possibly-responsive rows according to exactly matching values between the left exact match columns and the right exact match columns, similar to other join operations. The range join match bounds the beginning of the responsive range for a given output row by the relationship between a left start column and a right range column, governed by the rangeStartRule, and bounds the end of the responsive range for a given output row by the relationship between a left end column and the same right range column, governed by the rangeEndRule.

      Right Table Row-Inclusion Criteria and Relative Ordering Requirements

      Rows from rightTable with null or NaN values for the right range column are discarded; that is, they are never included in the responsive range for any output row. Within a group sharing the same values for the right exact match columns, rightTable must be relatively ordered (as if sorted) according to the right range column for all rows that are not discarded.

      Special Cases

      In order to produce aggregated output, it is required that the two relative match expressions define a range of values to determine the responsive rows to aggregate. There are a few noteworthy special cases of ranges.

      empty range
      An empty range occurs for any left row with no responsive right rows. That is, no non-null, non-NaN right rows were found using the exact join matches, or none were in range according to the range join match.
      single-value ranges
      A single-value range is a range where the left row’s values for the left start column and left end column are equal and both relative matches are inclusive (<= and >=, respectively). For a single-value range, only rows within the bucket where the right range column matches the single value are included in the output aggregations.
      invalid ranges
      An invalid range occurs in two scenarios: First, when the range is inverted, i.e. when the value of the left start column is greater than the value of the left end column. Second, when either relative-match is exclusive (< or >) and the value in the left start column is equal to the value in the left end column (because value < value == false). Specifying "allow preceding" or "allow following" for either rule will not constitute an exception to either of these defined scenarios. For invalid ranges, the result row will be null for all aggregation output columns.
      undefined ranges
      An undefined range occurs when either the left start column or the left end column is NaN. For rows with an undefined range, the corresponding output values will be null (as with invalid ranges).
      Unbounded Ranges
      A partially or fully unbounded range occurs when either the left start column or the left end column is null. If the left start column value is null the range is unbounded at the beginning, and all matched right rows will be included if they respect the match rule for the left end column. If the left end column value is null the range is unbounded at the end, and all matched right rows will be included if they respect the match rule for the left start column. If both the left start column and left end column values are null the range is unbounded in both directions, and all matched right rows will be included.
      Parameters:
      rightTable - The Table to join with
      exactMatches - Possibly-empty collection of join matches that dictate exact-match criteria. That is, rows from rightTable that might be responsive to rows from this Table will have identical values for the column pairs expressed by these matches.
      rangeMatch - Specifies the range match criteria for determining the responsive rows from rightTable for each row from this Table, within the buckets created by matching on the exactMatches
      aggregations - The aggregations to perform over the responsive ranges from rightTable for each row from this Table
      Returns:
      The result Table
      ImplNote:
      At this time, implementations only support static (i.e. !isRefreshing()) Tables and group aggregations. This operation remains under active development.
    • rangeJoin

      TOPS rangeJoin(TABLE rightTable, Collection<String> columnsToMatch, Collection<? extends Aggregation> aggregations)
      Perform a range join with rightTable. For each row in this Table, this operation joins aggregations over a range of responsive rows from rightTable according to zero-or-more exact join matches and one range join match. The operation is performed identically to rangeJoin(Object, Collection, RangeJoinMatch, Collection), after parsing is applied to the elements of columnsToMatch to produce the exact join matches and range join match.

      columnsToMatch Parsing

      The columnsToMatch argument is parsed as zero-or-more exact match expressions followed by a single range match expression.

      The exact match expressions are parsed as in other join operations. That is, the pattern expects an equals-separated pairing of a left column name with a right column name.

      For example:

       "LeftColumn = RightColumn"
       
      or
       "LeftColumn == RightColumn"
       

      The range match expression is expressed as a ternary logical expression, expressing the relationship between the left start column, the right range column, and the left end column. Each column name pair is separated by a logical operator, either < or <=. The entire expression may be preceded by a left arrow <- and/or followed by a right arrow ->, which when paired with the <= operator signify less than or equal (allow preceding) or greater than or equal (allow following), respectively.

      Examples:

      Parameters:
      rightTable - The Table to join with
      columnsToMatch - String expressions that will be parsed into join matches, a RangeStartRule and a RangeEndRule
      aggregations - The aggregations to perform over the responsive ranges from rightTable for each row from this Table
      Returns:
      The result Table
      ImplNote:
      At this time, implementations only support static (i.e. !isRefreshing()) Tables and group aggregations. This operation remains under active development.
    • groupBy

    • groupBy

      @ConcurrentMethod TOPS groupBy(String... groupByColumns)
    • groupBy

      @ConcurrentMethod TOPS groupBy(Collection<? extends ColumnName> groupByColumns)
    • aggAllBy

      @ConcurrentMethod TOPS aggAllBy(AggSpec spec)
    • aggAllBy

      @ConcurrentMethod TOPS aggAllBy(AggSpec spec, String... groupByColumns)
    • aggAllBy

      @ConcurrentMethod TOPS aggAllBy(AggSpec spec, ColumnName... groupByColumns)
    • aggAllBy

      @ConcurrentMethod TOPS aggAllBy(AggSpec spec, Collection<String> groupByColumns)
    • aggBy

      @ConcurrentMethod TOPS aggBy(Aggregation aggregation)
      Produce an aggregated result by grouping all rows from this into a single group of rows and applying aggregation to the result. The result table will have one row if this has one or more rows, or else zero rows.
      Parameters:
      aggregation - The aggregation to apply
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Collection<? extends Aggregation> aggregations)
      Produce an aggregated result by grouping all rows from this into a single group of rows and applying aggregations to the result. The result table will have one row if this has one or more rows, or else zero rows.
      Parameters:
      aggregations - The aggregations to apply
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Collection<? extends Aggregation> aggregations, boolean preserveEmpty)
      Produce an aggregated result by grouping all rows from this into a single group of rows and applying aggregations to the result.
      Parameters:
      aggregations - The aggregations to apply
      preserveEmpty - If preserveEmpty == true, the result table will always have one row. Otherwise, the result table will have one row if this has one or more rows, or else zero rows.
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Aggregation aggregation, String... groupByColumns)
      Produce an aggregated result by grouping this according to the groupByColumns and applying aggregation to each resulting group of rows. The result table will have one row per group, ordered by the encounter order within this, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.
      Parameters:
      aggregation - The aggregation to apply
      groupByColumns - The columns to group by
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Aggregation aggregation, Collection<? extends ColumnName> groupByColumns)
      Produce an aggregated result by grouping this according to the groupByColumns and applying aggregation to each resulting group of rows. The result table will have one row per group, ordered by the encounter order within this, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.
      Parameters:
      aggregation - The aggregation to apply
      groupByColumns - The columns to group by
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Collection<? extends Aggregation> aggregations, String... groupByColumns)
      Produce an aggregated result by grouping this according to the groupByColumns and applying aggregations to each resulting group of rows. The result table will have one row per group, ordered by the encounter order within this, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.
      Parameters:
      aggregations - The aggregations to apply
      groupByColumns - The columns to group by
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Collection<? extends Aggregation> aggregations, Collection<? extends ColumnName> groupByColumns)
      Produce an aggregated result by grouping this according to the groupByColumns and applying aggregations to each resulting group of rows. The result table will have one row per group, ordered by the encounter order within this, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.
      Parameters:
      aggregations - The aggregations to apply
      groupByColumns - The columns to group by
      Returns:
      A new table aggregating the rows of this
    • aggBy

      @ConcurrentMethod TOPS aggBy(Collection<? extends Aggregation> aggregations, boolean preserveEmpty, TABLE initialGroups, Collection<? extends ColumnName> groupByColumns)
      Produce an aggregated result by grouping this according to the groupByColumns and applying aggregations to each resulting group of rows. The result table will have one row per group, ordered by the encounter order within this, thereby ensuring that the row key for a given group never changes.
      Parameters:
      aggregations - The aggregations to apply
      preserveEmpty - Whether to keep result rows for groups that are initially empty or become empty as a result of updates. Each aggregation operator defines its own value for empty groups.
      initialGroups - A table whose distinct combinations of values for the groupByColumns should be used to create an initial set of aggregation groups. All other columns are ignored. This is useful in combination with preserveEmpty == true to ensure that particular groups appear in the result table, or with preserveEmpty == false to control the encounter order for a collection of groups and thus their relative order in the result. Changes to initialGroups are not expected or handled; if initialGroups is a refreshing table, only its contents at instantiation time will be used. If initialGroups == null, the result will be the same as if a table with no rows was supplied.
      groupByColumns - The columns to group by
      Returns:
      A new table aggregating the rows of this
    • updateBy

      TOPS updateBy(UpdateByOperation operation)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results over the entire table.
      Parameters:
      operation - the operation to apply to the table.
      Returns:
      a table with the same rowset, with the specified operation applied to the entire table
    • updateBy

      TOPS updateBy(UpdateByControl control, UpdateByOperation operation)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results over the entire table.
      Parameters:
      control - the control to use when updating the table.
      operation - the operation to apply to the table.
      Returns:
      a table with the same rowset, with the specified operation applied to the entire table
    • updateBy

      TOPS updateBy(Collection<? extends UpdateByOperation> operations)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results over the entire table.
      Parameters:
      operations - the operations to apply to the table.
      Returns:
      a table with the same rowset, with the specified operations applied to the entire table.
    • updateBy

      TOPS updateBy(UpdateByControl control, Collection<? extends UpdateByOperation> operations)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results over the entire 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 rowset, with the specified operations applied to the entire table
    • updateBy

      TOPS updateBy(UpdateByOperation operation, String... byColumns)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results for the row group (as determined by the byColumns).
      Parameters:
      operation - the operation to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same rowSet, with the specified operation applied to each group defined by the byColumns
    • updateBy

      TOPS updateBy(UpdateByControl control, UpdateByOperation operation, String... byColumns)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results for the row group (as determined by the byColumns).
      Parameters:
      operation - the operation to apply to the table.
      control - the control to use when updating the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same rowSet, with the specified operation applied to each group defined by the byColumns
    • updateBy

      TOPS updateBy(Collection<? extends UpdateByOperation> operations, String... byColumns)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results for the row group (as determined by the byColumns).
      Parameters:
      operations - the operations to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same rowSet, with the specified operations applied to each group defined by the byColumns
    • updateBy

      TOPS updateBy(Collection<? extends UpdateByOperation> operations, Collection<? extends ColumnName> byColumns)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results for the row group (as determined by the byColumns).
      Parameters:
      operations - the operations to apply to the table.
      byColumns - the columns to group by before applying.
      Returns:
      a table with the same rowSet, with the specified operations applied to each group defined by the byColumns
    • updateBy

      TOPS updateBy(UpdateByControl control, Collection<? extends UpdateByOperation> operations, Collection<? extends ColumnName> byColumns)
      Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by the operations, which support incremental aggregation over the corresponding rows in the parent table. The aggregations will apply position or time-based windowing and compute the results for the row group (as determined by the byColumns).
      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 rowSet, with the specified operations applied to each group defined by the byColumns
    • selectDistinct

      @ConcurrentMethod TOPS selectDistinct()
    • selectDistinct

      @ConcurrentMethod TOPS selectDistinct(String... columns)
    • selectDistinct

      @ConcurrentMethod TOPS selectDistinct(Collection<? extends Selectable> columns)
    • countBy

      @ConcurrentMethod TOPS countBy(String countColumnName)
    • countBy

      @ConcurrentMethod TOPS countBy(String countColumnName, String... groupByColumns)
    • countBy

      @ConcurrentMethod TOPS countBy(String countColumnName, ColumnName... groupByColumns)
    • countBy

      @ConcurrentMethod TOPS countBy(String countColumnName, Collection<String> groupByColumns)
    • firstBy

      Returns the first row of the given table.
    • firstBy

      @ConcurrentMethod TOPS firstBy(String... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • firstBy

      @ConcurrentMethod TOPS firstBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • firstBy

      @ConcurrentMethod TOPS firstBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and retrieves the first for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • lastBy

      Returns the last row of the given table.
    • lastBy

      @ConcurrentMethod TOPS lastBy(String... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • lastBy

      @ConcurrentMethod TOPS lastBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • lastBy

      @ConcurrentMethod TOPS lastBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and retrieves the last for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • minBy

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

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

    • minBy

      @ConcurrentMethod TOPS minBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • minBy

      @ConcurrentMethod TOPS minBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • minBy

      @ConcurrentMethod TOPS minBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the min for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • maxBy

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

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

    • maxBy

      @ConcurrentMethod TOPS maxBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy() }
    • maxBy

      @ConcurrentMethod TOPS maxBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy() }
    • maxBy

      @ConcurrentMethod TOPS maxBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the max for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy() }
    • sumBy

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

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

    • sumBy

      @ConcurrentMethod TOPS sumBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • sumBy

      @ConcurrentMethod TOPS sumBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • sumBy

      @ConcurrentMethod TOPS sumBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the sum for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • avgBy

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

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

    • avgBy

      @ConcurrentMethod TOPS avgBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • avgBy

      @ConcurrentMethod TOPS avgBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • avgBy

      @ConcurrentMethod TOPS avgBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the average for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • medianBy

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

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

    • medianBy

      @ConcurrentMethod TOPS medianBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy() }
    • medianBy

      @ConcurrentMethod TOPS medianBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy() }
    • medianBy

      @ConcurrentMethod TOPS medianBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the median for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy() }
    • stdBy

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

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

      Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

    • stdBy

      @ConcurrentMethod TOPS stdBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the sample standard deviation for the rest of the fields

      Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • stdBy

      @ConcurrentMethod TOPS stdBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the sample standard deviation for the rest of the fields

      Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • stdBy

      @ConcurrentMethod TOPS stdBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the sample standard deviation for the rest of the fields

      Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • varBy

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

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

      Sample variance is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

    • varBy

      @ConcurrentMethod TOPS varBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the sample variance for the rest of the fields

      Sample variance is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • varBy

      @ConcurrentMethod TOPS varBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the sample variance for the rest of the fields

      Sample variance is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • varBy

      @ConcurrentMethod TOPS varBy(Collection<String> groupByColumns)
      Groups the data column according to groupByColumns and computes the variance for the rest of the fields

      Sample variance is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.

      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • absSumBy

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

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

    • absSumBy

      @ConcurrentMethod TOPS absSumBy(String... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • absSumBy

      @ConcurrentMethod TOPS absSumBy(ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the sum of the absolute values for the rest of the fields
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • absSumBy

      @ConcurrentMethod TOPS 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
      Parameters:
      groupByColumns - The grouping columns as in groupBy()
    • wsumBy

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

      Parameters:
      weightColumn - the column to use for the weight
    • wsumBy

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

      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy()
    • wsumBy

      @ConcurrentMethod TOPS wsumBy(String weightColumn, ColumnName... 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.

      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy()
    • wsumBy

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

      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy()
    • wavgBy

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

      Parameters:
      weightColumn - the column to use for the weight
    • wavgBy

      @ConcurrentMethod TOPS wavgBy(String weightColumn, String... groupByColumns)
      Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy()
    • wavgBy

      @ConcurrentMethod TOPS wavgBy(String weightColumn, ColumnName... groupByColumns)
      Groups the data column according to groupByColumns and computes the weighted average using weightColumn for the rest of the fields
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy()
    • wavgBy

      @ConcurrentMethod TOPS 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
      Parameters:
      weightColumn - the column to use for the weight
      groupByColumns - The grouping columns as in groupBy()
    • ungroup

      TOPS ungroup()
      Ungroups a table by expanding all columns of arrays or vectors into columns of singular values, creating one row in the output table for each value in the columns to be ungrouped. Columns that are not ungrouped have their values duplicated in each output row corresponding to a given input row. All arrays and vectors must be the same size.
      Returns:
      the ungrouped table
    • ungroup

      TOPS ungroup(boolean nullFill)
      Ungroups a table by expanding all columns of arrays or vectors into columns of singular values, creating one row in the output table for each value in the columns to be ungrouped. Columns that are not ungrouped have their values duplicated in each output row corresponding to a given input row.
      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.
      Returns:
      the ungrouped table
    • ungroup

      TOPS ungroup(String... columnsToUngroup)
      Ungroups a table by expanding columns of arrays or vectors into columns of singular values, creating one row in the output table for each value in the columns to be ungrouped. Columns that are not ungrouped have their values duplicated in each output row corresponding to a given input row. The arrays and vectors must be the same size.
      Parameters:
      columnsToUngroup - the columns to ungroup
      Returns:
      the ungrouped table
    • ungroup

      TOPS ungroup(boolean nullFill, String... columnsToUngroup)
      Ungroups a table by expanding columns of arrays or vectors into columns of singular values, creating one row in the output table for each value in the columns to be ungrouped. Columns that are not ungrouped have their values duplicated in each output row corresponding to a given input row.
      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

      TOPS ungroup(boolean nullFill, Collection<? extends ColumnName> columnsToUngroup)
      Ungroups a table by expanding columns of arrays or vectors into columns of singular values, creating one row in the output table for each value in the columns to be ungrouped. Columns that are not ungrouped have their values duplicated in each output row corresponding to a given input row.
      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
    • dropColumns

      @ConcurrentMethod TOPS dropColumns(String... columnNames)
      Creates a new table without the columnNames from this.
      Parameters:
      columnNames - the columns to drop
      Returns:
      the table
    • dropColumns

      @ConcurrentMethod TOPS dropColumns(Collection<String> columnNames)
      Creates a new table without the columnNames from this.
      Parameters:
      columnNames - the columns to drop
      Returns:
      the table
    • dropColumns

      @ConcurrentMethod TOPS dropColumns(ColumnName... columnNames)
      Creates a new table without the columnNames from this.
      Parameters:
      columnNames - the columns to drop
      Returns:
      the table