cql: wrap CqlVarint with CqlValue::Varint

Author: muzarski

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

@@ -1,5 +1,7 @@
 use super::result::{CqlValue, Row};
-use crate::frame::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid};
+use crate::frame::value::{
+    Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid, CqlVarint,
+};
 use bigdecimal::BigDecimal;
 use num_bigint::BigInt;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
@@ -125,7 +127,7 @@ impl_from_cql_value_from_method!(i32, as_int); // i32::from_cql<CqlValue>
 impl_from_cql_value_from_method!(i64, as_bigint); // i64::from_cql<CqlValue>
 impl_from_cql_value_from_method!(Counter, as_counter); // Counter::from_cql<CqlValue>
 impl_from_cql_value_from_method!(i16, as_smallint); // i16::from_cql<CqlValue>
-impl_from_cql_value_from_method!(BigInt, into_varint); // BigInt::from_cql<CqlValue>
+impl_from_cql_value_from_method!(CqlVarint, into_cql_varint); // CqlVarint::from_cql<CqlValue>
 impl_from_cql_value_from_method!(i8, as_tinyint); // i8::from_cql<CqlValue>
 impl_from_cql_value_from_method!(f32, as_float); // f32::from_cql<CqlValue>
 impl_from_cql_value_from_method!(f64, as_double); // f64::from_cql<CqlValue>
@@ -148,6 +150,15 @@ impl<const N: usize> FromCqlVal<CqlValue> for [u8; N] {
     }
 }
 
+impl FromCqlVal<CqlValue> for BigInt {
+    fn from_cql(cql_val: CqlValue) -> Result<Self, FromCqlValError> {
+        match cql_val {
+            CqlValue::Varint(cql_varint) => Ok(cql_varint.into()),
+            _ => Err(FromCqlValError::BadCqlType),
+        }
+    }
+}
+
 #[cfg(feature = "chrono")]
 impl FromCqlVal<CqlValue> for NaiveDate {
     fn from_cql(cql_val: CqlValue) -> Result<Self, FromCqlValError> {
@@ -463,7 +474,7 @@ mod tests {
         let big_int = 0.to_bigint().unwrap();
         assert_eq!(
             Ok(big_int),
-            BigInt::from_cql(CqlValue::Varint(0.to_bigint().unwrap()))
+            BigInt::from_cql(CqlValue::Varint(0.to_bigint().unwrap().into()))
         );
     }
 

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

@@ -1,12 +1,13 @@
 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, CqlTimeuuid};
+use crate::frame::value::{
+    Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid, CqlVarint,
+};
 use crate::frame::{frame_errors::ParseError, types};
 use bigdecimal::BigDecimal;
 use byteorder::{BigEndian, ReadBytesExt};
 use bytes::{Buf, Bytes};
-use num_bigint::BigInt;
 use std::{
     convert::{TryFrom, TryInto},
     net::IpAddr,
@@ -113,7 +114,7 @@ pub enum CqlValue {
     Timeuuid(CqlTimeuuid),
     Tuple(Vec<Option<CqlValue>>),
     Uuid(Uuid),
-    Varint(BigInt),
+    Varint(CqlVarint),
 }
 
 impl ColumnType {
@@ -363,7 +364,7 @@ impl CqlValue {
         }
     }
 
-    pub fn into_varint(self) -> Option<BigInt> {
+    pub fn into_cql_varint(self) -> Option<CqlVarint> {
         match self {
             Self::Varint(i) => Some(i),
             _ => None,
@@ -810,7 +811,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::Uuid(uuid)
         }
-        Varint => CqlValue::Varint(num_bigint::BigInt::from_signed_bytes_be(buf)),
+        Varint => CqlValue::Varint(CqlVarint::from_signed_bytes_be(buf.to_vec())),
         List(type_name) => {
             let len: usize = types::read_int(buf)?.try_into()?;
             let mut res = Vec::with_capacity(len);
@@ -1086,7 +1087,7 @@ mod tests {
 
         for t in tests.iter() {
             let value = super::deser_cql_value(&ColumnType::Varint, &mut &*t.encoding).unwrap();
-            assert_eq!(CqlValue::Varint(t.value.clone()), value);
+            assert_eq!(CqlValue::Varint(t.value.clone().into()), value);
         }
     }
 

scylla-cql/src/frame/value.rs

@@ -995,6 +995,18 @@ impl Value for CqlTimeuuid {
     }
 }
 
+impl Value for CqlVarint {
+    fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig> {
+        let serialized = &self.0;
+        let serialized_len: i32 = serialized.len().try_into().map_err(|_| ValueTooBig)?;
+
+        buf.put_i32(serialized_len);
+        buf.extend_from_slice(serialized);
+
+        Ok(())
+    }
+}
+
 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,8 @@ 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, CqlTimeuuid, MaybeUnset, Unset, Value,
+    Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid, CqlVarint, MaybeUnset,
+    Unset, Value,
 };
 
 #[cfg(feature = "chrono")]
@@ -233,6 +234,14 @@ impl SerializeCql for CqlTimeuuid {
         writer.set_value(me.as_bytes().as_ref()).unwrap()
     });
 }
+impl SerializeCql for CqlVarint {
+    impl_serialize_via_writer!(|me, typ, writer| {
+        exact_type_check!(typ, Varint);
+        writer
+            .set_value(me.as_signed_bytes_be_slice())
+            .map_err(|_| mk_ser_err::<Self>(typ, BuiltinSerializationErrorKind::SizeOverflow))?
+    });
+}
 impl SerializeCql for BigInt {
     impl_serialize_via_writer!(|me, typ, writer| {
         exact_type_check!(typ, Varint);

scylla/src/utils/pretty.rs

@@ -51,7 +51,11 @@ where
             CqlValue::Inet(i) => write!(f, "'{}'", i)?,
             CqlValue::SmallInt(si) => write!(f, "{}", si)?,
             CqlValue::TinyInt(ti) => write!(f, "{}", ti)?,
-            CqlValue::Varint(vi) => write!(f, "{}", vi)?,
+            CqlValue::Varint(vi) => write!(
+                f,
+                "blobAsVarint(0x{:x})",
+                HexBytes(vi.as_signed_bytes_be_slice())
+            )?,
             CqlValue::Counter(c) => write!(f, "{}", c.0)?,
             CqlValue::Date(CqlDate(d)) => {
                 let days_since_epoch = chrono::Duration::days(*d as i64 - (1 << 31));