polyglot-sql 0.13.3__tar.gz → 0.13.5__tar.gz

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/Cargo.lock

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

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/Cargo.toml

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

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/PKG-INFO

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

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/Cargo.toml

@@ -103,14 +103,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.3" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.5" }
 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.13.3", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.5", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/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.13.3", default-features = false }
+polyglot-sql = { version = "0.13.5", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.13.3",
+    version = "0.13.5",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.13.3",
+    version = "0.13.5",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.13.3",
+    version = "0.13.5",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -111,6 +111,9 @@ impl DialectImpl for ClickHouseDialect {
 
         let wrap_not_target = |expr: Expression| -> Expression {
             match expr {
+                // The generator emits typed negated LIKE predicates directly.
+                // Keep that form stable when reparsing lowered notLike calls.
+                Expression::Like(_) | Expression::ILike(_) => expr,
                 Expression::Paren(_) => expr,
                 Expression::In(_)
                 | Expression::Between(_)
@@ -119,8 +122,6 @@ impl DialectImpl for ClickHouseDialect {
                 | Expression::IsTrue(_)
                 | Expression::IsFalse(_)
                 | Expression::IsJson(_)
-                | Expression::Like(_)
-                | Expression::ILike(_)
                 | Expression::SimilarTo(_)
                 | Expression::Glob(_)
                 | Expression::RegexpLike(_)

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/mod.rs

@@ -757,8 +757,8 @@ fn query_output_width(e: &Expression) -> Option<usize> {
 /// The source's explicit direction and NULL order (if any) carry over to each
 /// positional entry unchanged; the later cross-dialect NULL-ordering pass
 /// fills in the source dialect's implied default where the target's differs.
-/// MySQL is the exception: it has no NULLS FIRST/LAST syntax and is skipped by
-/// that pass, so compare every supported source's default against MySQL here.
+/// MySQL additionally checks placement here because a known width alone does
+/// not establish that every generated ordinal can be resolved to an expression.
 #[cfg(feature = "transpile")]
 fn expand_order_by_all(
     order_by: &mut Option<crate::expressions::OrderBy>,
@@ -800,11 +800,8 @@ fn expand_order_by_all(
         .map(|i| {
             let mut o = ob.expressions[0].clone();
             o.this = E::number(i);
-            if target == DialectType::MySQL {
-                // Matching explicit NULL placement is redundant and MySQL
-                // cannot print the NULLS FIRST/LAST syntax.
-                o.nulls_first = None;
-            }
+            // Keep explicit placement until generation. Clearing it here would
+            // make normalization substitute the source dialect's implicit default.
             o
         })
         .collect();
@@ -947,6 +944,8 @@ where
             | Expression::BitwiseAnd(_)
             | Expression::BitwiseOr(_)
             | Expression::BitwiseXor(_)
+            | Expression::BitwiseLeftShift(_)
+            | Expression::BitwiseRightShift(_)
             | Expression::Is(_)
             | Expression::MemberOf(_)
             | Expression::ArrayContainsAll(_)
@@ -2110,6 +2109,8 @@ where
         Expression::BitwiseAnd(op) => transform_binary!(BitwiseAnd, *op),
         Expression::BitwiseOr(op) => transform_binary!(BitwiseOr, *op),
         Expression::BitwiseXor(op) => transform_binary!(BitwiseXor, *op),
+        Expression::BitwiseLeftShift(op) => transform_binary!(BitwiseLeftShift, *op),
+        Expression::BitwiseRightShift(op) => transform_binary!(BitwiseRightShift, *op),
         Expression::Is(op) => transform_binary!(Is, *op),
 
         // ===== TryCast / SafeCast =====
@@ -3436,6 +3437,7 @@ impl Dialect {
             feature = "dialect-sqlite",
             feature = "dialect-trino",
             feature = "dialect-presto",
+            feature = "dialect-athena",
             feature = "dialect-duckdb",
             feature = "dialect-redshift",
             feature = "dialect-starrocks",
@@ -3579,6 +3581,12 @@ impl Dialect {
                 let expr = transforms::explode_projection_to_unnest(expr, DialectType::Presto)?;
                 Ok(expr)
             }
+            #[cfg(feature = "dialect-athena")]
+            DialectType::Athena => {
+                let expr = transforms::eliminate_qualify(expr)?;
+                let expr = transforms::eliminate_window_clause(expr)?;
+                transforms::explode_projection_to_unnest(expr, DialectType::Athena)
+            }
             // DuckDB supports QUALIFY - no elimination needed
             // Expand POSEXPLODE to GENERATE_SUBSCRIPTS + UNNEST
             // Expand LIKE ANY / ILIKE ANY to OR chains (DuckDB doesn't support quantifiers)
@@ -3588,15 +3596,14 @@ impl Dialect {
                 let expr = transforms::expand_like_any(expr)?;
                 Ok(expr)
             }
-            // Redshift doesn't support QUALIFY, WINDOW clause, or GENERATE_DATE_ARRAY
+            // Redshift supports QUALIFY, but not WINDOW or GENERATE_DATE_ARRAY.
             #[cfg(feature = "dialect-redshift")]
             DialectType::Redshift => {
-                let expr = transforms::eliminate_qualify(expr)?;
                 let expr = transforms::eliminate_window_clause(expr)?;
                 let expr = transforms::unnest_generate_date_array_using_recursive_cte(expr)?;
                 Ok(expr)
             }
-            // StarRocks doesn't support BETWEEN in DELETE statements or QUALIFY
+            // StarRocks supports only restricted QUALIFY forms; lower the general form.
             #[cfg(feature = "dialect-starrocks")]
             DialectType::StarRocks => {
                 let expr = transforms::eliminate_qualify(expr)?;
@@ -4329,6 +4336,11 @@ impl Dialect {
                     normalized
                 };
 
+                let normalized = crate::transforms::lower_set_operations_by_name(
+                    normalized,
+                    self.dialect_type,
+                    target,
+                )?;
                 let transformed =
                     target_dialect.transform_with_guard(normalized, opts.complexity_guard)?;
 
@@ -9201,6 +9213,7 @@ impl Dialect {
                 cross_apply: None,
                 ordinality: None,
                 column_aliases: vec![],
+                column_aliases_quoted: vec![],
             }));
 
             // Remove the original join and add to FROM expressions

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -2746,33 +2746,13 @@ pub(super) fn normalize(
                 // When nulls_first is not specified, fill in the source dialect's implied
                 // default so the target generator can correctly add/strip NULLS FIRST/LAST.
                 Expression::Ordered(o) => {
-                    // MySQL doesn't support NULLS FIRST/LAST - strip or rewrite
-                    if matches!(target, DialectType::MySQL) && o.nulls_first.is_some() {
-                        Action::Operators(operators::Action::MysqlNullsOrdering)
+                    if o.nulls_first.is_none()
+                        && source != target
+                        && source != DialectType::Vertica
+                    {
+                        Action::Operators(operators::Action::NullsOrdering)
                     } else {
-                        // Skip targets that don't support NULLS FIRST/LAST syntax unless
-                        // the generator can preserve semantics with a CASE sort key.
-                        let target_rewrites_nulls =
-                            matches!(target, DialectType::TSQL | DialectType::Fabric);
-                        let target_supports_nulls = !matches!(
-                            target,
-                            DialectType::MySQL
-                                | DialectType::TSQL
-                                | DialectType::Fabric
-                                | DialectType::StarRocks
-                                | DialectType::Doris
-                        );
-                        // Vertica's implicit NULL placement depends on the sort key's data
-                        // type (NULLS AUTO), so there is no source default to make explicit.
-                        if o.nulls_first.is_none()
-                            && source != target
-                            && source != DialectType::Vertica
-                            && (target_supports_nulls || target_rewrites_nulls)
-                        {
-                            Action::Operators(operators::Action::NullsOrdering)
-                        } else {
-                            Action::None
-                        }
+                        Action::None
                     }
                 }
                 // BigQuery data types: convert INT64, BYTES, NUMERIC etc. to standard types
@@ -3556,7 +3536,6 @@ pub(super) fn normalize(
                     Action::Collections(collections::Action::ArrayIndexConvert)
                 }
                 // ANY_VALUE IGNORE NULLS detection moved to the AnyValue arm above
-                // MysqlNullsOrdering for Ordered is now handled in the Ordered arm above
                 // RESPECT NULLS handling for SQLite (strip it, add NULLS LAST to ORDER BY)
                 // and for MySQL (rewrite ORDER BY with CASE WHEN for null ordering)
                 Expression::WindowFunction(ref wf) => {
@@ -3569,25 +3548,7 @@ pub(super) fn normalize(
                         && wf.over.order_by.iter().any(|o| o.nulls_first.is_some())
                     {
                         Action::Operators(operators::Action::BigQueryNullsOrdering)
-                    // DuckDB -> MySQL: Add CASE WHEN for NULLS LAST simulation in window ORDER BY
-                    // But NOT when frame is RANGE/GROUPS, since adding CASE WHEN would break value-based frames
                     } else {
-                        let source_nulls_last = matches!(source, DialectType::DuckDB);
-                        let has_range_frame = wf.over.frame.as_ref().map_or(false, |f| {
-                            matches!(
-                                f.kind,
-                                crate::expressions::WindowFrameKind::Range
-                                    | crate::expressions::WindowFrameKind::Groups
-                            )
-                        });
-                        if source_nulls_last
-                            && matches!(target, DialectType::MySQL)
-                            && !wf.over.order_by.is_empty()
-                            && wf.over.order_by.iter().any(|o| !o.desc)
-                            && !has_range_frame
-                        {
-                            Action::Scalar(scalar::Action::MysqlNullsLastRewrite)
-                        } else {
                             // Check for Snowflake window frame handling for FIRST_VALUE/LAST_VALUE/NTH_VALUE
                             let is_ranking_window_func = matches!(
                                 &wf.this,
@@ -3639,7 +3600,6 @@ pub(super) fn normalize(
                                     _ => Action::None,
                                 }
                             }
-                        }
                     }
                 }
                 // CREATE TABLE a LIKE b -> dialect-specific transformations

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/operators.rs

@@ -20,7 +20,6 @@ pub(super) enum Action {
     DollarParamConvert,
     AnyToExists,
     RespectNullsConvert,
-    MysqlNullsOrdering,
     BigQueryNullsOrdering,
     PipeConcatToConcat,
     PostgresPipeConcatToTsql,
@@ -691,57 +690,6 @@ pub(super) fn rewrite(
                 }
             }
 
-            Action::MysqlNullsOrdering => {
-                // MySQL doesn't support NULLS FIRST/LAST - strip or rewrite
-                if let Expression::Ordered(mut o) = e {
-                    let nulls_last = o.nulls_first == Some(false);
-                    let desc = o.desc;
-                    // MySQL default: ASC -> NULLS LAST, DESC -> NULLS FIRST
-                    // If requested ordering matches default, just strip NULLS clause
-                    let matches_default = if desc {
-                        // DESC default is NULLS FIRST, so nulls_first=true matches
-                        o.nulls_first == Some(true)
-                    } else {
-                        // ASC default is NULLS LAST, so nulls_first=false matches
-                        nulls_last
-                    };
-                    if matches_default {
-                        o.nulls_first = None;
-                        Ok(Expression::Ordered(o))
-                    } else {
-                        // Need CASE WHEN x IS NULL THEN 0/1 ELSE 0/1 END, x
-                        // For ASC NULLS FIRST: ORDER BY CASE WHEN x IS NULL THEN 0 ELSE 1 END, x ASC
-                        // For DESC NULLS LAST: ORDER BY CASE WHEN x IS NULL THEN 1 ELSE 0 END, x DESC
-                        let null_val = if desc { 1 } else { 0 };
-                        let non_null_val = if desc { 0 } else { 1 };
-                        let _case_expr = Expression::Case(Box::new(Case {
-                            operand: None,
-                            whens: vec![(
-                                Expression::IsNull(Box::new(crate::expressions::IsNull {
-                                    this: o.this.clone(),
-                                    not: false,
-                                    postfix_form: false,
-                                })),
-                                Expression::number(null_val),
-                            )],
-                            else_: Some(Expression::number(non_null_val)),
-                            comments: Vec::new(),
-                            inferred_type: None,
-                        }));
-                        o.nulls_first = None;
-                        // Return a tuple of [case_expr, ordered_expr]
-                        // We need to return both as part of the ORDER BY
-                        // But since transform_recursive processes individual expressions,
-                        // we can't easily add extra ORDER BY items here.
-                        // Instead, strip the nulls_first
-                        o.nulls_first = None;
-                        Ok(Expression::Ordered(o))
-                    }
-                } else {
-                    Ok(e)
-                }
-            }
-
             Action::BigQueryNullsOrdering => {
                 // BigQuery doesn't support NULLS FIRST/LAST in window function ORDER BY
                 if let Expression::WindowFunction(mut wf) = e {

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/scalar.rs

@@ -73,7 +73,6 @@ pub(super) enum Action {
     CurrentUserParens,
     EscapeStringNormalize,
     SnowflakeIntervalFormat,
-    MysqlNullsLastRewrite,
     FilterToIff,
     StrPositionExpand,
     CurrentUserSparkParens,
@@ -11247,57 +11246,6 @@ pub(super) fn rewrite(
                 }
             }
 
-            Action::MysqlNullsLastRewrite => {
-                // DuckDB -> MySQL: Add CASE WHEN IS NULL THEN 1 ELSE 0 END to ORDER BY
-                // to simulate NULLS LAST for ASC ordering
-                if let Expression::WindowFunction(mut wf) = e {
-                    let mut new_order_by = Vec::new();
-                    for o in wf.over.order_by {
-                        if !o.desc {
-                            // ASC: DuckDB has NULLS LAST, MySQL has NULLS FIRST
-                            // Add CASE WHEN expr IS NULL THEN 1 ELSE 0 END before expr
-                            let case_expr = Expression::Case(Box::new(Case {
-                                operand: None,
-                                whens: vec![(
-                                    Expression::IsNull(Box::new(crate::expressions::IsNull {
-                                        this: o.this.clone(),
-                                        not: false,
-                                        postfix_form: false,
-                                    })),
-                                    Expression::Literal(Box::new(Literal::Number("1".to_string()))),
-                                )],
-                                else_: Some(Expression::Literal(Box::new(Literal::Number(
-                                    "0".to_string(),
-                                )))),
-                                comments: Vec::new(),
-                                inferred_type: None,
-                            }));
-                            new_order_by.push(crate::expressions::Ordered {
-                                nulls_auto: false,
-                                this: case_expr,
-                                desc: false,
-                                nulls_first: None,
-                                explicit_asc: false,
-                                with_fill: None,
-                            });
-                            let mut ordered = o;
-                            ordered.nulls_first = None;
-                            new_order_by.push(ordered);
-                        } else {
-                            // DESC: DuckDB has NULLS LAST, MySQL also has NULLS LAST (NULLs smallest in DESC)
-                            // No change needed
-                            let mut ordered = o;
-                            ordered.nulls_first = None;
-                            new_order_by.push(ordered);
-                        }
-                    }
-                    wf.over.order_by = new_order_by;
-                    Ok(Expression::WindowFunction(wf))
-                } else {
-                    Ok(e)
-                }
-            }
-
             Action::FilterToIff => {
                 // FILTER(WHERE cond) -> rewrite aggregate: AGG(IFF(cond, val, NULL))
                 if let Expression::Filter(f) = e {

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/statements.rs

@@ -233,15 +233,27 @@ pub(super) fn normalize_root(expression: Expression, context: &NormalizationCont
             });
             for constraint in &mut ct.constraints {
                 if let crate::expressions::TableConstraint::PrimaryKey {
-                    columns, modifiers, ..
+                    columns,
+                    key_parts,
+                    modifiers,
+                    ..
                 } = constraint
                 {
-                    // Strip ASC/DESC from column names
-                    for col in columns.iter_mut() {
-                        if col.name.ends_with(" ASC") {
-                            col.name = col.name[..col.name.len() - 4].to_string();
-                        } else if col.name.ends_with(" DESC") {
-                            col.name = col.name[..col.name.len() - 5].to_string();
+                    if key_parts.is_empty() {
+                        // Older ASTs encoded order modifiers in column names.
+                        for col in columns.iter_mut() {
+                            if col.name.ends_with(" ASC") {
+                                col.name = col.name[..col.name.len() - 4].to_string();
+                            } else if col.name.ends_with(" DESC") {
+                                col.name = col.name[..col.name.len() - 5].to_string();
+                            }
+                        }
+                    } else {
+                        // Structured key names are literal; only remove the
+                        // sort modifiers, including for names ending in DESC.
+                        for part in key_parts.iter_mut() {
+                            part.asc = false;
+                            part.desc = false;
                         }
                     }
                     // Strip TSQL-specific modifiers

{polyglot_sql-0.13.3 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/starrocks.rs

@@ -50,7 +50,7 @@ impl DialectImpl for StarRocksDialect {
             // StarRocks: PROPERTIES prefix for WITH properties
             with_properties_prefix: "PROPERTIES",
             // StarRocks uses MySQL-style settings
-            null_ordering_supported: false,
+            null_ordering_supported: true,
             limit_only_literals: true,
             semi_anti_join_with_side: false,
             supports_table_alias_columns: false,