Function parse

nodedb/src/engine/graph/pattern/compiler/mod.rs:32–119

Parse a MATCH query string into a `MatchQuery` AST. The input should start with `MATCH` or `OPTIONAL MATCH`.

(sql: &str)

///
/// The input should start with `MATCH` or `OPTIONAL MATCH`.
pub fn parse(sql: &str) -> crate::Result<MatchQuery> {
    let mut where_predicates = Vec::new();
    let mut return_columns = Vec::new();
    let mut distinct = false;
    let mut limit = None;
    let mut order_by = Vec::new();
    let mut collection = None;

    let trimmed = sql.trim();
    let upper = trimmed.to_uppercase();

    let where_pos = find_top_level_keyword(&upper, "WHERE");
    let return_pos = find_top_level_keyword(&upper, "RETURN");
    let limit_pos = find_top_level_keyword(&upper, "LIMIT");
    let order_pos = find_top_level_keyword(&upper, "ORDER BY");
    // `IN 'collection'` clause: appears after the last closing `)` and before RETURN/WHERE.
    // Use a boundary-aware scan that accepts `)` before `IN`.
    let in_pos = find_in_clause(&upper);

    // Extract collection name from `IN 'collection'` if present.
    if let Some(ip) = in_pos {
        let after_in = trimmed[ip + 2..].trim();
        // Strip surrounding quotes.
        let coll = if (after_in.starts_with('\'') && after_in.contains('\''))
            || (after_in.starts_with('"') && after_in.contains('"'))
        {
            let q = after_in.chars().next().unwrap();
            let rest = &after_in[1..];
            rest.find(q).map(|end| rest[..end].to_string())
        } else {
            after_in.split_whitespace().next().map(|s| s.to_string())
        };
        collection = coll;
    }

    let pattern_end = [where_pos, return_pos, limit_pos, order_pos, in_pos]
        .iter()
        .filter_map(|&p| p)
        .min()
        .unwrap_or(trimmed.len());

    let pattern_section = &trimmed[..pattern_end];
    let clauses = parse_match_clauses(pattern_section)?;

    if let Some(wp) = where_pos {
        let where_end = [return_pos, limit_pos, order_pos]
            .iter()
            .filter_map(|&p| p)
            .min()
            .unwrap_or(trimmed.len());
        let where_section = &trimmed[wp + 5..where_end].trim();
        where_predicates = parse_where(where_section)?;
    }

    if let Some(rp) = return_pos {
        let return_end = [limit_pos, order_pos]
            .iter()
            .filter_map(|&p| p)