void on_create_table(CassFuture* future, void* data) {
const char* insert_query = "INSERT INTO callbacks (key, value) "
"VALUES (?, ?)";
CassUuid key;
CassStatement* statement = NULL;
CassFuture* insert_future = NULL;
CassError code = cass_future_error_code(future);
if (code != CASS_OK) {
print_error(future);
}
statement = cass_statement_new(insert_query, 2);
cass_uuid_gen_time(uuid_gen, &key);
cass_statement_bind_uuid(statement, 0, key);
cass_statement_bind_int64(statement, 1, cass_uuid_timestamp(key));
insert_future = cass_session_execute((CassSession*)data, statement);
cass_future_set_callback(insert_future, on_insert, data);
cass_statement_free(statement);
cass_future_free(insert_future);
}
void execute_query(CassSession* session, const char* query,
CassFutureCallback callback) {
CassStatement* statement = cass_statement_new(query, 0);
CassFuture* future = cass_session_execute(session, statement);
cass_future_set_callback(future, callback, session);
cass_future_free(future);
cass_statement_free(statement);
}
void on_insert(CassFuture* future, void* data) {
CassError code = cass_future_error_code(future);
if (code != CASS_OK) {
print_error(future);
signal_exit((CassSession*)data);
} else {
const char* select_query = "SELECT * FROM callbacks";
CassStatement* statement
= cass_statement_new(select_query, 0);
CassFuture* select_future
= cass_session_execute((CassSession*)data, statement);
cass_future_set_callback(select_future, on_select, data);
cass_statement_free(statement);
cass_future_free(select_future);
}
}
void CassDriver::Store(void (*cob)(CassFuture* future, void* data),
const Message& message, void* cb_data) {
CassStatement* statement = cass_prepared_bind(insert_prepared_);
cass_statement_bind_string(statement, 0,
cass_string_init(message.receiver_id.c_str()));
cass_statement_bind_string(statement, 1,
cass_string_init(message.timestamp.c_str()));
cass_statement_bind_string(statement, 2,
cass_string_init(message.msg_id.c_str()));
cass_statement_bind_string(statement, 3,
cass_string_init(message.group_id.c_str()));
cass_statement_bind_string(statement, 4,
cass_string_init(message.msg.c_str()));
cass_statement_bind_string(statement, 5,
cass_string_init(message.sender_id.c_str()));
CassFuture* future = cass_session_execute(session_, statement);
cass_future_set_callback(future, cob, cb_data);
cass_future_free(future);
cass_statement_free(statement);
}
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);
}
void connect_session(CassSession* session, const CassCluster* cluster, CassFutureCallback callback) {
CassFuture* future = cass_session_connect(session, cluster);
cass_future_set_callback(future, callback, session);
cass_future_free(future);
}
