/**
* Store an item into the database. Update the CAS id on the item before
* storing it in the database.
*
* @param trx the transaction to use
* @param item the item to store
* @return true if we can go ahead and commit the transaction, false otherwise
*/
static bool do_put_item(ib_trx_t trx, struct item* item)
{
update_cas(item);
ib_crsr_t cursor= NULL;
ib_tpl_t tuple= NULL;
bool retval= false;
checked(ib_cursor_open_table(tablename, trx, &cursor));
checked(ib_cursor_lock(cursor, IB_LOCK_X));
tuple= ib_clust_read_tuple_create(cursor);
checked(ib_col_set_value(tuple, key_col_idx, item->key, item->nkey));
checked(ib_col_set_value(tuple, data_col_idx, item->data, item->size));
checked(ib_tuple_write_u32(tuple, flags_col_idx, item->flags));
checked(ib_tuple_write_u64(tuple, cas_col_idx, item->cas));
checked(ib_tuple_write_u32(tuple, exp_col_idx, (ib_u32_t)item->exp));
checked(ib_cursor_insert_row(cursor, tuple));
retval= true;
/* Release resources: */
/* FALLTHROUGH */
error_exit:
if (tuple != NULL)
ib_tuple_delete(tuple);
if (cursor != NULL)
ib_cursor_close(cursor);
return retval;
}
/*********************************************************************
INSERT INTO T VALUE(N, RANDOM(n), RANDOM(n)); */
static
ib_err_t
insert_rows(
/*========*/
ib_crsr_t crsr, /*!< in, out: cursor to use for write */
int start, /*!< in: in: start of c1 value */
int count) /*!< in: number of rows to insert */
{
int i;
int dups = 0;
ib_tpl_t tpl = NULL;
ib_err_t err = DB_ERROR;
char* ptr = malloc(8192);
assert(ptr != NULL);
tpl = ib_clust_read_tuple_create(crsr);
assert(tpl != NULL);
for (i = start; i < start + count; ++i) {
int l;
err = ib_tuple_write_i32(tpl, 0, i);
assert(err == DB_SUCCESS);
l = gen_rand_text(ptr, C2_MAX_LEN);
err = ib_col_set_value(tpl, 1, ptr, l);
assert(err == DB_SUCCESS);
l = gen_rand_text(ptr, C3_MAX_LEN);
err = ib_col_set_value(tpl, 2, ptr, l);
assert(err == DB_SUCCESS);
err = ib_cursor_insert_row(crsr, tpl);
assert(err == DB_SUCCESS || err == DB_DUPLICATE_KEY);
if (err == DB_DUPLICATE_KEY) {
err = DB_SUCCESS;
++dups;
}
}
if (tpl != NULL) {
ib_tuple_delete(tpl);
}
free(ptr);
if (err == DB_SUCCESS) {
if (dups == count) {
err = DB_DUPLICATE_KEY;
printf("Recover OK\n");
} else {
assert(dups == 0);
printf("Insert OK\n");
}
}
return(err);
}
/*********************************************************************
INSERT INTO T VALUE(RANDOM(TEXT), RANDOM(TEXT), 0); */
static
ib_err_t
insert_random_rows(
/*===============*/
ib_crsr_t crsr) /*!< in, out: cursor to use for write */
{
int i;
ib_err_t err;
ib_tpl_t tpl = NULL;
char* ptr = malloc(8192);
tpl = ib_clust_read_tuple_create(crsr);
assert(tpl != NULL);
for (i = 0; i < 100; ++i) {
int l;
l = gen_rand_text(ptr, 128);
err = ib_col_set_value(tpl, 0, ptr, l);
assert(err == DB_SUCCESS);
l = gen_rand_text(ptr, 8192);
err = ib_col_set_value(tpl, 1, ptr, l);
assert(err == DB_SUCCESS);
err = ib_tuple_write_u32(tpl, 2, 0);
assert(err == DB_SUCCESS);
err = ib_cursor_insert_row(crsr, tpl);
assert(err == DB_SUCCESS || err == DB_DUPLICATE_KEY);
tpl = ib_tuple_clear(tpl);
assert(tpl != NULL);
}
if (tpl != NULL) {
ib_tuple_delete(tpl);
}
free(ptr);
return(err);
}
/*********************************************************************
INSERT INTO T VALUE(c1, c2, c3, c4, c5, c6); */
static
ib_err_t
insert_rows(
/*========*/
ib_crsr_t crsr) /*!< in, out: cursor to use for write */
{
ib_err_t err;
ib_tpl_t tpl = NULL;
tpl = ib_clust_read_tuple_create(crsr);
assert(tpl != NULL);
err = ib_col_set_value(tpl, 0, "abcdefghij", 10);
assert(err == DB_SUCCESS);
err = ib_tuple_write_float(tpl, 2, 2.0);
assert(err == DB_SUCCESS);
err = ib_tuple_write_double(tpl, 3, 3.0);
assert(err == DB_SUCCESS);
err = ib_col_set_value(tpl, 4, "BLOB", 4);
assert(err == DB_SUCCESS);
err = ib_col_set_value(tpl, 5, "1.23", 4);
assert(err == DB_SUCCESS);
/* Check for NULL constraint violation. */
err = ib_cursor_insert_row(crsr, tpl);
assert(err == DB_DATA_MISMATCH);
/* Set column C2 value and retry operation. */
err = ib_tuple_write_u32(tpl, 1, 1);
assert(err == DB_SUCCESS);
err = ib_cursor_insert_row(crsr, tpl);
assert(err == DB_SUCCESS);
ib_tuple_delete(tpl);
return(DB_SUCCESS);
}
/**
* 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);
});
/*********************************************************************
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);
}
/*********************************************************************
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);
}
/**********************************************************************
INSERT INTO t2 VALUES (<rand 1-100>, 0, run_number, 0)
@return DB_SUCCESS or error code */
static
ib_err_t
insert_t2(
/*======*/
void* arg) /*!< in: arguments for callback */
{
int i;
ib_err_t err;
ib_crsr_t crsr = NULL;
ib_tpl_t tpl = NULL;
cb_args_t* cb_arg = (cb_args_t *)arg;
tbl_class_t* tbl = cb_arg->tbl;
//fprintf(stderr, "t2: INSERT\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;
}
tpl = ib_clust_read_tuple_create(crsr);
assert(tpl != NULL);
for (i = 0; i < cb_arg->batch_size; ++i) {
int val = 0;
int zero = 0;
val = random() % key_range;
err = ib_col_set_value(tpl, 0, &val, 4);
assert(err == DB_SUCCESS);
err = ib_col_set_value(tpl, 1, &zero, 4);
assert(err == DB_SUCCESS);
err = ib_col_set_value(tpl, 2, &cb_arg->run_number, 4);
assert(err == DB_SUCCESS);
err = ib_col_set_value(tpl, 3, &zero, 4);
assert(err == DB_SUCCESS);
err = ib_cursor_insert_row(crsr, tpl);
if (err != DB_SUCCESS) {
goto err_exit;
}
update_err_stats(cb_arg->err_st, err);
tpl = ib_tuple_clear(tpl);
assert(tpl != NULL);
}
goto clean_exit;
err_exit:
update_err_stats(cb_arg->err_st, err);
clean_exit:
if (tpl != NULL) {
ib_tuple_delete(tpl);
}
if (crsr != NULL) {
ib_err_t err2;
err2 = ib_cursor_close(crsr);
assert(err2 == DB_SUCCESS);
crsr = NULL;
}
return(err);
}
