From ae41bd06d3733ea09a7fae3d7097af2719d23cd0 Mon Sep 17 00:00:00 2001 From: Pascal Seitz Date: Mon, 3 Aug 2026 14:55:02 +0200 Subject: [PATCH] simpler missing algorithm --- columnar/src/block_accessor.rs | 23 +++++++++++-------- src/aggregation/agg_data.rs | 42 +++++++++++++++------------------- 2 files changed, 32 insertions(+), 33 deletions(-) diff --git a/columnar/src/block_accessor.rs b/columnar/src/block_accessor.rs index d7a09ee35..9d2b12dd5 100644 --- a/columnar/src/block_accessor.rs +++ b/columnar/src/block_accessor.rs @@ -97,16 +97,19 @@ impl } if ordered && !is_multivalue { - // Expand backwards so values that have not moved yet are not overwritten. - let mut end = docs.len(); - self.val_cache.resize(end, missing); - for hit_idx in (0..self.docid_cache.len()).rev() { - let pos = docs[..end].partition_point(|&doc| doc < self.docid_cache[hit_idx]); - self.val_cache[pos + 1..end].fill(missing); - self.val_cache[pos] = self.val_cache[hit_idx]; - end = pos; + // Rewrite backwards so unread compact values are not overwritten. + let mut remaining_hits = self.docid_cache.len(); + self.val_cache.resize(docs.len(), missing); + for (target_idx, &doc) in docs.iter().enumerate().rev() { + let value = if remaining_hits > 0 && self.docid_cache[remaining_hits - 1] == doc { + remaining_hits -= 1; + self.val_cache[remaining_hits] + } else { + missing + }; + self.val_cache[target_idx] = value; } - self.val_cache[..end].fill(missing); + debug_assert_eq!(remaining_hits, 0); self.docid_cache.clear(); self.docid_cache.extend_from_slice(docs); return; @@ -129,6 +132,8 @@ impl for &doc in &self.missing_docids_cache { let pos = self.docid_cache.partition_point(|&hit| hit < doc); + // TODO insert by back to avoid shifting the same elements + // self.missing_docids_cache.len() times self.docid_cache.insert(pos, doc); self.val_cache.insert(pos, missing); } diff --git a/src/aggregation/agg_data.rs b/src/aggregation/agg_data.rs index 15ebd98ff..6a2f58038 100644 --- a/src/aggregation/agg_data.rs +++ b/src/aggregation/agg_data.rs @@ -769,32 +769,13 @@ fn build_multi_terms_nodes( // columns before injecting the fallback, so a value in another type-specific collector is // not mistaken for a missing field and a genuinely missing document is not counted once // per type. - let missing_choice = + let missing_accessor = prepare_multi_terms_missing(&columns, field_def.missing.as_ref(), field_name)?; - let all_columns: Option]>> = missing_choice.as_ref().map(|_| { - Arc::from( - columns - .iter() - .map(|(column, _)| column.clone()) - .collect::>(), - ) - }); let mut typed_accessors = Vec::with_capacity(columns.len()); for (column_idx, (column, column_type)) in columns.into_iter().enumerate() { - let missing = match (&missing_choice, &all_columns) { - (Some((missing_idx, missing_value)), Some(all_columns)) - if *missing_idx == column_idx => - { - Some(MultiTermsMissingAccessor { - all_columns: all_columns.clone(), - key: field_def - .missing - .clone() - .expect("missing choice requires a configured missing value"), - missing_value: *missing_value, - }) - } + let missing = match &missing_accessor { + Some((missing_idx, missing)) if *missing_idx == column_idx => Some(missing.clone()), _ => None, }; typed_accessors.push(( @@ -859,7 +840,7 @@ fn prepare_multi_terms_missing( columns: &[(Column, ColumnType)], missing: Option<&Key>, field_name: &str, -) -> crate::Result> { +) -> crate::Result> { let Some(missing) = missing else { return Ok(None); }; @@ -905,7 +886,20 @@ fn prepare_multi_terms_missing( get_missing_val_as_u64_lenient(*column_type, column.max_value(), missing, field_name)?; } - Ok(Some((column_idx, find_missing_sentinel(column)))) + let all_columns = Arc::from( + columns + .iter() + .map(|(column, _)| column.clone()) + .collect::>(), + ); + Ok(Some(( + column_idx, + MultiTermsMissingAccessor { + all_columns, + key: missing.clone(), + missing_value: find_missing_sentinel(column), + }, + ))) } /// Returns a value that cannot collide with a value in `column`.