refactor: Remove lifetime parameters from OdbcArguments and related types

This commit simplifies the OdbcArguments and OdbcArgumentValue structures by removing unnecessary lifetime parameters. The changes enhance code clarity and maintainability while ensuring that the functionality remains intact across the ODBC module. Additionally, adjustments were made to various encoding implementations to reflect these changes.

Author: lovasoa

sqlx-core/src/any/arguments.rs

@@ -48,10 +48,7 @@ pub(crate) enum AnyArgumentBufferKind<'q> {
     ),
 
     #[cfg(feature = "odbc")]
-    Odbc(
-        crate::odbc::OdbcArguments<'q>,
-        std::marker::PhantomData<&'q ()>,
-    ),
+    Odbc(crate::odbc::OdbcArguments, std::marker::PhantomData<&'q ()>),
 }
 
 // control flow inferred type bounds would be fun
@@ -140,7 +137,7 @@ impl<'q> From<AnyArguments<'q>> for crate::postgres::PgArguments {
 
 #[cfg(feature = "odbc")]
 #[allow(irrefutable_let_patterns)]
-impl<'q> From<AnyArguments<'q>> for crate::odbc::OdbcArguments<'q> {
+impl<'q> From<AnyArguments<'q>> for crate::odbc::OdbcArguments {
     fn from(args: AnyArguments<'q>) -> Self {
         let mut buf = AnyArgumentBuffer(AnyArgumentBufferKind::Odbc(
             Default::default(),

sqlx-core/src/odbc/arguments.rs

@@ -4,22 +4,20 @@ use crate::odbc::Odbc;
 use crate::types::Type;
 
 #[derive(Default)]
-pub struct OdbcArguments<'q> {
-    pub(crate) values: Vec<OdbcArgumentValue<'q>>,
+pub struct OdbcArguments {
+    pub(crate) values: Vec<OdbcArgumentValue>,
 }
 
 #[derive(Debug, Clone)]
-pub enum OdbcArgumentValue<'q> {
+pub enum OdbcArgumentValue {
     Text(String),
     Bytes(Vec<u8>),
     Int(i64),
     Float(f64),
     Null,
-    // Borrowed placeholder to satisfy lifetimes; not used for now
-    Phantom(std::marker::PhantomData<&'q ()>),
 }
 
-impl<'q> Arguments<'q> for OdbcArguments<'q> {
+impl<'q> Arguments<'q> for OdbcArguments {
     type Database = Odbc;
 
     fn reserve(&mut self, additional: usize, _size: usize) {
@@ -48,7 +46,7 @@ where
         }
     }
 
-    fn encode(self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode(self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         match self {
             Some(v) => v.encode(buf),
             None => {
@@ -58,7 +56,7 @@ where
         }
     }
 
-    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         match self {
             Some(v) => v.encode_by_ref(buf),
             None => {

sqlx-core/src/odbc/connection/executor.rs

@@ -1,9 +1,7 @@
 use crate::describe::Describe;
 use crate::error::Error;
 use crate::executor::{Execute, Executor};
-use crate::odbc::{
-    Odbc, OdbcArgumentValue, OdbcConnection, OdbcQueryResult, OdbcRow, OdbcStatement, OdbcTypeInfo,
-};
+use crate::odbc::{Odbc, OdbcConnection, OdbcQueryResult, OdbcRow, OdbcStatement, OdbcTypeInfo};
 use either::Either;
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
@@ -17,28 +15,17 @@ impl<'c> Executor<'c> for &'c mut OdbcConnection {
 
     fn fetch_many<'e, 'q: 'e, E>(
         self,
-        mut _query: E,
+        mut query: E,
     ) -> BoxStream<'e, Result<Either<OdbcQueryResult, OdbcRow>, Error>>
     where
         'c: 'e,
         E: Execute<'q, Self::Database> + 'q,
     {
-        let sql = _query.sql().to_string();
-        let mut args = _query.take_arguments();
+        let sql = query.sql().to_string();
+        let mut args = query.take_arguments();
         Box::pin(try_stream! {
-            let rx = if let Some(mut a) = args.take() {
-                let vals: Vec<OdbcArgumentValue<'static>> = std::mem::take(&mut a.values)
-                    .into_iter()
-                    .map(|v| match v {
-                        OdbcArgumentValue::Text(s) => OdbcArgumentValue::Text(s),
-                        OdbcArgumentValue::Bytes(b) => OdbcArgumentValue::Bytes(b),
-                        OdbcArgumentValue::Int(i) => OdbcArgumentValue::Int(i),
-                        OdbcArgumentValue::Float(f) => OdbcArgumentValue::Float(f),
-                        OdbcArgumentValue::Null => OdbcArgumentValue::Null,
-                        OdbcArgumentValue::Phantom(_) => OdbcArgumentValue::Null,
-                    })
-                    .collect();
-                self.worker.execute_stream_with_args(&sql, vals).await?
+            let rx = if let Some(a) = args.take() {
+                self.worker.execute_stream_with_args(&sql, a.values).await?
             } else {
                 self.worker.execute_stream(&sql).await?
             };

sqlx-core/src/odbc/connection/worker.rs

@@ -46,7 +46,7 @@ enum Command {
     },
     ExecuteWithArgs {
         sql: Box<str>,
-        args: Vec<OdbcArgumentValue<'static>>,
+        args: Vec<OdbcArgumentValue>,
         tx: flume::Sender<Result<Either<OdbcQueryResult, OdbcRow>, Error>>,
     },
 }
@@ -193,7 +193,7 @@ impl ConnectionWorker {
     pub(crate) async fn execute_stream_with_args(
         &mut self,
         sql: &str,
-        args: Vec<OdbcArgumentValue<'static>>,
+        args: Vec<OdbcArgumentValue>,
     ) -> Result<flume::Receiver<Result<Either<OdbcQueryResult, OdbcRow>, Error>>, Error> {
         let (tx, rx) = flume::bounded(64);
         self.command_tx
@@ -255,7 +255,7 @@ fn execute_sql(
 fn execute_sql_with_params(
     conn: &odbc_api::Connection<'static>,
     sql: &str,
-    args: Vec<OdbcArgumentValue<'static>>,
+    args: Vec<OdbcArgumentValue>,
     tx: &flume::Sender<Result<Either<OdbcQueryResult, OdbcRow>, Error>>,
 ) {
     if args.is_empty() {
@@ -271,17 +271,13 @@ fn execute_sql_with_params(
     dispatch_execute(conn, sql, &params[..], tx);
 }
 
-fn to_param(
-    arg: OdbcArgumentValue<'static>,
-) -> Box<dyn odbc_api::parameter::InputParameter + 'static> {
+fn to_param(arg: OdbcArgumentValue) -> Box<dyn odbc_api::parameter::InputParameter + 'static> {
     match arg {
         OdbcArgumentValue::Int(i) => Box::new(i.into_parameter()),
         OdbcArgumentValue::Float(f) => Box::new(f.into_parameter()),
         OdbcArgumentValue::Text(s) => Box::new(s.into_parameter()),
         OdbcArgumentValue::Bytes(b) => Box::new(b.into_parameter()),
-        OdbcArgumentValue::Null | OdbcArgumentValue::Phantom(_) => {
-            Box::new(Option::<String>::None.into_parameter())
-        }
+        OdbcArgumentValue::Null => Box::new(Option::<String>::None.into_parameter()),
     }
 }
 

sqlx-core/src/odbc/database.rs

@@ -32,9 +32,9 @@ impl<'r> HasValueRef<'r> for Odbc {
 impl<'q> HasArguments<'q> for Odbc {
     type Database = Odbc;
 
-    type Arguments = crate::odbc::OdbcArguments<'q>;
+    type Arguments = crate::odbc::OdbcArguments;
 
-    type ArgumentBuffer = Vec<crate::odbc::OdbcArgumentValue<'q>>;
+    type ArgumentBuffer = Vec<crate::odbc::OdbcArgumentValue>;
 }
 
 impl<'q> HasStatement<'q> for Odbc {

sqlx-core/src/odbc/mod.rs

@@ -39,7 +39,7 @@ pub trait OdbcExecutor<'c>: Executor<'c, Database = Odbc> {}
 impl<'c, T: Executor<'c, Database = Odbc>> OdbcExecutor<'c> for T {}
 
 // NOTE: required due to the lack of lazy normalization
-impl_into_arguments_for_arguments!(crate::odbc::OdbcArguments<'q>);
+impl_into_arguments_for_arguments!(crate::odbc::OdbcArguments);
 impl_executor_for_pool_connection!(Odbc, OdbcConnection, OdbcRow);
 impl_executor_for_transaction!(Odbc, OdbcRow);
 impl_column_index_for_row!(OdbcRow);

sqlx-core/src/odbc/statement.rs

@@ -34,7 +34,7 @@ impl<'q> Statement<'q> for OdbcStatement<'q> {
     }
 
     // ODBC arguments placeholder
-    impl_statement_query!(crate::odbc::OdbcArguments<'_>);
+    impl_statement_query!(crate::odbc::OdbcArguments);
 }
 
 impl ColumnIndex<OdbcStatement<'_>> for &'_ str {

sqlx-core/src/odbc/types/bigdecimal.rs

@@ -23,12 +23,12 @@ impl Type<Odbc> for BigDecimal {
 }
 
 impl<'q> Encode<'q, Odbc> for BigDecimal {
-    fn encode(self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode(self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Text(self.to_string()));
         crate::encode::IsNull::No
     }
 
-    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Text(self.to_string()));
         crate::encode::IsNull::No
     }

sqlx-core/src/odbc/types/bool.rs

@@ -18,12 +18,12 @@ impl Type<Odbc> for bool {
 }
 
 impl<'q> Encode<'q, Odbc> for bool {
-    fn encode(self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode(self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Int(if self { 1 } else { 0 }));
         crate::encode::IsNull::No
     }
 
-    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Int(if *self { 1 } else { 0 }));
         crate::encode::IsNull::No
     }

sqlx-core/src/odbc/types/bytes.rs

@@ -25,24 +25,24 @@ impl Type<Odbc> for &[u8] {
 }
 
 impl<'q> Encode<'q, Odbc> for Vec<u8> {
-    fn encode(self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode(self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Bytes(self));
         crate::encode::IsNull::No
     }
 
-    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Bytes(self.clone()));
         crate::encode::IsNull::No
     }
 }
 
 impl<'q> Encode<'q, Odbc> for &'q [u8] {
-    fn encode(self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode(self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Bytes(self.to_vec()));
         crate::encode::IsNull::No
     }
 
-    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue<'q>>) -> crate::encode::IsNull {
+    fn encode_by_ref(&self, buf: &mut Vec<OdbcArgumentValue>) -> crate::encode::IsNull {
         buf.push(OdbcArgumentValue::Bytes(self.to_vec()));
         crate::encode::IsNull::No
     }