remove configurable binary serialize, add enum for doc store version

Author: PSeitz

common/src/datetime.rs

@@ -1,11 +1,11 @@
 use std::fmt;
-use std::io::{self, Read, Write};
+use std::io::{Read, Write};
 
 use serde::{Deserialize, Serialize};
 use time::format_description::well_known::Rfc3339;
 use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
 
-use crate::{BinarySerializable, BinarySerializableConfig, ConfigurableBinarySerializable};
+use crate::BinarySerializable;
 
 /// Precision with which datetimes are truncated when stored in fast fields. This setting is only
 /// relevant for fast fields. In the docstore, datetimes are always saved with nanosecond precision.
@@ -174,29 +174,3 @@ impl BinarySerializable for DateTime {
         Ok(Self::from_timestamp_micros(timestamp_micros))
     }
 }
-
-impl ConfigurableBinarySerializable for DateTime {
-    fn serialize<W: Write + ?Sized>(
-        &self,
-        writer: &mut W,
-        config: &BinarySerializableConfig,
-    ) -> io::Result<()> {
-        let truncated_val = match config.date_time_precision {
-            DateTimePrecision::Seconds => self.into_timestamp_secs(),
-            DateTimePrecision::Milliseconds => self.into_timestamp_millis(),
-            DateTimePrecision::Microseconds => self.into_timestamp_micros(),
-            DateTimePrecision::Nanoseconds => self.into_timestamp_nanos(),
-        };
-        <i64 as BinarySerializable>::serialize(&truncated_val, writer)
-    }
-
-    fn deserialize<R: Read>(reader: &mut R, config: &BinarySerializableConfig) -> io::Result<Self> {
-        let timestamp = <i64 as BinarySerializable>::deserialize(reader)?;
-        match config.date_time_precision {
-            DateTimePrecision::Seconds => Ok(Self::from_timestamp_secs(timestamp)),
-            DateTimePrecision::Milliseconds => Ok(Self::from_timestamp_millis(timestamp)),
-            DateTimePrecision::Microseconds => Ok(Self::from_timestamp_micros(timestamp)),
-            DateTimePrecision::Nanoseconds => Ok(Self::from_timestamp_nanos(timestamp)),
-        }
-    }
-}

common/src/serialize.rs

@@ -4,7 +4,7 @@ use std::{fmt, io};
 
 use byteorder::{ReadBytesExt, WriteBytesExt};
 
-use crate::{DateTimePrecision, Endianness, VInt};
+use crate::{Endianness, VInt};
 
 #[derive(Default)]
 struct Counter(u64);
@@ -25,63 +25,6 @@ impl io::Write for Counter {
     }
 }
 
-/// The configuration for binary serialization.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct BinarySerializableConfig {
-    /// The precision with which DateTime is de/serialized
-    pub date_time_precision: DateTimePrecision,
-}
-
-/// Trait for configurable binary serialization
-pub trait ConfigurableBinarySerializable: fmt::Debug + Sized {
-    fn serialize<W: Write + ?Sized>(
-        &self,
-        writer: &mut W,
-        config: &BinarySerializableConfig,
-    ) -> io::Result<()>;
-    fn deserialize<R: Read>(reader: &mut R, config: &BinarySerializableConfig) -> io::Result<Self>;
-    fn num_bytes(&self, config: &BinarySerializableConfig) -> u64 {
-        let mut counter = Counter::default();
-        self.serialize(&mut counter, config).unwrap();
-        counter.0
-    }
-}
-
-/// Implement ConfigurableBinarySerializable trait for types that don't need versioning by
-/// forwarding to BinarySerializable trait.
-#[macro_export]
-macro_rules! impl_configurable_binary_serializable_by_calling_binary_serializable {
-    ($type:ty) => {
-        impl ConfigurableBinarySerializable for $type {
-            fn serialize<W: Write + ?Sized>(
-                &self,
-                writer: &mut W,
-                _version: &BinarySerializableConfig,
-            ) -> io::Result<()> {
-                <Self as BinarySerializable>::serialize(self, writer)
-            }
-
-            fn deserialize<R: Read>(
-                reader: &mut R,
-                _version: &BinarySerializableConfig,
-            ) -> io::Result<Self> {
-                <Self as BinarySerializable>::deserialize(reader)
-            }
-        }
-    };
-}
-
-impl_configurable_binary_serializable_by_calling_binary_serializable!(String);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(u64);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(i64);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(f64);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(Vec<u8>);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(u128);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(bool);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(());
-impl_configurable_binary_serializable_by_calling_binary_serializable!(Cow<'_, str>);
-impl_configurable_binary_serializable_by_calling_binary_serializable!(Cow<'_, [u8]>);
-
 /// Trait for a simple binary serialization.
 pub trait BinarySerializable: fmt::Debug + Sized {
     /// Serialize

src/schema/document/de.rs

@@ -16,13 +16,13 @@ use std::net::Ipv6Addr;
 use std::sync::Arc;
 
 use columnar::MonotonicallyMappableToU128;
-use common::{u64_to_f64, BinarySerializable, ConfigurableBinarySerializable, DateTime, VInt};
+use common::{u64_to_f64, BinarySerializable, DateTime, VInt};
 
 use super::se::BinaryObjectSerializer;
 use super::{OwnedValue, Value};
 use crate::schema::document::type_codes;
 use crate::schema::{Facet, Field};
-use crate::store::doc_store_version_to_serialize_config;
+use crate::store::DocStoreVersion;
 use crate::tokenizer::PreTokenizedString;
 
 #[derive(Debug, thiserror::Error, Clone)]
@@ -295,7 +295,7 @@ pub trait ObjectAccess<'de> {
 pub struct BinaryDocumentDeserializer<'de, R> {
     length: usize,
     position: usize,
-    doc_store_version: u32,
+    doc_store_version: DocStoreVersion,
     reader: &'de mut R,
 }
 
@@ -305,7 +305,7 @@ where R: Read
     /// Attempts to create a new document deserializer from a given reader.
     pub(crate) fn from_reader(
         reader: &'de mut R,
-        doc_store_version: u32,
+        doc_store_version: DocStoreVersion,
     ) -> Result<Self, DeserializeError> {
         let length = VInt::deserialize(reader)?;
 
@@ -353,14 +353,17 @@ where R: Read
 pub struct BinaryValueDeserializer<'de, R> {
     value_type: ValueType,
     reader: &'de mut R,
-    doc_store_version: u32,
+    doc_store_version: DocStoreVersion,
 }
 
 impl<'de, R> BinaryValueDeserializer<'de, R>
 where R: Read
 {
     /// Attempts to create a new value deserializer from a given reader.
-    fn from_reader(reader: &'de mut R, doc_store_version: u32) -> Result<Self, DeserializeError> {
+    fn from_reader(
+        reader: &'de mut R,
+        doc_store_version: DocStoreVersion,
+    ) -> Result<Self, DeserializeError> {
         let type_code = <u8 as BinarySerializable>::deserialize(reader)?;
 
         let value_type = match type_code {
@@ -430,94 +433,66 @@ where R: Read
 
     fn deserialize_string(self) -> Result<String, DeserializeError> {
         self.validate_type(ValueType::String)?;
-        <String as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <String as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
     }
 
     fn deserialize_u64(self) -> Result<u64, DeserializeError> {
         self.validate_type(ValueType::U64)?;
-        <u64 as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <u64 as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
     }
 
     fn deserialize_i64(self) -> Result<i64, DeserializeError> {
         self.validate_type(ValueType::I64)?;
-        <i64 as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <i64 as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
     }
 
     fn deserialize_f64(self) -> Result<f64, DeserializeError> {
         self.validate_type(ValueType::F64)?;
-        <u64 as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map(u64_to_f64)
-        .map_err(DeserializeError::from)
+        <u64 as BinarySerializable>::deserialize(self.reader)
+            .map(u64_to_f64)
+            .map_err(DeserializeError::from)
     }
 
     fn deserialize_datetime(self) -> Result<DateTime, DeserializeError> {
         self.validate_type(ValueType::DateTime)?;
-        <DateTime as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        match self.doc_store_version {
+            DocStoreVersion::V1 => {
+                let timestamp_micros = <i64 as BinarySerializable>::deserialize(self.reader)?;
+                Ok(DateTime::from_timestamp_micros(timestamp_micros))
+            }
+            DocStoreVersion::V2 => {
+                let timestamp_nanos = <i64 as BinarySerializable>::deserialize(self.reader)?;
+                Ok(DateTime::from_timestamp_nanos(timestamp_nanos))
+            }
+        }
     }
 
     fn deserialize_facet(self) -> Result<Facet, DeserializeError> {
         self.validate_type(ValueType::Facet)?;
-        <Facet as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <Facet as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
     }
 
     fn deserialize_bytes(self) -> Result<Vec<u8>, DeserializeError> {
         self.validate_type(ValueType::Bytes)?;
-        <Vec<u8> as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <Vec<u8> as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
     }
 
     fn deserialize_ip_address(self) -> Result<Ipv6Addr, DeserializeError> {
         self.validate_type(ValueType::IpAddr)?;
-        <u128 as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map(Ipv6Addr::from_u128)
-        .map_err(DeserializeError::from)
+        <u128 as BinarySerializable>::deserialize(self.reader)
+            .map(Ipv6Addr::from_u128)
+            .map_err(DeserializeError::from)
     }
 
     fn deserialize_bool(self) -> Result<bool, DeserializeError> {
         self.validate_type(ValueType::Bool)?;
-        <bool as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <bool as BinarySerializable>::deserialize(self.reader).map_err(DeserializeError::from)
     }
 
     fn deserialize_pre_tokenized_string(self) -> Result<PreTokenizedString, DeserializeError> {
         self.validate_type(ValueType::PreTokStr)?;
-        <PreTokenizedString as ConfigurableBinarySerializable>::deserialize(
-            self.reader,
-            &doc_store_version_to_serialize_config(self.doc_store_version)?,
-        )
-        .map_err(DeserializeError::from)
+        <PreTokenizedString as BinarySerializable>::deserialize(self.reader)
+            .map_err(DeserializeError::from)
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, DeserializeError>
@@ -605,14 +580,17 @@ pub struct BinaryArrayDeserializer<'de, R> {
     length: usize,
     position: usize,
     reader: &'de mut R,
-    doc_store_version: u32,
+    doc_store_version: DocStoreVersion,
 }
 
 impl<'de, R> BinaryArrayDeserializer<'de, R>
 where R: Read
 {
     /// Attempts to create a new array deserializer from a given reader.
-    fn from_reader(reader: &'de mut R, doc_store_version: u32) -> Result<Self, DeserializeError> {
+    fn from_reader(
+        reader: &'de mut R,
+        doc_store_version: DocStoreVersion,
+    ) -> Result<Self, DeserializeError> {
         let length = <VInt as BinarySerializable>::deserialize(reader)?;
 
         Ok(Self {
@@ -667,7 +645,10 @@ impl<'de, R> BinaryObjectDeserializer<'de, R>
 where R: Read
 {
     /// Attempts to create a new object deserializer from a given reader.
-    fn from_reader(reader: &'de mut R, doc_store_version: u32) -> Result<Self, DeserializeError> {
+    fn from_reader(
+        reader: &'de mut R,
+        doc_store_version: DocStoreVersion,
+    ) -> Result<Self, DeserializeError> {
         let inner = BinaryArrayDeserializer::from_reader(reader, doc_store_version)?;
         Ok(Self { inner })
     }
@@ -887,6 +868,15 @@ mod tests {
         writer
     }
 
+    fn serialize_owned_value<'a>(value: ReferenceValue<'a, &'a OwnedValue>) -> Vec<u8> {
+        let mut writer = Vec::new();
+
+        let mut serializer = BinaryValueSerializer::new(&mut writer);
+        serializer.serialize_value(value).expect("Serialize value");
+
+        writer
+    }
+
     fn deserialize_value(buffer: Vec<u8>) -> crate::schema::OwnedValue {
         let mut cursor = Cursor::new(buffer);
         let deserializer =
@@ -1069,6 +1059,17 @@ mod tests {
         assert_eq!(value, expected_val);
     }
 
+    #[test]
+    fn test_nested_date_precision() {
+        let object = OwnedValue::Object(vec![(
+            "my-date".into(),
+            OwnedValue::Date(DateTime::from_timestamp_nanos(323456)),
+        )]);
+        let result = serialize_owned_value((&object).as_value());
+        let value = deserialize_value(result);
+        assert_eq!(value, object);
+    }
+
     #[test]
     fn test_nested_serialize() {
         let mut object = serde_json::Map::new();