cql: wrap CqlTimeuuid in CqlValue::Timeuuid

Author: muzarski

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

@@ -1,5 +1,5 @@
 use super::result::{CqlValue, Row};
-use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp};
+use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid};
 use bigdecimal::BigDecimal;
 use num_bigint::BigInt;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
@@ -134,6 +134,7 @@ impl_from_cql_value_from_method!(String, into_string); // String::from_cql<CqlVa
 impl_from_cql_value_from_method!(Vec<u8>, into_blob); // Vec<u8>::from_cql<CqlValue>
 impl_from_cql_value_from_method!(IpAddr, as_inet); // IpAddr::from_cql<CqlValue>
 impl_from_cql_value_from_method!(Uuid, as_uuid); // Uuid::from_cql<CqlValue>
+impl_from_cql_value_from_method!(CqlTimeuuid, as_timeuuid); // CqlTimeuuid::from_cql<CqlValue>
 impl_from_cql_value_from_method!(BigDecimal, into_decimal); // BigDecimal::from_cql<CqlValue>
 impl_from_cql_value_from_method!(CqlDuration, as_cql_duration); // CqlDuration::from_cql<CqlValue>
 impl_from_cql_value_from_method!(CqlDate, as_cql_date); // CqlDate::from_cql<CqlValue>
@@ -390,7 +391,7 @@ impl_tuple_from_cql!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
 mod tests {
     use super::{CqlValue, FromCqlVal, FromCqlValError, FromRow, FromRowError, Row};
     use crate as scylla;
-    use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp};
+    use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid};
     use crate::macros::FromRow;
     use bigdecimal::BigDecimal;
     use num_bigint::{BigInt, ToBigInt};
@@ -753,16 +754,18 @@ mod tests {
 
     #[test]
     fn uuid_from_cql() {
-        let test_uuid: Uuid = Uuid::parse_str("8e14e760-7fa8-11eb-bc66-000000000001").unwrap();
+        let uuid_str = "8e14e760-7fa8-11eb-bc66-000000000001";
+        let test_uuid: Uuid = Uuid::parse_str(uuid_str).unwrap();
+        let test_time_uuid = CqlTimeuuid::from_str(uuid_str).unwrap();
 
         assert_eq!(
             test_uuid,
             Uuid::from_cql(CqlValue::Uuid(test_uuid)).unwrap()
         );
 
         assert_eq!(
-            test_uuid,
-            Uuid::from_cql(CqlValue::Timeuuid(test_uuid)).unwrap()
+            test_time_uuid,
+            CqlTimeuuid::from_cql(CqlValue::Timeuuid(test_time_uuid)).unwrap()
         );
     }
 

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

@@ -1,7 +1,7 @@
 use crate::cql_to_rust::{FromRow, FromRowError};
 use crate::frame::response::event::SchemaChangeEvent;
 use crate::frame::types::vint_decode;
-use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp};
+use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid};
 use crate::frame::{frame_errors::ParseError, types};
 use bigdecimal::BigDecimal;
 use byteorder::{BigEndian, ReadBytesExt};
@@ -110,7 +110,7 @@ pub enum CqlValue {
     TinyInt(i8),
     /// Nanoseconds since midnight
     Time(CqlTime),
-    Timeuuid(Uuid),
+    Timeuuid(CqlTimeuuid),
     Tuple(Vec<Option<CqlValue>>),
     Uuid(Uuid),
     Varint(BigInt),
@@ -231,7 +231,7 @@ impl CqlValue {
     pub fn as_uuid(&self) -> Option<Uuid> {
         match self {
             Self::Uuid(u) => Some(*u),
-            Self::Timeuuid(u) => Some(*u),
+            Self::Timeuuid(u) => Some(*u.as_ref()),
             _ => None,
         }
     }
@@ -285,7 +285,7 @@ impl CqlValue {
         }
     }
 
-    pub fn as_timeuuid(&self) -> Option<Uuid> {
+    pub fn as_timeuuid(&self) -> Option<CqlTimeuuid> {
         match self {
             Self::Timeuuid(u) => Some(*u),
             _ => None,
@@ -770,7 +770,7 @@ pub fn deser_cql_value(typ: &ColumnType, buf: &mut &[u8]) -> StdResult<CqlValue,
                 )));
             }
             let uuid = uuid::Uuid::from_slice(buf).expect("Deserializing Uuid failed.");
-            CqlValue::Timeuuid(uuid)
+            CqlValue::Timeuuid(CqlTimeuuid::from(uuid))
         }
         Duration => {
             let months = i32::try_from(vint_decode(buf)?)?;
@@ -966,7 +966,7 @@ pub fn deserialize(buf: &mut &[u8]) -> StdResult<Result, ParseError> {
 #[cfg(test)]
 mod tests {
     use crate as scylla;
-    use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp};
+    use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid};
     use bigdecimal::BigDecimal;
     use num_bigint::BigInt;
     use num_bigint::ToBigInt;
@@ -993,9 +993,10 @@ mod tests {
         let uuid_serialize = super::deser_cql_value(&ColumnType::Uuid, uuid_slice).unwrap();
         assert_eq!(uuid_serialize, CqlValue::Uuid(my_uuid));
 
+        let my_timeuuid = CqlTimeuuid::from_str("00000000000000000000000000000001").unwrap();
         let time_uuid_serialize =
             super::deser_cql_value(&ColumnType::Timeuuid, uuid_slice).unwrap();
-        assert_eq!(time_uuid_serialize, CqlValue::Timeuuid(my_uuid));
+        assert_eq!(time_uuid_serialize, CqlValue::Timeuuid(my_timeuuid));
 
         let my_ip = "::1".parse().unwrap();
         let ip_buf: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
@@ -1754,7 +1755,7 @@ mod tests {
             match cql_val {
                 CqlValue::Timeuuid(uuid) => {
                     assert_eq!(uuid.as_bytes(), uuid_bytes);
-                    assert_eq!(Uuid::parse_str(uuid_str).unwrap(), uuid);
+                    assert_eq!(CqlTimeuuid::from_str(uuid_str).unwrap(), uuid);
                 }
                 _ => panic!("Timeuuid parsed as wrong CqlValue"),
             }

scylla-cql/src/frame/value.rs

@@ -860,6 +860,12 @@ impl Value for Uuid {
     }
 }
 
+impl Value for CqlTimeuuid {
+    fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig> {
+        self.0.serialize(buf)
+    }
+}
+
 impl Value for BigInt {
     fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig> {
         let serialized = self.to_signed_bytes_be();

scylla-cql/src/types/serialize/value.rs

@@ -20,7 +20,7 @@ use secrecy::{ExposeSecret, Secret, Zeroize};
 use crate::frame::response::result::{ColumnType, CqlValue};
 use crate::frame::types::vint_encode;
 use crate::frame::value::{
-    Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, MaybeUnset, Unset, Value,
+    Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid, MaybeUnset, Unset, Value,
 };
 
 #[cfg(feature = "chrono")]
@@ -227,6 +227,12 @@ impl SerializeCql for Uuid {
         writer.set_value(me.as_bytes().as_ref()).unwrap()
     });
 }
+impl SerializeCql for CqlTimeuuid {
+    impl_serialize_via_writer!(|me, typ, writer| {
+        exact_type_check!(typ, Timeuuid);
+        writer.set_value(me.as_bytes().as_ref()).unwrap()
+    });
+}
 impl SerializeCql for BigInt {
     impl_serialize_via_writer!(|me, typ, writer| {
         exact_type_check!(typ, Varint);