static CassStatement* cassandra_query_po(const char* s, const char* p, const char* o) { char* query = "SELECT s, p, o FROM rdf.pos WHERE p = ? AND o = ?;"; CassStatement* statement = cass_statement_new(query, 2); cass_statement_bind_string(statement, 0, p); cass_statement_bind_string(statement, 1, o); return statement; }
static CassStatement* cassandra_query_sp(const char* s, const char* p, const char* o) { char* query = "SELECT s, p, o FROM rdf.spo WHERE s = ? AND p = ?;"; CassStatement* statement = cass_statement_new(query, 2); cass_statement_bind_string(statement, 0, s); cass_statement_bind_string(statement, 1, p); return statement; }
/** * 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; }
CassFuture* CassandraFS::remove_sub_entry(const char* path) { CassStatement* statement = cass_statement_new("DELETE FROM sub_entries WHERE parent_path = ? AND sub_path = ?", 2); char *subpathc = strdup(path); char *parentpathc = strdup(path); cass_statement_bind_string(statement, 0, dirname(parentpathc)); cass_statement_bind_string(statement, 1, basename(subpathc)); free(subpathc); free(parentpathc); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); return result_future; }
CassFuture* CassandraFS::create_sub_entry(const char* path) { CassStatement* statement = cass_statement_new("INSERT INTO sub_entries(sub_path, parent_path) VALUES(?,?)", 2); char *subpathc = strdup(path); char *parentpathc = strdup(path); cass_statement_bind_string(statement, 0, basename(subpathc)); cass_statement_bind_string(statement, 1, dirname(parentpathc)); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); free(subpathc); free(parentpathc); return result_future; }
static std::vector<CassUuid> insert_async(CassSession* session, CassUuidGen* uuid_gen, const std::string& table_name, size_t num_concurrent_requests, std::vector<test_utils::CassFuturePtr>* futures) { std::string create_table_query = str(boost::format("CREATE TABLE %s (id timeuuid PRIMARY KEY, num int, str text);") % table_name); test_utils::execute_query(session, create_table_query); std::string insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(?, ?, ?)") % table_name); std::vector<CassUuid> ids; for (size_t i = 0; i < num_concurrent_requests; ++i) { CassUuid id = test_utils::generate_time_uuid(uuid_gen); test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 3)); // Determine if bound parameters can be used based on C* version if (version.major == 1) { insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(%s, %s, 'row%s')") % table_name % test_utils::Value<CassUuid>::to_string(id) % i % i); statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0)); } else { BOOST_REQUIRE(cass_statement_bind_uuid(statement.get(), 0, id) == CASS_OK); BOOST_REQUIRE(cass_statement_bind_int32(statement.get(), 1, i) == CASS_OK); std::string str_value = str(boost::format("row%d") % i); BOOST_REQUIRE(cass_statement_bind_string(statement.get(), 2, str_value.c_str()) == CASS_OK); } cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM); futures->push_back(test_utils::CassFuturePtr(cass_session_execute(session, statement.get()))); ids.push_back(id); } return ids; }
void DbCassandra::Put( const std::string &key, const std::string &value ) { DbPtr db = db_; if ( db ) { auto statement = cass_prepared_bind( db_->GetPreparedInsert() ); cass_statement_bind_string( statement, 0, key.c_str() ); cass_statement_bind_string( statement, 1, value.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 ) ); } }
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; }
bool execute_insert(CassSession* session, const std::string& table_name) { std::string query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name); test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 3)); // Determine if bound parameters can be used based on C* version if (version.major == 1) { test_utils::CassPreparedPtr prepared = test_utils::prepare(session, query.c_str()); statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get())); } boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now()); boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch())); std::string text_sample(test_utils::string_from_time_point(now)); cass_statement_bind_uuid(statement.get(), 0, test_utils::generate_time_uuid(uuid_gen)); cass_statement_bind_int64(statement.get(), 1, event_time.count()); cass_statement_bind_string(statement.get(), 2, text_sample.c_str()); test_utils::CassFuturePtr future(cass_session_execute(session, statement.get())); cass_future_wait(future.get()); CassError code = cass_future_error_code(future.get()); if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay CassString message; cass_future_error_message(future.get(), &message.data, &message.length); fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data); return false; } return true; }
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; }
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; }
CassFuture* CassandraFS::remove_entry(const char* path) { CassStatement* statement = cass_statement_new("DELETE FROM entries WHERE path = ?", 1); cass_statement_bind_string(statement, 0, path); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); return result_future; }
static CassStatement* cassandra_query_o(const char* s, const char* p, const char* o) { char* query = "SELECT s, p, o FROM rdf.osp WHERE o = ?;"; CassStatement* statement = cass_statement_new(query, 1); cass_statement_bind_string(statement, 0, o); return statement; }
void bindString(unsigned idx, const char *value) { if (query.length()) { unsigned l = strlen(value); if (l > 100) l = 100; traceBind(idx, "'%.*s'", l, value); } check(cass_statement_bind_string(statement, idx, value)); }
CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepared* prepared, const Pair* pairs) { CassError rc = CASS_OK; CassFuture* future = NULL; CassBatch* batch = cass_batch_new(CASS_BATCH_TYPE_LOGGED); const Pair* pair; for (pair = pairs; pair->key != NULL; pair++) { CassStatement* statement = cass_prepared_bind(prepared); cass_statement_bind_string(statement, 0, pair->key); cass_statement_bind_string(statement, 1, pair->value); cass_batch_add_statement(batch, statement); cass_statement_free(statement); } { CassStatement* statement = cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES ('c', '3')", 0); cass_batch_add_statement(batch, statement); cass_statement_free(statement); } { CassStatement* statement = cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES (?, ?)", 2); cass_statement_bind_string(statement, 0, "d"); cass_statement_bind_string(statement, 1, "4"); cass_batch_add_statement(batch, statement); cass_statement_free(statement); } future = cass_session_execute_batch(session, batch); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); cass_batch_free(batch); return rc; }
void insert_into_perf(CassSession* session, const char* query, const CassPrepared* prepared) { int i; CassFuture* futures[NUM_CONCURRENT_REQUESTS]; CassCollection* collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2); cass_collection_append_string(collection, "jazz"); cass_collection_append_string(collection, "2013"); for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { CassUuid id; CassStatement* statement; if (prepared != NULL) { statement = cass_prepared_bind(prepared); } else { statement = cass_statement_new(query, 5); } cass_uuid_gen_time(uuid_gen, &id); cass_statement_bind_uuid(statement, 0, id); cass_statement_bind_string(statement, 1, big_string); cass_statement_bind_string(statement, 2, big_string); cass_statement_bind_string(statement, 3, big_string); cass_statement_bind_collection(statement, 4, collection); 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); } cass_future_free(future); } cass_collection_free(collection); }
CassFuture* CassandraFS::create_dir_entry(const char* path, mode_t mode) { CassStatement* statement = cass_statement_new("INSERT INTO entries(path, mode, created_at, modified_at) VALUES(?,?,?,?)", 4); cass_statement_bind_string(statement, 0, path); cass_statement_bind_int32(statement, 1, mode); cass_statement_bind_int64(statement, 2, time(NULL)*1000); cass_statement_bind_int64(statement, 3, time(NULL)*1000); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); return result_future; }
CassFuture* CassandraFS::sub_entries(const char* path, int limit) { CassStatement* statement = NULL; if (limit > 0) { statement = cass_statement_new("select sub_path FROM sub_entries WHERE parent_path = ? LIMIT ?", 2); cass_statement_bind_int32(statement, 1, limit); } else { statement = cass_statement_new("select sub_path FROM sub_entries WHERE parent_path = ?", 1); } cass_statement_bind_string(statement, 0, path); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); return result_future; }
void bindString_n(unsigned idx, const char *value, unsigned len) { if (strlen(value)<len) { if (query.length()) traceBind(idx, "'%s'", value); check(cass_statement_bind_string(statement, idx, value)); } else { if (query.length()) traceBind(idx, "'%.*s'", len>100?100:len, value); check(cass_statement_bind_string_n(statement, idx, value, len)); } }
CassError select_from_collections(CassSession* session, const char* key) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "SELECT items FROM examples.collections WHERE key = ?"; statement = cass_statement_new(query, 1); cass_statement_bind_string(statement, 0, key); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); CassIterator* iterator = cass_iterator_from_result(result); if (cass_iterator_next(iterator)) { const CassValue* value = NULL; const CassRow* row = cass_iterator_get_row(iterator); CassIterator* items_iterator = NULL; value = cass_row_get_column(row, 0); items_iterator = cass_iterator_from_collection(value); while (cass_iterator_next(items_iterator)) { const char* item; size_t item_length; cass_value_get_string(cass_iterator_get_value(items_iterator), &item, &item_length); printf("item: %.*s\n", (int)item_length, item); } cass_iterator_free(items_iterator); } cass_result_free(result); cass_iterator_free(iterator); } cass_future_free(future); cass_statement_free(statement); return rc; }
CassError select_from_maps(CassSession* session, const char* key) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "SELECT items FROM examples.maps WHERE key = ?"; statement = cass_statement_new(query, 1); cass_statement_bind_string(statement, 0, key); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); if (cass_result_row_count(result) > 0) { const CassRow* row = cass_result_first_row(result); CassIterator* iterator = cass_iterator_from_map( cass_row_get_column(row, 0)); while (cass_iterator_next(iterator)) { const char* key; size_t key_length; cass_int32_t value; cass_value_get_string(cass_iterator_get_map_key(iterator), &key, &key_length); cass_value_get_int32(cass_iterator_get_map_value(iterator), &value); printf("item: '%.*s' : %d \n", (int)key_length, key, value); } cass_iterator_free(iterator); } cass_result_free(result); } cass_future_free(future); cass_statement_free(statement); return rc; }
CassError select_from(CassSession* session, const char* key) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "SELECT * FROM examples.date_time WHERE key = ?"; statement = cass_statement_new(query, 1); cass_statement_bind_string(statement, 0, key); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); CassIterator* iterator = cass_iterator_from_result(result); if (cass_iterator_next(iterator)) { cass_uint32_t d; cass_int64_t t; time_t time; const CassRow* row = cass_iterator_get_row(iterator); cass_value_get_uint32(cass_row_get_column(row, 1), &d); cass_value_get_int64(cass_row_get_column(row, 2), &t); time = (time_t)cass_date_time_to_epoch(d, t); printf("Date and time: %s", asctime(localtime(&time))); } cass_result_free(result); cass_iterator_free(iterator); } cass_future_free(future); cass_statement_free(statement); return rc; }
int CassandraFS::update_timestamps(const char* path, const struct timespec last_access_stamp, const struct timespec last_modification_stamp) { CassStatement* statement = cass_statement_new("UPDATE entries SET modified_at = ? WHERE path = ?", 2); cass_statement_bind_int64(statement, 0, last_modification_stamp.tv_sec * 1000 + (last_modification_stamp.tv_nsec / 1000000)); cass_statement_bind_string(statement, 1, path); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); int error = 0; if (cass_future_error_code(result_future) == CASS_OK) { // Nada } else { /* Handle error */ error = -EIO; cassandra_log_error(result_future); } cass_future_free(result_future); return error; }
int CassandraFS::update_mode(const char* path, mode_t new_mode) { CassStatement* statement = cass_statement_new("UPDATE entries SET mode = ? WHERE path = ?", 2); cass_statement_bind_int32(statement, 0, new_mode); cass_statement_bind_string(statement, 1, path); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); int error = 0; if (cass_future_error_code(result_future) == CASS_OK) { // Nada } else { /* Handle error */ error = -EIO; cassandra_log_error(result_future); } cass_future_free(result_future); return error; }
/// ATM only supports (key, value) inserts void asyncInsert(const std::string &table, const int64_t &key, const std::string &value) { if(!connected_) { LOG(FATAL) << "asyncInsert failed, establish connection to cassandra first"; } else if(futures_.size() > kMaxNumQueuedFutures) { VLOG(1) << "asyncInsert, queue has reached capacity, draining..."; wait(); } const auto tableName = keyspace_ + "." + table; const auto query("INSERT INTO " + tableName + " (key, value) " + "VALUES (?, ?);"); auto statement = createStatement(cass_statement_new(query.c_str(), 2)); cass_statement_bind_int64(statement.get(), 0, (cass_int64_t)key); cass_statement_bind_string(statement.get(), 1, value.data()); futures_.emplace(cass_session_execute(session_.get(), statement.get()), cass_future_free); }
CassError select_from_basic(CassSession* session, const char* key, Basic* basic) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "SELECT * FROM examples.basic WHERE key = ?"; statement = cass_statement_new(query, 1); cass_statement_bind_string(statement, 0, key); future = cass_session_execute(session, statement); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); CassIterator* iterator = cass_iterator_from_result(result); if (cass_iterator_next(iterator)) { const CassRow* row = cass_iterator_get_row(iterator); cass_value_get_bool(cass_row_get_column(row, 1), &basic->bln); cass_value_get_double(cass_row_get_column(row, 2), &basic->dbl); cass_value_get_float(cass_row_get_column(row, 3), &basic->flt); cass_value_get_int32(cass_row_get_column(row, 4), &basic->i32); cass_value_get_int64(cass_row_get_column(row, 5), &basic->i64); } cass_result_free(result); cass_iterator_free(iterator); } cass_future_free(future); cass_statement_free(statement); return rc; }
void insert_into_async(CassSession* session, const char* key) { CassError rc = CASS_OK; CassStatement* statement = NULL; const char* query = "INSERT INTO async (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);"; CassFuture* futures[NUM_CONCURRENT_REQUESTS]; size_t i; for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { char key_buffer[64]; statement = cass_statement_new(query, 6); sprintf(key_buffer, "%s%u", key, (unsigned int)i); cass_statement_bind_string(statement, 0, key_buffer); cass_statement_bind_bool(statement, 1, i % 2 == 0 ? cass_true : cass_false); cass_statement_bind_float(statement, 2, i / 2.0f); cass_statement_bind_double(statement, 3, i / 200.0); cass_statement_bind_int32(statement, 4, (cass_int32_t)(i * 10)); cass_statement_bind_int64(statement, 5, (cass_int64_t)(i * 100)); futures[i] = cass_session_execute(session, statement); cass_statement_free(statement); } for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) { CassFuture* future = futures[i]; cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } cass_future_free(future); } }
void CassDriver::Store(void (*cob)(CassFuture* future, void* data), const Message& message, void* cb_data) { CassStatement* statement = cass_prepared_bind(insert_prepared_); cass_statement_bind_string(statement, 0, cass_string_init(message.receiver_id.c_str())); cass_statement_bind_string(statement, 1, cass_string_init(message.timestamp.c_str())); cass_statement_bind_string(statement, 2, cass_string_init(message.msg_id.c_str())); cass_statement_bind_string(statement, 3, cass_string_init(message.group_id.c_str())); cass_statement_bind_string(statement, 4, cass_string_init(message.msg.c_str())); cass_statement_bind_string(statement, 5, cass_string_init(message.sender_id.c_str())); CassFuture* future = cass_session_execute(session_, statement); cass_future_set_callback(future, cob, cb_data); cass_future_free(future); cass_statement_free(statement); }
void CassDriver::Retrieve( std::tr1::function<void(bool success, Wrapper* data)> cob, const std::string& receiver_id, Wrapper* data_wrapper) { CassStatement* statement = cass_prepared_bind(select_prepared_); cass_statement_bind_string(statement, 0, cass_string_init(receiver_id.c_str())); cass_statement_set_paging_size(statement, FLAGS_page_size); CassFuture* future = cass_session_execute(session_, statement); auto retrieve_cb = [](CassFuture* future, void* data) { CassError rc = cass_future_error_code(future); Wrapper* wrapper = (Wrapper*)data; if (rc == CASS_OK) { const CassResult* result = cass_future_get_result(future); if (cass_result_row_count(result)) { CassIterator* iterator = cass_iterator_from_result(result); CassString cass_receiver, cass_time, cass_msg_id, cass_group_id, cass_msg, cass_sender; while (cass_iterator_next(iterator)) { const CassRow* row = cass_iterator_get_row(iterator); cass_value_get_string(cass_row_get_column(row, 0), &cass_receiver); cass_value_get_string(cass_row_get_column(row, 1), &cass_time); cass_value_get_string(cass_row_get_column(row, 2), &cass_msg_id); cass_value_get_string(cass_row_get_column(row, 3), &cass_group_id); cass_value_get_string(cass_row_get_column(row, 4), &cass_msg); cass_value_get_string(cass_row_get_column(row, 5), &cass_sender); std::string receiver(cass_receiver.data, cass_receiver.length); std::string time(cass_time.data, cass_time.length); std::string msg_id(cass_msg_id.data, cass_msg_id.length); std::string group_id(cass_group_id.data, cass_group_id.length); std::string msg(cass_msg.data, cass_msg.length); std::string sender(cass_sender.data, cass_sender.length); boost::shared_ptr<Message> message(new Message()); message->__set_receiver_id(receiver); message->__set_timestamp(time); message->__set_msg_id(msg_id); message->__set_group_id(group_id); message->__set_msg(msg); message->__set_sender_id(sender); wrapper->pmsgs->push_back(message); } cass_bool_t has_more_pages = cass_result_has_more_pages(result); if (has_more_pages) { cass_statement_set_paging_state(wrapper->statement, result); (wrapper->func)(); } else { cass_statement_free(wrapper->statement); CassStatement* statement = cass_prepared_bind(wrapper->this_obj->delete_prepared_); cass_statement_bind_string(statement, 0, cass_receiver); CassFuture* delete_future = cass_session_execute(wrapper->this_obj->session_, statement); cass_future_free(delete_future); cass_statement_free(statement); (wrapper->cob)(true, wrapper); } cass_iterator_free(iterator); } else { cass_statement_free(wrapper->statement); (wrapper->cob)(true, wrapper); } cass_result_free(result); } else { cass_statement_free(wrapper->statement); wrapper->this_obj->PrintError(future); (wrapper->cob)(false, wrapper); } }; data_wrapper->this_obj = this; data_wrapper->cob = cob; data_wrapper->statement = statement; data_wrapper->func = [=]() { CassFuture* future = cass_session_execute(session_, statement); cass_future_set_callback(future, retrieve_cb, data_wrapper); cass_future_free(future); }; cass_future_set_callback(future, retrieve_cb, data_wrapper); cass_future_free(future); }
static int librdf_storage_cassandra_add_statements(librdf_storage* storage, librdf_stream* statement_stream) { librdf_storage_cassandra_instance* context; context = (librdf_storage_cassandra_instance*)storage->instance; CassBatch* batch = 0; const int batch_size = 10; int rows = 0; for(; !librdf_stream_end(statement_stream); librdf_stream_next(statement_stream)) { librdf_statement* statement; librdf_node* context_node; statement = librdf_stream_get_object(statement_stream); context_node = librdf_stream_get_context2(statement_stream); if(!statement) { break; } char* s; char* p; char* o; char* c; statement_helper(storage, statement, context_node, &s, &p, &o, &c); if (batch == 0) batch = cass_batch_new(CASS_BATCH_TYPE_LOGGED); char* query = "INSERT INTO rdf.spo (s, p, o) VALUES (?, ?, ?);"; CassStatement* stmt = cass_statement_new(query, 3); cass_statement_bind_string(stmt, 0, s); cass_statement_bind_string(stmt, 1, p); cass_statement_bind_string(stmt, 2, o); cass_batch_add_statement(batch, stmt); cass_statement_free(stmt); query = "INSERT INTO rdf.pos (s, p, o) VALUES (?, ?, ?);"; stmt = cass_statement_new(query, 3); cass_statement_bind_string(stmt, 0, s); cass_statement_bind_string(stmt, 1, p); cass_statement_bind_string(stmt, 2, o); cass_batch_add_statement(batch, stmt); cass_statement_free(stmt); query = "INSERT INTO rdf.osp (s, p, o) VALUES (?, ?, ?);"; stmt = cass_statement_new(query, 3); cass_statement_bind_string(stmt, 0, s); cass_statement_bind_string(stmt, 1, p); cass_statement_bind_string(stmt, 2, o); cass_batch_add_statement(batch, stmt); cass_statement_free(stmt); free(s); free(p); free(o); if (++rows > batch_size) { CassFuture* future = cass_session_execute_batch(context->session, batch); cass_batch_free(batch); 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); batch = 0; } } if (batch) { CassFuture* future = cass_session_execute_batch(context->session, batch); cass_batch_free(batch); 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; }