static void ClearDatabase(Upload& upload) { DatabaseSession session; std::string str = "delete from uploadchunks where model_id = ? and upload_id = ?"; CassStatement* statement = cass_statement_new(str.c_str(), 2); cass_statement_bind_uuid(statement, 0, upload.ModelId()); cass_statement_bind_uuid(statement, 1, upload.UploadId()); CassFuture* future = cass_session_execute(session.Session(), statement); cass_future_wait(future); cass_statement_free(statement); CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { std::string err = std::string("Failed to execute query: ") + CassandraUtils::GetCassandraError(future); cass_future_free(future); throw err; } cass_future_free(future); }
static int execute(CassSession* session, char* query, int ignore_error) { CassStatement* stmt = cass_statement_new(query, 0); CassFuture* future = cass_session_execute(session, stmt); cass_statement_free(stmt); CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { if (ignore_error) { cass_future_free(future); return 0; } fprintf(stderr, "Cassandra error: %s\n", cass_error_desc(rc)); cass_future_free(future); return -1; } cass_future_free(future); return 0; }
const CassResult* Connection::execute(CassStatement* statement) { this->log("debug", "Connection::execute"); CassFuture* result = cass_session_execute(this->_session, statement); CassError error = cass_future_error_code(result); if (error != CASS_OK) { CassString message = cass_future_error_message(result); cass_future_free(result); std::ostringstream out; out << cass_error_desc(error) << ": " << message.data; this->log("error", out.str()); throw Php::Exception(out.str()); return nullptr; } const CassResult* res = cass_future_get_result(result); if (res == nullptr) { throw Php::Exception("Error executing query, result is null"); } cass_future_free(result); return res; }
/** * librdf_storage_cassandra_context_add_statement: * @storage: #librdf_storage object * @context_node: #librdf_node object * @statement: #librdf_statement statement to add * * Add a statement to a storage context. * * Return value: non 0 on failure **/ static int librdf_storage_cassandra_context_add_statement(librdf_storage* storage, librdf_node* context_node, librdf_statement* statement) { char* s; char* p; char* o; char* c; statement_helper(storage, statement, context_node, &s, &p, &o, &c); librdf_storage_cassandra_instance* context; context = (librdf_storage_cassandra_instance*)storage->instance; char* query = "BEGIN BATCH " " INSERT INTO rdf.spo (s, p, o) VALUES (?, ?, ?);" " INSERT INTO rdf.pos (s, p, o) VALUES (?, ?, ?);" " INSERT INTO rdf.osp (s, p, o) VALUES (?, ?, ?);" "APPLY BATCH;"; CassStatement* stmt = cass_statement_new(query, 9); cass_statement_bind_string(stmt, 0, s); cass_statement_bind_string(stmt, 1, p); cass_statement_bind_string(stmt, 2, o); cass_statement_bind_string(stmt, 3, s); cass_statement_bind_string(stmt, 4, p); cass_statement_bind_string(stmt, 5, o); cass_statement_bind_string(stmt, 6, s); cass_statement_bind_string(stmt, 7, p); cass_statement_bind_string(stmt, 8, o); if (s) free(s); if (p) free(p); if (o) free(o); 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 -1; } cass_future_free(future); return 0; }
static int cassandra_results_stream_end_of_stream(void* context) { cassandra_results_stream* scontext; scontext = (cassandra_results_stream*)context; if (scontext->at_end) { if (scontext->more_pages) { CassError rc; rc = cass_statement_set_paging_state(scontext->stmt, scontext->result); if (rc != CASS_OK) { fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc)); return -1; } cass_result_free(scontext->result); scontext->result = 0; CassFuture* future = cass_session_execute(scontext->cassandra_context->session, scontext->stmt); 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 -1; } scontext->result = cass_future_get_result(future); cass_future_free(future); scontext->iter = cass_iterator_from_result(scontext->result); scontext->more_pages = cass_result_has_more_pages(scontext->result); scontext->at_end = !cass_iterator_next(scontext->iter); } } return (scontext->at_end); }
CassError CassandraFS::create_file(const char* path, mode_t mode) { CassUuid uuid; cass_uuid_gen_time(ctxt->uuid_gen, &uuid); CassError error_value = CASS_OK; CassFuture* result_future = NULL; if (S_ISDIR(mode)) { result_future = create_dir_entry(path, mode); } else { result_future = create_file_entry(path, &uuid, mode); } CassFuture* result_future2 = create_sub_entry(path); CassFuture* result_future3 = NULL; if (!S_ISDIR(mode)) { result_future3 = create_physical_file(&uuid); } CassError err1 = cass_future_error_code(result_future); CassError err2 = cass_future_error_code(result_future2); CassError err3 = CASS_OK; if (result_future3 != NULL) { err3 = cass_future_error_code(result_future3); } if (err1 != CASS_OK) { cassandra_log_error(result_future); error_value = err1; } if (err2 != CASS_OK) { cassandra_log_error(result_future2); error_value = err2; } if (err3 != CASS_OK && result_future3 != NULL) { cassandra_log_error(result_future3); error_value = err3; } cass_future_free(result_future); cass_future_free(result_future2); if (result_future3 != NULL) { cass_future_free(result_future3); } return error_value; }
void on_create_table(CassFuture* future, void* data) { const char* insert_query = "INSERT INTO callbacks (key, value) " "VALUES (?, ?)"; CassUuid key; CassStatement* statement = NULL; CassFuture* insert_future = NULL; CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); } statement = cass_statement_new(insert_query, 2); cass_uuid_gen_time(uuid_gen, &key); cass_statement_bind_uuid(statement, 0, key); cass_statement_bind_int64(statement, 1, cass_uuid_timestamp(key)); insert_future = cass_session_execute((CassSession*)data, statement); cass_future_set_callback(insert_future, on_insert, data); cass_statement_free(statement); cass_future_free(insert_future); }
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; }
void select_from_perf(CassSession* session, const char* query, const CassPrepared* prepared) { int i; CassFuture* futures[NUM_CONCURRENT_REQUESTS]; for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { CassStatement* statement; if (prepared != NULL) { statement = cass_prepared_bind(prepared); } else { statement = cass_statement_new(query, 0); } futures[i] = cass_session_execute(session, statement); cass_statement_free(statement); } for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { CassFuture* future = futures[i]; CassError rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); assert(cass_result_column_count(result) == 6); cass_result_free(result); } cass_future_free(future); } }
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 {
CassError insert_into(CassSession* session, const char* key) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; cass_uint32_t d; cass_int64_t t; const char* query = "INSERT INTO examples.date_time (key, d, t) VALUES (?, ?, ?);"; time_t now = time(NULL); d = cass_date_from_epoch(now); t = cass_time_from_epoch(now); statement = cass_statement_new(query, 3); cass_statement_bind_string(statement, 0, key); cass_statement_bind_uint32(statement, 1, d); cass_statement_bind_int64(statement, 2, t); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); cass_statement_free(statement); return rc; }
CassError insert_into_collections(CassSession* session, const char* key, const char* items[]) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; CassCollection* collection = NULL; const char** item = NULL; const char* query = "INSERT INTO examples.collections (key, items) VALUES (?, ?);"; statement = cass_statement_new(query, 2); cass_statement_bind_string(statement, 0, key); collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2); for (item = items; *item; item++) { cass_collection_append_string(collection, *item); } cass_statement_bind_collection(statement, 1, collection); cass_collection_free(collection); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); cass_statement_free(statement); return rc; }
CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (:k, :b, :f, :d, :i32, :i64);"; statement = cass_statement_new(query, 6); cass_statement_bind_string_by_name(statement, "k", key); cass_statement_bind_bool_by_name(statement, "b", basic->bln); cass_statement_bind_float_by_name(statement, "f", basic->flt); cass_statement_bind_double_by_name(statement, "d", basic->dbl); cass_statement_bind_int32_by_name(statement, "i32", basic->i32); cass_statement_bind_int64_by_name(statement, "i64", basic->i64); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); cass_statement_free(statement); return rc; }
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 ); }
CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);"; statement = cass_statement_new(query, 6); cass_statement_bind_string(statement, 0, key); cass_statement_bind_bool(statement, 1, basic->bln); cass_statement_bind_float(statement, 2, basic->flt); cass_statement_bind_double(statement, 3, basic->dbl); cass_statement_bind_int32(statement, 4, basic->i32); cass_statement_bind_int64(statement, 5, basic->i64); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); cass_statement_free(statement); return rc; }
void execute_query(CassSession* session, const char* query, CassFutureCallback callback) { CassStatement* statement = cass_statement_new(query, 0); CassFuture* future = cass_session_execute(session, statement); cass_future_set_callback(future, callback, session); cass_future_free(future); cass_statement_free(statement); }
void wait_exit() { uv_mutex_lock(&mutex); while (close_future == NULL) { uv_cond_wait(&cond, &mutex); } uv_mutex_unlock(&mutex); cass_future_wait(close_future); cass_future_free(close_future); }
/** * Closes the session instance and waits for in-flight requests to finish. */ int lua_cass_session_close (lua_State* L) { fprintf(stderr, "lua_cass_session_close\n"); CassSession* session = lua_session_get_ptr(L, 1); CassFuture* future = cass_session_close(session); cass_future_wait(future); cass_future_free(future); return 0; }
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_); }
void wait_exit() { uv_mutex_lock(&mutex); while (exit_flag == 0) { uv_cond_wait(&cond, &mutex); } uv_mutex_unlock(&mutex); if (close_future) { cass_future_wait(close_future); cass_future_free(close_future); } }
void CassDriver::PrepareQuery() { CassError rc = CASS_OK; CassString insert_query = cass_string_init("INSERT INTO receiver_table " "(receiver_id, ts, msg_id, group_id, msg, sender_id) " "VALUES (?, ?, ?, ?, ?, ?);"); CassFuture* insert_future = cass_session_prepare(session_, insert_query); cass_future_wait(insert_future); rc = cass_future_error_code(insert_future); if (rc != CASS_OK) { PrintError(insert_future); } else { insert_prepared_ = cass_future_get_prepared(insert_future); } cass_future_free(insert_future); rc = CASS_OK; CassString select_query = cass_string_init("SELECT * FROM receiver_table " "WHERE receiver_id = ?"); CassFuture* select_future = cass_session_prepare(session_, select_query); cass_future_wait(select_future); rc = cass_future_error_code(select_future); if (rc != CASS_OK) { PrintError(select_future); } else { select_prepared_ = cass_future_get_prepared(select_future); } cass_future_free(select_future); rc = CASS_OK; CassString delete_query = cass_string_init("DELETE FROM receiver_table " "WHERE receiver_id = ?"); CassFuture* delete_future = cass_session_prepare(session_, delete_query); cass_future_wait(delete_future); rc = cass_future_error_code(delete_future); if (rc != CASS_OK) { PrintError(delete_future); } else { delete_prepared_ = cass_future_get_prepared(delete_future); } cass_future_free(delete_future); }
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; }
CassError DbCassandra::PrepareQuery( CassSession *session, const char *query, const CassPrepared **prepared ) const { CassFuture *future = cass_session_prepare( session, query ); cass_future_wait( future ); CassError err = cass_future_error_code( future ); if ( err == CASS_OK ) *prepared = cass_future_get_prepared( future ); cass_future_free( future ); return err; }
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; }
CassError connect_session(CassSession* session, const CassCluster* cluster) { CassError rc = CASS_OK; CassFuture* future = cass_session_connect(session, cluster); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); return rc; }
void CassDriver::ConnectSession() { CassError rc = CASS_OK; CassFuture* future = cass_cluster_connect_keyspace(cluster_, "offline_keyspace"); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { PrintError(future); } else { session_ = cass_future_get_session(future); } cass_future_free(future); }
static void php_cassandra_session_dtor(php5to7_zend_resource rsrc TSRMLS_DC) { cassandra_psession *psession = (cassandra_psession*) rsrc->ptr; if (psession) { cass_future_free(psession->future); cass_session_free(psession->session); pefree(psession, 1); CASSANDRA_G(persistent_sessions)--; rsrc->ptr = NULL; } }
void DbCassandra::Delete( const std::string &key ) { DbPtr db = db_; if ( db ) { auto statement = cass_prepared_bind( db_->GetPreparedDelete() ); cass_statement_bind_string( statement, 0, key.c_str() ); auto query_future = cass_session_execute( db_->GetSession(), statement ); cass_statement_free( statement ); CassError err = cass_future_error_code( query_future ); cass_future_free( query_future ); if ( err != CASS_OK ) throw std::logic_error( cass_error_desc( err ) ); } }
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 execute_query(CassSession* session, const char* query) { CassError rc = CASS_OK; CassStatement* statement = cass_statement_new(query, 0); CassFuture* future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); cass_statement_free(statement); return rc; }