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

toasty_core/stmt/
visit.rs
