mod liveness;
mod restore;
mod schema;
#[cfg(any(windows, all(unix, not(target_os = "emscripten"))))]
pub(in crate::mvcc) use liveness::lease_file;
#[cfg(test)]
mod tests;
use rusqlite::Connection;
use uqa_storage::{
mvcc::{SerializableGraph, VersionResult, VersionedPersistence},
read_control::StorageReadControl,
};
use super::{admission, Error, PhysicalResult, SQLiteRecordStore};
use crate::SQLiteConnectionLease;
pub struct SQLiteSerializableAdmission {
connection: SQLiteConnectionLease,
graph: SerializableGraph,
previous_timeout: std::time::Duration,
}
impl SQLiteRecordStore {
pub fn serializable_admission(
&self,
control: &StorageReadControl,
) -> VersionResult<SQLiteSerializableAdmission> {
control.check()?;
let auxiliary = self
.connection
.serializable_connection(self.identity, control)?;
let held = SQLiteSerializableAdmission::load(&auxiliary, control, |_| Ok(self.identity))?;
held.graph
.validate_persisted_publications(control, |transaction| {
self.commit_status(transaction, control)
})?;
Ok(held)
}
}
impl SQLiteSerializableAdmission {
fn load(
auxiliary: &crate::ManagedConnection,
control: &StorageReadControl,
identity: impl FnOnce(&Connection) -> PhysicalResult<uqa_storage::mvcc::DatabaseId>,
) -> VersionResult<Self> {
let connection = auxiliary
.lease_connection_with_control(control)
.map_err(|error| Error::from(error).into_version())?;
let timeout = admission::BusyTimeout::new(&connection).map_err(super::sqlite_error)?;
begin(&connection, control).map_err(Error::into_version)?;
let identity = identity(&connection).map_err(Error::into_version)?;
let graph = schema::load(&connection, identity, control).map_err(Error::into_version)?;
drop(timeout);
let milliseconds: u32 = connection
.pragma_query_value(None, "busy_timeout", |row| row.get(0))
.map_err(super::sqlite_error)?;
connection
.busy_timeout(std::time::Duration::ZERO)
.map_err(super::sqlite_error)?;
Ok(Self {
connection,
graph,
previous_timeout: std::time::Duration::from_millis(u64::from(milliseconds)),
})
}
}
impl SQLiteSerializableAdmission {
pub fn graph(&self) -> &SerializableGraph {
&self.graph
}
pub fn graph_mut(&mut self) -> &mut SerializableGraph {
&mut self.graph
}
pub fn persist(self, control: &StorageReadControl) -> VersionResult<()> {
self.persist_in(control).map_err(Error::into_version)
}
fn persist_in(&self, control: &StorageReadControl) -> PhysicalResult<()> {
if !self.graph.checkpoint_records_changed() {
return retry(&self.connection, "COMMIT", false, control);
}
schema::persist(&self.connection, &self.graph, control)?;
retry(&self.connection, "COMMIT", false, control)
}
}
impl Drop for SQLiteSerializableAdmission {
fn drop(&mut self) {
let _ = self.connection.busy_timeout(self.previous_timeout);
}
}
fn begin(connection: &Connection, control: &StorageReadControl) -> PhysicalResult<()> {
retry(connection, "BEGIN IMMEDIATE", true, control)
}
fn retry(
connection: &Connection,
sql: &str,
autocommit: bool,
control: &StorageReadControl,
) -> PhysicalResult<()> {
admission::retry(connection, autocommit, control, || {
connection.execute_batch(sql).map_err(Into::into)
})
}