Skip to main content

uqa_sql/semantics/rules/
binding.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! OLD/NEW value binding for set-oriented rewrite-rule actions.
8
9use crate::{
10    ast::Expr,
11    plpgsql::{ResolvedVariable, VariableResolver},
12    ResultRow as Document, SQLError,
13};
14use std::collections::BTreeMap;
15use uqa_core::{DocId, Value};
16
17/// Logical OLD/NEW values used by rule action binding. Physical origins and source contexts stay in the executor.
18pub trait RuleRowValues {
19    fn old_row(&self) -> Option<&Document>;
20    fn new_row(&self) -> Option<&Document>;
21    fn old_doc_id(&self) -> Option<DocId>;
22    fn new_doc_id(&self) -> Option<DocId>;
23}
24
25impl<T: RuleRowValues + ?Sized> RuleRowValues for &T {
26    fn old_row(&self) -> Option<&Document> {
27        (**self).old_row()
28    }
29    fn new_row(&self) -> Option<&Document> {
30        (**self).new_row()
31    }
32    fn old_doc_id(&self) -> Option<DocId> {
33        (**self).old_doc_id()
34    }
35    fn new_doc_id(&self) -> Option<DocId> {
36        (**self).new_doc_id()
37    }
38}
39
40mod actions;
41pub use actions::{
42    bind_insert_values_action, bind_insert_values_action_from_rows,
43    bind_insert_values_action_from_rows_with_storage, bind_set_oriented_action,
44    BoundSetOrientedAction, InsertRuleQueries, MutationRuleInput, RetainedRuleInput, RuleAction,
45    RuleMutation, RuleQueryInput, RuleQueryResolver,
46};
47
48pub struct RuleColumnMetadata {
49    pub ty: crate::ast::ColumnType,
50    pub collation_oid: Option<u32>,
51    pub uses_document_id: bool,
52    pub position: usize,
53}
54
55impl RuleColumnMetadata {
56    /// A projected OLD/NEW field is still a column of the event relation. Its source expression cannot export explicit collation strength across that boundary.
57    pub fn bind_input(&self, expression: crate::ScalarExpr) -> crate::ScalarExpr {
58        if !crate::schema::composites::type_is_collatable(&self.ty) {
59            return expression;
60        }
61        let oid = self.collation_oid.unwrap_or_else(|| {
62            u32::try_from(crate::catalog::type_metadata::pg_type_collation_oid(
63                &self.ty,
64            ))
65            .expect("type collation identity")
66        });
67        crate::ScalarExpr::Collated {
68            expr: Box::new(expression),
69            ty: self.ty.clone(),
70            collation: crate::ir::ResultCollation::new(
71                crate::catalog::collations::derivation::Derivation::implicit(i64::from(oid)),
72                oid,
73            ),
74        }
75    }
76}
77
78pub(super) struct RuntimeRuleResolver<'a> {
79    pub(super) old: Option<&'a Document>,
80    pub(super) new: Option<&'a Document>,
81    pub(super) old_doc_id: Option<DocId>,
82    pub(super) new_doc_id: Option<DocId>,
83    pub(super) columns: &'a BTreeMap<String, RuleColumnMetadata>,
84}
85
86impl RuntimeRuleResolver<'_> {
87    pub(super) fn field_expression(
88        &self,
89        record: Option<&Document>,
90        doc_id: Option<DocId>,
91        column: &str,
92    ) -> Result<Expr, SQLError> {
93        self.record_field(record, doc_id, column)
94            .map(ResolvedVariable::into_expression)
95    }
96
97    pub(super) fn record_field(
98        &self,
99        record: Option<&Document>,
100        doc_id: Option<DocId>,
101        column: &str,
102    ) -> Result<ResolvedVariable, SQLError> {
103        let (metadata, value) = self.field(record, doc_id, column)?;
104        Ok(ResolvedVariable {
105            collation_oid: metadata.collation_oid,
106            value,
107            declared_type: Some(metadata.ty.catalog_name()),
108        })
109    }
110
111    fn field(
112        &self,
113        record: Option<&Document>,
114        doc_id: Option<DocId>,
115        column: &str,
116    ) -> Result<(&RuleColumnMetadata, Value), SQLError> {
117        let metadata = self
118            .columns
119            .get(column)
120            .ok_or_else(|| SQLError::UnknownColumn(column.to_string()))?;
121        let value = if let Some(value) = record.and_then(|record| record.get(column).cloned()) {
122            value
123        } else if metadata.uses_document_id {
124            doc_id
125                .filter(|doc_id| crate::semantics::key_identity::is_key_document_id(*doc_id))
126                .map(i64::try_from)
127                .transpose()
128                .map_err(|_| {
129                    SQLError::TypeMismatch("document id exceeds PostgreSQL bigint".into())
130                })?
131                .map_or(Value::Null, Value::Int)
132        } else {
133            Value::Null
134        };
135        Ok((metadata, value))
136    }
137
138    pub(super) fn record(
139        &self,
140        record: Option<&Document>,
141        doc_id: Option<DocId>,
142    ) -> Result<ResolvedVariable, SQLError> {
143        let mut columns = self.columns.iter().collect::<Vec<_>>();
144        columns.sort_by_key(|(_, metadata)| metadata.position);
145        let fields = columns
146            .into_iter()
147            .map(|(column, _)| {
148                self.record_field(record, doc_id, column)
149                    .map(|field| (column.clone(), field.value))
150            })
151            .collect::<Result<Vec<_>, _>>()?;
152        Ok(ResolvedVariable::untyped(Value::Record(fields.into())))
153    }
154}
155
156impl VariableResolver for RuntimeRuleResolver<'_> {
157    fn resolve_name(&mut self, name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
158        if name.eq_ignore_ascii_case("old") {
159            return self.record(self.old, self.old_doc_id).map(Some);
160        }
161        if name.eq_ignore_ascii_case("new") {
162            return self.record(self.new, self.new_doc_id).map(Some);
163        }
164        Ok(None)
165    }
166
167    fn resolve_qualified(
168        &mut self,
169        qualifier: &str,
170        column: &str,
171    ) -> Result<Option<ResolvedVariable>, SQLError> {
172        if qualifier.eq_ignore_ascii_case("old") {
173            return self
174                .record_field(self.old, self.old_doc_id, column)
175                .map(Some);
176        }
177        if qualifier.eq_ignore_ascii_case("new") {
178            return self
179                .record_field(self.new, self.new_doc_id, column)
180                .map(Some);
181        }
182        Ok(None)
183    }
184
185    fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
186        Ok(None)
187    }
188
189    fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
190        Ok(self
191            .resolve_name(qualifier)?
192            .map(|record| Expr::Literal(record.value)))
193    }
194}