use rusqlite::Connection;
use super::SCHEMA_VERSION_KEY;
#[cfg(feature = "sync")]
use super::SqliteEventStoreError;
pub(super) const BASELINE_SCHEMA_VERSION: u32 = 1;
pub(super) const WRITE_GROUP_SCHEMA_VERSION: u32 = 2;
const MIGRATION_2: &str = "\
ALTER TABLE event ADD COLUMN write_group INTEGER;
ALTER TABLE event ADD COLUMN group_guard BLOB;";
pub(super) const STAMP_SQL: &str = "UPDATE event \
SET write_group = ?1, group_guard = CASE WHEN position = ?1 THEN ?2 END \
WHERE position >= ?1 AND write_group IS NULL";
pub(super) fn migrate_to_2(transaction: &Connection) -> rusqlite::Result<()> {
let found: u32 = transaction.query_row(
"SELECT CAST(v AS INTEGER) FROM store_meta WHERE k = ?",
[SCHEMA_VERSION_KEY],
|row| row.get(0),
)?;
if found != BASELINE_SCHEMA_VERSION {
return Ok(());
}
transaction.execute_batch(MIGRATION_2)?;
transaction.execute(
"UPDATE store_meta SET v = ? WHERE k = ?",
rusqlite::params![WRITE_GROUP_SCHEMA_VERSION, SCHEMA_VERSION_KEY],
)?;
Ok(())
}
pub(super) fn stamp(
transaction: &Connection,
first: i64,
guard: Option<&[u8]>,
) -> rusqlite::Result<()> {
transaction.execute(STAMP_SQL, rusqlite::params![first, guard])?;
Ok(())
}
#[cfg(feature = "sync")]
pub(super) fn stamp_ingested(
transaction: &Connection,
first: i64,
guard: Option<&happenstance_core::AppendCondition>,
) -> Result<(), SqliteEventStoreError> {
let stored = guard
.map(happenstance_sync::write_group::encode_guard)
.transpose()
.map_err(|source| match super::position_from_row(first) {
Ok(first) => SqliteEventStoreError::StoredGuard { first, source },
Err(invalid) => invalid,
})?;
stamp(transaction, first, stored.as_deref())?;
Ok(())
}
#[cfg(feature = "sync")]
mod read;
#[cfg(test)]
mod tests {
use rusqlite::Connection;
use super::STAMP_SQL;
use crate::event_store::SqliteEventStore;
mod version_2;
fn plan(connection: &Connection, sql: &str) -> Vec<String> {
let mut statement = connection
.prepare(&format!("EXPLAIN QUERY PLAN {sql}"))
.expect("the statement prepares");
let rows = statement
.query_map(rusqlite::params![1, None::<Vec<u8>>], |row| {
row.get::<_, String>(3)
})
.expect("the plan reads");
rows.collect::<Result<_, _>>()
.expect("every plan row reads")
}
#[test]
fn the_group_stamp_is_a_rowid_seek() {
let mut connection = Connection::open_in_memory().expect("an in-memory database");
SqliteEventStore::migrate(&mut connection).expect("migrating must succeed");
let rows = plan(&connection, STAMP_SQL);
assert!(
rows.iter()
.any(|detail| detail.contains("USING INTEGER PRIMARY KEY")),
"the stamp does not seek on the position: {rows:?}"
);
assert!(
!rows.iter().any(|detail| detail == "SCAN event"),
"the stamp scans the log under the write lock: {rows:?}"
);
}
}