Method extract_variables_from_node

graphlite/src/exec/executor.rs:9285–9360

Extract variables from a physical node (returns None if not a projection node)

(&self, node: &PhysicalNode)

    /// Extract variables from a physical node (returns None if not a projection node)
    fn extract_variables_from_node(&self, node: &PhysicalNode) -> Option<Vec<String>> {
        match node {
            PhysicalNode::Project { expressions, .. } => {
                let variables: Vec<String> = expressions
                    .iter()
                    .map(|expr| {
                        // Use alias if available, otherwise try to derive variable name from expression
                        if let Some(ref alias) = expr.alias {
                            alias.clone()
                        } else {
                            self.derive_variable_name_from_expression(&expr.expression)
                        }
                    })
                    .collect();
                Some(variables)
            }

            // For Aggregate nodes, we need to figure out the output column order
            // This is a bit tricky because we need to reconstruct it from the aggregates and group_by
            PhysicalNode::HashAggregate {
                group_by,
                aggregates,
                ..
            }
            | PhysicalNode::SortAggregate {
                group_by,
                aggregates,
                ..
            } => {
                let mut variables = Vec::new();

                // Add group-by columns first (in their original order)
                for expr in group_by {
                    variables.push(self.expression_to_string(expr));
                }

                // Add aggregate columns
                for aggregate in aggregates {
                    let column_name = aggregate.alias.clone().unwrap_or_else(|| {
                        let function_name = match &aggregate.function {
                            crate::plan::logical::AggregateFunction::Count => "COUNT",
                            crate::plan::logical::AggregateFunction::Sum => "SUM",
                            crate::plan::logical::AggregateFunction::Avg => "AVERAGE",
                            crate::plan::logical::AggregateFunction::Min => "MIN",
                            crate::plan::logical::AggregateFunction::Max => "MAX",
                            crate::plan::logical::AggregateFunction::Collect => "COLLECT",
                        };
                        format!(
                            "{}_{}",
                            function_name,
                            self.expression_to_string(&aggregate.expression)
                        )
                    });
                    variables.push(column_name);
                }

                Some(variables)
            }