123 lines
3.4 KiB
Rust
123 lines
3.4 KiB
Rust
use rusqlite::NO_PARAMS;
|
|
use rusqlite::{params, Connection};
|
|
use std::collections::BTreeMap;
|
|
use std::ops::Bound::{Excluded, Unbounded};
|
|
use thiserror::Error;
|
|
use log::debug;
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum MigrationError {
|
|
#[error("sql error: {0}")]
|
|
SqlError(#[from] rusqlite::Error),
|
|
#[error("database version {0} too new to migrate")]
|
|
VersionTooNew(MigrationVersion),
|
|
}
|
|
|
|
pub type MigrationResult<T> = Result<T, MigrationError>;
|
|
|
|
pub trait Migration {
|
|
fn up(&self, conn: &Connection) -> MigrationResult<()>;
|
|
fn down(&self, conn: &Connection) -> MigrationResult<()>;
|
|
}
|
|
|
|
pub struct SimpleMigration {
|
|
pub up_sql: String,
|
|
pub down_sql: String,
|
|
}
|
|
|
|
impl SimpleMigration {
|
|
pub fn new<T1: ToString, T2: ToString>(up_sql: T1, down_sql: T2) -> Self {
|
|
Self {
|
|
up_sql: up_sql.to_string(),
|
|
down_sql: down_sql.to_string(),
|
|
}
|
|
}
|
|
|
|
pub fn new_box<T1: ToString, T2: ToString>(up_sql: T1, down_sql: T2) -> Box<dyn Migration> {
|
|
Box::new(Self::new(up_sql, down_sql))
|
|
}
|
|
}
|
|
|
|
impl Migration for SimpleMigration {
|
|
fn up(&self, conn: &Connection) -> MigrationResult<()> {
|
|
conn.execute(&self.up_sql, NO_PARAMS)?;
|
|
Ok(())
|
|
}
|
|
fn down(&self, conn: &Connection) -> MigrationResult<()> {
|
|
conn.execute(&self.down_sql, NO_PARAMS)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub type MigrationVersion = u32;
|
|
pub const NO_MIGRATIONS: MigrationVersion = 0;
|
|
|
|
pub fn get_db_version(conn: &Connection) -> MigrationResult<MigrationVersion> {
|
|
let table_count: u32 = conn.query_row(
|
|
"SELECT COUNT(*) FROM sqlite_master
|
|
WHERE type='table' AND name='db_version'",
|
|
NO_PARAMS,
|
|
|row| row.get(0),
|
|
)?;
|
|
if table_count == 0 {
|
|
return Ok(NO_MIGRATIONS);
|
|
}
|
|
|
|
let version: u32 = conn.query_row(
|
|
"SELECT version FROM db_version WHERE id = 1",
|
|
NO_PARAMS,
|
|
|row| row.get(0),
|
|
)?;
|
|
Ok(version)
|
|
}
|
|
|
|
pub fn set_db_version(conn: &Connection, version: MigrationVersion) -> MigrationResult<()> {
|
|
conn.execute(
|
|
"
|
|
CREATE TABLE IF NOT EXISTS db_version (
|
|
id INTEGER PRIMARY KEY,
|
|
version INTEGER
|
|
);", NO_PARAMS)?;
|
|
conn.execute(
|
|
"
|
|
INSERT OR REPLACE INTO db_version (id, version)
|
|
VALUES (1, ?1);",
|
|
params![version])?;
|
|
Ok(())
|
|
}
|
|
|
|
pub struct Migrations {
|
|
migrations: BTreeMap<MigrationVersion, Box<dyn Migration>>,
|
|
}
|
|
|
|
impl Migrations {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
migrations: BTreeMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn add(&mut self, version: MigrationVersion, migration: Box<dyn Migration>) {
|
|
self.migrations.insert(version, migration);
|
|
}
|
|
|
|
pub fn apply(&self, conn: &mut Connection) -> MigrationResult<()> {
|
|
let db_version = get_db_version(conn)?;
|
|
if db_version != 0 && !self.migrations.contains_key(&db_version) {
|
|
return Err(MigrationError::VersionTooNew(db_version));
|
|
}
|
|
let mig_range = self.migrations.range(
|
|
(Excluded(db_version), Unbounded));
|
|
let mut trans = conn.transaction()?;
|
|
let mut last_ver: MigrationVersion = 0;
|
|
for (ver, mig) in mig_range {
|
|
debug!("applying migration version {}", ver);
|
|
mig.up(&mut trans)?;
|
|
last_ver = *ver;
|
|
}
|
|
set_db_version(&trans, last_ver)?;
|
|
trans.commit()?;
|
|
Ok(())
|
|
}
|
|
}
|