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; }