uqa_sql/binding/preparation/production/
procedural.rs1use 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 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 PlanRef::Command(_) => {}
256 }
257 Ok(())
258 }
259}