enhance: use scan mode for like although inverted index exists

internal/core/src/exec/expression/Expr.h

@@ -1189,22 +1189,17 @@ class SegmentExpr : public Expr {
         }
 
         using Index = index::ScalarIndex<IndexInnerType>;
-        if (op == OpType::Match) {
-            for (size_t i = current_index_chunk_; i < num_index_chunk_; i++) {
-                auto pw =
-                    segment_->chunk_scalar_index<IndexInnerType>(field_id_, i);
-                auto index_ptr = const_cast<Index*>(pw.get());
-                // 1, index support regex query, then index handles the query;
-                // 2, index has raw data, then call index.Reverse_Lookup to handle the query;
-                if (!index_ptr->SupportRegexQuery() &&
-                    !index_ptr->HasRawData()) {
-                    return false;
-                }
-                // all chunks have same index.
-                return true;
-            }
+        if (op == OpType::Match || op == OpType::InnerMatch ||
+            op == OpType::PostfixMatch) {
+            auto pw = segment_->chunk_scalar_index<IndexInnerType>(
+                field_id_, current_index_chunk_);
+            auto* index_ptr = const_cast<Index*>(pw.get());
+            // 1, index support regex query and try use it, then index handles the query;
+            // 2, index has raw data, then call index.Reverse_Lookup to handle the query;
+            return (index_ptr->TryUseRegexQuery() &&
+                    index_ptr->SupportRegexQuery()) ||
+                   index_ptr->HasRawData();
         }
-
         return true;
     }
 

internal/core/src/exec/expression/UnaryExpr.cpp

@@ -1828,17 +1828,26 @@
 template <typename T>
 bool
 PhyUnaryRangeFilterExpr::CanUseIndex() {
-    bool res = is_index_mode_ && SegmentExpr::CanUseIndex<T>(expr_->op_type_);
-    use_index_ = res;
-    return res;
+    use_index_ = is_index_mode_ && SegmentExpr::CanUseIndex<T>(expr_->op_type_);
+    return use_index_;
 }
 
 bool
 PhyUnaryRangeFilterExpr::CanUseIndexForJson(DataType val_type) {
-    use_index_ =
+    auto has_index =
         segment_->HasIndex(field_id_,
                            milvus::Json::pointer(expr_->column_.nested_path_),
                            val_type);
+    switch (val_type) {
+        case DataType::STRING:
+            use_index_ = has_index &&
+                         expr_->op_type_ != proto::plan::OpType::Match &&
+                         expr_->op_type_ != proto::plan::OpType::PostfixMatch &&
+                         expr_->op_type_ != proto::plan::OpType::InnerMatch;
+            break;
+        default:
+            use_index_ = has_index;
+    }
     return use_index_;
 }
 

internal/core/src/index/HybridScalarIndex.h

@@ -115,6 +115,11 @@
         return internal_index_->PatternMatch(pattern, op);
     }
 
+    bool
+    TryUseRegexQuery() const override {
+        return internal_index_->TryUseRegexQuery();
+    }
+
     bool
     SupportRegexQuery() const override {
         return internal_index_->SupportRegexQuery();

internal/core/src/index/InvertedIndexTantivy.h

@@ -228,6 +228,12 @@ class InvertedIndexTantivy : public ScalarIndex<T> {
         return std::is_same_v<T, std::string>;
     }
 
+    bool
+    TryUseRegexQuery() const override {
+        // for inverted index, not use regex query to implement match
+        return false;
+    }
+
     const TargetBitmap
     RegexQuery(const std::string& regex_pattern) override;
 

internal/core/src/index/ScalarIndex.h

@@ -151,6 +151,11 @@ class ScalarIndex : public IndexBase {
         return false;
     }
 
+    virtual bool
+    TryUseRegexQuery() const {
+        return true;
+    }
+
     virtual const TargetBitmap
     RegexQuery(const std::string& pattern) {
         PanicInfo(Unsupported, "regex query is not supported");