polyglot-sql 0.13.2__tar.gz → 0.13.4__tar.gz

{polyglot_sql-0.13.2 → polyglot_sql-0.13.4}/Cargo.lock

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

{polyglot_sql-0.13.2 → polyglot_sql-0.13.4}/Cargo.toml

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

{polyglot_sql-0.13.2 → polyglot_sql-0.13.4}/PKG-INFO

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

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

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

{polyglot_sql-0.13.2 → polyglot_sql-0.13.4}/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.2 → polyglot_sql-0.13.4}/crates/polyglot-sql/src/dialects/mod.rs

@@ -947,6 +947,8 @@ where
             | Expression::BitwiseAnd(_)
             | Expression::BitwiseOr(_)
             | Expression::BitwiseXor(_)
+            | Expression::BitwiseLeftShift(_)
+            | Expression::BitwiseRightShift(_)
             | Expression::Is(_)
             | Expression::MemberOf(_)
             | Expression::ArrayContainsAll(_)
@@ -2110,6 +2112,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 =====
@@ -9201,6 +9205,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.4/crates/polyglot-sql/src/dialects/normalization/duckdb.rs

@@ -0,0 +1,272 @@
+//! Preserve DuckDB's type-dependent `//` semantics before target rewrites.
+
+use super::scalar::{expression_numeric_kind, NumericKind};
+use super::*;
+use crate::expressions::RoundFunc;
+
+fn combine(left: NumericKind, right: NumericKind) -> NumericKind {
+    use NumericKind::*;
+    match (left, right) {
+        (Unknown, _) | (_, Unknown) => Unknown,
+        (Float, _) | (_, Float) => Float,
+        (Decimal, _) | (_, Decimal) => Decimal,
+        (Integer, Integer) => Integer,
+    }
+}
+
+fn numeric_kind(expr: &Expression) -> NumericKind {
+    match expr {
+        Expression::Paren(p) => numeric_kind(&p.this),
+        Expression::Neg(n) => numeric_kind(&n.this),
+        Expression::Alias(a) => numeric_kind(&a.this),
+        Expression::Add(b) | Expression::Sub(b) | Expression::Mul(b) | Expression::Mod(b) => {
+            combine(numeric_kind(&b.left), numeric_kind(&b.right))
+        }
+        // The complete bottom-up source pass has already lowered fractional
+        // children to Div. Remaining IntDiv children have integer operands.
+        Expression::IntDiv(_) => NumericKind::Integer,
+        Expression::Div(_) => NumericKind::Float,
+        Expression::Function(f) if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 => {
+            numeric_kind(&f.args[0])
+        }
+        Expression::NullIf(f) => numeric_kind(&f.this),
+        _ => expression_numeric_kind(expr),
+    }
+}
+
+/// Classify the rewritten DataFusion expression. Source `/` nodes have already
+/// been made floating, and lowered `//` nodes retain their operands' types.
+/// Never infer provenance from SQL syntax such as a NULLIF divisor.
+fn datafusion_numeric_kind(expr: &Expression) -> NumericKind {
+    match expr {
+        Expression::Paren(p) => datafusion_numeric_kind(&p.this),
+        Expression::Annotated(a) => datafusion_numeric_kind(&a.this),
+        Expression::Neg(n) => datafusion_numeric_kind(&n.this),
+        Expression::Alias(a) => datafusion_numeric_kind(&a.this),
+        Expression::Abs(f) => datafusion_numeric_kind(&f.this),
+        Expression::Add(b) | Expression::Sub(b) | Expression::Mul(b) | Expression::Mod(b) => {
+            combine(
+                datafusion_numeric_kind(&b.left),
+                datafusion_numeric_kind(&b.right),
+            )
+        }
+        Expression::Div(b) => {
+            let left = datafusion_numeric_kind(&b.left);
+            // Div is already target SQL. Its generated NULLIF follows
+            // DataFusion's common-type coercion, including a floating divisor.
+            let right = match &b.right {
+                Expression::Function(f)
+                    if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 =>
+                {
+                    combine(
+                        datafusion_numeric_kind(&f.args[0]),
+                        datafusion_numeric_kind(&f.args[1]),
+                    )
+                }
+                other => datafusion_numeric_kind(other),
+            };
+            // A source `/` supplies a floating operand even when columns or
+            // function return types on the other side are unresolved.
+            if left == NumericKind::Float || right == NumericKind::Float {
+                NumericKind::Float
+            } else {
+                combine(left, right)
+            }
+        }
+        Expression::Coalesce(f) => datafusion_branch_kind(f.expressions.iter()),
+        Expression::Case(c) => datafusion_branch_kind(
+            c.whens
+                .iter()
+                .map(|(_, result)| result)
+                .chain(c.else_.iter()),
+        ),
+        Expression::IfFunc(f) => {
+            datafusion_branch_kind(std::iter::once(&f.true_value).chain(f.false_value.iter()))
+        }
+        Expression::Function(f) if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 => {
+            datafusion_nullif_kind(&f.args[0], &f.args[1])
+        }
+        Expression::NullIf(f) => datafusion_nullif_kind(&f.this, &f.expression),
+        // Do not assume functions such as ROUND preserve numeric types across
+        // dialects: DuckDB ROUND(integer) is integer, DataFusion's is floating.
+        _ => expression_numeric_kind(expr),
+    }
+}
+
+fn datafusion_branch_kind<'a>(branches: impl Iterator<Item = &'a Expression>) -> NumericKind {
+    branches
+        .filter(|expr| !matches!(expr, Expression::Null(_)))
+        .map(datafusion_numeric_kind)
+        .reduce(combine)
+        .unwrap_or(NumericKind::Unknown)
+}
+
+fn datafusion_nullif_kind(left: &Expression, right: &Expression) -> NumericKind {
+    let left_kind = datafusion_numeric_kind(left);
+    // DuckDB preserves the first argument's type, but DataFusion coerces both
+    // arguments to a common type. Mixed numeric types need an explicit cast.
+    if left_kind == datafusion_numeric_kind(right) || matches!(right, Expression::Null(_)) {
+        left_kind
+    } else {
+        NumericKind::Unknown
+    }
+}
+
+fn as_double(expr: Expression) -> Expression {
+    super::operators::cast_expr(
+        expr,
+        DataType::Double {
+            precision: None,
+            scale: None,
+        },
+    )
+}
+
+fn unresolved_division(target: DialectType) -> crate::error::Error {
+    crate::error::Error::unsupported(
+        "DuckDB // with unresolved operand types; use explicit numeric casts",
+        target.to_string(),
+    )
+}
+
+fn prepare_datafusion_division(expr: Expression) -> Result<Expression> {
+    // Stop the outer traversal at each outermost IntDiv. Rewrite that complete
+    // subtree once, bottom-up, including casts, functions, CASE and subqueries.
+    // Replacement nodes are not revisited, so a generated Div cannot be
+    // mistaken for a source `/`, even across nested integer divisions.
+    crate::traversal::transform_with_dispatch(
+        expr,
+        &Ok,
+        &|expr| !matches!(expr, Expression::IntDiv(_)),
+        &|expr, _| {
+            crate::traversal::transform_all(expr, &|mut expr| {
+                match &mut expr {
+                    Expression::Div(b) => {
+                        // Integer, decimal and unresolved source operands need
+                        // floating arithmetic. Preserve an existing FLOAT operand
+                        // rather than widening DuckDB's FLOAT/FLOAT division.
+                        if datafusion_numeric_kind(&b.left) != NumericKind::Float
+                            && datafusion_numeric_kind(&b.right) != NumericKind::Float
+                        {
+                            b.left =
+                                as_double(std::mem::replace(&mut b.left, Expression::number(0)));
+                        }
+                    }
+                    Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c)
+                        if super::scalar::data_type_numeric_kind(&c.to) == NumericKind::Integer
+                            && matches!(
+                                datafusion_numeric_kind(&c.this),
+                                NumericKind::Float | NumericKind::Decimal
+                            ) =>
+                    {
+                        // DuckDB rounds numeric casts to integers; DataFusion
+                        // truncates. This also matters after a nested source `/`.
+                        c.this = Expression::Round(Box::new(RoundFunc {
+                            this: std::mem::replace(&mut c.this, Expression::number(0)),
+                            decimals: Some(Expression::number(0)),
+                        }));
+                    }
+                    Expression::IntDiv(_) => {
+                        let Expression::IntDiv(mut division) = expr else {
+                            unreachable!()
+                        };
+                        let kind = combine(
+                            datafusion_numeric_kind(&division.this),
+                            datafusion_numeric_kind(&division.expression),
+                        );
+                        if kind == NumericKind::Unknown {
+                            return Err(unresolved_division(DialectType::DataFusion));
+                        }
+                        if kind == NumericKind::Decimal {
+                            division.this = as_double(division.this);
+                        }
+                        return Ok(Expression::Div(Box::new(BinaryOp::new(
+                            division.this,
+                            Expression::Function(Box::new(Function::new(
+                                "NULLIF".to_string(),
+                                vec![division.expression, Expression::number(0)],
+                            ))),
+                        ))));
+                    }
+                    _ => {}
+                }
+                Ok(expr)
+            })
+        },
+    )
+}
+
+pub(in crate::dialects) fn prepare_integer_division(
+    expr: Expression,
+    source: DialectType,
+    target: DialectType,
+) -> Result<Expression> {
+    if source != DialectType::DuckDB || target == DialectType::DuckDB {
+        return Ok(expr);
+    }
+
+    if target == DialectType::DataFusion {
+        return prepare_datafusion_division(expr);
+    }
+
+    // Visit every physical child, including typed function arguments and both
+    // operands of nested IntDiv nodes, before lowering the enclosing operator.
+    crate::traversal::transform_all(expr, &|expr| {
+        let Expression::IntDiv(mut division) = expr else {
+            return Ok(expr);
+        };
+        let left_kind = numeric_kind(&division.this);
+        let right_kind = numeric_kind(&division.expression);
+        let kind = combine(left_kind, right_kind);
+
+        if kind == NumericKind::Unknown {
+            return Err(unresolved_division(target));
+        }
+
+        // NULLIF evaluates the divisor once and preserves NULL on zero for
+        // literals, casts, computed expressions, and values only known at runtime.
+        division.expression = Expression::Function(Box::new(Function::new(
+            "NULLIF".to_string(),
+            vec![division.expression, Expression::number(0)],
+        )));
+
+        if kind != NumericKind::Integer {
+            // DuckDB decimal division produces DOUBLE, whereas some targets
+            // keep decimal arithmetic (and SQLite may treat DECIMAL as INTEGER).
+            // An explicitly floating operand already establishes float division.
+            if kind == NumericKind::Decimal {
+                division.this = super::operators::cast_expr(
+                    division.this,
+                    DataType::Double {
+                        precision: None,
+                        scale: None,
+                    },
+                );
+            }
+            return Ok(Expression::Div(Box::new(BinaryOp::new(
+                division.this,
+                division.expression,
+            ))));
+        }
+
+        // Only use IntDiv where generation has a native or exact lowering.
+        // A generic DIV(...) call is invalid in several other targets.
+        if !matches!(
+            target,
+            DialectType::PostgreSQL
+                | DialectType::BigQuery
+                | DialectType::ClickHouse
+                | DialectType::SQLite
+                | DialectType::Vertica
+                | DialectType::Hive
+                | DialectType::Spark
+                | DialectType::Databricks
+        ) {
+            return Err(crate::error::Error::unsupported(
+                "DuckDB integer // conversion",
+                target.to_string(),
+            ));
+        }
+        Ok(Expression::IntDiv(division))
+    })
+}

{polyglot_sql-0.13.2 → polyglot_sql-0.13.4}/crates/polyglot-sql/src/dialects/normalization/scalar.rs

@@ -15738,7 +15738,8 @@ pub(super) fn normalize_bigquery_function(
                 | DialectType::Athena
                 | DialectType::Snowflake
                 | DialectType::TSQL
-                | DialectType::Fabric => {
+                | DialectType::Fabric
+                | DialectType::DataFusion => {
                     let x = args.remove(0);
                     let y = args.remove(0);
                     // Wrap complex expressions in parens to preserve precedence

{polyglot_sql-0.13.2 → polyglot_sql-0.13.4}/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.2 → polyglot_sql-0.13.4}/crates/polyglot-sql/src/expressions.rs

@@ -8505,6 +8505,11 @@ pub enum TableConstraint {
     PrimaryKey {
         name: Option<Identifier>,
         columns: Vec<Identifier>,
+        /// Structured quoted, prefixed or ordered keys. When present these are
+        /// authoritative for rendering; `columns` retains the column names.
+        /// Older ASTs can encode prefix/order syntax directly in `columns`.
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        key_parts: Vec<IndexKeyPart>,
         /// Databricks primary-key columns marked with the TIMESERIES attribute.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         timeseries_columns: Vec<Identifier>,
@@ -8520,6 +8525,9 @@ pub enum TableConstraint {
     Unique {
         name: Option<Identifier>,
         columns: Vec<Identifier>,
+        /// Structured quoted, prefixed or ordered keys, as for `PrimaryKey`.
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        key_parts: Vec<IndexKeyPart>,
         /// Whether columns are parenthesized (false for UNIQUE idx_name without parens)
         #[serde(default)]
         columns_parenthesized: bool,
@@ -11676,6 +11684,9 @@ pub struct Lateral {
     /// Column aliases for the lateral expression (e.g., LATERAL func() AS alias(col1, col2))
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub column_aliases: Vec<String>,
+    /// Quoting of each column alias, parallel to `column_aliases`.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub column_aliases_quoted: Vec<bool>,
 }
 
 /// TableFromRows