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