test: cover regexp_like multiline flag

datafusion/functions/src/regex/regexplike.rs

@@ -603,6 +603,21 @@ mod tests {
         assert_eq!(re.as_ref(), &expected);
     }
 
+    #[test]
+    fn test_multiline_flag_regexp_like_utf8() {
+        let values = StringArray::from(vec!["a\nb"]);
+        let patterns = StringArray::from(vec!["^b"]);
+        let flags = StringArray::from(vec!["m"]);
+        let mut expected_builder = BooleanBuilder::new();
+        expected_builder.append_value(true);
+        let expected = expected_builder.finish();
+
+        let re = regexp_like(&[Arc::new(values), Arc::new(patterns), Arc::new(flags)])
+            .unwrap();
+
+        assert_eq!(re.as_ref(), &expected);
+    }
+
     #[test]
     fn test_unsupported_global_flag_regexp_like() {
         let values = StringArray::from(vec!["abc"]);
@@ -652,6 +667,41 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_regexp_like_scalar_multiline_flag_invoke() {
+        let args = vec![
+            ColumnarValue::Scalar(ScalarValue::Utf8(Some("a\nb".to_string()))),
+            ColumnarValue::Scalar(ScalarValue::Utf8(Some("^b".to_string()))),
+            ColumnarValue::Scalar(ScalarValue::Utf8(Some("m".to_string()))),
+        ];
+        let result = invoke_regexp_like(args).unwrap();
+        match result {
+            ColumnarValue::Scalar(ScalarValue::Boolean(Some(true))) => {}
+            other => panic!("Unexpected result {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_regexp_like_array_scalar_multiline_flag_invoke() {
+        let values = Arc::new(StringArray::from(vec!["a\nb", "a\nb"]));
+        let args = vec![
+            ColumnarValue::Array(values),
+            ColumnarValue::Scalar(ScalarValue::Utf8(Some("^b".to_string()))),
+            ColumnarValue::Scalar(ScalarValue::Utf8(Some("m".to_string()))),
+        ];
+        let result = invoke_regexp_like(args).unwrap();
+        let mut expected_builder = BooleanBuilder::new();
+        expected_builder.append_value(true);
+        expected_builder.append_value(true);
+        let expected = expected_builder.finish();
+        match result {
+            ColumnarValue::Array(array) => {
+                assert_eq!(array.as_ref(), &expected);
+            }
+            other => panic!("Unexpected result {other:?}"),
+        }
+    }
+
     #[test]
     fn test_regexp_like_scalar_flags_with_global() {
         let args = vec![

datafusion/sqllogictest/test_files/regexp/regexp_like.slt

@@ -168,6 +168,16 @@ SELECT 'foo\nbar\nbaz' ~ 'bar';
 ----
 true
 
+query B
+SELECT regexp_like(E'a\nb', '^b', 'm');
+----
+true
+
+query B
+SELECT regexp_like(E'a\nb', '^b');
+----
+false
+
 statement error
 Error during planning: Cannot infer common argument type for regex operation List(Field { name: "item", data_type: Int64, nullable: true, metadata: {} }) ~ List(Field { name: "item", data_type: Int64, nullable: true, metadata: {} })
 select [1,2] ~ [3];