polyglot-sql 0.2.2__tar.gz → 0.2.3__tar.gz

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/Cargo.lock

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

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/Cargo.toml

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

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/PKG-INFO

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

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

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -1141,6 +1141,10 @@ impl BigQueryDialect {
                 // Convert unit identifier to IntervalUnit
                 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()
+                    }
                     _ => "DAY".to_string(),
                 };
                 let unit = match unit_name.as_str() {

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -931,6 +931,14 @@ impl DatabricksDialect {
                         span: None,
                     });
                 }
+                Expression::Var(v) => {
+                    args[0] = Expression::Identifier(Identifier {
+                        name: v.this.to_uppercase(),
+                        quoted: false,
+                        trailing_comments: Vec::new(),
+                        span: None,
+                    });
+                }
                 Expression::Column(col) if col.table.is_none() => {
                     // Unqualified column name like "day" should be treated as a unit
                     args[0] = Expression::Identifier(Identifier {

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/hive.rs

@@ -609,6 +609,7 @@ fn hive_expr_to_datetime_field(expr: &Expression) -> Option<DateTimeField> {
             s.to_uppercase()
         }
         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(),
         _ => return None,
     };

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/mod.rs

@@ -1419,6 +1419,12 @@ where
             Expression::CreateTable(ct)
         }
 
+        // CreateView: recurse into the view body query
+        Expression::CreateView(mut cv) => {
+            cv.query = transform_recursive(cv.query, transform_fn)?;
+            Expression::CreateView(cv)
+        }
+
         // CreateTask: recurse into the task body
         Expression::CreateTask(mut ct) => {
             ct.body = transform_recursive(ct.body, transform_fn)?;
@@ -3989,7 +3995,10 @@ impl Dialect {
             JsonExtractToGetJsonObject, // JSON_EXTRACT/JSON_EXTRACT_SCALAR -> GET_JSON_OBJECT for Hive/Spark
             JsonExtractScalarToGetJsonObject, // JSON_EXTRACT_SCALAR -> GET_JSON_OBJECT for Hive/Spark
             JsonQueryValueConvert, // JsonQuery/JsonValue -> target-specific (ISNULL wrapper for TSQL, GET_JSON_OBJECT for Spark, etc.)
-            JsonLiteralToJsonParse, // JSON 'x' -> JSON_PARSE('x') for Presto, PARSE_JSON for Snowflake
+            JsonLiteralToJsonParse, // JSON 'x' -> JSON_PARSE('x') for Presto, PARSE_JSON for Snowflake; also DuckDB CAST(x AS JSON)
+            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
             AtTimeZoneConvert, // AT TIME ZONE -> AT_TIMEZONE (Presto) / FROM_UTC_TIMESTAMP (Spark)
             DayOfWeekConvert,  // DAY_OF_WEEK -> dialect-specific
@@ -5806,8 +5815,30 @@ impl Dialect {
                 match &e {
                     Expression::Function(f) => {
                         let name = f.name.to_ascii_uppercase();
+                        // DuckDB json(x) is a synonym for CAST(x AS JSON) — parses a string.
+                        // Map to JSON_PARSE(x) for Trino/Presto/Athena to preserve semantics.
+                        if name == "JSON"
+                            && f.args.len() == 1
+                            && matches!(source, DialectType::DuckDB)
+                            && matches!(
+                                target,
+                                DialectType::Presto | DialectType::Trino | DialectType::Athena
+                            )
+                        {
+                            Action::DuckDBJsonFuncToJsonParse
+                        // DuckDB json_valid(x) has no direct Trino equivalent; emit the
+                        // SQL:2016 `x IS JSON` predicate which has matching semantics.
+                        } else if name == "JSON_VALID"
+                            && f.args.len() == 1
+                            && matches!(source, DialectType::DuckDB)
+                            && matches!(
+                                target,
+                                DialectType::Presto | DialectType::Trino | DialectType::Athena
+                            )
+                        {
+                            Action::DuckDBJsonValidToIsJson
                         // DATE_PART: strip quotes from first arg when target is Snowflake (source != Snowflake)
-                        if (name == "DATE_PART" || name == "DATEPART")
+                        } else if (name == "DATE_PART" || name == "DATEPART")
                             && f.args.len() == 2
                             && matches!(target, DialectType::Snowflake)
                             && !matches!(source, DialectType::Snowflake)
@@ -6559,6 +6590,18 @@ impl Dialect {
                             // CAST('x' AS JSON) -> JSON_PARSE('x') for Presto, PARSE_JSON for Snowflake
                             // Only when the input is a string literal (JSON 'value' syntax)
                             Action::JsonLiteralToJsonParse
+                        } else if matches!(&c.to, DataType::Json)
+                            && matches!(source, DialectType::DuckDB)
+                            && matches!(
+                                target,
+                                DialectType::Presto | DialectType::Trino | DialectType::Athena
+                            )
+                        {
+                            // DuckDB's CAST(x AS JSON) parses the string value into a JSON value.
+                            // Trino/Presto/Athena's CAST(x AS JSON) instead wraps the value as a
+                            // JSON string (no parsing) — different semantics. Use JSON_PARSE(x)
+                            // in the target to preserve DuckDB's parse semantics.
+                            Action::JsonLiteralToJsonParse
                         } else if matches!(&c.to, DataType::Json | DataType::JsonB)
                             && matches!(target, DialectType::Spark | DialectType::Databricks)
                         {
@@ -6633,6 +6676,23 @@ impl Dialect {
                             Action::None
                         }
                     }
+                    Expression::TryCast(ref c) => {
+                        if matches!(&c.to, DataType::Json)
+                            && matches!(source, DialectType::DuckDB)
+                            && matches!(
+                                target,
+                                DialectType::Presto | DialectType::Trino | DialectType::Athena
+                            )
+                        {
+                            // DuckDB's TRY_CAST(x AS JSON) tries to parse x as JSON, returning
+                            // NULL on parse failure. Trino/Presto/Athena's TRY_CAST(x AS JSON)
+                            // wraps the value as a JSON string (no parse). Emit TRY(JSON_PARSE(x))
+                            // to preserve DuckDB's parse-or-null semantics.
+                            Action::DuckDBTryCastJsonToTryJsonParse
+                        } else {
+                            Action::None
+                        }
+                    }
                     // For DuckDB: DATE_TRUNC should preserve the input type
                     Expression::DateTrunc(_) | Expression::TimestampTrunc(_) => {
                         if matches!(source, DialectType::Snowflake)
@@ -17678,6 +17738,7 @@ impl Dialect {
                                 // Get the raw unit text preserving original case
                                 let raw_unit = match &f.args[0] {
                                     Expression::Identifier(id) => id.name.clone(),
+                                    Expression::Var(v) => v.this.clone(),
                                     Expression::Literal(lit)
                                         if matches!(
                                             lit.as_ref(),
@@ -22003,6 +22064,7 @@ impl Dialect {
 
                 Action::JsonLiteralToJsonParse => {
                     // CAST('x' AS JSON) -> JSON_PARSE('x') for Presto, PARSE_JSON for Snowflake
+                    // Also DuckDB CAST(x AS JSON) -> JSON_PARSE(x) for Trino/Presto/Athena
                     if let Expression::Cast(c) = e {
                         let func_name = if matches!(target, DialectType::Snowflake) {
                             "PARSE_JSON"
@@ -22018,6 +22080,52 @@ impl Dialect {
                     }
                 }
 
+                Action::DuckDBTryCastJsonToTryJsonParse => {
+                    // DuckDB TRY_CAST(x AS JSON) -> TRY(JSON_PARSE(x)) for Trino/Presto/Athena
+                    if let Expression::TryCast(c) = e {
+                        let json_parse = Expression::Function(Box::new(Function::new(
+                            "JSON_PARSE".to_string(),
+                            vec![c.this],
+                        )));
+                        Ok(Expression::Function(Box::new(Function::new(
+                            "TRY".to_string(),
+                            vec![json_parse],
+                        ))))
+                    } else {
+                        Ok(e)
+                    }
+                }
+
+                Action::DuckDBJsonFuncToJsonParse => {
+                    // DuckDB json(x) -> JSON_PARSE(x) for Trino/Presto/Athena
+                    if let Expression::Function(f) = e {
+                        let args = f.args;
+                        Ok(Expression::Function(Box::new(Function::new(
+                            "JSON_PARSE".to_string(),
+                            args,
+                        ))))
+                    } else {
+                        Ok(e)
+                    }
+                }
+
+                Action::DuckDBJsonValidToIsJson => {
+                    // 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,
+                            },
+                        )))
+                    } else {
+                        Ok(e)
+                    }
+                }
+
                 Action::AtTimeZoneConvert => {
                     // AT TIME ZONE -> target-specific conversion
                     if let Expression::AtTimeZone(atz) = e {
@@ -30301,6 +30409,7 @@ impl Dialect {
         fn get_unit_str(expr: &Expression) -> String {
             match expr {
                 Expression::Identifier(id) => id.name.to_ascii_uppercase(),
+                Expression::Var(v) => v.this.to_ascii_uppercase(),
                 Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
                     let Literal::String(s) = lit.as_ref() else {
                         unreachable!()
@@ -34724,6 +34833,7 @@ impl Dialect {
         use crate::expressions::Literal;
         match expr {
             Expression::Identifier(id) => id.name.to_ascii_uppercase(),
+            Expression::Var(v) => v.this.to_ascii_uppercase(),
             Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
                 let Literal::String(s) = lit.as_ref() else {
                     unreachable!()

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/postgres.rs

@@ -1256,6 +1256,7 @@ impl PostgresDialect {
                     // Extract unit name from identifier or column
                     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()
                         }

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/presto.rs

@@ -844,6 +844,7 @@ impl PrestoDialect {
             "DATE_PART" if f.args.len() == 2 => {
                 let part_name = match &f.args[0] {
                     Expression::Identifier(id) => Some(id.name.to_uppercase()),
+                    Expression::Var(v) => Some(v.this.to_uppercase()),
                     Expression::Column(c) => Some(c.name.name.to_uppercase()),
                     _ => None,
                 };

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/snowflake.rs

@@ -2816,6 +2816,7 @@ impl SnowflakeDialect {
                 // Transform the unit to canonical form and convert to string literal
                 let unit_name = match &args[0] {
                     Expression::Identifier(id) => Some(id.name.as_str()),
+                    Expression::Var(v) => Some(v.this.as_str()),
                     Expression::Column(col) if col.table.is_none() => Some(col.name.name.as_str()),
                     _ => None,
                 };

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/spark.rs

@@ -997,6 +997,7 @@ fn expr_to_datetime_field(expr: &Expression) -> Option<DateTimeField> {
             s.to_uppercase()
         }
         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(),
         _ => return None,
     };

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/sqlite.rs

@@ -354,6 +354,10 @@ impl SQLiteDialect {
                         s.to_lowercase()
                     }
                     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()
+                    }
                     _ => "day".to_string(),
                 };
 

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -1203,6 +1203,14 @@ impl TSQLDialect {
                         span: None,
                     });
                 }
+                Expression::Var(v) => {
+                    args[0] = Expression::Identifier(Identifier {
+                        name: v.this.to_uppercase(),
+                        quoted: false,
+                        trailing_comments: Vec::new(),
+                        span: None,
+                    });
+                }
                 Expression::Column(col) if col.table.is_none() => {
                     args[0] = Expression::Identifier(Identifier {
                         name: col.name.name.to_uppercase(),

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/expressions.rs

@@ -9667,6 +9667,9 @@ pub struct Describe {
     /// AS JSON suffix (Databricks)
     #[serde(default)]
     pub as_json: bool,
+    /// Parenthesized parameter types for DESCRIBE PROCEDURE/FUNCTION (e.g., INT, VARCHAR)
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub params: Vec<String>,
 }
 
 impl Describe {
@@ -9681,6 +9684,7 @@ impl Describe {
             partition: None,
             leading_comments: Vec::new(),
             as_json: false,
+            params: Vec::new(),
         }
     }
 }

{polyglot_sql-0.2.2 → polyglot_sql-0.2.3}/crates/polyglot-sql/src/generator.rs

@@ -13846,6 +13846,18 @@ impl Generator {
         self.write_space();
         self.generate_expression(&d.target)?;
 
+        // Output parenthesized parameter types for PROCEDURE/FUNCTION
+        if !d.params.is_empty() {
+            self.write("(");
+            for (i, param) in d.params.iter().enumerate() {
+                if i > 0 {
+                    self.write(", ");
+                }
+                self.write(param);
+            }
+            self.write(")");
+        }
+
         // Output PARTITION clause if present (the Partition expression outputs its own PARTITION keyword)
         if let Some(ref partition) = d.partition {
             self.write_space();
@@ -17955,6 +17967,7 @@ impl Generator {
                 Some(s.clone())
             }
             Expression::Identifier(id) => Some(id.name.clone()),
+            Expression::Var(v) => Some(v.this.clone()),
             Expression::Column(col) if col.table.is_none() => {
                 // Simple column reference without table prefix, treat as identifier
                 Some(col.name.name.clone())