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

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

Variants§

Ascii(String)

Boolean(bool)

Blob(Vec<u8, Global>)

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)

Duration(CqlDuration)

Empty

Float(f32)

Int(i32)

BigInt(i64)

Text(String)

Timestamp(Duration)

Milliseconds since unix epoch

Inet(IpAddr)

List(Vec<CqlValue, Global>)

Map(Vec<(CqlValue, CqlValue), Global>)

Set(Vec<CqlValue, Global>)

UserDefinedType

Fields

§keyspace: String

§type_name: String

§fields: Vec<(String, Option<CqlValue>), Global>

Order of fields vector must match the order of fields as defined in the UDT. The driver does not check it by itself, so incorrect data will be written if the order is wrong.

SmallInt(i16)

TinyInt(i8)

Time(Duration)

Nanoseconds since midnight

Timeuuid(Uuid)

Tuple(Vec<Option<CqlValue>, Global>)

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_cql_duration(&self) -> Option<CqlDuration>

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, Global>>

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, Global>>

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

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

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

pub fn as_map(&self) -> Option<&Vec<(CqlValue, CqlValue), Global>>

pub fn as_udt(&self) -> Option<&Vec<(String, Option<CqlValue>), Global>>

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

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

pub fn into_udt_pair_vec( self ) -> Option<Vec<(String, Option<CqlValue>), Global>>

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

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

Trait Implementations§

impl Clone for CqlValue

fn clone(&self) -> CqlValue

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Debug for CqlValue

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

Formats the value using the given formatter. Read more

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

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

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

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

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

fn from_cql(cql_val: CqlValue) -> Result<(T1, T2, T3), FromCqlValError>

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

fn from_cql(cql_val: CqlValue) -> Result<(T1, T2, T3, T4), FromCqlValError>

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

fn from_cql(cql_val: CqlValue) -> Result<(T1, T2, T3, T4, T5), FromCqlValError>

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

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6), FromCqlValError>

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

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7), FromCqlValError>

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

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>, T11: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>, T11: FromCqlVal<Option<CqlValue>>, T12: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>, T11: FromCqlVal<Option<CqlValue>>, T12: FromCqlVal<Option<CqlValue>>, T13: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>, T11: FromCqlVal<Option<CqlValue>>, T12: FromCqlVal<Option<CqlValue>>, T13: FromCqlVal<Option<CqlValue>>, T14: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>, T11: FromCqlVal<Option<CqlValue>>, T12: FromCqlVal<Option<CqlValue>>, T13: FromCqlVal<Option<CqlValue>>, T14: FromCqlVal<Option<CqlValue>>, T15: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), 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<Option<CqlValue>>, T2: FromCqlVal<Option<CqlValue>>, T3: FromCqlVal<Option<CqlValue>>, T4: FromCqlVal<Option<CqlValue>>, T5: FromCqlVal<Option<CqlValue>>, T6: FromCqlVal<Option<CqlValue>>, T7: FromCqlVal<Option<CqlValue>>, T8: FromCqlVal<Option<CqlValue>>, T9: FromCqlVal<Option<CqlValue>>, T10: FromCqlVal<Option<CqlValue>>, T11: FromCqlVal<Option<CqlValue>>, T12: FromCqlVal<Option<CqlValue>>, T13: FromCqlVal<Option<CqlValue>>, T14: FromCqlVal<Option<CqlValue>>, T15: FromCqlVal<Option<CqlValue>>, T16: FromCqlVal<Option<CqlValue>>,

fn from_cql( cql_val: CqlValue ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), FromCqlValError>

impl<K, V> FromCqlVal<CqlValue> for BTreeMap<K, V, Global>where K: FromCqlVal<CqlValue> + Ord, V: FromCqlVal<CqlValue>,

fn from_cql( cql_val: CqlValue ) -> Result<BTreeMap<K, V, Global>, FromCqlValError>

impl<T> FromCqlVal<CqlValue> for BTreeSet<T, Global>where T: FromCqlVal<CqlValue> + Ord,

fn from_cql(cql_val: CqlValue) -> Result<BTreeSet<T, Global>, FromCqlValError>

impl FromCqlVal<CqlValue> for BigDecimal

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

impl FromCqlVal<CqlValue> for BigInt

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

impl FromCqlVal<CqlValue> for Counter

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

impl FromCqlVal<CqlValue> for CqlDuration

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

impl FromCqlVal<CqlValue> for CqlValue

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

impl FromCqlVal<CqlValue> for Date

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

impl FromCqlVal<CqlValue> for DateTime<Utc>

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

impl FromCqlVal<CqlValue> for Duration

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

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

fn from_cql( cql_val: CqlValue ) -> Result<HashMap<T1, T2, RandomState>, FromCqlValError>

impl<T> FromCqlVal<CqlValue> for HashSet<T, RandomState>where T: FromCqlVal<CqlValue> + Eq + Hash,

fn from_cql( cql_val: CqlValue ) -> Result<HashSet<T, RandomState>, FromCqlValError>

impl FromCqlVal<CqlValue> for IpAddr

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

impl FromCqlVal<CqlValue> for NaiveDate

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

impl<V> FromCqlVal<CqlValue> for Secret<V>where V: FromCqlVal<CqlValue> + Zeroize,

Available on crate feature secret only.

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

impl FromCqlVal<CqlValue> for String

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

impl FromCqlVal<CqlValue> for Time

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

impl FromCqlVal<CqlValue> for Timestamp

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

impl FromCqlVal<CqlValue> for Uuid

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

impl<T> FromCqlVal<CqlValue> for Vec<T, Global>where T: FromCqlVal<CqlValue>,

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

impl FromCqlVal<CqlValue> for Vec<u8, Global>

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

impl FromCqlVal<CqlValue> for bool

fn from_cql(cql_val: CqlValue) -> Result<bool, 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 i16

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

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 i8

fn from_cql(cql_val: CqlValue) -> Result<i8, 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 ==.

1.0.0 · source§

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 Value for CqlValue

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

impl StructuralPartialEq for CqlValue

Auto Trait Implementations§

impl RefUnwindSafe for CqlValue

impl Send for CqlValue

impl Sync for CqlValue

impl Unpin for CqlValue

impl UnwindSafe for CqlValue

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> FromCqlVal<Option<CqlValue>> for Twhere T: FromCqlVal<CqlValue>,

fn from_cql(cql_val_opt: Option<CqlValue>) -> Result<T, FromCqlValError>

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more