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