///|
#derive(ToJson, FromJson)
priv struct CompiledQuery {
name : String
parameters : Int32
names : Array[String]
statement : DataStatement
}
///|
#derive(ToJson, FromJson)
priv struct CompiledProgram {
format : String
schema : Store
queries : Array[CompiledQuery]
storage : StoragePlan?
}
///|
struct Program {
schema : Store
queries : Map[String, CompiledQuery]
selections : Map[String, PreparedSelection]
id : String
storage : StoragePlan?
}
///|
struct Query {
program_id : String
plan : CompiledQuery
selection : PreparedSelection?
}
///|
/// Derived from the validated fixed schema, never serialized into moon-aot@1.
/// No Store, Table, row, parameter, clock or connection state is retained.
priv struct PreparedSelection {
output : Environment
simple : PreparedProjection?
}
///|
priv struct PreparedProjection {
layout : Environment
columns : Array[RowProjection]
}
///|
fn prepare_selection(
store : Store,
select : Selection,
parameters : Int32,
) -> PreparedSelection raise SqlError {
let output = selection_template(
select,
evaluation(store, Array::make(parameters, Null), []),
)
let mut simple : PreparedProjection? = None
if select.sources.length() == 1 {
let source = select.sources[0]
let key = identifier(source.name)
for table in store.tables {
if matches_identifier(table.name, key) &&
simple_projection(select, table, source.qualifier) is Some(columns) &&
columns.length() == output.length() {
simple = Some({
layout: row_environment(
table,
{ id: 0L, values: Array::make(table.columns.length(), Null), },
source.qualifier,
),
columns,
})
break
}
}
}
{ output, simple, }
}
///|
fn data_readonly(statement : DataStatement) -> Bool {
match statement {
PreparedSelect(_) | PreparedPragma(_, _) => true
_ => false
}
}
///|
fn prepared_names(
store : Store,
statement : DataStatement,
count : Int32,
) -> Array[String] raise SqlError {
let params = Array::make(count, Value::Null)
match statement {
PreparedTransaction(_, _) => []
PreparedSelect(select) =>
selection_template(select, evaluation(store, params, [])).map(b => b.name)
PreparedPragma(name, table) => {
ignore(execute_pragma(store, name, table, None, params))
match name {
"table_info" => ["cid", "name", "type", "notnull", "dflt_value", "pk"]
"table_xinfo" =>
["cid", "name", "type", "notnull", "dflt_value", "pk", "hidden"]
"foreign_key_list" =>
[
"id", "seq", "table", "from", "to", "on_update", "on_delete", "match",
]
"foreign_key_check" => ["table", "rowid", "parent", "fkid"]
_ => [name]
}
}
PreparedInsert(insertion) => {
let table = get_table(store, insertion.table)
prepare_foreign_table(store, table)
let columns = if insertion.columns.is_empty() {
table.columns.map(c => c.name)
} else {
insertion.columns
}
for name in columns {
ignore(insertion_column(table, name))
}
if insertion.selection is Some(select) {
guard selection_template(select, evaluation(store, params, [])).length() ==
columns.length() else {
fail("INSERT SELECT column count mismatch")
}
}
for row in insertion.values {
guard row.length() == columns.length() else {
fail("INSERT value count mismatch")
}
for value in row {
prepare_expression(value, evaluation(store, params, []), false, false)
}
}
let empty = { id: 0L, values: Array::make(table.columns.length(), Null), }
let row = row_environment(table, empty, table.name)
let excluded = row_environment(table, empty, "excluded")
for (name, expression) in insertion.updates {
ignore(column_index(table, name))
prepare_expression(
expression,
evaluation(store, params, row + excluded),
false,
false,
)
}
prepare_expression(
insertion.predicate,
evaluation(store, params, row + excluded),
false,
false,
)
prepare_returning(insertion.returning, evaluation(store, params, row))
project_template(insertion.returning, evaluation(store, params, row)).map(b => {
b.name
},
)
}
PreparedUpdate(name, setters, predicate, returning) => {
let table = get_table(store, name)
prepare_foreign_table(store, table)
let row = row_environment(
table,
{ id: 0L, values: Array::make(table.columns.length(), Null), },
name,
)
let context = evaluation(store, params, row)
prepare_expression(predicate, context, false, false)
for (column, expression) in setters {
ignore(column_index(table, column))
prepare_expression(expression, context, false, false)
}
prepare_returning(returning, context)
project_template(returning, context).map(b => b.name)
}
PreparedDelete(name, predicate, returning) => {
let table = get_table(store, name)
prepare_foreign_table(store, table)
let context = evaluation(
store,
params,
row_environment(
table,
{ id: 0L, values: Array::make(table.columns.length(), Null), },
name,
),
)
prepare_expression(predicate, context, false, false)
prepare_returning(returning, context)
project_template(returning, context).map(b => b.name)
}
}
}
///|
fn program_id(input : String) -> String {
let mut value = 14695981039346656037UL
for byte in @utf8.encode(input) {
value = (value ^ byte.to_uint64()) * 1099511628211UL
}
value.to_string()
}
///|
// Shared semantic validation has no dependency on a particular wire decoder.
fn prepare_compiled_program(
program : CompiledProgram,
id : String,
) -> Program raise SqlError {
guard program.format == "moon-aot@1" &&
program.queries.length() <= 1000 &&
program.schema.encoding.unwrap_or(1) == 1 &&
program.schema.tables.all(t => t.rows.is_empty()) else {
fail("unsupported compiled program")
}
validate_store_rows(program.schema)
for object in program.schema.objects {
if object.kind == "view" {
guard object.selection is Some(select) else {
fail("view has no compiled query")
}
ignore(selection_template(select, evaluation(program.schema, [], [])))
}
}
let queries : Map[String, CompiledQuery] = Map([])
let selections : Map[String, PreparedSelection] = Map([])
for query in program.queries {
validate_optional_features(query)
guard query.name != "" &&
!queries.contains(query.name) &&
query.parameters >= 0 &&
query.parameters <= 10000 else {
fail("invalid compiled query catalog")
}
let names = match query.statement {
PreparedSelect(select) => {
let prepared = prepare_selection(
program.schema,
select,
query.parameters,
)
selections[query.name] = prepared
prepared.output.map(b => b.name)
}
_ => prepared_names(program.schema, query.statement, query.parameters)
}
guard names == query.names else {
fail("invalid compiled query result metadata")
}
queries[query.name] = query
}
{ schema: program.schema, queries, selections, id, storage: program.storage, }
}
///|
/// Load an application build artifact once. It is not an untrusted SQL endpoint.
pub fn Program::load(input : String) -> Program raise SqliteError {
try {
guard input.length() <= 1048576 else {
fail("compiled program resource limit")
}
let program : CompiledProgram = @json.from_json(@json.parse(input))
let validated = prepare_compiled_program(program, "")
{ ..validated, id: program_id(@json.to_json(program).stringify()), }
} catch {
error =>
raise interface_error(
match error {
SqlError(message) => message
_ => error.to_string()
},
)
}
}
///|
pub fn Program::query(self : Program, name : String) -> Query raise SqliteError {
guard self.queries.get(name) is Some(plan) else {
raise sqlite_misuse("unknown query in compiled catalog: " + name)
}
{ program_id: self.id, plan, selection: self.selections.get(name), }
}
///|
pub fn Connection::from_program(program : Program) -> Connection {
{
database: { store: copy_store(program.schema), serial: 0, },
program: Some(program),
closed: false,
statements: 0,
}
}
///|
pub fn Connection::prepare_compiled(
self : Connection,
query : Query,
) -> Statement raise SqliteError {
self.healthy()
guard self.program is Some(program) && program.id == query.program_id else {
raise sqlite_misuse("compiled query belongs to a different program")
}
let plan = query.plan
statement_new(
self,
plan.parameters,
plan.names,
data_readonly(plan.statement),
params => {
execute_data_statement(
self.database.store,
plan.statement,
params,
prepared_selection=query.selection,
)
},
tracks_changes=!data_readonly(plan.statement),
)
}