refactor(sqlite): Improve support for references as query macro bind arguments by removing lifetime parameter from SqliteArguments

Signed-off-by: Joshua Potts <[email protected]>

Author: iamjpotts

sqlx-sqlite/src/any.rs

@@ -203,8 +203,7 @@ impl<'a> TryFrom<&'a AnyConnectOptions> for SqliteConnectOptions {
     }
 }
 
-/// Instead of `AnyArguments::convert_into()`, we can do a direct mapping and preserve the lifetime.
-fn map_arguments(args: AnyArguments<'_>) -> SqliteArguments<'_> {
+fn map_arguments(args: AnyArguments<'_>) -> SqliteArguments {
     SqliteArguments {
         values: args
             .values
@@ -218,8 +217,8 @@ fn map_arguments(args: AnyArguments<'_>) -> SqliteArguments<'_> {
                 AnyValueKind::BigInt(i) => SqliteArgumentValue::Int64(i),
                 AnyValueKind::Real(r) => SqliteArgumentValue::Double(r as f64),
                 AnyValueKind::Double(d) => SqliteArgumentValue::Double(d),
-                AnyValueKind::Text(t) => SqliteArgumentValue::Text(t),
-                AnyValueKind::Blob(b) => SqliteArgumentValue::Blob(b),
+                AnyValueKind::Text(t) => SqliteArgumentValue::Text(t.to_string()),
+                AnyValueKind::Blob(b) => SqliteArgumentValue::Blob(b.to_vec()),
                 // AnyValueKind is `#[non_exhaustive]` but we should have covered everything
                 _ => unreachable!("BUG: missing mapping for {val:?}"),
             })

sqlx-sqlite/src/arguments.rs

@@ -4,27 +4,26 @@ use crate::statement::StatementHandle;
 use crate::Sqlite;
 use atoi::atoi;
 use libsqlite3_sys::SQLITE_OK;
-use std::borrow::Cow;
 
 pub(crate) use sqlx_core::arguments::*;
 use sqlx_core::error::BoxDynError;
 
 #[derive(Debug, Clone)]
-pub enum SqliteArgumentValue<'q> {
+pub enum SqliteArgumentValue {
     Null,
-    Text(Cow<'q, str>),
-    Blob(Cow<'q, [u8]>),
+    Text(String),
+    Blob(Vec<u8>),
     Double(f64),
     Int(i32),
     Int64(i64),
 }
 
 #[derive(Default, Debug, Clone)]
-pub struct SqliteArguments<'q> {
-    pub(crate) values: Vec<SqliteArgumentValue<'q>>,
+pub struct SqliteArguments {
+    pub(crate) values: Vec<SqliteArgumentValue>,
 }
 
-impl<'q> SqliteArguments<'q> {
+impl<'q> SqliteArguments {
     pub(crate) fn add<T>(&mut self, value: T) -> Result<(), BoxDynError>
     where
         T: Encode<'q, Sqlite>,
@@ -43,19 +42,9 @@ impl<'q> SqliteArguments<'q> {
 
         Ok(())
     }
-
-    pub(crate) fn into_static(self) -> SqliteArguments<'static> {
-        SqliteArguments {
-            values: self
-                .values
-                .into_iter()
-                .map(SqliteArgumentValue::into_static)
-                .collect(),
-        }
-    }
 }
 
-impl<'q> Arguments<'q> for SqliteArguments<'q> {
+impl<'q> Arguments<'q> for SqliteArguments {
     type Database = Sqlite;
 
     fn reserve(&mut self, len: usize, _size_hint: usize) {
@@ -74,7 +63,7 @@ impl<'q> Arguments<'q> for SqliteArguments<'q> {
     }
 }
 
-impl SqliteArguments<'_> {
+impl SqliteArguments {
     pub(super) fn bind(&self, handle: &mut StatementHandle, offset: usize) -> Result<usize, Error> {
         let mut arg_i = offset;
         // for handle in &statement.handles {
@@ -120,20 +109,7 @@ impl SqliteArguments<'_> {
     }
 }
 
-impl SqliteArgumentValue<'_> {
-    fn into_static(self) -> SqliteArgumentValue<'static> {
-        use SqliteArgumentValue::*;
-
-        match self {
-            Null => Null,
-            Text(text) => Text(text.into_owned().into()),
-            Blob(blob) => Blob(blob.into_owned().into()),
-            Int(v) => Int(v),
-            Int64(v) => Int64(v),
-            Double(v) => Double(v),
-        }
-    }
-
+impl SqliteArgumentValue {
     fn bind(&self, handle: &mut StatementHandle, i: usize) -> Result<(), Error> {
         use SqliteArgumentValue::*;
 

sqlx-sqlite/src/connection/execute.rs

@@ -10,7 +10,7 @@ pub struct ExecuteIter<'a> {
     handle: &'a mut ConnectionHandle,
     statement: &'a mut VirtualStatement,
     logger: QueryLogger,
-    args: Option<SqliteArguments<'a>>,
+    args: Option<SqliteArguments>,
 
     /// since a `VirtualStatement` can encompass multiple actual statements,
     /// this keeps track of the number of arguments so far
@@ -19,12 +19,12 @@ pub struct ExecuteIter<'a> {
     goto_next: bool,
 }
 
-pub(crate) fn iter<'a>(
-    conn: &'a mut ConnectionState,
+pub(crate) fn iter(
+    conn: &mut ConnectionState,
     query: impl SqlSafeStr,
-    args: Option<SqliteArguments<'a>>,
+    args: Option<SqliteArguments>,
     persistent: bool,
-) -> Result<ExecuteIter<'a>, Error> {
+) -> Result<ExecuteIter<'_>, Error> {
     let query = query.into_sql_str();
     // fetch the cached statement or allocate a new one
     let statement = conn.statements.get(query.as_str(), persistent)?;
@@ -43,7 +43,7 @@ pub(crate) fn iter<'a>(
 
 fn bind(
     statement: &mut StatementHandle,
-    arguments: &Option<SqliteArguments<'_>>,
+    arguments: &Option<SqliteArguments>,
     offset: usize,
 ) -> Result<usize, Error> {
     let mut n = 0;
@@ -56,7 +56,7 @@ fn bind(
 }
 
 impl ExecuteIter<'_> {
-    pub fn finish(&mut self) -> Result<(), Error> {
+    pub fn finish(self) -> Result<(), Error> {
         for res in self {
             let _ = res?;
         }

sqlx-sqlite/src/connection/worker.rs

@@ -63,7 +63,7 @@ enum Command {
     },
     Execute {
         query: SqlStr,
-        arguments: Option<SqliteArguments<'static>>,
+        arguments: Option<SqliteArguments>,
         persistent: bool,
         tx: flume::Sender<Result<Either<SqliteQueryResult, SqliteRow>, Error>>,
         limit: Option<usize>,
@@ -353,7 +353,7 @@ impl ConnectionWorker {
     pub(crate) async fn execute(
         &mut self,
         query: SqlStr,
-        args: Option<SqliteArguments<'_>>,
+        args: Option<SqliteArguments>,
         chan_size: usize,
         persistent: bool,
         limit: Option<usize>,
@@ -364,7 +364,7 @@ impl ConnectionWorker {
             .send_async((
                 Command::Execute {
                     query,
-                    arguments: args.map(SqliteArguments::into_static),
+                    arguments: args,
                     persistent,
                     tx,
                     limit,

sqlx-sqlite/src/database.rs

@@ -26,8 +26,8 @@ impl Database for Sqlite {
     type Value = SqliteValue;
     type ValueRef<'r> = SqliteValueRef<'r>;
 
-    type Arguments<'q> = SqliteArguments<'q>;
-    type ArgumentBuffer<'q> = Vec<SqliteArgumentValue<'q>>;
+    type Arguments<'q> = SqliteArguments;
+    type ArgumentBuffer<'q> = Vec<SqliteArgumentValue>;
 
     type Statement = SqliteStatement;
 

sqlx-sqlite/src/lib.rs

@@ -147,7 +147,7 @@ impl<'c, T: Executor<'c, Database = Sqlite>> SqliteExecutor<'c> for T {}
 pub type SqliteTransaction<'c> = sqlx_core::transaction::Transaction<'c, Sqlite>;
 
 // NOTE: required due to the lack of lazy normalization
-impl_into_arguments_for_arguments!(SqliteArguments<'q>);
+impl_into_arguments_for_arguments!(SqliteArguments);
 impl_column_index_for_row!(SqliteRow);
 impl_column_index_for_statement!(SqliteStatement);
 impl_acquire!(Sqlite, SqliteConnection);

sqlx-sqlite/src/statement/mod.rs

@@ -45,7 +45,7 @@ impl Statement for SqliteStatement {
         &self.columns
     }
 
-    impl_statement_query!(SqliteArguments<'_>);
+    impl_statement_query!(SqliteArguments);
 }
 
 impl ColumnIndex<SqliteStatement> for &'_ str {

sqlx-sqlite/src/types/bool.rs

@@ -16,10 +16,7 @@ impl Type<Sqlite> for bool {
 }
 
 impl<'q> Encode<'q, Sqlite> for bool {
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'q>>,
-    ) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         args.push(SqliteArgumentValue::Int((*self).into()));
 
         Ok(IsNull::No)

sqlx-sqlite/src/types/bytes.rs

@@ -20,11 +20,8 @@ impl Type<Sqlite> for [u8] {
 }
 
 impl<'q> Encode<'q, Sqlite> for &'q [u8] {
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'q>>,
-    ) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(Cow::Borrowed(self)));
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.to_vec()));
 
         Ok(IsNull::No)
     }
@@ -37,19 +34,14 @@ impl<'r> Decode<'r, Sqlite> for &'r [u8] {
 }
 
 impl Encode<'_, Sqlite> for Box<[u8]> {
-    fn encode(self, args: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(Cow::Owned(self.into_vec())));
+    fn encode(self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.into_vec()));
 
         Ok(IsNull::No)
     }
 
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'_>>,
-    ) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(Cow::Owned(
-            self.clone().into_vec(),
-        )));
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.clone().into_vec()));
 
         Ok(IsNull::No)
     }
@@ -66,17 +58,14 @@ impl Type<Sqlite> for Vec<u8> {
 }
 
 impl<'q> Encode<'q, Sqlite> for Vec<u8> {
-    fn encode(self, args: &mut Vec<SqliteArgumentValue<'q>>) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(Cow::Owned(self)));
+    fn encode(self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self));
 
         Ok(IsNull::No)
     }
 
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'q>>,
-    ) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(Cow::Owned(self.clone())));
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.clone()));
 
         Ok(IsNull::No)
     }
@@ -89,36 +78,27 @@ impl<'r> Decode<'r, Sqlite> for Vec<u8> {
 }
 
 impl<'q> Encode<'q, Sqlite> for Cow<'q, [u8]> {
-    fn encode(self, args: &mut Vec<SqliteArgumentValue<'q>>) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(self));
+    fn encode(self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.to_vec()));
 
         Ok(IsNull::No)
     }
 
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'q>>,
-    ) -> Result<IsNull, BoxDynError> {
-        args.push(SqliteArgumentValue::Blob(self.clone()));
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.to_vec()));
 
         Ok(IsNull::No)
     }
 }
 
 impl<'q> Encode<'q, Sqlite> for Arc<[u8]> {
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'q>>,
-    ) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         <Vec<u8> as Encode<'_, Sqlite>>::encode(self.to_vec(), args)
     }
 }
 
 impl<'q> Encode<'q, Sqlite> for Rc<[u8]> {
-    fn encode_by_ref(
-        &self,
-        args: &mut Vec<SqliteArgumentValue<'q>>,
-    ) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, args: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         <Vec<u8> as Encode<'_, Sqlite>>::encode(self.to_vec(), args)
     }
 }

sqlx-sqlite/src/types/chrono.rs

@@ -65,25 +65,25 @@ impl<Tz: TimeZone> Encode<'_, Sqlite> for DateTime<Tz>
 where
     Tz::Offset: Display,
 {
-    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         Encode::<Sqlite>::encode(self.to_rfc3339_opts(SecondsFormat::AutoSi, false), buf)
     }
 }
 
 impl Encode<'_, Sqlite> for NaiveDateTime {
-    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         Encode::<Sqlite>::encode(self.format("%F %T%.f").to_string(), buf)
     }
 }
 
 impl Encode<'_, Sqlite> for NaiveDate {
-    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         Encode::<Sqlite>::encode(self.format("%F").to_string(), buf)
     }
 }
 
 impl Encode<'_, Sqlite> for NaiveTime {
-    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
+    fn encode_by_ref(&self, buf: &mut Vec<SqliteArgumentValue>) -> Result<IsNull, BoxDynError> {
         Encode::<Sqlite>::encode(self.format("%T%.f").to_string(), buf)
     }
 }