feat: like to range

wy1433 · Apr 24, 2024 · 11d397e · 11d397e
1 parent a6a3fb3
commit 11d397e
Show file tree

Hide file tree

Showing 3 changed files with 99 additions and 3 deletions.
diff --git a/include/expr/expr_node.h b/include/expr/expr_node.h
@@ -194,6 +194,7 @@ class ExprNode {
 
     // optimize or node to in node
     static void  or_node_optimize(ExprNode** expr_node);
+    static void like_node_optimize(ExprNode** root, std::vector<ExprNode*>& new_exprs);
     bool has_same_children();
     bool is_vaild_or_optimize_tree(int32_t level, std::unordered_set<int32_t>* tuple_set);
     static int change_or_node_to_in(ExprNode** expr_node);

diff --git a/src/exec/filter_node.cpp b/src/exec/filter_node.cpp
@@ -342,8 +342,8 @@ int FilterNode::expr_optimize(QueryContext* ctx) {
         DB_WARNING("ExecNode::optimize fail, ret:%d", ret);
         return ret;
     }
-    // sign => pred
-    std::map<int64_t, SlotPredicate> pred_map;
+
+    std::vector<ExprNode*> like2range;
     for (auto& expr : _conjuncts) {
         //类型推导
         ret = expr->expr_optimize();
@@ -352,7 +352,15 @@ int FilterNode::expr_optimize(QueryContext* ctx) {
             return ret;
         }
         ExprNode::or_node_optimize(&expr);
-
+        ExprNode::like_node_optimize(&expr, like2range);
+    }
+    for (auto expr : like2range) {
+        _conjuncts.push_back(expr);
+    }
+
+    // sign => pred
+    std::map<int64_t, SlotPredicate> pred_map;
+    for (auto& expr : _conjuncts) {
         //非bool型表达式判断
         if (expr->col_type() != pb::BOOL) {
             ExprNode::_s_non_boolean_sql_cnts << 1;

diff --git a/src/expr/expr_node.cpp b/src/expr/expr_node.cpp
@@ -341,6 +341,93 @@ void ExprNode::or_node_optimize(ExprNode** root) {
     return;
 }
 
+void ExprNode::like_node_optimize(ExprNode** root, std::vector<ExprNode*>& new_exprs) {
+    if (*root == nullptr) {
+        return;
+    }
+    if ((*root)->node_type() != pb::LIKE_PREDICATE) {
+        return;
+    }
+    auto expr = *root;
+    SlotRef* slot = (SlotRef*)expr->children(0);
+    if (slot->col_type() != pb::STRING) {
+        return;
+    }
+    if (expr->children(1)->is_constant()) {
+        expr->children(1)->open();
+    } else {
+        return;
+    }
+    bool is_eq = false;
+    bool is_prefix = false;
+    ExprValue prefix_value(pb::STRING);
+    static_cast<LikePredicate*>(expr)->hit_index(&is_eq, &is_prefix, &(prefix_value.str_val));
+    std::string old_val = expr->children(1)->get_value(nullptr).get_string();
+    if (!is_prefix || old_val.length() > prefix_value.str_val.length() + 1) {
+        return;
+    }
+    if (is_eq) {
+        ScalarFnCall * eqexpr = new ScalarFnCall();
+        SlotRef *sloteq = slot->clone();
+        Literal *eqval = new Literal(prefix_value);
+        pb::ExprNode node;
+        node.set_node_type(pb::FUNCTION_CALL);
+        node.set_col_type(pb::BOOL);
+        pb::Function* func = node.mutable_fn();
+        func->set_name("eq_string_string");
+        func->set_fn_op(parser::FT_EQ);
+        eqexpr->init(node);
+        eqexpr->set_is_constant(false);
+        eqexpr->add_child(sloteq);
+        eqexpr->add_child(eqval);
+        *root = eqexpr;
+        ExprNode::destroy_tree(expr);
+        return ;
+    } else if (is_prefix) {
+        ScalarFnCall *geexpr = new ScalarFnCall();
+        SlotRef *slotge = slot->clone();
+        Literal *geval = new Literal(prefix_value);
+        pb::ExprNode node;
+        node.set_node_type(pb::FUNCTION_CALL);
+        node.set_col_type(pb::BOOL);
+        pb::Function* func = node.mutable_fn();
+        func->set_name("ge_string_string");
+        func->set_fn_op(parser::FT_GE);
+        geexpr->init(node);
+        geexpr->set_is_constant(false);
+        geexpr->add_child(slotge);
+        geexpr->add_child(geval);
+        *root = geexpr;
+
+        ScalarFnCall *ltexpr = new ScalarFnCall();
+        SlotRef* ltslot = slot->clone();
+        ExprValue end_val = prefix_value;
+        int i = end_val.str_val.length() - 1;
+        for (; i >= 0; i --) {
+            uint8_t c = end_val.str_val[i];
+            if (c == 255) {
+                continue;
+            }
+            end_val.str_val[i] = char(c + 1);
+            break;
+        }
+        end_val.str_val = end_val.str_val.substr(0, i + 1);
+        Literal *ltval = new Literal(end_val);
+        pb::ExprNode ltnode;
+        ltnode.set_node_type(pb::FUNCTION_CALL);
+        ltnode.set_col_type(pb::BOOL);
+        func = ltnode.mutable_fn();
+        func->set_name("lt_string_string");
+        func->set_fn_op(parser::FT_LT);
+        ltexpr->init(ltnode);
+        ltexpr->set_is_constant(false);
+        ltexpr->add_child(ltslot);
+        ltexpr->add_child(ltval);
+        new_exprs.push_back(ltexpr);
+        ExprNode::destroy_tree(expr);
+    }      
+}
+
 int ExprNode::create_expr_node(const pb::ExprNode& node, ExprNode** expr_node) {
     switch (node.node_type()) {
         case pb::SLOT_REF: