Function apply_query_modifiers

graphlite/src/ast/parser.rs:364–405

Apply ORDER BY and LIMIT modifiers to any query type This is the unified approach - one function handles all query variants

(
    query: Query,
    order_clause: Option<OrderClause>,
    limit_clause: Option<LimitClause>,
)

/// Apply ORDER BY and LIMIT modifiers to any query type
/// This is the unified approach - one function handles all query variants
fn apply_query_modifiers(
    query: Query,
    order_clause: Option<OrderClause>,
    limit_clause: Option<LimitClause>,
) -> Query {
    match (order_clause, limit_clause) {
        // No modifiers - return query as-is
        (None, None) => query,

        // Has modifiers - apply them based on query type
        (order, limit) => {
            match query {
                // For set operations, apply modifiers directly to the SetOperation struct
                Query::SetOperation(mut set_op) => {
                    set_op.order_clause = order;
                    set_op.limit_clause = limit;
                    Query::SetOperation(set_op)
                }

                // For BasicQuery, apply modifiers directly to preserve GROUP BY/HAVING
                // BasicQuery already has order_clause and limit_clause fields
                Query::Basic(mut basic_query) => {
                    // Only override if not already set (basic_query parser may have consumed them)
                    if basic_query.order_clause.is_none() {
                        basic_query.order_clause = order;
                    }
                    if basic_query.limit_clause.is_none() {
                        basic_query.limit_clause = limit;
                    }
                    Query::Basic(basic_query)
                }

                // For other query types, use the Limited wrapper
                _ => Query::Limited {
                    query: Box::new(query),
                    order_clause: order,
                    limit_clause: limit,
                },
            }
        }
    }
}

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