Skip to main content

uqa_sql/semantics/rules/binding/actions/query/
resolver.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Native event templates own their syntax and deferred diagnostics independently of executable query inputs.
8
9use crate::{
10    ast::{DeferredSQLError, Expr, InternalColumnRef, InternalRelationId},
11    plan::{
12        copy::SyntaxProduction, input_projection::OwnedInputProjections, ExpressionPlan,
13        InsertPlan, MutableExpressionPlan, RelationalPlan,
14    },
15    plpgsql::{ResolvedVariable, RewriteReference, VariableResolver},
16    semantics::rules::analysis::{rule_returning_columns_with_control, RuleAnalysisContext},
17    SQLError,
18};
19use uqa_core::memory::{OwnedMap, Produced, ProductionControl};
20
21mod conditions;
22mod mutation;
23
24struct RuleColumnTemplate {
25    name: String,
26    old: Expr,
27    new: Result<Expr, DeferredSQLError>,
28}
29
30pub struct RuleInputColumns {
31    pub positions: Produced<Vec<usize>>,
32    pub width: usize,
33}
34
35pub struct OwnedRuleQueryResolver {
36    table: Produced<String>,
37    columns: Produced<Vec<RuleColumnTemplate>>,
38    pub expressions: OwnedInputProjections,
39}
40
41impl OwnedRuleQueryResolver {
42    pub(in crate::semantics::rules::binding::actions::query) fn column_count(&self) -> usize {
43        self.columns.len()
44    }
45
46    pub fn reserved_bytes(&self) -> usize {
47        self.table.reserved_bytes()
48            + self.columns.reserved_bytes()
49            + self.expressions.allocated_bytes()
50            + self
51                .expressions
52                .values()
53                .map(Produced::reserved_bytes)
54                .sum::<usize>()
55    }
56
57    pub fn input_columns_with_control(
58        &self,
59        context: RuleAnalysisContext<'_>,
60        insert: &InsertPlan,
61        action: &crate::ast::Statement,
62        condition: Option<&Expr>,
63        target_columns: &dyn crate::semantics::rules::action_binding::ActionColumns,
64        control: &ProductionControl<'_>,
65    ) -> Result<Option<RuleInputColumns>, SQLError> {
66        let Some(required) =
67            crate::semantics::rules::action_binding::rule_action_input_columns_with_control(
68                context.sources,
69                action,
70                condition,
71                target_columns,
72                control,
73            )?
74        else {
75            return Ok(None);
76        };
77        let width = if insert.columns.is_empty() {
78            insert
79                .source
80                .as_deref()
81                .and_then(|query| query.analyzed_output.as_ref())
82                .map_or_else(
83                    || super::inline_width(insert).unwrap_or(self.columns.len()),
84                    crate::RowSchema::len,
85                )
86                .min(self.columns.len())
87        } else {
88            insert.columns.len()
89        };
90        let mut positions = uqa_core::memory::ProductionVec::new(*control);
91        for position in 0..width {
92            control.check()?;
93            let name = if insert.columns.is_empty() {
94                &self.columns[position].name
95            } else {
96                &insert.columns[position].column
97            };
98            if required.binary_search(name).is_ok() {
99                positions.push_copy(position)?;
100            }
101        }
102        Ok(Some(RuleInputColumns {
103            positions: positions.finish()?,
104            width,
105        }))
106    }
107
108    pub fn from_insert_with_control(
109        context: RuleAnalysisContext<'_>,
110        insert: &InsertPlan,
111        relation: InternalRelationId,
112        control: &ProductionControl<'_>,
113    ) -> Result<Self, SQLError> {
114        control.check()?;
115        let definitions = rule_returning_columns_with_control(context, &insert.table, control)?;
116        let width = insert
117            .source
118            .as_deref()
119            .and_then(|source| source.analyzed_output.as_ref())
120            .map_or_else(
121                || super::inline_width(insert).unwrap_or(definitions.len()),
122                crate::RowSchema::len,
123            );
124        let output = SyntaxProduction::new(*control);
125        let mut columns = output.vector(definitions.len())?;
126        let mut pending = crate::production::Buffer::new(control);
127        for column in &*definitions {
128            output.check()?;
129            let ty = column.ty.catalog_name_with_control(control)?;
130            let old = Expr::Cast {
131                implicit: true,
132                expr: output.boxed(Expr::Literal(uqa_core::Value::Null))?,
133                ty: output.take(ty),
134            };
135            let expression = insert_column(
136                context,
137                insert,
138                &definitions,
139                column,
140                relation,
141                width,
142                control,
143            )?;
144            let expression = bind_column_collation(expression, column, control)?;
145            let reference = InternalRelationId::allocate().column(0);
146            pending.push((reference, expression), control)?;
147            columns.push(RuleColumnTemplate {
148                name: output.text(&column.name)?,
149                old,
150                new: Ok(Expr::InternalColumn(reference)),
151            })?;
152        }
153        let mut inputs = inline_inputs(insert, relation, control)?;
154        let subject = insert
155            .source
156            .as_ref()
157            .and_then(|source| source.relation_privilege_subject.as_ref());
158        let mut expressions = OwnedMap::new();
159        for (reference, expression) in pending {
160            let expression = crate::plan::input_projection::substitute_expression_inputs_owned(
161                expression, &inputs, control,
162            )?;
163            let expression = retain_authority(expression, subject, control)?;
164            insert_expression(
165                &mut expressions,
166                reference,
167                expression.finish(control)?,
168                control,
169            )?;
170        }
171        for (reference, expression) in std::mem::take(&mut inputs) {
172            insert_expression(&mut expressions, reference, expression, control)?;
173        }
174        let columns = columns.finish()?;
175        let columns = output.finish(columns)?;
176        Ok(Self {
177            table: control.copy_text(&insert.table)?,
178            columns,
179            expressions,
180        })
181    }
182}
183
184fn insert_column(
185    context: RuleAnalysisContext<'_>,
186    insert: &InsertPlan,
187    definitions: &[crate::ast::ColumnDef],
188    column: &crate::ast::ColumnDef,
189    relation: InternalRelationId,
190    width: usize,
191    control: &ProductionControl<'_>,
192) -> Result<MutableExpressionPlan, SQLError> {
193    if insert
194        .columns
195        .iter()
196        .any(|target| target.column == column.name && !target.is_whole_column())
197    {
198        return super::assignments::column_expression_with_control(
199            context, insert, column, relation, control,
200        );
201    }
202    let position = if insert.columns.is_empty() {
203        definitions
204            .iter()
205            .take(width)
206            .position(|candidate| candidate.name == column.name)
207    } else {
208        insert
209            .columns
210            .iter()
211            .position(|target| target.column == column.name)
212    }
213    .filter(|_| !super::values::overrides_identity(column, insert.overriding));
214    let value = if let Some(position) = position {
215        ExpressionPlan::lower_borrowed_for_rewrite(
216            &Expr::InternalColumn(relation.column(position)),
217            control,
218        )?
219    } else {
220        let default = super::values::default_expression_with_control(context, column, control)?;
221        ExpressionPlan::lower_borrowed_for_rewrite(
222            default
223                .as_deref()
224                .unwrap_or(&Expr::Literal(uqa_core::Value::Null)),
225            control,
226        )?
227    };
228    value.map_scalar(control, |scalar, _| {
229        Ok(crate::plan::OwnedScalarExpr::cast(
230            scalar,
231            column.ty.catalog_name_with_control(control)?,
232            true,
233            control,
234        )?)
235    })
236}
237
238pub(super) fn insert_expression(
239    output: &mut OwnedInputProjections,
240    reference: InternalColumnRef,
241    expression: Produced<ExpressionPlan>,
242    control: &ProductionControl<'_>,
243) -> Result<(), SQLError> {
244    control.check()?;
245    if let Some(budget) = control.budget() {
246        output.insert_budgeted(reference, expression, budget)?;
247    } else {
248        output.insert(reference, expression);
249    }
250    Ok(())
251}
252
253fn inline_inputs(
254    insert: &InsertPlan,
255    relation: InternalRelationId,
256    control: &ProductionControl<'_>,
257) -> Result<OwnedInputProjections, SQLError> {
258    let mut inputs = OwnedMap::new();
259    if !insert
260        .rule_values_input
261        .as_ref()
262        .is_some_and(crate::plan::RuleValuesInput::is_inline)
263    {
264        return Ok(inputs);
265    }
266    let source = insert.source.as_ref().expect("inline input query");
267    let RelationalPlan::QueryBlock(block) = &source.root else {
268        return Err(SQLError::Internal(
269            "rule target list lost its query block".into(),
270        ));
271    };
272    for (position, projection) in block.projections.iter().enumerate() {
273        let expression =
274            MutableExpressionPlan::copy_from(&projection.expr, &block.subqueries, control)?
275                .prune_subqueries(control)?;
276        let expression = retain_authority(
277            expression,
278            source.relation_privilege_subject.as_ref(),
279            control,
280        )?;
281        insert_expression(
282            &mut inputs,
283            relation.column(position),
284            expression.finish(control)?,
285            control,
286        )?;
287    }
288    Ok(inputs)
289}
290
291pub(super) fn retain_authority(
292    mut expression: MutableExpressionPlan,
293    subject: Option<&crate::catalog::roles::RoleReference>,
294    control: &ProductionControl<'_>,
295) -> Result<MutableExpressionPlan, SQLError> {
296    if let Some(subject) = subject {
297        for index in 0..expression.queries().len() {
298            if expression.queries()[index]
299                .relation_privilege_subject
300                .is_none()
301            {
302                expression = expression.map_query(index, control, |query| {
303                    query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
304                })?;
305            }
306        }
307    }
308    Ok(expression)
309}
310
311pub(super) fn bind_column_collation(
312    expression: MutableExpressionPlan,
313    column: &crate::ast::ColumnDef,
314    control: &ProductionControl<'_>,
315) -> Result<MutableExpressionPlan, SQLError> {
316    if !crate::schema::composites::type_is_collatable(&column.ty) {
317        return Ok(expression);
318    }
319    let oid = column.collation_oid.unwrap_or_else(|| {
320        u32::try_from(crate::catalog::type_metadata::pg_type_collation_oid(
321            &column.ty,
322        ))
323        .expect("type collation identity")
324    });
325    let collation = crate::ir::ResultCollation::new(
326        crate::catalog::collations::derivation::Derivation::implicit(i64::from(oid)),
327        oid,
328    );
329    expression.map_scalar(control, |scalar, _| {
330        Ok(crate::plan::OwnedScalarExpr::collated(
331            scalar,
332            column.ty.clone_with_control(control)?,
333            collation,
334            control,
335        )?)
336    })
337}
338
339impl VariableResolver for OwnedRuleQueryResolver {
340    fn rewrite_with_control(
341        &mut self,
342        reference: RewriteReference<'_>,
343        control: &ProductionControl<'_>,
344    ) -> Result<Option<Produced<Expr>>, SQLError> {
345        control.check()?;
346        let output = SyntaxProduction::new(*control);
347        let selected = |column: &RuleColumnTemplate, new: bool| -> Result<Expr, SQLError> {
348            if new {
349                output.copy(
350                    column
351                        .new
352                        .as_ref()
353                        .map_err(|error| SQLError::from(error.clone()))?,
354                )
355            } else {
356                output.copy(&column.old)
357            }
358        };
359        let expression = match reference {
360            RewriteReference::Name(name) | RewriteReference::WholeRow(name) => {
361                let new = name.eq_ignore_ascii_case("new");
362                if !new && !name.eq_ignore_ascii_case("old") {
363                    return Ok(None);
364                }
365                let mut items = output.vector(self.columns.len())?;
366                for column in &*self.columns {
367                    items.push(selected(column, new)?)?;
368                }
369                Expr::Cast {
370                    implicit: true,
371                    expr: output.boxed(Expr::Row(items.finish()?))?,
372                    ty: output.text(&self.table)?,
373                }
374            }
375            RewriteReference::Qualified { qualifier, column } => {
376                let new = qualifier.eq_ignore_ascii_case("new");
377                if !new && !qualifier.eq_ignore_ascii_case("old") {
378                    return Ok(None);
379                }
380                let selected_column = self
381                    .columns
382                    .iter()
383                    .find(|value| value.name == column)
384                    .ok_or_else(|| SQLError::UnknownColumn(format!("{qualifier}.{column}")))?;
385                selected(selected_column, new)?
386            }
387            RewriteReference::Parameter(_) | RewriteReference::Internal(_) => return Ok(None),
388        };
389        Ok(Some(output.finish(expression)?))
390    }
391    fn resolve_name(&mut self, _: &str) -> Result<Option<ResolvedVariable>, SQLError> {
392        Ok(None)
393    }
394    fn resolve_qualified(
395        &mut self,
396        _: &str,
397        _: &str,
398    ) -> Result<Option<ResolvedVariable>, SQLError> {
399        Ok(None)
400    }
401    fn resolve_param(&mut self, _: usize) -> Result<Option<ResolvedVariable>, SQLError> {
402        Ok(None)
403    }
404    fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
405        Ok(self
406            .rewrite_with_control(
407                RewriteReference::Name(name),
408                &ProductionControl::uncontrolled(),
409            )?
410            .map(|value| value.into_uncontrolled().expect("ordinary reference")))
411    }
412    fn rewrite_qualified(
413        &mut self,
414        qualifier: &str,
415        column: &str,
416    ) -> Result<Option<Expr>, SQLError> {
417        Ok(self
418            .rewrite_with_control(
419                RewriteReference::Qualified { qualifier, column },
420                &ProductionControl::uncontrolled(),
421            )?
422            .map(|value| value.into_uncontrolled().expect("ordinary reference")))
423    }
424    fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
425        self.rewrite_name(qualifier)
426    }
427}