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;
}
static std::vector<CassUuid> insert_async(CassSession* session,
CassUuidGen* uuid_gen,
const std::string& table_name,
size_t num_concurrent_requests,
std::vector<test_utils::CassFuturePtr>* futures) {
std::string create_table_query = str(boost::format("CREATE TABLE %s (id timeuuid PRIMARY KEY, num int, str text);") % table_name);
test_utils::execute_query(session, create_table_query);
std::string insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(?, ?, ?)") % table_name);
std::vector<CassUuid> ids;
for (size_t i = 0; i < num_concurrent_requests; ++i) {
CassUuid id = test_utils::generate_time_uuid(uuid_gen);
test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 3));
// Determine if bound parameters can be used based on C* version
if (version.major == 1) {
insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(%s, %s, 'row%s')") % table_name % test_utils::Value<CassUuid>::to_string(id) % i % i);
statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
} else {
BOOST_REQUIRE(cass_statement_bind_uuid(statement.get(), 0, id) == CASS_OK);
BOOST_REQUIRE(cass_statement_bind_int32(statement.get(), 1, i) == CASS_OK);
std::string str_value = str(boost::format("row%d") % i);
BOOST_REQUIRE(cass_statement_bind_string(statement.get(), 2, str_value.c_str()) == CASS_OK);
}
cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM);
futures->push_back(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())));
ids.push_back(id);
}
return ids;
}
/**
* Execute a select statement against the system tables for a specified amount
* of time.
*
* NOTE: Results and errors are ignored
*
* @param duration Duration in seconds to execute queries
* @param session Session instance
*/
void execute_system_query(int duration, test_utils::CassSessionPtr session) {
boost::posix_time::ptime start = boost::posix_time::second_clock::universal_time();
while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() < duration) {
test_utils::CassStatementPtr statement(cass_statement_new("SELECT * FROM system.local", 0));
cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_ONE);
test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
cass_future_wait_timed(future.get(), test_utils::ONE_SECOND_IN_MICROS);
}
}
bool insert_prepared_task(const CassPrepared* prepared, CassConsistency consistency, int rows_per_id) {
bool is_successful = true;
for (int i = 0; i < rows_per_id; ++i) {
test_utils::CassStatementPtr statement(cass_prepared_bind(prepared));
cass_statement_set_consistency(statement.get(), consistency);
if (!bind_and_execute_insert(statement.get())) {
is_successful = false;
}
}
return is_successful;
}
void PolicyTool::query(CassSession* session, int n, CassConsistency cl)
{
std::string select_query = str(boost::format("SELECT * FROM %s WHERE k = 0") % test_utils::SIMPLE_TABLE);
for (int i = 0; i < n; ++i) {
test_utils::CassStatementPtr statement(cass_statement_new_n(select_query.data(), select_query.size(), 0));
cass_statement_set_consistency(statement.get(), cl);
test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
test_utils::wait_and_check_error(future.get());
add_coordinator(cass::get_host_from_future(future.get()));
}
}
void execute_query(CassSession* session,
const std::string& query,
CassResultPtr* result,
CassConsistency consistency,
cass_duration_t timeout) {
CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
cass_statement_set_consistency(statement.get(), consistency);
CassFuturePtr future(cass_session_execute(session, statement.get()));
wait_and_check_error(future.get(), timeout);
if (result != NULL) {
*result = CassResultPtr(cass_future_get_result(future.get()));
}
}
std::string get_replica(test_utils::CassSessionPtr session,
const std::string& keyspace,
const std::string& value) {
// The query doesn't matter
test_utils::CassStatementPtr statement(
cass_statement_new("SELECT * FROM system.local", 1));
cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_ONE);
cass_statement_bind_string_n(statement.get(), 0, value.data(), value.size());
cass_statement_add_key_index(statement.get(), 0);
cass_statement_set_keyspace(statement.get(), keyspace.c_str());
test_utils::CassFuturePtr future(
cass_session_execute(session.get(), statement.get()));
return cass::get_host_from_future(future.get());
}
bool create_and_execute_insert(const std::string &query, CassConsistency consistency) {
CassUuid time_uuid = test_utils::generate_random_uuid(uuid_gen);
std::string time_uuid_string = test_utils::Value<CassUuid>::to_string(time_uuid);
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) + "'");
std::string simple_query = test_utils::replaceAll(query, "?", "%s");
simple_query = str(boost::format(simple_query) % time_uuid_string % event_time.count() % text_sample);
test_utils::CassStatementPtr statement(cass_statement_new(simple_query.c_str(), 0));
cass_statement_set_consistency(statement.get(), consistency);
return execute_insert(statement.get());
}
bool insert_task(const std::string& query, CassConsistency consistency, int rows_per_id) {
bool is_successful = true;
for (int i = 0; i < rows_per_id; ++i) {
if (version.major == 1) {
if (!create_and_execute_insert(query, consistency)) {
is_successful = false;
}
} else {
test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 3));
cass_statement_set_consistency(statement.get(), consistency);
if (!bind_and_execute_insert(statement.get())) {
is_successful = false;
}
}
}
return is_successful;
}
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;
}
