[refactor](inverted-index) replace void* query_value with typed param interface

Production query path no longer carries a const void* + reinterpret_cast
through InvertedIndexReader::query / try_query. Three classes with
distinct responsibilities replace the old conflated InvertedIndexQueryParamFactory:

  * InvertedIndexQueryParam            — abstract value interface; readers
                                          pull the value via typed virtuals
                                          (get_string / encode_ascending /
                                          encode_min_ascending /
                                          encode_max_ascending).
  * TypedInvertedIndexQueryParam<PT>   — concrete typed value; numeric/
                                          date/decimal/IP specialisation
                                          implements the encode_* virtuals
                                          using type_limit<>; string
                                          specialisation implements
                                          get_string only.
  * InvertedIndexQueryParamFactory     — static-only namespace class that
                                          maps FE values onto the correct
                                          TypedInvertedIndexQueryParam<PT>;
                                          no instances, no inheritance.

BkdIndexReader::construct_bkd_query_value drops the std::vector<char>
tmp scratch buffer and the _type_info->set_to_min/max calls used to
synthesize +/-infinity sentinels for half-bounded range queries. The
sentinel is now produced directly by the typed query value
(encode_min_ascending / encode_max_ascending), so only inverted-index
supported types ever need to know how to emit a min/max.

With BKD no longer the only consumer, the entire TypeInfo::set_to_min/max
API surface is removed: TypeInfo virtuals, ScalarTypeInfo storage,
List/Map/Struct DCHECK-fail overrides, every FieldTypeTraits<...>
specialization, the OLAP_FIELD_TYPE_CHAR static function pointer in
types.cpp, Field::set_to_min/max wrappers, and the CharField/VarcharField
/StringField overrides. Corresponding storage_types_test cases are removed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: csun5285

be/src/core/type_limit.h

@@ -17,8 +17,10 @@
 
 #pragma once
 
+#include "core/decimal12.h"
 #include "core/extended_types.h"
 #include "core/string_ref.h"
+#include "core/uint24.h"
 #include "core/value/decimalv2_value.h"
 #include "core/value/timestamptz_value.h"
 
@@ -54,6 +56,24 @@ struct type_limit<DecimalV2Value> {
     static DecimalV2Value max() { return DecimalV2Value::get_max_decimal(); }
 };
 
+// std::numeric_limits is not specialised for these custom storage types, so
+// the generic type_limit would return T() = zero for both min and max,
+// silently breaking BKD half-bounded range queries.
+
+// DECIMALV2 storage. Largest representable DecimalV2 value (18 digits . 9 digits).
+template <>
+struct type_limit<decimal12_t> {
+    static decimal12_t min() { return decimal12_t {-999999999999999999LL, -999999999}; }
+    static decimal12_t max() { return decimal12_t {+999999999999999999LL, +999999999}; }
+};
+
+// DATE storage. Packed as `year<<9 | month<<5 | day`: 33=0001-01-01, 5119903=9999-12-31.
+template <>
+struct type_limit<uint24_t> {
+    static uint24_t min() { return uint24_t(33); }
+    static uint24_t max() { return uint24_t(5119903); }
+};
+
 template <>
 struct type_limit<Decimal32> {
     static Decimal32 max() { return 999999999; }

be/src/exprs/function/array/function_array_index.h

@@ -45,6 +45,7 @@
 #include "core/types.h"
 #include "exprs/function/function.h"
 #include "storage/index/index_reader_helper.h"
+#include "storage/index/inverted/inverted_index_query_param.h"
 #include "storage/index/inverted/inverted_index_query_type.h"
 #include "storage/index/inverted/inverted_index_reader.h"
 #include "storage/predicate/column_predicate.h"
@@ -164,13 +165,13 @@ class FunctionArrayIndex : public IFunction {
             RETURN_IF_ERROR(iter->read_null_bitmap(&null_bitmap_cache_handle));
             null_bitmap = null_bitmap_cache_handle.get_bitmap();
         }
-        std::unique_ptr<InvertedIndexQueryParamFactory> query_param = nullptr;
+        std::unique_ptr<InvertedIndexQueryParam> query_param = nullptr;
         RETURN_IF_ERROR(InvertedIndexQueryParamFactory::create_query_value(param_type, &param_value,
                                                                            query_param));
         InvertedIndexParam param;
         param.column_name = data_type_with_name.first;
         param.column_type = data_type_with_name.second;
-        param.query_value = query_param->get_value();
+        param.query_value = std::move(query_param);
         param.query_type = segment_v2::InvertedIndexQueryType::EQUAL_QUERY;
         param.num_rows = num_rows;
         param.roaring = std::make_shared<roaring::Roaring>();

be/src/exprs/function/array/function_arrays_overlap.h

@@ -246,7 +246,7 @@ class FunctionArraysOverlap : public IFunction {
             RETURN_IF_ERROR(iter->read_null_bitmap(&null_bitmap_cache_handle));
             null_bitmap = null_bitmap_cache_handle.get_bitmap();
         }
-        std::unique_ptr<InvertedIndexQueryParamFactory> query_param = nullptr;
+        std::unique_ptr<InvertedIndexQueryParam> query_param = nullptr;
         const Array& query_val = param_value.get<TYPE_ARRAY>();
 
         InvertedIndexParam param;
@@ -262,7 +262,7 @@ class FunctionArraysOverlap : public IFunction {
             }
             RETURN_IF_ERROR(InvertedIndexQueryParamFactory::create_query_value(
                     nested_param_type, &nested_query_val, query_param));
-            param.query_value = query_param->get_value();
+            param.query_value = std::move(query_param);
             param.roaring = std::make_shared<roaring::Roaring>();
             param.analyzer_ctx = analyzer_ctx;
             RETURN_IF_ERROR(iter->read_from_index(segment_v2::IndexParam {&param}));

be/src/exprs/function/function_ip.h

@@ -48,6 +48,7 @@
 #include "exprs/function/function.h"
 #include "exprs/function/function_helpers.h"
 #include "storage/index/index_reader_helper.h"
+#include "storage/index/inverted/inverted_index_query_param.h"
 
 namespace doris {
 
@@ -708,7 +709,7 @@ class FunctionIsIPAddressInRange : public IFunction {
         std::shared_ptr<roaring::Roaring> null_bitmap = std::make_shared<roaring::Roaring>();
 
         auto param_type = data_type_with_name.second->get_primitive_type();
-        std::unique_ptr<segment_v2::InvertedIndexQueryParamFactory> query_param = nullptr;
+        std::unique_ptr<segment_v2::InvertedIndexQueryParam> query_param = nullptr;
 
         // >= min ip
         RETURN_IF_ERROR(segment_v2::InvertedIndexQueryParamFactory::create_query_value(
@@ -717,7 +718,7 @@ class FunctionIsIPAddressInRange : public IFunction {
         min_param.column_name = data_type_with_name.first;
         min_param.column_type = data_type_with_name.second;
         min_param.query_type = segment_v2::InvertedIndexQueryType::GREATER_EQUAL_QUERY;
-        min_param.query_value = query_param->get_value();
+        min_param.query_value = std::move(query_param);
         min_param.num_rows = num_rows;
         min_param.roaring = std::make_shared<roaring::Roaring>();
         RETURN_IF_ERROR(iter->read_from_index(&min_param));
@@ -729,7 +730,7 @@ class FunctionIsIPAddressInRange : public IFunction {
         max_param.column_name = data_type_with_name.first;
         max_param.column_type = data_type_with_name.second;
         max_param.query_type = segment_v2::InvertedIndexQueryType::LESS_EQUAL_QUERY;
-        max_param.query_value = query_param->get_value();
+        max_param.query_value = std::move(query_param);
         max_param.num_rows = num_rows;
         max_param.roaring = std::make_shared<roaring::Roaring>();
         RETURN_IF_ERROR(iter->read_from_index(&max_param));

be/src/exprs/function/function_multi_match.cpp

@@ -28,6 +28,7 @@
 #include "exprs/function/simple_function_factory.h"
 #include "exprs/vslot_ref.h"
 #include "io/fs/file_reader.h"
+#include "storage/index/inverted/inverted_index_query_param.h"
 #include "storage/index/inverted/query/phrase_prefix_query.h"
 #include "storage/segment/segment_iterator.h"
 
@@ -79,13 +80,15 @@ Status FunctionMultiMatch::evaluate_inverted_index(
         return Status::Error<ErrorCode::INDEX_INVALID_PARAMETERS>(
                 "arguments for multi_match must be string");
     }
-    // Must convert StringRef to std::string because downstream readers
-    // (e.g. FullTextIndexReader::query) reinterpret_cast query_value as std::string*.
-    std::string query_str(query_str_ref.data, query_str_ref.size);
+    // Wrap the query string in a typed InvertedIndexQueryParam so the reader
+    // can pull it via get_string() instead of relying on a void*->std::string
+    // reinterpret_cast.
+    auto query_param = segment_v2::TypedInvertedIndexQueryParam<TYPE_STRING>::create_unique();
+    query_param->set_value(&query_str_ref);
 
     // search
     InvertedIndexParam param;
-    param.query_value = &query_str;
+    param.query_value = std::move(query_param);
     param.query_type = query_type;
     param.num_rows = num_rows;
     for (size_t i = 0; i < data_type_with_names.size(); i++) {

be/src/exprs/function/functions_comparison.h

@@ -40,6 +40,7 @@
 #include "exprs/function/function_helpers.h"
 #include "exprs/function/functions_logical.h"
 #include "storage/index/index_reader_helper.h"
+#include "storage/index/inverted/inverted_index_query_param.h"
 
 namespace doris {
 
@@ -487,14 +488,14 @@ class FunctionComparison : public IFunction {
             return Status::OK();
         }
         auto param_type = arguments[0].type->get_primitive_type();
-        std::unique_ptr<segment_v2::InvertedIndexQueryParamFactory> query_param = nullptr;
+        std::unique_ptr<segment_v2::InvertedIndexQueryParam> query_param = nullptr;
         RETURN_IF_ERROR(segment_v2::InvertedIndexQueryParamFactory::create_query_value(
                 param_type, &param_value, query_param));
 
         segment_v2::InvertedIndexParam param;
         param.column_name = data_type_with_name.first;
         param.column_type = data_type_with_name.second;
-        param.query_value = query_param->get_value();
+        param.query_value = std::move(query_param);
         param.query_type = query_type;
         param.num_rows = num_rows;
         param.roaring = std::make_shared<roaring::Roaring>();

be/src/exprs/function/in.h

@@ -46,6 +46,7 @@
 #include "exprs/function_context.h"
 #include "exprs/hybrid_set.h"
 #include "storage/index/index_reader_helper.h"
+#include "storage/index/inverted/inverted_index_query_param.h"
 
 namespace doris {
 
@@ -170,14 +171,14 @@ class FunctionIn : public IFunction {
                 *roaring |= *null_bitmap;
                 continue;
             }
-            std::unique_ptr<InvertedIndexQueryParamFactory> query_param = nullptr;
+            std::unique_ptr<InvertedIndexQueryParam> query_param = nullptr;
             RETURN_IF_ERROR(InvertedIndexQueryParamFactory::create_query_value(
                     param_type, &param_value, query_param));
             InvertedIndexQueryType query_type = InvertedIndexQueryType::EQUAL_QUERY;
             segment_v2::InvertedIndexParam param;
             param.column_name = data_type_with_name.first;
             param.column_type = data_type_with_name.second;
-            param.query_value = query_param->get_value();
+            param.query_value = std::move(query_param);
             param.query_type = query_type;
             param.num_rows = num_rows;
             param.roaring = std::make_shared<roaring::Roaring>();

be/src/exprs/function/match.cpp

@@ -23,6 +23,7 @@
 #include "runtime/runtime_state.h"
 #include "storage/index/index_reader_helper.h"
 #include "storage/index/inverted/analyzer/analyzer.h"
+#include "storage/index/inverted/inverted_index_query_param.h"
 #include "util/debug_points.h"
 
 namespace doris {
@@ -79,14 +80,14 @@ Status FunctionMatchBase::evaluate_inverted_index(
         return Status::Error<ErrorCode::INDEX_INVALID_PARAMETERS>(
                 "arguments for match must be string");
     }
-    std::unique_ptr<InvertedIndexQueryParamFactory> query_param = nullptr;
+    std::unique_ptr<InvertedIndexQueryParam> query_param = nullptr;
     RETURN_IF_ERROR(InvertedIndexQueryParamFactory::create_query_value(param_type, &param_value,
                                                                        query_param));
 
     InvertedIndexParam param;
     param.column_name = data_type_with_name.first;
     param.column_type = data_type_with_name.second;
-    param.query_value = query_param->get_value();
+    param.query_value = std::move(query_param);
     param.query_type = get_query_type_from_fn_name();
     param.num_rows = num_rows;
     param.roaring = std::make_shared<roaring::Roaring>();

be/src/storage/field.h

@@ -64,10 +64,6 @@ class StorageField {
     const std::string& name() const { return _name; }
     const PathInDataPtr& path() const { return _path; }
 
-    virtual void set_to_max(char* buf) const { return _type_info->set_to_max(buf); }
-
-    virtual void set_to_min(char* buf) const { return _type_info->set_to_min(buf); }
-
     virtual StorageField* clone() const {
         auto* local = new StorageField(_desc);
         this->clone(local);
@@ -172,12 +168,6 @@ class CharField : public StorageField {
         StorageField::clone(local);
         return local;
     }
-
-    void set_to_max(char* ch) const override {
-        auto slice = reinterpret_cast<Slice*>(ch);
-        slice->size = _length;
-        memset(slice->data, 0xFF, slice->size);
-    }
 };
 
 class VarcharField : public StorageField {
@@ -189,12 +179,6 @@ class VarcharField : public StorageField {
         StorageField::clone(local);
         return local;
     }
-
-    void set_to_max(char* ch) const override {
-        auto slice = reinterpret_cast<Slice*>(ch);
-        slice->size = _length - OLAP_VARCHAR_MAX_BYTES;
-        memset(slice->data, 0xFF, slice->size);
-    }
 };
 class StringField : public StorageField {
 public:
@@ -205,11 +189,6 @@ class StringField : public StorageField {
         StorageField::clone(local);
         return local;
     }
-
-    void set_to_max(char* ch) const override {
-        auto slice = reinterpret_cast<Slice*>(ch);
-        memset(slice->data, 0xFF, slice->size);
-    }
 };
 
 class BitmapAggField : public StorageField {

be/src/storage/index/inverted/inverted_index_iterator.cpp

@@ -88,8 +88,8 @@ Status InvertedIndexIterator::read_from_index(const IndexParam& param) {
                     runtime_state->query_options().inverted_index_skip_threshold;
             size_t hit_count = 0;
             RETURN_IF_ERROR(try_read_from_inverted_index(reader, i_param->column_name,
-                                                         i_param->query_value, i_param->query_type,
-                                                         &hit_count));
+                                                         i_param->query_value.get(),
+                                                         i_param->query_type, &hit_count));
             if (hit_count > i_param->num_rows * query_bkd_limit_percent / 100) {
                 return Status::Error<ErrorCode::INVERTED_INDEX_BYPASS>(
                         "hit count: {}, bkd inverted reached limit {}% , segment num "
@@ -101,7 +101,7 @@ Status InvertedIndexIterator::read_from_index(const IndexParam& param) {
 
     // Note: analyzer_ctx is now passed via i_param->analyzer_ctx
     auto execute_query = [&]() {
-        return reader->query(_context, i_param->column_name, i_param->query_value,
+        return reader->query(_context, i_param->column_name, i_param->query_value.get(),
                              i_param->query_type, i_param->roaring, i_param->analyzer_ctx);
     };
 
@@ -133,11 +133,10 @@ Result<bool> InvertedIndexIterator::has_null() {
     return reader->has_null();
 }
 
-Status InvertedIndexIterator::try_read_from_inverted_index(const InvertedIndexReaderPtr& reader,
-                                                           const std::string& column_name,
-                                                           const void* query_value,
-                                                           InvertedIndexQueryType query_type,
-                                                           size_t* count) {
+Status InvertedIndexIterator::try_read_from_inverted_index(
+        const InvertedIndexReaderPtr& reader, const std::string& column_name,
+        const InvertedIndexQueryParam* query_value, InvertedIndexQueryType query_type,
+        size_t* count) {
     // NOTE: only bkd index support try read now.
     if (query_type == InvertedIndexQueryType::GREATER_EQUAL_QUERY ||
         query_type == InvertedIndexQueryType::GREATER_THAN_QUERY ||