simpler missing algorithm

This commit is contained in:
Pascal Seitz
2026-08-03 16:10:16 +02:00
parent 7d857723c2
commit ae41bd06d3
2 changed files with 32 additions and 33 deletions
+14 -9
View File
@@ -97,16 +97,19 @@ impl<T: PartialOrd + Copy + std::fmt::Debug + Send + Sync + 'static + Default>
}
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<T: PartialOrd + Copy + std::fmt::Debug + Send + Sync + 'static + Default>
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);
}
+18 -24
View File
@@ -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<Arc<[Column<u64>]>> = missing_choice.as_ref().map(|_| {
Arc::from(
columns
.iter()
.map(|(column, _)| column.clone())
.collect::<Vec<_>>(),
)
});
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<u64>, ColumnType)],
missing: Option<&Key>,
field_name: &str,
) -> crate::Result<Option<(usize, u64)>> {
) -> crate::Result<Option<(usize, MultiTermsMissingAccessor)>> {
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::<Vec<_>>(),
);
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`.