polyglot-sql 0.5.10__tar.gz → 0.5.12__tar.gz

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.5.10"
+version = "0.5.12"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.5.10"
+version = "0.5.12"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.5.10"
+version = "0.5.12"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.5.10"
+version = "0.5.12"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.5.10"
+version = "0.5.12"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/Cargo.toml

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

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/PKG-INFO

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

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/crates/polyglot-sql/Cargo.toml

@@ -106,7 +106,7 @@ 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.5.10", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.12", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -244,19 +244,6 @@ impl DialectImpl for DuckDBDialect {
             // UNNEST is native to DuckDB
             Expression::Unnest(f) => Ok(Expression::Unnest(f)),
 
-            // ArrayContainedBy (<@) -> ArrayContainsAll (@>) with swapped operands
-            // a <@ b becomes b @> a
-            Expression::ArrayContainedBy(op) => {
-                Ok(Expression::ArrayContainsAll(Box::new(BinaryOp {
-                    left: op.right,
-                    right: op.left,
-                    left_comments: Vec::new(),
-                    operator_comments: Vec::new(),
-                    trailing_comments: Vec::new(),
-                    inferred_type: None,
-                })))
-            }
-
             // DATE_ADD -> date + INTERVAL in DuckDB
             Expression::DateAdd(f) => {
                 // Reconstruct INTERVAL expression from value and unit

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/crates/polyglot-sql/src/dialects/mod.rs

@@ -4879,6 +4879,15 @@ impl Dialect {
                 Self::push_unsupported_diagnostic(&mut diagnostics, "ARRAY_AGG");
             }
 
+            if matches!(target, DialectType::TSQL | DialectType::Fabric)
+                && Self::node_is_regex_predicate(node)
+            {
+                Self::push_unsupported_diagnostic(
+                    &mut diagnostics,
+                    "regular expression predicates",
+                );
+            }
+
             if matches!(source, DialectType::PostgreSQL | DialectType::CockroachDB)
                 && !matches!(target, DialectType::PostgreSQL | DialectType::CockroachDB)
             {
@@ -5018,6 +5027,15 @@ impl Dialect {
         matches!(expr, Expression::ArrayAgg(_)) || Self::node_is_function_named(expr, "ARRAY_AGG")
     }
 
+    fn node_is_regex_predicate(expr: &Expression) -> bool {
+        matches!(
+            expr,
+            Expression::SimilarTo(_) | Expression::RegexpLike(_) | Expression::RegexpILike(_)
+        ) || Self::node_is_function_named(expr, "REGEXP_LIKE")
+            || Self::node_is_function_named(expr, "REGEXP_I_LIKE")
+            || Self::node_is_function_named(expr, "REGEXP_ILIKE")
+    }
+
     fn node_is_function_named(expr: &Expression, name: &str) -> bool {
         match expr {
             Expression::Function(function) => function.name.eq_ignore_ascii_case(name),
@@ -8911,7 +8929,7 @@ impl Dialect {
                                 | "SAFE_ADD" | "SAFE_SUBTRACT" | "SAFE_MULTIPLY"
                                 | "SAFE_CAST"
                                 | "GENERATE_DATE_ARRAY"
-                                | "PARSE_DATE" | "PARSE_TIMESTAMP"
+                                | "PARSE_DATE" | "PARSE_DATETIME" | "PARSE_TIMESTAMP"
                                 | "FORMAT_DATE" | "FORMAT_DATETIME" | "FORMAT_TIMESTAMP"
                                 | "ARRAY_CONCAT"
                                 | "JSON_QUERY" | "JSON_VALUE_ARRAY"
@@ -9040,7 +9058,8 @@ impl Dialect {
                                 | "CONVERT" | "TRY_CONVERT"
                                 | "STRFTIME" | "STRPTIME"
                                 | "DATE_FORMAT" | "FORMAT_DATE"
-                                | "PARSE_TIMESTAMP" | "PARSE_DATE"
+                                | "PARSE_TIMESTAMP" | "PARSE_DATETIME" | "PARSE_DATE"
+                                | "FROM_ISO8601_TIMESTAMP" | "FROM_ISO8601_DATE"
                                 | "FROM_BASE64" | "TO_BASE64"
                                 | "GETDATE"
                                 | "TO_HEX" | "FROM_HEX" | "UNHEX" | "HEX"
@@ -14569,6 +14588,108 @@ impl Dialect {
                                     )))),
                                 }
                             }
+                            // BigQuery PARSE_DATETIME(format, value) -> target-specific parsing calls.
+                            "PARSE_DATETIME"
+                                if matches!(source, DialectType::BigQuery) && f.args.len() == 2 =>
+                            {
+                                fn expand_bigquery_datetime_format(expr: Expression) -> Expression {
+                                    match expr {
+                                        Expression::Literal(lit) => match lit.as_ref() {
+                                            Literal::String(s) => Expression::string(
+                                                s.replace("%F", "%Y-%m-%d")
+                                                    .replace("%T", "%H:%M:%S"),
+                                            ),
+                                            _ => Expression::Literal(lit),
+                                        },
+                                        other => other,
+                                    }
+                                }
+
+                                let mut args = f.args;
+                                let format = expand_bigquery_datetime_format(args.remove(0));
+                                let value = args.remove(0);
+                                match target {
+                                    DialectType::DuckDB => {
+                                        let value_with_year = Expression::Concat(Box::new(
+                                            crate::expressions::BinaryOp::new(
+                                                Expression::string("1970 "),
+                                                value,
+                                            ),
+                                        ));
+                                        let format_with_year = Expression::Concat(Box::new(
+                                            crate::expressions::BinaryOp::new(
+                                                Expression::string("%Y "),
+                                                format,
+                                            ),
+                                        ));
+                                        Ok(Expression::Function(Box::new(Function::new(
+                                            "STRPTIME".to_string(),
+                                            vec![value_with_year, format_with_year],
+                                        ))))
+                                    }
+                                    DialectType::Snowflake => {
+                                        Ok(Expression::Function(Box::new(Function::new(
+                                            "PARSE_DATETIME".to_string(),
+                                            vec![value, format],
+                                        ))))
+                                    }
+                                    _ => Ok(Expression::Function(Box::new(Function::new(
+                                        "PARSE_DATETIME".to_string(),
+                                        vec![format, value],
+                                    )))),
+                                }
+                            }
+                            // Presto/Trino ISO-8601 helpers become casts outside Presto-family targets.
+                            "FROM_ISO8601_TIMESTAMP"
+                                if matches!(
+                                    source,
+                                    DialectType::Presto | DialectType::Trino | DialectType::Athena
+                                ) && f.args.len() == 1
+                                    && !matches!(
+                                        target,
+                                        DialectType::Presto
+                                            | DialectType::Trino
+                                            | DialectType::Athena
+                                    ) =>
+                            {
+                                Ok(Expression::Cast(Box::new(crate::expressions::Cast {
+                                    this: f.args.into_iter().next().unwrap(),
+                                    to: DataType::Timestamp {
+                                        precision: None,
+                                        timezone: matches!(
+                                            target,
+                                            DialectType::DuckDB | DialectType::Snowflake
+                                        ),
+                                    },
+                                    trailing_comments: Vec::new(),
+                                    double_colon_syntax: false,
+                                    format: None,
+                                    default: None,
+                                    inferred_type: None,
+                                })))
+                            }
+                            "FROM_ISO8601_DATE"
+                                if matches!(
+                                    source,
+                                    DialectType::Presto | DialectType::Trino | DialectType::Athena
+                                ) && f.args.len() == 1
+                                    && !matches!(
+                                        target,
+                                        DialectType::Presto
+                                            | DialectType::Trino
+                                            | DialectType::Athena
+                                    ) =>
+                            {
+                                Ok(Expression::Cast(Box::new(crate::expressions::Cast {
+                                    this: f.args.into_iter().next().unwrap(),
+                                    to: DataType::Date,
+                                    trailing_comments: Vec::new(),
+                                    double_colon_syntax: false,
+                                    format: None,
+                                    default: None,
+                                    inferred_type: None,
+                                })))
+                            }
                             // MAP(keys_array, vals_array) from Presto (2-arg form) -> target-specific
                             "MAP"
                                 if f.args.len() == 2
@@ -14706,6 +14827,7 @@ impl Dialect {
                                             | DialectType::Spark
                                             | DialectType::Databricks
                                             | DialectType::ClickHouse
+                                            | DialectType::StarRocks
                                     ) =>
                             {
                                 let args = f.args;
@@ -37095,6 +37217,41 @@ impl Dialect {
                 }
             }
 
+            // PARSE_DATETIME(format, str) -> target-specific
+            "PARSE_DATETIME" if args.len() == 2 => {
+                let format = args.remove(0);
+                let str_expr = args.remove(0);
+                let c_format = Self::bq_format_to_duckdb(&format);
+                match target {
+                    DialectType::DuckDB => {
+                        // DuckDB STRPTIME needs a date-bearing format for DATETIME parsing.
+                        let str_with_year = Expression::Concat(Box::new(BinaryOp::new(
+                            Expression::string("1970 "),
+                            str_expr,
+                        )));
+                        let format_with_year = Expression::Concat(Box::new(BinaryOp::new(
+                            Expression::string("%Y "),
+                            c_format,
+                        )));
+                        Ok(Expression::Function(Box::new(Function::new(
+                            "STRPTIME".to_string(),
+                            vec![str_with_year, format_with_year],
+                        ))))
+                    }
+                    DialectType::Snowflake => {
+                        // SQLGlot emits PARSE_DATETIME(value, format) with expanded C-style format tokens.
+                        Ok(Expression::Function(Box::new(Function::new(
+                            "PARSE_DATETIME".to_string(),
+                            vec![str_expr, c_format],
+                        ))))
+                    }
+                    _ => Ok(Expression::Function(Box::new(Function::new(
+                        "PARSE_DATETIME".to_string(),
+                        vec![format, str_expr],
+                    )))),
+                }
+            }
+
             // PARSE_TIMESTAMP(format, str) -> target-specific
             "PARSE_TIMESTAMP" if args.len() >= 2 => {
                 let format = args.remove(0);

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/crates/polyglot-sql/src/dialects/postgres.rs

@@ -319,22 +319,6 @@ impl DialectImpl for PostgresDialect {
                 }
             }
 
-            // ============================================
-            // ARRAY OPERATORS
-            // ============================================
-            // ArrayContainedBy (<@) -> ArrayContainsAll (@>) with swapped operands
-            // a <@ b -> b @> a (PostgreSQL prefers @> syntax)
-            Expression::ArrayContainedBy(op) => {
-                Ok(Expression::ArrayContainsAll(Box::new(BinaryOp {
-                    left: op.right,
-                    right: op.left,
-                    left_comments: Vec::new(),
-                    operator_comments: Vec::new(),
-                    trailing_comments: Vec::new(),
-                    inferred_type: None,
-                })))
-            }
-
             // ============================================
             // REGEXP OPERATIONS (PostgreSQL uses ~ and ~* operators)
             // ============================================

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/crates/polyglot-sql/src/expressions.rs

@@ -8060,17 +8060,20 @@ impl DropTable {
     }
 }
 
-/// UNDROP TABLE/SCHEMA/DATABASE statement (Snowflake, ClickHouse)
+/// UNDROP object statement (Snowflake, ClickHouse)
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]
 pub struct Undrop {
-    /// The object kind: "TABLE", "SCHEMA", or "DATABASE"
+    /// The object kind, e.g. "TABLE", "SCHEMA", "DATABASE", "DYNAMIC TABLE"
     pub kind: String,
     /// The object name
     pub name: TableRef,
     /// IF EXISTS clause
     #[serde(default)]
     pub if_exists: bool,
+    /// Snowflake: optional RENAME TO target
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub rename_to: Option<TableRef>,
 }
 
 /// ALTER TABLE statement

{polyglot_sql-0.5.10 → polyglot_sql-0.5.12}/crates/polyglot-sql/src/generator.rs

@@ -3269,10 +3269,10 @@ impl Generator {
             Expression::JSONBContainsAllTopKeys(op) => self.generate_binary_op(op, "?&"),
             Expression::JSONBContainsAnyTopKeys(op) => self.generate_binary_op(op, "?|"),
             Expression::JSONBContains(f) => {
-                // PostgreSQL JSONB contains key operator: a ? b
+                // PostgreSQL JSONB contains key/path operators: a ? b, a @? b
                 self.generate_expression(&f.this)?;
                 self.write_space();
-                self.write("?");
+                self.write(f.original_name.as_deref().unwrap_or("?"));
                 self.write_space();
                 self.generate_expression(&f.expression)
             }
@@ -3351,6 +3351,17 @@ impl Generator {
             Expression::TryCatch(try_catch) => self.generate_try_catch(try_catch),
             Expression::Command(cmd) => {
                 self.write(&cmd.this);
+                if matches!(self.config.dialect, Some(DialectType::ClickHouse))
+                    && cmd
+                        .this
+                        .trim_start()
+                        .get(..7)
+                        .is_some_and(|prefix| prefix.eq_ignore_ascii_case("EXPLAIN"))
+                {
+                    for _ in 0..Self::missing_closing_parens_outside_quotes(&cmd.this) {
+                        self.write(")");
+                    }
+                }
                 Ok(())
             }
             Expression::Kill(kill) => {
@@ -10394,6 +10405,12 @@ impl Generator {
         }
         self.write_space();
         self.generate_table(&u.name)?;
+        if let Some(rename_to) = &u.rename_to {
+            self.write_space();
+            self.write_keyword("RENAME TO");
+            self.write_space();
+            self.generate_table(rename_to)?;
+        }
         Ok(())
     }
 
@@ -12817,7 +12834,7 @@ impl Generator {
                 }
                 self.write_keyword("RETURNS");
                 self.write_space();
-                self.generate_data_type(return_type)?;
+                self.generate_function_return_type(return_type)?;
             }
         } else {
             // RETURNS first (default)
@@ -12851,7 +12868,7 @@ impl Generator {
                     if is_table_return {
                         self.write_keyword("TABLE");
                     } else {
-                        self.generate_data_type(return_type)?;
+                        self.generate_function_return_type(return_type)?;
                     }
                 }
             }
@@ -12864,6 +12881,10 @@ impl Generator {
                 self.config.dialect,
                 Some(crate::dialects::DialectType::BigQuery)
             );
+            let is_postgres = matches!(
+                self.config.dialect,
+                Some(crate::dialects::DialectType::PostgreSQL)
+            );
             let property_order = if is_bigquery {
                 // Move Options before As if both are present
                 let mut reordered = Vec::new();
@@ -12891,6 +12912,18 @@ impl Generator {
                 } else {
                     cf.property_order.clone()
                 }
+            } else if is_postgres
+                && cf.property_order.contains(&FunctionPropertyKind::As)
+                && cf.property_order.contains(&FunctionPropertyKind::NullInput)
+            {
+                let mut reordered: Vec<_> = cf
+                    .property_order
+                    .iter()
+                    .copied()
+                    .filter(|prop| *prop != FunctionPropertyKind::As)
+                    .collect();
+                reordered.push(FunctionPropertyKind::As);
+                reordered
             } else {
                 cf.property_order.clone()
             };
@@ -13120,6 +13153,22 @@ impl Generator {
         Ok(())
     }
 
+    fn generate_function_return_type(&mut self, return_type: &DataType) -> Result<()> {
+        if matches!(
+            self.config.dialect,
+            Some(crate::dialects::DialectType::PostgreSQL)
+        ) {
+            if let DataType::Custom { name } = return_type {
+                if name.eq_ignore_ascii_case("integer") {
+                    self.write_keyword("INT");
+                    return Ok(());
+                }
+            }
+        }
+
+        self.generate_data_type(return_type)
+    }
+
     /// Generate SET options for CREATE FUNCTION
     fn generate_function_set_options(&mut self, cf: &CreateFunction) -> Result<()> {
         for opt in &cf.set_options {
@@ -17585,7 +17634,13 @@ impl Generator {
 
     fn generate_function(&mut self, func: &Function) -> Result<()> {
         // Normalize function name based on dialect settings
-        let normalized_name = self.normalize_func_name(&func.name);
+        let normalized_name = if matches!(self.config.dialect, Some(DialectType::Snowflake))
+            && func.name.to_ascii_uppercase().starts_with("IDENTIFIER(")
+        {
+            Cow::Borrowed(func.name.as_str())
+        } else {
+            self.normalize_func_name(&func.name)
+        };
 
         // DuckDB: ARRAY_CONSTRUCT_COMPACT(a, b, c) -> LIST_FILTER([a, b, c], _u -> NOT _u IS NULL)
         if matches!(self.config.dialect, Some(DialectType::DuckDB))
@@ -17924,7 +17979,7 @@ impl Generator {
         {
             self.write_keyword("DATEPART");
             self.write("(");
-            self.generate_expression(&func.args[0])?;
+            self.write_tsql_date_part(&func.args[0])?;
             self.write(", ");
             self.generate_expression(&func.args[1])?;
             self.write(")");
@@ -18888,6 +18943,22 @@ impl Generator {
         }
     }
 
+    fn write_tsql_date_part(&mut self, expr: &Expression) -> Result<()> {
+        if let Some(part) = self.extract_date_part_string(expr) {
+            let upper = part.to_ascii_uppercase();
+            let unmapped = match upper.as_str() {
+                "DAYOFWEEK" => "WEEKDAY",
+                "WEEKISO" => "ISO_WEEK",
+                "TIMEZONE_MINUTE" => "TZOFFSET",
+                _ => part.as_str(),
+            };
+            self.write_keyword(unmapped);
+        } else {
+            self.generate_expression(expr)?;
+        }
+        Ok(())
+    }
+
     /// Extract date part string from expression (handles string literals and identifiers)
     fn extract_date_part_string(&self, expr: &Expression) -> Option<String> {
         match expr {
@@ -22591,6 +22662,36 @@ impl Generator {
         }
     }
 
+    fn missing_closing_parens_outside_quotes(sql: &str) -> usize {
+        let mut depth = 0usize;
+        let mut quote: Option<char> = None;
+        let mut chars = sql.chars().peekable();
+
+        while let Some(ch) = chars.next() {
+            if let Some(quote_char) = quote {
+                if ch == '\\' {
+                    chars.next();
+                } else if ch == quote_char {
+                    if quote_char == '\'' && chars.peek() == Some(&'\'') {
+                        chars.next();
+                    } else {
+                        quote = None;
+                    }
+                }
+                continue;
+            }
+
+            match ch {
+                '\'' | '"' | '`' => quote = Some(ch),
+                '(' => depth += 1,
+                ')' => depth = depth.saturating_sub(1),
+                _ => {}
+            }
+        }
+
+        depth
+    }
+
     /// Generate LIKE/ILIKE operation with optional ESCAPE clause
     fn generate_like_op(&mut self, op: &LikeOp, operator: &str) -> Result<()> {
         self.generate_like_op_inner(op, operator, false)
@@ -22615,6 +22716,51 @@ impl Generator {
             return self.generate_like_op_inner(op, operator, false);
         }
 
+        if matches!(self.config.dialect, Some(DialectType::ClickHouse)) {
+            if let Expression::Star(star) = &op.left {
+                if star
+                    .except
+                    .as_ref()
+                    .is_some_and(|except| !except.is_empty())
+                {
+                    if let Some(table) = &star.table {
+                        self.generate_identifier(table)?;
+                        self.write(".");
+                    }
+                    self.write("*");
+                    self.write_space();
+                    self.write_keyword(operator);
+                    if let Some(quantifier) = &op.quantifier {
+                        self.write_space();
+                        self.write_keyword(quantifier);
+                        self.write_space();
+                    } else {
+                        self.write_space();
+                    }
+                    self.generate_expression(&op.right)?;
+                    if let Some(escape) = &op.escape {
+                        self.write_space();
+                        self.write_keyword("ESCAPE");
+                        self.write_space();
+                        self.generate_expression(escape)?;
+                    }
+                    if let Some(except) = &star.except {
+                        self.write_space();
+                        self.write_keyword("EXCEPT");
+                        self.write(" (");
+                        for (i, col) in except.iter().enumerate() {
+                            if i > 0 {
+                                self.write(", ");
+                            }
+                            self.generate_identifier(col)?;
+                        }
+                        self.write(")");
+                    }
+                    return Ok(());
+                }
+            }
+        }
+
         self.generate_expression(&op.left)?;
         self.write_space();
         if negated {