Convert like and ilike to sqlfunc macro (#34342)

Converts the like and ilike operators to the sqlfunc macros. Part of
converting all binary functions to generated scaffolding.

---------

Signed-off-by: Moritz Hoffmann <[email protected]>

Author: antiguru

src/expr-derive/src/lib.rs

@@ -36,9 +36,11 @@
 ///   `output_type`.
 /// * `could_error`: A boolean indicating whether the function could error.
 /// * `propagate_nulls`: A boolean indicating whether the function propagates nulls. Applies to
-///   binary functions only.
+///   binary functions only. If not specified, use the default implementation from the trait.
+///   The default is to return true if all input types are not-nullable.
 /// * `introduces_nulls`: A boolean indicating whether the function introduces nulls. Applies to
-///   all functions.
+///   all functions. If not specified, use the default implementation from the trait.
+///   The default is to return the `nullable` property of the output type.
 ///
 /// # Limitations
 /// * The input and output types can contain lifetime parameters, as long as they are `'a`.

src/expr/src/scalar.rs

@@ -782,11 +782,25 @@ impl MirScalarExpr {
                                 Err(err.clone()),
                                 e.typ(column_types).scalar_type,
                             );
-                        } else if let BinaryFunc::IsLikeMatch { case_insensitive } = func {
+                        } else if let BinaryFunc::IsLikeMatchCaseInsensitive(_) = func {
                             if expr2.is_literal() {
                                 // We can at least precompile the regex.
                                 let pattern = expr2.as_literal_str().unwrap();
-                                *e = match like_pattern::compile(pattern, *case_insensitive) {
+                                *e = match like_pattern::compile(pattern, true) {
+                                    Ok(matcher) => expr1.take().call_unary(UnaryFunc::IsLikeMatch(
+                                        func::IsLikeMatch(matcher),
+                                    )),
+                                    Err(err) => MirScalarExpr::literal(
+                                        Err(err),
+                                        e.typ(column_types).scalar_type,
+                                    ),
+                                };
+                            }
+                        } else if let BinaryFunc::IsLikeMatchCaseSensitive(_) = func {
+                            if expr2.is_literal() {
+                                // We can at least precompile the regex.
+                                let pattern = expr2.as_literal_str().unwrap();
+                                *e = match like_pattern::compile(pattern, false) {
                                     Ok(matcher) => expr1.take().call_unary(UnaryFunc::IsLikeMatch(
                                         func::IsLikeMatch(matcher),
                                     )),

src/expr/src/scalar/func.rs

@@ -273,7 +273,8 @@ mod derive {
         GetByte,
         Gt,
         Gte,
-        // IsLikeMatch
+        IsLikeMatchCaseInsensitive,
+        IsLikeMatchCaseSensitive,
         // IsRegexpMatch
         JsonbConcat,
         JsonbContainsJsonb,

src/expr/src/scalar/func/binary.rs

@@ -0,0 +1,63 @@
+---
+source: src/expr/src/scalar/func.rs
+expression: "#[sqlfunc(is_infix_op = true, sqlname = \"ilike\")]\nfn is_like_match_case_insensitive(\n    haystack: &str,\n    pattern: &str,\n) -> Result<bool, EvalError> {\n    like_pattern::compile(pattern, true).map(|needle| needle.is_match(haystack))\n}\n"
+---
+#[derive(
+    proptest_derive::Arbitrary,
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect
+)]
+pub struct IsLikeMatchCaseInsensitive;
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for IsLikeMatchCaseInsensitive {
+    type Input1 = &'a str;
+    type Input2 = &'a str;
+    type Output = Result<bool, EvalError>;
+    fn call(
+        &self,
+        a: Self::Input1,
+        b: Self::Input2,
+        temp_storage: &'a mz_repr::RowArena,
+    ) -> Self::Output {
+        is_like_match_case_insensitive(a, b)
+    }
+    fn output_type(
+        &self,
+        input_type_a: mz_repr::SqlColumnType,
+        input_type_b: mz_repr::SqlColumnType,
+    ) -> mz_repr::SqlColumnType {
+        use mz_repr::AsColumnType;
+        let output = Self::Output::as_column_type();
+        let propagates_nulls = crate::func::binary::EagerBinaryFunc::propagates_nulls(
+            self,
+        );
+        let nullable = output.nullable;
+        output
+            .nullable(
+                nullable
+                    || (propagates_nulls
+                        && (input_type_a.nullable || input_type_b.nullable)),
+            )
+    }
+    fn is_infix_op(&self) -> bool {
+        true
+    }
+}
+impl std::fmt::Display for IsLikeMatchCaseInsensitive {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("ilike")
+    }
+}
+fn is_like_match_case_insensitive(
+    haystack: &str,
+    pattern: &str,
+) -> Result<bool, EvalError> {
+    like_pattern::compile(pattern, true).map(|needle| needle.is_match(haystack))
+}

src/expr/src/scalar/snapshots/mz_expr__scalar__func__is_like_match_case_insensitive.snap

@@ -0,0 +1,63 @@
+---
+source: src/expr/src/scalar/func.rs
+expression: "#[sqlfunc(is_infix_op = true, sqlname = \"like\")]\nfn is_like_match_case_sensitive(\n    haystack: &str,\n    pattern: &str,\n) -> Result<bool, EvalError> {\n    like_pattern::compile(pattern, false).map(|needle| needle.is_match(haystack))\n}\n"
+---
+#[derive(
+    proptest_derive::Arbitrary,
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect
+)]
+pub struct IsLikeMatchCaseSensitive;
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for IsLikeMatchCaseSensitive {
+    type Input1 = &'a str;
+    type Input2 = &'a str;
+    type Output = Result<bool, EvalError>;
+    fn call(
+        &self,
+        a: Self::Input1,
+        b: Self::Input2,
+        temp_storage: &'a mz_repr::RowArena,
+    ) -> Self::Output {
+        is_like_match_case_sensitive(a, b)
+    }
+    fn output_type(
+        &self,
+        input_type_a: mz_repr::SqlColumnType,
+        input_type_b: mz_repr::SqlColumnType,
+    ) -> mz_repr::SqlColumnType {
+        use mz_repr::AsColumnType;
+        let output = Self::Output::as_column_type();
+        let propagates_nulls = crate::func::binary::EagerBinaryFunc::propagates_nulls(
+            self,
+        );
+        let nullable = output.nullable;
+        output
+            .nullable(
+                nullable
+                    || (propagates_nulls
+                        && (input_type_a.nullable || input_type_b.nullable)),
+            )
+    }
+    fn is_infix_op(&self) -> bool {
+        true
+    }
+}
+impl std::fmt::Display for IsLikeMatchCaseSensitive {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("like")
+    }
+}
+fn is_like_match_case_sensitive(
+    haystack: &str,
+    pattern: &str,
+) -> Result<bool, EvalError> {
+    like_pattern::compile(pattern, false).map(|needle| needle.is_match(haystack))
+}

src/expr/src/scalar/snapshots/mz_expr__scalar__func__is_like_match_case_sensitive.snap

@@ -4646,24 +4646,24 @@ pub static OP_IMPLS: LazyLock<BTreeMap<&'static str, Func>> = LazyLock::new(|| {
 
         // ILIKE
         "~~*" => Scalar {
-            params!(String, String) => BF::IsLikeMatch { case_insensitive: true } => Bool, 1627;
+            params!(String, String) => BF::from(func::IsLikeMatchCaseInsensitive) => Bool, 1627;
             params!(Char, String) => Operation::binary(|ecx, lhs, rhs| {
                 let length = ecx.scalar_type(&lhs).unwrap_char_length();
                 Ok(lhs.call_unary(UnaryFunc::PadChar(func::PadChar { length }))
-                    .call_binary(rhs, BF::IsLikeMatch { case_insensitive: true })
+                    .call_binary(rhs, BF::from(func::IsLikeMatchCaseInsensitive))
                 )
             }) => Bool, 1629;
         },
         "!~~*" => Scalar {
             params!(String, String) => Operation::binary(|_ecx, lhs, rhs| {
                 Ok(lhs
-                    .call_binary(rhs, BF::IsLikeMatch { case_insensitive: true })
+                    .call_binary(rhs, BF::from(func::IsLikeMatchCaseInsensitive))
                     .call_unary(UnaryFunc::Not(func::Not)))
             }) => Bool, 1628;
             params!(Char, String) => Operation::binary(|ecx, lhs, rhs| {
                 let length = ecx.scalar_type(&lhs).unwrap_char_length();
                 Ok(lhs.call_unary(UnaryFunc::PadChar(func::PadChar { length }))
-                    .call_binary(rhs, BF::IsLikeMatch { case_insensitive: true })
+                    .call_binary(rhs, BF::from(func::IsLikeMatchCaseInsensitive))
                     .call_unary(UnaryFunc::Not(func::Not))
                 )
             }) => Bool, 1630;
@@ -4672,24 +4672,24 @@ pub static OP_IMPLS: LazyLock<BTreeMap<&'static str, Func>> = LazyLock::new(|| {
 
         // LIKE
         "~~" => Scalar {
-            params!(String, String) => BF::IsLikeMatch { case_insensitive: false } => Bool, 1209;
+            params!(String, String) => BF::from(func::IsLikeMatchCaseSensitive) => Bool, 1209;
             params!(Char, String) => Operation::binary(|ecx, lhs, rhs| {
                 let length = ecx.scalar_type(&lhs).unwrap_char_length();
                 Ok(lhs.call_unary(UnaryFunc::PadChar(func::PadChar { length }))
-                    .call_binary(rhs, BF::IsLikeMatch { case_insensitive: false })
+                    .call_binary(rhs, BF::from(func::IsLikeMatchCaseSensitive))
                 )
             }) => Bool, 1211;
         },
         "!~~" => Scalar {
             params!(String, String) => Operation::binary(|_ecx, lhs, rhs| {
                 Ok(lhs
-                    .call_binary(rhs, BF::IsLikeMatch { case_insensitive: false })
+                    .call_binary(rhs, BF::from(func::IsLikeMatchCaseSensitive))
                     .call_unary(UnaryFunc::Not(func::Not)))
             }) => Bool, 1210;
             params!(Char, String) => Operation::binary(|ecx, lhs, rhs| {
                 let length = ecx.scalar_type(&lhs).unwrap_char_length();
                 Ok(lhs.call_unary(UnaryFunc::PadChar(func::PadChar { length }))
-                    .call_binary(rhs, BF::IsLikeMatch { case_insensitive: false })
+                    .call_binary(rhs, BF::from(func::IsLikeMatchCaseSensitive))
                     .call_unary(UnaryFunc::Not(func::Not))
                 )
             }) => Bool, 1212;

src/sql/src/func.rs

@@ -4490,7 +4490,12 @@ fn plan_like(
             expr_func::LikeEscape,
         );
     }
-    let like = haystack.call_binary(pattern, BinaryFunc::IsLikeMatch { case_insensitive });
+    let func: BinaryFunc = if case_insensitive {
+        expr_func::IsLikeMatchCaseInsensitive.into()
+    } else {
+        expr_func::IsLikeMatchCaseSensitive.into()
+    };
+    let like = haystack.call_binary(pattern, func);
     if not {
         Ok(like.call_unary(UnaryFunc::Not(expr_func::Not)))
     } else {