CassDriver::~CassDriver() {
cass_prepared_free(insert_prepared_);
cass_prepared_free(select_prepared_);
cass_prepared_free(delete_prepared_);
CassFuture* close_future = cass_session_close(session_);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster_);
}
DbConnection::~DbConnection()
{
if ( session_ )
cass_session_free( session_ );
if ( cluster_ )
cass_cluster_free( cluster_ );
if ( prepared_insert_ )
cass_prepared_free( prepared_insert_ );
if ( prepared_delete_ )
cass_prepared_free( prepared_delete_ );
}
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;
}
void run_select_queries(void* data) {
int i;
CassSession* session = (CassSession*)data;
const CassPrepared* select_prepared = NULL;
const char* select_query = "SELECT * FROM songs WHERE id = a98d21b2-1900-11e4-b97b-e5e358e71e0d";
#if USE_PREPARED
if (prepare_query(session, select_query, &select_prepared) == CASS_OK) {
#endif
for (i = 0; i < NUM_ITERATIONS; ++i) {
select_from_perf(session, select_query, select_prepared);
}
#if USE_PREPARED
cass_prepared_free(select_prepared);
}
#endif
status_notify(&status);
}
void run_insert_queries(void* data) {
int i;
CassSession* session = (CassSession*)data;
const CassPrepared* insert_prepared = NULL;
const char* insert_query = "INSERT INTO songs (id, title, album, artist, tags) VALUES (?, ?, ?, ?, ?);";
#if USE_PREPARED
if (prepare_query(session, insert_query, &insert_prepared) == CASS_OK) {
#endif
for (i = 0; i < NUM_ITERATIONS; ++i) {
insert_into_perf(session, insert_query, insert_prepared);
}
#if USE_PREPARED
cass_prepared_free(insert_prepared);
}
#endif
status_notify(&status);
}
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;
}
inline ~CassandraPrepared()
{
if (prepared)
cass_prepared_free(prepared);
}
void InsertThread::run() {
// CONNECT TO CASSANDRA
CassCluster* cluster;
CassSession* session;
if (!CassConnectToKeyspace("127.0.0.1", "chaos", "'class': 'SimpleStrategy', 'replication_factor': 1", &cluster, &session)) {
// free resources
CassFreeClusterAndSession(cluster, session);
return;
}// if error ...
// INSERTING NUMBERS
const CassPrepared *preparedInsert = NULL;
CassFuture* prefuture = cass_session_prepare(session, "INSERT INTO test (group, num, minimize) VALUES (?, ?, ?) IF NOT EXISTS");
cass_future_wait(prefuture);
CassError prerc = cass_future_error_code(prefuture);
if (prerc != CASS_OK) {
CassPrintError(prefuture);
// free resources
cass_future_free(prefuture);
CassFreeClusterAndSession(cluster, session);
return;
} else
preparedInsert = cass_future_get_prepared(prefuture);
cass_future_free(prefuture);
int group;
unsigned long minimize;
CassStatement* statement;
CassFuture* future;
CassError rcI;
while (GetNextNum()) {
group = num % 1000000;
minimize = num;
statement = cass_prepared_bind(preparedInsert);
cass_statement_bind_int32(statement, 0, group);
cass_statement_bind_int64(statement, 1, num);
cass_statement_bind_int64(statement, 2, minimize);
future = cass_session_execute(session, statement);
cass_future_wait(future);
rcI = cass_future_error_code(future);
if (rcI != CASS_OK) {
CassPrintError(future);
}// if error ...
cass_future_free(future);
cass_statement_free(statement);
// stop loop on error
if (rcI != CASS_OK) break;
// show progress on console
if ((num % 3751) == 0) printf("%lu\n", num);
}// foreach num ...
// free resources
cass_prepared_free(preparedInsert);
CassFreeClusterAndSession(cluster, session);
}
void operator()(const CassPrepared* ptr) {
if (ptr != NULL) {
cass_prepared_free(ptr);
}
}
