experiment: custom value serializer

Cargo.toml

@@ -39,7 +39,7 @@ members = [
 async-trait = { version = "0.1.77" }
 enumflags2 = { version = "0.7", features = ["serde"] }
 psl = { path = "./psl/psl" }
-serde_json = { version = "1", features = ["float_roundtrip", "preserve_order"] }
+serde_json = { version = "1", features = ["float_roundtrip", "preserve_order", "raw_value"] }
 serde = { version = "1", features = ["derive"] }
 tokio = { version = "1.25", features = [
   "rt-multi-thread",
@@ -81,14 +81,14 @@ path = "quaint"
 [profile.dev.package.backtrace]
 opt-level = 3
 
-[profile.release.package.query-engine-node-api]
-strip = "symbols"
+# [profile.release.package.query-engine-node-api]
+# strip = "symbols"
 
-[profile.release.package.query-engine]
-strip = "symbols"
+# [profile.release.package.query-engine]
+# strip = "symbols"
 
-[profile.release.package.query-engine-c-abi]
-strip = "symbols"
+# [profile.release.package.query-engine-c-abi]
+# strip = "symbols"
 
 [profile.release]
 lto = "fat"

libs/prisma-value/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod arithmetic;
 
 mod error;
+mod raw_json;
 
 use bigdecimal::{BigDecimal, FromPrimitive, ToPrimitive};
 use chrono::prelude::*;
@@ -11,6 +12,7 @@ use std::{convert::TryFrom, fmt, str::FromStr};
 use uuid::Uuid;
 
 pub use error::ConversionFailure;
+pub use raw_json::RawJson;
 pub type PrismaValueResult<T> = std::result::Result<T, ConversionFailure>;
 pub type PrismaListValue = Vec<PrismaValue>;
 

libs/prisma-value/src/raw_json.rs

@@ -0,0 +1,36 @@
+use serde::Serialize;
+use serde_json::value::RawValue;
+
+/// We are using RawJson object to prevent stringification of
+/// certain JSON values. Difference between this is and PrismaValue::Json
+/// is the following:
+///
+/// PrismaValue::Json(r"""{"foo": "bar"}""") when serialized will produce the string "{\"foo\":\"bar\"}".
+/// RawJson(r"""{"foo": "bar"}""") will produce {"foo": "bar" } JSON object.
+/// So, it essentially would treat provided string as pre-serialized JSON fragment and not a string to be serialized.
+///
+/// It is a wrapper of `serde_json::value::RawValue`. We don't want to use `RawValue` inside of `ArgumentValue`
+/// directly because:
+/// 1. We need `Eq` implementation
+/// 2. `serde_json::value::RawValue::from_string` may error and we'd like to delay handling of that error to
+/// serialization time
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RawJson {
+    value: String,
+}
+
+impl RawJson {
+    pub fn from_string(value: String) -> Self {
+        Self { value }
+    }
+}
+
+impl Serialize for RawJson {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let raw_value = RawValue::from_string(self.value.to_owned()).map_err(serde::ser::Error::custom)?;
+        raw_value.serialize(serializer)
+    }
+}

quaint/Cargo.toml

@@ -89,7 +89,8 @@ native-tls = { version = "0.2", optional = true }
 bit-vec = { version = "0.6.1", optional = true }
 bytes = { version = "1.0", optional = true }
 mobc = { version = "0.8", optional = true }
-serde = { version = "1.0", optional = true }
+serde = { version = "1.0" }
+erased-serde = "0.4.5"
 sqlformat = { version = "0.2.3", optional = true }
 uuid.workspace = true
 crosstarget-utils = { path = "../libs/crosstarget-utils" }

quaint/src/ast/enums.rs

@@ -13,6 +13,10 @@ impl<'a> EnumVariant<'a> {
         self.0.into_owned()
     }
 
+    pub fn inner(&self) -> &str {
+        self.0.as_ref()
+    }
+
     pub fn into_text(self) -> Value<'a> {
         Value::text(self.0)
     }

quaint/src/connector.rs

@@ -17,6 +17,7 @@ pub mod metrics;
 pub mod native;
 mod queryable;
 mod result_set;
+mod ser;
 #[cfg(any(feature = "mssql-native", feature = "postgresql-native", feature = "mysql-native"))]
 mod timeout;
 mod transaction;

quaint/src/connector/result_set.rs

@@ -9,7 +9,7 @@ use serde_json::Map;
 use std::sync::Arc;
 
 /// Encapsulates a set of results and their respective column names.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone, PartialEq)]
 pub struct ResultSet {
     pub(crate) columns: Arc<Vec<String>>,
     pub(crate) rows: Vec<Vec<Value<'static>>>,
@@ -71,14 +71,21 @@ impl ResultSet {
             None => Err(Error::builder(ErrorKind::NotFound).build()),
         }
     }
+
+    pub fn iter(&self) -> ResultSetIterator<'_> {
+        ResultSetIterator {
+            columns: self.columns.clone(),
+            internal_iterator: self.rows.iter(),
+        }
+    }
 }
 
 impl IntoIterator for ResultSet {
     type Item = ResultRow;
-    type IntoIter = ResultSetIterator;
+    type IntoIter = ResultSetIntoIterator;
 
     fn into_iter(self) -> Self::IntoIter {
-        ResultSetIterator {
+        ResultSetIntoIterator {
             columns: self.columns,
             internal_iterator: self.rows.into_iter(),
         }
@@ -87,12 +94,12 @@ impl IntoIterator for ResultSet {
 
 /// Thin iterator for ResultSet rows.
 /// Might become lazy one day.
-pub struct ResultSetIterator {
+pub struct ResultSetIntoIterator {
     pub(crate) columns: Arc<Vec<String>>,
     pub(crate) internal_iterator: std::vec::IntoIter<Vec<Value<'static>>>,
 }
 
-impl Iterator for ResultSetIterator {
+impl Iterator for ResultSetIntoIterator {
     type Item = ResultRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -106,6 +113,25 @@ impl Iterator for ResultSetIterator {
     }
 }
 
+pub struct ResultSetIterator<'a> {
+    pub(crate) columns: Arc<Vec<String>>,
+    pub(crate) internal_iterator: std::slice::Iter<'a, Vec<Value<'static>>>,
+}
+
+impl<'a> Iterator for ResultSetIterator<'a> {
+    type Item = ResultRowRef<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.internal_iterator.next() {
+            Some(row) => Some(ResultRowRef {
+                columns: Arc::clone(&self.columns),
+                values: row,
+            }),
+            None => None,
+        }
+    }
+}
+
 impl From<ResultSet> for serde_json::Value {
     fn from(result_set: ResultSet) -> Self {
         let columns: Vec<String> = result_set.columns().iter().map(ToString::to_string).collect();

quaint/src/connector/ser.rs

@@ -0,0 +1,114 @@
+use super::ResultSet;
+use crate::{Value, ValueType};
+use ser::SerializeSeq as _;
+use serde::*;
+
+#[derive(Serialize)]
+struct SerializedResultSet<'a> {
+    columns: &'a Vec<String>,
+    types: SerializedTypes<'a>,
+    rows: &'a Vec<Vec<Value<'a>>>,
+}
+
+struct SerializedTypes<'a>(&'a Vec<Value<'a>>);
+
+impl<'a> Serialize for SerializedTypes<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
+
+        for value in self.0 {
+            seq.serialize_element(get_value_type_name(value))?;
+        }
+
+        seq.end()
+    }
+}
+
+impl serde::Serialize for ResultSet {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        SerializedResultSet {
+            columns: self.columns(),
+            types: SerializedTypes(&self.rows[0]),
+            rows: &self.rows,
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'a> Serialize for Value<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let val = &self;
+
+        if val.is_null() {
+            return serde_json::Value::Null.serialize(serializer);
+        }
+
+        match &val.typed {
+            ValueType::Array(Some(values)) => {
+                let mut seq = serializer.serialize_seq(Some(values.len()))?;
+
+                for value in values {
+                    seq.serialize_element(value)?;
+                }
+
+                seq.end()
+            }
+            ValueType::Int32(Some(value)) => value.serialize(serializer),
+            ValueType::Int64(Some(value)) => value.to_string().serialize(serializer),
+            ValueType::Numeric(Some(value)) => value.normalized().to_string().serialize(serializer),
+
+            ValueType::Float(Some(value)) => value.serialize(serializer),
+            ValueType::Double(Some(value)) => value.serialize(serializer),
+            ValueType::Text(Some(value)) => value.serialize(serializer),
+            ValueType::Enum(value, _) => value.as_ref().map(|val| val.inner()).serialize(serializer),
+            ValueType::EnumArray(_, _) => {
+                todo!()
+            }
+            ValueType::Bytes(Some(value)) => base64::encode(value).serialize(serializer),
+            ValueType::Boolean(Some(value)) => value.serialize(serializer),
+            ValueType::Char(Some(value)) => value.serialize(serializer),
+            ValueType::Json(Some(value)) => value.serialize(serializer),
+            ValueType::Xml(Some(value)) => value.serialize(serializer),
+            ValueType::Uuid(Some(value)) => value.serialize(serializer),
+            ValueType::DateTime(Some(value)) => value.to_rfc3339().serialize(serializer),
+            ValueType::Date(Some(value)) => value.serialize(serializer),
+            ValueType::Time(Some(value)) => value.serialize(serializer),
+            _ => unreachable!(),
+        }
+    }
+}
+
+fn get_value_type_name<'a>(value: &'a Value<'_>) -> &'a str {
+    if value.is_null() {
+        return "null";
+    }
+
+    match &value.typed {
+        crate::ValueType::Int32(_) => "int",
+        crate::ValueType::Int64(_) => "bigint",
+        crate::ValueType::Float(_) => "float",
+        crate::ValueType::Double(_) => "double",
+        crate::ValueType::Text(_) => "string",
+        crate::ValueType::Enum(_, _) => "enum",
+        crate::ValueType::Bytes(_) => "bytes",
+        crate::ValueType::Boolean(_) => "bool",
+        crate::ValueType::Char(_) => "char",
+        crate::ValueType::Numeric(_) => "decimal",
+        crate::ValueType::Json(_) => "json",
+        crate::ValueType::Xml(_) => "xml",
+        crate::ValueType::Uuid(_) => "uuid",
+        crate::ValueType::DateTime(_) => "datetime",
+        crate::ValueType::Date(_) => "date",
+        crate::ValueType::Time(_) => "time",
+        crate::ValueType::Array(_) | crate::ValueType::EnumArray(_, _) => "array",
+    }
+}

query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/response.rs

@@ -67,6 +67,7 @@ fn item_ref_to_owned_item(item_ref: ItemRef) -> Item {
         Item::List(list) => Item::List(list.to_owned()),
         Item::Value(val) => Item::Value(val.to_owned()),
         Item::Json(json) => Item::Json(json.to_owned()),
+        Item::RawJson(json) => Item::RawJson(json.clone()),
         Item::Ref(nested_ref) => item_ref_to_owned_item(nested_ref.clone()),
     }
 }