///|
#derive(FromJson)
priv struct QueryInput {
name : String
sql : String
}
///|
#derive(FromJson)
priv struct ProgramInput {
schema : Array[String]
queries : Array[QueryInput]
storage : StoragePlan?
}
///|
pub fn compile_program(request : String) -> String {
try {
guard request.length() <= 1048576 else {
fail("compiler input resource limit")
}
let input : ProgramInput = @json.from_json(@json.parse(request))
let db = database_open()
for sql in input.schema {
let parser = lex(sql)
let statement = parse_statement(parser)
guard parser.parameter == 0 &&
(statement is CreateTable(_, _) || statement is CreateObject(_, _)) else {
fail("schema catalog accepts CREATE TABLE/INDEX/VIEW/TRIGGER only")
}
ignore(execute_statement(db.store, statement, []))
}
for object in db.store.objects {
if object.kind == "trigger" {
prepare_trigger(db.store, get_table(db.store, object.table), object)
}
}
let queries : Array[CompiledQuery] = []
for query in input.queries {
let parser = lex(query.sql)
let parsed = parse_statement(parser)
let statement = match parsed {
Transaction(op, name) => PreparedTransaction(op, name)
Select(select) => PreparedSelect(select)
Pragma(name, table, None) => PreparedPragma(name, table)
Insert(insert) => PreparedInsert(insert)
Update(name, setters, predicate, returning) =>
PreparedUpdate(name, setters, predicate, returning)
Delete(name, predicate, returning) =>
PreparedDelete(name, predicate, returning)
_ => fail("runtime query catalog cannot contain DDL or writable PRAGMA")
}
queries.push({
name: query.name,
parameters: parser.parameter,
names: prepared_names(db.store, statement, parser.parameter),
statement,
})
}
// Declaration spelling is observable only through table_info/xinfo. Leave
// other application artifacts byte-compatible and keep the AOT parser absent.
if !queries.any(q => {
match q.statement {
PreparedPragma("table_info", _) | PreparedPragma("table_xinfo", _) =>
true
_ => false
}
}) {
for table in db.store.tables {
for col in table.columns {
col.default_source = None
}
}
}
let program : CompiledProgram = {
format: "moon-aot@1",
schema: db.store,
queries,
storage: input.storage,
}
let result = @json.to_json(program).stringify()
ignore(Program::load(result))
result
} catch {
error =>
(
{
"error": match error {
SqlError(message) => message
SqliteError(msg=message, ..) => message
_ => error.to_string()
},
} : Json).stringify()
}
}