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::query`].
29    async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
30    where
31        T: ?Sized + ToStatement + Sync + Send;
32
33    /// Like [`Client::query_one`].
34    async fn query_one<T>(
35        &self,
36        statement: &T,
37        params: &[&(dyn ToSql + Sync)],
38    ) -> Result<Row, Error>
39    where
40        T: ?Sized + ToStatement + Sync + Send;
41
42    /// Like [`Client::query_opt`].
43    async fn query_opt<T>(
44        &self,
45        statement: &T,
46        params: &[&(dyn ToSql + Sync)],
47    ) -> Result<Option<Row>, Error>
48    where
49        T: ?Sized + ToStatement + Sync + Send;
50
51    /// Like [`Client::query_raw`].
52    async fn query_raw<T, P, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
53    where
54        T: ?Sized + ToStatement + Sync + Send,
55        P: BorrowToSql,
56        I: IntoIterator<Item = P> + Sync + Send,
57        I::IntoIter: ExactSizeIterator;
58
59    /// Like [`Client::query_typed`]
60    async fn query_typed(
61        &self,
62        statement: &str,
63        params: &[(&(dyn ToSql + Sync), Type)],
64    ) -> Result<Vec<Row>, Error>;
65
66    /// Like [`Client::query_typed_raw`]
67    async fn query_typed_raw<P, I>(&self, statement: &str, params: I) -> Result<RowStream, Error>
68    where
69        P: BorrowToSql,
70        I: IntoIterator<Item = (P, Type)> + Sync + Send;
71
72    /// Like [`Client::prepare`].
73    async fn prepare(&self, query: &str) -> Result<Statement, Error>;
74
75    /// Like [`Client::prepare_typed`].
76    async fn prepare_typed(
77        &self,
78        query: &str,
79        parameter_types: &[Type],
80    ) -> Result<Statement, Error>;
81
82    /// Like [`Client::transaction`].
83    async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error>;
84
85    /// Like [`Client::batch_execute`].
86    async fn batch_execute(&self, query: &str) -> Result<(), Error>;
87
88    /// Like [`Client::simple_query`].
89    async fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error>;
90
91    /// Returns a reference to the underlying [`Client`].
92    fn client(&self) -> &Client;
93}
94
95impl private::Sealed for Client {}
96
97#[async_trait]
98impl GenericClient for Client {
99    async fn execute<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
100    where
101        T: ?Sized + ToStatement + Sync + Send,
102    {
103        self.execute(query, params).await
104    }
105
106    async fn execute_raw<P, I, T>(&self, statement: &T, params: I) -> Result<u64, Error>
107    where
108        T: ?Sized + ToStatement + Sync + Send,
109        P: BorrowToSql,
110        I: IntoIterator<Item = P> + Sync + Send,
111        I::IntoIter: ExactSizeIterator,
112    {
113        self.execute_raw(statement, params).await
114    }
115
116    async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
117    where
118        T: ?Sized + ToStatement + Sync + Send,
119    {
120        self.query(query, params).await
121    }
122
123    async fn query_one<T>(
124        &self,
125        statement: &T,
126        params: &[&(dyn ToSql + Sync)],
127    ) -> Result<Row, Error>
128    where
129        T: ?Sized + ToStatement + Sync + Send,
130    {
131        self.query_one(statement, params).await
132    }
133
134    async fn query_opt<T>(
135        &self,
136        statement: &T,
137        params: &[&(dyn ToSql + Sync)],
138    ) -> Result<Option<Row>, Error>
139    where
140        T: ?Sized + ToStatement + Sync + Send,
141    {
142        self.query_opt(statement, params).await
143    }
144
145    async fn query_raw<T, P, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
146    where
147        T: ?Sized + ToStatement + Sync + Send,
148        P: BorrowToSql,
149        I: IntoIterator<Item = P> + Sync + Send,
150        I::IntoIter: ExactSizeIterator,
151    {
152        self.query_raw(statement, params).await
153    }
154
155    async fn query_typed(
156        &self,
157        statement: &str,
158        params: &[(&(dyn ToSql + Sync), Type)],
159    ) -> Result<Vec<Row>, Error> {
160        self.query_typed(statement, params).await
161    }
162
163    async fn query_typed_raw<P, I>(&self, statement: &str, params: I) -> Result<RowStream, Error>
164    where
165        P: BorrowToSql,
166        I: IntoIterator<Item = (P, Type)> + Sync + Send,
167    {
168        self.query_typed_raw(statement, params).await
169    }
170
171    async fn prepare(&self, query: &str) -> Result<Statement, Error> {
172        self.prepare(query).await
173    }
174
175    async fn prepare_typed(
176        &self,
177        query: &str,
178        parameter_types: &[Type],
179    ) -> Result<Statement, Error> {
180        self.prepare_typed(query, parameter_types).await
181    }
182
183    async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
184        self.transaction().await
185    }
186
187    async fn batch_execute(&self, query: &str) -> Result<(), Error> {
188        self.batch_execute(query).await
189    }
190
191    async fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
192        self.simple_query(query).await
193    }
194
195    fn client(&self) -> &Client {
196        self
197    }
198}
199
200impl private::Sealed for Transaction<'_> {}
201
202#[async_trait]
203#[allow(clippy::needless_lifetimes)]
204impl GenericClient for Transaction<'_> {
205    async fn execute<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
206    where
207        T: ?Sized + ToStatement + Sync + Send,
208    {
209        self.execute(query, params).await
210    }
211
212    async fn execute_raw<P, I, T>(&self, statement: &T, params: I) -> Result<u64, Error>
213    where
214        T: ?Sized + ToStatement + Sync + Send,
215        P: BorrowToSql,
216        I: IntoIterator<Item = P> + Sync + Send,
217        I::IntoIter: ExactSizeIterator,
218    {
219        self.execute_raw(statement, params).await
220    }
221
222    async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
223    where
224        T: ?Sized + ToStatement + Sync + Send,
225    {
226        self.query(query, params).await
227    }
228
229    async fn query_one<T>(
230        &self,
231        statement: &T,
232        params: &[&(dyn ToSql + Sync)],
233    ) -> Result<Row, Error>
234    where
235        T: ?Sized + ToStatement + Sync + Send,
236    {
237        self.query_one(statement, params).await
238    }
239
240    async fn query_opt<T>(
241        &self,
242        statement: &T,
243        params: &[&(dyn ToSql + Sync)],
244    ) -> Result<Option<Row>, Error>
245    where
246        T: ?Sized + ToStatement + Sync + Send,
247    {
248        self.query_opt(statement, params).await
249    }
250
251    async fn query_raw<T, P, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
252    where
253        T: ?Sized + ToStatement + Sync + Send,
254        P: BorrowToSql,
255        I: IntoIterator<Item = P> + Sync + Send,
256        I::IntoIter: ExactSizeIterator,
257    {
258        self.query_raw(statement, params).await
259    }
260
261    async fn query_typed(
262        &self,
263        statement: &str,
264        params: &[(&(dyn ToSql + Sync), Type)],
265    ) -> Result<Vec<Row>, Error> {
266        self.query_typed(statement, params).await
267    }
268
269    async fn query_typed_raw<P, I>(&self, statement: &str, params: I) -> Result<RowStream, Error>
270    where
271        P: BorrowToSql,
272        I: IntoIterator<Item = (P, Type)> + Sync + Send,
273    {
274        self.query_typed_raw(statement, params).await
275    }
276
277    async fn prepare(&self, query: &str) -> Result<Statement, Error> {
278        self.prepare(query).await
279    }
280
281    async fn prepare_typed(
282        &self,
283        query: &str,
284        parameter_types: &[Type],
285    ) -> Result<Statement, Error> {
286        self.prepare_typed(query, parameter_types).await
287    }
288
289    #[allow(clippy::needless_lifetimes)]
290    async fn transaction<'a>(&'a mut self) -> Result<Transaction<'a>, Error> {
291        self.transaction().await
292    }
293
294    async fn batch_execute(&self, query: &str) -> Result<(), Error> {
295        self.batch_execute(query).await
296    }
297
298    async fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
299        self.simple_query(query).await
300    }
301
302    fn client(&self) -> &Client {
303        self.client()
304    }
305}
tokio_postgres/generic_client.rs

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

tokio_postgres/
generic_client.rs
