Method absorb_sparse

nodedb/src/engine/array/compaction/merger.rs:345–388

(&mut self, _schema: &ArraySchema, tile: &SparseTile)

    }

    fn absorb_sparse(&mut self, _schema: &ArraySchema, tile: &SparseTile) -> ArrayResult<()> {
        let n = tile.row_count();
        for row in 0..n {
            let coord: Vec<CoordValue> = tile
                .dim_dicts
                .iter()
                .map(|d| d.values[d.indices[row] as usize].clone())
                .collect();
            let kind = tile.row_kind(row)?;
            let (attrs, surrogate, valid_from_ms, valid_until_ms) = match kind {
                RowKind::Live => {
                    let attrs: Vec<CellValue> =
                        tile.attr_cols.iter().map(|col| col[row].clone()).collect();
                    let surrogate = tile
                        .surrogates
                        .get(row)
                        .copied()
                        .unwrap_or(nodedb_types::Surrogate::ZERO);
                    let vf = tile.valid_from_ms.get(row).copied().unwrap_or(0);
                    let vu = tile
                        .valid_until_ms
                        .get(row)
                        .copied()
                        .unwrap_or(nodedb_types::OPEN_UPPER);
                    (attrs, surrogate, vf, vu)
                }
                RowKind::Tombstone | RowKind::GdprErased => (
                    Vec::new(),
                    nodedb_types::Surrogate::ZERO,
                    0,
                    nodedb_types::OPEN_UPPER,
                ),
            };
            self.upsert(MergedRow {
                coord,
                attrs,
                surrogate,
                valid_from_ms,
                valid_until_ms,
                kind,
            });
        }
        Ok(())
    }

    fn absorb_dense(&mut self, _schema: &ArraySchema, _tile: &DenseTile) -> ArrayResult<()> {
        Err(nodedb_array::ArrayError::SegmentCorruption {