Function eval_ast_expr

nodedb/src/data/executor/handlers/recursive_value.rs:210–259

Recursively evaluate a sqlparser AST expression with column reference support.

(
    expr: &sqlparser::ast::Expr,
    ctx: &HashMap<String, nodedb_types::Value>,
)

/// Recursively evaluate a sqlparser AST expression with column reference support.
fn eval_ast_expr(
    expr: &sqlparser::ast::Expr,
    ctx: &HashMap<String, nodedb_types::Value>,
) -> Option<nodedb_types::Value> {
    use nodedb_types::Value;
    use sqlparser::ast::{Expr, UnaryOperator};

    match expr {
        Expr::Value(v) => eval_ast_literal(&v.value),

        // Unqualified column: `n`
        Expr::Identifier(ident) => {
            let name = ident.value.to_lowercase();
            ctx.get(&name).cloned()
        }

        // Qualified: `c.n` — strip qualifier
        Expr::CompoundIdentifier(parts) if parts.len() == 2 => {
            let col = parts[1].value.to_lowercase();
            ctx.get(&col).cloned()
        }

        Expr::UnaryOp {
            op: UnaryOperator::Minus,
            expr: inner,
        } => match eval_ast_expr(inner, ctx)? {
            Value::Integer(i) => Some(Value::Integer(-i)),
            Value::Float(f) => Some(Value::Float(-f)),
            _ => None,
        },

        Expr::UnaryOp {
            op: UnaryOperator::Not,
            expr: inner,
        } => match eval_ast_expr(inner, ctx)? {
            Value::Bool(b) => Some(Value::Bool(!b)),
            _ => None,
        },

        Expr::BinaryOp { left, op, right } => {
            let l = eval_ast_expr(left, ctx)?;
            let r = eval_ast_expr(right, ctx)?;
            eval_binary_op(&l, op, &r)
        }

        Expr::Nested(inner) => eval_ast_expr(inner, ctx),

        _ => None,
    }
}

fn eval_ast_literal(v: &sqlparser::ast::Value) -> Option<nodedb_types::Value> {
    use sqlparser::ast::Value;