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            v.visit_expr(expr);
844        }
845        Assignment::Pop => {}
846        Assignment::Batch(entries) => {
847            for entry in entries {
848                visit_assignment(v, entry);
849            }
850        }
851    }
852}
853
854/// Default traversal for [`Assignments`] nodes. Visits each assignment in the collection.
855pub fn visit_assignments<V>(v: &mut V, node: &Assignments)
856where
857    V: Visit + ?Sized,
858{
859    for (_, assignment) in node.iter() {
860        v.visit_assignment(assignment);
861    }
862}
863
864/// Default traversal for [`Association`] nodes. Visits the association's source query.
865pub fn visit_association<V>(v: &mut V, node: &Association)
866where
867    V: Visit + ?Sized,
868{
869    v.visit_stmt_query(&node.source);
870}
871
872/// Default traversal for [`Cte`] nodes. Visits the CTE's query.
873pub fn visit_cte<V>(v: &mut V, node: &Cte)
874where
875    V: Visit + ?Sized,
876{
877    v.visit_stmt_query(&node.query);
878}
879
880/// Default traversal for [`Expr`] nodes. Dispatches to the appropriate expression visitor based on variant.
881pub fn visit_expr<V>(v: &mut V, node: &Expr)
882where
883    V: Visit + ?Sized,
884{
885    match node {
886        Expr::AllOp(expr) => v.visit_expr_all_op(expr),
887        Expr::And(expr) => v.visit_expr_and(expr),
888        Expr::Any(expr) => v.visit_expr_any(expr),
889        Expr::AnyOp(expr) => v.visit_expr_any_op(expr),
890        Expr::Arg(expr) => v.visit_expr_arg(expr),
891        Expr::BinaryOp(expr) => v.visit_expr_binary_op(expr),
892        Expr::Cast(expr) => v.visit_expr_cast(expr),
893        Expr::Default => v.visit_expr_default(),
894        Expr::Error(expr) => v.visit_expr_error(expr),
895        Expr::Exists(expr) => v.visit_expr_exists(expr),
896        Expr::Func(expr) => v.visit_expr_func(expr),
897        Expr::Ident(_) => {}
898        Expr::InList(expr) => v.visit_expr_in_list(expr),
899        Expr::InSubquery(expr) => v.visit_expr_in_subquery(expr),
900        Expr::Intersects(expr) => v.visit_expr_intersects(expr),
901        Expr::IsNull(expr) => v.visit_expr_is_null(expr),
902        Expr::IsSuperset(expr) => v.visit_expr_is_superset(expr),
903        Expr::IsVariant(expr) => v.visit_expr_is_variant(expr),
904        Expr::Length(expr) => v.visit_expr_length(expr),
905        Expr::Let(expr) => v.visit_expr_let(expr),
906        Expr::Like(expr) => v.visit_expr_like(expr),
907        Expr::Map(expr) => v.visit_expr_map(expr),
908        Expr::Match(expr) => v.visit_expr_match(expr),
909        Expr::Not(expr) => v.visit_expr_not(expr),
910        Expr::Or(expr) => v.visit_expr_or(expr),
911        Expr::Project(expr) => v.visit_expr_project(expr),
912        Expr::Record(expr) => v.visit_expr_record(expr),
913        Expr::Reference(expr) => v.visit_expr_reference(expr),
914        Expr::List(expr) => v.visit_expr_list(expr),
915        Expr::StartsWith(expr) => v.visit_expr_starts_with(expr),
916        Expr::Stmt(expr) => v.visit_expr_stmt(expr),
917        Expr::Value(expr) => v.visit_value(expr),
918    }
919}
920
921/// Default traversal for [`ExprAnd`] nodes. Visits each operand expression.
922pub fn visit_expr_and<V>(v: &mut V, node: &ExprAnd)
923where
924    V: Visit + ?Sized,
925{
926    for expr in node {
927        v.visit_expr(expr);
928    }
929}
930
931/// Default traversal for [`ExprAny`] nodes. Visits the inner expression.
932pub fn visit_expr_any<V>(v: &mut V, node: &ExprAny)
933where
934    V: Visit + ?Sized,
935{
936    v.visit_expr(&node.expr);
937}
938
939/// Default traversal for [`ExprArg`] nodes. This is a leaf node with no children to visit.
940pub fn visit_expr_arg<V>(v: &mut V, node: &ExprArg)
941where
942    V: Visit + ?Sized,
943{
944}
945
946/// Default traversal for [`ExprBinaryOp`] nodes. Visits left and right operands.
947pub fn visit_expr_binary_op<V>(v: &mut V, node: &ExprBinaryOp)
948where
949    V: Visit + ?Sized,
950{
951    v.visit_expr(&node.lhs);
952    v.visit_expr(&node.rhs);
953}
954
955/// Default traversal for [`ExprAnyOp`] nodes. Visits left and right operands.
956pub fn visit_expr_any_op<V>(v: &mut V, node: &ExprAnyOp)
957where
958    V: Visit + ?Sized,
959{
960    v.visit_expr(&node.lhs);
961    v.visit_expr(&node.rhs);
962}
963
964/// Default traversal for [`ExprAllOp`] nodes. Visits left and right operands.
965pub fn visit_expr_all_op<V>(v: &mut V, node: &ExprAllOp)
966where
967    V: Visit + ?Sized,
968{
969    v.visit_expr(&node.lhs);
970    v.visit_expr(&node.rhs);
971}
972
973/// Default traversal for [`ExprCast`] nodes. Visits the inner expression and target type.
974pub fn visit_expr_cast<V>(v: &mut V, node: &ExprCast)
975where
976    V: Visit + ?Sized,
977{
978    v.visit_expr(&node.expr);
979    v.visit_type(&node.ty);
980}
981
982/// Default traversal for [`ExprColumn`] nodes. This is a leaf node with no children to visit.
983pub fn visit_expr_column<V>(v: &mut V, node: &ExprColumn)
984where
985    V: Visit + ?Sized,
986{
987}
988
989/// Default traversal for [`Expr::Default`] nodes. This is a leaf node with no children to visit.
990pub fn visit_expr_default<V>(v: &mut V)
991where
992    V: Visit + ?Sized,
993{
994}
995
996/// Default traversal for [`ExprError`] nodes. This is a leaf node with no children to visit.
997pub fn visit_expr_error<V>(v: &mut V, node: &ExprError)
998where
999    V: Visit + ?Sized,
1000{
1001    // ExprError has no child expressions to visit
1002}
1003
1004/// Default traversal for [`ExprExists`] nodes. Visits the subquery.
1005pub fn visit_expr_exists<V>(v: &mut V, node: &ExprExists)
1006where
1007    V: Visit + ?Sized,
1008{
1009    v.visit_stmt_query(&node.subquery);
1010}
1011
1012/// Default traversal for [`ExprFunc`] nodes. Dispatches to the specific function visitor.
1013pub fn visit_expr_func<V>(v: &mut V, node: &ExprFunc)
1014where
1015    V: Visit + ?Sized,
1016{
1017    match node {
1018        ExprFunc::Count(func) => v.visit_expr_func_count(func),
1019        ExprFunc::LastInsertId(func) => v.visit_expr_func_last_insert_id(func),
1020    }
1021}
1022
1023/// Default traversal for [`FuncCount`] nodes. Visits the optional argument and filter expressions.
1024pub fn visit_expr_func_count<V>(v: &mut V, node: &FuncCount)
1025where
1026    V: Visit + ?Sized,
1027{
1028    if let Some(expr) = &node.arg {
1029        v.visit_expr(expr);
1030    }
1031
1032    if let Some(expr) = &node.filter {
1033        v.visit_expr(expr);
1034    }
1035}
1036
1037/// Default traversal for [`FuncLastInsertId`] nodes. This is a leaf node with no children to visit.
1038pub fn visit_expr_func_last_insert_id<V>(_v: &mut V, _node: &FuncLastInsertId)
1039where
1040    V: Visit + ?Sized,
1041{
1042    // FuncLastInsertId has no fields to visit
1043}
1044
1045/// Default traversal for [`ExprInList`] nodes. Visits the expression and list.
1046pub fn visit_expr_in_list<V>(v: &mut V, node: &ExprInList)
1047where
1048    V: Visit + ?Sized,
1049{
1050    v.visit_expr(&node.expr);
1051    v.visit_expr(&node.list);
1052}
1053
1054/// Default traversal for [`ExprInSubquery`] nodes. Visits the expression and subquery.
1055pub fn visit_expr_in_subquery<V>(v: &mut V, node: &ExprInSubquery)
1056where
1057    V: Visit + ?Sized,
1058{
1059    v.visit_expr(&node.expr);
1060    v.visit_stmt_query(&node.query);
1061}
1062
1063/// Default traversal for [`ExprIntersects`] nodes. Visits left and right operands.
1064pub fn visit_expr_intersects<V>(v: &mut V, node: &ExprIntersects)
1065where
1066    V: Visit + ?Sized,
1067{
1068    v.visit_expr(&node.lhs);
1069    v.visit_expr(&node.rhs);
1070}
1071
1072/// Default traversal for [`ExprIsNull`] nodes. Visits the inner expression.
1073pub fn visit_expr_is_null<V>(v: &mut V, node: &ExprIsNull)
1074where
1075    V: Visit + ?Sized,
1076{
1077    v.visit_expr(&node.expr);
1078}
1079
1080/// Default traversal for [`ExprIsSuperset`] nodes. Visits left and right operands.
1081pub fn visit_expr_is_superset<V>(v: &mut V, node: &ExprIsSuperset)
1082where
1083    V: Visit + ?Sized,
1084{
1085    v.visit_expr(&node.lhs);
1086    v.visit_expr(&node.rhs);
1087}
1088
1089/// Default traversal for [`ExprLength`] nodes. Visits the inner expression.
1090pub fn visit_expr_length<V>(v: &mut V, node: &ExprLength)
1091where
1092    V: Visit + ?Sized,
1093{
1094    v.visit_expr(&node.expr);
1095}
1096
1097/// Default traversal for [`ExprIsVariant`] nodes. Visits the inner expression.
1098pub fn visit_expr_is_variant<V>(v: &mut V, node: &ExprIsVariant)
1099where
1100    V: Visit + ?Sized,
1101{
1102    v.visit_expr(&node.expr);
1103}
1104
1105/// Default traversal for [`ExprLet`] nodes. Visits bindings and body.
1106pub fn visit_expr_let<V>(v: &mut V, node: &ExprLet)
1107where
1108    V: Visit + ?Sized,
1109{
1110    for binding in &node.bindings {
1111        v.visit_expr(binding);
1112    }
1113    v.visit_expr(&node.body);
1114}
1115
1116/// Default traversal for [`ExprLike`] nodes. Visits the attribute expression and pattern.
1117pub fn visit_expr_like<V>(v: &mut V, node: &ExprLike)
1118where
1119    V: Visit + ?Sized,
1120{
1121    v.visit_expr(&node.expr);
1122    v.visit_expr(&node.pattern);
1123}
1124
1125/// Default traversal for [`ExprMap`] nodes. Visits base and map expressions.
1126pub fn visit_expr_map<V>(v: &mut V, node: &ExprMap)
1127where
1128    V: Visit + ?Sized,
1129{
1130    v.visit_expr(&node.base);
1131    v.visit_expr(&node.map);
1132}
1133
1134/// Default traversal for [`ExprMatch`] nodes. Visits subject, arms, and else expression.
1135pub fn visit_expr_match<V>(v: &mut V, node: &ExprMatch)
1136where
1137    V: Visit + ?Sized,
1138{
1139    v.visit_expr(&node.subject);
1140    for arm in &node.arms {
1141        v.visit_expr(&arm.expr);
1142    }
1143    v.visit_expr(&node.else_expr);
1144}
1145
1146/// Default traversal for [`ExprNot`] nodes. Visits the inner expression.
1147pub fn visit_expr_not<V>(v: &mut V, node: &ExprNot)
1148where
1149    V: Visit + ?Sized,
1150{
1151    v.visit_expr(&node.expr);
1152}
1153
1154/// Default traversal for [`ExprOr`] nodes. Visits each operand expression.
1155pub fn visit_expr_or<V>(v: &mut V, node: &ExprOr)
1156where
1157    V: Visit + ?Sized,
1158{
1159    for expr in node {
1160        v.visit_expr(expr);
1161    }
1162}
1163
1164/// Default traversal for [`ExprList`] nodes. Visits each item expression.
1165pub fn visit_expr_list<V>(v: &mut V, node: &ExprList)
1166where
1167    V: Visit + ?Sized,
1168{
1169    for expr in &node.items {
1170        v.visit_expr(expr);
1171    }
1172}
1173
1174/// Default traversal for [`ExprRecord`] nodes. Visits each field expression.
1175pub fn visit_expr_record<V>(v: &mut V, node: &ExprRecord)
1176where
1177    V: Visit + ?Sized,
1178{
1179    for expr in &**node {
1180        v.visit_expr(expr);
1181    }
1182}
1183
1184/// Default traversal for [`ExprReference`] nodes. Dispatches based on reference kind.
1185pub fn visit_expr_reference<V>(v: &mut V, node: &ExprReference)
1186where
1187    V: Visit + ?Sized,
1188{
1189    match node {
1190        ExprReference::Model { .. } => {}
1191        ExprReference::Field { .. } => {}
1192        ExprReference::Column(expr_column) => v.visit_expr_column(expr_column),
1193    }
1194}
1195
1196/// Default traversal for [`ExprSet`] nodes. Dispatches to the appropriate set expression visitor.
1197pub fn visit_expr_set<V>(v: &mut V, node: &ExprSet)
1198where
1199    V: Visit + ?Sized,
1200{
1201    match node {
1202        ExprSet::Select(expr) => v.visit_stmt_select(expr),
1203        ExprSet::SetOp(expr) => v.visit_expr_set_op(expr),
1204        ExprSet::Update(expr) => v.visit_stmt_update(expr),
1205        ExprSet::Values(expr) => v.visit_values(expr),
1206        ExprSet::Insert(expr) => v.visit_stmt_insert(expr),
1207    }
1208}
1209
1210/// Default traversal for [`ExprSetOp`] nodes. Visits each operand.
1211pub fn visit_expr_set_op<V>(v: &mut V, node: &ExprSetOp)
1212where
1213    V: Visit + ?Sized,
1214{
1215    for operand in &node.operands {
1216        v.visit_expr_set(operand);
1217    }
1218}
1219
1220/// Default traversal for [`ExprStartsWith`] nodes. Visits the attribute expression and prefix.
1221pub fn visit_expr_starts_with<V>(v: &mut V, node: &ExprStartsWith)
1222where
1223    V: Visit + ?Sized,
1224{
1225    v.visit_expr(&node.expr);
1226    v.visit_expr(&node.prefix);
1227}
1228
1229/// Default traversal for [`ExprStmt`] nodes. Visits the inner statement.
1230pub fn visit_expr_stmt<V>(v: &mut V, node: &ExprStmt)
1231where
1232    V: Visit + ?Sized,
1233{
1234    v.visit_stmt(&node.stmt);
1235}
1236
1237/// Default traversal for [`ExprProject`] nodes. Visits the base expression and projection.
1238pub fn visit_expr_project<V>(v: &mut V, node: &ExprProject)
1239where
1240    V: Visit + ?Sized,
1241{
1242    v.visit_expr(&node.base);
1243    v.visit_projection(&node.projection);
1244}
1245
1246/// Default traversal for [`Filter`] nodes. Visits the optional filter expression.
1247pub fn visit_filter<V>(v: &mut V, node: &Filter)
1248where
1249    V: Visit + ?Sized,
1250{
1251    if let Some(expr) = &node.expr {
1252        v.visit_expr(expr);
1253    }
1254}
1255
1256/// Default traversal for [`Condition`] nodes. Visits the optional condition expression.
1257pub fn visit_condition<V>(v: &mut V, node: &Condition)
1258where
1259    V: Visit + ?Sized,
1260{
1261    if let Some(expr) = &node.expr {
1262        v.visit_expr(expr);
1263    }
1264}
1265
1266/// Default traversal for [`InsertTarget`] nodes. Visits the scope query if present.
1267pub fn visit_insert_target<V>(v: &mut V, node: &InsertTarget)
1268where
1269    V: Visit + ?Sized,
1270{
1271    if let InsertTarget::Scope(stmt) = node {
1272        v.visit_stmt_query(stmt);
1273    }
1274}
1275
1276/// Default traversal for [`Join`] nodes. Visits the table and join constraint.
1277pub fn visit_join<V>(v: &mut V, node: &Join)
1278where
1279    V: Visit + ?Sized,
1280{
1281    v.visit_source_table_id(&node.table);
1282    match &node.constraint {
1283        JoinOp::Inner(expr) | JoinOp::Left(expr) => v.visit_expr(expr),
1284    }
1285}
1286
1287/// Default traversal for [`Limit`] nodes.
1288pub fn visit_limit<V>(v: &mut V, node: &Limit)
1289where
1290    V: Visit + ?Sized,
1291{
1292    match node {
1293        Limit::Cursor(cursor) => v.visit_limit_cursor(cursor),
1294        Limit::Offset(offset) => v.visit_limit_offset(offset),
1295    }
1296}
1297
1298/// Default traversal for [`LimitCursor`] nodes.
1299pub fn visit_limit_cursor<V>(v: &mut V, node: &LimitCursor)
1300where
1301    V: Visit + ?Sized,
1302{
1303    v.visit_expr(&node.page_size);
1304    if let Some(after) = &node.after {
1305        v.visit_expr(after);
1306    }
1307}
1308
1309/// Default traversal for [`LimitOffset`] nodes.
1310pub fn visit_limit_offset<V>(v: &mut V, node: &LimitOffset)
1311where
1312    V: Visit + ?Sized,
1313{
1314    v.visit_expr(&node.limit);
1315    if let Some(offset) = &node.offset {
1316        v.visit_expr(offset);
1317    }
1318}
1319
1320/// Default traversal for [`OrderBy`] nodes. Visits each ordering expression.
1321pub fn visit_order_by<V>(v: &mut V, node: &OrderBy)
1322where
1323    V: Visit + ?Sized,
1324{
1325    for expr in &node.exprs {
1326        v.visit_order_by_expr(expr);
1327    }
1328}
1329
1330/// Default traversal for [`OrderByExpr`] nodes. Visits the ordering expression.
1331pub fn visit_order_by_expr<V>(v: &mut V, node: &OrderByExpr)
1332where
1333    V: Visit + ?Sized,
1334{
1335    v.visit_expr(&node.expr);
1336}
1337
1338/// Default traversal for [`Path`] nodes. Visits the path's projection.
1339pub fn visit_path<V>(v: &mut V, node: &Path)
1340where
1341    V: Visit + ?Sized,
1342{
1343    v.visit_projection(&node.projection);
1344}
1345
1346/// Default traversal for [`Projection`] nodes. This is a leaf node with no children to visit.
1347pub fn visit_projection<V>(v: &mut V, node: &Projection)
1348where
1349    V: Visit + ?Sized,
1350{
1351}
1352
1353/// Default traversal for [`Returning`] nodes. Visits included paths or expressions based on variant.
1354pub fn visit_returning<V>(v: &mut V, node: &Returning)
1355where
1356    V: Visit + ?Sized,
1357{
1358    match node {
1359        Returning::Model { include } => {
1360            for path in include {
1361                v.visit_path(path);
1362            }
1363        }
1364        Returning::Changed => {}
1365        Returning::Project(expr) => v.visit_expr(expr),
1366        Returning::Expr(expr) => v.visit_expr(expr),
1367    }
1368}
1369
1370/// Default traversal for [`Source`] nodes. Dispatches to model or table source visitor.
1371pub fn visit_source<V>(v: &mut V, node: &Source)
1372where
1373    V: Visit + ?Sized,
1374{
1375    match node {
1376        Source::Model(source_model) => v.visit_source_model(source_model),
1377        Source::Table(source_table) => v.visit_source_table(source_table),
1378    }
1379}
1380
1381/// Default traversal for [`SourceModel`] nodes. Visits the optional association.
1382pub fn visit_source_model<V>(v: &mut V, node: &SourceModel)
1383where
1384    V: Visit + ?Sized,
1385{
1386    if let Some(association) = &node.via {
1387        v.visit_association(association);
1388    }
1389}
1390
1391/// Default traversal for [`SourceTable`] nodes. Visits table references and FROM clauses.
1392pub fn visit_source_table<V>(v: &mut V, node: &SourceTable)
1393where
1394    V: Visit + ?Sized,
1395{
1396    for table_ref in &node.tables {
1397        v.visit_table_ref(table_ref);
1398    }
1399    for table_with_joins in &node.from {
1400        v.visit_table_with_joins(table_with_joins);
1401    }
1402}
1403
1404/// Default traversal for [`SourceTableId`] nodes. This is a leaf node with no children to visit.
1405pub fn visit_source_table_id<V>(v: &mut V, node: &SourceTableId)
1406where
1407    V: Visit + ?Sized,
1408{
1409    // SourceTableId is just an index, nothing to visit
1410}
1411
1412/// Default traversal for [`TableFactor`] nodes. Dispatches based on factor type.
1413pub fn visit_table_factor<V>(v: &mut V, node: &TableFactor)
1414where
1415    V: Visit + ?Sized,
1416{
1417    match node {
1418        TableFactor::Table(table_id) => v.visit_source_table_id(table_id),
1419    }
1420}
1421
1422/// Default traversal for [`Statement`] nodes. Dispatches to the appropriate statement visitor.
1423pub fn visit_stmt<V>(v: &mut V, node: &Statement)
1424where
1425    V: Visit + ?Sized,
1426{
1427    match node {
1428        Statement::Delete(stmt) => v.visit_stmt_delete(stmt),
1429        Statement::Insert(stmt) => v.visit_stmt_insert(stmt),
1430        Statement::Query(stmt) => v.visit_stmt_query(stmt),
1431        Statement::Update(stmt) => v.visit_stmt_update(stmt),
1432    }
1433}
1434
1435/// Default traversal for [`Delete`] nodes. Visits source, filter, and optional returning.
1436pub fn visit_stmt_delete<V>(v: &mut V, node: &Delete)
1437where
1438    V: Visit + ?Sized,
1439{
1440    v.visit_source(&node.from);
1441    v.visit_filter(&node.filter);
1442    v.visit_condition(&node.condition);
1443
1444    if let Some(returning) = &node.returning {
1445        v.visit_returning(returning);
1446    }
1447}
1448
1449/// Default traversal for [`Insert`] nodes. Visits target, source query, and optional returning.
1450pub fn visit_stmt_insert<V>(v: &mut V, node: &Insert)
1451where
1452    V: Visit + ?Sized,
1453{
1454    if let InsertTarget::Scope(scope) = &node.target {
1455        v.visit_stmt_query(scope);
1456    }
1457    v.visit_stmt_query(&node.source);
1458
1459    if let Some(returning) = &node.returning {
1460        v.visit_returning(returning);
1461    }
1462}
1463
1464/// Default traversal for [`Query`] nodes. Visits optional WITH, body, order by, and limit.
1465pub fn visit_stmt_query<V>(v: &mut V, node: &Query)
1466where
1467    V: Visit + ?Sized,
1468{
1469    if let Some(with) = &node.with {
1470        v.visit_with(with);
1471    }
1472
1473    v.visit_expr_set(&node.body);
1474
1475    if let Some(order_by) = &node.order_by {
1476        v.visit_order_by(order_by);
1477    }
1478
1479    if let Some(limit) = &node.limit {
1480        v.visit_limit(limit);
1481    }
1482}
1483
1484/// Default traversal for [`Select`] nodes. Visits source, filter, and returning.
1485pub fn visit_stmt_select<V>(v: &mut V, node: &Select)
1486where
1487    V: Visit + ?Sized,
1488{
1489    v.visit_source(&node.source);
1490    v.visit_filter(&node.filter);
1491    v.visit_returning(&node.returning);
1492}
1493
1494/// Default traversal for [`Update`] nodes. Visits target, assignments, filter, and condition.
1495pub fn visit_stmt_update<V>(v: &mut V, node: &Update)
1496where
1497    V: Visit + ?Sized,
1498{
1499    v.visit_update_target(&node.target);
1500    v.visit_assignments(&node.assignments);
1501    v.visit_filter(&node.filter);
1502    v.visit_condition(&node.condition);
1503}
1504
1505/// Default traversal for [`TableDerived`] nodes. Visits the subquery.
1506pub fn visit_table_derived<V>(v: &mut V, node: &TableDerived)
1507where
1508    V: Visit + ?Sized,
1509{
1510    v.visit_stmt_query(&node.subquery);
1511}
1512
1513/// Default traversal for [`TableRef`] nodes. Dispatches based on reference kind.
1514pub fn visit_table_ref<V>(v: &mut V, node: &TableRef)
1515where
1516    V: Visit + ?Sized,
1517{
1518    match node {
1519        TableRef::Cte { .. } => {}
1520        TableRef::Derived(table_derived) => v.visit_table_derived(table_derived),
1521        TableRef::Table(_) => {}
1522        TableRef::Arg(expr_arg) => v.visit_expr_arg(expr_arg),
1523    }
1524}
1525
1526/// Default traversal for [`TableWithJoins`] nodes. Visits the relation and each join.
1527pub fn visit_table_with_joins<V>(v: &mut V, node: &TableWithJoins)
1528where
1529    V: Visit + ?Sized,
1530{
1531    v.visit_table_factor(&node.relation);
1532    for join in &node.joins {
1533        v.visit_join(join);
1534    }
1535}
1536
1537/// Default traversal for [`Type`] nodes. This is a leaf node with no children to visit.
1538pub fn visit_type<V>(v: &mut V, node: &Type)
1539where
1540    V: Visit + ?Sized,
1541{
1542    // Type is just type information, no traversal needed
1543}
1544
1545/// Default traversal for [`UpdateTarget`] nodes. Visits the query if target is a query.
1546pub fn visit_update_target<V>(v: &mut V, node: &UpdateTarget)
1547where
1548    V: Visit + ?Sized,
1549{
1550    if let UpdateTarget::Query(query) = node {
1551        v.visit_stmt_query(query)
1552    }
1553}
1554
1555/// Default traversal for [`Value`] nodes. Visits inner record if value is a record.
1556pub fn visit_value<V>(v: &mut V, node: &Value)
1557where
1558    V: Visit + ?Sized,
1559{
1560    if let Value::Record(node) = node {
1561        v.visit_value_record(node)
1562    }
1563}
1564
1565/// Default traversal for [`ValueRecord`] nodes. Visits each value in the record.
1566pub fn visit_value_record<V>(v: &mut V, node: &ValueRecord)
1567where
1568    V: Visit + ?Sized,
1569{
1570    for value in node.iter() {
1571        v.visit_value(value);
1572    }
1573}
1574
1575/// Default traversal for [`Values`] nodes. Visits each row expression.
1576pub fn visit_values<V>(v: &mut V, node: &Values)
1577where
1578    V: Visit + ?Sized,
1579{
1580    for expr in &node.rows {
1581        v.visit_expr(expr);
1582    }
1583}
1584
1585/// Default traversal for [`With`] nodes. Visits each CTE.
1586pub fn visit_with<V>(v: &mut V, node: &With)
1587where
1588    V: Visit + ?Sized,
1589{
1590    for cte in &node.ctes {
1591        v.visit_cte(cte);
1592    }
1593}
1594
1595/// Calls `f` for every [`Expr`] node reachable from `node`, in post-order.
1596///
1597/// This is a convenience wrapper that constructs a [`Visit`] implementation
1598/// internally and walks the full AST rooted at `node`.
1599pub fn for_each_expr<F>(node: &impl Node, f: F)
1600where
1601    F: FnMut(&Expr),
1602{
1603    struct ForEach<F> {
1604        f: F,
1605    }
1606
1607    impl<F> Visit for ForEach<F>
1608    where
1609        F: FnMut(&Expr),
1610    {
1611        fn visit_expr(&mut self, node: &Expr) {
1612            visit_expr(self, node);
1613            (self.f)(node);
1614        }
1615    }
1616
1617    node.visit(ForEach { f });
1618}
toasty_core/stmt/visit.rs

toasty_core/stmt/
visit.rs
