1mod inputs;
10mod owned;
11mod visit;
12pub use inputs::parameter_type_mismatch_with_control;
13pub use owned::{
14 parameterize_statement_variables_owned, OwnedPLpgSQLVariableBindings,
15 OwnedVariableSiteResolver, PLpgSQLInput,
16};
17
18use super::{
19 binding::{bind_statement, ResolvedVariable, VariableResolver},
20 variable_conflicts::{statement_variable_names, VariableSiteResolver},
21 VariableConflict,
22};
23use crate::{
24 ast::{Expr, Statement},
25 SQLError, SQLParam,
26};
27
28pub fn parameter_type_mismatch(
29 number: usize,
30 actual: &crate::ColumnType,
31 expected: &crate::ColumnType,
32) -> crate::ast::DeferredSQLError {
33 crate::ast::DeferredSQLError {
34 sqlstate: "42804".into(),
35 message: format!(
36 "type of parameter {number} ({}) does not match that when preparing the plan ({})",
37 actual.display_name(),
38 expected.display_name()
39 ),
40 detail: None,
41 hint: None,
42 }
43}
44
45#[derive(Debug, Clone)]
46pub enum PLpgSQLVariableReference {
47 Name(String),
48 Qualified { qualifier: String, column: String },
49 Parameter(usize),
50}
51impl PLpgSQLVariableReference {
52 pub fn read(&self, resolver: &mut dyn VariableResolver) -> Result<SQLParam, SQLError> {
53 resolver.resolve_parameter(self)?.ok_or_else(|| {
54 SQLError::Internal("prepared PL/pgSQL variable no longer resolves".into())
55 })
56 }
57}
58
59pub(super) fn resolve_parameter<R: VariableResolver + ?Sized>(
60 reference: &PLpgSQLVariableReference,
61 resolver: &mut R,
62) -> Result<Option<SQLParam>, SQLError> {
63 let value = match reference {
64 PLpgSQLVariableReference::Name(name) => resolver.resolve_name(name),
65 PLpgSQLVariableReference::Qualified { qualifier, column } => {
66 resolver.resolve_qualified(qualifier, column)
67 }
68 PLpgSQLVariableReference::Parameter(index) => resolver.resolve_param(*index),
69 }?;
70 Ok(value.map(|value| parameter(value, resolver)))
71}
72
73fn parameter<R: VariableResolver + ?Sized>(value: ResolvedVariable, resolver: &R) -> SQLParam {
74 match value
75 .declared_type
76 .as_deref()
77 .and_then(|name| resolver.parameter_type(name))
78 {
79 Some(ty) => SQLParam::typed_scalar(value.value, ty),
80 None => SQLParam::scalar(value.value),
81 }
82}
83
84pub struct PLpgSQLVariableBindings {
85 pub plan: crate::plan::UnifiedPlan,
86 pub references: Vec<PLpgSQLVariableReference>,
87 pub parameters: Vec<SQLParam>,
88}
89
90pub fn parameterize_statement_variables(
93 statement: &Statement,
94 resolver: &mut dyn VariableResolver,
95 conflict: VariableConflict,
96 resolve_sites: VariableSiteResolver<'_>,
97 aggregates: &dyn crate::plan::AggregateClassifier,
98) -> Result<PLpgSQLVariableBindings, SQLError> {
99 let keep = statement_variable_names(statement, resolver, conflict, resolve_sites)?;
100 let mut binding = VariableBindings {
101 inner: resolver,
102 keep: &keep,
103 next_name: 0,
104 references: Vec::new(),
105 parameters: Vec::new(),
106 collations: Vec::new(),
107 };
108 let statement = bind_statement(statement, &mut binding)?;
109 let mut plan = crate::plan::UnifiedPlan::lower_with(statement, aggregates);
110 plan.rewrite_scalar_expressions(&mut |expression| {
113 let crate::ScalarExpr::Param(number) = expression else {
114 return;
115 };
116 let Some(index) = number.checked_sub(1) else {
117 return;
118 };
119 let Some(oid) = binding.collations.get(index).copied().flatten() else {
120 return;
121 };
122 let Some(ty) = binding.parameters[index].declared_scalar_type() else {
123 return;
124 };
125 if crate::schema::composites::type_is_collatable(ty) {
126 *expression = crate::ScalarExpr::Collated {
127 expr: Box::new(crate::ScalarExpr::Param(*number)),
128 ty: ty.clone(),
129 collation: crate::ir::ResultCollation::new(
130 crate::catalog::collations::derivation::Derivation::implicit(i64::from(oid)),
131 oid,
132 ),
133 };
134 }
135 });
136 Ok(PLpgSQLVariableBindings {
137 plan,
138 references: binding.references,
139 parameters: binding.parameters,
140 })
141}
142struct VariableBindings<'a> {
143 inner: &'a mut dyn VariableResolver,
144 keep: &'a [bool],
145 next_name: usize,
146 references: Vec<PLpgSQLVariableReference>,
147 parameters: Vec<SQLParam>,
148 collations: Vec<Option<u32>>,
149}
150impl VariableBindings<'_> {
151 fn mark(
152 &mut self,
153 reference: PLpgSQLVariableReference,
154 value: Option<ResolvedVariable>,
155 named: bool,
156 ) -> Option<Expr> {
157 let value = value?;
158 if named {
159 let site = self.next_name;
160 self.next_name += 1;
161 if self.keep.get(site).copied().unwrap_or(false) {
162 return None;
163 }
164 }
165 self.references.push(reference);
166 self.collations.push(value.collation_oid);
167 self.parameters.push(parameter(value, self.inner));
168 Some(Expr::Param(self.references.len()))
169 }
170}
171impl VariableResolver for VariableBindings<'_> {
172 fn resolve_name(&mut self, name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
173 self.inner.resolve_name(name)
174 }
175 fn resolve_qualified(
176 &mut self,
177 qualifier: &str,
178 column: &str,
179 ) -> Result<Option<ResolvedVariable>, SQLError> {
180 self.inner.resolve_qualified(qualifier, column)
181 }
182 fn resolve_param(&mut self, index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
183 self.inner.resolve_param(index)
184 }
185 fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
186 let value = self.inner.resolve_name(name)?;
187 Ok(self.mark(
188 PLpgSQLVariableReference::Name(name.to_string()),
189 value,
190 true,
191 ))
192 }
193 fn rewrite_qualified(
194 &mut self,
195 qualifier: &str,
196 column: &str,
197 ) -> Result<Option<Expr>, SQLError> {
198 let value = self.inner.resolve_qualified(qualifier, column)?;
199 Ok(self.mark(
200 PLpgSQLVariableReference::Qualified {
201 qualifier: qualifier.to_string(),
202 column: column.to_string(),
203 },
204 value,
205 true,
206 ))
207 }
208 fn rewrite_param(&mut self, index: usize) -> Result<Option<Expr>, SQLError> {
209 let value = self.inner.resolve_param(index)?;
210 Ok(self.mark(PLpgSQLVariableReference::Parameter(index), value, false))
211 }
212}
213
214#[cfg(test)]
215mod tests;