polyglot-sql 0.9.1__tar.gz → 0.9.2__tar.gz

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/Cargo.lock

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

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/Cargo.toml

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

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/PKG-INFO

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

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

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/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.9.1", default-features = false }
+polyglot-sql = { version = "0.9.2", default-features = false }
 ```
 
 ```toml

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/ast_transforms.rs

@@ -897,4 +897,25 @@ mod tests {
 
         assert_eq!(aggregate_types, vec!["count_if", "median", "first"]);
     }
+
+    #[test]
+    fn test_get_duckdb_null_preserving_arg_extrema() {
+        let expr = crate::parse_one(
+            "SELECT ARG_MAX_NULL(label, score), ARG_MIN_NULL(label, score) FROM source_table",
+            crate::dialects::DialectType::DuckDB,
+        )
+        .unwrap();
+        let aggregates = get_aggregate_functions(&expr);
+
+        assert_eq!(aggregates.len(), 2);
+        for (aggregate, expected_name) in
+            aggregates.into_iter().zip(["ARG_MAX_NULL", "ARG_MIN_NULL"])
+        {
+            let Expression::AggregateFunction(function) = aggregate else {
+                panic!("expected a generic aggregate node, got {aggregate:?}");
+            };
+            assert_eq!(function.name, expected_name);
+            assert_eq!(function.args.len(), 2);
+        }
+    }
 }

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/builder/mod.rs

@@ -186,6 +186,7 @@ pub fn col(name: &str) -> Expr {
             expr = Expression::Dot(Box::new(DotAccess {
                 this: expr,
                 field: builder_identifier(field),
+                inferred_type: None,
             }));
         }
 
@@ -2783,6 +2784,27 @@ mod tests {
         assert_eq!(sql, "SELECT price * quantity AS total FROM items");
     }
 
+    #[test]
+    fn test_nested_operator_grouping() {
+        assert_eq!(
+            or(col("a").eq(lit(1)), col("b").eq(lit(2)))
+                .and(col("c").eq(lit(3)))
+                .to_sql(),
+            "(a = 1 OR b = 2) AND c = 3"
+        );
+        assert_eq!(
+            col("a")
+                .eq(lit(1))
+                .and(or(col("b").eq(lit(2)), col("c").eq(lit(3))))
+                .to_sql(),
+            "a = 1 AND (b = 2 OR c = 3)"
+        );
+        assert_eq!(col("a").add(col("b")).mul(col("c")).to_sql(), "(a + b) * c");
+        assert_eq!(col("a").mul(col("b").add(col("c"))).to_sql(), "a * (b + c)");
+        assert_eq!(col("a").sub(col("b").sub(col("c"))).to_sql(), "a - (b - c)");
+        assert_eq!(col("a").div(col("b").div(col("c"))).to_sql(), "a / (b / c)");
+    }
+
     #[test]
     fn test_cast() {
         let sql = select([col("id").cast("VARCHAR")]).from("users").to_sql();

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -6120,14 +6120,12 @@ impl DuckDBDialect {
                     trailing_comments: Vec::new(),
                     inferred_type: None,
                 }));
-                let two_pi_u2 = Expression::Mul(Box::new(BinaryOp {
-                    left: two_pi,
-                    right: u2,
-                    left_comments: Vec::new(),
-                    operator_comments: Vec::new(),
-                    trailing_comments: Vec::new(),
-                    inferred_type: None,
-                }));
+                let two_pi_u2 = if let Expression::Div(div) = u2 {
+                    let numerator = Expression::Mul(Box::new(BinaryOp::new(two_pi, div.left)));
+                    Expression::Div(Box::new(BinaryOp::new(numerator, div.right)))
+                } else {
+                    Expression::Mul(Box::new(BinaryOp::new(two_pi, u2)))
+                };
                 let cos_part = Expression::Function(Box::new(Function::new(
                     "COS".to_string(),
                     vec![two_pi_u2],
@@ -6328,6 +6326,7 @@ impl DuckDBDialect {
                 let x_value = Expression::Dot(Box::new(crate::expressions::DotAccess {
                     this: x_ref,
                     field: Identifier::new("value"),
+                    inferred_type: None,
                 }));
                 let x_value_is_null = Expression::IsNull(Box::new(crate::expressions::IsNull {
                     this: x_value,
@@ -7212,6 +7211,24 @@ impl DuckDBDialect {
     ) -> Result<Expression> {
         let name_upper = f.name.to_uppercase();
         match name_upper.as_str() {
+            // Keep the established canonical transpilation for a plain DuckDB
+            // LIST aggregate now that the parser represents it as an aggregate
+            // node. Modifier-bearing LIST calls retain their aggregate shape so
+            // DISTINCT, ORDER BY, FILTER, and LIMIT are not discarded.
+            "LIST"
+                if f.args.len() == 1
+                    && !f.distinct
+                    && f.filter.is_none()
+                    && f.order_by.is_empty()
+                    && f.limit.is_none()
+                    && f.ignore_nulls.is_none() =>
+            {
+                Ok(Expression::Function(Box::new(Function::new(
+                    "ARRAY_AGG".to_string(),
+                    f.args,
+                ))))
+            }
+
             // GROUP_CONCAT -> LISTAGG
             "GROUP_CONCAT" if !f.args.is_empty() => Ok(Expression::Function(Box::new(
                 Function::new("LISTAGG".to_string(), f.args),

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/normalization/aggregates.rs

@@ -32,6 +32,7 @@ pub(super) enum Action {
     CollectListToArrayAgg,
     CollectSetConvert,
     PercentileConvert,
+    DuckDBQuantileConvert,
     CorrIsnanWrap,
     FirstToAnyValue,
     PercentileContConvert,
@@ -191,10 +192,16 @@ pub(super) fn rewrite(
                         } else {
                             "ARG_MIN_NULL"
                         };
-                        Ok(Expression::Function(Box::new(Function::new(
-                            func_name.to_string(),
-                            vec![agg.this, *having_expr],
-                        ))))
+                        Ok(Expression::AggregateFunction(Box::new(AggregateFunction {
+                            name: func_name.to_string(),
+                            args: vec![agg.this, *having_expr],
+                            distinct: agg.distinct,
+                            filter: agg.filter,
+                            order_by: agg.order_by,
+                            limit: agg.limit,
+                            ignore_nulls: agg.ignore_nulls,
+                            inferred_type: agg.inferred_type,
+                        })))
                     } else {
                         Ok(Expression::AnyValue(agg))
                     }
@@ -247,11 +254,10 @@ pub(super) fn rewrite(
                             expressions: quantiles,
                         }));
 
-                        // Preserve DISTINCT modifier
-                        let mut new_func =
-                            Function::new("APPROX_QUANTILE".to_string(), vec![x_expr, array_expr]);
-                        new_func.distinct = agg.distinct;
-                        Ok(Expression::Function(Box::new(new_func)))
+                        let mut new_agg = *agg;
+                        new_agg.name = "APPROX_QUANTILE".to_string();
+                        new_agg.args = vec![x_expr, array_expr];
+                        Ok(Expression::AggregateFunction(Box::new(new_agg)))
                     } else {
                         Ok(Expression::AggregateFunction(agg))
                     }
@@ -1146,6 +1152,80 @@ pub(super) fn rewrite(
                 }
             }
 
+            Action::DuckDBQuantileConvert => {
+                let mut aggregate = if let Expression::AggregateFunction(aggregate) = e {
+                    *aggregate
+                } else {
+                    unreachable!("action only triggered for AggregateFunction expressions")
+                };
+                let name = aggregate.name.to_ascii_uppercase();
+
+                match name.as_str() {
+                    "QUANTILE" => {
+                        aggregate.name = match target {
+                            DialectType::Spark | DialectType::Databricks | DialectType::Hive => {
+                                "PERCENTILE"
+                            }
+                            DialectType::Presto | DialectType::Trino => "APPROX_PERCENTILE",
+                            DialectType::BigQuery => "PERCENTILE_CONT",
+                            _ => "QUANTILE",
+                        }
+                        .to_string();
+                        Ok(Expression::AggregateFunction(Box::new(aggregate)))
+                    }
+                    "APPROX_QUANTILE" => {
+                        if matches!(target, DialectType::Snowflake) {
+                            aggregate.name = "APPROX_PERCENTILE".to_string();
+                        }
+                        Ok(Expression::AggregateFunction(Box::new(aggregate)))
+                    }
+                    "QUANTILE_CONT" | "QUANTILE_DISC"
+                        if aggregate.args.len() == 2
+                            && matches!(
+                                target,
+                                DialectType::PostgreSQL
+                                    | DialectType::Redshift
+                                    | DialectType::Snowflake
+                            ) =>
+                    {
+                        // DISTINCT, an inner ORDER BY, LIMIT, and explicit null
+                        // handling cannot be represented by these targets' ordered-set
+                        // aggregate syntax. Keep the original aggregate intact rather
+                        // than silently dropping any of those modifiers.
+                        if aggregate.distinct
+                            || !aggregate.order_by.is_empty()
+                            || aggregate.limit.is_some()
+                            || aggregate.ignore_nulls.is_some()
+                        {
+                            return Ok(Expression::AggregateFunction(Box::new(aggregate)));
+                        }
+
+                        let mut args = aggregate.args;
+                        let column = args.remove(0);
+                        let percentile = args.remove(0);
+                        let percentile = PercentileFunc {
+                            this: column.clone(),
+                            percentile,
+                            order_by: Some(vec![Ordered {
+                                this: column,
+                                desc: false,
+                                nulls_first: None,
+                                explicit_asc: false,
+                                with_fill: None,
+                            }]),
+                            filter: aggregate.filter,
+                        };
+
+                        if name == "QUANTILE_CONT" {
+                            Ok(Expression::PercentileCont(Box::new(percentile)))
+                        } else {
+                            Ok(Expression::PercentileDisc(Box::new(percentile)))
+                        }
+                    }
+                    _ => Ok(Expression::AggregateFunction(Box::new(aggregate))),
+                }
+            }
+
             Action::CorrIsnanWrap => {
                 // CORR(a, b) -> CASE WHEN ISNAN(CORR(a, b)) THEN NULL ELSE CORR(a, b) END
                 // The CORR expression could be AggregateFunction, WindowFunction, or Filter-wrapped

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -2294,6 +2294,11 @@ pub(super) fn normalize(
                         {
                             Action::Aggregates(aggregates::Action::BigQueryPercentileContToDuckDB)
                         }
+                        "QUANTILE" | "QUANTILE_CONT" | "QUANTILE_DISC" | "APPROX_QUANTILE"
+                            if matches!(source, DialectType::DuckDB) =>
+                        {
+                            Action::Aggregates(aggregates::Action::DuckDBQuantileConvert)
+                        }
                         _ => Action::None,
                     }
                 }

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/normalization/operators.rs

@@ -1418,26 +1418,23 @@ pub(super) fn rewrite(
                         ],
                     )));
 
-                    // Position offset: pos - 1 when pos > 1, else 0
-                    let pos_offset: Expression = if !is_pos_1 {
+                    // ELSE base: 1 + split_sum + extract_sum
+                    let else_base = Expression::Add(Box::new(BinaryOp::new(
+                        Expression::Add(Box::new(BinaryOp::new(Expression::number(1), split_sum))),
+                        extract_sum,
+                    )));
+
+                    // Append the position offset as a left-associated `+ pos - 1` chain.
+                    let else_expr = if !is_pos_1 {
                         let pos = position.clone().unwrap_or(Expression::number(1));
-                        Expression::Sub(Box::new(BinaryOp::new(pos, Expression::number(1))))
+                        Expression::Sub(Box::new(BinaryOp::new(
+                            Expression::Add(Box::new(BinaryOp::new(else_base, pos))),
+                            Expression::number(1),
+                        )))
                     } else {
-                        Expression::number(0)
+                        Expression::Add(Box::new(BinaryOp::new(else_base, Expression::number(0))))
                     };
 
-                    // ELSE: 1 + split_sum + extract_sum + pos_offset
-                    let else_expr = Expression::Add(Box::new(BinaryOp::new(
-                        Expression::Add(Box::new(BinaryOp::new(
-                            Expression::Add(Box::new(BinaryOp::new(
-                                Expression::number(1),
-                                split_sum,
-                            ))),
-                            extract_sum,
-                        ))),
-                        pos_offset,
-                    )));
-
                     Ok(Expression::Case(Box::new(Case {
                         operand: None,
                         whens: vec![

{polyglot_sql-0.9.1 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/expressions.rs

@@ -1318,6 +1318,7 @@ impl Expression {
             }
 
             Expression::Column(c) => c.inferred_type.as_ref(),
+            Expression::Dot(dot) => dot.inferred_type.as_ref(),
             Expression::Function(f) => f.inferred_type.as_ref(),
             Expression::AggregateFunction(f) => f.inferred_type.as_ref(),
             Expression::WindowFunction(f) => f.inferred_type.as_ref(),
@@ -1546,6 +1547,7 @@ impl Expression {
             }
 
             Expression::Column(c) => c.inferred_type = Some(dt),
+            Expression::Dot(dot) => dot.inferred_type = Some(dt),
             Expression::Function(f) => f.inferred_type = Some(dt),
             Expression::AggregateFunction(f) => f.inferred_type = Some(dt),
             Expression::WindowFunction(f) => f.inferred_type = Some(dt),
@@ -7438,6 +7440,8 @@ pub struct Subscript {
 pub struct DotAccess {
     pub this: Expression,
     pub field: Identifier,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub inferred_type: Option<DataType>,
 }
 
 /// Method call (expr.method(args))
@@ -15342,6 +15346,21 @@ mod tests {
         // Run with: cargo test -p polyglot-sql --features bindings export_typescript_types
         Expression::export_all(&ts_rs::Config::default())
             .expect("Failed to export Expression types");
+
+        let mut variant_names = String::from(
+            "// This file was generated from the Rust Expression enum. Do not edit it manually.\n\n",
+        );
+        variant_names.push_str("export const EXPRESSION_VARIANT_NAMES = [\n");
+        for name in Expression::SERIALIZED_VARIANT_NAMES {
+            use std::fmt::Write;
+            writeln!(variant_names, "  {name:?},").expect("writing to a String cannot fail");
+        }
+        variant_names.push_str("] as const;\n");
+
+        let output_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("bindings/ExpressionVariantNames.ts");
+        std::fs::write(output_path, variant_names)
+            .expect("Failed to export serialized Expression variant names");
     }
 
     #[test]