Make modules.re methods accept an already compiled pattern (#5430)

* Make `modules.re` methods accept an already compiled pattern

COPYBARA PUBLIC PR: #601

Fixes part of #581 ("Compilation failures: The user's example still produces empty files in Fusion").

Methods in `modules.re` (such as `search` and `match`) can take both a string for the initial pattern argument as well an already compiled expression.

Before this change only the string variant was correctly supported:
```jinja2
{%- set pattern = '.*' -%}
{%- set result = re.search(pattern, 'xyz') -%}
```

This change makes compiled patterns work as well, restoring compatibility with [pythons re](https://docs.python.org/3/library/re.html)  / dbt-core / jinja2:
```jinja2
{%- set pattern = re.compile('.*') -%}
{%- set result = re.search(pattern, 'xyz') -%}
```

The rust edition in the `minijinja-contrib` crate was bumped to `2024` to allow the [let chain](rust-lang/rust#132833) used here. Bumping the edition means that `cargo fmt` formats differently - the (otherwise unrelated) formatting changes are done in the second commit in this PR, while the first commit contains the actual change.

GitOrigin-RevId: 99d438c

* Make `modules.re` methods accept an already compiled pattern

COPYBARA PUBLIC PR: #601

Fixes part of #581 ("Compilation failures: The user's example still produces empty files in Fusion").

Methods in `modules.re` (such as `search` and `match`) can take both a string for the initial pattern argument as well an already compiled expression.

Before this change only the string variant was correctly supported:
```jinja2
{%- set pattern = '.*' -%}
{%- set result = re.search(pattern, 'xyz') -%}
```

This change makes compiled patterns work as well, restoring compatibility with [pythons re](https://docs.python.org/3/library/re.html)  / dbt-core / jinja2:
```jinja2
{%- set pattern = re.compile('.*') -%}
{%- set result = re.search(pattern, 'xyz') -%}
```

The rust edition in the `minijinja-contrib` crate was bumped to `2024` to allow the [let chain](rust-lang/rust#132833) used here. Bumping the edition means that `cargo fmt` formats differently - the (otherwise unrelated) formatting changes are done in the second commit in this PR, while the first commit contains the actual change.

GitOrigin-RevId: 9dd9420

* Cargo fmt

* remove old changelog

* Change code to avoid clippy complaint about unstable let

* rename conflicting test name

* update test output

* Improve sdf-make-sql-functions build command

Let cargo consider only the actually necessary dependencies. When `-p`
is not present, cargo will do dependency feature unification across all
crates first.

* Remove table qualifiers in UNION plan

After UNION (or other set operation), the names are no longer qualified.
Keeping them qualified is incorrect (allows referencing which would be
rejected by CDW) and causes planning failures in DataFusion 48.

* Make `modules.re` methods accept an already compiled pattern

COPYBARA PUBLIC PR: #601

Fixes part of #581 ("Compilation failures: The user's example still produces empty files in Fusion").

Methods in `modules.re` (such as `search` and `match`) can take both a string for the initial pattern argument as well an already compiled expression.

Before this change only the string variant was correctly supported:
```jinja2
{%- set pattern = '.*' -%}
{%- set result = re.search(pattern, 'xyz') -%}
```

This change makes compiled patterns work as well, restoring compatibility with [pythons re](https://docs.python.org/3/library/re.html)  / dbt-core / jinja2:
```jinja2
{%- set pattern = re.compile('.*') -%}
{%- set result = re.search(pattern, 'xyz') -%}
```

The rust edition in the `minijinja-contrib` crate was bumped to `2024` to allow the [let chain](rust-lang/rust#132833) used here. Bumping the edition means that `cargo fmt` formats differently - the (otherwise unrelated) formatting changes are done in the second commit in this PR, while the first commit contains the actual change.

GitOrigin-RevId: 99d438c

* Cargo fmt

* fix bad merge

* Update output for flaky test test_regression_tests_internal_analytics_build_selector_cloud_users_1

* Remove old changelog

---------

Co-authored-by: Fredrik Fornwall <[email protected]>
Co-authored-by: Gerda Shank <[email protected]>
Co-authored-by: Gerda Shank <[email protected]>
Co-authored-by: Piotr Findeisen <[email protected]>
GitOrigin-RevId: dafcf71594623b1ce94e126eb1dd6f9a6896656a

Author: 4 people

crates/dbt-jinja/minijinja-contrib/src/filters/datetime.rs

@@ -39,7 +39,7 @@ fn value_to_datetime(
                             ErrorKind::InvalidOperation,
                             "not a valid date or timestamp",
                         )
-                        .with_source(original_err))
+                        .with_source(original_err));
                     }
                 },
             },

crates/dbt-jinja/minijinja-contrib/src/modules/py_datetime/time.rs

@@ -92,7 +92,7 @@ impl PyTimeClass {
                 return Err(Error::new(
                     ErrorKind::InvalidArgument,
                     format!("Invalid iso time format: {iso_str}: {e}"),
-                ))
+                ));
             }
         };
 

crates/dbt-jinja/minijinja-contrib/src/modules/re.rs

@@ -49,14 +49,14 @@ fn re_compile(args: &[Value]) -> Result<Value, Error> {
 #[derive(Debug, Clone)]
 pub struct Pattern {
     raw: String,
-    _compiled: Regex,
+    compiled: Regex,
 }
 
 impl Pattern {
     pub fn new(raw: &str, compiled: Regex) -> Self {
         Self {
             raw: raw.to_string(),
-            _compiled: compiled, // TODO: use this in re methods
+            compiled,
         }
     }
 }
@@ -307,13 +307,27 @@ fn get_or_compile_regex_and_text(args: &[Value]) -> Result<(Box<Regex>, &str), E
     }
 
     // First arg: either compiled or raw pattern
-    let pattern = args[0].to_string();
-    let compiled = Box::new(Regex::new(&pattern).map_err(|e| {
-        Error::new(
-            ErrorKind::InvalidOperation,
-            format!("Failed to compile regex: {e}"),
-        )
-    })?);
+    let compiled = if let Some(object) = args[0].as_object() {
+        if let Some(pattern) = object.downcast_ref::<Pattern>() {
+            Box::new(pattern.compiled.clone())
+        } else {
+            let pattern = args[0].to_string();
+            Box::new(Regex::new(&pattern).map_err(|e| {
+                Error::new(
+                    ErrorKind::InvalidOperation,
+                    format!("Failed to compile regex: {e}"),
+                )
+            })?)
+        }
+    } else {
+        let pattern = args[0].to_string();
+        Box::new(Regex::new(&pattern).map_err(|e| {
+            Error::new(
+                ErrorKind::InvalidOperation,
+                format!("Failed to compile regex: {e}"),
+            )
+        })?)
+    };
 
     // Second arg: the text to match against
     let text = args[1].to_string();
@@ -472,4 +486,18 @@ mod tests {
         assert!(!result.is_true());
         assert_eq!(result.to_string(), "none");
     }
+
+    #[test]
+    fn test_re_glob_search() {
+        let result = re_search(&[
+            Value::from(".*".to_string()),
+            Value::from("xyz".to_string()),
+        ])
+        .unwrap();
+        assert!(result.is_true());
+
+        let compiled_pattern = re_compile(&[Value::from(".*".to_string())]).unwrap();
+        let result = re_search(&[compiled_pattern, Value::from("xyz".to_string())]).unwrap();
+        assert!(result.is_true());
+    }
 }