toasty_core/stmt/
visit.rs

1#![allow(unused_variables)]
2
3use super::{
4    Assignment, Assignments, Association, Condition, Cte, Delete, Expr, ExprAllOp, ExprAnd,
5    ExprAny, ExprAnyOp, ExprArg, ExprBetween, ExprBinaryOp, ExprCast, ExprColumn, ExprError,
6    ExprExists, ExprFunc, ExprInList, ExprInSubquery, ExprIntersects, ExprIsNull, ExprIsSuperset,
7    ExprIsVariant, ExprLength, ExprLet, ExprLike, ExprList, ExprMap, ExprMatch, ExprNot, ExprOr,
8    ExprProject, ExprRecord, ExprReference, ExprSet, ExprSetOp, ExprStartsWith, ExprStmt, Filter,
9    FuncCount, FuncLastInsertId, Insert, InsertTarget, Join, JoinOp, Limit, LimitCursor,
10    LimitOffset, Node, OrderBy, OrderByExpr, Path, Projection, Query, Returning, Select, Source,
11    SourceModel, SourceTable, SourceTableId, Statement, TableDerived, TableFactor, TableRef,
12    TableWithJoins, Type, Update, UpdateTarget, Value, ValueRecord, Values, With,
13};
14
15/// Immutable visitor trait for the statement AST.
16///
17/// Implement this trait to walk the AST without modifying it. Each
18/// `visit_*` method has a default implementation that recurses into
19/// child nodes via the corresponding free function (e.g.,
20/// [`visit_expr`]). Override specific methods to inspect nodes of
21/// interest.
22///
23/// The companion [`for_each_expr`] helper visits every expression node
24/// in post-order.
25///
26/// # Examples
27///
28/// ```ignore
29/// use toasty_core::stmt::{visit, Expr, Value, Node};
30///
31/// let expr = Expr::from(Value::from(42_i64));
32/// let mut count = 0;
33/// visit::for_each_expr(&expr, |_| count += 1);
34/// assert_eq!(count, 1);
35/// ```
36pub trait Visit {
37    /// Dispatches to the appropriate `visit_*` method via [`Node::visit`].
38    fn visit<N: Node>(&mut self, i: &N)
39    where
40        Self: Sized,
41    {
42        i.visit(self);
43    }
44
45    /// Visits an [`Assignment`] node.
46    ///
47    /// The default implementation delegates to [`visit_assignment`].
48    fn visit_assignment(&mut self, i: &Assignment) {
49        visit_assignment(self, i);
50    }
51
52    /// Visits an [`Assignments`] node.
53    ///
54    /// The default implementation delegates to [`visit_assignments`].
55    fn visit_assignments(&mut self, i: &Assignments) {
56        visit_assignments(self, i);
57    }
58
59    /// Visits an [`Association`] node.
60    ///
61    /// The default implementation delegates to [`visit_association`].
62    fn visit_association(&mut self, i: &Association) {
63        visit_association(self, i);
64    }
65
66    /// Visits a [`Cte`] (common table expression) node.
67    ///
68    /// The default implementation delegates to [`visit_cte`].
69    fn visit_cte(&mut self, i: &Cte) {
70        visit_cte(self, i);
71    }
72
73    /// Visits an [`Expr`] node.
74    ///
75    /// The default implementation delegates to [`visit_expr`].
76    fn visit_expr(&mut self, i: &Expr) {
77        visit_expr(self, i);
78    }
79
80    /// Visits an [`ExprAnd`] node.
81    ///
82    /// The default implementation delegates to [`visit_expr_and`].
83    fn visit_expr_and(&mut self, i: &ExprAnd) {
84        visit_expr_and(self, i);
85    }
86
87    /// Visits an [`ExprAny`] node.
88    ///
89    /// The default implementation delegates to [`visit_expr_any`].
90    fn visit_expr_any(&mut self, i: &ExprAny) {
91        visit_expr_any(self, i);
92    }
93
94    /// Visits an [`ExprArg`] node.
95    ///
96    /// The default implementation delegates to [`visit_expr_arg`].
97    fn visit_expr_arg(&mut self, i: &ExprArg) {
98        visit_expr_arg(self, i);
99    }
100
101    /// Visits an [`ExprAnyOp`] node.
102    ///
103    /// The default implementation delegates to [`visit_expr_any_op`].
104    fn visit_expr_any_op(&mut self, i: &ExprAnyOp) {
105        visit_expr_any_op(self, i);
106    }
107
108    /// Visits an [`ExprAllOp`] node.
109    ///
110    /// The default implementation delegates to [`visit_expr_all_op`].
111    fn visit_expr_all_op(&mut self, i: &ExprAllOp) {
112        visit_expr_all_op(self, i);
113    }
114
115    /// Visits an [`ExprBetween`] node.
116    ///
117    /// The default implementation delegates to [`visit_expr_between`].
118    fn visit_expr_between(&mut self, i: &ExprBetween) {
119        visit_expr_between(self, i);
120    }
121
122    /// Visits an [`ExprBinaryOp`] node.
123    ///
124    /// The default implementation delegates to [`visit_expr_binary_op`].
125    fn visit_expr_binary_op(&mut self, i: &ExprBinaryOp) {
126        visit_expr_binary_op(self, i);
127    }
128
129    /// Visits an [`ExprCast`] node.
130    ///
131    /// The default implementation delegates to [`visit_expr_cast`].
132    fn visit_expr_cast(&mut self, i: &ExprCast) {
133        visit_expr_cast(self, i);
134    }
135
136    /// Visits an [`ExprColumn`] node.
137    ///
138    /// The default implementation delegates to [`visit_expr_column`].
139    fn visit_expr_column(&mut self, i: &ExprColumn) {
140        visit_expr_column(self, i);
141    }
142
143    /// Visits a default expression (no associated data).
144    ///
145    /// The default implementation delegates to [`visit_expr_default`].
146    fn visit_expr_default(&mut self) {
147        visit_expr_default(self);
148    }
149
150    /// Visits an [`ExprError`] node.
151    ///
152    /// The default implementation delegates to [`visit_expr_error`].
153    fn visit_expr_error(&mut self, i: &ExprError) {
154        visit_expr_error(self, i);
155    }
156
157    /// Visits an [`ExprExists`] node.
158    ///
159    /// The default implementation delegates to [`visit_expr_exists`].
160    fn visit_expr_exists(&mut self, i: &ExprExists) {
161        visit_expr_exists(self, i);
162    }
163
164    /// Visits an [`ExprFunc`] node.
165    ///
166    /// The default implementation delegates to [`visit_expr_func`].
167    fn visit_expr_func(&mut self, i: &ExprFunc) {
168        visit_expr_func(self, i);
169    }
170
171    /// Visits a [`FuncCount`] node.
172    ///
173    /// The default implementation delegates to [`visit_expr_func_count`].
174    fn visit_expr_func_count(&mut self, i: &FuncCount) {
175        visit_expr_func_count(self, i);
176    }
177
178    /// Visits a [`FuncLastInsertId`] node.
179    ///
180    /// The default implementation delegates to [`visit_expr_func_last_insert_id`].
181    fn visit_expr_func_last_insert_id(&mut self, i: &FuncLastInsertId) {
182        visit_expr_func_last_insert_id(self, i);
183    }
184
185    /// Visits an [`ExprInList`] node.
186    ///
187    /// The default implementation delegates to [`visit_expr_in_list`].
188    fn visit_expr_in_list(&mut self, i: &ExprInList) {
189        visit_expr_in_list(self, i);
190    }
191
192    /// Visits an [`ExprInSubquery`] node.
193    ///
194    /// The default implementation delegates to [`visit_expr_in_subquery`].
195    fn visit_expr_in_subquery(&mut self, i: &ExprInSubquery) {
196        visit_expr_in_subquery(self, i);
197    }
198
199    /// Visits an [`ExprIntersects`] node.
200    ///
201    /// The default implementation delegates to [`visit_expr_intersects`].
202    fn visit_expr_intersects(&mut self, i: &ExprIntersects) {
203        visit_expr_intersects(self, i);
204    }
205
206    /// Visits an [`ExprIsNull`] node.
207    ///
208    /// The default implementation delegates to [`visit_expr_is_null`].
209    fn visit_expr_is_null(&mut self, i: &ExprIsNull) {
210        visit_expr_is_null(self, i);
211    }
212
213    /// Visits an [`ExprIsSuperset`] node.
214    ///
215    /// The default implementation delegates to [`visit_expr_is_superset`].
216    fn visit_expr_is_superset(&mut self, i: &ExprIsSuperset) {
217        visit_expr_is_superset(self, i);
218    }
219
220    /// Visits an [`ExprIsVariant`] node.
221    ///
222    /// The default implementation delegates to [`visit_expr_is_variant`].
223    fn visit_expr_is_variant(&mut self, i: &ExprIsVariant) {
224        visit_expr_is_variant(self, i);
225    }
226
227    /// Visits an [`ExprLength`] node.
228    ///
229    /// The default implementation delegates to [`visit_expr_length`].
230    fn visit_expr_length(&mut self, i: &ExprLength) {
231        visit_expr_length(self, i);
232    }
233
234    /// Visits an [`ExprLet`] node.
235    ///
236    /// The default implementation delegates to [`visit_expr_let`].
237    fn visit_expr_let(&mut self, i: &ExprLet) {
238        visit_expr_let(self, i);
239    }
240
241    /// Visits an [`ExprLike`] node.
242    ///
243    /// The default implementation delegates to [`visit_expr_like`].
244    fn visit_expr_like(&mut self, i: &ExprLike) {
245        visit_expr_like(self, i);
246    }
247
248    /// Visits an [`ExprMap`] node.
249    ///
250    /// The default implementation delegates to [`visit_expr_map`].
251    fn visit_expr_map(&mut self, i: &ExprMap) {
252        visit_expr_map(self, i);
253    }
254
255    /// Visits an [`ExprMatch`] node.
256    ///
257    /// The default implementation delegates to [`visit_expr_match`].
258    fn visit_expr_match(&mut self, i: &ExprMatch) {
259        visit_expr_match(self, i);
260    }
261
262    /// Visits an [`ExprNot`] node.
263    ///
264    /// The default implementation delegates to [`visit_expr_not`].
265    fn visit_expr_not(&mut self, i: &ExprNot) {
266        visit_expr_not(self, i);
267    }
268
269    /// Visits an [`ExprOr`] node.
270    ///
271    /// The default implementation delegates to [`visit_expr_or`].
272    fn visit_expr_or(&mut self, i: &ExprOr) {
273        visit_expr_or(self, i);
274    }
275
276    /// Visits an [`ExprList`] node.
277    ///
278    /// The default implementation delegates to [`visit_expr_list`].
279    fn visit_expr_list(&mut self, i: &ExprList) {
280        visit_expr_list(self, i);
281    }
282
283    /// Visits an [`ExprRecord`] node.
284    ///
285    /// The default implementation delegates to [`visit_expr_record`].
286    fn visit_expr_record(&mut self, i: &ExprRecord) {
287        visit_expr_record(self, i);
288    }
289
290    /// Visits an [`ExprReference`] node.
291    ///
292    /// The default implementation delegates to [`visit_expr_reference`].
293    fn visit_expr_reference(&mut self, i: &ExprReference) {
294        visit_expr_reference(self, i);
295    }
296
297    /// Visits an [`ExprSet`] node.
298    ///
299    /// The default implementation delegates to [`visit_expr_set`].
300    fn visit_expr_set(&mut self, i: &ExprSet) {
301        visit_expr_set(self, i);
302    }
303
304    /// Visits an [`ExprSetOp`] node.
305    ///
306    /// The default implementation delegates to [`visit_expr_set_op`].
307    fn visit_expr_set_op(&mut self, i: &ExprSetOp) {
308        visit_expr_set_op(self, i);
309    }
310
311    /// Visits an [`ExprStartsWith`] node.
312    ///
313    /// The default implementation delegates to [`visit_expr_starts_with`].
314    fn visit_expr_starts_with(&mut self, i: &ExprStartsWith) {
315        visit_expr_starts_with(self, i);
316    }
317
318    /// Visits an [`ExprStmt`] node.
319    ///
320    /// The default implementation delegates to [`visit_expr_stmt`].
321    fn visit_expr_stmt(&mut self, i: &ExprStmt) {
322        visit_expr_stmt(self, i);
323    }
324
325    /// Visits a [`Filter`] node.
326    ///
327    /// The default implementation delegates to [`visit_filter`].
328    fn visit_filter(&mut self, i: &Filter) {
329        visit_filter(self, i);
330    }
331
332    /// Visits a [`Condition`] node.
333    ///
334    /// The default implementation delegates to [`visit_condition`].
335    fn visit_condition(&mut self, i: &Condition) {
336        visit_condition(self, i);
337    }
338
339    /// Visits an [`ExprProject`] node.
340    ///
341    /// The default implementation delegates to [`visit_expr_project`].
342    fn visit_expr_project(&mut self, i: &ExprProject) {
343        visit_expr_project(self, i);
344    }
345
346    /// Visits an [`InsertTarget`] node.
347    ///
348    /// The default implementation delegates to [`visit_insert_target`].
349    fn visit_insert_target(&mut self, i: &InsertTarget) {
350        visit_insert_target(self, i);
351    }
352
353    /// Visits a [`Join`] node.
354    ///
355    /// The default implementation delegates to [`visit_join`].
356    fn visit_join(&mut self, i: &Join) {
357        visit_join(self, i);
358    }
359
360    /// Visits a [`Limit`] node.
361    ///
362    /// The default implementation delegates to [`visit_limit`].
363    fn visit_limit(&mut self, i: &Limit) {
364        visit_limit(self, i);
365    }
366
367    /// Visits a [`LimitCursor`] node.
368    ///
369    /// The default implementation delegates to [`visit_limit_cursor`].
370    fn visit_limit_cursor(&mut self, i: &LimitCursor) {
371        visit_limit_cursor(self, i);
372    }
373
374    /// Visits a [`LimitOffset`] node.
375    ///
376    /// The default implementation delegates to [`visit_limit_offset`].
377    fn visit_limit_offset(&mut self, i: &LimitOffset) {
378        visit_limit_offset(self, i);
379    }
380
381    /// Visits an [`OrderBy`] node.
382    ///
383    /// The default implementation delegates to [`visit_order_by`].
384    fn visit_order_by(&mut self, i: &OrderBy) {
385        visit_order_by(self, i);
386    }
387
388    /// Visits an [`OrderByExpr`] node.
389    ///
390    /// The default implementation delegates to [`visit_order_by_expr`].
391    fn visit_order_by_expr(&mut self, i: &OrderByExpr) {
392        visit_order_by_expr(self, i);
393    }
394
395    /// Visits a [`Path`] node.
396    ///
397    /// The default implementation delegates to [`visit_path`].
398    fn visit_path(&mut self, i: &Path) {
399        visit_path(self, i);
400    }
401
402    /// Visits a [`Projection`] node.
403    ///
404    /// The default implementation delegates to [`visit_projection`].
405    fn visit_projection(&mut self, i: &Projection) {
406        visit_projection(self, i);
407    }
408
409    /// Visits a [`Returning`] node.
410    ///
411    /// The default implementation delegates to [`visit_returning`].
412    fn visit_returning(&mut self, i: &Returning) {
413        visit_returning(self, i);
414    }
415
416    /// Visits a [`Source`] node.
417    ///
418    /// The default implementation delegates to [`visit_source`].
419    fn visit_source(&mut self, i: &Source) {
420        visit_source(self, i);
421    }
422
423    /// Visits a [`SourceModel`] node.
424    ///
425    /// The default implementation delegates to [`visit_source_model`].
426    fn visit_source_model(&mut self, i: &SourceModel) {
427        visit_source_model(self, i);
428    }
429
430    /// Visits a [`SourceTable`] node.
431    ///
432    /// The default implementation delegates to [`visit_source_table`].
433    fn visit_source_table(&mut self, i: &SourceTable) {
434        visit_source_table(self, i);
435    }
436
437    /// Visits a [`SourceTableId`] node.
438    ///
439    /// The default implementation delegates to [`visit_source_table_id`].
440    fn visit_source_table_id(&mut self, i: &SourceTableId) {
441        visit_source_table_id(self, i);
442    }
443
444    /// Visits a [`Statement`] node.
445    ///
446    /// The default implementation delegates to [`visit_stmt`].
447    fn visit_stmt(&mut self, i: &Statement) {
448        visit_stmt(self, i);
449    }
450
451    /// Visits a [`Delete`] statement node.
452    ///
453    /// The default implementation delegates to [`visit_stmt_delete`].
454    fn visit_stmt_delete(&mut self, i: &Delete) {
455        visit_stmt_delete(self, i);
456    }
457
458    /// Visits an [`Insert`] statement node.
459    ///
460    /// The default implementation delegates to [`visit_stmt_insert`].
461    fn visit_stmt_insert(&mut self, i: &Insert) {
462        visit_stmt_insert(self, i);
463    }
464
465    /// Visits a [`Query`] statement node.
466    ///
467    /// The default implementation delegates to [`visit_stmt_query`].
468    fn visit_stmt_query(&mut self, i: &Query) {
469        visit_stmt_query(self, i);
470    }
471
472    /// Visits a [`Select`] statement node.
473    ///
474    /// The default implementation delegates to [`visit_stmt_select`].
475    fn visit_stmt_select(&mut self, i: &Select) {
476        visit_stmt_select(self, i);
477    }
478
479    /// Visits an [`Update`] statement node.
480    ///
481    /// The default implementation delegates to [`visit_stmt_update`].
482    fn visit_stmt_update(&mut self, i: &Update) {
483        visit_stmt_update(self, i);
484    }
485
486    /// Visits a [`TableDerived`] node.
487    ///
488    /// The default implementation delegates to [`visit_table_derived`].
489    fn visit_table_derived(&mut self, i: &TableDerived) {
490        visit_table_derived(self, i);
491    }
492
493    /// Visits a [`TableRef`] node.
494    ///
495    /// The default implementation delegates to [`visit_table_ref`].
496    fn visit_table_ref(&mut self, i: &TableRef) {
497        visit_table_ref(self, i);
498    }
499
500    /// Visits a [`TableFactor`] node.
501    ///
502    /// The default implementation delegates to [`visit_table_factor`].
503    fn visit_table_factor(&mut self, i: &TableFactor) {
504        visit_table_factor(self, i);
505    }
506
507    /// Visits a [`TableWithJoins`] node.
508    ///
509    /// The default implementation delegates to [`visit_table_with_joins`].
510    fn visit_table_with_joins(&mut self, i: &TableWithJoins) {
511        visit_table_with_joins(self, i);
512    }
513
514    /// Visits a [`Type`] node.
515    ///
516    /// The default implementation delegates to [`visit_type`].
517    fn visit_type(&mut self, i: &Type) {
518        visit_type(self, i);
519    }
520
521    /// Visits an [`UpdateTarget`] node.
522    ///
523    /// The default implementation delegates to [`visit_update_target`].
524    fn visit_update_target(&mut self, i: &UpdateTarget) {
525        visit_update_target(self, i);
526    }
527
528    /// Visits a [`Value`] node.
529    ///
530    /// The default implementation delegates to [`visit_value`].
531    fn visit_value(&mut self, i: &Value) {
532        visit_value(self, i);
533    }
534
535    /// Visits a [`ValueRecord`] node.
536    ///
537    /// The default implementation delegates to [`visit_value_record`].
538    fn visit_value_record(&mut self, i: &ValueRecord) {
539        visit_value_record(self, i);
540    }
541
542    /// Visits a [`Values`] node.
543    ///
544    /// The default implementation delegates to [`visit_values`].
545    fn visit_values(&mut self, i: &Values) {
546        visit_values(self, i);
547    }
548
549    /// Visits a [`With`] node.
550    ///
551    /// The default implementation delegates to [`visit_with`].
552    fn visit_with(&mut self, i: &With) {
553        visit_with(self, i);
554    }
555}
556
557impl<V: Visit> Visit for &mut V {
558    fn visit_assignment(&mut self, i: &Assignment) {
559        Visit::visit_assignment(&mut **self, i);
560    }
561
562    fn visit_assignments(&mut self, i: &Assignments) {
563        Visit::visit_assignments(&mut **self, i);
564    }
565
566    fn visit_association(&mut self, i: &Association) {
567        Visit::visit_association(&mut **self, i);
568    }
569
570    fn visit_cte(&mut self, i: &Cte) {
571        Visit::visit_cte(&mut **self, i);
572    }
573
574    fn visit_expr(&mut self, i: &Expr) {
575        Visit::visit_expr(&mut **self, i);
576    }
577
578    fn visit_expr_and(&mut self, i: &ExprAnd) {
579        Visit::visit_expr_and(&mut **self, i);
580    }
581
582    fn visit_expr_arg(&mut self, i: &ExprArg) {
583        Visit::visit_expr_arg(&mut **self, i);
584    }
585
586    fn visit_expr_any_op(&mut self, i: &ExprAnyOp) {
587        Visit::visit_expr_any_op(&mut **self, i);
588    }
589
590    fn visit_expr_all_op(&mut self, i: &ExprAllOp) {
591        Visit::visit_expr_all_op(&mut **self, i);
592    }
593
594    fn visit_expr_between(&mut self, i: &ExprBetween) {
595        Visit::visit_expr_between(&mut **self, i);
596    }
597
598    fn visit_expr_binary_op(&mut self, i: &ExprBinaryOp) {
599        Visit::visit_expr_binary_op(&mut **self, i);
600    }
601
602    fn visit_expr_cast(&mut self, i: &ExprCast) {
603        Visit::visit_expr_cast(&mut **self, i);
604    }
605
606    fn visit_expr_column(&mut self, i: &ExprColumn) {
607        Visit::visit_expr_column(&mut **self, i);
608    }
609
610    fn visit_expr_default(&mut self) {
611        Visit::visit_expr_default(&mut **self);
612    }
613
614    fn visit_expr_error(&mut self, i: &ExprError) {
615        Visit::visit_expr_error(&mut **self, i);
616    }
617
618    fn visit_expr_exists(&mut self, i: &ExprExists) {
619        Visit::visit_expr_exists(&mut **self, i);
620    }
621
622    fn visit_expr_func(&mut self, i: &ExprFunc) {
623        Visit::visit_expr_func(&mut **self, i);
624    }
625
626    fn visit_expr_func_count(&mut self, i: &FuncCount) {
627        Visit::visit_expr_func_count(&mut **self, i);
628    }
629
630    fn visit_expr_in_list(&mut self, i: &ExprInList) {
631        Visit::visit_expr_in_list(&mut **self, i);
632    }
633
634    fn visit_expr_in_subquery(&mut self, i: &ExprInSubquery) {
635        Visit::visit_expr_in_subquery(&mut **self, i);
636    }
637
638    fn visit_expr_intersects(&mut self, i: &ExprIntersects) {
639        Visit::visit_expr_intersects(&mut **self, i);
640    }
641
642    fn visit_expr_is_null(&mut self, i: &ExprIsNull) {
643        Visit::visit_expr_is_null(&mut **self, i);
644    }
645
646    fn visit_expr_is_superset(&mut self, i: &ExprIsSuperset) {
647        Visit::visit_expr_is_superset(&mut **self, i);
648    }
649
650    fn visit_expr_is_variant(&mut self, i: &ExprIsVariant) {
651        Visit::visit_expr_is_variant(&mut **self, i);
652    }
653
654    fn visit_expr_length(&mut self, i: &ExprLength) {
655        Visit::visit_expr_length(&mut **self, i);
656    }
657
658    fn visit_expr_let(&mut self, i: &ExprLet) {
659        Visit::visit_expr_let(&mut **self, i);
660    }
661
662    fn visit_expr_like(&mut self, i: &ExprLike) {
663        Visit::visit_expr_like(&mut **self, i);
664    }
665
666    fn visit_expr_map(&mut self, i: &ExprMap) {
667        Visit::visit_expr_map(&mut **self, i);
668    }
669
670    fn visit_expr_match(&mut self, i: &ExprMatch) {
671        Visit::visit_expr_match(&mut **self, i);
672    }
673
674    fn visit_expr_not(&mut self, i: &ExprNot) {
675        Visit::visit_expr_not(&mut **self, i);
676    }
677
678    fn visit_expr_or(&mut self, i: &ExprOr) {
679        Visit::visit_expr_or(&mut **self, i);
680    }
681
682    fn visit_expr_list(&mut self, i: &ExprList) {
683        Visit::visit_expr_list(&mut **self, i);
684    }
685
686    fn visit_expr_record(&mut self, i: &ExprRecord) {
687        Visit::visit_expr_record(&mut **self, i);
688    }
689
690    fn visit_expr_reference(&mut self, i: &ExprReference) {
691        Visit::visit_expr_reference(&mut **self, i);
692    }
693
694    fn visit_expr_set(&mut self, i: &ExprSet) {
695        Visit::visit_expr_set(&mut **self, i);
696    }
697
698    fn visit_expr_set_op(&mut self, i: &ExprSetOp) {
699        Visit::visit_expr_set_op(&mut **self, i);
700    }
701
702    fn visit_expr_starts_with(&mut self, i: &ExprStartsWith) {
703        Visit::visit_expr_starts_with(&mut **self, i);
704    }
705
706    fn visit_expr_stmt(&mut self, i: &ExprStmt) {
707        Visit::visit_expr_stmt(&mut **self, i);
708    }
709
710    fn visit_filter(&mut self, i: &Filter) {
711        Visit::visit_filter(&mut **self, i);
712    }
713
714    fn visit_condition(&mut self, i: &Condition) {
715        Visit::visit_condition(&mut **self, i);
716    }
717
718    fn visit_expr_project(&mut self, i: &ExprProject) {
719        Visit::visit_expr_project(&mut **self, i);
720    }
721
722    fn visit_insert_target(&mut self, i: &InsertTarget) {
723        Visit::visit_insert_target(&mut **self, i);
724    }
725
726    fn visit_join(&mut self, i: &Join) {
727        Visit::visit_join(&mut **self, i);
728    }
729
730    fn visit_limit(&mut self, i: &Limit) {
731        Visit::visit_limit(&mut **self, i);
732    }
733
734    fn visit_limit_cursor(&mut self, i: &LimitCursor) {
735        Visit::visit_limit_cursor(&mut **self, i);
736    }
737
738    fn visit_limit_offset(&mut self, i: &LimitOffset) {
739        Visit::visit_limit_offset(&mut **self, i);
740    }
741
742    fn visit_order_by(&mut self, i: &OrderBy) {
743        Visit::visit_order_by(&mut **self, i);
744    }
745
746    fn visit_order_by_expr(&mut self, i: &OrderByExpr) {
747        Visit::visit_order_by_expr(&mut **self, i);
748    }
749
750    fn visit_path(&mut self, i: &Path) {
751        Visit::visit_path(&mut **self, i);
752    }
753
754    fn visit_projection(&mut self, i: &Projection) {
755        Visit::visit_projection(&mut **self, i);
756    }
757
758    fn visit_returning(&mut self, i: &Returning) {
759        Visit::visit_returning(&mut **self, i);
760    }
761
762    fn visit_source(&mut self, i: &Source) {
763        Visit::visit_source(&mut **self, i);
764    }
765
766    fn visit_source_model(&mut self, i: &SourceModel) {
767        Visit::visit_source_model(&mut **self, i);
768    }
769
770    fn visit_source_table(&mut self, i: &SourceTable) {
771        Visit::visit_source_table(&mut **self, i);
772    }
773
774    fn visit_source_table_id(&mut self, i: &SourceTableId) {
775        Visit::visit_source_table_id(&mut **self, i);
776    }
777
778    fn visit_stmt(&mut self, i: &Statement) {
779        Visit::visit_stmt(&mut **self, i);
780    }
781
782    fn visit_stmt_delete(&mut self, i: &Delete) {
783        Visit::visit_stmt_delete(&mut **self, i);
784    }
785
786    fn visit_stmt_insert(&mut self, i: &Insert) {
787        Visit::visit_stmt_insert(&mut **self, i);
788    }
789
790    fn visit_stmt_query(&mut self, i: &Query) {
791        Visit::visit_stmt_query(&mut **self, i);
792    }
793
794    fn visit_stmt_select(&mut self, i: &Select) {
795        Visit::visit_stmt_select(&mut **self, i);
796    }
797
798    fn visit_stmt_update(&mut self, i: &Update) {
799        Visit::visit_stmt_update(&mut **self, i);
800    }
801
802    fn visit_table_derived(&mut self, i: &TableDerived) {
803        Visit::visit_table_derived(&mut **self, i);
804    }
805
806    fn visit_table_ref(&mut self, i: &TableRef) {
807        Visit::visit_table_ref(&mut **self, i);
808    }
809
810    fn visit_table_factor(&mut self, i: &TableFactor) {
811        Visit::visit_table_factor(&mut **self, i);
812    }
813
814    fn visit_table_with_joins(&mut self, i: &TableWithJoins) {
815        Visit::visit_table_with_joins(&mut **self, i);
816    }
817
818    fn visit_type(&mut self, i: &Type) {
819        Visit::visit_type(&mut **self, i);
820    }
821
822    fn visit_update_target(&mut self, i: &UpdateTarget) {
823        Visit::visit_update_target(&mut **self, i);
824    }
825
826    fn visit_value(&mut self, i: &Value) {
827        Visit::visit_value(&mut **self, i);
828    }
829
830    fn visit_value_record(&mut self, i: &ValueRecord) {
831        Visit::visit_value_record(&mut **self, i);
832    }
833
834    fn visit_values(&mut self, i: &Values) {
835        Visit::visit_values(&mut **self, i);
836    }
837
838    fn visit_with(&mut self, i: &With) {
839        Visit::visit_with(&mut **self, i);
840    }
841}
842
843/// Default traversal for [`Assignment`] nodes. Visits the assignment's expression(s).
844pub fn visit_assignment<V>(v: &mut V, node: &Assignment)
845where
846    V: Visit + ?Sized,
847{
848    match node {
849        Assignment::Set(expr)
850        | Assignment::Insert(expr)
851        | Assignment::Remove(expr)
852        | Assignment::Append(expr)
853        | Assignment::RemoveAt(expr)
854        | Assignment::Add(expr)
855        | Assignment::Subtract(expr) => {
856            v.visit_expr(expr);
857        }
858        Assignment::Pop => {}
859        Assignment::Batch(entries) => {
860            for entry in entries {
861                visit_assignment(v, entry);
862            }
863        }
864    }
865}
866
867/// Default traversal for [`Assignments`] nodes. Visits each assignment in the collection.
868pub fn visit_assignments<V>(v: &mut V, node: &Assignments)
869where
870    V: Visit + ?Sized,
871{
872    for (_, assignment) in node.iter() {
873        v.visit_assignment(assignment);
874    }
875}
876
877/// Default traversal for [`Association`] nodes. Visits the association's source query.
878pub fn visit_association<V>(v: &mut V, node: &Association)
879where
880    V: Visit + ?Sized,
881{
882    v.visit_stmt_query(&node.source);
883}
884
885/// Default traversal for [`Cte`] nodes. Visits the CTE's query.
886pub fn visit_cte<V>(v: &mut V, node: &Cte)
887where
888    V: Visit + ?Sized,
889{
890    v.visit_stmt_query(&node.query);
891}
892
893/// Default traversal for [`Expr`] nodes. Dispatches to the appropriate expression visitor based on variant.
894pub fn visit_expr<V>(v: &mut V, node: &Expr)
895where
896    V: Visit + ?Sized,
897{
898    match node {
899        Expr::AllOp(expr) => v.visit_expr_all_op(expr),
900        Expr::And(expr) => v.visit_expr_and(expr),
901        Expr::Any(expr) => v.visit_expr_any(expr),
902        Expr::AnyOp(expr) => v.visit_expr_any_op(expr),
903        Expr::Arg(expr) => v.visit_expr_arg(expr),
904        Expr::Between(expr) => v.visit_expr_between(expr),
905        Expr::BinaryOp(expr) => v.visit_expr_binary_op(expr),
906        Expr::Cast(expr) => v.visit_expr_cast(expr),
907        Expr::Default => v.visit_expr_default(),
908        Expr::Error(expr) => v.visit_expr_error(expr),
909        Expr::Exists(expr) => v.visit_expr_exists(expr),
910        Expr::Func(expr) => v.visit_expr_func(expr),
911        Expr::Ident(_) => {}
912        Expr::InList(expr) => v.visit_expr_in_list(expr),
913        Expr::InSubquery(expr) => v.visit_expr_in_subquery(expr),
914        Expr::Intersects(expr) => v.visit_expr_intersects(expr),
915        Expr::IsNull(expr) => v.visit_expr_is_null(expr),
916        Expr::IsSuperset(expr) => v.visit_expr_is_superset(expr),
917        Expr::IsVariant(expr) => v.visit_expr_is_variant(expr),
918        Expr::Length(expr) => v.visit_expr_length(expr),
919        Expr::Let(expr) => v.visit_expr_let(expr),
920        Expr::Like(expr) => v.visit_expr_like(expr),
921        Expr::Map(expr) => v.visit_expr_map(expr),
922        Expr::Match(expr) => v.visit_expr_match(expr),
923        Expr::Not(expr) => v.visit_expr_not(expr),
924        Expr::Or(expr) => v.visit_expr_or(expr),
925        Expr::Project(expr) => v.visit_expr_project(expr),
926        Expr::Record(expr) => v.visit_expr_record(expr),
927        Expr::Reference(expr) => v.visit_expr_reference(expr),
928        Expr::List(expr) => v.visit_expr_list(expr),
929        Expr::StartsWith(expr) => v.visit_expr_starts_with(expr),
930        Expr::Stmt(expr) => v.visit_expr_stmt(expr),
931        Expr::Value(expr) => v.visit_value(expr),
932    }
933}
934
935/// Default traversal for [`ExprAnd`] nodes. Visits each operand expression.
936pub fn visit_expr_and<V>(v: &mut V, node: &ExprAnd)
937where
938    V: Visit + ?Sized,
939{
940    for expr in node {
941        v.visit_expr(expr);
942    }
943}
944
945/// Default traversal for [`ExprAny`] nodes. Visits the inner expression.
946pub fn visit_expr_any<V>(v: &mut V, node: &ExprAny)
947where
948    V: Visit + ?Sized,
949{
950    v.visit_expr(&node.expr);
951}
952
953/// Default traversal for [`ExprArg`] nodes. This is a leaf node with no children to visit.
954pub fn visit_expr_arg<V>(v: &mut V, node: &ExprArg)
955where
956    V: Visit + ?Sized,
957{
958}
959
960/// Default traversal for [`ExprBinaryOp`] nodes. Visits left and right operands.
961pub fn visit_expr_binary_op<V>(v: &mut V, node: &ExprBinaryOp)
962where
963    V: Visit + ?Sized,
964{
965    v.visit_expr(&node.lhs);
966    v.visit_expr(&node.rhs);
967}
968
969/// Default traversal for [`ExprAnyOp`] nodes. Visits left and right operands.
970pub fn visit_expr_any_op<V>(v: &mut V, node: &ExprAnyOp)
971where
972    V: Visit + ?Sized,
973{
974    v.visit_expr(&node.lhs);
975    v.visit_expr(&node.rhs);
976}
977
978/// Default traversal for [`ExprAllOp`] nodes. Visits left and right operands.
979pub fn visit_expr_all_op<V>(v: &mut V, node: &ExprAllOp)
980where
981    V: Visit + ?Sized,
982{
983    v.visit_expr(&node.lhs);
984    v.visit_expr(&node.rhs);
985}
986
987/// Default traversal for [`ExprCast`] nodes. Visits the inner expression and target type.
988pub fn visit_expr_cast<V>(v: &mut V, node: &ExprCast)
989where
990    V: Visit + ?Sized,
991{
992    v.visit_expr(&node.expr);
993    v.visit_type(&node.ty);
994}
995
996/// Default traversal for [`ExprColumn`] nodes. This is a leaf node with no children to visit.
997pub fn visit_expr_column<V>(v: &mut V, node: &ExprColumn)
998where
999    V: Visit + ?Sized,
1000{
1001}
1002
1003/// Default traversal for [`Expr::Default`] nodes. This is a leaf node with no children to visit.
1004pub fn visit_expr_default<V>(v: &mut V)
1005where
1006    V: Visit + ?Sized,
1007{
1008}
1009
1010/// Default traversal for [`ExprError`] nodes. This is a leaf node with no children to visit.
1011pub fn visit_expr_error<V>(v: &mut V, node: &ExprError)
1012where
1013    V: Visit + ?Sized,
1014{
1015    // ExprError has no child expressions to visit
1016}
1017
1018/// Default traversal for [`ExprExists`] nodes. Visits the subquery.
1019pub fn visit_expr_exists<V>(v: &mut V, node: &ExprExists)
1020where
1021    V: Visit + ?Sized,
1022{
1023    v.visit_stmt_query(&node.subquery);
1024}
1025
1026/// Default traversal for [`ExprFunc`] nodes. Dispatches to the specific function visitor.
1027pub fn visit_expr_func<V>(v: &mut V, node: &ExprFunc)
1028where
1029    V: Visit + ?Sized,
1030{
1031    match node {
1032        ExprFunc::Count(func) => v.visit_expr_func_count(func),
1033        ExprFunc::LastInsertId(func) => v.visit_expr_func_last_insert_id(func),
1034    }
1035}
1036
1037/// Default traversal for [`FuncCount`] nodes. Visits the optional argument and filter expressions.
1038pub fn visit_expr_func_count<V>(v: &mut V, node: &FuncCount)
1039where
1040    V: Visit + ?Sized,
1041{
1042    if let Some(expr) = &node.arg {
1043        v.visit_expr(expr);
1044    }
1045
1046    if let Some(expr) = &node.filter {
1047        v.visit_expr(expr);
1048    }
1049}
1050
1051/// Default traversal for [`FuncLastInsertId`] nodes. This is a leaf node with no children to visit.
1052pub fn visit_expr_func_last_insert_id<V>(_v: &mut V, _node: &FuncLastInsertId)
1053where
1054    V: Visit + ?Sized,
1055{
1056    // FuncLastInsertId has no fields to visit
1057}
1058
1059/// Default traversal for [`ExprBetween`] nodes. Visits the expression, low, and high bounds.
1060pub fn visit_expr_between<V>(v: &mut V, node: &ExprBetween)
1061where
1062    V: Visit + ?Sized,
1063{
1064    v.visit_expr(&node.expr);
1065    v.visit_expr(&node.low);
1066    v.visit_expr(&node.high);
1067}
1068
1069/// Default traversal for [`ExprInList`] nodes. Visits the expression and list.
1070pub fn visit_expr_in_list<V>(v: &mut V, node: &ExprInList)
1071where
1072    V: Visit + ?Sized,
1073{
1074    v.visit_expr(&node.expr);
1075    v.visit_expr(&node.list);
1076}
1077
1078/// Default traversal for [`ExprInSubquery`] nodes. Visits the expression and subquery.
1079pub fn visit_expr_in_subquery<V>(v: &mut V, node: &ExprInSubquery)
1080where
1081    V: Visit + ?Sized,
1082{
1083    v.visit_expr(&node.expr);
1084    v.visit_stmt_query(&node.query);
1085}
1086
1087/// Default traversal for [`ExprIntersects`] nodes. Visits left and right operands.
1088pub fn visit_expr_intersects<V>(v: &mut V, node: &ExprIntersects)
1089where
1090    V: Visit + ?Sized,
1091{
1092    v.visit_expr(&node.lhs);
1093    v.visit_expr(&node.rhs);
1094}
1095
1096/// Default traversal for [`ExprIsNull`] nodes. Visits the inner expression.
1097pub fn visit_expr_is_null<V>(v: &mut V, node: &ExprIsNull)
1098where
1099    V: Visit + ?Sized,
1100{
1101    v.visit_expr(&node.expr);
1102}
1103
1104/// Default traversal for [`ExprIsSuperset`] nodes. Visits left and right operands.
1105pub fn visit_expr_is_superset<V>(v: &mut V, node: &ExprIsSuperset)
1106where
1107    V: Visit + ?Sized,
1108{
1109    v.visit_expr(&node.lhs);
1110    v.visit_expr(&node.rhs);
1111}
1112
1113/// Default traversal for [`ExprLength`] nodes. Visits the inner expression.
1114pub fn visit_expr_length<V>(v: &mut V, node: &ExprLength)
1115where
1116    V: Visit + ?Sized,
1117{
1118    v.visit_expr(&node.expr);
1119}
1120
1121/// Default traversal for [`ExprIsVariant`] nodes. Visits the inner expression.
1122pub fn visit_expr_is_variant<V>(v: &mut V, node: &ExprIsVariant)
1123where
1124    V: Visit + ?Sized,
1125{
1126    v.visit_expr(&node.expr);
1127}
1128
1129/// Default traversal for [`ExprLet`] nodes. Visits bindings and body.
1130pub fn visit_expr_let<V>(v: &mut V, node: &ExprLet)
1131where
1132    V: Visit + ?Sized,
1133{
1134    for binding in &node.bindings {
1135        v.visit_expr(binding);
1136    }
1137    v.visit_expr(&node.body);
1138}
1139
1140/// Default traversal for [`ExprLike`] nodes. Visits the attribute expression and pattern.
1141pub fn visit_expr_like<V>(v: &mut V, node: &ExprLike)
1142where
1143    V: Visit + ?Sized,
1144{
1145    v.visit_expr(&node.expr);
1146    v.visit_expr(&node.pattern);
1147}
1148
1149/// Default traversal for [`ExprMap`] nodes. Visits base and map expressions.
1150pub fn visit_expr_map<V>(v: &mut V, node: &ExprMap)
1151where
1152    V: Visit + ?Sized,
1153{
1154    v.visit_expr(&node.base);
1155    v.visit_expr(&node.map);
1156}
1157
1158/// Default traversal for [`ExprMatch`] nodes. Visits subject, arms, and else expression.
1159pub fn visit_expr_match<V>(v: &mut V, node: &ExprMatch)
1160where
1161    V: Visit + ?Sized,
1162{
1163    v.visit_expr(&node.subject);
1164    for arm in &node.arms {
1165        v.visit_expr(&arm.expr);
1166    }
1167    v.visit_expr(&node.else_expr);
1168}
1169
1170/// Default traversal for [`ExprNot`] nodes. Visits the inner expression.
1171pub fn visit_expr_not<V>(v: &mut V, node: &ExprNot)
1172where
1173    V: Visit + ?Sized,
1174{
1175    v.visit_expr(&node.expr);
1176}
1177
1178/// Default traversal for [`ExprOr`] nodes. Visits each operand expression.
1179pub fn visit_expr_or<V>(v: &mut V, node: &ExprOr)
1180where
1181    V: Visit + ?Sized,
1182{
1183    for expr in node {
1184        v.visit_expr(expr);
1185    }
1186}
1187
1188/// Default traversal for [`ExprList`] nodes. Visits each item expression.
1189pub fn visit_expr_list<V>(v: &mut V, node: &ExprList)
1190where
1191    V: Visit + ?Sized,
1192{
1193    for expr in &node.items {
1194        v.visit_expr(expr);
1195    }
1196}
1197
1198/// Default traversal for [`ExprRecord`] nodes. Visits each field expression.
1199pub fn visit_expr_record<V>(v: &mut V, node: &ExprRecord)
1200where
1201    V: Visit + ?Sized,
1202{
1203    for expr in &**node {
1204        v.visit_expr(expr);
1205    }
1206}
1207
1208/// Default traversal for [`ExprReference`] nodes. Dispatches based on reference kind.
1209pub fn visit_expr_reference<V>(v: &mut V, node: &ExprReference)
1210where
1211    V: Visit + ?Sized,
1212{
1213    match node {
1214        ExprReference::Model { .. } => {}
1215        ExprReference::Field { .. } => {}
1216        ExprReference::Column(expr_column) => v.visit_expr_column(expr_column),
1217    }
1218}
1219
1220/// Default traversal for [`ExprSet`] nodes. Dispatches to the appropriate set expression visitor.
1221pub fn visit_expr_set<V>(v: &mut V, node: &ExprSet)
1222where
1223    V: Visit + ?Sized,
1224{
1225    match node {
1226        ExprSet::Select(expr) => v.visit_stmt_select(expr),
1227        ExprSet::SetOp(expr) => v.visit_expr_set_op(expr),
1228        ExprSet::Update(expr) => v.visit_stmt_update(expr),
1229        ExprSet::Delete(expr) => v.visit_stmt_delete(expr),
1230        ExprSet::Values(expr) => v.visit_values(expr),
1231        ExprSet::Insert(expr) => v.visit_stmt_insert(expr),
1232    }
1233}
1234
1235/// Default traversal for [`ExprSetOp`] nodes. Visits each operand.
1236pub fn visit_expr_set_op<V>(v: &mut V, node: &ExprSetOp)
1237where
1238    V: Visit + ?Sized,
1239{
1240    for operand in &node.operands {
1241        v.visit_expr_set(operand);
1242    }
1243}
1244
1245/// Default traversal for [`ExprStartsWith`] nodes. Visits the attribute expression and prefix.
1246pub fn visit_expr_starts_with<V>(v: &mut V, node: &ExprStartsWith)
1247where
1248    V: Visit + ?Sized,
1249{
1250    v.visit_expr(&node.expr);
1251    v.visit_expr(&node.prefix);
1252}
1253
1254/// Default traversal for [`ExprStmt`] nodes. Visits the inner statement.
1255pub fn visit_expr_stmt<V>(v: &mut V, node: &ExprStmt)
1256where
1257    V: Visit + ?Sized,
1258{
1259    v.visit_stmt(&node.stmt);
1260}
1261
1262/// Default traversal for [`ExprProject`] nodes. Visits the base expression and projection.
1263pub fn visit_expr_project<V>(v: &mut V, node: &ExprProject)
1264where
1265    V: Visit + ?Sized,
1266{
1267    v.visit_expr(&node.base);
1268    v.visit_projection(&node.projection);
1269}
1270
1271/// Default traversal for [`Filter`] nodes. Visits the optional filter expression.
1272pub fn visit_filter<V>(v: &mut V, node: &Filter)
1273where
1274    V: Visit + ?Sized,
1275{
1276    if let Some(expr) = &node.expr {
1277        v.visit_expr(expr);
1278    }
1279}
1280
1281/// Default traversal for [`Condition`] nodes. Visits the optional condition expression.
1282pub fn visit_condition<V>(v: &mut V, node: &Condition)
1283where
1284    V: Visit + ?Sized,
1285{
1286    if let Some(expr) = &node.expr {
1287        v.visit_expr(expr);
1288    }
1289}
1290
1291/// Default traversal for [`InsertTarget`] nodes. Visits the scope query if present.
1292pub fn visit_insert_target<V>(v: &mut V, node: &InsertTarget)
1293where
1294    V: Visit + ?Sized,
1295{
1296    if let InsertTarget::Scope(stmt) = node {
1297        v.visit_stmt_query(stmt);
1298    }
1299}
1300
1301/// Default traversal for [`Join`] nodes. Visits the table and join constraint.
1302pub fn visit_join<V>(v: &mut V, node: &Join)
1303where
1304    V: Visit + ?Sized,
1305{
1306    v.visit_source_table_id(&node.table);
1307    match &node.constraint {
1308        JoinOp::Inner(expr) | JoinOp::Left(expr) => v.visit_expr(expr),
1309    }
1310}
1311
1312/// Default traversal for [`Limit`] nodes.
1313pub fn visit_limit<V>(v: &mut V, node: &Limit)
1314where
1315    V: Visit + ?Sized,
1316{
1317    match node {
1318        Limit::Cursor(cursor) => v.visit_limit_cursor(cursor),
1319        Limit::Offset(offset) => v.visit_limit_offset(offset),
1320    }
1321}
1322
1323/// Default traversal for [`LimitCursor`] nodes.
1324pub fn visit_limit_cursor<V>(v: &mut V, node: &LimitCursor)
1325where
1326    V: Visit + ?Sized,
1327{
1328    v.visit_expr(&node.page_size);
1329    if let Some(after) = &node.after {
1330        v.visit_expr(after);
1331    }
1332}
1333
1334/// Default traversal for [`LimitOffset`] nodes.
1335pub fn visit_limit_offset<V>(v: &mut V, node: &LimitOffset)
1336where
1337    V: Visit + ?Sized,
1338{
1339    v.visit_expr(&node.limit);
1340    if let Some(offset) = &node.offset {
1341        v.visit_expr(offset);
1342    }
1343}
1344
1345/// Default traversal for [`OrderBy`] nodes. Visits each ordering expression.
1346pub fn visit_order_by<V>(v: &mut V, node: &OrderBy)
1347where
1348    V: Visit + ?Sized,
1349{
1350    for expr in &node.exprs {
1351        v.visit_order_by_expr(expr);
1352    }
1353}
1354
1355/// Default traversal for [`OrderByExpr`] nodes. Visits the ordering expression.
1356pub fn visit_order_by_expr<V>(v: &mut V, node: &OrderByExpr)
1357where
1358    V: Visit + ?Sized,
1359{
1360    v.visit_expr(&node.expr);
1361}
1362
1363/// Default traversal for [`Path`] nodes. Visits the path's projection.
1364pub fn visit_path<V>(v: &mut V, node: &Path)
1365where
1366    V: Visit + ?Sized,
1367{
1368    v.visit_projection(&node.projection);
1369}
1370
1371/// Default traversal for [`Projection`] nodes. This is a leaf node with no children to visit.
1372pub fn visit_projection<V>(v: &mut V, node: &Projection)
1373where
1374    V: Visit + ?Sized,
1375{
1376}
1377
1378/// Default traversal for [`Returning`] nodes. Visits included paths or expressions based on variant.
1379pub fn visit_returning<V>(v: &mut V, node: &Returning)
1380where
1381    V: Visit + ?Sized,
1382{
1383    match node {
1384        Returning::Model { include } => {
1385            for path in include {
1386                v.visit_path(path);
1387            }
1388        }
1389        Returning::Changed => {}
1390        Returning::Project(expr) => v.visit_expr(expr),
1391        Returning::Expr(expr) => v.visit_expr(expr),
1392    }
1393}
1394
1395/// Default traversal for [`Source`] nodes. Dispatches to model or table source visitor.
1396pub fn visit_source<V>(v: &mut V, node: &Source)
1397where
1398    V: Visit + ?Sized,
1399{
1400    match node {
1401        Source::Model(source_model) => v.visit_source_model(source_model),
1402        Source::Table(source_table) => v.visit_source_table(source_table),
1403    }
1404}
1405
1406/// Default traversal for [`SourceModel`] nodes. Visits the optional association.
1407pub fn visit_source_model<V>(v: &mut V, node: &SourceModel)
1408where
1409    V: Visit + ?Sized,
1410{
1411    if let Some(association) = &node.via {
1412        v.visit_association(association);
1413    }
1414}
1415
1416/// Default traversal for [`SourceTable`] nodes. Visits table references and FROM clauses.
1417pub fn visit_source_table<V>(v: &mut V, node: &SourceTable)
1418where
1419    V: Visit + ?Sized,
1420{
1421    for table_ref in &node.tables {
1422        v.visit_table_ref(table_ref);
1423    }
1424    for table_with_joins in &node.from {
1425        v.visit_table_with_joins(table_with_joins);
1426    }
1427}
1428
1429/// Default traversal for [`SourceTableId`] nodes. This is a leaf node with no children to visit.
1430pub fn visit_source_table_id<V>(v: &mut V, node: &SourceTableId)
1431where
1432    V: Visit + ?Sized,
1433{
1434    // SourceTableId is just an index, nothing to visit
1435}
1436
1437/// Default traversal for [`TableFactor`] nodes. Dispatches based on factor type.
1438pub fn visit_table_factor<V>(v: &mut V, node: &TableFactor)
1439where
1440    V: Visit + ?Sized,
1441{
1442    match node {
1443        TableFactor::Table(table_id) => v.visit_source_table_id(table_id),
1444    }
1445}
1446
1447/// Default traversal for [`Statement`] nodes. Dispatches to the appropriate statement visitor.
1448pub fn visit_stmt<V>(v: &mut V, node: &Statement)
1449where
1450    V: Visit + ?Sized,
1451{
1452    match node {
1453        Statement::Delete(stmt) => v.visit_stmt_delete(stmt),
1454        Statement::Insert(stmt) => v.visit_stmt_insert(stmt),
1455        Statement::Query(stmt) => v.visit_stmt_query(stmt),
1456        Statement::Update(stmt) => v.visit_stmt_update(stmt),
1457    }
1458}
1459
1460/// Default traversal for [`Delete`] nodes. Visits source, filter, and optional returning.
1461pub fn visit_stmt_delete<V>(v: &mut V, node: &Delete)
1462where
1463    V: Visit + ?Sized,
1464{
1465    v.visit_source(&node.from);
1466    v.visit_filter(&node.filter);
1467    v.visit_condition(&node.condition);
1468
1469    if let Some(returning) = &node.returning {
1470        v.visit_returning(returning);
1471    }
1472}
1473
1474/// Default traversal for [`Insert`] nodes. Visits target, source query, and optional returning.
1475pub fn visit_stmt_insert<V>(v: &mut V, node: &Insert)
1476where
1477    V: Visit + ?Sized,
1478{
1479    if let InsertTarget::Scope(scope) = &node.target {
1480        v.visit_stmt_query(scope);
1481    }
1482    v.visit_stmt_query(&node.source);
1483
1484    if let Some(returning) = &node.returning {
1485        v.visit_returning(returning);
1486    }
1487}
1488
1489/// Default traversal for [`Query`] nodes. Visits optional WITH, body, order by, and limit.
1490pub fn visit_stmt_query<V>(v: &mut V, node: &Query)
1491where
1492    V: Visit + ?Sized,
1493{
1494    if let Some(with) = &node.with {
1495        v.visit_with(with);
1496    }
1497
1498    v.visit_expr_set(&node.body);
1499
1500    if let Some(order_by) = &node.order_by {
1501        v.visit_order_by(order_by);
1502    }
1503
1504    if let Some(limit) = &node.limit {
1505        v.visit_limit(limit);
1506    }
1507}
1508
1509/// Default traversal for [`Select`] nodes. Visits source, filter, and returning.
1510pub fn visit_stmt_select<V>(v: &mut V, node: &Select)
1511where
1512    V: Visit + ?Sized,
1513{
1514    v.visit_source(&node.source);
1515    v.visit_filter(&node.filter);
1516    v.visit_returning(&node.returning);
1517}
1518
1519/// Default traversal for [`Update`] nodes. Visits target, assignments, filter, and condition.
1520pub fn visit_stmt_update<V>(v: &mut V, node: &Update)
1521where
1522    V: Visit + ?Sized,
1523{
1524    v.visit_update_target(&node.target);
1525    v.visit_assignments(&node.assignments);
1526    v.visit_filter(&node.filter);
1527    v.visit_condition(&node.condition);
1528}
1529
1530/// Default traversal for [`TableDerived`] nodes. Visits the subquery.
1531pub fn visit_table_derived<V>(v: &mut V, node: &TableDerived)
1532where
1533    V: Visit + ?Sized,
1534{
1535    v.visit_stmt_query(&node.subquery);
1536}
1537
1538/// Default traversal for [`TableRef`] nodes. Dispatches based on reference kind.
1539pub fn visit_table_ref<V>(v: &mut V, node: &TableRef)
1540where
1541    V: Visit + ?Sized,
1542{
1543    match node {
1544        TableRef::Cte { .. } => {}
1545        TableRef::Derived(table_derived) => v.visit_table_derived(table_derived),
1546        TableRef::Table(_) => {}
1547        TableRef::Arg(expr_arg) => v.visit_expr_arg(expr_arg),
1548    }
1549}
1550
1551/// Default traversal for [`TableWithJoins`] nodes. Visits the relation and each join.
1552pub fn visit_table_with_joins<V>(v: &mut V, node: &TableWithJoins)
1553where
1554    V: Visit + ?Sized,
1555{
1556    v.visit_table_factor(&node.relation);
1557    for join in &node.joins {
1558        v.visit_join(join);
1559    }
1560}
1561
1562/// Default traversal for [`Type`] nodes. This is a leaf node with no children to visit.
1563pub fn visit_type<V>(v: &mut V, node: &Type)
1564where
1565    V: Visit + ?Sized,
1566{
1567    // Type is just type information, no traversal needed
1568}
1569
1570/// Default traversal for [`UpdateTarget`] nodes. Visits the query if target is a query.
1571pub fn visit_update_target<V>(v: &mut V, node: &UpdateTarget)
1572where
1573    V: Visit + ?Sized,
1574{
1575    if let UpdateTarget::Query(query) = node {
1576        v.visit_stmt_query(query)
1577    }
1578}
1579
1580/// Default traversal for [`Value`] nodes. Visits inner record if value is a record.
1581pub fn visit_value<V>(v: &mut V, node: &Value)
1582where
1583    V: Visit + ?Sized,
1584{
1585    if let Value::Record(node) = node {
1586        v.visit_value_record(node)
1587    }
1588}
1589
1590/// Default traversal for [`ValueRecord`] nodes. Visits each value in the record.
1591pub fn visit_value_record<V>(v: &mut V, node: &ValueRecord)
1592where
1593    V: Visit + ?Sized,
1594{
1595    for value in node.iter() {
1596        v.visit_value(value);
1597    }
1598}
1599
1600/// Default traversal for [`Values`] nodes. Visits each row expression.
1601pub fn visit_values<V>(v: &mut V, node: &Values)
1602where
1603    V: Visit + ?Sized,
1604{
1605    for expr in &node.rows {
1606        v.visit_expr(expr);
1607    }
1608}
1609
1610/// Default traversal for [`With`] nodes. Visits each CTE.
1611pub fn visit_with<V>(v: &mut V, node: &With)
1612where
1613    V: Visit + ?Sized,
1614{
1615    for cte in &node.ctes {
1616        v.visit_cte(cte);
1617    }
1618}
1619
1620/// Calls `f` for every [`Expr`] node reachable from `node`, in post-order.
1621///
1622/// This is a convenience wrapper that constructs a [`Visit`] implementation
1623/// internally and walks the full AST rooted at `node`.
1624pub fn for_each_expr<F>(node: &impl Node, f: F)
1625where
1626    F: FnMut(&Expr),
1627{
1628    struct ForEach<F> {
1629        f: F,
1630    }
1631
1632    impl<F> Visit for ForEach<F>
1633    where
1634        F: FnMut(&Expr),
1635    {
1636        fn visit_expr(&mut self, node: &Expr) {
1637            visit_expr(self, node);
1638            (self.f)(node);
1639        }
1640    }
1641
1642    node.visit(ForEach { f });
1643}
toasty_core/stmt/visit.rs

toasty_core/stmt/
visit.rs
