From 1e3900c93ab46f95bc8a904d1afbed4bbb43cd3e Mon Sep 17 00:00:00 2001 From: mace Date: Sat, 16 Mar 2024 15:15:07 +0100 Subject: [PATCH] optimize db pooling --- src/cli/controller.rs | 15 ++++++------- src/container.rs | 22 +++++++++--------- src/main.rs | 9 +------- src/repository/file_repo.rs | 27 ++++++++++++---------- src/repository/filter_repo.rs | 40 +++++++++++++++++---------------- src/repository/job_repo.rs | 35 +++++++++++++++-------------- src/repository/merchant_repo.rs | 27 +++++++++------------- src/repository/schema_repo.rs | 24 +++++++++----------- src/service/file_service.rs | 10 ++++----- src/service/filter_service.rs | 10 ++++----- src/service/job_service.rs | 10 ++++----- src/service/merchant_service.rs | 10 ++++----- src/service/schema_service.rs | 10 ++++----- 13 files changed, 121 insertions(+), 128 deletions(-) diff --git a/src/cli/controller.rs b/src/cli/controller.rs index bf4877e..58471bb 100644 --- a/src/cli/controller.rs +++ b/src/cli/controller.rs @@ -1,7 +1,6 @@ -use mysql::PooledConn; - use crate::{ container, + database::db::Db, service::{ file_service::FileService, filter_service::FilterService, job_service::JobService, merchant_service::MerchantService, schema_service::SchemaService, @@ -10,14 +9,14 @@ use crate::{ use super::command::{Cli, Commands}; -pub fn process_args(args: Cli, conn: &mut PooledConn) { +pub fn process_args(args: Cli, db: Db) { match args.mode { Commands::Merch { search } => { - let mut merchant_service: MerchantService = container::get_merchant_service(conn); + let mut merchant_service: MerchantService = container::get_merchant_service(db); merchant_service.get_merchant(&search.unwrap()); } Commands::Schema { search } => { - let mut schema_service: SchemaService = container::get_schema_service(conn); + let mut schema_service: SchemaService = container::get_schema_service(db); schema_service.get_columns(&search.unwrap()) } Commands::Filter { @@ -26,7 +25,7 @@ pub fn process_args(args: Cli, conn: &mut PooledConn) { all, log, } => { - let mut filter_service: FilterService = container::get_filter_service(conn); + let mut filter_service: FilterService = container::get_filter_service(db); if config { filter_service.get_filter_configs(&filter_id) } else if log { @@ -36,11 +35,11 @@ pub fn process_args(args: Cli, conn: &mut PooledConn) { } } Commands::Page { page_id } => { - let mut file_service: FileService = container::get_page_service(conn); + let mut file_service: FileService = container::get_page_service(db); file_service.get_page(&page_id); } Commands::Job { job_id, log } => { - let mut job_service: JobService = container::get_job_service(conn); + let mut job_service: JobService = container::get_job_service(db); if log { job_service.get_job_log(&job_id); } else { diff --git a/src/container.rs b/src/container.rs index 3b96925..ba82152 100644 --- a/src/container.rs +++ b/src/container.rs @@ -1,34 +1,36 @@ -use mysql::PooledConn; - use crate::{ - repository::{filter_repo::FilterRepo, merchant_repo::MerchantRepo, schema_repo::SchemaRepo, file_repo::FileRepo, job_repo::JobRepo}, + database::db::Db, + repository::{ + file_repo::FileRepo, filter_repo::FilterRepo, job_repo::JobRepo, + merchant_repo::MerchantRepo, schema_repo::SchemaRepo, + }, service::{ - filter_service::FilterService, merchant_service::MerchantService, - schema_service::SchemaService, file_service::FileService, job_service::JobService, + file_service::FileService, filter_service::FilterService, job_service::JobService, + merchant_service::MerchantService, schema_service::SchemaService, }, }; -pub fn get_filter_service(pool: &mut PooledConn) -> FilterService { +pub fn get_filter_service(pool: Db) -> FilterService { let repo = FilterRepo::new(pool); return FilterService::new(repo); } -pub fn get_merchant_service(pool: &mut PooledConn) -> MerchantService { +pub fn get_merchant_service(pool: Db) -> MerchantService { let repo = MerchantRepo::new(pool); return MerchantService::new(repo); } -pub fn get_schema_service(pool: &mut PooledConn) -> SchemaService { +pub fn get_schema_service(pool: Db) -> SchemaService { let repo = SchemaRepo::new(pool); return SchemaService::new(repo); } -pub fn get_page_service(pool: &mut PooledConn) -> FileService { +pub fn get_page_service(pool: Db) -> FileService { let repo = FileRepo::new(pool); return FileService::new(repo); } -pub(crate) fn get_job_service(pool: &mut PooledConn) -> JobService { +pub(crate) fn get_job_service(pool: Db) -> JobService { let repo = JobRepo::new(pool); return JobService::new(repo); } diff --git a/src/main.rs b/src/main.rs index 2a9084c..90cc0f6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,6 @@ use clap::Parser; use cli::{command::Cli, controller}; use database::db::Db; -use mysql::PooledConn; pub mod cli; pub mod container; @@ -15,14 +14,8 @@ fn main() -> std::result::Result<(), Box> { let args: Cli = Cli::parse(); let env: &String = &Cli::parse().env.unwrap_or("local".to_string()); let db: Db = Db::initialize(env.to_string())?; - let conn_res: Result = db.get_connection(); - match conn_res { - Ok(mut conn) => controller::process_args(args, &mut conn), - Err(e) => { - println!("Error connecting DB: {e}"); - } - } + controller::process_args(args, db); Ok(()) } diff --git a/src/repository/file_repo.rs b/src/repository/file_repo.rs index c797cf0..f44e652 100644 --- a/src/repository/file_repo.rs +++ b/src/repository/file_repo.rs @@ -1,28 +1,31 @@ -use mysql::{PooledConn, params, prelude::Queryable}; +use mysql::{params, prelude::Queryable}; -use crate::entity::file::Page; +use crate::{database::db::Db, entity::file::Page}; #[derive(Debug)] -pub struct FileRepo<'a> { - db_pool: &'a mut PooledConn, +pub struct FileRepo { + db_pool: Db, } -impl<'a> FileRepo<'a> { - pub fn new(db_pool: &'a mut PooledConn) -> Self { - Self { db_pool } +impl FileRepo { + pub fn new(db: Db) -> Self { + Self { db_pool: db } } pub fn find_page(&mut self, file_id: &usize) -> Result, mysql::Error> { - let stat = self.db_pool + let mut connection: mysql::PooledConn = self.db_pool.get_connection()?; + let stat = connection .prep("SELECT m_id, description, file FROM global_data.effi_file_mapping WHERE file_id = :file_id") .unwrap(); - - self.db_pool.exec_map( + connection.exec_map( stat, params! {"file_id" => file_id}, - |(m_id, description, file)| Page { m_id, title: description, file }, + |(m_id, description, file)| Page { + m_id, + title: description, + file, + }, ) - } } diff --git a/src/repository/filter_repo.rs b/src/repository/filter_repo.rs index e76274e..4fad865 100644 --- a/src/repository/filter_repo.rs +++ b/src/repository/filter_repo.rs @@ -1,20 +1,23 @@ use mysql::{params, prelude::Queryable, PooledConn}; -use crate::entity::{filter::Filter, filter_config::FilterConfig, filter_log::FilterLog}; +use crate::{ + database::db::Db, + entity::{filter::Filter, filter_config::FilterConfig, filter_log::FilterLog}, +}; #[derive(Debug)] -pub struct FilterRepo<'a> { - db_pool: &'a mut PooledConn, +pub struct FilterRepo { + db: Db, } -impl<'a> FilterRepo<'a> { - pub fn new(db_pool: &'a mut PooledConn) -> Self { - Self { db_pool } +impl FilterRepo { + pub fn new(db: Db) -> Self { + Self { db } } pub fn find_by_id(&mut self, filter_id: &usize) -> Result, mysql::Error> { - let stat = self.db_pool - .prep( + let mut connection: PooledConn = self.db.get_connection()?; + let stat = connection.prep( "SELECT f.filter_module_id, f.file_name, f.description, fm.filter_module_no, fm.filter_user FROM filter f JOIN global_data.filter_modules fm ON fm.filter_module_id = f.filter_module_id @@ -22,9 +25,10 @@ impl<'a> FilterRepo<'a> { ") .unwrap(); - self.db_pool.exec_map( + let params = params! {"filter_id" => filter_id}; + connection.exec_map( stat, - params! {"filter_id" => filter_id}, + params, |(filter_module_id, file_name, description, filter_module_no, filter_user)| Filter { filter_module_id, file_name, @@ -39,7 +43,8 @@ impl<'a> FilterRepo<'a> { &mut self, filter_id: &usize, ) -> Result, mysql::Error> { - let stat = self.db_pool + let mut connection: PooledConn = self.db.get_connection()?; + let stat = connection .prep( " SELECT t1.attribute, t1.value1, IF(t1.value2 is null or t1.value2 = '', 'EMPTY', t1.value2) as value2, t2.name, t1.upd_ts @@ -50,7 +55,7 @@ impl<'a> FilterRepo<'a> { ) .unwrap(); - self.db_pool.exec_map( + connection.exec_map( stat, params! {"filter_id" => filter_id}, |(attribute, value1, value2, name, upd_ts)| FilterConfig { @@ -63,12 +68,9 @@ impl<'a> FilterRepo<'a> { ) } - pub fn find_filter_log( - &mut self, - filter_id: &usize, - ) -> Result, mysql::Error> { - let stat = self - .db_pool + pub fn find_filter_log(&mut self, filter_id: &usize) -> Result, mysql::Error> { + let mut connection: PooledConn = self.db.get_connection()?; + let stat = connection .prep( " SELECT t1.run_ts, t1.error_code, t1.error_msg, t1.mysql_error @@ -78,7 +80,7 @@ impl<'a> FilterRepo<'a> { ) .unwrap(); - self.db_pool.exec_map( + connection.exec_map( stat, params! {"filter_id" => filter_id}, |(run_ts, error_code, error_msg, mysql_error)| FilterLog { diff --git a/src/repository/job_repo.rs b/src/repository/job_repo.rs index 410e04c..e61dfc0 100644 --- a/src/repository/job_repo.rs +++ b/src/repository/job_repo.rs @@ -1,20 +1,23 @@ -use mysql::{params, prelude::Queryable, PooledConn}; +use mysql::{params, prelude::Queryable}; -use crate::entity::job::{Job, JobLog}; +use crate::{ + database::db::Db, + entity::job::{Job, JobLog}, +}; #[derive(Debug)] -pub struct JobRepo<'a> { - db_pool: &'a mut PooledConn, +pub struct JobRepo { + db: Db, } -impl<'a> JobRepo<'a> { - pub fn new(db_pool: &'a mut PooledConn) -> Self { - Self { db_pool } +impl JobRepo { + pub fn new(db: Db) -> Self { + Self { db } } pub fn find_by_id(&mut self, job_id: &usize) -> Result, mysql::Error> { - let stat = self - .db_pool + let mut connection: mysql::PooledConn = self.db.get_connection()?; + let stat = connection .prep( "SELECT jm.file_name, jm.description @@ -26,7 +29,7 @@ impl<'a> JobRepo<'a> { ) .unwrap(); - self.db_pool.exec_map( + connection.exec_map( stat, params! {"job_id" => job_id}, |(file_name, description)| Job { @@ -37,8 +40,8 @@ impl<'a> JobRepo<'a> { } pub fn find_log(&mut self, job_id: &usize) -> Result, mysql::Error> { - let stat = self - .db_pool + let mut connection: mysql::PooledConn = self.db.get_connection()?; + let stat = connection .prep( " SELECT jea.content, jea.upd_ts @@ -51,10 +54,8 @@ impl<'a> JobRepo<'a> { ) .unwrap(); - self.db_pool.exec_map( - stat, - params! {"job_id" => job_id}, - |( content, upd_ts )| JobLog { content, upd_ts }, - ) + connection.exec_map(stat, params! {"job_id" => job_id}, |(content, upd_ts)| { + JobLog { content, upd_ts } + }) } } diff --git a/src/repository/merchant_repo.rs b/src/repository/merchant_repo.rs index 4127290..5e2e412 100644 --- a/src/repository/merchant_repo.rs +++ b/src/repository/merchant_repo.rs @@ -1,30 +1,25 @@ -use mysql::{params, prelude::Queryable, PooledConn}; +use mysql::{params, prelude::Queryable}; -use crate::entity::merchant::Merchant; +use crate::{database::db::Db, entity::merchant::Merchant}; -pub struct MerchantRepo<'a> { - db_pool: &'a mut PooledConn, +pub struct MerchantRepo { + db_pool: Db, } -impl<'a> MerchantRepo<'a> { - pub fn new(db_pool: &'a mut PooledConn) -> Self { +impl MerchantRepo { + pub fn new(db_pool: Db) -> Self { Self { db_pool } } - pub fn find_by_name_or_id( - &mut self, - search: &str, - ) -> Result, mysql::Error> { - let stat = self.db_pool + pub fn find_by_name_or_id(&mut self, search: &str) -> Result, mysql::Error> { + let mut connection = self.db_pool.get_connection()?; + let stat = connection .prep("SELECT m_name, m_id FROM global_data.merchant WHERE m_id = :search OR m_name LIKE :search2;") .unwrap(); let search_like = format!("%{}%", search); - self.db_pool.exec_map( - stat, - params! {"search" => search, "search2" => search_like}, - |(m_name, m_id)| Merchant { m_name, m_id }, - ) + let params = params! {"search" => search, "search2" => search_like}; + connection.exec_map(stat, params, |(m_name, m_id)| Merchant { m_name, m_id }) } } diff --git a/src/repository/schema_repo.rs b/src/repository/schema_repo.rs index 4ebf603..261f5cc 100644 --- a/src/repository/schema_repo.rs +++ b/src/repository/schema_repo.rs @@ -1,25 +1,23 @@ -use mysql::{params, prelude::Queryable, PooledConn}; +use mysql::{params, prelude::Queryable}; -use crate::entity::schema::Schema; +use crate::{database::db::Db, entity::schema::Schema}; -pub struct SchemaRepo<'a> { - db_pool: &'a mut PooledConn, +pub struct SchemaRepo { + db: Db, } -impl<'a> SchemaRepo<'a> { - pub fn new(db_pool: &'a mut PooledConn) -> Self { - Self { db_pool } +impl SchemaRepo { + pub fn new(db: Db) -> Self { + Self { db } } - pub fn find_by_column( - &mut self, - column_name: &str, - ) -> Result, mysql::Error> { - let stat = self.db_pool + pub fn find_by_column(&mut self, column_name: &str) -> Result, mysql::Error> { + let mut connection: mysql::PooledConn = self.db.get_connection()?; + let stat = connection .prep("SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE column_name LIKE :c_name") .unwrap(); - self.db_pool.exec_map( + connection.exec_map( stat, params! {"c_name" => column_name}, |(table_name, column_name, column_type)| Schema { diff --git a/src/service/file_service.rs b/src/service/file_service.rs index 1e1db92..9085f8f 100644 --- a/src/service/file_service.rs +++ b/src/service/file_service.rs @@ -2,14 +2,14 @@ use rcc::TerminalSize; use crate::{entity::file::Page, repository::file_repo::FileRepo}; -pub struct FileService<'a> { - repo: FileRepo<'a>, +pub struct FileService { + repo: FileRepo, } -impl TerminalSize for FileService<'_> {} +impl TerminalSize for FileService {} -impl<'a> FileService<'a> { - pub fn new(repo: FileRepo<'a>) -> Self { +impl FileService { + pub fn new(repo: FileRepo) -> Self { Self { repo } } diff --git a/src/service/filter_service.rs b/src/service/filter_service.rs index 30b6852..0a3977a 100644 --- a/src/service/filter_service.rs +++ b/src/service/filter_service.rs @@ -6,14 +6,14 @@ use crate::{ repository::filter_repo::FilterRepo, }; -pub struct FilterService<'a> { - repo: FilterRepo<'a>, +pub struct FilterService { + repo: FilterRepo, } -impl TerminalSize for FilterService<'_> {} +impl TerminalSize for FilterService {} -impl<'a> FilterService<'a> { - pub fn new(repo: FilterRepo<'a>) -> Self { +impl FilterService { + pub fn new(repo: FilterRepo) -> Self { Self { repo } } diff --git a/src/service/job_service.rs b/src/service/job_service.rs index b58cdf0..0599b4c 100644 --- a/src/service/job_service.rs +++ b/src/service/job_service.rs @@ -5,14 +5,14 @@ use crate::{ repository::job_repo::JobRepo, }; -pub struct JobService<'a> { - pub repo: JobRepo<'a>, +pub struct JobService { + pub repo: JobRepo, } -impl TerminalSize for JobService<'_> {} +impl TerminalSize for JobService {} -impl<'a> JobService<'a> { - pub fn new(repo: JobRepo<'a>) -> Self { +impl JobService { + pub fn new(repo: JobRepo) -> Self { Self { repo } } diff --git a/src/service/merchant_service.rs b/src/service/merchant_service.rs index 499eb1e..e01046a 100644 --- a/src/service/merchant_service.rs +++ b/src/service/merchant_service.rs @@ -2,14 +2,14 @@ use rcc::TerminalSize; use crate::repository::merchant_repo::MerchantRepo; -pub struct MerchantService<'a> { - repo: MerchantRepo<'a>, +pub struct MerchantService { + repo: MerchantRepo, } -impl TerminalSize for MerchantService<'_> {} +impl TerminalSize for MerchantService {} -impl<'a> MerchantService<'a> { - pub fn new(repo: MerchantRepo<'a>) -> Self { +impl MerchantService { + pub fn new(repo: MerchantRepo) -> Self { Self { repo } } diff --git a/src/service/schema_service.rs b/src/service/schema_service.rs index e12e455..24d5439 100644 --- a/src/service/schema_service.rs +++ b/src/service/schema_service.rs @@ -2,14 +2,14 @@ use rcc::TerminalSize; use crate::repository::schema_repo::SchemaRepo; -pub struct SchemaService<'a> { - repo: SchemaRepo<'a>, +pub struct SchemaService { + repo: SchemaRepo, } -impl TerminalSize for SchemaService<'_> {} +impl TerminalSize for SchemaService {} -impl<'a> SchemaService<'a> { - pub fn new(repo: SchemaRepo<'a>) -> Self { +impl SchemaService { + pub fn new(repo: SchemaRepo) -> Self { Self { repo } } pub fn get_columns(&mut self, column: &str) {