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

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

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

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

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

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

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

{polyglot_sql_chio-0.13.1 → 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.1" }
+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.1", 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.1 → 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.1", default-features = false }
+polyglot-sql = { version = "0.13.2", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.13.1",
+    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.1",
+    version = "0.13.2",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.13.1",
+    version = "0.13.2",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql_chio-0.13.1 → 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))
+                }
             }
         }
     }
@@ -2838,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:?}"
@@ -3740,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),
@@ -3753,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.1 → 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.1 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/optimizer/set_operation_types.rs

@@ -354,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),

{polyglot_sql_chio-0.13.1 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/parser.rs

@@ -10588,6 +10588,10 @@ impl Parser {
                     strict,
                     on_columns,
                 }));
+                // INTERSECT binds more tightly than UNION and EXCEPT on Snowflake.
+                if self.config.dialect == Some(crate::dialects::DialectType::Snowflake) {
+                    result = Self::snowflake_intersect_precedence(result);
+                }
                 found_set_op = true;
             } else if self.check_set_operation_start(TokenType::Except) {
                 self.skip();
@@ -10647,6 +10651,42 @@ impl Parser {
         Ok(result)
     }
 
+    fn snowflake_intersect_precedence(expression: Expression) -> Expression {
+        let Expression::Intersect(mut intersect) = expression else {
+            return expression;
+        };
+        match std::mem::replace(&mut intersect.left, Expression::null()) {
+            Expression::Annotated(mut annotated) => {
+                intersect.left = std::mem::replace(&mut annotated.this, Expression::null());
+                annotated.this =
+                    Self::snowflake_intersect_precedence(Expression::Intersect(intersect));
+                Expression::Annotated(annotated)
+            }
+            Expression::Union(mut outer) => {
+                intersect.left = std::mem::replace(&mut outer.right, Expression::null());
+                outer.order_by = intersect.order_by.take();
+                outer.limit = intersect.limit.take();
+                outer.offset = intersect.offset.take();
+                outer.right =
+                    Self::snowflake_intersect_precedence(Expression::Intersect(intersect));
+                Expression::Union(outer)
+            }
+            Expression::Except(mut outer) => {
+                intersect.left = std::mem::replace(&mut outer.right, Expression::null());
+                outer.order_by = intersect.order_by.take();
+                outer.limit = intersect.limit.take();
+                outer.offset = intersect.offset.take();
+                outer.right =
+                    Self::snowflake_intersect_precedence(Expression::Intersect(intersect));
+                Expression::Except(outer)
+            }
+            left => {
+                intersect.left = left;
+                Expression::Intersect(intersect)
+            }
+        }
+    }
+
     /// Canonicalize a VALUES set-operation branch as a SELECT from a derived table.
     /// This keeps VALUES branches addressable by later alias-pushdown transforms and
     /// matches SQLGlot's set-operation AST shape.
@@ -37450,18 +37490,12 @@ impl Parser {
                             }
                         }
                         self.expect(TokenType::RParen)?;
-                        // Multiple args without DISTINCT - treat as generic function
-                        return Ok(Expression::Function(Box::new(Function {
-                            name: name.to_string(),
-                            args,
-                            distinct: false,
-                            trailing_comments: Vec::new(),
-                            use_bracket_syntax: false,
-                            no_parens: false,
-                            quoted: false,
-                            span: None,
-                            inferred_type: None,
-                        })));
+                        // Multi-argument COUNT is still an aggregate (Snowflake).
+                        if self.config.dialect == Some(crate::dialects::DialectType::Snowflake) {
+                            let filter = self.parse_filter_clause()?;
+                            return Ok(Self::make_simple_aggregate(name, args, false, filter));
+                        }
+                        return Ok(Self::make_unquoted_function(name, args));
                     }
                     (Some(first_expr), false, false)
                 };

{polyglot_sql_chio-0.13.1 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/resolver.rs

@@ -397,6 +397,7 @@ impl<'a> Resolver<'a> {
     /// Get the alias or name for a select expression
     fn get_expression_alias(&self, expr: &Expression) -> Option<String> {
         match expr {
+            Expression::Annotated(annotated) => self.get_expression_alias(&annotated.this),
             Expression::Alias(alias) => Some(alias.alias.name.clone()),
             Expression::Column(col) => Some(col.name.name.clone()),
             Expression::Star(_) => Some("*".to_string()),

{polyglot_sql_chio-0.13.1 → polyglot_sql_chio-0.13.2}/crates/polyglot-sql/src/scope.rs

@@ -933,9 +933,11 @@ fn add_table_to_scope(expr: &Expression, scope: &mut Scope) {
             scope.derived_table_scopes.push(derived_scope);
         }
         Expression::Lateral(lateral) => {
-            if let Some(alias) = &lateral.alias {
-                scope.add_virtual_source(alias.clone(), expr.clone());
-            }
+            let name = lateral
+                .alias
+                .clone()
+                .unwrap_or_else(|| scope.next_virtual_source_name());
+            scope.add_virtual_source(name, expr.clone());
         }
         Expression::LateralView(lateral_view) => {
             add_lateral_view_to_scope(lateral_view, scope);

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

@@ -332,7 +332,13 @@ pub(super) fn check(
                     false,
                     validation_codes::E_INVALID_CAST,
                     validation_codes::W_LOSSY_CAST,
-                    format!("Unknown cast target type {:?}", expr.to),
+                    format!(
+                        "Unknown cast target type '{}'",
+                        match &expr.to {
+                            DataType::Custom { name } => name.as_str(),
+                            _ => unreachable!(),
+                        }
+                    ),
                 ));
             }
         }