Enum scylla::frame::response::result::CqlValue

pub enum CqlValue {
    Ascii(String),
    Boolean(bool),
    Blob(Vec<u8>),
    Counter(Counter),
    Decimal(BigDecimal),
    Date(u32),
    Double(f64),
    Float(f32),
    Int(i32),
    BigInt(i64),
    Text(String),
    Timestamp(Duration),
    Inet(IpAddr),
    List(Vec<CqlValue>),
    Map(Vec<(CqlValue, CqlValue)>),
    Set(Vec<CqlValue>),
    UserDefinedType {
        keyspace: String,
        type_name: String,
        fields: BTreeMap<String, Option<CqlValue>>,
    },
    SmallInt(i16),
    TinyInt(i8),
    Time(Duration),
    Timeuuid(Uuid),
    Tuple(Vec<CqlValue>),
    Uuid(Uuid),
    Varint(BigInt),
}

Variants

Ascii(String)

Boolean(bool)

Blob(Vec<u8>)

Counter(Counter)

Decimal(BigDecimal)

Date(u32)

Days since -5877641-06-23 i.e. 2^31 days before unix epoch Can be converted to chrono::NaiveDate (-262145-1-1 to 262143-12-31) using as_date

Double(f64)

Float(f32)

Int(i32)

BigInt(i64)

Text(String)

Timestamp(Duration)

Milliseconds since unix epoch

Inet(IpAddr)

List(Vec<CqlValue>)

Map(Vec<(CqlValue, CqlValue)>)

Set(Vec<CqlValue>)

UserDefinedType

Fields of UserDefinedType

keyspace: Stringtype_name: Stringfields: BTreeMap<String, Option<CqlValue>>

SmallInt(i16)

TinyInt(i8)

Time(Duration)

Nanoseconds since midnight

Timeuuid(Uuid)

Tuple(Vec<CqlValue>)

Uuid(Uuid)

Varint(BigInt)

Implementations

impl CqlValue

pub fn as_ascii(&self) -> Option<&String>

pub fn as_date(&self) -> Option<NaiveDate>

pub fn as_duration(&self) -> Option<Duration>

pub fn as_counter(&self) -> Option<Counter>

pub fn as_boolean(&self) -> Option<bool>

pub fn as_double(&self) -> Option<f64>

pub fn as_uuid(&self) -> Option<Uuid>

pub fn as_float(&self) -> Option<f32>

pub fn as_int(&self) -> Option<i32>

pub fn as_bigint(&self) -> Option<i64>

pub fn as_tinyint(&self) -> Option<i8>

pub fn as_smallint(&self) -> Option<i16>

pub fn as_blob(&self) -> Option<&Vec<u8>>

pub fn as_text(&self) -> Option<&String>

pub fn as_timeuuid(&self) -> Option<Uuid>

pub fn into_string(self) -> Option<String>

pub fn into_blob(self) -> Option<Vec<u8>>

pub fn as_inet(&self) -> Option<IpAddr>

pub fn as_list(&self) -> Option<&Vec<CqlValue>>

pub fn as_set(&self) -> Option<&Vec<CqlValue>>

pub fn into_vec(self) -> Option<Vec<CqlValue>>

pub fn into_pair_vec(self) -> Option<Vec<(CqlValue, CqlValue)>>

pub fn into_varint(self) -> Option<BigInt>

pub fn into_decimal(self) -> Option<BigDecimal>

Trait Implementations

impl Debug for CqlValue

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

Formats the value using the given formatter.

impl FromCqlVal<CqlValue> for i32

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

impl FromCqlVal<CqlValue> for i64

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

impl FromCqlVal<CqlValue> for String

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

impl FromCqlVal<CqlValue> for Vec<u8>

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

impl FromCqlVal<CqlValue> for IpAddr

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

impl FromCqlVal<CqlValue> for Uuid

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

impl FromCqlVal<CqlValue> for BigDecimal

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

impl FromCqlVal<CqlValue> for Duration

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

impl<T: FromCqlVal<CqlValue>> FromCqlVal<CqlValue> for Vec<T>

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

impl<T1: FromCqlVal<CqlValue> + Eq + Hash, T2: FromCqlVal<CqlValue>> FromCqlVal<CqlValue> for HashMap<T1, T2>

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

impl<T1> FromCqlVal<CqlValue> for (T1,) where
    T1: FromCqlVal<CqlValue>, 

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

impl<T1, T2> FromCqlVal<CqlValue> for (T1, T2) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>, 

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

impl FromCqlVal<CqlValue> for Counter

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

impl<T1, T2, T3> FromCqlVal<CqlValue> for (T1, T2, T3) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4> FromCqlVal<CqlValue> for (T1, T2, T3, T4) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>,
    T11: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>,
    T11: FromCqlVal<CqlValue>,
    T12: FromCqlVal<CqlValue>, 

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

impl FromCqlVal<CqlValue> for i16

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>,
    T11: FromCqlVal<CqlValue>,
    T12: FromCqlVal<CqlValue>,
    T13: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>,
    T11: FromCqlVal<CqlValue>,
    T12: FromCqlVal<CqlValue>,
    T13: FromCqlVal<CqlValue>,
    T14: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>,
    T11: FromCqlVal<CqlValue>,
    T12: FromCqlVal<CqlValue>,
    T13: FromCqlVal<CqlValue>,
    T14: FromCqlVal<CqlValue>,
    T15: FromCqlVal<CqlValue>, 

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> FromCqlVal<CqlValue> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) where
    T1: FromCqlVal<CqlValue>,
    T2: FromCqlVal<CqlValue>,
    T3: FromCqlVal<CqlValue>,
    T4: FromCqlVal<CqlValue>,
    T5: FromCqlVal<CqlValue>,
    T6: FromCqlVal<CqlValue>,
    T7: FromCqlVal<CqlValue>,
    T8: FromCqlVal<CqlValue>,
    T9: FromCqlVal<CqlValue>,
    T10: FromCqlVal<CqlValue>,
    T11: FromCqlVal<CqlValue>,
    T12: FromCqlVal<CqlValue>,
    T13: FromCqlVal<CqlValue>,
    T14: FromCqlVal<CqlValue>,
    T15: FromCqlVal<CqlValue>,
    T16: FromCqlVal<CqlValue>, 

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

impl FromCqlVal<CqlValue> for BigInt

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

impl FromCqlVal<CqlValue> for i8

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

impl FromCqlVal<CqlValue> for NaiveDate

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

impl FromCqlVal<CqlValue> for f32

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

impl FromCqlVal<CqlValue> for f64

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

impl FromCqlVal<CqlValue> for bool

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

impl PartialEq<CqlValue> for CqlValue

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

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

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

This method tests for !=.

impl StructuralPartialEq for CqlValue