postgres/
generic_client.rs

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

postgres/
generic_client.rs
