Value: box BigDecimal and Array (#931)

These two types are already internally heap-allocated.

And boxing these two would bring down Value to 32 bytes.

I hope this is a fair trade off.

Author: tyt2y3

sea-query-binder/src/sqlx_mysql.rs

@@ -100,7 +100,7 @@ impl sqlx::IntoArguments<'_, sqlx::mysql::MySql> for SqlxValues {
                 }
                 #[cfg(feature = "with-bigdecimal")]
                 Value::BigDecimal(d) => {
-                    let _ = args.add(d);
+                    let _ = args.add(d.as_deref());
                 }
                 #[cfg(feature = "with-json")]
                 Value::Json(j) => {

sea-query-binder/src/sqlx_postgres.rs

@@ -115,7 +115,7 @@ impl sqlx::IntoArguments<'_, sqlx::postgres::Postgres> for SqlxValues {
                 }
                 #[cfg(feature = "with-bigdecimal")]
                 Value::BigDecimal(d) => {
-                    let _ = args.add(d);
+                    let _ = args.add(d.as_deref());
                 }
                 #[cfg(feature = "with-json")]
                 Value::Json(j) => {

sea-query-postgres/src/lib.rs

@@ -102,7 +102,7 @@ impl ToSql for PostgresValue {
             #[cfg(feature = "with-bigdecimal")]
             Value::BigDecimal(v) => {
                 use bigdecimal::ToPrimitive;
-                v.as_ref()
+                v.as_deref()
                     .map(|v| v.to_f64().expect("Fail to convert bigdecimal as f64"))
                     .to_sql(ty, out)
             }

src/value.rs

@@ -196,11 +196,11 @@ pub enum Value {
 
     #[cfg(feature = "with-bigdecimal")]
     #[cfg_attr(docsrs, doc(cfg(feature = "with-bigdecimal")))]
-    BigDecimal(Option<BigDecimal>),
+    BigDecimal(Option<Box<BigDecimal>>),
 
     #[cfg(feature = "postgres-array")]
     #[cfg_attr(docsrs, doc(cfg(feature = "postgres-array")))]
-    Array(ArrayType, Option<Vec<Value>>),
+    Array(ArrayType, Option<Box<Vec<Value>>>),
 
     #[cfg(feature = "postgres-vector")]
     #[cfg_attr(docsrs, doc(cfg(feature = "postgres-vector")))]
@@ -215,6 +215,19 @@ pub enum Value {
     MacAddress(Option<MacAddress>),
 }
 
+/// This test is to check if the size of [`Value`] exceeds the limit.
+/// If the size exceeds the limit, you should box the variant.
+/// Previously, the size was 24. We bumped it to 32 such that `String`
+/// can be unboxed.
+pub const VALUE_SIZE: usize = check_value_size();
+
+const fn check_value_size() -> usize {
+    if std::mem::size_of::<Value>() > 32 {
+        panic!("the size of Value shouldn't be greater than 32 bytes")
+    }
+    std::mem::size_of::<Value>()
+}
+
 impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", CommonSqlQueryBuilder.value_to_string(self))
@@ -543,6 +556,45 @@ macro_rules! type_to_value {
     };
 }
 
+#[cfg(feature = "with-bigdecimal")]
+macro_rules! type_to_box_value {
+    ( $type: ty, $name: ident, $col_type: expr ) => {
+        impl From<$type> for Value {
+            fn from(x: $type) -> Value {
+                Value::$name(Some(Box::new(x)))
+            }
+        }
+
+        impl Nullable for $type {
+            fn null() -> Value {
+                Value::$name(None)
+            }
+        }
+
+        impl ValueType for $type {
+            fn try_from(v: Value) -> Result<Self, ValueTypeErr> {
+                match v {
+                    Value::$name(Some(x)) => Ok(*x),
+                    _ => Err(ValueTypeErr),
+                }
+            }
+
+            fn type_name() -> String {
+                stringify!($type).to_owned()
+            }
+
+            fn array_type() -> ArrayType {
+                ArrayType::$name
+            }
+
+            fn column_type() -> ColumnType {
+                use ColumnType::*;
+                $col_type
+            }
+        }
+    };
+}
+
 type_to_value!(bool, Bool, Boolean);
 type_to_value!(i8, TinyInt, TinyInteger);
 type_to_value!(i16, SmallInt, SmallInteger);
@@ -839,7 +891,7 @@ mod with_rust_decimal {
 mod with_bigdecimal {
     use super::*;
 
-    type_to_value!(BigDecimal, BigDecimal, Decimal(None));
+    type_to_box_value!(BigDecimal, BigDecimal, Decimal(None));
 }
 
 #[cfg(feature = "with-uuid")]
@@ -996,7 +1048,7 @@ pub mod with_array {
         fn from(x: Vec<T>) -> Value {
             Value::Array(
                 T::array_type(),
-                Some(x.into_iter().map(|e| e.into()).collect()),
+                Some(Box::new(x.into_iter().map(|e| e.into()).collect())),
             )
         }
     }
@@ -1636,12 +1688,14 @@ pub fn sea_value_to_json_value(value: &Value) -> Json {
         #[cfg(feature = "with-bigdecimal")]
         Value::BigDecimal(Some(v)) => {
             use bigdecimal::ToPrimitive;
-            v.to_f64().unwrap().into()
+            v.as_ref().to_f64().unwrap().into()
         }
         #[cfg(feature = "with-uuid")]
         Value::Uuid(Some(v)) => Json::String(v.to_string()),
         #[cfg(feature = "postgres-array")]
-        Value::Array(_, Some(v)) => Json::Array(v.iter().map(sea_value_to_json_value).collect()),
+        Value::Array(_, Some(v)) => {
+            Json::Array(v.as_ref().iter().map(sea_value_to_json_value).collect())
+        }
         #[cfg(feature = "postgres-vector")]
         Value::Vector(Some(v)) => Json::Array(v.as_slice().iter().map(|&v| v.into()).collect()),
         #[cfg(feature = "with-ipnetwork")]
@@ -2409,6 +2463,7 @@ mod hashable_value {
                         Value::Int(Some(1)),
                         Value::Int(Some(2))
                     ])
+                    .into()
                 )
             )
         );
@@ -2423,6 +2478,7 @@ mod hashable_value {
                         Value::Float(Some(1.0)),
                         Value::Float(Some(2.0))
                     ])
+                    .into()
                 )
             )
         );