CassError CassandraFS::create_file(const char* path, mode_t mode) { CassUuid uuid; cass_uuid_gen_time(ctxt->uuid_gen, &uuid); CassError error_value = CASS_OK; CassFuture* result_future = NULL; if (S_ISDIR(mode)) { result_future = create_dir_entry(path, mode); } else { result_future = create_file_entry(path, &uuid, mode); } CassFuture* result_future2 = create_sub_entry(path); CassFuture* result_future3 = NULL; if (!S_ISDIR(mode)) { result_future3 = create_physical_file(&uuid); } CassError err1 = cass_future_error_code(result_future); CassError err2 = cass_future_error_code(result_future2); CassError err3 = CASS_OK; if (result_future3 != NULL) { err3 = cass_future_error_code(result_future3); } if (err1 != CASS_OK) { cassandra_log_error(result_future); error_value = err1; } if (err2 != CASS_OK) { cassandra_log_error(result_future2); error_value = err2; } if (err3 != CASS_OK && result_future3 != NULL) { cassandra_log_error(result_future3); error_value = err3; } cass_future_free(result_future); cass_future_free(result_future2); if (result_future3 != NULL) { cass_future_free(result_future3); } return error_value; }
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); }
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; }
void select_from_perf(CassSession* session, const char* query, const CassPrepared* prepared) { int i; CassFuture* futures[NUM_CONCURRENT_REQUESTS]; for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { CassStatement* statement; if (prepared != NULL) { statement = cass_prepared_bind(prepared); } else { statement = cass_statement_new(query, 0); } futures[i] = cass_session_execute(session, statement); cass_statement_free(statement); } for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { CassFuture* future = futures[i]; CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); assert(cass_result_column_count(result) == 6); cass_result_free(result); } 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 (?, ?, ?, ?, ?, ?);"; 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; }
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(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; }
const CassResult* Connection::execute(CassStatement* statement) { this->log("debug", "Connection::execute"); CassFuture* result = cass_session_execute(this->_session, statement); CassError error = cass_future_error_code(result); if (error != CASS_OK) { CassString message = cass_future_error_message(result); cass_future_free(result); std::ostringstream out; out << cass_error_desc(error) << ": " << message.data; this->log("error", out.str()); throw Php::Exception(out.str()); return nullptr; } const CassResult* res = cass_future_get_result(result); if (res == nullptr) { throw Php::Exception("Error executing query, result is null"); } cass_future_free(result); return res; }
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; }
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 int execute(CassSession* session, char* query, int ignore_error) { CassStatement* stmt = cass_statement_new(query, 0); CassFuture* future = cass_session_execute(session, stmt); cass_statement_free(stmt); CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { if (ignore_error) { cass_future_free(future); return 0; } fprintf(stderr, "Cassandra error: %s\n", cass_error_desc(rc)); cass_future_free(future); return -1; } cass_future_free(future); return 0; }
void DbCassandra::Initialize( const std::string &configPath ) { ParseConfig( configPath ); const std::string remotes = config_.get<std::string>( "remotes" ); db_ = std::make_shared<DbConnection>(); auto cluster = cass_cluster_new(); db_->SetCluster( cluster ); auto session = cass_session_new(); db_->SetSession( session ); cass_cluster_set_contact_points( cluster, remotes.c_str() ); CassFuture *connect_future = cass_session_connect( session, cluster ); const CassError err = cass_future_error_code( connect_future ); cass_future_free( connect_future ); if ( err != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); const CassPrepared *prepared = nullptr; if ( PrepareQuery( session, "INSERT INTO prun.jobs (job_id, job_descr) VALUES (?, ?);", reinterpret_cast<const CassPrepared**>( &prepared ) ) != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); db_->SetPreparedInsert( prepared ); if ( PrepareQuery( session, "DELETE FROM prun.jobs WHERE job_id = ?;", reinterpret_cast<const CassPrepared**>( &prepared ) ) != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); db_->SetPreparedDelete( prepared ); }
void on_select(CassFuture* future, void* data) { CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); CassIterator* iterator = cass_iterator_from_result(result); while (cass_iterator_next(iterator)) { CassUuid key; char key_str[CASS_UUID_STRING_LENGTH]; cass_uint64_t value = 0; const CassRow* row = cass_iterator_get_row(iterator); cass_value_get_uuid(cass_row_get_column(row, 0), &key); cass_uuid_string(key, key_str); cass_value_get_int64(cass_row_get_column(row, 1), (cass_int64_t*)&value); printf("%s, %llu\n", key_str, (unsigned long long)value); } cass_iterator_free(iterator); cass_result_free(result); } signal_exit((CassSession*)data); }
void on_create_table(CassFuture* future, void* data) { const char* insert_query = "INSERT INTO callbacks (key, value) " "VALUES (?, ?)"; CassUuid key; CassStatement* statement = NULL; CassFuture* insert_future = NULL; CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); } statement = cass_statement_new(insert_query, 2); cass_uuid_gen_time(uuid_gen, &key); cass_statement_bind_uuid(statement, 0, key); cass_statement_bind_int64(statement, 1, cass_uuid_timestamp(key)); insert_future = cass_session_execute((CassSession*)data, statement); cass_future_set_callback(insert_future, on_insert, data); cass_statement_free(statement); cass_future_free(insert_future); }
int main(int argc, char* argv[]) { CassFuture* connect_future = NULL; CassCluster* cluster = cass_cluster_new(); CassSession* session = cass_session_new(); char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } cass_cluster_set_contact_points(cluster, hosts); 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));"); execute_query(session, "CREATE FUNCTION examples.avg_state(state tuple<int, bigint>, val int) \ CALLED ON NULL INPUT RETURNS tuple<int, bigint> \ LANGUAGE java AS \ 'if (val != null) { \ state.setInt(0, state.getInt(0) + 1); \ state.setLong(1, state.getLong(1) + val.intValue()); \ } \
/** * Prepare all queries on a given session. * * @param session The session to prepare the queries on */ void prepare_all_queries(test_utils::CassSessionPtr session) { for (std::vector<std::string>::const_iterator it = prepared_queries_.begin(); it != prepared_queries_.end(); ++it) { test_utils::CassFuturePtr future(cass_session_prepare(session.get(), it->c_str())); BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK); } }
/** * librdf_storage_cassandra_context_add_statement: * @storage: #librdf_storage object * @context_node: #librdf_node object * @statement: #librdf_statement statement to add * * Add a statement to a storage context. * * Return value: non 0 on failure **/ static int librdf_storage_cassandra_context_add_statement(librdf_storage* storage, librdf_node* context_node, librdf_statement* statement) { char* s; char* p; char* o; char* c; statement_helper(storage, statement, context_node, &s, &p, &o, &c); librdf_storage_cassandra_instance* context; context = (librdf_storage_cassandra_instance*)storage->instance; char* query = "BEGIN BATCH " " INSERT INTO rdf.spo (s, p, o) VALUES (?, ?, ?);" " INSERT INTO rdf.pos (s, p, o) VALUES (?, ?, ?);" " INSERT INTO rdf.osp (s, p, o) VALUES (?, ?, ?);" "APPLY BATCH;"; CassStatement* stmt = cass_statement_new(query, 9); cass_statement_bind_string(stmt, 0, s); cass_statement_bind_string(stmt, 1, p); cass_statement_bind_string(stmt, 2, o); cass_statement_bind_string(stmt, 3, s); cass_statement_bind_string(stmt, 4, p); cass_statement_bind_string(stmt, 5, o); cass_statement_bind_string(stmt, 6, s); cass_statement_bind_string(stmt, 7, p); cass_statement_bind_string(stmt, 8, o); if (s) free(s); if (p) free(p); if (o) free(o); CassFuture* future = cass_session_execute(context->session, stmt); cass_statement_free(stmt); CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); const char* msg; size_t msg_len; cass_future_error_message(future, &msg, &msg_len); fprintf(stderr, "Cassandra: %*s\n", msg_len, msg); cass_future_free(future); return -1; } cass_future_free(future); return 0; }
void on_create_keyspace(CassFuture* future, void* data) { CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); } execute_query((CassSession*)data, "USE examples", on_set_keyspace); }
static int cassandra_results_stream_end_of_stream(void* context) { cassandra_results_stream* scontext; scontext = (cassandra_results_stream*)context; if (scontext->at_end) { if (scontext->more_pages) { CassError rc; rc = cass_statement_set_paging_state(scontext->stmt, scontext->result); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); return -1; } cass_result_free(scontext->result); scontext->result = 0; CassFuture* future = cass_session_execute(scontext->cassandra_context->session, scontext->stmt); rc = cass_future_error_code(future); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); const char* msg; size_t msg_len; cass_future_error_message(future, &msg, &msg_len); fprintf(stderr, "Cassandra: %*s\n", msg_len, msg); cass_future_free(future); return -1; } scontext->result = cass_future_get_result(future); cass_future_free(future); scontext->iter = cass_iterator_from_result(scontext->result); scontext->more_pages = cass_result_has_more_pages(scontext->result); scontext->at_end = !cass_iterator_next(scontext->iter); } } return (scontext->at_end); }
void on_set_keyspace(CassFuture* future, void* data) { CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); } execute_query((CassSession*)data, "CREATE TABLE callbacks " "(key timeuuid PRIMARY KEY, value bigint)", on_create_table); }
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; }
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); }
/** * Check the column count of a bound statement before and after adding a * column to a table. * * @param expected_column_count_after_update */ void prepared_check_column_count_after_alter(size_t expected_column_count_after_update) { test_utils::CassSessionPtr session(test_utils::create_session(cluster)); test_utils::execute_query(session.get(), str(boost::format("USE %s") % keyspace)); test_utils::CassFuturePtr future(cass_session_prepare(session.get(), "SELECT * FROM test WHERE k = 'key1'")); BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK); test_utils::CassPreparedPtr prepared(cass_future_get_prepared(future.get())); BOOST_REQUIRE(prepared); test_utils::CassStatementPtr bound_statement(cass_prepared_bind(prepared.get())); BOOST_REQUIRE(bound_statement); // Verify that the table has two columns in the metadata { test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get())); BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK); test_utils::CassResultPtr result(cass_future_get_result(result_future.get())); BOOST_CHECK_EQUAL(cass_result_column_count(result.get()), 2u); } // Add a column to the table test_utils::execute_query(session.get(), "ALTER TABLE test ADD v2 int"); // The column count shouldn't have changed { test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get())); BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK); test_utils::CassResultPtr result(cass_future_get_result(result_future.get())); BOOST_CHECK_EQUAL(cass_result_column_count(result.get()), expected_column_count_after_update); } }
void on_session_connect(CassFuture* future, void* data) { CassSession* session = (CassSession*)data; CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); signal_exit(NULL); return; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { " "'class': 'SimpleStrategy', 'replication_factor': '3' };", on_create_keyspace); }
std::string get_executing_host(test_utils::CassSessionPtr session) { std::stringstream query; query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces"); test_utils::CassStatementPtr statement(cass_statement_new(query.str().c_str(), 0)); test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get())); if (cass_future_error_code(future.get()) == CASS_OK) { return cass::get_host_from_future(future.get()); } else { CassString message; cass_future_error_message(future.get(), &message.data, &message.length); std::cerr << "Failed to query host: " << std::string(message.data, message.length) << std::endl; } return ""; }