1use std::cell::RefCell;
10use std::collections::{BTreeMap, BTreeSet};
11
12use uqa_core::{DocId, Value};
13use uqa_sql::ast::{TriggerEvent, TriggerTiming};
14use uqa_sql::error::Result;
15use uqa_sql::plpgsql::{bind_expr, ResolvedVariable, VariableResolver};
16use uqa_sql::SQLError;
17use uqa_storage::document_store::Document;
18
19use context::TriggerContext;
20
21#[cfg(test)]
22mod tests;
23use uqa_core::RelationIdentity;
24pub mod context;
25
26use crate::routines::TriggerRoutineContext;
27
28type TransitionCaptureKey = (String, &'static str, Vec<String>);
29type TransitionCaptureStack = Vec<BTreeMap<TransitionCaptureKey, bool>>;
30
31thread_local! {
32 static ACTIVE_TRANSITION_RELATIONS: RefCell<Vec<BTreeMap<String, crate::SharedSpill>>> = const { RefCell::new(Vec::new()) };
33 static TRANSITION_CAPTURE_CACHE: RefCell<TransitionCaptureStack> = const { RefCell::new(Vec::new()) };
34 static TRIGGER_DEPTH: std::cell::Cell<i64> = const { std::cell::Cell::new(0) };
36}
37
38pub fn trigger_depth() -> i64 {
40 TRIGGER_DEPTH.with(std::cell::Cell::get)
41}
42
43struct TriggerDepthScope;
45
46impl TriggerDepthScope {
47 fn enter() -> Self {
48 TRIGGER_DEPTH.with(|depth| depth.set(depth.get() + 1));
49 Self
50 }
51}
52
53impl Drop for TriggerDepthScope {
54 fn drop(&mut self) {
55 TRIGGER_DEPTH.with(|depth| depth.set(depth.get() - 1));
56 }
57}
58
59pub struct TransitionRelationScope;
60
61impl TransitionRelationScope {
62 fn enter(relations: BTreeMap<String, crate::SharedSpill>) -> Self {
63 ACTIVE_TRANSITION_RELATIONS.with(|active| active.borrow_mut().push(relations));
64 Self
65 }
66
67 fn empty() -> Self {
68 Self::enter(BTreeMap::new())
69 }
70}
71
72impl Drop for TransitionRelationScope {
73 fn drop(&mut self) {
74 ACTIVE_TRANSITION_RELATIONS.with(|relations| {
75 let removed = relations.borrow_mut().pop();
76 debug_assert!(
77 removed.is_some(),
78 "transition relation scope stack underflow"
79 );
80 });
81 }
82}
83
84pub fn current_transition_relations() -> BTreeMap<String, crate::SharedSpill> {
85 ACTIVE_TRANSITION_RELATIONS
86 .with(|relations| relations.borrow().last().cloned().unwrap_or_default())
87}
88
89pub fn with_current_transition_relations<T>(
91 visit: impl FnOnce(Option<&BTreeMap<String, crate::SharedSpill>>) -> T,
92) -> T {
93 ACTIVE_TRANSITION_RELATIONS.with(|relations| {
94 let relations = relations.borrow();
95 visit(relations.last())
96 })
97}
98
99pub fn current_transition_relation_names() -> BTreeSet<String> {
100 ACTIVE_TRANSITION_RELATIONS.with(|relations| {
101 relations
102 .borrow()
103 .last()
104 .map(|relations| relations.keys().cloned().collect())
105 .unwrap_or_default()
106 })
107}
108
109pub fn current_transition_relation_names_with_control(
111 control: &uqa_core::memory::ProductionControl<'_>,
112) -> Result<uqa_sql::binding::production::BindingNameSet> {
113 control.check()?;
114 with_current_transition_relations(|relations| {
115 let mut names = uqa_sql::binding::production::BindingNameSet::new();
116 if let Some(relations) = relations {
117 for name in relations.keys() {
118 names.insert_with_control(name, control)?;
119 }
120 }
121 Ok(names)
122 })
123}
124
125pub fn enter_empty_transition_relation_scope() -> TransitionRelationScope {
126 TransitionRelationScope::empty()
127}
128
129pub struct TriggerStatementScope;
131
132impl TriggerStatementScope {
133 pub fn enter() -> Self {
134 TRANSITION_CAPTURE_CACHE.with(|cache| cache.borrow_mut().push(BTreeMap::new()));
135 row_triggers::enter();
136 Self
137 }
138}
139
140impl Drop for TriggerStatementScope {
141 fn drop(&mut self) {
142 row_triggers::leave();
143 TRANSITION_CAPTURE_CACHE.with(|cache| {
144 let removed = cache.borrow_mut().pop();
145 debug_assert!(
146 removed.is_some(),
147 "transition capture cache stack underflow"
148 );
149 });
150 }
151}
152
153pub mod events;
154pub mod queue;
155mod transitions;
156pub use transitions::{transition_capture_required, TransitionTables};
157
158mod row_triggers;
159mod rows;
160use rows::{
161 trigger_column_metadata, trigger_document, trigger_record, TriggerColumnMetadata,
162 TriggerVariableResolver,
163};
164
165fn operation_name(event: TriggerEvent) -> &'static str {
166 match event {
167 TriggerEvent::Insert => "INSERT",
168 TriggerEvent::Update => "UPDATE",
169 TriggerEvent::Delete => "DELETE",
170 TriggerEvent::Truncate => "TRUNCATE",
171 }
172}
173
174fn timing_name(timing: TriggerTiming) -> &'static str {
175 match timing {
176 TriggerTiming::Before => "BEFORE",
177 TriggerTiming::After => "AFTER",
178 TriggerTiming::InsteadOf => "INSTEAD OF",
179 }
180}
181
182fn trigger_condition_matches(
183 context: &TriggerContext<'_>,
184 condition: Option<&uqa_sql::ast::Expr>,
185 old: &Value,
186 new: &Value,
187 columns: &BTreeMap<String, TriggerColumnMetadata>,
188) -> Result<bool> {
189 let Some(condition) = condition else {
190 return Ok(true);
191 };
192 let condition = bind_expr(
193 condition,
194 &mut TriggerVariableResolver { old, new, columns },
195 )?;
196 Ok(uqa_sql::expr::truthy(
197 &context.expressions.evaluate(&condition)?,
198 ))
199}
200
201struct TriggerInvocation<'a> {
202 table: &'a str,
203 trigger: &'a uqa_sql::catalog::events::StoredTrigger,
204 timing: TriggerTiming,
205 event: TriggerEvent,
206 row: bool,
207 old: Value,
208 new: Value,
209}
210
211fn invoke_trigger(
212 context: &TriggerContext<'_>,
213 invocation: TriggerInvocation<'_>,
214 transition_tables: Option<&TransitionTables>,
215) -> Result<Value> {
216 let relation = RelationIdentity::from_legacy_name(invocation.table).map_err(|error| {
217 SQLError::Internal(format!(
218 "decode trigger relation `{}`: {error}",
219 invocation.table
220 ))
221 })?;
222 let function = context.routines.resolve_bound_trigger_function(
223 &invocation.trigger.definition.function,
224 invocation.trigger.function_object_id,
225 )?;
226 let _transition_scope = match transition_tables {
227 Some(tables) => tables.enter(&invocation.trigger.definition)?,
228 None if invocation
229 .trigger
230 .definition
231 .transition_relations
232 .is_empty() =>
233 {
234 TransitionRelationScope::empty()
235 }
236 None => {
237 return Err(SQLError::Internal(format!(
238 "trigger `{}` requested unavailable transition tables",
239 invocation.trigger.definition.name
240 )))
241 }
242 };
243 let _depth = TriggerDepthScope::enter();
244 context.routines.execute_trigger_routine(
245 &function,
246 &TriggerRoutineContext {
247 row_schema: uqa_sql::RowSchema::with_column_metadata(
248 None,
249 context
250 .catalog
251 .trigger_relation_definitions(invocation.table)?
252 .into_iter()
253 .map(|column| (column.name, Some(column.ty), column.collation_oid)),
254 ),
255 old: invocation.old,
256 new: invocation.new,
257 name: invocation.trigger.definition.name.clone(),
258 when: timing_name(invocation.timing).into(),
259 level: if invocation.row { "ROW" } else { "STATEMENT" }.into(),
260 operation: operation_name(invocation.event).into(),
261 relation_oid: crate::catalog::projection::event_relation_oid(
262 &context.projection,
263 invocation.table,
264 )?,
265 table_name: relation.name,
266 table_schema: relation.schema,
267 arguments: invocation.trigger.definition.arguments.clone(),
268 },
269 )
270}
271
272fn positional_trigger_record(
273 columns: &[(String, uqa_sql::ast::ColumnType)],
274 values: Option<&[Value]>,
275) -> Result<Value> {
276 if values.is_some_and(|values| values.len() != columns.len()) {
277 return Err(SQLError::Internal(
278 "INSTEAD OF trigger row does not match the view row type".into(),
279 ));
280 }
281 Ok(Value::Record(
282 columns
283 .iter()
284 .enumerate()
285 .map(|(position, (name, _))| {
286 (
287 name.clone(),
288 values
289 .and_then(|values| values.get(position))
290 .cloned()
291 .unwrap_or(Value::Null),
292 )
293 })
294 .collect::<Vec<_>>()
295 .into(),
296 ))
297}
298
299fn normalize_instead_of_trigger_record(
300 columns: &[(String, uqa_sql::ast::ColumnType)],
301 value: Value,
302) -> Result<Option<Vec<Value>>> {
303 let fields = match value {
304 Value::Null => return Ok(None),
305 Value::Record(fields) => fields.into_iter().collect::<BTreeMap<_, _>>(),
306 _ => {
307 return Err(SQLError::Routine {
308 sqlstate: "39P01".into(),
309 message: "trigger function returned non-composite value".into(),
310 })
311 }
312 };
313 if let Some(unknown) = fields
314 .keys()
315 .find(|name| !columns.iter().any(|(column, _)| column == *name))
316 {
317 return Err(SQLError::UnknownColumn(unknown.clone()));
318 }
319 Ok(Some(
321 columns
322 .iter()
323 .map(|(name, _)| fields.get(name).cloned().unwrap_or(Value::Null))
324 .collect(),
325 ))
326}
327
328pub fn fire_instead_of_row_triggers(
330 context: &TriggerContext<'_>,
331 view: &str,
332 event: TriggerEvent,
333 old_values: Option<&[Value]>,
334 new_values: Option<&[Value]>,
335 updated_columns: &[String],
336) -> Result<Option<Vec<Value>>> {
337 let columns = context.catalog.rule_relation_columns(view)?;
338 let old = positional_trigger_record(&columns, old_values)?;
339 let mut new = positional_trigger_record(&columns, new_values)?;
340 let triggers = context.catalog.triggers_for(
341 view,
342 TriggerTiming::InsteadOf,
343 event,
344 true,
345 updated_columns,
346 )?;
347 if triggers.is_empty()
348 && !context
349 .catalog
350 .has_trigger_definition(view, TriggerTiming::InsteadOf, event, true)?
351 {
352 return Err(SQLError::Routine {
353 sqlstate: "55000".into(),
354 message: format!(
355 "cannot {} view \"{}\": no active INSTEAD OF trigger",
356 operation_name(event).to_ascii_lowercase(),
357 RelationIdentity::from_legacy_name(view)
358 .map_or_else(|_| view.to_string(), |relation| relation.name)
359 ),
360 });
361 }
362 for trigger in triggers {
363 let returned = invoke_trigger(
364 context,
365 TriggerInvocation {
366 table: view,
367 trigger: &trigger,
368 timing: TriggerTiming::InsteadOf,
369 event,
370 row: true,
371 old: old.clone(),
372 new: new.clone(),
373 },
374 None,
375 )?;
376 let Some(values) = normalize_instead_of_trigger_record(&columns, returned)? else {
377 return Ok(None);
378 };
379 if event != TriggerEvent::Delete {
380 new = positional_trigger_record(&columns, Some(&values))?;
381 }
382 }
383 let final_record = if event == TriggerEvent::Delete {
384 old
385 } else {
386 new
387 };
388 normalize_instead_of_trigger_record(&columns, final_record)
389}
390
391pub fn fire_statement_triggers(
392 context: &TriggerContext<'_>,
393 table: &str,
394 timing: TriggerTiming,
395 event: TriggerEvent,
396 updated_columns: &[String],
397) -> Result<()> {
398 fire_statement_triggers_with_transition(context, table, timing, event, updated_columns, None)
399}
400
401fn fire_statement_triggers_with_transition(
402 context: &TriggerContext<'_>,
403 table: &str,
404 timing: TriggerTiming,
405 event: TriggerEvent,
406 updated_columns: &[String],
407 transition_tables: Option<&TransitionTables>,
408) -> Result<()> {
409 for trigger in context
410 .catalog
411 .triggers_for(table, timing, event, false, updated_columns)?
412 {
413 let _ = invoke_trigger(
414 context,
415 TriggerInvocation {
416 table,
417 trigger: &trigger,
418 timing,
419 event,
420 row: false,
421 old: Value::Null,
422 new: Value::Null,
423 },
424 transition_tables,
425 )?;
426 }
427 Ok(())
428}
429
430pub fn has_before_row_triggers(
432 context: &TriggerContext<'_>,
433 table: &str,
434 event: TriggerEvent,
435) -> Result<bool> {
436 Ok(!row_triggers::resolve(context, table, TriggerTiming::Before, event, None)?.is_empty())
437}
438
439pub fn fire_before_row_triggers(
440 context: &TriggerContext<'_>,
441 table: &str,
442 event: TriggerEvent,
443 doc_id: DocId,
444 old_document: Option<&Document>,
445 new_document: Option<&Document>,
446 updated_columns: &[String],
447) -> Result<Option<Document>> {
448 let triggers = row_triggers::resolve(
449 context,
450 table,
451 TriggerTiming::Before,
452 event,
453 Some(updated_columns),
454 )?;
455 let original = if event == TriggerEvent::Delete {
456 old_document
457 } else {
458 new_document
459 };
460 if !triggers
461 .iter()
462 .any(|trigger| row_triggers::fires(context, trigger))
463 {
464 return Ok(original.cloned());
465 }
466 let columns = trigger_column_metadata(context.catalog.trigger_relation_definitions(table)?);
467 let old = trigger_record(context, table, doc_id, old_document, false)?;
468 let mut new = trigger_record(context, table, doc_id, new_document, true)?;
469 let mut invoked = false;
470 for trigger in triggers.iter() {
471 if !row_triggers::fires(context, trigger)
473 || !trigger_condition_matches(
474 context,
475 trigger.definition.when.as_ref(),
476 &old,
477 &new,
478 &columns,
479 )?
480 {
481 continue;
482 }
483 invoked = true;
484 let returned = invoke_trigger(
485 context,
486 TriggerInvocation {
487 table,
488 trigger,
489 timing: TriggerTiming::Before,
490 event,
491 row: true,
492 old: old.clone(),
493 new: new.clone(),
494 },
495 None,
496 )?;
497 if matches!(returned, Value::Null) {
498 return Ok(None);
499 }
500 if event != TriggerEvent::Delete {
501 new = returned;
502 }
503 }
504 if event == TriggerEvent::Delete || !invoked {
505 return Ok(original.cloned());
506 }
507 trigger_document(context, table, new)
508}
509
510fn fire_after_row_trigger(
512 context: &TriggerContext<'_>,
513 event: &AfterRowTriggerEvent,
514 transition_table: Option<usize>,
515 queue: &queue::AfterTriggerQueue,
516) -> Result<()> {
517 let mut checks = event.foreign_keys.iter().peekable();
518 for trigger in &event.triggers {
519 while let Some(check) =
520 checks.next_if(|check| check.precedes_trigger(&trigger.definition.name))
521 {
522 context.foreign_keys.run_foreign_key_check(check, queue)?;
523 }
524 if trigger.definition.constraint
525 && context.deferrals.constraint_trigger_is_deferred(trigger)?
526 {
527 context
528 .deferrals
529 .defer_constraint_trigger_event(DeferredConstraintTriggerEvent {
530 constraint: trigger.constraint_identity()?,
531 firing_relation: RelationIdentity::from_legacy_name(&event.table).map_err(
532 |error| {
533 SQLError::Internal(format!(
534 "decode deferred trigger relation `{}`: {error}",
535 event.table
536 ))
537 },
538 )?,
539 table: event.table.clone(),
540 event: event.event,
541 old: event.old.clone(),
542 new: event.new.clone(),
543 trigger: trigger.clone(),
544 })?;
545 continue;
546 }
547 let transition_tables = match transition_table {
548 Some(table) if !trigger.definition.transition_relations.is_empty() => {
549 Some(queue.transitions(context, table)?)
550 }
551 _ => None,
552 };
553 let _ = invoke_trigger(
554 context,
555 TriggerInvocation {
556 table: &event.table,
557 trigger,
558 timing: TriggerTiming::After,
559 event: event.event,
560 row: true,
561 old: event.old.clone(),
562 new: event.new.clone(),
563 },
564 transition_tables.as_deref(),
565 )?;
566 }
567 for check in checks {
568 context.foreign_keys.run_foreign_key_check(check, queue)?;
569 }
570 Ok(())
571}
572
573#[derive(Clone)]
574pub struct DeferredConstraintTriggerEvent {
575 pub constraint: uqa_sql::catalog::constraints::ConstraintIdentity,
576 pub firing_relation: RelationIdentity,
577 pub table: String,
578 event: TriggerEvent,
579 old: Value,
580 new: Value,
581 pub trigger: uqa_sql::catalog::events::StoredTrigger,
582}
583
584pub fn fire_deferred_constraint_trigger_event(
585 context: &TriggerContext<'_>,
586 event: &DeferredConstraintTriggerEvent,
587) -> Result<()> {
588 let _ = invoke_trigger(
589 context,
590 TriggerInvocation {
591 table: &event.table,
592 trigger: &event.trigger,
593 timing: TriggerTiming::After,
594 event: event.event,
595 row: true,
596 old: event.old.clone(),
597 new: event.new.clone(),
598 },
599 None,
600 )?;
601 Ok(())
602}
603
604#[derive(serde::Serialize, serde::Deserialize)]
605pub struct AfterRowTriggerEvent {
606 table: String,
607 event: TriggerEvent,
608 #[serde(with = "events::values")]
609 old: Value,
610 #[serde(with = "events::values")]
611 new: Value,
612 captured: bool,
614 triggers: Vec<uqa_sql::catalog::events::StoredTrigger>,
615 foreign_keys: Vec<crate::mutation::referential::checks::ForeignKeyCheck>,
617}
618
619pub struct AfterRowTriggerInput<'a> {
620 pub table: &'a str,
621 pub event: TriggerEvent,
622 pub old_doc_id: DocId,
623 pub new_doc_id: DocId,
624 pub old_document: Option<&'a Document>,
625 pub new_document: Option<&'a Document>,
626 pub updated_columns: &'a [String],
627 pub foreign_key_checks: Vec<crate::mutation::referential::checks::ForeignKeyCheck>,
629}
630
631impl AfterRowTriggerEvent {
632 pub fn prepare(
633 context: &TriggerContext<'_>,
634 input: AfterRowTriggerInput<'_>,
635 ) -> Result<Option<Self>> {
636 let AfterRowTriggerInput {
637 table,
638 event,
639 old_doc_id,
640 new_doc_id,
641 old_document,
642 new_document,
643 updated_columns,
644 mut foreign_key_checks,
645 } = input;
646 crate::mutation::referential::checks::ForeignKeyCheck::sort(&mut foreign_key_checks);
647 let candidates = row_triggers::resolve(
648 context,
649 table,
650 TriggerTiming::After,
651 event,
652 Some(updated_columns),
653 )?;
654 let capture_transition =
655 transition_capture_required(context, table, event, updated_columns)?;
656 if !capture_transition
658 && !candidates
659 .iter()
660 .any(|trigger| row_triggers::fires(context, trigger))
661 {
662 return Ok(Self::foreign_key_checks(table, event, foreign_key_checks));
663 }
664 let columns = trigger_column_metadata(context.catalog.trigger_relation_definitions(table)?);
665 let old = trigger_record(context, table, old_doc_id, old_document, false)?;
666 let new = trigger_record(context, table, new_doc_id, new_document, false)?;
667 let mut matching = Vec::new();
668 for trigger in candidates.iter() {
669 if row_triggers::fires(context, trigger)
670 && trigger_condition_matches(
671 context,
672 trigger.definition.when.as_ref(),
673 &old,
674 &new,
675 &columns,
676 )?
677 {
678 let mut captured = trigger.clone();
679 captured.definition.when = None;
681 matching.push(captured);
682 }
683 }
684 if matching.is_empty() && !capture_transition {
685 return Ok(Self::foreign_key_checks(table, event, foreign_key_checks));
686 }
687 Ok(Some(Self {
688 table: table.to_string(),
689 event,
690 old,
691 new,
692 captured: true,
693 triggers: matching,
694 foreign_keys: foreign_key_checks,
695 }))
696 }
697
698 pub fn foreign_key_checks(
700 table: &str,
701 event: TriggerEvent,
702 mut foreign_key_checks: Vec<crate::mutation::referential::checks::ForeignKeyCheck>,
703 ) -> Option<Self> {
704 if foreign_key_checks.is_empty() {
705 return None;
706 }
707 crate::mutation::referential::checks::ForeignKeyCheck::sort(&mut foreign_key_checks);
708 Some(Self {
709 table: table.to_string(),
710 event,
711 old: Value::Null,
712 new: Value::Null,
713 captured: false,
714 triggers: Vec::new(),
715 foreign_keys: foreign_key_checks,
716 })
717 }
718
719 pub fn prepare_transition_capture(
720 context: &TriggerContext<'_>,
721 input: AfterRowTriggerInput<'_>,
722 ) -> Result<Option<Self>> {
723 let AfterRowTriggerInput {
724 table,
725 event,
726 old_doc_id,
727 new_doc_id,
728 old_document,
729 new_document,
730 updated_columns,
731 foreign_key_checks,
732 } = input;
733 if !transition_capture_required(context, table, event, updated_columns)? {
734 return Ok(Self::foreign_key_checks(table, event, foreign_key_checks));
735 }
736 let old = match old_document {
737 Some(document) => trigger_record(context, table, old_doc_id, Some(document), false)?,
738 None => Value::Null,
739 };
740 let new = match new_document {
741 Some(document) => trigger_record(context, table, new_doc_id, Some(document), false)?,
742 None => Value::Null,
743 };
744 let mut foreign_key_checks = foreign_key_checks;
745 crate::mutation::referential::checks::ForeignKeyCheck::sort(&mut foreign_key_checks);
746 Ok(Some(Self {
747 table: table.to_string(),
748 event,
749 old,
750 new,
751 captured: true,
752 triggers: Vec::new(),
753 foreign_keys: foreign_key_checks,
754 }))
755 }
756}