databendlabs/databend · error

transfer target initialized states overflow

Error message

transfer target initialized states overflow

What it means

commit() computes the number of initialized aggregate states as page.rows.checked_mul(payload.aggrs.len()). This panic fires on multiplication overflow — the product of rows and aggregate count exceeds the integer type — during aggregation state transfer commit.

Solutions

  1. Split the query into smaller aggregations (fewer aggregates or smaller pages) to keep rows*aggrs within range.
  2. Verify payload.aggrs and page.rows metadata are not corrupted by prior failed transfers.
  3. Use checked arithmetic with a wider type (u64/usize) for the initialized-state computation.
  4. Report the query plan; user-facing trigger is extreme aggregate width.
Defensive patterns

Strategy: validation

Validate before calling

let initialized = page
    .rows
    .checked_mul(payload.aggrs.len())
    .ok_or_else(|| ErrorCode::Internal("initialized states overflow"))?;

Prevention

When it happens

Trigger: commit_transferred_state_offsets where rows * aggrs.len() overflows the offset type: an extreme combination of page rows and aggregate functions, or corrupted rows/aggrs metadata.

Common situations: Queries with many aggregate functions over very wide/huge pages; metadata inconsistency in the payload arena after partial failures.

Related errors

AI-assisted analysis of databendlabs/databend@288d84d76e (2026-09-11). Data as JSON: /api/errors/c532aebd9cf53e4d. Report an issue: GitHub.

Appendix: source

Thrown at src/query/expression/src/aggregate/payload.rs:108

    fn commit(self, payloads: &mut [Payload]) {
        for (payload_index, page_index, offset) in self.offsets {
            let payload = payloads
                .get_mut(payload_index)
                .expect("transfer target payload index is out of bounds");

            let page = payload
                .pages
                .get_mut(page_index)
                .expect("transfer target page index is out of bounds");
            let next_state_offsets = page
                .state_offsets
                .checked_add(offset)
                .expect("transfer target state offsets overflow");
            let initialized_states = page
                .rows
                .checked_mul(payload.aggrs.len())
                .expect("transfer target initialized states overflow");

            assert!(
                next_state_offsets <= initialized_states,
                "transfer target state offsets exceed initialized aggregate states"
            );
            page.state_offsets = next_state_offsets;
        }
    }
}

impl<'a> PayloadTransferBatch<'a> {
    pub(super) fn from_flush_state(flush_state: &'a PayloadFlushState) -> Self {
        Self {
            rows: flush_state.row_count,
            addresses: &flush_state.addresses,
            partitions: &flush_state.probe_state.partition_entries,
        }
    }

View on GitHub (pinned to 288d84d76e)