/**
 * Flush the entire cache
 * @param when when the cache should be flushed (0 == immediately)
 */
void flush(uint32_t when __attribute__((unused))) 
{
  /* @TODO implement support for when != 0 */
  ib_trx_t transaction= ib_trx_begin(IB_TRX_REPEATABLE_READ);
  ib_crsr_t cursor= NULL;
	ib_err_t err= DB_SUCCESS;

  checked(ib_cursor_open_table(tablename, transaction, &cursor));
  checked(ib_cursor_first(cursor));
  checked(ib_cursor_lock(cursor, IB_LOCK_X));

  do 
  {
    checked(ib_cursor_delete_row(cursor));
  } while ((err= ib_cursor_next(cursor)) == DB_SUCCESS);

  if (err != DB_END_OF_INDEX)
  {
    fprintf(stderr, "Failed to flush the cache: %s\n", ib_strerror(err));
    goto error_exit;
  }
  ib_cursor_close(cursor);
  cursor= NULL;
  checked(ib_trx_commit(transaction));
  return;

 error_exit:
  if (cursor != NULL)
    ib_cursor_close(cursor);

  ib_err_t error= ib_trx_rollback(transaction);
  if (error != DB_SUCCESS)
    fprintf(stderr, "Failed to roll back the transaction:\n\t%s\n",
            ib_strerror(error));
}
Exemplo n.º 2
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;
}
Exemplo n.º 3
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;
}
Exemplo n.º 4
0
/*********************************************************************
SELECT * FROM T; */
static
ib_err_t
do_query(
/*=====*/
	ib_crsr_t	crsr)
{
	ib_err_t	err;
	ib_tpl_t	tpl;

	tpl = ib_clust_read_tuple_create(crsr);
	assert(tpl != NULL);

	err = ib_cursor_first(crsr);
	assert(err == DB_SUCCESS);

	while (err == DB_SUCCESS) {
		err = ib_cursor_read_row(crsr, tpl);

		assert(err == DB_SUCCESS
		       || err == DB_END_OF_INDEX
		       || err == DB_RECORD_NOT_FOUND);

		if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
			break;
		}

		print_tuple(stdout, tpl);

		err = ib_cursor_next(crsr);

		assert(err == DB_SUCCESS
		       || err == DB_END_OF_INDEX
		       || err == DB_RECORD_NOT_FOUND);

		tpl = ib_tuple_clear(tpl);
		assert(tpl != NULL);
	}

	if (tpl != NULL) {
		ib_tuple_delete(tpl);
	}

	if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
		err = DB_SUCCESS;
	}
	return(err);
}
Exemplo n.º 5
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;
}
Exemplo n.º 6
0
int main(int argc,char **argv){
    if(argc != 2){
        printf("give me a database\table name\n");
        return 1;
    }
    char *dtname=argv[1];
    
    ib_err_t err;
    err=ib_init();
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    
    err = ib_cfg_set_int("log_buffer_size", 8*1024*1024);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_int("force_recovery", 1);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_int("log_file_size", 128*1024*1024);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_int("log_files_in_group", 3);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_text("log_group_home_dir", "./");
    //err = ib_cfg_set_text("log_group_home_dir", "/var/lib/mysql/");
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_text("data_home_dir", "./");
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_text("data_file_path", "ibdata1:500M:autoextend");
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err = ib_cfg_set_bool_on("file_per_table");
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }

    err=ib_startup("Antelope");
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }

    ib_trx_t trx;
    ib_crsr_t crsr;
    trx=ib_trx_begin(IB_TRX_REPEATABLE_READ);
    assert(trx != NULL);
    err=ib_cursor_open_table(dtname,trx,&crsr);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    ib_tpl_t tpl;
    tpl=ib_clust_read_tuple_create(crsr);
    assert(tpl != NULL);
    
    err=ib_cursor_first(crsr);
    while(err == DB_SUCCESS){
        err=ib_cursor_read_row(crsr,tpl);
        print_tuple(stdout,tpl);
        err=ib_cursor_next(crsr);
        tpl=ib_tuple_clear(tpl);
    }
    ib_tuple_delete(tpl); 
    err=ib_cursor_close(crsr);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    err=ib_trx_commit(trx);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    
    err=ib_shutdown(IB_SHUTDOWN_NORMAL);
    if(err != DB_SUCCESS){
        puts(ib_strerror(err));
        return err;
    }
    return 0;
}
Exemplo n.º 7
0
void q3(void)
{
  char *l1_shipdate_rle = "l1_shipdate_rle";
  char *l1_extendedprice_uncompressed = "l1_extendedprice_uncompressed";
  char *l3_orderdate_rle = "l3_orderdate_rle";
  char *l3_custkey_uncompressed = "l3_custkey_uncompressed";
  char *l3_orderkey_uncompressed = "l3_orderkey_uncompressed";
  char *l5_customer_key_rle = "l5_customer_key_rle";
  char *l5_nationkey_uncompressed = "l5_nationkey_uncompressed";
  char *l6_orderkey_rle = "l6_orderkey_rle";
  char *l6_extendedprice_uncompressed = "l6_extendedprice_uncompressed";
  char *l6_shipdate_uncompressed = "l6_shipdate_uncompressed";
  char *ji_l3_l1 = "ji_l3-l1";

  char cstore_l1_shipdate_rle[64];
  char cstore_l1_extendedprice_uncompressed[64];
  char cstore_l3_orderdate_rle[64];
  char cstore_l3_custkey_uncompressed[64];
  char cstore_l3_orderkey_uncompressed[64];
  char cstore_l5_customer_key_rle[64];
  char cstore_l5_nationkey_uncompressed[64];
  char cstore_l6_orderkey_rle[64];
  char cstore_l6_extendedprice_uncompressed[64];
  char cstore_l6_shipdate_uncompressed[64];
  char cstore_ji_l3_l1[64];
  sprintf(cstore_l1_shipdate_rle, "%s/%s", db_name, l1_shipdate_rle);
  sprintf(cstore_l1_extendedprice_uncompressed, "%s/%s", db_name, l1_extendedprice_uncompressed);
  sprintf(cstore_l3_orderdate_rle, "%s/%s", db_name, l3_orderdate_rle);
  sprintf(cstore_l3_custkey_uncompressed, "%s/%s", db_name, l3_custkey_uncompressed);
  sprintf(cstore_l3_orderkey_uncompressed, "%s/%s", db_name, l3_orderkey_uncompressed);
  sprintf(cstore_l5_customer_key_rle, "%s/%s", db_name, l5_customer_key_rle);
  sprintf(cstore_l5_nationkey_uncompressed, "%s/%s", db_name, l5_nationkey_uncompressed);
  sprintf(cstore_l6_orderkey_rle, "%s/%s", db_name, l6_orderkey_rle);
  sprintf(cstore_l6_extendedprice_uncompressed, "%s/%s", db_name, l6_extendedprice_uncompressed);
  sprintf(cstore_l6_shipdate_uncompressed, "%s/%s", db_name, l6_shipdate_uncompressed);
  sprintf(cstore_ji_l3_l1, "%s/%s", db_name, ji_l3_l1);

  double t0 = gettimeofday_sec();
  ib_err_t err;
  //ib_crsr_t crsr_l1_s, crsr_l1_e, crsr_l3_o, crsr_l3_c, crsr_l5_c, crsr_l5_n, crsr_ji;

  ib_trx_t ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
  err = ib_cursor_open_table(cstore_l1_shipdate_rle, ib_trx, &crsr_l1_s);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l1_shipdate_rle << std::endl; }
  err = ib_cursor_open_table(cstore_l1_extendedprice_uncompressed, ib_trx, &crsr_l1_e);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l1_extendedprice_uncompressed << std::endl; }
  err = ib_cursor_open_table(cstore_l3_orderdate_rle, ib_trx, &crsr_l3_o);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l3_orderdate_rle << std::endl; }
  err = ib_cursor_open_table(cstore_l3_custkey_uncompressed, ib_trx, &crsr_l3_c);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l3_custkey_uncompressed << std::endl; }
  err = ib_cursor_open_table(cstore_l3_orderkey_uncompressed, ib_trx, &crsr_l3_ok);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l3_orderkey_uncompressed << std::endl; }
  err = ib_cursor_open_table(cstore_l5_customer_key_rle, ib_trx, &crsr_l5_c);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l5_customer_key_rle << std::endl; }
  err = ib_cursor_open_table(cstore_l5_nationkey_uncompressed, ib_trx, &crsr_l5_n);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l5_nationkey_uncompressed << std::endl; }
  err = ib_cursor_open_table(cstore_l6_orderkey_rle, ib_trx, &crsr_l6_o);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l6_orderkey_rle << std::endl; }
  err = ib_cursor_open_table(cstore_l6_extendedprice_uncompressed, ib_trx, &crsr_l6_e);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l6_extendedprice_uncompressed << std::endl; }
  err = ib_cursor_open_table(cstore_l6_shipdate_uncompressed, ib_trx, &crsr_l6_s);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_l6_shipdate_uncompressed << std::endl; }
  err = ib_cursor_open_table(cstore_ji_l3_l1, ib_trx, &crsr_ji);
  if (err != DB_SUCCESS) { std::cout << ib_strerror(err) << " " << cstore_ji_l3_l1 << std::endl; }

  tpl_l1_s = ib_clust_read_tuple_create(crsr_l1_s);
  tpl_l1_e = ib_clust_read_tuple_create(crsr_l1_e);
  tpl_l3_o = ib_clust_read_tuple_create(crsr_l3_o);
  tpl_l3_c = ib_clust_read_tuple_create(crsr_l3_c);
  tpl_l3_ok = ib_clust_read_tuple_create(crsr_l3_ok);
  tpl_l5_c = ib_clust_read_tuple_create(crsr_l5_c);
  tpl_l5_n = ib_clust_read_tuple_create(crsr_l5_n);
  tpl_l6_o = ib_clust_read_tuple_create(crsr_l6_o);
  tpl_l6_e = ib_clust_read_tuple_create(crsr_l6_e);
  tpl_l6_s = ib_clust_read_tuple_create(crsr_l6_s);
  tpl_ji = ib_clust_read_tuple_create(crsr_ji);

  ib_tpl_t key = ib_clust_search_tuple_create(crsr_l3_o);
  ib_tuple_write_u32(key, 0, pred_o_orderdate);
  int res;
  // move cursor
  //err = ib_cursor_moveto(l3_o, key, IB_CUR_L, &res);
  err = ib_cursor_first(crsr_l3_o);
  ib_tuple_delete(key);
  if (err == DB_SUCCESS) {
    //std::cout << "success" << std::endl;
  } else {
    std::cout << "failed" << std::endl;
    ib_cursor_close(crsr_l3_o); 
    return;
  }

  while (err == DB_SUCCESS) {
    err = ib_cursor_read_row(crsr_l3_o, tpl_l3_o);

    /* Possible handle locking and timeout errors too in multi-threaded applications. */
    if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
      break;
    }
    ib_u32_t orderdate, pos, freq;
    ib_tuple_read_u32(tpl_l3_o, 0, &orderdate);
    if (orderdate >= pred_o_orderdate) { break; }
    ib_tuple_read_u32(tpl_l3_o, 1, &pos);
    ib_tuple_read_u32(tpl_l3_o, 2, &freq);

    double t1 = gettimeofday_sec();
    // get L3 o_custkey from position filtering
    std::vector<im_val_t> pos_custkey_array = get_l3_custkeys_from_sequences(pos, freq);
    std::sort(pos_custkey_array.begin(), pos_custkey_array.end(), val_asc);
    /*
    for (int i = 0; i < pos_custkey_array.size(); ++i) {
      std::cout << pos_custkey_array[i].pos << ": " << pos_custkey_array[i].val << std::endl;
    }
    */
    double t2 = gettimeofday_sec();
    std::cout << "orderdate: " << pred_o_orderdate << " get_l3_custkeys_from_sequences: " << t2 - t1 << std::endl;

    // join with L5 and apply c_nationkey predicate
    //std::vector<uint32_t> pos_array = apply_l5_predicate(pos_custkey_array);
    std::vector<uint32_t> pos_array = apply_l5_predicate_scan(pos_custkey_array);
    /*
    for (int i = 0; i < pos_array.size(); ++i) {
      std::cout << "pos: " << pos_array[i] << std::endl;
    }
    */
    double t3 = gettimeofday_sec();
    std::cout << "orderdate: " << pred_o_orderdate << " apply_l5_predicate: " << t3 - t2 << std::endl;

    // get L3 o_orderkey from position filtring
    std::vector<im_val_t> pos_orderkey_array = get_l3_orderkeys_from_positions(pos_array);
    /*
    for (int i = 0; i < pos_orderkey_array.size(); ++i) {
      std::cout << pos_orderkey_array[i].pos << ": " << pos_orderkey_array[i].val << std::endl;
    }
    */
    double t4 = gettimeofday_sec();
    std::cout << "orderdate: " << pred_o_orderdate << " get_l3_orderkeys_from_positions: " << t4 - t3 << std::endl;
    
    // join with L1 apply L1 l_shipdate predicate
    // TODO: we don't need orderkey if we have L3->L1 join-index (we only need positions)
    if (use_ji) {
      std::vector<im_agg_t> extendedprice_array = apply_l1_predicate_via_ji(pos_orderkey_array);
      double t5 = gettimeofday_sec();
      std::cout << "orderdate: " << pred_o_orderdate << " apply_l1_predicate(JI): " << t5 - t4 << std::endl;
    } else {
      std::sort(pos_orderkey_array.begin(), pos_orderkey_array.end(), val_asc);
      std::vector<im_agg_t> extendedprice_array = apply_l6_predicate(pos_orderkey_array);
      double t5 = gettimeofday_sec();
      std::cout << "orderdate: " << pred_o_orderdate << " apply_l6_predicate: " << t5 - t4 << std::endl;
    }

    /*
    for (int i = 0; i < extendedprice_array.size(); ++i) {
      std::cout << "orderdate: " << orderdate << ", orderkey: " << pos_orderkey_array[i].val << ", SUM(extendedprice): " << extendedprice_array[i].agg << std::endl;
    }
    */

    // here we have L3.o_orderdate, L1.l_extendedprice
    // aggratation if needed (omitted)

    err = ib_cursor_next(crsr_l3_o);

    /* Possible handle locking and timeout errors too
    *  in multi-threaded applications. */
    if (err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX) {
      break;
    }
    tpl_l3_o = ib_tuple_clear(tpl_l3_o);
  }
  ib_tuple_delete(tpl_l3_o);
  ib_cursor_close(crsr_l1_s);
  ib_cursor_close(crsr_l1_e);
  ib_cursor_close(crsr_l3_o); 
  ib_cursor_close(crsr_l3_c); 
  ib_cursor_close(crsr_l3_ok); 
  ib_cursor_close(crsr_l5_c); 
  ib_cursor_close(crsr_l5_n); 
  ib_cursor_close(crsr_l6_o); 
  ib_cursor_close(crsr_l6_e); 
  ib_cursor_close(crsr_l6_s); 
  ib_cursor_close(crsr_ji); 
  ib_trx_commit(ib_trx);
  double t6 = gettimeofday_sec();
  std::cout << "orderdate: " << pred_o_orderdate << " total:" << t6-t0 << std::endl;
}
Exemplo n.º 8
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);
}