parsql_deadpool_postgres/
pool_extensions.rs

1use deadpool_postgres::Pool;
2use postgres::types::FromSql;
3use tokio_postgres::{Error, Row};
4use crate::traits::{SqlQuery, SqlParams, UpdateParams, FromRow, CrudOps};
5
6// Daha basit bir yaklaşım: PoolError'dan genel bir Error oluştur
7fn pool_err_to_io_err(e: deadpool_postgres::PoolError) -> Error {
8    // Bu özel fonksiyon tokio_postgres'in sağladığı timeout hatasını döndürür
9    // Güzel bir çözüm değil, ama çalışır bir örnek için kullanılabilir
10    let err = Error::__private_api_timeout();
11    
12    // Debug süreci için stderr'e hatayı yazdıralım
13    eprintln!("Pool bağlantı hatası: {}", e);
14    
15    err
16}
17
18/// Pool nesnesi için CrudOps trait'inin implementasyonu
19#[async_trait::async_trait]
20impl CrudOps for Pool {
21    async fn insert<T, P:for<'a> FromSql<'a> + Send + Sync>(&self, entity: T) -> Result<P, Error>
22    where
23        T: SqlQuery + SqlParams + Send + Sync
24    {
25        let client = self.get().await.map_err(pool_err_to_io_err)?;
26        let sql = T::query();
27        
28        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
29            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
30        }
31
32        let params = entity.params();
33        let row = client.query_one(&sql, &params).await?;
34        row.try_get::<_, P>(0)
35    }
36
37    async fn update<T>(&self, entity: T) -> Result<u64, Error>
38    where
39        T: SqlQuery + UpdateParams + Send + Sync
40    {
41        let client = self.get().await.map_err(pool_err_to_io_err)?;
42        let sql = T::query();
43        
44        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
45            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
46        }
47
48        let params = entity.params();
49        client.execute(&sql, &params).await
50    }
51
52    async fn delete<T>(&self, entity: T) -> Result<u64, Error>
53    where
54        T: SqlQuery + SqlParams + Send + Sync
55    {
56        let client = self.get().await.map_err(pool_err_to_io_err)?;
57        let sql = T::query();
58        
59        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
60            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
61        }
62
63        let params = entity.params();
64        client.execute(&sql, &params).await
65    }
66
67    async fn fetch<T>(&self, params: &T) -> Result<T, Error>
68    where
69        T: SqlQuery + FromRow + SqlParams + Send + Sync
70    {
71        let client = self.get().await.map_err(pool_err_to_io_err)?;
72        let sql = T::query();
73        
74        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
75            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
76        }
77
78        let query_params = params.params();
79        let row = client.query_one(&sql, &query_params).await?;
80        T::from_row(&row)
81    }
82
83    async fn fetch_all<T>(&self, params: &T) -> Result<Vec<T>, Error>
84    where
85        T: SqlQuery + FromRow + SqlParams + Send + Sync
86    {
87        let client = self.get().await.map_err(pool_err_to_io_err)?;
88        let sql = T::query();
89        
90        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
91            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
92        }
93
94        let query_params = params.params();
95        let rows = client.query(&sql, &query_params).await?;
96        
97        let mut results = Vec::with_capacity(rows.len());
98        for row in rows {
99            results.push(T::from_row(&row)?);
100        }
101        
102        Ok(results)
103    }
104
105    async fn select<T, R, F>(&self, entity: T, to_model: F) -> Result<R, Error>
106    where
107        T: SqlQuery + SqlParams + Send + Sync,
108        F: FnOnce(&Row) -> Result<R, Error> + Send + Sync
109    {
110        let client = self.get().await.map_err(pool_err_to_io_err)?;
111        let sql = T::query();
112        
113        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
114            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
115        }
116
117        let params = entity.params();
118        let row = client.query_one(&sql, &params).await?;
119        to_model(&row)
120    }
121
122    async fn select_all<T, R, F>(&self, entity: T, to_model: F) -> Result<Vec<R>, Error>
123    where
124        T: SqlQuery + SqlParams + Send + Sync,
125        F: Fn(&Row) -> R + Send + Sync
126    {
127        let client = self.get().await.map_err(pool_err_to_io_err)?;
128        let sql = T::query();
129        
130        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
131            println!("[PARSQL-TOKIO-POSTGRES-POOL] Execute SQL: {}", sql);
132        }
133
134        let params = entity.params();
135        let rows = client.query(&sql, &params).await?;
136        
137        let mut results = Vec::with_capacity(rows.len());
138        for row in rows {
139            results.push(to_model(&row));
140        }
141        
142        Ok(results)
143    }
144}
parsql_deadpool_postgres/pool_extensions.rs

parsql_deadpool_postgres/
pool_extensions.rs
