toasty_core/stmt/
visit.rs

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

toasty_core/stmt/
visit.rs
