Skip to main content

uqa_execution/mutation/
triggers.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! `BEFORE`/`AFTER`, row-level, and statement-level trigger execution.
8
9use 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    /// How many trigger functions this thread is inside.
35    static TRIGGER_DEPTH: std::cell::Cell<i64> = const { std::cell::Cell::new(0) };
36}
37
38/// How many trigger functions the running code is inside, as `pg_trigger_depth()` reports it: 0 outside any trigger.
39pub fn trigger_depth() -> i64 {
40    TRIGGER_DEPTH.with(std::cell::Cell::get)
41}
42
43/// One trigger function running until the guard drops.
44struct 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
89/// Borrow the current trigger's immutable materializations while the caller captures its own bindings.
90pub 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
109/// Capture owned transition names while the TLS map is borrowed; recursive SQL runs only after this snapshot returns.
110pub 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
129/// A statement that writes rows. What it resolves about the triggers of its tables, which row triggers they have and whether their transitions are captured, holds until it ends.
130pub 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    // The routine result has already passed descriptor validation; these values are admitted, not new input.
320    Ok(Some(
321        columns
322            .iter()
323            .map(|(name, _)| fields.get(name).cloned().unwrap_or(Value::Null))
324            .collect(),
325    ))
326}
327
328/// Run the `INSTEAD OF` row triggers of `view` for one row in name order, as `ExecIRInsertTriggers`, `ExecIRUpdateTriggers` and `ExecIRDeleteTriggers` do, and return the row the command then counts, checks and returns: the last trigger's result for INSERT and UPDATE and the original OLD row for DELETE, or `None` when a trigger returns NULL. When `session_replication_role` suppresses every trigger, the row is counted as it stands, although nothing performs the command.
329pub 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
430/// Whether `table` has BEFORE ROW triggers for `event`, whatever replication role fires them, which make `PostgreSQL` fetch a row through `GetTupleForTrigger` before it updates or deletes it.
431pub 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        // An earlier trigger of this row may have changed the role.
472        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
510/// Fire the AFTER ROW triggers of one queued row, and run its foreign key checks and referential actions, which are internal triggers that fire among the user triggers in the order of their names. A referential action queues the events of the rows it writes in `queue`. `transition_table` is the state whose transition tables collected the row, which the first trigger that reads them closes, after the internal triggers that precede it have run.
511fn 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    /// Whether `old` and `new` hold the row's images, which a row with no user trigger to fire and no transition to capture leaves out.
613    captured: bool,
614    triggers: Vec<uqa_sql::catalog::events::StoredTrigger>,
615    /// The foreign key checks and referential actions the row queued, in the order of their internal triggers' names.
616    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    /// The foreign key checks and referential actions the row's change queues (`referential::checks`).
628    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        // The role is read when the row's events are queued, as `PostgreSQL` checks each trigger in `AfterTriggerSaveEvent`.
657        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                // WHEN has already selected this event; firing must not retain or evaluate it again.
680                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    /// An event that only checks foreign keys and takes referential actions, for a row with no user trigger to fire and no transition to capture; `None` when the row queued neither.
699    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}