polyglot-sql 0.6.3__tar.gz → 0.7.0__tar.gz

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/Cargo.lock

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

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/Cargo.toml

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

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.6.3
+Version: 0.7.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -222,6 +222,11 @@ All functions are exported from `polyglot_sql`.
 - `validate(sql: str, dialect: str = "generic", *, strict_syntax: bool = False, semantic: bool = False) -> ValidationResult`
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
+- `lineage_at(ordinal: int, sql: str, dialect: str = "generic") -> dict`
+- `lineage_at_with_schema(ordinal: int, sql: str, schema: dict, dialect: str = "generic") -> dict`
+- `lineage_with_schema(column: str, sql: str, schema: dict, dialect: str = "generic") -> dict`
+- `output_columns(sql: str, dialect: str = "generic") -> dict`
+- `output_columns_with_schema(sql: str, schema: dict, dialect: str = "generic") -> dict`
 - `source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]`
 - `analyze_query(sql: str, options: dict | None = None, dialect: str = "generic") -> dict`
 - `openlineage_column_lineage(sql: str, options: dict) -> dict`
@@ -246,6 +251,7 @@ Exception hierarchy:
 - `GenerateError`
 - `TranspileError`
 - `ValidationError`
+- `ColumnResolutionError` (`reason`, `column`, and `ordinal` attributes)
 
 Unknown dialect names raise built-in `ValueError`.
 

{polyglot_sql-0.6.3/crates/polyglot-sql-python → polyglot_sql-0.7.0}/README.md

@@ -195,6 +195,11 @@ All functions are exported from `polyglot_sql`.
 - `validate(sql: str, dialect: str = "generic", *, strict_syntax: bool = False, semantic: bool = False) -> ValidationResult`
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
+- `lineage_at(ordinal: int, sql: str, dialect: str = "generic") -> dict`
+- `lineage_at_with_schema(ordinal: int, sql: str, schema: dict, dialect: str = "generic") -> dict`
+- `lineage_with_schema(column: str, sql: str, schema: dict, dialect: str = "generic") -> dict`
+- `output_columns(sql: str, dialect: str = "generic") -> dict`
+- `output_columns_with_schema(sql: str, schema: dict, dialect: str = "generic") -> dict`
 - `source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]`
 - `analyze_query(sql: str, options: dict | None = None, dialect: str = "generic") -> dict`
 - `openlineage_column_lineage(sql: str, options: dict) -> dict`
@@ -219,6 +224,7 @@ Exception hierarchy:
 - `GenerateError`
 - `TranspileError`
 - `ValidationError`
+- `ColumnResolutionError` (`reason`, `column`, and `ordinal` attributes)
 
 Unknown dialect names raise built-in `ValueError`.
 

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/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.6.3" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.7.0" }
 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.6.3", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.7.0", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/crates/polyglot-sql/README.md

@@ -25,7 +25,7 @@ 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.6.3", default-features = false }
+polyglot-sql = { version = "0.7.0", default-features = false }
 ```
 
 ```toml

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -15,7 +15,7 @@ use crate::expressions::{
     AggFunc, Alias, BinaryOp, Case, Cast, CeilFunc, Column, DataType, Expression, Function,
     Identifier, Interval, IntervalUnit, IntervalUnitSpec, IsNull, JSONPath, JSONPathKey,
     JSONPathRoot, JSONPathSubscript, JsonExtractFunc, Literal, Null, Paren, Struct, Subquery,
-    SubstringFunc, UnaryFunc, UnaryOp, VarArgFunc, WindowFunction,
+    SubstringFunc, UnaryFunc, UnaryOp, Unhex, VarArgFunc, WindowFunction,
 };
 #[cfg(feature = "generate")]
 use crate::generator::GeneratorConfig;
@@ -1687,6 +1687,14 @@ impl DuckDBDialect {
     fn transform_function(&self, f: Function) -> Result<Expression> {
         let name_upper = f.name.to_uppercase();
         match name_upper.as_str() {
+            "FROM_HEX" if f.args.len() == 1 => {
+                let mut args = f.args;
+                Ok(Expression::Unhex(Box::new(Unhex {
+                    this: Box::new(args.remove(0)),
+                    expression: None,
+                })))
+            }
+
             // IFNULL -> COALESCE
             "IFNULL" if f.args.len() == 2 => Ok(Expression::Coalesce(Box::new(VarArgFunc {
                 original_name: None,
@@ -1968,14 +1976,6 @@ impl DuckDBDialect {
                 f.args,
             )))),
 
-            // NOW -> CURRENT_TIMESTAMP
-            "NOW" => Ok(Expression::CurrentTimestamp(
-                crate::expressions::CurrentTimestamp {
-                    precision: None,
-                    sysdate: false,
-                },
-            )),
-
             // GETDATE -> CURRENT_TIMESTAMP
             "GETDATE" => Ok(Expression::CurrentTimestamp(
                 crate::expressions::CurrentTimestamp {

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/crates/polyglot-sql/src/dialects/mod.rs

@@ -580,6 +580,21 @@ fn presto_to_java_format(fmt: &str) -> String {
         .replace("%M", "MMMM")
 }
 
+#[cfg(feature = "transpile")]
+fn presto_to_java_parse_format(fmt: &str) -> String {
+    fmt.replace("%Y", "yyyy")
+        .replace("%m", "M")
+        .replace("%d", "d")
+        .replace("%H", "H")
+        .replace("%i", "m")
+        .replace("%S", "s")
+        .replace("%s", "s")
+        .replace("%y", "yy")
+        .replace("%T", "H:m:s")
+        .replace("%F", "yyyy-M-d")
+        .replace("%M", "MMMM")
+}
+
 #[cfg(feature = "transpile")]
 fn normalize_presto_format(fmt: &str) -> String {
     fmt.replace("%H:%i:%S", "%T").replace("%H:%i:%s", "%T")

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/crates/polyglot-sql/src/dialects/normalization/aggregates.rs

@@ -632,12 +632,9 @@ pub(super) fn rewrite(
 
             Action::ArrayAggToCollectList => {
                 // ARRAY_AGG(x ORDER BY ...) -> COLLECT_LIST(x) for Hive/Spark
-                // Python sqlglot Hive.arrayagg_sql strips ORDER BY for simple cases
-                // but preserves it when DISTINCT/IGNORE NULLS/LIMIT are present
                 match e {
                     Expression::AggregateFunction(mut af) => {
-                        let is_simple =
-                            !af.distinct && af.ignore_nulls.is_none() && af.limit.is_none();
+                        let preserves_order = af.limit.is_some();
                         let args = if af.args.is_empty() {
                             vec![]
                         } else {
@@ -645,24 +642,23 @@ pub(super) fn rewrite(
                         };
                         af.name = "COLLECT_LIST".to_string();
                         af.args = args;
-                        if is_simple {
+                        if !preserves_order {
                             af.order_by = Vec::new();
                         }
                         Ok(Expression::AggregateFunction(af))
                     }
                     Expression::ArrayAgg(agg) => {
-                        let is_simple =
-                            !agg.distinct && agg.ignore_nulls.is_none() && agg.limit.is_none();
+                        let preserves_order = agg.limit.is_some();
                         Ok(Expression::AggregateFunction(Box::new(
                             crate::expressions::AggregateFunction {
                                 name: "COLLECT_LIST".to_string(),
                                 args: vec![agg.this.clone()],
                                 distinct: agg.distinct,
                                 filter: agg.filter.clone(),
-                                order_by: if is_simple {
-                                    Vec::new()
-                                } else {
+                                order_by: if preserves_order {
                                     agg.order_by.clone()
+                                } else {
+                                    Vec::new()
                                 },
                                 limit: agg.limit.clone(),
                                 ignore_nulls: agg.ignore_nulls,
@@ -716,14 +712,19 @@ pub(super) fn rewrite(
             }
 
             Action::ArrayAggIgnoreNullsDuckDB => {
-                // ARRAY_AGG(x IGNORE NULLS ORDER BY a, b DESC) -> ARRAY_AGG(x ORDER BY a NULLS FIRST, b DESC)
-                // Strip IGNORE NULLS, add NULLS FIRST to first ORDER BY column
+                // ARRAY_AGG(x IGNORE NULLS ...) -> ARRAY_AGG(x ...) FILTER(WHERE x IS NOT NULL)
+                // DuckDB also needs NULLS FIRST on the first inline ordering expression.
                 let mut agg = if let Expression::ArrayAgg(a) = e {
                     *a
                 } else {
                     unreachable!("action only triggered for ArrayAgg expressions")
                 };
-                agg.ignore_nulls = None; // Strip IGNORE NULLS
+                agg.ignore_nulls = None;
+                agg.filter = Some(Expression::IsNull(Box::new(IsNull {
+                    this: agg.this.clone(),
+                    not: true,
+                    postfix_form: false,
+                })));
                 if !agg.order_by.is_empty() {
                     agg.order_by[0].nulls_first = Some(true);
                 }
@@ -858,11 +859,19 @@ pub(super) fn rewrite(
 
             Action::AggFilterToIff => {
                 // AggFunc.filter -> IFF wrapping: AVG(x) FILTER(WHERE cond) -> AVG(IFF(cond, x, NULL))
+                let prefix_not_null = |condition: Expression| match condition {
+                    Expression::IsNull(mut is_null) if is_null.not => {
+                        is_null.postfix_form = true;
+                        Expression::IsNull(is_null)
+                    }
+                    other => other,
+                };
                 // Helper macro to handle the common AggFunc case
                 macro_rules! handle_agg_filter_to_iff {
                     ($variant:ident, $agg:expr) => {{
                         let mut agg = $agg;
                         if let Some(filter_cond) = agg.filter.take() {
+                            let filter_cond = prefix_not_null(filter_cond);
                             let iff_call = Expression::Function(Box::new(Function::new(
                                 "IFF".to_string(),
                                 vec![filter_cond, agg.this.clone(), Expression::Null(Null)],
@@ -878,7 +887,24 @@ pub(super) fn rewrite(
                     Expression::Sum(agg) => handle_agg_filter_to_iff!(Sum, agg),
                     Expression::Min(agg) => handle_agg_filter_to_iff!(Min, agg),
                     Expression::Max(agg) => handle_agg_filter_to_iff!(Max, agg),
-                    Expression::ArrayAgg(agg) => handle_agg_filter_to_iff!(ArrayAgg, agg),
+                    Expression::ArrayAgg(mut agg) => {
+                        if let Some(filter_cond) = agg.filter.take() {
+                            let filter_cond = prefix_not_null(filter_cond);
+                            agg.this = Expression::Function(Box::new(Function::new(
+                                "IFF".to_string(),
+                                vec![filter_cond, agg.this, Expression::Null(Null)],
+                            )));
+                        }
+                        if agg.order_by.is_empty() {
+                            Ok(Expression::ArrayAgg(agg))
+                        } else {
+                            let order_by = std::mem::take(&mut agg.order_by);
+                            Ok(Expression::WithinGroup(Box::new(WithinGroup {
+                                this: Expression::ArrayAgg(agg),
+                                order_by,
+                            })))
+                        }
+                    }
                     Expression::CountIf(agg) => handle_agg_filter_to_iff!(CountIf, agg),
                     Expression::Stddev(agg) => handle_agg_filter_to_iff!(Stddev, agg),
                     Expression::StddevPop(agg) => handle_agg_filter_to_iff!(StddevPop, agg),
@@ -896,7 +922,21 @@ pub(super) fn rewrite(
                     }
                     Expression::Count(mut c) => {
                         if let Some(filter_cond) = c.filter.take() {
-                            if let Some(ref this_expr) = c.this {
+                            let filter_cond = prefix_not_null(filter_cond);
+                            let is_star = c.star || matches!(c.this, Some(Expression::Star(_)));
+                            if is_star {
+                                return Ok(Expression::CountIf(Box::new(AggFunc {
+                                    this: filter_cond,
+                                    distinct: false,
+                                    filter: None,
+                                    order_by: Vec::new(),
+                                    name: None,
+                                    ignore_nulls: None,
+                                    having_max: None,
+                                    limit: None,
+                                    inferred_type: None,
+                                })));
+                            } else if let Some(ref this_expr) = c.this {
                                 let iff_call = Expression::Function(Box::new(Function::new(
                                     "IFF".to_string(),
                                     vec![filter_cond, this_expr.clone(), Expression::Null(Null)],
@@ -906,6 +946,18 @@ pub(super) fn rewrite(
                         }
                         Ok(Expression::Count(c))
                     }
+                    Expression::AggregateFunction(mut af) => {
+                        if let Some(filter_cond) = af.filter.take() {
+                            let filter_cond = prefix_not_null(filter_cond);
+                            if let Some(first_arg) = af.args.first_mut() {
+                                *first_arg = Expression::Function(Box::new(Function::new(
+                                    "IFF".to_string(),
+                                    vec![filter_cond, first_arg.clone(), Expression::Null(Null)],
+                                )));
+                            }
+                        }
+                        Ok(Expression::AggregateFunction(af))
+                    }
                     other => Ok(other),
                 }
             }

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/crates/polyglot-sql/src/dialects/normalization/collections.rs

@@ -862,7 +862,11 @@ pub(super) fn rewrite(
                         }
 
                         let seq = Expression::Function(Box::new(Function::new(
-                            "SEQUENCE".to_string(),
+                            if matches!(target, DialectType::BigQuery) {
+                                "GENERATE_ARRAY".to_string()
+                            } else {
+                                "SEQUENCE".to_string()
+                            },
                             seq_args,
                         )));
 

{polyglot_sql-0.6.3 → polyglot_sql-0.7.0}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -86,6 +86,118 @@ pub(super) fn normalize(
     let expr = statements::normalize_root(expr, &context);
 
     transform_recursive(expr, &|e| {
+        if matches!(source, DialectType::DataFusion) && matches!(target, DialectType::DuckDB) {
+            if let Expression::Function(ref function) = e {
+                if function.name.eq_ignore_ascii_case("NOW") && function.args.is_empty() {
+                    return Ok(Expression::CurrentTimestamp(
+                        crate::expressions::CurrentTimestamp {
+                            precision: None,
+                            sysdate: false,
+                        },
+                    ));
+                }
+            }
+        }
+
+        if matches!(source, DialectType::Teradata)
+            && matches!(target, DialectType::Spark | DialectType::Databricks)
+        {
+            if let Expression::StrToDate(ref str_to_date) = e {
+                let mut normalized = str_to_date.as_ref().clone();
+                normalized.format = normalized.format.map(|format| format.replace("%d", "%-d"));
+                return Ok(Expression::StrToDate(Box::new(normalized)));
+            }
+        }
+
+        if matches!(source, DialectType::DuckDB) && matches!(target, DialectType::DuckDB) {
+            if let Expression::ArrayAgg(ref array_agg) = e {
+                if let Some(Expression::IsNull(is_null)) = &array_agg.filter {
+                    if is_null.not && !is_null.postfix_form {
+                        let mut normalized = array_agg.as_ref().clone();
+                        let mut condition = is_null.as_ref().clone();
+                        condition.postfix_form = true;
+                        normalized.filter = Some(Expression::IsNull(Box::new(condition)));
+                        return Ok(Expression::ArrayAgg(Box::new(normalized)));
+                    }
+                }
+            }
+        }
+
+        if matches!(source, DialectType::Generic) && matches!(target, DialectType::BigQuery) {
+            if let Expression::TimeToStr(ref time_to_str) = e {
+                let mut normalized = time_to_str.as_ref().clone();
+                normalized.format = normalized
+                    .format
+                    .replace("%Y-%m-%d", "%F")
+                    .replace("%H:%M:%S", "%T");
+                return Ok(Expression::TimeToStr(Box::new(normalized)));
+            }
+        }
+
+        if matches!(source, DialectType::Hive) && matches!(target, DialectType::Hive) {
+            if let Expression::Function(ref function) = e {
+                if function.name.eq_ignore_ascii_case("STR_TO_DATE") && function.args.len() == 1 {
+                    return Ok(Expression::Cast(Box::new(Cast {
+                        this: function.args[0].clone(),
+                        to: DataType::Date,
+                        trailing_comments: Vec::new(),
+                        double_colon_syntax: false,
+                        format: None,
+                        default: None,
+                        inferred_type: None,
+                    })));
+                }
+            }
+        }
+
+        if matches!(source, DialectType::Generic) && matches!(target, DialectType::Drill) {
+            if let Expression::ILike(ref like) = e {
+                return Ok(Expression::Function(Box::new(Function::new(
+                    "ILIKE".to_string(),
+                    vec![like.left.clone(), like.right.clone()],
+                ))));
+            }
+        }
+
+        // DuckDB canonicalizes `x IS NOT NULL` as prefix `NOT x IS NULL`.
+        if matches!(source, DialectType::DuckDB) {
+            if let Expression::IsNull(ref is_null) = e {
+                if is_null.not && !is_null.postfix_form {
+                    let mut normalized = is_null.as_ref().clone();
+                    normalized.postfix_form = true;
+                    return Ok(Expression::IsNull(Box::new(normalized)));
+                }
+            }
+        }
+
+        // Snowflake COUNT_IF requires an explicitly boolean predicate in DuckDB.
+        if matches!(source, DialectType::Snowflake) && matches!(target, DialectType::DuckDB) {
+            if let Expression::CountIf(ref count_if) = e {
+                let mut count_if = count_if.as_ref().clone();
+                count_if.this = Expression::Is(Box::new(crate::expressions::BinaryOp::new(
+                    Expression::Paren(Box::new(crate::expressions::Paren {
+                        this: count_if.this,
+                        trailing_comments: Vec::new(),
+                    })),
+                    Expression::Boolean(crate::expressions::BooleanLiteral { value: true }),
+                )));
+                return Ok(Expression::CountIf(Box::new(count_if)));
+            }
+        }
+
+        if matches!(source, DialectType::Presto | DialectType::Trino)
+            && matches!(target, DialectType::DuckDB)
+        {
+            if let Expression::Function(ref function) = e {
+                if function.name.eq_ignore_ascii_case("SHA256") && function.args.len() == 1 {
+                    return Ok(Expression::Unhex(Box::new(crate::expressions::Unhex {
+                        this: Box::new(Expression::Function(function.clone())),
+                        expression: None,
+                    })));
+                }
+            }
+        }
+
         if matches!(source, DialectType::PostgreSQL | DialectType::Redshift)
             && matches!(target, DialectType::TSQL | DialectType::Fabric)
         {
@@ -616,7 +728,100 @@ pub(super) fn normalize(
             }
         }
 
-        // BigQuery IN UNNEST(expr) -> IN (SELECT UNNEST/EXPLODE(expr)) for non-BigQuery targets
+        // BigQuery renders NOT IN UNNEST as prefix NOT around the membership predicate.
+        if matches!(source, DialectType::BigQuery) && matches!(target, DialectType::BigQuery) {
+            if let Expression::In(ref in_expr) = e {
+                if in_expr.not && in_expr.unnest.is_some() {
+                    let mut positive = in_expr.as_ref().clone();
+                    positive.not = false;
+                    return Ok(Expression::Not(Box::new(crate::expressions::UnaryOp::new(
+                        Expression::In(Box::new(positive)),
+                    ))));
+                }
+            }
+        }
+
+        // BigQuery IN UNNEST(expr) -> a NULL-aware DuckDB CASE expression.
+        if matches!(source, DialectType::BigQuery) && matches!(target, DialectType::DuckDB) {
+            if let Expression::In(ref in_expr) = e {
+                if let Some(ref unnest_inner) = in_expr.unnest {
+                    let array = unnest_inner.as_ref().clone();
+                    let value = in_expr.this.clone();
+                    let array_length = || {
+                        Expression::Function(Box::new(Function::new(
+                            "ARRAY_LENGTH".to_string(),
+                            vec![array.clone()],
+                        )))
+                    };
+                    let empty_or_null =
+                        Expression::Or(Box::new(crate::expressions::BinaryOp::new(
+                            Expression::IsNull(Box::new(crate::expressions::IsNull {
+                                this: array.clone(),
+                                not: false,
+                                postfix_form: false,
+                            })),
+                            Expression::Eq(Box::new(crate::expressions::BinaryOp::new(
+                                array_length(),
+                                Expression::number(0),
+                            ))),
+                        )));
+                    let contains = Expression::Function(Box::new(Function::new(
+                        "ARRAY_CONTAINS".to_string(),
+                        vec![array.clone(), value.clone()],
+                    )));
+                    let value_null_or_array_has_null =
+                        Expression::Or(Box::new(crate::expressions::BinaryOp::new(
+                            Expression::IsNull(Box::new(crate::expressions::IsNull {
+                                this: value,
+                                not: false,
+                                postfix_form: false,
+                            })),
+                            Expression::Neq(Box::new(crate::expressions::BinaryOp::new(
+                                array_length(),
+                                Expression::Function(Box::new(Function::new(
+                                    "LIST_COUNT".to_string(),
+                                    vec![array],
+                                ))),
+                            ))),
+                        )));
+                    let case = Expression::Case(Box::new(Case {
+                        operand: None,
+                        whens: vec![
+                            (
+                                empty_or_null,
+                                Expression::Boolean(crate::expressions::BooleanLiteral {
+                                    value: false,
+                                }),
+                            ),
+                            (
+                                contains,
+                                Expression::Boolean(crate::expressions::BooleanLiteral {
+                                    value: true,
+                                }),
+                            ),
+                            (
+                                value_null_or_array_has_null,
+                                Expression::Null(crate::expressions::Null),
+                            ),
+                        ],
+                        else_: Some(Expression::Boolean(crate::expressions::BooleanLiteral {
+                            value: false,
+                        })),
+                        comments: Vec::new(),
+                        inferred_type: None,
+                    }));
+                    return if in_expr.not {
+                        Ok(Expression::Not(Box::new(crate::expressions::UnaryOp::new(
+                            case,
+                        ))))
+                    } else {
+                        Ok(case)
+                    };
+                }
+            }
+        }
+
+        // BigQuery IN UNNEST(expr) -> IN (SELECT UNNEST/EXPLODE(expr)) for other targets
         if matches!(source, DialectType::BigQuery) && !matches!(target, DialectType::BigQuery) {
             if let Expression::In(ref in_expr) = e {
                 if let Some(ref unnest_inner) = in_expr.unnest {
@@ -1403,6 +1608,25 @@ pub(super) fn normalize(
             }
         }
 
+        // ARRAY_CONCAT_AGG -> DuckDB: flatten an ARRAY_AGG while excluding NULL arrays.
+        if matches!(target, DialectType::DuckDB) {
+            if let Expression::ArrayConcatAgg(ref agg) = e {
+                let mut agg = agg.as_ref().clone();
+                agg.name = None;
+                agg.filter = Some(Expression::IsNull(Box::new(crate::expressions::IsNull {
+                    this: agg.this.clone(),
+                    not: true,
+                    postfix_form: true,
+                })));
+                if let Some(first) = agg.order_by.first_mut() {
+                    first.nulls_first = Some(true);
+                }
+                return Ok(Expression::ArrayFlatten(Box::new(
+                    crate::expressions::UnaryFunc::new(Expression::ArrayAgg(Box::new(agg))),
+                )));
+            }
+        }
+
         // ARRAY_CONCAT_AGG -> others: keep as function for cross-dialect
         if !matches!(target, DialectType::BigQuery | DialectType::Snowflake) {
             if let Expression::ArrayConcatAgg(agg) = e {
@@ -1779,7 +2003,7 @@ pub(super) fn normalize(
                             | "STRFTIME" | "STRPTIME"
                             | "DATE_FORMAT" | "FORMAT_DATE"
                             | "PARSE_TIMESTAMP" | "PARSE_DATETIME" | "PARSE_DATE"
-                            | "FROM_ISO8601_TIMESTAMP" | "FROM_ISO8601_DATE"
+                            | "FROM_ISO8601_TIMESTAMP" | "FROM_ISO8601_TIMESTAMP_NANOS" | "FROM_ISO8601_DATE"
                             | "FROM_BASE64" | "TO_BASE64"
                             | "GETDATE"
                             | "TO_HEX" | "FROM_HEX" | "UNHEX" | "HEX"
@@ -1957,6 +2181,11 @@ pub(super) fn normalize(
                         }
                     }
                 }
+                Expression::AggregateFunction(af)
+                    if matches!(target, DialectType::Snowflake) && af.filter.is_some() =>
+                {
+                    Action::Aggregates(aggregates::Action::AggFilterToIff)
+                }
                 Expression::AggregateFunction(af) => {
                     let name = af.name.to_ascii_uppercase();
                     match name.as_str() {
@@ -2124,7 +2353,9 @@ pub(super) fn normalize(
                     _ => Action::None,
                 },
                 Expression::ArrayAgg(ref agg) => {
-                    if matches!(target, DialectType::MySQL | DialectType::SingleStore) {
+                    if matches!(target, DialectType::Snowflake) && agg.filter.is_some() {
+                        Action::Aggregates(aggregates::Action::AggFilterToIff)
+                    } else if matches!(target, DialectType::MySQL | DialectType::SingleStore) {
                         Action::Aggregates(aggregates::Action::ArrayAggToGroupConcat)
                     } else if matches!(
                         target,
@@ -2143,7 +2374,6 @@ pub(super) fn normalize(
                         Action::Aggregates(aggregates::Action::ArrayAggNullFilter)
                     } else if matches!(target, DialectType::DuckDB)
                         && agg.ignore_nulls == Some(true)
-                        && !agg.order_by.is_empty()
                     {
                         // BigQuery ARRAY_AGG(x IGNORE NULLS ORDER BY ...) -> DuckDB ARRAY_AGG(x ORDER BY a NULLS FIRST, ...)
                         Action::Aggregates(aggregates::Action::ArrayAggIgnoreNullsDuckDB)