burncloud_database_impl/
sqlite.rs

1#[cfg(feature = "sqlite")]
2use rusqlite::{Connection, params};
3use burncloud_database_core::{
4    DatabaseConnection, QueryExecutor,
5    TransactionManager, Transaction, QueryContext, QueryOptions, QueryResult, QueryParam
6};
7use burncloud_database_core::error::{DatabaseResult, DatabaseError};
8use async_trait::async_trait;
9use std::collections::HashMap;
10use std::sync::{Arc, Mutex};
11
12#[cfg(feature = "sqlite")]
13pub struct SQLiteConnection {
14    connection: Option<Arc<Mutex<Connection>>>,
15    database_path: String,
16}
17
18#[cfg(feature = "sqlite")]
19impl SQLiteConnection {
20    pub fn new(database_path: String) -> Self {
21        Self {
22            connection: None,
23            database_path,
24        }
25    }
26}
27
28#[cfg(feature = "sqlite")]
29#[async_trait]
30impl DatabaseConnection for SQLiteConnection {
31    async fn connect(&mut self) -> DatabaseResult<()> {
32        let conn = Connection::open(&self.database_path)
33            .map_err(|e| DatabaseError::ConnectionFailed(e.to_string()))?;
34
35        self.connection = Some(Arc::new(Mutex::new(conn)));
36        Ok(())
37    }
38
39    async fn disconnect(&mut self) -> DatabaseResult<()> {
40        self.connection = None;
41        Ok(())
42    }
43
44    async fn is_connected(&self) -> bool {
45        self.connection.is_some()
46    }
47
48    async fn ping(&self) -> DatabaseResult<()> {
49        if let Some(conn) = &self.connection {
50            let conn = conn.lock().unwrap();
51            conn.execute("SELECT 1", [])
52                .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
53            Ok(())
54        } else {
55            Err(DatabaseError::ConnectionFailed("Not connected".to_string()))
56        }
57    }
58}
59
60#[cfg(feature = "sqlite")]
61#[async_trait]
62impl QueryExecutor for SQLiteConnection {
63    async fn execute_query(
64        &self,
65        _query: &str,
66        _params: &[&dyn QueryParam],
67        _context: &QueryContext,
68    ) -> DatabaseResult<QueryResult> {
69        Ok(QueryResult {
70            rows: Vec::new(),
71            rows_affected: 0,
72            last_insert_id: None,
73        })
74    }
75
76    async fn execute_query_with_options(
77        &self,
78        query: &str,
79        params: &[&dyn QueryParam],
80        _options: &QueryOptions,
81        context: &QueryContext,
82    ) -> DatabaseResult<QueryResult> {
83        self.execute_query(query, params, context).await
84    }
85}
86
87#[cfg(feature = "sqlite")]
88pub struct SQLiteTransaction {
89    // Simplified for example
90}
91
92#[cfg(feature = "sqlite")]
93#[async_trait]
94impl Transaction for SQLiteTransaction {
95    async fn commit(self) -> DatabaseResult<()> {
96        Ok(())
97    }
98
99    async fn rollback(self) -> DatabaseResult<()> {
100        Ok(())
101    }
102
103    async fn execute_query(
104        &self,
105        _query: &str,
106        _params: &[&dyn QueryParam],
107    ) -> DatabaseResult<QueryResult> {
108        Ok(QueryResult {
109            rows: Vec::new(),
110            rows_affected: 0,
111            last_insert_id: None,
112        })
113    }
114}
115
116#[cfg(feature = "sqlite")]
117#[async_trait]
118impl TransactionManager for SQLiteConnection {
119    type Transaction = SQLiteTransaction;
120
121    async fn begin_transaction(&self, _context: &QueryContext) -> DatabaseResult<Self::Transaction> {
122        Ok(SQLiteTransaction {})
123    }
124}
burncloud_database_impl/sqlite.rs

burncloud_database_impl/
sqlite.rs
