Example #1
0
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;
}
Example #2
0
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;
}
Example #3
0
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;
}
Example #4
0
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;
}
Example #6
0
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);
                      });
Example #7
0
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;
}
Example #8
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);
}
Example #9
0
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;
}
Example #10
0
/*********************************************************************
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);
}
Example #11
0
/**********************************************************************
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);
}
Example #12
0
/**********************************************************************
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);
}