toasty_core/stmt/
visit.rs

1#![allow(unused_variables)]
2
3use super::{
4    Assignment, Assignments, Association, Condition, Cte, Delete, Expr, ExprAnd, ExprAny, ExprArg,
5    ExprBinaryOp, ExprCast, ExprColumn, ExprError, ExprExists, ExprFunc, ExprInList,
6    ExprInSubquery, ExprIsNull, ExprIsVariant, ExprLet, ExprList, ExprMap, ExprMatch, ExprNot,
7    ExprOr, ExprProject, ExprRecord, ExprReference, ExprSet, ExprSetOp, ExprStmt, Filter,
8    FuncCount, FuncLastInsertId, Insert, InsertTarget, Join, JoinOp, Limit, Node, Offset, OrderBy,
9    OrderByExpr, Path, Projection, Query, Returning, Select, Source, SourceModel, SourceTable,
10    SourceTableId, Statement, TableDerived, TableFactor, TableRef, TableWithJoins, Type, Update,
11    UpdateTarget, Value, ValueRecord, Values, With,
12};
13
14pub trait Visit {
15    fn visit<N: Node>(&mut self, i: &N)
16    where
17        Self: Sized,
18    {
19        i.visit(self);
20    }
21
22    fn visit_assignment(&mut self, i: &Assignment) {
23        visit_assignment(self, i);
24    }
25
26    fn visit_assignments(&mut self, i: &Assignments) {
27        visit_assignments(self, i);
28    }
29
30    fn visit_association(&mut self, i: &Association) {
31        visit_association(self, i);
32    }
33
34    fn visit_cte(&mut self, i: &Cte) {
35        visit_cte(self, i);
36    }
37
38    fn visit_expr(&mut self, i: &Expr) {
39        visit_expr(self, i);
40    }
41
42    fn visit_expr_and(&mut self, i: &ExprAnd) {
43        visit_expr_and(self, i);
44    }
45
46    fn visit_expr_any(&mut self, i: &ExprAny) {
47        visit_expr_any(self, i);
48    }
49
50    fn visit_expr_arg(&mut self, i: &ExprArg) {
51        visit_expr_arg(self, i);
52    }
53
54    fn visit_expr_binary_op(&mut self, i: &ExprBinaryOp) {
55        visit_expr_binary_op(self, i);
56    }
57
58    fn visit_expr_cast(&mut self, i: &ExprCast) {
59        visit_expr_cast(self, i);
60    }
61
62    fn visit_expr_column(&mut self, i: &ExprColumn) {
63        visit_expr_column(self, i);
64    }
65
66    fn visit_expr_default(&mut self) {
67        visit_expr_default(self);
68    }
69
70    fn visit_expr_error(&mut self, i: &ExprError) {
71        visit_expr_error(self, i);
72    }
73
74    fn visit_expr_exists(&mut self, i: &ExprExists) {
75        visit_expr_exists(self, i);
76    }
77
78    fn visit_expr_func(&mut self, i: &ExprFunc) {
79        visit_expr_func(self, i);
80    }
81
82    fn visit_expr_func_count(&mut self, i: &FuncCount) {
83        visit_expr_func_count(self, i);
84    }
85
86    fn visit_expr_func_last_insert_id(&mut self, i: &FuncLastInsertId) {
87        visit_expr_func_last_insert_id(self, i);
88    }
89
90    fn visit_expr_in_list(&mut self, i: &ExprInList) {
91        visit_expr_in_list(self, i);
92    }
93
94    fn visit_expr_in_subquery(&mut self, i: &ExprInSubquery) {
95        visit_expr_in_subquery(self, i);
96    }
97
98    fn visit_expr_is_null(&mut self, i: &ExprIsNull) {
99        visit_expr_is_null(self, i);
100    }
101
102    fn visit_expr_is_variant(&mut self, i: &ExprIsVariant) {
103        visit_expr_is_variant(self, i);
104    }
105
106    fn visit_expr_let(&mut self, i: &ExprLet) {
107        visit_expr_let(self, i);
108    }
109
110    fn visit_expr_map(&mut self, i: &ExprMap) {
111        visit_expr_map(self, i);
112    }
113
114    fn visit_expr_match(&mut self, i: &ExprMatch) {
115        visit_expr_match(self, i);
116    }
117
118    fn visit_expr_not(&mut self, i: &ExprNot) {
119        visit_expr_not(self, i);
120    }
121
122    fn visit_expr_or(&mut self, i: &ExprOr) {
123        visit_expr_or(self, i);
124    }
125
126    fn visit_expr_list(&mut self, i: &ExprList) {
127        visit_expr_list(self, i);
128    }
129
130    fn visit_expr_record(&mut self, i: &ExprRecord) {
131        visit_expr_record(self, i);
132    }
133
134    fn visit_expr_reference(&mut self, i: &ExprReference) {
135        visit_expr_reference(self, i);
136    }
137
138    fn visit_expr_set(&mut self, i: &ExprSet) {
139        visit_expr_set(self, i);
140    }
141
142    fn visit_expr_set_op(&mut self, i: &ExprSetOp) {
143        visit_expr_set_op(self, i);
144    }
145
146    fn visit_expr_stmt(&mut self, i: &ExprStmt) {
147        visit_expr_stmt(self, i);
148    }
149
150    fn visit_filter(&mut self, i: &Filter) {
151        visit_filter(self, i);
152    }
153
154    fn visit_condition(&mut self, i: &Condition) {
155        visit_condition(self, i);
156    }
157
158    fn visit_expr_project(&mut self, i: &ExprProject) {
159        visit_expr_project(self, i);
160    }
161
162    fn visit_insert_target(&mut self, i: &InsertTarget) {
163        visit_insert_target(self, i);
164    }
165
166    fn visit_join(&mut self, i: &Join) {
167        visit_join(self, i);
168    }
169
170    fn visit_limit(&mut self, i: &Limit) {
171        visit_limit(self, i);
172    }
173
174    fn visit_offset(&mut self, i: &Offset) {
175        visit_offset(self, i);
176    }
177
178    fn visit_order_by(&mut self, i: &OrderBy) {
179        visit_order_by(self, i);
180    }
181
182    fn visit_order_by_expr(&mut self, i: &OrderByExpr) {
183        visit_order_by_expr(self, i);
184    }
185
186    fn visit_path(&mut self, i: &Path) {
187        visit_path(self, i);
188    }
189
190    fn visit_projection(&mut self, i: &Projection) {
191        visit_projection(self, i);
192    }
193
194    fn visit_returning(&mut self, i: &Returning) {
195        visit_returning(self, i);
196    }
197
198    fn visit_source(&mut self, i: &Source) {
199        visit_source(self, i);
200    }
201
202    fn visit_source_model(&mut self, i: &SourceModel) {
203        visit_source_model(self, i);
204    }
205
206    fn visit_source_table(&mut self, i: &SourceTable) {
207        visit_source_table(self, i);
208    }
209
210    fn visit_source_table_id(&mut self, i: &SourceTableId) {
211        visit_source_table_id(self, i);
212    }
213
214    fn visit_stmt(&mut self, i: &Statement) {
215        visit_stmt(self, i);
216    }
217
218    fn visit_stmt_delete(&mut self, i: &Delete) {
219        visit_stmt_delete(self, i);
220    }
221
222    fn visit_stmt_insert(&mut self, i: &Insert) {
223        visit_stmt_insert(self, i);
224    }
225
226    fn visit_stmt_query(&mut self, i: &Query) {
227        visit_stmt_query(self, i);
228    }
229
230    fn visit_stmt_select(&mut self, i: &Select) {
231        visit_stmt_select(self, i);
232    }
233
234    fn visit_stmt_update(&mut self, i: &Update) {
235        visit_stmt_update(self, i);
236    }
237
238    fn visit_table_derived(&mut self, i: &TableDerived) {
239        visit_table_derived(self, i);
240    }
241
242    fn visit_table_ref(&mut self, i: &TableRef) {
243        visit_table_ref(self, i);
244    }
245
246    fn visit_table_factor(&mut self, i: &TableFactor) {
247        visit_table_factor(self, i);
248    }
249
250    fn visit_table_with_joins(&mut self, i: &TableWithJoins) {
251        visit_table_with_joins(self, i);
252    }
253
254    fn visit_type(&mut self, i: &Type) {
255        visit_type(self, i);
256    }
257
258    fn visit_update_target(&mut self, i: &UpdateTarget) {
259        visit_update_target(self, i);
260    }
261
262    fn visit_value(&mut self, i: &Value) {
263        visit_value(self, i);
264    }
265
266    fn visit_value_record(&mut self, i: &ValueRecord) {
267        visit_value_record(self, i);
268    }
269
270    fn visit_values(&mut self, i: &Values) {
271        visit_values(self, i);
272    }
273
274    fn visit_with(&mut self, i: &With) {
275        visit_with(self, i);
276    }
277}
278
279impl<V: Visit> Visit for &mut V {
280    fn visit_assignment(&mut self, i: &Assignment) {
281        Visit::visit_assignment(&mut **self, i);
282    }
283
284    fn visit_assignments(&mut self, i: &Assignments) {
285        Visit::visit_assignments(&mut **self, i);
286    }
287
288    fn visit_association(&mut self, i: &Association) {
289        Visit::visit_association(&mut **self, i);
290    }
291
292    fn visit_cte(&mut self, i: &Cte) {
293        Visit::visit_cte(&mut **self, i);
294    }
295
296    fn visit_expr(&mut self, i: &Expr) {
297        Visit::visit_expr(&mut **self, i);
298    }
299
300    fn visit_expr_and(&mut self, i: &ExprAnd) {
301        Visit::visit_expr_and(&mut **self, i);
302    }
303
304    fn visit_expr_arg(&mut self, i: &ExprArg) {
305        Visit::visit_expr_arg(&mut **self, i);
306    }
307
308    fn visit_expr_binary_op(&mut self, i: &ExprBinaryOp) {
309        Visit::visit_expr_binary_op(&mut **self, i);
310    }
311
312    fn visit_expr_cast(&mut self, i: &ExprCast) {
313        Visit::visit_expr_cast(&mut **self, i);
314    }
315
316    fn visit_expr_column(&mut self, i: &ExprColumn) {
317        Visit::visit_expr_column(&mut **self, i);
318    }
319
320    fn visit_expr_default(&mut self) {
321        Visit::visit_expr_default(&mut **self);
322    }
323
324    fn visit_expr_error(&mut self, i: &ExprError) {
325        Visit::visit_expr_error(&mut **self, i);
326    }
327
328    fn visit_expr_exists(&mut self, i: &ExprExists) {
329        Visit::visit_expr_exists(&mut **self, i);
330    }
331
332    fn visit_expr_func(&mut self, i: &ExprFunc) {
333        Visit::visit_expr_func(&mut **self, i);
334    }
335
336    fn visit_expr_func_count(&mut self, i: &FuncCount) {
337        Visit::visit_expr_func_count(&mut **self, i);
338    }
339
340    fn visit_expr_in_list(&mut self, i: &ExprInList) {
341        Visit::visit_expr_in_list(&mut **self, i);
342    }
343
344    fn visit_expr_in_subquery(&mut self, i: &ExprInSubquery) {
345        Visit::visit_expr_in_subquery(&mut **self, i);
346    }
347
348    fn visit_expr_is_null(&mut self, i: &ExprIsNull) {
349        Visit::visit_expr_is_null(&mut **self, i);
350    }
351
352    fn visit_expr_is_variant(&mut self, i: &ExprIsVariant) {
353        Visit::visit_expr_is_variant(&mut **self, i);
354    }
355
356    fn visit_expr_let(&mut self, i: &ExprLet) {
357        Visit::visit_expr_let(&mut **self, i);
358    }
359
360    fn visit_expr_map(&mut self, i: &ExprMap) {
361        Visit::visit_expr_map(&mut **self, i);
362    }
363
364    fn visit_expr_match(&mut self, i: &ExprMatch) {
365        Visit::visit_expr_match(&mut **self, i);
366    }
367
368    fn visit_expr_not(&mut self, i: &ExprNot) {
369        Visit::visit_expr_not(&mut **self, i);
370    }
371
372    fn visit_expr_or(&mut self, i: &ExprOr) {
373        Visit::visit_expr_or(&mut **self, i);
374    }
375
376    fn visit_expr_list(&mut self, i: &ExprList) {
377        Visit::visit_expr_list(&mut **self, i);
378    }
379
380    fn visit_expr_record(&mut self, i: &ExprRecord) {
381        Visit::visit_expr_record(&mut **self, i);
382    }
383
384    fn visit_expr_reference(&mut self, i: &ExprReference) {
385        Visit::visit_expr_reference(&mut **self, i);
386    }
387
388    fn visit_expr_set(&mut self, i: &ExprSet) {
389        Visit::visit_expr_set(&mut **self, i);
390    }
391
392    fn visit_expr_set_op(&mut self, i: &ExprSetOp) {
393        Visit::visit_expr_set_op(&mut **self, i);
394    }
395
396    fn visit_expr_stmt(&mut self, i: &ExprStmt) {
397        Visit::visit_expr_stmt(&mut **self, i);
398    }
399
400    fn visit_filter(&mut self, i: &Filter) {
401        Visit::visit_filter(&mut **self, i);
402    }
403
404    fn visit_condition(&mut self, i: &Condition) {
405        Visit::visit_condition(&mut **self, i);
406    }
407
408    fn visit_expr_project(&mut self, i: &ExprProject) {
409        Visit::visit_expr_project(&mut **self, i);
410    }
411
412    fn visit_insert_target(&mut self, i: &InsertTarget) {
413        Visit::visit_insert_target(&mut **self, i);
414    }
415
416    fn visit_join(&mut self, i: &Join) {
417        Visit::visit_join(&mut **self, i);
418    }
419
420    fn visit_limit(&mut self, i: &Limit) {
421        Visit::visit_limit(&mut **self, i);
422    }
423
424    fn visit_offset(&mut self, i: &Offset) {
425        Visit::visit_offset(&mut **self, i);
426    }
427
428    fn visit_order_by(&mut self, i: &OrderBy) {
429        Visit::visit_order_by(&mut **self, i);
430    }
431
432    fn visit_order_by_expr(&mut self, i: &OrderByExpr) {
433        Visit::visit_order_by_expr(&mut **self, i);
434    }
435
436    fn visit_path(&mut self, i: &Path) {
437        Visit::visit_path(&mut **self, i);
438    }
439
440    fn visit_projection(&mut self, i: &Projection) {
441        Visit::visit_projection(&mut **self, i);
442    }
443
444    fn visit_returning(&mut self, i: &Returning) {
445        Visit::visit_returning(&mut **self, i);
446    }
447
448    fn visit_source(&mut self, i: &Source) {
449        Visit::visit_source(&mut **self, i);
450    }
451
452    fn visit_source_model(&mut self, i: &SourceModel) {
453        Visit::visit_source_model(&mut **self, i);
454    }
455
456    fn visit_source_table(&mut self, i: &SourceTable) {
457        Visit::visit_source_table(&mut **self, i);
458    }
459
460    fn visit_source_table_id(&mut self, i: &SourceTableId) {
461        Visit::visit_source_table_id(&mut **self, i);
462    }
463
464    fn visit_stmt(&mut self, i: &Statement) {
465        Visit::visit_stmt(&mut **self, i);
466    }
467
468    fn visit_stmt_delete(&mut self, i: &Delete) {
469        Visit::visit_stmt_delete(&mut **self, i);
470    }
471
472    fn visit_stmt_insert(&mut self, i: &Insert) {
473        Visit::visit_stmt_insert(&mut **self, i);
474    }
475
476    fn visit_stmt_query(&mut self, i: &Query) {
477        Visit::visit_stmt_query(&mut **self, i);
478    }
479
480    fn visit_stmt_select(&mut self, i: &Select) {
481        Visit::visit_stmt_select(&mut **self, i);
482    }
483
484    fn visit_stmt_update(&mut self, i: &Update) {
485        Visit::visit_stmt_update(&mut **self, i);
486    }
487
488    fn visit_table_derived(&mut self, i: &TableDerived) {
489        Visit::visit_table_derived(&mut **self, i);
490    }
491
492    fn visit_table_ref(&mut self, i: &TableRef) {
493        Visit::visit_table_ref(&mut **self, i);
494    }
495
496    fn visit_table_factor(&mut self, i: &TableFactor) {
497        Visit::visit_table_factor(&mut **self, i);
498    }
499
500    fn visit_table_with_joins(&mut self, i: &TableWithJoins) {
501        Visit::visit_table_with_joins(&mut **self, i);
502    }
503
504    fn visit_type(&mut self, i: &Type) {
505        Visit::visit_type(&mut **self, i);
506    }
507
508    fn visit_update_target(&mut self, i: &UpdateTarget) {
509        Visit::visit_update_target(&mut **self, i);
510    }
511
512    fn visit_value(&mut self, i: &Value) {
513        Visit::visit_value(&mut **self, i);
514    }
515
516    fn visit_value_record(&mut self, i: &ValueRecord) {
517        Visit::visit_value_record(&mut **self, i);
518    }
519
520    fn visit_values(&mut self, i: &Values) {
521        Visit::visit_values(&mut **self, i);
522    }
523
524    fn visit_with(&mut self, i: &With) {
525        Visit::visit_with(&mut **self, i);
526    }
527}
528
529pub fn visit_assignment<V>(v: &mut V, node: &Assignment)
530where
531    V: Visit + ?Sized,
532{
533    v.visit_expr(&node.expr);
534}
535
536pub fn visit_assignments<V>(v: &mut V, node: &Assignments)
537where
538    V: Visit + ?Sized,
539{
540    for (_, assignment) in node.iter() {
541        v.visit_assignment(assignment);
542    }
543}
544
545pub fn visit_association<V>(v: &mut V, node: &Association)
546where
547    V: Visit + ?Sized,
548{
549    v.visit_stmt_query(&node.source);
550}
551
552pub fn visit_cte<V>(v: &mut V, node: &Cte)
553where
554    V: Visit + ?Sized,
555{
556    v.visit_stmt_query(&node.query);
557}
558
559pub fn visit_expr<V>(v: &mut V, node: &Expr)
560where
561    V: Visit + ?Sized,
562{
563    match node {
564        Expr::And(expr) => v.visit_expr_and(expr),
565        Expr::Any(expr) => v.visit_expr_any(expr),
566        Expr::Arg(expr) => v.visit_expr_arg(expr),
567        Expr::BinaryOp(expr) => v.visit_expr_binary_op(expr),
568        Expr::Cast(expr) => v.visit_expr_cast(expr),
569        Expr::Default => v.visit_expr_default(),
570        Expr::Error(expr) => v.visit_expr_error(expr),
571        Expr::Exists(expr) => v.visit_expr_exists(expr),
572        Expr::Func(expr) => v.visit_expr_func(expr),
573        Expr::InList(expr) => v.visit_expr_in_list(expr),
574        Expr::InSubquery(expr) => v.visit_expr_in_subquery(expr),
575        Expr::IsNull(expr) => v.visit_expr_is_null(expr),
576        Expr::IsVariant(expr) => v.visit_expr_is_variant(expr),
577        Expr::Let(expr) => v.visit_expr_let(expr),
578        Expr::Map(expr) => v.visit_expr_map(expr),
579        Expr::Match(expr) => v.visit_expr_match(expr),
580        Expr::Not(expr) => v.visit_expr_not(expr),
581        Expr::Or(expr) => v.visit_expr_or(expr),
582        Expr::Project(expr) => v.visit_expr_project(expr),
583        Expr::Record(expr) => v.visit_expr_record(expr),
584        Expr::Reference(expr) => v.visit_expr_reference(expr),
585        Expr::List(expr) => v.visit_expr_list(expr),
586        Expr::Stmt(expr) => v.visit_expr_stmt(expr),
587        Expr::Value(expr) => v.visit_value(expr),
588    }
589}
590
591pub fn visit_expr_and<V>(v: &mut V, node: &ExprAnd)
592where
593    V: Visit + ?Sized,
594{
595    for expr in node {
596        v.visit_expr(expr);
597    }
598}
599
600pub fn visit_expr_any<V>(v: &mut V, node: &ExprAny)
601where
602    V: Visit + ?Sized,
603{
604    v.visit_expr(&node.expr);
605}
606
607pub fn visit_expr_arg<V>(v: &mut V, node: &ExprArg)
608where
609    V: Visit + ?Sized,
610{
611}
612
613pub fn visit_expr_binary_op<V>(v: &mut V, node: &ExprBinaryOp)
614where
615    V: Visit + ?Sized,
616{
617    v.visit_expr(&node.lhs);
618    v.visit_expr(&node.rhs);
619}
620
621pub fn visit_expr_cast<V>(v: &mut V, node: &ExprCast)
622where
623    V: Visit + ?Sized,
624{
625    v.visit_expr(&node.expr);
626    v.visit_type(&node.ty);
627}
628
629pub fn visit_expr_column<V>(v: &mut V, node: &ExprColumn)
630where
631    V: Visit + ?Sized,
632{
633}
634
635pub fn visit_expr_default<V>(v: &mut V)
636where
637    V: Visit + ?Sized,
638{
639}
640
641pub fn visit_expr_error<V>(v: &mut V, node: &ExprError)
642where
643    V: Visit + ?Sized,
644{
645    // ExprError has no child expressions to visit
646}
647
648pub fn visit_expr_exists<V>(v: &mut V, node: &ExprExists)
649where
650    V: Visit + ?Sized,
651{
652    v.visit_stmt_query(&node.subquery);
653}
654
655pub fn visit_expr_func<V>(v: &mut V, node: &ExprFunc)
656where
657    V: Visit + ?Sized,
658{
659    match node {
660        ExprFunc::Count(func) => v.visit_expr_func_count(func),
661        ExprFunc::LastInsertId(func) => v.visit_expr_func_last_insert_id(func),
662    }
663}
664
665pub fn visit_expr_func_count<V>(v: &mut V, node: &FuncCount)
666where
667    V: Visit + ?Sized,
668{
669    if let Some(expr) = &node.arg {
670        v.visit_expr(expr);
671    }
672
673    if let Some(expr) = &node.filter {
674        v.visit_expr(expr);
675    }
676}
677
678pub fn visit_expr_func_last_insert_id<V>(_v: &mut V, _node: &FuncLastInsertId)
679where
680    V: Visit + ?Sized,
681{
682    // FuncLastInsertId has no fields to visit
683}
684
685pub fn visit_expr_in_list<V>(v: &mut V, node: &ExprInList)
686where
687    V: Visit + ?Sized,
688{
689    v.visit_expr(&node.expr);
690    v.visit_expr(&node.list);
691}
692
693pub fn visit_expr_in_subquery<V>(v: &mut V, node: &ExprInSubquery)
694where
695    V: Visit + ?Sized,
696{
697    v.visit_expr(&node.expr);
698    v.visit_stmt_query(&node.query);
699}
700
701pub fn visit_expr_is_null<V>(v: &mut V, node: &ExprIsNull)
702where
703    V: Visit + ?Sized,
704{
705    v.visit_expr(&node.expr);
706}
707
708pub fn visit_expr_is_variant<V>(v: &mut V, node: &ExprIsVariant)
709where
710    V: Visit + ?Sized,
711{
712    v.visit_expr(&node.expr);
713}
714
715pub fn visit_expr_let<V>(v: &mut V, node: &ExprLet)
716where
717    V: Visit + ?Sized,
718{
719    for binding in &node.bindings {
720        v.visit_expr(binding);
721    }
722    v.visit_expr(&node.body);
723}
724
725pub fn visit_expr_map<V>(v: &mut V, node: &ExprMap)
726where
727    V: Visit + ?Sized,
728{
729    v.visit_expr(&node.base);
730    v.visit_expr(&node.map);
731}
732
733pub fn visit_expr_match<V>(v: &mut V, node: &ExprMatch)
734where
735    V: Visit + ?Sized,
736{
737    v.visit_expr(&node.subject);
738    for arm in &node.arms {
739        v.visit_expr(&arm.expr);
740    }
741    v.visit_expr(&node.else_expr);
742}
743
744pub fn visit_expr_not<V>(v: &mut V, node: &ExprNot)
745where
746    V: Visit + ?Sized,
747{
748    v.visit_expr(&node.expr);
749}
750
751pub fn visit_expr_or<V>(v: &mut V, node: &ExprOr)
752where
753    V: Visit + ?Sized,
754{
755    for expr in node {
756        v.visit_expr(expr);
757    }
758}
759
760pub fn visit_expr_list<V>(v: &mut V, node: &ExprList)
761where
762    V: Visit + ?Sized,
763{
764    for expr in &node.items {
765        v.visit_expr(expr);
766    }
767}
768
769pub fn visit_expr_record<V>(v: &mut V, node: &ExprRecord)
770where
771    V: Visit + ?Sized,
772{
773    for expr in &**node {
774        v.visit_expr(expr);
775    }
776}
777
778pub fn visit_expr_reference<V>(v: &mut V, node: &ExprReference)
779where
780    V: Visit + ?Sized,
781{
782    match node {
783        ExprReference::Model { .. } => {}
784        ExprReference::Field { .. } => {}
785        ExprReference::Column(expr_column) => v.visit_expr_column(expr_column),
786    }
787}
788
789pub fn visit_expr_set<V>(v: &mut V, node: &ExprSet)
790where
791    V: Visit + ?Sized,
792{
793    match node {
794        ExprSet::Select(expr) => v.visit_stmt_select(expr),
795        ExprSet::SetOp(expr) => v.visit_expr_set_op(expr),
796        ExprSet::Update(expr) => v.visit_stmt_update(expr),
797        ExprSet::Values(expr) => v.visit_values(expr),
798        ExprSet::Insert(expr) => v.visit_stmt_insert(expr),
799    }
800}
801
802pub fn visit_expr_set_op<V>(v: &mut V, node: &ExprSetOp)
803where
804    V: Visit + ?Sized,
805{
806    for operand in &node.operands {
807        v.visit_expr_set(operand);
808    }
809}
810
811pub fn visit_expr_stmt<V>(v: &mut V, node: &ExprStmt)
812where
813    V: Visit + ?Sized,
814{
815    v.visit_stmt(&node.stmt);
816}
817
818pub fn visit_expr_project<V>(v: &mut V, node: &ExprProject)
819where
820    V: Visit + ?Sized,
821{
822    v.visit_expr(&node.base);
823    v.visit_projection(&node.projection);
824}
825
826pub fn visit_filter<V>(v: &mut V, node: &Filter)
827where
828    V: Visit + ?Sized,
829{
830    if let Some(expr) = &node.expr {
831        v.visit_expr(expr);
832    }
833}
834
835pub fn visit_condition<V>(v: &mut V, node: &Condition)
836where
837    V: Visit + ?Sized,
838{
839    if let Some(expr) = &node.expr {
840        v.visit_expr(expr);
841    }
842}
843
844pub fn visit_insert_target<V>(v: &mut V, node: &InsertTarget)
845where
846    V: Visit + ?Sized,
847{
848    if let InsertTarget::Scope(stmt) = node {
849        v.visit_stmt_query(stmt);
850    }
851}
852
853pub fn visit_join<V>(v: &mut V, node: &Join)
854where
855    V: Visit + ?Sized,
856{
857    v.visit_source_table_id(&node.table);
858    match &node.constraint {
859        JoinOp::Left(expr) => v.visit_expr(expr),
860    }
861}
862
863pub fn visit_limit<V>(v: &mut V, node: &Limit)
864where
865    V: Visit + ?Sized,
866{
867    v.visit_expr(&node.limit);
868
869    if let Some(offset) = &node.offset {
870        v.visit_offset(offset);
871    }
872}
873
874pub fn visit_offset<V>(v: &mut V, node: &Offset)
875where
876    V: Visit + ?Sized,
877{
878    match node {
879        Offset::After(expr) => v.visit_expr(expr),
880        Offset::Count(expr) => v.visit_expr(expr),
881    }
882}
883
884pub fn visit_order_by<V>(v: &mut V, node: &OrderBy)
885where
886    V: Visit + ?Sized,
887{
888    for expr in &node.exprs {
889        v.visit_order_by_expr(expr);
890    }
891}
892
893pub fn visit_order_by_expr<V>(v: &mut V, node: &OrderByExpr)
894where
895    V: Visit + ?Sized,
896{
897    v.visit_expr(&node.expr);
898}
899
900pub fn visit_path<V>(v: &mut V, node: &Path)
901where
902    V: Visit + ?Sized,
903{
904    v.visit_projection(&node.projection);
905}
906
907pub fn visit_projection<V>(v: &mut V, node: &Projection)
908where
909    V: Visit + ?Sized,
910{
911}
912
913pub fn visit_returning<V>(v: &mut V, node: &Returning)
914where
915    V: Visit + ?Sized,
916{
917    match node {
918        Returning::Model { include } => {
919            for path in include {
920                v.visit_path(path);
921            }
922        }
923        Returning::Changed => {}
924        Returning::Expr(expr) => v.visit_expr(expr),
925        Returning::Value(expr) => v.visit_expr(expr),
926    }
927}
928
929pub fn visit_source<V>(v: &mut V, node: &Source)
930where
931    V: Visit + ?Sized,
932{
933    match node {
934        Source::Model(source_model) => v.visit_source_model(source_model),
935        Source::Table(source_table) => v.visit_source_table(source_table),
936    }
937}
938
939pub fn visit_source_model<V>(v: &mut V, node: &SourceModel)
940where
941    V: Visit + ?Sized,
942{
943    if let Some(association) = &node.via {
944        v.visit_association(association);
945    }
946}
947
948pub fn visit_source_table<V>(v: &mut V, node: &SourceTable)
949where
950    V: Visit + ?Sized,
951{
952    for table_ref in &node.tables {
953        v.visit_table_ref(table_ref);
954    }
955    for table_with_joins in &node.from {
956        v.visit_table_with_joins(table_with_joins);
957    }
958}
959
960pub fn visit_source_table_id<V>(v: &mut V, node: &SourceTableId)
961where
962    V: Visit + ?Sized,
963{
964    // SourceTableId is just an index, nothing to visit
965}
966
967pub fn visit_table_factor<V>(v: &mut V, node: &TableFactor)
968where
969    V: Visit + ?Sized,
970{
971    match node {
972        TableFactor::Table(table_id) => v.visit_source_table_id(table_id),
973    }
974}
975
976pub fn visit_stmt<V>(v: &mut V, node: &Statement)
977where
978    V: Visit + ?Sized,
979{
980    match node {
981        Statement::Delete(stmt) => v.visit_stmt_delete(stmt),
982        Statement::Insert(stmt) => v.visit_stmt_insert(stmt),
983        Statement::Query(stmt) => v.visit_stmt_query(stmt),
984        Statement::Update(stmt) => v.visit_stmt_update(stmt),
985    }
986}
987
988pub fn visit_stmt_delete<V>(v: &mut V, node: &Delete)
989where
990    V: Visit + ?Sized,
991{
992    v.visit_source(&node.from);
993    v.visit_filter(&node.filter);
994
995    if let Some(returning) = &node.returning {
996        v.visit_returning(returning);
997    }
998}
999
1000pub fn visit_stmt_insert<V>(v: &mut V, node: &Insert)
1001where
1002    V: Visit + ?Sized,
1003{
1004    if let InsertTarget::Scope(scope) = &node.target {
1005        v.visit_stmt_query(scope);
1006    }
1007    v.visit_stmt_query(&node.source);
1008
1009    if let Some(returning) = &node.returning {
1010        v.visit_returning(returning);
1011    }
1012}
1013
1014pub fn visit_stmt_query<V>(v: &mut V, node: &Query)
1015where
1016    V: Visit + ?Sized,
1017{
1018    if let Some(with) = &node.with {
1019        v.visit_with(with);
1020    }
1021
1022    v.visit_expr_set(&node.body);
1023
1024    if let Some(order_by) = &node.order_by {
1025        v.visit_order_by(order_by);
1026    }
1027
1028    if let Some(limit) = &node.limit {
1029        v.visit_limit(limit);
1030    }
1031}
1032
1033pub fn visit_stmt_select<V>(v: &mut V, node: &Select)
1034where
1035    V: Visit + ?Sized,
1036{
1037    v.visit_source(&node.source);
1038    v.visit_filter(&node.filter);
1039    v.visit_returning(&node.returning);
1040}
1041
1042pub fn visit_stmt_update<V>(v: &mut V, node: &Update)
1043where
1044    V: Visit + ?Sized,
1045{
1046    v.visit_update_target(&node.target);
1047    v.visit_assignments(&node.assignments);
1048    v.visit_filter(&node.filter);
1049    v.visit_condition(&node.condition);
1050}
1051
1052pub fn visit_table_derived<V>(v: &mut V, node: &TableDerived)
1053where
1054    V: Visit + ?Sized,
1055{
1056    v.visit_stmt_query(&node.subquery);
1057}
1058
1059pub fn visit_table_ref<V>(v: &mut V, node: &TableRef)
1060where
1061    V: Visit + ?Sized,
1062{
1063    match node {
1064        TableRef::Cte { .. } => {}
1065        TableRef::Derived(table_derived) => v.visit_table_derived(table_derived),
1066        TableRef::Table(_) => {}
1067        TableRef::Arg(expr_arg) => v.visit_expr_arg(expr_arg),
1068    }
1069}
1070
1071pub fn visit_table_with_joins<V>(v: &mut V, node: &TableWithJoins)
1072where
1073    V: Visit + ?Sized,
1074{
1075    v.visit_table_factor(&node.relation);
1076    for join in &node.joins {
1077        v.visit_join(join);
1078    }
1079}
1080
1081pub fn visit_type<V>(v: &mut V, node: &Type)
1082where
1083    V: Visit + ?Sized,
1084{
1085    // Type is just type information, no traversal needed
1086}
1087
1088pub fn visit_update_target<V>(v: &mut V, node: &UpdateTarget)
1089where
1090    V: Visit + ?Sized,
1091{
1092    if let UpdateTarget::Query(query) = node {
1093        v.visit_stmt_query(query)
1094    }
1095}
1096
1097pub fn visit_value<V>(v: &mut V, node: &Value)
1098where
1099    V: Visit + ?Sized,
1100{
1101    if let Value::Record(node) = node {
1102        v.visit_value_record(node)
1103    }
1104}
1105
1106pub fn visit_value_record<V>(v: &mut V, node: &ValueRecord)
1107where
1108    V: Visit + ?Sized,
1109{
1110    for value in node.iter() {
1111        v.visit_value(value);
1112    }
1113}
1114
1115pub fn visit_values<V>(v: &mut V, node: &Values)
1116where
1117    V: Visit + ?Sized,
1118{
1119    for expr in &node.rows {
1120        v.visit_expr(expr);
1121    }
1122}
1123
1124pub fn visit_with<V>(v: &mut V, node: &With)
1125where
1126    V: Visit + ?Sized,
1127{
1128    for cte in &node.ctes {
1129        v.visit_cte(cte);
1130    }
1131}
1132
1133pub fn for_each_expr<F>(node: &impl Node, f: F)
1134where
1135    F: FnMut(&Expr),
1136{
1137    struct ForEach<F> {
1138        f: F,
1139    }
1140
1141    impl<F> Visit for ForEach<F>
1142    where
1143        F: FnMut(&Expr),
1144    {
1145        fn visit_expr(&mut self, node: &Expr) {
1146            visit_expr(self, node);
1147            (self.f)(node);
1148        }
1149    }
1150
1151    node.visit(ForEach { f });
1152}
toasty_core/stmt/visit.rs

toasty_core/stmt/
visit.rs
