ScyllaDB Docs Scylla Rust Driver Data Types Bool, Tinyint, Smallint, Int, Bigint, Float, Double

Caution

You're viewing documentation for a deprecated version of Scylla Rust Driver. Switch to the latest stable version.

Bool, Tinyint, Smallint, Int, Bigint, Float, Double¶

Bool¶

Bool is represented as rust bool

use futures::TryStreamExt;

// Insert a bool into the table
let to_insert: bool = true;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read a bool from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(bool,)>()?;
while let Some((bool_value,)) = iter.try_next().await? {
    println!("{:?}", bool_value);
}

Tinyint¶

Tinyint is represented as rust i8

use futures::TryStreamExt;

// Insert a tinyint into the table
let to_insert: i8 = 123;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read a tinyint from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(i8,)>()?;
while let Some((tinyint_value,)) = iter.try_next().await? {
    println!("{:?}", tinyint_value);
}

Smallint¶

Smallint is represented as rust i16

use futures::TryStreamExt;

// Insert a smallint into the table
let to_insert: i16 = 12345;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read a smallint from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(i16,)>()?;
while let Some((smallint_value,)) = iter.try_next().await? {
    println!("{}", smallint_value);
}

Int¶

Int is represented as rust i32

use futures::TryStreamExt;

// Insert an int into the table
let to_insert: i32 = 12345;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read an int from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(i32,)>()?;
while let Some((int_value,)) = iter.try_next().await? {
    println!("{}", int_value);
}

Bigint¶

Bigint is represented as rust i64

use futures::TryStreamExt;

// Insert a bigint into the table
let to_insert: i64 = 12345;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read a bigint from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(i64,)>()?;
while let Some((bigint_value,)) = iter.try_next().await? {
    println!("{:?}", bigint_value);
}

Float¶

Float is represented as rust f32

use futures::TryStreamExt;

// Insert a float into the table
let to_insert: f32 = 123.0;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read a float from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(f32,)>()?;
while let Some((float_value,)) = iter.try_next().await? {
    println!("{:?}", float_value);
}

Double¶

Double is represented as rust f64

use futures::TryStreamExt;

// Insert a double into the table
let to_insert: f64 = 12345.0;
session
    .query_unpaged("INSERT INTO keyspace.table (a) VALUES(?)", (to_insert,))
    .await?;

// Read a double from the table
let mut iter = session.query_iter("SELECT a FROM keyspace.table", &[])
    .await?
    .rows_stream::<(f64,)>()?;
while let Some((double_value,)) = iter.try_next().await? {
    println!("{:?}", double_value);
}

Was this page helpful?