Skip to main content

uqa_sql/plan/mutable/
traversal.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Consuming query visitation retains the existing ownership order and can stop at a query root.
8
9use super::{
10    CommandQuerySlot, MutableCommandPlan, MutableExecutablePlan, MutableQueryPlan,
11    MutableSourcePlan, QueryChildSlot, SourceChildSlot,
12};
13use crate::{
14    plan::{CommandPlan, RelationalPlan, SourcePlan},
15    SQLError,
16};
17use uqa_core::memory::ProductionControl;
18
19type Visitor<'a> = dyn FnMut(MutableQueryPlan) -> Result<(MutableQueryPlan, bool), SQLError> + 'a;
20
21impl MutableExecutablePlan {
22    /// Visit query owners in pre-order. The callback's boolean selects whether to recurse into the returned query's owned children.
23    pub fn map_queries_while(
24        self,
25        control: &ProductionControl<'_>,
26        visit: &mut Visitor<'_>,
27    ) -> Result<Self, SQLError> {
28        control.check()?;
29        Ok(match self {
30            Self::Query(query) => Self::Query(query.map_queries_while(control, visit)?),
31            Self::Command(command) => Self::Command(command.map_queries_while(control, visit)?),
32        })
33    }
34}
35
36impl MutableQueryPlan {
37    pub fn map_queries_while(
38        self,
39        control: &ProductionControl<'_>,
40        visit: &mut Visitor<'_>,
41    ) -> Result<Self, SQLError> {
42        self.assert_owner(control);
43        control.check()?;
44        let (mut query, descend) = visit(self)?;
45        query.assert_owner(control);
46        control.check()?;
47        if !descend {
48            return Ok(query);
49        }
50        for index in 0..query.ctes.len() {
51            query = query.map_cte(index, control, |body| {
52                body.map_queries_while(control, visit)
53            })?;
54        }
55        match &query.root {
56            RelationalPlan::QueryBlock(_) => {
57                query =
58                    query.map_source(control, |source| source_queries(source, control, visit))?;
59            }
60            RelationalPlan::SetOp { .. } => {
61                query = query.map_query_child(QueryChildSlot::Left, control, |query| {
62                    query.map_queries_while(control, visit)
63                })?;
64                query = query.map_query_child(QueryChildSlot::Right, control, |query| {
65                    query.map_queries_while(control, visit)
66                })?;
67            }
68            RelationalPlan::Values { .. } => {}
69        }
70        let count = match &query.root {
71            RelationalPlan::QueryBlock(block) => block.subqueries.len(),
72            RelationalPlan::SetOp { subqueries, .. }
73            | RelationalPlan::Values { subqueries, .. } => subqueries.len(),
74        };
75        for index in 0..count {
76            query = query.map_query_child(QueryChildSlot::Subquery(index), control, |query| {
77                query.map_queries_while(control, visit)
78            })?;
79        }
80        Ok(query)
81    }
82}
83
84impl MutableCommandPlan {
85    pub fn map_queries_while(
86        mut self,
87        control: &ProductionControl<'_>,
88        visit: &mut Visitor<'_>,
89    ) -> Result<Self, SQLError> {
90        self.assert_owner(control);
91        control.check()?;
92        match &*self {
93            CommandPlan::CreateView { .. }
94            | CommandPlan::CreateTableAs { .. }
95            | CommandPlan::CreateMaterializedView { .. }
96            | CommandPlan::DeclareCursor { .. } => {
97                return self
98                    .map_query_body(control, |query| query.map_queries_while(control, visit));
99            }
100            CommandPlan::Explain { .. } | CommandPlan::Prepare { .. } => {
101                return self
102                    .map_executable_body(control, |body| body.map_queries_while(control, visit));
103            }
104            CommandPlan::Call { args, .. } => {
105                let count = args.len();
106                for argument in 0..count {
107                    let CommandPlan::Call { args, .. } = &*self else {
108                        unreachable!()
109                    };
110                    for query in 0..args[argument].subqueries.len() {
111                        self = self.map_query_child(
112                            CommandQuerySlot::CallArgumentSubquery { argument, query },
113                            control,
114                            |query| query.map_queries_while(control, visit),
115                        )?;
116                    }
117                }
118                return Ok(self);
119            }
120            CommandPlan::Execute { params, .. } => {
121                let count = params.len();
122                for parameter in 0..count {
123                    let CommandPlan::Execute { params, .. } = &*self else {
124                        unreachable!()
125                    };
126                    for query in 0..params[parameter].subqueries.len() {
127                        self = self.map_query_child(
128                            CommandQuerySlot::ExecuteParameterSubquery { parameter, query },
129                            control,
130                            |query| query.map_queries_while(control, visit),
131                        )?;
132                    }
133                }
134                return Ok(self);
135            }
136            _ => {}
137        }
138        for index in 0..self.ctes().len() {
139            self = self.map_cte(index, control, |body| {
140                body.map_queries_while(control, visit)
141            })?;
142        }
143        let (insert, count) = match &*self {
144            CommandPlan::Insert(plan) => (plan.source.is_some(), plan.subqueries.len()),
145            CommandPlan::Update(plan) => (false, plan.subqueries.len()),
146            CommandPlan::Delete(plan) => (false, plan.subqueries.len()),
147            CommandPlan::Merge(plan) => (false, plan.subqueries.len()),
148            _ => (false, 0),
149        };
150        if insert {
151            self = self.map_query_child(CommandQuerySlot::InsertSource, control, |query| {
152                query.map_queries_while(control, visit)
153            })?;
154        }
155        for index in 0..count {
156            self = self.map_query_child(CommandQuerySlot::Subquery(index), control, |query| {
157                query.map_queries_while(control, visit)
158            })?;
159        }
160        self.map_source(control, |source| source_queries(source, control, visit))
161    }
162}
163
164fn source_queries(
165    mut source: MutableSourcePlan,
166    control: &ProductionControl<'_>,
167    visit: &mut Visitor<'_>,
168) -> Result<MutableSourcePlan, SQLError> {
169    match &*source {
170        SourcePlan::Subquery { .. }
171        | SourcePlan::Table {
172            executable_query: Some(_),
173            ..
174        } => source.map_query(control, |query| query.map_queries_while(control, visit)),
175        SourcePlan::Join { .. } => {
176            source = source.map_child(SourceChildSlot::Left, control, |source| {
177                source_queries(source, control, visit)
178            })?;
179            source.map_child(SourceChildSlot::Right, control, |source| {
180                source_queries(source, control, visit)
181            })
182        }
183        _ => Ok(source),
184    }
185}