parametrize DeserializeValue with two lifetimes

`DeserializeValue` requires two types of data in order to perform
deserialization:
1) a reference to the CQL frame (a FrameSlice),
2) the type of the column being deserialized, being part of the
   ResultMetadata.

It's important to understand what is a _deserialized value_. It's not
just an implementor of DeserializeValue; there are some implementors of
`DeserializeValue` who are not yet final values, but **partially**
deserialized types that support further deserialization - _value
deserializers_, such as `ListlikeIterator` or `UdtIterator`.
_Value deserializers_, as they still need to deserialize some value, are
naturally bound by 'metadata lifetime. However, _values_ are completely
deserialized, so they should not be bound by 'metadata - only by 'frame.

When deserializing owned values, both the frame and the metadata can
have any lifetime and it's not important. When deserializing borrowing
values, however, they borrow from the frame, so their lifetime must
necessarily be bound by the lifetime of the frame. Metadata is only
needed for the deserialization, so its lifetime does not abstractly
bound the deserialized value.

Up to this commit, DeserializeValue was only parametrized by one
lifetime: 'frame, which bounded both the frame slice and the metadata.
(why? see next paragraph about value deserializers)
This was done that way due to an assumption that both the metadata and
the frame (shared using Bytes) will be owned by the same entity.
However, the new idea of deserializing result metadata to a borrowed
form (to save allocations) makes result metadata's lifetime shorter than
the frame's lifetime. Not to unnecessarily shorten the deserialized
values' lifetime, a separate lifetime parameter is introduced for
result metadata: 'metadata.

Up to this commit, value deserializers could only be parametrized by
'frame lifetime. Therefore, borrowed metadata held by value
deserializers limits the 'frame lifetime to its lifetime. Hence, values
deserialized by value deserializers must have been bounded by the
lifetime of the metadata.

The commit is large, but the changes are mostly mechanical, by adding
the second lifetime parameter.

DeserializeRow & friends are going to get the second lifetime parameter,
too, but for now they pass 'frame as both lifetime parameters of
DeserializeValue.

Author: wprzytula

scylla-cql/src/frame/response/result.rs

@@ -1013,7 +1013,7 @@ pub fn deser_cql_value(
             CqlValue::List(l)
         }
         Map(_key_type, _value_type) => {
-            let iter = MapIterator::<'_, CqlValue, CqlValue>::deserialize(typ, v)?;
+            let iter = MapIterator::<'_, '_, CqlValue, CqlValue>::deserialize(typ, v)?;
             let m: Vec<(CqlValue, CqlValue)> = iter.collect::<StdResult<_, _>>()?;
             CqlValue::Map(m)
         }

scylla-cql/src/types/deserialize/mod.rs

@@ -2,7 +2,7 @@
 //!
 //! Deserialization is based on two traits:
 //!
-//! - A type that implements `DeserializeValue<'frame>` can be deserialized
+//! - A type that implements `DeserializeValue<'frame, 'metadata>` can be deserialized
 //!   from a single _CQL value_ - i.e. an element of a row in the query result,
 //! - A type that implements `DeserializeRow<'frame>` can be deserialized
 //!   from a single _row_ of a query result.
@@ -57,7 +57,7 @@
 //!     #[error("Expected non-null")]
 //!     ExpectedNonNull,
 //! }
-//! impl<'frame> DeserializeValue<'frame> for MyVec {
+//! impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for MyVec {
 //!     fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
 //!          if let ColumnType::Blob = typ {
 //!              return Ok(());
@@ -66,7 +66,7 @@
 //!      }
 //!
 //!      fn deserialize(
-//!          _typ: &'frame ColumnType,
+//!          _typ: &'metadata ColumnType<'metadata>,
 //!          v: Option<FrameSlice<'frame>>,
 //!      ) -> Result<Self, DeserializationError> {
 //!          v.ok_or_else(|| DeserializationError::new(MyDeserError::ExpectedNonNull))
@@ -98,7 +98,7 @@
 //!     #[error("Expected non-null")]
 //!     ExpectedNonNull,
 //! }
-//! impl<'a, 'frame> DeserializeValue<'frame> for MySlice<'a>
+//! impl<'a, 'frame, 'metadata> DeserializeValue<'frame, 'metadata> for MySlice<'a>
 //! where
 //!     'frame: 'a,
 //! {
@@ -110,7 +110,7 @@
 //!      }
 //!
 //!      fn deserialize(
-//!          _typ: &'frame ColumnType,
+//!          _typ: &'metadata ColumnType<'metadata>,
 //!          v: Option<FrameSlice<'frame>>,
 //!      ) -> Result<Self, DeserializationError> {
 //!          v.ok_or_else(|| DeserializationError::new(MyDeserError::ExpectedNonNull))
@@ -150,7 +150,7 @@
 //!     #[error("Expected non-null")]
 //!     ExpectedNonNull,
 //! }
-//! impl<'frame> DeserializeValue<'frame> for MyBytes {
+//! impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for MyBytes {
 //!     fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
 //!          if let ColumnType::Blob = typ {
 //!              return Ok(());
@@ -159,7 +159,7 @@
 //!      }
 //!
 //!      fn deserialize(
-//!          _typ: &'frame ColumnType,
+//!          _typ: &'metadata ColumnType<'metadata>,
 //!          v: Option<FrameSlice<'frame>>,
 //!      ) -> Result<Self, DeserializationError> {
 //!          v.ok_or_else(|| DeserializationError::new(MyDeserError::ExpectedNonNull))

scylla-cql/src/types/deserialize/row.rs

@@ -183,15 +183,15 @@ macro_rules! impl_tuple {
     ($($Ti:ident),*; $($idx:literal),*; $($idf:ident),*) => {
         impl<'frame, $($Ti),*> DeserializeRow<'frame> for ($($Ti,)*)
         where
-            $($Ti: DeserializeValue<'frame>),*
+            $($Ti: DeserializeValue<'frame, 'frame>),*
         {
             fn type_check(specs: &[ColumnSpec]) -> Result<(), TypeCheckError> {
                 const TUPLE_LEN: usize = (&[$($idx),*] as &[i32]).len();
 
                 let column_types_iter = || specs.iter().map(|spec| spec.typ().clone().into_owned());
                 if let [$($idf),*] = &specs {
                     $(
-                        <$Ti as DeserializeValue<'frame>>::type_check($idf.typ())
+                        <$Ti as DeserializeValue<'frame, 'frame>>::type_check($idf.typ())
                             .map_err(|err| mk_typck_err::<Self>(column_types_iter(), BuiltinTypeCheckErrorKind::ColumnTypeCheckFailed {
                                 column_index: $idx,
                                 column_name: specs[$idx].name().to_owned(),
@@ -217,7 +217,7 @@ macro_rules! impl_tuple {
                             $idx
                         )).map_err(deser_error_replace_rust_name::<Self>)?;
 
-                        <$Ti as DeserializeValue<'frame>>::deserialize(column.spec.typ(), column.slice)
+                        <$Ti as DeserializeValue<'frame, 'frame>>::deserialize(column.spec.typ(), column.slice)
                             .map_err(|err| mk_deser_err::<Self>(BuiltinDeserializationErrorKind::ColumnDeserializationFailed {
                                 column_index: column.index,
                                 column_name: column.spec.name().to_owned(),