1use 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}