Function validate_select_statement

graphlite/src/ast/validator.rs:2332–2393

Validate SELECT statement

(
    select_stmt: &SelectStatement,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
)

/// Validate SELECT statement
fn validate_select_statement(
    select_stmt: &SelectStatement,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
) {
    // Validate return items structure
    match &select_stmt.return_items {
        SelectItems::Wildcard { .. } => {
            // Wildcard (*) is always valid
        }
        SelectItems::Explicit { items, .. } => {
            if items.is_empty() {
                errors.push(ValidationError {
                    message: "SELECT statement must have at least one return item".to_string(),
                    location: Some(select_stmt.location.clone()),
                    error_type: ValidationErrorType::Structural,
                });
            }
        }
    }

    // Validate FROM clause FIRST to declare variables
    if let Some(from_clause) = &select_stmt.from_clause {
        validate_from_clause(from_clause, ctx, errors);
    }

    // Validate return item expressions AFTER variables are declared
    match &select_stmt.return_items {
        SelectItems::Wildcard { .. } => {
            // Wildcard is always valid, no expressions to validate
        }
        SelectItems::Explicit { items, .. } => {
            for item in items {
                validate_expression(&item.expression, ctx, errors);
            }
        }
    }

    // Validate WHERE clause if present
    if let Some(where_clause) = &select_stmt.where_clause {
        validate_expression(&where_clause.condition, ctx, errors);
    }

    // Validate GROUP BY clause if present
    if let Some(group_clause) = &select_stmt.group_clause {
        for expr in &group_clause.expressions {
            validate_expression(expr, ctx, errors);
        }
    }

    // Validate HAVING clause if present
    if let Some(having_clause) = &select_stmt.having_clause {
        validate_expression(&having_clause.condition, ctx, errors);
    }

    // Validate ORDER BY clause if present
    if let Some(order_clause) = &select_stmt.order_clause {
        for item in &order_clause.items {