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()));
}
}
/**
* 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));
}
/**
* 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));
}
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;
}
