WIP

Author: gammelalf

src/conditional.rs

@@ -333,7 +333,7 @@ impl<'a> BuildCondition<'a> for Condition<'a> {
                 Value::Null(NullType::Choice) => write!(writer, "NULL"),
 
                 _ => {
-                    lookup.push(*value);
+                    lookup.push(value.clone());
                     match dialect {
                         #[cfg(feature = "sqlite")]
                         DBImpl::SQLite => {

src/cows.rs

@@ -0,0 +1,94 @@
+//! Alternate [`Cow`]s which are covariant over their second argument
+
+use std::borrow::Cow;
+use std::ops::Deref;
+
+/// [`Cow<'a, [T]>`](Cow) which is covariant over `T`.
+#[derive(Clone, Debug, PartialEq)]
+pub enum VecCow<'a, T> {
+    /// Borrowed data
+    Borrowed(&'a [T]),
+
+    /// Owned data
+    Owned(Vec<T>),
+}
+
+impl<'a, T> Deref for VecCow<'a, T> {
+    type Target = [T];
+
+    fn deref(&self) -> &[T] {
+        match self {
+            VecCow::Borrowed(slice) => slice,
+            VecCow::Owned(vec) => vec,
+        }
+    }
+}
+
+impl<'a, T> From<Cow<'a, [T]>> for VecCow<'a, T>
+where
+    T: Clone,
+{
+    fn from(value: Cow<'a, [T]>) -> Self {
+        match value {
+            Cow::Borrowed(x) => Self::Borrowed(x),
+            Cow::Owned(x) => Self::Owned(x),
+        }
+    }
+}
+
+impl<'a, T> From<&'a [T]> for VecCow<'a, T> {
+    fn from(value: &'a [T]) -> Self {
+        Self::Borrowed(value)
+    }
+}
+
+impl<'a, T> From<Vec<T>> for VecCow<'a, T> {
+    fn from(value: Vec<T>) -> Self {
+        Self::Owned(value)
+    }
+}
+
+/// `Cow<'a, T>` which is covariant over `T`.
+#[derive(Clone, Debug, PartialEq)]
+pub enum RefCow<'a, T> {
+    /// Borrowed data
+    Borrowed(&'a T),
+
+    /// Owned data
+    Owned(T),
+}
+
+impl<'a, T> Deref for RefCow<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        match self {
+            Self::Borrowed(x) => x,
+            Self::Owned(x) => x,
+        }
+    }
+}
+
+impl<'a, T> From<Cow<'a, T>> for RefCow<'a, T>
+where
+    T: Clone,
+{
+    fn from(value: Cow<'a, T>) -> Self {
+        match value {
+            Cow::Borrowed(x) => Self::Borrowed(x),
+            Cow::Owned(x) => Self::Owned(x),
+        }
+    }
+}
+
+impl<'a, T> From<&'a T> for RefCow<'a, T> {
+    fn from(value: &'a T) -> Self {
+        Self::Borrowed(value)
+    }
+}
+
+impl<'a, T> From<T> for RefCow<'a, T> {
+    fn from(value: T) -> Self {
+        Self::Owned(value)
+    }
+}

src/insert.rs

@@ -198,7 +198,7 @@ impl<'post_build> Insert<'post_build> for InsertImpl<'_, 'post_build> {
                             Value::Choice(c) => write!(s, "{}", postgres::fmt(c)).unwrap(),
                             Value::Null(NullType::Choice) => write!(s, "NULL").unwrap(),
                             _ => {
-                                d.lookup.push(*y);
+                                d.lookup.push(y.clone());
                                 write!(s, "${}", d.lookup.len()).unwrap();
                             }
                         }

src/join_table.rs

@@ -1,7 +1,7 @@
-use std::borrow::Cow;
 use std::fmt::{Display, Formatter, Write};
 
 use crate::conditional::{BuildCondition, Condition};
+use crate::cows::RefCow;
 use crate::value::Value;
 use crate::DBImpl;
 
@@ -79,7 +79,16 @@ pub struct JoinTableData<'until_build, 'post_query> {
     /// Alias for the join table
     pub join_alias: &'until_build str,
     /// Condition to apply the join on
-    pub join_condition: Cow<'until_build, Condition<'post_query>>,
+    pub join_condition: RefCow<'until_build, Condition<'post_query>>,
+}
+
+/// [`JoinTableData`] should not be invariant over `'post_query`
+#[expect(unused)]
+fn test_variance<'a, 'b, 'c>(x: JoinTableData<'c, 'a>) -> JoinTableData<'c, 'b>
+where
+    'a: 'b,
+{
+    x
 }
 
 /**

src/lib.rs

@@ -44,15 +44,15 @@ pub mod update;
 /// Implementation of supported datatypes
 pub mod value;
 
+pub mod cows;
 mod db_specific;
 
-use std::borrow::Cow;
-
 use rorm_declaration::imr::{Annotation, DbType};
 
 use crate::aggregation::SelectAggregator;
 use crate::alter_table::{AlterTable, AlterTableData, AlterTableImpl, AlterTableOperation};
 use crate::conditional::Condition;
+use crate::cows::RefCow;
 #[cfg(feature = "postgres")]
 use crate::create_column::CreateColumnPostgresData;
 #[cfg(feature = "sqlite")]
@@ -417,7 +417,7 @@ impl DBImpl {
         join_type: JoinType,
         table_name: &'until_build str,
         join_alias: &'until_build str,
-        join_condition: Cow<'until_build, Condition<'post_query>>,
+        join_condition: RefCow<'until_build, Condition<'post_query>>,
     ) -> JoinTableImpl<'until_build, 'post_query> {
         let d = JoinTableData {
             join_type,

src/update.rs

@@ -174,7 +174,7 @@ impl<'until_build, 'post_build> Update<'until_build, 'post_build>
                 let update_index = d.updates.len() - 1;
                 for (idx, (name, value)) in d.updates.into_iter().enumerate() {
                     if let Value::Choice(c) = value {
-                        write!(s, "\"{name}\" = {}", postgres::fmt(c)).unwrap();
+                        write!(s, "\"{name}\" = {}", postgres::fmt(&c)).unwrap();
                     } else if let Value::Null(NullType::Choice) = value {
                         write!(s, "\"{name}\" = NULL").unwrap();
                     } else {

src/value.rs

@@ -1,7 +1,11 @@
+use std::borrow::Cow;
+
 use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
 use time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
 use uuid::Uuid;
 
+use crate::cows::VecCow;
+
 /// This enum represents a [Null](Value::Null)'s type
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum NullType {
@@ -61,27 +65,27 @@ pub enum NullType {
 /**
 This enum represents a value
  */
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Value<'a> {
     /// null representation
     Null(NullType),
     /// Representation of an identifier, e.g. a column.
     /// This variant will not be escaped, so do not
     /// pass unchecked data to it.
     #[deprecated(note = "Is this still used?")]
-    Ident(&'a str),
+    Ident(Cow<'a, str>),
     /// Representation of a column name with
     /// an optional table name
     Column {
         /// Name of the table
-        table_name: Option<&'a str>,
+        table_name: Option<Cow<'a, str>>,
         /// Name of the column
-        column_name: &'a str,
+        column_name: Cow<'a, str>,
     },
     /// Representation of choices
-    Choice(&'a str),
+    Choice(Cow<'a, str>),
     /// String representation
-    String(&'a str),
+    String(Cow<'a, str>),
     /// i64 representation
     I64(i64),
     /// i32 representation
@@ -95,7 +99,7 @@ pub enum Value<'a> {
     /// f32 representation
     F32(f32),
     /// binary representation
-    Binary(&'a [u8]),
+    Binary(Cow<'a, [u8]>),
     /// chrono's Naive Time representation
     ChronoNaiveTime(NaiveTime),
     /// chrono's Naive Date representation
@@ -131,73 +135,82 @@ pub enum Value<'a> {
     IpNetwork(ipnetwork::IpNetwork),
     /// Bit vec representation
     #[cfg(feature = "postgres-only")]
-    BitVec(&'a bit_vec::BitVec),
+    BitVec(Cow<'a, bit_vec::BitVec>),
 
     /// null representation
     #[cfg(feature = "postgres-only")]
     ArrayNull(NullType),
     /// String representation
     #[cfg(feature = "postgres-only")]
-    ArrayString(&'a [&'a str]),
+    ArrayString(VecCow<'a, Cow<'a, str>>),
     /// i64 representation
     #[cfg(feature = "postgres-only")]
-    ArrayI64(&'a [i64]),
+    ArrayI64(VecCow<'a, i64>),
     /// i32 representation
     #[cfg(feature = "postgres-only")]
-    ArrayI32(&'a [i32]),
+    ArrayI32(VecCow<'a, i32>),
     /// i16 representation
     #[cfg(feature = "postgres-only")]
-    ArrayI16(&'a [i16]),
+    ArrayI16(VecCow<'a, i16>),
     /// Bool representation
     #[cfg(feature = "postgres-only")]
-    ArrayBool(&'a [bool]),
+    ArrayBool(VecCow<'a, bool>),
     /// f64 representation
     #[cfg(feature = "postgres-only")]
-    ArrayF64(&'a [f64]),
+    ArrayF64(VecCow<'a, f64>),
     /// f32 representation
     #[cfg(feature = "postgres-only")]
-    ArrayF32(&'a [f32]),
+    ArrayF32(VecCow<'a, f32>),
     /// binary representation
     #[cfg(feature = "postgres-only")]
-    ArrayBinary(&'a [&'a [u8]]),
+    ArrayBinary(VecCow<'a, Cow<'a, [u8]>>),
     /// chrono's Naive Time representation
     #[cfg(feature = "postgres-only")]
-    ArrayChronoNaiveTime(&'a [NaiveTime]),
+    ArrayChronoNaiveTime(VecCow<'a, NaiveTime>),
     /// chrono's Naive Date representation
     #[cfg(feature = "postgres-only")]
-    ArrayChronoNaiveDate(&'a [NaiveDate]),
+    ArrayChronoNaiveDate(VecCow<'a, NaiveDate>),
     /// chrono's Naive DateTime representation
     #[cfg(feature = "postgres-only")]
-    ArrayChronoNaiveDateTime(&'a [NaiveDateTime]),
+    ArrayChronoNaiveDateTime(VecCow<'a, NaiveDateTime>),
     /// chrono's Timezone aware datetime
     #[cfg(feature = "postgres-only")]
-    ArrayChronoDateTime(&'a [DateTime<Utc>]),
+    ArrayChronoDateTime(VecCow<'a, DateTime<Utc>>),
     /// time's date representation
     #[cfg(feature = "postgres-only")]
-    ArrayTimeDate(&'a [Date]),
+    ArrayTimeDate(VecCow<'a, Date>),
     /// time's time representation
     #[cfg(feature = "postgres-only")]
-    ArrayTimeTime(&'a [Time]),
+    ArrayTimeTime(VecCow<'a, Time>),
     /// time's offset datetime representation
     #[cfg(feature = "postgres-only")]
-    ArrayTimeOffsetDateTime(&'a [OffsetDateTime]),
+    ArrayTimeOffsetDateTime(VecCow<'a, OffsetDateTime>),
     /// time's primitive datetime representation
     #[cfg(feature = "postgres-only")]
-    ArrayTimePrimitiveDateTime(&'a [PrimitiveDateTime]),
+    ArrayTimePrimitiveDateTime(VecCow<'a, PrimitiveDateTime>),
     /// Uuid representation
     #[cfg(feature = "postgres-only")]
-    ArrayUuid(&'a [Uuid]),
+    ArrayUuid(VecCow<'a, Uuid>),
     /// serde_json's Value representation
     #[cfg(feature = "postgres-only")]
-    ArrayJsonValue(&'a [&'a serde_json::Value]),
+    ArrayJsonValue(VecCow<'a, &'a serde_json::Value>),
 
     /// Mac address representation
     #[cfg(feature = "postgres-only")]
-    ArrayMacAddress(&'a [mac_address::MacAddress]),
+    ArrayMacAddress(VecCow<'a, mac_address::MacAddress>),
     /// IP network presentation
     #[cfg(feature = "postgres-only")]
-    ArrayIpNetwork(&'a [ipnetwork::IpNetwork]),
+    ArrayIpNetwork(VecCow<'a, ipnetwork::IpNetwork>),
     /// Bit vec representation
     #[cfg(feature = "postgres-only")]
-    ArrayBitVec(&'a [&'a bit_vec::BitVec]),
+    ArrayBitVec(VecCow<'a, Cow<'a, bit_vec::BitVec>>),
+}
+
+/// [`Value`] should be covariant over `'a`
+#[expect(unused)]
+fn test_variance<'a, 'b>(x: Value<'a>) -> Value<'b>
+where
+    'a: 'b,
+{
+    x
 }