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