Function parse_as_of_expr

nodedb-sql/src/parser/preprocess/temporal.rs:331–401

Extract the temporal expression that follows an AS-OF keyword at `offset` in `sql`. Returns `(resolved_ms, end_offset_exclusive)`. The expression is delimited by end-of-string or the next keyword-boundary token (a subsequent `AS OF`, or certain SQL keywords that cannot appear inside a temporal expression). Quoted string literals are consumed whole.

(sql: &str, offset: usize)

/// token (a subsequent `AS OF`, or certain SQL keywords that cannot appear
/// inside a temporal expression). Quoted string literals are consumed whole.
fn parse_as_of_expr(sql: &str, offset: usize) -> Result<(i64, usize), TemporalParseError> {
    let rest = &sql[offset..];
    let trimmed = rest.trim_start();
    let leading = rest.len() - trimmed.len();
    let abs_start = offset + leading;

    // If the next non-whitespace character opens a quoted string, consume
    // through the closing quote.
    if trimmed.starts_with('\'') || trimmed.starts_with('"') {
        let quote = trimmed
            .chars()
            .next()
            .expect("invariant: trimmed.starts_with('\\'' | '\"') guarantees at least one char");
        let inner_start = 1;
        let close = trimmed[inner_start..].find(quote).ok_or_else(|| {
            TemporalParseError(format!(
                "AS OF temporal expression: unterminated string literal at offset {abs_start}"
            ))
        })?;
        let end_rel = inner_start + close + 1; // include closing quote
        let token = &trimmed[..end_rel];
        let ms = parse_temporal_expr(token)?;
        return Ok((ms, abs_start + end_rel));
    }

    // Otherwise scan to the next whitespace-delimited boundary. We stop at:
    // a) another `AS OF` sequence (another clause),
    // b) certain SQL delimiter tokens: WHERE, LIMIT, ORDER, GROUP, HAVING,
    //    UNION, EXCEPT, INTERSECT, FETCH, FOR, OFFSET, semicolon.
    let stop_tokens = [
        "AS OF",
        "WHERE",
        "LIMIT",
        "ORDER",
        "GROUP",
        "HAVING",
        "UNION",
        "EXCEPT",
        "INTERSECT",
        "FETCH",
        "OFFSET",
        ";",
    ];
    let upper_trimmed = trimmed.to_uppercase();
    let mut end_rel = trimmed.len();
    for stop in &stop_tokens {
        // Only match at a word boundary (preceded by whitespace or start).
        let mut search_from = 0;
        while let Some(pos) = upper_trimmed[search_from..].find(stop) {
            let abs_pos = search_from + pos;
            let at_boundary = abs_pos == 0
                || upper_trimmed[..abs_pos].ends_with(|c: char| c.is_ascii_whitespace());
            if at_boundary {
                end_rel = end_rel.min(abs_pos);
                break;
            }
            search_from = abs_pos + 1;
        }