Skip to main content

uqa_sql/plan/copy/
lowering.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Borrowed syntax produces its first executable destination under the selected allowance.
8
9use 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    /// Lower a borrowed expression and every nested query directly into independently movable owners.
30    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    /// Lower retained syntax directly into independently owned executable fields. Source parsing and its original syntax owner remain separate; no temporary ordinary executable is constructed on the controlled path.
60    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, &copying.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}