Interface TableOperations<TOPS extends TableOperations<TOPS,TABLE>,TABLE>
 Type Parameters:
TOPS
 the table operations typeTABLE
 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
,MultiJoinTable
,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

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 asof join with therightTable
.Perform an asof 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 exactjoin with therightTable
.Perform an exactjoin with therightTable
.exactJoin
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform an exactjoin 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 naturaljoin with therightTable
.naturalJoin
(TABLE rightTable, String columnsToMatch, String columnsToAdd) Perform a naturaljoin with therightTable
.naturalJoin
(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform an exactjoin with therightTable
.Perform an reverseasof join with therightTable
.Perform a reverseasof 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) 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 windowbased aggregations of columns in its parent.updateBy
(UpdateByControl control, UpdateByOperation operation, String... byColumns) Creates a table with additional columns calculated from windowbased aggregations of columns in its parent.updateBy
(UpdateByControl control, Collection<? extends UpdateByOperation> operations) Creates a table with additional columns calculated from windowbased 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 windowbased aggregations of columns in its parent.updateBy
(UpdateByOperation operation) Creates a table with additional columns calculated from windowbased aggregations of columns in its parent.updateBy
(UpdateByOperation operation, String... byColumns) Creates a table with additional columns calculated from windowbased aggregations of columns in its parent.updateBy
(Collection<? extends UpdateByOperation> operations) Creates a table with additional columns calculated from windowbased aggregations of columns in its parent.updateBy
(Collection<? extends UpdateByOperation> operations, String... byColumns) Creates a table with additional columns calculated from windowbased aggregations of columns in its parent.updateBy
(Collection<? extends UpdateByOperation> operations, Collection<? extends ColumnName> byColumns) Creates a table with additional columns calculated from windowbased 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 reevaluated, 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 reevaluated, 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

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 naturaljoin 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 naturaljoined table

naturalJoin
Perform a naturaljoin 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 naturaljoined table

naturalJoin
TOPS naturalJoin(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform an exactjoin 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 naturaljoined table

exactJoin
Perform an exactjoin 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 exactjoined table

exactJoin
Perform an exactjoin 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 exactjoined table

exactJoin
TOPS exactJoin(TABLE rightTable, Collection<? extends JoinMatch> columnsToMatch, Collection<? extends JoinAddition> columnsToAdd) Perform an exactjoin 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 exactjoined 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 keycolumns 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 nonkeycolumns 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 nonempty 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 keycolumns 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 rightrow 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 asof 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 asof 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 reverseasof 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 reverseasof 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 zeroormore exact join matches and one range join match.Matching Rules
The exact join matches identify possiblyresponsive 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 RowInclusion 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
, nonNaN
right rows were found using the exact join matches, or none were in range according to the range join match.  singlevalue ranges
 A singlevalue 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 singlevalue 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 relativematch 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
 Possiblyempty collection ofjoin matches
that dictate exactmatch 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 zeroormore 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 zeroormore 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 equalsseparated 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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 windowbased 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 timebased 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
