Interface UpdateByOperation

All Known Implementing Classes:
ColumnUpdateOperation

public interface UpdateByOperation
Defines an operation that can be applied to a table with Table#updateBy()}
  • 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
    • 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
    • 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 (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)
      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 (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)
      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 forumla 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 forumla 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 forumla 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 forumla 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 forumla 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 forumla 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
    • walk

      <T> T walk(UpdateByOperation.Visitor<T> visitor)