The watermark value for closing aggregates and evicting state. It is different from the late events filtering watermark (consider chained aggregators agg1 -> agg2: agg1 evicts state which will be effectively late against the eviction watermark but should not be late for agg2 input late record filtering watermark. Thus agg1 and agg2 use the current batch watermark for state eviction but the previous batch watermark for late record filtering.

The watermark value for filtering late events/records. This should be the previous batch state eviction watermark.

Aggregator used for the executors to pass new state store checkpoints' IDs to driver. For the general checkpoint ID workflow, see comments of class class StatefulOperatorStateInfo

Cleans up the resources used by the physical operator (if any). In general, all the resources should be cleaned up when the task finishes but operators like SortMergeJoinExec and LimitExec may want eager cleanup to free up tight resources (e.g., memory).

Set of stateful operator custom metrics. These are captured as part of the generic key-value map StateOperatorProgress.customMetrics. Stateful operators can extend this method to provide their own unique custom metrics.

Produces the result of the query as an RDD[InternalRow]

Overridden by concrete implementations of SparkPlan.

Produces the result of the query as a broadcast variable.

Overridden by concrete implementations of SparkPlan.

Produces the result of the query as an RDD[ColumnarBatch] if supportsColumnar returns true. By convention the executor that creates a ColumnarBatch is responsible for closing it when it is no longer needed. This allows input formats to be able to reuse batches if needed.

Produces the result of the writes as an RDD[WriterCommitMessage]

Overridden by concrete implementations of SparkPlan.

Overridden by concrete implementations of SparkPlan. It is guaranteed to run before any execute of SparkPlan. This is helpful if we want to set up some state before executing the query, e.g., BroadcastHashJoin uses it to broadcast asynchronously.

Returns the result of this query as an RDD[InternalRow] by delegating to doExecute after preparations.

Concrete implementations of SparkPlan should override doExecute.

Returns the result of this query as a broadcast variable by delegating to doExecuteBroadcast after preparations.

Concrete implementations of SparkPlan should override doExecuteBroadcast.

Runs this query returning the result as an array.

Runs this query returning the result as an array, using external Row format.

Returns the result of this query as an RDD[ColumnarBatch] by delegating to doColumnarExecute after preparations.

Concrete implementations of SparkPlan should override doColumnarExecute if supportsColumnar returns true.

Executes a query after preparing the query and adding query plan information to created RDDs for visualization.

Runs this query returning the last n rows as an array.

This is modeled after RDD.take but never runs any job locally on the driver.

Runs this query returning the first n rows as an array.

This is modeled after RDD.take but never runs any job locally on the driver.

Runs this query returning the result as an iterator of InternalRow.

Returns the result of writes as an RDD[WriterCommitMessage] variable by delegating to doExecuteWrite after preparations.

Concrete implementations of SparkPlan should override doExecuteWrite.

Get the progress made by this stateful operator after execution. This should be called in the driver after this SparkPlan has been executed and metrics have been updated.

Get aggregated checkpoint ID info for all shuffle partitions For the general checkpoint ID workflow, see comments of class class StatefulOperatorStateInfo

The keys that may have a watermark attribute.

Overridden make copy also propagates sqlContext to copied plan.

Metadata of this stateful operator and its states stores.

Specifies how data is partitioned across different nodes in the cluster. Note this method may fail if it is invoked before EnsureRequirements is applied since PartitioningCollection requires all its partitionings to have the same number of partitions.

Prepares this SparkPlan for execution. It's idempotent.

Finds scalar subquery expressions in this plan node and starts evaluating them.

Process data by applying the user defined function on a per partition basis.

Produce the output watermark for given input watermark (ms).

In most cases, this is same as the criteria of state eviction, as most stateful operators produce the output from two different kinds:

1. without buffering 2. with buffering (state)

The state eviction happens when event time exceeds a "certain threshold of timestamp", which denotes a lower bound of event time values for output (output watermark).

The default implementation provides the input watermark as it is. Most built-in operators will evict based on min input watermark and ensure it will be minimum of the event time value for the output so far (including output from eviction). Operators which behave differently (e.g. different criteria on eviction) must override this method.

Note that the default behavior wil advance the watermark aggressively to simplify the logic, but it does not break the semantic of output watermark, which is following:

An operator guarantees that it will not emit record with an event timestamp lower than its output watermark.

For example, for 5 minutes time window aggregation, the advancement of watermark can happen "before" the window has been evicted and produced as output. Say, suppose there's an window in state: [0, 5) and input watermark = 3. Although there is no output for this operator, this operator will produce an output watermark as 3. It's still respecting the guarantee, as the operator will produce the window [0, 5) only when the output watermark is equal or greater than 5, and the downstream operator will process the input data, "and then" advance the watermark. Hence this window is considered as "non-late" record.

Distribute by grouping attributes - We need the underlying data and the initial state data to have the same grouping so that the data are co-lacated on the same task.

Ordering needed for using GroupingIterator. We need the initial state to also use the ordering as the data so that we can co-locate the keys from the underlying data and the initial state.

Resets all the metrics.

Set logical plan link recursively if unset.

Set the operator level metrics

The executor reports its state store checkpoint ID, which would be sent back to the driver. For the general checkpoint ID workflow, see comments of class class StatefulOperatorStateInfo

Set the SQL metrics related to the state store. This should be called in that task after the store has been updated.

Name to output in StreamingOperatorProgress to identify operator type

Should the MicroBatchExecution run another batch based on this stateful operator and the new input watermark.

Return true if this stage of the plan supports columnar execution. A plan can also support row-based execution (see supportsRowBased). Spark will decide which execution to be called during query planning.

Return true if this stage of the plan supports row-based execution. A plan can also support columnar execution (see supportsColumnar). Spark will decide which execution to be called during query planning.

Records the duration of running body for the next query progress update.

Converts the output of this plan to row-based if it is columnar plan.

The exact java types of the columns that are output in columnar processing mode. This is a performance optimization for code generation and is optional.

Blocks the thread until all subqueries finish evaluation and update the results.

Generate an expression that matches data older than the state eviction watermark

Generate an expression that matches data older than late event filtering watermark

Predicate based on the child output that matches data older than the watermark for late events filtering.

Generate an expression that matches data older than the state eviction watermark

Predicate based on keys that matches data older than the late event filtering watermark