polyglot-sql 0.3.7__tar.gz → 0.3.10__tar.gz

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/Cargo.lock

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

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/Cargo.toml

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

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/PKG-INFO

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

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

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/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.7 → polyglot_sql-0.3.10}/crates/polyglot-sql/src/dialects/mod.rs

@@ -158,7 +158,10 @@ pub use trino::TrinoDialect;
 pub use tsql::TSQLDialect;
 
 use crate::error::Result;
-use crate::expressions::{Expression, Function, FunctionBody, Identifier, Null};
+use crate::expressions::{
+    Expression, From, Function, FunctionBody, Identifier, Join, Null, OrderBy, OutputClause,
+    TableRef, With,
+};
 use crate::generator::{Generator, GeneratorConfig};
 use crate::parser::Parser;
 use crate::tokens::{Token, TokenType, Tokenizer, TokenizerConfig};
@@ -1661,6 +1664,122 @@ where
     }
 }
 
+fn transform_table_ref_recursive<F>(table: TableRef, transform_fn: &F) -> Result<TableRef>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    match transform_recursive(Expression::Table(Box::new(table)), transform_fn)? {
+        Expression::Table(table) => Ok(*table),
+        _ => Err(crate::error::Error::parse(
+            "TableRef transformation returned non-table expression",
+            0,
+            0,
+            0,
+            0,
+        )),
+    }
+}
+
+fn transform_from_recursive<F>(from: From, transform_fn: &F) -> Result<From>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    match transform_recursive(Expression::From(Box::new(from)), transform_fn)? {
+        Expression::From(from) => Ok(*from),
+        _ => Err(crate::error::Error::parse(
+            "FROM transformation returned non-FROM expression",
+            0,
+            0,
+            0,
+            0,
+        )),
+    }
+}
+
+fn transform_join_recursive<F>(mut join: Join, transform_fn: &F) -> Result<Join>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    join.this = transform_recursive(join.this, transform_fn)?;
+    if let Some(on) = join.on.take() {
+        join.on = Some(transform_recursive(on, transform_fn)?);
+    }
+    if let Some(match_condition) = join.match_condition.take() {
+        join.match_condition = Some(transform_recursive(match_condition, transform_fn)?);
+    }
+    join.pivots = join
+        .pivots
+        .into_iter()
+        .map(|pivot| transform_recursive(pivot, transform_fn))
+        .collect::<Result<Vec<_>>>()?;
+
+    match transform_fn(Expression::Join(Box::new(join)))? {
+        Expression::Join(join) => Ok(*join),
+        _ => Err(crate::error::Error::parse(
+            "Join transformation returned non-join expression",
+            0,
+            0,
+            0,
+            0,
+        )),
+    }
+}
+
+fn transform_output_clause_recursive<F>(
+    mut output: OutputClause,
+    transform_fn: &F,
+) -> Result<OutputClause>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    output.columns = output
+        .columns
+        .into_iter()
+        .map(|column| transform_recursive(column, transform_fn))
+        .collect::<Result<Vec<_>>>()?;
+    if let Some(into_table) = output.into_table.take() {
+        output.into_table = Some(transform_recursive(into_table, transform_fn)?);
+    }
+    Ok(output)
+}
+
+fn transform_with_recursive<F>(mut with: With, transform_fn: &F) -> Result<With>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    with.ctes = with
+        .ctes
+        .into_iter()
+        .map(|mut cte| {
+            cte.this = transform_recursive(cte.this, transform_fn)?;
+            Ok(cte)
+        })
+        .collect::<Result<Vec<_>>>()?;
+    if let Some(search) = with.search.take() {
+        with.search = Some(Box::new(transform_recursive(*search, transform_fn)?));
+    }
+    Ok(with)
+}
+
+fn transform_order_by_recursive<F>(mut order: OrderBy, transform_fn: &F) -> Result<OrderBy>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    order.expressions = order
+        .expressions
+        .into_iter()
+        .map(|mut ordered| {
+            let original = ordered.this.clone();
+            ordered.this = transform_recursive(ordered.this, transform_fn).unwrap_or(original);
+            match transform_fn(Expression::Ordered(Box::new(ordered.clone()))) {
+                Ok(Expression::Ordered(transformed)) => Ok(*transformed),
+                Ok(_) | Err(_) => Ok(ordered),
+            }
+        })
+        .collect::<Result<Vec<_>>>()?;
+    Ok(order)
+}
+
 fn transform_recursive_reference<F>(expr: Expression, transform_fn: &F) -> Result<Expression>
 where
     F: Fn(Expression) -> Result<Expression>,
@@ -2377,6 +2496,17 @@ where
             Expression::Insert(ins)
         }
         Expression::Update(mut upd) => {
+            upd.table = transform_table_ref_recursive(upd.table, transform_fn)?;
+            upd.extra_tables = upd
+                .extra_tables
+                .into_iter()
+                .map(|table| transform_table_ref_recursive(table, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            upd.table_joins = upd
+                .table_joins
+                .into_iter()
+                .map(|join| transform_join_recursive(join, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             upd.set = upd
                 .set
                 .into_iter()
@@ -2385,17 +2515,75 @@ where
                     (id, new_val)
                 })
                 .collect();
+            if let Some(from_clause) = upd.from_clause.take() {
+                upd.from_clause = Some(transform_from_recursive(from_clause, transform_fn)?);
+            }
+            upd.from_joins = upd
+                .from_joins
+                .into_iter()
+                .map(|join| transform_join_recursive(join, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             if let Some(mut where_clause) = upd.where_clause.take() {
                 where_clause.this = transform_recursive(where_clause.this, transform_fn)?;
                 upd.where_clause = Some(where_clause);
             }
+            upd.returning = upd
+                .returning
+                .into_iter()
+                .map(|expr| transform_recursive(expr, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            if let Some(output) = upd.output.take() {
+                upd.output = Some(transform_output_clause_recursive(output, transform_fn)?);
+            }
+            if let Some(with) = upd.with.take() {
+                upd.with = Some(transform_with_recursive(with, transform_fn)?);
+            }
+            if let Some(limit) = upd.limit.take() {
+                upd.limit = Some(transform_recursive(limit, transform_fn)?);
+            }
+            if let Some(order_by) = upd.order_by.take() {
+                upd.order_by = Some(transform_order_by_recursive(order_by, transform_fn)?);
+            }
             Expression::Update(upd)
         }
         Expression::Delete(mut del) => {
+            del.table = transform_table_ref_recursive(del.table, transform_fn)?;
+            del.using = del
+                .using
+                .into_iter()
+                .map(|table| transform_table_ref_recursive(table, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             if let Some(mut where_clause) = del.where_clause.take() {
                 where_clause.this = transform_recursive(where_clause.this, transform_fn)?;
                 del.where_clause = Some(where_clause);
             }
+            if let Some(output) = del.output.take() {
+                del.output = Some(transform_output_clause_recursive(output, transform_fn)?);
+            }
+            if let Some(with) = del.with.take() {
+                del.with = Some(transform_with_recursive(with, transform_fn)?);
+            }
+            if let Some(limit) = del.limit.take() {
+                del.limit = Some(transform_recursive(limit, transform_fn)?);
+            }
+            if let Some(order_by) = del.order_by.take() {
+                del.order_by = Some(transform_order_by_recursive(order_by, transform_fn)?);
+            }
+            del.returning = del
+                .returning
+                .into_iter()
+                .map(|expr| transform_recursive(expr, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            del.tables = del
+                .tables
+                .into_iter()
+                .map(|table| transform_table_ref_recursive(table, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            del.joins = del
+                .joins
+                .into_iter()
+                .map(|join| transform_join_recursive(join, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             Expression::Delete(del)
         }
 
@@ -8097,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 {
@@ -32060,7 +32254,7 @@ impl Dialect {
             match unit.trim().to_ascii_uppercase().as_str() {
                 "YEAR" | "YEARS" => Some(IntervalUnit::Year),
                 "QUARTER" | "QUARTERS" => Some(IntervalUnit::Quarter),
-                "MONTH" | "MONTHS" => Some(IntervalUnit::Month),
+                "MONTH" | "MONTHS" | "MON" | "MONS" | "MM" => Some(IntervalUnit::Month),
                 "WEEK" | "WEEKS" | "ISOWEEK" => Some(IntervalUnit::Week),
                 "DAY" | "DAYS" => Some(IntervalUnit::Day),
                 "HOUR" | "HOURS" => Some(IntervalUnit::Hour),
@@ -36732,7 +36926,9 @@ impl Dialect {
         match s {
             "YEAR" | "YY" | "YYYY" => crate::expressions::IntervalUnit::Year,
             "QUARTER" | "QQ" | "Q" => crate::expressions::IntervalUnit::Quarter,
-            "MONTH" | "MM" | "M" => crate::expressions::IntervalUnit::Month,
+            "MONTH" | "MONTHS" | "MON" | "MONS" | "MM" | "M" => {
+                crate::expressions::IntervalUnit::Month
+            }
             "WEEK" | "WK" | "WW" | "ISOWEEK" => crate::expressions::IntervalUnit::Week,
             "DAY" | "DD" | "D" | "DY" => crate::expressions::IntervalUnit::Day,
             "HOUR" | "HH" => crate::expressions::IntervalUnit::Hour,

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/crates/polyglot-sql/src/expressions.rs

@@ -114,6 +114,7 @@ pub enum Expression {
     Copy(Box<CopyStmt>),
     Put(Box<PutStmt>),
     StageReference(Box<StageReference>),
+    TryCatch(Box<TryCatch>),
 
     // Expressions
     Alias(Box<Alias>),
@@ -1146,6 +1147,7 @@ impl Expression {
             | Expression::Copy(_)
             | Expression::Put(_)
             | Expression::Merge(_)
+            | Expression::TryCatch(_)
 
             // DDL
             | Expression::CreateTable(_)
@@ -2229,6 +2231,7 @@ impl Expression {
             Expression::Describe(_) => "describe",
             Expression::Show(_) => "show",
             Expression::Command(_) => "command",
+            Expression::TryCatch(_) => "try_catch",
             Expression::Kill(_) => "kill",
             Expression::Execute(_) => "execute",
             Expression::Raw(_) => "raw",
@@ -6003,6 +6006,18 @@ pub struct Command {
     pub this: String,
 }
 
+/// T-SQL TRY/CATCH block.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "bindings", derive(TS))]
+pub struct TryCatch {
+    /// Statements inside BEGIN TRY ... END TRY.
+    #[serde(default)]
+    pub try_body: Vec<Expression>,
+    /// Statements inside BEGIN CATCH ... END CATCH, when present.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catch_body: Option<Vec<Expression>>,
+}
+
 /// EXEC/EXECUTE statement (TSQL stored procedure call)
 /// Syntax: EXEC [schema.]procedure_name [@param=value, ...]
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/crates/polyglot-sql/src/generator.rs

@@ -3342,6 +3342,7 @@ impl Generator {
                 Ok(())
             }
             Expression::CreateTask(task) => self.generate_create_task(task),
+            Expression::TryCatch(try_catch) => self.generate_try_catch(try_catch),
             Expression::Command(cmd) => {
                 self.write(&cmd.this);
                 Ok(())
@@ -4802,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();
@@ -14109,6 +14113,58 @@ impl Generator {
         Ok(())
     }
 
+    fn generate_try_catch(&mut self, try_catch: &TryCatch) -> Result<()> {
+        self.write_keyword("BEGIN TRY");
+        self.generate_tsql_block_statements(&try_catch.try_body)?;
+        self.write_keyword("END TRY");
+
+        if let Some(catch_body) = &try_catch.catch_body {
+            if self.config.pretty {
+                self.write_newline();
+                self.write_indent();
+            } else {
+                self.write_space();
+            }
+            self.write_keyword("BEGIN CATCH");
+            self.generate_tsql_block_statements(catch_body)?;
+            self.write_keyword("END CATCH");
+        }
+
+        Ok(())
+    }
+
+    fn generate_tsql_block_statements(&mut self, statements: &[Expression]) -> Result<()> {
+        if statements.is_empty() {
+            self.write_space();
+            return Ok(());
+        }
+
+        if self.config.pretty {
+            self.indent_level += 1;
+            for stmt in statements {
+                self.write_newline();
+                self.write_indent();
+                self.generate_expression(stmt)?;
+                self.write(";");
+            }
+            self.indent_level -= 1;
+            self.write_newline();
+            self.write_indent();
+        } else {
+            self.write_space();
+            for (i, stmt) in statements.iter().enumerate() {
+                if i > 0 {
+                    self.write_space();
+                }
+                self.generate_expression(stmt)?;
+                self.write(";");
+            }
+            self.write_space();
+        }
+
+        Ok(())
+    }
+
     fn generate_drop_type(&mut self, dt: &DropType) -> Result<()> {
         self.write_keyword("DROP TYPE");
 
@@ -18528,7 +18584,7 @@ impl Generator {
         };
         match lower {
             "day" | "days" | "d" => "DAY".to_string(),
-            "month" | "months" | "mon" | "mm" => "MONTH".to_string(),
+            "month" | "months" | "mon" | "mons" | "mm" => "MONTH".to_string(),
             "year" | "years" | "y" | "yy" | "yyyy" => "YEAR".to_string(),
             "week" | "weeks" | "w" | "wk" => "WEEK".to_string(),
             "hour" | "hours" | "h" | "hh" => "HOUR".to_string(),
@@ -23159,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();
@@ -23168,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:

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/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::{

{polyglot_sql-0.3.7 → polyglot_sql-0.3.10}/crates/polyglot-sql/src/lineage.rs

@@ -1658,6 +1658,16 @@ fn collect_column_refs(expr: &Expression, refs: &mut Vec<SimpleColumnRef>) {
             Expression::NamedArgument(n) => {
                 stack.push(&n.value);
             }
+            Expression::TryCatch(t) => {
+                for stmt in &t.try_body {
+                    stack.push(stmt);
+                }
+                if let Some(catch_body) = &t.catch_body {
+                    for stmt in catch_body {
+                        stack.push(stmt);
+                    }
+                }
+            }
             Expression::BracedWildcard(e) | Expression::ReturnStmt(e) => {
                 stack.push(e);
             }