Struct StatementParser 

pub struct StatementParser {
    buffer: String,
    scan_offset: usize,
    stmt_start: usize,
    state: LexState,
    block_comment_depth: usize,
    in_batch: bool,
}

Incremental statement parser.

Tracks lexer state across feed_line calls so that each call only scans the newly appended bytes. Total work is O(n) over the lifetime of the parser, not O(n²). See PR #151 for why this matters.

Fields

buffer: String

Accumulated input buffer.

scan_offset: usize

Byte offset in buffer where the next scan should resume.

stmt_start: usize

Byte offset of the start of the current (in-progress) statement.

state: LexState

Current lexer state at scan_offset.

block_comment_depth: usize

Depth of nested block comments.

in_batch: bool

True when we are inside a BEGIN BATCH … APPLY BATCH block. Semicolons inside a batch do not terminate the batch statement.

Implementations

impl StatementParser

pub fn new() -> Self

Create a new empty parser.

pub fn reset(&mut self)

Reset the parser, discarding any accumulated input.

pub fn is_empty(&self) -> bool

Returns true if the parser has no accumulated input.

pub fn remaining(&self) -> &str

Returns the remaining unparsed content in the buffer.

pub fn feed_line(&mut self, line: &str) -> ParseResult

Feed a line of input and return any complete statements.

This is the incremental entry point. Each call scans only the newly appended bytes, preserving lexer state from the previous call. Total work across all feed_line calls is O(n).

fn scan_for_statements(&mut self) -> ParseResult

Scan from scan_offset forward for statement terminators.

Only scans newly appended bytes — does NOT re-scan from the start. State (self.state, self.block_comment_depth) is preserved across calls.

Trait Implementations

impl Debug for StatementParser

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

Formats the value using the given formatter.

impl Default for StatementParser

fn default() -> StatementParser

Returns the “default value” for a type.