uqa_sql/plpgsql/parameters/
owned.rs1use super::{
10 parameterize_statement_variables, Expr, PLpgSQLVariableReference, SQLError, SQLParam,
11 Statement, VariableConflict, VariableResolver,
12};
13use crate::{
14 binding::VariableSiteResolution,
15 plan::{MutableExecutablePlan, UnifiedPlan},
16 ScalarExpr,
17};
18use uqa_core::memory::{Produced, ProductionControl, ProductionMap, ProductionVec};
19
20pub struct PLpgSQLInput {
21 pub parameter: SQLParam,
22 pub collation_oid: Option<u32>,
23}
24
25impl PLpgSQLInput {
26 pub fn from_parts(
27 value: Produced<uqa_core::Value>,
28 ty: Option<Produced<crate::ColumnType>>,
29 collation_oid: Option<u32>,
30 control: &ProductionControl<'_>,
31 ) -> Result<Produced<Self>, SQLError> {
32 let (value, mut memory) = value.into_parts();
33 let parameter = if let Some(ty) = ty {
34 let (ty, lease) = ty.into_parts();
35 memory = control.combine(memory, lease);
36 SQLParam::typed_scalar(value, ty)
37 } else {
38 SQLParam::scalar(value)
39 };
40 Ok(control.finish(
41 Self {
42 parameter,
43 collation_oid,
44 },
45 memory,
46 )?)
47 }
48}
49
50pub struct OwnedPLpgSQLVariableBindings {
51 pub plan: MutableExecutablePlan,
52 pub references: Produced<Vec<PLpgSQLVariableReference>>,
53 pub parameters: Produced<Vec<SQLParam>>,
54}
55
56pub type OwnedVariableSiteResolver<'a> =
57 &'a mut dyn FnMut(
58 &MutableExecutablePlan,
59 &[SQLParam],
60 Produced<Vec<ScalarExpr>>,
61 &ProductionControl<'_>,
62 ) -> Result<Produced<Vec<VariableSiteResolution>>, SQLError>;
63
64impl PLpgSQLVariableReference {
65 fn from_expression(
66 expression: &Expr,
67 control: &ProductionControl<'_>,
68 ) -> Result<Option<Produced<Self>>, SQLError> {
69 Ok(Some(match expression {
70 Expr::Column(name) => {
71 let (name, memory) = control.copy_text(name)?.into_parts();
72 control.finish(Self::Name(name), memory)?
73 }
74 Expr::QualifiedColumn { qualifier, column } => {
75 let (qualifier, first) = control.copy_text(qualifier)?.into_parts();
76 let (column, second) = control.copy_text(column)?.into_parts();
77 control.finish(
78 Self::Qualified { qualifier, column },
79 control.combine(first, second),
80 )?
81 }
82 Expr::Param(index) => {
83 control.finish(Self::Parameter(*index), control.empty_reservation())?
84 }
85 _ => return Ok(None),
86 }))
87 }
88}
89
90pub fn parameterize_statement_variables_owned(
91 statement: &Statement,
92 resolver: &mut dyn VariableResolver,
93 conflict: VariableConflict,
94 resolve_sites: OwnedVariableSiteResolver<'_>,
95 aggregates: &dyn crate::plan::AggregateClassifier,
96 control: &ProductionControl<'_>,
97) -> Result<OwnedPLpgSQLVariableBindings, SQLError> {
98 control.check()?;
99 if control.budget().is_none() {
100 let result = parameterize_statement_variables(
101 statement,
102 resolver,
103 conflict,
104 &mut |statement, params, names| {
105 let plan =
106 UnifiedPlan::lower_borrowed_for_rewrite(&statement, aggregates, control)?;
107 let resolutions =
108 resolve_sites(&plan, ¶ms, control.finish(names, None)?, control)?;
109 Ok(resolutions
110 .into_uncontrolled()
111 .expect("ordinary variable site callback"))
112 },
113 aggregates,
114 )?;
115 return Ok(OwnedPLpgSQLVariableBindings {
116 plan: result.plan.copy_for_rewrite(control)?,
117 references: control.finish(result.references, None)?,
118 parameters: control.finish(result.parameters, None)?,
119 });
120 }
121
122 let mut sites = ProductionMap::new(*control);
123 let mut names = ProductionVec::new(*control);
124 let mut params = ProductionVec::new(*control);
125 super::visit::Visitor {
126 control: *control,
127 visit: &mut |expression| {
128 let Some(reference) = PLpgSQLVariableReference::from_expression(expression, control)?
129 else {
130 return Ok(());
131 };
132 let Some(input) = resolver.resolve_input_with_control(&reference, control)? else {
133 return Ok(());
134 };
135 let name = if matches!(expression, Expr::Param(_)) {
136 control.finish(
137 ScalarExpr::Literal(uqa_core::Value::Null),
138 control.empty_reservation(),
139 )?
140 } else {
141 crate::plan::ExpressionPlan::lower_scalar_with_control(expression, control)?
142 };
143 let (input, memory) = input.into_parts();
144 params.push_produced(control.finish(input.parameter, memory)?)?;
145 names.push_produced(name)?;
146 sites.insert_copy(std::ptr::from_ref(expression) as usize, params.len())?;
147 Ok(())
148 },
149 }
150 .statement(statement)?;
151 let resolutions = if sites.is_empty() {
152 control.finish(Vec::new(), control.empty_reservation())?
153 } else {
154 let numbered = UnifiedPlan::lower_borrowed_with_parameters(
155 statement,
156 aggregates,
157 control,
158 Some(&|expression| {
159 sites
160 .get(&(std::ptr::from_ref(expression) as usize))
161 .copied()
162 }),
163 )?;
164 resolve_sites(&numbered, ¶ms.finish()?, names.finish()?, control)?
165 };
166 let mut keep = ProductionMap::new(*control);
168 super::visit::Visitor {
169 control: *control,
170 visit: &mut |expression| {
171 let Some(site) = sites.get(&(std::ptr::from_ref(expression) as usize)) else {
172 return Ok(());
173 };
174 let resolution = resolutions.get(site - 1).copied().ok_or_else(|| {
175 SQLError::Internal("procedural site analysis lost a resolution".into())
176 })?;
177 match (resolution, conflict) {
178 (VariableSiteResolution::Output, _)
179 | (VariableSiteResolution::Column, VariableConflict::UseColumn) => {
180 keep.insert_copy(std::ptr::from_ref(expression) as usize, true)?;
181 }
182 (VariableSiteResolution::Column, VariableConflict::Error) => {
183 return Err(super::super::variable_conflicts::ambiguous_variable_error(
184 expression,
185 ))
186 }
187 _ => {}
188 }
189 Ok(())
190 },
191 }
192 .statement(statement)?;
193 drop(sites);
194 drop(resolutions);
195
196 bind_selected_inputs(statement, resolver, aggregates, &keep, control)
197}
198
199fn bind_selected_inputs(
200 statement: &Statement,
201 resolver: &mut dyn VariableResolver,
202 aggregates: &dyn crate::plan::AggregateClassifier,
203 keep: &ProductionMap<'_, usize, bool>,
204 control: &ProductionControl<'_>,
205) -> Result<OwnedPLpgSQLVariableBindings, SQLError> {
206 let mut selected = ProductionMap::new(*control);
207 let mut parameters = ProductionVec::new(*control);
208 let mut references = ProductionVec::new(*control);
209 let mut collations = ProductionVec::new(*control);
210 super::visit::Visitor {
211 control: *control,
212 visit: &mut |expression| {
213 let Some(reference) = PLpgSQLVariableReference::from_expression(expression, control)?
214 else {
215 return Ok(());
216 };
217 let Some(input) = resolver.resolve_input_with_control(&reference, control)? else {
218 return Ok(());
219 };
220 if keep
221 .get(&(std::ptr::from_ref(expression) as usize))
222 .copied()
223 .unwrap_or(false)
224 {
225 return Ok(());
226 }
227 let (input, memory) = input.into_parts();
228 collations.extend_from_slice(&[input.collation_oid])?;
229 parameters.push_produced(control.finish(input.parameter, memory)?)?;
230 references.push_produced(reference)?;
231 selected.insert_copy(std::ptr::from_ref(expression) as usize, parameters.len())?;
232 Ok(())
233 },
234 }
235 .statement(statement)?;
236 let mut plan = UnifiedPlan::lower_borrowed_with_parameters(
237 statement,
238 aggregates,
239 control,
240 Some(&|expression| {
241 selected
242 .get(&(std::ptr::from_ref(expression) as usize))
243 .copied()
244 }),
245 )?;
246 let parameters = parameters.finish()?;
247 plan = plan.transform_scalar_nodes(control, &mut |_, expression| {
248 let ScalarExpr::Param(number) = &*expression else {
249 return Ok(expression);
250 };
251 let Some(index) = number.checked_sub(1) else {
252 return Ok(expression);
253 };
254 let Some(oid) = collations.get(index).copied().flatten() else {
255 return Ok(expression);
256 };
257 let Some(ty) = parameters[index]
258 .declared_scalar_type()
259 .filter(|ty| crate::schema::composites::type_is_collatable(ty))
260 else {
261 return Ok(expression);
262 };
263 Ok(crate::plan::OwnedScalarExpr::collated(
264 expression,
265 ty.clone_with_control(control)?,
266 crate::ir::ResultCollation::new(
267 crate::catalog::collations::derivation::Derivation::implicit(i64::from(oid)),
268 oid,
269 ),
270 control,
271 )?)
272 })?;
273 Ok(OwnedPLpgSQLVariableBindings {
274 plan,
275 references: references.finish()?,
276 parameters,
277 })
278}