Method from_table

atomic-core/src/pristine/txn/read.rs:1942–1989

Pre-load using an already-opened INODE_GRAPH table handle. This avoids the per-file `open_multimap_table` overhead when processing many files in parallel — the caller opens the table once and passes the handle to each file's preloader.

(
        txn: &'txn ReadTxn,
        inode: Inode,
        table: &redb::ReadOnlyMultimapTable<&'static [u8; 32], &'static [u8; 24]>,
    )

    /// processing many files in parallel — the caller opens the table
    /// once and passes the handle to each file's preloader.
    pub fn from_table(
        txn: &'txn ReadTxn,
        inode: Inode,
        table: &redb::ReadOnlyMultimapTable<&'static [u8; 32], &'static [u8; 24]>,
    ) -> PristineResult<Self> {
        let inode_id = inode.get();
        let start_key = encode_inode_vertex(inode_id, 0, 0, 0);
        let end_key = encode_inode_vertex(inode_id, u64::MAX, u64::MAX, u64::MAX);

        let mut edges: std::collections::HashMap<GraphNode<NodeId>, Vec<SerializedGraphEdge>> =
            std::collections::HashMap::new();
        let mut vertex_set: std::collections::HashSet<GraphNode<NodeId>> =
            std::collections::HashSet::new();

        for result in table.range::<&[u8; 32]>(&start_key..=&end_key)? {
            let (key, values) = result?;
            let (_, v_change, v_start, v_end) = decode_inode_vertex(key.value());

            let vertex = GraphNode {
                change: NodeId::new(v_change),
                start: ChangePosition::new(v_start),
                end: ChangePosition::new(v_end),
            };
            vertex_set.insert(vertex);

            let edge_list = edges.entry(vertex).or_default();
            for v in values.filter_map(|r| r.ok()) {
                let bytes: &[u8; 24] = v.value();
                let edge = deserialize_edge(bytes);
                edge_list.push(edge);
            }
        }

        let mut vertices: Vec<GraphNode<NodeId>> = vertex_set.into_iter().collect();
        vertices.sort_by(|a, b| {
            a.change
                .get()
                .cmp(&b.change.get())
                .then(a.start.get().cmp(&b.start.get()))
                .then(a.end.get().cmp(&b.end.get()))
        });

        Ok(Self {
            txn,
            edges,
            vertices,
        })
    }

    /// Whether any pre-loaded edge for this inode is a DELETED edge whose
    /// introducing change is in `visible`.