Struct Config 

pub struct Config { /* private fields */ }

Configuration for a Skytable connection

Implementations

impl Config

pub fn new_default(username: &str, password: &str) -> Self

Create a new Config using the default connection settings and using the provided username and password

Examples found in repository

examples/multi_row.rs (line 12)

fn main() {
    let mut db = Config::new_default("user", "password").connect().unwrap();
    let users: Rows<User> = db
        .query_parse(&query!(
            "select all username, password, followers, email from myspace.mymodel limit ?",
            1000u64
        ))
        .unwrap();
    // assume the first row has username set to 'sayan'
    assert_eq!(users[0].username, "sayan");
}

examples/dynamic_lists_advanced.rs (line 64)

fn main() {
    let mut db = Config::new_default("root", "password12345678")
        .connect()
        .unwrap();
    let data_from_api = get_data_from_api();
    db.query_parse::<()>(&skytable::query!(
        "insert into myapp.mydb { username: ?, password: ?, data: ? }",
        &data_from_api
    ))
    .unwrap();
    let fetched_user: User = db
        .query_parse(&skytable::query!(
            "select * from myapp.mydb where username = ?",
            "sayan"
        ))
        .unwrap();
    assert_eq!(data_from_api, fetched_user);
}

examples/custom_types.rs (line 44)

fn main() {
    let mut db = Config::new_default("username", "password")
        .connect()
        .unwrap();

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64, null email: string)"
    ))
    .unwrap();

    // insert data
    let our_user = User::new("myuser".into(), "pass123".into(), 0, None);
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?, ?)",
        our_user.clone()
    ))
    .unwrap();

    // select data
    let ret_user: User = db
        .query_parse(&query!(
            "select * from myspace.mymodel WHERE username = ?",
            &our_user.username
        ))
        .unwrap();

    assert_eq!(our_user, ret_user);
}

examples/dynamic_lists_simple.rs (line 20)

fn main() {
    let mut db = Config::new_default("root", "password12345678")
        .connect()
        .unwrap();
    let data_from_api = get_list_data_from_api();
    let q = skytable::query!(
        "insert into myapp.mydb { username: ?, password: ?, data: ? }",
        "sayan",
        "ulw06afuMCAg+1gh2lh1Y9xTIr/dUv2vqGLeZ39cVrE=",
        QList::new(&data_from_api)
    );
    db.query_parse::<()>(&q).unwrap(); // expect this data to be inserted correctly
                                       // now fetch this data
    let (username, password, data): (String, String, RList<String>) = db
        .query_parse(&skytable::query!(
            "select * from myapp.mydb where username = ?",
            "sayan"
        ))
        .unwrap();
    assert_eq!(username, "sayan");
    assert_eq!(password, "ulw06afuMCAg+1gh2lh1Y9xTIr/dUv2vqGLeZ39cVrE=");
    assert_eq!(data.into_values(), data_from_api);
}

examples/simple.rs (line 11)

fn main() {
    let mut db = Config::new_default("username", "password")
        .connect()
        .unwrap();

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64)"
    ))
    .unwrap();

    // manipulate data

    let (form_username, form_pass) = dummy_web_fetch_username_password();
    // insert some data
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?)",
        &form_username,
        form_pass,
        100_000_000u64
    ))
    .unwrap();

    // get it back
    let (password, followers): (String, u64) = db
        .query_parse(&query!(
            "select password, followers FROM myspace.mymodel WHERE username = ?",
            &form_username
        ))
        .unwrap();
    assert_eq!(password, "rick123", "password changed!");
    // send to our client
    dummy_respond_to_request(followers);

    // update followers to account for huge numbers who were angry after being rickrolled
    db.query_parse::<()>(&query!(
        "update myspace.mymodel SET followers -= ? WHERE username = ?",
        50_000_000u64,
        &form_username
    ))
    .unwrap();

    // alright, everyone is tired from being rickrolled so we'll have to ban rick's account
    db.query_parse::<()>(&query!(
        "delete from myspace.mymodel where username = ?",
        &form_username
    ))
    .unwrap();
}

pub fn new(host: &str, port: u16, username: &str, password: &str) -> Self

Create a new Config using the given settings.

PROTOCOL VERSION: Defaults to [ProtocolVersion::V2_0]

pub fn host(&self) -> &str

Returns the host setting for this this configuration

pub fn port(&self) -> u16

Returns the port setting for this this configuration

pub fn username(&self) -> &str

Returns the username setting for this this configuration

pub fn password(&self) -> &str

Returns the password set using this configuration

impl Config

pub async fn connect_async(&self) -> ClientResult<ConnectionAsync>

Establish an async connection to the database using the current configuration

pub async fn connect_tls_async( &self, cert: &str, ) -> ClientResult<ConnectionTlsAsync>

Establish an async TLS connection to the database using the current configuration. Pass the certificate in PEM format.

impl Config

pub fn connect(&self) -> ClientResult<Connection>

Establish a connection to the database using the current configuration

Examples found in repository

examples/multi_row.rs (line 12)

fn main() {
    let mut db = Config::new_default("user", "password").connect().unwrap();
    let users: Rows<User> = db
        .query_parse(&query!(
            "select all username, password, followers, email from myspace.mymodel limit ?",
            1000u64
        ))
        .unwrap();
    // assume the first row has username set to 'sayan'
    assert_eq!(users[0].username, "sayan");
}

examples/dynamic_lists_advanced.rs (line 65)

fn main() {
    let mut db = Config::new_default("root", "password12345678")
        .connect()
        .unwrap();
    let data_from_api = get_data_from_api();
    db.query_parse::<()>(&skytable::query!(
        "insert into myapp.mydb { username: ?, password: ?, data: ? }",
        &data_from_api
    ))
    .unwrap();
    let fetched_user: User = db
        .query_parse(&skytable::query!(
            "select * from myapp.mydb where username = ?",
            "sayan"
        ))
        .unwrap();
    assert_eq!(data_from_api, fetched_user);
}

examples/custom_types.rs (line 45)

fn main() {
    let mut db = Config::new_default("username", "password")
        .connect()
        .unwrap();

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64, null email: string)"
    ))
    .unwrap();

    // insert data
    let our_user = User::new("myuser".into(), "pass123".into(), 0, None);
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?, ?)",
        our_user.clone()
    ))
    .unwrap();

    // select data
    let ret_user: User = db
        .query_parse(&query!(
            "select * from myspace.mymodel WHERE username = ?",
            &our_user.username
        ))
        .unwrap();

    assert_eq!(our_user, ret_user);
}

examples/dynamic_lists_simple.rs (line 21)

fn main() {
    let mut db = Config::new_default("root", "password12345678")
        .connect()
        .unwrap();
    let data_from_api = get_list_data_from_api();
    let q = skytable::query!(
        "insert into myapp.mydb { username: ?, password: ?, data: ? }",
        "sayan",
        "ulw06afuMCAg+1gh2lh1Y9xTIr/dUv2vqGLeZ39cVrE=",
        QList::new(&data_from_api)
    );
    db.query_parse::<()>(&q).unwrap(); // expect this data to be inserted correctly
                                       // now fetch this data
    let (username, password, data): (String, String, RList<String>) = db
        .query_parse(&skytable::query!(
            "select * from myapp.mydb where username = ?",
            "sayan"
        ))
        .unwrap();
    assert_eq!(username, "sayan");
    assert_eq!(password, "ulw06afuMCAg+1gh2lh1Y9xTIr/dUv2vqGLeZ39cVrE=");
    assert_eq!(data.into_values(), data_from_api);
}

examples/simple.rs (line 12)

fn main() {
    let mut db = Config::new_default("username", "password")
        .connect()
        .unwrap();

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64)"
    ))
    .unwrap();

    // manipulate data

    let (form_username, form_pass) = dummy_web_fetch_username_password();
    // insert some data
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?)",
        &form_username,
        form_pass,
        100_000_000u64
    ))
    .unwrap();

    // get it back
    let (password, followers): (String, u64) = db
        .query_parse(&query!(
            "select password, followers FROM myspace.mymodel WHERE username = ?",
            &form_username
        ))
        .unwrap();
    assert_eq!(password, "rick123", "password changed!");
    // send to our client
    dummy_respond_to_request(followers);

    // update followers to account for huge numbers who were angry after being rickrolled
    db.query_parse::<()>(&query!(
        "update myspace.mymodel SET followers -= ? WHERE username = ?",
        50_000_000u64,
        &form_username
    ))
    .unwrap();

    // alright, everyone is tired from being rickrolled so we'll have to ban rick's account
    db.query_parse::<()>(&query!(
        "delete from myspace.mymodel where username = ?",
        &form_username
    ))
    .unwrap();
}

pub fn connect_tls(&self, cert: &str) -> ClientResult<ConnectionTls>

Establish a TLS connection to the database using the current configuration. Pass the certificate in PEM format.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl PartialEq for Config

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Config