Function execute_plan

atomic-repository/src/query_plan.rs:143–373

Execute a query plan against a repository.

(repo: &Repository, plan: &QueryPlan)

/// Execute a query plan against a repository.
pub fn execute_plan(repo: &Repository, plan: &QueryPlan) -> Result<PlanResult, RepositoryError> {
    let overall_start = std::time::Instant::now();

    let mut bindings: HashMap<String, Vec<KgNode>> = HashMap::new();
    let mut all_nodes: Vec<KgNode> = Vec::new();
    let mut all_edges: Vec<KgEdge> = Vec::new();
    let mut content: HashMap<String, String> = HashMap::new();
    let mut step_stats: Vec<StepStat> = Vec::new();

    for step in &plan.steps {
        let step_start = std::time::Instant::now();

        match step {
            QueryStep::KgSearch { query, limit, bind } => {
                let nodes = repo.vault_kg_search(query, *limit, None)?;
                let count = nodes.len();

                if let Some(var) = bind {
                    bindings.insert(var.clone(), nodes.clone());
                }
                all_nodes.extend(nodes);

                step_stats.push(StepStat {
                    step_type: "kg_search".to_string(),
                    result_count: count,
                    elapsed_ms: step_start.elapsed().as_millis() as u64,
                });
            }

            QueryStep::KgNeighbors {
                node_id,
                depth,
                bind,
            } => {
                // Resolve $variable references
                let ids = resolve_node_ids(node_id, &bindings);

                let mut step_nodes = Vec::new();
                let mut step_edges = Vec::new();

                for id in &ids {
                    match repo.vault_kg_neighbors(id, *depth) {
                        Ok(sg) => {
                            step_nodes.extend(sg.nodes);
                            step_edges.extend(sg.edges);
                        }
                        Err(e) => {
                            log::warn!("KG neighbors failed for {}: {}", id, e);
                        }
                    }
                }

                let count = step_nodes.len();
                if let Some(var) = bind {
                    bindings.insert(var.clone(), step_nodes.clone());
                }
                all_nodes.extend(step_nodes);
                all_edges.extend(step_edges);