burncloud-database-impl 0.1.0

Database implementations for multiple backends (PostgreSQL, MySQL, SQLite, MongoDB) 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

#[cfg(feature = "mongodb_support")]
use mongodb::{Client, Database};
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::collections::HashMap;

#[cfg(feature = "mongodb_support")]
pub struct MongoDBConnection {
    client: Option<Client>,
    database: Option<Database>,
    connection_string: String,
    database_name: String,
}

#[cfg(feature = "mongodb_support")]
impl MongoDBConnection {
    pub fn new(connection_string: String, database_name: String) -> Self {
        Self {
            client: None,
            database: None,
            connection_string,
            database_name,
        }
    }
}

#[cfg(feature = "mongodb_support")]
#[async_trait]
impl DatabaseConnection for MongoDBConnection {
    async fn connect(&mut self) -> DatabaseResult<()> {
        let client = Client::with_uri_str(&self.connection_string).await
            .map_err(|e| DatabaseError::ConnectionFailed(e.to_string()))?;

        let database = client.database(&self.database_name);

        self.client = Some(client);
        self.database = Some(database);
        Ok(())
    }

    async fn disconnect(&mut self) -> DatabaseResult<()> {
        self.client = None;
        self.database = None;
        Ok(())
    }

    async fn is_connected(&self) -> bool {
        self.client.is_some() && self.database.is_some()
    }

    async fn ping(&self) -> DatabaseResult<()> {
        if let Some(database) = &self.database {
            database.run_command(mongodb::bson::doc! { "ping": 1 }).await
                .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
            Ok(())
        } else {
            Err(DatabaseError::ConnectionFailed("Not connected".to_string()))
        }
    }
}

#[cfg(feature = "mongodb_support")]
#[async_trait]
impl QueryExecutor for MongoDBConnection {
    async fn execute_query(
        &self,
        _query: &str,
        _params: &[&dyn QueryParam],
        _context: &QueryContext,
    ) -> DatabaseResult<QueryResult> {
        Ok(QueryResult {
            rows: Vec::new(),
            rows_affected: 0,
            last_insert_id: None,
        })
    }

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

#[cfg(feature = "mongodb_support")]
pub struct MongoDBTransaction {
    // Simplified for example
}

#[cfg(feature = "mongodb_support")]
#[async_trait]
impl Transaction for MongoDBTransaction {
    async fn commit(self) -> DatabaseResult<()> {
        Ok(())
    }

    async fn rollback(self) -> DatabaseResult<()> {
        Ok(())
    }

    async fn execute_query(
        &self,
        _query: &str,
        _params: &[&dyn QueryParam],
    ) -> DatabaseResult<QueryResult> {
        Ok(QueryResult {
            rows: Vec::new(),
            rows_affected: 0,
            last_insert_id: None,
        })
    }
}

#[cfg(feature = "mongodb_support")]
#[async_trait]
impl TransactionManager for MongoDBConnection {
    type Transaction = MongoDBTransaction;

    async fn begin_transaction(&self, _context: &QueryContext) -> DatabaseResult<Self::Transaction> {
        Ok(MongoDBTransaction {})
    }
}