Function validate_call_statement

graphlite/src/ast/validator.rs:2178–2227

Validate CALL statement

(
    call_stmt: &CallStatement,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
)

/// Validate CALL statement
fn validate_call_statement(
    call_stmt: &CallStatement,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
) {
    // Validate procedure name (should be valid system procedure)
    if !crate::catalog::system_procedures::is_system_procedure(&call_stmt.procedure_name) {
        errors.push(ValidationError {
            message: format!("Unknown system procedure: {}", call_stmt.procedure_name),
            location: Some(call_stmt.location.clone()),
            error_type: ValidationErrorType::Semantic,
        });
    }

    // Validate arguments
    for arg in &call_stmt.arguments {
        validate_expression(arg, ctx, errors);
    }

    // Validate YIELD clause if present
    if let Some(yield_clause) = &call_stmt.yield_clause {
        validate_yield_clause(yield_clause, errors);
    }

    // Validate WHERE clause if present
    if let Some(where_clause) = &call_stmt.where_clause {
        // WHERE clause can only be used with YIELD clause
        if call_stmt.yield_clause.is_none() {
            errors.push(ValidationError {
                message: "WHERE clause can only be used with YIELD clause in CALL statements"
                    .to_string(),
                location: Some(where_clause.location.clone()),
                error_type: ValidationErrorType::Semantic,
            });
        } else {
            // For CALL statements, we only validate WHERE structure and that it references YIELD columns
            // We skip general variable existence validation since procedure results are runtime-dependent

            // Additional validation: WHERE should reference columns from YIELD
            // This is a semantic check to ensure WHERE only uses yielded columns
            if let Some(yield_clause) = &call_stmt.yield_clause {
                validate_where_references_yield_columns(where_clause, yield_clause, errors);
            }

            // Note: We deliberately skip validate_expression() here for CALL WHERE clauses
            // because CALL procedure results are only known at runtime. The WHERE clause
            // validation happens during execution when the actual column names are available.
        }
    }
}

/// Validate that WHERE clause only references columns from YIELD clause
fn validate_where_references_yield_columns(