Skip to main content

uqa_sql/plpgsql/
parameters.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind procedural variables as invocation parameters, preserving catalog inputs.
8
9mod 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
90/// Reuse the ordinary PL name/column conflict resolver, then number only names
91/// it selected as variables. Repeated reads receive fresh invocation values.
92pub 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    // A procedural variable is an implicitly collated input. Retain that
111    // identity on its parameter node before ordinary prepared analysis.
112    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;