1use super::{ParameterTypes, Preparation, RoutineResolution, SQLError, SchemaScope};
10use crate::{
11 binding::{
12 production::ControlledBindingContext, statements::AnalyzedResult, RoutineParameterScope,
13 },
14 plan::{MutableExecutablePlan, PlanRef, RelationalPlan},
15 prepared::dependencies::PreparedAnalysisDependencies,
16 schema::dependencies::oid_alias::OidAliasInput,
17 ColumnType, SQLParam,
18};
19use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
20
21mod procedural;
22pub use procedural::{
23 bind_routine_parameter_references_owned, parameter_input_types_with_control,
24 read_executable_inputs_owned, read_procedural_inputs_owned, ProceduralOwnedInputs,
25};
26mod explain;
27pub use explain::read_generic_explain_inputs_owned;
28mod stored;
29pub use stored::bind_expression_plan_routines_for_storage_owned;
30pub(crate) use stored::bind_rule_inputs_owned;
31
32pub struct PreparedOwnedInputs {
33 pub plan: MutableExecutablePlan,
34 pub parameter_types: Produced<Vec<Option<ColumnType>>>,
35 pub dependencies: Produced<PreparedAnalysisDependencies>,
36}
37
38pub struct PreparedOwnedRoutineBody {
39 pub plan: MutableExecutablePlan,
40 pub result: AnalyzedResult,
41}
42
43pub fn read_prepared_inputs_owned(
44 routines: &dyn RoutineResolution,
45 mut plan: MutableExecutablePlan,
46 declared: &[Option<ColumnType>],
47 binding: ControlledBindingContext<'_>,
48 aliases: Option<&dyn OidAliasInput>,
49 control: &ProductionControl<'_>,
50) -> Result<PreparedOwnedInputs, SQLError> {
51 let metadata_binding = binding.copy_with_control(control)?;
52 let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
53 scope.prepared_dependencies = Some(PreparedAnalysisDependencies::default());
54 let mut analysis = Preparation {
55 bound_condition_queries: None,
56 routines,
57 scope: &mut scope,
58 parameters: ParameterTypes::with_input_constants_with_control(
59 declared,
60 aliases,
61 routines.enum_labels(),
62 routines.catalog_input_functions(),
63 control,
64 )?
65 .retain_result_metadata(),
66 schema_expression: None,
67 };
68 analysis.observe_owned_plan(&plan, None)?;
69 let constants = analysis.parameters.take_input_constants();
70 let parameters = analysis.parameters.finish_produced()?;
71 let params = crate::prepared::analysis_parameters_with_control(¶meters, control)?;
72 constants.apply_owned(&mut plan, routines, ¶ms, control)?;
73 let plan = retain_prepared_input_metadata_owned(
74 routines,
75 plan,
76 ¶meters,
77 metadata_binding,
78 control,
79 )?;
80 let mut dependencies = scope.prepared_dependencies.take().unwrap_or_default();
81 include_plan_dependencies(&mut dependencies, &plan, control)?;
82 Ok(PreparedOwnedInputs {
83 plan,
84 parameter_types: parameters,
85 dependencies: control.finish(dependencies, control.empty_reservation())?,
86 })
87}
88
89pub fn prepare_routine_body_inputs_owned(
90 routines: &dyn RoutineResolution,
91 mut plan: MutableExecutablePlan,
92 params: &[SQLParam],
93 binding: ControlledBindingContext<'_>,
94 aliases: &dyn OidAliasInput,
95 parameters: Option<&RoutineParameterScope>,
96 control: &ProductionControl<'_>,
97) -> Result<PreparedOwnedRoutineBody, SQLError> {
98 let declared = declared_inputs(params, control)?;
99 let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
100 scope.routine_parameters = parameters.cloned();
101 let mut analysis = Preparation {
102 bound_condition_queries: None,
103 routines,
104 scope: &mut scope,
105 parameters: ParameterTypes::with_input_constants_with_control(
106 &declared,
107 Some(aliases),
108 routines.enum_labels(),
109 routines.catalog_input_functions(),
110 control,
111 )?
112 .with_routine_parameter_binding(),
113 schema_expression: None,
114 };
115 let result =
116 analysis.observe_owned_plan(&plan, parameters.map(RoutineParameterScope::schema))?;
117 let constants = analysis.parameters.take_input_constants();
118 analysis.parameters.finish_produced()?;
119 constants.apply_owned(&mut plan, routines, params, control)?;
120 let plan = normalize_windows(plan, control)?;
121 Ok(PreparedOwnedRoutineBody { plan, result })
122}
123
124pub(super) fn normalize_windows(
125 plan: MutableExecutablePlan,
126 control: &ProductionControl<'_>,
127) -> Result<MutableExecutablePlan, SQLError> {
128 plan.normalize_window_definitions(control)
129}
130
131pub(super) fn retain_compute_kinds_owned(
132 plan: MutableExecutablePlan,
133 routines: &dyn RoutineResolution,
134 control: &ProductionControl<'_>,
135) -> Result<MutableExecutablePlan, SQLError> {
136 struct Aggregates<'a>(&'a dyn RoutineResolution);
137 impl crate::plan::AggregateClassifier for Aggregates<'_> {
138 fn is_registered_aggregate(&self, name: &str) -> bool {
139 self.0.has_registered_aggregate_function(name)
140 }
141 fn is_registered_aggregate_with_control(
142 &self,
143 name: &str,
144 control: &ProductionControl<'_>,
145 ) -> Result<bool, SQLError> {
146 self.0
147 .has_registered_aggregate_function_with_control(name, control)
148 }
149 }
150 plan.map_queries_while(control, &mut |query| {
151 let compute = match &query.root {
152 RelationalPlan::QueryBlock(block) => {
153 Some(block.compute_kind_with_control(&Aggregates(routines), control)?)
154 }
155 _ => None,
156 };
157 Ok((
158 match compute {
159 Some(compute) => query.set_compute(compute, control)?,
160 None => query,
161 },
162 true,
163 ))
164 })
165}
166
167fn declared_inputs(
168 params: &[SQLParam],
169 control: &ProductionControl<'_>,
170) -> Result<Produced<Vec<Option<ColumnType>>>, SQLError> {
171 let mut declared = ProductionVec::new(*control);
172 declared.reserve(params.len())?;
173 for parameter in params {
174 let (ty, memory) = parameter.declared_scalar_type().map_or_else(
175 || Ok::<_, SQLError>((None, control.empty_reservation())),
176 |ty| {
177 let (ty, memory) = ty.clone_with_control(control)?.into_parts();
178 Ok((Some(ty), memory))
179 },
180 )?;
181 declared.push_produced(control.finish(ty, memory)?)?;
182 }
183 Ok(declared.finish()?)
184}
185
186fn include_plan_dependencies(
187 dependencies: &mut PreparedAnalysisDependencies,
188 plan: &MutableExecutablePlan,
189 control: &ProductionControl<'_>,
190) -> Result<(), SQLError> {
191 let mut status = Ok(());
192 let mut include = |expression: &crate::ScalarExpr| {
193 if status.is_ok() {
194 status = dependencies.include_expression_with_control(expression, control);
195 }
196 };
197 match plan.as_plan_ref() {
198 PlanRef::Query(query) => query.visit_scalar_expressions(&mut include),
199 PlanRef::Command(command) => command.visit_scalar_expressions(&mut include),
200 }
201 status
202}
203
204impl Preparation<'_> {
205 pub(super) fn observe_owned_plan(
206 &mut self,
207 plan: &MutableExecutablePlan,
208 outer: Option<&crate::RowSchema>,
209 ) -> Result<AnalyzedResult, SQLError> {
210 let result = match plan.as_plan_ref() {
211 PlanRef::Query(query) => Some(self.query(query, outer)?),
212 PlanRef::Command(command) => self.command(command)?,
213 };
214 Ok(result.map_or(AnalyzedResult::Command, AnalyzedResult::Schema))
215 }
216}
217
218pub fn read_procedure_inputs_owned(
220 context: &crate::binding::statements::StatementAnalysisContext<'_>,
221 overloads: &crate::routines::resolution::RoutineOverloadContext<'_>,
222 types: &dyn crate::routines::declaration::RoutineTypeCatalog,
223 mut plan: MutableExecutablePlan,
224 declared: &[Option<ColumnType>],
225 binding: ControlledBindingContext<'_>,
226 control: &ProductionControl<'_>,
227) -> Result<(Option<crate::RowSchema>, PreparedOwnedInputs), SQLError> {
228 let PlanRef::Command(crate::plan::CommandPlan::Call { name, args }) = plan.as_plan_ref() else {
229 return Err(SQLError::Internal(
230 "procedure input analysis requires CALL".into(),
231 ));
232 };
233 let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
234 scope.prepared_dependencies = Some(PreparedAnalysisDependencies::default());
235 let mut analysis = Preparation {
236 bound_condition_queries: None,
237 routines: context.routines,
238 scope: &mut scope,
239 parameters: ParameterTypes::with_input_constants_with_control(
240 declared,
241 Some(context.aliases),
242 context.routines.enum_labels(),
243 context.routines.catalog_input_functions(),
244 control,
245 )?,
246 schema_expression: None,
247 };
248 analysis.scope.set_placement = crate::semantics::sets::placement::SetPlacement::CallArgument;
249 let call = crate::routines::call::OwnedProcedureCallAnalysis::new(args, control)?;
250 let mut expressions = super::ownership::AnalysisVec::new(control);
251 expressions.reserve(call.decoded().len(), control)?;
252 let empty = crate::RowSchema::empty_with_control(control)?;
253 for argument in call.decoded() {
254 expressions.push(analysis.expression(argument.value, &empty, &[])?, control)?;
255 }
256 let mut argument_types = ProductionVec::new(*control);
257 argument_types.reserve(expressions.len())?;
258 for expression in &expressions {
259 let (ty, memory) = match &expression.ty {
260 Some(ty) => {
261 let (ty, memory) = ty.clone_with_control(control)?.into_parts();
262 (Some(ty), memory)
263 }
264 None => (None, control.empty_reservation()),
265 };
266 argument_types.push_produced(control.finish(ty, memory)?)?;
267 }
268 let argument_types = argument_types.finish()?;
269 let resolved = call.resolve_types(name, overloads, &argument_types, control)?;
270 drop(argument_types);
271 drop(call);
272 for (expression, target) in expressions
273 .iter_mut()
274 .zip(&resolved.invocation.argument_targets)
275 {
276 let target = types.resolve_catalog_column_type_name_with_control(target, control)?;
277 analysis.parameters.coerce_unknown(expression, &target)?;
278 }
279 let schema = crate::routines::invocation::call_output_schema_with_control(
280 types,
281 &resolved.function.def,
282 &resolved.invocation.parameter_types,
283 control,
284 )?;
285 let constants = analysis.parameters.take_input_constants();
286 let parameter_types = analysis.parameters.finish_produced()?;
287 let params = crate::prepared::analysis_parameters_with_control(¶meter_types, control)?;
288 constants.apply_owned(&mut plan, context.routines, ¶ms, control)?;
289 let mut dependencies = scope.prepared_dependencies.take().unwrap_or_default();
290 if let Some(identity) = resolved.function.def.object_id {
291 dependencies.include_routine_identity_with_control(identity, control)?;
292 }
293 include_plan_dependencies(&mut dependencies, &plan, control)?;
294 Ok((
295 schema,
296 PreparedOwnedInputs {
297 plan,
298 parameter_types,
299 dependencies: control.finish(dependencies, control.empty_reservation())?,
300 },
301 ))
302}
303
304pub fn retain_prepared_input_metadata_owned(
306 routines: &dyn RoutineResolution,
307 plan: MutableExecutablePlan,
308 parameters: &[Option<ColumnType>],
309 binding: ControlledBindingContext<'_>,
310 control: &ProductionControl<'_>,
311) -> Result<MutableExecutablePlan, SQLError> {
312 let params = crate::prepared::analysis_parameters_with_control(parameters, control)?;
313 retain_input_metadata_owned(routines, plan, ¶ms, binding, control)
314}
315
316pub(in crate::binding) fn retain_input_metadata_owned(
317 routines: &dyn RoutineResolution,
318 plan: MutableExecutablePlan,
319 params: &[SQLParam],
320 binding: ControlledBindingContext<'_>,
321 control: &ProductionControl<'_>,
322) -> Result<MutableExecutablePlan, SQLError> {
323 let mut plan = retain_compute_kinds_owned(plan, routines, control)?;
324 let mut needed = false;
325 let mut inspect = |expression: &crate::ScalarExpr| {
326 expression.visit(&mut |node| {
327 use crate::{ScalarExpr, ast::FunctionDispatch};
328 needed |= matches!(node, ScalarExpr::CompositeRow { .. });
329 needed |= matches!(node, ScalarExpr::Cast { expr, .. } if matches!(expr.as_ref(), ScalarExpr::Row(_)));
330 needed |= matches!(node, ScalarExpr::Func { binding:Some(binding), .. } if matches!(binding.dispatch, Some(FunctionDispatch::FieldSelect | FunctionDispatch::IsDistinct | FunctionDispatch::ValueNullTest { .. })));
331 });
332 };
333 match plan.as_plan_ref() {
334 PlanRef::Query(query) => query.visit_scalar_expressions(&mut inspect),
335 PlanRef::Command(command) => command.visit_scalar_expressions(&mut inspect),
336 }
337 if needed {
338 let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
339 scope.scalar_binding = crate::binding::ScalarBindingMode::CompositeInputs;
340 scope.preserve_syntax_shape = true;
341 let mut analysis = Preparation {
342 bound_condition_queries: None,
343 routines,
344 scope: &mut scope,
345 parameters: ParameterTypes::fixed_with_control(params, control)?
346 .with_composite_retention(),
347 schema_expression: None,
348 };
349 analysis.observe_owned_plan(&plan, None)?;
350 let mut replacements = analysis.parameters.take_composite_inputs();
351 plan = plan.transform_scalar_nodes(control, &mut |identity, expression| {
352 Ok(replacements.remove(&identity).unwrap_or(expression))
353 })?;
354 if !replacements.is_empty() {
355 return Err(SQLError::Internal(
356 "composite observation did not belong to its analyzed plan".into(),
357 ));
358 }
359 }
360 normalize_windows(plan, control)
361}
362
363pub fn resolve_variable_sites_owned(
365 routines: &dyn RoutineResolution,
366 plan: &MutableExecutablePlan,
367 params: &[SQLParam],
368 binding: ControlledBindingContext<'_>,
369 names: Produced<Vec<crate::ScalarExpr>>,
370 control: &ProductionControl<'_>,
371) -> Result<Produced<Vec<crate::binding::VariableSiteResolution>>, SQLError> {
372 use crate::binding::{variable_sites::VariableSites, VariableSiteResolution};
373 let mut resolutions = ProductionVec::new(*control);
374 resolutions.reserve(names.len())?;
375 for _ in 0..names.len() {
376 resolutions.extend_from_slice(&[VariableSiteResolution::Variable])?;
377 }
378 let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
379 scope.scalar_binding = crate::binding::ScalarBindingMode::References;
380 scope.variable_sites = Some(VariableSites {
381 names,
382 resolutions: resolutions.finish()?,
383 });
384 let mut analysis = Preparation {
385 bound_condition_queries: None,
386 routines,
387 scope: &mut scope,
388 parameters: ParameterTypes::fixed_with_control(params, control)?,
389 schema_expression: None,
390 };
391 let walked = analysis.observe_owned_plan(plan, None);
392 let resolutions = scope
393 .variable_sites
394 .take()
395 .expect("procedural name scope")
396 .resolutions;
397 match walked {
398 Ok(_) => Ok(resolutions),
399 Err(error) if matches!(error.sqlstate(), Some("53200" | "57014")) => Err(error),
400 Err(_) if resolutions.contains(&VariableSiteResolution::Column) => Ok(resolutions),
401 Err(error) => Err(error),
402 }
403}