unsigned char* CassandraFS::read_block(CassUuid* physical_file_id, int block, int* bytes_read) {
CassStatement* statement = cass_statement_new("SELECT data, size FROM file_blocks WHERE physical_file_id = ? AND block_number = ?", 2);
cass_statement_bind_uuid(statement, 0, *physical_file_id);
cass_statement_bind_int32(statement, 1, block);
unsigned char* return_data = NULL;
CassFuture* result_future = cass_session_execute(ctxt->session, statement);
cass_statement_free(statement);
if (cass_future_error_code(result_future) == CASS_OK) {
const CassResult* result = cass_future_get_result(result_future);
CassIterator* rows = cass_iterator_from_result(result);
if (cass_iterator_next(rows)) {
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* data_value = cass_row_get_column_by_name(row, "data");
const CassValue* size_value = cass_row_get_column_by_name(row, "size");
const cass_byte_t* cass_data;
size_t size;
int size2;
cass_value_get_bytes(data_value, &cass_data, &size);
cass_value_get_int32(size_value, &size2);
// Let's use the value from "size" field unless bigger than the actual data.
if (size2>size) {
warning("Problem: size field is showing value %d which is bigger than the actual block data length %zu", size2, size);
size2 = size;
}
return_data = (unsigned char*)malloc(size2);
memcpy(return_data, cass_data, size2);
(*bytes_read) = size2;
}
cass_result_free(result);
cass_iterator_free(rows);
} else {
/* Handle error */
cassandra_log_error(result_future);
}
cass_future_free(result_future);
return return_data;
}
void build(const std::string& ip_prefix, int num_nodes) {
test_utils::CassClusterPtr cluster(cass_cluster_new());
test_utils::initialize_contact_points(cluster.get(), ip_prefix, num_nodes, 0);
cass_cluster_set_load_balance_round_robin(cluster.get());
cass_cluster_set_token_aware_routing(cluster.get(), cass_false);
test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
for (int i = 0; i < num_nodes; ++i) {
test_utils::CassStatementPtr statement(
cass_statement_new("SELECT tokens, data_center FROM system.local", 0));
test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
test_utils::wait_and_check_error(future.get());
test_utils::CassResultPtr result(cass_future_get_result(future.get()));
const CassRow* row = cass_result_first_row(result.get());
const CassValue* data_center = cass_row_get_column_by_name(row, "data_center");
const CassValue* token_set = cass_row_get_column_by_name(row, "tokens");
CassString str;
cass_value_get_string(data_center, &str.data, &str.length);
std::string dc(str.data, str.length);
std::string ip = cass::get_host_from_future(future.get());
test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(token_set));
while (cass_iterator_next(iterator.get())) {
cass_value_get_string(cass_iterator_get_value(iterator.get()), &str.data, &str.length);
std::string token(str.data, str.length);
tokens[boost::lexical_cast<int64_t>(token)] = Host(ip, dc);
}
}
}
/**
* Test established connection with a high load query
*/
void test_high_load() {
//Create and use the simple keyspace
test_utils::execute_query(session_, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
test_utils::execute_query(session_, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
//Create a table to fill with large text fields
test_utils::execute_query(session_, "CREATE TABLE high_load (key int PRIMARY KEY, a text, b text, c text)");
//Perform queries and validate inserted data
for (int n = 0; n < NUMBER_OF_ITERATIONS; ++n) {
std::string text_a = test_utils::generate_random_string(10240);
std::string text_b = test_utils::generate_random_string(20480);
std::string text_c = test_utils::generate_random_string(40960);
test_utils::execute_query(session_, str(boost::format("INSERT INTO high_load (key, a, b, c) VALUES (%d, '%s', '%s', '%s')") % n % text_a % text_b % text_c));
test_utils::CassResultPtr result;
test_utils::execute_query(session_, str(boost::format("SELECT * FROM high_load WHERE key = %d") % n), &result);
BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4u);
BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1u);
const CassRow* row = cass_result_first_row(result.get());
const CassValue* value;
value = cass_row_get_column_by_name(row, "key");
BOOST_REQUIRE(value != NULL);
cass_int32_t key;
BOOST_REQUIRE_EQUAL(cass_value_get_int32(value, &key), CASS_OK);
BOOST_CHECK_EQUAL(key, n);
value = cass_row_get_column_by_name(row, "a");
BOOST_REQUIRE(value != NULL);
CassString a;
BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &a.data, &a.length), CASS_OK);
BOOST_CHECK(test_utils::Value<CassString>::equal(a, CassString(text_a.c_str())));
value = cass_row_get_column_by_name(row, "b");
BOOST_REQUIRE(value != NULL);
CassString b;
BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &b.data, &b.length), CASS_OK);
BOOST_CHECK(test_utils::Value<CassString>::equal(b, CassString(text_b.c_str())));
value = cass_row_get_column_by_name(row, "c");
BOOST_REQUIRE(value != NULL);
CassString c;
BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &c.data, &c.length), CASS_OK);
BOOST_CHECK(test_utils::Value<CassString>::equal(c, CassString(text_c.c_str())));
}
//Drop the table and keyspace
test_utils::execute_query(session_, "DROP TABLE high_load");
test_utils::execute_query(session_, str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
}
/**
* Test established connection with a normal load query
*/
void test_normal_load() {
//Create and use the simple keyspace
test_utils::execute_query(session_, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1"));
test_utils::execute_query(session_, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE));
//Create a table to fill with numbers and characters
test_utils::execute_query(session_, "CREATE TABLE normal_load (key int PRIMARY KEY, a int, b float, c text)");
//Perform queries and validate inserted data
for (int n = 0; n < NUMBER_OF_ITERATIONS; ++n) {
std::string text = test_utils::generate_random_string(16);
test_utils::execute_query(session_, str(boost::format("INSERT INTO normal_load (key, a, b, c) VALUES (%d, %d, %f, '%s')") % n % (n * 100) % (n * .001f) % text));
test_utils::CassResultPtr result;
test_utils::execute_query(session_, str(boost::format("SELECT * FROM normal_load WHERE key = %d") % n), &result);
BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4u);
BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1u);
const CassRow* row = cass_result_first_row(result.get());
const CassValue* value;
value = cass_row_get_column_by_name(row, "key");
BOOST_REQUIRE(value != NULL);
cass_int32_t key;
BOOST_REQUIRE_EQUAL(cass_value_get_int32(value, &key), CASS_OK);
BOOST_CHECK_EQUAL(key, n);
value = cass_row_get_column_by_name(row, "a");
BOOST_REQUIRE(value != NULL);
cass_int32_t a;
BOOST_REQUIRE_EQUAL(cass_value_get_int32(value, &a), CASS_OK);
BOOST_CHECK_EQUAL(a, (n * 100));
value = cass_row_get_column_by_name(row, "b");
BOOST_REQUIRE(value != NULL);
cass_float_t b;
BOOST_REQUIRE_EQUAL(cass_value_get_float(value, &b), CASS_OK);
BOOST_CHECK_EQUAL(b, (n * .001f));
value = cass_row_get_column_by_name(row, "c");
BOOST_REQUIRE(value != NULL);
CassString c;
BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &c.data, &c.length), CASS_OK);
BOOST_CHECK(test_utils::Value<CassString>::equal(c, CassString(text.c_str())));
}
//Drop the table and keyspace
test_utils::execute_query(session_, "DROP TABLE normal_load");
test_utils::execute_query(session_, str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE));
}
CassError select_from_basic(CassSession* session, const char* key, Basic* basic) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query
= "SELECT * FROM examples.basic WHERE key = ?";
statement = cass_statement_new(query, 1);
cass_statement_bind_string_by_name(statement, "key", 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 CassRow* row = cass_iterator_get_row(iterator);
cass_value_get_bool(cass_row_get_column_by_name(row, "BLN"), &basic->bln);
cass_value_get_double(cass_row_get_column_by_name(row, "dbl"), &basic->dbl);
cass_value_get_float(cass_row_get_column_by_name(row, "flt"), &basic->flt);
cass_value_get_int32(cass_row_get_column_by_name(row, "\"i32\""), &basic->i32);
cass_value_get_int64(cass_row_get_column_by_name(row, "i64"), &basic->i64);
}
cass_result_free(result);
cass_iterator_free(iterator);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
CassError CassandraFS::read_physical_file_info(struct stat* stat, struct cfs_attrs* cfs_attrs) {
CassStatement* statement = cass_statement_new("SELECT size, block_size FROM physical_files WHERE id = ?", 1);
cass_statement_bind_uuid(statement, 0, cfs_attrs->physical_file_id);
CassFuture* result_future = cass_session_execute(ctxt->session, statement);
cass_statement_free(statement);
CassError error = cass_future_error_code(result_future);
if (error == CASS_OK) {
/* Retrieve result set and iterate over the rows */
const CassResult* result = cass_future_get_result(result_future);
CassIterator* rows = cass_iterator_from_result(result);
if (cass_iterator_next(rows)) {
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* size_value = cass_row_get_column_by_name(row, "size");
if (!cass_value_is_null(size_value)) {
cass_int64_t size;
cass_value_get_int64(size_value, &size);
stat->st_size = size;
}
const CassValue* block_size_value = cass_row_get_column_by_name(row, "block_size");
if (!cass_value_is_null(block_size_value)) {
int size;
cass_value_get_int32(block_size_value, &size);
cfs_attrs->block_size = size;
}
}
cass_result_free(result);
cass_iterator_free(rows);
} else {
/* Handle error */
cassandra_log_error(result_future);
}
cass_future_free(result_future);
return error;
}
CassVersion get_version(CassSession* session) {
// Execute the version query
CassResultPtr result;
execute_query(session, SELECT_VERSION, &result);
// Only one row should be returned; get the first row
const CassRow *row = cass_result_first_row(result.get());
// Convert the release_version value to a string
const CassValue* value = cass_row_get_column_by_name(row, "release_version");
CassString version_string;
cass_value_get_string(value, &version_string.data, &version_string.length);
// Parse the version string and return the Cassandra version
CassVersion version;
std::string str(version_string.data, version_string.length); // Needed for null termination
sscanf(str.c_str(), "%hu.%hu.%hu-%s", &version.major, &version.minor, &version.patch, version.extra);
return version;
}
/**
* Check to see if a query has been prepared on a given node.
*
* @param node The node to check
* @param query A query string
* @return true if the query has been prepared on the node, otherwise false
*/
bool prepared_statement_is_present(int node, const std::string& query) {
test_utils::CassResultPtr result;
test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result);
test_utils::CassIteratorPtr iterator(cass_iterator_from_result(result.get()));
while (cass_iterator_next(iterator.get())) {
const CassRow* row = cass_iterator_get_row(iterator.get());
BOOST_REQUIRE(row);
const CassValue* query_column = cass_row_get_column_by_name(row, "query_string");
const char* query_string;
size_t query_string_len;
BOOST_REQUIRE_EQUAL(cass_value_get_string(query_column, &query_string, &query_string_len), CASS_OK);
if (query == std::string(query_string, query_string_len)) {
return true;
}
}
return false;
}
int main(int argc, char* argv[]) {
/* Setup and connect to cluster */
CassFuture* connect_future = NULL;
CassCluster* cluster = cass_cluster_new();
CassSession* session = cass_session_new();
CassSsl* ssl = cass_ssl_new();
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cass_cluster_set_contact_points(cluster, hosts);
/* Only verify the certification and not the identity */
cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_PEER_CERT);
if (!load_trusted_cert_file("cert.pem", ssl)) {
fprintf(stderr, "Failed to load certificate disabling peer verification\n");
cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_NONE);
}
cass_cluster_set_ssl(cluster, ssl);
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
/* Build statement and execute query */
const char* query = "SELECT release_version FROM system.local";
CassStatement* statement = cass_statement_new(query, 0);
CassFuture* result_future = cass_session_execute(session, statement);
if (cass_future_error_code(result_future) == CASS_OK) {
/* Retrieve result set and get the first row */
const CassResult* result = cass_future_get_result(result_future);
const CassRow* row = cass_result_first_row(result);
if (row) {
const CassValue* value = cass_row_get_column_by_name(row, "release_version");
const char* release_version;
size_t release_version_length;
cass_value_get_string(value, &release_version, &release_version_length);
printf("release_version: '%.*s'\n", (int)release_version_length,
release_version);
}
cass_result_free(result);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(result_future, &message, &message_length);
fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length,
message);
}
cass_statement_free(statement);
cass_future_free(result_future);
/* Close the session */
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(connect_future, &message, &message_length);
fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
message);
}
cass_future_free(connect_future);
cass_cluster_free(cluster);
cass_session_free(session);
cass_ssl_free(ssl);
return 0;
}
int main(int argc, char* argv[]) {
/* Setup and connect to cluster */
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];
}
/* Add contact points */
cass_cluster_set_contact_points(cluster, hosts);
/* Provide the cluster object as configuration to connect the session */
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
/* Build statement and execute query */
const char* query = "SELECT keyspace_name "
"FROM system.schema_keyspaces;";
CassStatement* statement = cass_statement_new(query, 0);
CassFuture* result_future = cass_session_execute(session, statement);
if (cass_future_error_code(result_future) == CASS_OK) {
/* Retrieve result set and iterate over the rows */
const CassResult* result = cass_future_get_result(result_future);
CassIterator* rows = cass_iterator_from_result(result);
while (cass_iterator_next(rows)) {
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* value = cass_row_get_column_by_name(row, "keyspace_name");
const char* keyspace_name;
size_t keyspace_name_length;
cass_value_get_string(value, &keyspace_name, &keyspace_name_length);
printf("keyspace_name: '%.*s'\n", (int)keyspace_name_length,
keyspace_name);
}
cass_result_free(result);
cass_iterator_free(rows);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(result_future, &message, &message_length);
fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length,
message);
}
cass_statement_free(statement);
cass_future_free(result_future);
/* Close the session */
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(connect_future, &message, &message_length);
fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
message);
}
cass_future_free(connect_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
CassError select_from_udt(CassSession* session) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query = "SELECT * FROM examples.udt";
statement = cass_statement_new(query, 0);
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 = NULL;
CassIterator* rows = NULL;
result = cass_future_get_result(future);
rows = cass_iterator_from_result(result);
while(cass_iterator_next(rows)) {
CassUuid id;
char id_str[CASS_UUID_STRING_LENGTH];
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* id_value = cass_row_get_column_by_name(row, "id");
const CassValue* address_value = cass_row_get_column_by_name(row, "address");
CassIterator* fields = cass_iterator_fields_from_user_type(address_value);
cass_value_get_uuid(id_value, &id);
cass_uuid_string(id, id_str);
printf("id %s ", id_str);
while(fields != NULL && cass_iterator_next(fields)) {
const char* field_name;
size_t field_name_length;
const CassValue* field_value = NULL;
cass_iterator_get_user_type_field_name(fields, &field_name, &field_name_length);
field_value = cass_iterator_get_user_type_field_value(fields);
printf("%.*s ", (int)field_name_length, field_name);
if (!cass_value_is_null(field_value)) {
if (cass_value_type(field_value) == CASS_VALUE_TYPE_VARCHAR) {
const char* text;
size_t text_length;
cass_value_get_string(field_value, &text, &text_length);
printf("\"%.*s\" ", (int)text_length, text);
} else if (cass_value_type(field_value) == CASS_VALUE_TYPE_INT) {
cass_int32_t i;
cass_value_get_int32(field_value, &i);
printf("%d ", i);
} else if (cass_value_type(field_value) == CASS_VALUE_TYPE_SET) {
CassIterator* phone_numbers = cass_iterator_from_collection(field_value);
while (cass_iterator_next(phone_numbers)) {
const CassValue* phone_value = cass_iterator_get_value(phone_numbers);
CassIterator* phone_fields = cass_iterator_fields_from_user_type(phone_value);
assert(cass_value_type(phone_value) == CASS_VALUE_TYPE_UDT);
while (cass_iterator_next(phone_fields)) {
const CassValue* phone_number_value = cass_iterator_get_user_type_field_value(phone_fields);
cass_int32_t i;
cass_value_get_int32(phone_number_value, &i);
printf("%d ", i);
}
}
} else {
printf("<invalid> ");
}
} else {
printf("<null> ");
}
}
printf("\n");
}
cass_result_free(result);
cass_iterator_free(rows);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
int CassandraFS::getattr(const char* path, struct stat *stbuf, struct cfs_attrs *cfs_attrs) {
int found = 0;
memset(stbuf, 0, sizeof(struct stat));
memset(cfs_attrs, 0, sizeof(struct cfs_attrs));
CassStatement* statement = cass_statement_new("SELECT mode, modified_at, physical_file_id FROM entries WHERE path = ?", 1);
cass_statement_bind_string(statement, 0, path);
CassFuture* result_future = cass_session_execute(ctxt->session, statement);
cass_statement_free(statement);
int error = 0;
if (cass_future_error_code(result_future) == CASS_OK) {
/* Retrieve result set and iterate over the rows */
const CassResult* result = cass_future_get_result(result_future);
CassIterator* rows = cass_iterator_from_result(result);
if (cass_iterator_next(rows)) {
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* value = cass_row_get_column_by_name(row, "mode");
const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at");
int mode;
cass_value_get_int32(value, &mode);
stbuf->st_mode = mode;
// regular file
if (S_ISREG(mode)) {
const CassValue* file_id_value = cass_row_get_column_by_name(row, "physical_file_id");
if (!cass_value_is_null(file_id_value)) {
cass_value_get_uuid(file_id_value, &(cfs_attrs->physical_file_id));
}
CassError phys_err = read_physical_file_info(stbuf, cfs_attrs);
if (phys_err != CASS_OK) {
error = -EIO;
}
}
if (!cass_value_is_null(modified_at_value)) {
cass_int64_t modified_at;
cass_value_get_int64(modified_at_value, &modified_at);
stbuf->st_mtime = modified_at / 1000;
}
stbuf->st_nlink = 1;
found = 1;
}
cass_result_free(result);
cass_iterator_free(rows);
} else {
/* Handle error */
error = -EIO;
cassandra_log_error(result_future);
}
cass_future_free(result_future);
if (!found) {
return -ENOENT;
}
return error;
}
int CassandraFS::hardlink(const char* from, const char* to) {
int operation_done = 0;
CassStatement* statement = cass_statement_new("SELECT mode, created_at, modified_at, physical_file_id FROM entries WHERE path = ?", 1);
cass_statement_bind_string(statement, 0, from);
CassFuture* result_future = cass_session_execute(ctxt->session, statement);
cass_statement_free(statement);
int error = 0;
if (cass_future_error_code(result_future) == CASS_OK) {
/* Retrieve result set and iterate over the rows */
const CassResult* result = cass_future_get_result(result_future);
CassIterator* rows = cass_iterator_from_result(result);
if (cass_iterator_next(rows)) {
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* mode_value = cass_row_get_column_by_name(row, "mode");
const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at");
const CassValue* created_at_value = cass_row_get_column_by_name(row, "created_at");
const CassValue* physical_file_id_value = cass_row_get_column_by_name(row, "physical_file_id");
int mode;
cass_value_get_int32(mode_value, &mode);
cass_int64_t modified_at;
cass_value_get_int64(modified_at_value, &modified_at);
cass_int64_t created_at;
cass_value_get_int64(created_at_value, &created_at);
CassUuid physical_file_id;
cass_value_get_uuid(physical_file_id_value, &physical_file_id);
CassStatement* insert_statement = cass_statement_new("INSERT INTO entries(path, mode, created_at, modified_at, physical_file_id) VALUES(?,?,?,?,?)", 5);
cass_statement_bind_string(insert_statement, 0, to);
cass_statement_bind_int32(insert_statement, 1, mode);
cass_statement_bind_int64(insert_statement, 2, created_at);
cass_statement_bind_int64(insert_statement, 3, modified_at);
cass_statement_bind_uuid(insert_statement, 4, physical_file_id);
CassFuture* insert_future2 = create_sub_entry(to);
CassFuture* insert_future = cass_session_execute(ctxt->session, insert_statement);
cass_statement_free(insert_statement);
if (cass_future_error_code(insert_future) == CASS_OK) {
operation_done = 1;
} else {
operation_done = 0;
cassandra_log_error(insert_future);
}
if (cass_future_error_code(insert_future2) == CASS_OK) {
operation_done = 1;
} else {
operation_done = 0;
cassandra_log_error(insert_future2);
}
cass_future_free(insert_future);
cass_future_free(insert_future2);
}
cass_result_free(result);
cass_iterator_free(rows);
} else {
/* Handle error */
error = -EIO;
cassandra_log_error(result_future);
}
cass_future_free(result_future);
if (!operation_done) {
return -ENOENT;
}
return error;
}
