Enum SkipMode 

pub enum SkipMode {
    PastLastRow,
    ToNextRow,
    ToFirst(String),
    ToLast(String),
}

Where the scan resumes after a match (the AFTER MATCH SKIP strategy).

Variants

PastLastRow

AFTER MATCH SKIP PAST LAST ROW: resume past the match’s last row (non-overlapping).

ToNextRow

AFTER MATCH SKIP TO NEXT ROW: resume at the row after the match’s first row (overlapping).

ToFirst(String)

AFTER MATCH SKIP TO FIRST <var>: resume at the first row labeled var.

ToLast(String)

AFTER MATCH SKIP TO LAST <var>: resume at the last row labeled var.

Implementations

impl SkipMode

pub fn clause_name(&self) -> &'static str

The AFTER MATCH SKIP clause as SQL spells it, without the target variable — the mode alone. &'static str so it can be the name of an ExprError::InvalidParam; the target variable is named by SkipDegradation::describe instead, so a rendered diagnostic states the mode once.

pub fn target_var(&self) -> Option<&str>

The pattern variable a SKIP TO FIRST|LAST resumes at; None for the variable-less modes, which are also the only ones that can never degrade.

pub fn next_pos( &self, start: usize, end: usize, labels: &[String], ) -> (usize, Option<SkipDegradation>)

The position the scan resumes at after a match spanning [start, end) with per-row labels (labels[i] is the variable bound to rows[start + i]), plus a SkipDegradation when that position is not the one the query asked for. Always returns > start so the scan makes progress.

Two cases have no valid resume row, and both are data-dependent — the same query degrades or not depending on which rows arrive:

• the target variable is bound to no row of this match ((a b?) matching only a, with SKIP TO LAST b), so the resume position falls back to the match end — silently becoming SKIP PAST LAST ROW;
• the target resolves to the match’s own first row (SKIP TO FIRST of the pattern’s leading variable), which would re-find the same match forever, so it is clamped to start + 1 — silently becoming SKIP TO NEXT ROW.

The SQL standard prescribes a runtime error for both (Oracle raises ORA-62511 / ORA-62512; Flink likewise). This implementation deliberately keeps the degradation and reports it instead of raising it: an error here would abort the actor over a data-dependent condition, and since the materialized view is already committed, every recovery attempt would replay the same rows and die again — a recoverable query turned into a crash loop. No RisingWave streaming operator fails an actor for a data-dependent condition; every hard error in this operator is a contract or plan violation (non-append-only input, an unknown slot kind), which recovery cannot fix either way. So the degradation is made visible rather than fatal: the executor routes the returned diagnostic to the actor’s EvalErrorReport, the same surface expression evaluation errors already use (the stream_expr_error log and the user_compute_error metric). See report_skip_degradation_once in executor.rs for how the message is rendered — including the surface’s fixed log prefix — and for the volume policy.

Trait Implementations

impl Clone for SkipMode

fn clone(&self) -> SkipMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SkipMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for SkipMode

impl PartialEq for SkipMode

fn eq(&self, other: &SkipMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SkipMode