Function validate_expression

graphlite/src/ast/validator.rs:1107–1215

Validate a single expression

(
    expr: &Expression,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
)

/// Validate a single expression
fn validate_expression(
    expr: &Expression,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
) {
    match expr {
        Expression::Binary(binary) => {
            validate_expression(&binary.left, ctx, errors);
            validate_expression(&binary.right, ctx, errors);
            validate_binary_operation(&binary.operator, &binary.left, &binary.right, ctx, errors);
        }
        Expression::Unary(unary) => {
            validate_expression(&unary.expression, ctx, errors);
            validate_unary_operation(&unary.operator, &unary.expression, ctx, errors);
        }
        Expression::FunctionCall(func_call) => {
            validate_function_call(func_call, ctx, errors);
        }
        Expression::PropertyAccess(prop_access) => {
            validate_property_access(prop_access, ctx, errors);
        }
        Expression::Variable(variable) => {
            validate_variable_usage(variable, ctx, errors);
        }
        Expression::Literal(literal) => {
            validate_literal(literal, errors);
        }
        Expression::Case(case_expr) => {
            validate_case_expression(case_expr, ctx, errors);
        }
        Expression::PathConstructor(path_constructor) => {
            validate_path_constructor(path_constructor, ctx, errors);
        }
        Expression::Cast(cast_expr) => {
            validate_cast_expression(cast_expr, ctx, errors);
        }
        Expression::Subquery(subquery_expr) => {
            // Validate the subquery recursively
            validate_subquery(&subquery_expr.query, ctx, errors);
        }
        Expression::ExistsSubquery(subquery_expr) => {
            // Validate the EXISTS subquery recursively
            validate_subquery(&subquery_expr.query, ctx, errors);
        }
        Expression::NotExistsSubquery(subquery_expr) => {
            // Validate the NOT EXISTS subquery recursively
            validate_subquery(&subquery_expr.query, ctx, errors);
        }
        Expression::InSubquery(subquery_expr) => {
            // Validate the left expression and the subquery
            validate_expression(&subquery_expr.expression, ctx, errors);
            validate_subquery(&subquery_expr.query, ctx, errors);
        }
        Expression::NotInSubquery(subquery_expr) => {
            // Validate the left expression and the subquery
            validate_expression(&subquery_expr.expression, ctx, errors);
            validate_subquery(&subquery_expr.query, ctx, errors);
        }