#[cfg(feature = "e2e-tests")]
#[macro_use]
extern crate cdrs;
extern crate regex;
extern crate time;
extern crate uuid;
mod common;
#[cfg(feature = "e2e-tests")]
use common::*;
#[cfg(feature = "e2e-tests")]
use cdrs::error::Result;
#[cfg(feature = "e2e-tests")]
use cdrs::frame::IntoBytes;
#[cfg(feature = "e2e-tests")]
use cdrs::query::QueryExecutor;
#[cfg(feature = "e2e-tests")]
use cdrs::types::blob::Blob;
#[cfg(feature = "e2e-tests")]
use cdrs::types::tuple::Tuple;
#[cfg(feature = "e2e-tests")]
use cdrs::types::value::{Bytes, Value};
#[cfg(feature = "e2e-tests")]
use cdrs::types::{IntoRustByIndex, IntoRustByName};
#[cfg(feature = "e2e-tests")]
use time::Timespec;
#[cfg(feature = "e2e-tests")]
use uuid::Uuid;
#[cfg(feature = "e2e-tests")]
use std::str::FromStr;
#[test]
#[cfg(feature = "e2e-tests")]
fn simple_tuple() {
let cql = "CREATE TABLE IF NOT EXISTS cdrs_test.simple_tuple \
(my_tuple tuple<text, int> PRIMARY KEY)";
let session = setup(cql).expect("setup");
#[derive(Debug, Clone, PartialEq)]
struct MyTuple {
pub my_text: String,
pub my_int: i32,
}
impl MyTuple {
pub fn try_from(tuple: Tuple) -> Result<MyTuple> {
let my_text: String = tuple.get_r_by_index(0)?;
let my_int: i32 = tuple.get_r_by_index(1)?;
Ok(MyTuple {
my_text: my_text,
my_int: my_int,
})
}
}
impl Into<Bytes> for MyTuple {
fn into(self) -> Bytes {
let mut bytes = Vec::new();
let val_bytes: Bytes = self.my_text.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
let val_bytes: Bytes = self.my_int.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
Bytes::new(bytes)
}
}
let my_tuple = MyTuple {
my_text: "my_text".to_string(),
my_int: 0,
};
let values = query_values!(my_tuple.clone());
let cql = "INSERT INTO cdrs_test.simple_tuple \
(my_tuple) VALUES (?)";
session.query_with_values(cql, values).expect("insert");
let cql = "SELECT * FROM cdrs_test.simple_tuple";
let rows = session
.query(cql)
.expect("query")
.get_body()
.expect("get body")
.into_rows()
.expect("into rows");
assert_eq!(rows.len(), 1);
for row in rows {
let my_tuple_row: Tuple = row.get_r_by_name("my_tuple").expect("my_tuple");
let my_tuple_row = MyTuple::try_from(my_tuple_row).expect("my_tuple as rust");
assert_eq!(my_tuple_row, my_tuple);
}
}
#[test]
#[cfg(feature = "e2e-tests")]
fn nested_tuples() {
let cql = "CREATE TABLE IF NOT EXISTS cdrs_test.test_nested_tuples \
(my_key int PRIMARY KEY, \
my_outer_tuple tuple<uuid, blob, tuple<text, int, timestamp>>)";
let session = setup(cql).expect("setup");
#[derive(Debug, Clone, PartialEq)]
struct MyInnerTuple {
pub my_text: String,
pub my_int: i32,
pub my_timestamp: Timespec,
}
impl MyInnerTuple {
pub fn try_from(tuple: Tuple) -> Result<MyInnerTuple> {
let my_text: String = tuple.get_r_by_index(0)?;
let my_int: i32 = tuple.get_r_by_index(1)?;
let my_timestamp: Timespec = tuple.get_r_by_index(2)?;
Ok(MyInnerTuple {
my_text: my_text,
my_int: my_int,
my_timestamp: my_timestamp,
})
}
}
impl Into<Bytes> for MyInnerTuple {
fn into(self) -> Bytes {
let mut bytes = Vec::new();
let val_bytes: Bytes = self.my_text.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
let val_bytes: Bytes = self.my_int.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
let val_bytes: Bytes = self.my_timestamp.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
Bytes::new(bytes)
}
}
#[derive(Debug, Clone, PartialEq)]
struct MyOuterTuple {
pub my_uuid: Uuid,
pub my_blob: Vec<u8>,
pub my_inner_tuple: MyInnerTuple,
}
impl MyOuterTuple {
pub fn try_from(tuple: Tuple) -> Result<MyOuterTuple> {
let my_uuid: Uuid = tuple.get_r_by_index(0)?;
let my_blob: Blob = tuple.get_r_by_index(1)?;
let my_inner_tuple: Tuple = tuple.get_r_by_index(2)?;
let my_inner_tuple = MyInnerTuple::try_from(my_inner_tuple).expect("from tuple");
Ok(MyOuterTuple {
my_uuid: my_uuid,
my_blob: my_blob.into_vec(),
my_inner_tuple: my_inner_tuple,
})
}
}
impl Into<Bytes> for MyOuterTuple {
fn into(self) -> Bytes {
let mut bytes = Vec::new();
let val_bytes: Bytes = self.my_uuid.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
let val_bytes: Bytes = Bytes::new(self.my_blob);
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
let val_bytes: Bytes = self.my_inner_tuple.into();
bytes.extend_from_slice(Value::new_normal(val_bytes).into_cbytes().as_slice());
Bytes::new(bytes)
}
}
let my_uuid = Uuid::from_str("bb16106a-10bc-4a07-baa3-126ffe208c43").unwrap();
let my_blob: Vec<u8> = vec![0, 1, 2, 4, 8, 16, 32, 64, 128, 255];
let my_inner_tuple = MyInnerTuple {
my_text: "my_text".to_string(),
my_int: 1_000,
my_timestamp: Timespec {
sec: 1,
nsec: 999_000_000,
},
};
let my_outer_tuple = MyOuterTuple {
my_uuid: my_uuid,
my_blob: my_blob,
my_inner_tuple: my_inner_tuple,
};
let values = query_values!(0i32, my_outer_tuple.clone());
let cql = "INSERT INTO cdrs_test.test_nested_tuples \
(my_key, my_outer_tuple) VALUES (?, ?)";
session.query_with_values(cql, values).expect("insert");
let cql = "SELECT * FROM cdrs_test.test_nested_tuples";
let rows = session
.query(cql)
.expect("query")
.get_body()
.expect("get body")
.into_rows()
.expect("into rows");
assert_eq!(rows.len(), 1);
for row in rows {
let my_outer_tuple_row: Tuple =
row.get_r_by_name("my_outer_tuple").expect("my_outer_tuple");
let my_outer_tuple_row = MyOuterTuple::try_from(my_outer_tuple_row).expect("from tuple");
assert_eq!(my_outer_tuple_row, my_outer_tuple);
}
}