Enum ScyllaDBArgument 

pub enum ScyllaDBArgument {
    Null,
    Any(Arc<dyn SerializeValue + Send + Sync>),
    Boolean(bool),
    BooleanArray(Vec<bool>),
    TinyInt(i8),
    TinyIntArray(Vec<i8>),
    SmallInt(i16),
    SmallIntArray(Vec<i16>),
    Int(i32),
    IntArray(Vec<i32>),
    BigInt(i64),
    BigIntArray(Vec<i64>),
    Float(f32),
    FloatArray(Vec<f32>),
    Double(f64),
    DoubleArray(Vec<f64>),
    Text(String),
    TextArray(Vec<String>),
    Blob(Vec<u8>),
    BlobArray(Vec<Vec<u8>>),
    Uuid(Uuid),
    UuidArray(Vec<Uuid>),
    Timeuuid(CqlTimeuuid),
    TimeuuidArray(Vec<CqlTimeuuid>),
    IpAddr(IpAddr),
    IpAddrArray(Vec<IpAddr>),
    Duration(CqlDuration),
    DurationArray(Vec<CqlDuration>),
    CqlTimestamp(CqlTimestamp),
    CqlTimestampArray(Vec<CqlTimestamp>),
    CqlDate(CqlDate),
    CqlDateArray(Vec<CqlDate>),
    CqlTime(CqlTime),
    CqlTimeArray(Vec<CqlTime>),
    Tuple(Box<dyn SerializeValue + Send + Sync>),
    UserDefinedType(Box<dyn SerializeValue + Send + Sync>),
    UserDefinedTypeArray(Vec<Box<dyn SerializeValue + Send + Sync>>),
    TextTextMap(HashMap<String, String>),
    TextBooleanMap(HashMap<String, bool>),
    TextTinyIntMap(HashMap<String, i8>),
    TextSmallIntMap(HashMap<String, i16>),
    TextIntMap(HashMap<String, i32>),
    TextBigIntMap(HashMap<String, i64>),
    TextFloatMap(HashMap<String, f32>),
    TextDoubleMap(HashMap<String, f64>),
    TextUuidMap(HashMap<String, Uuid>),
    TextIpAddrMap(HashMap<String, IpAddr>),
}

The enum of data types that can be handled by scylla-rust-driver.

Variants

Null

Internally used NULL.

Any(Arc<dyn SerializeValue + Send + Sync>)

Any type can be used.

Boolean(bool)

boolean type.

BooleanArray(Vec<bool>)

array of boolean type.

TinyInt(i8)

tinyint type.

TinyIntArray(Vec<i8>)

array of tinyint type.

SmallInt(i16)

smallint type.

SmallIntArray(Vec<i16>)

array of smallint type

Int(i32)

int type.

IntArray(Vec<i32>)

array of int type.

BigInt(i64)

bigint type.

BigIntArray(Vec<i64>)

array of bigint type.

Float(f32)

float type.

FloatArray(Vec<f32>)

array of float type.

Double(f64)

double type.

DoubleArray(Vec<f64>)

array of double type.

Text(String)

text or ascii type.

TextArray(Vec<String>)

array of text or ascii type.

Blob(Vec<u8>)

blob type.

BlobArray(Vec<Vec<u8>>)

array of blob type.

Uuid(Uuid)

uuid type.

UuidArray(Vec<Uuid>)

array of uuid type.

Timeuuid(CqlTimeuuid)

timeuuid type.

TimeuuidArray(Vec<CqlTimeuuid>)

array of timeuuid type.

IpAddr(IpAddr)

inet type.

IpAddrArray(Vec<IpAddr>)

array of inet type.

Duration(CqlDuration)

duration type.

DurationArray(Vec<CqlDuration>)

array of duration type.

CqlTimestamp(CqlTimestamp)

timestamp type.

CqlTimestampArray(Vec<CqlTimestamp>)

array of timestamp type.

CqlDate(CqlDate)

date type.

CqlDateArray(Vec<CqlDate>)

array of date type.

CqlTime(CqlTime)

time type.

CqlTimeArray(Vec<CqlTime>)

array of time type.

Tuple(Box<dyn SerializeValue + Send + Sync>)

any tuple type.

UserDefinedType(Box<dyn SerializeValue + Send + Sync>)

user-defined type.

UserDefinedTypeArray(Vec<Box<dyn SerializeValue + Send + Sync>>)

array of user-defined type.

TextTextMap(HashMap<String, String>)

map type for text and text.

TextBooleanMap(HashMap<String, bool>)

map type for text and boolean.

TextTinyIntMap(HashMap<String, i8>)

map type for text and tinyint.

TextSmallIntMap(HashMap<String, i16>)

map type for text and smallint.

TextIntMap(HashMap<String, i32>)

map type for text and int.

TextBigIntMap(HashMap<String, i64>)

map type for text and bigint.

TextFloatMap(HashMap<String, f32>)

map type for text and float.

TextDoubleMap(HashMap<String, f64>)

map type for text and double.

TextUuidMap(HashMap<String, Uuid>)

map type for text and uuid.

TextIpAddrMap(HashMap<String, IpAddr>)

map type for text and inet.

Trait Implementations

impl SerializeValue for ScyllaDBArgument

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

Serializes the value to given CQL type.