///|
/// SQL text entry point for development/build tools. The AOT runtime constructs
/// the same Statement through statement_new without retaining this function.
pub fn Connection::prepare(
self : Connection,
sql : String,
) -> Statement raise SqliteError {
self.healthy()
guard self.program is None else {
raise sqlite_misuse("compiled connections require prepare_compiled")
}
try {
let parser = lex(sql)
let statement = parse_statement(parser)
let params = Array::make(parser.parameter, Value::Null)
let names = match statement {
Select(select) =>
selection_template(select, evaluation(self.database.store, params, [])).map(b => {
b.name
},
)
Insert(insertion) =>
project_template(
insertion.returning,
evaluation(
self.database.store,
params,
row_environment(
get_table(self.database.store, insertion.table),
{
id: 0L,
values: Array::make(
get_table(self.database.store, insertion.table).columns.length(),
Null,
),
},
insertion.table,
),
),
).map(b => b.name)
Update(name, _, _, returning) | Delete(name, _, returning) => {
let table = get_table(self.database.store, name)
project_template(
returning,
evaluation(
self.database.store,
params,
row_environment(
table,
{ id: 0L, values: Array::make(table.columns.length(), Null), },
name,
),
),
).map(b => b.name)
}
Pragma(name, table, None) => {
let result = execute_pragma(
self.database.store,
name,
table,
None,
params,
)
if result.is_empty() {
[]
} else {
result[0].filter(b => !b.hidden).map(b => b.name)
}
}
_ => []
}
let read_only = match statement {
Select(_) | Pragma(_, _, None) => true
_ => false
}
statement_new(
self,
parser.parameter,
names,
read_only,
parameters => {
execute_statement(self.database.store, statement, parameters)
},
tracks_changes=statement is Insert(_) ||
statement is Update(_, _, _, _) ||
statement is Delete(_, _, _),
)
} catch {
error => raise interface_error(public_error(error))
}
}