libsql: Make Connection::execute() immutable

Author: penberg

libsql/src/hrana/hyper.rs

@@ -237,7 +237,7 @@ impl Conn for HttpConnection<HttpSender> {
 impl crate::statement::Stmt for crate::hrana::Statement<HttpSender> {
     fn finalize(&mut self) {}
 
-    async fn execute(&mut self, params: &Params) -> crate::Result<usize> {
+    async fn execute(&self, params: &Params) -> crate::Result<usize> {
         self.execute(params).await
     }
 

libsql/src/hrana/mod.rs

@@ -162,7 +162,7 @@ where
         }
     }
 
-    pub async fn execute(&mut self, params: &Params) -> crate::Result<usize> {
+    pub async fn execute(&self, params: &Params) -> crate::Result<usize> {
         let mut stmt = self.inner.clone();
         bind_params(params.clone(), &mut stmt);
 

libsql/src/local/impls.rs

@@ -108,7 +108,7 @@ impl Stmt for LibsqlStmt {
         self.0.finalize();
     }
 
-    async fn execute(&mut self, params: &Params) -> Result<usize> {
+    async fn execute(&self, params: &Params) -> Result<usize> {
         let params = params.clone();
         let stmt = self.0.clone();
 

libsql/src/replication/connection.rs

@@ -654,8 +654,8 @@ async fn fetch_metas(
 impl Stmt for RemoteStatement {
     fn finalize(&mut self) {}
 
-    async fn execute(&mut self, params: &Params) -> Result<usize> {
-        if let Some(stmt) = &mut self.local_statement {
+    async fn execute(&self, params: &Params) -> Result<usize> {
+        if let Some(stmt) = &self.local_statement {
             return stmt.execute(params.clone()).await;
         }
 

libsql/src/statement.rs

@@ -8,7 +8,7 @@ use crate::{Row, Rows};
 pub(crate) trait Stmt {
     fn finalize(&mut self);
 
-    async fn execute(&mut self, params: &Params) -> Result<usize>;
+    async fn execute(&self, params: &Params) -> Result<usize>;
 
     async fn query(&self, params: &Params) -> Result<Rows>;
 
@@ -39,7 +39,7 @@ impl Statement {
     }
 
     /// Execute queries on the statement, check [`Connection::execute`] for usage.
-    pub async fn execute(&mut self, params: impl IntoParams) -> Result<usize> {
+    pub async fn execute(&self, params: impl IntoParams) -> Result<usize> {
         tracing::trace!("execute for prepared statement");
         self.inner.execute(&params.into_params()?).await
     }

libsql/src/sync/connection.rs

@@ -104,7 +104,7 @@ impl SyncedConnection {
 #[async_trait::async_trait]
 impl Conn for SyncedConnection {
     async fn execute(&self, sql: &str, params: Params) -> Result<u64> {
-        let mut stmt = self.prepare(sql).await?;
+        let stmt = self.prepare(sql).await?;
         stmt.execute(params).await.map(|v| v as u64)
     }
 

libsql/src/sync/statement.rs

@@ -20,7 +20,7 @@ impl Stmt for SyncedStatement {
         self.inner.finalize()
     }
 
-    async fn execute(&mut self, params: &Params) -> Result<usize> {
+    async fn execute(&self, params: &Params) -> Result<usize> {
         if self.needs_pull.load(Ordering::Relaxed) {
             let mut context = self.context.lock().await;
             crate::sync::try_pull(&mut context, &self.conn).await?;