This snippet:

let query = format!("select column_name, type from system_schema.columns where keyspace_name = '{}' and table_name = '{}'", keyspace, table);
            let schema_query = Statement::new(&query, 0);

            let result = self.session.execute(&schema_query).wait().unwrap();
            for row in result {
                let name : String = row.get_col_by_name("column_name").unwrap();
                let ftype : String = row.get_col_by_name("type").unwrap();

                println!("{} {}", name, ftype);
            }

Causes this error:

thread 'main' panicked at 'Unsupported type: CASS_VALUE_TYPE_BLOB', /Users/jhaddad/.multirust/toolchains/nightly/cargo/registry/src/github.com-1ecc6299db9ec823/cassandra-0.6.10/src/cassandra/column.rs:279

The odd thing is that re-running the same pgoram gives me another error; except sometimes it errors with 'Unsupported type: CASS_VALUE_TYPE_BLOB'.

@tupshin @rustyrazorblade

Currently it is almost impossible to work with Timestamp values how about implementing traits of chrono or time ? What do you think ?

Rust v1.0
[cqlsh 4.1.1 | Cassandra 2.0.14 | CQL spec 3.1.1 | Thrift protocol 19.39.0]

My code is nearly the same as the code in examples/

extern crate cassandra;
use cassandra::*;
static CONTACT_POINTS:&'static str = "172.20.20.10";

fn main() {
  println!("Before cluster connect");
  let cluster = &CassCluster::new()
                      .set_contact_points(CONTACT_POINTS).unwrap()
                      .set_load_balance_round_robin().unwrap();

  println!("Before session connect");
  let mut session = CassSession::new().connect(&cluster).wait().unwrap();
  println!("Before session execute");
  let result = session.execute("SELECT keyspace_name FROM system.schema_keyspaces;", 0).wait().unwrap();

  println!("{:?}", result);

  session.close().wait().unwrap();
}

And I get the output & error:

in Ticks/ on master
› cargo run --verbose
       Fresh gcc v0.3.5
       Fresh libc v0.1.7
       Fresh cql_bindgen v0.0.11
       Fresh cassandra v0.2.5
       Fresh time v0.1.25
       Fresh Ticks v0.1.0 (file:///Users/cschneid/Code/Rust/Ticks)
     Running `target/debug/Ticks`
Before cluster connect
Before session connect
Before session execute
thread '<main>' panicked at 'called `Result::unwrap()` on an `Err` value: "Syntax error"', /Users/rustbuild/src/rust-buildbot/slave/stable-dist-rustc-mac/build/src/libcore/result.rs:729
Process didn't exit successfully: `target/debug/Ticks` (exit code: 101)

The query runs fine in the cqlsh interface, so there's something else going on with the result, or result unwraping. I have the c++ library linked from their homebrew recipe, which is 1.0.0.

Tested that this 'worked'* for fork. ~Will now need https://travis-ci.org/tupshin/cassandra-rs (or equivalent from another maintainer) to be set up.~

* - https://travis-ci.org/BenjaminGill-Metaswitch/cassandra-rs: the build failed, but it did at least make an attempt.

This PR extends the current .travis.yml to support nightly and beta Rust, and includes some minor tweaks required to get nightly to build and test cleanly.

Beta/stable look as if they've been broken by 2c57a8216e26cb7e16d46c2a718b171d5b1d0286, so they are not expected to build cleanly yet. Likewise for the plethora of warnings on nightly.

I get

thread '::test_find_one' panicked at 'called `Result::unwrap()` on an `Err` value: Error(LIB_NULL_VALUE(CASS_ERROR_LIB_NULL_VALUE), State { next_error: None, backtrace: None })', ../src/libcore/result.rs:837

https://github.com/tupshin/cassandra-rs/commit/2c57a8216e26cb7e16d46c2a718b171d5b1d0286

This is related to to_result("").unwrap().into()

Hi,

can you share your plans for progress on this driver? I am about to build more than a toy project on top of Rust/C* and am looking for the driver to use.

Jan

: the trait bound cassandra::TableMeta: std::fmt::Display is not satisfied [E0277] src/main.rssrc/main.rs:188 :188 println!("Schema: {}", schema);

Ideally, crates that provide C-to-Rust bindings have the suffix -sys, but that doesn't appear to be the case here. This allows multiple nice user-facing interfaces to be built on top of shared code, and avoids an issue where you try to link to the same native library multiple times.

As reported in #4, these were leaked previously. With this patch in place memory usage is constant, and valgrind is happy.

The session future needed some different handling due to its move return.

I wonder if it would make sense to implement Drop directly on cql_bindgen::CassFuture instead, as that would cover all these cases.

Currently, one of this project's dependencies does not build on stable Rust, so this does not either.

To fix, merge https://github.com/tupshin/cassandra-sys-rs/pull/6, publish the new version, and update this crate to use the new version.

Hi,

I have forked this project to https://github.com/Metaswitch/cassandra-rs and intend to maintain it there. If you no longer intend to maintain this project, please could you contact me and/or Alex Crichton to arrange a transfer of the cassandra and cassandra-sys crates to myself? I would like to avoid forking on crates.io, so that we don't leave the stale crates in place to trip people up in future.

To anyone else who is interested - my maintained fork is available on crates.io at cassandra-cpp.

Thanks,

--KW 8-)

When retrieving data from the database I get this error if there is a null – tried with bool, i32, i64m double and worked fine – issue only with string.

RUST_BACKTRACE=1 cargo run
    Finished debug [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/cassandra-connector`
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error(LIB_NULL_VALUE(CASS_ERROR_LIB_NULL_VALUE), State { next_error: None, backtrace: Some(stack backtrace:
   0:     0x7fe28e3f0401 - backtrace::backtrace::libunwind::trace
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.0/src/backtrace/mod.rs:90
                         - backtrace::backtrace::trace<closure>
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.0/src/backtrace/mod.rs:42
   1:     0x7fe28e3f1408 - backtrace::capture::{{impl}}::new
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.0/src/lib.rs:101
   2:     0x7fe28e3e82c1 - error_chain::make_backtrace
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/error-chain-0.7.2/src/lib.rs:411
   3:     0x7fe28e3e8377 - error_chain::{{impl}}::default
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/error-chain-0.7.2/src/lib.rs:462
   4:     0x7fe28e2b464b - cassandra_sys::error::{{impl}}::from_kind
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/cassandra-sys-0.8.7/src/error.rs:6
   5:     0x7fe28e2b4841 - cassandra_sys::error::{{impl}}::from
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/cassandra-sys-0.8.7/src/error.rs:6
   6:     0x7fe28e2aaf51 - core::convert::{{impl}}::into<cassandra_sys::error::ErrorKind,cassandra_sys::error::Error>
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/convert.rs:271
   7:     0x7fe28e2a0be9 - cassandra_sys::error::{{impl}}::to_result<&str>
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/cassandra-sys-0.8.7/src/error.rs:133
   8:     0x7fe28e2b17c9 - cassandra::cassandra::column::{{impl}}::get_string
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/cassandra-0.8.1/src/cassandra/column.rs:270
   9:     0x7fe28e299e65 - cassandra_connector::show
                        at /home/proj/cassandra-connector/src/main.rs:38
  10:     0x7fe28e29ab19 - cassandra_connector::main
                        at /home/proj/cassandra-connector/src/main.rs:76
  11:     0x7fe28e4095ca - panic_unwind::__rust_maybe_catch_panic
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libpanic_unwind/lib.rs:98
  12:     0x7fe28e4031b6 - std::panicking::try<(),fn()>
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:434
                         - std::panic::catch_unwind<fn(),()>
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panic.rs:351
                         - std::rt::lang_start
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/rt.rs:57
  13:     0x7fe28e29b042 - main
  14:     0x7fe28c8f0b34 - __libc_start_main
  15:     0x7fe28e28d3e8 - <unknown>
  16:                0x0 - <unknown>) })', /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/result.rs:837
stack backtrace:
   1:     0x7fe28e4008fa - std::sys::imp::backtrace::tracing::imp::write::h3188f035833a2635
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs:42
   2:     0x7fe28e40286f - std::panicking::default_hook::{{closure}}::h6385b6959a2dd25b
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:349
   3:     0x7fe28e40246e - std::panicking::default_hook::he4f3b61755d7fa95
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:365
   4:     0x7fe28e402cb7 - std::panicking::rust_panic_with_hook::hf00b8130f73095ec
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:553
   5:     0x7fe28e402af4 - std::panicking::begin_panic::h6227f62cb2cdaeb4
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:515
   6:     0x7fe28e402a69 - std::panicking::begin_panic_fmt::h173eadd80ae64bec
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:499
   7:     0x7fe28e4029f7 - rust_begin_unwind
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:475
   8:     0x7fe28e4331ed - core::panicking::panic_fmt::h3b2d1e30090844ff
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/panicking.rs:69
   9:     0x7fe28e2aa215 - core::result::unwrap_failed::h6f1089a4164b68db
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/macros.rs:29
  10:     0x7fe28e2a58bb - <core::result::Result<T, E>>::unwrap::hddf0ca9c49ea9914
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/result.rs:737
  11:     0x7fe28e2b187a - cassandra::cassandra::column::Column::get_string::he370ca9df985f0ee
                        at /opt/rust/.cargo/registry/src/github.com-1ecc6299db9ec823/cassandra-0.8.1/src/cassandra/column.rs:270
  12:     0x7fe28e299e65 - cassandra_connector::show::hb977a687937c57f0
                        at /home/proj/cassandra-connector/src/main.rs:38
  13:     0x7fe28e29ab19 - cassandra_connector::main::h0159580624f528ae
                        at /home/proj/cassandra-connector/src/main.rs:76
  14:     0x7fe28e4095ca - __rust_maybe_catch_panic
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libpanic_unwind/lib.rs:98
  15:     0x7fe28e4031b6 - std::rt::lang_start::h65647f6e36cffdae
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panicking.rs:434
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/panic.rs:351
                        at /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libstd/rt.rs:57
  16:     0x7fe28e29b042 - main
  17:     0x7fe28c8f0b34 - __libc_start_main
  18:     0x7fe28e28d3e8 - <unknown>
  19:                0x0 - <unknown>

I was hoping that the program would panic with the message “Bad string value! Error message….” As it does with other data types. (for the other types in the database it worked as expected: bool, i32, i62, double)

#[macro_use(stmt)]

extern crate cassandra;
use cassandra::*;
use std::str::FromStr;
#[derive(Debug,PartialEq,Clone,Copy)]
struct Basic {
    bln: bool,
    flt: f32,
    dbl: f64,
    i32: i32,
    i64: i64,
}
fn insert_into_basic(session: &mut Session, key: &str, basic: Basic) -> CassResult {
    let mut statement = stmt!("INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES \
                               (?, ?, ?, ?, ?, ?);");
    statement.bind(0, key);
    statement.bind(1, basic.bln);
    statement.bind(2, basic.flt);
    statement.bind(3, basic.dbl);
    statement.bind(4, basic.i32);
    statement.bind(5, basic.i64);
    let res = session.execute(&statement).wait().unwrap();
    res
}
fn select_all(session: &mut Session) -> CassResult {
    let stmt = stmt!("SELECT * FROM examples.basic");
    let result = match session.execute(&stmt).wait() {
        Result::Ok(val) => val,
        Result::Err(err) => panic!("Bad select! {}", err),
    };
    result
}
fn show(data: &CassResult) {
    for i in data.iter() {
        match i.get_column(5) {
            Result::Ok(val) => {
                match val.get_string() {
                    Result::Ok(s) => println!("{:?}", s),
                    Result::Err(err) => {
                        panic!("Bad string value! {}", err);
                    }
               }
            }
            Result::Err(err) => panic!("Bad column! {}", err),
        };
    }
}
fn main() {
    let input = Basic {
        bln: true,
        flt: 0.001f32,
        dbl: 0.0002f64,
        i32: 1,
        i64: 2,
    };
    let contact_points = match ContactPoints::from_str("127.0.0.1") {
        Result::Ok(val) => val,
        Result::Err(err) => panic!("My error! {}", err),
    };
    let mut cluster = Cluster::default();
    cluster.set_contact_points(contact_points).unwrap();
    cluster.set_load_balance_round_robin();
    match cluster.connect() {
        Ok(ref mut session) => {
            let ks_statement = &stmt!("CREATE KEYSPACE IF NOT EXISTS examples WITH replication = \
                                       { \'class\': \'SimpleStrategy\', \'replication_factor\': \
                                       \'1\' };");
            let table_statement = &stmt!("CREATE TABLE IF NOT EXISTS examples.basic (key text, \
                                          bln boolean, flt float, dbl double, i32 int, i64 \
                                          bigint, PRIMARY KEY (flt));");
            session.execute(ks_statement).wait().unwrap();
            session.execute(table_statement).wait().unwrap();
            insert_into_basic(session, "test", input);
            let output = select_all(session);
            show(&output);
            println!("{:?}", input);
            // println!("{:?}", output);
        }
        err => println!("{:?}", err),
    }
}

The documentation on https://docs.rs/crate/cassandra/0.8.1 which should cover this crate is currently reporting

docs.rs failed to build cassandra-0.8.1 Please check build logs and if you believe this is docs.rs' fault, report into this issue report.

Please can someone knowledgeable investigate and fix?

I’m not sure if this is user error or something going on in the crates but I have 18+ errors expecting cassandra::error::Error that all look like:

= note:  expected type 'std::result::Result<std::vec::Vec<u8>, cassandra::error::Error>' 
= note:  found type 'std::result::Result<std::vec::Vec<u8>, errors::Error>'

Pretty much all of the errors are looking for cassandra::error:Error. I suspect the error_chain! macro is not modifying the errors quite right. I was curious if you’ve heard about this problem before.

I've got a partially working CQL parser over here: https://github.com/rustyrazorblade/cql_parser

One day it might be nice to finish it and get compile time syntax checking of CQL statements