che-orm 0.3.1

Typed SQLite and PostgreSQL ORM for che-rest applications
Documentation
use crate::{CompiledQuery, DatabaseValue, ExecuteResult, MigrationGraph, OrmError, Row};
use deadpool_sqlite::{Config, Object, Runtime};
use std::sync::Arc;
use tokio::sync::Mutex;

pub(crate) type Pool = deadpool_sqlite::Pool;
pub(crate) const MAX_PARAMETERS: usize = 900;

pub(crate) async fn connect(url: String, size: usize) -> Result<Pool, OrmError> {
    if size == 0 {
        return Err(OrmError::Configuration("pool size must be positive".into()));
    }
    let path = url.strip_prefix("sqlite://").unwrap_or(&url);
    if path == ":memory:" && size != 1 {
        return Err(OrmError::Configuration(
            "an in-memory SQLite database requires pool size 1".into(),
        ));
    }
    let mut config = Config::new(path);
    config.pool = Some(deadpool_sqlite::PoolConfig::new(size));
    let pool = config
        .create_pool(Runtime::Tokio1)
        .map_err(|error| OrmError::Configuration(error.to_string()))?;
    Session::acquire(&pool).await?;
    Ok(pool)
}

#[derive(Clone)]
pub(crate) struct Session(Arc<Mutex<Object>>);

impl Session {
    pub(crate) async fn acquire(pool: &Pool) -> Result<Self, OrmError> {
        let object = tokio::time::timeout(std::time::Duration::from_secs(30), pool.get())
            .await
            .map_err(|_| OrmError::Pool("connection acquisition timed out".into()))?
            .map_err(|error| OrmError::Pool(error.to_string()))?;
        let session = Self(Arc::new(Mutex::new(object)));
        session
            .interact(|connection| {
                if !connection.is_autocommit() {
                    connection.execute_batch("ROLLBACK")?;
                }
                connection.execute_batch("PRAGMA foreign_keys = ON")?;
                connection.create_collation("che_datetime", |left, right| {
                    use time::{OffsetDateTime, format_description::well_known::Rfc3339};
                    // Keep a total order even if application-owned raw SQL stored invalid text.
                    match (
                        OffsetDateTime::parse(left, &Rfc3339),
                        OffsetDateTime::parse(right, &Rfc3339),
                    ) {
                        (Ok(left), Ok(right)) => left.cmp(&right),
                        (Ok(_), Err(_)) => std::cmp::Ordering::Less,
                        (Err(_), Ok(_)) => std::cmp::Ordering::Greater,
                        (Err(_), Err(_)) => left.cmp(right),
                    }
                })?;
                Ok(())
            })
            .await?;
        Ok(session)
    }

    pub(crate) async fn interact<T, F>(&self, action: F) -> Result<T, OrmError>
    where
        T: Send + 'static,
        F: FnOnce(&mut rusqlite::Connection) -> Result<T, OrmError> + Send + 'static,
    {
        self.0
            .lock()
            .await
            .interact(action)
            .await
            .map_err(|error| OrmError::Interaction(error.to_string()))?
    }

    pub(crate) async fn batch(&self, sql: &str) -> Result<(), OrmError> {
        let sql = sql.to_owned();
        self.interact(move |connection| {
            connection.execute_batch(&sql)?;
            Ok(())
        })
        .await
    }
    pub(crate) async fn commit(&self) -> Result<(), OrmError> {
        self.batch("COMMIT").await
    }

    pub(crate) async fn execute(&self, query: CompiledQuery) -> Result<ExecuteResult, OrmError> {
        self.interact(move |connection| {
            let params = params(&query)?;
            let rows_affected =
                connection.execute(&query.sql, rusqlite::params_from_iter(params))?;
            Ok(ExecuteResult {
                rows_affected,
                last_insert_rowid: if query.sql.starts_with("INSERT") {
                    Some(connection.last_insert_rowid())
                } else {
                    None
                },
            })
        })
        .await
    }

    pub(crate) async fn query(&self, query: CompiledQuery) -> Result<Vec<Row>, OrmError> {
        self.interact(move |connection| {
            let params = params(&query)?;
            let mut statement = connection.prepare(&query.sql)?;
            let rows = statement.query_map(rusqlite::params_from_iter(params), Row::from_sqlite)?;
            rows.collect::<rusqlite::Result<Vec<_>>>()
                .map_err(Into::into)
        })
        .await
    }

    pub(crate) async fn migrate(
        &self,
        graph: MigrationGraph,
        target: Option<crate::MigrationId>,
    ) -> Result<usize, OrmError> {
        self.interact(move |connection| {
            crate::migration::sqlite_executor::apply_operation_migrations_to_on_connection(
                connection, graph, target,
            )
            .map_err(|error| OrmError::Migration(error.to_string()))
        })
        .await
    }

    pub(crate) async fn history(
        &self,
    ) -> Result<std::collections::HashMap<(String, String), String>, OrmError> {
        self.interact(|connection| {
            crate::migration::sqlite_executor::applied_operation_migrations(connection)
                .map_err(|error| OrmError::Migration(error.to_string()))
        })
        .await
    }
}

fn params(query: &CompiledQuery) -> Result<Vec<rusqlite::types::Value>, OrmError> {
    use rusqlite::types::Value;
    query
        .params
        .iter()
        .map(|value| {
            Ok(match value {
                DatabaseValue::Integer(value) => Value::Integer(*value),
                DatabaseValue::Real(value) => Value::Real(*value),
                DatabaseValue::Text(value) => Value::Text(value.clone()),
                DatabaseValue::Binary(value) => Value::Blob(value.clone()),
                DatabaseValue::Boolean(value) => Value::Integer(i64::from(*value)),
                DatabaseValue::Uuid(value) => Value::Blob(value.as_bytes().to_vec()),
                DatabaseValue::DateTime(value) => Value::Text(
                    value
                        .to_offset(time::UtcOffset::UTC)
                        .format(&time::format_description::well_known::Rfc3339)
                        .map_err(|error| OrmError::Interaction(error.to_string()))?,
                ),
                DatabaseValue::Null => Value::Null,
            })
        })
        .collect()
}