refactor: String column like % can rewrite to true (#18263)

optimize: String/Variant column like % can rewrite to true

Author: TCeason

src/query/functions/src/scalars/comparison.rs

@@ -1038,34 +1038,34 @@ fn register_like(registry: &mut FunctionRegistry) {
 }
 
 fn calc_like_domain(lhs: &StringDomain, pattern: String) -> Option<FunctionDomain<BooleanType>> {
-    let pattern_type = generate_like_pattern(pattern.as_bytes(), 1);
-
-    if matches!(pattern_type, LikePattern::OrdinalStr(_)) {
-        return Some(lhs.domain_eq(&StringDomain {
+    match generate_like_pattern(pattern.as_bytes(), 1) {
+        LikePattern::StartOfPercent(v) if v.is_empty() => {
+            Some(FunctionDomain::Domain(ALL_TRUE_DOMAIN))
+        }
+        LikePattern::OrdinalStr(_) => Some(lhs.domain_eq(&StringDomain {
             min: pattern.clone(),
             max: Some(pattern),
-        }));
-    }
-
-    if matches!(pattern_type, LikePattern::EndOfPercent(_)) {
-        let mut pat_str = pattern;
-        // remove the last char '%'
-        pat_str.pop();
-        let pat_len = pat_str.chars().count();
-        let other = StringDomain {
-            min: pat_str.clone(),
-            max: Some(pat_str),
-        };
-        let lhs = StringDomain {
-            min: lhs.min.chars().take(pat_len).collect(),
-            max: lhs
-                .max
-                .as_ref()
-                .map(|max| max.chars().take(pat_len).collect()),
-        };
-        return Some(lhs.domain_eq(&other));
+        })),
+        LikePattern::EndOfPercent(_) => {
+            let mut pat_str = pattern;
+            // remove the last char '%'
+            pat_str.pop();
+            let pat_len = pat_str.chars().count();
+            let other = StringDomain {
+                min: pat_str.clone(),
+                max: Some(pat_str),
+            };
+            let lhs = StringDomain {
+                min: lhs.min.chars().take(pat_len).collect(),
+                max: lhs
+                    .max
+                    .as_ref()
+                    .map(|max| max.chars().take(pat_len).collect()),
+            };
+            Some(lhs.domain_eq(&other))
+        }
+        _ => None,
     }
-    None
 }
 
 fn variant_vectorize_like_jsonb() -> impl Fn(

tests/sqllogictests/suites/mode/standalone/explain/explain_like.test

@@ -14,6 +14,24 @@ abcd
 abcd[
 abcde
 
+query T
+explain select * from t1 where s like '%';
+----
+Filter
+├── output columns: [t1.s (#0)]
+├── filters: [is_true(like(t1.s (#0), '%'))]
+├── estimated rows: 5.00
+└── TableScan
+    ├── table: default.default.t1
+    ├── output columns: [s (#0)]
+    ├── read rows: 5
+    ├── read size: < 1 KiB
+    ├── partitions total: 1
+    ├── partitions scanned: 1
+    ├── pruning stats: [segments: <range pruning: 1 to 1>, blocks: <range pruning: 1 to 1>]
+    ├── push downs: [filters: [is_true(like(t1.s (#0), '%'))], limit: NONE]
+    └── estimated rows: 5.00
+
 query T
 explain select * from t1 where s like 'abcd%' order by s;
 ----
@@ -161,3 +179,27 @@ Filter
     ├── pruning stats: [segments: <range pruning: 1 to 1>, blocks: <range pruning: 1 to 1>]
     ├── push downs: [filters: [is_true(like_any(t1.s (#0), '%b$%c%', '$'))], limit: NONE]
     └── estimated rows: 5.00
+
+
+statement ok
+create or replace table t1 (c varchar not null, c3 variant not null, c5 int);
+
+statement ok
+insert into t1 values('c',parse_json('[1,2,3,["a","b","c"],{"k":"v"}]'), 1),('c1',parse_json('[1,2,3,["a","b","c"],{"k":"v1"}]'), 2)
+
+query T
+explain select c from t1 where c like '%'
+----
+TableScan
+├── table: default.default.t1
+├── output columns: [c (#0)]
+├── read rows: 2
+├── read size: < 1 KiB
+├── partitions total: 1
+├── partitions scanned: 1
+├── pruning stats: [segments: <range pruning: 1 to 1>, blocks: <range pruning: 1 to 1>]
+├── push downs: [filters: [], limit: NONE]
+└── estimated rows: 2.00
+
+statement ok
+drop table if exists t1;