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);
}
/**
* librdf_storage_cassandra_find_statements:
* @storage: the storage
* @statement: the statement to match
*
* .
*
* Return a stream of statements matching the given statement (or
* all statements if NULL). Parts (subject, predicate, object) of the
* statement can be empty in which case any statement part will match that.
* Uses #librdf_statement_match to do the matching.
*
* Return value: a #librdf_stream or NULL on failure
**/
static librdf_stream*
librdf_storage_cassandra_find_statements(librdf_storage* storage,
librdf_statement* statement)
{
librdf_storage_cassandra_instance* context;
cassandra_results_stream* scontext;
librdf_stream* stream;
char* s;
char* p;
char* o;
char* c;
context = (librdf_storage_cassandra_instance*)storage->instance;
scontext =
LIBRDF_CALLOC(cassandra_results_stream*, 1, sizeof(*scontext));
if(!scontext)
return NULL;
scontext->storage = storage;
librdf_storage_add_reference(scontext->storage);
scontext->cassandra_context = context;
statement_helper(storage, statement, 0, &s, &p, &o, &c);
#ifdef DEBUG
fprintf(stderr, "Query: ");
if (s)
fprintf(stderr, "s=%s ", s);
if (p)
fprintf(stderr, "p=%s ", p);
if (o)
fprintf(stderr, "o=%s ", o);
fprintf(stderr, "\n");
#endif
typedef CassStatement* (*query_function)(const char* s, const char* p,
const char* o);
query_function functions[8] = {
&cassandra_query_, /* ??? */
&cassandra_query_s, /* S?? */
&cassandra_query_p, /* ?P? */
&cassandra_query_sp, /* SP? */
&cassandra_query_o, /* ??O */
&cassandra_query_so, /* S?O */
&cassandra_query_po, /* ?PO */
&cassandra_query_spo /* SPO */
};
/* This creates an index into the function table, depending on input
terms. */
int num = 0;
if (o) num += 4;
if (p) num += 2;
if (s) num++;
index_type tp;
query_function fn = functions[num];
CassStatement* stmt = (*fn)(s, p, o);
cass_statement_set_paging_size(stmt, 1000);
if (s) free(s);
if (p) free(p);
if (o) free(o);
CassFuture* future = cass_session_execute(context->session, 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);
CassIterator* iter = cass_iterator_from_result(result);
scontext->stmt = stmt;
scontext->result = result;
scontext->iter = iter;
scontext->more_pages = cass_result_has_more_pages(result);
scontext->at_end = !cass_iterator_next(scontext->iter);
stream =
librdf_new_stream(storage->world,
(void*)scontext,
&cassandra_results_stream_end_of_stream,
&cassandra_results_stream_next_statement,
&cassandra_results_stream_get_statement,
&cassandra_results_stream_finished);
if(!stream) {
cassandra_results_stream_finished((void*)scontext);
return NULL;
}
return stream;
}
