Method expression_needs_graph_context

graphlite/src/exec/executor.rs:2918–3030

Check if an expression needs graph context

(&self, expr: &crate::ast::Expression)

    /// Check if an expression needs graph context
    fn expression_needs_graph_context(&self, expr: &crate::ast::Expression) -> bool {
        use crate::ast::Expression;

        match expr {
            Expression::Variable(_var) => {
                // TODO: Check session parameters when session context is available
                // For now, assume variables need graph context
                true
            }
            Expression::PropertyAccess(_) => true, // Property access on graph elements
            Expression::FunctionCall(func_call) => {
                // Check if the function itself needs graph context
                if self.function_needs_graph_context(&func_call.name) {
                    return true;
                }
                // Check if any arguments need graph context
                for arg in &func_call.arguments {
                    if self.expression_needs_graph_context(arg) {
                        return true;
                    }
                }
                false
            }
            Expression::Binary(binary) => {
                self.expression_needs_graph_context(&binary.left)
                    || self.expression_needs_graph_context(&binary.right)
            }
            Expression::Unary(unary) => self.expression_needs_graph_context(&unary.expression),
            Expression::Case(case_expr) => {
                use crate::ast::CaseType;
                match &case_expr.case_type {
                    CaseType::Simple(simple_case) => {
                        if self.expression_needs_graph_context(&simple_case.test_expression) {
                            return true;
                        }
                        for branch in &simple_case.when_branches {
                            for when_val in &branch.when_values {
                                if self.expression_needs_graph_context(when_val) {
                                    return true;
                                }
                            }
                            if self.expression_needs_graph_context(&branch.then_expression) {
                                return true;
                            }
                        }
                        if let Some(else_expr) = &simple_case.else_expression {
                            return self.expression_needs_graph_context(else_expr);
                        }
                        false
                    }
                    CaseType::Searched(searched_case) => {
                        for branch in &searched_case.when_branches {
                            if self.expression_needs_graph_context(&branch.condition) {
                                return true;
                            }
                            if self.expression_needs_graph_context(&branch.then_expression) {
                                return true;
                            }