Method expand_select_items

graphlite/src/exec/executor.rs:8486–8536

Expand SELECT items, handling wildcard (*) by creating return items for all node properties

(
        &self,
        select_items: &SelectItems,
        graph: &Arc<GraphCache>,
    )

    /// Expand SELECT items, handling wildcard (*) by creating return items for all node properties
    fn expand_select_items(
        &self,
        select_items: &SelectItems,
        graph: &Arc<GraphCache>,
    ) -> Result<Vec<ReturnItem>, ExecutionError> {
        match select_items {
            SelectItems::Explicit { items, .. } => Ok(items.clone()),
            SelectItems::Wildcard { .. } => {
                // For wildcard, we need to determine what properties are available
                // This is a simplified implementation - in a full implementation,
                // we'd analyze the query to determine available variables and their properties
                // Since graph is Arc<GraphCache>, we can access it directly

                // Get all unique property names from all nodes
                let mut property_names = std::collections::BTreeSet::new();
                for node in graph.get_all_nodes() {
                    for prop_name in node.properties.keys() {
                        property_names.insert(prop_name.clone());
                    }
                }

                // Create return items for each unique property
                let mut return_items = Vec::new();

                // Add node variable itself (assuming 'm' from the pattern)
                return_items.push(ReturnItem {
                    expression: Expression::Variable(Variable {
                        name: "m".to_string(),
                        location: Location::default(),
                    }),
                    alias: None,
                    location: Location::default(),
                });

                // Add each property as m.property_name
                for prop_name in property_names {
                    return_items.push(ReturnItem {
                        expression: Expression::PropertyAccess(PropertyAccess {
                            object: "m".to_string(),
                            property: prop_name,
                            location: Location::default(),
                        }),
                        alias: None,
                        location: Location::default(),
                    });
                }

                Ok(return_items)
            }
        }
    }

    /// Execute DECLARE statement to define local variables with type specifications
    /// Internal method for declare statements