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

toasty_core/stmt/
visit.rs
