Interface UpdateByOperation
 All Known Implementing Classes:
ColumnUpdateOperation

Nested Class Summary

Method Summary
Modifier and TypeMethodDescriptionstatic UpdateByOperation
Create acumulative maximum
for the supplied column name pairs.static UpdateByOperation
Create acumulative minimum
for the supplied column name pairs.static UpdateByOperation
Create acumulative product
for the supplied column name pairs.static UpdateByOperation
Create acumulative sum
for the supplied column name pairs.static UpdateByOperation
Delta
(DeltaControl control, String... pairs) Create adelta
for the supplied column name pairs.static UpdateByOperation
Create adelta
for the supplied column name pairs.static UpdateByOperation
Create anexponential moving average
for the supplied column name pairs, using ticks as the decay unit.static UpdateByOperation
Ema
(OperationControl control, double tickDecay, String... pairs) Create anexponential 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 anexponential 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 anexponential moving average
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving average
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving average
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving maximum
for the supplied column name pairs, using ticks as the decay unit.static UpdateByOperation
EmMax
(OperationControl control, double tickDecay, String... pairs) Create anexponential 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 anexponential 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 anexponential moving maximum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving maximum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving maximum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving minimum
for the supplied column name pairs, using ticks as the decay unit.static UpdateByOperation
EmMin
(OperationControl control, double tickDecay, String... pairs) Create anexponential 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 anexponential 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 anexponential moving minimum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving minimum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving minimum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving sum
for the supplied column name pairs, using ticks as the decay unit.static UpdateByOperation
Ems
(OperationControl control, double tickDecay, String... pairs) Create anexponential 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 anexponential 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 anexponential moving sum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving sum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving sum
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential 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 anexponential 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 anexponential 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 anexponential moving standard deviation
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving standard deviation
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create anexponential moving standard deviation
for the supplied column name pairs, using time as the decay unit.static UpdateByOperation
Create aforward fill
for the supplied column name pairs.static ColumnUpdateOperation
of
(UpdateBySpec spec, Pair... columns) Conjoin anUpdateBySpec
with columns for it to be applied to so the engine can construct the proper operators.static ColumnUpdateOperation
of
(UpdateBySpec spec, String... columns) Conjoin anUpdateBySpec
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 arolling average
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingAvg
(long revTicks, String... pairs) Create arolling 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 arolling average
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingAvg
(String timestampCol, long revTime, String... pairs) Create arolling average
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingAvg
(String timestampCol, Duration revDuration, String... pairs) Create arolling 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 arolling average
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingCount
(long revTicks, long fwdTicks, String... pairs) Create arolling count
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingCount
(long revTicks, String... pairs) Create arolling 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 arolling count
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingCount
(String timestampCol, long revTime, String... pairs) Create arolling count
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingCount
(String timestampCol, Duration revDuration, String... pairs) Create arolling 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 arolling count
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingFormula
(long revTicks, long fwdTicks, String formula, String paramToken, String... pairs) Create arolling forumla
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingFormula
(long revTicks, String formula, String paramToken, String... pairs) Create arolling forumla
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingFormula
(String timestampCol, long revTime, long fwdTime, String formula, String paramToken, String... pairs) Create arolling forumla
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingFormula
(String timestampCol, long revTime, String formula, String paramToken, String... pairs) Create arolling forumla
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingFormula
(String timestampCol, Duration revDuration, String formula, String paramToken, String... pairs) Create arolling forumla
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingFormula
(String timestampCol, Duration revDuration, Duration fwdDuration, String formula, String paramToken, String... pairs) Create arolling forumla
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingGroup
(long prevTimeTicks, long fwdTimeTicks, String... pairs) Createrolling groups
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingGroup
(long prevTimeTicks, String... pairs) Createrolling groups
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingGroup
(String timestampCol, long prevWindowNanos, long fwdWindowNanos, String... pairs) Createrolling groups
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingGroup
(String timestampCol, long prevWindowNanos, String... pairs) Createrolling groups
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingGroup
(String timestampCol, Duration prevWindowDuration, String... pairs) Createrolling groups
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingGroup
(String timestampCol, Duration prevWindowDuration, Duration fwdWindowDuration, String... pairs) Createrolling groups
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingMax
(long revTicks, long fwdTicks, String... pairs) Create arolling maximum
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingMax
(long revTicks, String... pairs) Create arolling 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 arolling maximum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingMax
(String timestampCol, long revTime, String... pairs) Create arolling maximum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingMax
(String timestampCol, Duration revDuration, String... pairs) Create arolling 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 arolling maximum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingMin
(long revTicks, long fwdTicks, String... pairs) Create arolling minimum
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingMin
(long revTicks, String... pairs) Create arolling 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 arolling minimum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingMin
(String timestampCol, long revTime, String... pairs) Create arolling minimum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingMin
(String timestampCol, Duration revDuration, String... pairs) Create arolling 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 arolling minimum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingProduct
(long revTicks, long fwdTicks, String... pairs) Create arolling 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 arolling product
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingProduct
(String timestampCol, long revTime, String... pairs) Create arolling product
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingProduct
(String timestampCol, Duration revDuration, String... pairs) Create arolling 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 arolling product
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingStd
(long revTicks, long fwdTicks, String... pairs) Create arolling sample standard deviation
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingStd
(long revTicks, String... pairs) Create arolling 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 arolling 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 arolling 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 arolling 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 arolling 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 arolling sum
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingSum
(long revTicks, String... pairs) Create arolling 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 arolling sum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingSum
(String timestampCol, long revTime, String... pairs) Create arolling sum
for the supplied column name pairs, using time as the windowing unit.static UpdateByOperation
RollingSum
(String timestampCol, Duration revDuration, String... pairs) Create arolling 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 arolling 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 arolling weighted average
for the supplied column name pairs, using ticks as the windowing unit.static UpdateByOperation
RollingWAvg
(long revTicks, String weightCol, String... pairs) Create arolling 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 arolling 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 arolling 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 arolling 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 arolling weighted average
for the supplied column name pairs, using time as the windowing unit.<T> T
walk
(UpdateByOperation.Visitor<T> visitor)

Method Details

of
Conjoin anUpdateBySpec
with columns for it to be applied to so the engine can construct the proper operators. Parameters:
spec
 theUpdateBySpec
that defines the operation to performcolumns
 the columns to apply the operation to. Returns:
 a
ColumnUpdateOperation
that will be used to construct operations for each column

of
Conjoin anUpdateBySpec
with columns for it to be applied to so the engine can construct the proper operators. Parameters:
spec
 theUpdateBySpec
that defines the operation to performcolumns
 the columns to apply the operation to. Returns:
 a
ColumnUpdateOperation
that will be used to construct operations for each column

CumSum
Create acumulative sum
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

CumProd
Create acumulative product
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

CumMin
Create acumulative minimum
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

CumMax
Create acumulative maximum
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

Fill
Create aforward fill
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

Ema
Create anexponential 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 tickspairs
 The input/output column name pairs Returns:
 The aggregation

Ema
Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.tickDecay
 the decay rate in tickspairs
 The input/output column name pairs Returns:
 The aggregation

Ema
Create anexponential 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 timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

Ema
static UpdateByOperation Ema(OperationControl control, String timestampColumn, long timeDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

Ema
Create anexponential 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 timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

Ema
static UpdateByOperation Ema(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

Ems
Create anexponential 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 tickspairs
 The input/output column name pairs Returns:
 The aggregation

Ems
Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.tickDecay
 the decay rate in tickspairs
 The input/output column name pairs Returns:
 The aggregation

Ems
Create anexponential 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 timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

Ems
static UpdateByOperation Ems(OperationControl control, String timestampColumn, long timeDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

Ems
Create anexponential 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 timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

Ems
static UpdateByOperation Ems(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

EmMin
Create anexponential 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 tickspairs
 The input/output column name pairs Returns:
 The aggregation

EmMin
Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.tickDecay
 the decay rate in tickspairs
 The input/output column name pairs Returns:
 The aggregation

EmMin
Create anexponential 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 timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

EmMin
static UpdateByOperation EmMin(OperationControl control, String timestampColumn, long timeDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

EmMin
Create anexponential 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 timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

EmMin
static UpdateByOperation EmMin(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

EmMax
Create anexponential 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 tickspairs
 The input/output column name pairs Returns:
 The aggregation

EmMax
Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.tickDecay
 the decay rate in tickspairs
 The input/output column name pairs Returns:
 The aggregation

EmMax
Create anexponential 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 timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

EmMax
static UpdateByOperation EmMax(OperationControl control, String timestampColumn, long timeDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

EmMax
Create anexponential 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 timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

EmMax
static UpdateByOperation EmMax(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

EmStd
Create anexponential 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 tickspairs
 The input/output column name pairs Returns:
 The aggregation

EmStd
Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.tickDecay
 the decay rate in tickspairs
 The input/output column name pairs Returns:
 The aggregation

EmStd
Create anexponential 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 timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

EmStd
static UpdateByOperation EmStd(OperationControl control, String timestampColumn, long timeDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampstimeDecay
 the decay rate in nanosecondspairs
 The input/output column name pairs Returns:
 The aggregation

EmStd
Create anexponential 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 timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

EmStd
static UpdateByOperation EmStd(OperationControl control, String timestampColumn, Duration durationDecay, String... pairs) Create anexponential 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
 acontrol
object that defines how special cases should behave. SeeOperationControl
for further details.timestampColumn
 the column in the source table to use for timestampsdurationDecay
 the decay rate asduration
pairs
 The input/output column name pairs Returns:
 The aggregation

Delta
Create adelta
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

Delta
Create adelta
for the supplied column name pairs. Parameters:
pairs
 The input/output column name pairs Returns:
 The aggregation

RollingSum
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingSum
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingSum
Create arolling sum
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling sum
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingSum
Create arolling sum
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling sum
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingGroup
Createrolling groups
for the supplied column name pairs, using ticks as the windowing unit. Uses the default OperationControl settings. Parameters:
prevTimeTicks
 the lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingGroup
Createrolling groups
for the supplied column name pairs, using ticks as the windowing unit. Uses the default OperationControl settings. Parameters:
prevTimeTicks
 the lookbehind window size (in rows/ticks)fwdTimeTicks
 the lookahead 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) Createrolling groups
for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings. Parameters:
prevWindowDuration
 the lookbehind 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) Createrolling groups
for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings. Parameters:
prevWindowDuration
 the lookbehind window size (in Duration)fwdWindowDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingGroup
Createrolling groups
for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings. Parameters:
prevWindowNanos
 the lookbehind 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) Createrolling groups
for the supplied column name pairs, using time as the windowing unit. Uses the default OperationControl settings. Parameters:
prevWindowNanos
 the lookbehind window size (in nanoseconds)fwdWindowNanos
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingAvg
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingAvg
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingAvg
Create arolling average
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling average
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingAvg
Create arolling average
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling average
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMin
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMin
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMin
Create arolling minimum
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling minimum
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMin
Create arolling minimum
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling minimum
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMax
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMax
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMax
Create arolling maximum
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling maximum
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingMax
Create arolling maximum
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling maximum
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingProduct
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingProduct
Create arolling product
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling product
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingProduct
Create arolling product
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling product
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingCount
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingCount
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingCount
Create arolling count
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling count
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingCount
Create arolling count
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling count
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingStd
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 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 lookbehind window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingStd
Create arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingStd
Create arolling sample standard deviation
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling sample standard deviation
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingStd
Create arolling sample standard deviation
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling sample standard deviation
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)pairs
 The input/output column name pairs Returns:
 The aggregation

RollingWAvg
Create arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind 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 arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead 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 arolling weighted average
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind 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 arolling weighted average
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead 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 arolling weighted average
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind 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 arolling weighted average
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead 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 arolling 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 withrevTicks = 1
will simply return the current row. SpecifyingrevTicks = 10
will include the previous 9 rows to this one and this row for a total of 10 rows. Parameters:
revTicks
 the lookbehind window size (in rows/ticks)formula
 the userdefined formula to apply to each group. This formula can contain any combination of the following: Builtin functions such as min, max, etc.
 Mathematical arithmetic such as *, +, /, etc.
 Userdefined 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 arolling 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 rowrevTicks = 10, fwdTicks = 0
 contains 9 previous rows and the current rowrevTicks = 0, fwdTicks = 10
 contains the following 10 rows, excludes the current rowrevTicks = 10, fwdTicks = 10
 contains the previous 9 rows, the current row and the 10 rows followingrevTicks = 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 lookbehind window size (in rows/ticks)fwdTicks
 the lookahead window size (in rows/ticks)formula
 the userdefined formula to apply to each group. This formula can contain any combination of the following: Builtin functions such as min, max, etc.
 Mathematical arithmetic such as *, +, /, etc.
 Userdefined 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 arolling forumla
for the supplied column name pairs, using time as the windowing unit. This function acceptsduration
as the reverse window parameter. A row containing anull
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 timestamprevDuration = 10m
 contains rows from 10m earlier through the current row timestamp (inclusive)
 Parameters:
timestampCol
 the name of the timestamp columnrevDuration
 the lookbehind window size (in Duration)formula
 the userdefinedformula
to apply to each group. This formula can contain any combination of the following: Builtin functions such as min, max, etc.
 Mathematical arithmetic such as *, +, /, etc.
 Userdefined functions
paramToken
 theparameter 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 arolling forumla
for the supplied column name pairs, using time as the windowing unit. This function acceptsdurations
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 anull
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 timestamprevDuration = 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 windowrevDuration = 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 columnrevDuration
 the lookbehind window size (in Duration)fwdDuration
 the lookahead window size (in Duration)formula
 the userdefinedformula
to apply to each group. This formula can contain any combination of the following: Builtin functions such as min, max, etc.
 Mathematical arithmetic such as *, +, /, etc.
 Userdefined functions
paramToken
 theparameter 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 arolling forumla
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
as the reverse window parameters. A row containing anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)formula
 the userdefined formula to apply to each group. This formula can contain any combination of the following: Builtin functions such as min, max, etc.
 Mathematical arithmetic such as *, +, /, etc.
 Userdefined 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 arolling forumla
for the supplied column name pairs, using time as the windowing unit. This function acceptsnanoseconds
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 anull
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 columnrevTime
 the lookbehind window size (in nanoseconds)fwdTime
 the lookahead window size (in nanoseconds)formula
 the userdefined formula to apply to each group. This formula can contain any combination of the following: Builtin functions such as min, max, etc.
 Mathematical arithmetic such as *, +, /, etc.
 Userdefined 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
