///|
#derive(ToJson, FromJson)
priv struct TriggerDefinition {
timing : String
event : String
columns : Array[String]
condition : Expr
body : Array[DataStatement]
}
///|
/// Connection-local execution frames, never serialized or shared with a clone.
priv struct TriggerRuntime {
mut clock : Int64?
mut row : Environment
active : Array[String]
mut recursive : Bool
mut prior_changes : Int32
mut data_depth : Int32
mut failed_statement : Bool
mut conflict_override : String?
}
///|
fn trigger_runtime() -> TriggerRuntime {
{
clock: None,
row: [],
active: [],
recursive: false,
prior_changes: 0,
data_depth: 0,
failed_statement: false,
conflict_override: None,
}
}
///|
fn connection_changes(store : Store) -> Int32 {
if store.triggers.failed_statement {
0
} else {
store.changes
}
}
///|
fn trigger_raise_action(args : Array[Expr]) -> String raise SqlError {
guard !args.is_empty() && args[0] is Column("", name) else {
fail("unsupported RAISE() action")
}
let name = identifier(name)
guard (name == "ignore" && args.length() == 1) ||
(name == "abort" && args.length() == 2) else {
fail("unsupported RAISE() action")
}
name
}
///|
fn trigger_environment(
table : Table,
event : String,
before : StoredRow?,
after : StoredRow?,
) -> Environment {
let mut env : Environment = []
if event != "insert" && before is Some(row) {
env = env + row_environment(table, row, "old")
}
if event != "delete" && after is Some(row) {
env = env + row_environment(table, row, "new")
}
env
}
///|
fn trigger_applies(
trigger : TriggerDefinition,
event : String,
columns : Array[String],
) -> Bool {
trigger.event == event &&
(
trigger.columns.is_empty() ||
trigger.columns.any(c => columns.any(n => identifier(c) == identifier(n)))
)
}
///|
fn validate_trigger_metadata(
table : Table,
object : SchemaObject,
) -> Unit raise SqlError {
guard FEATURE_TRIGGERS else { fail("feature disabled: triggers") }
validate_optional_features(object)
guard object.trigger is Some(t) &&
["before", "after"].contains(t.timing) &&
["insert", "update", "delete"].contains(t.event) &&
!t.body.is_empty() &&
t.body.length() <= 1000 &&
(t.event == "update" || t.columns.is_empty()) &&
(t.timing != "before" || t.body.all(data_readonly)) &&
identifier(object.table) == identifier(table.name) else {
fail("invalid or unsupported trigger definition")
}
}
///|
fn prepare_trigger(
store : Store,
table : Table,
object : SchemaObject,
) -> Unit raise SqlError {
guard FEATURE_TRIGGERS else { fail("feature disabled: triggers") }
validate_trigger_metadata(table, object)
guard object.trigger is Some(t) else { fail("missing trigger definition") }
let row = { id: 0L, values: Array::make(table.columns.length(), Null), }
let old = store.triggers.row
store.triggers.row = trigger_environment(table, t.event, Some(row), Some(row))
store.triggers.active.push(identifier(object.name))
defer {
store.triggers.row = old
ignore(store.triggers.active.pop())
}
prepare_expression(t.condition, evaluation(store, [], []), false, false)
for statement in t.body {
ignore(prepared_names(store, statement, 0))
}
}
///|
fn prepare_trigger_event(
store : Store,
table : Table,
event : String,
columns : Array[String],
) -> Unit raise SqlError {
if !FEATURE_TRIGGERS {
return
}
for object in store.objects {
if object.kind == "trigger" &&
matches_identifier(object.table, identifier(table.name)) &&
object.trigger is Some(t) &&
trigger_applies(t, event, columns) {
prepare_trigger(store, table, object)
}
}
}
///|
fn fire_trigger(
store : Store,
table : Table,
object : SchemaObject,
before : StoredRow?,
after : StoredRow?,
) -> Bool raise SqlError {
guard object.trigger is Some(t) else { fail("missing trigger definition") }
guard store.triggers.active.length() < 32 else {
fail("too many levels of trigger recursion")
}
let env = store.triggers.row
let changes = store.changes
let rowid = store.last_rowid
store.triggers.row = trigger_environment(table, t.event, before, after)
store.triggers.active.push(identifier(object.name))
store.changes = store.triggers.prior_changes
defer {
store.triggers.row = env
ignore(store.triggers.active.pop())
store.changes = changes
store.last_rowid = rowid
}
try {
if truth(evaluate(t.condition, evaluation(store, [], []))) != 1 {
return true
}
for statement in t.body {
ignore(execute_data_statement(store, statement, []))
}
true
} catch {
TriggerIgnore => false
TriggerAbort(message) => raise TriggerAbort(message)
SqlError(message) => fail(message)
}
}
///|
#derive(ToJson)
priv struct LegacyInsertion {
table : String
columns : Array[String]
values : Array[Array[Expr]]
conflict : String
target : Array[String]
updates : Array[(String, Expr)]
predicate : Expr
returning : Array[Projection]
}
///|
impl @json.ToJson for Insertion with fn to_json(self) {
let json = @json.to_json(
(
{
table: self.table,
columns: self.columns,
values: self.values,
conflict: self.conflict,
target: self.target,
updates: self.updates,
predicate: self.predicate,
returning: self.returning,
} : LegacyInsertion),
)
if json is Object(fields) {
if self.conflict_override is Some(value) {
fields["conflict_override"] = @json.to_json(value)
}
if self.selection is Some(value) {
fields["selection"] = @json.to_json(value)
}
if self.target_predicate is Some(value) {
fields["target_predicate"] = @json.to_json(value)
}
}
json
}
///|
fn run_triggers(
store : Store,
table : Table,
timing : String,
event : String,
columns : Array[String],
before : StoredRow?,
after : StoredRow?,
) -> Bool raise SqlError {
if !FEATURE_TRIGGERS {
return true
}
let triggers = store.objects.filter(o => {
o.kind == "trigger" && matches_identifier(o.table, identifier(table.name))
})
for i in 0..