unsigned char* CassandraFS::read_block(CassUuid* physical_file_id, int block, int* bytes_read) { CassStatement* statement = cass_statement_new("SELECT data, size FROM file_blocks WHERE physical_file_id = ? AND block_number = ?", 2); cass_statement_bind_uuid(statement, 0, *physical_file_id); cass_statement_bind_int32(statement, 1, block); unsigned char* return_data = NULL; CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); if (cass_future_error_code(result_future) == CASS_OK) { const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* data_value = cass_row_get_column_by_name(row, "data"); const CassValue* size_value = cass_row_get_column_by_name(row, "size"); const cass_byte_t* cass_data; size_t size; int size2; cass_value_get_bytes(data_value, &cass_data, &size); cass_value_get_int32(size_value, &size2); // Let's use the value from "size" field unless bigger than the actual data. if (size2>size) { warning("Problem: size field is showing value %d which is bigger than the actual block data length %zu", size2, size); size2 = size; } return_data = (unsigned char*)malloc(size2); memcpy(return_data, cass_data, size2); (*bytes_read) = size2; } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ cassandra_log_error(result_future); } cass_future_free(result_future); return return_data; }
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); }
void build(const std::string& ip_prefix, int num_nodes) { test_utils::CassClusterPtr cluster(cass_cluster_new()); test_utils::initialize_contact_points(cluster.get(), ip_prefix, num_nodes, 0); cass_cluster_set_load_balance_round_robin(cluster.get()); cass_cluster_set_token_aware_routing(cluster.get(), cass_false); test_utils::CassSessionPtr session(test_utils::create_session(cluster.get())); for (int i = 0; i < num_nodes; ++i) { test_utils::CassStatementPtr statement( cass_statement_new("SELECT tokens, data_center FROM system.local", 0)); test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get())); test_utils::wait_and_check_error(future.get()); test_utils::CassResultPtr result(cass_future_get_result(future.get())); const CassRow* row = cass_result_first_row(result.get()); const CassValue* data_center = cass_row_get_column_by_name(row, "data_center"); const CassValue* token_set = cass_row_get_column_by_name(row, "tokens"); CassString str; cass_value_get_string(data_center, &str.data, &str.length); std::string dc(str.data, str.length); std::string ip = cass::get_host_from_future(future.get()); test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(token_set)); while (cass_iterator_next(iterator.get())) { cass_value_get_string(cass_iterator_get_value(iterator.get()), &str.data, &str.length); std::string token(str.data, str.length); tokens[boost::lexical_cast<int64_t>(token)] = Host(ip, dc); } } }
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; }
/** * Verify the phone UDT field names * * @param value The phone UDT value to iterate over */ void verify_phone_udt_field_names(const CassValue* value) { // Ensure the value is a UDT and create the iterator for the validation BOOST_REQUIRE_EQUAL(cass_value_type(value), CASS_VALUE_TYPE_UDT); BOOST_REQUIRE_EQUAL(cass_value_item_count(value), 2); test_utils::CassIteratorPtr iterator(cass_iterator_from_user_type(value)); // Verify alias field name BOOST_REQUIRE(cass_iterator_next(iterator.get())); CassString alias_field_name; BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &alias_field_name.data, &alias_field_name.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal("alias", alias_field_name)); // Verify number field name BOOST_REQUIRE(cass_iterator_next(iterator.get())); CassString number_field_name; BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &number_field_name.data, &number_field_name.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal("number", number_field_name)); }
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++; } }
static int cassandra_results_stream_end_of_stream(void* context) { cassandra_results_stream* scontext; scontext = (cassandra_results_stream*)context; if (scontext->at_end) { if (scontext->more_pages) { CassError rc; rc = cass_statement_set_paging_state(scontext->stmt, scontext->result); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); return -1; } cass_result_free(scontext->result); scontext->result = 0; CassFuture* future = cass_session_execute(scontext->cassandra_context->session, scontext->stmt); 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 -1; } scontext->result = cass_future_get_result(future); cass_future_free(future); scontext->iter = cass_iterator_from_result(scontext->result); scontext->more_pages = cass_result_has_more_pages(scontext->result); scontext->at_end = !cass_iterator_next(scontext->iter); } } return (scontext->at_end); }
/** * Verify the phone UDT (field names and results) * * @param value The phone UDT value to iterate over * @param expected_alias Expected alias to verify against result * @param expected_number Expected number to verify against result */ void verify_phone_udt(const CassValue* value, CassString expected_alias, CassString expected_number) { // Verify field names for phone UDT and create the iterator for validation verify_phone_udt_field_names(value); test_utils::CassIteratorPtr iterator(cass_iterator_from_user_type(value)); // Verify alias result BOOST_REQUIRE(cass_iterator_next(iterator.get())); const CassValue* alias_value = cass_iterator_get_user_type_field_value(iterator.get()); BOOST_REQUIRE_EQUAL(cass_value_type(alias_value), CASS_VALUE_TYPE_VARCHAR); CassString alias_result; BOOST_REQUIRE_EQUAL(cass_value_get_string(alias_value, &alias_result.data, &alias_result.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal(alias_result, expected_alias)); // Verify number result BOOST_REQUIRE(cass_iterator_next(iterator.get())); const CassValue* number_value = cass_iterator_get_user_type_field_value(iterator.get()); BOOST_REQUIRE_EQUAL(cass_value_type(number_value), CASS_VALUE_TYPE_VARCHAR); CassString number_result; BOOST_REQUIRE_EQUAL(cass_value_get_string(number_value, &number_result.data, &number_result.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal(number_result, expected_number)); }
/** * Verify the address UDT field names * * @param value The address UDT value to iterate over */ void verify_address_udt_field_names(const CassValue* value) { // Ensure the value is a UDT and create the iterator for the validation BOOST_REQUIRE_EQUAL(cass_value_type(value), CASS_VALUE_TYPE_UDT); BOOST_REQUIRE_EQUAL(cass_value_item_count(value), 3); test_utils::CassIteratorPtr iterator(cass_iterator_from_user_type(value)); // Verify street field name BOOST_REQUIRE(cass_iterator_next(iterator.get())); CassString street_field_name; BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &street_field_name.data, &street_field_name.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal("street", street_field_name)); // Verify zip field name BOOST_REQUIRE(cass_iterator_next(iterator.get())); CassString zip_field_name; BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &zip_field_name.data, &zip_field_name.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal("ZIP", zip_field_name)); // Verify phone numbers field name BOOST_REQUIRE(cass_iterator_next(iterator.get())); CassString phone_numbers_field_name; BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &phone_numbers_field_name.data, &phone_numbers_field_name.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal("phone_numbers", phone_numbers_field_name)); }
/** * Verify the address UDT (field names and results) * * @param value The address UDT value to iterate over * @param expected_street Expected street address to verify against result * @param expected_zip Expected zip code to verify against result * @param expected_phone_numbers Expected numbers to verify against result */ void verify_address_udt(const CassValue* value, CassString expected_street, cass_int32_t expected_zip, PhoneMap expected_phone_numbers) { // Verify field names for address UDT and create the iterator for validation verify_address_udt_field_names(value); test_utils::CassIteratorPtr iterator(cass_iterator_from_user_type(value)); // Verify street result BOOST_REQUIRE(cass_iterator_next(iterator.get())); const CassValue* street_value = cass_iterator_get_user_type_field_value(iterator.get()); BOOST_REQUIRE_EQUAL(cass_value_type(street_value), CASS_VALUE_TYPE_VARCHAR); CassString street_result; BOOST_REQUIRE_EQUAL(cass_value_get_string(street_value, &street_result.data, &street_result.length), CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal(street_result, expected_street)); // Verify zip result BOOST_REQUIRE(cass_iterator_next(iterator.get())); const CassValue* zip_value = cass_iterator_get_user_type_field_value(iterator.get()); BOOST_REQUIRE_EQUAL(cass_value_type(zip_value), CASS_VALUE_TYPE_INT); cass_int32_t zip_result; BOOST_REQUIRE_EQUAL(cass_value_get_int32(zip_value, &zip_result), CASS_OK); BOOST_REQUIRE(test_utils::Value<cass_int32_t>::equal(zip_result, expected_zip)); // Verify phone numbers result BOOST_REQUIRE(cass_iterator_next(iterator.get())); const CassValue* phone_numbers_value = cass_iterator_get_user_type_field_value(iterator.get()); BOOST_REQUIRE_EQUAL(cass_value_type(phone_numbers_value), CASS_VALUE_TYPE_SET); BOOST_REQUIRE_EQUAL(cass_value_item_count(phone_numbers_value), expected_phone_numbers.size()); test_utils::CassIteratorPtr phone_numbers_iterator(cass_iterator_from_collection(phone_numbers_value)); unsigned int count = 0; PhoneMap::iterator phone_iterator = expected_phone_numbers.begin(); while (cass_iterator_next(phone_numbers_iterator.get()) && phone_iterator != expected_phone_numbers.end()) { verify_phone_udt(cass_iterator_get_value(phone_numbers_iterator.get()), phone_iterator->first, phone_iterator->second); ++phone_iterator; ++count; } BOOST_REQUIRE_EQUAL(expected_phone_numbers.size(), count); }
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(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()); } }
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; }
CassError CassandraFS::read_physical_file_info(struct stat* stat, struct cfs_attrs* cfs_attrs) { CassStatement* statement = cass_statement_new("SELECT size, block_size FROM physical_files WHERE id = ?", 1); cass_statement_bind_uuid(statement, 0, cfs_attrs->physical_file_id); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); CassError error = cass_future_error_code(result_future); if (error == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* size_value = cass_row_get_column_by_name(row, "size"); if (!cass_value_is_null(size_value)) { cass_int64_t size; cass_value_get_int64(size_value, &size); stat->st_size = size; } const CassValue* block_size_value = cass_row_get_column_by_name(row, "block_size"); if (!cass_value_is_null(block_size_value)) { int size; cass_value_get_int32(block_size_value, &size); cfs_attrs->block_size = size; } } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ cassandra_log_error(result_future); } cass_future_free(result_future); return error; }
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_by_name(statement, "key", 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_by_name(row, "BLN"), &basic->bln); cass_value_get_double(cass_row_get_column_by_name(row, "dbl"), &basic->dbl); cass_value_get_float(cass_row_get_column_by_name(row, "flt"), &basic->flt); cass_value_get_int32(cass_row_get_column_by_name(row, "\"i32\""), &basic->i32); cass_value_get_int64(cass_row_get_column_by_name(row, "i64"), &basic->i64); } cass_result_free(result); cass_iterator_free(iterator); } cass_future_free(future); cass_statement_free(statement); return rc; }
/** * Check to see if a query has been prepared on a given node. * * @param node The node to check * @param query A query string * @return true if the query has been prepared on the node, otherwise false */ bool prepared_statement_is_present(int node, const std::string& query) { test_utils::CassResultPtr result; test_utils::execute_query(session_for_node(node).get(), "SELECT * FROM system.prepared_statements", &result); 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()); BOOST_REQUIRE(row); const CassValue* query_column = cass_row_get_column_by_name(row, "query_string"); const char* query_string; size_t query_string_len; BOOST_REQUIRE_EQUAL(cass_value_get_string(query_column, &query_string, &query_string_len), CASS_OK); if (query == std::string(query_string, query_string_len)) { return true; } } return false; }
CassError select_from_basic(CassSession* session, const CassPrepared * prepared, const char* key, Basic* basic) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; statement = cass_prepared_bind(prepared); 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 ); } }
int main(int argc, char* argv[]) { /* Setup and connect to cluster */ CassFuture* connect_future = NULL; CassCluster* cluster = cass_cluster_new(); CassSession* session = cass_session_new(); char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } /* Add contact points */ cass_cluster_set_contact_points(cluster, hosts); /* Provide the cluster object as configuration to connect the session */ connect_future = cass_session_connect(session, cluster); if (cass_future_error_code(connect_future) == CASS_OK) { CassFuture* close_future = NULL; /* Build statement and execute query */ const char* query = "SELECT keyspace_name " "FROM system.schema_keyspaces;"; CassStatement* statement = cass_statement_new(query, 0); CassFuture* result_future = cass_session_execute(session, statement); if (cass_future_error_code(result_future) == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); while (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* value = cass_row_get_column_by_name(row, "keyspace_name"); const char* keyspace_name; size_t keyspace_name_length; cass_value_get_string(value, &keyspace_name, &keyspace_name_length); printf("keyspace_name: '%.*s'\n", (int)keyspace_name_length, keyspace_name); } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ const char* message; size_t message_length; cass_future_error_message(result_future, &message, &message_length); fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length, message); } cass_statement_free(statement); cass_future_free(result_future); /* Close the session */ close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); } else { /* Handle error */ const char* message; size_t message_length; cass_future_error_message(connect_future, &message, &message_length); fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message); } cass_future_free(connect_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
/** * 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; }
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(); }
int CassandraFS::hardlink(const char* from, const char* to) { int operation_done = 0; CassStatement* statement = cass_statement_new("SELECT mode, created_at, modified_at, physical_file_id FROM entries WHERE path = ?", 1); cass_statement_bind_string(statement, 0, from); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); int error = 0; if (cass_future_error_code(result_future) == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* mode_value = cass_row_get_column_by_name(row, "mode"); const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at"); const CassValue* created_at_value = cass_row_get_column_by_name(row, "created_at"); const CassValue* physical_file_id_value = cass_row_get_column_by_name(row, "physical_file_id"); int mode; cass_value_get_int32(mode_value, &mode); cass_int64_t modified_at; cass_value_get_int64(modified_at_value, &modified_at); cass_int64_t created_at; cass_value_get_int64(created_at_value, &created_at); CassUuid physical_file_id; cass_value_get_uuid(physical_file_id_value, &physical_file_id); CassStatement* insert_statement = cass_statement_new("INSERT INTO entries(path, mode, created_at, modified_at, physical_file_id) VALUES(?,?,?,?,?)", 5); cass_statement_bind_string(insert_statement, 0, to); cass_statement_bind_int32(insert_statement, 1, mode); cass_statement_bind_int64(insert_statement, 2, created_at); cass_statement_bind_int64(insert_statement, 3, modified_at); cass_statement_bind_uuid(insert_statement, 4, physical_file_id); CassFuture* insert_future2 = create_sub_entry(to); CassFuture* insert_future = cass_session_execute(ctxt->session, insert_statement); cass_statement_free(insert_statement); if (cass_future_error_code(insert_future) == CASS_OK) { operation_done = 1; } else { operation_done = 0; cassandra_log_error(insert_future); } if (cass_future_error_code(insert_future2) == CASS_OK) { operation_done = 1; } else { operation_done = 0; cassandra_log_error(insert_future2); } cass_future_free(insert_future); cass_future_free(insert_future2); } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ error = -EIO; cassandra_log_error(result_future); } cass_future_free(result_future); if (!operation_done) { return -ENOENT; } return error; }
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); }
int CassandraFS::getattr(const char* path, struct stat *stbuf, struct cfs_attrs *cfs_attrs) { int found = 0; memset(stbuf, 0, sizeof(struct stat)); memset(cfs_attrs, 0, sizeof(struct cfs_attrs)); CassStatement* statement = cass_statement_new("SELECT mode, modified_at, physical_file_id FROM entries WHERE path = ?", 1); cass_statement_bind_string(statement, 0, path); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); int error = 0; if (cass_future_error_code(result_future) == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* value = cass_row_get_column_by_name(row, "mode"); const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at"); int mode; cass_value_get_int32(value, &mode); stbuf->st_mode = mode; // regular file if (S_ISREG(mode)) { const CassValue* file_id_value = cass_row_get_column_by_name(row, "physical_file_id"); if (!cass_value_is_null(file_id_value)) { cass_value_get_uuid(file_id_value, &(cfs_attrs->physical_file_id)); } CassError phys_err = read_physical_file_info(stbuf, cfs_attrs); if (phys_err != CASS_OK) { error = -EIO; } } if (!cass_value_is_null(modified_at_value)) { cass_int64_t modified_at; cass_value_get_int64(modified_at_value, &modified_at); stbuf->st_mtime = modified_at / 1000; } stbuf->st_nlink = 1; found = 1; } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ error = -EIO; cassandra_log_error(result_future); } cass_future_free(result_future); if (!found) { return -ENOENT; } return error; }
CassError select_from_udt(CassSession* session) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "SELECT * FROM examples.udt"; statement = cass_statement_new(query, 0); 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 = NULL; CassIterator* rows = NULL; result = cass_future_get_result(future); rows = cass_iterator_from_result(result); while(cass_iterator_next(rows)) { CassUuid id; char id_str[CASS_UUID_STRING_LENGTH]; const CassRow* row = cass_iterator_get_row(rows); const CassValue* id_value = cass_row_get_column_by_name(row, "id"); const CassValue* address_value = cass_row_get_column_by_name(row, "address"); CassIterator* fields = cass_iterator_fields_from_user_type(address_value); cass_value_get_uuid(id_value, &id); cass_uuid_string(id, id_str); printf("id %s ", id_str); while(fields != NULL && cass_iterator_next(fields)) { const char* field_name; size_t field_name_length; const CassValue* field_value = NULL; cass_iterator_get_user_type_field_name(fields, &field_name, &field_name_length); field_value = cass_iterator_get_user_type_field_value(fields); printf("%.*s ", (int)field_name_length, field_name); if (!cass_value_is_null(field_value)) { if (cass_value_type(field_value) == CASS_VALUE_TYPE_VARCHAR) { const char* text; size_t text_length; cass_value_get_string(field_value, &text, &text_length); printf("\"%.*s\" ", (int)text_length, text); } else if (cass_value_type(field_value) == CASS_VALUE_TYPE_INT) { cass_int32_t i; cass_value_get_int32(field_value, &i); printf("%d ", i); } else if (cass_value_type(field_value) == CASS_VALUE_TYPE_SET) { CassIterator* phone_numbers = cass_iterator_from_collection(field_value); while (cass_iterator_next(phone_numbers)) { const CassValue* phone_value = cass_iterator_get_value(phone_numbers); CassIterator* phone_fields = cass_iterator_fields_from_user_type(phone_value); assert(cass_value_type(phone_value) == CASS_VALUE_TYPE_UDT); while (cass_iterator_next(phone_fields)) { const CassValue* phone_number_value = cass_iterator_get_user_type_field_value(phone_fields); cass_int32_t i; cass_value_get_int32(phone_number_value, &i); printf("%d ", i); } } } else { printf("<invalid> "); } } else { printf("<null> "); } } printf("\n"); } cass_result_free(result); cass_iterator_free(rows); } cass_future_free(future); cass_statement_free(statement); return rc; }
/** * 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; }