Remove query_raw_with_param_types as per PR feedback

Author: ramnivas

tokio-postgres/src/client.rs

@@ -366,8 +366,13 @@ impl Client {
 
     /// Like `query`, but requires the types of query parameters to be explicitly specified.
     ///
-    /// Compared to `query`, this method allows performing queries without three round trips (for prepare, execute, and close). Thus,
-    /// this is suitable in environments where prepared statements aren't supported (such as Cloudflare Workers with Hyperdrive).
+    /// Compared to `query`, this method allows performing queries without three round trips (for
+    /// prepare, execute, and close) by requiring the caller to specify parameter values along with
+    /// their Postgres type. Thus, this is suitable in environments where prepared statements aren't
+    /// supported (such as Cloudflare Workers with Hyperdrive).
+    ///
+    /// A statement may contain parameters, specified by `$n`, where `n` is the index of the
+    /// parameter of the list provided, 1-indexed.
     ///
     /// # Examples
     ///
@@ -394,56 +399,17 @@ impl Client {
         statement: &str,
         params: &[(&(dyn ToSql + Sync), Type)],
     ) -> Result<Vec<Row>, Error> {
-        self.query_raw_with_param_types(statement, params)
-            .await?
-            .try_collect()
-            .await
-    }
-
-    /// The maximally flexible version of [`query_with_param_types`].
-    ///
-    /// A statement may contain parameters, specified by `$n`, where `n` is the index of the parameter of the list
-    /// provided, 1-indexed.
-    ///
-    /// The parameters must specify value along with their Postgres type. This allows performing
-    /// queries without three round trips (for prepare, execute, and close).
-    ///
-    /// [`query_with_param_types`]: #method.query_with_param_types
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # async fn async_main(client: &tokio_postgres::Client) -> Result<(), tokio_postgres::Error> {
-    /// use tokio_postgres::types::ToSql;
-    /// use tokio_postgres::types::Type;
-    /// use futures_util::{pin_mut, TryStreamExt};
-    ///
-    /// let mut it = client.query_raw_with_param_types(
-    ///     "SELECT foo FROM bar WHERE biz = $1 AND baz = $2",
-    ///     &[(&"first param", Type::TEXT), (&2i32, Type::INT4)],
-    /// ).await?;
-    ///
-    /// pin_mut!(it);
-    /// while let Some(row) = it.try_next().await? {
-    ///     let foo: i32 = row.get("foo");
-    ///     println!("foo: {}", foo);
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub async fn query_raw_with_param_types(
-        &self,
-        statement: &str,
-        params: &[(&(dyn ToSql + Sync), Type)],
-    ) -> Result<RowStream, Error> {
         fn slice_iter<'a>(
             s: &'a [(&'a (dyn ToSql + Sync), Type)],
         ) -> impl ExactSizeIterator<Item = (&'a dyn ToSql, Type)> + 'a {
             s.iter()
                 .map(|(param, param_type)| (*param as _, param_type.clone()))
         }
 
-        query::query_with_param_types(&self.inner, statement, slice_iter(params)).await
+        query::query_with_param_types(&self.inner, statement, slice_iter(params))
+            .await?
+            .try_collect()
+            .await
     }
 
     /// Executes a statement, returning the number of rows modified.

tokio-postgres/src/generic_client.rs

@@ -63,13 +63,6 @@ pub trait GenericClient: private::Sealed {
         params: &[(&(dyn ToSql + Sync), Type)],
     ) -> Result<Vec<Row>, Error>;
 
-    /// Like `Client::query_raw_with_param_types`.
-    async fn query_raw_with_param_types(
-        &self,
-        statement: &str,
-        params: &[(&(dyn ToSql + Sync), Type)],
-    ) -> Result<RowStream, Error>;
-
     /// Like `Client::prepare`.
     async fn prepare(&self, query: &str) -> Result<Statement, Error>;
 
@@ -158,14 +151,6 @@ impl GenericClient for Client {
         self.query_with_param_types(statement, params).await
     }
 
-    async fn query_raw_with_param_types(
-        &self,
-        statement: &str,
-        params: &[(&(dyn ToSql + Sync), Type)],
-    ) -> Result<RowStream, Error> {
-        self.query_raw_with_param_types(statement, params).await
-    }
-
     async fn prepare(&self, query: &str) -> Result<Statement, Error> {
         self.prepare(query).await
     }
@@ -260,14 +245,6 @@ impl GenericClient for Transaction<'_> {
         self.query_with_param_types(statement, params).await
     }
 
-    async fn query_raw_with_param_types(
-        &self,
-        statement: &str,
-        params: &[(&(dyn ToSql + Sync), Type)],
-    ) -> Result<RowStream, Error> {
-        self.query_raw_with_param_types(statement, params).await
-    }
-
     async fn prepare(&self, query: &str) -> Result<Statement, Error> {
         self.prepare(query).await
     }

tokio-postgres/src/transaction.rs

@@ -233,25 +233,7 @@ impl<'a> Transaction<'a> {
         statement: &str,
         params: &[(&(dyn ToSql + Sync), Type)],
     ) -> Result<Vec<Row>, Error> {
-        self.query_raw_with_param_types(statement, params)
-            .await?
-            .try_collect()
-            .await
-    }
-
-    /// Like `Client::query_raw_with_param_types`.
-    pub async fn query_raw_with_param_types(
-        &self,
-        statement: &str,
-        params: &[(&(dyn ToSql + Sync), Type)],
-    ) -> Result<RowStream, Error> {
-        fn slice_iter<'a>(
-            s: &'a [(&'a (dyn ToSql + Sync), Type)],
-        ) -> impl ExactSizeIterator<Item = (&'a dyn ToSql, Type)> + 'a {
-            s.iter()
-                .map(|(param, param_type)| (*param as _, param_type.clone()))
-        }
-        query::query_with_param_types(self.client.inner(), statement, slice_iter(params)).await
+        self.client.query_with_param_types(statement, params).await
     }
 
     /// Like `Client::copy_in`.