1use crate::{
10 ast::Expr,
11 plpgsql::{ResolvedVariable, VariableResolver},
12 ResultRow as Document, SQLError,
13};
14use std::collections::BTreeMap;
15use uqa_core::{DocId, Value};
16
17pub 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 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}