Skip to content

Commit 27635a2

Browse files
sfacklersfackler
committed
Clean up GenericClient traits
1 parent 5429a79 commit 27635a2

6 files changed

Lines changed: 373 additions & 208 deletions

File tree

‎postgres/src/client.rs‎

Lines changed: 2 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use crate::{
2-
CancelToken, Config, CopyInWriter, CopyOutReader, GenericClient, RowIter, Statement,
3-
ToStatement, Transaction, TransactionBuilder,
2+
CancelToken, Config, CopyInWriter, CopyOutReader, RowIter, Statement, ToStatement, Transaction,
3+
TransactionBuilder,
44
};
55
use std::ops::{Deref, DerefMut};
66
use tokio::runtime::Runtime;
@@ -517,27 +517,3 @@ impl Client {
517517
self.client.is_closed()
518518
}
519519
}
520-
521-
impl GenericClient for Client {
522-
fn execute<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
523-
where
524-
T: ?Sized + ToStatement,
525-
{
526-
self.execute(query, params)
527-
}
528-
529-
fn query<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
530-
where
531-
T: ?Sized + ToStatement,
532-
{
533-
self.query(query, params)
534-
}
535-
536-
fn prepare(&mut self, query: &str) -> Result<Statement, Error> {
537-
self.prepare(query)
538-
}
539-
540-
fn transaction(&mut self) -> Result<Transaction<'_>, Error> {
541-
self.transaction()
542-
}
543-
}

‎postgres/src/generic_client.rs‎

Lines changed: 210 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,17 @@
1-
use crate::types::ToSql;
2-
use crate::{Error, Row, Statement, ToStatement, Transaction};
1+
use crate::types::{ToSql, Type};
2+
use crate::{
3+
Client, CopyInWriter, CopyOutReader, Error, Row, RowIter, SimpleQueryMessage, Statement,
4+
ToStatement, Transaction,
5+
};
6+
7+
mod private {
8+
pub trait Sealed {}
9+
}
310

411
/// A trait allowing abstraction over connections and transactions.
5-
pub trait GenericClient {
12+
///
13+
/// This trait is "sealed", and cannot be implemented outside of this crate.
14+
pub trait GenericClient: private::Sealed {
615
/// Like `Client::execute`.
716
fn execute<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
817
where
@@ -13,9 +22,207 @@ pub trait GenericClient {
1322
where
1423
T: ?Sized + ToStatement;
1524

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<'a, T, I>(&mut self, query: &T, params: I) -> Result<RowIter<'_>, Error>
41+
where
42+
T: ?Sized + ToStatement,
43+
I: IntoIterator<Item = &'a dyn ToSql>,
44+
I::IntoIter: ExactSizeIterator;
45+
1646
/// Like `Client::prepare`.
1747
fn prepare(&mut self, query: &str) -> Result<Statement, Error>;
1848

49+
/// Like `Client::prepare_typed`.
50+
fn prepare_typed(&mut self, query: &str, types: &[Type]) -> Result<Statement, Error>;
51+
52+
/// Like `Client::copy_in`.
53+
fn copy_in<T>(&mut self, query: &T) -> Result<CopyInWriter<'_>, Error>
54+
where
55+
T: ?Sized + ToStatement;
56+
57+
/// Like `Client::copy_out`.
58+
fn copy_out<T>(&mut self, query: &T) -> Result<CopyOutReader<'_>, Error>
59+
where
60+
T: ?Sized + ToStatement;
61+
62+
/// Like `Client::simple_query`.
63+
fn simple_query(&mut self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error>;
64+
65+
/// Like `Client::batch_execute`.
66+
fn batch_execute(&mut self, query: &str) -> Result<(), Error>;
67+
1968
/// Like `Client::transaction`.
2069
fn transaction(&mut self) -> Result<Transaction<'_>, Error>;
2170
}
71+
72+
impl private::Sealed for Client {}
73+
74+
impl GenericClient for Client {
75+
fn execute<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
76+
where
77+
T: ?Sized + ToStatement,
78+
{
79+
self.execute(query, params)
80+
}
81+
82+
fn query<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
83+
where
84+
T: ?Sized + ToStatement,
85+
{
86+
self.query(query, params)
87+
}
88+
89+
fn query_one<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Row, Error>
90+
where
91+
T: ?Sized + ToStatement,
92+
{
93+
self.query_one(query, params)
94+
}
95+
96+
fn query_opt<T>(
97+
&mut self,
98+
query: &T,
99+
params: &[&(dyn ToSql + Sync)],
100+
) -> Result<Option<Row>, Error>
101+
where
102+
T: ?Sized + ToStatement,
103+
{
104+
self.query_opt(query, params)
105+
}
106+
107+
fn query_raw<'a, T, I>(&mut self, query: &T, params: I) -> Result<RowIter<'_>, Error>
108+
where
109+
T: ?Sized + ToStatement,
110+
I: IntoIterator<Item = &'a dyn ToSql>,
111+
I::IntoIter: ExactSizeIterator,
112+
{
113+
self.query_raw(query, params)
114+
}
115+
116+
fn prepare(&mut self, query: &str) -> Result<Statement, Error> {
117+
self.prepare(query)
118+
}
119+
120+
fn prepare_typed(&mut self, query: &str, types: &[Type]) -> Result<Statement, Error> {
121+
self.prepare_typed(query, types)
122+
}
123+
124+
fn copy_in<T>(&mut self, query: &T) -> Result<CopyInWriter<'_>, Error>
125+
where
126+
T: ?Sized + ToStatement,
127+
{
128+
self.copy_in(query)
129+
}
130+
131+
fn copy_out<T>(&mut self, query: &T) -> Result<CopyOutReader<'_>, Error>
132+
where
133+
T: ?Sized + ToStatement,
134+
{
135+
self.copy_out(query)
136+
}
137+
138+
fn simple_query(&mut self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
139+
self.simple_query(query)
140+
}
141+
142+
fn batch_execute(&mut self, query: &str) -> Result<(), Error> {
143+
self.batch_execute(query)
144+
}
145+
146+
fn transaction(&mut self) -> Result<Transaction<'_>, Error> {
147+
self.transaction()
148+
}
149+
}
150+
151+
impl private::Sealed for Transaction<'_> {}
152+
153+
impl GenericClient for Transaction<'_> {
154+
fn execute<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
155+
where
156+
T: ?Sized + ToStatement,
157+
{
158+
self.execute(query, params)
159+
}
160+
161+
fn query<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
162+
where
163+
T: ?Sized + ToStatement,
164+
{
165+
self.query(query, params)
166+
}
167+
168+
fn query_one<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Row, Error>
169+
where
170+
T: ?Sized + ToStatement,
171+
{
172+
self.query_one(query, params)
173+
}
174+
175+
fn query_opt<T>(
176+
&mut self,
177+
query: &T,
178+
params: &[&(dyn ToSql + Sync)],
179+
) -> Result<Option<Row>, Error>
180+
where
181+
T: ?Sized + ToStatement,
182+
{
183+
self.query_opt(query, params)
184+
}
185+
186+
fn query_raw<'a, T, I>(&mut self, query: &T, params: I) -> Result<RowIter<'_>, Error>
187+
where
188+
T: ?Sized + ToStatement,
189+
I: IntoIterator<Item = &'a dyn ToSql>,
190+
I::IntoIter: ExactSizeIterator,
191+
{
192+
self.query_raw(query, params)
193+
}
194+
195+
fn prepare(&mut self, query: &str) -> Result<Statement, Error> {
196+
self.prepare(query)
197+
}
198+
199+
fn prepare_typed(&mut self, query: &str, types: &[Type]) -> Result<Statement, Error> {
200+
self.prepare_typed(query, types)
201+
}
202+
203+
fn copy_in<T>(&mut self, query: &T) -> Result<CopyInWriter<'_>, Error>
204+
where
205+
T: ?Sized + ToStatement,
206+
{
207+
self.copy_in(query)
208+
}
209+
210+
fn copy_out<T>(&mut self, query: &T) -> Result<CopyOutReader<'_>, Error>
211+
where
212+
T: ?Sized + ToStatement,
213+
{
214+
self.copy_out(query)
215+
}
216+
217+
fn simple_query(&mut self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
218+
self.simple_query(query)
219+
}
220+
221+
fn batch_execute(&mut self, query: &str) -> Result<(), Error> {
222+
self.batch_execute(query)
223+
}
224+
225+
fn transaction(&mut self) -> Result<Transaction<'_>, Error> {
226+
self.transaction()
227+
}
228+
}

‎postgres/src/transaction.rs‎

Lines changed: 1 addition & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
use crate::{
2-
CancelToken, CopyInWriter, CopyOutReader, GenericClient, Portal, RowIter, Rt, Statement,
3-
ToStatement,
2+
CancelToken, CopyInWriter, CopyOutReader, Portal, RowIter, Rt, Statement, ToStatement,
43
};
54
use tokio::runtime::Runtime;
65
use tokio_postgres::types::{ToSql, Type};
@@ -185,27 +184,3 @@ impl<'a> Transaction<'a> {
185184
})
186185
}
187186
}
188-
189-
impl<'a> GenericClient for Transaction<'a> {
190-
fn execute<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
191-
where
192-
T: ?Sized + ToStatement,
193-
{
194-
self.execute(query, params)
195-
}
196-
197-
fn query<T>(&mut self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
198-
where
199-
T: ?Sized + ToStatement,
200-
{
201-
self.query(query, params)
202-
}
203-
204-
fn prepare(&mut self, query: &str) -> Result<Statement, Error> {
205-
self.prepare(query)
206-
}
207-
208-
fn transaction(&mut self) -> Result<Transaction<'_>, Error> {
209-
self.transaction()
210-
}
211-
}

‎tokio-postgres/src/client.rs‎

Lines changed: 1 addition & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -12,10 +12,8 @@ use crate::types::{Oid, ToSql, Type};
1212
use crate::Socket;
1313
use crate::{
1414
copy_in, copy_out, prepare, query, simple_query, slice_iter, CancelToken, CopyInSink, Error,
15-
GenericClient, Row, SimpleQueryMessage, Statement, ToStatement, Transaction,
16-
TransactionBuilder,
15+
Row, SimpleQueryMessage, Statement, ToStatement, Transaction, TransactionBuilder,
1716
};
18-
use async_trait::async_trait;
1917
use bytes::{Buf, BytesMut};
2018
use fallible_iterator::FallibleIterator;
2119
use futures::channel::mpsc;
@@ -503,76 +501,3 @@ impl Client {
503501
self.inner.sender.is_closed()
504502
}
505503
}
506-
507-
#[async_trait]
508-
impl GenericClient for Client {
509-
async fn execute<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error>
510-
where
511-
T: ?Sized + ToStatement + Sync + Send,
512-
{
513-
self.execute(query, params).await
514-
}
515-
516-
async fn execute_raw<'b, I, T>(&self, statement: &T, params: I) -> Result<u64, Error>
517-
where
518-
T: ?Sized + ToStatement + Sync + Send,
519-
I: IntoIterator<Item = &'b dyn ToSql> + Sync + Send,
520-
I::IntoIter: ExactSizeIterator,
521-
{
522-
self.execute_raw(statement, params).await
523-
}
524-
525-
async fn query<T>(&self, query: &T, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<Row>, Error>
526-
where
527-
T: ?Sized + ToStatement + Sync + Send,
528-
{
529-
self.query(query, params).await
530-
}
531-
532-
async fn query_one<T>(
533-
&self,
534-
statement: &T,
535-
params: &[&(dyn ToSql + Sync)],
536-
) -> Result<Row, Error>
537-
where
538-
T: ?Sized + ToStatement + Sync + Send,
539-
{
540-
self.query_one(statement, params).await
541-
}
542-
543-
async fn query_opt<T>(
544-
&self,
545-
statement: &T,
546-
params: &[&(dyn ToSql + Sync)],
547-
) -> Result<Option<Row>, Error>
548-
where
549-
T: ?Sized + ToStatement + Sync + Send,
550-
{
551-
self.query_opt(statement, params).await
552-
}
553-
554-
async fn query_raw<'b, T, I>(&self, statement: &T, params: I) -> Result<RowStream, Error>
555-
where
556-
T: ?Sized + ToStatement + Sync + Send,
557-
I: IntoIterator<Item = &'b dyn ToSql> + Sync + Send,
558-
I::IntoIter: ExactSizeIterator,
559-
{
560-
self.query_raw(statement, params).await
561-
}
562-
563-
async fn prepare(&self, query: &str) -> Result<Statement, Error> {
564-
self.prepare(query).await
565-
}
566-
567-
async fn prepare_typed(
568-
&self,
569-
query: &str,
570-
parameter_types: &[Type],
571-
) -> Result<Statement, Error> {
572-
self.prepare_typed(query, parameter_types).await
573-
}
574-
575-
async fn transaction(&mut self) -> Result<Transaction<'_>, Error> {
576-
self.transaction().await
577-
}
578-
}

0 commit comments

Comments
 (0)