toasty_core/stmt/
visit.rs

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

toasty_core/stmt/
visit.rs
