Skip to main content

uqa_sql/plpgsql/parameters/
owned.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Procedural parameters borrow syntax and admit only selected variable inputs and the final executable.
8
9use 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, &params, 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, &params.finish()?, names.finish()?, control)?
165    };
166    // Conflict diagnostics follow the first analysis site, before reading invocation values again.
167    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}