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;
}
