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
9use 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
81/// Reuse the ordinary PL name/column conflict resolver, then number only names
82/// it selected as variables. Repeated reads receive fresh invocation values.
83pub 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    // A procedural variable is an implicitly collated input. Retain that
102    // identity on its parameter node before ordinary prepared analysis.
103    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;