int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); CassFuture* close_future = NULL; const Pair items[] = { { "apple", 1 }, { "orange", 2 }, { "banana", 3 }, { "mango", 4 }, { NULL, 0 } }; if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); execute_query(session, "CREATE TABLE examples.maps (key text, \ items map<text, int>, \ PRIMARY KEY (key))"); insert_into_maps(session, "test", items); select_from_maps(session, "test"); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
int main() { CassFuture* connect_future = NULL; CassCluster* cluster = cass_cluster_new(); CassSession* session = cass_session_new(); cass_cluster_set_contact_points(cluster, "127.0.0.1"); connect_future = cass_session_connect(session, cluster); if (cass_future_error_code(connect_future) == CASS_OK) { CassFuture* close_future = NULL; execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); print_keyspace(session, "examples"); execute_query(session, "CREATE TABLE examples.schema_meta (key text, \ value bigint, \ PRIMARY KEY (key));"); print_table(session, "examples", "schema_meta"); /* Close the session */ close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); } else {
int main(int argc, char* argv[]) { 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]; } cass_cluster_set_contact_points(cluster, hosts); connect_future = cass_session_connect(session, cluster); if (cass_future_error_code(connect_future) == CASS_OK) { CassFuture* close_future = NULL; execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); print_keyspace(session, "examples"); execute_query(session, "CREATE TABLE examples.schema_meta (key text, \ value bigint, \ PRIMARY KEY (key));"); execute_query(session, "CREATE FUNCTION examples.avg_state(state tuple<int, bigint>, val int) \ CALLED ON NULL INPUT RETURNS tuple<int, bigint> \ LANGUAGE java AS \ 'if (val != null) { \ state.setInt(0, state.getInt(0) + 1); \ state.setLong(1, state.getLong(1) + val.intValue()); \ } \
/** * Open a session and add it to the list of sessions opened * * @param arg Session container to add session */ static void open_session(void* arg) { SessionContainer* sessions = static_cast<SessionContainer*>(arg); test_utils::CassSessionPtr session(cass_session_new()); test_utils::CassFuturePtr session_future(cass_session_connect(session.get(), sessions->cluster)); test_utils::wait_and_check_error(session_future.get(), 20 * test_utils::ONE_SECOND_IN_MICROS); sessions->add_session(session); }
void DbCassandra::Initialize( const std::string &configPath ) { ParseConfig( configPath ); const std::string remotes = config_.get<std::string>( "remotes" ); db_ = std::make_shared<DbConnection>(); auto cluster = cass_cluster_new(); db_->SetCluster( cluster ); auto session = cass_session_new(); db_->SetSession( session ); cass_cluster_set_contact_points( cluster, remotes.c_str() ); CassFuture *connect_future = cass_session_connect( session, cluster ); const CassError err = cass_future_error_code( connect_future ); cass_future_free( connect_future ); if ( err != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); const CassPrepared *prepared = nullptr; if ( PrepareQuery( session, "INSERT INTO prun.jobs (job_id, job_descr) VALUES (?, ?);", reinterpret_cast<const CassPrepared**>( &prepared ) ) != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); db_->SetPreparedInsert( prepared ); if ( PrepareQuery( session, "DELETE FROM prun.jobs WHERE job_id = ?;", reinterpret_cast<const CassPrepared**>( &prepared ) ) != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); db_->SetPreparedDelete( prepared ); }
CassSessionPtr create_session(CassCluster* cluster, CassError* code, cass_duration_t timeout) { test_utils::CassSessionPtr session(cass_session_new()); test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster)); if (code) { *code = test_utils::wait_and_return_error(connect_future.get(), timeout); } return session; }
int main(int argc, char* argv[]) { CassCluster* cluster = NULL; CassSession* session = cass_session_new(); CassFuture* close_future = NULL; Basic input = { cass_true, 0.001f, 0.0002, 1, 2 }; Basic output; const CassPrepared* prepared = NULL; char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } cluster = create_cluster(hosts); if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); execute_query(session, "CREATE TABLE examples.basic (key text, \ bln boolean, \ flt float, dbl double,\ i32 int, i64 bigint, \ PRIMARY KEY (key));"); insert_into_basic(session, "prepared_test", &input); if (prepare_select_from_basic(session, &prepared) == CASS_OK) { select_from_basic(session, prepared, "prepared_test", &output); assert(input.bln == output.bln); assert(input.flt == output.flt); assert(input.dbl == output.dbl); assert(input.i32 == output.i32); assert(input.i64 == output.i64); cass_prepared_free(prepared); } close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
int lua_cass_session_new(lua_State* L) { fprintf(stderr, "lua_cass_session_new\n"); CassSession* session = cass_session_new(); if (!session) { return luaL_error(L, "cass_session_new call failed"); } void* ptr = lua_newuserdata(L, sizeof(CassSession*)); luaL_getmetatable(L, "CassSession"); lua_setmetatable(L, -2); memcpy(ptr, &((void*)session), sizeof(CassSession*)); return 1; }
void CCassandraLogAgent::ensureDefaultKeySpace() { CassandraSession s(cass_session_new()); CassandraFuture future1(cass_session_connect(s, cassSession->queryCluster())); future1.wait("connect without keyspace"); VStringBuffer st("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '1' };", defaultDB.str()); CassandraStatement statement(cass_statement_new(st.str(), 0)); CassandraFuture future2(cass_session_execute(s, statement)); future2.wait("execute"); s.set(NULL); }
void prepare_alter_schema_version_session() { // Create a new session for altering node2 and node3 system tables std::string ip_prefix = inst.ccm->get_ip_prefix(); std::stringstream whitelist_hosts; whitelist_hosts << ip_prefix << "2," << ip_prefix << "3"; cass_cluster_set_whitelist_filtering(inst.cluster, whitelist_hosts.str().c_str()); schema_alter_session = cass_session_new(); test_utils::CassFuturePtr connect_future(cass_session_connect(schema_alter_session, inst.cluster)); test_utils::wait_and_check_error(connect_future.get()); std::string update_peer("UPDATE system.peers SET schema_version=? WHERE peer='" + ip_prefix + "1'"); test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(schema_alter_session, update_peer.data(), update_peer.size())); test_utils::wait_and_check_error(prepared_future.get()); schema_alter_prepared = test_utils::CassPreparedPtr(cass_future_get_prepared(prepared_future.get())); }
/** * Create the session * * @param is_timeout True if for timeout tests; false otherwise */ void create_session(bool is_timeout = false) { close_session(); test_utils::CassSessionPtr session(cass_session_new()); test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster_.get())); CassError error_code = test_utils::wait_and_return_error(connect_future.get()); session_ = test_utils::create_session(cluster_.get(), &error_code); if (error_code != CASS_OK) { if (is_timeout) { if (error_code == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE) { return; } } CassString message; cass_future_error_message(connect_future.get(), &message.data, &message.length); BOOST_FAIL(std::string(message.data, message.length) << "' (" << cass_error_desc(error_code) << ")"); } }
int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); CassFuture* close_future = NULL; uuid_gen = cass_uuid_gen_new(); if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } schema_meta = cass_session_get_schema_meta(session); execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' }");
int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); CassFuture* close_future = NULL; Basic input = { cass_true, 0.001f, 0.0002, 1, 2 }; Basic output; if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); execute_query(session, "CREATE TABLE examples.basic (key text, \ bln boolean, \ flt float, dbl double,\ i32 int, i64 bigint, \ PRIMARY KEY (key));"); insert_into_basic(session, "test", &input); select_from_basic(session, "test", &output); assert(input.bln == output.bln); assert(input.flt == output.flt); assert(input.dbl == output.dbl); assert(input.i32 == output.i32); assert(input.i64 == output.i64); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
int main(int argc, char* argv[]) { CassCluster* cluster = NULL; CassSession* session = cass_session_new(); CassFuture* close_future = NULL; char* hosts = "127.0.0.1"; const char* items[] = { "apple", "orange", "banana", "mango", NULL }; cass_cluster_set_protocol_version(cluster, 2); if (argc > 1) { hosts = argv[1]; } cluster = create_cluster(hosts); if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '1' };"); execute_query(session, "CREATE TABLE examples.collections (key text, \ items set<text>, \ PRIMARY KEY (key))"); insert_into_collections(session, "test", items); select_from_collections(session, "test"); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
//Keep this for now just in case. We may remove after a few releases. void CCassandraLogAgent::ensureKeySpace() { CassandraSession s(cass_session_new()); CassandraFuture future(cass_session_connect(s, cassSession->queryCluster())); future.wait("connect without keyspace"); VStringBuffer createKeySpace("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '1' };", cassSession->queryKeySpace()); executeSimpleStatement(createKeySpace.str()); s.set(NULL); //prepare transSeedTable StringBuffer transSeedTableKeys; StringArray transSeedTableColumnNames, transSeedTableColumnTypes; transSeedTableColumnNames.append("id"); transSeedTableColumnTypes.append("int"); transSeedTableColumnNames.append("application"); transSeedTableColumnTypes.append("varchar"); transSeedTableColumnNames.append("update_time"); transSeedTableColumnTypes.append("timestamp"); transSeedTableKeys.set("application"); cassSession->connect(); createTable("transactions", transSeedTableColumnNames, transSeedTableColumnTypes, transSeedTableKeys.str()); //prepare log tables ForEachItemIn(i, logDBTables) { CDBTable& table = logDBTables.item(i); StringBuffer logTableKeys; StringArray logTableColumnNames, logTableColumnTypes; DBFieldMap* fieldMap = table.getFieldMap(); StringArray& logTableColumnNameArray = fieldMap->getMapToNames(); logTableColumnNames.append("log_id"); logTableColumnTypes.append("varchar"); ForEachItemIn(ii, logTableColumnNameArray) { logTableColumnNames.append(logTableColumnNameArray.item(ii)); logTableColumnTypes.append(fieldMap->getMapToTypes().item(ii)); }
int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); CassFuture* close_future = NULL; const CassPrepared* prepared = NULL; Pair pairs[] = { {"a", "1"}, {"b", "2"}, { NULL, NULL} }; if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); execute_query(session, "CREATE TABLE examples.pairs (key text, \ value text, \ PRIMARY KEY (key));"); if (prepare_insert_into_batch(session, &prepared) == CASS_OK) { insert_into_batch_with_prepared(session, prepared, pairs); } cass_prepared_free(prepared); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
CassError CassandraClient::connect(const std::string nodes) { CassError rc = CASS_OK; logger.information("Connecting to " + nodes); cluster = cass_cluster_new(); session = cass_session_new(); CassFuture* connect_future = NULL; // Optional: use multiple nodes for better load balancing. Just enter more IPs here /re // cass_cluster_set_contact_points(cluster, "127.0.0.1"); cass_cluster_set_contact_points(cluster, nodes.c_str()); connect_future = cass_session_connect(session, cluster); cass_future_wait(connect_future); rc = cass_future_error_code(connect_future); if (rc == CASS_OK) { logger.information("Connected!"); } else { return printError(rc); } cass_future_free(connect_future); return rc; }
int main(int argc, char* argv[]) { CassCluster* cluster = NULL; CassSession* session = cass_session_new(); CassFuture* close_future = NULL; char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } cluster = create_cluster(hosts); uuid_gen = cass_uuid_gen_new(); if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } schema_meta = cass_session_get_schema_meta(session); execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' }");
int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); CassFuture* close_future = NULL; if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); execute_query(session, "CREATE TABLE examples.async (key text, \ bln boolean, \ flt float, dbl double,\ i32 int, i64 bigint, \ PRIMARY KEY (key));"); execute_query(session, "USE examples"); insert_into_async(session, "test"); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
int main(int argc, char* argv[]) { CassCluster* cluster = NULL; CassSession* session = cass_session_new(); CassFuture* close_future = NULL; char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } cluster = create_cluster(hosts); if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "CREATE KEYSPACE examples WITH replication = { \ 'class': 'SimpleStrategy', 'replication_factor': '3' };"); execute_query(session, "CREATE TABLE examples.date_time (key text PRIMARY KEY, d date, t time)"); insert_into(session, "test"); select_from(session, "test"); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
/** * Create the Cassandra cluster, initialize the cpp-driver cluster, and create * the connection to the cluster. * * @param is_ssl True if SSL should be enabled on Cassandra cluster; false * otherwise (default: true) * @param is_client_authentication True if client authentication should be * enabled on Cassandra cluster; false otherwise * (default: false) * @param is_failure True if test is supposed to fail; false otherwise * (default: false) * @param nodes Number of nodes for the cluster (default: 1) */ void setup(bool is_ssl = true, bool is_client_authentication = false, bool is_failure = false, unsigned int nodes = 1) { //Create a n-node cluster ccm_->create_cluster(nodes, 0, false, is_ssl, is_client_authentication); ccm_->start_cluster(); //Initialize the cpp-driver cluster_ = cass_cluster_new(); test_utils::initialize_contact_points(cluster_, ccm_->get_ip_prefix(), nodes); cass_cluster_set_connect_timeout(cluster_, 10000); cass_cluster_set_request_timeout(cluster_, 10000); cass_cluster_set_num_threads_io(cluster_, 1); cass_cluster_set_core_connections_per_host(cluster_, 2); cass_cluster_set_max_connections_per_host(cluster_, 4); cass_cluster_set_ssl(cluster_, ssl_); //Establish the connection (if ssl) session_ = cass_session_new(); connect_future_ = cass_session_connect(session_, cluster_); if (!is_failure) { test_utils::wait_and_check_error(connect_future_); } else { BOOST_REQUIRE(!cass_future_wait_timed(connect_future_, 2000)); //Ensure the wait is long enough for slow machines } }
int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); uuid_gen = cass_uuid_gen_new(); uv_mutex_init(&mutex); uv_cond_init(&cond); connect_session(session, cluster, on_session_connect); /* Code running in parallel with queries */ wait_exit(); uv_cond_destroy(&cond); uv_mutex_destroy(&mutex); cass_cluster_free(cluster); cass_uuid_gen_free(uuid_gen); 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; }
void new_session() { close_session(); session = cass_session_new(); test_utils::CassFuturePtr connect_future(cass_session_connect(session, inst.cluster)); test_utils::wait_and_check_error(connect_future.get()); }
PHP_METHOD(DefaultCluster, connectAsync) { char* hash_key; int hash_key_len = 0; char* keyspace = NULL; int keyspace_len; cassandra_cluster* cluster = NULL; cassandra_future_session* future = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &keyspace, &keyspace_len) == FAILURE) { return; } cluster = (cassandra_cluster*) zend_object_store_get_object(getThis() TSRMLS_CC); object_init_ex(return_value, cassandra_future_session_ce); future = (cassandra_future_session*) zend_object_store_get_object(return_value TSRMLS_CC); future->persist = cluster->persist; if (cluster->persist) { zend_rsrc_list_entry *le; hash_key_len = spprintf(&hash_key, 0, "%s:session:%s", cluster->hash_key, SAFE_STR(keyspace)); future->hash_key = hash_key; future->hash_key_len = hash_key_len; if (zend_hash_find(&EG(persistent_list), hash_key, hash_key_len + 1, (void **)&le) == SUCCESS) { if (Z_TYPE_P(le) == php_le_cassandra_session()) { cassandra_psession* psession = (cassandra_psession*) le->ptr; future->session = psession->session; future->future = psession->future; return; } } } future->session = cass_session_new(); if (keyspace) { future->future = cass_session_connect_keyspace(future->session, cluster->cluster, keyspace); } else { future->future = cass_session_connect(future->session, cluster->cluster); } if (cluster->persist) { zend_rsrc_list_entry le; cassandra_psession* psession = (cassandra_psession*) pecalloc(1, sizeof(cassandra_psession), 1); psession->session = future->session; psession->future = future->future; le.type = php_le_cassandra_session(); le.ptr = psession; zend_hash_update(&EG(persistent_list), hash_key, hash_key_len + 1, &le, sizeof(zend_rsrc_list_entry), NULL); CASSANDRA_G(persistent_sessions)++; } }
CassandraSession createSession() { return CassandraSession(cass_session_new(), cass_session_free); }
/* functions implementing storage api */ static int librdf_storage_cassandra_init(librdf_storage* storage, const char *name, librdf_hash* options) { char *name_copy; librdf_storage_cassandra_instance* context; if(!name) { if(options) librdf_free_hash(options); return 1; } context = LIBRDF_CALLOC(librdf_storage_cassandra_instance*, 1, sizeof(*context)); if(!context) { if(options) librdf_free_hash(options); return 1; } librdf_storage_set_instance(storage, context); context->storage = storage; context->name_len = strlen(name); // context->transaction = 0; name_copy = LIBRDF_MALLOC(char*, context->name_len + 1); if(!name_copy) { if(options) librdf_free_hash(options); return 1; } strcpy(name_copy, name); context->name = name_copy; // Add options here. /* no more options, might as well free them now */ if(options) librdf_free_hash(options); // FIXME: Hard-coded; context->session = cass_session_new(); context->cluster = cass_cluster_new(); cass_cluster_set_contact_points(context->cluster, name); CassFuture* future = cass_session_connect(context->session, context->cluster); CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); cass_cluster_free(context->cluster); cass_session_free(context->session); free(context->name); free(context); return 1; } cass_future_free(future); 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(); 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; }
PHP_METHOD(DefaultCluster, connect) { CassFuture* future = NULL; char* hash_key; int hash_key_len = 0; char* keyspace = NULL; int keyspace_len; zval* timeout = NULL; cassandra_psession* psession; cassandra_cluster* cluster = NULL; cassandra_session* session = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &keyspace, &keyspace_len, &timeout) == FAILURE) { return; } cluster = (cassandra_cluster*) zend_object_store_get_object(getThis() TSRMLS_CC); object_init_ex(return_value, cassandra_default_session_ce); session = (cassandra_session*) zend_object_store_get_object(return_value TSRMLS_CC); session->default_consistency = cluster->default_consistency; session->default_page_size = cluster->default_page_size; session->default_timeout = cluster->default_timeout; session->persist = cluster->persist; if (session->default_timeout) { Z_ADDREF_P(session->default_timeout); } if (session->persist) { zend_rsrc_list_entry *le; hash_key_len = spprintf(&hash_key, 0, "%s:session:%s", cluster->hash_key, SAFE_STR(keyspace)); if (zend_hash_find(&EG(persistent_list), hash_key, hash_key_len + 1, (void **)&le) == SUCCESS && Z_TYPE_P(le) == php_le_cassandra_session()) { psession = (cassandra_psession*) le->ptr; session->session = psession->session; future = psession->future; } } if (future == NULL) { session->session = cass_session_new(); if (keyspace) { future = cass_session_connect_keyspace(session->session, cluster->cluster, keyspace); } else { future = cass_session_connect(session->session, cluster->cluster); } if (session->persist) { zend_rsrc_list_entry pe; psession = (cassandra_psession*) pecalloc(1, sizeof(cassandra_psession), 1); psession->session = session->session; psession->future = future; pe.type = php_le_cassandra_session(); pe.ptr = psession; zend_hash_update(&EG(persistent_list), hash_key, hash_key_len + 1, &pe, sizeof(zend_rsrc_list_entry), NULL); CASSANDRA_G(persistent_sessions)++; } } if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) { if (session->persist) { efree(hash_key); } else { cass_future_free(future); } return; } if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) { if (session->persist) { if (zend_hash_del(&EG(persistent_list), hash_key, hash_key_len + 1) == SUCCESS) { session->session = NULL; } efree(hash_key); } else { cass_future_free(future); } return; } if (session->persist) efree(hash_key); }
int main() { int i; CassMetrics metrics; uv_thread_t threads[NUM_THREADS]; CassCluster* cluster = NULL; CassSession* session = NULL; CassFuture* close_future = NULL; status_init(&status, NUM_THREADS); cass_log_set_level(CASS_LOG_INFO); cluster = create_cluster(); uuid_gen = cass_uuid_gen_new(); session = cass_session_new(); if (connect_session(session, cluster) != CASS_OK) { cass_cluster_free(cluster); cass_session_free(session); return -1; } execute_query(session, "INSERT INTO songs (id, title, album, artist, tags) VALUES " "(a98d21b2-1900-11e4-b97b-e5e358e71e0d, " "'La Petite Tonkinoise', 'Bye Bye Blackbird', 'Joséphine Baker', { 'jazz', '2013' });"); for (i = 0; i < NUM_THREADS; ++i) { #if DO_SELECTS uv_thread_create(&threads[i], run_select_queries, (void*)session); #else uv_thread_create(&threads[i], run_insert_queries, (void*)session); #endif } while (status_wait(&status, 5) > 0) { cass_session_get_metrics(session, &metrics); printf("rate stats (requests/second): mean %f 1m %f 5m %f 10m %f\n", metrics.requests.mean_rate, metrics.requests.one_minute_rate, metrics.requests.five_minute_rate, metrics.requests.fifteen_minute_rate); } cass_session_get_metrics(session, &metrics); printf("final stats (microseconds): min %llu max %llu median %llu 75th %llu 95th %llu 98th %llu 99th %llu 99.9th %llu\n", (unsigned long long int)metrics.requests.min, (unsigned long long int)metrics.requests.max, (unsigned long long int)metrics.requests.median, (unsigned long long int)metrics.requests.percentile_75th, (unsigned long long int)metrics.requests.percentile_95th, (unsigned long long int)metrics.requests.percentile_98th, (unsigned long long int)metrics.requests.percentile_99th, (unsigned long long int)metrics.requests.percentile_999th); for (i = 0; i < NUM_THREADS; ++i) { uv_thread_join(&threads[i]); } close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); cass_uuid_gen_free(uuid_gen); status_destroy(&status); return 0; }