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(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; }
/** * Author: Joel Denke * Description: Connect client to server * Params: connection Struct to save connection data to * server_ip Server ip */ int clientConnect(connection_data * connection, char * server_ip) { int result1, result2; uint16_t server_port = 1025; srand(time(NULL)); uint16_t client_port = (1026 + rand() % (5000 - 1026)); printf("Client port: %d\n", client_port); printf("--------- Start trying to connect client: %p -----------\n", connection); printf("Server_ip: %s (%d)\n", server_ip, (int)strlen(server_ip)); return connect_session(connection, server_ip, server_port, client_port); }
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; }
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; }
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() { 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[]) { 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; }
struct session *new_session(struct session *ses, char *name, char *arg, int desc) { int cnt = 0; char host[BUFFER_SIZE], port[BUFFER_SIZE], file[BUFFER_SIZE]; struct session *newsession; push_call("new_session(%p,%p,%p,%d)",ses,name,arg,desc); if (HAS_BIT(gtd->flags, TINTIN_FLAG_TERMINATE)) { pop_call(); return ses; } arg = sub_arg_in_braces(ses, arg, host, GET_ONE, SUB_VAR|SUB_FUN); arg = sub_arg_in_braces(ses, arg, port, GET_ONE, SUB_VAR|SUB_FUN); arg = sub_arg_in_braces(ses, arg, file, GET_ONE, SUB_VAR|SUB_FUN); if (desc == 0) { if (*host == 0) { tintin_puts(ses, "#HEY! SPECIFY AN ADDRESS WILL YOU?"); pop_call(); return ses; } if (*port == 0) { tintin_puts(ses, "#HEY! SPECIFY A PORT NUMBER WILL YOU?"); pop_call(); return ses; } } for (newsession = gts ; newsession ; newsession = newsession->next) { if (!strcmp(newsession->name, name)) { tintin_puts(ses, "THERE'S A SESSION WITH THAT NAME ALREADY."); pop_call(); return ses; } } newsession = (struct session *) calloc(1, sizeof(struct session)); newsession->name = strdup(name); newsession->host = strdup(host); newsession->ip = strdup(""); newsession->port = strdup(port); newsession->group = strdup(gts->group); newsession->flags = gts->flags; newsession->telopts = gts->telopts; newsession->auto_tab = gts->auto_tab; newsession->cmd_color = strdup(gts->cmd_color); newsession->read_max = gts->read_max; newsession->read_buf = (unsigned char *) calloc(1, gts->read_max); LINK(newsession, gts->next, gts->prev); for (cnt = 0 ; cnt < LIST_MAX ; cnt++) { newsession->list[cnt] = copy_list(newsession, gts->list[cnt], cnt); } newsession->rows = gts->rows; newsession->cols = gts->cols; newsession->top_row = gts->top_row; newsession->bot_row = gts->bot_row; init_buffer(newsession, gts->scroll_max); if (desc) { tintin_printf(ses, "#TRYING TO LAUNCH '%s' RUNNING '%s'.", newsession->name, newsession->host); } else { tintin_printf(ses, "#TRYING TO CONNECT '%s' TO '%s' PORT '%s'.", newsession->name, newsession->host, newsession->port); } gtd->ses = newsession; dirty_screen(newsession); if (desc == 0) { newsession = connect_session(newsession); } else { SET_BIT(newsession->flags, SES_FLAG_CONNECTED|SES_FLAG_RUN); SET_BIT(newsession->telopts, TELOPT_FLAG_SGA); DEL_BIT(newsession->telopts, TELOPT_FLAG_ECHO); gtd->ses = newsession; gtd->ses->socket = desc; } if (newsession) { if (*file) { do_read(newsession, file); } } pop_call(); return gtd->ses; }
int main() { char sql[1024]; time_t start, stop; FILE *fp = fopen("/Users/carybourgeois/flights_exercise/flights_from_pg.csv", "r") ; CassError rc = CASS_OK; CassCluster* cluster = create_cluster(); CassSession* session = NULL; CassFuture* close_future = NULL; rc = connect_session(cluster, &session); if(rc != CASS_OK) { return -1; } execute_stmt(session, "CREATE KEYSPACE IF NOT EXISTS exercise WITH \ replication = {'class': 'SimpleStrategy','replication_factor': '1'};"); execute_stmt(session, "USE exercise;"); execute_stmt(session, "DROP TABLE IF EXISTS flights;"); execute_stmt(session, "CREATE TABLE flights ( \ id int, year int, day_of_month int, fl_date varchar, \ airline_id int, carrier varchar, fl_num int, origin_airport_id int, \ origin varchar, origin_city_name varchar, origin_state_abr varchar, dest varchar, \ dest_city_name varchar, dest_state_abr varchar, dep_time int, arr_time int, \ actual_elapsed_time int, air_time int, distance int, air_time_grp int, \ PRIMARY KEY (carrier, origin, air_time_grp, id));"); time(&start); if ( fp != NULL ) { int i = 0; while(!feof(fp)) { i++; fscanf(fp, "%d, %d, %d, %[^,], %d, %[^,], %d, %d, %[^,], %[^,], %[^,], %[^,], %[^,], %[^,], %d, %d, %d, %d, %d \n", &Flight.id, &Flight.year, &Flight.day_of_month, Flight.fl_date, &Flight.airline_id, Flight.carrier, &Flight.fl_num, &Flight.origin_airport_id, Flight.origin, Flight.origin_city_name, Flight.origin_state_abr, Flight.dest, Flight.dest_city_name, Flight.dest_state_abr, &Flight.dep_time, &Flight.arr_time, &Flight.actual_elapsed_time, &Flight.air_time, &Flight.distance); sprintf(sql, "INSERT INTO flights (id, year, day_of_month, fl_date, airline_id, carrier, fl_num, origin_airport_id, origin, origin_city_name, origin_state_abr, dest, dest_city_name, dest_state_abr, dep_time, arr_time, actual_elapsed_time, air_time, distance, air_time_grp) VALUES (%d, %d, %d, \'%s\', %d, \'%s\', %d, %d, \'%s\', \'%s\', \'%s\', \'%s\', \'%s\', \'%s\', %d, %d, %d, %d, %d, %d);\n", Flight.id, Flight.year, Flight.day_of_month, Flight.fl_date, Flight.airline_id, Flight.carrier, Flight.fl_num, Flight.origin_airport_id, Flight.origin, Flight.origin_city_name, Flight.origin_state_abr, Flight.dest, Flight.dest_city_name, Flight.dest_state_abr, Flight.dep_time, Flight.arr_time, Flight.actual_elapsed_time, Flight.air_time, Flight.distance, Flight.air_time/10 ); /* printf("%s", sql); */ execute_stmt(session, sql); /* if (i > 999) break; */ } /* EOF */ printf("%d Records loaded.\n", i); } /* File exists */ time(&stop); printf("%.f Seconds total load time.\n", difftime(start, stop)); close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); cass_cluster_free(cluster); fclose( fp ); return 0; }
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; }