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