///|
priv struct ForeignReference {
parent : String
targets : Array[String]
delete_action : String
update_action : String
initially_deferred : Bool
}
///|
fn Parser::foreign_reference(p : Parser) -> ForeignReference raise SqlError {
let parent = p.name()
let targets = if p.peek() == "(" { p.names() } else { [] }
let mut delete_action = "no action"
let mut update_action = "no action"
let mut initially_deferred = false
while true {
if p.take("on") {
let update = p.take("update")
if !update {
p.expect("delete")
}
let action = if p.take("no") {
p.expect("action")
"no action"
} else if p.take("set") {
if p.take("null") {
"set null"
} else {
p.expect("default")
"set default"
}
} else if p.take("cascade") {
"cascade"
} else {
p.expect("restrict")
"restrict"
}
if update {
update_action = action
} else {
delete_action = action
}
} else if p.take("deferrable") {
if p.take("initially") {
initially_deferred = p.take("deferred")
if !initially_deferred {
p.expect("immediate")
}
}
} else if p.peek() == "not" &&
p.position + 1 < p.tokens.length() &&
p.tokens[p.position + 1].word == "deferrable" {
p.position += 2
if p.take("initially") {
if !p.take("immediate") {
p.expect("deferred")
}
}
} else {
break
}
}
{ parent, targets, delete_action, update_action, initially_deferred, }
}
///|
fn make_foreign_key(
columns : Array[Int32],
reference : ForeignReference,
) -> ForeignKey raise SqlError {
guard !columns.is_empty() &&
(
reference.targets.is_empty() ||
columns.length() == reference.targets.length()
) else {
fail("foreign key column count mismatch")
}
{
column: columns[0],
parent: reference.parent,
target: if reference.targets.is_empty() {
""
} else {
reference.targets[0]
},
cascade: reference.delete_action == "cascade",
columns: if columns.length() > 1 {
Some(columns)
} else {
None
},
targets: if reference.targets.length() > 1 {
Some(reference.targets)
} else {
None
},
delete_action: if reference.delete_action == "no action" ||
reference.delete_action == "cascade" {
None
} else {
Some(reference.delete_action)
},
update_action: if reference.update_action == "no action" {
None
} else {
Some(reference.update_action)
},
initially_deferred: if reference.initially_deferred {
Some(true)
} else {
None
},
}
}
///|
#derive(ToJson)
priv struct LegacyForeignKey {
column : Int32
parent : String
target : String
cascade : Bool
}
///|
impl @json.ToJson for ForeignKey with fn to_json(self) {
let old : LegacyForeignKey = {
column: self.column,
parent: self.parent,
target: self.target,
cascade: self.cascade,
}
let json = @json.to_json(old)
if json is Object(fields) {
if self.columns is Some(v) {
fields["columns"] = @json.to_json(v)
}
if self.targets is Some(v) {
fields["targets"] = @json.to_json(v)
}
if self.delete_action is Some(v) {
fields["delete_action"] = @json.to_json(v)
}
if self.update_action is Some(v) {
fields["update_action"] = @json.to_json(v)
}
if self.initially_deferred is Some(v) {
fields["initially_deferred"] = @json.to_json(v)
}
}
json
}
///|
fn foreign_columns(fk : ForeignKey) -> Array[Int32] {
fk.columns.unwrap_or([fk.column])
}
///|
fn foreign_targets(
parent : Table,
fk : ForeignKey,
) -> Array[Int32] raise SqlError {
let names = fk.targets.unwrap_or(
if fk.target == "" {
[]
} else {
[fk.target]
},
)
let targets = if names.is_empty() {
primary_key(parent)
} else {
names.map(n => column_index(parent, n))
}
guard targets.length() == foreign_columns(fk).length() else {
fail("foreign key mismatch")
}
targets
}
///|
fn foreign_action(fk : ForeignKey, update : Bool) -> String {
if update {
fk.update_action.unwrap_or("no action")
} else {
fk.delete_action.unwrap_or(if fk.cascade { "cascade" } else { "no action" })
}
}
///|
fn foreign_matches(
store : Store,
parent : Table,
row : StoredRow,
child : StoredRow,
fk : ForeignKey,
) -> Bool raise SqlError {
let targets = foreign_targets(parent, fk)
foreign_columns(fk)
.mapi((i, c) => {
!(child.values[c] is Null) &&
compare_stored(
store,
apply_affinity(
child.values[c],
column_affinity(parent, parent.columns[targets[i]]),
),
row.values[targets[i]],
parent.columns[targets[i]].collation,
) ==
0
})
.all(v => v)
}
///|
fn foreign_unchanged(
store : Store,
parent : Table,
old : StoredRow,
next : StoredRow?,
fk : ForeignKey,
) -> Bool raise SqlError {
if next is Some(next) {
return foreign_targets(parent, fk).all(i => {
compare_stored(
store,
old.values[i],
next.values[i],
parent.columns[i].collation,
) ==
0
})
}
false
}
///|
fn foreign_restrict(
store : Store,
table : Table,
old : StoredRow,
next : StoredRow?,
) -> Unit raise SqlError {
if !FEATURE_FOREIGN_KEYS {
return
}
if !store.foreign_keys {
return
}
for child in store.tables {
for fk in child.foreign_keys {
if identifier(fk.parent) == identifier(table.name) &&
foreign_action(fk, next is Some(_)) == "restrict" &&
!foreign_unchanged(store, table, old, next, fk) &&
child.rows.any(r => foreign_matches(store, table, old, r, fk)) {
fail("FOREIGN KEY constraint failed")
}
}
}
}
///|
fn foreign_actions(
store : Store,
table : Table,
old : StoredRow,
next : StoredRow?,
depth : Int32,
) -> Unit raise SqlError {
if !FEATURE_FOREIGN_KEYS {
return
}
if !store.foreign_keys {
return
}
guard depth <= 32 else { fail("foreign key cascade depth limit") }
let changes = store.changes
defer {
store.changes = changes
}
for child in store.tables {
for fk in child.foreign_keys {
if identifier(fk.parent) != identifier(table.name) ||
foreign_unchanged(store, table, old, next, fk) {
continue
}
let action = foreign_action(fk, next is Some(_))
if action == "no action" || action == "restrict" {
continue
}
for row in child.rows.copy() {
if !foreign_matches(store, table, old, row, fk) {
continue
}
if action == "cascade" && next is None {
ignore(delete_row(store, child, row, depth + 1, true))
continue
}
let targets = foreign_targets(table, fk)
let setters = foreign_columns(fk).mapi((i, c) => {
(
child.columns[c].name,
if action == "set null" {
Literal(Null)
} else if action == "set default" {
child.columns[c].default_value
} else {
Literal(next.unwrap().values[targets[i]])
},
)
})
let updated = updated_row(store, child, row, setters, [], [])
let columns = setters.map(s => s.0)
prepare_trigger_event(store, child, "update", columns)
if !run_triggers(
store,
child,
"before",
"update",
columns,
Some(row),
Some(updated),
) {
continue
}
ignore(check_updated_row(store, child, row, updated, []))
foreign_restrict(store, child, row, Some(updated))
replace_table_row(store, child, row, updated)
foreign_actions(store, child, row, Some(updated), depth + 1)
ignore(
run_triggers(
store,
child,
"after",
"update",
columns,
Some(row),
Some(updated),
),
)
}
}
}
}
///|
fn prepare_foreign_table(store : Store, table : Table) -> Unit raise SqlError {
if !FEATURE_FOREIGN_KEYS || !store.foreign_keys {
return
}
for fk in table.foreign_keys {
let parent = get_table(store, fk.parent)
let targets = foreign_targets(parent, fk)
guard unique_keys(store, parent).any(k => {
k.length() == targets.length() && targets.all(i => k.contains(i))
}) else {
fail("foreign key mismatch: " + table.name)
}
}
}