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