unsigned char* CassandraFS::read_block(CassUuid* physical_file_id, int block, int* bytes_read) { CassStatement* statement = cass_statement_new("SELECT data, size FROM file_blocks WHERE physical_file_id = ? AND block_number = ?", 2); cass_statement_bind_uuid(statement, 0, *physical_file_id); cass_statement_bind_int32(statement, 1, block); unsigned char* return_data = NULL; CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); if (cass_future_error_code(result_future) == CASS_OK) { 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* data_value = cass_row_get_column_by_name(row, "data"); const CassValue* size_value = cass_row_get_column_by_name(row, "size"); const cass_byte_t* cass_data; size_t size; int size2; cass_value_get_bytes(data_value, &cass_data, &size); cass_value_get_int32(size_value, &size2); // Let's use the value from "size" field unless bigger than the actual data. if (size2>size) { warning("Problem: size field is showing value %d which is bigger than the actual block data length %zu", size2, size); size2 = size; } return_data = (unsigned char*)malloc(size2); memcpy(return_data, cass_data, size2); (*bytes_read) = size2; } cass_result_free(result); cass_iterator_free(rows); } else { /* Handle error */ cassandra_log_error(result_future); } cass_future_free(result_future); return return_data; }
CassFuture* CassandraFS::truncate_block(struct stat* stat, struct cfs_attrs* cfs_attrs, int block_number, int size) { CassStatement* statement = cass_statement_new("UPDATE file_blocks SET size = ? WHERE physical_file_id = ? AND block_number = ?", 3); cass_statement_bind_int32(statement, 0, size); cass_statement_bind_uuid(statement, 1, cfs_attrs->physical_file_id); cass_statement_bind_int32(statement, 2, block_number); CassFuture* future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); return future; }
void CassandraFS::write_block(CassUuid* physical_file_id, int block, const unsigned char* data, int length, CassandraFutureSpool* spool) { CassStatement* statement = cass_statement_new("INSERT INTO file_blocks(physical_file_id, block_number, data, size) VALUES(?,?,?,?)", 4); cass_statement_bind_uuid(statement, 0, *physical_file_id); cass_statement_bind_int32(statement, 1, block); cass_statement_bind_bytes(statement, 2, data, length); cass_statement_bind_int32(statement, 3, length); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); spool->append(result_future); }
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; }
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; }
CassFuture* CassandraFS::delete_file_block(struct stat* stat, struct cfs_attrs* cfs_attrs, int block_number) { CassStatement* statement = cass_statement_new("DELETE FROM file_blocks WHERE block_number = ? AND physical_file_id = ?", 2); cass_statement_bind_int32(statement, 0, block_number); cass_statement_bind_uuid(statement, 1, cfs_attrs->physical_file_id); CassFuture* result_future = cass_session_execute(ctxt->session, statement); cass_statement_free(statement); return result_future; }
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 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())); } }
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; }
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 bindInt32(unsigned idx, __int32 value) { if (query.length()) traceBind(idx, "%d", value); check(cass_statement_bind_int32(statement, idx, value)); }
void InsertThread::run() { // CONNECT TO CASSANDRA CassCluster* cluster; CassSession* session; if (!CassConnectToKeyspace("127.0.0.1", "chaos", "'class': 'SimpleStrategy', 'replication_factor': 1", &cluster, &session)) { // free resources CassFreeClusterAndSession(cluster, session); return; }// if error ... // INSERTING NUMBERS const CassPrepared *preparedInsert = NULL; CassFuture* prefuture = cass_session_prepare(session, "INSERT INTO test (group, num, minimize) VALUES (?, ?, ?) IF NOT EXISTS"); cass_future_wait(prefuture); CassError prerc = cass_future_error_code(prefuture); if (prerc != CASS_OK) { CassPrintError(prefuture); // free resources cass_future_free(prefuture); CassFreeClusterAndSession(cluster, session); return; } else preparedInsert = cass_future_get_prepared(prefuture); cass_future_free(prefuture); int group; unsigned long minimize; CassStatement* statement; CassFuture* future; CassError rcI; while (GetNextNum()) { group = num % 1000000; minimize = num; statement = cass_prepared_bind(preparedInsert); cass_statement_bind_int32(statement, 0, group); cass_statement_bind_int64(statement, 1, num); cass_statement_bind_int64(statement, 2, minimize); future = cass_session_execute(session, statement); cass_future_wait(future); rcI = cass_future_error_code(future); if (rcI != CASS_OK) { CassPrintError(future); }// if error ... cass_future_free(future); cass_statement_free(statement); // stop loop on error if (rcI != CASS_OK) break; // show progress on console if ((num % 3751) == 0) printf("%lu\n", num); }// foreach num ... // free resources cass_prepared_free(preparedInsert); CassFreeClusterAndSession(cluster, session); }
static CassError bind(CassStatement* statement, size_t index, cass_int32_t value) { return cass_statement_bind_int32(statement, index, value); }
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; }
void statement_bind(shared::native::StatementPtr statement, size_t index) { ASSERT_EQ(CASS_OK, cass_statement_bind_int32(statement.get(), index, integer_)); }