@@ -418,10 +418,9 @@ Status CluceneTextIndexReader::_run_leaf(const IndexQueryContextPtr& context,
                                          const logical::Node& leaf,
                                          const roaring::Roaring* candidates, bool scoring,
                                          std::shared_ptr<roaring::Roaring>* out) {
-    const bool publish_scores = scoring && leaf.as<logical::Expand>() == nullptr;
     auto result = std::make_shared<roaring::Roaring>();
     RETURN_IF_ERROR(run_clucene_leaf(context, StringUtil::string_to_wstring(column_name), leaf,
-                                     candidates, publish_scores,
+                                     candidates, scoring,
                                      static_cast<CluceneOpenedIndex&>(index).searcher, result));
     result->runOptimize();
     *out = std::move(result);
 
@@ -72,14 +72,15 @@ class PhrasePrefixQuery : public Query {
             return nullptr;
         }
 
-        SimilarityPtr bm25_similarity;
+        std::shared_ptr<BM25Similarity> bm25_similarity;
         if (enable_scoring) {
             bm25_similarity = std::make_shared<BM25Similarity>();
             std::vector<std::wstring> all_terms;
             for (const auto& phrase_term : _phrase_terms) {
                 all_terms.push_back(StringHelper::to_wstring(phrase_term.second));
             }
-            bm25_similarity->for_terms(_context, _field, all_terms);
+            bm25_similarity->for_terms_and_prefix(_context, _field, all_terms,
+                                                  StringHelper::to_wstring(_prefix.value().second));
         }
 
         return std::make_shared<PhrasePrefixWeight>(
 
@@ -92,6 +92,18 @@ void BM25Similarity::for_terms(const IndexQueryContextPtr& context, const std::w
     compute_tf_cache();
 }
 
+void BM25Similarity::for_terms_and_prefix(const IndexQueryContextPtr& context,
+                                          const std::wstring& field_name,
+                                          const std::vector<std::wstring>& terms,
+                                          const std::wstring& prefix) {
+    std::vector<std::wstring> all_terms = terms;
+    for (auto& expansion :
+         context->collection_statistics->get_prefix_expansions(field_name, prefix)) {
+        all_terms.push_back(std::move(expansion));
+    }
+    for_terms(context, field_name, all_terms);
+}
+
 float BM25Similarity::score(float freq, int64_t encoded_norm) {
     float norm_inverse = _cache[((uint8_t)encoded_norm) & 0xFF];
     return _weight - _weight / (1.0F + freq * norm_inverse);
 
@@ -37,6 +37,15 @@ class BM25Similarity : public Similarity {
     void for_terms(const IndexQueryContextPtr& context, const std::wstring& field_name,
                    const std::vector<std::wstring>& terms) override;
 
+    // for_terms of `terms` and of every term the tablet expanded `prefix` to, so that a phrase
+    // prefix is scored on the idf of the terms it matches, as Lucene's multi-phrase query does.
+    //
+    // Example: "quick bro" over a tablet holding brother and brown is scored on
+    // idf(quick) + idf(brother) + idf(brown), so a row with the rare brother ranks above one with
+    // the common brown.
+    void for_terms_and_prefix(const IndexQueryContextPtr& context, const std::wstring& field_name,
+                              const std::vector<std::wstring>& terms, const std::wstring& prefix);
+
     float score(float freq, int64_t encoded_norm) override;
     float max_score() override;
     void bind_norms(std::span<const float> lengths) override;
 
@@ -22,6 +22,7 @@
 #include <iterator>
 #include <set>
 #include <sstream>
+#include <unordered_set>
 
 #include "common/exception.h"
 #include "core/column/column_vector.h"
@@ -40,6 +41,7 @@
 #include "storage/index/inverted/clucene/spi/clucene_index_source.h"
 #include "storage/index/inverted/common/inverted_index_cache.h"
 #include "storage/index/inverted/common/string_helper.h"
+#include "storage/index/inverted/query/exec/term_pattern.h"
 #include "storage/index/inverted/snii/reader/snii_index_source.h"
 #include "storage/index/inverted/snii/snii_doris_adapter.h"
 #include "storage/iterators.h"
@@ -117,6 +119,35 @@ void add_term_doc_frequency(
     (*logical_frequencies)[field][logical_term] += doc_frequency;
 }
 
+Status segment_scoring_terms(index_query::IndexSource& source, const CollectInfo& collect_info,
+                             std::unordered_map<std::wstring, std::set<std::wstring>>* expansions,
+                             std::vector<std::string>* terms) {
+    DORIS_CHECK(expansions != nullptr);
+    DORIS_CHECK(terms != nullptr);
+    *terms = collect_info.unique_terms;
+    std::unordered_set<std::string> listed(terms->begin(), terms->end());
+    for (const auto& scoring_prefix : collect_info.scoring_prefixes) {
+        index_query::TermPattern pattern;
+        RETURN_IF_ERROR(index_query::TermPattern::create(index_query::TermPatternKind::kPrefix,
+                                                         scoring_prefix.prefix, &pattern));
+        std::vector<std::string> expanded;
+        RETURN_IF_ERROR(source.expand_terms(
+                pattern,
+                index_query::expansion_limit(index_query::TermPatternKind::kPrefix,
+                                             scoring_prefix.max_expansions),
+                &expanded));
+        auto& prefix_terms = (*expansions)[segment_v2::inverted_index::StringHelper::to_wstring(
+                scoring_prefix.prefix)];
+        for (auto& term : expanded) {
+            prefix_terms.insert(segment_v2::inverted_index::StringHelper::to_wstring(term));
+            if (listed.insert(term).second) {
+                terms->push_back(std::move(term));
+            }
+        }
+    }
+    return Status::OK();
+}
+
 Status sum_non_null_norm_lengths(index_query::IndexSource& source,
                                  std::span<const uint32_t> null_docs, uint64_t* out) {
     if (!null_docs.empty() && null_docs.back() >= source.doc_count()) {
@@ -513,7 +544,11 @@ Status CollectionStatistics::process_segment(const RowsetSharedPtr& rowset,
                     segment_v2::IndexReaderHelper::is_normalizer_only(
                             collect_info.index_meta->properties())));
 
-            for (const auto& logical_term_bytes : collect_info.unique_terms) {
+            std::vector<std::string> segment_terms;
+            RETURN_IF_ERROR(collection_statistics_detail::segment_scoring_terms(
+                    source, collect_info, &segment_accumulator.prefix_expansions[ws_field_name],
+                    &segment_terms));
+            for (const auto& logical_term_bytes : segment_terms) {
                 const auto logical_term =
                         segment_v2::inverted_index::StringHelper::to_wstring(logical_term_bytes);
                 uint64_t doc_frequency = 0;
@@ -647,7 +682,10 @@ Status CollectionStatistics::process_segment(const RowsetSharedPtr& rowset,
         _total_num_tokens[ws_field_name] +=
                 scoring_stats.has_norms ? scoring_stats.token_count : scoring_stats.doc_count;
 
-        for (const auto& logical_term_bytes : collect_info.unique_terms) {
+        std::vector<std::string> segment_terms;
+        RETURN_IF_ERROR(collection_statistics_detail::segment_scoring_terms(
+                *source, collect_info, &_prefix_expansions[ws_field_name], &segment_terms));
+        for (const auto& logical_term_bytes : segment_terms) {
             const auto logical_term =
                     segment_v2::inverted_index::StringHelper::to_wstring(logical_term_bytes);
             uint64_t doc_frequency = 0;
@@ -703,6 +741,11 @@ void CollectionStatistics::commit_snii_scoring_segment(
             _term_doc_freqs[field_name][term] += doc_freq;
         }
     }
+    for (const auto& [field_name, prefixes] : segment_accumulator.prefix_expansions) {
+        for (const auto& [prefix, terms] : prefixes) {
+            _prefix_expansions[field_name][prefix].insert(terms.begin(), terms.end());
+        }
+    }
     _total_num_docs += segment_accumulator.doc_count;
     _avg_dl_by_col.clear();
     _idf_by_col_term.clear();
@@ -713,6 +756,7 @@ void CollectionStatistics::clear() {
     _counted_hidden_docs = false;
     _total_num_tokens.clear();
     _term_doc_freqs.clear();
+    _prefix_expansions.clear();
     _avg_dl_by_col.clear();
     _idf_by_col_term.clear();
 }
@@ -722,6 +766,7 @@ void CollectionStatistics::copy_collected_from(const CollectionStatistics& other
     _counted_hidden_docs = other._counted_hidden_docs;
     _total_num_tokens = other._total_num_tokens;
     _term_doc_freqs = other._term_doc_freqs;
+    _prefix_expansions = other._prefix_expansions;
     _avg_dl_by_col.clear();
     _idf_by_col_term.clear();
 }
@@ -801,6 +846,27 @@ float CollectionStatistics::get_or_calculate_avg_dl(const std::wstring& lucene_c
     return avg_dl;
 }
 
+std::vector<std::wstring> CollectionStatistics::get_prefix_expansions(
+        const std::wstring& lucene_col_name, const std::wstring& prefix) {
+    const auto field = _prefix_expansions.find(lucene_col_name);
+    if (field == _prefix_expansions.end()) {
+        return {};
+    }
+    const auto expansions = field->second.find(prefix);
+    if (expansions == field->second.end()) {
+        return {};
+    }
+    // A merge-on-write scan hides rows: a term whose documents are all hidden was expanded in
+    // its segment but has no document frequency left, and its idf would be that of an absent term.
+    std::vector<std::wstring> terms;
+    for (const auto& term : expansions->second) {
+        if (get_term_doc_freq_by_col(lucene_col_name, term) > 0) {
+            terms.push_back(term);
+        }
+    }
+    return terms;
+}
+
 float CollectionStatistics::get_or_calculate_idf(const std::wstring& lucene_col_name,
                                                  const std::wstring& term) {
     auto iter = _idf_by_col_term.find(lucene_col_name);
 
@@ -21,6 +21,7 @@
 #include <functional>
 #include <mutex>
 #include <optional>
+#include <set>
 #include <span>
 #include <string>
 #include <string_view>
@@ -106,15 +107,27 @@ class CollectionStatistics {
                                              const std::wstring& term);
     MOCK_FUNCTION float get_or_calculate_avg_dl(const std::wstring& lucene_col_name);
 
+    // The terms the collected `prefix` expanded to in any segment of the tablet and that some
+    // returned row holds, in dictionary order; their idfs are in get_or_calculate_idf. None for a
+    // prefix that was not collected, as for a SEARCH predicate.
+    MOCK_FUNCTION std::vector<std::wstring> get_prefix_expansions(
+            const std::wstring& lucene_col_name, const std::wstring& prefix);
+
     // Replaces the collected counters with those of `other`. The derived idf/avgdl caches are
     // reset rather than copied, so the copy can be used by another thread without sharing them.
     void copy_collected_from(const CollectionStatistics& other);
 
 private:
+    // The terms each collected prefix expanded to, by field and prefix.
+    using PrefixExpansions =
+            std::unordered_map<std::wstring,
+                               std::unordered_map<std::wstring, std::set<std::wstring>>>;
+
     struct SniiScoringSegmentAccumulator {
         uint64_t doc_count = 0;
         std::unordered_map<std::wstring, uint64_t> token_counts;
         std::unordered_map<std::wstring, std::unordered_map<std::wstring, uint64_t>> term_doc_freqs;
+        PrefixExpansions prefix_expansions;
     };
 
     Status extract_collect_info(RuntimeState* state,
@@ -143,6 +156,7 @@ class CollectionStatistics {
     bool _counted_hidden_docs = false;
     std::unordered_map<std::wstring, uint64_t> _total_num_tokens;
     std::unordered_map<std::wstring, std::unordered_map<std::wstring, uint64_t>> _term_doc_freqs;
+    PrefixExpansions _prefix_expansions;
 
     std::unordered_map<std::wstring, float> _avg_dl_by_col;
     std::unordered_map<std::wstring, std::unordered_map<std::wstring, float>> _idf_by_col_term;
@@ -230,6 +244,17 @@ Status exclude_hidden_docs(std::span<const uint32_t> hidden_docs, const roaring:
                            const SumNormLengthsOf& sum_norm_lengths_of,
                            index_query::IndexScoringStats* stats);
 
+// The terms whose document frequencies a segment adds for `collect_info`: its scoring terms, then
+// each term its prefixes expand to in `source`, so that a phrase prefix is scored on the same
+// tablet statistics as the other terms. A term met twice is listed once, as its documents count
+// once. The expansions of each prefix, of this segment alone, are added to `expansions`.
+//
+// Example: "red r" collects red and, in a segment holding red, rose and run, the terms red (already
+// listed), rose and run, and records {red, rose, run} for the prefix "r".
+Status segment_scoring_terms(index_query::IndexSource& source, const CollectInfo& collect_info,
+                             std::unordered_map<std::wstring, std::set<std::wstring>>* expansions,
+                             std::vector<std::string>* terms);
+
 // Takes from a term's document frequency the documents of `hidden_docs` that hold it.
 Status exclude_hidden_term_docs(index_query::IndexSource& source, std::string_view term,
                                 std::span<const uint32_t> hidden_docs, uint64_t* doc_frequency);
 
@@ -19,6 +19,8 @@
 
 #include <glog/logging.h>
 
+#include <algorithm>
+#include <optional>
 #include <vector>
 
 #include "exec/common/variant_util.h"
@@ -30,6 +32,7 @@
 #include "storage/index/index_reader_helper.h"
 #include "storage/index/inverted/analysis/analyzer/analyzer.h"
 #include "storage/index/inverted/common/string_helper.h"
+#include "storage/index/inverted/query/exec/term_pattern.h"
 #include "storage/index/inverted/reader/inverted_index_selector.h"
 #include "storage/tablet/tablet_schema.h"
 #include "storage/utils.h"
@@ -116,6 +119,21 @@ Status append_scoring_leaf(CollectInfo* collect_info, const std::vector<TermInfo
     return Status::OK();
 }
 
+void append_scoring_prefix(CollectInfo* collect_info, const TermInfo& prefix,
+                           int32_t max_expansions) {
+    DORIS_CHECK(collect_info != nullptr);
+    DORIS_CHECK(prefix.is_single_term());
+    const auto& text = prefix.get_single_term();
+    const bool known = std::ranges::any_of(
+            collect_info->scoring_prefixes, [&](const LogicalScoringPrefix& registered) {
+                return registered.prefix == text && registered.max_expansions == max_expansions;
+            });
+    if (!known) {
+        collect_info->scoring_prefixes.push_back(
+                LogicalScoringPrefix {.prefix = text, .max_expansions = max_expansions});
+    }
+}
+
 InvertedIndexQueryType match_query_type(TExprOpcode::type opcode) {
     switch (opcode) {
     case TExprOpcode::MATCH_ANY:
@@ -356,7 +374,13 @@ Status MatchPredicateCollector::collect(RuntimeState* state, const TabletSchemaS
     auto options = DataTypeSerDe::get_default_format_options();
     options.timezone = &state->timezone_obj();
     auto term_infos = DORIS_TRY(analyze_plain_query(right_literal->value(options), *analyzer_ctx));
+    // The prefix of a phrase prefix is scored by the terms it expands to, so the statistics are
+    // collected for them per segment; a prefix alone scores a constant and needs none.
+    std::optional<TermInfo> scoring_prefix;
     if (expr->op() == TExprOpcode::MATCH_PHRASE_PREFIX && !term_infos.empty()) {
+        if (term_infos.size() > 1) {
+            scoring_prefix = term_infos.back();
+        }
         term_infos.pop_back();
     }
 
@@ -369,11 +393,14 @@ Status MatchPredicateCollector::collect(RuntimeState* state, const TabletSchemaS
         CollectInfo collect_info;
         RETURN_IF_ERROR(append_scoring_leaf(&collect_info, term_infos));
         preserve_selected_index_metadata(candidates, index_meta, &collect_info);
-        (*collect_infos)[ws_field_name] = std::move(collect_info);
+        iter = collect_infos->emplace(ws_field_name, std::move(collect_info)).first;
     } else {
         RETURN_IF_ERROR(validate_same_physical_index(iter->second, *index_meta));
         RETURN_IF_ERROR(append_scoring_leaf(&iter->second, term_infos));
     }
+    if (scoring_prefix.has_value()) {
+        append_scoring_prefix(&iter->second, *scoring_prefix, index_query::max_expansions(state));
+    }
 
     return Status::OK();
 }
 
@@ -56,9 +56,17 @@ struct LogicalScoringLeaf {
     std::vector<LogicalScoringClause> clauses;
 };
 
+// The last term of a scored phrase prefix, whose idf is the sum of the idfs of the terms it
+// expands to, as many as `max_expansions` in each segment.
+struct LogicalScoringPrefix {
+    std::string prefix;
+    int32_t max_expansions = 0;
+};
+
 struct CollectInfo {
     std::vector<std::string> unique_terms;
     std::unordered_map<std::string, uint32_t> unique_term_slots;
+    std::vector<LogicalScoringPrefix> scoring_prefixes;
     std::vector<LogicalScoringLeaf> logical_scoring_leaves;
     std::shared_ptr<const TabletIndex> owned_index_meta;
     const TabletIndex* index_meta = nullptr;
@@ -78,6 +86,9 @@ Result<std::vector<segment_v2::TermInfo>> analyze_plain_query(
         const std::string& value, const InvertedIndexAnalyzerCtx& analyzer_ctx);
 Status append_scoring_leaf(CollectInfo* collect_info,
                            const std::vector<segment_v2::TermInfo>& term_infos);
+// Registers the prefix of a scored phrase prefix once, however many predicates repeat it.
+void append_scoring_prefix(CollectInfo* collect_info, const segment_v2::TermInfo& prefix,
+                           int32_t max_expansions);
 Result<const TabletIndex*> select_index_meta(const std::vector<const TabletIndex*>& index_metas,
                                              FieldType field_type,
                                              segment_v2::InvertedIndexQueryType query_type,
Original file line number	Diff line number	Diff line change
`@@ -72,14 +72,15 @@ class PhrasePrefixQuery : public Query {`
`72`	`72`	`return nullptr;`
`73`	`73`	`}`
`74`	`74`
`75`		`- SimilarityPtr bm25_similarity;`
	`75`	`+ std::shared_ptr<BM25Similarity> bm25_similarity;`
`76`	`76`	`if (enable_scoring) {`
`77`	`77`	`bm25_similarity = std::make_shared<BM25Similarity>();`
`78`	`78`	`std::vector<std::wstring> all_terms;`
`79`	`79`	`for (const auto& phrase_term : _phrase_terms) {`
`80`	`80`	`all_terms.push_back(StringHelper::to_wstring(phrase_term.second));`
`81`	`81`	`}`
`82`		`- bm25_similarity->for_terms(_context, _field, all_terms);`
	`82`	`+ bm25_similarity->for_terms_and_prefix(_context, _field, all_terms,`
	`83`	`+ StringHelper::to_wstring(_prefix.value().second));`
`83`	`84`	`}`
`84`	`85`
`85`	`86`	`return std::make_shared<PhrasePrefixWeight>(`