tokio_postgres/
generic_client.rs

1use crate::query::RowStream;
2use crate::types::{BorrowToSql, ToSql, Type};
3use crate::{Client, Error, Row, SimpleQueryMessage, Statement, ToStatement, Transaction};
4use async_trait::async_trait;
5
6mod private {
7    pub trait Sealed {}
8}
9
10/// A trait allowing abstraction over connections and transactions.
11///
12/// This trait is "sealed", and cannot be implemented outside of this crate.
13#[async_trait]
14pub trait GenericClient: private::Sealed {
15    /// Like [`Client::execute`].
16    async fn execute<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
17    where
18        T: ?Sized + ToStatement + Sync + Send;
19
20    /// Like [`Client::execute_raw`].
21    async fn execute_raw<P, I, T>(&self, statement: &T, params: I) -> Result<u64, Error>
22    where
23        T: ?Sized + ToStatement + Sync + Send,
24        P: BorrowToSql,
25        I: IntoIterator<Item = P> + Sync + Send,
26        I::IntoIter: ExactSizeIterator;
27
28    /// Like [`Client::execute_typed`].
29    async fn execute_typed(
30        &self,
31        statement: &str,
32        params: &[(&(dyn ToSql + Sync), Type)],
33    ) -> Result<u64, Error>;
34
35    /// Like [`Client::query`].
36    async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
37    where
38        T: ?Sized + ToStatement + Sync + Send;
39
40    /// Like [`Client::query_one`].
41    async fn query_one<T>(
42        &self,
43        statement: &T,
44        params: &[&(dyn ToSql + Sync)],
45    ) -> Result<Row, Error>
46    where
47        T: ?Sized + ToStatement + Sync + Send;
48
49    /// Like [`Client::query_opt`].
50    async fn query_opt<T>(
51        &self,
52        statement: &T,
53        params: &[&(dyn ToSql + Sync)],
54    ) -> Result<Option<Row>, Error>
55    where
56        T: ?Sized + ToStatement + Sync + Send;
57
58    /// Like [`Client::query_raw`].
59    async fn query_raw<T, P, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
60    where
61        T: ?Sized + ToStatement + Sync + Send,
62        P: BorrowToSql,
63        I: IntoIterator<Item = P> + Sync + Send,
64        I::IntoIter: ExactSizeIterator;
65
66    /// Like [`Client::query_typed`]
67    async fn query_typed(
68        &self,
69        statement: &str,
70        params: &[(&(dyn ToSql + Sync), Type)],
71    ) -> Result<Vec<Row>, Error>;
72
73    /// Like [`Client::query_one_typed`].
74    async fn query_typed_one(
75        &self,
76        statement: &str,
77        params: &[(&(dyn ToSql + Sync), Type)],
78    ) -> Result<Row, Error>;
79
80    /// Like [`Client::query_opt_typed`].
81    async fn query_typed_opt(
82        &self,
83        statement: &str,
84        params: &[(&(dyn ToSql + Sync), Type)],
85    ) -> Result<Option<Row>, Error>;
86
87    /// Like [`Client::query_typed_raw`]
88    async fn query_typed_raw<P, I>(&self, statement: &str, params: I) -> Result<RowStream, Error>
89    where
90        P: BorrowToSql,
91        I: IntoIterator<Item = (P, Type)> + Sync + Send;
92
93    /// Like [`Client::prepare`].
94    async fn prepare(&self, query: &str) -> Result<Statement, Error>;
95
96    /// Like [`Client::prepare_typed`].
97    async fn prepare_typed(
98        &self,
99        query: &str,
100        parameter_types: &[Type],
101    ) -> Result<Statement, Error>;
102
103    /// Like [`Client::transaction`].
104    async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error>;
105
106    /// Like [`Client::batch_execute`].
107    async fn batch_execute(&self, query: &str) -> Result<(), Error>;
108
109    /// Like [`Client::simple_query`].
110    async fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error>;
111
112    /// Returns a reference to the underlying [`Client`].
113    fn client(&self) -> &Client;
114}
115
116impl private::Sealed for Client {}
117
118#[async_trait]
119impl GenericClient for Client {
120    async fn execute<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
121    where
122        T: ?Sized + ToStatement + Sync + Send,
123    {
124        self.execute(query, params).await
125    }
126
127    async fn execute_typed(
128        &self,
129        statement: &str,
130        params: &[(&(dyn ToSql + Sync), Type)],
131    ) -> Result<u64, Error> {
132        self.execute_typed(statement, params).await
133    }
134
135    async fn execute_raw<P, I, T>(&self, statement: &T, params: I) -> Result<u64, Error>
136    where
137        T: ?Sized + ToStatement + Sync + Send,
138        P: BorrowToSql,
139        I: IntoIterator<Item = P> + Sync + Send,
140        I::IntoIter: ExactSizeIterator,
141    {
142        self.execute_raw(statement, params).await
143    }
144
145    async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
146    where
147        T: ?Sized + ToStatement + Sync + Send,
148    {
149        self.query(query, params).await
150    }
151
152    async fn query_one<T>(
153        &self,
154        statement: &T,
155        params: &[&(dyn ToSql + Sync)],
156    ) -> Result<Row, Error>
157    where
158        T: ?Sized + ToStatement + Sync + Send,
159    {
160        self.query_one(statement, params).await
161    }
162
163    async fn query_opt<T>(
164        &self,
165        statement: &T,
166        params: &[&(dyn ToSql + Sync)],
167    ) -> Result<Option<Row>, Error>
168    where
169        T: ?Sized + ToStatement + Sync + Send,
170    {
171        self.query_opt(statement, params).await
172    }
173
174    async fn query_raw<T, P, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
175    where
176        T: ?Sized + ToStatement + Sync + Send,
177        P: BorrowToSql,
178        I: IntoIterator<Item = P> + Sync + Send,
179        I::IntoIter: ExactSizeIterator,
180    {
181        self.query_raw(statement, params).await
182    }
183
184    async fn query_typed(
185        &self,
186        statement: &str,
187        params: &[(&(dyn ToSql + Sync), Type)],
188    ) -> Result<Vec<Row>, Error> {
189        self.query_typed(statement, params).await
190    }
191
192    async fn query_typed_one(
193        &self,
194        statement: &str,
195        params: &[(&(dyn ToSql + Sync), Type)],
196    ) -> Result<Row, Error> {
197        self.query_typed_one(statement, params).await
198    }
199
200    /// Like [`Client::query_opt_typed`].
201    async fn query_typed_opt(
202        &self,
203        statement: &str,
204        params: &[(&(dyn ToSql + Sync), Type)],
205    ) -> Result<Option<Row>, Error> {
206        self.query_typed_opt(statement, params).await
207    }
208
209    async fn query_typed_raw<P, I>(&self, statement: &str, params: I) -> Result<RowStream, Error>
210    where
211        P: BorrowToSql,
212        I: IntoIterator<Item = (P, Type)> + Sync + Send,
213    {
214        self.query_typed_raw(statement, params).await
215    }
216
217    async fn prepare(&self, query: &str) -> Result<Statement, Error> {
218        self.prepare(query).await
219    }
220
221    async fn prepare_typed(
222        &self,
223        query: &str,
224        parameter_types: &[Type],
225    ) -> Result<Statement, Error> {
226        self.prepare_typed(query, parameter_types).await
227    }
228
229    async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
230        self.transaction().await
231    }
232
233    async fn batch_execute(&self, query: &str) -> Result<(), Error> {
234        self.batch_execute(query).await
235    }
236
237    async fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
238        self.simple_query(query).await
239    }
240
241    fn client(&self) -> &Client {
242        self
243    }
244}
245
246impl private::Sealed for Transaction<'_> {}
247
248#[async_trait]
249#[allow(clippy::needless_lifetimes)]
250impl GenericClient for Transaction<'_> {
251    async fn execute<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
252    where
253        T: ?Sized + ToStatement + Sync + Send,
254    {
255        self.execute(query, params).await
256    }
257
258    async fn execute_raw<P, I, T>(&self, statement: &T, params: I) -> Result<u64, Error>
259    where
260        T: ?Sized + ToStatement + Sync + Send,
261        P: BorrowToSql,
262        I: IntoIterator<Item = P> + Sync + Send,
263        I::IntoIter: ExactSizeIterator,
264    {
265        self.execute_raw(statement, params).await
266    }
267
268    async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
269    where
270        T: ?Sized + ToStatement + Sync + Send,
271    {
272        self.query(query, params).await
273    }
274
275    async fn query_one<T>(
276        &self,
277        statement: &T,
278        params: &[&(dyn ToSql + Sync)],
279    ) -> Result<Row, Error>
280    where
281        T: ?Sized + ToStatement + Sync + Send,
282    {
283        self.query_one(statement, params).await
284    }
285
286    async fn query_opt<T>(
287        &self,
288        statement: &T,
289        params: &[&(dyn ToSql + Sync)],
290    ) -> Result<Option<Row>, Error>
291    where
292        T: ?Sized + ToStatement + Sync + Send,
293    {
294        self.query_opt(statement, params).await
295    }
296
297    async fn query_raw<T, P, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
298    where
299        T: ?Sized + ToStatement + Sync + Send,
300        P: BorrowToSql,
301        I: IntoIterator<Item = P> + Sync + Send,
302        I::IntoIter: ExactSizeIterator,
303    {
304        self.query_raw(statement, params).await
305    }
306
307    async fn query_typed(
308        &self,
309        statement: &str,
310        params: &[(&(dyn ToSql + Sync), Type)],
311    ) -> Result<Vec<Row>, Error> {
312        self.query_typed(statement, params).await
313    }
314
315    async fn query_typed_one(
316        &self,
317        statement: &str,
318        params: &[(&(dyn ToSql + Sync), Type)],
319    ) -> Result<Row, Error> {
320        self.query_typed_one(statement, params).await
321    }
322
323    /// Like [`Client::query_opt_typed`].
324    async fn query_typed_opt(
325        &self,
326        statement: &str,
327        params: &[(&(dyn ToSql + Sync), Type)],
328    ) -> Result<Option<Row>, Error> {
329        self.query_typed_opt(statement, params).await
330    }
331
332    async fn query_typed_raw<P, I>(&self, statement: &str, params: I) -> Result<RowStream, Error>
333    where
334        P: BorrowToSql,
335        I: IntoIterator<Item = (P, Type)> + Sync + Send,
336    {
337        self.query_typed_raw(statement, params).await
338    }
339
340    async fn prepare(&self, query: &str) -> Result<Statement, Error> {
341        self.prepare(query).await
342    }
343
344    async fn prepare_typed(
345        &self,
346        query: &str,
347        parameter_types: &[Type],
348    ) -> Result<Statement, Error> {
349        self.prepare_typed(query, parameter_types).await
350    }
351
352    #[allow(clippy::needless_lifetimes)]
353    async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
354        self.transaction().await
355    }
356
357    async fn batch_execute(&self, query: &str) -> Result<(), Error> {
358        self.batch_execute(query).await
359    }
360
361    async fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
362        self.simple_query(query).await
363    }
364
365    fn client(&self) -> &Client {
366        self.client()
367    }
368
369    async fn execute_typed(
370        &self,
371        statement: &str,
372        params: &[(&(dyn ToSql + Sync), Type)],
373    ) -> Result<u64, Error> {
374        self.client().execute_typed(statement, params).await
375    }
376}
tokio_postgres/generic_client.rs

tokio_postgres/
generic_client.rs
