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

toasty_core/stmt/
visit.rs
