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); } } }
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; } }
/** * Test established connection with a high load query */ void test_high_load() { //Create and use the simple keyspace test_utils::execute_query(session_, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1")); test_utils::execute_query(session_, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE)); //Create a table to fill with large text fields test_utils::execute_query(session_, "CREATE TABLE high_load (key int PRIMARY KEY, a text, b text, c text)"); //Perform queries and validate inserted data for (int n = 0; n < NUMBER_OF_ITERATIONS; ++n) { std::string text_a = test_utils::generate_random_string(10240); std::string text_b = test_utils::generate_random_string(20480); std::string text_c = test_utils::generate_random_string(40960); test_utils::execute_query(session_, str(boost::format("INSERT INTO high_load (key, a, b, c) VALUES (%d, '%s', '%s', '%s')") % n % text_a % text_b % text_c)); test_utils::CassResultPtr result; test_utils::execute_query(session_, str(boost::format("SELECT * FROM high_load WHERE key = %d") % n), &result); BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4u); BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1u); const CassRow* row = cass_result_first_row(result.get()); const CassValue* value; value = cass_row_get_column_by_name(row, "key"); BOOST_REQUIRE(value != NULL); cass_int32_t key; BOOST_REQUIRE_EQUAL(cass_value_get_int32(value, &key), CASS_OK); BOOST_CHECK_EQUAL(key, n); value = cass_row_get_column_by_name(row, "a"); BOOST_REQUIRE(value != NULL); CassString a; BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &a.data, &a.length), CASS_OK); BOOST_CHECK(test_utils::Value<CassString>::equal(a, CassString(text_a.c_str()))); value = cass_row_get_column_by_name(row, "b"); BOOST_REQUIRE(value != NULL); CassString b; BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &b.data, &b.length), CASS_OK); BOOST_CHECK(test_utils::Value<CassString>::equal(b, CassString(text_b.c_str()))); value = cass_row_get_column_by_name(row, "c"); BOOST_REQUIRE(value != NULL); CassString c; BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &c.data, &c.length), CASS_OK); BOOST_CHECK(test_utils::Value<CassString>::equal(c, CassString(text_c.c_str()))); } //Drop the table and keyspace test_utils::execute_query(session_, "DROP TABLE high_load"); test_utils::execute_query(session_, str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE)); }
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++; } }
/** * 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)); }
/** * Test established connection with a normal load query */ void test_normal_load() { //Create and use the simple keyspace test_utils::execute_query(session_, str(boost::format(test_utils::CREATE_KEYSPACE_SIMPLE_FORMAT) % test_utils::SIMPLE_KEYSPACE % "1")); test_utils::execute_query(session_, str(boost::format("USE %s") % test_utils::SIMPLE_KEYSPACE)); //Create a table to fill with numbers and characters test_utils::execute_query(session_, "CREATE TABLE normal_load (key int PRIMARY KEY, a int, b float, c text)"); //Perform queries and validate inserted data for (int n = 0; n < NUMBER_OF_ITERATIONS; ++n) { std::string text = test_utils::generate_random_string(16); test_utils::execute_query(session_, str(boost::format("INSERT INTO normal_load (key, a, b, c) VALUES (%d, %d, %f, '%s')") % n % (n * 100) % (n * .001f) % text)); test_utils::CassResultPtr result; test_utils::execute_query(session_, str(boost::format("SELECT * FROM normal_load WHERE key = %d") % n), &result); BOOST_REQUIRE_EQUAL(cass_result_column_count(result.get()), 4u); BOOST_REQUIRE_EQUAL(cass_result_row_count(result.get()), 1u); const CassRow* row = cass_result_first_row(result.get()); const CassValue* value; value = cass_row_get_column_by_name(row, "key"); BOOST_REQUIRE(value != NULL); cass_int32_t key; BOOST_REQUIRE_EQUAL(cass_value_get_int32(value, &key), CASS_OK); BOOST_CHECK_EQUAL(key, n); value = cass_row_get_column_by_name(row, "a"); BOOST_REQUIRE(value != NULL); cass_int32_t a; BOOST_REQUIRE_EQUAL(cass_value_get_int32(value, &a), CASS_OK); BOOST_CHECK_EQUAL(a, (n * 100)); value = cass_row_get_column_by_name(row, "b"); BOOST_REQUIRE(value != NULL); cass_float_t b; BOOST_REQUIRE_EQUAL(cass_value_get_float(value, &b), CASS_OK); BOOST_CHECK_EQUAL(b, (n * .001f)); value = cass_row_get_column_by_name(row, "c"); BOOST_REQUIRE(value != NULL); CassString c; BOOST_REQUIRE_EQUAL(cass_value_get_string(value, &c.data, &c.length), CASS_OK); BOOST_CHECK(test_utils::Value<CassString>::equal(c, CassString(text.c_str()))); } //Drop the table and keyspace test_utils::execute_query(session_, "DROP TABLE normal_load"); test_utils::execute_query(session_, str(boost::format("DROP KEYSPACE %s") % test_utils::SIMPLE_KEYSPACE)); }
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_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; }
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; }
PHP_METHOD(DefaultColumn, isStatic) { cassandra_column *self; const CassValue *value; const char *str; size_t str_len; if (zend_parse_parameters_none() == FAILURE) { return; } self = PHP_CASSANDRA_GET_COLUMN(getThis()); value = cass_column_meta_field_by_name(self->meta, "type"); ASSERT_SUCCESS_BLOCK(cass_value_get_string(value, &str, &str_len), RETURN_FALSE; );
CassVersion get_version(CassSession* session) { // Execute the version query CassResultPtr result; execute_query(session, SELECT_VERSION, &result); // Only one row should be returned; get the first row const CassRow *row = cass_result_first_row(result.get()); // Convert the release_version value to a string const CassValue* value = cass_row_get_column_by_name(row, "release_version"); CassString version_string; cass_value_get_string(value, &version_string.data, &version_string.length); // Parse the version string and return the Cassandra version CassVersion version; std::string str(version_string.data, version_string.length); // Needed for null termination sscanf(str.c_str(), "%hu.%hu.%hu-%s", &version.major, &version.minor, &version.patch, version.extra); return version; }
PHP_METHOD(DefaultColumn, isStatic) { cassandra_column* self; const CassSchemaMetaField* field; const CassValue* value; const char* str; size_t str_len; if (zend_parse_parameters_none() == FAILURE) { return; } self = (cassandra_column*) zend_object_store_get_object(getThis() TSRMLS_CC); field = cass_schema_meta_get_field(self->meta, "type"); value = cass_schema_meta_field_value(field); ASSERT_SUCCESS_BLOCK(cass_value_get_string(value, &str, &str_len), RETURN_FALSE; );
/** * 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; }
/** * 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); }
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; }
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(); CassSsl* ssl = cass_ssl_new(); char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } cass_cluster_set_contact_points(cluster, hosts); /* Only verify the certification and not the identity */ cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_PEER_CERT); if (!load_trusted_cert_file("cert.pem", ssl)) { fprintf(stderr, "Failed to load certificate disabling peer verification\n"); cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_NONE); } cass_cluster_set_ssl(cluster, ssl); 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 release_version FROM system.local"; 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 get the first row */ const CassResult* result = cass_future_get_result(result_future); const CassRow* row = cass_result_first_row(result); if (row) { const CassValue* value = cass_row_get_column_by_name(row, "release_version"); const char* release_version; size_t release_version_length; cass_value_get_string(value, &release_version, &release_version_length); printf("release_version: '%.*s'\n", (int)release_version_length, release_version); } cass_result_free(result); } 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); cass_ssl_free(ssl); return 0; }
php_cassandra_create_column(cassandra_ref *schema, cassandra_column_meta *meta TSRMLS_DC) { php5to7_zval result; cassandra_column *column; const CassValue *value; const char *validator; size_t validator_length; PHP5TO7_ZVAL_UNDEF(result); value = cass_column_meta_field_by_name(meta, "validator"); ASSERT_SUCCESS_VALUE(cass_value_get_string(value, &validator, &validator_length), result); PHP5TO7_ZVAL_MAYBE_MAKE(result); object_init_ex(PHP5TO7_ZVAL_MAYBE_P(result), cassandra_default_column_ce); column = PHP_CASSANDRA_GET_COLUMN(PHP5TO7_ZVAL_MAYBE_P(result)); ASSERT_SUCCESS_BLOCK(php_cassandra_get_column_field(meta, "column_name", &column->name TSRMLS_CC), zval_ptr_dtor(&result); PHP5TO7_ZVAL_UNDEF(result); return result; ); if (php_cassandra_parse_column_type(validator, validator_length, &column->reversed, &column->frozen,
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; }
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 CassError get(const CassValue* value, CassString* output) { return cass_value_get_string(value, &output->data, &output->length); }