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

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

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

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

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

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

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

{polyglot_sql-0.3.7 → polyglot_sql-0.3.9}/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.9", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.7 → polyglot_sql-0.3.9}/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)
         }
 
@@ -32060,7 +32248,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 +36920,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.9}/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.9}/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(())
@@ -14109,6 +14110,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 +18581,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(),

{polyglot_sql-0.3.7 → polyglot_sql-0.3.9}/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);
             }

{polyglot_sql-0.3.7 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/parser.rs

@@ -21032,66 +21032,17 @@ impl Parser {
 
         if !is_transaction {
             // TSQL: BEGIN TRY ... END TRY [BEGIN CATCH ... END CATCH]
-            // These are block-structured constructs that may contain semicolons,
-            // so we can't use parse_command() which stops at the first semicolon.
-            let is_try = self.check_identifier("TRY");
-            let is_catch = self.check_identifier("CATCH");
-            if is_try || is_catch {
-                let block_kind = if is_try { "TRY" } else { "CATCH" };
-                self.skip(); // consume TRY or CATCH
-                let mut tokens: Vec<(String, TokenType)> = vec![
-                    ("BEGIN".to_string(), TokenType::Begin),
-                    (block_kind.to_string(), TokenType::Var),
-                ];
-                // Collect tokens until matching END TRY / END CATCH
-                while !self.is_at_end() {
-                    if self.check(TokenType::End)
-                        && self.current + 1 < self.tokens.len()
-                        && self.tokens[self.current + 1]
-                            .text
-                            .eq_ignore_ascii_case(block_kind)
-                    {
-                        tokens.push(("END".to_string(), TokenType::End));
-                        self.skip(); // consume END
-                        tokens.push((block_kind.to_string(), TokenType::Var));
-                        self.skip(); // consume TRY/CATCH
-                        break;
-                    }
-                    let token = self.advance();
-                    let text = if token.token_type == TokenType::String {
-                        format!("'{}'", token.text)
-                    } else if token.token_type == TokenType::QuotedIdentifier {
-                        format!("\"{}\"", token.text)
-                    } else {
-                        token.text.clone()
-                    };
-                    tokens.push((text, token.token_type));
-                }
-                let mut result = Expression::Command(Box::new(Command {
-                    this: self.join_command_tokens(tokens),
-                }));
-
-                // If this was a TRY block, check for a following BEGIN CATCH block
-                if is_try
-                    && self.check(TokenType::Begin)
-                    && self.current + 1 < self.tokens.len()
-                    && self.tokens[self.current + 1]
-                        .text
-                        .eq_ignore_ascii_case("CATCH")
-                {
-                    // Recursively parse the BEGIN CATCH block
-                    let catch_block = self.parse_transaction()?;
-                    // Combine TRY and CATCH into a single command
-                    if let (Expression::Command(try_cmd), Expression::Command(catch_cmd)) =
-                        (&result, &catch_block)
-                    {
-                        result = Expression::Command(Box::new(Command {
-                            this: format!("{} {}", try_cmd.this, catch_cmd.this),
-                        }));
-                    }
-                }
-
-                return Ok(result);
+            // Parse bodies into statement nodes so traversal can see table refs.
+            if self.check_identifier("TRY") {
+                return self.parse_tsql_try_catch();
+            }
+            if self.check_identifier("CATCH") {
+                self.skip(); // consume CATCH
+                let catch_body = self.parse_tsql_block_body("CATCH")?;
+                return Ok(Expression::TryCatch(Box::new(TryCatch {
+                    try_body: Vec::new(),
+                    catch_body: Some(catch_body),
+                })));
             }
 
             // This is a procedural BEGIN block - parse as Command
@@ -21190,6 +21141,79 @@ impl Parser {
         })))
     }
 
+    fn parse_tsql_try_catch(&mut self) -> Result<Expression> {
+        self.skip(); // consume TRY
+        let try_body = self.parse_tsql_block_body("TRY")?;
+        let catch_body = if self.check(TokenType::Begin)
+            && self.current + 1 < self.tokens.len()
+            && self.tokens[self.current + 1]
+                .text
+                .eq_ignore_ascii_case("CATCH")
+        {
+            self.skip(); // consume BEGIN
+            self.skip(); // consume CATCH
+            Some(self.parse_tsql_block_body("CATCH")?)
+        } else {
+            None
+        };
+
+        Ok(Expression::TryCatch(Box::new(TryCatch {
+            try_body,
+            catch_body,
+        })))
+    }
+
+    fn parse_tsql_block_body(&mut self, block_kind: &str) -> Result<Vec<Expression>> {
+        let tokens = self.collect_tsql_block_body_tokens(block_kind)?;
+        if tokens.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let mut parser = Parser::with_config(tokens, self.config.clone());
+        parser.parse()
+    }
+
+    fn collect_tsql_block_body_tokens(&mut self, block_kind: &str) -> Result<Vec<Token>> {
+        let mut tokens = Vec::new();
+        let mut depth = 1usize;
+
+        while !self.is_at_end() {
+            if self.check(TokenType::Begin)
+                && self.current + 1 < self.tokens.len()
+                && self.tokens[self.current + 1]
+                    .text
+                    .eq_ignore_ascii_case(block_kind)
+            {
+                depth += 1;
+                tokens.push(self.advance());
+                tokens.push(self.advance());
+                continue;
+            }
+
+            if self.check(TokenType::End)
+                && self.current + 1 < self.tokens.len()
+                && self.tokens[self.current + 1]
+                    .text
+                    .eq_ignore_ascii_case(block_kind)
+            {
+                depth -= 1;
+                if depth == 0 {
+                    self.skip(); // consume END
+                    self.skip(); // consume TRY/CATCH
+                    return Ok(tokens);
+                }
+
+                tokens.push(self.advance());
+                tokens.push(self.advance());
+                continue;
+            }
+
+            tokens.push(self.advance());
+        }
+
+        Err(self.parse_error(format!("Expected END {}", block_kind)))
+    }
+
     /// Parse START TRANSACTION statement
     /// START TRANSACTION [READ ONLY | READ WRITE] [, ISOLATION LEVEL ...]
     fn parse_start_transaction(&mut self) -> Result<Expression> {
@@ -47359,12 +47383,10 @@ impl Parser {
             } else {
                 break;
             }
-            // Accept comma (TSQL/BigQuery) or semicolon (Snowflake scripting) as separator
-            if self.match_token(TokenType::Comma) || self.match_token(TokenType::Semicolon) {
-                // Stop if next token is BEGIN (end of DECLARE block)
-                if self.check(TokenType::Begin) {
-                    break;
-                }
+            // Accept comma-separated DECLARE items. Statement-level semicolons
+            // are consumed by the top-level parser so batches like
+            // `DECLARE @x INT; SELECT @x` keep their statement boundary.
+            if self.match_token(TokenType::Comma) {
                 continue;
             }
             break;

{polyglot_sql-0.3.7 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/scope.rs

@@ -1001,6 +1001,16 @@ impl<'a> WalkInScopeIter<'a> {
                 // Tables don't have child expressions to traverse within scope
                 // (joins are handled at the Select level)
             }
+            Expression::TryCatch(try_catch) => {
+                for stmt in &try_catch.try_body {
+                    children.push(stmt);
+                }
+                if let Some(catch_body) = &try_catch.catch_body {
+                    for stmt in catch_body {
+                        children.push(stmt);
+                    }
+                }
+            }
             Expression::Column(_) | Expression::Literal(_) | Expression::Identifier(_) => {
                 // Leaf nodes - no children
             }

{polyglot_sql-0.3.7 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/traversal.rs

@@ -746,6 +746,12 @@ fn iter_children_lists(expr: &Expression) -> Vec<(&'static str, &[Expression])>
         Expression::Tuple(t) => {
             lists.push(("expressions", t.expressions.as_slice()));
         }
+        Expression::TryCatch(try_catch) => {
+            lists.push(("try_body", try_catch.try_body.as_slice()));
+            if let Some(catch_body) = &try_catch.catch_body {
+                lists.push(("catch_body", catch_body.as_slice()));
+            }
+        }
         // Values.expressions is Vec<Tuple>, handle specially
         Expression::Coalesce(c) => {
             lists.push(("expressions", c.expressions.as_slice()));