uqa_sql/semantics/rules/
binding.rs1use 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, RetainedRuleInput,
45};
46
47pub struct RuleColumnMetadata {
48 pub ty: crate::ast::ColumnType,
49 pub collation_oid: Option<u32>,
50 pub uses_document_id: bool,
51 pub position: usize,
52}
53
54impl RuleColumnMetadata {
55 pub fn bind_input(&self, expression: crate::ScalarExpr) -> crate::ScalarExpr {
57 if !crate::schema::composites::type_is_collatable(&self.ty) {
58 return expression;
59 }
60 let oid = self.collation_oid.unwrap_or_else(|| {
61 u32::try_from(crate::catalog::type_metadata::pg_type_collation_oid(
62 &self.ty,
63 ))
64 .expect("type collation identity")
65 });
66 crate::ScalarExpr::Collated {
67 expr: Box::new(expression),
68 ty: self.ty.clone(),
69 collation: crate::ir::ResultCollation::new(
70 crate::catalog::collations::derivation::Derivation::implicit(i64::from(oid)),
71 oid,
72 ),
73 }
74 }
75}
76
77pub(super) struct RuntimeRuleResolver<'a> {
78 pub(super) old: Option<&'a Document>,
79 pub(super) new: Option<&'a Document>,
80 pub(super) old_doc_id: Option<DocId>,
81 pub(super) new_doc_id: Option<DocId>,
82 pub(super) columns: &'a BTreeMap<String, RuleColumnMetadata>,
83}
84
85impl RuntimeRuleResolver<'_> {
86 pub(super) fn field_expression(
87 &self,
88 record: Option<&Document>,
89 doc_id: Option<DocId>,
90 column: &str,
91 ) -> Result<Expr, SQLError> {
92 self.record_field(record, doc_id, column)
93 .map(ResolvedVariable::into_expression)
94 }
95
96 pub(super) fn record_field(
97 &self,
98 record: Option<&Document>,
99 doc_id: Option<DocId>,
100 column: &str,
101 ) -> Result<ResolvedVariable, SQLError> {
102 let (metadata, value) = self.field(record, doc_id, column)?;
103 Ok(ResolvedVariable {
104 collation_oid: metadata.collation_oid,
105 value,
106 declared_type: Some(metadata.ty.catalog_name()),
107 })
108 }
109
110 fn field(
111 &self,
112 record: Option<&Document>,
113 doc_id: Option<DocId>,
114 column: &str,
115 ) -> Result<(&RuleColumnMetadata, Value), SQLError> {
116 let metadata = self
117 .columns
118 .get(column)
119 .ok_or_else(|| SQLError::UnknownColumn(column.to_string()))?;
120 let value = if let Some(value) = record.and_then(|record| record.get(column).cloned()) {
121 value
122 } else if metadata.uses_document_id {
123 doc_id
124 .filter(|doc_id| crate::semantics::key_identity::is_key_document_id(*doc_id))
125 .map(i64::try_from)
126 .transpose()
127 .map_err(|_| {
128 SQLError::TypeMismatch("document id exceeds PostgreSQL bigint".into())
129 })?
130 .map_or(Value::Null, Value::Int)
131 } else {
132 Value::Null
133 };
134 Ok((metadata, value))
135 }
136
137 pub(super) fn record(
138 &self,
139 record: Option<&Document>,
140 doc_id: Option<DocId>,
141 ) -> Result<ResolvedVariable, SQLError> {
142 let mut columns = self.columns.iter().collect::<Vec<_>>();
143 columns.sort_by_key(|(_, metadata)| metadata.position);
144 let fields = columns
145 .into_iter()
146 .map(|(column, _)| {
147 self.record_field(record, doc_id, column)
148 .map(|field| (column.clone(), field.value))
149 })
150 .collect::<Result<Vec<_>, _>>()?;
151 Ok(ResolvedVariable::untyped(Value::Record(fields.into())))
152 }
153}
154
155impl VariableResolver for RuntimeRuleResolver<'_> {
156 fn resolve_name(&mut self, name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
157 if name.eq_ignore_ascii_case("old") {
158 return self.record(self.old, self.old_doc_id).map(Some);
159 }
160 if name.eq_ignore_ascii_case("new") {
161 return self.record(self.new, self.new_doc_id).map(Some);
162 }
163 Ok(None)
164 }
165
166 fn resolve_qualified(
167 &mut self,
168 qualifier: &str,
169 column: &str,
170 ) -> Result<Option<ResolvedVariable>, SQLError> {
171 if qualifier.eq_ignore_ascii_case("old") {
172 return self
173 .record_field(self.old, self.old_doc_id, column)
174 .map(Some);
175 }
176 if qualifier.eq_ignore_ascii_case("new") {
177 return self
178 .record_field(self.new, self.new_doc_id, column)
179 .map(Some);
180 }
181 Ok(None)
182 }
183
184 fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
185 Ok(None)
186 }
187
188 fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
189 Ok(self
190 .resolve_name(qualifier)?
191 .map(|record| Expr::Literal(record.value)))
192 }
193}