Skip to main content

uqa_sql/binding/preparation/production/
procedural.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Reached procedural statements retain converted inputs and selected dependencies in their own executable destination.
8
9use super::{
10    include_plan_dependencies, retain_input_metadata_owned, AnalyzedResult, ColumnType,
11    ControlledBindingContext, MutableExecutablePlan, OidAliasInput, ParameterTypes, PlanRef,
12    Preparation, PreparedAnalysisDependencies, Produced, ProductionControl, ProductionVec,
13    RoutineParameterScope, RoutineResolution, SQLError, SQLParam, SchemaScope,
14};
15use crate::plan::CommandPlan;
16use uqa_core::Value;
17
18pub struct ProceduralOwnedInputs {
19    pub plan: MutableExecutablePlan,
20    pub result: AnalyzedResult,
21    pub reusable: bool,
22    pub dependencies: Produced<PreparedAnalysisDependencies>,
23}
24
25pub fn parameter_input_types_with_control(
26    params: &[SQLParam],
27    control: &ProductionControl<'_>,
28) -> Result<Produced<Vec<Option<ColumnType>>>, SQLError> {
29    let schema = crate::RowSchema::empty_with_control(control)?;
30    let mut types = ProductionVec::new(*control);
31    types.reserve(params.len())?;
32    for (index, parameter) in params.iter().enumerate() {
33        let selected = match parameter {
34            SQLParam::Scalar(Value::Str(_) | Value::Null) => None,
35            _ => crate::scalar_type_with_control(
36                &crate::ScalarExpr::Param(index + 1),
37                &schema,
38                params,
39                control,
40            )?,
41        };
42        let (selected, memory) = match selected {
43            Some(ty) => {
44                let (ty, memory) = ty.into_parts();
45                (Some(ty), memory)
46            }
47            None => (None, control.empty_reservation()),
48        };
49        types.push_produced(control.finish(selected, memory)?)?;
50    }
51    Ok(types.finish()?)
52}
53
54pub fn read_procedural_inputs_owned(
55    routines: &dyn RoutineResolution,
56    plan: MutableExecutablePlan,
57    params: &[SQLParam],
58    binding: ControlledBindingContext<'_>,
59    aliases: &dyn OidAliasInput,
60    control: &ProductionControl<'_>,
61) -> Result<ProceduralOwnedInputs, SQLError> {
62    let declared = parameter_input_types_with_control(params, control)?;
63    read_inputs_owned(
64        routines,
65        plan,
66        DeclaredInputs {
67            values: params,
68            types: &declared,
69        },
70        binding,
71        aliases,
72        true,
73        control,
74    )
75}
76
77pub fn read_executable_inputs_owned(
78    routines: &dyn RoutineResolution,
79    plan: MutableExecutablePlan,
80    params: &[SQLParam],
81    binding: ControlledBindingContext<'_>,
82    aliases: &dyn OidAliasInput,
83    control: &ProductionControl<'_>,
84) -> Result<ProceduralOwnedInputs, SQLError> {
85    let mut declared = ProductionVec::new(*control);
86    declared.reserve(params.len())?;
87    for parameter in params {
88        let selected =
89            crate::params::bind_parameter_type_with_control(parameter, routines, control)?;
90        let (selected, memory) = match selected {
91            Some(ty) => {
92                let (ty, memory) = ty.into_parts();
93                (Some(ty), memory)
94            }
95            None => (None, control.empty_reservation()),
96        };
97        declared.push_produced(control.finish(selected, memory)?)?;
98    }
99    read_inputs_owned(
100        routines,
101        plan,
102        DeclaredInputs {
103            values: params,
104            types: &declared.finish()?,
105        },
106        binding,
107        aliases,
108        false,
109        control,
110    )
111}
112
113struct DeclaredInputs<'a> {
114    values: &'a [SQLParam],
115    types: &'a [Option<ColumnType>],
116}
117
118fn read_inputs_owned(
119    routines: &dyn RoutineResolution,
120    mut plan: MutableExecutablePlan,
121    inputs: DeclaredInputs<'_>,
122    binding: ControlledBindingContext<'_>,
123    aliases: &dyn OidAliasInput,
124    track_dependencies: bool,
125    control: &ProductionControl<'_>,
126) -> Result<ProceduralOwnedInputs, SQLError> {
127    let DeclaredInputs {
128        values: params,
129        types: declared,
130    } = inputs;
131    let metadata = binding.copy_with_control(control)?;
132    let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
133    scope.prepared_dependencies = track_dependencies.then(PreparedAnalysisDependencies::default);
134    let mut analysis = Preparation {
135        bound_condition_queries: None,
136        routines,
137        scope: &mut scope,
138        parameters: ParameterTypes::with_input_constants_with_control(
139            declared,
140            Some(aliases),
141            routines.enum_labels(),
142            routines.catalog_input_functions(),
143            control,
144        )?
145        .retain_result_metadata(),
146        schema_expression: None,
147    };
148    let mut finish_parameters = false;
149    let result = match plan.as_plan_ref() {
150        PlanRef::Query(query) => AnalyzedResult::Schema(analysis.query(query, None)?),
151        PlanRef::Command(command) => match command {
152            CommandPlan::CreateView { .. }
153            | CommandPlan::CreateTableAs { .. }
154            | CommandPlan::CreateMaterializedView { .. }
155            | CommandPlan::DeclareCursor { .. } => {
156                analysis.command(command)?;
157                AnalyzedResult::Command
158            }
159            _ if command.mutation_target().is_some() => {
160                finish_parameters = true;
161                analysis
162                    .command(command)?
163                    .map_or(AnalyzedResult::Command, AnalyzedResult::Schema)
164            }
165            _ => AnalyzedResult::Command,
166        },
167    };
168    let constants = analysis.parameters.take_input_constants();
169    if finish_parameters {
170        analysis.parameters.finish_produced()?;
171    }
172    let reusable = constants.reusable_across_messages();
173    constants.apply_owned(&mut plan, routines, params, control)?;
174    let plan = retain_input_metadata_owned(routines, plan, params, metadata, control)?;
175    let mut dependencies = scope.prepared_dependencies.take().unwrap_or_default();
176    if track_dependencies {
177        include_plan_dependencies(&mut dependencies, &plan, control)?;
178    }
179    Ok(ProceduralOwnedInputs {
180        plan,
181        result,
182        reusable,
183        dependencies: control.finish(dependencies, control.empty_reservation())?,
184    })
185}
186
187pub fn bind_routine_parameter_references_owned(
188    routines: &dyn RoutineResolution,
189    mut plan: MutableExecutablePlan,
190    params: &[SQLParam],
191    binding: ControlledBindingContext<'_>,
192    parameters: &RoutineParameterScope,
193    control: &ProductionControl<'_>,
194) -> Result<MutableExecutablePlan, SQLError> {
195    let mut scope = SchemaScope::for_analysis_with_control(binding, control)?;
196    scope.routine_parameters = Some(parameters.clone());
197    scope.scalar_binding = crate::binding::ScalarBindingMode::References;
198    scope.preserve_syntax_shape = true;
199    let mut analysis = Preparation {
200        bound_condition_queries: None,
201        routines,
202        scope: &mut scope,
203        parameters: ParameterTypes::fixed_with_control(params, control)?.with_reference_retention(),
204        schema_expression: None,
205    };
206    analysis.observe_routine_parameter_references(plan.as_plan_ref(), parameters.schema())?;
207    let references = analysis.parameters.take_reference_constants();
208    references.apply_owned(&mut plan, routines, params, control)?;
209    Ok(plan)
210}
211
212impl Preparation<'_> {
213    /// Parameter binding follows statement namespaces without selecting the calls that later statement analysis owns.
214    fn observe_routine_parameter_references(
215        &mut self,
216        plan: PlanRef<'_>,
217        outer: &crate::RowSchema,
218    ) -> Result<(), SQLError> {
219        match plan {
220            PlanRef::Query(query) => {
221                self.query(query, Some(outer))?;
222            }
223            PlanRef::Command(CommandPlan::Explain { body, .. }) => {
224                let body = match &**body {
225                    crate::plan::UnifiedPlan::Query(query) => PlanRef::Query(query),
226                    crate::plan::UnifiedPlan::Command(command) => PlanRef::Command(command),
227                };
228                self.observe_routine_parameter_references(body, outer)?;
229            }
230            PlanRef::Command(
231                CommandPlan::CreateTableAs { query, .. }
232                | CommandPlan::CreateMaterializedView { query, .. }
233                | CommandPlan::DeclareCursor { query, .. },
234            ) => {
235                self.query(query, Some(outer))?;
236            }
237            PlanRef::Command(CommandPlan::Call { args, .. }) => {
238                for argument in args {
239                    for query in &argument.subqueries {
240                        self.query(query, Some(outer))?;
241                    }
242                    argument.scalar.try_visit(&mut |node| {
243                        self.scope.control().check()?;
244                        if let Some(index) = self.scope.routine_parameter_reference(node, outer) {
245                            self.parameters.named_reference(node, index)?;
246                        }
247                        Ok::<_, SQLError>(true)
248                    })?;
249                }
250            }
251            PlanRef::Command(command) if command.mutation_target().is_some() => {
252                self.command(command)?;
253            }
254            // Utility syntax has no routine parameter namespace.
255            PlanRef::Command(_) => {}
256        }
257        Ok(())
258    }
259}