///|
fn defined_state_write(db : DefinedDatabase, w : BinaryWriter) -> Unit raise {
let (connection, _) = db.core.ready()
let store = connection.database.store
guard database_autocommit(connection.database) && !store.deferred else {
fail("cannot persist an active defined transaction")
}
Binary::write(db.schema_id, w)
Binary::write(connection.database.serial, w)
Binary::write(store.changes, w)
Binary::write(store.last_rowid, w)
Binary::write(store.foreign_keys, w)
w.uint(store.tables.length().reinterpret_as_uint())
for table in store.tables {
Binary::write(table.sequence, w)
Binary::write(table.sequence_present, w)
Binary::write(table.rows.copy(), w)
}
}
///|
pub fn defined_snapshot(db : DefinedDatabase) -> BinaryResult {
try {
let (connection, _) = db.core.ready()
let w = binary_writer()
defined_state_write(db, w)
{
data: binary_finish(w, 4),
full: true,
serial: connection.database.serial,
error: "",
}
} catch {
e => { data: b"", full: true, serial: 0, error: public_error(e), }
}
}
///|
fn defined_restore_checked(db : DefinedDatabase, bytes : Bytes) -> Unit raise {
let (connection, program) = db.core.ready()
guard database_autocommit(connection.database) else {
fail("cannot restore an active transaction")
}
let r = binary_reader(bytes, 4, 67108864)
let schema_id : String = Binary::read(r)
guard schema_id == db.schema_id else {
fail("defined snapshot schema mismatch")
}
let serial : Int32 = Binary::read(r)
let changes : Int32 = Binary::read(r)
let last_rowid : Int64 = Binary::read(r)
let foreign_keys : Bool = Binary::read(r)
let count = r.length()
let store = copy_store(program.schema)
guard serial >= 0 &&
changes >= 0 &&
count == store.tables.length() &&
foreign_keys == store.foreign_keys else {
fail("invalid defined snapshot metadata")
}
for table in store.tables {
table.sequence = Binary::read(r)
table.sequence_present = Binary::read(r)
let rows : Array[StoredRow] = Binary::read(r)
table.rows = row_pages(rows)
}
r.finish()
store.changes = changes
store.last_rowid = last_rowid
validate_store_rows(store)
publish_flush(connection.database, store, serial)
}
///|
pub fn defined_restore(db : DefinedDatabase, bytes : Bytes) -> String {
try {
defined_restore_checked(db, bytes)
"{}"
} catch {
e => ({ "error": public_error(e) } : Json).stringify()
}
}
///|
pub fn defined_delta(
db : DefinedDatabase,
force_snapshot : Bool,
) -> BinaryResult {
try {
let (connection, _) = db.core.ready()
let database = connection.database
let store = database.store
if force_snapshot || store.dirty.full || database.serial == store.dirty.base {
return defined_snapshot(db)
}
guard database_autocommit(database) && !store.deferred else {
fail("cannot persist an active defined transaction")
}
let w = binary_writer()
Binary::write(db.schema_id, w)
Binary::write(store.dirty.base, w)
Binary::write(database.serial, w)
Binary::write(store.changes, w)
Binary::write(store.last_rowid, w)
Binary::write(store.foreign_keys, w)
Binary::write(store.tables.map(t => (t.sequence, t.sequence_present)), w)
Binary::write(store.dirty.edits, w)
{
data: binary_finish(w, 5),
full: false,
serial: database.serial,
error: "",
}
} catch {
e => { data: b"", full: false, serial: 0, error: public_error(e), }
}
}
///|
pub fn defined_apply_delta(db : DefinedDatabase, bytes : Bytes) -> String {
try {
let (connection, _) = db.core.ready()
let database = connection.database
guard database_autocommit(database) else {
fail("cannot replay into an active transaction")
}
let r = binary_reader(bytes, 5, 67108864)
let schema_id : String = Binary::read(r)
let base : Int32 = Binary::read(r)
let serial : Int32 = Binary::read(r)
let changes : Int32 = Binary::read(r)
let last_rowid : Int64 = Binary::read(r)
let foreign_keys : Bool = Binary::read(r)
let sequences : Array[(Int64, Bool?)] = Binary::read(r)
let edits : Array[RowEdit] = Binary::read(r)
r.finish()
guard schema_id == db.schema_id &&
base == database.serial &&
serial > base &&
changes >= 0 &&
sequences.length() == database.store.tables.length() &&
foreign_keys == database.store.foreign_keys else {
fail("defined delta schema/serial mismatch")
}
let store = copy_store(database.store)
store.dirty = dirty_state()
apply_materialized_edits(store, edits)
for i, (sequence, present) in sequences {
store.tables[i].sequence = sequence
store.tables[i].sequence_present = present
}
store.changes = changes
store.last_rowid = last_rowid
validate_foreign_keys(store)
publish_flush(database, store, serial)
"{}"
} catch {
e => ({ "error": public_error(e) } : Json).stringify()
}
}
///|
// Optional entry point. Only this path loads a SQLite layout/template.
pub fn defined_export_sqlite(
schema : Bytes,
statements : Bytes,
layout : Bytes,
image : Bytes,
) -> SqliteResult {
try {
let db = defined_open(schema, statements, image)
let (connection, _) = db.core.ready()
let r = binary_reader(layout, 3, 1048576)
let schema_id : String = Binary::read(r)
guard schema_id == db.schema_id else {
fail("SQLite layout schema mismatch")
}
let format : String = Binary::read(r)
let page_size : Int32 = Binary::read(r)
let template : Bytes = Binary::read(r)
let trees : Array[StorageTree] = Binary::read(r)
r.finish()
let plan : StoragePlan = {
format,
page_size,
image: @base64.encode(template),
trees,
}
{
data: sqlite_export(
connection.database.store,
connection.database.serial,
plan,
),
info: "{}",
}
} catch {
e => { data: b"", info: ({ "error": public_error(e) } : Json).stringify(), }
}
}