use crate::error::BaseError;
use crate::plugin::{Plugin, PluginManager};
use std::sync::Arc;
use yang_db::Database;
pub struct DatabaseInitializer {
db: Database,
use_transaction: bool,
}
impl DatabaseInitializer {
pub fn new(db: Database, use_transaction: bool) -> Self {
Self {
db,
use_transaction,
}
}
pub async fn initialize_all(&self, plugin_manager: &PluginManager) -> Result<(), BaseError> {
log::info!("开始初始化数据库...");
self.create_migration_table().await?;
let plugins = plugin_manager.get_all().await;
if self.use_transaction {
self.initialize_with_transaction(&plugins).await?;
} else {
self.initialize_without_transaction(&plugins).await?;
}
log::info!("数据库初始化完成");
Ok(())
}
async fn initialize_with_transaction(
&self,
plugins: &[Arc<dyn Plugin>],
) -> Result<(), BaseError> {
let mut tx = self
.db
.transaction()
.await
.map_err(BaseError::DatabaseTransactionFailed)?;
for plugin in plugins {
let name = plugin.name();
log::info!("初始化插件数据库: {}", name);
for sql in plugin.init_sql() {
if let Err(e) = tx.execute(&sql).await {
log::error!("插件 {} 初始化失败: {}", name, e);
return Err(BaseError::PluginInitFailed(name.to_string(), e.to_string()));
}
}
self.run_migrations_in_tx(&mut tx, plugin.as_ref()).await?;
if let Err(e) = plugin.on_init().await {
log::error!("插件 {} 初始化回调失败: {}", name, e);
return Err(BaseError::PluginInitFailed(name.to_string(), e.to_string()));
}
}
tx.commit()
.await
.map_err(BaseError::DatabaseTransactionFailed)?;
Ok(())
}
async fn initialize_without_transaction(
&self,
plugins: &[Arc<dyn Plugin>],
) -> Result<(), BaseError> {
for plugin in plugins {
let name = plugin.name();
log::info!("初始化插件数据库: {}", name);
for sql in plugin.init_sql() {
if let Err(e) = self.db.execute(&sql).await {
log::error!("插件 {} 初始化失败: {}", name, e);
return Err(BaseError::PluginInitFailed(name.to_string(), e.to_string()));
}
}
self.run_migrations(plugin.as_ref()).await?;
if let Err(e) = plugin.on_init().await {
log::error!("插件 {} 初始化回调失败: {}", name, e);
return Err(BaseError::PluginInitFailed(name.to_string(), e.to_string()));
}
}
Ok(())
}
pub async fn create_migration_table(&self) -> Result<(), BaseError> {
let sql = r#"
CREATE TABLE IF NOT EXISTS _migrations (
id INT AUTO_INCREMENT PRIMARY KEY,
module_name VARCHAR(255) NOT NULL COMMENT '模块名称',
version VARCHAR(255) NOT NULL COMMENT '迁移版本',
executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '执行时间',
UNIQUE KEY unique_migration (module_name, version),
INDEX idx_module_name (module_name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='数据库迁移记录表'
"#;
self.db
.execute(sql)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok(())
}
pub async fn run_migrations(&self, plugin: &dyn Plugin) -> Result<(), BaseError> {
let module_name = plugin.name();
for (version, sql) in plugin.migration_sql() {
if self.is_migration_executed(module_name, &version).await? {
log::debug!("迁移 {} v{} 已执行,跳过", module_name, version);
continue;
}
log::info!("执行迁移: {} v{}", module_name, version);
self.db.execute(&sql).await.map_err(|e| {
BaseError::MigrationFailed(module_name.to_string(), version.clone(), e.to_string())
})?;
self.record_migration(module_name, &version).await?;
}
Ok(())
}
pub async fn run_migrations_in_tx(
&self,
tx: &mut yang_db::Transaction,
plugin: &dyn Plugin,
) -> Result<(), BaseError> {
let module_name = plugin.name();
for (version, sql) in plugin.migration_sql() {
if self.is_migration_executed(module_name, &version).await? {
log::debug!("迁移 {} v{} 已执行,跳过", module_name, version);
continue;
}
log::info!("执行迁移: {} v{}", module_name, version);
tx.execute(&sql).await.map_err(|e| {
BaseError::MigrationFailed(module_name.to_string(), version.clone(), e.to_string())
})?;
let record_sql = "INSERT INTO _migrations (module_name, version) VALUES (?, ?)";
let record_params = vec![
serde_json::Value::String(module_name.to_string()),
serde_json::Value::String(version.clone()),
];
tx.execute_with_params(record_sql, record_params)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
}
Ok(())
}
pub async fn is_migration_executed(
&self,
module_name: &str,
version: &str,
) -> Result<bool, BaseError> {
#[derive(sqlx::FromRow)]
struct CountResult {
count: i64,
}
let sql = "SELECT COUNT(*) as count FROM _migrations WHERE module_name = ? AND version = ?";
let params = vec![
serde_json::Value::String(module_name.to_string()),
serde_json::Value::String(version.to_string()),
];
let results: Vec<CountResult> = self
.db
.query_with_params(sql, params)
.await
.map_err(BaseError::DatabaseQueryFailed)?;
Ok(results.first().map(|r| r.count > 0).unwrap_or(false))
}
pub async fn record_migration(
&self,
module_name: &str,
version: &str,
) -> Result<(), BaseError> {
let sql = "INSERT INTO _migrations (module_name, version) VALUES (?, ?)";
let params = vec![
serde_json::Value::String(module_name.to_string()),
serde_json::Value::String(version.to_string()),
];
self.db
.execute_with_params(sql, params)
.await
.map_err(BaseError::DatabaseExecuteFailed)?;
Ok(())
}
}