Function parse_query

graphlite/src/ast/parser.rs:95–347

Parse a GQL query or statement into an AST Document

(input: &str)

/// Parse a GQL query or statement into an AST Document
pub fn parse_query(input: &str) -> Result<Document, ParserError> {
    // Debug: Print query text if it contains GROUP BY
    if input.contains("GROUP BY") {
        log::debug!(
            "PARSER: Parsing query with GROUP BY: {}",
            input.trim().split('\n').collect::<Vec<_>>().join(" ")
        );
    }

    // First tokenize the input
    let mut tokens = tokenize(input).map_err(ParserError::LexerError)?;

    // Filter out SQL-style comments at the parser level
    tokens = filter_sql_comments(tokens);

    // Debug: Check if GROUP BY tokens exist
    if input.contains("GROUP BY") {
        let has_group_token = tokens.iter().any(|t| matches!(t, Token::Group));
        let has_by_token = tokens.iter().any(|t| matches!(t, Token::By));
        log::debug!(
            "PARSER: Token stream has GROUP={}, BY={}",
            has_group_token,
            has_by_token
        );
    }

    // Check for invalid DELETE SCHEMA and DELETE GRAPH patterns before parsing
    if tokens.len() >= 2 {
        match (&tokens[0], &tokens[1]) {
            (Token::Delete, Token::Schema) => {
                return Err(ParserError::InvalidDeleteSchema);
            }
            (Token::Delete, Token::Graph) => {
                return Err(ParserError::InvalidDeleteGraph);
            }
            _ => {}
        }
    }

    // Check for incomplete set operations (trailing keywords without right-hand side)
    // Look for set operation keywords followed by EOF or at the end
    for i in 0..tokens.len() {
        match &tokens[i] {
            Token::Union => {
                // Check if this is followed by EOF or is the last meaningful token
                if i + 1 >= tokens.len() || matches!(tokens.get(i + 1), Some(Token::Eof) | None) {
                    return Err(ParserError::IncompleteUnion);
                }
            }
            Token::Except => {
                if i + 1 >= tokens.len() || matches!(tokens.get(i + 1), Some(Token::Eof) | None) {
                    return Err(ParserError::IncompleteExcept);
                }
            }
            Token::Intersect => {
                if i + 1 >= tokens.len() || matches!(tokens.get(i + 1), Some(Token::Eof) | None) {
                    return Err(ParserError::IncompleteIntersect);
                }