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); } } }
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; }
/** * 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)); }
/** * 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)); }
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 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++; } }
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; }
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; }
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; }
static const CassValue* getSingleResult(const CassResult* result) { const CassRow* row = cass_result_first_row(result); return row ? cass_row_get_column(row, 0) : NULL; }