[refactor](predicate) Refactor predicates on external tables

be/src/olap/column_predicate.h

@@ -120,6 +120,43 @@ inline std::string type_to_string(PredicateType type) {
     return "";
 }
 
+inline std::string type_to_op_str(PredicateType type) {
+    switch (type) {
+    case PredicateType::EQ:
+        return "=";
+
+    case PredicateType::NE:
+        return "!=";
+
+    case PredicateType::LT:
+        return "<<";
+
+    case PredicateType::LE:
+        return "<=";
+
+    case PredicateType::GT:
+        return ">>";
+
+    case PredicateType::GE:
+        return ">=";
+
+    case PredicateType::IN_LIST:
+        return "*=";
+
+    case PredicateType::NOT_IN_LIST:
+        return "!*=";
+
+    case PredicateType::IS_NULL:
+    case PredicateType::IS_NOT_NULL:
+        return "is";
+
+    default:
+        break;
+    };
+
+    return "";
+}
+
 struct PredicateTypeTraits {
     static constexpr bool is_range(PredicateType type) {
         return (type == PredicateType::LT || type == PredicateType::LE ||

be/src/olap/delete_handler.h

@@ -25,6 +25,7 @@
 
 #include "common/factory_creator.h"
 #include "common/status.h"
+#include "olap/column_predicate.h"
 #include "olap/rowset/rowset_meta.h"
 #include "olap/tablet_schema.h"
 #include "vec/common/arena.h"
@@ -55,8 +56,14 @@ struct DeleteConditions {
 //    * In the first step, before calling delete_handler.init(), you should lock the tablet's header file.
 class DeleteHandler {
     ENABLE_FACTORY_CREATOR(DeleteHandler);
-    // These static method is used to generate delete predicate pb during write or push handler
+
 public:
+    struct ConditionParseResult {
+        int32_t col_unique_id;
+        std::string column_name;
+        PredicateType condition_op;
+        std::list<std::string> value_str;
+    };
     // generated DeletePredicatePB by TCondition
     static Status generate_delete_predicate(const TabletSchema& schema,
                                             const std::vector<TCondition>& conditions,
@@ -71,7 +78,10 @@ class DeleteHandler {
      * @param condition output param
      * @return OK if matched and extracted correctly otherwise DELETE_INVALID_PARAMETERS
      */
-    static Status parse_condition(const std::string& condition_str, TCondition* condition);
+    static ConditionParseResult parse_condition(const std::string& condition_str);
+    static ConditionParseResult parse_condition(const DeleteSubPredicatePB& sub_cond);
+    static PredicateType parse_condition_op(const std::string& op_str,
+                                            const std::list<std::string>& cond_values);
 
 private:
     // Validate the condition on the schema.
@@ -86,9 +96,6 @@ class DeleteHandler {
                                          const std::string& condition_op,
                                          const std::string& value_str);
 
-    // extract 'column_name', 'op' and 'operands' to condition
-    static Status parse_condition(const DeleteSubPredicatePB& sub_cond, TCondition* condition);
-
 public:
     DeleteHandler() = default;
     ~DeleteHandler();

be/src/olap/in_list_predicate.h

@@ -703,82 +703,5 @@ class InListPredicateBase final : public ColumnPredicate {
     // temp string for char type column
     std::list<std::string> _temp_datas;
 };
-
-template <PrimitiveType Type, PredicateType PT, typename ConditionType, typename ConvertFunc,
-          size_t N = 0>
-std::shared_ptr<ColumnPredicate> _create_in_list_predicate(
-        uint32_t column_id, const ConditionType& conditions, const ConvertFunc& convert,
-        bool is_opposite, const vectorized::DataTypePtr& data_type, vectorized::Arena& arena) {
-    return InListPredicateBase<Type, PT, N>::create_shared(column_id, conditions, convert,
-                                                           is_opposite, data_type, arena);
-}
-
-template <PrimitiveType Type, PredicateType PT, typename ConditionType, typename ConvertFunc>
-std::shared_ptr<ColumnPredicate> create_in_list_predicate(
-        uint32_t column_id, const ConditionType& conditions, const ConvertFunc& convert,
-        bool is_opposite, const vectorized::DataTypePtr& data_type, vectorized::Arena& arena) {
-    if (conditions.size() == 1) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 1>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == 2) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 2>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == 3) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 3>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == 4) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 4>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == 5) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 5>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == 6) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 6>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == 7) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc, 7>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    } else if (conditions.size() == FIXED_CONTAINER_MAX_SIZE) {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc,
-                                         FIXED_CONTAINER_MAX_SIZE>(column_id, conditions, convert,
-                                                                   is_opposite, data_type, arena);
-    } else {
-        return _create_in_list_predicate<Type, PT, ConditionType, ConvertFunc>(
-                column_id, conditions, convert, is_opposite, data_type, arena);
-    }
-}
-
-template <PrimitiveType Type, PredicateType PT, size_t N = 0>
-std::shared_ptr<ColumnPredicate> _create_in_list_predicate(
-        uint32_t column_id, const std::shared_ptr<HybridSetBase>& hybrid_set,
-        size_t char_length = 0) {
-    return InListPredicateBase<Type, PT, N>::create_shared(column_id, hybrid_set, char_length);
-}
-
-template <PrimitiveType Type, PredicateType PT>
-std::shared_ptr<ColumnPredicate> create_in_list_predicate(
-        uint32_t column_id, const std::shared_ptr<HybridSetBase>& hybrid_set,
-        size_t char_length = 0) {
-    if (hybrid_set->size() == 1) {
-        return _create_in_list_predicate<Type, PT, 1>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == 2) {
-        return _create_in_list_predicate<Type, PT, 2>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == 3) {
-        return _create_in_list_predicate<Type, PT, 3>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == 4) {
-        return _create_in_list_predicate<Type, PT, 4>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == 5) {
-        return _create_in_list_predicate<Type, PT, 5>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == 6) {
-        return _create_in_list_predicate<Type, PT, 6>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == 7) {
-        return _create_in_list_predicate<Type, PT, 7>(column_id, hybrid_set, char_length);
-    } else if (hybrid_set->size() == FIXED_CONTAINER_MAX_SIZE) {
-        return _create_in_list_predicate<Type, PT, FIXED_CONTAINER_MAX_SIZE>(column_id, hybrid_set,
-                                                                             char_length);
-    } else {
-        return _create_in_list_predicate<Type, PT>(column_id, hybrid_set, char_length);
-    }
-}
 #include "common/compile_check_end.h"
 } //namespace doris