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; }