Interface TableOperations<TOPS extends TableOperations<TOPS,TABLE>,TABLE>
- Type Parameters:
TOPS
- the table operations typeTABLE
- the table type
- All Known Subinterfaces:
IcebergTable
,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
,IcebergTableImpl
,InMemoryAppendOnlyInputTable
,InMemoryKeyBackedInputTable
,InMemoryTable
,InputTableBase
,JoinBase
,JoinTable
,KeyedArrayBackedInputTable
,LazyUpdateTable
,MergeTable
,MultiJoinTable
,NaturalJoinTable
,NewTable
,PartitionAwareSourceTable
,QueryReplayGroupedTable
,QueryTable
,QueryTable.FilteredTable
,RangeJoinTable
,RedefinableTable
,ReplayGroupedFullTable
,ReplayLastByGroupedTable
,ReplayTable
,ReplayTableBase
,ReverseTable
,SelectDistinctTable
,SelectTable
,SimpleSourceTable
,SliceTable
,SnapshotTable
,SnapshotWhenTable
,SortTable
,SourceTable
,StackTraceMixIn
,TableBase
,TableHandle
,TableOperationsAdapter
,TableSpecAdapter
,TailTable
,TicketTable
,TimeTable
,TimeTable
,UncoalescedTable
,UngroupTable
,UpdatableTable
,UpdateByTable
,UpdateSourceQueryTable
,UpdateTable
,UpdateViewTable
,ViewTable
,WhereInTable
,WhereTable
-
Field Summary
-
Method Summary
Modifier and TypeMethodDescriptionabsSumBy()
Produces a single row table with the absolute sum of each column.absSumBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the sum of the absolute values for the rest of the fieldsGroups the data column according togroupByColumns
and computes the sum of the absolute values for the rest of the fieldsabsSumBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the sum of the absolute values for the rest of the fieldsaggAllBy
(AggSpec spec, ColumnName... groupByColumns) aggAllBy
(AggSpec spec, Collection<String> groupByColumns) aggBy
(Aggregation aggregation) Produce an aggregated result by grouping all rows fromthis
into a single group of rows and applyingaggregation
to the result.aggBy
(Aggregation aggregation, String... groupByColumns) Produce an aggregated result by groupingthis
according to thegroupByColumns
and applyingaggregation
to each resulting group of rows.aggBy
(Aggregation aggregation, Collection<? extends ColumnName> groupByColumns) Produce an aggregated result by groupingthis
according to thegroupByColumns
and applyingaggregation
to each resulting group of rows.aggBy
(Collection<? extends Aggregation> aggregations) Produce an aggregated result by grouping all rows fromthis
into a single group of rows and applyingaggregations
to the result.aggBy
(Collection<? extends Aggregation> aggregations, boolean preserveEmpty) Produce an aggregated result by grouping all rows fromthis
into a single group of rows and applyingaggregations
to the result.aggBy
(Collection<? extends Aggregation> aggregations, boolean preserveEmpty, TABLE initialGroups, Collection<? extends ColumnName> groupByColumns) Produce an aggregated result by groupingthis
according to thegroupByColumns
and applyingaggregations
to each resulting group of rows.aggBy
(Collection<? extends Aggregation> aggregations, String... groupByColumns) Produce an aggregated result by groupingthis
according to thegroupByColumns
and applyingaggregations
to each resulting group of rows.aggBy
(Collection<? extends Aggregation> aggregations, Collection<? extends ColumnName> groupByColumns) Produce an aggregated result by groupingthis
according to thegroupByColumns
and applyingaggregations
to each resulting group of rows.Perform an as-of join with therightTable
.Perform an as-of join with therightTable
.asOfJoin
(TABLE rightTable, Collection<? extends JoinMatch> exactMatches, AsOfJoinMatch asOfMatch, Collection<? extends JoinAddition> columnsToAdd) avgBy()
Produces a single row table with the average of each column.avgBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the average for the rest of the fieldsGroups the data column according togroupByColumns
and computes the average for the rest of the fieldsavgBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the average for the rest of the fieldscountBy
(String countColumnName, ColumnName... groupByColumns) countBy
(String countColumnName, Collection<String> groupByColumns) dropColumns
(ColumnName... columnNames) Creates a new table without thecolumnNames
fromthis
.dropColumns
(String... columnNames) Creates a new table without thecolumnNames
fromthis
.dropColumns
(Collection<String> columnNames) Creates a new table without thecolumnNames
fromthis
.Perform an exact-join with therightTable
.Perform an exact-join with therightTable
.exactJoin
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform an exact-join with therightTable
.firstBy()
Returns the first row of the given table.firstBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and retrieves the first for the rest of the fieldsGroups the data column according togroupByColumns
and retrieves the first for the rest of the fieldsfirstBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and retrieves the first for the rest of the fieldsgroupBy()
groupBy
(Collection<? extends ColumnName> groupByColumns) head
(long size) Perform a cross join with therightTable
.Perform a cross join with therightTable
.Perform a cross join with therightTable
.join
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform a cross join with therightTable
.join
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd, int reserveBits) Perform a cross join with therightTable
.lastBy()
Returns the last row of the given table.lastBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and retrieves the last for the rest of the fieldsGroups the data column according togroupByColumns
and retrieves the last for the rest of the fieldslastBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and retrieves the last for the rest of the fieldslazyUpdate
(String... columns) Compute column formulas on demand.lazyUpdate
(Collection<? extends Selectable> columns) Compute column formulas on demand.maxBy()
Produces a single row table with the maximum of each column.maxBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the max for the rest of the fieldsGroups the data column according togroupByColumns
and computes the max for the rest of the fieldsmaxBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the max for the rest of the fieldsmedianBy()
Produces a single row table with the median of each column.medianBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the median for the rest of the fieldsGroups the data column according togroupByColumns
and computes the median for the rest of the fieldsmedianBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the median for the rest of the fieldsminBy()
Produces a single row table with the minimum of each column.minBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the min for the rest of the fieldsGroups the data column according togroupByColumns
and computes the min for the rest of the fieldsminBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the min for the rest of the fieldsnaturalJoin
(TABLE rightTable, String columnsToMatch) Perform an natural-join with therightTable
.naturalJoin
(TABLE rightTable, String columnsToMatch, String columnsToAdd) Perform a natural-join with therightTable
.naturalJoin
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform an exact-join with therightTable
.Perform an reverse-as-of join with therightTable
.Perform a reverse-as-of join with therightTable
.rangeJoin
(TABLE rightTable, Collection<? extends JoinMatch> exactMatches, RangeJoinMatch rangeMatch, Collection<? extends Aggregation> aggregations) Perform a range join withrightTable
.rangeJoin
(TABLE rightTable, Collection<String> columnsToMatch, Collection<? extends Aggregation> aggregations) Perform a range join withrightTable
.reverse()
select()
select
(Collection<? extends Selectable> columns) selectDistinct
(String... columns) selectDistinct
(Collection<? extends Selectable> columns) slice
(long firstPositionInclusive, long lastPositionExclusive) Extracts a subset of a table by row position.snapshot()
Creates a table with a single static snapshot ofthis
.snapshotWhen
(TABLE trigger, SnapshotWhenOptions options) Creates a table that captures a snapshot ofthis
whenevertrigger
updates.snapshotWhen
(TABLE trigger, SnapshotWhenOptions.Flag... features) Creates a table that captures a snapshot ofthis
whenevertrigger
updates.snapshotWhen
(TABLE trigger, Collection<SnapshotWhenOptions.Flag> features, String... stampColumns) Creates a table that captures a snapshot ofthis
whenevertrigger
updates.sort
(Collection<SortColumn> columnsToSortBy) sortDescending
(String... columnsToSortBy) stdBy()
Produces a single row table with the sample standard deviation of each column.stdBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the sample standard deviation for the rest of the fieldsGroups the data column according togroupByColumns
and computes the sample standard deviation for the rest of the fieldsstdBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the sample standard deviation for the rest of the fieldssumBy()
Produces a single row table with the sum of each column.sumBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the sum for the rest of the fieldsGroups the data column according togroupByColumns
and computes the sum for the rest of the fieldssumBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the sum for the rest of the fieldstail
(long size) 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.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.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.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.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.update
(Collection<? extends Selectable> columns) updateBy
(UpdateByControl control, UpdateByOperation operation) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.updateBy
(UpdateByControl control, UpdateByOperation operation, String... byColumns) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.updateBy
(UpdateByControl control, Collection<? extends UpdateByOperation> operations) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.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.updateBy
(UpdateByOperation operation) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.updateBy
(UpdateByOperation operation, String... byColumns) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.updateBy
(Collection<? extends UpdateByOperation> operations) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.updateBy
(Collection<? extends UpdateByOperation> operations, String... byColumns) Creates a table with additional columns calculated from window-based aggregations of columns in its parent.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.updateView
(String... columns) updateView
(Collection<? extends Selectable> columns) varBy()
Produces a single row table with the sample variance of each column.varBy
(ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the sample variance for the rest of the fieldsGroups the data column according togroupByColumns
and computes the sample variance for the rest of the fieldsvarBy
(Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the variance for the rest of the fieldsview
(Collection<? extends Selectable> columns) Produces a single row table with the weighted average using weightColumn for the rest of the fieldswavgBy
(String weightColumn, ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the weighted average using weightColumn for the rest of the fieldsGroups the data column according togroupByColumns
and computes the weighted average using weightColumn for the rest of the fieldswavgBy
(String weightColumn, Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the weighted average using weightColumn for the rest of the fieldsFiltersthis
table based on the set of values in therightTable
.whereIn
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch) Filtersthis
table based on the set of values in therightTable
.whereNotIn
(TABLE rightTable, String... columnsToMatch) Filtersthis
table based on the set of values not in therightTable
.whereNotIn
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch) Filtersthis
table based on the set of values not in therightTable
.Computes the weighted sum for all rows in the table using weightColumn for the rest of the fieldswsumBy
(String weightColumn, ColumnName... groupByColumns) Groups the data column according togroupByColumns
and computes the weighted sum using weightColumn for the rest of the fieldsGroups the data column according togroupByColumns
and computes the weighted sum using weightColumn for the rest of the fieldswsumBy
(String weightColumn, Collection<String> groupByColumns) Groups the data column according togroupByColumns
and computes the weighted sum using weightColumn for the rest of the fields
-
Field Details
-
AGG_BY_PRESERVE_EMPTY_DEFAULT
static final boolean AGG_BY_PRESERVE_EMPTY_DEFAULT- See Also:
-
-
Method Details
-
head
-
tail
-
reverse
-
snapshot
TOPS snapshot()Creates a table with a single static snapshot ofthis
.- Returns:
- the snapshot
-
snapshotWhen
Creates a table that captures a snapshot ofthis
whenevertrigger
updates.Equivalent to
snapshotWhen(trigger, SnapshotWhenControl.of(features))
.- Parameters:
trigger
- the trigger tablefeatures
- 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 ofthis
whenevertrigger
updates.Equivalent to
snapshotWhen(trigger, SnapshotWhenControl.of(features, stampColumns))
.See
SnapshotWhenOptions
for details on thestampColumns
.- Parameters:
trigger
- the trigger tablefeatures
- the snapshot featuresstampColumns
- the stamp columns- Returns:
- the snapshotting table
- See Also:
-
snapshotWhen
Creates a table that captures a snapshot ofthis
whenevertrigger
updates.- Parameters:
trigger
- the trigger tableoptions
- the snapshot options- Returns:
- the snapshotting table
- See Also:
-
sort
-
sortDescending
-
sort
-
where
-
where
-
whereIn
Filtersthis
table based on the set of values in therightTable
.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
Filtersthis
table based on the set of values in therightTable
.Note that when the
rightTable
ticks, all of the rows inthis
table are going to be re-evaluated, thus the intention is that therightTable
is fairly slow moving compared withthis
table.- Parameters:
rightTable
- the filtering table.columnsToMatch
- the columns to match between the two tables- Returns:
- a new table filtered on right table
-
whereNotIn
Filtersthis
table based on the set of values not in therightTable
.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
Filtersthis
table based on the set of values not in therightTable
.Note that when the
rightTable
ticks, all of the rows inthis
table are going to be re-evaluated, thus the intention is that therightTable
is fairly slow moving compared withthis
table.- Parameters:
rightTable
- the filtering table.columnsToMatch
- the columns to match between the two tables- Returns:
- a new table filtered on right table
-
slice
Extracts a subset of a table by row position.If both firstPosition and lastPosition are positive, then the rows are counted from the beginning of the table. The firstPosition is inclusive, and the lastPosition is exclusive. The
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.
If firstPosition is negative and lastPosition is positive, then firstPosition is counted from the end of the table, inclusively. The lastPosition is counted from the beginning of the table, exclusively. For example, slice(-3, 5) returns all rows starting from the third-last row to the fifth row of the table. If there are no rows between these positions, the function will return an empty table.
- Parameters:
firstPositionInclusive
- the first position to include in the resultlastPositionExclusive
- the last position to include in the result- Returns:
- a new Table, which is the request subset of rows from the original table
-
view
-
view
-
updateView
-
updateView
-
update
-
update
-
lazyUpdate
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
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
-
select
-
naturalJoin
Perform an natural-join with therightTable
.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
Perform a natural-join with therightTable
.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 therightTable
.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
Perform an exact-join with therightTable
.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
Perform an exact-join with therightTable
.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 therightTable
.Similar to
naturalJoin(Object, Collection, Collection)
, but requires that exactly one match from therightTable
.- 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
Perform a cross join with therightTable
.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
Perform a cross join with therightTable
.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
Perform a cross join with therightTable
.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 therightTable
.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 therightTable
.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 therightTable
's columns that are included in thecolumnsToAdd
argument. The rows are ordered first by thethis
table then by therightTable
. IfcolumnsToMatch
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
Perform an as-of join with therightTable
.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
Perform an as-of join with therightTable
.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
Perform an reverse-as-of join with therightTable
.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
Perform a reverse-as-of join with therightTable
.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 withrightTable
. For each row inthis
Table, this operation joinsaggregations
over a range of responsive rows fromrightTable
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
withnull
orNaN
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 ifsorted
) 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 (becausevalue < 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 benull
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 benull
(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 isnull
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 isnull
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 arenull
the range is unbounded in both directions, and all matched right rows will be included.
- Parameters:
rightTable
- The Table to join withexactMatches
- Possibly-empty collection ofjoin matches
that dictate exact-match criteria. That is, rows fromrightTable
that might be responsive to rows fromthis
Table will have identical values for the column pairs expressed by these matches.rangeMatch
- Specifies the range match criteria for determining the responsive rows fromrightTable
for each row fromthis
Table, within the buckets created by matching on theexactMatches
aggregations
- Theaggregations
to perform over the responsive ranges fromrightTable
for each row fromthis
Table- Returns:
- The result Table
- ImplNote:
- At this time, implementations only support static (i.e.
!isRefreshing()
) Tables andgroup
aggregations. This operation remains under active development.
-
rangeJoin
TOPS rangeJoin(TABLE rightTable, Collection<String> columnsToMatch, Collection<? extends Aggregation> aggregations) Perform a range join withrightTable
. For each row inthis
Table, this operation joinsaggregations
over a range of responsive rows fromrightTable
according to zero-or-more exact join matches and one range join match. The operation is performed identically torangeJoin(Object, Collection, RangeJoinMatch, Collection)
, after parsing is applied to the elements ofcolumnsToMatch
to produce theexact join matches
andrange join match
.columnsToMatch
ParsingThe
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 signifyless than or equal (allow preceding)
orgreater than or equal (allow following)
, respectively.Examples:
- For
less than
paired withgreater than
:"leftStartColumn < rightRangeColumn < leftEndColumn"
- For
less than or equal
paired withgreater than or equal
:"leftStartColumn <= rightRangeColumn <= leftEndColumn"
- For
less than or equal (allow preceding)
paired withgreater than or equal (allow following)
:"<- leftStartColumn <= rightRangeColumn <= leftEndColumn ->"
- Parameters:
rightTable
- The Table to join withcolumnsToMatch
-String
expressions that will be parsed intojoin matches
, aRangeStartRule
and aRangeEndRule
aggregations
- Theaggregations
to perform over the responsive ranges fromrightTable
for each row fromthis
Table- Returns:
- The result Table
- ImplNote:
- At this time, implementations only support static (i.e.
!isRefreshing()
) Tables andgroup
aggregations. This operation remains under active development.
- For
-
groupBy
-
groupBy
-
groupBy
-
aggAllBy
-
aggAllBy
-
aggAllBy
-
aggAllBy
-
aggBy
Produce an aggregated result by grouping all rows fromthis
into a single group of rows and applyingaggregation
to the result. The result table will have one row ifthis
has one or more rows, or else zero rows.- Parameters:
aggregation
- Theaggregation
to apply- Returns:
- A new table aggregating the rows of
this
-
aggBy
Produce an aggregated result by grouping all rows fromthis
into a single group of rows and applyingaggregations
to the result. The result table will have one row ifthis
has one or more rows, or else zero rows.- Parameters:
aggregations
- Theaggregations
to apply- Returns:
- A new table aggregating the rows of
this
-
aggBy
Produce an aggregated result by grouping all rows fromthis
into a single group of rows and applyingaggregations
to the result.- Parameters:
aggregations
- Theaggregations
to applypreserveEmpty
- IfpreserveEmpty == true
, the result table will always have one row. Otherwise, the result table will have one row ifthis
has one or more rows, or else zero rows.- Returns:
- A new table aggregating the rows of
this
-
aggBy
Produce an aggregated result by groupingthis
according to thegroupByColumns
and applyingaggregation
to each resulting group of rows. The result table will have one row per group, ordered by the encounter order withinthis
, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.- Parameters:
aggregation
- Theaggregation
to applygroupByColumns
- 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 groupingthis
according to thegroupByColumns
and applyingaggregation
to each resulting group of rows. The result table will have one row per group, ordered by the encounter order withinthis
, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.- Parameters:
aggregation
- Theaggregation
to applygroupByColumns
- Thecolumns
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 groupingthis
according to thegroupByColumns
and applyingaggregations
to each resulting group of rows. The result table will have one row per group, ordered by the encounter order withinthis
, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.- Parameters:
aggregations
- Theaggregations
to applygroupByColumns
- 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 groupingthis
according to thegroupByColumns
and applyingaggregations
to each resulting group of rows. The result table will have one row per group, ordered by the encounter order withinthis
, thereby ensuring that the row key for a given group never changes. Groups that become empty will be removed from the result.- Parameters:
aggregations
- Theaggregations
to applygroupByColumns
- Thecolumns
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 groupingthis
according to thegroupByColumns
and applyingaggregations
to each resulting group of rows. The result table will have one row per group, ordered by the encounter order withinthis
, thereby ensuring that the row key for a given group never changes.- Parameters:
aggregations
- Theaggregations
to applypreserveEmpty
- Whether to keep result rows for groups that are initially empty or become empty as a result of updates. Each aggregation operator defines its own value for empty groups.initialGroups
- A table whose distinct combinations of values for thegroupByColumns
should be used to create an initial set of aggregation groups. All other columns are ignored. This is useful in combination withpreserveEmpty == true
to ensure that particular groups appear in the result table, or withpreserveEmpty == false
to control the encounter order for a collection of groups and thus their relative order in the result. Changes toinitialGroups
are not expected or handled; ifinitialGroups
is a refreshing table, only its contents at instantiation time will be used. IfinitialGroups == null
, the result will be the same as if a table with no rows was supplied.groupByColumns
- Thecolumns
to group by- Returns:
- A new table aggregating the rows of
this
-
updateBy
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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
- thecontrol
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
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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
- thecontrol
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
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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 thebyColumns
).- 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
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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 thebyColumns
).- Parameters:
operation
- the operation to apply to the table.control
- thecontrol
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
Creates a table with additional columns calculated from window-based aggregations of columns in its parent. The aggregations are defined by theoperations
, 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 thebyColumns
).- 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 theoperations
, 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 thebyColumns
).- 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 theoperations
, 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 thebyColumns
).- Parameters:
control
- thecontrol
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
-
selectDistinct
-
selectDistinct
-
countBy
-
countBy
-
countBy
-
countBy
-
firstBy
Returns the first row of the given table. -
firstBy
Groups the data column according togroupByColumns
and retrieves the first for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
firstBy
Groups the data column according togroupByColumns
and retrieves the first for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
firstBy
Groups the data column according togroupByColumns
and retrieves the first for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
lastBy
Returns the last row of the given table. -
lastBy
Groups the data column according togroupByColumns
and retrieves the last for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
lastBy
Groups the data column according togroupByColumns
and retrieves the last for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
lastBy
Groups the data column according togroupByColumns
and retrieves the last for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
minBy
Produces a single row table with the minimum of each column.When the input table is empty, zero output rows are produced.
-
minBy
Groups the data column according togroupByColumns
and computes the min for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
minBy
Groups the data column according togroupByColumns
and computes the min for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
minBy
Groups the data column according togroupByColumns
and computes the min for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
maxBy
Produces a single row table with the maximum of each column.When the input table is empty, zero output rows are produced.
-
maxBy
Groups the data column according togroupByColumns
and computes the max for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
}
-
maxBy
Groups the data column according togroupByColumns
and computes the max for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
}
-
maxBy
Groups the data column according togroupByColumns
and computes the max for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
}
-
sumBy
Produces a single row table with the sum of each column.When the input table is empty, zero output rows are produced.
-
sumBy
Groups the data column according togroupByColumns
and computes the sum for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
sumBy
Groups the data column according togroupByColumns
and computes the sum for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
sumBy
Groups the data column according togroupByColumns
and computes the sum for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
avgBy
Produces a single row table with the average of each column.When the input table is empty, zero output rows are produced.
-
avgBy
Groups the data column according togroupByColumns
and computes the average for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
avgBy
Groups the data column according togroupByColumns
and computes the average for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
avgBy
Groups the data column according togroupByColumns
and computes the average for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
medianBy
Produces a single row table with the median of each column.When the input table is empty, zero output rows are produced.
-
medianBy
Groups the data column according togroupByColumns
and computes the median for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
}
-
medianBy
Groups the data column according togroupByColumns
and computes the median for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
}
-
medianBy
Groups the data column according togroupByColumns
and computes the median for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
}
-
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
Groups the data column according togroupByColumns
and computes the sample standard deviation for the rest of the fieldsSample 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 ingroupBy()
-
stdBy
Groups the data column according togroupByColumns
and computes the sample standard deviation for the rest of the fieldsSample 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 ingroupBy()
-
stdBy
Groups the data column according togroupByColumns
and computes the sample standard deviation for the rest of the fieldsSample 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 ingroupBy()
-
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
Groups the data column according togroupByColumns
and computes the sample variance for the rest of the fieldsSample 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 ingroupBy()
-
varBy
Groups the data column according togroupByColumns
and computes the sample variance for the rest of the fieldsSample 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 ingroupBy()
-
varBy
Groups the data column according togroupByColumns
and computes the variance for the rest of the fieldsSample 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 ingroupBy()
-
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
Groups the data column according togroupByColumns
and computes the sum of the absolute values for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
absSumBy
Groups the data column according togroupByColumns
and computes the sum of the absolute values for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
absSumBy
Groups the data column according togroupByColumns
and computes the sum of the absolute values for the rest of the fields- Parameters:
groupByColumns
- The grouping columns as ingroupBy()
-
wsumBy
Computes the weighted sum for all rows in the table using weightColumn for the rest of the fieldsIf 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
Groups the data column according togroupByColumns
and computes the weighted sum using weightColumn for the rest of the fieldsIf 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 weightgroupByColumns
- The grouping columns as ingroupBy()
-
wsumBy
Groups the data column according togroupByColumns
and computes the weighted sum using weightColumn for the rest of the fieldsIf 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 weightgroupByColumns
- The grouping columns as ingroupBy()
-
wsumBy
Groups the data column according togroupByColumns
and computes the weighted sum using weightColumn for the rest of the fieldsIf 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 weightgroupByColumns
- The grouping columns as ingroupBy()
-
wavgBy
Produces a single row table with the weighted average using weightColumn for the rest of the fieldsWhen the input table is empty, zero output rows are produced.
- Parameters:
weightColumn
- the column to use for the weight
-
wavgBy
Groups the data column according togroupByColumns
and computes the weighted average using weightColumn for the rest of the fields- Parameters:
weightColumn
- the column to use for the weightgroupByColumns
- The grouping columns as ingroupBy()
-
wavgBy
Groups the data column according togroupByColumns
and computes the weighted average using weightColumn for the rest of the fields- Parameters:
weightColumn
- the column to use for the weightgroupByColumns
- The grouping columns as ingroupBy()
-
wavgBy
Groups the data column according togroupByColumns
and computes the weighted average using weightColumn for the rest of the fields- Parameters:
weightColumn
- the column to use for the weightgroupByColumns
- The grouping columns as ingroupBy()
-
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
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
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
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
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
Creates a new table without thecolumnNames
fromthis
.- Parameters:
columnNames
- the columns to drop- Returns:
- the table
-
dropColumns
Creates a new table without thecolumnNames
fromthis
.- Parameters:
columnNames
- the columns to drop- Returns:
- the table
-
dropColumns
Creates a new table without thecolumnNames
fromthis
.- Parameters:
columnNames
- the columns to drop- Returns:
- the table
-