polyglot-sql 0.2.0__tar.gz → 0.2.1__tar.gz

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/Cargo.lock

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

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/Cargo.toml

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

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/PKG-INFO

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

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

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/crates/polyglot-sql/src/builder.rs

@@ -1617,6 +1617,7 @@ impl SelectBuilder {
             copy_grants: false,
             using_template: None,
             rollup: None,
+            uuid: None,
         }))
     }
 
@@ -2328,7 +2329,9 @@ pub trait IntoLiteral {
 impl IntoLiteral for &str {
     /// Produce a SQL string literal (e.g. `'hello'`).
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Box::new(Literal::String(self.to_string()))))
+        Expr(Expression::Literal(Box::new(Literal::String(
+            self.to_string(),
+        ))))
     }
 }
 
@@ -2342,28 +2345,36 @@ impl IntoLiteral for String {
 impl IntoLiteral for i64 {
     /// Produce a SQL numeric literal from a 64-bit integer.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
+        Expr(Expression::Literal(Box::new(Literal::Number(
+            self.to_string(),
+        ))))
     }
 }
 
 impl IntoLiteral for i32 {
     /// Produce a SQL numeric literal from a 32-bit integer.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
+        Expr(Expression::Literal(Box::new(Literal::Number(
+            self.to_string(),
+        ))))
     }
 }
 
 impl IntoLiteral for usize {
     /// Produce a SQL numeric literal from a `usize`.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
+        Expr(Expression::Literal(Box::new(Literal::Number(
+            self.to_string(),
+        ))))
     }
 }
 
 impl IntoLiteral for f64 {
     /// Produce a SQL numeric literal from a 64-bit float.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
+        Expr(Expression::Literal(Box::new(Literal::Number(
+            self.to_string(),
+        ))))
     }
 }
 

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -523,8 +523,11 @@ impl DialectImpl for BigQueryDialect {
             Expression::Split(f) => {
                 // Check if delimiter is empty or a placeholder - add default comma
                 let delimiter = match &f.delimiter {
-                    Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(s) if s.is_empty()) => {
-                        let Literal::String(_) = lit.as_ref() else { unreachable!() };
+                    Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(s) if s.is_empty()) =>
+                    {
+                        let Literal::String(_) = lit.as_ref() else {
+                            unreachable!()
+                        };
                         Expression::Literal(Box::new(Literal::String(",".to_string())))
                     }
                     _ => f.delimiter,
@@ -537,16 +540,56 @@ impl DialectImpl for BigQueryDialect {
 
             // Cast: Transform the target type according to BigQuery TYPE_MAPPING
             // Special case: CAST to JSON -> PARSE_JSON in BigQuery
+            // Special case: CAST(x AS temporal FORMAT 'fmt') -> PARSE_DATE/PARSE_TIMESTAMP
             Expression::Cast(c) => {
                 use crate::expressions::DataType;
                 // Check if casting to JSON - use PARSE_JSON instead
-                // Handle both DataType::Json/JsonB and DataType::Custom { name: "JSON" }
-                // (parser creates Custom for type literals like JSON 'string')
                 let is_json = matches!(c.to, DataType::Json | DataType::JsonB)
                     || matches!(&c.to, DataType::Custom { name } if name.eq_ignore_ascii_case("JSON") || name.eq_ignore_ascii_case("JSONB"));
                 if is_json {
                     return Ok(Expression::ParseJson(Box::new(UnaryFunc::new(c.this))));
                 }
+                // CAST(x AS temporal_type FORMAT 'fmt') -> PARSE_DATE/PARSE_TIMESTAMP(strftime_fmt, x)
+                if c.format.is_some() {
+                    let is_temporal = matches!(
+                        c.to,
+                        DataType::Date | DataType::Timestamp { .. } | DataType::Time { .. }
+                    ) || matches!(&c.to, DataType::Custom { name } if
+                        name.eq_ignore_ascii_case("TIMESTAMP") ||
+                        name.eq_ignore_ascii_case("DATE") ||
+                        name.eq_ignore_ascii_case("DATETIME") ||
+                        name.eq_ignore_ascii_case("TIME")
+                    );
+                    if is_temporal {
+                        let format_expr = c.format.as_ref().unwrap().as_ref();
+                        // Extract the actual format expr and timezone (if AT TIME ZONE is present)
+                        let (actual_format, timezone) = match format_expr {
+                            Expression::AtTimeZone(ref atz) => {
+                                (atz.this.clone(), Some(atz.zone.clone()))
+                            }
+                            _ => (format_expr.clone(), None),
+                        };
+                        let strftime_fmt = Self::bq_cast_format_to_strftime(&actual_format);
+                        let func_name = match &c.to {
+                            DataType::Date => "PARSE_DATE",
+                            DataType::Custom { name } if name.eq_ignore_ascii_case("DATE") => {
+                                "PARSE_DATE"
+                            }
+                            DataType::Custom { name } if name.eq_ignore_ascii_case("DATETIME") => {
+                                "PARSE_DATETIME"
+                            }
+                            _ => "PARSE_TIMESTAMP",
+                        };
+                        let mut func_args = vec![strftime_fmt, c.this];
+                        if let Some(tz) = timezone {
+                            func_args.push(tz);
+                        }
+                        return Ok(Expression::Function(Box::new(Function::new(
+                            func_name.to_string(),
+                            func_args,
+                        ))));
+                    }
+                }
                 let transformed_type = match self.transform_data_type(c.to)? {
                     Expression::DataType(dt) => dt,
                     _ => return Err(crate::error::Error::parse("Expected DataType", 0, 0, 0, 0)),
@@ -599,7 +642,8 @@ impl DialectImpl for BigQueryDialect {
                     if let Some(ref mut group_by) = select.group_by {
                         for grouped in group_by.expressions.iter_mut() {
                             // Skip numeric indices (already aliased)
-                            if matches!(grouped, Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_))) {
+                            if matches!(grouped, Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_)))
+                            {
                                 continue;
                             }
                             // Check if this GROUP BY expression matches a SELECT alias
@@ -662,7 +706,9 @@ impl DialectImpl for BigQueryDialect {
                     })),
                 };
                 let inner_select = Expression::Select(Box::new(Select {
-                    expressions: vec![Expression::Literal(Box::new(Literal::Number("1".to_string())))],
+                    expressions: vec![Expression::Literal(Box::new(Literal::Number(
+                        "1".to_string(),
+                    )))],
                     from: Some(From {
                         expressions: vec![aliased_unnest],
                     }),
@@ -718,7 +764,9 @@ impl DialectImpl for BigQueryDialect {
             Expression::JSONExtract(e) if e.variant_extract.is_some() => {
                 let path = match *e.expression {
                     Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
-                        let Literal::String(s) = lit.as_ref() else { unreachable!() };
+                        let Literal::String(s) = lit.as_ref() else {
+                            unreachable!()
+                        };
                         let normalized = if s.starts_with('$') {
                             s.clone()
                         } else if s.starts_with('[') {
@@ -1193,7 +1241,9 @@ impl BigQueryDialect {
             // SPLIT(foo) -> SPLIT(foo, ',')
             "SPLIT" if f.args.len() == 1 => {
                 let mut args = f.args;
-                args.push(Expression::Literal(Box::new(Literal::String(",".to_string()))));
+                args.push(Expression::Literal(Box::new(Literal::String(
+                    ",".to_string(),
+                ))));
                 Ok(Expression::Split(Box::new(SplitFunc {
                     this: args.remove(0),
                     delimiter: args.remove(0),
@@ -1299,7 +1349,9 @@ impl BigQueryDialect {
                 let path = args.remove(0);
                 let json_path = match &path {
                     Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
-                        let Literal::String(s) = lit.as_ref() else { unreachable!() };
+                        let Literal::String(s) = lit.as_ref() else {
+                            unreachable!()
+                        };
                         let normalized = if s.starts_with('$') {
                             s.clone()
                         } else if s.starts_with('[') {
@@ -1399,6 +1451,35 @@ impl BigQueryDialect {
     fn normalize_time_format(&self, format: &str) -> String {
         format.replace("%Y-%m-%d", "%F").replace("%H:%M:%S", "%T")
     }
+
+    /// Convert BigQuery CAST FORMAT elements to strftime equivalents,
+    /// then normalize BigQuery shorthand forms (%Y-%m-%d -> %F, %H:%M:%S -> %T)
+    fn bq_cast_format_to_strftime(format_expr: &Expression) -> Expression {
+        use crate::expressions::Literal;
+        if let Expression::Literal(lit) = format_expr {
+            if let Literal::String(s) = lit.as_ref() {
+                let result = s
+                    .replace("YYYYMMDD", "%Y%m%d")
+                    .replace("YYYY", "%Y")
+                    .replace("YY", "%y")
+                    .replace("MONTH", "%B")
+                    .replace("MON", "%b")
+                    .replace("MM", "%m")
+                    .replace("DD", "%d")
+                    .replace("HH24", "%H")
+                    .replace("HH12", "%I")
+                    .replace("HH", "%I")
+                    .replace("MI", "%M")
+                    .replace("SSTZH", "%S%z")
+                    .replace("SS", "%S")
+                    .replace("TZH", "%z");
+                // Normalize: %Y-%m-%d -> %F, %H:%M:%S -> %T
+                let normalized = result.replace("%Y-%m-%d", "%F").replace("%H:%M:%S", "%T");
+                return Expression::Literal(Box::new(Literal::String(normalized)));
+            }
+        }
+        format_expr.clone()
+    }
 }
 
 #[cfg(test)]

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -355,8 +355,7 @@ impl DialectImpl for ClickHouseDialect {
     }
 }
 
-impl ClickHouseDialect {
-}
+impl ClickHouseDialect {}
 
 impl ClickHouseDialect {
     fn transform_function(&self, f: Function) -> Result<Expression> {

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -149,11 +149,14 @@ impl DialectImpl for DatabricksDialect {
             Expression::DateSub(f) => {
                 // Convert string literals to numbers (interval values are often stored as strings)
                 let val = match f.interval {
-                    Expression::Literal(lit) if matches!(lit.as_ref(), crate::expressions::Literal::String(s) if s.parse::<i64>().is_ok())
-                        =>
+                    Expression::Literal(lit) if matches!(lit.as_ref(), crate::expressions::Literal::String(s) if s.parse::<i64>().is_ok()) =>
                     {
-                        let crate::expressions::Literal::String(s) = lit.as_ref() else { unreachable!() };
-                        Expression::Literal(Box::new(crate::expressions::Literal::Number(s.clone())))
+                        let crate::expressions::Literal::String(s) = lit.as_ref() else {
+                            unreachable!()
+                        };
+                        Expression::Literal(Box::new(crate::expressions::Literal::Number(
+                            s.clone(),
+                        )))
                     }
                     other => other,
                 };
@@ -515,8 +518,12 @@ impl DatabricksDialect {
 
                 // Extract and strip the $. prefix from the path
                 let path_expr = match &path_arg {
-                    Expression::Literal(lit) if matches!(lit.as_ref(), crate::expressions::Literal::String(_)) => {
-                        let crate::expressions::Literal::String(s) = lit.as_ref() else { unreachable!() };
+                    Expression::Literal(lit)
+                        if matches!(lit.as_ref(), crate::expressions::Literal::String(_)) =>
+                    {
+                        let crate::expressions::Literal::String(s) = lit.as_ref() else {
+                            unreachable!()
+                        };
                         // Strip leading '$.' if present
                         let stripped = if s.starts_with("$.") {
                             &s[2..]
@@ -819,7 +826,9 @@ impl DatabricksDialect {
         match &c.this {
             // TIMESTAMP 'value'::TYPE -> CAST(CAST('value' AS TYPE) AS TIMESTAMP)
             Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Timestamp(_)) => {
-                let Literal::Timestamp(value) = lit.as_ref() else { unreachable!() };
+                let Literal::Timestamp(value) = lit.as_ref() else {
+                    unreachable!()
+                };
                 // Create inner cast: CAST('value' AS target_type)
                 let inner_cast = Expression::Cast(Box::new(Cast {
                     this: Expression::Literal(Box::new(Literal::String(value.clone()))),
@@ -846,7 +855,9 @@ impl DatabricksDialect {
             }
             // DATE 'value'::TYPE -> CAST(CAST('value' AS TYPE) AS DATE)
             Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Date(_)) => {
-                let Literal::Date(value) = lit.as_ref() else { unreachable!() };
+                let Literal::Date(value) = lit.as_ref() else {
+                    unreachable!()
+                };
                 let inner_cast = Expression::Cast(Box::new(Cast {
                     this: Expression::Literal(Box::new(Literal::String(value.clone()))),
                     to: c.to,
@@ -868,7 +879,9 @@ impl DatabricksDialect {
             }
             // TIME 'value'::TYPE -> CAST(CAST('value' AS TYPE) AS TIME)
             Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Time(_)) => {
-                let Literal::Time(value) = lit.as_ref() else { unreachable!() };
+                let Literal::Time(value) = lit.as_ref() else {
+                    unreachable!()
+                };
                 let inner_cast = Expression::Cast(Box::new(Cast {
                     this: Expression::Literal(Box::new(Literal::String(value.clone()))),
                     to: c.to,

{polyglot_sql-0.2.0 → polyglot_sql-0.2.1}/crates/polyglot-sql/src/dialects/datafusion.rs

@@ -113,9 +113,9 @@ impl DataFusionDialect {
             // SQUARE(x) → POWER(x, 2)
             "SQUARE" => {
                 let mut args = f.args;
-                args.push(Expression::Literal(Box::new(crate::expressions::Literal::Number(
-                    "2".to_string(),
-                ))));
+                args.push(Expression::Literal(Box::new(
+                    crate::expressions::Literal::Number("2".to_string()),
+                )));
                 Ok(Expression::Function(Box::new(Function::new(
                     "power".to_string(),
                     args,