Method compute_statistics

nodedb-graph/src/csr/statistics.rs:68–157

Compute full graph statistics from the current CSR state. O(V + E) — iterates all nodes and edges once. Intended for query planning, not hot-path execution. # Errors Returns [`GraphError::MemoryBudget`] if a memory governor is installed and the degree-array working set would exceed the `Graph` engine budget.

(&self)

    /// Returns [`GraphError::MemoryBudget`] if a memory governor is installed
    /// and the degree-array working set would exceed the `Graph` engine budget.
    pub fn compute_statistics(&self) -> Result<GraphStatistics, GraphError> {
        let n = self.node_count();
        if n == 0 {
            return Ok(GraphStatistics {
                node_count: 0,
                edge_count: 0,
                label_count: 0,
                label_stats: HashMap::new(),
                out_degree_histogram: DegreeHistogram {
                    min: 0,
                    max: 0,
                    avg: 0.0,
                    p50: 0,
                    p95: 0,
                    p99: 0,
                },
                in_degree_histogram: DegreeHistogram {
                    min: 0,
                    max: 0,
                    avg: 0.0,
                    p50: 0,
                    p95: 0,
                    p99: 0,
                },
            });
        }

        // Reserve memory for the two degree-distribution scratch arrays.
        let degree_bytes = 2 * n * size_of::<usize>();
        let _degree_guard = self
            .governor
            .as_ref()
            .map(|g| g.reserve(EngineId::Graph, degree_bytes))
            .transpose()?;

        // Per-label counters.
        let mut label_edge_count: HashMap<u32, usize> = HashMap::new();
        let mut label_sources: HashMap<u32, std::collections::HashSet<u32>> = HashMap::new();
        let mut label_targets: HashMap<u32, std::collections::HashSet<u32>> = HashMap::new();

        // Degree arrays.
        let mut out_degrees: Vec<usize> = Vec::with_capacity(n);
        let mut in_degrees: Vec<usize> = Vec::with_capacity(n);

        let mut total_edges = 0usize;

        for node in 0..n {
            let node_id = node as u32;
            let mut out_deg = 0usize;
            let mut in_deg = 0usize;

            for (lid, dst) in self.dense_iter_out(node_id) {
                out_deg += 1;
                total_edges += 1;
                *label_edge_count.entry(lid).or_insert(0) += 1;
                label_sources.entry(lid).or_default().insert(node_id);
                label_targets.entry(lid).or_default().insert(dst);
            }