Method execute_project_node

graphlite/src/exec/executor.rs:9110–9159

Execute a projection node without graph context (scalar-only)

(
        &self,
        node: &PhysicalNode,
        context: &mut ExecutionContext,
        _graph: Option<&Arc<GraphCache>>,
    )

    /// Execute a projection node without graph context (scalar-only)
    fn execute_project_node(
        &self,
        node: &PhysicalNode,
        context: &mut ExecutionContext,
        _graph: Option<&Arc<GraphCache>>,
    ) -> Result<Vec<Row>, ExecutionError> {
        match node {
            PhysicalNode::Project {
                expressions, input, ..
            } => {
                // First execute the input
                let input_rows = if let Some(graph) = _graph {
                    self.execute_node_with_graph(input, context, graph)?
                } else {
                    // For standalone projections (like RETURN literals), we might not have meaningful input
                    // In that case, try to execute without graph, and if it fails, assume it's a standalone projection
                    match self.execute_node_without_graph(input, context) {
                        Ok(rows) => rows,
                        Err(_) => {
                            // If input execution fails, assume this is a standalone projection
                            // Create a single empty row as input for the projection
                            vec![Row::from_values(std::collections::HashMap::new())]
                        }
                    }
                };

                // Apply projections to each row
                let mut result_rows = Vec::new();
                for _row in input_rows {
                    let mut projected_values = std::collections::HashMap::new();

                    for proj in expressions {
                        let value = self.evaluate_expression(&proj.expression, context)?;
                        let alias = proj
                            .alias
                            .clone()
                            .unwrap_or_else(|| format!("col_{}", projected_values.len()));
                        projected_values.insert(alias, value);
                    }

                    result_rows.push(Row::from_values(projected_values));
                }

                Ok(result_rows)
            }
            _ => Err(ExecutionError::RuntimeError(
                "Expected Project node".to_string(),
            )),
        }
    }

    /// Validate graph expression via catalog
    fn validate_graph_expression_via_catalog(&self, graph_expression: &GraphExpression) -> bool {