polyglot-sql 0.12.0__tar.gz → 0.12.1__tar.gz

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.12.0"
+version = "0.12.1"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.12.0"
+version = "0.12.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.12.0"
+version = "0.12.1"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.12.0"
+version = "0.12.1"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.12.0"
+version = "0.12.1"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.12.0"
+version = "0.12.1"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.12.0"
+version = "0.12.1"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.12.0
+Version: 0.12.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.12.0" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.12.1" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.12.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.12.1", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/README.md

@@ -25,12 +25,12 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.12.0", default-features = false }
+polyglot-sql = { version = "0.12.1", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.12.0",
+    version = "0.12.1",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.12.0",
+    version = "0.12.1",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.12.0",
+    version = "0.12.1",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -7513,6 +7513,179 @@ mod tests {
         result[0].clone()
     }
 
+    #[test]
+    fn test_athena_max_by_preserves_filter() {
+        let sql = "SELECT max_by(value,seq) FILTER (WHERE keep) AS answer FROM (VALUES ('kept',1,true),('ignored',2,false)) t(value,seq,keep)";
+        assert_eq!(
+            transpile_to_duckdb_from(sql, DialectType::Athena),
+            "SELECT ARG_MAX_NULL(value, seq) FILTER(WHERE keep) AS answer FROM (VALUES ('kept', 1, TRUE), ('ignored', 2, FALSE)) AS t(value, seq, keep)"
+        );
+
+        for read in [DialectType::Athena, DialectType::Presto, DialectType::Trino] {
+            for (source, target) in [("MAX_BY", "ARG_MAX"), ("MIN_BY", "ARG_MIN")] {
+                for args in ["value, seq", "value, seq, 2"] {
+                    let target = if args == "value, seq" {
+                        format!("{target}_NULL")
+                    } else {
+                        target.to_string()
+                    };
+                    for suffix in ["", " OVER (PARTITION BY category)"] {
+                        let sql =
+                            format!("SELECT {source}({args}) FILTER (WHERE keep){suffix} FROM t");
+                        assert_eq!(
+                            transpile_to_duckdb_from(&sql, read),
+                            format!("SELECT {target}({args}) FILTER(WHERE keep){suffix} FROM t"),
+                            "{read:?}: {sql}"
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_athena_max_by_preserves_null_winner() {
+        for read in [DialectType::Athena, DialectType::Presto, DialectType::Trino] {
+            for (source, target) in [("MAX_BY", "ARG_MAX_NULL"), ("MIN_BY", "ARG_MIN_NULL")] {
+                let sql = format!(
+                    "SELECT {source}(value, seq) AS answer FROM (VALUES ('older', 1), (CAST(NULL AS VARCHAR), 2)) t(value, seq)"
+                );
+                assert_eq!(
+                    transpile_to_duckdb_from(&sql, read),
+                    format!("SELECT {target}(value, seq) AS answer FROM (VALUES ('older', 1), (CAST(NULL AS TEXT), 2)) AS t(value, seq)"),
+                    "{read:?}: {sql}"
+                );
+                assert_eq!(
+                    transpile_to_duckdb_from(
+                        &format!("SELECT {source}(DISTINCT value, seq) FILTER (WHERE keep) FROM t"),
+                        read,
+                    ),
+                    format!("SELECT {target}(DISTINCT value, seq) FILTER(WHERE keep) FROM t")
+                );
+            }
+        }
+
+        // DuckDB's native aliases intentionally skip NULL values.
+        for (source, target) in [("MAX_BY", "ARG_MAX"), ("MIN_BY", "ARG_MIN")] {
+            assert_eq!(
+                transpile_to_duckdb_from(
+                    &format!("SELECT {source}(value, seq) FROM t"),
+                    DialectType::DuckDB,
+                ),
+                format!("SELECT {target}(value, seq) FROM t")
+            );
+        }
+    }
+
+    #[test]
+    fn test_athena_regexp_extract_preserves_null_and_empty_matches() {
+        for read in [DialectType::Athena, DialectType::Presto, DialectType::Trino] {
+            for args in [
+                "'no-match', '([0-9]+)', 1",
+                "'abc', '(z*)a', 1",
+                "'abc', '(z)?a', 1",
+                "'abc', '(a)(b)(c)'",
+                "'abc', '(a)(b)(c)', 2",
+                "'12 34', '[0-9]+'",
+                "'', '()'",
+                "NULL, '([0-9]+)', 1",
+                "'abc', NULL, 1",
+                "value, pattern, group_index",
+            ] {
+                assert_eq!(
+                    transpile_to_duckdb_from(
+                        &format!("SELECT REGEXP_EXTRACT({args}) AS answer"),
+                        read,
+                    ),
+                    format!("SELECT ARRAY_EXTRACT(REGEXP_EXTRACT_ALL({args}), 1) AS answer"),
+                    "{read:?}: {args}"
+                );
+            }
+        }
+
+        assert_eq!(
+            transpile_to_duckdb_from(
+                "SELECT REGEXP_EXTRACT('no-match', '([0-9]+)', 1)",
+                DialectType::DuckDB,
+            ),
+            "SELECT REGEXP_EXTRACT('no-match', '([0-9]+)', 1)"
+        );
+    }
+
+    #[test]
+    fn test_athena_regexp_replace_capture_references() {
+        for read in [DialectType::Athena, DialectType::Presto, DialectType::Trino] {
+            for (sql, expected) in [
+                (
+                    "SELECT regexp_replace('2026.09 2027.10', '([0-9]+)[.]([0-9]+)', '$1-$2') AS answer",
+                    r"SELECT REGEXP_REPLACE('2026.09 2027.10', '([0-9]+)[.]([0-9]+)', '\1-\2', 'g') AS answer",
+                ),
+                (
+                    "SELECT regexp_replace(value, pattern, '$0/$1/$2') FROM t",
+                    r"SELECT REGEXP_REPLACE(value, pattern, '\0/\1/\2', 'g') FROM t",
+                ),
+                (
+                    r"SELECT regexp_replace('aa', '(a)', '\$1')",
+                    "SELECT REGEXP_REPLACE('aa', '(a)', '$1', 'g')",
+                ),
+                (
+                    "SELECT regexp_replace('a1b2', '[0-9]')",
+                    "SELECT REGEXP_REPLACE('a1b2', '[0-9]', '', 'g')",
+                ),
+                (
+                    "SELECT regexp_replace('aa', 'a', 'x')",
+                    "SELECT REGEXP_REPLACE('aa', 'a', 'x', 'g')",
+                ),
+            ] {
+                assert_eq!(transpile_to_duckdb_from(sql, read), expected, "{read:?}: {sql}");
+            }
+        }
+
+        assert_eq!(
+            transpile_to_duckdb_from(
+                "SELECT REGEXP_REPLACE('aa', '(a)', '$1')",
+                DialectType::DuckDB,
+            ),
+            "SELECT REGEXP_REPLACE('aa', '(a)', '$1')"
+        );
+    }
+
+    #[test]
+    fn test_athena_to_iso8601_reports_unsupported_translation() {
+        for read in [DialectType::Athena, DialectType::Presto, DialectType::Trino] {
+            let dialect = Dialect::get(read);
+            for argument in [
+                "TIMESTAMP '2026-05-26 02:08:02.930'",
+                "TIMESTAMP '2026-05-26 02:08:02.123456789'",
+                "TIMESTAMP '2026-05-26 02:08:02.930 +02:00'",
+                "DATE '2026-05-26'",
+                "CAST(value AS TIMESTAMP(3))",
+                "CAST(value AS TIMESTAMP WITH TIME ZONE)",
+                "value",
+            ] {
+                let sql = format!("SELECT TO_ISO8601({argument}) AS answer FROM t");
+                for options in [
+                    crate::dialects::TranspileOptions::default(),
+                    crate::dialects::TranspileOptions::strict(),
+                ] {
+                    let error = dialect
+                        .transpile_with(&sql, DialectType::DuckDB, options)
+                        .expect_err("unsupported TO_ISO8601 must not emit invalid DuckDB SQL");
+                    assert!(matches!(error, crate::error::Error::Unsupported { .. }));
+                    assert!(error.to_string().contains("TO_ISO8601"));
+                    assert!(error.to_string().contains("precision and time zone"));
+                }
+            }
+
+            assert_eq!(
+                dialect
+                    .transpile("SELECT TO_ISO8601(value) FROM t", read)
+                    .unwrap()[0],
+                "SELECT TO_ISO8601(value) FROM t"
+            );
+        }
+    }
+
     #[test]
     fn test_ifnull_to_coalesce() {
         let result = transpile_to_duckdb("SELECT IFNULL(a, b)");

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/src/dialects/normalization/aggregates.rs

@@ -681,11 +681,31 @@ pub(super) fn rewrite(
                         ))))
                     }
                     DialectType::DuckDB => {
-                        let name = if is_max { "ARG_MAX" } else { "ARG_MIN" };
-                        Ok(Expression::Function(Box::new(Function::new(
-                            name.to_string(),
-                            args,
-                        ))))
+                        let preserve_null_value = args.len() == 2
+                            && matches!(
+                                context.source,
+                                DialectType::Athena | DialectType::Presto | DialectType::Trino
+                            );
+                        // Trino/Presto retain a NULL value when its key wins.
+                        // DuckDB's ordinary ARG_MAX/ARG_MIN skip such rows.
+                        let name = match (is_max, preserve_null_value) {
+                            (true, true) => "ARG_MAX_NULL",
+                            (false, true) => "ARG_MIN_NULL",
+                            (true, false) => "ARG_MAX",
+                            (false, false) => "ARG_MIN",
+                        };
+                        // Renaming must retain FILTER and other aggregate modifiers.
+                        match e {
+                            Expression::AggregateFunction(mut af) => {
+                                af.name = name.to_string();
+                                Ok(Expression::AggregateFunction(af))
+                            }
+                            Expression::Function(mut f) => {
+                                f.name = name.to_string();
+                                Ok(Expression::Function(f))
+                            }
+                            _ => Ok(e),
+                        }
                     }
                     DialectType::Spark | DialectType::Databricks => {
                         let mut args = args;

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -1667,6 +1667,17 @@ pub(super) fn normalize(
                 }
                 Expression::Function(f) => {
                     let name = f.name.to_ascii_uppercase();
+                    if name == "TO_ISO8601"
+                        && matches!(source, DialectType::Athena | DialectType::Presto | DialectType::Trino)
+                        && matches!(target, DialectType::DuckDB)
+                    {
+                        // DuckDB has no native equivalent. A generic STRFTIME
+                        // rewrite loses source precision and per-value time zones.
+                        return Err(crate::error::Error::unsupported(
+                            "TO_ISO8601 translation preserving source precision and time zone",
+                            target.to_string(),
+                        ));
+                    }
                     // DuckDB json(x) is a synonym for CAST(x AS JSON) — parses a string.
                     // Map to JSON_PARSE(x) for Trino/Presto/Athena to preserve semantics.
                     if matches!(source, DialectType::PostgreSQL)
@@ -1795,6 +1806,19 @@ pub(super) fn normalize(
                         // The Redshift parser adds 'UTC' as default source_tz, but when
                         // transpiling from other dialects, we should preserve the original form.
                         Action::Temporal(temporal::Action::ConvertTimezoneToExpr)
+                    } else if matches!(source, DialectType::Athena | DialectType::Presto | DialectType::Trino)
+                        && matches!(target, DialectType::DuckDB)
+                        && name == "REGEXP_EXTRACT"
+                        && matches!(f.args.len(), 2 | 3)
+                    {
+                        Action::Operators(operators::Action::RegexpExtractPrestoToDuckDB)
+                    } else if matches!(source, DialectType::Athena | DialectType::Presto | DialectType::Trino)
+                        && matches!(target, DialectType::DuckDB)
+                        && name == "REGEXP_REPLACE"
+                        && matches!(f.args.len(), 2 | 3)
+                        && !matches!(f.args.get(2), Some(Expression::Lambda(_)))
+                    {
+                        Action::Operators(operators::Action::RegexpReplacePrestoToDuckDB)
                     } else if matches!(source, DialectType::Snowflake)
                         && matches!(target, DialectType::DuckDB)
                         && name == "REGEXP_REPLACE"

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/src/dialects/normalization/operators.rs

@@ -8,6 +8,8 @@ pub(super) enum Action {
     Div0TypedDivision,
     SourceDivisionToClickHouse,
     RegexpReplaceSnowflakeToDuckDB,
+    RegexpExtractPrestoToDuckDB,
+    RegexpReplacePrestoToDuckDB,
     BigQuerySafeDivide,
     RegexpLikeToDuckDB,
     RegexpLikeToTsqlPatindex,
@@ -47,6 +49,36 @@ pub(super) fn rewrite(
     let e = expression;
     let expression = (|| -> Result<Expression> {
         match action {
+            Action::RegexpReplacePrestoToDuckDB => {
+                if let Expression::Function(mut f) = e {
+                    if f.args.len() == 2 {
+                        f.args.push(Expression::string(""));
+                    } else if let Expression::Literal(lit) = &f.args[2] {
+                        if let Literal::String(replacement) = lit.as_ref() {
+                            f.args[2] = Expression::string(presto_regexp_replacement_to_duckdb(
+                                replacement,
+                            )?);
+                        }
+                    }
+                    f.args.push(Expression::string("g"));
+                    Ok(Expression::Function(f))
+                } else {
+                    unreachable!("action only triggered for REGEXP_REPLACE functions")
+                }
+            }
+            Action::RegexpExtractPrestoToDuckDB => {
+                if let Expression::Function(mut f) = e {
+                    // A missing first match (or capture group) is NULL, while
+                    // a successful empty capture must remain an empty string.
+                    f.name = "REGEXP_EXTRACT_ALL".to_string();
+                    Ok(Expression::Function(Box::new(Function::new(
+                        "ARRAY_EXTRACT",
+                        vec![Expression::Function(f), Expression::number(1)],
+                    ))))
+                } else {
+                    unreachable!("action only triggered for REGEXP_EXTRACT functions")
+                }
+            }
             Action::SourceDivisionToClickHouse => {
                 if let Expression::Div(div) = e {
                     normalize_source_division_to_clickhouse(*div, context)
@@ -2223,3 +2255,47 @@ pub(super) fn build_tsql_cbrt_power(this: Expression) -> Expression {
         inferred_type: None,
     }))
 }
+
+fn presto_regexp_replacement_to_duckdb(replacement: &str) -> Result<String> {
+    let mut chars = replacement.chars().peekable();
+    let mut converted = String::with_capacity(replacement.len());
+    while let Some(ch) = chars.next() {
+        match ch {
+            '\\' => {
+                if let Some(literal) = chars.next() {
+                    // Trino quotes the following character; RE2 only needs
+                    // quoting for a literal backslash in replacement text.
+                    if literal == '\\' {
+                        converted.push('\\');
+                    }
+                    converted.push(literal);
+                } else {
+                    return Err(crate::error::Error::unsupported(
+                        "REGEXP_REPLACE replacement ends in an escape",
+                        "duckdb",
+                    ));
+                }
+            }
+            '$' => match chars.next() {
+                Some(group) if group.is_ascii_digit() => {
+                    if chars.peek().is_some_and(|ch| ch.is_ascii_digit()) {
+                        return Err(crate::error::Error::unsupported(
+                            "DuckDB REGEXP_REPLACE does not support multi-digit capture references",
+                            "duckdb",
+                        ));
+                    }
+                    converted.push('\\');
+                    converted.push(group);
+                }
+                _ => {
+                    return Err(crate::error::Error::unsupported(
+                        "DuckDB REGEXP_REPLACE requires numbered capture references",
+                        "duckdb",
+                    ))
+                }
+            },
+            _ => converted.push(ch),
+        }
+    }
+    Ok(converted)
+}

{polyglot_sql-0.12.0 → polyglot_sql-0.12.1}/crates/polyglot-sql/src/generator.rs

@@ -2447,6 +2447,18 @@ impl Generator {
         Ok(std::mem::take(&mut self.output))
     }
 
+    /// Render an analysis type without implicit ClickHouse Nullable wrapping.
+    #[cfg(feature = "semantic")]
+    pub(crate) fn generate_type_hint(&mut self, data_type: &DataType) -> Result<String> {
+        // Analysis already models nullability separately. Native ClickHouse
+        // types must acquire Nullable only from an explicit type wrapper.
+        let saved_depth = self.clickhouse_nullable_depth;
+        self.clickhouse_nullable_depth = -1;
+        let result = self.generate(&Expression::DataType(data_type.clone()));
+        self.clickhouse_nullable_depth = saved_depth;
+        result
+    }
+
     /// Returns the unsupported diagnostics collected during the most recent generate call.
     pub fn unsupported_messages(&self) -> &[String] {
         &self.unsupported_messages
@@ -26850,9 +26862,10 @@ impl Generator {
                         // ClickHouse: Map(key_type, value_type) with parenthesized syntax
                         // Key types must NOT be wrapped in Nullable
                         self.write("Map(");
+                        let saved_depth = self.clickhouse_nullable_depth;
                         self.clickhouse_nullable_depth = -1; // suppress Nullable for key
                         self.generate_data_type(key_type)?;
-                        self.clickhouse_nullable_depth = 0;
+                        self.clickhouse_nullable_depth = saved_depth;
                         self.write(", ");
                         self.generate_data_type(value_type)?;
                         self.write(")");