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

toasty_core/stmt/
visit.rs
