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.try_visit_queries_mut(&mut |query| {
16            visit(query);
17            Ok::<_, std::convert::Infallible>(())
18        })
19        .unwrap_or_else(|never| match never {});
20    }
21
22    /// Visit command-owned query roots without descending into their query children.
23    pub fn visit_query_roots_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
24        self.visit_queries_while_mut(&mut |query| {
25            visit(query);
26            Ok::<_, std::convert::Infallible>(false)
27        })
28        .unwrap_or_else(|never| match never {});
29    }
30
31    /// Visit query owners in pre-order, stopping immediately on the first error.
32    pub fn try_visit_queries_mut<E>(
33        &mut self,
34        visit: &mut dyn FnMut(&mut QueryPlan) -> Result<(), E>,
35    ) -> Result<(), E> {
36        self.visit_queries_while_mut(&mut |query| visit(query).map(|()| true))
37    }
38
39    fn visit_queries_while_mut<E>(
40        &mut self,
41        visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
42    ) -> Result<(), E> {
43        match self {
44            Self::Query(query) => query.visit_queries_while_mut(visit),
45            Self::Command(command) => visit_command(command, visit),
46        }
47    }
48}
49
50fn visit_ctes<E>(
51    ctes: &mut [CtePlan],
52    visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
53) -> Result<(), E> {
54    for cte in ctes {
55        match &mut cte.body {
56            CtePlanBody::Query(query) => query.visit_queries_while_mut(visit)?,
57            CtePlanBody::Command(command) => visit_command(command, visit)?,
58        }
59    }
60    Ok(())
61}
62
63fn visit_command<E>(
64    command: &mut CommandPlan,
65    visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
66) -> Result<(), E> {
67    match command {
68        CommandPlan::CreateView { query, .. }
69        | CommandPlan::CreateTableAs { query, .. }
70        | CommandPlan::CreateMaterializedView { query, .. }
71        | CommandPlan::DeclareCursor { query, .. } => {
72            return query.visit_queries_while_mut(visit);
73        }
74        CommandPlan::Explain { body, .. } | CommandPlan::Prepare { body, .. } => {
75            return body.visit_queries_while_mut(visit);
76        }
77        CommandPlan::Execute { params, .. } | CommandPlan::Call { args: params, .. } => {
78            for expression in params {
79                for query in &mut expression.subqueries {
80                    query.visit_queries_while_mut(visit)?;
81                }
82            }
83            return Ok(());
84        }
85        _ => {}
86    }
87    if let Some(ctes) = command.ctes_mut() {
88        visit_ctes(ctes, visit)?;
89    }
90    for query in command.query_inputs_mut() {
91        query.visit_queries_while_mut(visit)?;
92    }
93    if let Some(source) = command.source_input_mut() {
94        visit_source(source, visit)?;
95    }
96    Ok(())
97}
98
99impl QueryPlan {
100    pub fn visit_queries_mut(&mut self, visit: &mut dyn FnMut(&mut Self)) {
101        self.try_visit_queries_mut(&mut |query| {
102            visit(query);
103            Ok::<_, std::convert::Infallible>(())
104        })
105        .unwrap_or_else(|never| match never {});
106    }
107
108    /// Visit this query and its children in ownership order, stopping immediately on error.
109    pub fn try_visit_queries_mut<E>(
110        &mut self,
111        visit: &mut dyn FnMut(&mut Self) -> Result<(), E>,
112    ) -> Result<(), E> {
113        self.visit_queries_while_mut(&mut |query| visit(query).map(|()| true))
114    }
115
116    fn visit_queries_while_mut<E>(
117        &mut self,
118        visit: &mut dyn FnMut(&mut Self) -> Result<bool, E>,
119    ) -> Result<(), E> {
120        if !visit(self)? {
121            return Ok(());
122        }
123        visit_ctes(&mut self.ctes, visit)?;
124        let subqueries = match &mut self.root {
125            RelationalPlan::QueryBlock(block) => {
126                if let Some(source) = &mut block.from {
127                    visit_source(source, visit)?;
128                }
129                &mut block.subqueries
130            }
131            RelationalPlan::SetOp {
132                left,
133                right,
134                subqueries,
135                ..
136            } => {
137                left.visit_queries_while_mut(visit)?;
138                right.visit_queries_while_mut(visit)?;
139                subqueries
140            }
141            RelationalPlan::Values { subqueries, .. } => subqueries,
142        };
143        for query in subqueries {
144            query.visit_queries_while_mut(visit)?;
145        }
146        Ok(())
147    }
148}
149
150fn visit_source<E>(
151    source: &mut SourcePlan,
152    visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
153) -> Result<(), E> {
154    match source {
155        SourcePlan::Subquery { body, .. } => body.visit_queries_while_mut(visit)?,
156        SourcePlan::Table {
157            executable_query: Some(body),
158            ..
159        } => body.visit_queries_while_mut(visit)?,
160        SourcePlan::Join { left, right, .. } => {
161            visit_source(left, visit)?;
162            visit_source(right, visit)?;
163        }
164        _ => {}
165    }
166    Ok(())
167}
168
169impl CommandPlan {
170    pub fn visit_query_roots_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
171        visit_command(self, &mut |query| {
172            visit(query);
173            Ok::<_, std::convert::Infallible>(false)
174        })
175        .unwrap_or_else(|never| match never {});
176    }
177}