Package io.deephaven.engine.table.impl.select

Class BaseIncrementalReleaseFilter

java.lang.Object
io.deephaven.util.referencecounting.ReferenceCounted
io.deephaven.engine.liveness.ReferenceCountedLivenessReferent
io.deephaven.engine.liveness.ReferenceCountedLivenessNode
io.deephaven.engine.liveness.LivenessArtifact
io.deephaven.engine.table.impl.select.WhereFilterLivenessArtifactImpl
io.deephaven.engine.table.impl.select.BaseIncrementalReleaseFilter
All Implemented Interfaces:
ConcurrencyControl<Filter>, Expression, Filter, LogOutputAppendable, LivenessManager, LivenessNode, LivenessReferent, WhereFilter, NotificationQueue.Dependency, Serializable, Runnable
Direct Known Subclasses:
AutoTuningIncrementalReleaseFilter, IncrementalReleaseFilter
public abstract class BaseIncrementalReleaseFilter extends WhereFilterLivenessArtifactImpl implements Runnable, NotificationQueue.Dependency
Base class for filters that will release more rows of a table on each UGP cycle.

The use case is for benchmarks that want to replay a table in order to better understand incremental processing capacity.

See Also:

  • Method Details

    • getColumns

      public List<String> getColumns()
      Description copied from interface: WhereFilter
      Get the columns required by this select filter.

      This filter must already be initialized before calling this method.

      Specified by:
      getColumns in interface WhereFilter
      Returns:
      the columns used as input by this select filter.

    • getColumnArrays

      public List<String> getColumnArrays()
      Description copied from interface: WhereFilter
      Get the array columns required by this select filter.

      This filter must already be initialized before calling this method.

      Specified by:
      getColumnArrays in interface WhereFilter
      Returns:
      the columns used as array input by this select filter.

    • init

      public void init(@NotNull @NotNull TableDefinition tableDefinition)
      Description copied from interface: WhereFilter
      Initialize this filter given the table definition. If this filter has already been initialized, this should be a no-op, or optionally validate that the table definition is compatible with previous initialization.
      Specified by:
      init in interface WhereFilter
      Parameters:
      tableDefinition - the definition of the table that will be filtered

    • addToUpdateGraph

      protected void addToUpdateGraph()
      If this filter is not part of the update graph's sources, then add it.

    • removeFromUpdateGraph

      protected void removeFromUpdateGraph(@NotNull @NotNull Table table)
      If this filter is part of the update graph's sources, then remove it.

      Additionally, if the table we are filtering is not refreshing; we drop the reference to our recompute listener. The reference to the recompute listener is dropped, because there are never going to be any more rows to add to the result table.

    • filter

      @NotNull public @NotNull WritableRowSet filter(@NotNull @NotNull RowSet selection, @NotNull @NotNull RowSet fullSet, @NotNull @NotNull Table table, boolean usePrev)
      Description copied from interface: WhereFilter
      Filter selection to only matching rows.
      Specified by:
      filter in interface WhereFilter
      Parameters:
      selection - the indices that should be filtered. The selection must be a subset of fullSet, and may include rows that the engine determines need not be evaluated to produce the result. Implementations may not mutate or close selection.
      fullSet - the complete RowSet of the table to filter. The fullSet is used for calculating variables like "i" or "ii". Implementations may not mutate or close fullSet.
      table - the table to filter
      usePrev - true if previous values should be used. Implementing previous value filtering is optional, and a WhereFilter.PreviousFilteringNotSupported exception may be thrown. If a PreviousFiltering exception is thrown, then the caller must acquire the PeriodicUpdateGraph lock.
      Returns:
      The subset of selection accepted by this filter; ownership passes to the caller

    • waitForCompletion

      @ScriptApi public void waitForCompletion() throws InterruptedException
      Wait for all rows to be released.
      Throws:
      InterruptedException

    • waitForCompletion

      @ScriptApi public void waitForCompletion(long timeoutMillis) throws InterruptedException
      Wait for all rows to be released.
      Throws:
      InterruptedException

    • durationNanos

      @ScriptApi public long durationNanos()
      How many nanos between the first release event and the final release event?
      Returns:
      nano duration of this filter, or NULL_LONG if the filter is not completed

    • start

      public void start()
      Begin releasing rows during update propagation.

    • satisfied

      public boolean satisfied(long step)
      Description copied from interface: NotificationQueue.Dependency
      Is this ancestor satisfied? Note that this method must be safe to call on any thread.
      Specified by:
      satisfied in interface NotificationQueue.Dependency
      Parameters:
      step - The step for which we are testing satisfaction
      Returns:
      Whether the dependency is satisfied on step (and will not fire subsequent notifications)

    • getUpdateGraph

      public UpdateGraph getUpdateGraph()
      Specified by:
      getUpdateGraph in interface NotificationQueue.Dependency
      Returns:
      the update graph that this dependency is a part of

    • getInitialSize

      public long getInitialSize()

    • getExpectedSize

      public long getExpectedSize()
      Returns:
      the expected size of the table, or QueryConstants.NULL_LONG if the table is not known

    • isSimpleFilter

      public boolean isSimpleFilter()
      Specified by:
      isSimpleFilter in interface WhereFilter
      Returns:
      true if this is a filter that does not require any code execution, but rather is handled entirely within the database engine.

    • setRecomputeListener

      public void setRecomputeListener(WhereFilter.RecomputeListener listener)
      Description copied from interface: WhereFilter
      Set the WhereFilter.RecomputeListener that should be notified if results based on this WhereFilter must be recomputed.
      Specified by:
      setRecomputeListener in interface WhereFilter
      Parameters:
      listener - The WhereFilter.RecomputeListener to notify

    • copy

      public BaseIncrementalReleaseFilter copy()
      Description copied from interface: WhereFilter
      Create a copy of this WhereFilter.
      Specified by:
      copy in interface WhereFilter
      Returns:
      an independent copy of this WhereFilter.

    • isRefreshing

      public boolean isRefreshing()
      Description copied from interface: WhereFilter
      Is this filter refreshing?
      Specified by:
      isRefreshing in interface WhereFilter
      Returns:
      if this filter is refreshing

    • run

      public void run()
      Specified by:
      run in interface Runnable

    • destroy

      @OverridingMethodsMustInvokeSuper protected void destroy()
      Description copied from class: ReferenceCountedLivenessReferent
      Attempt to release (destructively when necessary) resources held by this object. This may render the object unusable for subsequent operations. Implementations should be sure to call super.destroy().

      This is intended to only ever be used as a side effect of decreasing the reference count to 0.

      Overrides:
      destroy in class ReferenceCountedLivenessReferent

    • permitParallelization

      public boolean permitParallelization()
      Description copied from interface: WhereFilter
      Returns true if this filter permits parallelism.

      No serial filters permit parallelization. A filter may not permit parallelism if the internal implementation does not support multiple WhereFilter.filter(RowSet, RowSet, Table, boolean) calls (e.g., some special filters that operate only on a rowset or have external state). ConditionFilters automatically determine whether they permit parallelization based on whether filters are stateless by default.

      Specified by:
      permitParallelization in interface WhereFilter
      Returns:
      if this filter can be applied in parallel