Add a ToStatement trait in tokio-postgres

Author: sfackler

postgres-native-tls/src/lib.rs

@@ -38,7 +38,7 @@
 //!     .build()?;
 //! let connector = MakeTlsConnector::new(connector);
 //!
-//! let mut client = postgres::Client::connect(
+//! let client = postgres::Client::connect(
 //!     "host=localhost user=postgres sslmode=require",
 //!     connector,
 //! )?;

postgres-openssl/src/lib.rs

@@ -30,7 +30,7 @@
 //! builder.set_ca_file("database_cert.pem")?;
 //! let connector = MakeTlsConnector::new(builder.build());
 //!
-//! let mut client = postgres::Client::connect(
+//! let client = postgres::Client::connect(
 //!     "host=localhost user=postgres sslmode=require",
 //!     connector,
 //! )?;

postgres/src/client.rs

@@ -84,8 +84,7 @@ impl Client {
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        executor::block_on(self.0.execute(&statement, params))
+        executor::block_on(self.0.execute(query, params))
     }
 
     /// Executes a statement, returning the resulting rows.
@@ -154,14 +153,13 @@ impl Client {
     /// ```
     pub fn query_iter<'a, T>(
         &'a mut self,
-        query: &T,
-        params: &[&(dyn ToSql + Sync)],
+        query: &'a T,
+        params: &'a [&(dyn ToSql + Sync)],
     ) -> Result<impl FallibleIterator<Item = Row, Error = Error> + 'a, Error>
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        Ok(Iter::new(self.0.query(&statement, params)))
+        Ok(Iter::new(self.0.query(query, params)))
     }
 
     /// Creates a new prepared statement.
@@ -249,8 +247,7 @@ impl Client {
         T: ?Sized + ToStatement,
         R: Read + Unpin,
     {
-        let statement = query.__statement(self)?;
-        executor::block_on(self.0.copy_in(&statement, params, CopyInStream(reader)))
+        executor::block_on(self.0.copy_in(query, params, CopyInStream(reader)))
     }
 
     /// Executes a `COPY TO STDOUT` statement, returning a reader of the resulting data.
@@ -274,14 +271,13 @@ impl Client {
     /// ```
     pub fn copy_out<'a, T>(
         &'a mut self,
-        query: &T,
-        params: &[&(dyn ToSql + Sync)],
+        query: &'a T,
+        params: &'a [&(dyn ToSql + Sync)],
     ) -> Result<impl BufRead + 'a, Error>
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        let stream = self.0.copy_out(&statement, params);
+        let stream = self.0.copy_out(query, params);
         CopyOutReader::new(stream)
     }
 
@@ -314,7 +310,7 @@ impl Client {
     /// them to this method!
     pub fn simple_query_iter<'a>(
         &'a mut self,
-        query: &str,
+        query: &'a str,
     ) -> Result<impl FallibleIterator<Item = SimpleQueryMessage, Error = Error> + 'a, Error> {
         Ok(Iter::new(self.0.simple_query(query)))
     }

postgres/src/lib.rs

@@ -62,7 +62,9 @@ use tokio::runtime::{self, Runtime};
 
 #[cfg(feature = "runtime")]
 pub use tokio_postgres::Socket;
-pub use tokio_postgres::{error, row, tls, types, Column, Portal, SimpleQueryMessage, Statement};
+pub use tokio_postgres::{
+    error, row, tls, types, Column, Portal, SimpleQueryMessage, Statement, ToStatement,
+};
 
 pub use crate::client::*;
 #[cfg(feature = "runtime")]
@@ -73,7 +75,6 @@ pub use crate::error::Error;
 pub use crate::row::{Row, SimpleQueryRow};
 #[doc(no_inline)]
 pub use crate::tls::NoTls;
-pub use crate::to_statement::*;
 pub use crate::transaction::*;
 
 mod client;
@@ -82,7 +83,6 @@ pub mod config;
 mod copy_in_stream;
 mod copy_out_reader;
 mod iter;
-mod to_statement;
 mod transaction;
 
 #[cfg(feature = "runtime")]

postgres/src/to_statement.rs

@@ -47,8 +47,7 @@ impl<'a> Transaction<'a> {
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        executor::block_on(self.0.execute(&statement, params))
+        executor::block_on(self.0.execute(query, params))
     }
 
     /// Like `Client::query`.
@@ -60,16 +59,15 @@ impl<'a> Transaction<'a> {
     }
 
     /// Like `Client::query_iter`.
-    pub fn query_iter<T>(
-        &mut self,
-        query: &T,
-        params: &[&(dyn ToSql + Sync)],
-    ) -> Result<impl FallibleIterator<Item = Row, Error = Error>, Error>
+    pub fn query_iter<'b, T>(
+        &'b mut self,
+        query: &'b T,
+        params: &'b [&(dyn ToSql + Sync)],
+    ) -> Result<impl FallibleIterator<Item = Row, Error = Error> + 'b, Error>
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        Ok(Iter::new(self.0.query(&statement, params)))
+        Ok(Iter::new(self.0.query(query, params)))
     }
 
     /// Binds parameters to a statement, creating a "portal".
@@ -86,8 +84,7 @@ impl<'a> Transaction<'a> {
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        executor::block_on(self.0.bind(&statement, params))
+        executor::block_on(self.0.bind(query, params))
     }
 
     /// Continues execution of a portal, returning the next set of rows.
@@ -100,11 +97,11 @@ impl<'a> Transaction<'a> {
 
     /// Like `query_portal`, except that it returns a fallible iterator over the resulting rows rather than buffering
     /// the entire response in memory.
-    pub fn query_portal_iter(
-        &mut self,
-        portal: &Portal,
+    pub fn query_portal_iter<'b>(
+        &'b mut self,
+        portal: &'b Portal,
         max_rows: i32,
-    ) -> Result<impl FallibleIterator<Item = Row, Error = Error>, Error> {
+    ) -> Result<impl FallibleIterator<Item = Row, Error = Error> + 'b, Error> {
         Ok(Iter::new(self.0.query_portal(&portal, max_rows)))
     }
 
@@ -119,21 +116,19 @@ impl<'a> Transaction<'a> {
         T: ?Sized + ToStatement,
         R: Read + Unpin,
     {
-        let statement = query.__statement(self)?;
-        executor::block_on(self.0.copy_in(&statement, params, CopyInStream(reader)))
+        executor::block_on(self.0.copy_in(query, params, CopyInStream(reader)))
     }
 
     /// Like `Client::copy_out`.
     pub fn copy_out<'b, T>(
-        &'a mut self,
-        query: &T,
-        params: &[&(dyn ToSql + Sync)],
+        &'b mut self,
+        query: &'b T,
+        params: &'b [&(dyn ToSql + Sync)],
     ) -> Result<impl BufRead + 'b, Error>
     where
         T: ?Sized + ToStatement,
     {
-        let statement = query.__statement(self)?;
-        let stream = self.0.copy_out(&statement, params);
+        let stream = self.0.copy_out(query, params);
         CopyOutReader::new(stream)
     }
 
@@ -145,7 +140,7 @@ impl<'a> Transaction<'a> {
     /// Like `Client::simple_query_iter`.
     pub fn simple_query_iter<'b>(
         &'b mut self,
-        query: &str,
+        query: &'b str,
     ) -> Result<impl FallibleIterator<Item = SimpleQueryMessage, Error = Error> + 'b, Error> {
         Ok(Iter::new(self.0.simple_query(query)))
     }

postgres/src/transaction.rs

@@ -10,36 +10,25 @@ use std::sync::Arc;
 
 static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
 
-pub async fn bind(
-    client: Arc<InnerClient>,
+pub async fn bind<'a, I>(
+    client: &Arc<InnerClient>,
     statement: Statement,
-    bind: Result<PendingBind, Error>,
-) -> Result<Portal, Error> {
-    let bind = bind?;
-
-    let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(bind.buf)))?;
-
-    match responses.next().await? {
-        Message::BindComplete => {}
-        _ => return Err(Error::unexpected_message()),
-    }
-
-    Ok(Portal::new(&client, bind.name, statement))
-}
-
-pub struct PendingBind {
-    buf: Vec<u8>,
-    name: String,
-}
-
-pub fn encode<'a, I>(statement: &Statement, params: I) -> Result<PendingBind, Error>
+    params: I,
+) -> Result<Portal, Error>
 where
     I: IntoIterator<Item = &'a dyn ToSql>,
     I::IntoIter: ExactSizeIterator,
 {
     let name = format!("p{}", NEXT_ID.fetch_add(1, Ordering::SeqCst));
-    let mut buf = query::encode_bind(statement, params, &name)?;
+    let mut buf = query::encode_bind(&statement, params, &name)?;
     frontend::sync(&mut buf);
 
-    Ok(PendingBind { buf, name })
+    let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
+
+    match responses.next().await? {
+        Message::BindComplete => {}
+        _ => return Err(Error::unexpected_message()),
+    }
+
+    Ok(Portal::new(client, name, statement))
 }