polyglot-sql-chio 0.13.0__tar.gz → 0.13.2__tar.gz

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.13.0"
+version = "0.13.2"
 dependencies = [
  "criterion",
  "once_cell",
@@ -624,7 +624,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.13.0"
+version = "0.13.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -633,7 +633,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.13.0"
+version = "0.13.2"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -643,11 +643,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.13.0"
+version = "0.13.2"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.13.0"
+version = "0.13.2"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -658,7 +658,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.13.0"
+version = "0.13.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/Cargo.toml

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

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/PKG-INFO

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

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/Cargo.toml

@@ -101,14 +101,14 @@ function-catalog-all-dialects = [
 
 [dependencies]
 regex = { version = "1", optional = true }
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.0" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.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.13.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

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

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/builder/mod.rs

@@ -416,6 +416,7 @@ pub fn condition(sql: &str) -> Expr {
 /// Create a `COUNT(expr)` expression.
 pub fn count(expr: Expr) -> Expr {
     Expr(Expression::Count(Box::new(CountFunc {
+        span: None,
         this: Some(expr.0),
         star: false,
         distinct: false,
@@ -429,6 +430,7 @@ pub fn count(expr: Expr) -> Expr {
 /// Create a `COUNT(*)` expression.
 pub fn count_star() -> Expr {
     Expr(Expression::Count(Box::new(CountFunc {
+        span: None,
         this: None,
         star: true,
         distinct: false,
@@ -442,6 +444,7 @@ pub fn count_star() -> Expr {
 /// Create a `COUNT(DISTINCT expr)` expression.
 pub fn count_distinct(expr: Expr) -> Expr {
     Expr(Expression::Count(Box::new(CountFunc {
+        span: None,
         this: Some(expr.0),
         star: false,
         distinct: true,

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/dialects/mod.rs

@@ -3065,7 +3065,9 @@ impl Dialect {
     pub fn generate_pretty(&self, expr: &Expression) -> Result<String> {
         let mut config = self.get_config_for_expr(expr);
         config.pretty = true;
-        let mut generator = Generator::with_config(config).with_preserved_null_ordering();
+        let mut generator = Generator::with_config(config)
+            .with_preserved_null_ordering()
+            .with_preserved_variant_paths();
         generator.generate(expr)
     }
 

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/dialects/normalization/aggregates.rs

@@ -866,6 +866,7 @@ pub(super) fn rewrite(
                             inferred_type: None,
                         }));
                         Ok(Expression::Count(Box::new(crate::expressions::CountFunc {
+                            span: None,
                             this: Some(case_expr),
                             star: false,
                             distinct: true,

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/expressions.rs

@@ -6745,9 +6745,13 @@ pub struct AggFunc {
 }
 
 /// COUNT function with optional star
-#[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]
 pub struct CountFunc {
+    /// Source range of the call; metadata, not expression identity.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[ast(skip)]
+    pub span: Option<Span>,
     pub this: Option<Expression>,
     pub star: bool,
     pub distinct: bool,
@@ -6764,6 +6768,18 @@ pub struct CountFunc {
     pub inferred_type: Option<DataType>,
 }
 
+impl PartialEq for CountFunc {
+    fn eq(&self, other: &Self) -> bool {
+        self.this == other.this
+            && self.star == other.star
+            && self.distinct == other.distinct
+            && self.filter == other.filter
+            && self.ignore_nulls == other.ignore_nulls
+            && self.original_name == other.original_name
+            && self.inferred_type == other.inferred_type
+    }
+}
+
 /// GROUP_CONCAT function (MySQL style)
 #[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/generator.rs

@@ -46,6 +46,7 @@ use serde::{Deserialize, Serialize};
 pub struct Generator {
     /// Formatting preserves the parsed null-ordering clauses instead of normalizing them.
     preserve_null_ordering: bool,
+    preserve_variant_paths: bool,
     config: Arc<GeneratorConfig>,
     output: String,
     unsupported_messages: Vec<String>,
@@ -2201,6 +2202,7 @@ impl Generator {
     pub(crate) fn with_arc_config(config: Arc<GeneratorConfig>) -> Self {
         Self {
             preserve_null_ordering: false,
+            preserve_variant_paths: false,
             config,
             output: String::new(),
             unsupported_messages: Vec::new(),
@@ -2217,9 +2219,15 @@ impl Generator {
         self
     }
 
+    pub(crate) fn with_preserved_variant_paths(mut self) -> Self {
+        self.preserve_variant_paths = true;
+        self
+    }
+
     fn child_generator(&self) -> Self {
         let mut generator = Self::with_arc_config(self.config.clone());
         generator.preserve_null_ordering = self.preserve_null_ordering;
+        generator.preserve_variant_paths = self.preserve_variant_paths;
         generator
     }
 
@@ -27993,6 +28001,7 @@ impl Generator {
         };
         let mut gen = Generator::with_config(config);
         gen.preserve_null_ordering = self.preserve_null_ordering;
+        gen.preserve_variant_paths = self.preserve_variant_paths;
         gen.generate_expression(expr)?;
         Ok(gen.output)
     }
@@ -33291,12 +33300,23 @@ impl Generator {
         // Otherwise output JSON_EXTRACT(this, expression)
         if e.variant_extract.is_some() {
             use crate::dialects::DialectType;
-            if matches!(self.config.dialect, Some(DialectType::Databricks)) {
+            if matches!(self.config.dialect, Some(DialectType::Databricks))
+                || (self.preserve_variant_paths
+                    && self.config.dialect == Some(DialectType::Snowflake))
+            {
                 // Databricks: output col:path syntax (e.g., c1:price, c1:price.foo, c1:price.bar[1])
                 // Keys that are not safe identifiers (contain hyphens, spaces, etc.) must use
                 // bracket notation: c:["x-y"] instead of c:x-y
                 self.generate_expression(&e.this)?;
-                self.write(":");
+                self.write(
+                    if self.preserve_variant_paths
+                        && matches!(e.this.as_ref(), Expression::Subscript(_))
+                    {
+                        "."
+                    } else {
+                        ":"
+                    },
+                );
                 match e.expression.as_ref() {
                     Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
                         let Literal::String(s) = lit.as_ref() else {

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/optimizer/annotate_types.rs

@@ -403,6 +403,33 @@ impl<'a> TypeAnnotator<'a> {
 
     /// Annotate types for an expression tree
     pub fn annotate(&mut self, expr: &Expression) -> Option<DataType> {
+        if self._dialect == Some(DialectType::Snowflake) {
+            match expr {
+                Expression::CurrentTimestamp(_) | Expression::CurrentTimestampLTZ(_) => {
+                    return Some(DataType::Custom {
+                        name: "TIMESTAMPLTZ".into(),
+                    });
+                }
+                Expression::TimestampTzFromParts(_) => {
+                    return Some(DataType::Timestamp {
+                        precision: None,
+                        timezone: true,
+                    })
+                }
+                Expression::TimestampFromParts(_) | Expression::ToTimestamp(_) => {
+                    return Some(DataType::Timestamp {
+                        precision: None,
+                        timezone: false,
+                    })
+                }
+                _ => {}
+            }
+        }
+        if self._dialect == Some(DialectType::Snowflake)
+            && matches!(expr, Expression::ParseJson(_) | Expression::ParseJSON(_))
+        {
+            return Some(DataType::Json);
+        }
         match expr {
             // Literals
             Expression::Literal(lit) => Self::annotate_literal(lit),
@@ -1421,6 +1448,56 @@ impl<'a> TypeAnnotator<'a> {
         }
         let func_name = func.name.to_uppercase();
 
+        if self._dialect == Some(DialectType::Snowflake) && !func.quoted {
+            match func_name.as_str() {
+                "CURRENT_TIMESTAMP" | "GETDATE" | "LOCALTIMESTAMP" | "SYSTIMESTAMP" => {
+                    return Some(DataType::Custom {
+                        name: "TIMESTAMPLTZ".into(),
+                    })
+                }
+                "PARSE_JSON" | "TRY_PARSE_JSON" | "TO_VARIANT" => return Some(DataType::Json),
+                "ARRAY_CONSTRUCT" | "ARRAY_CONSTRUCT_COMPACT" => {
+                    return Some(DataType::Array {
+                        element_type: Box::new(DataType::Json),
+                        dimension: None,
+                    })
+                }
+                "TO_TIMESTAMP"
+                | "TO_TIMESTAMP_NTZ"
+                | "TO_TIMESTAMP_LTZ"
+                | "TO_TIMESTAMP_TZ"
+                | "TRY_TO_TIMESTAMP"
+                | "TRY_TO_TIMESTAMP_NTZ"
+                | "TRY_TO_TIMESTAMP_LTZ"
+                | "TRY_TO_TIMESTAMP_TZ"
+                | "TIMESTAMP_FROM_PARTS"
+                | "TIMESTAMP_NTZ_FROM_PARTS"
+                | "TIMESTAMP_LTZ_FROM_PARTS"
+                | "TIMESTAMP_TZ_FROM_PARTS" => {
+                    if func_name.contains("_NTZ") || func_name.contains("_LTZ") {
+                        return Some(DataType::Custom {
+                            name: if func_name.contains("_LTZ") {
+                                "TIMESTAMPLTZ"
+                            } else {
+                                "TIMESTAMPNTZ"
+                            }
+                            .to_string(),
+                        });
+                    }
+                    return Some(DataType::Timestamp {
+                        precision: None,
+                        timezone: func_name.contains("_TZ"),
+                    });
+                }
+                "DATE_FROM_PARTS" | "DATEFROMPARTS" | "TO_DATE" | "TRY_TO_DATE" => {
+                    return Some(DataType::Date)
+                }
+                "DAYOFWEEKISO" | "WEEKISO" | "WEEKOFYEAR" | "YEAROFWEEK" | "YEAROFWEEKISO"
+                | "DAYOFYEAR" => return Some(DataType::BigInt { length: None }),
+                _ => {}
+            }
+        }
+
         if self._dialect == Some(DialectType::PostgreSQL) && !func.quoted {
             match func_name.as_str() {
                 "SUM" => return func.args.first().and_then(|arg| self.annotate_sum(arg)),
@@ -1512,7 +1589,11 @@ impl<'a> TypeAnnotator<'a> {
                     };
                 }
                 self.used_unknown_function_fallback = true;
-                func.args.first().and_then(|arg| self.annotate(arg))
+                if self._dialect == Some(DialectType::Snowflake) {
+                    Some(DataType::Unknown)
+                } else {
+                    func.args.first().and_then(|arg| self.annotate(arg))
+                }
             }
         }
     }
@@ -2672,6 +2753,16 @@ fn annotate_scoped_expression_with_outer(
     parent: Option<&dyn Schema>,
     dialect: Option<DialectType>,
     outer: Option<&dyn Schema>,
+) -> OutputColumns {
+    annotate_scoped_outputs(expression, parent, dialect, outer, true)
+}
+
+fn annotate_scoped_outputs(
+    expression: &mut Expression,
+    parent: Option<&dyn Schema>,
+    dialect: Option<DialectType>,
+    outer: Option<&dyn Schema>,
+    resolve_outputs: bool,
 ) -> OutputColumns {
     match expression {
         Expression::Select(select) => annotate_select(select, parent, dialect, outer),
@@ -2692,33 +2783,35 @@ fn annotate_scoped_expression_with_outer(
         Expression::Union(union) => {
             let mut schema = ScopedSchema::new(parent, dialect);
             annotate_with(&mut union.with, &mut schema, dialect, outer);
-            annotate_scoped_expression_with_outer(&mut union.left, Some(&schema), dialect, outer);
-            annotate_scoped_expression_with_outer(&mut union.right, Some(&schema), dialect, outer);
-            super::set_operation_types::query_columns(expression, dialect)
+            annotate_scoped_outputs(&mut union.left, Some(&schema), dialect, outer, false);
+            annotate_scoped_outputs(&mut union.right, Some(&schema), dialect, outer, false);
+            if resolve_outputs {
+                super::set_operation_types::query_columns(expression, dialect)
+            } else {
+                Vec::new()
+            }
         }
         Expression::Intersect(intersect) => {
             let mut schema = ScopedSchema::new(parent, dialect);
             annotate_with(&mut intersect.with, &mut schema, dialect, outer);
-            annotate_scoped_expression_with_outer(
-                &mut intersect.left,
-                Some(&schema),
-                dialect,
-                outer,
-            );
-            annotate_scoped_expression_with_outer(
-                &mut intersect.right,
-                Some(&schema),
-                dialect,
-                outer,
-            );
-            super::set_operation_types::query_columns(expression, dialect)
+            annotate_scoped_outputs(&mut intersect.left, Some(&schema), dialect, outer, false);
+            annotate_scoped_outputs(&mut intersect.right, Some(&schema), dialect, outer, false);
+            if resolve_outputs {
+                super::set_operation_types::query_columns(expression, dialect)
+            } else {
+                Vec::new()
+            }
         }
         Expression::Except(except) => {
             let mut schema = ScopedSchema::new(parent, dialect);
             annotate_with(&mut except.with, &mut schema, dialect, outer);
-            annotate_scoped_expression_with_outer(&mut except.left, Some(&schema), dialect, outer);
-            annotate_scoped_expression_with_outer(&mut except.right, Some(&schema), dialect, outer);
-            super::set_operation_types::query_columns(expression, dialect)
+            annotate_scoped_outputs(&mut except.left, Some(&schema), dialect, outer, false);
+            annotate_scoped_outputs(&mut except.right, Some(&schema), dialect, outer, false);
+            if resolve_outputs {
+                super::set_operation_types::query_columns(expression, dialect)
+            } else {
+                Vec::new()
+            }
         }
         _ => {
             if let Some(mut selected) = crate::binding::dml_scope(expression) {
@@ -2826,6 +2919,16 @@ mod tests {
                         actual.is_none_or(|t| *t == DataType::Unknown),
                         "{dialect:?}: {actual:?}"
                     ),
+                    Snowflake => assert!(
+                        matches!(
+                            actual,
+                            Some(DataType::Decimal {
+                                precision: Some(38),
+                                scale: Some(0)
+                            })
+                        ),
+                        "{dialect:?}: {actual:?}"
+                    ),
                     Teradata if left == "INT" => assert!(
                         matches!(actual, Some(DataType::Int { .. })),
                         "{dialect:?}: {actual:?}"
@@ -3728,7 +3831,7 @@ mod tests {
     #[test]
     fn test_regexp_extract_all_rule_is_duckdb_specific() {
         // Other dialects have different overloads, notably BigQuery BYTES.
-        // Preserve their existing behavior rather than installing a global rule.
+        // No DuckDB-specific return rule may leak into another dialect.
         for dialect in [
             None,
             Some(DialectType::Generic),
@@ -3741,7 +3844,13 @@ mod tests {
                 Expression::Literal(Box::new(Literal::ByteString("a1".to_string()))),
             ] {
                 let mut annotator = TypeAnnotator::new(None, dialect);
-                let expected = annotator.annotate(&input);
+                let expected = if dialect == Some(DialectType::Snowflake) {
+                    // An unmodelled warehouse function must not acquire its
+                    // input type and propagate that guess into CASE/CTE outputs.
+                    Some(DataType::Unknown)
+                } else {
+                    annotator.annotate(&input)
+                };
                 let function = Expression::Function(Box::new(Function::new(
                     "REGEXP_EXTRACT_ALL",
                     vec![input, make_string_literal("[0-9]+")],

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/optimizer/qualify_columns.rs

@@ -1198,23 +1198,28 @@ pub fn qualify_outputs(scope: &Scope) -> QualifyColumnsResult<()> {
 }
 
 fn qualify_outputs_select(select: &mut Select) -> QualifyColumnsResult<()> {
-    let mut new_selections: Vec<Expression> = Vec::new();
-
-    for (i, expr) in select.expressions.iter().enumerate() {
+    fn qualify_output(expr: &Expression, i: usize) -> Expression {
         match expr {
-            Expression::Alias(_) => new_selections.push(expr.clone()),
-            Expression::Column(col) => {
-                new_selections.push(create_alias(expr.clone(), &col.name.name));
-            }
-            Expression::Star(_) => new_selections.push(expr.clone()),
+            Expression::Annotated(annotated) => {
+                let mut annotated = annotated.clone();
+                annotated.this = qualify_output(&annotated.this, i);
+                Expression::Annotated(annotated)
+            }
+            Expression::Alias(_) => expr.clone(),
+            Expression::Column(col) => create_alias(expr.clone(), &col.name.name),
+            Expression::Star(_) => expr.clone(),
             _ => {
                 let alias_name = get_output_name(expr).unwrap_or_else(|| format!("_col_{}", i));
-                new_selections.push(create_alias(expr.clone(), &alias_name));
+                create_alias(expr.clone(), &alias_name)
             }
         }
     }
-
-    select.expressions = new_selections;
+    select.expressions = select
+        .expressions
+        .iter()
+        .enumerate()
+        .map(|(i, expr)| qualify_output(expr, i))
+        .collect();
     Ok(())
 }
 
@@ -3071,6 +3076,7 @@ fn create_alias(expr: Expression, alias_name: &str) -> Expression {
 /// Get the output name for an expression
 fn get_output_name(expr: &Expression) -> Option<String> {
     match expr {
+        Expression::Annotated(annotated) => get_output_name(&annotated.this),
         Expression::Column(col) => Some(col.name.name.clone()),
         Expression::Alias(alias) => Some(alias.alias.name.clone()),
         Expression::Identifier(id) => Some(id.name.clone()),

{polyglot_sql_chio-0.13.0 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/optimizer/set_operation_types.rs

@@ -4,7 +4,7 @@
 
 use crate::dialects::DialectType;
 use crate::expressions::{DataType, Expression, Literal, OracleDataType, StructField};
-use crate::set_operation::set_operation_layout;
+use crate::set_operation::set_operation_layout_from_identifiers;
 use std::collections::HashMap;
 
 #[derive(Clone, Debug)]
@@ -111,7 +111,18 @@ impl OutputResolver {
     ) -> Vec<QueryOutput> {
         let left = self.resolve_inner(left, depth + 1);
         let right = self.resolve_inner(right, depth + 1);
-        let layout = set_operation_layout(query, Some(self.dialect));
+        let identifiers = |outputs: &[QueryOutput]| {
+            outputs
+                .iter()
+                .map(|output| crate::binding::schema_identifier(&output.name))
+                .collect::<Vec<_>>()
+        };
+        let layout = set_operation_layout_from_identifiers(
+            query,
+            Some(self.dialect),
+            &identifiers(&left),
+            &identifiers(&right),
+        );
         let pairs = match layout {
             Ok(Some(layout)) => layout
                 .outputs
@@ -343,6 +354,22 @@ fn combine(
     if depth > 64 || matches!(left, Unknown) || matches!(right, Unknown) {
         return Unknown;
     }
+    if dialect == DialectType::Snowflake {
+        if matches!((left, right), (Null, Null)) {
+            return Null;
+        }
+        let data_type = |value: &OutputType| match value {
+            Known(ty) => Some(ty.clone()),
+            StringLiteral(_) => Some(text_type(dialect)),
+            _ => None,
+        };
+        return crate::validation::snowflake_setops::result_type(
+            data_type(left).as_ref(),
+            data_type(right).as_ref(),
+        )
+        .map(Known)
+        .unwrap_or(Unknown);
+    }
     match (left, right) {
         (Null, Null) => match family(dialect) {
             Family::Postgres => Known(DataType::Text),