Skip to main content

uqa_sql/semantics/rules/binding/
actions.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Set-oriented rewrite-rule action binding and internal OLD/NEW row sources.
8
9use std::collections::BTreeMap;
10
11use crate::ast::{
12    ColumnType, Expr, FromClause, InsertStmt, InternalColumnRef, InternalRelationId, JoinKind,
13    OnConflict, Projection, ReturningAliases, SelectStmt, Statement,
14};
15use crate::plpgsql::{bind_expr, bind_select, ResolvedVariable, VariableResolver};
16use crate::SQLError;
17use uqa_core::Value;
18
19use super::{RuleColumnMetadata, RuleRowValues, RuntimeRuleResolver};
20
21#[cfg(test)]
22mod tests;
23
24mod retained;
25pub use retained::RetainedRuleInput;
26
27type BindRuleAction<'a> = dyn Fn(&mut dyn VariableResolver) -> Result<Statement, SQLError> + 'a;
28
29pub fn bind_insert_values_action(
30    matching_rows: &[usize],
31    rows: &[impl RuleRowValues],
32    columns: &BTreeMap<String, RuleColumnMetadata>,
33    bind_action: &BindRuleAction<'_>,
34) -> Result<Statement, SQLError> {
35    bind_insert_values_action_from_rows(
36        matching_rows.iter().map(|index| {
37            rows.get(*index).ok_or_else(|| {
38                SQLError::Internal("rewrite rule lost its qualified row image".into())
39            })
40        }),
41        columns,
42        bind_action,
43    )
44}
45
46pub fn bind_insert_values_action_from_rows<R: RuleRowValues>(
47    rows: impl IntoIterator<Item = Result<R, SQLError>>,
48    columns: &BTreeMap<String, RuleColumnMetadata>,
49    bind_action: &BindRuleAction<'_>,
50) -> Result<Statement, SQLError> {
51    bind_insert_values_action_from_rows_with_storage(rows, columns, bind_action, None)
52}
53
54pub fn bind_insert_values_action_from_rows_with_storage<R: RuleRowValues>(
55    rows: impl IntoIterator<Item = Result<R, SQLError>>,
56    columns: &BTreeMap<String, RuleColumnMetadata>,
57    bind_action: &BindRuleAction<'_>,
58    storage: Option<&dyn crate::ir::ConstantValueStorage>,
59) -> Result<Statement, SQLError> {
60    let mut combined = None;
61    for row in rows {
62        let row = row?;
63        let mut resolver = runtime_rule_resolver(&row, columns);
64        let bound = if let Some(storage) = storage {
65            bind_action(&mut RetainedInputResolver {
66                inner: &mut resolver,
67                storage,
68            })?
69        } else {
70            bind_action(&mut resolver)?
71        };
72        let Statement::Insert(mut insert) = bound else {
73            return Err(SQLError::Internal(
74                "rewrite rule INSERT VALUES action changed statement kind".into(),
75            ));
76        };
77        if let Some(Statement::Insert(existing)) = combined.as_mut() {
78            if BoundInsertContract::from(&*existing) != BoundInsertContract::from(&insert) {
79                return Err(SQLError::Internal(
80                    "rewrite rule INSERT VALUES action produced row-dependent statement clauses"
81                        .into(),
82                ));
83            }
84            existing.rows.append(&mut insert.rows);
85        } else {
86            combined = Some(Statement::Insert(insert));
87        }
88    }
89    if let Some(bound) = combined {
90        Ok(bound)
91    } else {
92        let mut bound = bind_action(&mut RuntimeRuleResolver {
93            old: None,
94            new: None,
95            old_doc_id: None,
96            new_doc_id: None,
97            columns,
98        })?;
99        let Statement::Insert(insert) = &mut bound else {
100            return Err(SQLError::Internal(
101                "rewrite rule INSERT VALUES action changed statement kind".into(),
102            ));
103        };
104        insert.rows.clear();
105        Ok(bound)
106    }
107}
108
109struct RetainedInputResolver<'a, 'b> {
110    inner: &'a mut RuntimeRuleResolver<'b>,
111    storage: &'a dyn crate::ir::ConstantValueStorage,
112}
113
114impl VariableResolver for RetainedInputResolver<'_, '_> {
115    fn resolve_name(&mut self, name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
116        self.inner.resolve_name(name)
117    }
118    fn resolve_qualified(
119        &mut self,
120        qualifier: &str,
121        column: &str,
122    ) -> Result<Option<ResolvedVariable>, SQLError> {
123        self.inner.resolve_qualified(qualifier, column)
124    }
125    fn resolve_param(&mut self, index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
126        self.inner.resolve_param(index)
127    }
128    fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
129        self.inner
130            .rewrite_name(name)?
131            .map(|value| crate::ast::RetainedInputLiteral::retain(value, self.storage))
132            .transpose()
133    }
134    fn rewrite_qualified(
135        &mut self,
136        qualifier: &str,
137        column: &str,
138    ) -> Result<Option<Expr>, SQLError> {
139        self.inner
140            .rewrite_qualified(qualifier, column)?
141            .map(|value| crate::ast::RetainedInputLiteral::retain(value, self.storage))
142            .transpose()
143    }
144    fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
145        self.inner.rewrite_qualified_whole_row(qualifier)
146    }
147}
148
149#[derive(PartialEq)]
150struct BoundInsertContract<'a> {
151    table: &'a str,
152    target_relation_bound: bool,
153    target_qualifier: &'a str,
154    include_descendants: bool,
155    columns: &'a [crate::ast::AssignmentTarget],
156    with: &'a [crate::ast::CTE],
157    select_source: Option<&'a SelectStmt>,
158    on_conflict: Option<&'a OnConflict>,
159    returning: &'a [Projection],
160    returning_aliases: &'a ReturningAliases,
161}
162
163impl<'a> From<&'a InsertStmt> for BoundInsertContract<'a> {
164    fn from(insert: &'a InsertStmt) -> Self {
165        Self {
166            table: &insert.table,
167            target_relation_bound: insert.target_relation_bound,
168            target_qualifier: &insert.target_qualifier,
169            include_descendants: insert.include_descendants,
170            columns: &insert.columns,
171            with: &insert.with,
172            select_source: insert.select_source.as_deref(),
173            on_conflict: insert.on_conflict.as_ref(),
174            returning: &insert.returning,
175            returning_aliases: &insert.returning_aliases,
176        }
177    }
178}
179
180fn runtime_rule_resolver<'a>(
181    row: &'a dyn RuleRowValues,
182    columns: &'a BTreeMap<String, RuleColumnMetadata>,
183) -> RuntimeRuleResolver<'a> {
184    RuntimeRuleResolver {
185        old: row.old_row(),
186        new: row.new_row(),
187        old_doc_id: row.old_doc_id(),
188        new_doc_id: row.new_doc_id(),
189        columns,
190    }
191}
192
193struct RuleRowSource {
194    clause: FromClause,
195    metadata: RuleRowMetadata,
196}
197
198struct RuleRowMetadata {
199    relation: InternalRelationId,
200    old_columns: BTreeMap<String, InternalColumnRef>,
201    new_columns: BTreeMap<String, InternalColumnRef>,
202    old_row: InternalColumnRef,
203    new_row: InternalColumnRef,
204    source_index: InternalColumnRef,
205    types: Vec<Option<ColumnType>>,
206    collations: Vec<Option<u32>>,
207}
208
209pub struct BoundSetOrientedAction {
210    pub statement: Statement,
211    pub source_index: Expr,
212}
213
214pub fn bind_set_oriented_action(
215    matching_rows: &[usize],
216    rows: &[impl RuleRowValues],
217    columns: &BTreeMap<String, RuleColumnMetadata>,
218    bind_action: &BindRuleAction<'_>,
219) -> Result<BoundSetOrientedAction, SQLError> {
220    let source = rule_row_source(matching_rows, rows, columns)?;
221    bind_source_action(source, bind_action)
222}
223
224fn bind_source_action(
225    source: RuleRowSource,
226    bind_action: &BindRuleAction<'_>,
227) -> Result<BoundSetOrientedAction, SQLError> {
228    let source_index = Expr::InternalColumn(source.metadata.source_index);
229    let mut bound = bind_action(&mut RuleSourceResolver {
230        old_columns: &source.metadata.old_columns,
231        new_columns: &source.metadata.new_columns,
232        old_row: source.metadata.old_row,
233        new_row: source.metadata.new_row,
234    })?;
235    attach_rule_row_source(&mut bound, source.clause, source.metadata.relation)?;
236    Ok(BoundSetOrientedAction {
237        statement: bound,
238        source_index,
239    })
240}
241
242fn rule_row_source(
243    matching_rows: &[usize],
244    rows: &[impl RuleRowValues],
245    columns: &BTreeMap<String, RuleColumnMetadata>,
246) -> Result<RuleRowSource, SQLError> {
247    let metadata = rule_row_metadata(InternalRelationId::allocate(), columns);
248    let values = matching_rows
249        .iter()
250        .map(|row_index| {
251            let row = rows.get(*row_index).ok_or_else(|| {
252                SQLError::Internal("rewrite rule lost its qualified row image".into())
253            })?;
254            let resolver = runtime_rule_resolver(row, columns);
255            let mut values = Vec::with_capacity(metadata.types.len());
256            for column in columns.keys() {
257                values.push(resolver.field_expression(row.old_row(), row.old_doc_id(), column)?);
258                values.push(resolver.field_expression(row.new_row(), row.new_doc_id(), column)?);
259            }
260            values.push(ResolvedVariable::into_expression(
261                resolver.record(row.old_row(), row.old_doc_id())?,
262            ));
263            values.push(ResolvedVariable::into_expression(
264                resolver.record(row.new_row(), row.new_doc_id())?,
265            ));
266            let row_index = i64::try_from(*row_index).map_err(|_| {
267                SQLError::Internal("rewrite rule event row index exceeds BIGINT".into())
268            })?;
269            values.push(Expr::Literal(Value::Int(row_index)));
270            Ok(values)
271        })
272        .collect::<Result<Vec<_>, SQLError>>()?;
273    Ok(RuleRowSource {
274        clause: FromClause::Values {
275            rows: values,
276            alias: None,
277            column_aliases: Vec::new(),
278            internal_relation: Some(metadata.relation),
279            internal_column_types: metadata.types.clone(),
280            internal_column_collations: metadata.collations.clone(),
281        },
282        metadata,
283    })
284}
285
286fn rule_row_metadata(
287    relation: InternalRelationId,
288    columns: &BTreeMap<String, RuleColumnMetadata>,
289) -> RuleRowMetadata {
290    let mut internal_column_types = Vec::with_capacity(columns.len() * 2 + 3);
291    let mut internal_column_collations = Vec::with_capacity(columns.len() * 2 + 3);
292    let mut old_columns = BTreeMap::new();
293    let mut new_columns = BTreeMap::new();
294    for (index, (column, metadata)) in columns.iter().enumerate() {
295        let old = relation.column(index * 2);
296        let new = relation.column(index * 2 + 1);
297        old_columns.insert(column.clone(), old);
298        new_columns.insert(column.clone(), new);
299        internal_column_types.push(Some(metadata.ty.clone()));
300        internal_column_types.push(Some(metadata.ty.clone()));
301        internal_column_collations.extend([metadata.collation_oid; 2]);
302    }
303    let old_row = relation.column(internal_column_types.len());
304    internal_column_types.push(Some(ColumnType::Record));
305    let new_row = relation.column(internal_column_types.len());
306    internal_column_types.push(Some(ColumnType::Record));
307    let source_index = relation.column(internal_column_types.len());
308    internal_column_types.push(Some(ColumnType::BigInteger));
309    internal_column_collations.extend([None; 3]);
310    RuleRowMetadata {
311        relation,
312        old_columns,
313        new_columns,
314        old_row,
315        new_row,
316        source_index,
317        types: internal_column_types,
318        collations: internal_column_collations,
319    }
320}
321
322struct RuleSourceResolver<'a> {
323    old_columns: &'a BTreeMap<String, InternalColumnRef>,
324    new_columns: &'a BTreeMap<String, InternalColumnRef>,
325    old_row: InternalColumnRef,
326    new_row: InternalColumnRef,
327}
328
329impl VariableResolver for RuleSourceResolver<'_> {
330    fn resolve_name(&mut self, _name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
331        Ok(None)
332    }
333
334    fn resolve_qualified(
335        &mut self,
336        _qualifier: &str,
337        _column: &str,
338    ) -> Result<Option<ResolvedVariable>, SQLError> {
339        Ok(None)
340    }
341
342    fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
343        Ok(None)
344    }
345
346    fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
347        Ok(if name.eq_ignore_ascii_case("old") {
348            Some(Expr::InternalColumn(self.old_row))
349        } else if name.eq_ignore_ascii_case("new") {
350            Some(Expr::InternalColumn(self.new_row))
351        } else {
352            None
353        })
354    }
355
356    fn rewrite_qualified(
357        &mut self,
358        qualifier: &str,
359        column: &str,
360    ) -> Result<Option<Expr>, SQLError> {
361        let columns = if qualifier.eq_ignore_ascii_case("old") {
362            self.old_columns
363        } else if qualifier.eq_ignore_ascii_case("new") {
364            self.new_columns
365        } else {
366            return Ok(None);
367        };
368        let source_column = columns
369            .get(column)
370            .ok_or_else(|| SQLError::UnknownColumn(format!("{qualifier}.{column}")))?;
371        Ok(Some(Expr::InternalColumn(*source_column)))
372    }
373
374    fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
375        self.rewrite_name(qualifier)
376    }
377}
378
379fn attach_rule_row_source(
380    statement: &mut Statement,
381    source: FromClause,
382    relation: InternalRelationId,
383) -> Result<(), SQLError> {
384    match statement {
385        Statement::Select(select) => attach_select_rule_source(select, &source, relation),
386        Statement::Insert(insert) => {
387            let select = insert.select_source.as_mut().ok_or_else(|| {
388                SQLError::Internal("set-oriented rule INSERT action has no SELECT source".into())
389            })?;
390            attach_select_rule_source(select, &source, relation);
391        }
392        Statement::Update(update) => {
393            update.from = Some(prepend_rule_row_source(
394                update.from.take(),
395                source,
396                relation,
397            ));
398        }
399        Statement::Delete(delete) => {
400            delete.using = Some(prepend_rule_row_source(
401                delete.using.take(),
402                source,
403                relation,
404            ));
405        }
406        _ => {
407            return Err(SQLError::Internal(
408                "validated rewrite-rule action changed statement kind".into(),
409            ))
410        }
411    }
412    Ok(())
413}
414
415fn attach_select_rule_source(
416    select: &mut SelectStmt,
417    source: &FromClause,
418    relation: InternalRelationId,
419) {
420    if let Some(set_op) = select.set_op.as_mut() {
421        if let Some(left) = set_op.left.as_mut() {
422            attach_select_rule_source(left, source, relation);
423        } else {
424            select.from = Some(prepend_rule_row_source(
425                select.from.take(),
426                source.clone(),
427                relation,
428            ));
429        }
430        attach_select_rule_source(&mut set_op.right, source, relation);
431    } else {
432        select.from = Some(prepend_rule_row_source(
433            select.from.take(),
434            source.clone(),
435            relation,
436        ));
437    }
438}
439
440fn prepend_rule_row_source(
441    existing: Option<FromClause>,
442    source: FromClause,
443    relation: InternalRelationId,
444) -> FromClause {
445    let Some(existing) = existing else {
446        return source;
447    };
448    let lateral = from_references_internal_relation(&existing, relation);
449    FromClause::Join {
450        left: Box::new(source),
451        right: Box::new(existing),
452        kind: JoinKind::Cross,
453        on: None,
454        using: None,
455        natural: false,
456        alias: None,
457        column_aliases: Vec::new(),
458        lateral,
459    }
460}
461
462struct InternalReferenceResolver {
463    relation: InternalRelationId,
464    referenced: bool,
465}
466
467impl VariableResolver for InternalReferenceResolver {
468    fn resolve_name(&mut self, _name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
469        Ok(None)
470    }
471
472    fn resolve_qualified(
473        &mut self,
474        _qualifier: &str,
475        _column: &str,
476    ) -> Result<Option<ResolvedVariable>, SQLError> {
477        Ok(None)
478    }
479
480    fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
481        Ok(None)
482    }
483
484    fn rewrite_internal(&mut self, column: InternalColumnRef) -> Result<Option<Expr>, SQLError> {
485        if column.relation() == self.relation {
486            self.referenced = true;
487        }
488        Ok(None)
489    }
490}
491
492fn expr_references_internal_relation(expr: &Expr, relation: InternalRelationId) -> bool {
493    let mut resolver = InternalReferenceResolver {
494        relation,
495        referenced: false,
496    };
497    let _ = bind_expr(expr, &mut resolver);
498    resolver.referenced
499}
500
501fn select_references_internal_relation(select: &SelectStmt, relation: InternalRelationId) -> bool {
502    let mut resolver = InternalReferenceResolver {
503        relation,
504        referenced: false,
505    };
506    let _ = bind_select(select, &mut resolver);
507    resolver.referenced
508}
509
510fn from_references_internal_relation(from: &FromClause, relation: InternalRelationId) -> bool {
511    match from {
512        crate::ast::FromClause::RetainedRows(_) => false,
513        FromClause::Table { .. } => false,
514        FromClause::Join {
515            left, right, on, ..
516        } => {
517            from_references_internal_relation(left, relation)
518                || from_references_internal_relation(right, relation)
519                || on
520                    .as_ref()
521                    .is_some_and(|expr| expr_references_internal_relation(expr, relation))
522        }
523        FromClause::Values { rows, .. } => rows
524            .iter()
525            .flatten()
526            .any(|expr| expr_references_internal_relation(expr, relation)),
527        FromClause::Function { args, .. } => args
528            .iter()
529            .any(|expr| expr_references_internal_relation(expr, relation)),
530        FromClause::FunctionGroup { functions, .. } => functions.iter().any(|function| {
531            function
532                .args
533                .iter()
534                .any(|expr| expr_references_internal_relation(expr, relation))
535        }),
536        FromClause::Subquery { body, .. } => select_references_internal_relation(body, relation),
537    }
538}