///|
struct AotDatabase {
connection : Connection?
program : Program?
error : String?
}
///|
fn AotDatabase::ready(
db : AotDatabase,
) -> (Connection, Program) raise SqliteError {
guard db.connection is Some(connection) && db.program is Some(program) else {
raise sqlite_misuse(db.error.unwrap_or("invalid AOT connection"))
}
connection.healthy()
(connection, program)
}
///|
fn public_error(error : Error) -> String {
match error {
SqliteError(msg=message, ..) => message
SqlError(message) => message
TriggerIgnore => "RAISE(IGNORE) escaped its trigger frame"
TriggerAbort(message) => message
_ => error.to_string()
}
}
///|
pub fn aot_open(artifact : String, image : String) -> AotDatabase {
try {
let program = Program::load(artifact)
let connection = Connection::from_program(program)
let result : AotDatabase = {
connection: Some(connection),
program: Some(program),
error: None,
}
if image != "" {
aot_restore_checked(result, image)
}
result
} catch {
error =>
{ connection: None, program: None, error: Some(public_error(error)), }
}
}
///|
pub fn aot_info(db : AotDatabase) -> String {
try {
let (connection, program) = db.ready()
(
{
"programId": program.id,
"schemaVersion": connection.database.store.cookie,
"serial": connection.database.serial,
"queryCount": program.queries.length(),
"autocommit": connection.database.store.transactions.frames.is_empty(),
} : Json).stringify()
} catch {
error => public_error_json(error).stringify()
}
}
///|
fn public_error_json(error : Error) -> Json {
let json : Json = { "error": public_error(error) }
if (
error is TriggerAbort(_) ||
error
is SqliteError(code=Constraint, extended=Some(ConstraintTrigger), ..)
) &&
json is Object(fields) {
fields["code"] = "SQLITE_CONSTRAINT_TRIGGER"
}
if public_error(error).contains("datatype constraint") &&
json is Object(fields) {
fields["code"] = "SQLITE_CONSTRAINT_DATATYPE"
}
json
}
///|
pub fn aot_execute(
db : AotDatabase,
name : String,
bindings : String,
) -> String {
try {
let (connection, program) = db.ready()
let query = program.query(name)
let values : Array[Json] = @json.from_json(@json.parse(bindings))
guard values.length() == query.plan.parameters else {
raise sqlite_misuse("SQL binding count mismatch")
}
let statement = connection.prepare_compiled(query)
defer (statement.finalize() catch { _ => () })
// JSON owns these freshly decoded values; unlike the public typed binding
// API, there is no caller-owned BLOB to copy or binding index to validate.
for i, value in values {
statement.parameters[i] = json_value(value)
}
let rows : Array[Json] = []
while statement.step() {
let row : Array[Json] = []
// Serialize each visible binding once. Reading through column() would
// recheck state, filter the entire row and copy BLOBs for every cell.
for binding in statement.rows[statement.cursor] {
if !binding.hidden {
row.push(value_json(binding.value))
}
}
rows.push(Json::array(row))
}
(
{
"names": query.plan.names,
"rows": rows,
"readonly": data_readonly(query.plan.statement),
"changes": connection_changes(connection.database.store),
} : Json).stringify()
} catch {
error => public_error_json(error).stringify()
}
}
///|
pub fn aot_dump(db : AotDatabase) -> String {
try {
let (connection, program) = db.ready()
(
{
"format": "moon-aot-image@1",
"programId": program.id,
"serial": connection.database.serial,
"state": @json.to_json(connection.database.store),
} : Json).stringify()
} catch {
error => ({ "error": public_error(error) } : Json).stringify()
}
}
///|
fn aot_restore_checked(db : AotDatabase, image : String) -> Unit raise {
let (connection, program) = db.ready()
guard image.length() <= 67108864 else { fail("AOT image resource limit") }
guard @json.parse(image)
is {
"format": "moon-aot-image@1",
"programId": String(id),
"serial": Number(serial, ..),
"state": state,
..
} &&
id == program.id &&
serial >= 0.0 &&
serial <= 2147483647.0 &&
serial.to_int().to_double() == serial else {
fail("invalid AOT image/program identity")
}
let candidate : Store = @json.from_json(state)
guard schema_identity(candidate) == schema_identity(program.schema) else {
fail("AOT image schema mismatch")
}
validate_store_rows(candidate)
connection.database.store = candidate
connection.database.serial = serial.to_int()
}
///|
pub fn aot_restore(db : AotDatabase, image : String) -> String {
try {
aot_restore_checked(db, image)
"{}"
} catch {
error => ({ "error": public_error(error) } : Json).stringify()
}
}
///|
pub fn aot_query_info(db : AotDatabase, name : String) -> String {
try {
let (_, program) = db.ready()
let query = program.query(name).plan
(
{
"parameters": query.parameters,
"names": query.names,
"readonly": data_readonly(query.statement),
} : Json).stringify()
} catch {
error => ({ "error": public_error(error) } : Json).stringify()
}
}
///|
pub fn aot_clone(db : AotDatabase) -> AotDatabase {
try {
let (connection, program) = db.ready()
{
connection: Some({
database: database_clone(connection.database),
program: Some(program),
closed: false,
statements: 0,
}),
program: Some(program),
error: None,
}
} catch {
error =>
{ connection: None, program: None, error: Some(public_error(error)), }
}
}
///|
pub fn aot_delta(db : AotDatabase, force_snapshot : Bool) -> String {
try {
let (connection, program) = db.ready()
(
{
"format": "aot-flush@1",
"programId": program.id,
"data": @json.parse(database_delta(connection.database, force_snapshot)),
} : Json).stringify()
} catch {
error => ({ "error": public_error(error) } : Json).stringify()
}
}
///|
pub fn aot_ack_delta(db : AotDatabase, serial : Int32) -> String {
try {
let (connection, _) = db.ready()
database_ack_delta(connection.database, serial)
} catch {
error => ({ "error": public_error(error) } : Json).stringify()
}
}
///|
pub fn aot_apply_delta(db : AotDatabase, text : String) -> String {
try {
let (connection, program) = db.ready()
guard @json.parse(text)
is { "format": "aot-flush@1", "programId": String(id), "data": data, .. } &&
id == program.id else {
fail("flush program mismatch")
}
let (store, serial, full) = decode_flush(
connection.database,
data.stringify(),
)
guard schema_identity(store) == schema_identity(program.schema) else {
fail("flush schema mismatch")
}
if full {
validate_store_rows(store)
}
publish_flush(connection.database, store, serial)
"{}"
} catch {
error => ({ "error": public_error(error) } : Json).stringify()
}
}
///|
pub fn aot_set_clock(db : AotDatabase, milliseconds : String) -> String {
try {
let (connection, _) = db.ready()
database_set_clock(connection.database, milliseconds)
} catch {
e => public_error_json(e).stringify()
}
}
///|
pub fn aot_copy_connection_state(
target : AotDatabase,
source : AotDatabase,
) -> String {
try {
let (to, to_program) = target.ready()
let (from, from_program) = source.ready()
guard to_program.id == from_program.id else {
fail("connection program mismatch")
}
database_copy_connection_state(to.database, from.database)
"{}"
} catch {
e => ({ "error": public_error(e) } : Json).stringify()
}
}