hwhkit 0.1.2

一个用于快速构建 Web 服务的 Rust 工具库
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! 关系数据库连接管理模块

use crate::config::{DatabaseConfig, DatabaseType};
use crate::error::{Error, Result};
use sqlx::any::{AnyConnectOptions, AnyPoolOptions};
use sqlx::{Any, Pool};
use std::str::FromStr;
use std::time::Duration;

/// 数据库连接池类型
pub type DatabasePool = Pool<Any>;

/// 数据库管理器
#[derive(Debug, Clone)]
pub struct Database {
    pool: DatabasePool,
    config: DatabaseConfig,
}

impl Database {
    /// 从配置创建数据库连接
    ///
    /// # Arguments
    ///
    /// * `config` - 数据库配置
    ///
    /// # Returns
    ///
    /// 返回数据库实例或错误
    pub async fn from_config(config: DatabaseConfig) -> Result<Self> {
        if !config.enabled {
            return Err(Error::Database("数据库未启用".to_string()));
        }

        // 验证 URL 格式
        let connect_options = AnyConnectOptions::from_str(&config.url)
            .map_err(|e| Error::Database(format!("无效的数据库连接 URL: {}", e)))?;

        // 创建连接池
        let pool = AnyPoolOptions::new()
            .max_connections(config.max_connections)
            .min_connections(config.min_connections)
            .acquire_timeout(Duration::from_secs(config.connect_timeout))
            .connect_with(connect_options)
            .await
            .map_err(|e| Error::Database(format!("数据库连接失败: {}", e)))?;

        tracing::info!(
            "数据库连接成功: {:?}, 最大连接数: {}, 最小连接数: {}",
            config.db_type,
            config.max_connections,
            config.min_connections
        );

        Ok(Self { pool, config })
    }

    /// 获取数据库连接池
    pub fn pool(&self) -> &DatabasePool {
        &self.pool
    }

    /// 获取数据库配置
    pub fn config(&self) -> &DatabaseConfig {
        &self.config
    }

    /// 测试数据库连接
    pub async fn ping(&self) -> Result<()> {
        sqlx::query("SELECT 1")
            .execute(&self.pool)
            .await
            .map_err(|e| Error::Database(format!("数据库连接测试失败: {}", e)))?;

        Ok(())
    }

    /// 关闭数据库连接
    pub async fn close(&self) {
        self.pool.close().await;
        tracing::info!("数据库连接已关闭");
    }

    /// 获取数据库类型
    pub fn db_type(&self) -> &DatabaseType {
        &self.config.db_type
    }

    /// 执行原始 SQL 查询（用于迁移等操作）
    pub async fn execute_raw(&self, sql: &str) -> Result<()> {
        sqlx::query(sql)
            .execute(&self.pool)
            .await
            .map_err(|e| Error::Database(format!("SQL 执行失败: {}", e)))?;

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    #[ignore] // 需要实际的数据库连接
    async fn test_database_connection() {
        let config = DatabaseConfig {
            enabled: true,
            db_type: DatabaseType::Sqlite,
            url: "sqlite::memory:".to_string(),
            max_connections: 5,
            min_connections: 1,
            connect_timeout: 30,
            auto_migrate: false,
        };

        let db = Database::from_config(config).await;
        assert!(db.is_ok());

        if let Ok(db) = db {
            assert!(db.ping().await.is_ok());
        }
    }
}