1use super::{syntax::SyntaxCopy, Copying, ParameterLookup, Result, RewriteField};
10use crate::{
11 ast::{Expr, SelectStmt, Statement},
12 plan::{
13 scalar::{lower_scalar_with_arena, QueryLowering},
14 AggregateClassifier, MutableCommandPlan, MutableExecutablePlan, MutableQueryPlan,
15 QueryPlan, UnifiedPlan,
16 },
17 schema::retention::CatalogRetentionError,
18};
19use uqa_core::memory::{BudgetedVec, ProductionControl};
20
21mod commands;
22mod ctes;
23mod expressions;
24mod mutations;
25mod query;
26mod source;
27
28impl crate::plan::ExpressionPlan {
29 pub fn lower_borrowed_for_rewrite(
31 expression: &Expr,
32 control: &ProductionControl<'_>,
33 ) -> Result<crate::plan::MutableExpressionPlan> {
34 Self::lower_borrowed_with(expression, &crate::plan::NoRegisteredAggregates, control)
35 }
36
37 pub fn lower_borrowed_with(
38 expression: &Expr,
39 aggregates: &dyn AggregateClassifier,
40 control: &ProductionControl<'_>,
41 ) -> Result<crate::plan::MutableExpressionPlan> {
42 control.check()?;
43 if control.budget().is_none() {
44 return Self::lower_with(expression.clone(), aggregates).copy_for_rewrite(control);
45 }
46 let mut arena = QueryArena::new(*control, None);
47 let scalar = lower_scalar_with_arena(expression, aggregates, &mut arena, *control)?;
48 let (queries, memory) = arena.queries.into_parts();
49 arena.copying.memory.absorb(memory);
50 let arena = crate::plan::ScalarQueryArena::from_rewrite_parts(
51 queries,
52 Some(arena.copying.into_rewrite_memory()),
53 );
54 crate::plan::MutableExpressionPlan::from_parts(scalar, arena, control)
55 }
56}
57
58impl UnifiedPlan {
59 pub fn lower_borrowed_for_rewrite(
61 statement: &Statement,
62 aggregates: &dyn AggregateClassifier,
63 control: &ProductionControl<'_>,
64 ) -> Result<MutableExecutablePlan> {
65 Self::lower_borrowed_with_parameters(statement, aggregates, control, None)
66 }
67
68 pub(crate) fn lower_borrowed_with_parameters(
69 statement: &Statement,
70 aggregates: &dyn AggregateClassifier,
71 control: &ProductionControl<'_>,
72 parameters: Option<&ParameterLookup<'_>>,
73 ) -> Result<MutableExecutablePlan> {
74 control.check()?;
75 let Some(mut copying) = Copying::for_rewrite(*control) else {
76 if parameters.is_some() {
77 return Err(crate::SQLError::Internal(
78 "parameter substitution requires an owning syntax producer".into(),
79 ));
80 }
81 return Ok(match Self::lower_with(statement.clone(), aggregates) {
82 Self::Query(query) => {
83 MutableExecutablePlan::Query(MutableQueryPlan::from_rewrite_parts(*query, None))
84 }
85 Self::Command(command) => MutableExecutablePlan::Command(
86 MutableCommandPlan::from_rewrite_parts(*command, None),
87 ),
88 });
89 };
90 copying.parameters = parameters;
91 match statement {
92 Statement::Select(query) => Ok(MutableExecutablePlan::Query(lower_query(
93 query, aggregates, control, parameters,
94 )?)),
95 Statement::Values { rows } => {
96 let query = copying.lower_values_query(rows, aggregates)?;
97 Ok(MutableExecutablePlan::Query(
98 MutableQueryPlan::from_rewrite_parts(
99 query,
100 Some(copying.into_rewrite_memory()),
101 ),
102 ))
103 }
104 statement => {
105 let command = copying.lower_command(statement, aggregates)?;
106 control.check()?;
107 Ok(MutableExecutablePlan::Command(
108 MutableCommandPlan::from_rewrite_parts(
109 command,
110 Some(copying.into_rewrite_memory()),
111 ),
112 ))
113 }
114 }
115 }
116}
117
118fn lower_query(
119 statement: &SelectStmt,
120 aggregates: &dyn AggregateClassifier,
121 control: &ProductionControl<'_>,
122 parameters: Option<&ParameterLookup<'_>>,
123) -> Result<MutableQueryPlan> {
124 let mut copying = Copying::for_rewrite(*control).expect("admitted syntax lowering");
125 copying.parameters = parameters;
126 let query = copying.lower_query_fields(statement, aggregates)?;
127 MutableQueryPlan::from_rewrite_parts(query, Some(copying.into_rewrite_memory()))
128 .normalize_window_definitions(control)
129}
130
131struct QueryArena<'a> {
132 copying: Copying<'a>,
133 queries: BudgetedVec<QueryPlan>,
134}
135
136impl<'a> QueryArena<'a> {
137 fn new(control: ProductionControl<'a>, parameters: Option<&'a ParameterLookup<'a>>) -> Self {
138 let mut copying = Copying::for_rewrite(control).expect("admitted query arena");
139 copying.parameters = parameters;
140 Self {
141 copying,
142 queries: BudgetedVec::new(control.budget().expect("admitted query arena")),
143 }
144 }
145}
146
147impl QueryLowering for QueryArena<'_> {
148 fn parameter(&self, expression: &Expr) -> Option<usize> {
149 self.copying
150 .parameters
151 .and_then(|parameters| parameters(expression))
152 }
153 fn append_owned(
154 &mut self,
155 statement: SelectStmt,
156 aggregates: &dyn AggregateClassifier,
157 ) -> std::result::Result<usize, CatalogRetentionError> {
158 self.append_borrowed(&statement, aggregates)
159 }
160
161 fn append_borrowed(
162 &mut self,
163 statement: &SelectStmt,
164 aggregates: &dyn AggregateClassifier,
165 ) -> std::result::Result<usize, CatalogRetentionError> {
166 self.copying.check()?;
167 self.queries.reserve(1)?;
168 let index = self.queries.len();
169 let query = self.copying.field("item", |copying| {
170 let query = lower_query(statement, aggregates, ©ing.control, copying.parameters)?;
171 copying.take_query(query)
172 })?;
173 self.queries.push(query)?;
174 Ok(index)
175 }
176}
177
178impl Copying<'_> {
179 fn take_arena(&mut self, mut arena: QueryArena<'_>) -> Result<Vec<QueryPlan>> {
180 self.check()?;
181 self.fields.as_mut().expect("query fields").reserve(1)?;
182 let (queries, memory) = arena.queries.into_parts();
183 arena.copying.memory.absorb(memory);
184 self.fields
185 .as_mut()
186 .expect("query fields")
187 .push(RewriteField {
188 name: "subqueries",
189 memory: Some(arena.copying.into_rewrite_memory()),
190 })?;
191 Ok(queries)
192 }
193
194 fn lower_scalar(
195 &mut self,
196 expression: &Expr,
197 aggregates: &dyn AggregateClassifier,
198 arena: &mut QueryArena<'_>,
199 ) -> Result<crate::ScalarExpr> {
200 let expression = lower_scalar_with_arena(expression, aggregates, arena, self.control)?;
201 self.take_scalar(expression)
202 }
203
204 fn lower_nested_query(
205 &mut self,
206 statement: &SelectStmt,
207 aggregates: &dyn AggregateClassifier,
208 ) -> Result<QueryPlan> {
209 self.take_query(lower_query(
210 statement,
211 aggregates,
212 &self.control,
213 self.parameters,
214 )?)
215 }
216
217 fn lower_statement(
218 &mut self,
219 statement: &Statement,
220 aggregates: &dyn AggregateClassifier,
221 ) -> Result<UnifiedPlan> {
222 Ok(match statement {
223 Statement::Select(query) => UnifiedPlan::Query(
224 self.boxed(|copying| copying.lower_nested_query(query, aggregates))?,
225 ),
226 Statement::Values { rows } => UnifiedPlan::Query(self.boxed(|copying| {
227 copying.field("query", |copying| {
228 copying.lower_values_query(rows, aggregates)
229 })
230 })?),
231 statement => UnifiedPlan::Command(self.boxed(|copying| {
232 copying.field("command", |copying| {
233 copying.lower_command(statement, aggregates)
234 })
235 })?),
236 })
237 }
238}