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

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

postgres/
generic_client.rs
