void on_select(CassFuture* future, void* data) { CassError code = cass_future_error_code(future); if (code != CASS_OK) { print_error(future); } else { const CassResult* result = cass_future_get_result(future); CassIterator* iterator = cass_iterator_from_result(result); while (cass_iterator_next(iterator)) { CassUuid key; char key_str[CASS_UUID_STRING_LENGTH]; cass_uint64_t value = 0; const CassRow* row = cass_iterator_get_row(iterator); cass_value_get_uuid(cass_row_get_column(row, 0), &key); cass_uuid_string(key, key_str); cass_value_get_int64(cass_row_get_column(row, 1), (cass_int64_t*)&value); printf("%s, %llu\n", key_str, (unsigned long long)value); } cass_iterator_free(iterator); cass_result_free(result); } signal_exit((CassSession*)data); }
cass_int64_t get_timestamp(const std::string table_name, const std::string& key) { cass_int64_t timestamp; test_utils::CassResultPtr result; std::string query = str(boost::format("SELECT writetime(value) FROM %s WHERE key = '%s'") % table_name % key); test_utils::execute_query(session, query, &result); BOOST_REQUIRE(cass_result_row_count(result.get()) > 0); BOOST_REQUIRE(cass_result_column_count(result.get()) > 0); const CassRow* row = cass_result_first_row(result.get()); const CassValue* writetime = cass_row_get_column(row, 0); cass_value_get_int64(writetime, ×tamp); return timestamp; }
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; }
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; }
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 CassPrepared * prepared, const char* key, Basic* basic) { CassError rc = CASS_OK; CassStatement* statement = NULL; CassFuture* future = NULL; statement = cass_prepared_bind(prepared); 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; }
static CassError get(const CassValue* value, cass_int64_t* output) { return cass_value_get_int64(value, output); }
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; }
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; }