std::vector<im_agg_t>
apply_l1_predicate_via_ji(std::vector<im_val_t> pos_orderkey_array)
{
ib_err_t err;
std::vector<im_agg_t> extendedprice_array;
ib_tpl_t key_ji = ib_clust_search_tuple_create(crsr_ji);
ib_tpl_t key_l1_s = ib_clust_search_tuple_create(crsr_l1_s);
ib_tpl_t key_l1_e = ib_clust_search_tuple_create(crsr_l1_e);
size_t size = pos_orderkey_array.size();
int res;
for (int i = 0; i < size; ++i) {
uint32_t sum_extendedprice = 0;
ib_tuple_write_u32(key_ji, 0, pos_orderkey_array[i].pos);
err = ib_cursor_moveto(crsr_ji, key_ji, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for ji" << std::endl;
}
while (err == DB_SUCCESS) {
err = ib_cursor_read_row(crsr_ji, tpl_ji);
if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
}
ib_u32_t l3_pos, l1_pos;
ib_tuple_read_u32(tpl_ji, 0, &l3_pos);
ib_tuple_read_u32(tpl_ji, 1, &l1_pos);
if (l3_pos != pos_orderkey_array[i].pos) {
break;
}
ib_tuple_write_u32(key_l1_s, 0, l1_pos);
err = ib_cursor_moveto(crsr_l1_s, key_l1_s, IB_CUR_LE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l1_s" << std::endl;
}
// getting shipdate RLE triple
err = ib_cursor_read_row(crsr_l1_s, tpl_l1_s);
ib_u32_t l_shipdate, pos, freq;
ib_tuple_read_u32(tpl_l1_s, 0, &l_shipdate);
if (l_shipdate > pred_l_shipdate) {
ib_tuple_write_u32(key_l1_e, 0, l1_pos);
err = ib_cursor_moveto(crsr_l1_e, key_l1_e, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l1_s" << std::endl;
}
err = ib_cursor_read_row(crsr_l1_e, tpl_l1_e);
ib_u32_t l_extendedprice;
ib_tuple_read_u32(tpl_l1_e, 1, &l_extendedprice);
sum_extendedprice += l_extendedprice;
}
err = ib_cursor_next(crsr_ji);
tpl_ji = ib_tuple_clear(tpl_ji);
}
im_agg_t im_agg = {sum_extendedprice};
extendedprice_array.push_back(im_agg);
}
ib_tuple_delete(key_ji);
ib_tuple_delete(key_l1_s);
return extendedprice_array;
}
std::vector<uint32_t>
apply_l5_predicate_scan(std::vector<im_val_t> pos_custkey_array)
{
ib_err_t err;
std::vector<uint32_t> pos_array;
ib_crsr_t index_crsr;
err = ib_cursor_open_index_using_name(crsr_l5_c, "SECONDARY_KEY", &index_crsr);
if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << std::endl; }
ib_cursor_set_cluster_access(index_crsr);
ib_tpl_t key_l5_c = ib_sec_search_tuple_create(index_crsr);
ib_tpl_t key_l5_n = ib_clust_search_tuple_create(crsr_l5_n);
size_t size = pos_custkey_array.size();
int res;
// TODO: first fetches all l5_pos for custkeys
std::vector<uint32_t> l5_pos_array;
for (int i = 0; i < size; ++i) {
// custkey
ib_tuple_write_u32(key_l5_c, 0, pos_custkey_array[i].val);
err = ib_cursor_moveto(index_crsr, key_l5_c, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l5_c" << std::endl;
}
err = ib_cursor_read_row(index_crsr, tpl_l5_c);
if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
}
ib_u32_t l5_pos;
ib_tuple_read_u32(tpl_l5_c, 1, &l5_pos);
l5_pos_array.push_back(l5_pos);
tpl_l5_c = ib_tuple_clear(tpl_l5_c);
}
for (int i = 0; i < size; ++i) {
ib_tuple_write_u32(key_l5_n, 0, l5_pos_array[i]);
err = ib_cursor_moveto(crsr_l5_n, key_l5_n, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l5_c" << std::endl;
}
if (res == 0) {
err = ib_cursor_read_row(crsr_l5_n, tpl_l5_n);
ib_u32_t c_nationkey;
ib_tuple_read_u32(tpl_l5_n, 1, &c_nationkey);
if (c_nationkey == pred_c_nationkey) {
pos_array.push_back(pos_custkey_array[i].pos);
}
}
tpl_l5_n = ib_tuple_clear(tpl_l5_n);
}
ib_tuple_delete(key_l5_c);
ib_tuple_delete(key_l5_n);
ib_cursor_close(index_crsr);
return pos_array;
}
std::vector<im_val_t>
get_l3_custkeys_from_sequences(int pos, int freq)
{
ib_err_t err;
std::vector<im_val_t> pos_custkey_array;
ib_tpl_t key = ib_clust_search_tuple_create(crsr_l3_c);
ib_tuple_write_u32(key, 0, pos);
int res;
static bool moved = false;
if (!moved) {
err = ib_cursor_moveto(crsr_l3_c, key, IB_CUR_GE, &res);
ib_tuple_delete(key);
}
for (uint32_t i = pos; i < pos + freq; ++i) {
err = ib_cursor_read_row(crsr_l3_c, tpl_l3_c);
ib_u32_t custkey;
ib_tuple_read_u32(tpl_l3_c, 1, &custkey);
im_val_t im_val = {i, (uint32_t) custkey};
pos_custkey_array.push_back(im_val);
err = ib_cursor_next(crsr_l3_c);
tpl_l3_c = ib_tuple_clear(tpl_l3_c);
}
return pos_custkey_array;
}
std::vector<im_val_t>
get_l3_orderkeys_from_positions(std::vector<uint32_t> pos_array)
{
ib_err_t err;
std::vector<im_val_t> pos_orderkey_array;
ib_tpl_t key = ib_clust_search_tuple_create(crsr_l3_ok);
int res;
size_t size = pos_array.size();
// TODO: better to scan ?
for (int i = 0; i < size; ++i) {
ib_tuple_write_u32(key, 0, pos_array[i]);
err = ib_cursor_moveto(crsr_l3_ok, key, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l5_c" << std::endl;
}
if (res == 0) {
err = ib_cursor_read_row(crsr_l3_ok, tpl_l3_ok);
ib_u32_t orderkey;
ib_tuple_read_u32(tpl_l3_ok, 1, &orderkey);
//std::cout << "orderkey: " << orderkey << std::endl;
im_val_t im_val = {pos_array[i], (uint32_t) orderkey};
pos_orderkey_array.push_back(im_val);
tpl_l3_ok = ib_tuple_clear(tpl_l3_ok);
}
}
ib_tuple_delete(key);
return pos_orderkey_array;
}
/**
* Try to locate an item in the database. Return a cursor and the tuple to
* the item if I found it in the database.
*
* @param trx the transaction to use
* @param key the key of the item to look up
* @param nkey the size of the key
* @param cursor where to store the cursor (OUT)
* @param tuple where to store the tuple (OUT)
* @return true if I found the object, false otherwise
*/
static bool do_locate_item(ib_trx_t trx,
const void* key,
size_t nkey,
ib_crsr_t *cursor)
{
int res;
ib_tpl_t tuple= NULL;
*cursor= NULL;
checked(ib_cursor_open_table(tablename, trx, cursor));
tuple= ib_clust_search_tuple_create(*cursor);
if (tuple == NULL)
{
fprintf(stderr, "Failed to allocate tuple object\n");
goto error_exit;
}
checked(ib_col_set_value(tuple, key_col_idx, key, nkey));
ib_err_t err= ib_cursor_moveto(*cursor, tuple, IB_CUR_GE, &res);
if (err == DB_SUCCESS && res == 0)
{
ib_tuple_delete(tuple);
return true;
}
else if (err != DB_SUCCESS &&
err != DB_RECORD_NOT_FOUND &&
err != DB_END_OF_INDEX)
{
fprintf(stderr, "ERROR: ib_cursor_moveto(): %s\n", ib_strerror(err));
}
/* FALLTHROUGH */
error_exit:
if (tuple != NULL)
ib_tuple_delete(tuple);
if (*cursor != NULL)
{
ib_err_t cursor_error;
cursor_error= ib_cursor_close(*cursor);
(void) cursor_error;
}
*cursor= NULL;
return false;
}
static void do_get(void* arg)
{
PortState* state = (PortState*)arg;
// Unpack key from work buffer
// table - 8 bytes
// keysz - 1 byte
// key - variable
ib_id_t table ; UNPACK_INT(state->work_buffer, 0, &table);
unsigned char keysz = UNPACK_BYTE(state->work_buffer, sizeof(table));
char* key = UNPACK_BLOB(state->work_buffer, sizeof(table)+1);
ib_trx_t txn = ib_trx_begin(IB_TRX_REPEATABLE_READ);
ib_crsr_t cursor;
FAIL_ON_ERROR(ib_cursor_open_table_using_id(table, txn, &cursor),
ROLLBACK_RETURN(txn));
ib_tpl_t key_tuple = ib_clust_search_tuple_create(cursor);
ib_col_set_value(key_tuple, KEY_COL, key, keysz);
int searchloc;
ib_err_t error = ib_cursor_moveto(cursor, key_tuple, IB_CUR_GE, &searchloc);
// Drop the key tuple -- cursor is at desired location
ib_tuple_delete(key_tuple);
// If we encountered an error, bail
if (error != DB_SUCCESS && error != DB_RECORD_NOT_FOUND && error != DB_END_OF_INDEX)
{
ib_cursor_close(cursor);
send_error_str(state, ib_strerror(error));
ROLLBACK_RETURN(txn);
}
// Found it, read the value and send back to caller
if (searchloc == 0)
{
ib_tpl_t tuple = ib_clust_read_tuple_create(cursor);
// TODO: May need better error handling here
FAIL_ON_ERROR(ib_cursor_read_row(cursor, tuple),
{
ib_tuple_delete(tuple);
ib_cursor_close(cursor);
ROLLBACK_RETURN(txn);
});
int main(int argc, char *argv[])
{
if (!init_db()) { exit(1); }
ib_crsr_t crsr, index_crsr;
ib_tpl_t tpl;
ib_err_t err;
char *l6_orderkey_rle = "l5_customer_key_rle";
char cstore_l6_orderkey_rle[64];
sprintf(cstore_l6_orderkey_rle, "%s/%s", db_name, l6_orderkey_rle);
ib_trx_t ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
err = ib_cursor_open_table(cstore_l6_orderkey_rle, ib_trx, &crsr);
if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l6_orderkey_rle << std::endl; }
err = ib_cursor_open_index_using_name(crsr, "SECONDARY_KEY", &index_crsr);
if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << std::endl; }
ib_cursor_set_cluster_access(index_crsr);
ib_tpl_t key = ib_sec_search_tuple_create(index_crsr);
ib_tuple_write_u32(key, 0, 330575);
int res;
err = ib_cursor_moveto(index_crsr, key, IB_CUR_GE, &res);
std::cout << "res: " << res << std::endl;
assert(err == DB_SUCCESS || err == DB_END_OF_INDEX || err == DB_RECORD_NOT_FOUND);
tpl = ib_clust_read_tuple_create(crsr);
while (err == DB_SUCCESS) {
err = ib_cursor_read_row(index_crsr, tpl);
if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
std::cerr << "not found" << std::endl;
}
ib_u32_t orderkey, pos, freq;
ib_tuple_read_u32(tpl, 0, &orderkey);
ib_tuple_read_u32(tpl, 1, &pos);
ib_tuple_read_u32(tpl, 2, &freq);
std::cout << "orderkey: " << orderkey << ", pos: " << pos << ", freq: " << freq << std::endl;
err = ib_cursor_next(index_crsr);
tpl = ib_tuple_clear(tpl);
break;
}
ib_cursor_close(index_crsr);
ib_cursor_close(crsr);
ib_trx_commit(ib_trx);
fin_db();
return 0;
}
/*********************************************************************
UPDATE T SET score = score + 100 WHERE first = 'a'; */
static
ib_err_t
update_random_rows(
/*===============*/
ib_crsr_t crsr)
{
ib_err_t err;
int l;
char* ptr;
int res = ~0;
ib_tpl_t key_tpl;
ib_tpl_t old_tpl = NULL;
ib_tpl_t new_tpl = NULL;
/* Create a tuple for searching an index. */
key_tpl = ib_sec_search_tuple_create(crsr);
assert(key_tpl != NULL);
ptr = (char*) malloc(8192);
l = gen_rand_text(ptr, 128);
/* Set the value to look for. */
err = ib_col_set_value(key_tpl, 0, ptr, l);
assert(err == DB_SUCCESS);
/* Search for the key using the cluster index (PK) */
err = ib_cursor_moveto(crsr, key_tpl, IB_CUR_GE, &res);
assert(err == DB_SUCCESS
|| err == DB_END_OF_INDEX
|| err == DB_RECORD_NOT_FOUND);
if (key_tpl != NULL) {
ib_tuple_delete(key_tpl);
}
/* Match found */
if (res == 0) {
ib_u32_t score;
const char* first;
ib_ulint_t data_len;
ib_ulint_t first_len;
ib_col_meta_t col_meta;
/* Create the tuple instance that we will use to update the
table. old_tpl is used for reading the existing row and
new_tpl will contain the update row data. */
old_tpl = ib_clust_read_tuple_create(crsr);
assert(old_tpl != NULL);
new_tpl = ib_clust_read_tuple_create(crsr);
assert(new_tpl != NULL);
err = ib_cursor_read_row(crsr, old_tpl);
assert(err == DB_SUCCESS);
/* Get the first column value. */
first = ib_col_get_value(old_tpl, 0);
first_len = ib_col_get_meta(old_tpl, 0, &col_meta);
/* There are no SQL_NULL values in our test data. */
assert(first != NULL);
/* Copy the old contents to the new tuple. */
err = ib_tuple_copy(new_tpl, old_tpl);
/* Update the score column in the new tuple. */
data_len = ib_col_get_meta(old_tpl, 2, &col_meta);
assert(data_len != IB_SQL_NULL);
err = ib_tuple_read_u32(old_tpl, 2, &score);
assert(err == DB_SUCCESS);
++score;
/* Get the new text to insert. */
l = gen_rand_text(ptr, 128);
/* Set the new key value in the new tuple. */
err = ib_col_set_value(new_tpl, 0, ptr, l);
assert(err == DB_SUCCESS);
first_len = ib_col_get_len(new_tpl, 0);
assert(first_len == IB_SQL_NULL || first_len <= 128);
/* Get the new text to insert. */
l = gen_rand_text(ptr, 8192);
/* Set the blob value in the new tuple. */
err = ib_col_set_value(new_tpl, 1, ptr, l);
assert(err == DB_SUCCESS);
/* Set the updated score value in the new tuple. */
err = ib_tuple_write_u32(new_tpl, 2, score);
assert(err == DB_SUCCESS);
err = ib_cursor_update_row(crsr, old_tpl, new_tpl);
assert(err == DB_SUCCESS
|| err == DB_DUPLICATE_KEY);
}
if (old_tpl != NULL) {
ib_tuple_delete(old_tpl);
}
if (new_tpl != NULL) {
ib_tuple_delete(new_tpl);
}
free(ptr);
return(err);
}
std::vector<im_agg_t>
apply_l6_predicate(std::vector<im_val_t> pos_orderkey_array)
{
ib_err_t err;
std::vector<im_agg_t> extendedprice_array;
ib_crsr_t index_crsr;
err = ib_cursor_open_index_using_name(crsr_l6_o, "SECONDARY_KEY", &index_crsr);
if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << std::endl; }
ib_cursor_set_cluster_access(index_crsr);
ib_tpl_t key_l6_o = ib_sec_search_tuple_create(index_crsr);
ib_tpl_t key_l6_s = ib_clust_search_tuple_create(crsr_l6_s);
ib_tpl_t key_l6_e = ib_clust_search_tuple_create(crsr_l6_e);
size_t size = pos_orderkey_array.size();
int res;
for (int i = 0; i < size; ++i) {
uint32_t sum_extendedprice = 0;
ib_tuple_write_u32(key_l6_o, 0, pos_orderkey_array[i].val);
err = ib_cursor_moveto(index_crsr, key_l6_o, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for index_crsr" << std::endl;
}
err = ib_cursor_read_row(index_crsr, tpl_l6_o);
if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
}
ib_u32_t orderkey, pos, freq;
ib_tuple_read_u32(tpl_l6_o, 0, &orderkey);
ib_tuple_read_u32(tpl_l6_o, 1, &pos);
ib_tuple_read_u32(tpl_l6_o, 2, &freq);
//std::cout << "orderkey: " << orderkey << ", pos: " << pos << ", freq: " << freq << std::endl;
if (orderkey != pos_orderkey_array[i].val) {
break;
}
tpl_l6_o = ib_tuple_clear(tpl_l6_o);
for (int i = pos; i < pos + freq; ++i) {
ib_tuple_write_u32(key_l6_s, 0, i);
err = ib_cursor_moveto(crsr_l6_s, key_l6_s, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l6_s" << std::endl;
}
err = ib_cursor_read_row(crsr_l6_s, tpl_l6_s);
ib_u32_t shipdate;
ib_tuple_read_u32(tpl_l6_s, 1, &shipdate);
//std::cout << "shipdate: " << shipdate << std::endl;
if (shipdate > pred_l_shipdate) {
ib_tuple_write_u32(key_l6_e, 0, i);
err = ib_cursor_moveto(crsr_l6_e, key_l6_e, IB_CUR_GE, &res);
if (err != DB_SUCCESS) {
std::cout << "failed moving cursor for l6_e" << std::endl;
}
err = ib_cursor_read_row(crsr_l6_e, tpl_l6_e);
ib_u32_t extendedprice;
ib_tuple_read_u32(tpl_l6_e, 1, &extendedprice);
sum_extendedprice += extendedprice;
tpl_l6_e = ib_tuple_clear(tpl_l6_e);
}
tpl_l6_s = ib_tuple_clear(tpl_l6_s);
}
im_agg_t im_agg = {sum_extendedprice};
extendedprice_array.push_back(im_agg);
}
ib_tuple_delete(key_l6_o);
ib_tuple_delete(key_l6_e);
ib_tuple_delete(key_l6_s);
ib_cursor_close(index_crsr);
return extendedprice_array;
}
/*********************************************************************
UPDATE T SET c1 = RANDOM(string), c3 = MOD(c3 + 1, 10)
WHERE c3 = MOD(RANDOM(INT), 10); */
static
ib_err_t
update_random_rows(
/*===============*/
ib_crsr_t crsr)
{
ib_i32_t c3;
ib_err_t err;
ib_i32_t key;
int res = ~0;
ib_crsr_t index_crsr;
ib_tpl_t sec_key_tpl;
/* Open the secondary index. */
err = ib_cursor_open_index_using_name(crsr, "c3", &index_crsr);
assert(err == DB_SUCCESS);
/* Set the record lock mode */
err = ib_cursor_set_lock_mode(index_crsr, IB_LOCK_X);
assert(err == DB_SUCCESS);
/* Since we will be updating the clustered index record, set the
need to access clustered index flag in the cursor. */
ib_cursor_set_cluster_access(index_crsr);
/* Create a tuple for searching the secondary index. */
sec_key_tpl = ib_sec_search_tuple_create(index_crsr);
assert(sec_key_tpl != NULL);
/* Set the value to look for. */
#ifdef __WIN__
key = rand() % 10;
#else
key = random() % 10;
#endif
err = ib_tuple_write_i32(sec_key_tpl, 0, key);
assert(err == DB_SUCCESS);
/* Search for the key using the cluster index (PK) */
err = ib_cursor_moveto(index_crsr, sec_key_tpl, IB_CUR_GE, &res);
assert(err == DB_SUCCESS
|| err == DB_END_OF_INDEX
|| err == DB_RECORD_NOT_FOUND);
ib_tuple_delete(sec_key_tpl);
/* Match found */
if (res == 0) {
int l;
char* ptr;
const char* first;
ib_ulint_t data_len;
ib_col_meta_t col_meta;
ib_ulint_t first_len;
ib_tpl_t old_tpl = NULL;
ib_tpl_t new_tpl = NULL;
/* Create the tuple instance that we will use to update the
table. old_tpl is used for reading the existing row and
new_tpl will contain the update row data. */
old_tpl = ib_clust_read_tuple_create(crsr);
assert(old_tpl != NULL);
new_tpl = ib_clust_read_tuple_create(crsr);
assert(new_tpl != NULL);
err = ib_cursor_read_row(index_crsr, old_tpl);
assert(err == DB_SUCCESS);
/* Get the first column value. */
first = ib_col_get_value(old_tpl, 0);
first_len = ib_col_get_meta(old_tpl, 0, &col_meta);
/* There are no SQL_NULL values in our test data. */
assert(first != NULL);
/* Copy the old contents to the new tuple. */
err = ib_tuple_copy(new_tpl, old_tpl);
/* Update the c3 column in the new tuple. */
data_len = ib_col_get_meta(old_tpl, 2, &col_meta);
assert(data_len != IB_SQL_NULL);
err = ib_tuple_read_i32(old_tpl, 2, &c3);
assert(err == DB_SUCCESS);
assert(c3 == key);
c3 = (c3 + 1) % 10;
ptr = (char*) malloc(8192);
l = gen_rand_text(ptr, 128);
/* Get the new text to insert. */
l = gen_rand_text(ptr, 8192);
/* Set the new key value in the new tuple. */
err = ib_col_set_value(new_tpl, 0, ptr, l);
assert(err == DB_SUCCESS);
/* Get the new text to insert. */
l = gen_rand_text(ptr, 8192);
/* Set the c2 value in the new tuple. */
err = ib_col_set_value(new_tpl, 1, ptr, l);
assert(err == DB_SUCCESS);
/* Set the updated c3 value in the new tuple. */
err = ib_tuple_write_i32(new_tpl, 2, c3);
assert(err == DB_SUCCESS);
/* NOTE: We are using the secondary index cursor to update
the record and not the cluster index cursor. */
err = ib_cursor_update_row(index_crsr, old_tpl, new_tpl);
assert(err == DB_SUCCESS || err == DB_DUPLICATE_KEY);
/* Reset the old and new tuple instances. */
old_tpl = ib_tuple_clear(old_tpl);
assert(old_tpl != NULL);
new_tpl = ib_tuple_clear(new_tpl);
assert(new_tpl != NULL);
free(ptr);
ib_tuple_delete(old_tpl);
ib_tuple_delete(new_tpl);
}
err = ib_cursor_close(index_crsr);
assert(err == DB_SUCCESS);
return(err);
}
/**********************************************************************
DELETE FROM t2 WHERE c1 == 9
@return DB_SUCCESS or error code */
static
ib_err_t
delete_t2(
/*======*/
void* arg) /*!< in: arguments for callback */
{
ib_err_t err;
int res = ~0;
int nine = 9;
ib_tpl_t key_tpl = NULL;
ib_crsr_t crsr = NULL;
cb_args_t* cb_arg = (cb_args_t *)arg;
tbl_class_t* tbl = cb_arg->tbl;
//fprintf(stderr, "t2: DELETE\n");
err = open_table(tbl->db_name, tbl->name, cb_arg->trx, &crsr);
if (err != DB_SUCCESS) {
goto err_exit;
}
err = ib_cursor_lock(crsr, IB_LOCK_IX);
if (err != DB_SUCCESS) {
goto err_exit;
}
err = ib_cursor_set_lock_mode(crsr, IB_LOCK_X);
if (err != DB_SUCCESS) {
goto err_exit;
}
/* Create a tuple for searching an index. */
key_tpl = ib_sec_search_tuple_create(crsr);
assert(key_tpl != NULL);
/* Set the value to delete. */
err = ib_col_set_value(key_tpl, 0, &nine, 4);
assert(err == DB_SUCCESS);
/* Search for the key using the cluster index (PK) */
err = ib_cursor_moveto(crsr, key_tpl, IB_CUR_GE, &res);
if (res != 0) {
goto clean_exit;
}
if (err != DB_SUCCESS) {
goto err_exit;
}
/* InnoDB handles the updating of all secondary indexes. */
err = ib_cursor_delete_row(crsr);
if (err != DB_SUCCESS) {
goto err_exit;
}
update_err_stats(cb_arg->err_st, err);
goto clean_exit;
err_exit:
update_err_stats(cb_arg->err_st, err);
clean_exit:
if (key_tpl != NULL) {
ib_tuple_delete(key_tpl);
}
if (crsr != NULL) {
ib_err_t err2;
err2 = ib_cursor_close(crsr);
assert(err2 == DB_SUCCESS);
crsr = NULL;
}
return(err);
}
/**********************************************************************
UPDATE t2 SET score = score + 100 AND upd_run = run_number
WHERE c1 == 5
@return DB_SUCCESS or error code */
static
ib_err_t
update_t2(
/*======*/
void* arg) /*!< in: arguments for callback */
{
ib_err_t err;
int res = ~0;
int five = 5;
ib_tpl_t key_tpl = NULL;
ib_tpl_t old_tpl = NULL;
ib_tpl_t new_tpl = NULL;
ib_crsr_t crsr = NULL;
cb_args_t* cb_arg = (cb_args_t *)arg;
tbl_class_t* tbl = cb_arg->tbl;
//fprintf(stderr, "t2: UPDATE\n");
err = open_table(tbl->db_name, tbl->name, cb_arg->trx, &crsr);
if (err != DB_SUCCESS) {
goto err_exit;
}
err = ib_cursor_lock(crsr, IB_LOCK_IX);
if (err != DB_SUCCESS) {
goto err_exit;
}
err = ib_cursor_set_lock_mode(crsr, IB_LOCK_X);
if (err != DB_SUCCESS) {
goto err_exit;
}
err = ib_cursor_set_lock_mode(crsr, IB_LOCK_X);
assert(err == DB_SUCCESS);
/* Create a tuple for searching an index. */
key_tpl = ib_sec_search_tuple_create(crsr);
assert(key_tpl != NULL);
/* Set the value to look for. */
err = ib_col_set_value(key_tpl, 0, &five, 4);
assert(err == DB_SUCCESS);
/* Search for the key using the cluster index (PK) */
err = ib_cursor_moveto(crsr, key_tpl, IB_CUR_GE, &res);
ib_tuple_delete(key_tpl);
if (res != 0) {
goto clean_exit;
} else if (err != DB_SUCCESS) {
goto err_exit;
}
/* Create the tuple instance that we will use to update the
table. old_tpl is used for reading the existing row and
new_tpl will contain the update row data. */
old_tpl = ib_clust_read_tuple_create(crsr);
assert(old_tpl != NULL);
new_tpl = ib_clust_read_tuple_create(crsr);
assert(new_tpl != NULL);
/* Iterate over the records while the first column matches "a". */
while (1) {
ib_u32_t score;
ib_u32_t val;
ib_ulint_t data_len;
ib_col_meta_t col_meta;
err = ib_cursor_read_row(crsr, old_tpl);
assert(err == DB_SUCCESS);
ib_col_get_meta(old_tpl, 0, &col_meta);
err = ib_tuple_read_u32(old_tpl, 0, &val);
assert(err == DB_SUCCESS);
if (val != five) {
goto clean_exit;
}
/* Copy the old contents to the new tuple. */
err = ib_tuple_copy(new_tpl, old_tpl);
/* Update the score column in the new tuple. */
data_len = ib_col_get_meta(old_tpl, 1, &col_meta);
assert(data_len != IB_SQL_NULL);
err = ib_tuple_read_u32(old_tpl, 1, &score);
assert(err == DB_SUCCESS);
score += 100;
/* Set the updated value in the new tuple. */
err = ib_tuple_write_u32(new_tpl, 1, score);
assert(err == DB_SUCCESS);
/* Set the updated value in the new tuple. */
err = ib_tuple_write_u32(new_tpl, 3, cb_arg->run_number);
assert(err == DB_SUCCESS);
err = ib_cursor_update_row(crsr, old_tpl, new_tpl);
if (err != DB_SUCCESS) {
goto err_exit;
}
update_err_stats(cb_arg->err_st, err);
/* Move to the next record to update. */
err = ib_cursor_next(crsr);
if (err != DB_SUCCESS) {
goto err_exit;
}
/* Reset the old and new tuple instances. */
old_tpl = ib_tuple_clear(old_tpl);
assert(old_tpl != NULL);
new_tpl = ib_tuple_clear(new_tpl);
assert(new_tpl != NULL);
}
err_exit:
update_err_stats(cb_arg->err_st, err);
clean_exit:
if (old_tpl != NULL) {
ib_tuple_delete(old_tpl);
}
if (new_tpl != NULL) {
ib_tuple_delete(new_tpl);
}
if (crsr != NULL) {
ib_err_t err2;
err2 = ib_cursor_close(crsr);
assert(err2 == DB_SUCCESS);
crsr = NULL;
}
return(err);
}