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);
}
static void*
cassandra_results_stream_get_statement(void* context, int flags)
{
cassandra_results_stream* scontext;
const char* s;
size_t s_len;
const char* p;
size_t p_len;
const char* o;
size_t o_len;
const CassRow* row;
scontext = (cassandra_results_stream*)context;
switch(flags) {
case LIBRDF_ITERATOR_GET_METHOD_GET_OBJECT:
row = cass_iterator_get_row(scontext->iter);
cass_value_get_string(cass_row_get_column(row, 0), &s, &s_len);
cass_value_get_string(cass_row_get_column(row, 1), &p, &p_len);
cass_value_get_string(cass_row_get_column(row, 2), &o, &o_len);
if (scontext->statement) {
librdf_free_statement(scontext->statement);
scontext->statement = 0;
}
librdf_node* sn, * pn, * on;
sn = node_constructor_helper(scontext->storage->world, s, s_len);
pn = node_constructor_helper(scontext->storage->world, p, p_len);
on = node_constructor_helper(scontext->storage->world, o, o_len);
if (sn == 0 || pn == 0 || on == 0) {
if (sn) librdf_free_node(sn);
if (pn) librdf_free_node(pn);
if (on) librdf_free_node(on);
return 0;
}
scontext->statement =
librdf_new_statement_from_nodes(scontext->storage->world,
sn, pn, on);
return scontext->statement;
case LIBRDF_ITERATOR_GET_METHOD_GET_CONTEXT:
return scontext->context;
default:
librdf_log(scontext->storage->world,
0, LIBRDF_LOG_ERROR, LIBRDF_FROM_STORAGE, NULL,
"Unknown iterator method flag %d", flags);
return NULL;
}
}
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++;
}
}
CassError select_from(CassSession* session, const char* key) {
CassError rc = CASS_OK;
CassStatement* statement = NULL;
CassFuture* future = NULL;
const char* query = "SELECT * FROM examples.date_time 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)) {
cass_uint32_t d;
cass_int64_t t;
time_t time;
const CassRow* row = cass_iterator_get_row(iterator);
cass_value_get_uint32(cass_row_get_column(row, 1), &d);
cass_value_get_int64(cass_row_get_column(row, 2), &t);
time = (time_t)cass_date_time_to_epoch(d, t);
printf("Date and time: %s", asctime(localtime(&time)));
}
cass_result_free(result);
cass_iterator_free(iterator);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
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;
}
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(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 CassRow* row = cass_iterator_get_row(iterator);
cass_value_get_bool(cass_row_get_column(row, 1), &basic->bln);
cass_value_get_double(cass_row_get_column(row, 2), &basic->dbl);
cass_value_get_float(cass_row_get_column(row, 3), &basic->flt);
cass_value_get_int32(cass_row_get_column(row, 4), &basic->i32);
cass_value_get_int64(cass_row_get_column(row, 5), &basic->i64);
}
cass_result_free(result);
cass_iterator_free(iterator);
}
cass_future_free(future);
cass_statement_free(statement);
return rc;
}
void DbCassandra::GetAll( GetCallback callback )
{
DbPtr db = db_;
if ( db )
{
auto statement = cass_statement_new( "SELECT * FROM prun.jobs;", 0 );
auto query_future = cass_session_execute( db_->GetSession(), statement );
cass_statement_free( statement );
CassError err = cass_future_error_code( query_future );
if ( err != CASS_OK )
{
cass_future_free( query_future );
throw std::logic_error( cass_error_desc( err ) );
}
auto result = cass_future_get_result( query_future );
cass_future_free( query_future );
auto iterator = cass_iterator_from_result( result );
while( cass_iterator_next( iterator ) )
{
const CassRow *row = cass_iterator_get_row( iterator );
const char *job_id, *job_descr;
size_t job_id_length, job_descr_length;
cass_value_get_string( cass_row_get_column( row, 0 ), &job_id, &job_id_length );
cass_value_get_string( cass_row_get_column( row, 1 ), &job_descr, &job_descr_length );
callback( std::string( job_id, job_id_length ), std::string( job_descr, job_descr_length ) );
}
cass_iterator_free( iterator );
cass_result_free( result );
}
}
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 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(int num_rows) {
std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % BatchTests::SIMPLE_TABLE_NAME);
for (int y = 0; y < num_rows; y++)
{
test_utils::CassStatementPtr select_statement(cass_statement_new(select_query.c_str(), 1));
BOOST_REQUIRE(cass_statement_bind_int32(select_statement.get(), 0, y) == CASS_OK);
test_utils::CassFuturePtr select_future(cass_session_execute(session, select_statement.get()));
test_utils::wait_and_check_error(select_future.get());
test_utils::CassResultPtr result(cass_future_get_result(select_future.get()));
const CassValue* column = cass_row_get_column(cass_result_first_row(result.get()), 1);
CassString result_value;
BOOST_REQUIRE(cass_value_type(column) == CASS_VALUE_TYPE_VARCHAR);
BOOST_REQUIRE(test_utils::Value<CassString>::get(column, &result_value) == CASS_OK);
BOOST_REQUIRE(test_utils::Value<CassString>::equal(result_value, str(boost::format("test data %s") % y).c_str()));
}
}
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());
}
}
static int
librdf_storage_cassandra_size(librdf_storage* storage)
{
librdf_storage_cassandra_instance* context;
context = (librdf_storage_cassandra_instance*)storage->instance;
char* query = "SELECT count(s) FROM rdf.spo";
CassStatement* stmt = cass_statement_new(query, 0);
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 0;
}
const CassResult* result = cass_future_get_result(future);
cass_future_free(future);
const CassRow* row = cass_result_first_row(result);
int64_t count;
cass_value_get_int64(cass_row_get_column(row, 0), &count);
cass_result_free(result);
return count;
}
static std::string LoadFile(Upload& upload)
{
std::stringstream ss;
DatabaseSession session;
try {
CassError rc = CASS_OK;
//std::string str = ("SELECT upload_id, model_id, date, processed, result {includeFile} FROM prophet.models {onlyPending}");
std::string str = "SELECT chunk from prophet.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);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
auto err = std::string("Failed to execute query: ")
+ CassandraUtils::GetCassandraError(future);
cass_future_free(future);
cass_statement_free(statement);
throw err;
}
else {
const CassResult* result = cass_future_get_result(future);
CassIterator* iterator = cass_iterator_from_result(result);
while (cass_iterator_next(iterator)) {
const CassRow* row = cass_iterator_get_row(iterator);
std::string buffer;
CassString::Load(buffer, cass_row_get_column(row, 0));
ss << buffer;
}
cass_result_free(result);
cass_iterator_free(iterator);
}
cass_future_free(future);
cass_statement_free(statement);
}
catch (...) {
std::exception_ptr e = std::current_exception();
try {
if (e) {
std::rethrow_exception(e);
}
}
catch (const std::exception& ex) {
std::cout << "Caught exception \"" << ex.what() << "\"\n";
}
}
return ss.str();
}
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);
}
static const CassValue* getSingleResult(const CassResult* result)
{
const CassRow* row = cass_result_first_row(result);
return row ? cass_row_get_column(row, 0) : NULL;
}
/**
* 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;
}
