Method convert_rows_to_processor_format

graphlite/src/exec/executor.rs:1634–1728

Convert Vec to the format expected by WithClauseProcessor

(
        &self,
        input_rows: Vec<Row>,
    )

    /// Convert Vec<Row> to the format expected by WithClauseProcessor
    fn convert_rows_to_processor_format(
        &self,
        input_rows: Vec<Row>,
    ) -> Result<
        (
            std::collections::HashMap<String, Vec<crate::storage::Node>>,
            Vec<crate::storage::Edge>,
        ),
        ExecutionError,
    > {
        use crate::storage::Edge;
        use std::collections::HashMap;

        let mut variable_bindings = HashMap::new();
        let mut edges = Vec::new();

        // Extract variables for nodes and edges - we need to handle both node references and property accesses
        for row in input_rows.iter() {
            // First collect all variables (keys without dots)
            let mut vars = std::collections::HashSet::new();
            let mut edge_vars = std::collections::HashSet::new();

            for key in row.values.keys() {
                if !key.contains('.') {
                    // Check if this variable represents an edge (common patterns: t, r, e, rel)
                    // Also check for variables that have an associated .amount property (likely transaction edges)
                    if key == "t"
                        || key == "r"
                        || key == "e"
                        || key == "rel"
                        || row.values.contains_key(&format!("{}.amount", key))
                    {
                        edge_vars.insert(key.clone());
                    } else {
                        vars.insert(key.clone());
                    }
                }
            }

            // For each edge variable, create an edge with properties from the row
            for edge_var in &edge_vars {
                // Create a synthetic edge for aggregation purposes
                let mut edge_props = HashMap::new();

                // Collect properties for this edge
                for (key, value) in &row.values {
                    if key.starts_with(&format!("{}.", edge_var)) {
                        let property_name = key.strip_prefix(&format!("{}.", edge_var)).unwrap();
                        edge_props.insert(property_name.to_string(), value.clone());
                    } else if key == edge_var {
                        // If the edge variable itself has a value (like t: Number),
                        // treat it as the amount for Transaction edges
                        if let crate::storage::Value::Number(_amount) = value {
                            edge_props.insert("amount".to_string(), value.clone());
                        }
                    }
                }