Method execute_path_traversal

graphlite/src/exec/executor.rs:6338–6391

Execute path traversal with type constraints

(
        &self,
        path_type: &PathType,
        from_variable: &str,
        to_variable: &str,
        path_elements: &[PathElement],
        input_rows: Vec<Row>,
        context: &mut Execut

    /// Execute path traversal with type constraints
    fn execute_path_traversal(
        &self,
        path_type: &PathType,
        from_variable: &str,
        to_variable: &str,
        path_elements: &[PathElement],
        input_rows: Vec<Row>,
        context: &mut ExecutionContext,
        graph: &Arc<GraphCache>,
    ) -> Result<Vec<Row>, ExecutionError> {
        let mut result_rows = Vec::new();

        for input_row in input_rows {
            // Get the starting node
            let start_node_id = input_row.get_value(from_variable).ok_or_else(|| {
                ExecutionError::RuntimeError(format!("Variable not found: {}", from_variable))
            })?;

            if let Value::String(start_id) = start_node_id {
                // Find all paths from start node based on path type
                let paths = self.find_paths_with_constraints(
                    start_id,
                    path_elements,
                    path_type,
                    graph,
                    context,
                )?;

                // Create result rows for each valid path
                for path in paths {
                    let mut row = input_row.clone();

                    // Add the end node to the row
                    if let Some(end_node_id) = path.last() {
                        row.set_value(to_variable.to_string(), Value::String(end_node_id.clone()));
                    }

                    // Add intermediate variables if specified
                    for (i, element) in path_elements.iter().enumerate() {
                        if i < path.len() - 1 {
                            row.set_value(
                                element.node_variable.clone(),
                                Value::String(path[i + 1].clone()),
                            );
                        }
                    }

                    result_rows.push(row);
                }
            }
        }

        Ok(result_rows)
    }

    /// Find paths with type constraints
    fn find_paths_with_constraints(