int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
const Pair items[] = { { "apple", 1 }, { "orange", 2 }, { "banana", 3 }, { "mango", 4 }, { NULL, 0 } };
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.maps (key text, \
items map<text, int>, \
PRIMARY KEY (key))");
insert_into_maps(session, "test", items);
select_from_maps(session, "test");
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
CassError insert_into_collections(CassSession* session, const char* key, const char* items[]) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
CassCollection* collection = NULL;
const char** item = NULL;
const char* query = "INSERT INTO examples.collections (key, items) VALUES (?, ?);";
statement = cass_statement_new(query, 2);
cass_statement_bind_string(statement, 0, key);
collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2);
for (item = items; *item; item++) {
cass_collection_append_string(collection, *item);
}
cass_statement_bind_collection(statement, 1, collection);
cass_collection_free(collection);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
static void ClearDatabase(Upload& upload) {
DatabaseSession session;
std::string str = "delete from uploadchunks where model_id = ? and upload_id = ?";
CassStatement* statement = cass_statement_new(str.c_str(), 2);
cass_statement_bind_uuid(statement, 0, upload.ModelId());
cass_statement_bind_uuid(statement, 1, upload.UploadId());
CassFuture* future = cass_session_execute(session.Session(), statement);
cass_future_wait(future);
cass_statement_free(statement);
CassError rc = cass_future_error_code(future);
if (rc != CASS_OK) {
std::string err = std::string("Failed to execute query: ")
+ CassandraUtils::GetCassandraError(future);
cass_future_free(future);
throw err;
}
cass_future_free(future);
}
int main() {
CassFuture* connect_future = NULL;
CassCluster* cluster = cass_cluster_new();
CassSession* session = cass_session_new();
cass_cluster_set_contact_points(cluster, "127.0.0.1");
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
print_keyspace(session, "examples");
execute_query(session,
"CREATE TABLE examples.schema_meta (key text, \
value bigint, \
PRIMARY KEY (key));");
print_table(session, "examples", "schema_meta");
/* Close the session */
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
} else {
CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query
= "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (:k, :b, :f, :d, :i32, :i64);";
statement = cass_statement_new(query, 6);
cass_statement_bind_string_by_name(statement, "k", key);
cass_statement_bind_bool_by_name(statement, "b", basic->bln);
cass_statement_bind_float_by_name(statement, "f", basic->flt);
cass_statement_bind_double_by_name(statement, "d", basic->dbl);
cass_statement_bind_int32_by_name(statement, "i32", basic->i32);
cass_statement_bind_int64_by_name(statement, "i64", basic->i64);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
bool select_task(const std::string& query, CassConsistency consistency, int num_iterations) {
bool is_successful = true;
test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
cass_statement_set_consistency(statement.get(), consistency);
for (int i = 0; i < num_iterations; ++i) {
test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
cass_future_wait(future.get());
CassError code = cass_future_error_code(future.get());
if (code != CASS_OK
&& code != CASS_ERROR_LIB_REQUEST_TIMED_OUT
&& code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay
CassString message;
cass_future_error_message(future.get(), &message.data, &message.length);
fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length), message.data);
is_successful = false;
}
if (code == CASS_OK) {
test_utils::CassResultPtr result(cass_future_get_result(future.get()));
if (cass_result_row_count(result.get()) == 0) {
fprintf(stderr, "No rows returned from query\n");
is_successful = false;
}
}
}
return is_successful;
}
CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
statement = cass_statement_new(query, 6);
cass_statement_bind_string(statement, 0, key);
cass_statement_bind_bool(statement, 1, basic->bln);
cass_statement_bind_float(statement, 2, basic->flt);
cass_statement_bind_double(statement, 3, basic->dbl);
cass_statement_bind_int32(statement, 4, basic->i32);
cass_statement_bind_int64(statement, 5, basic->i64);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
CassError insert_into(CassSession* session, const char* key) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
cass_uint32_t d;
cass_int64_t t;
const char* query = "INSERT INTO examples.date_time (key, d, t) VALUES (?, ?, ?);";
time_t now = time(NULL);
d = cass_date_from_epoch(now);
t = cass_time_from_epoch(now);
statement = cass_statement_new(query, 3);
cass_statement_bind_string(statement, 0, key);
cass_statement_bind_uint32(statement, 1, d);
cass_statement_bind_int64(statement, 2, t);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
bool execute_insert(CassSession* session, const std::string& table_name) {
std::string query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 3));
// Determine if bound parameters can be used based on C* version
if (version.major == 1) {
test_utils::CassPreparedPtr prepared = test_utils::prepare(session, query.c_str());
statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
}
boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
std::string text_sample(test_utils::string_from_time_point(now));
cass_statement_bind_uuid(statement.get(), 0, test_utils::generate_time_uuid(uuid_gen));
cass_statement_bind_int64(statement.get(), 1, event_time.count());
cass_statement_bind_string(statement.get(), 2, text_sample.c_str());
test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
cass_future_wait(future.get());
CassError code = cass_future_error_code(future.get());
if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay
CassString message;
cass_future_error_message(future.get(), &message.data, &message.length);
fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data);
return false;
}
return true;
}
~LatencyAwarePolicyTest() {
stop_query_execution();
uv_mutex_destroy(&lock_);
uv_cond_destroy(&condition_);
test_utils::CassFuturePtr close_future(cass_session_close(session_.get()));
cass_future_wait(close_future.get());
}
/**
* Closes the session instance and waits for in-flight requests to finish.
*/
int lua_cass_session_close (lua_State* L)
{
fprintf(stderr, "lua_cass_session_close\n");
CassSession* session = lua_session_get_ptr(L, 1);
CassFuture* future = cass_session_close(session);
cass_future_wait(future);
cass_future_free(future);
return 0;
}
CassDriver::~CassDriver() {
cass_prepared_free(insert_prepared_);
cass_prepared_free(select_prepared_);
cass_prepared_free(delete_prepared_);
CassFuture* close_future = cass_session_close(session_);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster_);
}
SingleSessionTest::~SingleSessionTest() {
if (session) {
CassFuturePtr close_future(cass_session_close(session));
cass_future_wait(close_future.get());
}
if (ssl) {
cass_ssl_free(ssl);
}
}
void wait_exit() {
uv_mutex_lock(&mutex);
while (close_future == NULL) {
uv_cond_wait(&cond, &mutex);
}
uv_mutex_unlock(&mutex);
cass_future_wait(close_future);
cass_future_free(close_future);
}
void wait_exit() {
uv_mutex_lock(&mutex);
while (exit_flag == 0) {
uv_cond_wait(&cond, &mutex);
}
uv_mutex_unlock(&mutex);
if (close_future) {
cass_future_wait(close_future);
cass_future_free(close_future);
}
}
void CassDriver::PrepareQuery() {
CassError rc = CASS_OK;
CassString insert_query = cass_string_init("INSERT INTO receiver_table "
"(receiver_id, ts, msg_id, group_id, msg, sender_id) "
"VALUES (?, ?, ?, ?, ?, ?);");
CassFuture* insert_future = cass_session_prepare(session_, insert_query);
cass_future_wait(insert_future);
rc = cass_future_error_code(insert_future);
if (rc != CASS_OK) {
PrintError(insert_future);
} else {
insert_prepared_ = cass_future_get_prepared(insert_future);
}
cass_future_free(insert_future);
rc = CASS_OK;
CassString select_query = cass_string_init("SELECT * FROM receiver_table "
"WHERE receiver_id = ?");
CassFuture* select_future = cass_session_prepare(session_, select_query);
cass_future_wait(select_future);
rc = cass_future_error_code(select_future);
if (rc != CASS_OK) {
PrintError(select_future);
} else {
select_prepared_ = cass_future_get_prepared(select_future);
}
cass_future_free(select_future);
rc = CASS_OK;
CassString delete_query = cass_string_init("DELETE FROM receiver_table "
"WHERE receiver_id = ?");
CassFuture* delete_future = cass_session_prepare(session_, delete_query);
cass_future_wait(delete_future);
rc = cass_future_error_code(delete_future);
if (rc != CASS_OK) {
PrintError(delete_future);
} else {
delete_prepared_ = cass_future_get_prepared(delete_future);
}
cass_future_free(delete_future);
}
CassError DbCassandra::PrepareQuery( CassSession *session, const char *query, const CassPrepared **prepared ) const
{
CassFuture *future = cass_session_prepare( session, query );
cass_future_wait( future );
CassError err = cass_future_error_code( future );
if ( err == CASS_OK )
*prepared = cass_future_get_prepared( future );
cass_future_free( future );
return err;
}
int main(int argc, char* argv[]) {
CassCluster* cluster = NULL;
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
Basic input = { cass_true, 0.001f, 0.0002, 1, 2 };
Basic output;
const CassPrepared* prepared = NULL;
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cluster = create_cluster(hosts);
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.basic (key text, \
bln boolean, \
flt float, dbl double,\
i32 int, i64 bigint, \
PRIMARY KEY (key));");
insert_into_basic(session, "prepared_test", &input);
if (prepare_select_from_basic(session, &prepared) == CASS_OK) {
select_from_basic(session, prepared, "prepared_test", &output);
assert(input.bln == output.bln);
assert(input.flt == output.flt);
assert(input.dbl == output.dbl);
assert(input.i32 == output.i32);
assert(input.i64 == output.i64);
cass_prepared_free(prepared);
}
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
bool execute_insert(CassStatement* statement) {
test_utils::CassFuturePtr future(cass_session_execute(session, statement));
cass_future_wait(future.get());
CassError code = cass_future_error_code(future.get());
if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay
CassString message;
cass_future_error_message(future.get(), &message.data, &message.length);
fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data);
return false;
}
return true;
}
CassError connect_session(CassSession* session, const CassCluster* cluster) {
CassError rc = CASS_OK;
CassFuture* future = cass_session_connect(session, cluster);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
return rc;
}
void CassDriver::ConnectSession() {
CassError rc = CASS_OK;
CassFuture* future = cass_cluster_connect_keyspace(cluster_,
"offline_keyspace");
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
PrintError(future);
} else {
session_ = cass_future_get_session(future);
}
cass_future_free(future);
}
static void alter_schmea_version(void *arg) {
ClusterInit* cluster_init = static_cast<ClusterInit*>(arg);
test_utils::CassLog::reset("No schema agreement on live nodes after ");
test_utils::CassStatementPtr schema_stmt(cass_prepared_bind(cluster_init->schema_alter_prepared.get()));
boost::chrono::steady_clock::time_point end =
boost::chrono::steady_clock::now() + boost::chrono::milliseconds(MAX_SCHEMA_AGREEMENT_WAIT_MS + 1000);
// mess with system.peers for node 1 more than the wait time; targetting specific nodes
do {
cass_statement_bind_uuid(schema_stmt.get(), 0, test_utils::generate_random_uuid(cluster_init->inst.uuid_gen));
test_utils::CassFuturePtr future(cass_session_execute(cluster_init->schema_alter_session, schema_stmt.get()));
cass_future_wait(future.get());
BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);
} while (boost::chrono::steady_clock::now() < end && test_utils::CassLog::message_count() == 0);
}
/// Blocks on queued futures created by 'asyncInsert'
void wait() {
if(!connected_) {
LOG(ERROR) << "wait failed, establish connection to cassandra first";
return;
}
while(!futures_.empty()) {
CassFuture *future = futures_.front().get();
cass_future_wait(future);
const auto rc = cass_future_error_code(future);
if(rc != CASS_OK) {
LOG(ERROR) << "wait failed: " << getFutureError(future);
}
futures_.pop(); // Deallocates 'future' var memory
}
}
CassError execute_query(CassSession* session, const char* query) {
CassError rc = CASS_OK;
CassStatement* statement = cass_statement_new(query, 0);
CassFuture* future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
CassError connect_session(CassCluster* cluster, CassSession** output) {
CassError rc = CASS_OK;
CassFuture* future = cass_cluster_connect(cluster);
*output = NULL;
cass_future_wait(future);
rc = cass_future_error_code(future);
if(rc != CASS_OK) {
print_error(future);
} else {
*output = cass_future_get_session(future);
}
cass_future_free(future);
return rc;
}
CassError select_from_maps(CassSession* session, const char* key) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query = "SELECT items FROM examples.maps WHERE key = ?";
statement = cass_statement_new(query, 1);
cass_statement_bind_string(statement, 0, key);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
} else {
const CassResult* result = cass_future_get_result(future);
if (cass_result_row_count(result) > 0) {
const CassRow* row = cass_result_first_row(result);
CassIterator* iterator
= cass_iterator_from_map(
cass_row_get_column(row, 0));
while (cass_iterator_next(iterator)) {
const char* key;
size_t key_length;
cass_int32_t value;
cass_value_get_string(cass_iterator_get_map_key(iterator), &key, &key_length);
cass_value_get_int32(cass_iterator_get_map_value(iterator), &value);
printf("item: '%.*s' : %d \n", (int)key_length, key, value);
}
cass_iterator_free(iterator);
}
cass_result_free(result);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
CassError select_from_collections(CassSession* session, const char* key) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query = "SELECT items FROM examples.collections WHERE key = ?";
statement = cass_statement_new(query, 1);
cass_statement_bind_string(statement, 0, key);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
} else {
const CassResult* result = cass_future_get_result(future);
CassIterator* iterator = cass_iterator_from_result(result);
if (cass_iterator_next(iterator)) {
const CassValue* value = NULL;
const CassRow* row = cass_iterator_get_row(iterator);
CassIterator* items_iterator = NULL;
value = cass_row_get_column(row, 0);
items_iterator = cass_iterator_from_collection(value);
while (cass_iterator_next(items_iterator)) {
const char* item;
size_t item_length;
cass_value_get_string(cass_iterator_get_value(items_iterator), &item, &item_length);
printf("item: %.*s\n", (int)item_length, item);
}
cass_iterator_free(items_iterator);
}
cass_result_free(result);
cass_iterator_free(iterator);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
CassError prepare_query(CassSession* session, const char* query, const CassPrepared** prepared) {
CassError rc = CASS_OK;
CassFuture* future = NULL;
future = cass_session_prepare(session, query);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
} else {
*prepared = cass_future_get_prepared(future);
}
cass_future_free(future);
return rc;
}
int main() {
CassCluster* cluster = create_cluster();
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
Basic input = { cass_true, 0.001f, 0.0002, 1, 2 };
Basic output;
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
execute_query(session,
"CREATE TABLE examples.basic (key text, \
bln boolean, \
flt float, dbl double,\
i32 int, i64 bigint, \
PRIMARY KEY (key));");
insert_into_basic(session, "test", &input);
select_from_basic(session, "test", &output);
assert(input.bln == output.bln);
assert(input.flt == output.flt);
assert(input.dbl == output.dbl);
assert(input.i32 == output.i32);
assert(input.i64 == output.i64);
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
CassError prepare_insert_into_batch(CassSession* session, const CassPrepared** prepared) {
CassError rc = CASS_OK;
CassFuture* future = NULL;
const char* query = "INSERT INTO examples.pairs (key, value) VALUES (?, ?)";
future = cass_session_prepare(session, query);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
} else {
*prepared = cass_future_get_prepared(future);
}
cass_future_free(future);
return rc;
}
