polyglot-sql 0.3.0__tar.gz → 0.3.2__tar.gz

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/Cargo.lock

@@ -587,7 +587,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "criterion",
  "once_cell",
@@ -602,7 +602,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -612,11 +612,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.3.0"
+version = "0.3.2"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -627,7 +627,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/Cargo.toml

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

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/PKG-INFO

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

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/Cargo.toml

@@ -78,7 +78,7 @@ serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/ast_transforms.rs

@@ -422,6 +422,18 @@ pub fn get_table_names(expr: &Expression) -> Vec<String> {
                     }
                 }
             }
+            Expression::Cache(cache) => {
+                let name = cache.table.name.clone();
+                if !name.is_empty() && !cte_aliases.contains(&name) {
+                    names.push(name);
+                }
+            }
+            Expression::Uncache(uncache) => {
+                let name = uncache.table.name.clone();
+                if !name.is_empty() && !cte_aliases.contains(&name) {
+                    names.push(name);
+                }
+            }
             _ => {}
         }
     }

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/builder.rs

@@ -1618,6 +1618,8 @@ impl SelectBuilder {
             using_template: None,
             rollup: None,
             uuid: None,
+            with_partition_columns: vec![],
+            with_connection: None,
         }))
     }
 

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -1142,9 +1142,7 @@ impl BigQueryDialect {
                 let unit_name = match &unit_expr {
                     Expression::Identifier(id) => id.name.to_uppercase(),
                     Expression::Var(v) => v.this.to_uppercase(),
-                    Expression::Column(col) if col.table.is_none() => {
-                        col.name.name.to_uppercase()
-                    }
+                    Expression::Column(col) if col.table.is_none() => col.name.name.to_uppercase(),
                     _ => "DAY".to_string(),
                 };
                 let unit = match unit_name.as_str() {

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -13,9 +13,9 @@ use super::{DialectImpl, DialectType};
 use crate::error::Result;
 use crate::expressions::{
     AggFunc, Alias, BinaryOp, Case, Cast, CeilFunc, Column, DataType, Expression, Function,
-    Identifier, Interval, IntervalUnit, IntervalUnitSpec, IsNull, JSONPath,
-    JSONPathKey, JSONPathRoot, JSONPathSubscript, JsonExtractFunc, Literal, Null, Paren, Struct,
-    Subquery, SubstringFunc, UnaryFunc, UnaryOp, VarArgFunc, WindowFunction,
+    Identifier, Interval, IntervalUnit, IntervalUnitSpec, IsNull, JSONPath, JSONPathKey,
+    JSONPathRoot, JSONPathSubscript, JsonExtractFunc, Literal, Null, Paren, Struct, Subquery,
+    SubstringFunc, UnaryFunc, UnaryOp, VarArgFunc, WindowFunction,
 };
 use crate::generator::GeneratorConfig;
 use crate::tokens::TokenizerConfig;

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/mod.rs

@@ -543,6 +543,33 @@ where
 {
     use crate::expressions::BinaryOp;
 
+    // Helper macro to recurse into AggFunc-based expressions (this, filter, order_by, having_max, limit).
+    macro_rules! recurse_agg {
+        ($variant:ident, $f:expr) => {{
+            let mut f = $f;
+            f.this = transform_recursive(f.this, transform_fn)?;
+            if let Some(filter) = f.filter.take() {
+                f.filter = Some(transform_recursive(filter, transform_fn)?);
+            }
+            for ord in &mut f.order_by {
+                ord.this = transform_recursive(
+                    std::mem::replace(&mut ord.this, Expression::Null(crate::expressions::Null)),
+                    transform_fn,
+                )?;
+            }
+            if let Some((ref mut expr, _)) = f.having_max {
+                *expr = Box::new(transform_recursive(
+                    std::mem::replace(expr.as_mut(), Expression::Null(crate::expressions::Null)),
+                    transform_fn,
+                )?);
+            }
+            if let Some(limit) = f.limit.take() {
+                f.limit = Some(Box::new(transform_recursive(*limit, transform_fn)?));
+            }
+            Expression::$variant(f)
+        }};
+    }
+
     // Helper macro to transform binary ops with Box<BinaryOp>
     macro_rules! transform_binary {
         ($variant:ident, $op:expr) => {{
@@ -954,14 +981,9 @@ where
             f.this = transform_recursive(f.this, transform_fn)?;
             Expression::Date(f)
         }
-        Expression::Stddev(mut f) => {
-            f.this = transform_recursive(f.this, transform_fn)?;
-            Expression::Stddev(f)
-        }
-        Expression::Variance(mut f) => {
-            f.this = transform_recursive(f.this, transform_fn)?;
-            Expression::Variance(f)
-        }
+        Expression::Stddev(f) => recurse_agg!(Stddev, f),
+        Expression::StddevSamp(f) => recurse_agg!(StddevSamp, f),
+        Expression::Variance(f) => recurse_agg!(Variance, f),
 
         // ===== BinaryFunc-based expressions =====
         Expression::ModFunc(mut f) => {
@@ -1586,19 +1608,45 @@ where
             Expression::Filter(f)
         }
 
-        // BitwiseOrAgg/BitwiseAndAgg/BitwiseXorAgg: recurse into the aggregate argument
-        Expression::BitwiseOrAgg(mut f) => {
-            f.this = transform_recursive(f.this, transform_fn)?;
-            Expression::BitwiseOrAgg(f)
-        }
-        Expression::BitwiseAndAgg(mut f) => {
-            f.this = transform_recursive(f.this, transform_fn)?;
-            Expression::BitwiseAndAgg(f)
-        }
-        Expression::BitwiseXorAgg(mut f) => {
-            f.this = transform_recursive(f.this, transform_fn)?;
-            Expression::BitwiseXorAgg(f)
+        // Aggregate functions (AggFunc-based): recurse into the aggregate argument,
+        // filter, order_by, having_max, and limit.
+        // Stddev, StddevSamp, Variance, and ArrayAgg are handled earlier in this match.
+        Expression::Sum(f) => recurse_agg!(Sum, f),
+        Expression::Avg(f) => recurse_agg!(Avg, f),
+        Expression::Min(f) => recurse_agg!(Min, f),
+        Expression::Max(f) => recurse_agg!(Max, f),
+        Expression::CountIf(f) => recurse_agg!(CountIf, f),
+        Expression::StddevPop(f) => recurse_agg!(StddevPop, f),
+        Expression::VarPop(f) => recurse_agg!(VarPop, f),
+        Expression::VarSamp(f) => recurse_agg!(VarSamp, f),
+        Expression::Median(f) => recurse_agg!(Median, f),
+        Expression::Mode(f) => recurse_agg!(Mode, f),
+        Expression::First(f) => recurse_agg!(First, f),
+        Expression::Last(f) => recurse_agg!(Last, f),
+        Expression::AnyValue(f) => recurse_agg!(AnyValue, f),
+        Expression::ApproxDistinct(f) => recurse_agg!(ApproxDistinct, f),
+        Expression::ApproxCountDistinct(f) => recurse_agg!(ApproxCountDistinct, f),
+        Expression::LogicalAnd(f) => recurse_agg!(LogicalAnd, f),
+        Expression::LogicalOr(f) => recurse_agg!(LogicalOr, f),
+        Expression::Skewness(f) => recurse_agg!(Skewness, f),
+        Expression::ArrayConcatAgg(f) => recurse_agg!(ArrayConcatAgg, f),
+        Expression::ArrayUniqueAgg(f) => recurse_agg!(ArrayUniqueAgg, f),
+        Expression::BoolXorAgg(f) => recurse_agg!(BoolXorAgg, f),
+        Expression::BitwiseOrAgg(f) => recurse_agg!(BitwiseOrAgg, f),
+        Expression::BitwiseAndAgg(f) => recurse_agg!(BitwiseAndAgg, f),
+        Expression::BitwiseXorAgg(f) => recurse_agg!(BitwiseXorAgg, f),
+
+        // Count has its own struct with an Option<Expression> `this` field
+        Expression::Count(mut c) => {
+            if let Some(this) = c.this.take() {
+                c.this = Some(transform_recursive(this, transform_fn)?);
+            }
+            if let Some(filter) = c.filter.take() {
+                c.filter = Some(transform_recursive(filter, transform_fn)?);
+            }
+            Expression::Count(c)
         }
+
         Expression::PipeOperator(mut pipe) => {
             pipe.this = transform_recursive(pipe.this, transform_fn)?;
             pipe.expression = transform_recursive(pipe.expression, transform_fn)?;
@@ -4061,7 +4109,7 @@ impl Dialect {
             DuckDBTryCastJsonToTryJsonParse, // DuckDB TRY_CAST(x AS JSON) -> TRY(JSON_PARSE(x)) for Trino/Presto/Athena
             DuckDBJsonFuncToJsonParse, // DuckDB json(x) -> JSON_PARSE(x) for Trino/Presto/Athena
             DuckDBJsonValidToIsJson,   // DuckDB json_valid(x) -> x IS JSON for Trino/Presto/Athena
-            ArraySyntaxConvert,     // ARRAY[x] -> ARRAY(x) for Spark, [x] for BigQuery/DuckDB
+            ArraySyntaxConvert,        // ARRAY[x] -> ARRAY(x) for Spark, [x] for BigQuery/DuckDB
             AtTimeZoneConvert, // AT TIME ZONE -> AT_TIMEZONE (Presto) / FROM_UTC_TIMESTAMP (Spark)
             DayOfWeekConvert,  // DAY_OF_WEEK -> dialect-specific
             MaxByMinByConvert, // MAX_BY/MIN_BY -> argMax/argMin for ClickHouse
@@ -20018,20 +20066,27 @@ impl Dialect {
                                         // DuckDB supports TRUNC(x, decimals) — preserve both args
                                         let mut args = f.args;
                                         // Snowflake fractions_supported: wrap non-INT decimals in CAST(... AS INT)
-                                        if args.len() == 2 && matches!(source, DialectType::Snowflake) {
+                                        if args.len() == 2
+                                            && matches!(source, DialectType::Snowflake)
+                                        {
                                             let decimals = args.remove(1);
                                             let is_int = matches!(&decimals, Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_)))
                                                 || matches!(&decimals, Expression::Cast(c) if matches!(c.to, DataType::Int { .. } | DataType::SmallInt { .. } | DataType::BigInt { .. } | DataType::TinyInt { .. }));
                                             let wrapped = if !is_int {
-                                                Expression::Cast(Box::new(crate::expressions::Cast {
-                                                    this: decimals,
-                                                    to: DataType::Int { length: None, integer_spelling: false },
-                                                    double_colon_syntax: false,
-                                                    trailing_comments: Vec::new(),
-                                                    format: None,
-                                                    default: None,
-                                                    inferred_type: None,
-                                                }))
+                                                Expression::Cast(Box::new(
+                                                    crate::expressions::Cast {
+                                                        this: decimals,
+                                                        to: DataType::Int {
+                                                            length: None,
+                                                            integer_spelling: false,
+                                                        },
+                                                        double_colon_syntax: false,
+                                                        trailing_comments: Vec::new(),
+                                                        format: None,
+                                                        default: None,
+                                                        inferred_type: None,
+                                                    },
+                                                ))
                                             } else {
                                                 decimals
                                             };
@@ -22182,14 +22237,12 @@ impl Dialect {
                     // DuckDB json_valid(x) -> x IS JSON (SQL:2016 predicate) for Trino/Presto/Athena
                     if let Expression::Function(mut f) = e {
                         let arg = f.args.remove(0);
-                        Ok(Expression::IsJson(Box::new(
-                            crate::expressions::IsJson {
-                                this: arg,
-                                json_type: None,
-                                unique_keys: None,
-                                negated: false,
-                            },
-                        )))
+                        Ok(Expression::IsJson(Box::new(crate::expressions::IsJson {
+                            this: arg,
+                            json_type: None,
+                            unique_keys: None,
+                            negated: false,
+                        })))
                     } else {
                         Ok(e)
                     }
@@ -29880,6 +29933,8 @@ impl Dialect {
                             using_template: None,
                             rollup: None,
                             uuid: None,
+                            with_partition_columns: Vec::new(),
+                            with_connection: None,
                         };
                         return Expression::CreateTable(Box::new(ct));
                     }
@@ -35948,9 +36003,7 @@ mod tests {
     #[test]
     fn test_pg_hash_bitwise_xor() {
         let dialect = Dialect::get(DialectType::PostgreSQL);
-        let result = dialect
-            .transpile("x # y", DialectType::PostgreSQL)
-            .unwrap();
+        let result = dialect.transpile("x # y", DialectType::PostgreSQL).unwrap();
         assert_eq!(result[0], "x # y");
     }
 

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/sqlite.rs

@@ -355,9 +355,7 @@ impl SQLiteDialect {
                     }
                     Expression::Identifier(id) => id.name.to_lowercase(),
                     Expression::Var(v) => v.this.to_lowercase(),
-                    Expression::Column(col) if col.table.is_none() => {
-                        col.name.name.to_lowercase()
-                    }
+                    Expression::Column(col) if col.table.is_none() => col.name.name.to_lowercase(),
                     _ => "day".to_string(),
                 };
 

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/expressions.rs

@@ -7344,6 +7344,15 @@ pub struct CreateTable {
     /// ClickHouse: UUID 'xxx' clause after table name
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub uuid: Option<String>,
+    /// WITH PARTITION COLUMNS (col_name col_type, ...) — currently used by BigQuery
+    /// for hive-partitioned external tables. Not dialect-prefixed since the syntax
+    /// could appear in other engines.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub with_partition_columns: Vec<ColumnDef>,
+    /// WITH CONNECTION `project.region.connection` — currently used by BigQuery
+    /// for external tables that reference a Cloud Resource connection.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub with_connection: Option<TableRef>,
 }
 
 /// Teradata index specification for CREATE TABLE
@@ -7411,6 +7420,8 @@ impl CreateTable {
             using_template: None,
             rollup: None,
             uuid: None,
+            with_partition_columns: Vec::new(),
+            with_connection: None,
         }
     }
 }
@@ -10592,6 +10603,9 @@ pub struct MultitableInserts {
     /// Leading comments before the statement
     #[serde(default)]
     pub leading_comments: Vec<String>,
+    /// OVERWRITE modifier (Snowflake: INSERT OVERWRITE ALL)
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub overwrite: bool,
 }
 
 /// OnConflict

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/generator.rs

@@ -7947,6 +7947,51 @@ impl Generator {
             self.generate_expression(&on_prop.this)?;
         }
 
+        // BigQuery: WITH PARTITION COLUMNS (col_name col_type, ...)
+        if !ct.with_partition_columns.is_empty() {
+            if self.config.pretty {
+                self.write_newline();
+            } else {
+                self.write_space();
+            }
+            self.write_keyword("WITH PARTITION COLUMNS");
+            self.write(" (");
+            if self.config.pretty {
+                self.write_newline();
+                self.indent_level += 1;
+                for (i, col) in ct.with_partition_columns.iter().enumerate() {
+                    if i > 0 {
+                        self.write(",");
+                        self.write_newline();
+                    }
+                    self.write_indent();
+                    self.generate_column_def(col)?;
+                }
+                self.indent_level -= 1;
+                self.write_newline();
+            } else {
+                for (i, col) in ct.with_partition_columns.iter().enumerate() {
+                    if i > 0 {
+                        self.write(", ");
+                    }
+                    self.generate_column_def(col)?;
+                }
+            }
+            self.write(")");
+        }
+
+        // BigQuery: WITH CONNECTION `project.region.connection`
+        if let Some(ref conn) = ct.with_connection {
+            if self.config.pretty {
+                self.write_newline();
+            } else {
+                self.write_space();
+            }
+            self.write_keyword("WITH CONNECTION");
+            self.write_space();
+            self.generate_table(conn)?;
+        }
+
         // Output SchemaCommentProperty BEFORE WITH properties (Presto/Hive/Spark style)
         // For ClickHouse, SchemaCommentProperty goes after AS SELECT, handled later
         if !is_clickhouse {
@@ -31093,8 +31138,12 @@ impl Generator {
                 self.write_space();
             }
         }
-        // Python: INSERT kind expressions source
+        // Python: INSERT [OVERWRITE] kind expressions source
         self.write_keyword("INSERT");
+        if e.overwrite {
+            self.write_space();
+            self.write_keyword("OVERWRITE");
+        }
         self.write_space();
         self.write(&e.kind);
         if self.config.pretty {

{polyglot_sql-0.3.0 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/lib.rs

@@ -846,17 +846,48 @@ mod format_tests {
     #[test]
     fn transpile_matches_dialect_method() {
         let cases: &[(DialectType, DialectType, &str, &str, &str)] = &[
-            (DialectType::DuckDB, DialectType::Trino, "duckdb", "trino",
-             "SELECT to_timestamp(col) FROM t"),
-            (DialectType::DuckDB, DialectType::Trino, "duckdb", "trino",
-             "SELECT CAST(col AS JSON) FROM t"),
-            (DialectType::DuckDB, DialectType::Trino, "duckdb", "trino",
-             "SELECT json_valid(col) FROM t"),
-            (DialectType::Snowflake, DialectType::DuckDB, "snowflake", "duckdb",
-             "SELECT DATEDIFF(day, a, b) FROM t"),
-            (DialectType::BigQuery, DialectType::DuckDB, "bigquery", "duckdb",
-             "SELECT DATE_DIFF(a, b, DAY) FROM t"),
-            (DialectType::Generic, DialectType::Generic, "generic", "generic", "SELECT 1"),
+            (
+                DialectType::DuckDB,
+                DialectType::Trino,
+                "duckdb",
+                "trino",
+                "SELECT to_timestamp(col) FROM t",
+            ),
+            (
+                DialectType::DuckDB,
+                DialectType::Trino,
+                "duckdb",
+                "trino",
+                "SELECT CAST(col AS JSON) FROM t",
+            ),
+            (
+                DialectType::DuckDB,
+                DialectType::Trino,
+                "duckdb",
+                "trino",
+                "SELECT json_valid(col) FROM t",
+            ),
+            (
+                DialectType::Snowflake,
+                DialectType::DuckDB,
+                "snowflake",
+                "duckdb",
+                "SELECT DATEDIFF(day, a, b) FROM t",
+            ),
+            (
+                DialectType::BigQuery,
+                DialectType::DuckDB,
+                "bigquery",
+                "duckdb",
+                "SELECT DATE_DIFF(a, b, DAY) FROM t",
+            ),
+            (
+                DialectType::Generic,
+                DialectType::Generic,
+                "generic",
+                "generic",
+                "SELECT 1",
+            ),
         ];
         for (read, write, read_name, write_name, sql) in cases {
             let via_lib = transpile(sql, *read, *write).expect("lib::transpile failed");