CassError execute_stmt(CassSession* session, const char* query) { CassError rc = CASS_OK; CassFuture* future = NULL; CassStatement* statement = cass_statement_new(cass_string_init(query), 0); 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 validate_results(int num_rows) { std::string select_query = str(boost::format("SELECT * FROM %s WHERE tweet_id = ?;") % BatchTests::SIMPLE_TABLE_NAME); for (int y = 0; y < num_rows; y++) { test_utils::CassStatementPtr select_statement(cass_statement_new(select_query.c_str(), 1)); BOOST_REQUIRE(cass_statement_bind_int32(select_statement.get(), 0, y) == CASS_OK); test_utils::CassFuturePtr select_future(cass_session_execute(session, select_statement.get())); test_utils::wait_and_check_error(select_future.get()); test_utils::CassResultPtr result(cass_future_get_result(select_future.get())); const CassValue* column = cass_row_get_column(cass_result_first_row(result.get()), 1); CassString result_value; BOOST_REQUIRE(cass_value_type(column) == CASS_VALUE_TYPE_VARCHAR); BOOST_REQUIRE(test_utils::Value<CassString>::get(column, &result_value) == CASS_OK); BOOST_REQUIRE(test_utils::Value<CassString>::equal(result_value, str(boost::format("test data %s") % y).c_str())); } }
void on_insert(CassFuture* future, void* data) { CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); signal_exit((CassSession*)data); } else { const char* select_query = "SELECT * FROM callbacks"; CassStatement* statement = cass_statement_new(select_query, 0); CassFuture* select_future = cass_session_execute((CassSession*)data, statement); cass_future_set_callback(select_future, on_select, data); cass_statement_free(statement); cass_future_free(select_future); } }
/** * Wait for a session to reconnect to a node. * * @param session The session to use for waiting * @param node The node to wait for */ void wait_for_node(test_utils::CassSessionPtr session, int node) { std::stringstream ip_address; ip_address << ccm->get_ip_prefix() << node; for (int i = 0; i < 30; ++i) { test_utils::CassStatementPtr statement(cass_statement_new("SELECT * FROM system.peers", 0)); test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get())); std::string host(cass::get_host_from_future(future.get()).c_str()); if (cass_future_error_code(future.get()) == CASS_OK && host == ip_address.str()) { return; } boost::this_thread::sleep_for(boost::chrono::seconds(1)); } BOOST_REQUIRE_MESSAGE(false, "Failed to wait for node " << ip_address.str() << " to become availble"); }
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_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; }
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; }
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); }
CassError CassandraFS::read_physical_file_info(struct stat* stat, struct cfs_attrs* cfs_attrs) { CassStatement* statement = cass_statement_new("SELECT size, block_size FROM physical_files WHERE id = ?", 1); cass_statement_bind_uuid(statement, 0, cfs_attrs->physical_file_id); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); CassError error = cass_future_error_code(result_future); if (error == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* size_value = cass_row_get_column_by_name(row, "size"); if (!cass_value_is_null(size_value)) { cass_int64_t size; cass_value_get_int64(size_value, &size); stat->st_size = size; } const CassValue* block_size_value = cass_row_get_column_by_name(row, "block_size"); if (!cass_value_is_null(block_size_value)) { int size; cass_value_get_int32(block_size_value, &size); cfs_attrs->block_size = size; } } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ cassandra_log_error(result_future); } cass_future_free(result_future); return error; }
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_by_name(statement, "key", 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_by_name(row, "BLN"), &basic->bln); cass_value_get_double(cass_row_get_column_by_name(row, "dbl"), &basic->dbl); cass_value_get_float(cass_row_get_column_by_name(row, "flt"), &basic->flt); cass_value_get_int32(cass_row_get_column_by_name(row, "\"i32\""), &basic->i32); cass_value_get_int64(cass_row_get_column_by_name(row, "i64"), &basic->i64); } cass_result_free(result); cass_iterator_free(iterator); } cass_future_free(future); cass_statement_free(statement); return rc; }
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; }
/// 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); }
int CassandraFS::truncate(const char* path, off_t size) { CassStatement* statement = NULL; struct stat stat; struct cfs_attrs cfs_attrs; CassandraFutureSpool* spool = new CassandraFutureSpool(4); int err = getattr(path, &stat, &cfs_attrs); if (err != 0) { return -EIO; } statement = cass_statement_new("UPDATE physical_files SET size = ? WHERE id = ?", 2); cass_statement_bind_int64(statement, 0, size); cass_statement_bind_uuid(statement, 1, cfs_attrs.physical_file_id); spool->append(cass_session_execute(ctxt->session, statement)); cass_statement_free(statement); off_t current_size = stat.st_size; int current_blocks = blocks_needed(current_size, cfs_attrs.block_size); int needed_blocks = blocks_needed(size, cfs_attrs.block_size); for (int a = needed_blocks; a<current_blocks; a++) { spool->append(delete_file_block(&stat, &cfs_attrs, a)); } if (size % cfs_attrs.block_size > 0) { spool->append(truncate_block(&stat, &cfs_attrs, needed_blocks-1, size % cfs_attrs.block_size)); } spool->wait_all(); int errors = spool->get_errors(); delete spool; if (errors>0) { return -EIO; } return 0; }
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); } }
bool client_thread(CassSession* session, const std::string table_name) { std::string query = str(boost::format("SELECT * FROM %s LIMIT 10000") % table_name); for (int i = 0 ; i < 10; ++i) execute_insert(session, table_name); boost::posix_time::ptime start = boost::posix_time::second_clock::universal_time(); test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 0)); cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_ONE); while ((boost::posix_time::second_clock::universal_time() - start).total_seconds() < TEST_DURATION_SECS) { 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 && code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay CassString message; cass_future_error_message(future.get(), &message.data, &message.length); fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length), message.data); is_done = true; return false; } if (code == CASS_OK) { test_utils::CassResultPtr result(cass_future_get_result(future.get())); if (cass_result_row_count(result.get()) == 0) { fprintf(stderr, "No rows returned from query\n"); is_done = true; return false; } } } is_done = true; return true; }
inline CassError CassandraClient::executeStatement(std::string cqlStatement) { CassError rc = CASS_OK; CassFuture* result_future = NULL; logger.trace("Executing CQL Command"); CassStatement* statement = cass_statement_new(cqlStatement.c_str(), 0); result_future = cass_session_execute(session, statement); cass_future_wait(result_future); rc = cass_future_error_code(result_future); if (rc == CASS_OK) { logger.trace("Executing CQL Command: Success"); } else { return printError(rc); } cass_statement_free(statement); cass_future_free(result_future); return rc; }
void check_for_live_hosts(test_utils::CassSessionPtr session, const std::set<std::string>& should_be_present) { std::set<std::string> hosts; for (size_t i = 0; i < should_be_present.size() + 1; ++i) { const char* query = "SELECT * FROM system.schema_keyspaces"; test_utils::CassStatementPtr statement(cass_statement_new(query, 0)); test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get())); if (cass_future_error_code(future.get()) == CASS_OK) { hosts.insert(cass::get_host_from_future(future.get())); } else { CassString message; cass_future_error_message(future.get(), &message.data, &message.length); BOOST_MESSAGE("Failed to query host: " << std::string(message.data, message.length)); } } BOOST_CHECK(hosts.size() == should_be_present.size()); for (std::set<std::string>::const_iterator it = should_be_present.begin(); it != should_be_present.end(); ++it) { BOOST_CHECK(hosts.count(*it) > 0); } }
void check_for_live_hosts(test_utils::CassSessionPtr session, const std::set<std::string>& should_be_present) { std::set<std::string> hosts; std::stringstream query; query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces"); for (size_t i = 0; i < should_be_present.size() + 2; ++i) { test_utils::CassStatementPtr statement(cass_statement_new(query.str().c_str(), 0)); test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get())); if (cass_future_error_code(future.get()) == CASS_OK) { hosts.insert(cass::get_host_from_future(future.get())); } else { CassString message; cass_future_error_message(future.get(), &message.data, &message.length); std::cerr << "Failed to query host: " << std::string(message.data, message.length) << std::endl; } } BOOST_CHECK(hosts.size() == should_be_present.size()); for (std::set<std::string>::const_iterator it = should_be_present.begin(); it != should_be_present.end(); ++it) { BOOST_CHECK(hosts.count(*it) > 0); } }
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 ); } }
inline CassandraStatement(const char *simple) : statement(cass_statement_new(simple, 0)) { }
int main(int argc, char* argv[]) { /* Setup and connect to cluster */ CassFuture* connect_future = NULL; CassCluster* cluster = cass_cluster_new(); CassSession* session = cass_session_new(); CassSsl* ssl = cass_ssl_new(); char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } cass_cluster_set_contact_points(cluster, hosts); /* Only verify the certification and not the identity */ cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_PEER_CERT); if (!load_trusted_cert_file("cert.pem", ssl)) { fprintf(stderr, "Failed to load certificate disabling peer verification\n"); cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_NONE); } cass_cluster_set_ssl(cluster, ssl); connect_future = cass_session_connect(session, cluster); if (cass_future_error_code(connect_future) == CASS_OK) { CassFuture* close_future = NULL; /* Build statement and execute query */ const char* query = "SELECT release_version FROM system.local"; CassStatement* statement = cass_statement_new(query, 0); CassFuture* result_future = cass_session_execute(session, statement); if (cass_future_error_code(result_future) == CASS_OK) { /* Retrieve result set and get the first row */ const CassResult* result = cass_future_get_result(result_future); const CassRow* row = cass_result_first_row(result); if (row) { const CassValue* value = cass_row_get_column_by_name(row, "release_version"); const char* release_version; size_t release_version_length; cass_value_get_string(value, &release_version, &release_version_length); printf("release_version: '%.*s'\n", (int)release_version_length, release_version); } cass_result_free(result); } else { /* Handle error */ const char* message; size_t message_length; cass_future_error_message(result_future, &message, &message_length); fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length, message); } cass_statement_free(statement); cass_future_free(result_future); /* Close the session */ close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); } else { /* Handle error */ const char* message; size_t message_length; cass_future_error_message(connect_future, &message, &message_length); fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message); } cass_future_free(connect_future); cass_cluster_free(cluster); cass_session_free(session); cass_ssl_free(ssl); return 0; }
int CassandraFS::hardlink(const char* from, const char* to) { int operation_done = 0; CassStatement* statement = cass_statement_new("SELECT mode, created_at, modified_at, physical_file_id FROM entries WHERE path = ?", 1); cass_statement_bind_string(statement, 0, from); 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) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* mode_value = cass_row_get_column_by_name(row, "mode"); const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at"); const CassValue* created_at_value = cass_row_get_column_by_name(row, "created_at"); const CassValue* physical_file_id_value = cass_row_get_column_by_name(row, "physical_file_id"); int mode; cass_value_get_int32(mode_value, &mode); cass_int64_t modified_at; cass_value_get_int64(modified_at_value, &modified_at); cass_int64_t created_at; cass_value_get_int64(created_at_value, &created_at); CassUuid physical_file_id; cass_value_get_uuid(physical_file_id_value, &physical_file_id); CassStatement* insert_statement = cass_statement_new("INSERT INTO entries(path, mode, created_at, modified_at, physical_file_id) VALUES(?,?,?,?,?)", 5); cass_statement_bind_string(insert_statement, 0, to); cass_statement_bind_int32(insert_statement, 1, mode); cass_statement_bind_int64(insert_statement, 2, created_at); cass_statement_bind_int64(insert_statement, 3, modified_at); cass_statement_bind_uuid(insert_statement, 4, physical_file_id); CassFuture* insert_future2 = create_sub_entry(to); CassFuture* insert_future = cass_session_execute(ctxt->session, insert_statement); cass_statement_free(insert_statement); if (cass_future_error_code(insert_future) == CASS_OK) { operation_done = 1; } else { operation_done = 0; cassandra_log_error(insert_future); } if (cass_future_error_code(insert_future2) == CASS_OK) { operation_done = 1; } else { operation_done = 0; cassandra_log_error(insert_future2); } cass_future_free(insert_future); cass_future_free(insert_future2); } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ error = -EIO; cassandra_log_error(result_future); } cass_future_free(result_future); if (!operation_done) { return -ENOENT; } return error; }
int CassandraFS::getattr(const char* path, struct stat *stbuf, struct cfs_attrs *cfs_attrs) { int found = 0; memset(stbuf, 0, sizeof(struct stat)); memset(cfs_attrs, 0, sizeof(struct cfs_attrs)); CassStatement* statement = cass_statement_new("SELECT mode, modified_at, physical_file_id 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); int error = 0; if (cass_future_error_code(result_future) == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); if (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* value = cass_row_get_column_by_name(row, "mode"); const CassValue* modified_at_value = cass_row_get_column_by_name(row, "modified_at"); int mode; cass_value_get_int32(value, &mode); stbuf->st_mode = mode; // regular file if (S_ISREG(mode)) { const CassValue* file_id_value = cass_row_get_column_by_name(row, "physical_file_id"); if (!cass_value_is_null(file_id_value)) { cass_value_get_uuid(file_id_value, &(cfs_attrs->physical_file_id)); } CassError phys_err = read_physical_file_info(stbuf, cfs_attrs); if (phys_err != CASS_OK) { error = -EIO; } } if (!cass_value_is_null(modified_at_value)) { cass_int64_t modified_at; cass_value_get_int64(modified_at_value, &modified_at); stbuf->st_mtime = modified_at / 1000; } stbuf->st_nlink = 1; found = 1; } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ error = -EIO; cassandra_log_error(result_future); } cass_future_free(result_future); if (!found) { return -ENOENT; } return error; }
static std::string LoadFile(Upload& upload) { std::stringstream ss; DatabaseSession session; try { CassError rc = CASS_OK; //std::string str = ("SELECT upload_id, model_id, date, processed, result {includeFile} FROM prophet.models {onlyPending}"); std::string str = "SELECT chunk from prophet.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); rc = cass_future_error_code(future); if (rc != CASS_OK) { auto err = std::string("Failed to execute query: ") + CassandraUtils::GetCassandraError(future); cass_future_free(future); cass_statement_free(statement); throw err; } else { const CassResult* result = cass_future_get_result(future); CassIterator* iterator = cass_iterator_from_result(result); while (cass_iterator_next(iterator)) { const CassRow* row = cass_iterator_get_row(iterator); std::string buffer; CassString::Load(buffer, cass_row_get_column(row, 0)); ss << buffer; } cass_result_free(result); cass_iterator_free(iterator); } cass_future_free(future); cass_statement_free(statement); } catch (...) { std::exception_ptr e = std::current_exception(); try { if (e) { std::rethrow_exception(e); } } catch (const std::exception& ex) { std::cout << "Caught exception \"" << ex.what() << "\"\n"; } } return ss.str(); }
CassError select_from_udt(CassSession* session) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; const char* query = "SELECT * FROM examples.udt"; statement = cass_statement_new(query, 0); 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 = NULL; CassIterator* rows = NULL; result = cass_future_get_result(future); rows = cass_iterator_from_result(result); while(cass_iterator_next(rows)) { CassUuid id; char id_str[CASS_UUID_STRING_LENGTH]; const CassRow* row = cass_iterator_get_row(rows); const CassValue* id_value = cass_row_get_column_by_name(row, "id"); const CassValue* address_value = cass_row_get_column_by_name(row, "address"); CassIterator* fields = cass_iterator_fields_from_user_type(address_value); cass_value_get_uuid(id_value, &id); cass_uuid_string(id, id_str); printf("id %s ", id_str); while(fields != NULL && cass_iterator_next(fields)) { const char* field_name; size_t field_name_length; const CassValue* field_value = NULL; cass_iterator_get_user_type_field_name(fields, &field_name, &field_name_length); field_value = cass_iterator_get_user_type_field_value(fields); printf("%.*s ", (int)field_name_length, field_name); if (!cass_value_is_null(field_value)) { if (cass_value_type(field_value) == CASS_VALUE_TYPE_VARCHAR) { const char* text; size_t text_length; cass_value_get_string(field_value, &text, &text_length); printf("\"%.*s\" ", (int)text_length, text); } else if (cass_value_type(field_value) == CASS_VALUE_TYPE_INT) { cass_int32_t i; cass_value_get_int32(field_value, &i); printf("%d ", i); } else if (cass_value_type(field_value) == CASS_VALUE_TYPE_SET) { CassIterator* phone_numbers = cass_iterator_from_collection(field_value); while (cass_iterator_next(phone_numbers)) { const CassValue* phone_value = cass_iterator_get_value(phone_numbers); CassIterator* phone_fields = cass_iterator_fields_from_user_type(phone_value); assert(cass_value_type(phone_value) == CASS_VALUE_TYPE_UDT); while (cass_iterator_next(phone_fields)) { const CassValue* phone_number_value = cass_iterator_get_user_type_field_value(phone_fields); cass_int32_t i; cass_value_get_int32(phone_number_value, &i); printf("%d ", i); } } } else { printf("<invalid> "); } } else { printf("<null> "); } } printf("\n"); } cass_result_free(result); cass_iterator_free(rows); } cass_future_free(future); cass_statement_free(statement); return rc; }
CassStatementPtr create_insert_statement(const std::string table_name) { std::string query(str(boost::format("INSERT INTO %s (key, value) VALUES (?, ?)") % table_name)); return CassStatementPtr(cass_statement_new(query.c_str(), 2)); }
int main(int argc, char* argv[]) { /* Setup and connect to cluster */ CassFuture* connect_future = NULL; CassCluster* cluster = cass_cluster_new(); CassSession* session = cass_session_new(); char* hosts = "127.0.0.1"; if (argc > 1) { hosts = argv[1]; } /* Add contact points */ cass_cluster_set_contact_points(cluster, hosts); /* Provide the cluster object as configuration to connect the session */ connect_future = cass_session_connect(session, cluster); if (cass_future_error_code(connect_future) == CASS_OK) { CassFuture* close_future = NULL; /* Build statement and execute query */ const char* query = "SELECT keyspace_name " "FROM system.schema_keyspaces;"; CassStatement* statement = cass_statement_new(query, 0); CassFuture* result_future = cass_session_execute(session, statement); if (cass_future_error_code(result_future) == CASS_OK) { /* Retrieve result set and iterate over the rows */ const CassResult* result = cass_future_get_result(result_future); CassIterator* rows = cass_iterator_from_result(result); while (cass_iterator_next(rows)) { const CassRow* row = cass_iterator_get_row(rows); const CassValue* value = cass_row_get_column_by_name(row, "keyspace_name"); const char* keyspace_name; size_t keyspace_name_length; cass_value_get_string(value, &keyspace_name, &keyspace_name_length); printf("keyspace_name: '%.*s'\n", (int)keyspace_name_length, keyspace_name); } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ const char* message; size_t message_length; cass_future_error_message(result_future, &message, &message_length); fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length, message); } cass_statement_free(statement); cass_future_free(result_future); /* Close the session */ close_future = cass_session_close(session); cass_future_wait(close_future); cass_future_free(close_future); } else { /* Handle error */ const char* message; size_t message_length; cass_future_error_message(connect_future, &message, &message_length); fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message); } cass_future_free(connect_future); cass_cluster_free(cluster); cass_session_free(session); return 0; }
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; }
CassError insert_into_udt(CassSession* session) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; CassUuid id; char id_str[CASS_UUID_STRING_LENGTH]; const CassKeyspaceMeta* keyspace_meta = NULL; const CassDataType* udt_address = NULL; const CassDataType* udt_phone = NULL; const char* query = "INSERT INTO examples.udt (id, address) VALUES (?, ?)"; statement = cass_statement_new(query, 2); cass_uuid_gen_time(uuid_gen, &id); cass_uuid_string(id, id_str); keyspace_meta = cass_schema_meta_keyspace_by_name(schema_meta, "examples"); if (keyspace_meta != NULL) { udt_address = cass_keyspace_meta_user_type_by_name(keyspace_meta, "address"); udt_phone = cass_keyspace_meta_user_type_by_name(keyspace_meta, "phone_numbers"); } if (udt_address != NULL && udt_phone != NULL) { int i; CassUserType* address = cass_user_type_new_from_data_type(udt_address); CassCollection* phone = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2); for (i = 0; i < 2; ++i) { CassUserType* phone_numbers = cass_user_type_new_from_data_type(udt_phone); cass_user_type_set_int32_by_name(phone_numbers, "phone1", i + 1); cass_user_type_set_int32_by_name(phone_numbers, "phone2", i + 2); cass_collection_append_user_type(phone, phone_numbers); cass_user_type_free(phone_numbers); } cass_user_type_set_string_by_name(address, "street", id_str); cass_user_type_set_string_by_name(address, "city", id_str); cass_user_type_set_int32_by_name(address, "zip", (cass_int32_t)id.time_and_version); cass_user_type_set_collection_by_name(address, "phone", phone); cass_statement_bind_uuid(statement, 0, id); cass_statement_bind_user_type(statement, 1, address); 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_user_type_free(address); cass_collection_free(phone); } cass_statement_free(statement); return rc; }