Method execute

graphlite/src/functions/graph_functions.rs:60–167

(&self, context: &FunctionContext)

    }

    fn execute(&self, context: &FunctionContext) -> FunctionResult<Value> {
        if context.arguments.len() != 1 {
            return Err(FunctionError::InvalidArgumentCount {
                expected: 1,
                actual: context.arguments.len(),
            });
        }

        let node_ref = &context.arguments[0];

        // Handle direct Node values (from query execution)
        match node_ref {
            Value::Node(node) => {
                let labels: Vec<Value> = node
                    .labels
                    .iter()
                    .map(|label| Value::String(label.clone()))
                    .collect();
                return Ok(Value::List(labels));
            }
            Value::String(variable_name) => {
                // First, check if this is a variable name in the aggregation context
                // Look through the rows to find the actual node data
                if !context.rows.is_empty() {
                    // Try to find the variable in the first row to get a sample value
                    for row in &context.rows {
                        if let Some(Value::Node(node)) = row.get_value(variable_name) {
                            let labels: Vec<Value> = node
                                .labels
                                .iter()
                                .map(|label| Value::String(label.clone()))
                                .collect();
                            return Ok(Value::List(labels));
                        }
                    }
                }

                // If not found in rows, continue with node ID lookup for string references
                let node_id = variable_name.clone();

                // Method 1: Try current_graph first (fastest)
                if let Some(ref current_graph) = context.current_graph {
                    if let Some(node) = current_graph.get_node(&node_id) {
                        let labels: Vec<Value> = node
                            .labels
                            .iter()
                            .map(|label| Value::String(label.clone()))
                            .collect();
                        return Ok(Value::List(labels));
                    }
                }

                // Method 2: Try storage_manager with graph_name
                if let (Some(ref storage_manager), Some(ref graph_name)) =
                    (&context.storage_manager, &context.graph_name)
                {
                    if let Ok(Some(graph)) = storage_manager.get_graph(graph_name) {
                        if let Some(node) = graph.get_node(&node_id) {