78 lines
2.1 KiB
Rust
78 lines
2.1 KiB
Rust
pub mod query;
|
|
pub mod rows;
|
|
pub mod part;
|
|
pub mod types;
|
|
|
|
use anyhow::Context;
|
|
use sqlx::{PgConnection, PgPool, Postgres};
|
|
use sqlx::migrate::Migrator;
|
|
use sqlx::postgres::{PgArguments, PgConnectOptions, PgPoolOptions, PgQueryResult};
|
|
use sqlx::query::Query;
|
|
|
|
pub struct CoveDB {
|
|
pg_connect_options: PgConnectOptions,
|
|
db_pool: PgPool,
|
|
}
|
|
|
|
impl CoveDB {
|
|
pub async fn new(host: &str, port: u16, username: &str, password: &str, database: &str) -> Result<CoveDB, anyhow::Error> {
|
|
let pg_connect_options = <PgConnection as sqlx::Connection>::Options::new()
|
|
.host(host)
|
|
.port(port)
|
|
.username(username)
|
|
.password(password)
|
|
.database(database);
|
|
|
|
let db_pool = CoveDB::create_pool(10, pg_connect_options.clone()).await?;
|
|
|
|
|
|
|
|
let db = CoveDB {
|
|
pg_connect_options,
|
|
db_pool
|
|
};
|
|
|
|
Ok(db)
|
|
}
|
|
|
|
async fn create_pool(max_connections: u32, options: PgConnectOptions) -> Result<PgPool, anyhow::Error> {
|
|
PgPoolOptions::new()
|
|
.max_connections(max_connections)
|
|
.connect_with(options)
|
|
.await
|
|
.context("Failed to create database connection")
|
|
}
|
|
|
|
pub async fn run_migrations(&self) -> Result<(), anyhow::Error> {
|
|
let m = Migrator::new(std::path::Path::new("./migrations")).await?;
|
|
m.run(&self.db_pool).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn run_system_migrations(&self) -> Result<(), anyhow::Error> {
|
|
let m = Migrator::new(std::path::Path::new("./system-migrations")).await?;
|
|
let db_pool = CoveDB::create_pool(5, self.pg_connect_options.clone().database("postgres")).await?;
|
|
m.run(&db_pool).await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl CoveDBImpl for CoveDB {
|
|
fn get_pool(&self) -> &PgPool {
|
|
&self.db_pool
|
|
}
|
|
}
|
|
|
|
pub trait CoveDBImpl {
|
|
fn get_pool(&self) -> &PgPool;
|
|
|
|
async fn run_query<T: From<PgQueryResult>>(&self, query: Query<'_, Postgres, PgArguments>) -> Result<T, anyhow::Error> {
|
|
let result = query.execute(self.get_pool())
|
|
.await
|
|
.context("Failed to execute query")?;
|
|
|
|
Ok(result.into())
|
|
}
|
|
} |