Struct scylla_cql::frame::value::CqlVarint

pub struct CqlVarint(/* private fields */);

Native CQL varint representation.

Represented as two’s-complement binary in big-endian order.

This type is a raw representation in bytes. It’s the default implementation of varint type - independent of any external crates and crate features.

The type is not very useful in most use cases. However, users can make use of more complex types such as num_bigint::BigInt (v0.3/v0.4). The library support (e.g. conversion from CqlValue) for these types is enabled via num-bigint-03 and num-bigint-04 crate features.

DB data format

Notice that constructors don’t perform any normalization on the provided data. This means that underlying bytes may contain leading zeros.

Currently, Scylla and Cassandra support non-normalized varint values. Bytes provided by the user via constructor are passed to DB as is.

The implementation of PartialEq, however, normalizes the underlying bytes before comparison. For details, check examples.

Implementations

impl CqlVarint

Constructors from bytes

pub fn from_signed_bytes_be(digits: Vec<u8>) -> Self

Creates a CqlVarint from an array of bytes in two’s complement big-endian binary representation.

See: disclaimer about non-normalized values.

pub fn from_signed_bytes_be_slice(digits: &[u8]) -> Self

Creates a CqlVarint from a slice of bytes in two’s complement binary big-endian representation.

See: disclaimer about non-normalized values.

impl CqlVarint

Conversion to bytes

pub fn into_signed_bytes_be(self) -> Vec<u8>

Converts CqlVarint to an array of bytes in two’s complement binary big-endian representation.

pub fn as_signed_bytes_be_slice(&self) -> &[u8]

Returns a slice of bytes in two’s complement binary big-endian representation.

Trait Implementations

impl Clone for CqlVarint

fn clone(&self) -> CqlVarint

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CqlVarint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for CqlVarint

fn type_check(typ: &ColumnType<'_>) -> Result<(), TypeCheckError>

Checks that the column type matches what this type expects.

fn deserialize( typ: &'metadata ColumnType<'metadata>, v: Option<FrameSlice<'frame>>, ) -> Result<Self, DeserializationError>

Deserialize a column value from given serialized representation.

impl FromCqlVal<CqlValue> for CqlVarint

fn from_cql(cql_val: CqlValue) -> Result<CqlVarint, FromCqlValError>

👎Deprecated since 0.15.0: Legacy deserialization API is inefficient and is going to be removed soon

impl Hash for CqlVarint

Computes the hash of normalized CqlVarint.

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CqlVarint

Compares two CqlVarint values after normalization.

Example

let non_normalized_bytes = vec![0x00, 0x01];
let normalized_bytes = vec![0x01];
assert_eq!(
    CqlVarint::from_signed_bytes_be(non_normalized_bytes),
    CqlVarint::from_signed_bytes_be(normalized_bytes)
);

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SerializeValue for CqlVarint

fn serialize<'b>( &self, typ: &ColumnType<'_>, writer: CellWriter<'b>, ) -> Result<WrittenCellProof<'b>, SerializationError>

Serializes the value to given CQL type.

impl Value for CqlVarint

fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig>

👎Deprecated since 0.15.1: Legacy serialization API is not type-safe and is going to be removed soon

impl Emptiable for CqlVarint

impl Eq for CqlVarint