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, ¶ms)
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, ¶ms)
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, ¶ms)
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, ¶ms)?;
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, ¶ms)?;
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, ¶ms)?;
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, ¶ms)?;
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}