98 lines
2.8 KiB
Rust
98 lines
2.8 KiB
Rust
use std::{ops::Deref, time::Duration};
|
|
|
|
use sea_orm::{
|
|
ConnectOptions, ConnectionTrait, Database, DatabaseBackend, DatabaseConnection, DbBackend,
|
|
DbErr, ExecResult, QueryResult, Statement,
|
|
};
|
|
use sea_orm_migration::MigratorTrait;
|
|
|
|
use super::DatabaseConfig;
|
|
use crate::{errors::RecorderResult, migrations::Migrator};
|
|
|
|
pub struct DatabaseService {
|
|
connection: DatabaseConnection,
|
|
}
|
|
|
|
impl DatabaseService {
|
|
pub async fn from_config(config: DatabaseConfig) -> RecorderResult<Self> {
|
|
let mut opt = ConnectOptions::new(&config.uri);
|
|
opt.max_connections(config.max_connections)
|
|
.min_connections(config.min_connections)
|
|
.connect_timeout(Duration::from_millis(config.connect_timeout))
|
|
.idle_timeout(Duration::from_millis(config.idle_timeout))
|
|
.sqlx_logging(config.enable_logging);
|
|
|
|
if let Some(acquire_timeout) = config.acquire_timeout {
|
|
opt.acquire_timeout(Duration::from_millis(acquire_timeout));
|
|
}
|
|
|
|
let db = Database::connect(opt).await?;
|
|
|
|
if db.get_database_backend() == DatabaseBackend::Sqlite {
|
|
db.execute(Statement::from_string(
|
|
DatabaseBackend::Sqlite,
|
|
"
|
|
PRAGMA foreign_keys = ON;
|
|
PRAGMA journal_mode = WAL;
|
|
PRAGMA synchronous = NORMAL;
|
|
PRAGMA mmap_size = 134217728;
|
|
PRAGMA journal_size_limit = 67108864;
|
|
PRAGMA cache_size = 2000;
|
|
",
|
|
))
|
|
.await?;
|
|
}
|
|
|
|
if config.auto_migrate {
|
|
Migrator::up(&db, None).await?;
|
|
}
|
|
|
|
Ok(Self { connection: db })
|
|
}
|
|
}
|
|
|
|
impl Deref for DatabaseService {
|
|
type Target = DatabaseConnection;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.connection
|
|
}
|
|
}
|
|
|
|
impl AsRef<DatabaseConnection> for DatabaseService {
|
|
fn as_ref(&self) -> &DatabaseConnection {
|
|
&self.connection
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl ConnectionTrait for DatabaseService {
|
|
fn get_database_backend(&self) -> DbBackend {
|
|
self.deref().get_database_backend()
|
|
}
|
|
|
|
async fn execute(&self, stmt: Statement) -> Result<ExecResult, DbErr> {
|
|
self.deref().execute(stmt).await
|
|
}
|
|
|
|
async fn execute_unprepared(&self, sql: &str) -> Result<ExecResult, DbErr> {
|
|
self.deref().execute_unprepared(sql).await
|
|
}
|
|
|
|
async fn query_one(&self, stmt: Statement) -> Result<Option<QueryResult>, DbErr> {
|
|
self.deref().query_one(stmt).await
|
|
}
|
|
|
|
async fn query_all(&self, stmt: Statement) -> Result<Vec<QueryResult>, DbErr> {
|
|
self.deref().query_all(stmt).await
|
|
}
|
|
|
|
fn support_returning(&self) -> bool {
|
|
self.deref().support_returning()
|
|
}
|
|
|
|
fn is_mock_connection(&self) -> bool {
|
|
self.deref().is_mock_connection()
|
|
}
|
|
}
|