burncloud-database-client 0.1.1

High-level database client with migrations, pooling, and AI model management for BurnCloud
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
125
126
127
128
129
130
131

use burncloud_database_core::{
    DatabaseConnection, QueryExecutor, TransactionManager, Transaction,
    QueryContext, QueryOptions, QueryResult, QueryParam
};
use burncloud_database_core::error::{DatabaseResult, DatabaseError};
use async_trait::async_trait;
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{info, error, debug};

pub struct DatabaseClient {
    connection: Arc<RwLock<Box<dyn DatabaseConnection>>>,
    query_executor: Arc<Box<dyn QueryExecutor>>,
}

impl DatabaseClient {
    pub fn new(
        connection: Box<dyn DatabaseConnection>,
        query_executor: Box<dyn QueryExecutor>,
    ) -> Self {
        Self {
            connection: Arc::new(RwLock::new(connection)),
            query_executor: Arc::new(query_executor),
        }
    }

    pub async fn connect(&self) -> DatabaseResult<()> {
        let mut conn = self.connection.write().await;
        info!("Connecting to database...");
        conn.connect().await?;
        info!("Successfully connected to database");
        Ok(())
    }

    pub async fn disconnect(&self) -> DatabaseResult<()> {
        let mut conn = self.connection.write().await;
        info!("Disconnecting from database...");
        conn.disconnect().await?;
        info!("Successfully disconnected from database");
        Ok(())
    }

    pub async fn is_connected(&self) -> bool {
        let conn = self.connection.read().await;
        conn.is_connected().await
    }

    pub async fn ping(&self) -> DatabaseResult<()> {
        let conn = self.connection.read().await;
        debug!("Pinging database...");
        conn.ping().await?;
        debug!("Database ping successful");
        Ok(())
    }

    pub async fn execute_query(
        &self,
        query: &str,
        params: &[&dyn QueryParam],
        context: &QueryContext,
    ) -> DatabaseResult<QueryResult> {
        debug!("Executing query: {}", query);
        let result = self.query_executor.execute_query(query, params, context).await;

        match &result {
            Ok(res) => debug!("Query executed successfully, {} rows returned", res.rows.len()),
            Err(e) => error!("Query execution failed: {}", e),
        }

        result
    }

    pub async fn execute_query_with_options(
        &self,
        query: &str,
        params: &[&dyn QueryParam],
        options: &QueryOptions,
        context: &QueryContext,
    ) -> DatabaseResult<QueryResult> {
        debug!("Executing query with options: {}", query);
        let result = self.query_executor.execute_query_with_options(query, params, options, context).await;

        match &result {
            Ok(res) => debug!("Query with options executed successfully, {} rows returned", res.rows.len()),
            Err(e) => error!("Query with options execution failed: {}", e),
        }

        result
    }
}

#[async_trait]
impl DatabaseConnection for DatabaseClient {
    async fn connect(&mut self) -> DatabaseResult<()> {
        self.connect().await
    }

    async fn disconnect(&mut self) -> DatabaseResult<()> {
        self.disconnect().await
    }

    async fn is_connected(&self) -> bool {
        self.is_connected().await
    }

    async fn ping(&self) -> DatabaseResult<()> {
        self.ping().await
    }
}

#[async_trait]
impl QueryExecutor for DatabaseClient {
    async fn execute_query(
        &self,
        query: &str,
        params: &[&dyn QueryParam],
        context: &QueryContext,
    ) -> DatabaseResult<QueryResult> {
        self.execute_query(query, params, context).await
    }

    async fn execute_query_with_options(
        &self,
        query: &str,
        params: &[&dyn QueryParam],
        options: &QueryOptions,
        context: &QueryContext,
    ) -> DatabaseResult<QueryResult> {
        self.execute_query_with_options(query, params, options, context).await
    }
}