Add generic immutable interface.

Add a GenericClient trait over Client and Transaction, and replace &mut with &.

Author: enzious

postgres/src/client.rs

@@ -77,7 +77,7 @@ impl Client {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn execute<T>(&mut self, query: &T, params: &[&dyn ToSql]) -> Result<u64, Error>
+    pub fn execute<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<u64, Error>
     where
         T: ?Sized + ToStatement,
     {
@@ -116,7 +116,7 @@ impl Client {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn query<T>(&mut self, query: &T, params: &[&dyn ToSql]) -> Result<Vec<Row>, Error>
+    pub fn query<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<Vec<Row>, Error>
     where
         T: ?Sized + ToStatement,
     {
@@ -148,11 +148,7 @@ impl Client {
     /// }
     /// # Ok(())
     /// # }
-    pub fn query_iter<T>(
-        &mut self,
-        query: &T,
-        params: &[&dyn ToSql],
-    ) -> Result<QueryIter<'_>, Error>
+    pub fn query_iter<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<QueryIter<'_>, Error>
     where
         T: ?Sized + ToStatement,
     {
@@ -183,7 +179,7 @@ impl Client {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn prepare(&mut self, query: &str) -> Result<Statement, Error> {
+    pub fn prepare(&self, query: &str) -> Result<Statement, Error> {
         self.0.prepare(query).wait()
     }
 
@@ -213,7 +209,7 @@ impl Client {
     /// }
     /// # Ok(())
     /// # }
-    pub fn prepare_typed(&mut self, query: &str, types: &[Type]) -> Result<Statement, Error> {
+    pub fn prepare_typed(&self, query: &str, types: &[Type]) -> Result<Statement, Error> {
         self.0.prepare_typed(query, types).wait()
     }
 
@@ -234,12 +230,7 @@ impl Client {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn copy_in<T, R>(
-        &mut self,
-        query: &T,
-        params: &[&dyn ToSql],
-        reader: R,
-    ) -> Result<u64, Error>
+    pub fn copy_in<T, R>(&self, query: &T, params: &[&dyn ToSql], reader: R) -> Result<u64, Error>
     where
         T: ?Sized + ToStatement,
         R: Read,
@@ -269,11 +260,7 @@ impl Client {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn copy_out<T>(
-        &mut self,
-        query: &T,
-        params: &[&dyn ToSql],
-    ) -> Result<CopyOutReader<'_>, Error>
+    pub fn copy_out<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<CopyOutReader<'_>, Error>
     where
         T: ?Sized + ToStatement,
     {
@@ -297,7 +284,7 @@ impl Client {
     /// Prepared statements should be use for any query which contains user-specified data, as they provided the
     /// functionality to safely imbed that data in the request. Do not form statements via string concatenation and pass
     /// them to this method!
-    pub fn simple_query(&mut self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
+    pub fn simple_query(&self, query: &str) -> Result<Vec<SimpleQueryMessage>, Error> {
         self.simple_query_iter(query)?.collect()
     }
 
@@ -309,7 +296,7 @@ impl Client {
     /// Prepared statements should be use for any query which contains user-specified data, as they provided the
     /// functionality to safely imbed that data in the request. Do not form statements via string concatenation and pass
     /// them to this method!
-    pub fn simple_query_iter(&mut self, query: &str) -> Result<SimpleQueryIter<'_>, Error> {
+    pub fn simple_query_iter(&self, query: &str) -> Result<SimpleQueryIter<'_>, Error> {
         Ok(SimpleQueryIter::new(self.0.simple_query(query)))
     }
 
@@ -333,7 +320,7 @@ impl Client {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn transaction(&mut self) -> Result<Transaction<'_>, Error> {
+    pub fn transaction(&self) -> Result<Transaction<'_>, Error> {
         self.simple_query("BEGIN")?;
         Ok(Transaction::new(self))
     }
@@ -351,9 +338,9 @@ impl Client {
     }
 
     /// Returns a mutable reference to the inner nonblocking client.
-    pub fn get_mut(&mut self) -> &mut tokio_postgres::Client {
+    /*pub fn get_mut(&mut self) -> &mut tokio_postgres::Client {
         &mut self.0
-    }
+    }*/
 
     /// Consumes the client, returning the inner nonblocking client.
     pub fn into_inner(self) -> tokio_postgres::Client {
@@ -384,3 +371,43 @@ where
         }
     }
 }
+
+/// A trait allowing abstraction over connections and transactions
+pub trait GenericClient {
+    /// Like `Client::execute`.
+    fn execute<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<u64, Error>
+    where
+        T: ?Sized + ToStatement;
+
+    /// Like `Client::query`.
+    fn query<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<Vec<Row>, Error>
+    where
+        T: ?Sized + ToStatement;
+
+    /// Like `Client::prepare`.
+    fn prepare(&self, query: &str) -> Result<Statement, Error>;
+
+    /// Like `Client::transaction`.
+    fn transaction(&self) -> Result<Transaction<'_>, Error>;
+}
+
+impl GenericClient for Client {
+    fn execute<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<u64, Error>
+    where
+        T: ?Sized + ToStatement,
+    {
+        self.execute(query, params)
+    }
+    fn query<T>(&self, query: &T, params: &[&dyn ToSql]) -> Result<Vec<Row>, Error>
+    where
+        T: ?Sized + ToStatement,
+    {
+        self.query(query, params)
+    }
+    fn prepare(&self, query: &str) -> Result<Statement, Error> {
+        self.prepare(query)
+    }
+    fn transaction(&self) -> Result<Transaction<'_>, Error> {
+        self.transaction()
+    }
+}

postgres/src/test.rs

@@ -6,7 +6,7 @@ use super::*;
 
 #[test]
 fn prepare() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     let stmt = client.prepare("SELECT 1::INT, $1::TEXT").unwrap();
     assert_eq!(stmt.params(), &[Type::TEXT]);
@@ -17,7 +17,7 @@ fn prepare() {
 
 #[test]
 fn query_prepared() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     let stmt = client.prepare("SELECT $1::TEXT").unwrap();
     let rows = client.query(&stmt, &[&"hello"]).unwrap();
@@ -27,7 +27,7 @@ fn query_prepared() {
 
 #[test]
 fn query_unprepared() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     let rows = client.query("SELECT $1::TEXT", &[&"hello"]).unwrap();
     assert_eq!(rows.len(), 1);
@@ -36,13 +36,13 @@ fn query_unprepared() {
 
 #[test]
 fn transaction_commit() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)")
         .unwrap();
 
-    let mut transaction = client.transaction().unwrap();
+    let transaction = client.transaction().unwrap();
 
     transaction
         .execute("INSERT INTO foo DEFAULT VALUES", &[])
@@ -57,13 +57,13 @@ fn transaction_commit() {
 
 #[test]
 fn transaction_rollback() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)")
         .unwrap();
 
-    let mut transaction = client.transaction().unwrap();
+    let transaction = client.transaction().unwrap();
 
     transaction
         .execute("INSERT INTO foo DEFAULT VALUES", &[])
@@ -77,13 +77,13 @@ fn transaction_rollback() {
 
 #[test]
 fn transaction_drop() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)")
         .unwrap();
 
-    let mut transaction = client.transaction().unwrap();
+    let transaction = client.transaction().unwrap();
 
     transaction
         .execute("INSERT INTO foo DEFAULT VALUES", &[])
@@ -97,19 +97,19 @@ fn transaction_drop() {
 
 #[test]
 fn nested_transactions() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)")
         .unwrap();
 
-    let mut transaction = client.transaction().unwrap();
+    let transaction = client.transaction().unwrap();
 
     transaction
         .execute("INSERT INTO foo (id) VALUES (1)", &[])
         .unwrap();
 
-    let mut transaction2 = transaction.transaction().unwrap();
+    let transaction2 = transaction.transaction().unwrap();
 
     transaction2
         .execute("INSERT INTO foo (id) VALUES (2)", &[])
@@ -123,13 +123,13 @@ fn nested_transactions() {
     assert_eq!(rows.len(), 1);
     assert_eq!(rows[0].get::<_, i32>(0), 1);
 
-    let mut transaction3 = transaction.transaction().unwrap();
+    let transaction3 = transaction.transaction().unwrap();
 
     transaction3
         .execute("INSERT INTO foo (id) VALUES(3)", &[])
         .unwrap();
 
-    let mut transaction4 = transaction3.transaction().unwrap();
+    let transaction4 = transaction3.transaction().unwrap();
 
     transaction4
         .execute("INSERT INTO foo (id) VALUES(4)", &[])
@@ -148,7 +148,7 @@ fn nested_transactions() {
 
 #[test]
 fn copy_in() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query("CREATE TEMPORARY TABLE foo (id INT, name TEXT)")
@@ -175,7 +175,7 @@ fn copy_in() {
 
 #[test]
 fn copy_out() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query(
@@ -198,7 +198,7 @@ fn copy_out() {
 
 #[test]
 fn portal() {
-    let mut client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
+    let client = Client::connect("host=localhost port=5433 user=postgres", NoTls).unwrap();
 
     client
         .simple_query(
@@ -207,7 +207,7 @@ fn portal() {
         )
         .unwrap();
 
-    let mut transaction = client.transaction().unwrap();
+    let transaction = client.transaction().unwrap();
 
     let portal = transaction
         .bind("SELECT * FROM foo ORDER BY id", &[])

postgres/src/to_statement.rs

@@ -14,21 +14,21 @@ mod sealed {
 /// This trait is "sealed" and cannot be implemented by anything outside this crate.
 pub trait ToStatement: sealed::Sealed {
     #[doc(hidden)]
-    fn __statement(&self, client: &mut Client) -> Result<Statement, Error>;
+    fn __statement(&self, client: &Client) -> Result<Statement, Error>;
 }
 
 impl sealed::Sealed for str {}
 
 impl ToStatement for str {
-    fn __statement(&self, client: &mut Client) -> Result<Statement, Error> {
+    fn __statement(&self, client: &Client) -> Result<Statement, Error> {
         client.prepare(self)
     }
 }
 
 impl sealed::Sealed for Statement {}
 
 impl ToStatement for Statement {
-    fn __statement(&self, _: &mut Client) -> Result<Statement, Error> {
+    fn __statement(&self, _: &Client) -> Result<Statement, Error> {
         Ok(self.clone())
     }
 }