For example:

suppose that there is a table in Cassandra called tableA and it has two columns: ID column and timestamp column.

id is INT timestamp is DECIMAL

When executing those lines of code:

let update_struct_cql: String = format!("update tableA SET  timestamp = ? where id = ?;");

ddb.query_with_values(update_struct_cql,query_values!(current_time, id)).expect("[Err]: Could not update table");  

When I print out timestamp BEFORE it is being used in above query, it will print something normal, like 1545870134, however, when I check column value in Cassandra DB, I see something like:

6.1805539111220E-825570344

The question is: What happened to the timestamp ?

1. "Return" Results from as_rust! instead of using unwrap() and unreachable!.

2. Implement IntoRustByName<_> for Row using a new macro row_into_rust_by_name!. row_into_rust_by_name! uses as_rust! and the implementations change a bit, although I think the new behavior is more accurate. But it still leaves a problem. get_by_name() returns Option<Result<_>>. None if the column can't be found and Some(Err(_)) if the conversion fails. It also returns a custom error if the value is empty (except for blobs) and it doesn't handle null values explicitly. It would be nice if an Option could be returned, that is None in case of a null value. Maybe we could change the return type to Result<Option<_>> and return an error if the column can't be found. I'm not sure what the use case for the current implementation is, is it a common use case to look for a column that might not be there?

have run cargo fmt for all the files and has been incorporated into travis as well. so if we were to push file with a different style travis won't let you build it.

before pushing run cargo fmt -- --write-mode=diff

if there is anything coming on the console try cargo fmt -- --write-mode=overwrite cargo test

then push else build would fail

Reported in #61

When --all-features was used, the ssl transport was provided via the transport_ssl module. However, the examples were not prepared for this, and cargo test --all-features would fail.

As both transports are mutually exclusive, it seems reasonable to just use the same module name and make life easier for clients.

• [x] fix existing examples
• [x] add examples which would use ssl

It took me a while to figure out that calling into() on a Vec<u8> in order to convert it into Bytes doesn't work as I expected. impl<T: Into<Bytes> + Clone + Debug> From<Vec<T>> for Bytes exists but I'm not sure what it does exactly.

the rustfmt has been changed and it has been incorporated back to the project. right now I have enabled force installation of rustfmt in travis so builds might be slightly slower. once the dust settles down we shall enable the caching of cargo rust fmt

When configuring multiple scylla nodes, insert failes with an error "failed to fill whole buffer":

thread '<unnamed>' panicked at 'Failed to insert data: Io(Custom { kind: UnexpectedEof, error: StringError("failed to fill whole buffer") })', libcore/result.rs:1009:5
stack backtrace:
   0: std::sys::unix::backtrace::tracing::imp::unwind_backtrace
             at libstd/sys/unix/backtrace/tracing/gcc_s.rs:49
   1: std::sys_common::backtrace::print
             at libstd/sys_common/backtrace.rs:71
             at libstd/sys_common/backtrace.rs:59
   2: std::panicking::default_hook::{{closure}}
             at libstd/panicking.rs:211
   3: std::panicking::default_hook
             at libstd/panicking.rs:227
   4: std::panicking::rust_panic_with_hook
             at libstd/panicking.rs:476
   5: std::panicking::continue_panic_fmt
             at libstd/panicking.rs:390
   6: rust_begin_unwind
             at libstd/panicking.rs:325
   7: core::panicking::panic_fmt
             at libcore/panicking.rs:77
   8: core::result::unwrap_failed
             at libcore/macros.rs:26
   9: <core::result::Result<T, E>>::expect
             at libcore/result.rs:835
  10: <unknown>
             at src/main.rs:62

The issue can be reproduced with the following setup:

1. Setup scylla cluster with 3 nodes

docker run --name scylla-0 -p 9042:9042 -d scylladb/scylla
# wait until scylla-0 is up: docker exec -it scylla-0 nodetool status
docker run --name scylla-1 -p 9043:9042 -d scylladb/scylla --seeds="$(docker inspect --format='{{ .NetworkSettings.IPAddress }}' scylla-0)"
docker run --name scylla-2 -p 9044:9042 -d scylladb/scylla --seeds="$(docker inspect --format='{{ .NetworkSettings.IPAddress }}' scylla-0)"

2. Create column family within cqlsh: docker exec -it scylla-0 cqlsh

CREATE KEYSPACE test
WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 2};

use test;

CREATE TABLE data (
    id int,
    epoch_utc timestamp,
    value double,
    PRIMARY KEY (id, epoch_utc))
WITH CLUSTERING ORDER BY (epoch_utc DESC)
AND COMPACTION = {
    'class': 'TimeWindowCompactionStrategy',
    'compaction_window_unit': 'DAYS',
    'compaction_window_size': '1'
};

3. Cargo.toml

[package]
name = "rust_test_scylla"
version = "0.1.0"
authors = ["Pascal Sachs <[email protected]>"]
edition = "2018"

[dependencies]
cdrs = "^2.0.0-beta.6"
cdrs_helpers_derive = "0.1.0"
rand = "^0.6.5"

[profile.dev]
panic = "abort"

[profile.release]
panic = "abort"

4. main.rs

#[macro_use]
extern crate cdrs;
#[macro_use]
extern crate cdrs_helpers_derive;

use std::sync::Arc;
use std::thread;
use std::time::SystemTime;

use rand::prelude::*;

use cdrs::authenticators::NoneAuthenticator;
use cdrs::cluster::session::{new_lz4 as new_session, Session};
use cdrs::cluster::{ClusterTcpConfig, NodeTcpConfigBuilder, TcpConnectionPool};
use cdrs::frame::IntoBytes;
use cdrs::load_balancing::RoundRobinSync;
use cdrs::query::*;
use cdrs::types::prelude::*;

type ScyllaSession = Session<RoundRobinSync<TcpConnectionPool<NoneAuthenticator>>>;

const SCYLLA_NODES: &'static [&'static str] =
    &["localhost:9042", "localhost:9043", "localhost:9044"];

const INSERT_DATA: &'static str = "\
                                   INSERT INTO test.data \
                                   (id, epoch_utc, value) \
                                   VALUES (?, ?, ?)";

fn main() {
    let nodes = SCYLLA_NODES
        .into_iter()
        .map(|addr| NodeTcpConfigBuilder::new(addr, NoneAuthenticator {}).build())
        .collect();
    let cluster_config = ClusterTcpConfig(nodes);
    let session: Arc<ScyllaSession> = Arc::new(
        new_session(&cluster_config, RoundRobinSync::new())
            .expect("Could not connect to scylla cluster"),
    );

    for i in 0..20 {
        let thread_session = session.clone();
        thread::spawn(move || {
            let mut rng = rand::thread_rng();
            let query_insert_data = thread_session
                .prepare(INSERT_DATA)
                .expect("Failed to prepare insert data query");

            let id = i;
            let epoch_utc = (1_000
                * SystemTime::now()
                    .duration_since(SystemTime::UNIX_EPOCH)
                    .unwrap()
                    .as_secs()) as i64;
            let value = rng.gen();
            let values = DataStruct {
                id,
                epoch_utc,
                value,
            }
            .into_query_values();
            thread_session
                .exec_with_values(&query_insert_data, values)
                .expect("Failed to insert data");
        })
        .join()
        .expect("thread error");
    }
}

#[derive(Clone, Debug, IntoCDRSValue, PartialEq)]
pub struct DataStruct {
    id: i32,
    epoch_utc: i64,
    value: f64,
}

impl DataStruct {
    fn into_query_values(self) -> QueryValues {
        query_values!(self.id, self.epoch_utc, self.value)
    }
}

Needed to take some vector element without breaking an vector of rows (also needed since try_from_row method can't work with refs)

(also please tell if there is any communication channel, I had few additional questions)

CDRS drives fails to fetch data from Cassandra, if one or more of the columns has a "null" value.

Code:

fn select_struct(session: &CurrentSession) { let select_struct_cql = "SELECT * FROM autopush.message_2018_10 where uaid='185afbf3d7a94fc6a577c20ffc62431d'"; let rows = session .query(select_struct_cql) .expect("query") .get_body() .expect("get body") .into_rows() .expect("into rows"); for row in rows { let my_row: RowStruct = RowStruct::try_from_row(row).expect("into RowStruct"); println!("struct got: {:?}", my_row); } }

Error details: thread 'main' panicked at 'into RowStruct: General("Column or UDT property 'key' is empty")', libcore/result.rs:1009:5

Table description:

CREATE TABLE autopush.message_2018_10 ( uaid text, chidmessageid text, chids set, current_timestamp decimal, data text, headers map<text, text>, timestamp int, ttl int, updateid text, PRIMARY KEY (uaid, chidmessageid) ) WITH CLUSTERING ORDER BY (chidmessageid ASC) AND bloom_filter_fp_chance = 0.01 AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'} AND comment = '' AND compaction = {'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'} AND compression = {'chunk_length_in_kb': '64', 'class': 'org.apache.cassandra.io.compress.LZ4Compressor'} AND crc_check_chance = 1.0 AND dclocal_read_repair_chance = 0.1 AND default_time_to_live = 0 AND gc_grace_seconds = 864000 AND max_index_interval = 2048 AND memtable_flush_period_in_ms = 0 AND min_index_interval = 128 AND read_repair_chance = 0.0 AND speculative_retry = '99PERCENTILE';

Example of an entry (Which has been failed) to be fetched into RowStructure:

185afbf3d7a94fc6a577c20ffc62431d | 02:1545961471067:86ba2621-db55-4749-b38f-f8300133ae17 | null | null | K61oUoC5-EZRDHi2-R-EKBFO_aiV6iYFuAPAZ1zJmJ6F8mxdwaQ | {'crypto_key': 'dh=BM-rwWt2s4L6sFNuqJA6pzNE9zy-h1mbiUU_28hndA-IbyQJM3PLCk5787515X_9QX66IP34b8JM1HXQHzPb-A8', 'encoding': 'aesgcm', 'encryption': 'salt=bB7LtNdeLUXbtJTzM7715Q'} | 1545961468 | 300 | gAAAAABcJX_8_7OWPBENWF-w9BEDpX-O_rILoKS8PQir3c18ZNJN-tElzsrHUoA3uQs_RuJs7qNoSupz4LwUh6SxtkmsyWO7NnwVFyvwUH9mp-qmTl948hQl4fNToqArtq9d5P1oVo2yuqlHTFCf6uvkagt7pxr17kLuJnDgAOG5dvQ_E1qgkr6DYw7E5DpX3up1QLG-OI6e

I have enabled the CI for windows env. unit tests are working but the integration tests are still not working as i was unable to get cassandra installed on the windows image

Noticed that when inserting/reading data that contains NULL causes

fatal runtime error: out of memory

I reproduced issue below. Couldn't trace error due to lack of details.

cc @AlexPikalov @harrydevnull

I was trying to make my credentials configurable. Like this:

    let session = if let Some((user, pass)) = pass {
        let auth = StaticPasswordAuthenticator::new(user, pass);
        let node = NodeTcpConfigBuilder::new("127.0.0.1:9042", auth).build();
        let cluster_config = ClusterTcpConfig(vec![node]);
        session::new(&cluster_config, RoundRobin::new()).expect("session should be created")
    } else {
        let auth = NoneAuthenticator {};
        let node = NodeTcpConfigBuilder::new("127.0.0.1:9042", auth).build();
        let cluster_config = ClusterTcpConfig(vec![node]);
        session::new(&cluster_config, RoundRobin::new()).expect("session should be created")
    };

That obviously fails as it will generate incompatible types. What would be the proper way?

It's more a question than an issue. I'm trying to use CDRS in an actix-web application. I would like to share the database session among the HTTP requests but for that, the struct must implement the Clonetrait. Given that, r2d2 would fit nicely. However, when trying to use TcpConnectionsManager to pass to a Poolfrom r2d2, I can only get a TransportTcp struct and not the Session itself. Am I missing something in order to get a proper session from the r2d2 pool?

$ cargo audit
    Fetching advisory database from `https://github.com/RustSec/advisory-db.git`
      Loaded 126 security advisories (from /home/olexiyb/.cargo/advisory-db)
    Updating crates.io index
    Scanning Cargo.lock for vulnerabilities (54 crate dependencies)
     Success No vulnerable packages found

warning: 1 warning found

Crate:  lz4-compress
Title:  lz4-compress is unmaintained
Date:   2017-04-17
URL:    https://rustsec.org/advisories/RUSTSEC-2017-0007
Dependency tree: 
lz4-compress 0.1.0
└── cdrs 2.3.1

I have tried to use lz4-compression, but it requires some improvement in error handling. I also would recommend taking a look into lz-fear

Note that first https://github.com/AlexPikalov/cdrs/pull/347 and https://github.com/AlexPikalov/cdrs/pull/337 must be merged, since now commits are in this PR that are inside the other PR's