test_utils::CassResultPtr select_all_from_bytes_by_name() {
test_utils::CassResultPtr result;
test_utils::execute_query(session, "SELECT * FROM bytes_by_name", &result);
BOOST_REQUIRE(cass_result_column_count(result.get()) == 3);
BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
return result;
}
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;
}
cass_int64_t get_timestamp(const std::string table_name, const std::string& key) {
cass_int64_t timestamp;
test_utils::CassResultPtr result;
std::string query = str(boost::format("SELECT writetime(value) FROM %s WHERE key = '%s'") % table_name % key);
test_utils::execute_query(session, query, &result);
BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
BOOST_REQUIRE(cass_result_column_count(result.get()) > 0);
const CassRow* row = cass_result_first_row(result.get());
const CassValue* writetime = cass_row_get_column(row, 0);
cass_value_get_int64(writetime, ×tamp);
return timestamp;
}
bool CCassandraLogAgent::executeSimpleSelectStatement(const char* st, unsigned& resultValue)
{
CassandraStatement statement(cassSession->prepareStatement(st, getEspLogLevel()>LogNormal));
CassandraFuture future(cass_session_execute(cassSession->querySession(), statement));
future.wait("execute");
CassandraResult result(cass_future_get_result(future));
if (cass_result_row_count(result) == 0)
return false;
resultValue = getUnsignedResult(NULL, getSingleResult(result));
return true;
}
void auth(int protocol_version) {
cass_cluster_set_protocol_version(cluster.get(), protocol_version);
cass_cluster_set_credentials(cluster.get(), "cassandra", "cassandra");
test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
test_utils::CassResultPtr result;
std::stringstream query;
query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
test_utils::execute_query(session.get(), query.str().c_str(), &result);
BOOST_CHECK(cass_result_row_count(result.get()) > 0);
}
/**
* 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_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;
}
void validate_results(const std::string& table_name,
size_t num_concurrent_requests,
const std::vector<CassUuid>& ids)
{
std::string select_query = str(boost::format("SELECT * FROM %s;") % table_name);
test_utils::CassResultPtr result;
test_utils::execute_query(session, select_query, &result, CASS_CONSISTENCY_QUORUM);
BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), num_concurrent_requests);
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());
CassUuid result_id;
cass_value_get_uuid(cass_row_get_column(row, 0), &result_id);
BOOST_REQUIRE(std::find(ids.begin(), ids.end(), result_id) != ids.end());
}
}
void check_result(CassSession* session) {
test_utils::CassResultPtr result;
test_utils::execute_query(session, "SELECT * FROM test", &result);
BOOST_REQUIRE(cass_result_column_count(result.get()) == 5);
BOOST_REQUIRE(cass_result_row_count(result.get()) > 0);
const CassRow* row = cass_result_first_row(result.get());
cass_int32_t key;
BOOST_REQUIRE(cass_value_get_int32(cass_row_get_column(row, 0), &key) == CASS_OK);
cass_int32_t v1;
BOOST_REQUIRE(cass_value_get_int32(cass_row_get_column(row, 1), &v1) == CASS_OK);
CassString v2;
BOOST_REQUIRE(cass_value_get_string(cass_row_get_column(row, 2), &v2.data, &v2.length) == CASS_OK);
test_utils::CassIteratorPtr v3(cass_iterator_from_collection(cass_row_get_column(row, 3)));
cass_int32_t i = 0;
while (cass_iterator_next(v3.get())) {
const CassValue* value = cass_iterator_get_value(v3.get());
BOOST_REQUIRE(cass_value_type(value) == CASS_VALUE_TYPE_INT);
cass_int32_t output;
cass_value_get_int32(value, &output);
BOOST_REQUIRE(i == output);
i++;
}
test_utils::CassIteratorPtr v4(cass_iterator_from_collection(cass_row_get_column(row, 4)));
cass_int32_t j = 0;
while (cass_iterator_next(v4.get())) {
const CassValue* value = cass_iterator_get_value(v4.get());
BOOST_REQUIRE(cass_value_type(value) == CASS_VALUE_TYPE_VARCHAR);
CassString output;
cass_value_get_string(value, &output.data, &output.length);
BOOST_REQUIRE(output.length == 1 && output.data[0] == 'd' + j);
j++;
}
}
bool client_thread(CassSession* session, const std::string table_name) {
std::string query = str(boost::format("SELECT * FROM %s LIMIT 10000") % table_name);
for (int i = 0 ; i < 10; ++i) execute_insert(session, table_name);
boost::posix_time::ptime start = boost::posix_time::second_clock::universal_time();
test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_ONE);
while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() < TEST_DURATION_SECS) {
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_done = true;
return 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_done = true;
return false;
}
}
}
is_done = true;
return true;
}
/**
* Verify that a nodes "system.prepared_statements" table is empty.
*
* @param node The node to check
*/
void prepared_statements_is_empty(int node) {
test_utils::CassResultPtr result;
test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result);
BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 0u);
}
void CassDriver::Retrieve(
std::tr1::function<void(bool success, Wrapper* data)> cob,
const std::string& receiver_id, Wrapper* data_wrapper) {
CassStatement* statement = cass_prepared_bind(select_prepared_);
cass_statement_bind_string(statement, 0,
cass_string_init(receiver_id.c_str()));
cass_statement_set_paging_size(statement, FLAGS_page_size);
CassFuture* future = cass_session_execute(session_, statement);
auto retrieve_cb = [](CassFuture* future, void* data) {
CassError rc = cass_future_error_code(future);
Wrapper* wrapper = (Wrapper*)data;
if (rc == CASS_OK) {
const CassResult* result = cass_future_get_result(future);
if (cass_result_row_count(result)) {
CassIterator* iterator = cass_iterator_from_result(result);
CassString cass_receiver, cass_time, cass_msg_id,
cass_group_id, cass_msg, cass_sender;
while (cass_iterator_next(iterator)) {
const CassRow* row = cass_iterator_get_row(iterator);
cass_value_get_string(cass_row_get_column(row, 0), &cass_receiver);
cass_value_get_string(cass_row_get_column(row, 1), &cass_time);
cass_value_get_string(cass_row_get_column(row, 2), &cass_msg_id);
cass_value_get_string(cass_row_get_column(row, 3), &cass_group_id);
cass_value_get_string(cass_row_get_column(row, 4), &cass_msg);
cass_value_get_string(cass_row_get_column(row, 5), &cass_sender);
std::string receiver(cass_receiver.data, cass_receiver.length);
std::string time(cass_time.data, cass_time.length);
std::string msg_id(cass_msg_id.data, cass_msg_id.length);
std::string group_id(cass_group_id.data, cass_group_id.length);
std::string msg(cass_msg.data, cass_msg.length);
std::string sender(cass_sender.data, cass_sender.length);
boost::shared_ptr<Message> message(new Message());
message->__set_receiver_id(receiver);
message->__set_timestamp(time);
message->__set_msg_id(msg_id);
message->__set_group_id(group_id);
message->__set_msg(msg);
message->__set_sender_id(sender);
wrapper->pmsgs->push_back(message);
}
cass_bool_t has_more_pages = cass_result_has_more_pages(result);
if (has_more_pages) {
cass_statement_set_paging_state(wrapper->statement, result);
(wrapper->func)();
} else {
cass_statement_free(wrapper->statement);
CassStatement* statement =
cass_prepared_bind(wrapper->this_obj->delete_prepared_);
cass_statement_bind_string(statement, 0, cass_receiver);
CassFuture* delete_future =
cass_session_execute(wrapper->this_obj->session_, statement);
cass_future_free(delete_future);
cass_statement_free(statement);
(wrapper->cob)(true, wrapper);
}
cass_iterator_free(iterator);
} else {
cass_statement_free(wrapper->statement);
(wrapper->cob)(true, wrapper);
}
cass_result_free(result);
} else {
cass_statement_free(wrapper->statement);
wrapper->this_obj->PrintError(future);
(wrapper->cob)(false, wrapper);
}
};
data_wrapper->this_obj = this;
data_wrapper->cob = cob;
data_wrapper->statement = statement;
data_wrapper->func = [=]() {
CassFuture* future = cass_session_execute(session_, statement);
cass_future_set_callback(future, retrieve_cb, data_wrapper);
cass_future_free(future);
};
cass_future_set_callback(future, retrieve_cb, data_wrapper);
cass_future_free(future);
}
/**
* Executes a statement on a given session. Currently builds an array of rows.
* That will hopefully change.
* Also, I may expose the iterator instead, so you can go crazy in Lua-land.
*/
int lua_cass_session_execute(lua_State* L)
{
CassSession* session = lua_session_get_ptr(L, 1);
CassStatement* statement = lua_statement_get_ptr(L, 2);
CassFuture* future = cass_session_execute(session, statement);
cass_future_wait(future);
CassError rc = cass_future_error_code(future);
if (rc != CASS_OK) {
int num = lua_cass_push_future_error(L, future);
cass_future_free(future);
return num;
}
const CassResult* result = cass_future_get_result(future);
cass_future_free(future);
CassIterator* iterator = cass_iterator_from_result(result);
// TODO: devolver un iterador ?
int row_count = cass_result_row_count(result);
int column_count = cass_result_column_count(result);
int i = 0;
lua_newtable(L);
int rows_table = lua_gettop(L);
/* iterate over rows */
while (cass_iterator_next(iterator)) {
const CassRow* row = cass_iterator_get_row(iterator);
lua_newtable(L);
int columns_table = lua_gettop(L);
/* loop over columns */
for (int j = 0; j < column_count; ++j) {
CassString name = cass_result_column_name(result, j);
lua_pushlstring(L, name.data, name.length);
lua_cass_value_to_lua(L, cass_row_get_column(row, j));
lua_settable(L, columns_table);
//lua_rawseti(L, columns_table, j + 1);
}
/*int j = 0;
CassIterator* it_columns = cass_iterator_from_row(row);
while (cass_iterator_next(it_columns)) {
const CassValue* column = cass_iterator_get_column(it_columns);
CassString name = cass_result_column_name(result, j);
lua_pushlstring(L, name.data, name.length);
lua_cass_value_to_lua(L, column);
lua_settable(L, columns_table);
j++;
}*/
lua_rawseti(L, rows_table, ++i);
}
cass_result_free(result);
cass_iterator_free(iterator);
return 1;
}
