uqa_sql/routines/inlining/
preparation.rs1use super::{selection::InlineSelection, InlineOwnedRoutineExpression, RoutineInliningContext};
10use crate::{
11 ast::{CreateFunction, FunctionBinding, FunctionBody},
12 binding::statements::AnalyzedResult,
13 plan::{MutableExecutablePlan, OwnedScalarExpr, QueryScalarSlot, RelationalPlan, UnifiedPlan},
14 routines::{CompiledFunctionBody, RoutineBody, SQLUserFunction},
15 ColumnType, SQLError, SQLParam, ScalarExpr,
16};
17use uqa_core::memory::{Produced, ProductionControl};
18
19type OwnedInlineScalar = (OwnedScalarExpr, Produced<Vec<SQLParam>>);
20
21pub(super) struct OwnedAnalyzedBody {
22 pub plan: MutableExecutablePlan,
23 pub result: AnalyzedResult,
24 pub parameters: Produced<Vec<SQLParam>>,
25}
26
27impl RoutineInliningContext<'_> {
28 pub fn prepare_owned(
29 &self,
30 binding: &FunctionBinding,
31 arguments: &[ScalarExpr],
32 active: &[[u8; 16]],
33 control: &ProductionControl<'_>,
34 ) -> Result<Option<InlineOwnedRoutineExpression>, SQLError> {
35 match self.select_inline_with_control(binding, arguments, active, control)? {
36 InlineSelection::Declined => Ok(None),
37 InlineSelection::Expression(expression) => Ok(Some(expression)),
38 InlineSelection::Body(candidate) => {
39 let Some((expression, parameters)) = self
40 .analyze_body_owned(&candidate.function, candidate.definition(), control)
41 .map_err(|error| error.with_context(candidate.error_context.as_str()))?
42 else {
43 return Ok(None);
44 };
45 candidate.substitute(expression, ¶meters, control, self)
46 }
47 }
48 }
49
50 fn analyze_body_owned(
51 &self,
52 function: &SQLUserFunction,
53 definition: &CreateFunction,
54 control: &ProductionControl<'_>,
55 ) -> Result<Option<OwnedInlineScalar>, SQLError> {
56 let Some(OwnedAnalyzedBody {
57 plan,
58 result,
59 parameters,
60 }) = self.analyze_plan_owned(function, definition, control)?
61 else {
62 return Ok(None);
63 };
64 let MutableExecutablePlan::Query(query) = plan else {
65 return Ok(None);
66 };
67 if !query.ctes.is_empty() {
68 return Ok(None);
69 }
70 let RelationalPlan::QueryBlock(block) = &query.root else {
71 return Ok(None);
72 };
73 if !block.is_single_expression() {
74 return Ok(None);
75 }
76 let layout = crate::routines::result_check::sql_function_result_layout_with_control(
77 self.types,
78 definition,
79 Some(&result),
80 control,
81 )?;
82 use crate::routines::result_check::SQLFunctionResultKind;
83 if layout.kind == SQLFunctionResultKind::Tuple {
84 return Ok(None);
85 }
86 let actual = result
87 .column_types()
88 .and_then(|types| types.first())
89 .and_then(Option::as_ref);
90 if layout.kind == SQLFunctionResultKind::Void && actual != Some(&ColumnType::Void) {
91 return Ok(None);
92 }
93 let mut expression = query
94 .select_scalar(QueryScalarSlot::Projection(0), control)?
95 .expect("single-expression projection");
96 if actual != Some(&layout.declared_type) {
97 expression = OwnedScalarExpr::cast(
98 expression,
99 layout.declared_type.catalog_name_with_control(control)?,
100 true,
101 control,
102 )?;
103 }
104 Ok(Some((expression, parameters)))
105 }
106
107 pub(super) fn analyze_plan_owned(
108 &self,
109 function: &SQLUserFunction,
110 definition: &CreateFunction,
111 control: &ProductionControl<'_>,
112 ) -> Result<Option<OwnedAnalyzedBody>, SQLError> {
113 let Some(plan) = self.body_plan_owned(function, control)? else {
114 return Ok(None);
115 };
116 let parameters = crate::routines::body_validation::routine_parameter_values_with_control(
117 self.types, definition, control,
118 )?;
119 let names = matches!(definition.body, FunctionBody::Source(_))
120 .then(|| {
121 crate::routines::body_parameters::sql_body_parameter_scope_with_control(
122 definition,
123 ¶meters,
124 control,
125 )
126 })
127 .transpose()?;
128 let mut snapshot = self.catalog.binding_snapshot_with_control(control)?;
129 let namespace = self.catalog.stored_query_namespace_with_control(control)?;
130 snapshot
131 .ctes
132 .retain(|name, _| namespace.transition_relations.contains(name));
133 snapshot.deferred_ctes.clear();
134 snapshot.non_returning_ctes.clear();
135 snapshot.scalar_subqueries = crate::plan::RetainedQueryArena::default();
136 let prepared = {
137 let _placement = if matches!(definition.body, FunctionBody::Statements(_)) {
138 crate::semantics::sets::placement_scope::SetPlacementScope::stored_definition()
139 } else {
140 crate::semantics::sets::placement_scope::SetPlacementScope::compiled_source()
141 };
142 crate::binding::prepare_routine_body_inputs_owned(
143 self.routines,
144 plan,
145 ¶meters,
146 snapshot.context_with_control(control)?,
147 self.catalog,
148 names.as_ref(),
149 control,
150 )?
151 };
152 Ok(Some(OwnedAnalyzedBody {
153 plan: prepared.plan,
154 result: prepared.result,
155 parameters,
156 }))
157 }
158
159 fn body_plan_owned(
160 &self,
161 function: &SQLUserFunction,
162 control: &ProductionControl<'_>,
163 ) -> Result<Option<MutableExecutablePlan>, SQLError> {
164 control.check()?;
165 match &function.body {
166 RoutineBody::Bound(body) => match body.as_ref() {
167 CompiledFunctionBody::SQL(plans) if plans.len() == 1 => {
168 plans[0].copy_for_rewrite(control).map(Some)
169 }
170 _ => Ok(None),
171 },
172 RoutineBody::Source => {
173 let FunctionBody::Source(source) = &function.def.body else {
174 return Err(SQLError::Internal(
175 "source routine has no SQL source".into(),
176 ));
177 };
178 super::super::compilation::with_parser_context(self.parsers, || {
179 let statements =
180 crate::compiler::parse_statements_with_control(source, control)?;
181 let [statement] = statements.as_slice() else {
182 return Ok(None);
183 };
184 let syntax = statement.compile()?;
185 UnifiedPlan::lower_borrowed_for_rewrite(
186 &syntax,
187 &AggregateLookup(self.routines),
188 control,
189 )
190 .map(Some)
191 })
192 }
193 }
194 }
195}
196
197struct AggregateLookup<'a>(&'a dyn crate::routines::RoutineResolution);
198impl crate::plan::AggregateClassifier for AggregateLookup<'_> {
199 fn is_registered_aggregate(&self, name: &str) -> bool {
200 self.0.has_registered_aggregate_function(name)
201 }
202 fn is_registered_aggregate_with_control(
203 &self,
204 name: &str,
205 control: &ProductionControl<'_>,
206 ) -> Result<bool, SQLError> {
207 self.0
208 .has_registered_aggregate_function_with_control(name, control)
209 }
210}