polyglot-sql 0.3.9__tar.gz → 0.3.11__tar.gz

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/Cargo.lock

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

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/Cargo.toml

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

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/PKG-INFO

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

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/crates/polyglot-sql/Cargo.toml

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

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/ast_transforms.rs

@@ -159,12 +159,61 @@ pub fn rename_columns(expr: Expression, mapping: &HashMap<String, String>) -> Ex
     })
 }
 
+/// Options for table renaming.
+#[derive(Debug, Clone)]
+pub struct RenameTablesOptions {
+    /// Whether renamed table references should receive aliases.
+    pub alias_renamed_tables: bool,
+    /// Whether existing aliases should be preserved when aliasing renamed tables.
+    pub preserve_existing_aliases: bool,
+}
+
+impl Default for RenameTablesOptions {
+    fn default() -> Self {
+        Self {
+            alias_renamed_tables: false,
+            preserve_existing_aliases: true,
+        }
+    }
+}
+
+impl RenameTablesOptions {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_alias_renamed_tables(mut self, alias: bool) -> Self {
+        self.alias_renamed_tables = alias;
+        self
+    }
+
+    pub fn with_preserve_existing_aliases(mut self, preserve: bool) -> Self {
+        self.preserve_existing_aliases = preserve;
+        self
+    }
+}
+
 /// Rename tables throughout the expression tree using the provided mapping.
 pub fn rename_tables(expr: Expression, mapping: &HashMap<String, String>) -> Expression {
+    rename_tables_with_options(expr, mapping, &RenameTablesOptions::default())
+}
+
+/// Rename tables throughout the expression tree using the provided mapping and options.
+pub fn rename_tables_with_options(
+    expr: Expression,
+    mapping: &HashMap<String, String>,
+    options: &RenameTablesOptions,
+) -> Expression {
     xform(expr, |node| match node {
         Expression::Table(mut tbl) => {
             if let Some(new_name) = mapping.get(&tbl.name.name) {
                 tbl.name.name = new_name.clone();
+                if options.alias_renamed_tables
+                    && (!options.preserve_existing_aliases || tbl.alias.is_none())
+                {
+                    tbl.alias = Some(Identifier::new(new_name));
+                    tbl.alias_explicit_as = true;
+                }
             }
             Expression::Table(tbl)
         }
@@ -701,6 +750,30 @@ mod tests {
         assert!(sql.contains("new_table"), "Expected new_table in: {}", sql);
     }
 
+    #[test]
+    fn test_rename_tables_with_alias_renamed_tables() {
+        let expr = parse_one("SELECT a FROM old_table");
+        let mut mapping = HashMap::new();
+        mapping.insert("old_table".to_string(), "new_table".to_string());
+        let options = RenameTablesOptions::new().with_alias_renamed_tables(true);
+        let result = rename_tables_with_options(expr, &mapping, &options);
+        let sql = result.sql();
+
+        assert_eq!(sql, "SELECT a FROM new_table AS new_table");
+    }
+
+    #[test]
+    fn test_rename_tables_with_alias_preserves_existing_alias() {
+        let expr = parse_one("SELECT a FROM old_table AS t");
+        let mut mapping = HashMap::new();
+        mapping.insert("old_table".to_string(), "new_table".to_string());
+        let options = RenameTablesOptions::new().with_alias_renamed_tables(true);
+        let result = rename_tables_with_options(expr, &mapping, &options);
+        let sql = result.sql();
+
+        assert_eq!(sql, "SELECT a FROM new_table AS t");
+    }
+
     #[test]
     fn test_set_distinct() {
         let expr = parse_one("SELECT a FROM t");

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/dialects/fabric.rs

@@ -371,6 +371,7 @@ impl FabricDialect {
                 // Parse out precision and scale if present: "TYPENAME(n)" or "TYPENAME(n, m)"
                 let (base_name, precision, scale) =
                     TSQLDialect::parse_type_precision_and_scale(&upper);
+                let has_max_length = upper.contains("(MAX)");
 
                 match base_name.as_str() {
                     // DATETIME -> DATETIME2(6)
@@ -445,7 +446,11 @@ impl FabricDialect {
 
                     // NCHAR -> CHAR (with length preserved)
                     "NCHAR" => {
-                        if let Some(len) = precision {
+                        if has_max_length {
+                            DataType::Custom {
+                                name: "CHAR(MAX)".to_string(),
+                            }
+                        } else if let Some(len) = precision {
                             DataType::Custom {
                                 name: format!("CHAR({})", len),
                             }
@@ -458,7 +463,11 @@ impl FabricDialect {
 
                     // NVARCHAR -> VARCHAR (with length preserved)
                     "NVARCHAR" => {
-                        if let Some(len) = precision {
+                        if has_max_length {
+                            DataType::Custom {
+                                name: "VARCHAR(MAX)".to_string(),
+                            }
+                        } else if let Some(len) = precision {
                             DataType::Custom {
                                 name: format!("VARCHAR({})", len),
                             }

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/dialects/mod.rs

@@ -8285,15 +8285,21 @@ impl Dialect {
                         if matches!(target, DialectType::MySQL) && o.nulls_first.is_some() {
                             Action::MysqlNullsOrdering
                         } else {
-                            // Skip targets that don't support NULLS FIRST/LAST syntax
+                            // Skip targets that don't support NULLS FIRST/LAST syntax unless
+                            // the generator can preserve semantics with a CASE sort key.
+                            let target_rewrites_nulls =
+                                matches!(target, DialectType::TSQL | DialectType::Fabric);
                             let target_supports_nulls = !matches!(
                                 target,
                                 DialectType::MySQL
                                     | DialectType::TSQL
+                                    | DialectType::Fabric
                                     | DialectType::StarRocks
                                     | DialectType::Doris
                             );
-                            if o.nulls_first.is_none() && source != target && target_supports_nulls
+                            if o.nulls_first.is_none()
+                                && source != target
+                                && (target_supports_nulls || target_rewrites_nulls)
                             {
                                 Action::NullsOrdering
                             } else {

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/generator.rs

@@ -4803,7 +4803,10 @@ impl Generator {
                 } else {
                     self.write_space();
                 }
-                if matches!(self.config.dialect, Some(DialectType::TSQL)) {
+                if matches!(
+                    self.config.dialect,
+                    Some(DialectType::TSQL) | Some(DialectType::Fabric)
+                ) {
                     // SQL Server 2012+ OFFSET ... FETCH syntax
                     self.write_keyword("OFFSET");
                     self.write_space();
@@ -23212,6 +23215,36 @@ impl Generator {
     }
 
     fn generate_ordered(&mut self, ordered: &Ordered) -> Result<()> {
+        let unsupported_tsql_null_ordering = ordered.nulls_first.is_some()
+            && !self.config.null_ordering_supported
+            && matches!(
+                self.config.dialect,
+                Some(DialectType::TSQL) | Some(DialectType::Fabric)
+            );
+        let random_ordering = matches!(ordered.this, Expression::Rand(_) | Expression::Random(_));
+        let emulate_tsql_null_ordering = if let Some(nulls_first) = ordered.nulls_first {
+            let target_default_nulls_first = !ordered.desc;
+
+            unsupported_tsql_null_ordering
+                && nulls_first != target_default_nulls_first
+                && !random_ordering
+        } else {
+            false
+        };
+
+        if emulate_tsql_null_ordering {
+            self.write_keyword("CASE WHEN");
+            self.write_space();
+            self.generate_expression(&ordered.this)?;
+            self.write_space();
+            self.write_keyword("IS NULL THEN 1 ELSE 0 END");
+            if ordered.nulls_first == Some(true) {
+                self.write_space();
+                self.write_keyword("DESC");
+            }
+            self.write(", ");
+        }
+
         self.generate_expression(&ordered.this)?;
         if ordered.desc {
             self.write_space();
@@ -23221,8 +23254,9 @@ impl Generator {
             self.write_keyword("ASC");
         }
         if let Some(nulls_first) = ordered.nulls_first {
-            if self.config.null_ordering_supported
-                || !matches!(self.config.dialect, Some(DialectType::Fabric))
+            if !unsupported_tsql_null_ordering
+                && (self.config.null_ordering_supported
+                    || !matches!(self.config.dialect, Some(DialectType::Fabric)))
             {
                 // Determine if we should skip outputting NULLS FIRST/LAST when it's the default
                 // for the dialect. Different dialects have different NULL ordering defaults:
@@ -23995,6 +24029,12 @@ impl Generator {
             } => {
                 // Dialect-specific timestamp type mappings
                 match self.config.dialect {
+                    Some(DialectType::Snowflake) if *timezone => {
+                        self.write_keyword("TIMESTAMPTZ");
+                        if let Some(p) = precision {
+                            self.write(&format!("({})", p));
+                        }
+                    }
                     Some(DialectType::ClickHouse) => {
                         self.write("DateTime");
                         if let Some(p) = precision {
@@ -24563,6 +24603,52 @@ impl Generator {
                         // MySQL doesn't support TIMESTAMPTZ/TIMESTAMPLTZ, use TIMESTAMP
                         self.write_keyword("TIMESTAMP");
                     }
+                    Some(DialectType::Snowflake) => {
+                        let (base_upper, suffix) = if let Some(idx) = name.find('(') {
+                            (name_upper[..idx].to_string(), &name[idx..])
+                        } else {
+                            (name_upper.clone(), "")
+                        };
+
+                        match base_upper.as_str() {
+                            "TIMESTAMPNTZ" | "TIMESTAMP_NTZ" => {
+                                self.write_keyword("TIMESTAMPNTZ");
+                                self.write(suffix);
+                            }
+                            "TIMESTAMPLTZ" | "TIMESTAMP_LTZ" => {
+                                self.write_keyword("TIMESTAMPLTZ");
+                                self.write(suffix);
+                            }
+                            "TIMESTAMPTZ" | "TIMESTAMP_TZ" => {
+                                self.write_keyword("TIMESTAMPTZ");
+                                self.write(suffix);
+                            }
+                            _ => self.write(name),
+                        }
+                    }
+                    Some(DialectType::Fabric) => {
+                        let (base_upper, args_str) = if let Some(idx) = name.find('(') {
+                            (name_upper[..idx].to_string(), Some(&name[idx..]))
+                        } else {
+                            (name_upper.clone(), None)
+                        };
+
+                        match base_upper.as_str() {
+                            "NVARCHAR" => {
+                                self.write_keyword("VARCHAR");
+                                if let Some(args) = args_str {
+                                    self.write(args);
+                                }
+                            }
+                            "NCHAR" => {
+                                self.write_keyword("CHAR");
+                                if let Some(args) = args_str {
+                                    self.write(args);
+                                }
+                            }
+                            _ => self.write(name),
+                        }
+                    }
                     Some(DialectType::TSQL) if name_upper == "VARIANT" => {
                         self.write_keyword("SQL_VARIANT");
                     }

{polyglot_sql-0.3.9 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/lib.rs

@@ -42,8 +42,8 @@ pub use ast_transforms::{
     add_select_columns, add_where, get_aggregate_functions, get_column_names, get_functions,
     get_identifiers, get_literals, get_output_column_names, get_subqueries, get_table_names,
     get_window_functions, node_count, qualify_columns, remove_limit_offset, remove_nodes,
-    remove_select_columns, remove_where, rename_columns, rename_tables, replace_by_type,
-    replace_nodes, set_distinct, set_limit, set_offset,
+    remove_select_columns, remove_where, rename_columns, rename_tables, rename_tables_with_options,
+    replace_by_type, replace_nodes, set_distinct, set_limit, set_offset, RenameTablesOptions,
 };
 pub use dialects::{
     unregister_custom_dialect, CustomDialectBuilder, Dialect, DialectType, TranspileOptions,
@@ -59,7 +59,9 @@ pub use helper::{
     csv, find_new_name, is_date_unit, is_float, is_int, is_iso_date, is_iso_datetime, merge_ranges,
     name_sequence, seq_get, split_num_words, tsort, while_changing, DATE_UNITS,
 };
-pub use optimizer::{annotate_types, TypeAnnotator, TypeCoercionClass};
+pub use optimizer::{
+    annotate_types, qualify_tables, QualifyTablesOptions, TypeAnnotator, TypeCoercionClass,
+};
 pub use parser::Parser;
 pub use resolver::{is_column_ambiguous, resolve_column, Resolver, ResolverError, ResolverResult};
 pub use schema::{