fuzz test and refactor

fmt:

cleanup

Author: Pavan-Nambi

core/translate/alter.rs

@@ -2571,133 +2571,55 @@ pub fn walk_upsert_for_table_rename(
 ///
 /// `old_table_norm`: Normalized (lowercase) name of the table being renamed.
 /// `new_table_name`: New name for the table (will be double-quoted in output).
+///
+/// This function uses `walk_expr_mut` from `expr.rs` to traverse all expression
+/// variants automatically, including WINDOW clauses and frame bounds. Only the
+/// special cases (table-qualified names) are handled in the callback.
 pub fn rewrite_expr_table_refs_for_rename(
     expr: &mut Box<ast::Expr>,
     old_table_norm: &str,
     new_table_name: &str,
 ) -> bool {
     let mut changed = false;
 
-    match expr.as_mut() {
-        ast::Expr::Qualified(ref mut tbl_name, _) => {
-            if normalize_ident(tbl_name.as_str()) == old_table_norm {
-                // Wrap new name in double quotes to handle special characters/keywords
-                *tbl_name = ast::Name::from_string(format!("\"{new_table_name}\""));
-                changed = true;
-            }
-        }
-
-        ast::Expr::DoublyQualified(_, ref mut tbl_name, _) => {
-            if normalize_ident(tbl_name.as_str()) == old_table_norm {
-                *tbl_name = ast::Name::from_string(format!("\"{new_table_name}\""));
-                changed = true;
-            }
-        }
-        ast::Expr::Between {
-            lhs, start, end, ..
-        } => {
-            changed |= rewrite_expr_table_refs_for_rename(lhs, old_table_norm, new_table_name);
-            changed |= rewrite_expr_table_refs_for_rename(start, old_table_norm, new_table_name);
-            changed |= rewrite_expr_table_refs_for_rename(end, old_table_norm, new_table_name);
-        }
-        ast::Expr::Binary(lhs, _, rhs) => {
-            changed |= rewrite_expr_table_refs_for_rename(lhs, old_table_norm, new_table_name);
-            changed |= rewrite_expr_table_refs_for_rename(rhs, old_table_norm, new_table_name);
-        }
-        ast::Expr::Case {
-            base,
-            when_then_pairs,
-            else_expr,
-            ..
-        } => {
-            if let Some(b) = base {
-                changed |= rewrite_expr_table_refs_for_rename(b, old_table_norm, new_table_name);
-            }
-            for (when_expr, then_expr) in when_then_pairs {
-                changed |=
-                    rewrite_expr_table_refs_for_rename(when_expr, old_table_norm, new_table_name);
-                changed |=
-                    rewrite_expr_table_refs_for_rename(then_expr, old_table_norm, new_table_name);
+    // Use walk_expr_mut to traverse ALL expression types automatically.
+    // This handles WINDOW clauses, frame bounds, and all other nested expressions.
+    let _ = walk_expr_mut(expr, &mut |e: &mut ast::Expr| -> Result<WalkControl> {
+        match e {
+            // Handle table-qualified column references: tbl.col -> "new_tbl".col
+            ast::Expr::Qualified(ref mut tbl_name, _) => {
+                if normalize_ident(tbl_name.as_str()) == old_table_norm {
+                    *tbl_name = ast::Name::from_string(format!("\"{new_table_name}\""));
+                    changed = true;
+                }
             }
-            if let Some(else_e) = else_expr {
-                changed |=
-                    rewrite_expr_table_refs_for_rename(else_e, old_table_norm, new_table_name);
+            // Handle doubly-qualified references: db.tbl.col -> db."new_tbl".col
+            ast::Expr::DoublyQualified(_, ref mut tbl_name, _) => {
+                if normalize_ident(tbl_name.as_str()) == old_table_norm {
+                    *tbl_name = ast::Name::from_string(format!("\"{new_table_name}\""));
+                    changed = true;
+                }
             }
-        }
-        ast::Expr::Cast { expr: inner, .. } => {
-            changed |= rewrite_expr_table_refs_for_rename(inner, old_table_norm, new_table_name);
-        }
-        ast::Expr::Collate(inner, _) => {
-            changed |= rewrite_expr_table_refs_for_rename(inner, old_table_norm, new_table_name);
-        }
-        ast::Expr::FunctionCall {
-            args, filter_over, ..
-        } => {
-            for arg in args {
-                changed |= rewrite_expr_table_refs_for_rename(arg, old_table_norm, new_table_name);
+            // Handle `x IN tbl` - the table reference is not a sub-expression
+            ast::Expr::InTable { rhs, .. } => {
+                if normalize_ident(rhs.name.as_str()) == old_table_norm {
+                    rhs.name = ast::Name::from_string(format!("\"{new_table_name}\""));
+                    changed = true;
+                }
             }
-            if let Some(ref mut filter_expr) = filter_over.filter_clause {
+            // Handle subqueries - walk_expr_mut doesn't descend into SELECT statements
+            ast::Expr::InSelect { rhs, .. } => {
                 changed |=
-                    rewrite_expr_table_refs_for_rename(filter_expr, old_table_norm, new_table_name);
+                    rewrite_select_table_refs_for_rename(rhs, old_table_norm, new_table_name);
             }
-        }
-        ast::Expr::FunctionCallStar { filter_over, .. } => {
-            if let Some(ref mut filter_expr) = filter_over.filter_clause {
+            ast::Expr::Subquery(select) | ast::Expr::Exists(select) => {
                 changed |=
-                    rewrite_expr_table_refs_for_rename(filter_expr, old_table_norm, new_table_name);
-            }
-        }
-        ast::Expr::InList { lhs, rhs, .. } => {
-            changed |= rewrite_expr_table_refs_for_rename(lhs, old_table_norm, new_table_name);
-            for item in rhs {
-                changed |= rewrite_expr_table_refs_for_rename(item, old_table_norm, new_table_name);
+                    rewrite_select_table_refs_for_rename(select, old_table_norm, new_table_name);
             }
+            _ => {}
         }
-        ast::Expr::InSelect { lhs, rhs, .. } => {
-            changed |= rewrite_expr_table_refs_for_rename(lhs, old_table_norm, new_table_name);
-            changed |= rewrite_select_table_refs_for_rename(rhs, old_table_norm, new_table_name);
-        }
-        ast::Expr::InTable { lhs, rhs, .. } => {
-            changed |= rewrite_expr_table_refs_for_rename(lhs, old_table_norm, new_table_name);
-            // `x IN tbl` - the table reference is not qualified, rewrite directly
-            if normalize_ident(rhs.name.as_str()) == old_table_norm {
-                rhs.name = ast::Name::from_string(format!("\"{new_table_name}\""));
-                changed = true;
-            }
-        }
-        ast::Expr::IsNull(inner) | ast::Expr::NotNull(inner) => {
-            changed |= rewrite_expr_table_refs_for_rename(inner, old_table_norm, new_table_name);
-        }
-        ast::Expr::Like {
-            lhs, rhs, escape, ..
-        } => {
-            changed |= rewrite_expr_table_refs_for_rename(lhs, old_table_norm, new_table_name);
-            changed |= rewrite_expr_table_refs_for_rename(rhs, old_table_norm, new_table_name);
-            if let Some(ref mut esc) = escape {
-                changed |= rewrite_expr_table_refs_for_rename(esc, old_table_norm, new_table_name);
-            }
-        }
-        ast::Expr::Parenthesized(inner) => {
-            for e in inner {
-                changed |= rewrite_expr_table_refs_for_rename(e, old_table_norm, new_table_name);
-            }
-        }
-        ast::Expr::Subquery(select) | ast::Expr::Exists(select) => {
-            changed |= rewrite_select_table_refs_for_rename(select, old_table_norm, new_table_name);
-        }
-        ast::Expr::Unary(_, inner) => {
-            changed |= rewrite_expr_table_refs_for_rename(inner, old_table_norm, new_table_name);
-        }
-        ast::Expr::Id(_)
-        | ast::Expr::Literal(_)
-        | ast::Expr::Name(_)
-        | ast::Expr::Variable(_)
-        | ast::Expr::Raise(_, _)
-        | ast::Expr::Register(_)
-        | ast::Expr::Column { .. }
-        | ast::Expr::RowId { .. }
-        | ast::Expr::SubqueryResult { .. } => {}
-    }
+        Ok(WalkControl::Continue)
+    });
 
     changed
 }