fix: forward RowBinaryDeserializer::deserialize_any to best-effort deserialize_* method

Author: timvermeulen

src/rowbinary/de.rs

@@ -159,8 +159,35 @@ where
     impl_num!(f64, deserialize_f64, visit_f64, get_f64_le, SerdeType::F64);
 
     #[inline(always)]
-    fn deserialize_any<V: Visitor<'data>>(self, _: V) -> Result<V::Value> {
-        Err(Error::DeserializeAnyNotSupported)
+    fn deserialize_any<V: Visitor<'data>>(self, visitor: V) -> Result<V::Value> {
+        match self
+            .validator
+            .peek()
+            .ok_or(Error::DeserializeAnyNotSupported)?
+        {
+            SerdeType::Bool => self.deserialize_bool(visitor),
+            SerdeType::I8 => self.deserialize_i8(visitor),
+            SerdeType::I16 => self.deserialize_i16(visitor),
+            SerdeType::I32 => self.deserialize_i32(visitor),
+            SerdeType::I64 => self.deserialize_i64(visitor),
+            SerdeType::I128 => self.deserialize_i128(visitor),
+            SerdeType::U8 => self.deserialize_u8(visitor),
+            SerdeType::U16 => self.deserialize_u16(visitor),
+            SerdeType::U32 => self.deserialize_u32(visitor),
+            SerdeType::U64 => self.deserialize_u64(visitor),
+            SerdeType::U128 => self.deserialize_u128(visitor),
+            SerdeType::F32 => self.deserialize_f32(visitor),
+            SerdeType::F64 => self.deserialize_f64(visitor),
+            SerdeType::Str => self.deserialize_str(visitor),
+            SerdeType::String => self.deserialize_string(visitor),
+            SerdeType::Option => self.deserialize_option(visitor),
+            SerdeType::Enum => self.deserialize_enum("", &[], visitor),
+            SerdeType::Bytes(_) => self.deserialize_bytes(visitor),
+            SerdeType::ByteBuf(_) => self.deserialize_byte_buf(visitor),
+            SerdeType::Tuple(len) => self.deserialize_tuple(len, visitor),
+            SerdeType::Seq(_) => self.deserialize_seq(visitor),
+            SerdeType::Map(_) => self.deserialize_map(visitor),
+        }
     }
 
     #[inline(always)]

src/rowbinary/validation.rs

@@ -29,6 +29,7 @@ pub(crate) trait SchemaValidator<R: Row>: Sized {
     /// the field order in the struct does not match the column order in the database schema.
     fn get_schema_index(&self, struct_idx: usize) -> usize;
     fn get_field_name(&self, struct_idx: usize) -> Option<&'static str>;
+    fn peek(&self) -> Option<SerdeType>;
 }
 
 pub(crate) struct DataTypeValidator<'cursor, R: Row> {
@@ -189,6 +190,30 @@ impl<'cursor, R: Row> SchemaValidator<R> for DataTypeValidator<'cursor, R> {
         self.metadata.get_field_name(struct_idx)
     }
 
+    fn peek(&self) -> Option<SerdeType> {
+        match R::KIND {
+            RowKind::Primitive => {
+                let data_type = &self.metadata.columns[0].data_type;
+                Some(data_type.into())
+            }
+            RowKind::Tuple => Some(SerdeType::Tuple(self.metadata.columns.len()).into()),
+            RowKind::Vec => {
+                let data_type = &self.metadata.columns[0].data_type;
+                match data_type {
+                    DataTypeNode::Array(inner_type) => Some(From::from(&**inner_type)),
+                    _ => panic!(
+                        "Expected Array type when validating root level sequence, but got {}",
+                        self.metadata.columns[0].data_type
+                    ),
+                }
+            }
+            RowKind::Struct => {
+                let current_column = &self.metadata.columns[self.current_column_idx];
+                Some(From::from(&current_column.data_type))
+            }
+        }
+    }
+
     #[cold]
     fn validate_identifier<T: EnumOrVariantIdentifier>(&mut self, _value: T) {
         unreachable!()
@@ -402,6 +427,46 @@ impl<'cursor, R: Row> SchemaValidator<R> for Option<InnerDataTypeValidator<'_, '
     fn get_field_name(&self, _struct_idx: usize) -> Option<&'static str> {
         unreachable!()
     }
+
+    fn peek(&self) -> Option<SerdeType> {
+        let inner = self.as_ref()?;
+        match &inner.kind {
+            InnerDataTypeValidatorKind::Map(kv, state) => match state {
+                MapValidatorState::Key => Some(From::from(&*kv[0])),
+                MapValidatorState::Value => Some(From::from(&*kv[1])),
+            },
+            InnerDataTypeValidatorKind::MapAsSequence(kv, state) => match state {
+                MapAsSequenceValidatorState::Tuple | MapAsSequenceValidatorState::Key => {
+                    Some(From::from(&*kv[0]))
+                }
+                MapAsSequenceValidatorState::Value => Some(From::from(&*kv[1])),
+            },
+            InnerDataTypeValidatorKind::Array(inner_type) => Some(From::from(*inner_type)),
+            InnerDataTypeValidatorKind::Nullable(inner_type) => Some(From::from(*inner_type)),
+            InnerDataTypeValidatorKind::Tuple(elements_types) => {
+                Some(From::from(&elements_types[0]))
+            }
+            InnerDataTypeValidatorKind::FixedString(_len) => None,
+            InnerDataTypeValidatorKind::RootTuple(columns, current_index) => {
+                Some(From::from(&columns[*current_index].data_type))
+            }
+            InnerDataTypeValidatorKind::RootArray(inner_data_type) => {
+                Some(From::from(*inner_data_type))
+            }
+            InnerDataTypeValidatorKind::Variant(possible_types, state) => match state {
+                VariantValidationState::Pending => {
+                    unreachable!()
+                }
+                VariantValidationState::Identifier(value) => {
+                    let data_type = &possible_types[*value as usize];
+                    Some(From::from(data_type))
+                }
+            },
+            InnerDataTypeValidatorKind::Enum(_values_map) => {
+                unreachable!()
+            }
+        }
+    }
 }
 
 impl<R: Row> Drop for InnerDataTypeValidator<'_, '_, R> {
@@ -651,6 +716,10 @@ impl<R: Row> SchemaValidator<R> for () {
     fn get_field_name(&self, _struct_idx: usize) -> Option<&'static str> {
         unreachable!()
     }
+
+    fn peek(&self) -> Option<SerdeType> {
+        unreachable!()
+    }
 }
 
 /// Which Serde data type (De)serializer used for the given type.
@@ -690,6 +759,51 @@ pub(crate) enum SerdeType {
     // IgnoredAny,
 }
 
+impl From<&DataTypeNode> for SerdeType {
+    fn from(data_type: &DataTypeNode) -> Self {
+        match dbg!(data_type.remove_low_cardinality()) {
+            DataTypeNode::Bool => SerdeType::Bool,
+            DataTypeNode::Int8 | DataTypeNode::Enum(EnumType::Enum8, _) => SerdeType::I8,
+            DataTypeNode::Int16 | DataTypeNode::Enum(EnumType::Enum16, _) => SerdeType::I16,
+            DataTypeNode::Int32
+            | DataTypeNode::Date32
+            | DataTypeNode::Time
+            | DataTypeNode::Decimal(_, _, DecimalType::Decimal32) => SerdeType::I32,
+            DataTypeNode::Int64
+            | DataTypeNode::DateTime64(_, _)
+            | DataTypeNode::Time64(_)
+            | DataTypeNode::Decimal(_, _, DecimalType::Decimal64)
+            | DataTypeNode::Interval(_) => SerdeType::I64,
+            DataTypeNode::Int128 | DataTypeNode::Decimal(_, _, DecimalType::Decimal128) => {
+                SerdeType::I128
+            }
+            DataTypeNode::UInt8 => SerdeType::U8,
+            DataTypeNode::UInt16 | DataTypeNode::Date => SerdeType::U16,
+            DataTypeNode::UInt32 | DataTypeNode::DateTime(_) | DataTypeNode::IPv4 => SerdeType::U32,
+            DataTypeNode::UInt64 => SerdeType::U64,
+            DataTypeNode::UInt128 => SerdeType::U128,
+            DataTypeNode::Float32 => SerdeType::F32,
+            DataTypeNode::Float64 => SerdeType::F64,
+            DataTypeNode::String | DataTypeNode::JSON => SerdeType::String,
+            DataTypeNode::Nullable(_) => SerdeType::Option,
+            DataTypeNode::Array(_)
+            | DataTypeNode::Ring
+            | DataTypeNode::Polygon
+            | DataTypeNode::MultiPolygon
+            | DataTypeNode::LineString
+            | DataTypeNode::MultiLineString => SerdeType::Seq(0),
+            DataTypeNode::Tuple(elements) => SerdeType::Tuple(elements.len()),
+            DataTypeNode::FixedString(len) => SerdeType::Tuple(*len),
+            DataTypeNode::IPv6 => SerdeType::Tuple(16),
+            DataTypeNode::UUID => SerdeType::Tuple(UUID_TUPLE_ELEMENTS.len()),
+            DataTypeNode::Point => SerdeType::Tuple(POINT_TUPLE_ELEMENTS.len()),
+            DataTypeNode::Map(_) => SerdeType::Map(0),
+            DataTypeNode::Variant(_) => SerdeType::Enum,
+            _ => unimplemented!(),
+        }
+    }
+}
+
 impl Display for SerdeType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {