Function parse_set_operation

graphlite/src/ast/parser.rs:409–461

Parse complete query with clean precedence: core query + modifiers This implements Option 3: Restructured Parser Precedence

(tokens: &[Token])

/// Parse complete query with clean precedence: core query + modifiers
/// This implements Option 3: Restructured Parser Precedence
fn parse_set_operation(tokens: &[Token]) -> IResult<&[Token], Query> {
    // Step 1: Parse the core query (UNION, INTERSECT, MATCH, etc.)
    let (remaining, core_query) = parse_core_query(tokens)?;

    log::debug!(
        "parse_set_operation: core_query type = {:?}",
        std::mem::discriminant(&core_query)
    );
    match &core_query {
        Query::Basic(bq) => {
            log::debug!("parse_set_operation: BasicQuery has group_clause={}, order_clause={}, limit_clause={}",
                     bq.group_clause.is_some(), bq.order_clause.is_some(), bq.limit_clause.is_some());
        }
        Query::Limited {
            query,
            order_clause,
            limit_clause,
        } => {
            log::debug!(
                "parse_set_operation: Limited query has order={}, limit={}",
                order_clause.is_some(),
                limit_clause.is_some()
            );
            if let Query::Basic(bq) = query.as_ref() {
                log::debug!("parse_set_operation: Wrapped BasicQuery has group_clause={}, order_clause={}, limit_clause={}",
                         bq.group_clause.is_some(), bq.order_clause.is_some(), bq.limit_clause.is_some());
            }
        }
        _ => {
            log::debug!("parse_set_operation: Other query type");
        }
    }

    // Step 2: Parse optional modifiers that can apply to any query
    let (remaining, order_clause) = opt(order_clause)(remaining)?;
    let (remaining, limit_clause) = opt(limit_clause)(remaining)?;

    log::debug!(
        "parse_set_operation: Parsed order_clause={}, limit_clause={}",
        order_clause.is_some(),
        limit_clause.is_some()
    );

    // Step 3: Apply modifiers using unified logic
    let final_query = apply_query_modifiers(core_query, order_clause, limit_clause);

    log::debug!(
        "parse_set_operation: final_query type = {:?}",
        std::mem::discriminant(&final_query)
    );

    Ok((remaining, final_query))
}

/// Parse UNION and EXCEPT operations (lower precedence)
fn parse_union_except(tokens: &[Token]) -> IResult<&[Token], Query> {