Skip to main content

uqa_sql/plan/
query_visit.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Mutable query traversal without moving the analyzed syntax nodes.
8
9use super::{
10    CommandPlan, CtePlan, CtePlanBody, QueryPlan, RelationalPlan, SourcePlan, UnifiedPlan,
11};
12
13impl UnifiedPlan {
14    pub fn visit_queries_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
15        self.visit_queries_while_mut(&mut |query| {
16            visit(query);
17            true
18        });
19    }
20
21    /// Visit command-owned query roots without descending into their query children.
22    pub fn visit_query_roots_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
23        self.visit_queries_while_mut(&mut |query| {
24            visit(query);
25            false
26        });
27    }
28
29    fn visit_queries_while_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan) -> bool) {
30        match self {
31            Self::Query(query) => query.visit_queries_while_mut(visit),
32            Self::Command(command) => visit_command(command, visit),
33        }
34    }
35}
36
37fn visit_ctes(ctes: &mut [CtePlan], visit: &mut dyn FnMut(&mut QueryPlan) -> bool) {
38    for cte in ctes {
39        match &mut cte.body {
40            CtePlanBody::Query(query) => query.visit_queries_while_mut(visit),
41            CtePlanBody::Command(command) => visit_command(command, visit),
42        }
43    }
44}
45
46fn visit_command(command: &mut CommandPlan, visit: &mut dyn FnMut(&mut QueryPlan) -> bool) {
47    match command {
48        CommandPlan::CreateView { query, .. }
49        | CommandPlan::CreateTableAs { query, .. }
50        | CommandPlan::CreateMaterializedView { query, .. }
51        | CommandPlan::DeclareCursor { query, .. } => {
52            query.visit_queries_while_mut(visit);
53            return;
54        }
55        CommandPlan::Explain { body, .. } | CommandPlan::Prepare { body, .. } => {
56            body.visit_queries_while_mut(visit);
57            return;
58        }
59        CommandPlan::Execute { params, .. } | CommandPlan::Call { args: params, .. } => {
60            for expression in params {
61                for query in &mut expression.subqueries {
62                    query.visit_queries_while_mut(visit);
63                }
64            }
65            return;
66        }
67        _ => {}
68    }
69    if let Some(ctes) = command.ctes_mut() {
70        visit_ctes(ctes, visit);
71    }
72    for query in command.query_inputs_mut() {
73        query.visit_queries_while_mut(visit);
74    }
75    if let Some(source) = command.source_input_mut() {
76        visit_source(source, visit);
77    }
78}
79
80impl QueryPlan {
81    pub fn visit_queries_mut(&mut self, visit: &mut dyn FnMut(&mut Self)) {
82        self.visit_queries_while_mut(&mut |query| {
83            visit(query);
84            true
85        });
86    }
87
88    fn visit_queries_while_mut(&mut self, visit: &mut dyn FnMut(&mut Self) -> bool) {
89        if !visit(self) {
90            return;
91        }
92        visit_ctes(&mut self.ctes, visit);
93        let subqueries = match &mut self.root {
94            RelationalPlan::QueryBlock(block) => {
95                if let Some(source) = &mut block.from {
96                    visit_source(source, visit);
97                }
98                &mut block.subqueries
99            }
100            RelationalPlan::SetOp {
101                left,
102                right,
103                subqueries,
104                ..
105            } => {
106                left.visit_queries_while_mut(visit);
107                right.visit_queries_while_mut(visit);
108                subqueries
109            }
110            RelationalPlan::Values { subqueries, .. } => subqueries,
111        };
112        for query in subqueries {
113            query.visit_queries_while_mut(visit);
114        }
115    }
116}
117
118fn visit_source(source: &mut SourcePlan, visit: &mut dyn FnMut(&mut QueryPlan) -> bool) {
119    match source {
120        SourcePlan::Subquery { body, .. } => body.visit_queries_while_mut(visit),
121        SourcePlan::Table {
122            executable_query: Some(body),
123            ..
124        } => body.visit_queries_while_mut(visit),
125        SourcePlan::Join { left, right, .. } => {
126            visit_source(left, visit);
127            visit_source(right, visit);
128        }
129        _ => {}
130    }
131}
132
133impl CommandPlan {
134    pub fn visit_query_roots_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
135        visit_command(self, &mut |query| {
136            visit(query);
137            false
138        });
139    }
140}