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

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

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

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

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

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

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

{polyglot_sql-0.9.0 → polyglot_sql-0.9.1}/crates/polyglot-sql/Cargo.toml

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

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

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

@@ -11,7 +11,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::builder::engine;
 use crate::expressions::*;
-use crate::traversal::ExpressionWalk;
+use crate::traversal::{is_aggregate, ExpressionWalk};
 
 /// Apply a bottom-up transformation to every node in the tree.
 /// Wraps `crate::traversal::transform` with a simpler signature for this module.
@@ -336,6 +336,26 @@ pub fn get_output_column_names(expr: &Expression) -> Vec<String> {
     output_column_names_from_query(expr)
 }
 
+/// Collect projected output column names using dialect-specific set-operation
+/// alignment rules.
+///
+/// This differs from [`get_output_column_names`] only for name-aligned set
+/// operations. When an output shape is not statically knowable (for example an
+/// unresolved wildcard), it preserves the existing leftmost-branch behavior.
+pub fn get_output_column_names_for_dialect(
+    expr: &Expression,
+    dialect: Option<crate::dialects::DialectType>,
+) -> Vec<String> {
+    crate::set_operation::query_output_identifiers(expr, dialect)
+        .map(|identifiers| {
+            identifiers
+                .into_iter()
+                .map(|identifier| identifier.name)
+                .collect()
+        })
+        .unwrap_or_else(|_| output_column_names_from_query(expr))
+}
+
 fn output_column_names_from_query(expr: &Expression) -> Vec<String> {
     match expr {
         Expression::Select(select) => select_output_column_names(select),
@@ -540,22 +560,7 @@ pub fn get_subqueries(expr: &Expression) -> Vec<&Expression> {
 /// Includes typed aggregates (`Count`, `Sum`, `Avg`, `Min`, `Max`, etc.)
 /// and generic `AggregateFunction` nodes.
 pub fn get_aggregate_functions(expr: &Expression) -> Vec<&Expression> {
-    expr.find_all(|e| {
-        matches!(
-            e,
-            Expression::AggregateFunction(_)
-                | Expression::Count(_)
-                | Expression::Sum(_)
-                | Expression::Avg(_)
-                | Expression::Min(_)
-                | Expression::Max(_)
-                | Expression::ApproxDistinct(_)
-                | Expression::ArrayAgg(_)
-                | Expression::GroupConcat(_)
-                | Expression::StringAgg(_)
-                | Expression::ListAgg(_)
-        )
-    })
+    expr.find_all(is_aggregate)
 }
 
 /// Collect all window function nodes in the expression tree.
@@ -695,6 +700,37 @@ mod tests {
         assert_eq!(names, vec!["c1".to_string(), "c2".to_string()]);
     }
 
+    #[test]
+    fn test_get_output_column_names_uses_dialect_by_name_layout() {
+        for dialect in [
+            crate::dialects::DialectType::DuckDB,
+            crate::dialects::DialectType::Snowflake,
+        ] {
+            let expr = crate::parse_one(
+                "SELECT 1 AS left_value UNION ALL BY NAME SELECT 2 AS right_value",
+                dialect,
+            )
+            .expect("parse");
+            assert_eq!(
+                get_output_column_names_for_dialect(&expr, Some(dialect)),
+                vec!["left_value", "right_value"]
+            );
+        }
+
+        let expr = crate::parse_one(
+            "SELECT 1 AS a, 2 AS b UNION ALL BY NAME SELECT 3 AS b, 4 AS a",
+            crate::dialects::DialectType::BigQuery,
+        )
+        .expect("parse");
+        assert_eq!(
+            get_output_column_names_for_dialect(
+                &expr,
+                Some(crate::dialects::DialectType::BigQuery),
+            ),
+            vec!["a", "b"]
+        );
+    }
+
     #[test]
     fn test_get_column_names_union_still_returns_all_references() {
         let expr =
@@ -851,12 +887,14 @@ mod tests {
 
     #[test]
     fn test_get_aggregate_functions() {
-        let expr = parse_one("SELECT COUNT(*), SUM(x) FROM t");
+        let expr = crate::parse_one(
+            "SELECT COUNT_IF(numeric_value > 0), MEDIAN(numeric_value), FIRST(numeric_value) FROM source_table",
+            crate::dialects::DialectType::DuckDB,
+        )
+        .unwrap();
         let aggs = get_aggregate_functions(&expr);
-        assert!(
-            aggs.len() >= 2,
-            "Expected at least 2 aggregates, got {}",
-            aggs.len()
-        );
+        let aggregate_types: Vec<_> = aggs.iter().map(|agg| agg.variant_name()).collect();
+
+        assert_eq!(aggregate_types, vec!["count_if", "median", "first"]);
     }
 }

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

@@ -188,7 +188,7 @@ use crate::parser::Parser;
 use crate::tokens::TokenType;
 use crate::tokens::{Token, Tokenizer, TokenizerConfig};
 #[cfg(feature = "transpile")]
-use crate::traversal::ExpressionWalk;
+use crate::traversal::{is_aggregate, ExpressionWalk};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 #[cfg(feature = "transpile")]
@@ -4561,6 +4561,12 @@ impl Dialect {
                         "qualified whole-row aggregate arguments",
                     );
                 }
+                if Self::node_has_subquery_in_aggregate_argument(node) {
+                    Self::push_unsupported_diagnostic(
+                        &mut diagnostics,
+                        "aggregate arguments containing subqueries",
+                    );
+                }
             }
 
             if !Self::target_supports_distinct_on(target) && Self::node_has_distinct_on(node) {
@@ -5368,63 +5374,7 @@ impl Dialect {
     }
 
     fn node_is_aggregate_function(expr: &Expression) -> bool {
-        matches!(
-            expr,
-            Expression::AggregateFunction(_)
-                | Expression::Count(_)
-                | Expression::Sum(_)
-                | Expression::Avg(_)
-                | Expression::Min(_)
-                | Expression::Max(_)
-                | Expression::GroupConcat(_)
-                | Expression::StringAgg(_)
-                | Expression::ListAgg(_)
-                | Expression::ArrayAgg(_)
-                | Expression::CountIf(_)
-                | Expression::SumIf(_)
-                | Expression::Stddev(_)
-                | Expression::StddevPop(_)
-                | Expression::StddevSamp(_)
-                | Expression::Variance(_)
-                | Expression::VarPop(_)
-                | Expression::VarSamp(_)
-                | Expression::Median(_)
-                | Expression::Mode(_)
-                | Expression::First(_)
-                | Expression::Last(_)
-                | Expression::AnyValue(_)
-                | Expression::ApproxDistinct(_)
-                | Expression::ApproxCountDistinct(_)
-                | Expression::ApproxPercentile(_)
-                | Expression::Percentile(_)
-                | Expression::LogicalAnd(_)
-                | Expression::LogicalOr(_)
-                | Expression::Skewness(_)
-                | Expression::BitwiseCount(_)
-                | Expression::BitwiseAndAgg(_)
-                | Expression::BitwiseOrAgg(_)
-                | Expression::BitwiseXorAgg(_)
-                | Expression::ArrayConcatAgg(_)
-                | Expression::ArrayUniqueAgg(_)
-                | Expression::BoolXorAgg(_)
-                | Expression::JsonArrayAgg(_)
-                | Expression::JsonObjectAgg(_)
-                | Expression::ParameterizedAgg(_)
-                | Expression::ArgMax(_)
-                | Expression::ArgMin(_)
-                | Expression::ApproxTopK(_)
-                | Expression::ApproxTopKAccumulate(_)
-                | Expression::ApproxTopKCombine(_)
-                | Expression::ApproxTopKEstimate(_)
-                | Expression::ApproxTopSum(_)
-                | Expression::ApproxQuantiles(_)
-                | Expression::AnonymousAggFunc(_)
-                | Expression::CombinedAggFunc(_)
-                | Expression::CombinedParameterizedAgg(_)
-                | Expression::HashAgg(_)
-                | Expression::ObjectAgg(_)
-                | Expression::AIAgg(_)
-        )
+        is_aggregate(expr)
     }
 
     fn node_has_qualified_whole_row_aggregate_argument(expr: &Expression) -> bool {
@@ -5446,6 +5396,21 @@ impl Dialect {
             && expr.children().into_iter().any(contains_qualified_star)
     }
 
+    fn node_has_subquery_in_aggregate_argument(expr: &Expression) -> bool {
+        fn contains_query(expr: &Expression) -> bool {
+            matches!(
+                expr,
+                Expression::Select(_)
+                    | Expression::Subquery(_)
+                    | Expression::Union(_)
+                    | Expression::Intersect(_)
+                    | Expression::Except(_)
+            ) || expr.children().into_iter().any(contains_query)
+        }
+
+        Self::node_is_aggregate_function(expr) && expr.children().into_iter().any(contains_query)
+    }
+
     fn tsql_apply_has_invalid_outer_aggregate(expr: &Expression) -> bool {
         // SQL Server error 8124: if an aggregate expression contains an outer
         // reference, that reference must be the only column used by the expression.

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

@@ -3791,7 +3791,7 @@ impl Default for Select {
 ///
 /// When `all` is true, duplicate rows are preserved (UNION ALL).
 /// ORDER BY, LIMIT, and OFFSET can be applied to the combined result.
-/// Supports DuckDB's BY NAME modifier and BigQuery's CORRESPONDING modifier.
+/// Supports DuckDB/Snowflake BY NAME and BigQuery BY NAME/CORRESPONDING modifiers.
 #[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]
 pub struct Union {
@@ -3821,7 +3821,7 @@ pub struct Union {
     /// CLUSTER BY clause (Hive/Spark)
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub cluster_by: Option<ClusterBy>,
-    /// DuckDB BY NAME modifier
+    /// DuckDB, Snowflake, and BigQuery BY NAME modifier
     #[serde(default)]
     pub by_name: bool,
     /// BigQuery: Set operation side (LEFT, RIGHT, FULL)
@@ -3890,7 +3890,7 @@ pub struct Intersect {
     /// CLUSTER BY clause (Hive/Spark)
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub cluster_by: Option<ClusterBy>,
-    /// DuckDB BY NAME modifier
+    /// DuckDB, Snowflake, and BigQuery BY NAME modifier
     #[serde(default)]
     pub by_name: bool,
     /// BigQuery: Set operation side (LEFT, RIGHT, FULL)
@@ -3957,7 +3957,7 @@ pub struct Except {
     /// CLUSTER BY clause (Hive/Spark)
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub cluster_by: Option<ClusterBy>,
-    /// DuckDB BY NAME modifier
+    /// DuckDB, Snowflake, and BigQuery BY NAME modifier
     #[serde(default)]
     pub by_name: bool,
     /// BigQuery: Set operation side (LEFT, RIGHT, FULL)

{polyglot_sql-0.9.0 → polyglot_sql-0.9.1}/crates/polyglot-sql/src/generator.rs

@@ -7183,7 +7183,7 @@ impl Generator {
         }
 
         // BigQuery: CORRESPONDING/STRICT CORRESPONDING -> BY NAME, BY (cols) -> ON (cols)
-        // DuckDB: BY NAME
+        // DuckDB/Snowflake: BY NAME
         if union.corresponding || union.by_name {
             self.write_space();
             self.write_keyword("BY NAME");
@@ -7357,7 +7357,7 @@ impl Generator {
         }
 
         // BigQuery: CORRESPONDING/STRICT CORRESPONDING -> BY NAME, BY (cols) -> ON (cols)
-        // DuckDB: BY NAME
+        // DuckDB/Snowflake: BY NAME
         if intersect.corresponding || intersect.by_name {
             self.write_space();
             self.write_keyword("BY NAME");
@@ -7565,7 +7565,7 @@ impl Generator {
         }
 
         // BigQuery: CORRESPONDING/STRICT CORRESPONDING -> BY NAME, BY (cols) -> ON (cols)
-        // DuckDB: BY NAME
+        // DuckDB/Snowflake: BY NAME
         if except.corresponding || except.by_name {
             self.write_space();
             self.write_keyword("BY NAME");
@@ -37817,6 +37817,48 @@ impl Generator {
         }
     }
 
+    fn postgres_tsql_literal_string(expr: &Expression) -> Option<Cow<'_, str>> {
+        match expr {
+            Expression::Literal(literal) => match literal.as_ref() {
+                Literal::String(value) => Some(Cow::Borrowed(value)),
+                _ => None,
+            },
+            Expression::Cast(cast) | Expression::TryCast(cast) | Expression::SafeCast(cast)
+                if Self::is_string_data_type(&cast.to) =>
+            {
+                let value = Self::postgres_tsql_literal_string(&cast.this)?;
+                match &cast.to {
+                    DataType::Char { length } => Some(Self::postgres_string_cast_literal(
+                        value,
+                        length.unwrap_or(1),
+                    )),
+                    DataType::VarChar {
+                        length: Some(length),
+                        ..
+                    }
+                    | DataType::String {
+                        length: Some(length),
+                    } => Some(Self::postgres_string_cast_literal(value, *length)),
+                    DataType::TextWithLength { length } => {
+                        Some(Self::postgres_string_cast_literal(value, *length))
+                    }
+                    _ => Some(value),
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn postgres_string_cast_literal(value: Cow<'_, str>, length: u32) -> Cow<'_, str> {
+        let length = length as usize;
+        let value_length = value.chars().count();
+        if value_length > length {
+            Cow::Owned(value.chars().take(length).collect())
+        } else {
+            value
+        }
+    }
+
     fn postgres_year_is_outside_tsql_range(value: &str, format: &str) -> bool {
         fn component_is_outside(component: &str, forced_negative: bool) -> bool {
             let component = component.trim().trim_end_matches(',');
@@ -37898,13 +37940,11 @@ impl Generator {
                 if target_type == "DATE"
                     && matches!(self.config.source_dialect, Some(DialectType::PostgreSQL))
                 {
-                    if let Expression::Literal(literal) = this {
-                        if let Literal::String(value) = literal.as_ref() {
-                            if Self::postgres_year_is_outside_tsql_range(value, format) {
-                                self.unsupported(
-                                    "PostgreSQL TO_DATE literal is outside the T-SQL/Fabric DATE range 0001-01-01 through 9999-12-31",
-                                )?;
-                            }
+                    if let Some(value) = Self::postgres_tsql_literal_string(this) {
+                        if Self::postgres_year_is_outside_tsql_range(&value, format) {
+                            self.unsupported(
+                                "PostgreSQL TO_DATE literal is outside the T-SQL/Fabric DATE range 0001-01-01 through 9999-12-31",
+                            )?;
                         }
                     }
                 }

{polyglot_sql-0.9.0 → polyglot_sql-0.9.1}/crates/polyglot-sql/src/lib.rs

@@ -50,6 +50,7 @@ pub mod resolver;
 pub mod schema;
 #[cfg(feature = "semantic")]
 pub mod scope;
+mod set_operation;
 #[cfg(feature = "time")]
 pub mod time;
 pub mod tokens;
@@ -991,6 +992,18 @@ mod validation_tests {
         assert!(result.errors.iter().any(|error| error.code == "W001"));
         assert!(result.errors.iter().any(|error| error.code == "W002"));
         assert!(result.errors.iter().any(|error| error.code == "W004"));
+
+        let median_result = validate_with_options(
+            "SELECT category, MEDIAN(price) FROM products",
+            DialectType::DuckDB,
+            &options,
+        );
+
+        assert!(median_result.valid, "Warnings must not invalidate SQL");
+        assert!(median_result
+            .errors
+            .iter()
+            .any(|error| error.code == "W002"));
     }
 
     #[test]