parsql_postgres/
transaction_ops.rs

1use postgres::{Transaction, Error, Row};
2use crate::{SqlQuery, SqlParams, FromRow, UpdateParams, CrudOps};
3
4/// CrudOps trait implementasyonu Transaction<'_> için.
5/// Bu sayede transaction içinde tüm CRUD işlemleri extension metotları olarak kullanılabilir.
6impl<'a> CrudOps for Transaction<'a> {
7    fn insert<T: SqlQuery + SqlParams>(&mut self, entity: T) -> Result<u64, Error> {
8        let sql = T::query();
9        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
10            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
11        }
12
13        let params = entity.params();
14        self.execute(&sql, &params)
15    }
16
17    fn update<T: SqlQuery + UpdateParams>(&mut self, entity: T) -> Result<u64, Error> {
18        let sql = T::query();
19        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
20            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
21        }
22
23        let params = entity.params();
24        self.execute(&sql, &params)
25    }
26
27    fn delete<T: SqlQuery + SqlParams>(&mut self, entity: T) -> Result<u64, Error> {
28        let sql = T::query();
29        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
30            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
31        }
32
33        let params = entity.params();
34        self.execute(&sql, &params)
35    }
36
37    fn get<T: SqlQuery + FromRow + SqlParams>(&mut self, entity: &T) -> Result<T, Error> {
38        let sql = T::query();
39        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
40            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
41        }
42        
43        let params = entity.params();
44        let row = self.query_one(&sql, &params)?;
45        T::from_row(&row)
46    }
47
48    fn get_all<T: SqlQuery + FromRow + SqlParams>(&mut self, entity: &T) -> Result<Vec<T>, Error> {
49        let sql = T::query();
50        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
51            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
52        }
53        
54        let params = entity.params();
55        let rows = self.query(&sql, &params)?;
56        
57        rows.iter()
58            .map(|row| T::from_row(row))
59            .collect::<Result<Vec<_>, _>>()
60    }
61
62    fn select<T, F, R>(&mut self, entity: &T, to_model: F) -> Result<R, Error>
63    where
64        T: SqlQuery + SqlParams,
65        F: FnOnce(&Row) -> Result<R, Error>,
66    {
67        let sql = T::query();
68        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
69            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
70        }
71
72        let params = entity.params();
73        let row = self.query_one(&sql, &params)?;
74        to_model(&row)
75    }
76
77    fn select_all<T, F, R>(&mut self, entity: &T, to_model: F) -> Result<Vec<R>, Error>
78    where
79        T: SqlQuery + SqlParams,
80        F: FnMut(&Row) -> Result<R, Error>,
81    {
82        let sql = T::query();
83        if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
84            println!("[PARSQL-POSTGRES] Execute SQL (Transaction): {}", sql);
85        }
86
87        let params = entity.params();
88        let rows = self.query(&sql, &params)?;
89        
90        rows.iter().map(to_model).collect()
91    }
92}
93
94/// # begin
95/// 
96/// Yeni bir transaction başlatır.
97/// 
98/// ## Parametreler
99/// - `client`: Veritabanı bağlantı istemcisi
100/// 
101/// ## Dönüş Değeri
102/// - `Result<Transaction<'_>, Error>`: Başarılı olursa, yeni bir transaction nesnesi döner; hata durumunda Error döner
103/// 
104/// ## Örnek Kullanım
105/// ```rust,no_run
106/// use postgres::{Client, NoTls, Error};
107/// use parsql::postgres::transactional::begin;
108/// 
109/// fn main() -> Result<(), Error> {
110///     let mut client = Client::connect(
111///         "host=localhost user=postgres dbname=test",
112///         NoTls,
113///     )?;
114///     
115///     // Transaction başlat
116///     let mut tx = begin(&mut client)?;
117///     
118///     // İşlemler...
119///     
120///     // Transaction'ı tamamla
121///     tx.commit()?;
122///     Ok(())
123/// }
124/// ```
125pub fn begin<'a>(client: &'a mut postgres::Client) -> Result<Transaction<'a>, Error> {
126    if std::env::var("PARSQL_TRACE").unwrap_or_default() == "1" {
127        println!("[PARSQL-POSTGRES] Begin Transaction");
128    }
129    client.transaction()
130}
131
132/// # tx_insert
133/// 
134/// Transaction içinde bir kaydı veritabanına ekler.
135/// 
136/// ## Parametreler
137/// - `tx`: Transaction nesnesi
138/// - `entity`: Eklenecek veri nesnesi (SqlQuery ve SqlParams trait'lerini implement etmeli)
139/// 
140/// ## Dönüş Değeri
141/// - `Result<(Transaction<'_>, u64), Error>`: Başarılı olursa, transaction ve etkilenen kayıt sayısını döner; hata durumunda Error döner
142/// 
143/// ## Örnek Kullanım
144/// ```rust,no_run
145/// use postgres::{Client, NoTls, Error};
146/// use parsql::postgres::transactional::{begin, tx_insert};
147/// 
148/// #[derive(Insertable, SqlParams)]
149/// #[table("users")]
150/// pub struct InsertUser {
151///     pub name: String,
152///     pub email: String,
153/// }
154///
155/// fn main() -> Result<(), Error> {
156///     let mut client = Client::connect(
157///         "host=localhost user=postgres dbname=test",
158///         NoTls,
159///     )?;
160///     
161///     let mut tx = begin(&mut client)?;
162///     
163///     let insert_user = InsertUser {
164///         name: "John".to_string(),
165///         email: "john@example.com".to_string(),
166///     };
167///     
168///     let (tx, rows_affected) = tx_insert(tx, insert_user)?;
169///     
170///     // İşlemler devam edebilir...
171///     
172///     // Transaction'ı tamamla
173///     tx.commit()?;
174///     Ok(())
175/// }
176/// ```
177pub fn tx_insert<'a, T>(mut tx: Transaction<'a>, entity: T) -> Result<(Transaction<'a>, u64), Error>
178where
179    T: SqlQuery + SqlParams,
180{
181    let result = tx.insert(entity)?;
182    Ok((tx, result))
183}
184
185/// # tx_update
186/// 
187/// Transaction içinde bir kaydı günceller.
188/// 
189/// ## Parametreler
190/// - `tx`: Transaction nesnesi
191/// - `entity`: Güncellenecek veri nesnesi (SqlQuery ve UpdateParams trait'lerini implement etmeli)
192/// 
193/// ## Dönüş Değeri
194/// - `Result<(Transaction<'_>, u64), Error>`: Başarılı olursa, transaction ve etkilenen kayıt sayısını döner; hata durumunda Error döner
195/// 
196/// ## Örnek Kullanım
197/// ```rust,no_run
198/// use postgres::{Client, NoTls, Error};
199/// use parsql::postgres::transactional::{begin, tx_update};
200/// 
201/// #[derive(Updateable, UpdateParams)]
202/// #[table("users")]
203/// #[update("name, email")]
204/// #[where_clause("id = $")]
205/// pub struct UpdateUser {
206///     pub id: i32,
207///     pub name: String,
208///     pub email: String,
209/// }
210///
211/// fn main() -> Result<(), Error> {
212///     let mut client = Client::connect(
213///         "host=localhost user=postgres dbname=test",
214///         NoTls,
215///     )?;
216///     
217///     let mut tx = begin(&mut client)?;
218///     
219///     let update_user = UpdateUser {
220///         id: 1,
221///         name: "John Updated".to_string(),
222///         email: "john.updated@example.com".to_string(),
223///     };
224///     
225///     let (tx, rows_affected) = tx_update(tx, update_user)?;
226///     
227///     // İşlemler devam edebilir...
228///     
229///     // Transaction'ı tamamla
230///     tx.commit()?;
231///     Ok(())
232/// }
233/// ```
234pub fn tx_update<'a, T>(mut tx: Transaction<'a>, entity: T) -> Result<(Transaction<'a>, u64), Error>
235where
236    T: SqlQuery + UpdateParams,
237{
238    let result = tx.update(entity)?;
239    Ok((tx, result))
240}
241
242/// # tx_delete
243/// 
244/// Transaction içinde bir kaydı siler.
245/// 
246/// ## Parametreler
247/// - `tx`: Transaction nesnesi
248/// - `entity`: Silinecek veri nesnesi (SqlQuery ve SqlParams trait'lerini implement etmeli)
249/// 
250/// ## Dönüş Değeri
251/// - `Result<(Transaction<'_>, u64), Error>`: Başarılı olursa, transaction ve etkilenen kayıt sayısını döner; hata durumunda Error döner
252/// 
253/// ## Örnek Kullanım
254/// ```rust,no_run
255/// use postgres::{Client, NoTls, Error};
256/// use parsql::postgres::transactional::{begin, tx_delete};
257/// 
258/// #[derive(Deletable, SqlParams)]
259/// #[table("users")]
260/// #[where_clause("id = $")]
261/// pub struct DeleteUser {
262///     pub id: i32,
263/// }
264///
265/// fn main() -> Result<(), Error> {
266///     let mut client = Client::connect(
267///         "host=localhost user=postgres dbname=test",
268///         NoTls,
269///     )?;
270///     
271///     let mut tx = begin(&mut client)?;
272///     
273///     let delete_user = DeleteUser { id: 1 };
274///     
275///     let (tx, rows_affected) = tx_delete(tx, delete_user)?;
276///     
277///     // İşlemler devam edebilir...
278///     
279///     // Transaction'ı tamamla
280///     tx.commit()?;
281///     Ok(())
282/// }
283/// ```
284pub fn tx_delete<'a, T>(mut tx: Transaction<'a>, entity: T) -> Result<(Transaction<'a>, u64), Error>
285where
286    T: SqlQuery + SqlParams,
287{
288    let result = tx.delete(entity)?;
289    Ok((tx, result))
290}
291
292/// # tx_get
293/// 
294/// Transaction içinde bir kaydı getirir.
295/// 
296/// ## Parametreler
297/// - `tx`: Transaction nesnesi
298/// - `entity`: Sorgu parametresi nesnesi (SqlQuery, FromRow ve SqlParams trait'lerini implement etmeli)
299/// 
300/// ## Dönüş Değeri
301/// - `Result<(Transaction<'_>, T), Error>`: Başarılı olursa, transaction ve bulunan kaydı döner; hata durumunda Error döner
302/// 
303/// ## Örnek Kullanım
304/// ```rust,no_run
305/// use postgres::{Client, NoTls, Error};
306/// use parsql::postgres::transactional::{begin, tx_get};
307/// 
308/// #[derive(Queryable, FromRow, SqlParams)]
309/// #[table("users")]
310/// #[where_clause("id = $")]
311/// pub struct GetUser {
312///     pub id: i32,
313///     pub name: String,
314///     pub email: String,
315/// }
316///
317/// fn main() -> Result<(), Error> {
318///     let mut client = Client::connect(
319///         "host=localhost user=postgres dbname=test",
320///         NoTls,
321///     )?;
322///     
323///     let mut tx = begin(&mut client)?;
324///     
325///     let get_user = GetUser {
326///         id: 1,
327///         name: String::new(),
328///         email: String::new(),
329///     };
330///     
331///     let (tx, user) = tx_get(tx, &get_user)?;
332///     
333///     // İşlemler devam edebilir...
334///     
335///     // Transaction'ı tamamla
336///     tx.commit()?;
337///     Ok(())
338/// }
339/// ```
340pub fn tx_get<'a, T>(mut tx: Transaction<'a>, entity: &T) -> Result<(Transaction<'a>, T), Error>
341where
342    T: SqlQuery + FromRow + SqlParams,
343{
344    let result = tx.get(entity)?;
345    Ok((tx, result))
346}
347
348/// # tx_get_all
349/// 
350/// Transaction içinde birden fazla kaydı getirir.
351/// 
352/// ## Parametreler
353/// - `tx`: Transaction nesnesi
354/// - `entity`: Sorgu parametresi nesnesi (SqlQuery, FromRow ve SqlParams trait'lerini implement etmeli)
355/// 
356/// ## Dönüş Değeri
357/// - `Result<(Transaction<'_>, Vec<T>), Error>`: Başarılı olursa, transaction ve bulunan kayıtların listesini döner; hata durumunda Error döner
358/// 
359/// ## Örnek Kullanım
360/// ```rust,no_run
361/// use postgres::{Client, NoTls, Error};
362/// use parsql::postgres::transactional::{begin, tx_get_all};
363/// 
364/// #[derive(Queryable, FromRow, SqlParams)]
365/// #[table("users")]
366/// #[where_clause("active = $")]
367/// pub struct GetUsers {
368///     pub active: bool,
369///     pub id: i32,
370///     pub name: String,
371///     pub email: String,
372/// }
373///
374/// fn main() -> Result<(), Error> {
375///     let mut client = Client::connect(
376///         "host=localhost user=postgres dbname=test",
377///         NoTls,
378///     )?;
379///     
380///     let mut tx = begin(&mut client)?;
381///     
382///     let get_users = GetUsers {
383///         active: true,
384///         id: 0,
385///         name: String::new(),
386///         email: String::new(),
387///     };
388///     
389///     let (tx, users) = tx_get_all(tx, &get_users)?;
390///     
391///     // İşlemler devam edebilir...
392///     
393///     // Transaction'ı tamamla
394///     tx.commit()?;
395///     Ok(())
396/// }
397/// ```
398pub fn tx_get_all<'a, T>(mut tx: Transaction<'a>, entity: &T) -> Result<(Transaction<'a>, Vec<T>), Error>
399where
400    T: SqlQuery + FromRow + SqlParams,
401{
402    let result = tx.get_all(entity)?;
403    Ok((tx, result))
404}
405
406/// # tx_select
407/// 
408/// Transaction içinde özel bir sorgu çalıştırır ve sonucu dönüştürür.
409/// 
410/// ## Parametreler
411/// - `tx`: Transaction nesnesi
412/// - `entity`: Sorgu parametresi nesnesi (SqlQuery ve SqlParams trait'lerini implement etmeli)
413/// - `to_model`: Row nesnesini hedef nesne tipine dönüştüren fonksiyon
414/// 
415/// ## Dönüş Değeri
416/// - `Result<(Transaction<'_>, R), Error>`: Başarılı olursa, transaction ve dönüştürülmüş nesneyi döner; hata durumunda Error döner
417pub fn tx_select<'a, T, F, R>(mut tx: Transaction<'a>, entity: &T, to_model: F) -> Result<(Transaction<'a>, R), Error>
418where
419    T: SqlQuery + SqlParams,
420    F: FnOnce(&Row) -> Result<R, Error>,
421{
422    let result = tx.select(entity, to_model)?;
423    Ok((tx, result))
424}
425
426/// # tx_select_all
427/// 
428/// Transaction içinde özel bir sorgu çalıştırır ve tüm sonuçları dönüştürür.
429/// 
430/// ## Parametreler
431/// - `tx`: Transaction nesnesi
432/// - `entity`: Sorgu parametresi nesnesi (SqlQuery ve SqlParams trait'lerini implement etmeli)
433/// - `to_model`: Row nesnesini hedef nesne tipine dönüştüren fonksiyon
434/// 
435/// ## Dönüş Değeri
436/// - `Result<(Transaction<'_>, Vec<R>), Error>`: Başarılı olursa, transaction ve dönüştürülmüş nesnelerin listesini döner; hata durumunda Error döner
437pub fn tx_select_all<'a, T, F, R>(mut tx: Transaction<'a>, entity: &T, to_model: F) -> Result<(Transaction<'a>, Vec<R>), Error>
438where
439    T: SqlQuery + SqlParams,
440    F: FnMut(&Row) -> Result<R, Error>,
441{
442    let result = tx.select_all(entity, to_model)?;
443    Ok((tx, result))
444}
parsql_postgres/transaction_ops.rs

parsql_postgres/
transaction_ops.rs
