From a1e707f0290526e41094226843e27ff39922dbe6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=B6ren=20Brunk?= <soeren.brunk@commercetools.com>
Date: Mon, 17 Aug 2026 12:07:44 +0200
Subject: [PATCH 1/3] feat(fts): score unindexed and partially indexed
 fragments in combined_fields

The previous commit refuses a `combined_fields` query whose target columns do
not all cover every scanned fragment, so a default full-text search fails on
any dataset with rows appended since the indexes were built. `MatchQuery`
already unions in a flat scan for its unindexed fragments; this does the same
for BM25F.

Coverage is per column here, which makes it more than a copy of the
single-column path. `dl'` sums each column's document length and a row absent
from a column's `DocSet` contributes 0, so a fragment indexed for `title` but
not `body` cannot be scored from the index at all. The indexed scan is
therefore restricted to the intersection of per-column coverage and
everything else goes to the flat scan, rather than splitting on the union.

Both sides then score against one shared corpus. The flat side alone sees the
rows no index covers, so it measures their contribution and publishes the
blend; the indexed side waits for it instead of folding only its own
`docCount'`/`docFreq'`/`avgdl'`. Without that, a row reached through either
path would rank differently depending on which side happened to score it.

Data overlays are handled by measuring rather than patching. When a target
column carries an overlay-stale index entry, folding the flat row into the
index statistics would double count it against the entry it replaces, and the
flat scan cannot subtract what it replaced. So the corpus is measured from
current data instead: every target fragment is scanned, every row folded into
every column, and the index statistics left out. That costs a full scan of the
target columns, so it stays confined to the stale case. `fast_search` is
unchanged, being index-only by contract.
---
 rust/lance-index/src/scalar/inverted.rs       |   4 +-
 .../src/scalar/inverted/combined.rs           |  11 +-
 .../src/scalar/inverted/combined/flat.rs      | 201 ++++++
 .../src/scalar/inverted/combined/search.rs    |  15 +-
 .../src/scalar/inverted/combined/stats.rs     | 260 +++++++-
 .../src/scalar/inverted/combined/testing.rs   |  65 +-
 rust/lance-index/src/scalar/inverted/index.rs |   6 +-
 .../src/scalar/inverted/index/flat_search.rs  | 222 ++++++-
 .../src/scalar/inverted/index/partition.rs    |  58 ++
 .../src/scalar/inverted/index/search.rs       |  70 ++
 .../src/scalar/inverted/index/tests/stats.rs  |   9 +-
 rust/lance/src/dataset/scanner.rs             | 221 ++++++-
 rust/lance/src/index/scalar/inverted.rs       |  65 ++
 rust/lance/src/io/exec/fts.rs                 | 606 ++++++++++++++++--
 rust/lance/tests/query/inverted.rs            |  20 +-
 15 files changed, 1717 insertions(+), 116 deletions(-)
 create mode 100644 rust/lance-index/src/scalar/inverted/combined/flat.rs

diff --git a/rust/lance-index/src/scalar/inverted.rs b/rust/lance-index/src/scalar/inverted.rs
index 11a2b6e513f..a5c7dd05f8b 100644
--- a/rust/lance-index/src/scalar/inverted.rs
+++ b/rust/lance-index/src/scalar/inverted.rs
@@ -30,8 +30,8 @@ use arrow_schema::{DataType, Field};
 use async_trait::async_trait;
 pub use builder::InvertedIndexBuilder;
 pub use combined::{
-    CombinedFieldColumn, build_combined_bm25_scorer, combined_fields_search,
-    validate_combined_tokenizers,
+    CombinedCorpusStats, CombinedFieldColumn, FlatFieldStats, build_combined_bm25_scorer,
+    combined_fields_search, flat_combined_fields_search_stream, validate_combined_tokenizers,
 };
 pub use compound::{
     compound_search, compound_search_prepared_match,
diff --git a/rust/lance-index/src/scalar/inverted/combined.rs b/rust/lance-index/src/scalar/inverted/combined.rs
index 9de77185ce7..e48f245b8a0 100644
--- a/rust/lance-index/src/scalar/inverted/combined.rs
+++ b/rust/lance-index/src/scalar/inverted/combined.rs
@@ -23,6 +23,7 @@
 //! scored; see [`combined_fields_search`].
 
 mod cursor;
+mod flat;
 mod search;
 mod stats;
 #[cfg(test)]
@@ -31,9 +32,11 @@ mod testing;
 use std::sync::Arc;
 
 use lance_core::{Error, Result};
+use lance_select::RowAddrTreeMap;
 
+pub use flat::flat_combined_fields_search_stream;
 pub use search::combined_fields_search;
-pub use stats::build_combined_bm25_scorer;
+pub use stats::{CombinedCorpusStats, FlatFieldStats, build_combined_bm25_scorer};
 
 use super::index::InvertedIndex;
 use super::query::Tokens;
@@ -47,6 +50,12 @@ pub struct CombinedFieldColumn {
     pub weight: f32,
     /// Opened inverted-index segments for this column.
     pub indices: Vec<Arc<InvertedIndex>>,
+    /// Rows an overlay made stale, in the row-id domain index results use.
+    ///
+    /// The flat scan folds their current values into the corpus, so their old
+    /// values are subtracted from `indices` to avoid counting them twice.
+    /// `None` when no overlay touched this column.
+    pub stale_rows: Option<Arc<RowAddrTreeMap>>,
 }
 
 /// Deduplicate the query tokens into the unique terms of the virtual field,
diff --git a/rust/lance-index/src/scalar/inverted/combined/flat.rs b/rust/lance-index/src/scalar/inverted/combined/flat.rs
new file mode 100644
index 00000000000..0e0d6ac3155
--- /dev/null
+++ b/rust/lance-index/src/scalar/inverted/combined/flat.rs
@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The Lance Authors
+
+//! The unindexed `combined_fields` plan: blend the scanned column values into
+//! `dl'`/`tf'` and score the rows no target column's index covers.
+
+use std::sync::Arc;
+
+use arrow::array::{Float32Builder, UInt64Builder};
+use arrow_array::{ArrayRef, RecordBatch};
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::physical_plan::metrics::Time;
+use datafusion::physical_plan::stream::RecordBatchStreamAdapter;
+use futures::{FutureExt, stream};
+use lance_core::error::DataFusionResult;
+use lance_core::utils::tokio::spawn_cpu;
+use lance_select::RowAddrMask;
+
+use super::super::index::{BlendedRows, FTS_SCHEMA, slice_into_batches, tokenize_and_blend_multi};
+use super::super::query::{Operator, Tokens};
+use super::super::scorer::CombinedFieldsBM25Scorer;
+use super::super::tokenizer::document_tokenizer::LanceTokenizer;
+use super::stats::{CombinedCorpusStats, FlatFieldStats, build_combined_bm25_scorer};
+use super::{CombinedFieldColumn, unique_terms};
+use crate::metrics::MetricsCollector;
+
+/// Exact cross-field BM25F search over rows that no index fully covers, scored
+/// straight from their column values. Together with the indexed
+/// [`combined_fields_search`](super::combined_fields_search) this covers the
+/// whole dataset, with the same term deduplication and `operator` semantics.
+///
+/// - `input` carries `_rowid` plus every target column; `doc_col_indices` locates
+///   them, in `columns` order.
+/// - `stats_masks[column]` selects the rows folded into that column's corpus
+///   statistics, so a row indexed for some columns is not counted twice.
+/// - `emit_mask`, when set, selects the rows to emit from an unfiltered `input`.
+/// - `flat_covers_whole_corpus` selects [`CombinedCorpusStats::FlatOnly`].
+/// - `metrics` receives only the scorer build's index reads.
+///
+/// Returns the scorer alongside the stream. The whole input is consumed before
+/// the first output batch, so an indexed sibling can score against the same
+/// statistics.
+#[allow(clippy::too_many_arguments)]
+pub async fn flat_combined_fields_search_stream(
+    input: SendableRecordBatchStream,
+    columns: &[CombinedFieldColumn],
+    doc_col_indices: Vec<usize>,
+    stats_masks: &[Arc<RowAddrMask>],
+    emit_mask: Option<Arc<RowAddrMask>>,
+    flat_covers_whole_corpus: bool,
+    tokens: &Tokens,
+    tokenizer: Box<dyn LanceTokenizer>,
+    operator: Operator,
+    target_batch_size: usize,
+    elapsed_compute: Option<Time>,
+    metrics: Option<&dyn MetricsCollector>,
+) -> DataFusionResult<(SendableRecordBatchStream, Arc<CombinedFieldsBM25Scorer>)> {
+    let terms = unique_terms(tokens);
+    debug_assert_eq!(doc_col_indices.len(), columns.len());
+    debug_assert_eq!(stats_masks.len(), columns.len());
+    // A query that tokenizes to nothing matches nothing, as on the indexed path.
+    // The scorer is still returned, because an indexed sibling waits for it.
+    if terms.is_empty() || columns.is_empty() {
+        let empty = FlatFieldStats::zeros(columns.len(), 0);
+        let scorer = Arc::new(
+            build_combined_bm25_scorer(
+                columns,
+                tokens,
+                CombinedCorpusStats::for_flat_scan(&empty, flat_covers_whole_corpus),
+                metrics,
+            )
+            .boxed()
+            .await?,
+        );
+        return Ok((
+            Box::pin(RecordBatchStreamAdapter::new(
+                FTS_SCHEMA.clone(),
+                stream::empty::<DataFusionResult<RecordBatch>>(),
+            )),
+            scorer,
+        ));
+    }
+
+    let input_schema = input.schema();
+    // `tf'` is one value per deduplicated term, so the counter must see the same
+    // deduplicated list the indexed scan scores.
+    let unique_tokens = Arc::new(Tokens::new(terms.clone(), tokens.token_type().clone()));
+    // Same thresholds as the single-column flat path: tokenization is CPU-bound,
+    // so batches are accumulated before a task is dispatched.
+    const ACCUMULATE_BYTES: usize = 256 * 1024;
+    const SLICE_BYTES: usize = 512 * 1024;
+    let chunked = lance_arrow::stream::rechunk_stream_by_size(
+        input,
+        input_schema,
+        ACCUMULATE_BYTES,
+        SLICE_BYTES,
+    );
+
+    let weights: Vec<f32> = columns.iter().map(|column| column.weight).collect();
+    let (blended, flat_stats) = tokenize_and_blend_multi(
+        chunked,
+        tokenizer,
+        unique_tokens,
+        Arc::new(doc_col_indices),
+        Arc::new(weights),
+        Arc::new(stats_masks.to_vec()),
+        elapsed_compute.clone(),
+    )
+    .await?;
+
+    // Time the scorer build and the scoring loop together.
+    let post_await_start = std::time::Instant::now();
+    let scorer = Arc::new(
+        build_combined_bm25_scorer(
+            columns,
+            tokens,
+            CombinedCorpusStats::for_flat_scan(&flat_stats, flat_covers_whole_corpus),
+            metrics,
+        )
+        .boxed()
+        .await?,
+    );
+    // `rows x terms` synchronous work, offloaded like the indexed scoring loop so a
+    // large flat scan cannot hold a DataFusion worker.
+    let scores = {
+        let terms_for_scoring = terms.clone();
+        let scorer_for_scoring = scorer.clone();
+        let require_all_terms = operator == Operator::And;
+        spawn_cpu(move || {
+            flat_combined_score(
+                &terms_for_scoring,
+                blended,
+                scorer_for_scoring.as_ref(),
+                require_all_terms,
+                emit_mask.as_deref(),
+            )
+        })
+        .await?
+    };
+
+    let batches = slice_into_batches(scores, target_batch_size);
+    if let Some(t) = &elapsed_compute {
+        t.add_duration(post_await_start.elapsed());
+    }
+    Ok((
+        Box::pin(RecordBatchStreamAdapter::new(
+            FTS_SCHEMA.clone(),
+            stream::iter(batches),
+        )),
+        scorer,
+    ))
+}
+
+/// Score every retained flat row from its blended `dl'`/`tf'`, emitting
+/// `(ROW_ID, SCORE)` in [`FTS_SCHEMA`] for the rows `emit_mask` selects.
+///
+/// Takes the chunks by value and drops each one as it is scored, so the blend and
+/// the output arrays are never both fully resident.
+fn flat_combined_score(
+    terms: &[String],
+    blended: Vec<BlendedRows>,
+    scorer: &CombinedFieldsBM25Scorer,
+    require_all_terms: bool,
+    emit_mask: Option<&RowAddrMask>,
+) -> DataFusionResult<RecordBatch> {
+    let num_terms = terms.len();
+    let num_rows = blended.iter().map(|chunk| chunk.row_ids.len()).sum();
+    let mut row_ids = UInt64Builder::with_capacity(num_rows);
+    let mut scores = Float32Builder::with_capacity(num_rows);
+    for chunk in blended {
+        for (row, (input_row_id, dl_prime)) in
+            chunk.row_ids.iter().zip(&chunk.doc_lengths).enumerate()
+        {
+            if emit_mask.is_some_and(|mask| !mask.selected(*input_row_id)) {
+                continue;
+            }
+            let tf_prime = &chunk.term_freqs[row * num_terms..(row + 1) * num_terms];
+            // `And` spans the virtual field, so it checks the blended `tf'`.
+            if require_all_terms && tf_prime.iter().any(|tf| *tf <= 0.0) {
+                continue;
+            }
+            let score: f32 = terms
+                .iter()
+                .zip(tf_prime)
+                .map(|(term, tf)| scorer.query_weight(term) * scorer.doc_weight(*tf, *dl_prime))
+                .sum();
+            if score > 0.0 {
+                row_ids.append_value(*input_row_id);
+                scores.append_value(score);
+            }
+        }
+    }
+
+    Ok(RecordBatch::try_new(
+        FTS_SCHEMA.clone(),
+        vec![
+            Arc::new(row_ids.finish()) as ArrayRef,
+            Arc::new(scores.finish()) as ArrayRef,
+        ],
+    )?)
+}
diff --git a/rust/lance-index/src/scalar/inverted/combined/search.rs b/rust/lance-index/src/scalar/inverted/combined/search.rs
index f9650ffd5bc..65e66f2c4c1 100644
--- a/rust/lance-index/src/scalar/inverted/combined/search.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/search.rs
@@ -183,7 +183,7 @@ mod tests {
     use super::super::super::index::InvertedListFormatVersion;
     use super::super::super::scorer::idf;
     use super::super::super::tokenizer::document_tokenizer::DocType;
-    use super::super::stats::build_combined_bm25_scorer;
+    use super::super::stats::{CombinedCorpusStats, build_combined_bm25_scorer};
     use super::super::testing::{
         ElementRows, as_row_documents, combined_columns, combined_top_k, element_document_index,
     };
@@ -242,7 +242,7 @@ mod tests {
         );
         assert_eq!(
             title_index
-                .bm25_row_stats_for_terms(&terms, None)
+                .bm25_row_stats_for_terms(&terms, None, None)
                 .await
                 .unwrap(),
             (19, 10, vec![1, 1]),
@@ -389,11 +389,17 @@ mod tests {
             "the fixture must still be element-per-document",
         );
         assert_eq!(
-            legacy.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            legacy
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             (9, 4, vec![1, 3]),
         );
         assert_eq!(
-            modern.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            modern
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             modern.bm25_stats_for_terms(&terms, None).await.unwrap(),
             "a row-per-document index must be untouched",
         );
@@ -404,6 +410,7 @@ mod tests {
         let scorer = build_combined_bm25_scorer(
             &columns,
             &Tokens::new(vec!["alpha".to_owned(), "beta".to_owned()], DocType::Text),
+            CombinedCorpusStats::IndexOnly,
             None,
         )
         .await
diff --git a/rust/lance-index/src/scalar/inverted/combined/stats.rs b/rust/lance-index/src/scalar/inverted/combined/stats.rs
index 8be1f095d52..0f21dc861ed 100644
--- a/rust/lance-index/src/scalar/inverted/combined/stats.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/stats.rs
@@ -1,18 +1,146 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The Lance Authors
 
-//! Corpus statistics for `combined_fields`: the cross-column BM25F scorer
-//! build.
+//! Corpus statistics for `combined_fields`: the flat-scan contribution
+//! ([`FlatFieldStats`]) and the cross-column BM25F scorer build.
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use lance_core::Result;
+use lance_select::RowAddrMask;
 
 use super::super::query::Tokens;
 use super::super::scorer::CombinedFieldsBM25Scorer;
 use super::{CombinedFieldColumn, unique_terms};
 use crate::metrics::MetricsCollector;
 
+/// Per-column corpus contributions of the rows a `combined_fields` flat scan
+/// covers, i.e. rows in fragments that at least one target column's index is
+/// missing.
+///
+/// Folded into each column's own totals ahead of the BM25F cross-column blend so
+/// that `docCount'`, `docFreq'`, and `avgdl'` describe the whole scanned corpus
+/// rather than only its indexed part. Folding after the blend would be wrong:
+/// `docCount'`/`docFreq'` are a `max_f`, and `max_f(a_f) + max_f(b_f)` is not
+/// `max_f(a_f + b_f)`.
+///
+/// Every vector is indexed by the position of the column in the
+/// [`CombinedFieldColumn`] slice, and `doc_freqs[column]` is indexed by the
+/// deduplicated query term position (the order
+/// [`combined_fields_search`](super::combined_fields_search) uses).
+#[derive(Debug, Default, Clone)]
+pub struct FlatFieldStats {
+    /// Per column: flat docs with at least one token in that column.
+    pub doc_counts: Vec<usize>,
+    /// Per column: total tokens over all flat docs.
+    pub total_tokens: Vec<u64>,
+    /// `[column][term]`: flat docs containing that term in that column.
+    pub doc_freqs: Vec<Vec<usize>>,
+}
+
+impl FlatFieldStats {
+    /// An empty accumulator sized for `num_columns` columns and `num_terms`
+    /// deduplicated query terms.
+    pub(in crate::scalar::inverted) fn zeros(num_columns: usize, num_terms: usize) -> Self {
+        Self {
+            doc_counts: vec![0; num_columns],
+            total_tokens: vec![0; num_columns],
+            doc_freqs: vec![vec![0; num_terms]; num_columns],
+        }
+    }
+
+    /// Fold one flat row's per-column contribution in.
+    ///
+    /// `doc_lengths` is `dl_f` per column and `term_counts` is `[column][term]`,
+    /// both for a single row. A row absent from a field (`dl_f == 0`) counts
+    /// toward neither `docCount_f` nor `docFreq_f`, matching the indexed side
+    /// where it owns no document in that field's index.
+    ///
+    /// `stats_masks[column]` selects the rows that column's index does not
+    /// already count, so a row indexed for some target columns is not counted
+    /// twice for them. It may admit an overlay-stale row, whose old value the
+    /// index statistics then subtract (see [`CombinedFieldColumn::stale_rows`]).
+    pub(in crate::scalar::inverted) fn fold_row(
+        &mut self,
+        row_id: u64,
+        stats_masks: &[Arc<RowAddrMask>],
+        doc_lengths: &[u64],
+        term_counts: &[u64],
+    ) {
+        let num_terms = self.doc_freqs.first().map_or(0, |freqs| freqs.len());
+        for (column, doc_count) in self.doc_counts.iter_mut().enumerate() {
+            if doc_lengths[column] == 0 || !stats_masks[column].selected(row_id) {
+                continue;
+            }
+            *doc_count += 1;
+            self.total_tokens[column] += doc_lengths[column];
+            let base = column * num_terms;
+            for (term, doc_freq) in self.doc_freqs[column].iter_mut().enumerate() {
+                if term_counts[base + term] > 0 {
+                    *doc_freq += 1;
+                }
+            }
+        }
+    }
+
+    /// Add another accumulator's totals. Every field is an integer count, so
+    /// merging per-batch folds is exact and order-independent.
+    pub(in crate::scalar::inverted) fn merge(&mut self, other: Self) {
+        for (total, part) in self.doc_counts.iter_mut().zip(other.doc_counts) {
+            *total += part;
+        }
+        for (total, part) in self.total_tokens.iter_mut().zip(other.total_tokens) {
+            *total += part;
+        }
+        for (total, part) in self.doc_freqs.iter_mut().zip(other.doc_freqs) {
+            for (total, part) in total.iter_mut().zip(part) {
+                *total += part;
+            }
+        }
+    }
+}
+
+/// Which statistics [`build_combined_bm25_scorer`] folds into the BM25F blend.
+#[derive(Debug, Clone, Copy)]
+pub enum CombinedCorpusStats<'a> {
+    /// Index statistics alone: every target column's index covers every scanned
+    /// fragment, so no row was flat-scanned.
+    IndexOnly,
+    /// Index statistics plus a flat scan's contribution for the rows no index
+    /// covers. The masks the fold applied decide which rows those are, and so
+    /// whether a row lands on one side or, deliberately, on both.
+    Blended(&'a FlatFieldStats),
+    /// A flat scan's statistics alone, covering the whole target corpus.
+    ///
+    /// For a legacy segment, which cannot name the rows an overlay made stale, so
+    /// their pre-overlay values cannot be subtracted from its statistics.
+    FlatOnly(&'a FlatFieldStats),
+}
+
+impl<'a> CombinedCorpusStats<'a> {
+    /// The variant for a flat scan's statistics, by whether the scan read every
+    /// target fragment or only the rows no index covers.
+    pub fn for_flat_scan(flat: &'a FlatFieldStats, covers_whole_corpus: bool) -> Self {
+        if covers_whole_corpus {
+            Self::FlatOnly(flat)
+        } else {
+            Self::Blended(flat)
+        }
+    }
+
+    fn flat(&self) -> Option<&'a FlatFieldStats> {
+        match self {
+            Self::IndexOnly => None,
+            Self::Blended(flat) | Self::FlatOnly(flat) => Some(flat),
+        }
+    }
+
+    fn folds_index_stats(&self) -> bool {
+        !matches!(self, Self::FlatOnly(_))
+    }
+}
+
 /// Fold the target columns' segment statistics into a single [`CombinedFieldsBM25Scorer`].
 ///
 /// Generalizes [`build_global_bm25_scorer`](super::super::build_global_bm25_scorer)
@@ -23,34 +151,44 @@ use crate::metrics::MetricsCollector;
 /// deduplicates them, so the resulting per-term `docFreq'` covers exactly the
 /// terms [`combined_fields_search`](super::combined_fields_search) scores.
 ///
+/// `corpus` selects which statistics the blend is built from; see
+/// [`CombinedCorpusStats`].
+///
 /// `metrics`, when provided, receives the per-token posting-metadata cache
 /// lookups this fold triggers, exactly as
 /// [`build_global_bm25_scorer`](super::super::build_global_bm25_scorer)
 /// reports them on the single-column path. Without it a cold cross-field query
 /// undercounts `index_cache_misses` by one lookup per (term, partition, column).
+/// [`CombinedCorpusStats::FlatOnly`] reads none, so it reports none.
 pub async fn build_combined_bm25_scorer(
     columns: &[CombinedFieldColumn],
     tokens: &Tokens,
+    corpus: CombinedCorpusStats<'_>,
     metrics: Option<&dyn MetricsCollector>,
 ) -> Result<CombinedFieldsBM25Scorer> {
     let terms = unique_terms(tokens);
+    if let Some(flat) = corpus.flat() {
+        debug_assert_eq!(flat.doc_counts.len(), columns.len());
+        debug_assert!(flat.doc_freqs.iter().all(|df| df.len() == terms.len()));
+    }
     let mut doc_count = 0usize;
     let mut sum_total_term_freq = 0f64;
     let mut doc_freq: HashMap<String, usize> = terms.iter().map(|t| (t.clone(), 0)).collect();
 
-    for column in columns {
+    for (column_slot, column) in columns.iter().enumerate() {
         let mut column_num_docs = 0usize;
         let mut column_total_tokens = 0u64;
         let mut column_doc_freq = vec![0usize; terms.len()];
-        {
+        if corpus.folds_index_stats() {
             for index in &column.indices {
                 // Row granularity, not document granularity: `combined_fields_search`
                 // blends every posting a row owns into one `tf'` and every document
                 // length it owns into one `dl'`, and released V1/V2 indexes may hold
                 // one document per list element. See
                 // [`InvertedIndex::bm25_row_stats_for_terms`].
-                let (total_tokens, num_docs, token_docs) =
-                    index.bm25_row_stats_for_terms(&terms, metrics).await?;
+                let (total_tokens, num_docs, token_docs) = index
+                    .bm25_row_stats_for_terms(&terms, column.stale_rows.as_deref(), metrics)
+                    .await?;
                 column_total_tokens += total_tokens;
                 column_num_docs += num_docs;
                 for (slot, df) in token_docs.into_iter().enumerate() {
@@ -58,6 +196,13 @@ pub async fn build_combined_bm25_scorer(
                 }
             }
         }
+        if let Some(flat) = corpus.flat() {
+            column_num_docs += flat.doc_counts[column_slot];
+            column_total_tokens += flat.total_tokens[column_slot];
+            for (slot, df) in flat.doc_freqs[column_slot].iter().enumerate() {
+                column_doc_freq[slot] += df;
+            }
+        }
 
         doc_count = doc_count.max(column_num_docs);
         sum_total_term_freq += column.weight as f64 * column_total_tokens as f64;
@@ -84,13 +229,58 @@ pub async fn build_combined_bm25_scorer(
 #[cfg(test)]
 mod tests {
     use super::super::super::index::InvertedListFormatVersion;
+    use super::super::super::tokenizer::InvertedIndexParams;
     use super::super::super::tokenizer::document_tokenizer::DocType;
-    use super::super::testing::{ElementRows, combined_columns, element_document_index};
+    use super::super::flat::flat_combined_fields_search_stream;
+    use super::super::testing::{
+        ElementRows, combined_columns, element_document_index, flat_input, flat_scores,
+    };
     use super::*;
     use crate::metrics::LocalMetricsCollector;
+    use crate::scalar::inverted::query::Operator;
+    use lance_select::RowAddrTreeMap;
     use rstest::rstest;
 
-    /// The scorer build must report its index cache lookups to the query's
+    /// The statistics fold runs per batch and the partial results are merged, so
+    /// it must not matter how the scan is chunked.
+    #[test]
+    fn test_flat_field_stats_fold_is_split_invariant() {
+        // Two columns, two terms. Row 7 is empty in column 1 and row 9 is masked
+        // out of column 1, so neither contributes there.
+        let rows: [(u64, [u64; 2], [u64; 4]); 3] = [
+            (7, [4, 0], [1, 0, 0, 0]),
+            (8, [3, 5], [1, 1, 2, 0]),
+            (9, [2, 6], [0, 1, 1, 1]),
+        ];
+        let masks = vec![
+            Arc::new(RowAddrMask::all_rows()),
+            Arc::new(RowAddrMask::all_rows().also_block(RowAddrTreeMap::from_iter([9u64]))),
+        ];
+        let fold = |rows: &[(u64, [u64; 2], [u64; 4])]| {
+            let mut stats = FlatFieldStats::zeros(2, 2);
+            for (row_id, lengths, counts) in rows {
+                stats.fold_row(*row_id, &masks, lengths, counts);
+            }
+            stats
+        };
+
+        let whole = fold(&rows);
+        assert_eq!(whole.doc_counts, vec![3, 1]);
+        assert_eq!(whole.total_tokens, vec![9, 5]);
+        // Column 0: "cat" in rows 7 and 8, "dog" in rows 8 and 9.
+        // Column 1: only row 8 counts, with "cat" present and "dog" absent.
+        assert_eq!(whole.doc_freqs, vec![vec![2, 2], vec![1, 0]]);
+
+        for split in 0..=rows.len() {
+            let mut merged = fold(&rows[..split]);
+            merged.merge(fold(&rows[split..]));
+            assert_eq!(merged.doc_counts, whole.doc_counts, "split at {split}");
+            assert_eq!(merged.total_tokens, whole.total_tokens, "split at {split}");
+            assert_eq!(merged.doc_freqs, whole.doc_freqs, "split at {split}");
+        }
+    }
+
+    /// Both scorer builds must report their index cache lookups to the query's
     /// collector, the way the single-column `build_global_bm25_scorer` does; see
     /// [`build_combined_bm25_scorer`] for what goes wrong otherwise.
     ///
@@ -118,13 +308,49 @@ mod tests {
         let expected_lookups = 2 * columns.len();
 
         let indexed = LocalMetricsCollector::default();
-        build_combined_bm25_scorer(&columns, &tokens, Some(&indexed))
-            .await
-            .unwrap();
+        build_combined_bm25_scorer(
+            &columns,
+            &tokens,
+            CombinedCorpusStats::IndexOnly,
+            Some(&indexed),
+        )
+        .await
+        .unwrap();
         assert_eq!(
             indexed.index_cache_hits() + indexed.index_cache_misses(),
             expected_lookups,
-            "the scorer build must report every cache lookup it makes",
+            "indexed scorer build must report every cache lookup it makes",
+        );
+
+        // The flat sibling folds the same per-column index statistics in, so its
+        // build reports the same lookups. An empty input isolates them: the
+        // scanned rows contribute no index reads at all.
+        let flat = LocalMetricsCollector::default();
+        let stream = flat_combined_fields_search_stream(
+            flat_input(&[], &[Vec::new(), Vec::new()], 1),
+            &columns,
+            vec![1, 2],
+            &[
+                Arc::new(RowAddrMask::all_rows()),
+                Arc::new(RowAddrMask::all_rows()),
+            ],
+            /*emit_mask=*/ None,
+            /*flat_covers_whole_corpus=*/ false,
+            &tokens,
+            InvertedIndexParams::default().build().unwrap(),
+            Operator::Or,
+            16,
+            None,
+            Some(&flat),
+        )
+        .await
+        .unwrap()
+        .0;
+        assert!(flat_scores(stream).await.1.is_empty());
+        assert_eq!(
+            flat.index_cache_hits() + flat.index_cache_misses(),
+            expected_lookups,
+            "flat scorer build must report every cache lookup it makes",
         );
     }
 
@@ -158,7 +384,10 @@ mod tests {
         let documents = index.bm25_stats_for_terms(&terms, None).await.unwrap();
         assert_eq!(documents, (5, 3, vec![2, 2, 0]));
         assert_eq!(
-            index.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            index
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             documents
         );
     }
@@ -201,7 +430,10 @@ mod tests {
             (4, 4, vec![2, 2]),
         );
         assert_eq!(
-            index.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            index
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             (4, 2, vec![1, 2]),
         );
     }
diff --git a/rust/lance-index/src/scalar/inverted/combined/testing.rs b/rust/lance-index/src/scalar/inverted/combined/testing.rs
index e6f83fa60d6..4d41ce0c911 100644
--- a/rust/lance-index/src/scalar/inverted/combined/testing.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/testing.rs
@@ -8,9 +8,15 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use arrow::array::AsArray;
+use arrow::datatypes::{Float32Type, UInt64Type};
 use arrow_array::{ArrayRef, RecordBatch, UInt32Array, UInt64Array};
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::physical_plan::stream::RecordBatchStreamAdapter;
+use futures::stream;
 use lance_core::Result;
 use lance_core::cache::{LanceCache, WeakLanceCache};
+use lance_core::error::DataFusionResult;
 use lance_core::utils::tempfile::TempObjDir;
 use lance_io::object_store::ObjectStore;
 use lance_select::RowAddrTreeMap;
@@ -29,7 +35,9 @@ use super::super::index::{
 use super::super::query::{FtsSearchParams, Operator, Tokens};
 use super::super::tokenizer::document_tokenizer::DocType;
 use super::super::tokenizer::{InvertedIndexParams, LEGACY_BLOCK_SIZE};
-use super::{CombinedFieldColumn, build_combined_bm25_scorer, combined_fields_search};
+use super::{
+    CombinedCorpusStats, CombinedFieldColumn, build_combined_bm25_scorer, combined_fields_search,
+};
 use crate::metrics::NoOpMetricsCollector;
 use crate::prefilter::NoFilter;
 use crate::scalar::lance_format::LanceIndexStore;
@@ -135,6 +143,58 @@ pub(super) async fn modern_identity_docs(
     .unwrap()
 }
 
+/// `_rowid` plus one `Utf8` document column per entry of `docs`
+/// (`docs[column][row]`), delivered as `num_batches` equal batches.
+pub(super) fn flat_input(
+    row_ids: &[u64],
+    docs: &[Vec<Option<&str>>],
+    num_batches: usize,
+) -> SendableRecordBatchStream {
+    use arrow_array::StringArray;
+    use arrow_schema::{DataType, Field, Schema};
+
+    let mut fields = vec![lance_core::ROW_ID_FIELD.clone()];
+    let mut arrays: Vec<ArrayRef> = vec![Arc::new(UInt64Array::from(row_ids.to_vec()))];
+    for (slot, column) in docs.iter().enumerate() {
+        fields.push(Field::new(format!("doc{slot}"), DataType::Utf8, true));
+        arrays.push(Arc::new(StringArray::from(column.clone())));
+    }
+    let schema = Arc::new(Schema::new(fields));
+    let batch = RecordBatch::try_new(schema.clone(), arrays).unwrap();
+    // No rows means no batches at all, the way an empty scan arrives.
+    let rows_per_batch = row_ids.len().div_ceil(num_batches.max(1));
+    let batches = (0..row_ids.len().div_ceil(rows_per_batch.max(1)))
+        .map(|i| {
+            let start = i * rows_per_batch;
+            let len = (row_ids.len() - start).min(rows_per_batch);
+            DataFusionResult::Ok(batch.slice(start, len))
+        })
+        .collect::<Vec<_>>();
+    Box::pin(RecordBatchStreamAdapter::new(schema, stream::iter(batches)))
+}
+
+/// Every `(row_id, score)` the flat scan emits, in emission order, with the
+/// score as raw bits so the comparison is exact.
+pub(super) async fn flat_scores(
+    stream: SendableRecordBatchStream,
+) -> (Vec<usize>, Vec<(u64, u32)>) {
+    use futures::TryStreamExt;
+
+    let batches: Vec<RecordBatch> = stream.try_collect().await.unwrap();
+    let sizes = batches.iter().map(|batch| batch.num_rows()).collect();
+    let scored = batches
+        .iter()
+        .flat_map(|batch| {
+            let row_ids = batch.column(0).as_primitive::<UInt64Type>();
+            let scores = batch.column(1).as_primitive::<Float32Type>();
+            (0..batch.num_rows())
+                .map(|i| (row_ids.value(i), scores.value(i).to_bits()))
+                .collect::<Vec<_>>()
+        })
+        .collect();
+    (sizes, scored)
+}
+
 // Legacy element-per-document corpus statistics.
 //
 // Released V1/V2 indexes indexed every `List<String>` element as its own document,
@@ -270,6 +330,7 @@ pub(super) fn combined_columns(indices: Vec<Arc<InvertedIndex>>) -> Vec<Combined
             column: format!("col{slot}"),
             weight: 1.0,
             indices: vec![index],
+            stale_rows: None,
         })
         .collect()
 }
@@ -284,7 +345,7 @@ pub(super) async fn combined_top_k(
         terms.iter().map(|t| (*t).to_owned()).collect(),
         DocType::Text,
     );
-    let scorer = build_combined_bm25_scorer(columns, &tokens, None)
+    let scorer = build_combined_bm25_scorer(columns, &tokens, CombinedCorpusStats::IndexOnly, None)
         .await
         .unwrap();
     let params = FtsSearchParams::new().with_limit(Some(limit));
diff --git a/rust/lance-index/src/scalar/inverted/index.rs b/rust/lance-index/src/scalar/inverted/index.rs
index d2b039ff07a..66d9feb8115 100644
--- a/rust/lance-index/src/scalar/inverted/index.rs
+++ b/rust/lance-index/src/scalar/inverted/index.rs
@@ -51,7 +51,7 @@ use lance_core::utils::address::RowAddress;
 use lance_core::utils::tokio::{get_num_compute_intensive_cpus, spawn_cpu};
 use lance_core::utils::tracing::{IO_TYPE_LOAD_SCALAR_PART, TRACE_IO_EVENTS};
 use lance_core::{Error, ROW_ID, ROW_ID_FIELD, Result};
-use lance_select::{RowAddrMask, RowAddrTreeMap};
+use lance_select::{RowAddrMask, RowAddrTreeMap, RowSetOps};
 use roaring::{RoaringBitmap, RoaringTreemap};
 use std::sync::LazyLock;
 use tokio::{
@@ -68,7 +68,9 @@ use super::encoding::{MAX_POSTING_BLOCK_SIZE, PositionBlockBuilder};
 use super::impact::{IMPACT_LEVEL1_BLOCKS, ImpactSkipData, ImpactSkipDataBuilder};
 use super::iter::PostingListIterator;
 use super::tokenizer::{LEGACY_BLOCK_SIZE, validate_block_size};
-use super::{DocumentGranularity, InvertedIndexBuilder, InvertedIndexParams, wand::*};
+use super::{
+    DocumentGranularity, FlatFieldStats, InvertedIndexBuilder, InvertedIndexParams, wand::*,
+};
 use super::{
     builder::{
         BLOCK_SIZE, ScoredDoc, doc_file_path,
diff --git a/rust/lance-index/src/scalar/inverted/index/flat_search.rs b/rust/lance-index/src/scalar/inverted/index/flat_search.rs
index 90c6946b2cc..136d202f2e6 100644
--- a/rust/lance-index/src/scalar/inverted/index/flat_search.rs
+++ b/rust/lance-index/src/scalar/inverted/index/flat_search.rs
@@ -521,6 +521,203 @@ pub(super) fn tokenize_and_count_list<ListOffset: OffsetSizeTrait>(
     Ok(())
 }
 
+/// One chunk's worth of blended per-row BM25F scoring inputs: everything a flat
+/// `combined_fields` scan retains until the corpus statistics are complete.
+/// `8 + 4·(1 + t)` bytes per row for `t` terms, independent of the column count.
+pub(in super::super) struct BlendedRows {
+    /// `_rowid` of every retained row.
+    pub(in super::super) row_ids: Vec<u64>,
+    /// `dl'(d) = Σ_f w_f · dl_f(d)`, one per retained row.
+    pub(in super::super) doc_lengths: Vec<f32>,
+    /// `tf'(t, d) = Σ_f w_f · tf_f(t, d)`, `num_terms`-strided by row.
+    pub(in super::super) term_freqs: Vec<f32>,
+}
+
+/// Count the query tokens in every target column of a flat batch stream and blend
+/// them into per-row BM25F scoring inputs, retaining a row when any column has
+/// tokens.
+///
+/// Unlike [`tokenize_and_count`], this walks all target columns in one pass,
+/// since a row may be empty in one field and populated in another. The
+/// per-column counts are dropped with each batch once blended; only the
+/// fixed-size [`FlatFieldStats`] needs them, so it is folded here, gated by
+/// `stats_masks`.
+pub(in super::super) async fn tokenize_and_blend_multi(
+    input: impl Stream<Item = DataFusionResult<RecordBatch>> + Send,
+    tokenizer: Box<dyn LanceTokenizer>,
+    query_tokens: Arc<Tokens>,
+    doc_col_indices: Arc<Vec<usize>>,
+    weights: Arc<Vec<f32>>,
+    stats_masks: Arc<Vec<Arc<RowAddrMask>>>,
+    elapsed_compute: Option<Time>,
+) -> DataFusionResult<(Vec<BlendedRows>, FlatFieldStats)> {
+    let num_columns = doc_col_indices.len();
+    let num_terms = query_tokens.len();
+    let retained_bytes_per_row = (size_of::<u64>() + (1 + num_terms) * size_of::<f32>()) as u64;
+    let query_token_indices = Arc::new(query_token_indices(query_tokens.as_ref()));
+    let bytes_accumulated = Arc::new(AtomicU64::new(0));
+    let bytes_warning_emitted = Arc::new(AtomicBool::new(false));
+
+    let tasks = input
+        .map(move |batch| {
+            let mut tokenizer = tokenizer.box_clone();
+            let query_token_indices = query_token_indices.clone();
+            let doc_col_indices = doc_col_indices.clone();
+            let weights = weights.clone();
+            let stats_masks = stats_masks.clone();
+            let bytes_accumulated = bytes_accumulated.clone();
+            let bytes_warning_emitted = bytes_warning_emitted.clone();
+            let elapsed_compute = elapsed_compute.clone();
+            spawn_cpu(move || {
+                let start = std::time::Instant::now();
+                let batch = batch?;
+                let num_rows = batch.num_rows();
+                let row_id_array = batch[ROW_ID].as_primitive::<UInt64Type>();
+
+                // Dense `(row, column)`-strided scratch, freed with the batch:
+                // whether a row is retained depends on all of its columns, so every
+                // column is counted before any row is filtered.
+                let mut all_tokens = vec![0u64; num_rows * num_columns];
+                let mut counts = vec![0u64; num_rows * num_columns * num_terms];
+                for (column_slot, doc_col_idx) in doc_col_indices.iter().enumerate() {
+                    count_column_into(
+                        batch.column(*doc_col_idx),
+                        num_columns,
+                        num_terms,
+                        column_slot,
+                        &mut tokenizer,
+                        &query_token_indices,
+                        &mut all_tokens,
+                        &mut counts,
+                    )?;
+                }
+
+                let mut blended = BlendedRows {
+                    row_ids: Vec::with_capacity(num_rows),
+                    doc_lengths: Vec::with_capacity(num_rows),
+                    term_freqs: Vec::with_capacity(num_rows * num_terms),
+                };
+                let mut stats = FlatFieldStats::zeros(num_columns, num_terms);
+                let counts_stride = num_columns * num_terms;
+                for row in 0..num_rows {
+                    let lengths = &all_tokens[row * num_columns..(row + 1) * num_columns];
+                    // Empty in every target column: `dl' == 0` and `tf' == 0`, so the
+                    // row cannot score. Dropping it here also keeps it out of the
+                    // corpus statistics, matching the indexed side (a row absent from
+                    // every field's DocSet contributes to no `docCount_f`).
+                    if lengths.iter().all(|length| *length == 0) {
+                        continue;
+                    }
+                    let row_id = row_id_array.value(row);
+                    let row_counts = &counts[row * counts_stride..(row + 1) * counts_stride];
+
+                    // Accumulate in column-slot order. f32 addition is not
+                    // associative, so this order is part of the contract: it keeps
+                    // the scores identical to summing the same contributions
+                    // downstream from a materialized breakdown.
+                    let terms_start = blended.term_freqs.len();
+                    blended.term_freqs.resize(terms_start + num_terms, 0.0);
+                    let term_freqs = &mut blended.term_freqs[terms_start..];
+                    let mut doc_length = 0f32;
+                    for (column, weight) in weights.iter().enumerate() {
+                        doc_length += weight * lengths[column] as f32;
+                        let base = column * num_terms;
+                        for (term, tf) in term_freqs.iter_mut().enumerate() {
+                            *tf += weight * row_counts[base + term] as f32;
+                        }
+                    }
+                    blended.row_ids.push(row_id);
+                    blended.doc_lengths.push(doc_length);
+
+                    stats.fold_row(row_id, &stats_masks, lengths, row_counts);
+                }
+
+                let bytes_accumulated = bytes_accumulated.fetch_add(
+                    blended.row_ids.len() as u64 * retained_bytes_per_row,
+                    Ordering::Relaxed,
+                );
+                if bytes_accumulated > BYTES_ACCUMULATED_WARNING_THRESHOLD
+                    && !bytes_warning_emitted.swap(true, Ordering::Relaxed)
+                {
+                    tracing::warn!(
+                        "Flat combined_fields search is accumulating a large number of bytes.  Consider indexing every target column instead."
+                    );
+                }
+                if let Some(t) = &elapsed_compute {
+                    t.add_duration(start.elapsed());
+                }
+                DataFusionResult::Ok((blended, stats))
+            })
+        })
+        .buffered(get_num_compute_intensive_cpus());
+
+    // Folded incrementally rather than collected and concatenated: the retained
+    // rows are already the whole accumulation, so a second contiguous copy would
+    // double the peak for nothing.
+    let mut tasks = std::pin::pin!(tasks);
+    let mut chunks = Vec::new();
+    // Seeded rather than taken from the first batch so that a scan with no batches
+    // at all still reports statistics, as all-zero totals.
+    let mut totals = FlatFieldStats::zeros(num_columns, num_terms);
+    while let Some(counted) = tasks.next().await {
+        let (blended, stats) = counted?;
+        totals.merge(stats);
+        chunks.push(blended);
+    }
+    Ok((chunks, totals))
+}
+
+/// Tokenize one column into the `(row, column_slot)`-strided slots of
+/// `all_tokens` / `counts`. Mirrors [`tokenize_and_count`]'s per-type handling: a
+/// list column sums over its elements and a null leaves the slots at zero.
+#[allow(clippy::too_many_arguments)]
+fn count_column_into(
+    doc_col: &ArrayRef,
+    num_columns: usize,
+    num_terms: usize,
+    column_slot: usize,
+    tokenizer: &mut Box<dyn LanceTokenizer>,
+    query_token_indices: &HashMap<String, Vec<usize>>,
+    all_tokens: &mut [u64],
+    counts: &mut [u64],
+) -> DataFusionResult<()> {
+    let mut record = |row: usize, doc: &str| {
+        let slot = row * num_columns + column_slot;
+        let base = slot * num_terms;
+        let mut stream = tokenizer.token_stream_for_doc(doc);
+        while let Some(token) = stream.next() {
+            all_tokens[slot] += 1;
+            if let Some(token_indices) = query_token_indices.get(&token.text) {
+                for token_index in token_indices {
+                    counts[base + *token_index] += 1;
+                }
+            }
+        }
+    };
+    match doc_col.data_type() {
+        DataType::Utf8 | DataType::LargeUtf8 => {
+            for (row, doc) in iter_str_array(doc_col.as_ref()).enumerate() {
+                if let Some(doc) = doc {
+                    record(row, doc);
+                }
+            }
+        }
+        // One string per row is the whole contract: a caller whose field path
+        // crosses a `List` owes a column already reduced to a row's document text
+        // (the planner uses `flatten_fts_document_column`), because reducing it
+        // here would count the elements separately and diverge from the single row
+        // document the index builder wrote.
+        data_type => {
+            return Err(datafusion_common::DataFusionError::Execution(format!(
+                "flat combined_fields search needs one string per row per column, got {}; \
+                 reduce a list-bearing field path to its row document first",
+                data_type
+            )));
+        }
+    }
+    Ok(())
+}
+
 pub(super) fn query_token_indices(query_tokens: &Tokens) -> HashMap<String, Vec<usize>> {
     let mut indices = HashMap::new();
     for idx in 0..query_tokens.len() {
@@ -948,13 +1145,7 @@ pub async fn flat_bm25_search_stream_with_options_and_scorer(
     )?;
 
     // Finally we emit batches according to the target batch size
-    let num_out_batches = scores.num_rows().div_ceil(target_batch_size);
-    let mut batches = Vec::with_capacity(num_out_batches);
-    for i in 0..num_out_batches {
-        let start = i * target_batch_size;
-        let len = (scores.num_rows() - start).min(target_batch_size);
-        batches.push(Ok(scores.slice(start, len)));
-    }
+    let batches = slice_into_batches(scores, target_batch_size);
     if let Some(t) = &elapsed_compute {
         t.add_duration(post_await_start.elapsed());
     }
@@ -967,6 +1158,23 @@ pub async fn flat_bm25_search_stream_with_options_and_scorer(
     ))
 }
 
+/// Cut one scored batch into the `target_batch_size` chunks a flat FTS scan
+/// emits. Slicing is zero-copy, so the whole scan's scores stay in one
+/// allocation.
+pub(in super::super) fn slice_into_batches(
+    batch: RecordBatch,
+    target_batch_size: usize,
+) -> Vec<DataFusionResult<RecordBatch>> {
+    let num_out_batches = batch.num_rows().div_ceil(target_batch_size);
+    let mut batches = Vec::with_capacity(num_out_batches);
+    for i in 0..num_out_batches {
+        let start = i * target_batch_size;
+        let len = (batch.num_rows() - start).min(target_batch_size);
+        batches.push(Ok(batch.slice(start, len)));
+    }
+    batches
+}
+
 pub fn is_phrase_query(query: &str) -> bool {
     phrase_query_text(query).is_some()
 }
diff --git a/rust/lance-index/src/scalar/inverted/index/partition.rs b/rust/lance-index/src/scalar/inverted/index/partition.rs
index 057d3ec2824..1f7c66f584b 100644
--- a/rust/lance-index/src/scalar/inverted/index/partition.rs
+++ b/rust/lance-index/src/scalar/inverted/index/partition.rs
@@ -742,6 +742,64 @@ impl InvertedPartition {
         Ok((num_rows, row_freqs))
     }
 
+    /// This partition's share of `stale_rows`, counted the same way
+    /// [`Self::row_stats_for_terms`] counts the whole partition, so the caller can
+    /// subtract one from the other.
+    ///
+    /// Rows this partition holds no document for are skipped, so it is fine to pass
+    /// rows that live elsewhere.
+    pub(super) async fn stale_row_stats_for_terms(
+        &self,
+        terms: &[String],
+        stale_rows: &RowAddrTreeMap,
+        metrics: Option<&dyn MetricsCollector>,
+    ) -> Result<(u64, usize, Vec<usize>)> {
+        let mut row_freqs = vec![0usize; terms.len()];
+        let Some(addresses) = stale_rows.row_addrs() else {
+            // A whole-fragment marker names no row to look up in a posting list.
+            return Err(Error::invalid_input(
+                "FTS corpus statistics cannot subtract overlay-stale rows named by whole fragments"
+                    .to_string(),
+            ));
+        };
+        let docs = self.docs.address_keyed().await?;
+        let mut total_tokens = 0u64;
+        let mut stale = RoaringTreemap::new();
+        for address in addresses {
+            let address = u64::from(address);
+            let doc_length = docs.doc_length_at(address);
+            if doc_length == 0 {
+                continue;
+            }
+            total_tokens += doc_length;
+            stale.insert(address);
+        }
+        if stale.is_empty() {
+            return Ok((0, 0, row_freqs));
+        }
+        let is_legacy = self.is_legacy();
+        for (slot, term) in terms.iter().enumerate() {
+            let Some(token_id) = self.tokens.get(term) else {
+                continue;
+            };
+            // Whether a row held the term before the overlay is only visible in the
+            // posting list itself, so this reads it rather than taking the
+            // `posting_len_for_token` count the unrestricted path uses.
+            let posting = self
+                .inverted_list
+                .posting_list(token_id, false, metrics.unwrap_or(&NoOpMetricsCollector))
+                .await?;
+            let mut rows = RoaringTreemap::new();
+            for (row_id, _) in live_posting_rows(&posting, &docs, is_legacy) {
+                if stale.contains(row_id) {
+                    rows.insert(row_id);
+                }
+            }
+            row_freqs[slot] = rows.len() as usize;
+        }
+        Ok((total_tokens, stale.len() as usize, row_freqs))
+    }
+
     pub async fn load(
         store: Arc<dyn IndexStore>,
         id: u64,
diff --git a/rust/lance-index/src/scalar/inverted/index/search.rs b/rust/lance-index/src/scalar/inverted/index/search.rs
index be3bd144ecd..db5f640cb27 100644
--- a/rust/lance-index/src/scalar/inverted/index/search.rs
+++ b/rust/lance-index/src/scalar/inverted/index/search.rs
@@ -205,6 +205,76 @@ impl InvertedIndex {
     /// statistics trigger, so both granularities report comparable
     /// `index_cache_hits`/`index_cache_misses`.
     pub async fn bm25_row_stats_for_terms(
+        &self,
+        terms: &[String],
+        stale_rows: Option<&RowAddrTreeMap>,
+        metrics: Option<&dyn MetricsCollector>,
+    ) -> Result<(u64, usize, Vec<usize>)> {
+        let base = self.bm25_row_stats_for_terms_unrestricted(terms, metrics);
+        let Some(stale_rows) = stale_rows.filter(|rows| !rows.is_empty()) else {
+            return base.await;
+        };
+        let (total_tokens, num_rows, mut row_freqs) = base.await?;
+        let (stale_tokens, stale_num_rows, stale_freqs) = self
+            .stale_row_stats_for_terms(terms, stale_rows, metrics)
+            .await?;
+        for (total, stale) in row_freqs.iter_mut().zip(stale_freqs) {
+            *total = total.saturating_sub(stale);
+        }
+        Ok((
+            total_tokens.saturating_sub(stale_tokens),
+            num_rows.saturating_sub(stale_num_rows),
+            row_freqs,
+        ))
+    }
+
+    /// What the rows an overlay made stale still contribute to this index's
+    /// statistics, for the caller to subtract.
+    ///
+    /// The index holds their pre-overlay values until it is optimized, and the flat
+    /// scan folds in their current ones. Counting both inflates `docCount` and
+    /// `docFreq`, which is enough to reorder results after an overlay that changed
+    /// no searchable value.
+    async fn stale_row_stats_for_terms(
+        &self,
+        terms: &[String],
+        stale_rows: &RowAddrTreeMap,
+        metrics: Option<&dyn MetricsCollector>,
+    ) -> Result<(u64, usize, Vec<usize>)> {
+        let io_parallelism = self.store.io_parallelism();
+        let futures = self
+            .partitions
+            .iter()
+            .map(|partition| {
+                let partition = partition.clone();
+                async move {
+                    partition
+                        .stale_row_stats_for_terms(terms, stale_rows, metrics)
+                        .await
+                }
+            })
+            .collect::<Vec<_>>();
+        let per_partition: Vec<(u64, usize, Vec<usize>)> = stream::iter(futures)
+            .buffer_unordered(io_parallelism)
+            .try_collect()
+            .await?;
+
+        let mut total_tokens = 0u64;
+        let mut num_rows = 0usize;
+        let mut row_freqs = vec![0usize; terms.len()];
+        // Partitions hold disjoint row sets, so a row lands in at most one of these.
+        for (partition_tokens, partition_rows, partition_freqs) in per_partition {
+            total_tokens += partition_tokens;
+            num_rows += partition_rows;
+            for (total, partition_freq) in row_freqs.iter_mut().zip(partition_freqs) {
+                *total += partition_freq;
+            }
+        }
+        Ok((total_tokens, num_rows, row_freqs))
+    }
+
+    /// [`Self::bm25_row_stats_for_terms`] with nothing subtracted.
+    async fn bm25_row_stats_for_terms_unrestricted(
         &self,
         terms: &[String],
         metrics: Option<&dyn MetricsCollector>,
diff --git a/rust/lance-index/src/scalar/inverted/index/tests/stats.rs b/rust/lance-index/src/scalar/inverted/index/tests/stats.rs
index 7c23d2c4337..e5ec2f558ba 100644
--- a/rust/lance-index/src/scalar/inverted/index/tests/stats.rs
+++ b/rust/lance-index/src/scalar/inverted/index/tests/stats.rs
@@ -358,7 +358,10 @@ async fn test_bm25_row_stats_for_terms_keeps_the_lazy_posting_metadata_path() {
     assert_eq!(metadata_rows, 1);
 
     assert_eq!(
-        index.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+        index
+            .bm25_row_stats_for_terms(&terms, None, None)
+            .await
+            .unwrap(),
         documents,
         "one document per row leaves the two granularities identical",
     );
@@ -427,7 +430,7 @@ async fn test_bm25_row_stats_for_terms_records_metadata_cache_stats() {
     let terms = ["t0".to_string(), "t1".to_string(), "t2".to_string()];
     let cold = LocalMetricsCollector::default();
     let cold_stats = index
-        .bm25_row_stats_for_terms(&terms, Some(&cold))
+        .bm25_row_stats_for_terms(&terms, None, Some(&cold))
         .await
         .unwrap();
     assert_eq!(cold_stats, (100, 100, vec![1, 1, 1]));
@@ -437,7 +440,7 @@ async fn test_bm25_row_stats_for_terms_records_metadata_cache_stats() {
     let warm = LocalMetricsCollector::default();
     assert_eq!(
         index
-            .bm25_row_stats_for_terms(&terms, Some(&warm))
+            .bm25_row_stats_for_terms(&terms, None, Some(&warm))
             .await
             .unwrap(),
         cold_stats,
diff --git a/rust/lance/src/dataset/scanner.rs b/rust/lance/src/dataset/scanner.rs
index c81afb9b663..8f97287d08c 100644
--- a/rust/lance/src/dataset/scanner.rs
+++ b/rust/lance/src/dataset/scanner.rs
@@ -115,8 +115,9 @@ use crate::io::exec::filtered_read::{
 };
 use crate::io::exec::fts::{
     BoostQueryExec, CombinedFieldsQueryExec, CompoundQueryExec, CrossColumnCompoundQueryExec,
-    FlatMatchFilterExec, FlatMatchQueryExec, FtsDocumentExec, HybridCompoundQueryExec,
-    MatchQueryExec, PhraseQueryExec, SharedFtsScorer,
+    FlatCombinedFieldsExec, FlatMatchFilterExec, FlatMatchQueryExec, FlatStatsCoverage,
+    FlatStatsScope, FtsDocumentExec, HybridCompoundQueryExec, MatchQueryExec, PhraseQueryExec,
+    SharedFtsScorer,
 };
 use crate::io::exec::knn::MultivectorScoringExec;
 use crate::io::exec::scalar_index::{MaterializeIndexExec, ScalarIndexExec};
@@ -173,6 +174,18 @@ enum FtsOverlayPlan {
     FullScan,
 }
 
+/// How a `combined_fields` flat scan gets its rows and which of them it emits.
+enum FlatScanFilter<'a> {
+    /// Push the filter into the scan. Its statistics then describe only the rows
+    /// that survive, which is what the index already reports for everything else.
+    PushDown(&'a ExprFilterPlan),
+    /// Read unfiltered and pick emitted rows with this prefilter, as the indexed
+    /// side does. Needed once a stale row folds: with the filter on the scan, a
+    /// folded row's contribution would depend on the filter, so a same-value
+    /// overlay would move the corpus and with it the ranking.
+    AtEmission(PreFilterSource),
+}
+
 fn collect_fts_columns_in_order(query: &FtsQuery) -> Vec<String> {
     fn visit(query: &FtsQuery, columns: &mut Vec<String>, seen: &mut HashSet<String>) {
         match query {
@@ -5219,7 +5232,7 @@ impl Scanner {
                 Arc::new(SortExec::new(sort_exprs.into(), fts_node).with_fetch(params.limit))
             }
             FtsQuery::CombinedFields(query) => {
-                self.plan_combined_fields_query(query, params, prefilter_source)
+                self.plan_combined_fields_query(query, params, filter_plan, prefilter_source)
                     .await?
             }
             FtsQuery::Boolean(query) => {
@@ -5776,12 +5789,14 @@ impl Scanner {
     /// overlay made stale, per target column, so the indexed scan neither returns a
     /// pre-overlay hit nor hides a new one. See [`Self::fts_overlay_plan`].
     ///
-    /// A fragment any target column's index does not fully cover cannot be scored,
-    /// so the query is refused rather than answered from partial statistics.
+    /// Those fragments are routed to [`FlatCombinedFieldsExec`] instead, and the
+    /// two sides are unioned and re-sorted by score, mirroring
+    /// [`Self::plan_match_query`].
     async fn plan_combined_fields_query(
         &self,
         query: &CombinedFieldsQuery,
         params: &FtsSearchParams,
+        filter_plan: &ExprFilterPlan,
         prefilter_source: &PreFilterSource,
     ) -> Result<Arc<dyn ExecutionPlan>> {
         let target_fragments: &[Fragment] = self
@@ -5798,8 +5813,12 @@ impl Scanner {
             ))));
         }
 
+        // Kept per column; see `FlatStatsCoverage`.
+        let mut per_column_coverage = Vec::with_capacity(query.column_names().len());
         let mut uncovered = RoaringBitmap::new();
         let mut any_indexed = false;
+        let mut any_overlay_stale = false;
+        let mut needs_whole_corpus = false;
         for column in query.column_names() {
             let column_uncovered: RoaringBitmap = match self
                 .dataset
@@ -5827,14 +5846,18 @@ impl Scanner {
                     .collect(),
             };
 
-            // Fragments this column's index holds documents for, but whose entries a
-            // newer data overlay made stale. The index cannot score them from its own
-            // statistics, so they count as uncovered.
+            // Fragments this column's index does hold documents for, but whose entries
+            // a newer data overlay made stale. They join the union so the indexed scan
+            // skips them and the flat sibling re-reads their current values, and the
+            // stale rows themselves also join this column's fold so a term the overlay
+            // introduced reaches `docFreq_f`.
             //
-            // Coverage is decided per fragment, not per row: a BM25F score needs every
-            // target column's `tf_f`/`dl_f`, so a row must be scored wholly from the
-            // index or not at all, and the fragment is the granularity the indexed
-            // scan's prefilter restriction works at.
+            // `plan_match_query` blocks the individual stale row addresses and takes
+            // them back on the flat side. BM25F cannot: a row's score needs every
+            // target column's `tf_f`/`dl_f`, so a row is scored on exactly one side,
+            // and the side is chosen per fragment because that is the granularity the
+            // indexed scan's prefilter restriction works at.
+            let mut column_stale_rows = RowAddrTreeMap::new();
             match self
                 .fts_overlay_plan(column, DocumentGranularity::Row, target_fragments)
                 .await?
@@ -5842,15 +5865,23 @@ impl Scanner {
                 FtsOverlayPlan::Unchanged(_) => {}
                 FtsOverlayPlan::RowLevel { stale_rows, .. } => {
                     uncovered.extend(stale_rows.keys().copied());
+                    column_stale_rows = self.stale_rows_in_id_domain(&stale_rows).await?;
+                    any_overlay_stale = true;
                 }
                 // A legacy segment reports no fragment coverage, so no target fragment
                 // can be proven free of stale entries and no row can be named as one.
                 FtsOverlayPlan::FullScan => {
                     uncovered.extend(target_fragments.iter().map(|fragment| fragment.id as u32));
+                    needs_whole_corpus = true;
+                    any_overlay_stale = true;
                 }
             }
 
             uncovered |= &column_uncovered;
+            per_column_coverage.push(FlatStatsCoverage {
+                fragments: column_uncovered,
+                stale_rows: Arc::new(column_stale_rows),
+            });
         }
 
         // BM25F needs one shared tokenizer configuration across the target columns
@@ -5928,22 +5959,156 @@ impl Scanner {
             return Ok(index_exec(Some(covered), None));
         }
 
-        // The flat scan that would score the rows no index covers is not part of
-        // this change, so a partial plan would silently drop them. Refuse instead,
-        // and name what is missing.
-        Err(Error::invalid_input(format!(
-            "combined_fields requires every target column to be indexed over every \
-             scanned fragment, but {} of {} fragments are not fully covered. Optimize \
-             the indexes on {} and retry.",
-            uncovered_fragments.len(),
-            target_fragments.len(),
-            query
-                .columns()
-                .iter()
-                .cloned()
-                .collect::<Vec<_>>()
-                .join(", "),
-        )))
+        // A legacy segment names no stale rows, so nothing can be folded on top of the
+        // index and the corpus has to be re-measured from every target fragment. That
+        // is a full scan, so it stays confined to that case.
+        let (flat_fragments, stats_scope) = if needs_whole_corpus {
+            (target_fragments.to_vec(), FlatStatsScope::WholeCorpus)
+        } else {
+            (
+                uncovered_fragments,
+                FlatStatsScope::PerColumn(per_column_coverage),
+            )
+        };
+        // Reading unfiltered costs the flat side its pushdown, so it is confined to
+        // the scans that fold a stale row (see `FlatScanFilter::AtEmission`).
+        //
+        // The emission prefilter is built over the fragments this scan reads, not
+        // reused from the indexed child. `prefilter_source` spans the fragments the
+        // target columns' indexes cover, so it names no row in an unindexed fragment,
+        // and an allow-list can only be narrowed afterwards
+        // (`build_prefilter_restricted_to_fragments`), never widened. Reusing it would
+        // drop every match an unindexed fragment holds as soon as an overlay routes
+        // the scan onto this path.
+        let scan_filter = if any_overlay_stale {
+            let flat_prefilter = self
+                .prefilter_source(
+                    filter_plan,
+                    flat_fragments
+                        .iter()
+                        .map(|fragment| fragment.id as u32)
+                        .collect(),
+                )
+                .await?;
+            FlatScanFilter::AtEmission(flat_prefilter)
+        } else {
+            FlatScanFilter::PushDown(filter_plan)
+        };
+        // Only a plan with both children needs the two to agree on a corpus, and a
+        // whole-corpus scan leaves no fragment for an indexed child.
+        let is_mixed = !needs_whole_corpus && flat_fragments.len() != target_fragments.len();
+        let shared_scorer = is_mixed.then(|| Arc::new(SharedFtsScorer::new()));
+        let flat_plan = self
+            .plan_flat_combined_fields_query(
+                flat_fragments,
+                stats_scope,
+                scan_filter,
+                query,
+                params,
+                shared_scorer.clone(),
+            )
+            .await?;
+        // The flat exec emits in scan order and applies no limit, so even with no
+        // index child the plan still needs the score sort and top-k fetch.
+        let scored_plan = if !is_mixed {
+            flat_plan
+        } else {
+            let union =
+                UnionExec::try_new(vec![index_exec(Some(covered), shared_scorer), flat_plan])?;
+            Arc::new(RepartitionExec::try_new(
+                union,
+                Partitioning::RoundRobinBatch(1),
+            )?)
+        };
+        Ok(Arc::new(
+            SortExec::new(
+                Self::fts_score_sort_exprs(scored_plan.schema().as_ref())?.into(),
+                scored_plan,
+            )
+            .with_fetch(params.limit),
+        ))
+    }
+
+    /// Plan the flat (unindexed) side of a `combined_fields` query: one scan over
+    /// `fragments` projecting every target column, scored as one virtual field.
+    ///
+    /// Emits in scan order with no limit applied; the caller supplies the score
+    /// sort and top-k fetch.
+    async fn plan_flat_combined_fields_query(
+        &self,
+        fragments: Vec<Fragment>,
+        stats_scope: FlatStatsScope,
+        scan_filter: FlatScanFilter<'_>,
+        query: &CombinedFieldsQuery,
+        params: &FtsSearchParams,
+        shared_scorer: Option<Arc<SharedFtsScorer<CombinedFieldsBM25Scorer>>>,
+    ) -> Result<Arc<dyn ExecutionPlan>> {
+        let unfiltered = ExprFilterPlan::default();
+        let (filter_plan, emit_prefilter) = match scan_filter {
+            FlatScanFilter::PushDown(filter_plan) => (filter_plan, None),
+            FlatScanFilter::AtEmission(prefilter) => (&unfiltered, Some(prefilter)),
+        };
+        // A path that continues past a `List` is not addressable by a projection,
+        // so such a column is scanned through its list root and walked down to the
+        // leaf by `FlatCombinedFieldsExec`, exactly as `plan_flat_match_query`
+        // does for a single column.
+        let resolved_fields = query
+            .column_names()
+            .map(|column| {
+                resolve_fts_field(self.dataset.schema(), column, DocumentGranularity::Row)
+            })
+            .collect::<Result<Vec<_>>>()?;
+        let columns = resolved_fields
+            .iter()
+            .map(|resolved| {
+                if resolved.has_lists() {
+                    resolved.root_column.clone()
+                } else {
+                    resolved.canonical_path.clone()
+                }
+            })
+            .collect::<Vec<_>>();
+        let scanned_fragments: RoaringBitmap = fragments
+            .iter()
+            .map(|fragment| fragment.id as u32)
+            .collect();
+        let mut plan = self
+            .plan_uncovered_rows_scan(fragments, HashMap::new(), columns, filter_plan)
+            .await?;
+        // A nested target column needs a flat alias so the exec can resolve it by
+        // name in the batch schema. A list-bearing one gets its flat column from
+        // the exec instead, since no projection can produce it.
+        for (column, resolved) in query.column_names().zip(&resolved_fields) {
+            if !resolved.has_lists() {
+                plan = self.ensure_column_alias(plan, column)?;
+            }
+        }
+
+        let mut flat_plan = FlatCombinedFieldsExec::try_new(
+            self.dataset.clone(),
+            query.clone(),
+            params.clone(),
+            plan,
+            scanned_fragments,
+            resolved_fields,
+            stats_scope,
+        )?;
+        if let Some(prefilter) = emit_prefilter {
+            flat_plan = flat_plan.with_emit_prefilter(prefilter);
+        }
+        if let Some(shared_scorer) = shared_scorer {
+            flat_plan = flat_plan.with_shared_scorer(shared_scorer);
+        }
+        let flat_plan: Arc<dyn ExecutionPlan> = Arc::new(flat_plan);
+        // The rows this side scores never reach an index-side prefilter, so the
+        // external row-address mask is applied to its output here, as the flat
+        // MatchQuery branch does. It restricts what is emitted, not the corpus the
+        // scores are computed against, so both children of a mixed plan keep
+        // scoring against the same statistics.
+        if let Some(mask) = self.external_row_mask.clone() {
+            return Ok(Arc::new(RowAddrMaskFilterExec::new(flat_plan, mask)));
+        }
+        Ok(flat_plan)
     }
 
     // ANN/KNN search execution node with optional prefilter
diff --git a/rust/lance/src/index/scalar/inverted.rs b/rust/lance/src/index/scalar/inverted.rs
index 19be788e908..f8591fd2074 100644
--- a/rust/lance/src/index/scalar/inverted.rs
+++ b/rust/lance/src/index/scalar/inverted.rs
@@ -734,6 +734,71 @@ pub(crate) fn fts_document_schema(coordinate_rank: usize) -> Arc<ArrowSchema> {
     Arc::new(ArrowSchema::new(fields))
 }
 
+/// Add (or replace) a flat `Utf8` column holding each row's document text for a
+/// list-bearing FTS field path, leaving every other column and row untouched.
+///
+/// A Lance projection cannot address a field that continues past a `List`, so a
+/// scan that needs `docs.content` has to project the `docs` root instead. This
+/// walks the traversal down to the leaf per row, joining the elements exactly the
+/// way the index builder does at row granularity.
+///
+/// Row granularity yields one document per input row, in row order, keeping several
+/// such columns aligned for a cross-field blend. Not valid for list-element
+/// granularity, where a row expands to several documents.
+pub(crate) fn flatten_fts_document_column(
+    input: SendableRecordBatchStream,
+    resolved: ResolvedFtsField,
+) -> Result<SendableRecordBatchStream> {
+    if resolved.document_granularity.is_list_element() {
+        return Err(Error::internal(
+            "flatten_fts_document_column needs row documents to keep one output row per input row"
+                .to_string(),
+        ));
+    }
+    let input_schema = input.schema();
+    if input_schema
+        .column_with_name(&resolved.root_column)
+        .is_none()
+    {
+        return Err(Error::internal(format!(
+            "FTS document input must contain the root source column '{}'",
+            resolved.root_column
+        )));
+    }
+    let text_field = ArrowField::new(&resolved.canonical_path, DataType::Utf8, false);
+    let replaced = input_schema.column_with_name(&resolved.canonical_path);
+    let mut fields = input_schema.fields().to_vec();
+    match replaced {
+        Some((index, _)) => fields[index] = Arc::new(text_field),
+        None => fields.push(Arc::new(text_field)),
+    }
+    let replaced = replaced.map(|(index, _)| index);
+    let output_schema = Arc::new(ArrowSchema::new(fields));
+    let stream_schema = output_schema.clone();
+    let stream = input.map(move |batch| {
+        let batch = batch?;
+        let source = batch
+            .column_by_name(&resolved.root_column)
+            .expect("FTS document input schema was validated");
+        let documents = resolved
+            .documents_from_array(source, batch.num_rows())
+            .map_err(DataFusionError::from)?;
+        let texts = Arc::new(StringArray::from_iter_values(
+            documents.iter().map(|document| document.text.as_str()),
+        )) as ArrayRef;
+        let mut columns = batch.columns().to_vec();
+        match replaced {
+            Some(index) => columns[index] = texts,
+            None => columns.push(texts),
+        }
+        RecordBatch::try_new(stream_schema.clone(), columns).map_err(DataFusionError::from)
+    });
+    Ok(Box::pin(RecordBatchStreamAdapter::new(
+        output_schema,
+        stream,
+    )))
+}
+
 pub(crate) fn transform_fts_document_stream(
     input: SendableRecordBatchStream,
     resolved: ResolvedFtsField,
diff --git a/rust/lance/src/io/exec/fts.rs b/rust/lance/src/io/exec/fts.rs
index 38f40e9dc44..fe7d7d8b0ae 100644
--- a/rust/lance/src/io/exec/fts.rs
+++ b/rust/lance/src/io/exec/fts.rs
@@ -45,9 +45,10 @@ use super::utils::{
     IndexMetrics, PreFilterMasks, build_prefilter, build_prefilter_restricted_to_fragments,
 };
 use crate::dataset::mem_wal::index::{QueryLocalFtsIndex, QueryLocalFtsStats};
+use crate::index::prefilter::DatasetPreFilter;
 use crate::index::scalar::inverted::{
-    ResolvedFtsField, fts_document_schema, load_segment_details, load_segments,
-    transform_fts_document_stream,
+    ResolvedFtsField, flatten_fts_document_column, fts_document_schema, load_segment_details,
+    load_segments, transform_fts_document_stream,
 };
 use crate::{Dataset, index::DatasetIndexInternalExt};
 use lance_index::metrics::MetricsCollector;
@@ -60,15 +61,17 @@ use lance_index::scalar::inverted::query::{
 };
 use lance_index::scalar::inverted::tokenizer::document_tokenizer::TextTokenizer;
 use lance_index::scalar::inverted::{
-    CombinedFieldColumn, CombinedFieldsBM25Scorer, DOC_INDEX_COL, DocumentGranularity, FTS_SCHEMA,
-    FlatBm25SearchOptions, InvertedIndex, MemBM25Scorer, PreparedBm25Query, SCORE_COL, Scorer,
-    build_combined_bm25_scorer, build_global_bm25_scorer, combined_fields_search, compound_search,
-    compound_search_prepared_match, compound_search_prepared_match_with_score_floor,
-    compound_search_with_base_scorer, cross_column_compound_search, exclusive_scaled_score_floor,
-    flat_bm25_search_stream_with_options_and_scorer, fts_schema, materialized_compound_top_k,
-    prepare_bm25_query, validate_combined_tokenizers,
+    CombinedCorpusStats, CombinedFieldColumn, CombinedFieldsBM25Scorer, DOC_INDEX_COL,
+    DocumentGranularity, FTS_SCHEMA, FlatBm25SearchOptions, InvertedIndex, MemBM25Scorer,
+    PreparedBm25Query, SCORE_COL, Scorer, build_combined_bm25_scorer, build_global_bm25_scorer,
+    combined_fields_search, compound_search, compound_search_prepared_match,
+    compound_search_prepared_match_with_score_floor, compound_search_with_base_scorer,
+    cross_column_compound_search, exclusive_scaled_score_floor,
+    flat_bm25_search_stream_with_options_and_scorer, flat_combined_fields_search_stream,
+    fts_schema, materialized_compound_top_k, prepare_bm25_query, validate_combined_tokenizers,
 };
 use lance_index::{prefilter::PreFilter, scalar::inverted::query::BooleanQuery};
+use lance_select::{RowAddrTreeMap, RowSetOps};
 use lance_tokenizer::{SimpleTokenizer, TextAnalyzer};
 use tracing::instrument;
 use uuid::Uuid;
@@ -3301,13 +3304,26 @@ fn fmt_combined_fields(
     fmt_tokenized_query(tokenized_query, separator, f)
 }
 
-/// What [`open_combined_fields_scan`] hands back to the `combined_fields` exec.
+/// Which target columns of a `combined_fields` scan need an inverted index.
+#[derive(Debug, Clone, Copy)]
+enum CombinedFieldsIndexRequirement {
+    /// Every column, because the indexed side scores each of them from its
+    /// index.
+    EveryColumn,
+    /// At least one column, for the tokenizer. The flat side reads the document
+    /// text from the scan, so a column without an index only misses out on
+    /// contributing corpus statistics.
+    AtLeastOneColumn,
+}
+
+/// What [`open_combined_fields_scan`] hands back to either `combined_fields` exec.
 struct CombinedFieldsScan {
     columns: Vec<CombinedFieldColumn>,
     /// Every segment opened across all target columns, for the indexed side's
     /// prefilter.
     segments: Vec<IndexMetadata>,
     tokens: Tokens,
+    tokenizer: Box<dyn LanceTokenizer>,
 }
 
 /// Open every target column's segments, pair each with its boost, and tokenize
@@ -3321,25 +3337,37 @@ struct CombinedFieldsScan {
 /// Both sides count the opened segments toward parts searched: the flat side needs
 /// them for the tokenizer and the blended corpus statistics, the indexed side for
 /// scoring.
+///
+/// `stale_rows` is empty, or one entry per target column in query column order.
+/// See [`CombinedFieldColumn::stale_rows`].
 async fn open_combined_fields_scan(
     dataset: &Dataset,
     query: &CombinedFieldsQuery,
+    index_requirement: CombinedFieldsIndexRequirement,
+    stale_rows: &[Arc<RowAddrTreeMap>],
     tokenized_query: &OnceLock<TokenizedQuery>,
     metrics: &FtsIndexMetrics,
 ) -> DataFusionResult<CombinedFieldsScan> {
     let mut columns = Vec::with_capacity(query.column_names().len());
     let mut all_segments = Vec::new();
-    for (column, weight) in query.weighted_columns() {
-        let segments = Some(
-            FtsSegmentSelection::AllCommitted
-                .resolve(
-                    dataset,
-                    column,
-                    DocumentGranularity::Row,
-                    &metrics.segment_bind_duration,
-                )
-                .await?,
-        );
+    for (slot, (column, weight)) in query.weighted_columns().enumerate() {
+        let segments = match index_requirement {
+            CombinedFieldsIndexRequirement::EveryColumn => Some(
+                FtsSegmentSelection::AllCommitted
+                    .resolve(
+                        dataset,
+                        column,
+                        DocumentGranularity::Row,
+                        &metrics.segment_bind_duration,
+                    )
+                    .await?,
+            ),
+            CombinedFieldsIndexRequirement::AtLeastOneColumn => {
+                load_segments(dataset, column, DocumentGranularity::Row)
+                    .await?
+                    .map(Arc::from)
+            }
+        };
         let indices = match segments {
             Some(segments) => {
                 let _details = load_segment_details(dataset, column, &segments).await?;
@@ -3354,6 +3382,10 @@ async fn open_combined_fields_scan(
             column: column.to_string(),
             weight,
             indices,
+            stale_rows: stale_rows
+                .get(slot)
+                .filter(|rows| !rows.is_empty())
+                .cloned(),
         });
     }
     validate_combined_tokenizers(&columns)?;
@@ -3369,13 +3401,20 @@ async fn open_combined_fields_scan(
     let first_index = columns
         .iter()
         .find_map(|column| column.indices.first())
-        .ok_or_else(|| {
-            // Not a user error: segment resolution already failed for any column
-            // without an index, and `CombinedFieldsQuery::try_new` rejects an empty
-            // column list, so reaching this means one of those two guarantees broke.
-            DataFusionError::Internal(
+        .ok_or_else(|| match index_requirement {
+            // Not a user error: `EveryColumn` resolution already failed for any
+            // column without an index, and `CombinedFieldsQuery::try_new` rejects
+            // an empty column list, so reaching this means one of those two
+            // guarantees broke.
+            CombinedFieldsIndexRequirement::EveryColumn => DataFusionError::Internal(
                 "combined_fields query reached execution with no target columns".to_string(),
-            )
+            ),
+            CombinedFieldsIndexRequirement::AtLeastOneColumn => {
+                DataFusionError::Execution(format!(
+                    "combined_fields requires an inverted index on at least one of {:?}",
+                    query.column_names().collect::<Vec<_>>()
+                ))
+            }
         })?;
     let mut tokenizer = first_index.tokenizer();
     let tokens = try_collect_query_tokens(query.terms(), &mut tokenizer)?;
@@ -3385,6 +3424,7 @@ async fn open_combined_fields_scan(
         columns,
         segments: all_segments,
         tokens,
+        tokenizer,
     })
 }
 
@@ -3447,7 +3487,18 @@ impl ExecutionPlan for CombinedFieldsQueryExec {
                 segments: all_segments,
                 tokens,
                 ..
-            } = open_combined_fields_scan(&ds, &query, &tokenized_query, metrics.as_ref()).await?;
+            } = open_combined_fields_scan(
+                &ds,
+                &query,
+                CombinedFieldsIndexRequirement::EveryColumn,
+                // Nothing to subtract: this side either scores against index
+                // statistics alone or against the scorer the flat sibling built,
+                // and only that sibling folds a stale row in.
+                &[],
+                &tokenized_query,
+                metrics.as_ref(),
+            )
+            .await?;
 
             // With mixed coverage the planner supplies the fragments every target
             // column indexes, and the scan is restricted to exactly those: the
@@ -3490,15 +3541,22 @@ impl ExecutionPlan for CombinedFieldsQueryExec {
             }
             let scorer = match (preset_base_scorer, shared_scorer) {
                 (Some(scorer), _) => scorer,
-                // An injected scorer describes the corpus the whole plan scores
-                // against; wait for it rather than folding this side's statistics.
+                // A mixed plan routes the rows no index covers to a flat sibling,
+                // so folding only this side's index statistics here would score the
+                // two children against different `docCount'`/`docFreq'`/`avgdl'`.
+                // Wait for the blend that describes the whole scanned corpus.
                 (None, Some(shared_scorer)) => shared_scorer.wait().await?,
                 (None, None) => {
                     let scorer_start = std::time::Instant::now();
                     let scorer = Arc::new(
-                        build_combined_bm25_scorer(&columns, &tokens, Some(metrics.as_ref()))
-                            .boxed()
-                            .await?,
+                        build_combined_bm25_scorer(
+                            &columns,
+                            &tokens,
+                            CombinedCorpusStats::IndexOnly,
+                            Some(metrics.as_ref()),
+                        )
+                        .boxed()
+                        .await?,
                     );
                     metrics.record_scorer_build(scorer_start.elapsed());
                     scorer
@@ -4374,6 +4432,393 @@ impl ExecutionPlan for FlatMatchQueryExec {
     }
 }
 
+/// The rows of one target column that a flat `combined_fields` scan folds into
+/// that column's corpus statistics: the ones its index does not already count.
+///
+/// The scan reads every target column of every row it scores, but a scanned
+/// fragment can still be indexed for some of those columns. Folding such a row
+/// into that column's statistics as well would count it twice, inflating
+/// `docCount_f`, `sumTotalTermFreq_f` and `docFreq_f`.
+#[derive(Debug, Clone, Default)]
+pub struct FlatStatsCoverage {
+    /// Fragments this column's index does not cover at all.
+    pub fragments: roaring::RoaringBitmap,
+    /// Rows it does cover, but whose entries a newer overlay made stale, in the id
+    /// domain the scan's `_rowid` uses. Their current values are folded in, and
+    /// their pre-overlay values are subtracted from the index statistics (see
+    /// [`CombinedFieldColumn::stale_rows`]), so each counts once.
+    pub stale_rows: Arc<RowAddrTreeMap>,
+}
+
+/// Which corpus statistics a flat `combined_fields` scan contributes.
+#[derive(Debug, Clone)]
+pub enum FlatStatsScope {
+    /// Per target column, in query order, the rows to fold on top of that
+    /// column's index statistics.
+    PerColumn(Vec<FlatStatsCoverage>),
+    /// The scan reads every target fragment and its statistics replace the index
+    /// statistics; see [`CombinedCorpusStats::FlatOnly`].
+    WholeCorpus,
+}
+
+/// The sibling of [`CombinedFieldsQueryExec`] for the fragments that at least one
+/// target column's index is missing. Those rows cannot be scored from the indexes
+/// (`tf'`/`dl'` would omit the unindexed columns), so they are scored straight
+/// from their column values here. The two plans are unioned and re-sorted by the
+/// planner, exactly as the single-column match path does.
+///
+/// The input must carry `_rowid` plus every target column of the query.
+#[derive(Debug)]
+pub struct FlatCombinedFieldsExec {
+    dataset: Arc<Dataset>,
+    query: CombinedFieldsQuery,
+    /// Tokens `execute()` actually produced, for `analyze_plan`. Single snapshot
+    /// for the same reason as [`CombinedFieldsQueryExec::tokenized_query`].
+    tokenized_query: Arc<OnceLock<TokenizedQuery>>,
+    params: FtsSearchParams,
+    unindexed_input: Arc<dyn ExecutionPlan>,
+    /// The fragments `unindexed_input` reads.
+    scanned_fragments: roaring::RoaringBitmap,
+    /// Per target column, in query order: how `execute` turns the scanned column
+    /// into document text.
+    resolved_fields: Vec<ResolvedFtsField>,
+    stats_scope: FlatStatsScope,
+    /// See [`Self::with_emit_prefilter`].
+    emit_prefilter: Option<PreFilterSource>,
+    /// Publishes the blended scorer to an indexed sibling; see
+    /// [`Self::with_shared_scorer`].
+    shared_scorer: Option<Arc<SharedFtsScorer<CombinedFieldsBM25Scorer>>>,
+    properties: Arc<PlanProperties>,
+    metrics: ExecutionPlanMetricsSet,
+}
+
+impl DisplayAs for FlatCombinedFieldsExec {
+    fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        fmt_combined_fields(
+            "FlatCombinedFields",
+            &self.query,
+            &self.tokenized_query,
+            t,
+            f,
+        )
+    }
+}
+
+impl FlatCombinedFieldsExec {
+    /// `resolved_fields` and a [`FlatStatsScope::PerColumn`] scope must hold one
+    /// entry per target column, in query order.
+    pub(crate) fn try_new(
+        dataset: Arc<Dataset>,
+        query: CombinedFieldsQuery,
+        params: FtsSearchParams,
+        unindexed_input: Arc<dyn ExecutionPlan>,
+        scanned_fragments: roaring::RoaringBitmap,
+        resolved_fields: Vec<ResolvedFtsField>,
+        stats_scope: FlatStatsScope,
+    ) -> Result<Self> {
+        let num_columns = query.column_names().len();
+        let num_coverage = match &stats_scope {
+            FlatStatsScope::PerColumn(coverage) => coverage.len(),
+            FlatStatsScope::WholeCorpus => num_columns,
+        };
+        if resolved_fields.len() != num_columns || num_coverage != num_columns {
+            return Err(Error::internal(format!(
+                "combined_fields flat scan got {} resolved fields and {} statistics coverage \
+                 sets for {} target columns",
+                resolved_fields.len(),
+                num_coverage,
+                num_columns
+            )));
+        }
+        let properties = Arc::new(PlanProperties::new(
+            EquivalenceProperties::new(FTS_SCHEMA.clone()),
+            Partitioning::RoundRobinBatch(1),
+            EmissionType::Incremental,
+            Boundedness::Bounded,
+        ));
+        Ok(Self {
+            dataset,
+            query,
+            tokenized_query: Arc::new(OnceLock::new()),
+            params,
+            unindexed_input,
+            scanned_fragments,
+            resolved_fields,
+            stats_scope,
+            emit_prefilter: None,
+            shared_scorer: None,
+            properties,
+            metrics: ExecutionPlanMetricsSet::new(),
+        })
+    }
+
+    /// Publish the blended scorer this scan builds to an indexed sibling.
+    ///
+    /// Only this side sees the unindexed rows, so only it can produce the corpus
+    /// statistics both sides must score against.
+    pub(crate) fn with_shared_scorer(
+        mut self,
+        scorer: Arc<SharedFtsScorer<CombinedFieldsBM25Scorer>>,
+    ) -> Self {
+        self.shared_scorer = Some(scorer);
+        self
+    }
+
+    /// Select the emitted rows with `prefilter`, for a scan the planner reads
+    /// unfiltered; see `FlatScanFilter::AtEmission` in the scanner.
+    pub(crate) fn with_emit_prefilter(mut self, prefilter: PreFilterSource) -> Self {
+        self.emit_prefilter = Some(prefilter);
+        self
+    }
+}
+
+impl ExecutionPlan for FlatCombinedFieldsExec {
+    fn name(&self) -> &str {
+        "FlatCombinedFieldsExec"
+    }
+
+    fn children(&self) -> Vec<&Arc<dyn ExecutionPlan>> {
+        let mut children = vec![&self.unindexed_input];
+        children.extend(
+            self.emit_prefilter
+                .as_ref()
+                .and_then(PreFilterSource::execution_plan),
+        );
+        children
+    }
+
+    fn required_input_distribution(&self) -> Vec<Distribution> {
+        // `execute()` reads only `unindexed_input.execute(partition)` for the
+        // single output partition, so the input must be coalesced to one
+        // partition or fragments would be silently dropped. Same reasoning as
+        // `FlatMatchQueryExec`.
+        self.children()
+            .iter()
+            .map(|_| Distribution::SinglePartition)
+            .collect()
+    }
+
+    fn with_new_children(
+        self: Arc<Self>,
+        mut children: Vec<Arc<dyn ExecutionPlan>>,
+    ) -> DataFusionResult<Arc<dyn ExecutionPlan>> {
+        if children.len() != self.children().len() {
+            return Err(DataFusionError::Internal(
+                "Unexpected number of children".to_string(),
+            ));
+        }
+        // Reverse order: the optional prefilter child is last, so pop it first.
+        let emit_prefilter = match &self.emit_prefilter {
+            Some(source) if source.execution_plan().is_some() => Some(
+                source.with_execution_plan(children.pop().expect("child count checked above"))?,
+            ),
+            // A prefilter source with no child of its own leaves the input last.
+            source => source.clone(),
+        };
+        let Some(unindexed_input) = children.pop() else {
+            return Err(DataFusionError::Internal(
+                "combined_fields flat scan lost its input child".to_string(),
+            ));
+        };
+        Ok(Arc::new(Self {
+            dataset: self.dataset.clone(),
+            query: self.query.clone(),
+            tokenized_query: self.tokenized_query.clone(),
+            params: self.params.clone(),
+            unindexed_input,
+            scanned_fragments: self.scanned_fragments.clone(),
+            resolved_fields: self.resolved_fields.clone(),
+            stats_scope: self.stats_scope.clone(),
+            emit_prefilter,
+            shared_scorer: self.shared_scorer.clone(),
+            properties: self.properties.clone(),
+            metrics: ExecutionPlanMetricsSet::new(),
+        }))
+    }
+
+    #[instrument(name = "flat_combined_fields_exec", level = "debug", skip_all)]
+    fn execute(
+        &self,
+        partition: usize,
+        context: Arc<datafusion::execution::TaskContext>,
+    ) -> DataFusionResult<SendableRecordBatchStream> {
+        let query = self.query.clone();
+        let tokenized_query = self.tokenized_query.clone();
+        let ds = self.dataset.clone();
+        let stats_scope = self.stats_scope.clone();
+        let stale_rows_per_column: Vec<Arc<RowAddrTreeMap>> = match &stats_scope {
+            FlatStatsScope::PerColumn(coverage) => coverage
+                .iter()
+                .map(|coverage| coverage.stale_rows.clone())
+                .collect(),
+            FlatStatsScope::WholeCorpus => Vec::new(),
+        };
+        let emit_prefilter = self.emit_prefilter.clone();
+        let scanned_fragments = self.scanned_fragments.clone();
+        let prefilter_context = context.clone();
+        let stats_mask_ds = self.dataset.clone();
+        let metrics_set = self.metrics.clone();
+        let metrics = Arc::new(FtsIndexMetrics::new(&self.metrics, partition));
+        let metrics_clone = metrics.clone();
+        let target_batch_size = context.session_config().batch_size();
+        let elapsed_compute = metrics.baseline_metrics.elapsed_compute().clone();
+
+        let shared_scorer_producer = self.shared_scorer.clone().map(SharedFtsScorerProducer::new);
+
+        let mut input = self.unindexed_input.execute(partition, context)?;
+        for (column, resolved) in query.column_names().zip(&self.resolved_fields) {
+            // A path that continues past a `List` cannot be projected, so the scan
+            // brought its list root instead and the leaf text is derived here.
+            input = if resolved.has_lists() {
+                flatten_fts_document_column(input, resolved.clone())?
+            } else {
+                document_input(input, column)?
+            };
+        }
+
+        let stream = stream::once(async move {
+            let shared_scorer_producer = shared_scorer_producer;
+            let result = async {
+                let CombinedFieldsScan {
+                    columns,
+                    tokens,
+                    tokenizer,
+                    ..
+                } = open_combined_fields_scan(
+                    &ds,
+                    &query,
+                    CombinedFieldsIndexRequirement::AtLeastOneColumn,
+                    &stale_rows_per_column,
+                    &tokenized_query,
+                    metrics.as_ref(),
+                )
+                .await?;
+
+                let input_schema = input.schema();
+                let doc_col_indices = query
+                    .column_names()
+                    .map(|column| input_schema.index_of(column))
+                    .collect::<std::result::Result<Vec<_>, _>>()?;
+
+                // One mask per target column over the rows it may fold. Built through
+                // `create_restricted_deletion_mask` so the fragment restriction lands in
+                // the id space the scan's `_rowid` uses; a hand-rolled fragment-address
+                // allow list would match nothing under stable row ids.
+                let fragment_mask = |fragments: roaring::RoaringBitmap| {
+                    let ds = stats_mask_ds.clone();
+                    async move {
+                        match DatasetPreFilter::create_restricted_deletion_mask(ds, fragments) {
+                            Some(mask) => mask.await,
+                            None => Ok(Arc::new(RowAddrMask::all_rows())),
+                        }
+                    }
+                };
+                let stats_masks = match &stats_scope {
+                    FlatStatsScope::PerColumn(coverage) => {
+                        let mut stats_masks = Vec::with_capacity(coverage.len());
+                        for coverage in coverage {
+                            let mask = fragment_mask(coverage.fragments.clone()).await?;
+                            // Stale rows sit in fragments the index does cover, so they
+                            // are allowed by address rather than by fragment.
+                            stats_masks.push(if coverage.stale_rows.is_empty() {
+                                mask
+                            } else {
+                                Arc::new(
+                                    mask.as_ref()
+                                        .clone()
+                                        .also_allow(coverage.stale_rows.as_ref().clone()),
+                                )
+                            });
+                        }
+                        stats_masks
+                    }
+                    FlatStatsScope::WholeCorpus => {
+                        vec![fragment_mask(scanned_fragments.clone()).await?; columns.len()]
+                    }
+                };
+
+                let emit_mask = match emit_prefilter {
+                    Some(prefilter) => {
+                        let pre_filter = build_prefilter_restricted_to_fragments(
+                            prefilter_context,
+                            partition,
+                            &prefilter,
+                            stats_mask_ds.clone(),
+                            scanned_fragments,
+                            // The external row-address mask is applied by the
+                            // planner's `RowAddrMaskFilterExec` wrap around this
+                            // node, so it stays out of the corpus statistics.
+                            None,
+                            &metrics_set,
+                        )?;
+                        pre_filter.wait_for_ready().await?;
+                        Some(pre_filter.mask())
+                    }
+                    None => None,
+                };
+
+                flat_combined_fields_search_stream(
+                    input,
+                    &columns,
+                    doc_col_indices,
+                    &stats_masks,
+                    emit_mask,
+                    matches!(stats_scope, FlatStatsScope::WholeCorpus),
+                    &tokens,
+                    tokenizer,
+                    query.operator(),
+                    target_batch_size,
+                    Some(elapsed_compute),
+                    Some(metrics.as_ref()),
+                )
+                .await
+            }
+            .await;
+
+            match result {
+                Ok((stream, scorer)) => {
+                    if let Some(producer) = shared_scorer_producer {
+                        producer.publish(scorer);
+                    }
+                    Ok(stream)
+                }
+                Err(error) => {
+                    if let Some(producer) = shared_scorer_producer {
+                        producer.publish_error(&error);
+                    }
+                    Err(error)
+                }
+            }
+        })
+        .try_flatten()
+        .map(move |batch| {
+            let poll = metrics_clone
+                .baseline_metrics
+                .record_poll(std::task::Poll::Ready(Some(batch)));
+            match poll {
+                std::task::Poll::Ready(Some(b)) => b,
+                _ => unreachable!("record_poll preserves Ready(Some) input"),
+            }
+        });
+        Ok(Box::pin(RecordBatchStreamAdapter::new(
+            self.schema(),
+            stream.stream_in_current_span().boxed(),
+        )))
+    }
+
+    fn metrics(&self) -> Option<MetricsSet> {
+        Some(self.metrics.clone_inner())
+    }
+
+    fn properties(&self) -> &Arc<PlanProperties> {
+        &self.properties
+    }
+
+    fn supports_limit_pushdown(&self) -> bool {
+        false
+    }
+}
+
 #[derive(Debug)]
 pub struct PhraseQueryExec {
     dataset: Arc<Dataset>,
@@ -5366,7 +5811,9 @@ mod tests {
     use lance_core::{ROW_ID, utils::address::RowAddress};
     use lance_datafusion::datagen::DatafusionDatagenExt;
     use lance_datafusion::exec::{ExecutionStatsCallback, ExecutionSummaryCounts};
-    use lance_datafusion::utils::{INDEX_CACHE_HITS_METRIC, PARTITIONS_SEARCHED_METRIC};
+    use lance_datafusion::utils::{
+        INDEX_CACHE_HITS_METRIC, INDEX_CACHE_MISSES_METRIC, PARTITIONS_SEARCHED_METRIC,
+    };
     use lance_datagen::{BatchCount, ByteCount, RowCount};
     use lance_index::metrics::NoOpMetricsCollector;
     use lance_index::scalar::inverted::builder::ScoredDoc;
@@ -5376,8 +5823,9 @@ mod tests {
         try_collect_query_tokens,
     };
     use lance_index::scalar::inverted::{
-        CombinedFieldColumn, DocumentGranularity, FTS_SCHEMA, InvertedIndex, Language, SCORE_COL,
-        build_combined_bm25_scorer, build_global_bm25_scorer, prepare_bm25_query,
+        CombinedCorpusStats, CombinedFieldColumn, DocumentGranularity, FTS_SCHEMA, InvertedIndex,
+        Language, SCORE_COL, build_combined_bm25_scorer, build_global_bm25_scorer,
+        prepare_bm25_query,
     };
     use lance_index::scalar::{FullTextSearchQuery, InvertedIndexParams};
     use lance_index::{IndexCriteria, IndexType};
@@ -5395,11 +5843,11 @@ mod tests {
 
     use super::{
         BoolSlot, BoostQueryExec, CombinedFieldsQueryExec, CompoundQueryExec,
-        CrossColumnCompoundQueryExec, FTS_SEGMENT_BIND_DURATION_METRIC, FlatMatchFilterExec,
-        FlatMatchQueryExec, MatchQueryExec, PhraseQueryExec, WAND_TIE_COMPLETION_BUDGET,
-        WandExactnessCertificate, build_boolean_query_children,
-        classify_wand_exactness_certificate, default_text_tokenizer, open_fts_segments,
-        tokenizer_for_match_query,
+        CrossColumnCompoundQueryExec, FTS_SEGMENT_BIND_DURATION_METRIC, FlatCombinedFieldsExec,
+        FlatMatchFilterExec, FlatMatchQueryExec, FlatStatsCoverage, FlatStatsScope, MatchQueryExec,
+        PhraseQueryExec, WAND_TIE_COMPLETION_BUDGET, WandExactnessCertificate,
+        build_boolean_query_children, classify_wand_exactness_certificate, default_text_tokenizer,
+        open_fts_segments, tokenizer_for_match_query,
     };
     use crate::io::exec::utils::IndexMetrics;
     use datafusion::physical_plan::empty::EmptyExec;
@@ -6090,6 +6538,41 @@ mod tests {
         );
     }
 
+    /// A `combined_fields` scan is a leaf FTS node, so `analyze_plan` must show
+    /// its tokens the way it does for `match` and `phrase`. Both children of a
+    /// mixed plan report, or a `Boolean{combined_fields, match}` plan would show
+    /// tokens on the `match` sibling only.
+    #[tokio::test]
+    async fn test_analyze_plan_shows_combined_fields_tokens() {
+        let dataset = create_tokenized_query_fixture(&["title", "body"], true).await;
+        let query = CombinedFieldsQuery::try_new(
+            "FIRST and SECOND".to_string(),
+            vec!["title".to_string(), "body".to_string()],
+        )
+        .unwrap();
+        let mut scanner = dataset.scan();
+        scanner
+            .full_text_search(FullTextSearchQuery::new_query(query.into()))
+            .unwrap();
+
+        let explained = scanner.explain_plan(false).await.unwrap();
+        assert!(
+            !explained.contains("tokenized_query="),
+            "explain_plan should not claim runtime tokenization: {explained}"
+        );
+
+        let analysis = scanner.analyze_plan().await.unwrap();
+        let expected = r#"tokenized_query=[("first", 0), ("second", 2)]"#;
+        assert!(
+            find_plan_line(&analysis, "CombinedFieldsQuery:").contains(expected),
+            "indexed combined_fields is missing token positions:\n{analysis}"
+        );
+        assert!(
+            find_plan_line(&analysis, "FlatCombinedFields:").contains(expected),
+            "flat combined_fields is missing token positions:\n{analysis}"
+        );
+    }
+
     #[tokio::test]
     async fn test_boolean_query_parts_searched_metrics() {
         let mut dataset = lance_datagen::gen_batch()
@@ -6228,6 +6711,7 @@ mod tests {
                 column: column.to_string(),
                 weight,
                 indices,
+                stale_rows: None,
             });
         }
         let mut tokenizer = columns[0].indices[0].tokenizer();
@@ -6246,7 +6730,7 @@ mod tests {
         let expected_lookups = terms.len() * partitions;
         assert!(expected_lookups > 0);
         let scorer = Arc::new(
-            build_combined_bm25_scorer(&columns, &tokens, None)
+            build_combined_bm25_scorer(&columns, &tokens, CombinedCorpusStats::IndexOnly, None)
                 .await
                 .unwrap(),
         );
@@ -6288,6 +6772,44 @@ mod tests {
             expected_lookups,
             "CombinedFieldsQueryExec must report the scorer build's cache lookups",
         );
+
+        // The flat sibling builds its own scorer from the same per-column index
+        // statistics. An empty input isolates those reads: the scanned rows
+        // contribute none, so the count is absolute rather than a delta.
+        let flat_schema = Arc::new(arrow_schema::Schema::new(vec![
+            lance_core::ROW_ID_FIELD.clone(),
+            arrow_schema::Field::new("title", DataType::Utf8, true),
+            arrow_schema::Field::new("body", DataType::Utf8, true),
+        ]));
+        let resolved_fields = query
+            .column_names()
+            .map(|column| {
+                crate::index::scalar::inverted::resolve_fts_field(
+                    dataset.schema(),
+                    column,
+                    DocumentGranularity::Row,
+                )
+                .unwrap()
+            })
+            .collect::<Vec<_>>();
+        let num_columns = resolved_fields.len();
+        let flat = FlatCombinedFieldsExec::try_new(
+            dataset.clone(),
+            query.clone(),
+            params.clone(),
+            Arc::new(EmptyExec::new(flat_schema)),
+            roaring::RoaringBitmap::new(),
+            resolved_fields,
+            FlatStatsScope::PerColumn(vec![FlatStatsCoverage::default(); num_columns]),
+        )
+        .unwrap();
+        assert!(execute_results(&flat).await.unwrap().is_empty());
+        assert_eq!(
+            metric_value(&flat, INDEX_CACHE_HITS_METRIC)
+                + metric_value(&flat, INDEX_CACHE_MISSES_METRIC),
+            expected_lookups,
+            "FlatCombinedFieldsExec must report the scorer build's cache lookups",
+        );
     }
 
     #[tokio::test]
diff --git a/rust/lance/tests/query/inverted.rs b/rust/lance/tests/query/inverted.rs
index dd24eb30fcb..f215aefa071 100644
--- a/rust/lance/tests/query/inverted.rs
+++ b/rust/lance/tests/query/inverted.rs
@@ -1089,7 +1089,9 @@ async fn test_element_document_nested_lists_use_deepest_boundary() {
     assert_eq!(row.fields, vec![content.id]);
     assert_ne!(row.fields, vec![docs.children[0].id]);
 
-    // A cross-field scan resolves the same nested path through the row index.
+    // A cross-field scan resolves the same path through the row index, and its
+    // flat sibling walks two list levels down to the leaf. Rows 2 and 3 repeat
+    // rows 0 and 1 in a fragment no index covers, so both sides contribute.
     let combined_indexed = run_fts(&ds, combined_fields("alpha", &[path]), None).await;
     assert_eq!(
         combined_indexed["id"]
@@ -1113,16 +1115,12 @@ async fn test_element_document_nested_lists_use_deepest_boundary() {
         .await
         .unwrap();
 
-    let mut combined_mixed = ds.scan();
-    combined_mixed
-        .full_text_search(combined_fields("alpha", &[path]))
-        .unwrap();
-    let error = combined_mixed.try_into_batch().await.unwrap_err();
-    assert!(matches!(error, lance_core::Error::InvalidInput { .. }));
-    let message = error.to_string();
-    assert!(
-        message.contains("1 of 2 fragments are not fully covered") && message.contains(path),
-        "{message}"
+    let combined_mixed = run_fts(&ds, combined_fields("alpha", &[path]), None).await;
+    assert_eq!(
+        combined_mixed["id"]
+            .as_primitive::<arrow_array::types::Int32Type>()
+            .values(),
+        &[0, 1, 2, 3]
     );
 
     let mut combined_fast = ds.scan();

From a2d9808862ab77f8f3445f95caae1ad10d2c6e90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=B6ren=20Brunk?= <soeren.brunk@commercetools.com>
Date: Mon, 17 Aug 2026 12:07:55 +0200
Subject: [PATCH 2/3] test(fts): cover the combined_fields flat scan and
 overlay corpus statistics

The cases that matter here are the ones where a shared corpus is easy to
lose, since both scan sides must agree on `docCount'`/`docFreq'`/`avgdl'`:
unindexed and partially indexed fragments, per-column index skew over both
row-id schemes, a mixed indexed/flat plan, deletions followed by optimize,
and overlay-stale fragments. Each asserts exact scores against the
brute-force reference, because scoring the two sides against different
corpora still returns the right rows in almost the right order.

Also covers what only the flat path reaches: nulls and empty strings read
from the scan rather than an index, list and nested columns, a column under a
list, filters, and the plan shape itself, so a query that should union does
not silently answer from the index alone.

The external row-address prefilter is covered for the same reason, over both
plan shapes: the fully covered plan ANDs the mask into the indexed scan's
prefilter, while the mixed plan's flat child never reaches an index-side
prefilter and is masked on its output instead. Scores are asserted there too,
because the mask picks what is emitted and not the corpus it is measured
against, so a surviving row must keep the score the unmasked query gave it.
---
 .../src/scalar/inverted/combined/flat.rs      |  187 +++
 .../src/scalar/inverted/combined/testing.rs   |   13 +
 .../tests/dataset_fts_combined_fields.rs      | 1458 ++++++++++++++++-
 .../tests/dataset_overlay_index_masking.rs    |  681 +++++++-
 4 files changed, 2334 insertions(+), 5 deletions(-)

diff --git a/rust/lance-index/src/scalar/inverted/combined/flat.rs b/rust/lance-index/src/scalar/inverted/combined/flat.rs
index 0e0d6ac3155..6391db557ec 100644
--- a/rust/lance-index/src/scalar/inverted/combined/flat.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/flat.rs
@@ -199,3 +199,190 @@ fn flat_combined_score(
         ],
     )?)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::super::super::tokenizer::InvertedIndexParams;
+    use super::super::super::tokenizer::document_tokenizer::DocType;
+    use super::super::testing::{flat_columns, flat_input, flat_scores};
+    use super::*;
+    use lance_select::RowAddrTreeMap;
+
+    /// Golden `(row_id, score)` for the flat BM25F scan, compared bit-for-bit.
+    ///
+    /// The blend `dl' = Σ_f w_f·dl_f` and `tf'_t = Σ_f w_f·tf_f,t` accumulates in
+    /// f32, which is not associative, and the corpus statistics it feeds are
+    /// derived from the same rows. Any change to how or where the per-column
+    /// contributions are summed has to leave these exact bits alone, so they are
+    /// pinned here rather than compared with a tolerance.
+    ///
+    /// The fixture exercises the parts that a plausible rewrite gets wrong:
+    /// non-unit and unequal weights, a row empty in one column but not the other,
+    /// a null, a row empty everywhere (dropped), and a `stats_masks` entry that
+    /// keeps one row out of one column's corpus totals.
+    #[tokio::test]
+    async fn test_flat_combined_fields_golden_scores() {
+        let row_ids: Vec<u64> = (0..7).collect();
+        let docs = vec![
+            vec![
+                Some("cat"),
+                Some("dog cat"),
+                None,
+                Some("bird"),
+                Some("cat cat dog"),
+                Some(""),
+                Some("cat dog bird"),
+            ],
+            vec![
+                Some("dog"),
+                None,
+                Some("cat dog dog"),
+                Some("fish"),
+                Some("cat"),
+                Some(""),
+                Some("bird bird"),
+            ],
+        ];
+        let weights = [1.0f32, 2.5];
+        let columns = flat_columns(&weights);
+        let tokens = Tokens::new(vec!["cat".to_string(), "dog".to_string()], DocType::Text);
+        let tokenizer = InvertedIndexParams::default().build().unwrap();
+        // Column 1 must not fold row 4 into its corpus totals (its index already
+        // holds that row); column 0 folds everything.
+        let stats_masks = vec![
+            Arc::new(RowAddrMask::all_rows()),
+            Arc::new(RowAddrMask::all_rows().also_block(RowAddrTreeMap::from_iter([4u64]))),
+        ];
+
+        let stream = flat_combined_fields_search_stream(
+            flat_input(&row_ids, &docs, 1),
+            &columns,
+            vec![1, 2],
+            &stats_masks,
+            /*emit_mask=*/ None,
+            /*flat_covers_whole_corpus=*/ false,
+            &tokens,
+            tokenizer,
+            Operator::Or,
+            3,
+            None,
+            None,
+        )
+        .await
+        .unwrap()
+        .0;
+        let (batch_sizes, scored) = flat_scores(stream).await;
+
+        // Row 5 is empty in both columns, so it never reaches the scorer, and row 3
+        // ("bird" / "fish") carries no query term, so it scores 0 and is dropped.
+        // `target_batch_size` of 3 splits the 5 survivors into 3 + 2.
+        assert_eq!(batch_sizes, vec![3, 2]);
+        assert_eq!(
+            scored,
+            vec![
+                (0, 0x3f9b_c3cf),
+                (1, 0x3f8f_0e96),
+                (2, 0x3fa6_8e68),
+                (4, 0x3f84_f2a6),
+                (6, 0x3f32_7287),
+            ]
+        );
+    }
+
+    /// The retained per-row payload must not grow with the number of target
+    /// columns. That independence is the whole point of blending during
+    /// tokenization: a `combined_fields` query over a wide column list routes the
+    /// entire dataset down this path as soon as one column's index is stale, and
+    /// the accumulation lives until the corpus statistics are complete.
+    ///
+    /// The input arrives as several batches, so this also covers the per-batch
+    /// statistics fold and that the retained rows stay in scan order across chunks.
+    #[tokio::test]
+    async fn test_flat_combined_fields_retention_is_independent_of_column_count() {
+        let row_ids: Vec<u64> = (0..64).collect();
+        let column = vec![Some("cat dog bird"); 64];
+        let tokens = Arc::new(Tokens::new(
+            vec!["cat".to_string(), "dog".to_string(), "bird".to_string()],
+            DocType::Text,
+        ));
+        let num_terms = tokens.len();
+
+        let mut footprints = Vec::new();
+        for num_columns in 1..=4usize {
+            let docs = vec![column.clone(); num_columns];
+            let (chunks, stats) = tokenize_and_blend_multi(
+                flat_input(&row_ids, &docs, 5),
+                InvertedIndexParams::default().build().unwrap(),
+                tokens.clone(),
+                Arc::new((1..=num_columns).collect()),
+                Arc::new(vec![1.0; num_columns]),
+                Arc::new(
+                    (0..num_columns)
+                        .map(|_| Arc::new(RowAddrMask::all_rows()))
+                        .collect(),
+                ),
+                None,
+            )
+            .await
+            .unwrap();
+
+            let retained: usize = chunks
+                .iter()
+                .map(|chunk| {
+                    chunk.row_ids.len() * size_of::<u64>()
+                        + (chunk.doc_lengths.len() + chunk.term_freqs.len()) * size_of::<f32>()
+                })
+                .sum();
+            let retained_row_ids: Vec<u64> = chunks
+                .iter()
+                .flat_map(|chunk| &chunk.row_ids)
+                .copied()
+                .collect();
+            assert!(chunks.len() > 1, "expected several chunks to fold");
+            assert_eq!(retained_row_ids, row_ids);
+            let rows = retained_row_ids.len();
+            // 8 bytes of row id plus `dl'` and one `tf'` per term, all f32.
+            assert_eq!(retained, rows * (8 + 4 * (1 + num_terms)));
+            footprints.push(retained);
+
+            // Every column sees the same three-token doc, so the statistics scale
+            // with the column count while the retained payload does not.
+            assert_eq!(stats.doc_counts, vec![rows; num_columns]);
+            assert_eq!(stats.total_tokens, vec![3 * rows as u64; num_columns]);
+            assert_eq!(stats.doc_freqs, vec![vec![rows; num_terms]; num_columns]);
+        }
+        assert!(footprints.windows(2).all(|pair| pair[0] == pair[1]));
+    }
+
+    /// A flat scan can legitimately see no batches at all (every scanned fragment
+    /// empty, or a prefilter that keeps nothing). The statistics fold still owes the
+    /// caller a scorer, so it reports all-zero totals rather than nothing.
+    #[tokio::test]
+    async fn test_flat_combined_fields_empty_scan_still_builds_a_scorer() {
+        let docs = vec![Vec::<Option<&str>>::new(), Vec::new()];
+        let stream = flat_combined_fields_search_stream(
+            flat_input(&[], &docs, 1),
+            &flat_columns(&[1.0, 2.5]),
+            vec![1, 2],
+            &[
+                Arc::new(RowAddrMask::all_rows()),
+                Arc::new(RowAddrMask::all_rows()),
+            ],
+            /*emit_mask=*/ None,
+            /*flat_covers_whole_corpus=*/ false,
+            &Tokens::new(vec!["cat".to_string()], DocType::Text),
+            InvertedIndexParams::default().build().unwrap(),
+            Operator::Or,
+            16,
+            None,
+            None,
+        )
+        .await
+        .unwrap()
+        .0;
+
+        let (batch_sizes, scored) = flat_scores(stream).await;
+        assert!(batch_sizes.is_empty());
+        assert!(scored.is_empty());
+    }
+}
diff --git a/rust/lance-index/src/scalar/inverted/combined/testing.rs b/rust/lance-index/src/scalar/inverted/combined/testing.rs
index 4d41ce0c911..21f187e4c74 100644
--- a/rust/lance-index/src/scalar/inverted/combined/testing.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/testing.rs
@@ -173,6 +173,19 @@ pub(super) fn flat_input(
     Box::pin(RecordBatchStreamAdapter::new(schema, stream::iter(batches)))
 }
 
+pub(super) fn flat_columns(weights: &[f32]) -> Vec<CombinedFieldColumn> {
+    weights
+        .iter()
+        .enumerate()
+        .map(|(slot, weight)| CombinedFieldColumn {
+            column: format!("doc{slot}"),
+            weight: *weight,
+            indices: Vec::new(),
+            stale_rows: None,
+        })
+        .collect()
+}
+
 /// Every `(row_id, score)` the flat scan emits, in emission order, with the
 /// score as raw bits so the comparison is exact.
 pub(super) async fn flat_scores(
diff --git a/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs b/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs
index 914f9fa5055..0e2c4d34736 100644
--- a/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs
+++ b/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs
@@ -2,28 +2,38 @@
 // SPDX-FileCopyrightText: Copyright The Lance Authors
 
 use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
 use std::vec;
 
+use super::dataset_index::nested_fts_batch;
+
 use crate::Dataset;
 
 use crate::dataset::write::{WriteMode, WriteParams};
 use crate::index::DatasetIndexExt;
 use crate::utils::test::copy_test_data_to_tmp;
-use arrow::array::AsArray;
+use arrow::array::{AsArray, GenericListBuilder, GenericStringBuilder};
+use arrow::datatypes::UInt64Type;
 use arrow_array::RecordBatch;
 use arrow_array::record_batch;
+use arrow_array::{Array, GenericStringArray, ListArray, StructArray};
 use arrow_array::{
-    RecordBatchIterator,
+    ArrayRef, Int32Array, RecordBatchIterator, StringArray,
     types::{Float32Type, Int32Type, Int64Type},
 };
+use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+use arrow_schema::{DataType, Field as ArrowField, Fields as ArrowFields, Schema as ArrowSchema};
+use lance_core::ROW_ID;
 use lance_core::utils::tempfile::TempStrDir;
-use lance_index::IndexType;
+use lance_index::optimize::OptimizeOptions;
 use lance_index::scalar::FullTextSearchQuery;
 use lance_index::scalar::inverted::{
     Language,
     query::{MatchQuery, Operator},
     tokenizer::InvertedIndexParams,
 };
+use lance_index::{IndexType, scalar::ScalarIndexParams};
+use lance_select::{RowAddrMask, RowAddrTreeMap};
 
 use lance_index::scalar::inverted::builder::BLOCK_SIZE;
 use lance_index::scalar::inverted::oracle::{brute_force_bm25f, brute_force_ids};
@@ -836,6 +846,516 @@ async fn test_fts_combined_fields_concatenation_identity() {
     }
 }
 
+#[rstest]
+#[case::or(Operator::Or)]
+#[case::and(Operator::And)]
+#[tokio::test]
+async fn test_fts_combined_fields_covers_unindexed_fragments(#[case] operator: Operator) {
+    // A combined_fields query must not silently drop rows appended after the indexes
+    // were built. The indexed scan cannot score them (their fragment is in no
+    // index), so the planner has to union in a flat scan the same way a single
+    // MatchQuery does.
+    //
+    // Every row here matches, so both children of the union emit and the exact
+    // scores also pin down that they scored against a single shared corpus. Only the
+    // flat side sees the appended rows, so an indexed child that folded its own
+    // statistics would score row 0 on a 1-document corpus while rows 1 and 2 were
+    // scored on a 3-document one.
+    let titles = vec!["alpha", "alpha alpha", "gamma"];
+    let bodies = vec!["omega", "omega", "omega omega"];
+
+    let (test_uri, mut dataset) =
+        indexed_two_column_dataset(&titles[..1], &bodies[..1], None).await;
+
+    // Two appended fragments, so the flat side has to cover more than one.
+    for row in 1..3 {
+        let batch = combined_fields_batch(vec![row as i32], vec![titles[row]], vec![bodies[row]]);
+        dataset = append_fts_dataset(&test_uri, batch, Some(1)).await;
+    }
+
+    // A single-column match already falls back to a flat scan; combined_fields
+    // must reach the same rows.
+    let match_ids = fts_result_ids(
+        &dataset,
+        FtsQuery::Match(
+            MatchQuery::new("alpha".to_string()).with_column(Some("title".to_string())),
+        ),
+    )
+    .await;
+    // Score order, so compare as a set: both alpha-bearing rows must be reached.
+    assert_eq!(
+        match_ids.iter().copied().collect::<HashSet<_>>(),
+        HashSet::from([0, 1])
+    );
+
+    let expected = brute_force_bm25f(
+        &[(1.0, titles.clone()), (1.0, bodies.clone())],
+        "alpha omega",
+        operator == Operator::And,
+    );
+    let actual =
+        fts_result_id_scores(&dataset, combined_query("alpha omega", operator), None).await;
+    // Row 0 comes from the indexed child and rows 1 and 2 from the flat one, so
+    // matching the reference on all three proves the two share a corpus: the flat
+    // scan publishes the blend that folds in the appended rows, and the indexed scan
+    // waits for it instead of using its own `docCount'`/`docFreq'`/`avgdl'`.
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "rows in unindexed fragments must be reached exactly once through the index/flat union",
+    );
+}
+
+/// An external row-address prefilter
+/// ([`Scanner::with_row_addr_prefilter`](crate::dataset::Scanner::with_row_addr_prefilter))
+/// must restrict a `combined_fields` result.
+///
+/// The two plan shapes reach it by different routes and are both checked: the
+/// fully covered one is a single indexed scan that ANDs the mask into its
+/// prefilter, while the mixed one adds a flat child whose rows never reach an
+/// index-side prefilter and so is masked on its output instead.
+///
+/// The mask picks what is emitted, not the corpus the scores are measured
+/// against, so the surviving rows keep the scores the unmasked query gave them.
+/// Folding it into the statistics would make a masked query rank its results
+/// differently from the same rows in an unmasked one.
+#[rstest]
+#[case::fully_indexed(false)]
+#[case::mixed_index_and_flat(true)]
+#[tokio::test]
+async fn test_fts_combined_fields_respects_external_row_mask(#[case] append_unindexed: bool) {
+    let titles = vec!["alpha", "alpha alpha", "gamma"];
+    let bodies = vec!["omega", "omega", "omega omega"];
+
+    let (_test_uri, mut dataset) = if append_unindexed {
+        // Index only row 0, then append the rest so the planner unions an indexed
+        // scan with a flat one.
+        let (test_uri, mut dataset) =
+            indexed_two_column_dataset(&titles[..1], &bodies[..1], None).await;
+        for row in 1..3 {
+            let batch =
+                combined_fields_batch(vec![row as i32], vec![titles[row]], vec![bodies[row]]);
+            dataset = append_fts_dataset(&test_uri, batch, Some(1)).await;
+        }
+        (test_uri, dataset)
+    } else {
+        indexed_two_column_dataset(&titles, &bodies, None).await
+    };
+    // Reload so the scanner sees the indices written above.
+    dataset.checkout_latest().await.unwrap();
+
+    // Row ids paired with the `id` values they carry, so the mask can be built in
+    // `_rowid` space while the assertions stay in terms of `id`.
+    let baseline = dataset
+        .scan()
+        .project(&["id"])
+        .unwrap()
+        .with_row_id()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query(
+            "alpha omega",
+            Operator::Or,
+        )))
+        .unwrap()
+        .try_into_batch()
+        .await
+        .unwrap();
+    let baseline_ids = baseline["id"].as_primitive::<Int32Type>();
+    let baseline_row_ids = baseline[ROW_ID].as_primitive::<UInt64Type>();
+    let baseline_scores = baseline["_score"].as_primitive::<Float32Type>();
+    let baseline: Vec<(i32, u64, f32)> = (0..baseline.num_rows())
+        .map(|i| {
+            (
+                baseline_ids.value(i),
+                baseline_row_ids.value(i),
+                baseline_scores.value(i),
+            )
+        })
+        .collect();
+    assert_eq!(
+        baseline.iter().map(|(id, ..)| *id).collect::<HashSet<_>>(),
+        HashSet::from([0, 1, 2]),
+        "every row matches this query, so all three must be in the baseline"
+    );
+
+    let masked = |allowed: Vec<u64>| {
+        let dataset = dataset.clone();
+        async move {
+            let mut scan = dataset.scan();
+            scan.project(&["id"])
+                .unwrap()
+                .full_text_search(FullTextSearchQuery::new_query(combined_query(
+                    "alpha omega",
+                    Operator::Or,
+                )))
+                .unwrap()
+                .with_row_addr_prefilter(RowAddrMask::from_allowed(RowAddrTreeMap::from_iter(
+                    allowed,
+                )));
+            let batch = scan.try_into_batch().await.unwrap();
+            let ids = batch["id"].as_primitive::<Int32Type>();
+            let scores = batch["_score"].as_primitive::<Float32Type>();
+            (0..batch.num_rows())
+                .map(|i| (ids.value(i), scores.value(i)))
+                .collect::<Vec<_>>()
+        }
+    };
+
+    assert!(
+        masked(vec![]).await.is_empty(),
+        "an empty allow list must drop every combined_fields match"
+    );
+
+    // One row at a time, so both the indexed row (0) and the flat ones (1, 2) are
+    // each checked on their own.
+    for &(id, row_id, score) in &baseline {
+        let actual = masked(vec![row_id]).await;
+        assert_eq!(
+            actual.len(),
+            1,
+            "allowing only _rowid {row_id} must return exactly id {id}, got {actual:?}"
+        );
+        assert_eq!(actual[0].0, id);
+        assert!(
+            (actual[0].1 - score).abs() < 1e-3,
+            "masking must not move id {id}'s score: {} vs the unmasked {score}",
+            actual[0].1
+        );
+    }
+}
+
+/// Per-column index skew, over both row-id schemes.
+///
+/// The indexed scan is restricted to fragments every target column covers. That
+/// restriction has to be expressed in the same id space the index stores, and the
+/// inverted index trains with `_rowid` (`TrainingCriteria::with_row_id`), which is a
+/// logical stable id when the dataset uses stable row ids and a row address
+/// otherwise. A fragment-address block list therefore matches nothing under stable
+/// row ids, letting the indexed scan emit the very rows the flat scan also emits,
+/// the same duplicate-across-a-UNION failure `do_create_deletion_mask_row_id`
+/// documents for issue #6877.
+///
+/// `Operator::And` is checked here too: it decides matching across the virtual field
+/// as a whole, so a row whose terms are split between an indexed and a stale-indexed
+/// column must still be admitted, and the flat side has to evaluate the operator over
+/// the same blended `tf'` the indexed side does.
+#[rstest]
+#[case::or_row_addresses(false, Operator::Or)]
+#[case::or_stable_row_ids(true, Operator::Or)]
+#[case::and_row_addresses(false, Operator::And)]
+#[case::and_stable_row_ids(true, Operator::And)]
+#[tokio::test]
+async fn test_fts_combined_fields_per_column_index_skew(
+    #[case] stable_row_ids: bool,
+    #[case] operator: Operator,
+) {
+    // Columns indexed at different dataset versions: `title` covers every
+    // fragment, `body` only the first. A fragment indexed for some target columns
+    // but not others cannot be scored by the indexed scan at all, `dl'` sums each
+    // column's document length and a row missing from a column's DocSet
+    // contributes 0, so those fragments must be routed to the flat scan whole,
+    // not emitted with a partial `tf'`/`dl'`.
+    let params = combined_fields_test_params();
+    // Fragment 0 (rows 0-1) ends up indexed for both columns. Fragment 1 (rows
+    // 2-3) is indexed for `title` only: row 2 carries the term in `title`, which a
+    // partial score would rank wrongly, and row 3 carries it only in `body`, which
+    // a partial score would miss entirely.
+    let titles = vec!["aa bb", "cc", "aa aa", "dd"];
+    let bodies = vec!["cc dd", "aa bb", "dd", "aa bb bb"];
+    let write_params = |mode: WriteMode| WriteParams {
+        mode,
+        max_rows_per_file: 2,
+        enable_stable_row_ids: stable_row_ids,
+        ..Default::default()
+    };
+
+    let first = combined_fields_batch(
+        vec![0, 1],
+        vec![titles[0], titles[1]],
+        vec![bodies[0], bodies[1]],
+    );
+    let test_uri = TempStrDir::default();
+    let mut dataset =
+        write_fts_dataset(&test_uri, first, Some(write_params(WriteMode::Create))).await;
+    create_inverted_indices(&mut dataset, &["title", "body"], &params).await;
+
+    let second = combined_fields_batch(
+        vec![2, 3],
+        vec![titles[2], titles[3]],
+        vec![bodies[2], bodies[3]],
+    );
+    let mut dataset =
+        write_fts_dataset(&test_uri, second, Some(write_params(WriteMode::Append))).await;
+    // Re-index `title` only, so the two columns disagree on fragment coverage.
+    create_inverted_indices(&mut dataset, &["title"], &params).await;
+    assert_eq!(
+        dataset.manifest.uses_stable_row_ids(),
+        stable_row_ids,
+        "row-id scheme precondition"
+    );
+
+    // Non-unit weights so `tf'`/`dl'` actually depend on `w_f` on the flat path.
+    // Two terms so `And` differs from `Or`: row 2 carries only "aa", so it drops out
+    // under `And` while every other matching row keeps both terms somewhere.
+    let weights = [3.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[(weights[0], titles.clone()), (weights[1], bodies.clone())],
+        "aa bb",
+        operator == Operator::And,
+    );
+    let expected_ids = brute_force_ids(&expected);
+
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_with_boosts("aa bb", operator, Some(weights.to_vec())),
+        None,
+    )
+    .await;
+    let actual_ids: HashSet<i32> = actual.iter().map(|(id, _)| *id).collect();
+    assert_eq!(
+        actual.len(),
+        expected_ids.len(),
+        "row emitted twice by both sides of the union: {actual:?}"
+    );
+    // Row 3 has "aa" only in `body`, whose index is missing fragment 1; an
+    // index-only plan cannot see it at all.
+    assert!(
+        actual_ids.contains(&3),
+        "row matching only through the column with stale index coverage was dropped: {actual_ids:?}"
+    );
+    assert_eq!(actual_ids, expected_ids);
+
+    // Rows 2 and 3 are scored by the flat side, which folds `body`'s missing
+    // fragment into the blended statistics, so it reaches the exact BM25F score.
+    // A partial `dl'` (missing `body`) would inflate row 2's score instead.
+    let scores: HashMap<i32, f32> = actual.into_iter().collect();
+    for id in [2, 3] {
+        match expected[id as usize] {
+            Some(want) => {
+                let got = scores[&id];
+                assert!(
+                    (got - want).abs() < 1e-3,
+                    "id {id} scored with partial cross-field data: scan={got}, brute force={want}"
+                );
+            }
+            None => assert!(
+                !scores.contains_key(&id),
+                "id {id} does not carry every term but {operator:?} returned it"
+            ),
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_partially_indexed_columns() {
+    // Only `title` is indexed. Every fragment is then uncovered for `body`, so the
+    // whole scan takes the flat-only planner branch, with no index child at all. That
+    // branch is the only one that builds a `CombinedFieldColumn` with no segments,
+    // and the only one where a column contributes zero index statistics and its
+    // entire contribution comes from the flat scan.
+    let params = combined_fields_test_params();
+    let titles = vec!["aa bb", "cc", "aa aa", "dd"];
+    let bodies = vec!["cc dd", "aa bb", "dd", "aa bb bb"];
+    let batch = combined_fields_batch(vec![0, 1, 2, 3], titles.clone(), bodies.clone());
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(
+        &test_uri,
+        batch,
+        Some(WriteParams {
+            max_rows_per_file: 2,
+            ..Default::default()
+        }),
+    )
+    .await;
+    create_inverted_indices(&mut dataset, &["title"], &params).await;
+
+    let weights = [2.0f32, 1.0f32];
+    let mut plan_scan = dataset.scan();
+    plan_scan
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query_with_boosts(
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        )))
+        .unwrap();
+    let plan = plan_scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "the flat-only branch must carry a flat child:\n{plan}"
+    );
+    assert!(
+        !plan.contains("CombinedFieldsQuery"),
+        "no fragment is covered for `body`, so nothing can be scored by an index \
+         child:\n{plan}"
+    );
+
+    let expected = brute_force_bm25f(
+        &[(weights[0], titles.clone()), (weights[1], bodies.clone())],
+        "aa",
+        false,
+    );
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_with_boosts("aa", Operator::Or, Some(weights.to_vec())),
+        None,
+    )
+    .await;
+    // The flat scan owns the entire corpus for `body` and reads `title` from its
+    // index, so the blended statistics are exact.
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "the flat-only plan must score against the blend of its own corpus and \
+         `title`'s index",
+    );
+
+    // The flat exec emits in scan order and applies no limit, so this branch needs
+    // its own score sort: without one the rows come back unordered and `limit`
+    // truncates positionally instead of taking the top-k.
+    let scores: Vec<f32> = actual.iter().map(|(_, score)| *score).collect();
+    assert!(
+        scores.windows(2).all(|w| w[0] >= w[1]),
+        "flat-only plan is not score-ordered: {actual:?}"
+    );
+
+    let best = actual
+        .iter()
+        .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
+        .map(|(id, _)| *id)
+        .unwrap();
+    let batch = dataset
+        .scan()
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query_with_boosts(
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        )))
+        .unwrap()
+        .limit(Some(1), None)
+        .unwrap()
+        .try_into_batch()
+        .await
+        .unwrap();
+    let top = batch
+        .column_by_name("id")
+        .unwrap()
+        .as_primitive::<Int32Type>()
+        .values()
+        .to_vec();
+    assert_eq!(
+        top,
+        vec![best],
+        "limit=1 on the flat-only plan did not return the top-scoring row"
+    );
+}
+
+/// Every row scores identically, so the whole result is one tie and
+/// `(score DESC, row_id ASC)` fixes the answer completely: the top-5 is the five
+/// lowest row ids.
+///
+/// Both plan shapes are covered because they settle ties in different places, and
+/// only one of them has a sort at all:
+///
+/// - **mixed coverage** unions an indexed child with a flat scan, so ties would
+///   otherwise break by fragment arrival order. The plan's `row_id ASC` second
+///   sort key decides them.
+/// - **fully indexed** returns `CombinedFieldsQueryExec` directly with no
+///   `SortExec` above it, so nothing downstream can reorder or recover a row.
+///   `combined_fields_search`'s own `(score, row_id)` heap ordering has to be
+///   right, and its bounded heap must not evict a tied row that belongs in the
+///   top-k.
+///
+/// Without either, `limit`/`offset` pagination could skip and repeat rows.
+#[rstest]
+#[case::fully_indexed(true)]
+#[case::mixed_coverage(false)]
+#[tokio::test]
+async fn test_fts_combined_fields_tied_scores_are_deterministic(#[case] fully_indexed: bool) {
+    let rows = 24usize;
+    // Spread the rows over several fragments either way: on the mixed plan that
+    // makes the flat scan's arrival order genuinely nondeterministic, and on the
+    // fully indexed one it spreads the postings over several index partitions.
+    let (_test_uri, dataset) = if fully_indexed {
+        indexed_two_column_dataset(&vec!["aa"; rows], &vec!["aa"; rows], Some(3)).await
+    } else {
+        let (test_uri, _indexed) =
+            indexed_two_column_dataset(&["aa", "aa"], &["aa", "aa"], None).await;
+        let second = combined_fields_batch(
+            (2..rows as i32).collect(),
+            vec!["aa"; rows - 2],
+            vec!["aa"; rows - 2],
+        );
+        let dataset = append_fts_dataset(&test_uri, second, Some(3)).await;
+        (test_uri, dataset)
+    };
+
+    // The two shapes must really be the two shapes, or the fully indexed case
+    // silently gains a sort that would mask the heap's own ordering.
+    let mut plan_scan = dataset.scan();
+    plan_scan
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query(
+            "aa",
+            Operator::Or,
+        )))
+        .unwrap()
+        .limit(Some(5), None)
+        .unwrap();
+    let plan = plan_scan.explain_plan(true).await.unwrap();
+    assert_eq!(
+        plan.contains("FlatCombinedFields"),
+        !fully_indexed,
+        "wrong plan shape for fully_indexed={fully_indexed}:\n{plan}"
+    );
+    assert_eq!(
+        plan.contains("SortExec"),
+        !fully_indexed,
+        "fully indexed plan must settle ties in the search, not in a sort:\n{plan}"
+    );
+
+    // Rows were written in id order across fragments, so row-id order is id order.
+    // Asserting the five lowest ids pins the specification, rather than observing
+    // that repeated runs happen to agree.
+    let expected_top: Vec<i32> = (0..5).collect();
+    let mut seen = HashSet::new();
+    for _ in 0..8 {
+        let batch = dataset
+            .scan()
+            .project(&["id"])
+            .unwrap()
+            .full_text_search(FullTextSearchQuery::new_query(combined_query(
+                "aa",
+                Operator::Or,
+            )))
+            .unwrap()
+            .limit(Some(5), None)
+            .unwrap()
+            .try_into_batch()
+            .await
+            .unwrap();
+        let ids = batch
+            .column_by_name("id")
+            .unwrap()
+            .as_primitive::<Int32Type>()
+            .values()
+            .to_vec();
+        assert_eq!(
+            ids, expected_top,
+            "tied scores must break by ascending row id"
+        );
+        seen.insert(ids);
+    }
+    assert_eq!(
+        seen.len(),
+        1,
+        "top-k over tied scores is nondeterministic across runs: {seen:?}"
+    );
+}
+
 #[tokio::test]
 async fn test_fts_combined_fields_fast_search_without_full_coverage_is_empty() {
     // `fast_search` is index-only. When a target column has no index at all no
@@ -864,6 +1384,44 @@ async fn test_fts_combined_fields_fast_search_without_full_coverage_is_empty() {
     assert_eq!(batch.num_rows(), 0);
 }
 
+#[tokio::test]
+async fn test_fts_combined_fields_unindexed_row_wins_topk() {
+    // The union applies the top-k limit after re-sorting both sides, so a row in an
+    // unindexed fragment must be able to take the single top slot. A plan that pushed
+    // the limit into the indexed side only would return the best row the index holds
+    // instead.
+    let titles = ["filler", "filler", "aa aa aa"];
+    let bodies = ["aa", "filler", "aa aa aa"];
+
+    let (test_uri, _indexed) = indexed_two_column_dataset(&titles[..2], &bodies[..2], None).await;
+
+    // Row 2 is the strongest match for "aa" but lands in an unindexed fragment.
+    let second = combined_fields_batch(vec![2], vec![titles[2]], vec![bodies[2]]);
+    let dataset = append_fts_dataset(&test_uri, second, None).await;
+
+    let batch = dataset
+        .scan()
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query(
+            "aa",
+            Operator::Or,
+        )))
+        .unwrap()
+        .limit(Some(1), None)
+        .unwrap()
+        .try_into_batch()
+        .await
+        .unwrap();
+    let ids = batch
+        .column_by_name("id")
+        .unwrap()
+        .as_primitive::<Int32Type>()
+        .values()
+        .to_vec();
+    assert_eq!(ids, vec![2], "top-1 was taken from the indexed side only");
+}
+
 #[tokio::test]
 async fn test_fts_combined_fields_fast_search_skips_uncovered_fragments() {
     // `fast_search` is index-only by contract, so appended rows stay invisible. It
@@ -950,3 +1508,897 @@ async fn test_fts_combined_fields_requires_an_index() {
         "unexpected error: {message}"
     );
 }
+
+/// Like [`combined_fields_batch`] but with optional text values, so a row can be
+/// NULL in one target column or in every one of them.
+fn nullable_combined_fields_batch(
+    ids: Vec<i32>,
+    titles: Vec<Option<&str>>,
+    bodies: Vec<Option<&str>>,
+) -> RecordBatch {
+    record_batch!(
+        ("id", Int32, ids),
+        ("title", Utf8, titles),
+        ("body", Utf8, bodies)
+    )
+    .unwrap()
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_flat_nulls_and_empty_strings() {
+    // NULL / empty-string handling on the flat path, which has its own counting
+    // code: `count_column_into` leaves a row's slots at zero for a NULL,
+    // `tokenize_and_blend_multi` drops a row that is empty in all target columns,
+    // and `FlatFieldStats::fold_row` skips a column whose `dl_f == 0` so the row
+    // raises neither that column's `docCount_f` nor its `docFreq_f`. Unlike
+    // `test_fts_combined_fields_nulls`, which covers the fully-indexed path, this
+    // one also pins the exact scores, where a miscounted `docCount'` shows up.
+    let params = combined_fields_test_params();
+    // Rows 0-1 are indexed for both columns and carry no query term, so the indexed
+    // child emits nothing and every returned row comes from the flat scan, whose
+    // blended statistics must still fold in the indexed rows.
+    let titles = vec![
+        Some("zz zz"),
+        Some("zz"),
+        None,          // NULL in one column
+        Some("aa aa"), // paired with an empty string in the other column
+        None,          // NULL in every column: never scored
+        Some(""),      // empty in every column: never scored
+        Some("aa"),
+        None, // NULL in one column, and no query term anywhere
+    ];
+    let bodies = vec![
+        Some("zz"),
+        Some("zz zz"),
+        Some("aa"),
+        Some(""),
+        None,
+        Some(""),
+        Some("aa zz"),
+        Some("zz"),
+    ];
+
+    let first =
+        nullable_combined_fields_batch(vec![0, 1], titles[..2].to_vec(), bodies[..2].to_vec());
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["title", "body"], &params).await;
+
+    // Spread the appended rows over several fragments, one of which holds only
+    // rows that tokenize to nothing at all.
+    let second = nullable_combined_fields_batch(
+        (2..titles.len() as i32).collect(),
+        titles[2..].to_vec(),
+        bodies[2..].to_vec(),
+    );
+    let dataset = append_fts_dataset(&test_uri, second, Some(2)).await;
+
+    // A NULL and an empty string both tokenize to nothing, so the reference models
+    // either as `""`.
+    fn as_text<'a>(values: &[Option<&'a str>]) -> Vec<&'a str> {
+        values.iter().map(|v| v.unwrap_or("")).collect()
+    }
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[
+            (weights[0], as_text(&titles)),
+            (weights[1], as_text(&bodies)),
+        ],
+        "aa",
+        false,
+    );
+    assert_eq!(
+        brute_force_ids(&expected),
+        HashSet::from([2, 3, 6]),
+        "reference corpus changed; the null rows must stay unmatched"
+    );
+
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_with_boosts("aa", Operator::Or, Some(weights.to_vec())),
+        None,
+    )
+    .await;
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "a row empty in every target column must not be scored, and docCount' must \
+         count only rows with tokens in that column",
+    );
+}
+
+/// An `id` + `tags` (a list of strings) + `body` batch, for the list-valued target
+/// column cases. `ListOffset` picks `List` vs `LargeList` and `StringOffset` picks
+/// `Utf8` vs `LargeUtf8`, both for the list elements and for `body`. A `None` entry
+/// in `tags` is a NULL list, an empty `Vec` an empty one.
+fn list_column_batch<
+    ListOffset: arrow::array::OffsetSizeTrait,
+    StringOffset: arrow::array::OffsetSizeTrait,
+>(
+    ids: &[i32],
+    tags: &[Option<Vec<&str>>],
+    bodies: &[&str],
+) -> RecordBatch {
+    let mut builder =
+        GenericListBuilder::<ListOffset, _>::new(GenericStringBuilder::<StringOffset>::new());
+    for row in tags {
+        match row {
+            Some(elements) => {
+                for element in elements {
+                    builder.values().append_value(element);
+                }
+                builder.append(true);
+            }
+            None => builder.append(false),
+        }
+    }
+    let tags_col = Arc::new(builder.finish()) as ArrayRef;
+    let bodies_col =
+        Arc::new(GenericStringArray::<StringOffset>::from(bodies.to_vec())) as ArrayRef;
+    RecordBatch::try_new(
+        Arc::new(ArrowSchema::new(vec![
+            ArrowField::new("id", DataType::Int32, false),
+            ArrowField::new("tags", tags_col.data_type().clone(), true),
+            ArrowField::new("body", bodies_col.data_type().clone(), false),
+        ])),
+        vec![
+            Arc::new(Int32Array::from(ids.to_vec())) as ArrayRef,
+            tags_col,
+            bodies_col,
+        ],
+    )
+    .unwrap()
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_flat_list_column() {
+    assert_combined_fields_flat_list_column::<i32, i32>().await;
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_flat_large_list_column() {
+    assert_combined_fields_flat_list_column::<i64, i64>().await;
+}
+
+/// The flat scan must reduce a list column to a row's document text the same way
+/// the index builder does, which is to join the elements with a space.
+///
+/// Under `simple` the two readings agree, because counting each element on its own
+/// yields the same tokens as counting them joined; only a tokenizer that is
+/// sensitive to the element boundary can tell them apart. `raw` emits one token
+/// per document, so a 2-element list is `dl_f = 1` when joined and `dl_f = 2` when
+/// counted per element.
+///
+/// Scoring the same rows once through each side pins the agreement down without a
+/// hand-computed reference: with `tags` indexed the statistics come from the
+/// index, and with only `body` indexed they come from the flat fold instead.
+#[tokio::test]
+async fn test_fts_combined_fields_flat_list_matches_index_under_raw_tokenizer() {
+    let params = InvertedIndexParams::new("raw".to_string(), Language::English)
+        .lower_case(false)
+        .stem(false)
+        .remove_stop_words(false);
+
+    // Row 1 is the discriminator: joined, its tags are the single token
+    // "alpha beta gamma", which does not match, but counted per element it holds
+    // the token "alpha beta", which does. Rows 0 and 2 match either way and pin
+    // down the scores.
+    let tags: Vec<Option<Vec<&str>>> = vec![
+        Some(vec!["alpha beta"]),
+        Some(vec!["alpha beta", "gamma"]),
+        Some(vec!["gamma", "delta"]),
+    ];
+    let bodies = vec!["alpha beta", "gamma", "alpha beta"];
+
+    let build = |indexed_columns: &'static [&'static str]| {
+        let params = params.clone();
+        let tags = tags.clone();
+        let bodies = bodies.clone();
+        async move {
+            let batch = list_column_batch::<i32, i32>(
+                &(0..tags.len() as i32).collect::<Vec<_>>(),
+                &tags,
+                &bodies,
+            );
+            let test_uri = TempStrDir::default();
+            let mut dataset = write_fts_dataset(&test_uri, batch, None).await;
+            create_inverted_indices(&mut dataset, indexed_columns, &params).await;
+            let scored = fts_result_id_scores(
+                &dataset,
+                combined_query_over(&["tags", "body"], "alpha beta", Operator::Or, None),
+                None,
+            )
+            .await;
+            // Keep the temporary directory alive until the scan has finished.
+            drop(test_uri);
+            scored
+        }
+    };
+
+    // `tags` indexed: its statistics and per-row lengths come from the index.
+    let indexed = build(&["tags", "body"]).await;
+    // `tags` unindexed: every fragment is uncovered for it, so the flat scan reads
+    // the raw list and folds its own statistics in.
+    let flat = build(&["body"]).await;
+
+    assert_eq!(
+        indexed.iter().map(|(id, _)| *id).collect::<Vec<_>>(),
+        vec![0, 2],
+        "row 1 only matches when its tag elements are counted separately"
+    );
+    assert_eq!(
+        indexed.len(),
+        flat.len(),
+        "flat={flat:?} indexed={indexed:?}"
+    );
+    for ((indexed_id, indexed_score), (flat_id, flat_score)) in indexed.iter().zip(&flat) {
+        assert_eq!(indexed_id, flat_id, "flat={flat:?} indexed={indexed:?}");
+        assert!(
+            (indexed_score - flat_score).abs() < 1e-5,
+            "id {indexed_id}: indexed={indexed_score}, flat={flat_score}; the flat scan must \
+             join a row's list elements the way the index builder does"
+        );
+    }
+}
+
+/// A list-valued target column on the flat path: the scan reduces the list to the
+/// row's document text and counts it as one document, so every element lands in
+/// the row's single `dl_f`/`tf_f`.
+async fn assert_combined_fields_flat_list_column<
+    ListOffset: arrow::array::OffsetSizeTrait,
+    StringOffset: arrow::array::OffsetSizeTrait,
+>() {
+    let params = combined_fields_test_params();
+    // `tags` is the list column. Row 2 spreads one term over two elements of
+    // differing length and row 3 repeats the term in two elements, so a reader that
+    // took only the first element, or treated each element as its own document,
+    // lands on a different `dl_f`/`tf_f` and a different score.
+    let tags: Vec<Option<Vec<&str>>> = vec![
+        Some(vec!["zz"]),
+        Some(vec!["zz", "zz"]),
+        Some(vec!["aa", "bb cc"]),
+        Some(vec!["aa", "aa"]),
+        None,         // NULL list
+        Some(vec![]), // empty list
+        Some(vec!["zz"]),
+    ];
+    let bodies = vec!["zz", "zz zz", "zz", "zz zz", "aa", "aa aa", "zz"];
+
+    // Rows 0-1 are indexed for both columns and match nothing, so every returned
+    // row is scored by the flat scan.
+    let first = list_column_batch::<ListOffset, StringOffset>(&[0, 1], &tags[..2], &bodies[..2]);
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["tags", "body"], &params).await;
+
+    let second = list_column_batch::<ListOffset, StringOffset>(
+        &(2..tags.len() as i32).collect::<Vec<_>>(),
+        &tags[2..],
+        &bodies[2..],
+    );
+    let dataset = append_fts_dataset(&test_uri, second, Some(2)).await;
+
+    // The index joins list elements with a space before tokenizing, so the
+    // reference sees the same token counts either way.
+    let flattened: Vec<String> = tags
+        .iter()
+        .map(|row| row.as_ref().map(|e| e.join(" ")).unwrap_or_default())
+        .collect();
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[
+            (weights[0], flattened.iter().map(|s| s.as_str()).collect()),
+            (weights[1], bodies.clone()),
+        ],
+        "aa",
+        false,
+    );
+    assert_eq!(brute_force_ids(&expected), HashSet::from([2, 3, 4, 5]));
+
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_over(
+            &["tags", "body"],
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        ),
+        None,
+    )
+    .await;
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "a row's list elements must sum into one dl_f",
+    );
+}
+
+/// A target column reached through a list (`List<Struct<Utf8>>`) is a shape a Lance
+/// projection cannot address by its public path, so the flat side scans the list
+/// root and walks down to the leaf itself.
+#[tokio::test]
+async fn test_fts_combined_fields_column_under_a_list() {
+    let params = combined_fields_test_params();
+    // Rows 0-1 are indexed and match "aa" nowhere, so every "aa" hit comes from
+    // the flat side and its score is the exact blended BM25F. Row 2 spreads the
+    // term over two struct elements and row 4 pairs an empty list with a matching
+    // title, so a reader that stopped at the first element, treated each element
+    // as its own document, or skipped empty lists lands on a different score.
+    let docs: Vec<Vec<&str>> = vec![
+        vec!["zz"],
+        vec!["zz zz"],
+        vec!["aa", "bb aa"],
+        vec!["aa aa"],
+        vec![],
+    ];
+    let titles = vec!["zz", "zz", "zz", "aa", "aa aa"];
+
+    let nested_batch = |ids: &[i32], docs: &[Vec<&str>], titles: &[&str]| {
+        let content_field = Arc::new(ArrowField::new("content", DataType::Utf8, true));
+        let struct_fields = ArrowFields::from(vec![content_field]);
+        let contents = docs.iter().flatten().copied().collect::<Vec<_>>();
+        let struct_values = StructArray::new(
+            struct_fields.clone(),
+            vec![Arc::new(StringArray::from(contents)) as ArrayRef],
+            None,
+        );
+        let item = Arc::new(ArrowField::new(
+            "item",
+            DataType::Struct(struct_fields),
+            true,
+        ));
+        let mut offsets = Vec::with_capacity(docs.len() + 1);
+        offsets.push(0i32);
+        for row in docs {
+            offsets.push(offsets.last().unwrap() + row.len() as i32);
+        }
+        let docs_col = Arc::new(ListArray::new(
+            item,
+            OffsetBuffer::new(ScalarBuffer::from(offsets)),
+            Arc::new(struct_values),
+            None,
+        )) as ArrayRef;
+        RecordBatch::try_new(
+            Arc::new(ArrowSchema::new(vec![
+                ArrowField::new("id", DataType::Int32, false),
+                ArrowField::new("docs", docs_col.data_type().clone(), true),
+                ArrowField::new("title", DataType::Utf8, false),
+            ])),
+            vec![
+                Arc::new(Int32Array::from(ids.to_vec())) as ArrayRef,
+                docs_col,
+                Arc::new(StringArray::from(titles.to_vec())) as ArrayRef,
+            ],
+        )
+        .unwrap()
+    };
+
+    let first = nested_batch(&[0, 1], &docs[..2], &titles[..2]);
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["docs.content", "title"], &params).await;
+
+    let weights = [2.0f32, 1.0f32];
+    // The index joins a row's list elements with a space before tokenizing, so the
+    // reference counts the same tokens either way.
+    let joined: Vec<String> = docs.iter().map(|row| row.join(" ")).collect();
+    let assert_scored_like_reference = |dataset: Dataset, terms: &'static str, rows: usize| {
+        let joined = joined.clone();
+        let titles = titles.clone();
+        async move {
+            let expected = brute_force_bm25f(
+                &[
+                    (
+                        weights[0],
+                        joined[..rows].iter().map(|s| s.as_str()).collect(),
+                    ),
+                    (weights[1], titles[..rows].to_vec()),
+                ],
+                terms,
+                false,
+            );
+            assert!(
+                !brute_force_ids(&expected).is_empty(),
+                "the reference must match something"
+            );
+            let actual = fts_result_id_scores(
+                &dataset,
+                combined_query_over(
+                    &["docs.content", "title"],
+                    terms,
+                    Operator::Or,
+                    Some(weights.to_vec()),
+                ),
+                None,
+            )
+            .await;
+            assert_matches_brute_force(
+                &actual,
+                &expected,
+                "a target column reached through a list must be walked down to its leaf",
+            );
+        }
+    };
+
+    // Fully indexed, so the indexed child owns every hit.
+    assert_scored_like_reference(dataset.clone(), "zz", 2).await;
+
+    // Appending fragments no index covers routes the new rows to the flat sibling,
+    // which has to reach `docs.content` without projecting it.
+    let second = nested_batch(
+        &(2..docs.len() as i32).collect::<Vec<_>>(),
+        &docs[2..],
+        &titles[2..],
+    );
+    let dataset = append_fts_dataset(&test_uri, second, Some(2)).await;
+
+    assert_scored_like_reference(dataset, "aa", docs.len()).await;
+}
+
+/// A `title`/`body`/`tags` batch, for the three-column stride case.
+fn three_column_batch(
+    ids: Vec<i32>,
+    titles: Vec<&str>,
+    bodies: Vec<&str>,
+    tags: Vec<&str>,
+) -> RecordBatch {
+    record_batch!(
+        ("id", Int32, ids),
+        ("title", Utf8, titles),
+        ("body", Utf8, bodies),
+        ("tags", Utf8, tags)
+    )
+    .unwrap()
+}
+
+/// Three columns and two terms, with distinct per-column weights.
+///
+/// Every per-row count is addressed as `(row * num_columns + column) * num_terms +
+/// term`. With two columns and two terms that stride is symmetric enough for a
+/// transposition to survive. The corpus places each term in a different column per
+/// row, so swapping the column and term strides permutes `tf'` and changes the
+/// scores.
+///
+/// Both cases share one corpus and one expected answer: the `flat_side` case only
+/// moves where the rows are scored, which also asserts that the flat scan
+/// reproduces the fully-indexed scores exactly.
+#[rstest]
+#[case::fully_indexed(false)]
+#[case::flat_side(true)]
+#[tokio::test]
+async fn test_fts_combined_fields_three_columns_two_terms(#[case] append_unindexed: bool) {
+    let params = combined_fields_test_params();
+    // Rows 0-1 carry no query term, so they are never returned and the `flat_side`
+    // case can be compared against the same exact scores as the indexed one.
+    let titles = vec!["zz", "zz zz", "aa", "bb bb", "zz", "aa aa"];
+    let bodies = vec!["zz zz", "zz", "bb", "zz", "aa bb", "zz zz"];
+    let tags = vec!["zz", "zz zz", "zz", "aa", "bb", "aa bb"];
+    let columns = ["title", "body", "tags"];
+    let weights = [3.0f32, 2.0f32, 1.0f32];
+
+    let test_uri = TempStrDir::default();
+    let write_params = |mode: WriteMode| WriteParams {
+        mode,
+        max_rows_per_file: 2,
+        ..Default::default()
+    };
+    let indexed_rows = if append_unindexed { 2 } else { titles.len() };
+    let first = three_column_batch(
+        (0..indexed_rows as i32).collect(),
+        titles[..indexed_rows].to_vec(),
+        bodies[..indexed_rows].to_vec(),
+        tags[..indexed_rows].to_vec(),
+    );
+    let mut dataset =
+        write_fts_dataset(&test_uri, first, Some(write_params(WriteMode::Create))).await;
+    create_inverted_indices(&mut dataset, &columns, &params).await;
+
+    let dataset = if append_unindexed {
+        let second = three_column_batch(
+            (indexed_rows as i32..titles.len() as i32).collect(),
+            titles[indexed_rows..].to_vec(),
+            bodies[indexed_rows..].to_vec(),
+            tags[indexed_rows..].to_vec(),
+        );
+        write_fts_dataset(&test_uri, second, Some(write_params(WriteMode::Append))).await
+    } else {
+        dataset
+    };
+
+    for operator in [Operator::Or, Operator::And] {
+        let expected = brute_force_bm25f(
+            &[
+                (weights[0], titles.clone()),
+                (weights[1], bodies.clone()),
+                (weights[2], tags.clone()),
+            ],
+            "aa bb",
+            operator == Operator::And,
+        );
+        assert_eq!(
+            brute_force_ids(&expected),
+            HashSet::from([2, 3, 4, 5]),
+            "reference corpus changed; rows 0-1 must stay unmatched"
+        );
+
+        let actual = fts_result_id_scores(
+            &dataset,
+            combined_query_over(&columns, "aa bb", operator, Some(weights.to_vec())),
+            None,
+        )
+        .await;
+        assert_matches_brute_force(
+            &actual,
+            &expected,
+            &format!("op={operator:?}: the three-column, two-term stride must not transpose"),
+        );
+    }
+}
+
+/// A `combined_fields` query with a filter, over a mixed-coverage dataset.
+///
+/// The flat scan is a `filtered_read(is_prefilter=true)`. When the filter needs a
+/// refine expression, the scan projection gains that expression's columns, so the
+/// document columns no longer sit at the positions the query lists them in and
+/// `doc_col_indices` has to resolve them by name.
+///
+/// Both cases filter to the same rows through different plan shapes: `id >= 4`
+/// resolves entirely through the scalar index (no refine), while `category` has no
+/// index so the whole predicate becomes a refine expression.
+#[rstest]
+#[case::scalar_index_prefilter("id >= 4", true)]
+#[case::refine_expression("category = 'keep'", false)]
+#[tokio::test]
+async fn test_fts_combined_fields_with_filter(
+    #[case] filter: &str,
+    #[case] index_filter_column: bool,
+) {
+    let params = combined_fields_test_params();
+    // Rows 0-1 are indexed for both text columns and match nothing, so every
+    // returned row comes from the flat side and its score can be checked exactly.
+    // Rows 2-3 match but are filtered out, so they contribute no corpus statistics
+    // either: the flat scan never sees them.
+    let titles = vec!["zz zz", "zz", "aa", "zz", "aa aa", "zz"];
+    let bodies = vec!["zz", "zz zz", "zz", "aa aa", "zz", "aa"];
+    let categories = ["keep", "keep", "drop", "drop", "keep", "keep"];
+    // `category` is placed ahead of the document columns, so the refine expression
+    // pulling it into the projection shifts their positions.
+    let batch = |ids: Vec<i32>, rows: std::ops::Range<usize>| {
+        record_batch!(
+            ("id", Int32, ids),
+            ("category", Utf8, categories[rows.clone()].to_vec()),
+            ("title", Utf8, titles[rows.clone()].to_vec()),
+            ("body", Utf8, bodies[rows].to_vec())
+        )
+        .unwrap()
+    };
+
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, batch(vec![0, 1], 0..2), None).await;
+    create_inverted_indices(&mut dataset, &["title", "body"], &params).await;
+    if index_filter_column {
+        dataset
+            .create_index(
+                &["id"],
+                IndexType::BTree,
+                None,
+                &ScalarIndexParams::default(),
+                true,
+            )
+            .await
+            .unwrap();
+    }
+
+    let dataset = append_fts_dataset(&test_uri, batch((2..6).collect(), 2..6), Some(2)).await;
+
+    // The corpus the scan can see: every row of the indexed fragment (the index
+    // statistics are not filtered) plus only the flat rows that survive the filter.
+    let stats_rows = [0usize, 1, 4, 5];
+    let pick = |values: &[&'static str]| {
+        stats_rows
+            .iter()
+            .map(|&row| values[row])
+            .collect::<Vec<_>>()
+    };
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[(weights[0], pick(&titles)), (weights[1], pick(&bodies))],
+        "aa",
+        false,
+    );
+    let expected_scores: HashMap<i32, f32> = stats_rows
+        .iter()
+        .enumerate()
+        .filter_map(|(slot, &row)| expected[slot].map(|score| (row as i32, score)))
+        .collect();
+    assert_eq!(
+        expected_scores.keys().copied().collect::<HashSet<_>>(),
+        HashSet::from([4, 5]),
+        "reference corpus changed; only the kept rows may match"
+    );
+
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .prefilter(true)
+        .full_text_search(FullTextSearchQuery::new_query(combined_query_with_boosts(
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        )))
+        .unwrap()
+        .filter(filter)
+        .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "filtered plan lost its flat child:\n{plan}"
+    );
+    // Confirm the two cases really took the two different branches, rather than
+    // both landing on the same one.
+    if index_filter_column {
+        assert!(
+            plan.contains("ScalarIndexQuery") && plan.contains("refine_filter=--"),
+            "expected the filter to resolve entirely through the scalar index:\n{plan}"
+        );
+        assert!(
+            !plan.contains("category"),
+            "no refine expression, so `category` must stay out of the projection:\n{plan}"
+        );
+    } else {
+        assert!(
+            plan.contains("refine_filter=category"),
+            "expected the filter to become a refine expression:\n{plan}"
+        );
+        assert!(
+            !plan.contains("FilterExec"),
+            "the scan already applies the refine expression, so no second filter:\n{plan}"
+        );
+        assert!(
+            plan.contains("projection=[category, title, body]"),
+            "the refine expression's column must be added to the flat scan \
+             projection:\n{plan}"
+        );
+    }
+
+    let scan_batch = scan.try_into_batch().await.unwrap();
+    let ids = scan_batch
+        .column_by_name("id")
+        .unwrap()
+        .as_primitive::<Int32Type>();
+    let scores = scan_batch
+        .column_by_name("_score")
+        .unwrap()
+        .as_primitive::<Float32Type>();
+    let actual: Vec<(i32, f32)> = (0..scan_batch.num_rows())
+        .map(|i| (ids.value(i), scores.value(i)))
+        .collect();
+
+    assert_eq!(
+        actual.len(),
+        expected_scores.len(),
+        "filter did not restrict the result set:\n{plan}\n{actual:?}"
+    );
+    for (id, score) in actual {
+        let want = *expected_scores
+            .get(&id)
+            .unwrap_or_else(|| panic!("filtered-out row {id} was returned:\n{plan}"));
+        assert!(
+            (score - want).abs() < 1e-3,
+            "id {id}: scan={score}, brute force={want}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_deletions_then_optimize() {
+    // Deleted rows must disappear from both sides of the union: the indexed child
+    // sees them through the restricted deletion mask, and the flat child through
+    // its filtered read. The surviving scores must then be unchanged by
+    // `optimize_indices`, because folding a fragment's flat statistics in has to
+    // produce exactly the totals that indexing it produces.
+    let titles = vec!["aa", "aa aa", "zz", "aa aa aa", "aa", "zz zz"];
+    let bodies = vec!["zz", "zz", "aa aa", "zz", "aa aa", "aa"];
+
+    let (test_uri, _indexed) = indexed_two_column_dataset(&titles[..3], &bodies[..3], None).await;
+    let second = combined_fields_batch(vec![3, 4, 5], titles[3..].to_vec(), bodies[3..].to_vec());
+    let mut dataset = append_fts_dataset(&test_uri, second, None).await;
+
+    // One deletion in the indexed fragment, one in the appended (flat) fragment.
+    dataset.delete("id in (1, 4)").await.unwrap();
+
+    // Row 1 stays in the index's own statistics, because a delete does not rewrite
+    // the `DocSet`, while row 4 never reaches the flat counter, so it drops out of
+    // the corpus entirely.
+    let stats_rows = [0usize, 1, 2, 3, 5];
+    let pick = |values: &[&'static str]| {
+        stats_rows
+            .iter()
+            .map(|&row| values[row])
+            .collect::<Vec<_>>()
+    };
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[(weights[0], pick(&titles)), (weights[1], pick(&bodies))],
+        "aa",
+        false,
+    );
+    let expected_scores: HashMap<i32, f32> = stats_rows
+        .iter()
+        .enumerate()
+        .filter_map(|(slot, &row)| expected[slot].map(|score| (row as i32, score)))
+        .collect();
+
+    let query = || combined_query_with_boosts("aa", Operator::Or, Some(weights.to_vec()));
+    let live_ids = HashSet::from([0, 2, 3, 5]);
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(query()))
+        .unwrap();
+    let mixed_plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        mixed_plan.contains("FlatCombinedFields"),
+        "the appended fragment is unindexed, so the plan must have a flat child:\n{mixed_plan}"
+    );
+
+    let mixed = fts_result_id_scores(&dataset, query(), None).await;
+    assert_eq!(
+        mixed.iter().map(|(id, _)| *id).collect::<HashSet<_>>(),
+        live_ids,
+        "deleted rows leaked into the mixed index/flat plan: {mixed:?}"
+    );
+    assert_eq!(mixed.len(), live_ids.len(), "duplicate row: {mixed:?}");
+    // Rows 3 and 5 are the ones the flat child scores, so they see the blended
+    // statistics in full. Rows 0 and 2 come from the indexed child, which still
+    // scores against index-only statistics (a known gap documented at the union).
+    let mixed_scores: HashMap<i32, f32> = mixed.into_iter().collect();
+    for id in [3, 5] {
+        let want = expected_scores[&id];
+        let got = mixed_scores[&id];
+        assert!(
+            (got - want).abs() < 1e-3,
+            "id {id} after delete: scan={got}, brute force={want}"
+        );
+    }
+
+    // Indexing the appended fragment must leave those scores untouched, and the
+    // plan must collapse back to a single indexed scan.
+    dataset
+        .optimize_indices(&OptimizeOptions::default())
+        .await
+        .unwrap();
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(query()))
+        .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("CombinedFieldsQuery"),
+        "expected an indexed combined-fields scan:\n{plan}"
+    );
+    assert!(
+        !plan.contains("FlatCombinedFields"),
+        "every fragment is indexed but the plan still has a flat child:\n{plan}"
+    );
+
+    let optimized = fts_result_id_scores(&dataset, query(), None).await;
+    assert_eq!(
+        optimized.iter().map(|(id, _)| *id).collect::<HashSet<_>>(),
+        live_ids,
+        "deleted rows came back after optimize: {optimized:?}"
+    );
+    // Now that every row is indexed there is a single corpus, so every score has to
+    // match the reference, including the rows the mixed plan scored from the index
+    // only.
+    for (id, score) in optimized {
+        let want = expected_scores[&id];
+        assert!(
+            (score - want).abs() < 1e-3,
+            "id {id} after optimize: scan={score}, brute force={want}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_nested_columns() {
+    // Nested target columns: the flat plan projects the struct column from storage,
+    // so it calls `ensure_column_alias` once per target column to expose `s.a` and
+    // `s.b` as top-level names the exec can resolve. Both aliases survive only
+    // because one projection is nested inside the other.
+    let params = combined_fields_test_params();
+    let a_values = [
+        Some("zz zz"),
+        Some("zz"),
+        Some("aa"),
+        Some("zz"),
+        Some("aa aa"),
+    ];
+    let b_values = [
+        Some("zz"),
+        Some("zz zz"),
+        Some("zz"),
+        Some("aa aa"),
+        Some("aa"),
+    ];
+
+    let first = nested_fts_batch(vec![0, 1], a_values[..2].to_vec(), b_values[..2].to_vec());
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["s.a", "s.b"], &params).await;
+    // Rows 0-1 are indexed and match nothing, so the appended rows are the ones
+    // returned and the flat path owns every score.
+    let second = nested_fts_batch(
+        vec![2, 3, 4],
+        a_values[2..].to_vec(),
+        b_values[2..].to_vec(),
+    );
+    let schema = second.schema();
+    dataset
+        .append(
+            RecordBatchIterator::new(vec![second].into_iter().map(Ok), schema),
+            None,
+        )
+        .await
+        .unwrap();
+
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[
+            (
+                weights[0],
+                a_values.iter().map(|v| v.unwrap_or("")).collect(),
+            ),
+            (
+                weights[1],
+                b_values.iter().map(|v| v.unwrap_or("")).collect(),
+            ),
+        ],
+        "aa",
+        false,
+    );
+    let expected_ids: HashSet<u64> = (0..expected.len())
+        .filter(|&i| expected[i].is_some())
+        .map(|i| i as u64)
+        .collect();
+    assert_eq!(expected_ids, HashSet::from([2, 3, 4]));
+
+    let mut scan = dataset.scan();
+    scan.full_text_search(FullTextSearchQuery::new_query(combined_query_over(
+        &["s.a", "s.b"],
+        "aa",
+        Operator::Or,
+        Some(weights.to_vec()),
+    )))
+    .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "the appended fragment is unindexed, so the nested columns must be aliased \
+         for a flat child:\n{plan}"
+    );
+
+    let batch = scan.try_into_batch().await.unwrap();
+    let ids = batch["id"].as_primitive::<UInt64Type>();
+    let scores = batch["_score"].as_primitive::<Float32Type>();
+    let actual: Vec<(u64, f32)> = (0..batch.num_rows())
+        .map(|i| (ids.value(i), scores.value(i)))
+        .collect();
+    assert_eq!(
+        actual.len(),
+        expected_ids.len(),
+        "duplicate row: {actual:?}"
+    );
+    assert_eq!(
+        actual.iter().map(|(id, _)| *id).collect::<HashSet<_>>(),
+        expected_ids
+    );
+    for (id, score) in actual {
+        let want = expected[id as usize].expect("scan returned an unmatched doc");
+        assert!(
+            (score - want).abs() < 1e-3,
+            "id {id}: scan={score}, brute force={want}"
+        );
+    }
+}
diff --git a/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs b/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs
index 0113319c528..b3155560363 100644
--- a/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs
+++ b/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs
@@ -11,7 +11,7 @@ use futures::TryStreamExt;
 
 use arrow_array::builder::{ListBuilder, StringBuilder};
 use arrow_array::cast::AsArray;
-use arrow_array::types::Int32Type;
+use arrow_array::types::{Float32Type, Int32Type};
 use arrow_array::{ArrayRef, Int32Array, RecordBatch, RecordBatchIterator, StringArray};
 use arrow_schema::{DataType, Field as ArrowField, Schema as ArrowSchema};
 use lance_index::IndexType;
@@ -873,7 +873,7 @@ async fn build_text_fts_index_with_positions(dataset: &mut Dataset) {
         .unwrap();
 }
 
-/// Collect sorted IDs of rows returned by an FTS query on `text`.
+/// Collect sorted IDs of rows returned by an FTS query.
 async fn fts_ids(dataset: &Dataset, query: FullTextSearchQuery) -> Vec<i32> {
     let results = dataset
         .scan()
@@ -1649,6 +1649,683 @@ async fn test_fts_overlay_unrelated_field_not_excluded() {
     assert_eq!(fts_ids_matching(&dataset, "banana").await, vec![3, 999]);
 }
 
+fn combined_fields_query(terms: &str, columns: &[&str]) -> FullTextSearchQuery {
+    use lance_index::scalar::inverted::query::{CombinedFieldsQuery, FtsQuery};
+
+    FullTextSearchQuery::new_query(FtsQuery::CombinedFields(
+        CombinedFieldsQuery::try_new(
+            terms.to_owned(),
+            columns.iter().map(|column| column.to_string()).collect(),
+        )
+        .unwrap(),
+    ))
+}
+
+/// Optional settings for a `combined_fields` query in these tests.
+#[derive(Default)]
+struct CombinedScan<'a> {
+    /// Applied as a prefilter.
+    filter: Option<&'a str>,
+    fragment_ids: Option<&'a [u32]>,
+    limit: Option<i64>,
+    fast_search: bool,
+}
+
+/// `(id, score)` of every cross-field (BM25F) `combined_fields` hit, in score
+/// order. Scores are bit patterns, so a corpus that shifted by one document shows
+/// up instead of passing a tolerance.
+async fn fts_combined_hits(
+    dataset: &Dataset,
+    terms: &str,
+    columns: &[&str],
+    scan: CombinedScan<'_>,
+) -> Vec<(i32, u32)> {
+    let mut scanner = dataset.scan();
+    if let Some(fragment_ids) = scan.fragment_ids {
+        scanner.with_fragments(
+            dataset
+                .fragments()
+                .iter()
+                .filter(|fragment| fragment_ids.contains(&(fragment.id as u32)))
+                .cloned()
+                .collect(),
+        );
+    }
+    if let Some(filter) = scan.filter {
+        scanner.prefilter(true).filter(filter).unwrap();
+    }
+    if scan.fast_search {
+        scanner.fast_search();
+    }
+    scanner
+        .full_text_search(combined_fields_query(terms, columns).limit(scan.limit))
+        .unwrap()
+        .project(&["id"])
+        .unwrap();
+    let batch = scanner.try_into_batch().await.unwrap();
+    let ids = batch["id"].as_primitive::<Int32Type>();
+    let scores = batch["_score"].as_primitive::<Float32Type>();
+    (0..batch.num_rows())
+        .map(|i| (ids.value(i), scores.value(i).to_bits()))
+        .collect()
+}
+
+/// Sorted ids of [`fts_combined_hits`].
+async fn fts_combined_ids(
+    dataset: &Dataset,
+    terms: &str,
+    columns: &[&str],
+    scan: CombinedScan<'_>,
+) -> Vec<i32> {
+    let mut ids: Vec<i32> = fts_combined_hits(dataset, terms, columns, scan)
+        .await
+        .into_iter()
+        .map(|(id, _)| id)
+        .collect();
+    ids.sort_unstable();
+    ids
+}
+
+/// Sorted `id` values a single-column `MatchQuery` returns. This is the reference
+/// answer `combined_fields` must agree with: an `Or` combined-fields query matches
+/// a document when a query term appears in at least one target column, so the
+/// combined result is the union of the per-column match results.
+async fn fts_match_ids(dataset: &Dataset, term: &str, column: &str) -> Vec<i32> {
+    use lance_index::scalar::inverted::query::{FtsQuery, MatchQuery};
+
+    let query = FullTextSearchQuery::new_query(FtsQuery::Match(
+        MatchQuery::new(term.to_owned()).with_column(Some(column.to_owned())),
+    ));
+    fts_ids(dataset, query).await
+}
+
+/// Union of the per-column `MatchQuery` results for `term`, sorted.
+async fn fts_match_union_ids(dataset: &Dataset, term: &str, columns: &[&str]) -> Vec<i32> {
+    let mut ids = Vec::new();
+    for column in columns {
+        ids.extend(fts_match_ids(dataset, term, column).await);
+    }
+    ids.sort_unstable();
+    ids.dedup();
+    ids
+}
+
+/// Build an FTS index on `column` as one segment per fragment, the multi-segment
+/// counterpart of the whole-index single segment `build_text_fts_index` produces.
+/// An overlay-stale fragment is excluded from the indexed scan either way, so both
+/// layouts run the indexed and the flat side; only the number of segments the
+/// indexed side opens differs.
+async fn build_per_fragment_fts_index(dataset: &mut Dataset, column: &str) {
+    let params = InvertedIndexParams::default();
+    let name = format!("{column}_fts");
+    let fragment_ids = dataset
+        .get_fragments()
+        .into_iter()
+        .map(|fragment| fragment.id() as u32)
+        .collect::<Vec<_>>();
+    let mut segments = Vec::with_capacity(fragment_ids.len());
+    for fragment_id in fragment_ids {
+        segments.push(
+            CreateIndexBuilder::new(dataset, &[column], IndexType::Inverted, &params)
+                .name(name.clone())
+                .fragments(vec![fragment_id])
+                .execute_uncommitted()
+                .await
+                .unwrap(),
+        );
+    }
+    dataset
+        .commit_existing_index_segments(&name, column, segments)
+        .await
+        .unwrap();
+}
+
+/// `combined_fields` must honour the same data-overlay contract as `match`: a
+/// fragment holding an overlay-stale row is dropped from the indexed scan and
+/// re-evaluated on the flat path. Without that the indexed scan answers from the
+/// pre-overlay index, so it both returns stale hits and misses new matches.
+///
+/// `match` blocks the individual stale row addresses instead (see
+/// `plan_combined_fields_query` for why BM25F cannot), but the answer must be the
+/// same either way.
+///
+/// Parametrized over the segment layout: one segment for the whole index, and one
+/// segment per fragment.
+#[rstest]
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_agrees_with_match(
+    #[values(false, true)] per_fragment_segments: bool,
+) {
+    let mut dataset = create_text_dataset(false).await;
+    if per_fragment_segments {
+        build_per_fragment_fts_index(&mut dataset, "text").await;
+    } else {
+        build_text_fts_index(&mut dataset).await;
+    }
+
+    // fragment 0, row offset 1 (id=1): "apple banana" → "cherry mango".
+    // Field ID 1 is the `text` column.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_text_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    // Both directions: "apple"/"banana" must lose the stale id=1 hit, and
+    // "cherry"/"mango" must gain it.
+    for (term, expected) in [
+        ("apple", vec![0]),
+        ("banana", vec![3]),
+        ("cherry", vec![1, 2]),
+        ("mango", vec![1, 6]),
+    ] {
+        let combined = fts_combined_ids(&dataset, term, &["text"], CombinedScan::default()).await;
+        assert_eq!(
+            combined,
+            fts_match_ids(&dataset, term, "text").await,
+            "combined_fields disagrees with match for '{term}'"
+        );
+        assert_eq!(combined, expected, "wrong rows for '{term}'");
+    }
+}
+
+/// The overlay term must be findable even when no indexed posting list holds it.
+///
+/// Taking the column's `docFreq_f` from the pre-overlay index alone leaves a term the
+/// overlay introduced at `docFreq' == 0`, so `query_weight` is `0.0`, the row scores
+/// zero and the flat scan drops it.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_new_term_absent_from_index_stats() {
+    let mut dataset = create_text_dataset(false).await;
+    build_text_fts_index(&mut dataset).await;
+
+    // fragment 0, row offset 1 (id=1): "apple banana" → "quasarunique", a term that
+    // occurs in no other row and so in no indexed posting list.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_unique_text_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("quasarunique")]))],
+    )
+    .await;
+
+    assert_eq!(
+        fts_match_ids(&dataset, "quasarunique", "text").await,
+        vec![1]
+    );
+    assert_eq!(
+        fts_combined_ids(&dataset, "quasarunique", &["text"], CombinedScan::default()).await,
+        vec![1]
+    );
+}
+
+/// Text dataset with an `id` column holding the row offset plus one `Utf8` column per
+/// entry of `columns`, laid out `rows_per_file` rows to a fragment. `id` is field 0 and
+/// the text columns take the following field IDs in order.
+async fn create_text_dataset_with(columns: &[(&str, &[&str])], rows_per_file: usize) -> Dataset {
+    let num_rows = columns[0].1.len() as i32;
+    let mut fields = vec![ArrowField::new("id", DataType::Int32, true)];
+    let mut arrays: Vec<ArrayRef> = vec![Arc::new(Int32Array::from_iter_values(0..num_rows))];
+    for (name, values) in columns {
+        fields.push(ArrowField::new(*name, DataType::Utf8, true));
+        arrays.push(Arc::new(StringArray::from(values.to_vec())));
+    }
+    let schema = Arc::new(ArrowSchema::new(fields));
+    let batch = RecordBatch::try_new(schema.clone(), arrays).unwrap();
+    let write_params = WriteParams {
+        max_rows_per_file: rows_per_file,
+        ..Default::default()
+    };
+    let reader = RecordBatchIterator::new(vec![Ok(batch)], schema.clone());
+    Dataset::write(reader, "memory://", Some(write_params))
+        .await
+        .unwrap()
+}
+
+/// A same-value overlay must not move top-k: it leaves every searchable value alone, so
+/// the corpus the ranking is measured against must not change either.
+///
+/// The prefilter prunes the flat scan, so statistics folded from that scan describe the
+/// filtered subset, while the indexed plan an overlay-free dataset takes uses the whole index.
+/// Globally `beta` is the rare term, so id 1 wins; the overlay rewrites a row the filter
+/// excludes.
+///
+/// - `tie`: over the filtered pair the two terms have equal `docFreq`, so the scores tie,
+///   which is enough to lose id 1.
+/// - `strict`: over ids 0..2, `df(alpha) = 1` against `df(beta) = 2` puts id 0 ahead by
+///   roughly 2x, so the ranking flips on a strict inequality rather than on tie order.
+///   Id 2 carries filler tokens purely to lengthen it, so it never ties with id 1.
+#[rstest]
+#[case::tie("alpha", "id < 2", 2)]
+#[case::strict("beta gamma delta", "id < 3", 5)]
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_preserves_prefilter_corpus(
+    #[case] third_text: &str,
+    #[case] filter: &str,
+    #[case] overwritten_row: u32,
+) {
+    let mut texts = vec!["alpha"; 12];
+    texts[1] = "beta";
+    texts[2] = third_text;
+    let mut dataset = create_text_dataset_with(&[("text", &texts)], 12).await;
+    build_text_fts_index(&mut dataset).await;
+    let scan = || CombinedScan {
+        filter: Some(filter),
+        limit: Some(1),
+        ..Default::default()
+    };
+    assert_eq!(
+        fts_combined_ids(&dataset, "alpha beta", &["text"], scan()).await,
+        vec![1]
+    );
+
+    let dataset = commit_overlay(
+        dataset,
+        "combined_prefilter_same_value_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([overwritten_row])),
+        vec![Arc::new(StringArray::from(vec![Some("alpha")]))],
+    )
+    .await;
+    assert_eq!(
+        fts_combined_ids(&dataset, "alpha beta", &["text"], scan()).await,
+        vec![1]
+    );
+}
+
+/// Fragment selection must restrict which rows are returned, not which corpus they
+/// are scored against. A same-value overlay inside the selection leaves every
+/// searchable value alone, so top-k must not move.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_preserves_fragment_corpus() {
+    // Fragment 0 holds the only `beta` rows; the nine `alpha` rows behind it are what
+    // make `beta` the rare term, and they are outside the selection.
+    let texts: &[&str] = &[
+        "alpha",
+        "beta",
+        "beta gamma delta",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+    ];
+    let mut dataset = create_text_dataset_with(&[("text", texts)], 3).await;
+    build_text_fts_index(&mut dataset).await;
+
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "alpha beta",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&[0]),
+                limit: Some(1),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![1]
+    );
+
+    // Row offset 2 rewritten with the value it already holds.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_fragment_same_value_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([2])),
+        vec![Arc::new(StringArray::from(vec![Some("beta gamma delta")]))],
+    )
+    .await;
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "alpha beta",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&[0]),
+                limit: Some(1),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![1]
+    );
+}
+
+/// An overlay that rewrites rows with the values they already hold has to leave
+/// every score alone, not just the order.
+///
+/// The index counts a stale row's old value and the flat scan folds in its current
+/// one, so the row is counted twice unless the old value is subtracted. Here that
+/// makes `alpha` look commoner than `beta` and flips the ranking. Ids alone would
+/// not catch it, because the same five rows come back either way.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_preserves_every_score() {
+    let texts: &[&str] = &["alpha", "alpha", "beta", "beta", "beta"];
+    let mut dataset = create_text_dataset_with(&[("text", texts)], 5).await;
+    build_text_fts_index(&mut dataset).await;
+    let before =
+        fts_combined_hits(&dataset, "alpha beta", &["text"], CombinedScan::default()).await;
+    // `alpha` is the rarer term, so its rows lead.
+    assert_eq!(
+        before.iter().map(|(id, _)| *id).collect::<Vec<_>>(),
+        vec![0, 1, 2, 3, 4]
+    );
+
+    let dataset = commit_overlay(
+        dataset,
+        "combined_same_value_overlay_scores",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([0, 1])),
+        vec![Arc::new(StringArray::from(vec![
+            Some("alpha"),
+            Some("alpha"),
+        ]))],
+    )
+    .await;
+
+    assert_eq!(
+        fts_combined_hits(&dataset, "alpha beta", &["text"], CombinedScan::default()).await,
+        before
+    );
+}
+
+/// An overlay must cost only the fragments it touched. Folding the stale rows on top
+/// of the index keeps the corpus global, so the untouched fragments stay on the
+/// indexed side instead of the whole table going through a full scan.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_keeps_clean_fragments_indexed() {
+    let mut dataset = create_text_dataset(false).await;
+    build_text_fts_index(&mut dataset).await;
+
+    // Fragment 0 only; fragment 1 (ids 6..11) is untouched.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_partial_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .full_text_search(combined_fields_query("cherry", &["text"]))
+        .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("CombinedFieldsQuery"),
+        "fragment 1 has no stale entry, so it must stay on the indexed side:\n{plan}"
+    );
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "fragment 0 must be re-read on the flat side:\n{plan}"
+    );
+}
+
+/// An overlay must not cost the flat scan the rows only it can return.
+///
+/// Once a stale row folds, the flat scan is read unfiltered and its emitted rows
+/// are picked by a prefilter instead, so that a same-value overlay cannot move the
+/// corpus (see `test_fts_combined_fields_overlay_preserves_prefilter_corpus`).
+/// That prefilter has to span the fragments the flat scan reads. The indexed
+/// child's own prefilter does not: it is built over the fragments the target
+/// columns' indexes cover, so it names no row in an appended fragment, and an
+/// allow-list can only be narrowed afterwards, never widened.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_keeps_unindexed_selected_match() {
+    let mut dataset = create_text_dataset(false).await;
+    build_text_fts_index(&mut dataset).await;
+
+    // `mango` now sits both in indexed fragment 1 (id 6) and in an appended
+    // fragment no index covers, so the two sides of the union are told apart.
+    let batch = arrow_array::record_batch!(("id", Int32, [12]), ("text", Utf8, ["mango"])).unwrap();
+    let schema = batch.schema();
+    let reader = RecordBatchIterator::new(vec![Ok(batch)], schema);
+    let dataset = Dataset::write(
+        reader,
+        Arc::new(dataset),
+        Some(WriteParams {
+            mode: crate::dataset::write::WriteMode::Append,
+            ..Default::default()
+        }),
+    )
+    .await
+    .unwrap();
+    let appended_fragment_id = dataset.fragments().last().unwrap().id as u32;
+    // A fragment selection is what makes the prefilter fragment-scoped in the first
+    // place; with no filter and no selection it allows every row.
+    let selected_fragments = [0, appended_fragment_id];
+
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "mango",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&selected_fragments),
+                limit: Some(10),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![12],
+        "precondition: the appended match is returned before any overlay exists"
+    );
+
+    // Fragment 0 holds no `mango`, so this overlay changes no answer. All it does is
+    // route the scan onto the unfiltered-read path.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_unindexed_selected_match_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([0])),
+        vec![Arc::new(StringArray::from(vec![Some("apple pie")]))],
+    )
+    .await;
+
+    assert_eq!(
+        fts_combined_ids(&dataset, "mango", &["text"], CombinedScan::default()).await,
+        vec![6, 12],
+        "unselected control: both matches are still reachable"
+    );
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "mango",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&selected_fragments),
+                limit: Some(10),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![12],
+        "the overlay dropped a match from a selected unindexed fragment"
+    );
+}
+
+/// Two-fragment dataset with two indexable text columns: `id`, `title`, `body`.
+/// Field IDs are 0 (`id`), 1 (`title`), 2 (`body`).
+async fn create_two_column_text_dataset() -> Dataset {
+    let titles: &[&str] = &[
+        "apple pie",
+        "apple banana", // row 1, fragment 0, overlaid in tests
+        "cherry cake",
+        "banana split",
+        "orange juice",
+        "grape vine",
+        "mango sorbet", // fragment 1 starts here
+        "pear tart",
+        "lemon curd",
+        "peach cobbler",
+        "plum pudding",
+        "fig newton",
+    ];
+    // `dessert` spans both fragments, and `fruit` sits on the overlaid row plus a
+    // row in the other fragment, so a body term exercises the flat and the indexed
+    // side of the union at once.
+    let bodies: &[&str] = &[
+        "sweet dessert",
+        "yellow fruit",
+        "red dessert",
+        "frozen treat",
+        "citrus drink",
+        "purple cluster",
+        "tropical ice",
+        "green fruit",
+        "sour spread",
+        "warm bake",
+        "dark dessert",
+        "dry biscuit",
+    ];
+    create_text_dataset_with(&[("title", titles), ("body", bodies)], 6).await
+}
+
+/// The multi-column shape of the contract above. An overlay on one target column
+/// makes the whole fragment unscorable from the indexes: a stale row poisons the
+/// blended `dl'`/`tf'` of every target column, not just the overlaid one, so the
+/// fragment has to be re-evaluated flat across all of them.
+///
+/// Only `title` is overlaid, so `body`'s index still covers the fragment. The
+/// indexed scan has to skip it for both columns anyway, the case where a missing
+/// fragment allow list emits the fragment twice, once per side of the union.
+#[rstest]
+#[tokio::test]
+async fn test_fts_combined_fields_multi_column_overlay_agrees_with_match(
+    #[values(false, true)] per_fragment_segments: bool,
+) {
+    let mut dataset = create_two_column_text_dataset().await;
+    for column in ["title", "body"] {
+        if per_fragment_segments {
+            build_per_fragment_fts_index(&mut dataset, column).await;
+        } else {
+            dataset
+                .create_index(
+                    &[column],
+                    IndexType::Inverted,
+                    None,
+                    &InvertedIndexParams::default(),
+                    true,
+                )
+                .await
+                .unwrap();
+        }
+    }
+
+    // Overlay `title` (field 1) of fragment 0, row offset 1 (id=1):
+    // "apple banana" → "cherry mango". `body` is untouched.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_title_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    let columns = ["title", "body"];
+    for (term, expected) in [
+        // Stale title hits are dropped.
+        ("apple", vec![0]),
+        ("banana", vec![3]),
+        // New title matches are found.
+        ("cherry", vec![1, 2]),
+        ("mango", vec![1, 6]),
+        // A term of the untouched target column still resolves on both sides of the
+        // union: id=1 comes from the flat path, id=7 from the indexed path.
+        ("fruit", vec![1, 7]),
+        ("dessert", vec![0, 2, 10]),
+    ] {
+        let combined = fts_combined_ids(&dataset, term, &columns, CombinedScan::default()).await;
+        assert_eq!(
+            combined,
+            fts_match_union_ids(&dataset, term, &columns).await,
+            "combined_fields disagrees with match for '{term}'"
+        );
+        assert_eq!(combined, expected, "wrong rows for '{term}'");
+    }
+}
+
+/// `fast_search` is index-only, so the overlay-stale fragment is dropped instead of
+/// re-evaluated: the stale hit still must not come back, and the new value stays
+/// invisible until compaction folds the overlay into the base. Every other fragment
+/// keeps answering, whichever segment layout holds it.
+#[rstest]
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_under_fast_search(
+    #[values(false, true)] per_fragment_segments: bool,
+) {
+    let mut dataset = create_text_dataset(false).await;
+    if per_fragment_segments {
+        build_per_fragment_fts_index(&mut dataset, "text").await;
+    } else {
+        build_text_fts_index(&mut dataset).await;
+    }
+    let dataset = commit_overlay(
+        dataset,
+        "combined_fast_search_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    // Fragment 0 is stale either way, so nothing it holds is answerable: no stale
+    // "apple"/"banana" hit and no new "cherry" hit.
+    for term in ["apple", "banana", "cherry"] {
+        assert_eq!(
+            fts_combined_ids(
+                &dataset,
+                term,
+                &["text"],
+                CombinedScan {
+                    fast_search: true,
+                    ..Default::default()
+                },
+            )
+            .await,
+            Vec::<i32>::new(),
+            "fast_search returned a row from the stale fragment for '{term}'"
+        );
+    }
+    // Fragment 1 holds no stale row, so it stays on the indexed side and answers
+    // even though the whole-index segment layout also covers the stale fragment.
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "mango",
+            &["text"],
+            CombinedScan {
+                fast_search: true,
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![6]
+    );
+}
+
 /// Benchmark: measure query latency for BTree, FTS, and vector ANN with 0/4/16 overlay layers.
 ///
 /// Run with:

From cf3624efb7c07f3a7514255b5e3e39891477744f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=B6ren=20Brunk?= <soeren.brunk@commercetools.com>
Date: Fri, 14 Aug 2026 22:59:58 +0200
Subject: [PATCH 3/3] feat(java): add combined_fields (BM25F) full-text query

---
 java/lance-jni/src/blocking_scanner.rs        |  33 ++++-
 .../java/org/lance/ipc/FullTextQuery.java     |  97 ++++++++++++++
 .../java/org/lance/ipc/FullTextQueryTest.java |  95 ++++++++++++++
 .../ipc/LanceScannerFullTextSearchTest.java   | 120 +++++++++++++++---
 4 files changed, 321 insertions(+), 24 deletions(-)

diff --git a/java/lance-jni/src/blocking_scanner.rs b/java/lance-jni/src/blocking_scanner.rs
index 9d65220aa53..8f06847da8b 100644
--- a/java/lance-jni/src/blocking_scanner.rs
+++ b/java/lance-jni/src/blocking_scanner.rs
@@ -21,9 +21,9 @@ use lance_index::scalar::FullTextSearchQuery;
 use lance_index::scalar::inverted::{
     DocumentGranularity,
     query::{
-        BooleanQuery as FtsBooleanQuery, BoostQuery as FtsBoostQuery, FtsQuery,
-        MatchQuery as FtsMatchQuery, MultiMatchQuery as FtsMultiMatchQuery, Occur as FtsOccur,
-        PhraseQuery as FtsPhraseQuery,
+        BooleanQuery as FtsBooleanQuery, BoostQuery as FtsBoostQuery,
+        CombinedFieldsQuery as FtsCombinedFieldsQuery, FtsQuery, MatchQuery as FtsMatchQuery,
+        MultiMatchQuery as FtsMultiMatchQuery, Occur as FtsOccur, PhraseQuery as FtsPhraseQuery,
     },
 };
 use lance_io::ffi::to_ffi_arrow_array_stream;
@@ -174,6 +174,33 @@ pub(crate) fn build_full_text_search_query<'a>(
 
             Ok(FtsQuery::MultiMatch(query))
         }
+        "COMBINED_FIELDS" => {
+            let query_text = env.get_string_from_method(&java_obj, "getQueryText")?;
+            let columns: Vec<String> =
+                import_vec_from_method(env, &java_obj, "getColumns", |env, elem| {
+                    let jstr = JString::from(elem);
+                    let value: String = env.get_string(&jstr)?.into();
+                    Ok(value)
+                })?;
+
+            let boosts: Option<Vec<f32>> =
+                env.get_optional_from_method(&java_obj, "getBoosts", |env, list_obj| {
+                    import_vec_to_rust(env, &list_obj, |env, elem| {
+                        env.get_f32_from_method(&elem, "floatValue")
+                    })
+                })?;
+            let operator = env.get_fts_operator_from_method(&java_obj)?;
+
+            // Column uniqueness and boost (>= 1) validation live in the Rust core;
+            // `?` surfaces those errors across the JNI boundary.
+            let mut query = FtsCombinedFieldsQuery::try_new(query_text, columns)?;
+            if let Some(boosts) = boosts {
+                query = query.try_with_boosts(boosts)?;
+            }
+            query = query.with_operator(operator);
+
+            Ok(FtsQuery::CombinedFields(query))
+        }
         "BOOST" => {
             let positive_obj = env
                 .call_method(
diff --git a/java/src/main/java/org/lance/ipc/FullTextQuery.java b/java/src/main/java/org/lance/ipc/FullTextQuery.java
index 73badab9a49..193b3452ea0 100755
--- a/java/src/main/java/org/lance/ipc/FullTextQuery.java
+++ b/java/src/main/java/org/lance/ipc/FullTextQuery.java
@@ -36,6 +36,7 @@ public enum Type {
     MATCH_PHRASE,
     BOOST,
     MULTI_MATCH,
+    COMBINED_FIELDS,
     BOOLEAN
   }
 
@@ -156,6 +157,15 @@ public static FullTextQuery multiMatch(
     return new MultiMatchQuery(queryText, columns, boosts, operator);
   }
 
+  public static FullTextQuery combinedFields(String queryText, List<String> columns) {
+    return combinedFields(queryText, columns, null, Operator.OR);
+  }
+
+  public static FullTextQuery combinedFields(
+      String queryText, List<String> columns, List<Float> boosts, Operator operator) {
+    return new CombinedFieldsQuery(queryText, columns, boosts, operator);
+  }
+
   public static FullTextQuery boost(FullTextQuery positive, FullTextQuery negative) {
     return boost(positive, negative, 0.5f);
   }
@@ -431,6 +441,93 @@ public String toString() {
     }
   }
 
+  /**
+   * Combined-fields (BM25F) query across multiple columns.
+   *
+   * <p>Unlike {@link MultiMatchQuery}, which scores each column independently and keeps the best
+   * field, this query treats the target columns as a single virtual field so that term statistics
+   * are blended across fields (Lucene {@code CombinedFieldQuery}). A term that is rare in one field
+   * but common in another then scores consistently, and a single query term can match across fields
+   * (for example a first name in one column and a last name in another).
+   *
+   * <p>Target columns must be unique and share the same tokenizer/index configuration. When {@code
+   * boosts} is given, its length must equal the number of columns and each per-column weight must
+   * be finite and {@code >= 1} (fractional weights allowed); when {@code null}, every column
+   * defaults to {@code 1.0}. A {@code null} operator defaults to {@link Operator#OR}. These
+   * constraints are validated in the Rust core and surface as an exception when the query runs.
+   */
+  public static final class CombinedFieldsQuery extends FullTextQuery {
+    private final String queryText;
+    private final List<String> columns;
+    private final Optional<List<Float>> boosts;
+    private final Operator operator;
+
+    CombinedFieldsQuery(
+        String queryText, List<String> columns, List<Float> boosts, Operator operator) {
+      Preconditions.checkArgument(
+          queryText != null && !queryText.isEmpty(), "queryText must not be null or empty");
+      Preconditions.checkArgument(
+          columns != null && !columns.isEmpty(), "columns must not be null or empty");
+
+      this.queryText = queryText;
+      this.columns =
+          Collections.unmodifiableList(new java.util.ArrayList<>(Objects.requireNonNull(columns)));
+      this.boosts =
+          boosts == null
+              ? Optional.empty()
+              : Optional.of(Collections.unmodifiableList(new java.util.ArrayList<>(boosts)));
+      this.operator = operator == null ? Operator.OR : operator;
+    }
+
+    @Override
+    public Type getType() {
+      return Type.COMBINED_FIELDS;
+    }
+
+    public String getQueryText() {
+      return queryText;
+    }
+
+    public List<String> getColumns() {
+      return columns;
+    }
+
+    public Optional<List<Float>> getBoosts() {
+      return boosts;
+    }
+
+    public Operator getOperator() {
+      return operator;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (!(o instanceof CombinedFieldsQuery)) return false;
+      CombinedFieldsQuery other = (CombinedFieldsQuery) o;
+      return operator == other.operator
+          && Objects.equals(queryText, other.queryText)
+          && Objects.equals(columns, other.columns)
+          && Objects.equals(boosts, other.boosts);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(queryText, columns, operator, boosts);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("type", getType())
+          .add("queryText", queryText)
+          .add("columns", columns)
+          .add("boosts", boosts)
+          .add("operator", operator)
+          .toString();
+    }
+  }
+
   /** Boost query combining positive and negative queries. */
   public static final class BoostQuery extends FullTextQuery {
     private final FullTextQuery positive;
diff --git a/java/src/test/java/org/lance/ipc/FullTextQueryTest.java b/java/src/test/java/org/lance/ipc/FullTextQueryTest.java
index b84a19db4c8..7b6fe54784d 100755
--- a/java/src/test/java/org/lance/ipc/FullTextQueryTest.java
+++ b/java/src/test/java/org/lance/ipc/FullTextQueryTest.java
@@ -331,6 +331,101 @@ void testMultiMatchQueryInequalityDifferentBoosts() {
     assertFalse(a.equals(b), "MultiMatchQuery instances with different boosts must not be equal");
   }
 
+  @Test
+  void testCombinedFieldsWithoutBoosts() {
+    FullTextQuery.CombinedFieldsQuery q =
+        (FullTextQuery.CombinedFieldsQuery)
+            FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+
+    assertEquals(FullTextQuery.Type.COMBINED_FIELDS, q.getType());
+    assertEquals("hello", q.getQueryText());
+    assertEquals(Arrays.asList("title", "body"), q.getColumns());
+    assertFalse(q.getBoosts().isPresent());
+    assertEquals(FullTextQuery.Operator.OR, q.getOperator());
+  }
+
+  @Test
+  void testCombinedFieldsWithBoosts() {
+    FullTextQuery.CombinedFieldsQuery q =
+        (FullTextQuery.CombinedFieldsQuery)
+            FullTextQuery.combinedFields(
+                "hello",
+                Arrays.asList("title", "body"),
+                Arrays.asList(2.0f, 1.0f),
+                FullTextQuery.Operator.AND);
+
+    assertEquals(FullTextQuery.Type.COMBINED_FIELDS, q.getType());
+    assertTrue(q.getBoosts().isPresent());
+    assertEquals(2, q.getBoosts().get().size());
+    assertEquals(2.0f, q.getBoosts().get().get(0));
+    assertEquals(1.0f, q.getBoosts().get().get(1));
+    assertEquals(FullTextQuery.Operator.AND, q.getOperator());
+    assertNotNull(q.toString());
+  }
+
+  @Test
+  void testCombinedFieldsQueryEquality() {
+    FullTextQuery a = FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+    FullTextQuery b = FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+    assertEquals(a, b, "Two CombinedFieldsQuery instances with the same fields must be equal");
+    assertEquals(a.hashCode(), b.hashCode());
+  }
+
+  @Test
+  void testCombinedFieldsQueryInequalityDifferentOperator() {
+    FullTextQuery a =
+        FullTextQuery.combinedFields(
+            "hello", Arrays.asList("title", "body"), null, FullTextQuery.Operator.AND);
+    FullTextQuery b =
+        FullTextQuery.combinedFields(
+            "hello", Arrays.asList("title", "body"), null, FullTextQuery.Operator.OR);
+    assertFalse(
+        a.equals(b), "CombinedFieldsQuery instances with different operator must not be equal");
+  }
+
+  @Test
+  void testCombinedFieldsQueryInequalityDifferentBoosts() {
+    FullTextQuery a =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("title", "body"),
+            Arrays.asList(2.0f, 1.0f),
+            FullTextQuery.Operator.OR);
+    FullTextQuery b =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("title", "body"),
+            Arrays.asList(1.0f, 1.0f),
+            FullTextQuery.Operator.OR);
+    assertFalse(
+        a.equals(b), "CombinedFieldsQuery instances with different boosts must not be equal");
+  }
+
+  @Test
+  void testCombinedFieldsNotEqualMultiMatch() {
+    FullTextQuery combined = FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+    FullTextQuery multi = FullTextQuery.multiMatch("hello", Arrays.asList("title", "body"));
+    assertFalse(
+        combined.equals(multi),
+        "CombinedFieldsQuery and MultiMatchQuery must not be equal even with same fields");
+  }
+
+  @Test
+  void testCombinedFieldsBoostsDefensivelyCopied() {
+    java.util.List<Float> boosts = new java.util.ArrayList<>(Arrays.asList(2.0f, 1.0f));
+    FullTextQuery.CombinedFieldsQuery q =
+        (FullTextQuery.CombinedFieldsQuery)
+            FullTextQuery.combinedFields(
+                "hello", Arrays.asList("title", "body"), boosts, FullTextQuery.Operator.OR);
+
+    // Mutating the caller-provided list must not change the stored query.
+    boosts.set(0, 9.0f);
+    boosts.clear();
+
+    assertTrue(q.getBoosts().isPresent());
+    assertEquals(Arrays.asList(2.0f, 1.0f), q.getBoosts().get());
+  }
+
   @Test
   void testDifferentSubtypesNotEqual() {
     FullTextQuery match = FullTextQuery.match("hello", "body");
diff --git a/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java b/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java
index 06438d30706..e79b76a331f 100755
--- a/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java
+++ b/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java
@@ -49,6 +49,15 @@
 
 class LanceScannerFullTextSearchTest {
 
+  private static final List<String> DEFAULT_DOCUMENTS =
+      Arrays.asList("hello world", "hello lance", "other text");
+
+  private static ScalarIndexParams defaultIndexParams() {
+    return ScalarIndexParams.create(
+        "inverted",
+        "{\"base_tokenizer\":\"simple\",\"language\":\"English\",\"with_position\":true}");
+  }
+
   @Test
   void testMatchQuery() throws Exception {
     runFtsQuery(
@@ -120,6 +129,55 @@ void testMultiMatch() throws Exception {
     runFtsQuery("memory://fts_java_multimatch", multiMatch, 3);
   }
 
+  @Test
+  void testCombinedFields() throws Exception {
+    // "hello" appears in doc or title of every row, so all 3 match.
+    FullTextQuery combined = FullTextQuery.combinedFields("hello", Arrays.asList("doc", "title"));
+    runFtsQuery("memory://fts_java_combined", combined, 3);
+  }
+
+  @Test
+  void testCombinedFieldsWithBoosts() throws Exception {
+    FullTextQuery combined =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("doc", "title"),
+            Arrays.asList(2.0f, 1.0f),
+            FullTextQuery.Operator.OR);
+    runFtsQuery("memory://fts_java_combined_boosts", combined, 3);
+  }
+
+  @Test
+  void testCombinedFieldsInvalidBoostPropagates() throws Exception {
+    // Per-column weights must be >= 1. The check lives in the Rust core and must
+    // surface across the JNI boundary when the query runs.
+    FullTextQuery combined =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("doc", "title"),
+            Arrays.asList(0.5f, 1.0f),
+            FullTextQuery.Operator.OR);
+    withIndexedDataset(
+        "memory://fts_java_combined_bad_boost",
+        dataset -> {
+          ScanOptions scanOptions = new ScanOptions.Builder().fullTextQuery(combined).build();
+          IllegalArgumentException ex =
+              assertThrows(
+                  IllegalArgumentException.class,
+                  () -> {
+                    try (LanceScanner scanner = dataset.newScan(scanOptions);
+                        ArrowReader arrowReader = scanner.scanBatches()) {
+                      while (arrowReader.loadNextBatch()) {
+                        // Drain batches to force query execution.
+                      }
+                    }
+                  });
+          assertTrue(
+              ex.getMessage().contains("combined_fields boost for column 'doc'"),
+              "expected invalid-boost validation error, got: " + ex.getMessage());
+        });
+  }
+
   @Test
   void testBooleanQuery() throws Exception {
     FullTextQuery.MatchQuery shouldMatch =
@@ -139,16 +197,7 @@ void testBooleanQuery() throws Exception {
   }
 
   private void runFtsQuery(String uri, FullTextQuery query, long expectedTotal) throws Exception {
-    ScalarIndexParams indexParams =
-        ScalarIndexParams.create(
-            "inverted",
-            "{\"base_tokenizer\":\"simple\",\"language\":\"English\",\"with_position\":true}");
-    runFtsQuery(
-        uri,
-        query,
-        expectedTotal,
-        Arrays.asList("hello world", "hello lance", "other text"),
-        indexParams);
+    runFtsQuery(uri, query, expectedTotal, DEFAULT_DOCUMENTS, defaultIndexParams());
   }
 
   private void runFtsQuery(
@@ -158,7 +207,41 @@ private void runFtsQuery(
       List<String> documents,
       ScalarIndexParams scalarParams)
       throws Exception {
+    withIndexedDataset(
+        uri,
+        documents,
+        scalarParams,
+        dataset -> {
+          ScanOptions scanOptions = new ScanOptions.Builder().fullTextQuery(query).build();
+
+          try (LanceScanner scanner = dataset.newScan(scanOptions)) {
+            long total = 0L;
+            try (ArrowReader arrowReader = scanner.scanBatches()) {
+              while (arrowReader.loadNextBatch()) {
+                total += arrowReader.getVectorSchemaRoot().getRowCount();
+              }
+            }
+            assertEquals(expectedTotal, total);
+          }
+        });
+  }
+
+  /** Same dataset as the three-argument {@link #runFtsQuery}, without running a query on it. */
+  private void withIndexedDataset(String uri, IndexedDatasetConsumer consumer) throws Exception {
+    withIndexedDataset(uri, DEFAULT_DOCUMENTS, defaultIndexParams(), consumer);
+  }
 
+  /**
+   * Create an in-memory dataset with two text columns ({@code doc}, {@code title}), each backed by
+   * an inverted index, and hand it to {@code consumer}. Resources are released when the consumer
+   * returns.
+   */
+  private void withIndexedDataset(
+      String uri,
+      List<String> documents,
+      ScalarIndexParams scalarParams,
+      IndexedDatasetConsumer consumer)
+      throws Exception {
     Schema schema =
         new Schema(
             Arrays.asList(
@@ -212,20 +295,15 @@ private void runFtsQuery(
                     .withIndexName("title_idx")
                     .build());
 
-            ScanOptions scanOptions = new ScanOptions.Builder().fullTextQuery(query).build();
-
-            try (LanceScanner scanner = dataset.newScan(scanOptions)) {
-              long total = 0L;
-              try (ArrowReader arrowReader = scanner.scanBatches()) {
-                while (arrowReader.loadNextBatch()) {
-                  total += arrowReader.getVectorSchemaRoot().getRowCount();
-                }
-              }
-              assertEquals(expectedTotal, total);
-            }
+            consumer.accept(dataset);
           }
         }
       }
     }
   }
+
+  @FunctionalInterface
+  private interface IndexedDatasetConsumer {
+    void accept(Dataset dataset) throws Exception;
+  }
 }