Skip to main content

uqa_sql/binding/preparation/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Ordered analysis owns its executable destination, parameter observations and published dependency nodes independently.
8
9use 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(&parameters, control)?;
72    constants.apply_owned(&mut plan, routines, &params, control)?;
73    let plan = retain_prepared_input_metadata_owned(
74        routines,
75        plan,
76        &parameters,
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
218/// Infer and retain CALL inputs in written order, keeping decoded argument sites borrowed until every selected constant has been recorded.
219pub 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(&parameter_types, control)?;
288    constants.apply_owned(&mut plan, context.routines, &params, 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
304/// Retain selected composite identities in their analyzed lexical scopes, then normalize window syntax under the same executable owner.
305pub 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, &params, 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
363/// Inspect procedural name/column conflicts in the owned statement's original scopes, preserving the first conflicting site over later semantic diagnostics.
364pub 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}