Skip to content

Merge command

Purpose

obikmer merge combines multiple existing kmer indexes into a single index. The result contains all kmers from all sources, with per-genome presence/absence or count data for every genome across every layer.

Modes

pub enum MergeMode { Presence, Count }

Default mode is Presence. Count mode requires all source indexes to have with_counts=true; mixing count and non-count sources is rejected at validation.

Mode Column type Constraint
Presence PersistentBitMatrix (one bit per genome per slot) none
Count PersistentCompactIntMatrix (one u32 per genome per slot) all sources with_counts=true

Input / output constraints

All source indexes must satisfy:

  • IndexState::Indexed (fully built — index.done sentinel present)
  • Same kmer_size, minimizer_size, n_partitions
  • Same evidence kind: all Exact, or all Approx with identical (b, z) parameters
  • If Count mode: all sources must have with_counts=true

--force: if the output directory already exists, it is deleted before the merge begins.

Evidence compatibility

validate_evidence_compat(sources) is called before any I/O. It compares each source's EvidenceKind against sources[0]:

  • All Exact → accepted, output uses Exact
  • All Approx { b, z } with same (b, z) → accepted, output uses those parameters
  • Any other combination → OKIError::IncompatibleEvidence, with a message directing the user to run reindex first

Mixed exact/approx is a hard error, not a silent conversion.

fn validate_evidence_compat(sources: &[&KmerIndex]) -> OKIResult<EvidenceKind>

Genome label deduplication

compute_labels(sources, rename_duplicates) assigns final genome labels across all sources before any file is written. The first occurrence of a label keeps the original name. Subsequent occurrences receive .1, .2, … suffixes when rename_duplicates is true, or trigger OKIError::DuplicateGenomeLabel otherwise.

Algorithm

1. Validation

Check all sources against the constraints above. Abort on any mismatch.

2. Bootstrap output from first source

Recursive file copy of sources[0] → output. Immediately after the copy:

  • index.meta is rewritten with the final genome list (all sources, possibly renamed) and the effective evidence kind.
  • In Presence mode, any counts/ directories inherited from source_0 are removed.
  • spectrums/ from source_0 is removed and rebuilt from scratch across all sources, applying the (possibly renamed) labels.

This establishes the partition layout, all existing MPHFs, unitigs, and evidence files. The first source's genomes occupy columns 0 … n_dst_genomes - 1 in the destination.

3. For each subsequent source (parallel across partitions)

KmerPartition::merge_partition(i, sources, mode, n_dst_genomes, block_bits) is called for each partition index i. block_bits is taken from dst.meta.config.block_bits.

Each entry in sources is (&KmerPartition, n_genomes) where n_genomes is the column count that source contributes (> 1 when the source is itself a merged index).

First merge, Presence mode: when n_dst_genomes == 1, Layer::<()>::init_presence_matrix is called on every existing destination layer before any source column is appended. This creates presence/col_000000.pbiv set all-true (genome 0 is present in every slot).

Pass 1 — classify kmers

Iterate all kmers from all source partitions (via UnitigFileReader + canonical kmer iteration). For each kmer, probe the destination LayeredMap<()>:

  • Hit: kmer already in the destination; record for Pass 2.
  • Miss: push kmer into a GraphDeBruijn accumulator.

New layer construction

If the accumulator is non-empty, compute de Bruijn unitigs and call Layer::<()>::build(&new_layer_dir, block_bits). All kmers absent from the destination — across all sources — accumulate into a single graph, producing one new layer per merge operation (not one per source).

Pass 2 — fill column builders

For each source and each of its layers, re-iterate unitigs and look up stored values via SrcLayerData::lookup(kmer, src_n):

  • SrcLayerData::SetMembership — no data directory exists; every kmer returns vec![1; n_genomes]
  • SrcLayerData::Presence — reads PersistentBitMatrix from presence/
  • SrcLayerData::Count — reads PersistentCompactIntMatrix from counts/

Hits are routed to exist_builders[dst_layer][src_col]; misses are routed to new_src_builders[src_col].

Column prepending for new layers

Before source columns are written to the new layer, n_dst_genomes absent columns (all-zero / all-false) are prepended — one per genome already in the index — so the column count invariant holds immediately after layer creation.

Close and update metadata

Close all builders; update presence/meta.json or counts/meta.json with {"n": N, "n_cols": n_dst_genomes + n_src_total}; increment PartitionMeta::n_layers if a new layer was added.

4. Update index metadata

index.meta was already written during bootstrap with the complete genome list and evidence kind. No further update is needed after the partition loop.

append_genome_column

Defined on two concrete specialisations of Layer<D>:

impl Layer<PersistentCompactIntMatrix> {
    pub fn append_genome_column(layer_dir: &Path, value_of: impl Fn(usize) -> u32) -> OLMResult<()>
}

impl Layer<PersistentBitMatrix> {
    pub fn append_genome_column(layer_dir: &Path, value_of: impl Fn(usize) -> bool) -> OLMResult<()>
}

Each appends one column file to the matrix subdirectory (counts/ or presence/). In merge_partition, columns are written directly via PersistentBitVecBuilder / PersistentCompactIntVecBuilder rather than through these helpers, but the invariant they enforce is the same.

Column count invariant

After any merge, every layer in every partition has exactly n_genomes columns, where n_genomes is the total genome count in the index at that point.

Maintained by three mechanisms:

  1. Existing layers: n_src_total columns appended (one per source genome).
  2. New layers created during merge: n_dst_genomes absent columns prepended before source columns.
  3. First merge, Presence mode: init_presence_matrix retroactively creates presence/col_0 all-true for genome 0.

The invariant is a precondition of LayeredStore aggregation traits: col_weights() and all partial distance methods assume every inner store has the same column count.

Error variants relevant to merge

Variant Condition
OKIError::NotIndexed(path) Source not in Indexed state
OKIError::IncompatibleConfig Mismatched kmer_size, minimizer_size, or n_partitions
OKIError::MismatchedMode Count mode but a source has with_counts=false
OKIError::IncompatibleEvidence(msg) Mixed exact/approx or different approx (b, z)
OKIError::DuplicateGenomeLabel(label) Duplicate label and rename_duplicates=false

On-disk impact

After merging G genomes (sources_0 contributes G0, subsequent sources the rest):

partitions/
  part_00000/
    index/
      meta.json              ← n_layers updated if new layer added
      layer_0/
        mphf.bin             ← unchanged
        unitigs.bin          ← unchanged
        evidence.bin         ← unchanged
        presence/            ← created on first merge (Presence mode)
          meta.json            {"n": N, "n_cols": G}
          col_000000.pbiv      ← all-true (genome 0 … G0-1)
          col_000001.pbiv      ← next source
          ...
        counts/              ← extended (Count mode)
          meta.json            {"n": N, "n_cols": G}
          col_000000.pciv      ← genome 0 counts (from original build)
          col_000001.pciv      ← next source
          ...
      layer_N/               ← new layer (if new kmers found)
        mphf.bin
        unitigs.bin
        evidence.bin
        presence/ or counts/
          meta.json            {"n": N1, "n_cols": G}
          col_000000.pbiv      ← all-false (absent for existing genomes)
          ...
spectrums/
  <label>.json               ← one file per genome, rebuilt from all sources
index.meta                   ← complete genome list + evidence kind written at bootstrap