Method evaluate_expression

graphlite/src/exec/executor.rs:4587–4808

Evaluate an expression in the given context (legacy method)

(
        &self,
        expr: &Expression,
        context: &ExecutionContext,
    )

    /// Evaluate an expression in the given context (legacy method)
    fn evaluate_expression(
        &self,
        expr: &Expression,
        context: &ExecutionContext,
    ) -> Result<Value, ExecutionError> {
        match expr {
            Expression::Literal(literal) => self.evaluate_literal(literal),

            Expression::PropertyAccess(prop_access) => {
                // First, try the prefixed property name (for pre-expanded properties)
                let var_name = format!("{}.{}", prop_access.object, prop_access.property);
                if let Some(value) = context.get_variable(&var_name) {
                    return Ok(value);
                }

                // If not found, try to access property from the node variable directly
                if let Some(crate::storage::Value::Node(node)) =
                    context.get_variable(&prop_access.object).as_ref()
                {
                    if let Some(prop_value) = node.properties.get(&prop_access.property) {
                        return Ok(prop_value.clone());
                    }
                }

                // Return NULL if property doesn't exist (SQL standard behavior)
                Ok(Value::Null)
            }

            Expression::Binary(binary) => {
                let left_val = self.evaluate_expression(&binary.left, context)?;
                let right_val = self.evaluate_expression(&binary.right, context)?;
                self.evaluate_binary_op(&binary.operator, left_val, right_val)
            }

            Expression::Variable(var) => {
                // Check both local variables and session parameters
                log::debug!(
                    "Looking for variable '{}' in context with {} variables",
                    var.name,
                    context.variables.len()
                );
                for key in context.variables.keys() {
                    log::debug!("  Context has variable: '{}'", key);
                }
                context.get_variable(&var.name).ok_or_else(|| {
                    ExecutionError::ExpressionError(format!("Variable not found: {}", var.name))
                })
            }

            Expression::FunctionCall(func_call) => self.evaluate_function_call(func_call, context),

            Expression::Case(case_expr) => self.evaluate_case_expression(case_expr, context),

            Expression::Unary(unary) => {
                let operand_val = self.evaluate_expression(&unary.expression, context)?;
                self.evaluate_unary_op(&unary.operator, operand_val)
            }