All Known Implementing Classes:: ColumnUpdateOperation

public interface UpdateByOperation

Defines an operation that can be applied to a table with Table#updateBy()}

Nested Class Summary

Nested Classes

Modifier and Type

Interface

Description

static interface

UpdateByOperation.Visitor<T>
Method Summary

Modifier and Type

Method

Description

static UpdateByOperation

CumCountWhere(String resultColumn, Filter filter)

Create a cumulative count where that counts the number of rows that pass the provided filter.

static UpdateByOperation

CumCountWhere(String resultColumn, String... filters)

Create a cumulative count where that counts the number of rows that pass the provided filters.

static UpdateByOperation

CumMax(String... pairs)

Create a cumulative maximum for the supplied column name pairs.

static UpdateByOperation

CumMin(String... pairs)

Create a cumulative minimum for the supplied column name pairs.

static UpdateByOperation

CumProd(String... pairs)

Create a cumulative product for the supplied column name pairs.

static UpdateByOperation

CumSum(String... pairs)

Create a cumulative sum for the supplied column name pairs.

static UpdateByOperation

Delta(DeltaControl control, String... pairs)

Create a delta for the supplied column name pairs.

static UpdateByOperation

Delta(String... pairs)

Create a delta for the supplied column name pairs.

static UpdateByOperation

Ema(double tickDecay, String... pairs)

Create an exponential moving average for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

Ema(OperationControl control, double tickDecay, String... pairs)

Create an exponential moving average for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

Ema(OperationControl control, String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving average for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ema(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving average for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ema(String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving average for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ema(String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving average for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMax(double tickDecay, String... pairs)

Create an exponential moving maximum for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

EmMax(OperationControl control, double tickDecay, String... pairs)

Create an exponential moving maximum for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

EmMax(OperationControl control, String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMax(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMax(String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMax(String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMin(double tickDecay, String... pairs)

Create an exponential moving minimum for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

EmMin(OperationControl control, double tickDecay, String... pairs)

Create an exponential moving minimum for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

EmMin(OperationControl control, String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMin(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMin(String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmMin(String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ems(double tickDecay, String... pairs)

Create an exponential moving sum for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

Ems(OperationControl control, double tickDecay, String... pairs)

Create an exponential moving sum for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

Ems(OperationControl control, String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving sum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ems(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving sum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ems(String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving sum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Ems(String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving sum for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmStd(double tickDecay, String... pairs)

Create an exponential moving standard deviation for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

EmStd(OperationControl control, double tickDecay, String... pairs)

Create an exponential moving standard deviation for the supplied column name pairs, using ticks as the decay unit.

static UpdateByOperation

EmStd(OperationControl control, String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmStd(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmStd(String timestampColumn, long timeDecay, String... pairs)

Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

EmStd(String timestampColumn, Duration durationDecay, String... pairs)

Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit.

static UpdateByOperation

Fill(String... pairs)

Create a forward fill for the supplied column name pairs.

static ColumnUpdateOperation

of(UpdateBySpec spec, Pair... columns)

Conjoin an UpdateBySpec with columns for it to be applied to so the engine can construct the proper operators.

static ColumnUpdateOperation

of(UpdateBySpec spec, String... columns)

Conjoin an UpdateBySpec with columns for it to be applied to so the engine can construct the proper operators.

static UpdateByOperation

RollingAvg(long revTicks, long fwdTicks, String... pairs)

Create a rolling average for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingAvg(long revTicks, String... pairs)

Create a rolling average for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingAvg(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingAvg(String timestampCol, long revTime, String... pairs)

Create a rolling average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingAvg(String timestampCol, Duration revDuration, String... pairs)

Create a rolling average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingAvg(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingCount(long revTicks, long fwdTicks, String... pairs)

Create a rolling count for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingCount(long revTicks, String... pairs)

Create a rolling count for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingCount(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling count for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingCount(String timestampCol, long revTime, String... pairs)

Create a rolling count for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingCount(String timestampCol, Duration revDuration, String... pairs)

Create a rolling count for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingCount(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling count for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(long revTicks, long fwdTicks, String resultColumn, Filter filter)

Create a rolling count where that will count values that pass the provided filter, using ticks as the windowing unit.

static UpdateByOperation

RollingCountWhere(long revTicks, long fwdTicks, String resultColumn, String... filters)

Create a rolling count where that will count values that pass the provided filters, using ticks as the windowing unit.

static UpdateByOperation

RollingCountWhere(long revTicks, String resultColumn, Filter filter)

Create a rolling count where that will count values that pass the provided filter, using ticks as the windowing unit.

static UpdateByOperation

RollingCountWhere(long revTicks, String resultColumn, String... filters)

Create a rolling count where that will count values that pass the provided filters, using ticks as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, long revTime, long fwdTime, String resultColumn, Filter filter)

Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, long revTime, long fwdTime, String resultColumn, String... filters)

Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, long revTime, String resultColumn, Filter filter)

Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, long revTime, String resultColumn, String... filters)

Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, Duration revDuration, String resultColumn, Filter filter)

Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, Duration revDuration, String resultColumn, String... filters)

Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, Duration revDuration, Duration fwdDuration, String resultColumn, Filter filter)

Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit.

static UpdateByOperation

RollingCountWhere(String timestampCol, Duration revDuration, Duration fwdDuration, String resultColumn, String... filters)

Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit.

static UpdateByOperation

RollingFormula(long revTicks, long fwdTicks, String formula)

Create a rolling formula using ticks as the windowing unit.

static UpdateByOperation

RollingFormula(long revTicks, long fwdTicks, String formula, String paramToken, String... pairs)

Create a rolling formula for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingFormula(long revTicks, String formula)

Create a rolling formula using ticks as the windowing unit.

static UpdateByOperation

RollingFormula(long revTicks, String formula, String paramToken, String... pairs)

Create a rolling formula for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, long revTime, long fwdTime, String formula)

Create a rolling formula using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, long revTime, long fwdTime, String formula, String paramToken, String... pairs)

Create a rolling formula for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, long revTime, String formula)

Create a rolling formula using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, long revTime, String formula, String paramToken, String... pairs)

Create a rolling formula for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, Duration revDuration, String formula)

Create a rolling formula using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, Duration revDuration, String formula, String paramToken, String... pairs)

Create a rolling formula for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, Duration revDuration, Duration fwdDuration, String formula)

Create a rolling formula using time as the windowing unit.

static UpdateByOperation

RollingFormula(String timestampCol, Duration revDuration, Duration fwdDuration, String formula, String paramToken, String... pairs)

Create a rolling formula for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingGroup(long prevTimeTicks, long fwdTimeTicks, String... pairs)

Create rolling groups for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingGroup(long prevTimeTicks, String... pairs)

Create rolling groups for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingGroup(String timestampCol, long prevWindowNanos, long fwdWindowNanos, String... pairs)

Create rolling groups for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingGroup(String timestampCol, long prevWindowNanos, String... pairs)

Create rolling groups for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingGroup(String timestampCol, Duration prevWindowDuration, String... pairs)

Create rolling groups for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingGroup(String timestampCol, Duration prevWindowDuration, Duration fwdWindowDuration, String... pairs)

Create rolling groups for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMax(long revTicks, long fwdTicks, String... pairs)

Create a rolling maximum for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingMax(long revTicks, String... pairs)

Create a rolling maximum for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingMax(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling maximum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMax(String timestampCol, long revTime, String... pairs)

Create a rolling maximum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMax(String timestampCol, Duration revDuration, String... pairs)

Create a rolling maximum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMax(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling maximum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMin(long revTicks, long fwdTicks, String... pairs)

Create a rolling minimum for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingMin(long revTicks, String... pairs)

Create a rolling minimum for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingMin(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling minimum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMin(String timestampCol, long revTime, String... pairs)

Create a rolling minimum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMin(String timestampCol, Duration revDuration, String... pairs)

Create a rolling minimum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingMin(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling minimum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingProduct(long revTicks, long fwdTicks, String... pairs)

Create a rolling product for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingProduct(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling product for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingProduct(String timestampCol, long revTime, String... pairs)

Create a rolling product for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingProduct(String timestampCol, Duration revDuration, String... pairs)

Create a rolling product for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingProduct(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling product for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingStd(long revTicks, long fwdTicks, String... pairs)

Create a rolling sample standard deviation for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingStd(long revTicks, String... pairs)

Create a rolling sample standard deviation for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingStd(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingStd(String timestampCol, long revTime, String... pairs)

Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingStd(String timestampCol, Duration revDuration, String... pairs)

Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingStd(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingSum(long revTicks, long fwdTicks, String... pairs)

Create a rolling sum for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingSum(long revTicks, String... pairs)

Create a rolling sum for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingSum(String timestampCol, long revTime, long fwdTime, String... pairs)

Create a rolling sum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingSum(String timestampCol, long revTime, String... pairs)

Create a rolling sum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingSum(String timestampCol, Duration revDuration, String... pairs)

Create a rolling sum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingSum(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)

Create a rolling sum for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingWAvg(long revTicks, long fwdTicks, String weightCol, String... pairs)

Create a rolling weighted average for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingWAvg(long revTicks, String weightCol, String... pairs)

Create a rolling weighted average for the supplied column name pairs, using ticks as the windowing unit.

static UpdateByOperation

RollingWAvg(String timestampCol, long revTime, long fwdTime, String weightCol, String... pairs)

Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingWAvg(String timestampCol, long revTime, String weightCol, String... pairs)

Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingWAvg(String timestampCol, Duration revDuration, String weightCol, String... pairs)

Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit.

static UpdateByOperation

RollingWAvg(String timestampCol, Duration revDuration, Duration fwdDuration, String weightCol, String... pairs)

Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit.

<T> T

walk(UpdateByOperation.Visitor<T> visitor)

Method Details
- of
  
  static ColumnUpdateOperation of(UpdateBySpec spec, String... columns)
  
  Conjoin an UpdateBySpec with columns for it to be applied to so the engine can construct the proper operators.
  
  Parameters:
  
  spec - the UpdateBySpec that defines the operation to perform
  
  columns - the columns to apply the operation to.
  
  Returns:
  
  a ColumnUpdateOperation that will be used to construct operations for each column
- of
  
  static ColumnUpdateOperation of(UpdateBySpec spec, Pair... columns)
  
  Conjoin an UpdateBySpec with columns for it to be applied to so the engine can construct the proper operators.
  
  Parameters:
  
  spec - the UpdateBySpec that defines the operation to perform
  
  columns - the columns to apply the operation to.
  
  Returns:
  
  a ColumnUpdateOperation that will be used to construct operations for each column
- CumSum
  
  static UpdateByOperation CumSum(String... pairs)
  
  Create a cumulative sum for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- CumProd
  
  static UpdateByOperation CumProd(String... pairs)
  
  Create a cumulative product for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- CumMin
  
  static UpdateByOperation CumMin(String... pairs)
  
  Create a cumulative minimum for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- CumMax
  
  static UpdateByOperation CumMax(String... pairs)
  
  Create a cumulative maximum for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- CumCountWhere
  
  static UpdateByOperation CumCountWhere(String resultColumn, String... filters)
  
  Create a cumulative count where that counts the number of rows that pass the provided filters.
  
  Parameters:
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- CumCountWhere
  
  static UpdateByOperation CumCountWhere(String resultColumn, Filter filter)
  
  Create a cumulative count where that counts the number of rows that pass the provided filter.
  
  Parameters:
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- Fill
  
  static UpdateByOperation Fill(String... pairs)
  
  Create a forward fill for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ema
  
  static UpdateByOperation Ema(double tickDecay, String... pairs)
  Create an exponential moving average for the supplied column name pairs, using ticks as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-1 / tickDecay) ema_next = a * ema_last + (1 - a) * value
  Parameters:
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ema
  
  static UpdateByOperation Ema(OperationControl control, double tickDecay, String... pairs)
  Create an exponential moving average for the supplied column name pairs, using ticks as the decay unit.
  The formula used is
  
  a = e^(-1 / tickDecay) ema_next = a * ema_last + (1 - a) * value
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ema
  
  static UpdateByOperation Ema(String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving average for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / timeDecay) ema_next = a * ema_last + (1 - a) * value
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ema
  
  static UpdateByOperation Ema(OperationControl control, String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving average for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / timeDecay) ema_next = a * ema_last + (1 - a) * value
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ema
  
  static UpdateByOperation Ema(String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving average for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / durationDecay) ema_next = a * ema_last + (1 - a) * value
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ema
  
  static UpdateByOperation Ema(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving average for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / durationDecay) ema_next = a * ema_last + (1 - a) * value
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ems
  
  static UpdateByOperation Ems(double tickDecay, String... pairs)
  Create an exponential moving sum for the supplied column name pairs, using ticks as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-1 / tickDecay) ems_next = a * ems_last + value
  Parameters:
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ems
  
  static UpdateByOperation Ems(OperationControl control, double tickDecay, String... pairs)
  Create an exponential moving sum for the supplied column name pairs, using ticks as the decay unit.
  The formula used is
  
  a = e^(-1 / tickDecay) ems_next = a * ems_last + value
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ems
  
  static UpdateByOperation Ems(String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving sum for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / timeDecay) ems_next = a * ems_last + value
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ems
  
  static UpdateByOperation Ems(OperationControl control, String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving sum for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / timeDecay) ems_next = a * ems_last + value
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ems
  
  static UpdateByOperation Ems(String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving sum for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / durationDecay) ems_next = a * ems_last + value
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Ems
  
  static UpdateByOperation Ems(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving sum for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / durationDecay) ems_next = a * ems_last + value
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMin
  
  static UpdateByOperation EmMin(double tickDecay, String... pairs)
  Create an exponential moving minimum for the supplied column name pairs, using ticks as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-1 / tickDecay) em_val_next = min(a * em_val_last, value)
  Parameters:
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMin
  
  static UpdateByOperation EmMin(OperationControl control, double tickDecay, String... pairs)
  Create an exponential moving minimum for the supplied column name pairs, using ticks as the decay unit.
  The formula used is
  
  a = e^(-1 / tickDecay) em_val_next = min(a * em_val_last, value)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMin
  
  static UpdateByOperation EmMin(String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / timeDecay) em_val_next = min(a * em_val_last, value)
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMin
  
  static UpdateByOperation EmMin(OperationControl control, String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / timeDecay) em_val_next = min(a * em_val_last, value)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMin
  
  static UpdateByOperation EmMin(String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / durationDecay) em_val_next = min(a * em_val_last, value)
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMin
  
  static UpdateByOperation EmMin(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving minimum for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / durationDecay) em_val_next = min(a * em_val_last, value)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMax
  
  static UpdateByOperation EmMax(double tickDecay, String... pairs)
  Create an exponential moving maximum for the supplied column name pairs, using ticks as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-1 / tickDecay) em_val_next = max(a * em_val_last, value)
  Parameters:
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMax
  
  static UpdateByOperation EmMax(OperationControl control, double tickDecay, String... pairs)
  Create an exponential moving maximum for the supplied column name pairs, using ticks as the decay unit.
  The formula used is
  
  a = e^(-1 / tickDecay) em_val_next = max(a * em_val_last, value)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMax
  
  static UpdateByOperation EmMax(String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / timeDecay) em_val_next = max(a * em_val_last, value)
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMax
  
  static UpdateByOperation EmMax(OperationControl control, String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / timeDecay) em_val_next = max(a * em_val_last, value)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMax
  
  static UpdateByOperation EmMax(String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / durationDecay) em_val_next = max(a * em_val_last, value)
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmMax
  
  static UpdateByOperation EmMax(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving maximum for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / durationDecay) em_val_next = max(a * em_val_last, value)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmStd
  
  static UpdateByOperation EmStd(double tickDecay, String... pairs)
  Create an exponential moving standard deviation for the supplied column name pairs, using ticks as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-1 / tickDecay) variance = a * (prevVariance + (1 - a) * (x - prevEma)^2) ema = a * prevEma + x std = sqrt(variance)
  Parameters:
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmStd
  
  static UpdateByOperation EmStd(OperationControl control, double tickDecay, String... pairs)
  Create an exponential moving standard deviation for the supplied column name pairs, using ticks as the decay unit.
  The formula used is
  
  a = e^(-1 / tickDecay) variance = a * (prevVariance + (1 - a) * (x - prevEma)^2) ema = a * prevEma + x std = sqrt(variance)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  tickDecay - the decay rate in ticks
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmStd
  
  static UpdateByOperation EmStd(String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / timeDecay) variance = a * (prevVariance + (1 - a) * (x - prevEma)^2) ema = a * prevEma + x std = sqrt(variance)
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmStd
  
  static UpdateByOperation EmStd(OperationControl control, String timestampColumn, long timeDecay, String... pairs)
  Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / timeDecay) variance = a * (prevVariance + (1 - a) * (x - prevEma)^2) ema = a * prevEma + x std = sqrt(variance)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  timeDecay - the decay rate in nanoseconds
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmStd
  
  static UpdateByOperation EmStd(String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit. Uses the default OperationControl settings.
  The formula used is
  
  a = e^(-dt / durationDecay) variance = a * (prevVariance + (1 - a) * (x - prevEma)^2) ema = a * prevEma + x std = sqrt(variance)
  Parameters:
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- EmStd
  
  static UpdateByOperation EmStd(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs)
  Create an exponential moving standard deviation for the supplied column name pairs, using time as the decay unit.
  The formula used is
  
  a = e^(-dt / durationDecay) variance = a * (prevVariance + (1 - a) * (x - prevEma)^2) ema = a * prevEma + x std = sqrt(variance)
  Parameters:
  
  control - a control object that defines how special cases should behave. See OperationControl for further details.
  
  timestampColumn - the column in the source table to use for timestamps
  
  durationDecay - the decay rate as duration
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Delta
  
  static UpdateByOperation Delta(String... pairs)
  
  Create a delta for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- Delta
  
  static UpdateByOperation Delta(DeltaControl control, String... pairs)
  
  Create a delta for the supplied column name pairs.
  
  Parameters:
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingSum
  
  static UpdateByOperation RollingSum(long revTicks, String... pairs)
  
  Create a rolling sum for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingSum
  
  static UpdateByOperation RollingSum(long revTicks, long fwdTicks, String... pairs)
  Create a rolling sum for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows.
  Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingSum
  
  static UpdateByOperation RollingSum(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling sum for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingSum
  
  static UpdateByOperation RollingSum(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling sum for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingSum
  
  static UpdateByOperation RollingSum(String timestampCol, long revTime, String... pairs)
  
  Create a rolling sum for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingSum
  
  static UpdateByOperation RollingSum(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling sum for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingGroup
  
  static UpdateByOperation RollingGroup(long prevTimeTicks, String... pairs)
  
  Create rolling groups for the supplied column name pairs, using ticks as the windowing unit. Uses the default OperationControl settings.
  
  Parameters:
  
  prevTimeTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingGroup
  
  static UpdateByOperation RollingGroup(long prevTimeTicks, long fwdTimeTicks, String... pairs)
  
  Create rolling groups for the supplied column name pairs, using ticks as the windowing unit. Uses the default OperationControl settings.
  
  Parameters:
  
  prevTimeTicks - the look-behind window size (in rows/ticks)
  
  fwdTimeTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingGroup
  
  static UpdateByOperation RollingGroup(String timestampCol, Duration prevWindowDuration, String... pairs)
  
  Create rolling groups for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings.
  
  Parameters:
  
  prevWindowDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingGroup
  
  static UpdateByOperation RollingGroup(String timestampCol, Duration prevWindowDuration, Duration fwdWindowDuration, String... pairs)
  
  Create rolling groups for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings.
  
  Parameters:
  
  prevWindowDuration - the look-behind window size (in Duration)
  
  fwdWindowDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingGroup
  
  static UpdateByOperation RollingGroup(String timestampCol, long prevWindowNanos, String... pairs)
  
  Create rolling groups for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings.
  
  Parameters:
  
  prevWindowNanos - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingGroup
  
  static UpdateByOperation RollingGroup(String timestampCol, long prevWindowNanos, long fwdWindowNanos, String... pairs)
  
  Create rolling groups for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings.
  
  Parameters:
  
  prevWindowNanos - the look-behind window size (in nanoseconds)
  
  fwdWindowNanos - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingAvg
  
  static UpdateByOperation RollingAvg(long revTicks, String... pairs)
  
  Create a rolling average for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingAvg
  
  static UpdateByOperation RollingAvg(long revTicks, long fwdTicks, String... pairs)
  Create a rolling average for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows. Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingAvg
  
  static UpdateByOperation RollingAvg(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling average for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingAvg
  
  static UpdateByOperation RollingAvg(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling average for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingAvg
  
  static UpdateByOperation RollingAvg(String timestampCol, long revTime, String... pairs)
  
  Create a rolling average for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingAvg
  
  static UpdateByOperation RollingAvg(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling average for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMin
  
  static UpdateByOperation RollingMin(long revTicks, String... pairs)
  
  Create a rolling minimum for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMin
  
  static UpdateByOperation RollingMin(long revTicks, long fwdTicks, String... pairs)
  Create a rolling minimum for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows.
  Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMin
  
  static UpdateByOperation RollingMin(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling minimum for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMin
  
  static UpdateByOperation RollingMin(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling minimum for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMin
  
  static UpdateByOperation RollingMin(String timestampCol, long revTime, String... pairs)
  
  Create a rolling minimum for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMin
  
  static UpdateByOperation RollingMin(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling minimum for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMax
  
  static UpdateByOperation RollingMax(long revTicks, String... pairs)
  
  Create a rolling maximum for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMax
  
  static UpdateByOperation RollingMax(long revTicks, long fwdTicks, String... pairs)
  Create a rolling maximum for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows. Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMax
  
  static UpdateByOperation RollingMax(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling maximum for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMax
  
  static UpdateByOperation RollingMax(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling maximum for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMax
  
  static UpdateByOperation RollingMax(String timestampCol, long revTime, String... pairs)
  
  Create a rolling maximum for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingMax
  
  static UpdateByOperation RollingMax(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling maximum for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingProduct
  
  static UpdateByOperation RollingProduct(long revTicks, long fwdTicks, String... pairs)
  Create a rolling product for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows. Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingProduct
  
  static UpdateByOperation RollingProduct(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling product for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingProduct
  
  static UpdateByOperation RollingProduct(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling product for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingProduct
  
  static UpdateByOperation RollingProduct(String timestampCol, long revTime, String... pairs)
  
  Create a rolling product for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingProduct
  
  static UpdateByOperation RollingProduct(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling product for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCount
  
  static UpdateByOperation RollingCount(long revTicks, String... pairs)
  
  Create a rolling count for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCount
  
  static UpdateByOperation RollingCount(long revTicks, long fwdTicks, String... pairs)
  Create a rolling count for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows.
  Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCount
  
  static UpdateByOperation RollingCount(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling count for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCount
  
  static UpdateByOperation RollingCount(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling count for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCount
  
  static UpdateByOperation RollingCount(String timestampCol, long revTime, String... pairs)
  
  Create a rolling count for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCount
  
  static UpdateByOperation RollingCount(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling count for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(long revTicks, String resultColumn, String... filters)
  
  Create a rolling count where that will count values that pass the provided filters, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(long revTicks, long fwdTicks, String resultColumn, String... filters)
  
  Create a rolling count where that will count values that pass the provided filters, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(long revTicks, String resultColumn, Filter filter)
  
  Create a rolling count where that will count values that pass the provided filter, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(long revTicks, long fwdTicks, String resultColumn, Filter filter)
  
  Create a rolling count where that will count values that pass the provided filter, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, Duration revDuration, String resultColumn, String... filters)
  Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, Duration revDuration, Duration fwdDuration, String resultColumn, String... filters)
  Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, long revTime, String resultColumn, String... filters)
  
  Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, long revTime, long fwdTime, String resultColumn, String... filters)
  
  Create a rolling count where that will count values that pass the provided filters, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  resultColumn - The output column name in the result table
  
  filters - The filters to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, Duration revDuration, String resultColumn, Filter filter)
  Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, Duration revDuration, Duration fwdDuration, String resultColumn, Filter filter)
  Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, long revTime, String resultColumn, Filter filter)
  
  Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingCountWhere
  
  static UpdateByOperation RollingCountWhere(String timestampCol, long revTime, long fwdTime, String resultColumn, Filter filter)
  
  Create a rolling count where that will count values that pass the provided filter, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  resultColumn - The output column name in the result table
  
  filter - The filter to apply to the input columns
  
  Returns:
  
  The aggregation
- RollingStd
  
  static UpdateByOperation RollingStd(long revTicks, String... pairs)
  
  Create a rolling sample standard deviation for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows. Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingStd
  
  static UpdateByOperation RollingStd(long revTicks, long fwdTicks, String... pairs)
  Create a rolling sample standard deviation for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows. Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  
  Sample standard deviation is computed using Bessel's correction, which ensures that the sample variance will be an unbiased estimator of population variance.
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingStd
  
  static UpdateByOperation RollingStd(String timestampCol, Duration revDuration, String... pairs)
  Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  Sample standard deviation is computed using Bessel's correction, which ensures that the sample variance will be an unbiased estimator of population variance.
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingStd
  
  static UpdateByOperation RollingStd(String timestampCol, Duration revDuration, Duration fwdDuration, String... pairs)
  Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  
  Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingStd
  
  static UpdateByOperation RollingStd(String timestampCol, long revTime, String... pairs)
  
  Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingStd
  
  static UpdateByOperation RollingStd(String timestampCol, long revTime, long fwdTime, String... pairs)
  
  Create a rolling sample standard deviation for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows. Sample standard deviation is computed using Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction), which ensures that the sample variance will be an unbiased estimator of population variance.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingWAvg
  
  static UpdateByOperation RollingWAvg(long revTicks, String weightCol, String... pairs)
  
  Create a rolling weighted average for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingWAvg
  
  static UpdateByOperation RollingWAvg(long revTicks, long fwdTicks, String weightCol, String... pairs)
  Create a rolling weighted average for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows.
  Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingWAvg
  
  static UpdateByOperation RollingWAvg(String timestampCol, Duration revDuration, String weightCol, String... pairs)
  Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingWAvg
  
  static UpdateByOperation RollingWAvg(String timestampCol, Duration revDuration, Duration fwdDuration, String weightCol, String... pairs)
  Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingWAvg
  
  static UpdateByOperation RollingWAvg(String timestampCol, long revTime, String weightCol, String... pairs)
  
  Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingWAvg
  
  static UpdateByOperation RollingWAvg(String timestampCol, long revTime, long fwdTime, String weightCol, String... pairs)
  
  Create a rolling weighted average for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(long revTicks, String formula, String paramToken, String... pairs)
  
  Create a rolling formula for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  paramToken - the parameter name for the input column's vector within the formula. If formula is max(each), then each is the formula_param.
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(long revTicks, long fwdTicks, String formula, String paramToken, String... pairs)
  Create a rolling formula for the supplied column name pairs, using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows.
  Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  paramToken - the parameter name for the input column's vector within the formula. If formula is max(each), then each is the formula_param.
  
  pairs - the input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, Duration revDuration, String formula, String paramToken, String... pairs)
  Create a rolling formula for the supplied column name pairs, using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  paramToken - the parameter token for the input column's vector within the formula. If formula is max(each), then each is the formula_param.
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, Duration revDuration, Duration fwdDuration, String formula, String paramToken, String... pairs)
  Create a rolling formula for the supplied column name pairs, using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  paramToken - the parameter token for the input column's vector within the formula. If formula is max(each), then each is the formula_param.
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, long revTime, String formula, String paramToken, String... pairs)
  
  Create a rolling formula for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  paramToken - the parameter name for the input column's vector within the formula. If formula is max(each), then each is the formula_param.
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, long revTime, long fwdTime, String formula, String paramToken, String... pairs)
  
  Create a rolling formula for the supplied column name pairs, using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  paramToken - the parameter name for the input column's vector within the formula. If formula is max(each), then each is the formula_param.
  
  pairs - The input/output column name pairs
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(long revTicks, String formula)
  Create a rolling formula using ticks as the windowing unit. Ticks are row counts and you may specify the previous window in number of rows to include. The current row is considered to belong to the reverse window, so calling this with revTicks = 1 will simply return the current row. Specifying revTicks = 10 will include the previous 9 rows to this one and this row for a total of 10 rows.
  The provided formula should specify the output column name. Some examples of formula are:
  sum_AB = sum(col_A) + sum(col_B) max_AB = max(col_A) + max(col_B) values = col_A + col_B
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  formula - the user-defined formula to apply to each group. This formula includes the output column name and can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(long revTicks, long fwdTicks, String formula)
  Create a rolling formula using ticks as the windowing unit. Ticks are row counts and you may specify the reverse and forward window in number of rows to include. The current row is considered to belong to the reverse window but not the forward window. Also, negative values are allowed and can be used to generate completely forward or completely reverse windows.
  Here are some examples of window values:
  
  revTicks = 1, fwdTicks = 0 - contains only the current row
  
  revTicks = 10, fwdTicks = 0 - contains 9 previous rows and the current row
  
  revTicks = 0, fwdTicks = 10 - contains the following 10 rows, excludes the current row
  
  revTicks = 10, fwdTicks = 10 - contains the previous 9 rows, the current row and the 10 rows following
  
  revTicks = 10, fwdTicks = -5 - contains 5 rows, beginning at 9 rows before, ending at 5 rows before the current row (inclusive)
  
  revTicks = 11, fwdTicks = -1 - contains 10 rows, beginning at 10 rows before, ending at 1 row before the current row (inclusive)
  
  revTicks = -5, fwdTicks = 10 - contains 5 rows, beginning 5 rows following, ending at 10 rows following the current row (inclusive)
  
  The provided formula should specify the output column name. Some examples of formula are:
  sum_AB = sum(col_A) + sum(col_B) max_AB = max(col_A) + max(col_B) values = col_A + col_B
  Parameters:
  
  revTicks - the look-behind window size (in rows/ticks)
  
  fwdTicks - the look-ahead window size (in rows/ticks)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, Duration revDuration, String formula)
  Create a rolling formula using time as the windowing unit. This function accepts duration as the reverse window parameter. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  The provided formula should specify the output column name. Some examples of formula are:
  sum_AB = sum(col_A) + sum(col_B) max_AB = max(col_A) + max(col_B) values = col_A + col_B
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, Duration revDuration, Duration fwdDuration, String formula)
  Create a rolling formula using time as the windowing unit. This function accepts durations as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  Here are some examples of window values:
  
  revDuration = 0m, fwdDuration = 0m - contains rows that exactly match the current row timestamp
  
  revDuration = 10m, fwdDuration = 0m - contains rows from 10m earlier through the current row timestamp (inclusive)
  
  revDuration = 0m, fwdDuration = 10m - contains rows from the current row through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = 10m - contains rows from 10m earlier through 10m following the current row timestamp (inclusive)
  
  revDuration = 10m, fwdDuration = -5m - contains rows from 10m earlier through 5m before the current row timestamp (inclusive), this is a purely backwards looking window
  
  revDuration = -5m, fwdDuration = 10m - contains rows from 5m following through 10m following the current row timestamp (inclusive), this is a purely forwards looking window
  
  The provided formula should specify the output column name. Some examples of formula are:
  sum_AB = sum(col_A) + sum(col_B) max_AB = max(col_A) + max(col_B) values = col_A + col_B
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revDuration - the look-behind window size (in Duration)
  
  fwdDuration - the look-ahead window size (in Duration)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, long revTime, String formula)
  Create a rolling formula using time as the windowing unit. This function accepts nanoseconds as the reverse window parameters. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  The provided formula should specify the output column name. Some examples of formula are:
  sum_AB = sum(col_A) + sum(col_B) max_AB = max(col_A) + max(col_B) values = col_A + col_B
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  Returns:
  
  The aggregation
- RollingFormula
  
  static UpdateByOperation RollingFormula(String timestampCol, long revTime, long fwdTime, String formula)
  Create a rolling formula using time as the windowing unit. This function accepts nanoseconds as the reverse and forward window parameters. Negative values are allowed and can be used to generate completely forward or completely reverse windows. A row containing a null in the timestamp column belongs to no window and will not have a value computed or be considered in the windows of other rows.
  The provided formula should specify the output column name. Some examples of formula are:
  sum_AB = sum(col_A) + sum(col_B) max_AB = max(col_A) + max(col_B) values = col_A + col_B
  Parameters:
  
  timestampCol - the name of the timestamp column
  
  revTime - the look-behind window size (in nanoseconds)
  
  fwdTime - the look-ahead window size (in nanoseconds)
  
  formula - the user-defined formula to apply to each group. This formula can contain any combination of the following:
  
  Built-in functions such as min, max, etc.
  
  Mathematical arithmetic such as *, +, /, etc.
  
  User-defined functions
  
  Returns:
  
  The aggregation
- walk
  
  <T> T walk(UpdateByOperation.Visitor<T> visitor)

Interface UpdateByOperation

Nested Class Summary

Method Summary

Method Details

of

of

CumSum

CumProd

CumMin

CumMax

CumCountWhere

CumCountWhere

Fill

Ema

Ema

Ema

Ema

Ema

Ema

Ems

Ems

Ems

Ems

Ems

Ems

EmMin

EmMin

EmMin

EmMin

EmMin

EmMin

EmMax

EmMax

EmMax

EmMax

EmMax

EmMax

EmStd

EmStd

EmStd

EmStd

EmStd

EmStd

Delta

Delta

RollingSum

RollingSum

RollingSum

RollingSum

RollingSum

RollingSum

RollingGroup

RollingGroup

RollingGroup

RollingGroup

RollingGroup

RollingGroup

RollingAvg

RollingAvg

RollingAvg

RollingAvg

RollingAvg

RollingAvg

RollingMin

RollingMin

RollingMin

RollingMin

RollingMin

RollingMin

RollingMax

RollingMax

RollingMax

RollingMax

RollingMax

RollingMax

RollingProduct

RollingProduct

RollingProduct

RollingProduct

RollingProduct