1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
//! An adapter enabling use of the schemer schema migration library with
//! SQLite3.
//!
//! # Examples:
//!
//! ```rust
//! extern crate rusqlite;
//! #[macro_use]
//! extern crate schemer;
//! extern crate schemer_rusqlite;
//! extern crate uuid;
//!
//! use std::collections::HashSet;
//!
//! use rusqlite::{params, Connection, Transaction, Error as RusqliteError};
//! use schemer::{Migration, Migrator};
//! use schemer_rusqlite::{RusqliteAdapter, RusqliteAdapterError, RusqliteMigration};
//! use uuid::Uuid;
//!
//! struct MyExampleMigration;
//! migration!(
//! MyExampleMigration,
//! "4885e8ab-dafa-4d76-a565-2dee8b04ef60",
//! [],
//! "An example migration without dependencies.");
//!
//! impl RusqliteMigration for MyExampleMigration {
//! type Error = RusqliteError;
//!
//! fn up(&self, transaction: &Transaction) -> Result<(), RusqliteAdapterError> {
//! transaction.execute("CREATE TABLE my_example (id integer PRIMARY KEY);", params![])?;
//! Ok(())
//! }
//!
//! fn down(&self, transaction: &Transaction) -> Result<(), RusqliteAdapterError> {
//! transaction.execute("DROP TABLE my_example;", params![])?;
//! Ok(())
//! }
//! }
//!
//! fn main() {
//! let mut conn = Connection::open_in_memory().unwrap();
//! let adapter = RusqliteAdapter::new(&mut conn, None);
//!
//! let mut migrator = Migrator::new(adapter);
//!
//! let migration = Box::new(MyExampleMigration {});
//! migrator.register(migration);
//! migrator.up(None);
//! }
//! ```
#![warn(clippy::all)]
#![forbid(unsafe_code)]
use std::collections::HashSet;
use std::error::Error;
use std::marker::{PhantomData, Send, Sync};
use rusqlite::{params, Connection, Error as RusqliteError, Transaction};
use uuid::Uuid;
use schemer::{Adapter, Migration};
/// SQlite-specific trait for schema migrations.
pub trait RusqliteMigration: Migration {
type Error: From<RusqliteError>;
/// Apply a migration to the database using a transaction.
fn up(&self, _transaction: &Transaction<'_>) -> Result<(), Self::Error> {
Ok(())
}
/// Revert a migration to the database using a transaction.
fn down(&self, _transaction: &Transaction<'_>) -> Result<(), Self::Error> {
Ok(())
}
}
pub type RusqliteAdapterError = RusqliteError;
struct WrappedUuid(Uuid);
impl rusqlite::types::FromSql for WrappedUuid {
fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
Ok(WrappedUuid(Uuid::from_slice(value.as_blob()?).map_err(
|e| rusqlite::types::FromSqlError::Other(Box::new(e)),
)?))
}
}
/// Adapter between schemer and SQLite.
pub struct RusqliteAdapter<'a, E> {
conn: &'a mut Connection,
migration_metadata_table: String,
_err: PhantomData<E>,
}
impl<'a, E> RusqliteAdapter<'a, E> {
/// Construct a SQLite schemer adapter.
///
/// `table_name` specifies the name of the table that schemer will use
/// for storing metadata about applied migrations. If `None`, a default
/// will be used.
///
/// ```rust
/// # extern crate rusqlite;
/// # use rusqlite::{Error as RusqliteError};
/// #
/// # fn main() {
/// let mut conn = rusqlite::Connection::open_in_memory().unwrap();
/// let adapter: schemer_rusqlite::RusqliteAdapter<RusqliteError> = schemer_rusqlite::RusqliteAdapter::new(&mut conn, None);
/// # }
/// ```
pub fn new(conn: &'a mut Connection, table_name: Option<String>) -> RusqliteAdapter<'a, E> {
RusqliteAdapter {
conn,
migration_metadata_table: table_name.unwrap_or_else(|| "_schemer".into()),
_err: PhantomData,
}
}
/// Initialize the schemer metadata schema. This must be called before
/// using `Migrator` with this adapter. This is safe to call multiple times.
pub fn init(&self) -> Result<(), RusqliteError> {
self.conn.execute(
&format!(
r#"
CREATE TABLE IF NOT EXISTS {} (
id blob PRIMARY KEY
)
"#,
self.migration_metadata_table
),
params![],
)?;
Ok(())
}
}
impl<'a, E: From<RusqliteError> + Sync + Send + Error + 'static> Adapter
for RusqliteAdapter<'a, E>
{
type MigrationType = dyn RusqliteMigration<Error = E>;
type Error = E;
fn applied_migrations(&mut self) -> Result<HashSet<Uuid>, Self::Error> {
let mut stmt = self.conn.prepare(&format!(
"SELECT id FROM {};",
self.migration_metadata_table
))?;
// TODO: have to do this rather than `collect` because Rusqlite has an
// interface that goes against map conventions.
let rows = stmt.query_map(params![], |row| row.get::<_, WrappedUuid>(0))?;
let mut ids = HashSet::new();
for row in rows {
ids.insert(row?.0);
}
Ok(ids)
}
fn apply_migration(&mut self, migration: &Self::MigrationType) -> Result<(), Self::Error> {
let trans = self.conn.transaction()?;
migration.up(&trans)?;
let uuid = migration.id();
let uuid_bytes = &uuid.as_bytes()[..];
trans.execute(
&format!(
"INSERT INTO {} (id) VALUES (?1);",
self.migration_metadata_table
),
[&uuid_bytes],
)?;
trans.commit().map_err(|e| e.into())
}
fn revert_migration(&mut self, migration: &Self::MigrationType) -> Result<(), Self::Error> {
let trans = self.conn.transaction()?;
migration.down(&trans)?;
let uuid = migration.id();
let uuid_bytes = &uuid.as_bytes()[..];
trans.execute(
&format!(
"DELETE FROM {} WHERE id = ?1;",
self.migration_metadata_table
),
[&uuid_bytes],
)?;
trans.commit().map_err(|e| e.into())
}
}
#[cfg(test)]
mod tests {
use super::*;
use rusqlite::Error as RusqliteError;
use schemer::test_schemer_adapter;
use schemer::testing::*;
impl RusqliteMigration for TestMigration {
type Error = RusqliteError;
}
impl<'a> TestAdapter for RusqliteAdapter<'a, RusqliteError> {
fn mock(id: Uuid, dependencies: HashSet<Uuid>) -> Box<Self::MigrationType> {
Box::new(TestMigration::new(id, dependencies))
}
}
fn build_test_connection() -> Connection {
Connection::open_in_memory().unwrap()
}
fn build_test_adapter(conn: &mut Connection) -> RusqliteAdapter<'_, RusqliteError> {
let adapter = RusqliteAdapter::new(conn, None);
adapter.init().unwrap();
adapter
}
test_schemer_adapter!(
let mut conn = build_test_connection(),
build_test_adapter(&mut conn));
}