Method execute_node_seq_scan_with_graph

graphlite/src/exec/executor.rs:3901–3995

Execute a sequential node scan with specific graph

(
        &self,
        variable: &str,
        labels: &[String],
        properties: Option<&HashMap<String, Expression>>,
        _context: &mut ExecutionContext,
        graph: &Arc<GraphCache>,

    /// Execute a sequential node scan with specific graph
    fn execute_node_seq_scan_with_graph(
        &self,
        variable: &str,
        labels: &[String],
        properties: Option<&HashMap<String, Expression>>,
        _context: &mut ExecutionContext,
        graph: &Arc<GraphCache>,
    ) -> Result<Vec<Row>, ExecutionError> {
        let mut rows = Vec::new();

        // Get nodes by label (if label specified, otherwise all nodes)
        let nodes = if labels.is_empty() {
            graph.get_all_nodes()
        } else {
            // For simplicity, just use the first label
            graph.get_nodes_by_label(&labels[0])
        };

        // Create a row for each node that matches property filters
        for node in nodes {
            // Check property filters if specified
            if let Some(property_filters) = properties {
                let mut matches_all_properties = true;

                for (prop_name, expected_expr) in property_filters {
                    // Evaluate the expected value expression
                    let expected_value = match expected_expr {
                        Expression::Literal(literal) => self.literal_to_value(literal),
                        Expression::Variable(var) => {
                            // For variables, we'd need to look them up in context
                            // For now, treat as string literal of the variable name
                            Value::String(var.name.clone())
                        }
                        _ => {
                            // For complex expressions, skip this property check for now
                            continue;
                        }
                    };

                    // Check if the node has this property with the expected value
                    match node.properties.get(prop_name) {
                        Some(actual_value) => {
                            if actual_value != &expected_value {
                                matches_all_properties = false;
                                break;
                            }
                        }
                        None => {
                            // Node doesn't have this property
                            matches_all_properties = false;
                            break;
                        }
                    }
                }

                // Skip this node if it doesn't match all property filters
                if !matches_all_properties {
                    continue;