/** * 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)); }
int main(int argc, char *argv[]) { if (argc != 2) { exit(1); } char db_name[32] = "cstore"; char *table_name = argv[1]; char full_table_name[32]; if (!init_db()) { exit(1); } if (!create_db(db_name)) { std::cerr << "create_db failed" << std::endl; exit(1); } sprintf(full_table_name, "%s/%s", db_name, table_name); if (!create_schema(full_table_name)) { std::cerr << "create_schema failed" << std::endl; exit(1); } ib_crsr_t ib_crsr; std::string line; int i = 0; ib_trx_t ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); ib_cursor_open_table(full_table_name, ib_trx, &ib_crsr); while (getline(std::cin, line)) { std::vector<std::string> strs; boost::split(strs, line, boost::is_any_of(" ") ); ib_tpl_t tpl = ib_clust_read_tuple_create(ib_crsr); ib_tuple_write_u32(tpl, 0, atoi(strs[0].c_str())); ib_tuple_write_u32(tpl, 1, atoi(strs[1].c_str())); ib_tuple_write_u32(tpl, 2, atoi(strs[2].c_str())); ib_err_t err = ib_cursor_insert_row(ib_crsr, tpl); if (err != DB_SUCCESS) { std::cerr << "insert_row failed" << std::endl; } ib_tuple_delete(tpl); if (++i % 10000 == 0) { std::cout << i << std::endl; ib_cursor_close(ib_crsr); ib_trx_commit(ib_trx); ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); ib_cursor_open_table(full_table_name, ib_trx, &ib_crsr); } } ib_cursor_close(ib_crsr); ib_trx_commit(ib_trx); fin_db(); return 0; }
/** * 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; }
static void innostore_drv_stop(ErlDrvData handle) { PortState* state = (PortState*)handle; // Grab the worker lock, in case we have an job running erl_drv_mutex_lock(state->worker_lock); // Signal the shutdown and wait until the current operation has completed state->shutdown_flag = 1; erl_drv_cond_signal(state->worker_cv); while (state->op) { erl_drv_cond_wait(state->worker_cv, state->worker_lock); } // If the port state is not marked as READY, close the cursor and abort the txn if (state->port_state != STATE_READY) { ib_cursor_close(state->cursor); ib_trx_rollback(state->txn); } // No pending jobs and we have the lock again -- join our worker thread erl_drv_cond_signal(state->worker_cv); erl_drv_mutex_unlock(state->worker_lock); erl_drv_thread_join(state->worker, 0); // Cleanup erl_drv_cond_destroy(state->worker_cv); erl_drv_mutex_destroy(state->worker_lock); driver_free(handle); }
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; }
/********************************************************************* Open the secondary indexes on T(C1), T(C2), T(C3). */ static ib_err_t open_sec_index_1( /*=============*/ const char* dbname, /*!< in: database name */ const char* name) /*!< in: table name */ { ib_crsr_t crsr; ib_trx_t ib_trx; ib_err_t err = DB_SUCCESS; char index_name[IB_MAX_TABLE_NAME_LEN]; char table_name[IB_MAX_TABLE_NAME_LEN]; #ifdef __WIN__ sprintf(table_name, "%s/%s", dbname, name); #else snprintf(table_name, sizeof(table_name), "%s/%s", dbname, name); #endif ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); err = ib_cursor_open_table(table_name, ib_trx, &crsr); assert(err == DB_SUCCESS); #ifdef __WIN__ sprintf(index_name, "%s_%s", table_name, "c1"); #else snprintf(index_name, sizeof(index_name), "%s_%s", table_name, "c1"); #endif err = open_sec_index(crsr, index_name); assert(err == DB_SUCCESS); #ifdef __WIN__ sprintf(index_name, "%s_%s", table_name, "c2"); #else snprintf(index_name, sizeof(index_name), "%s_%s", table_name, "c2"); #endif err = open_sec_index(crsr, index_name); assert(err == DB_SUCCESS); #ifdef __WIN__ sprintf(index_name, "%s_%s", table_name, "c3"); #else snprintf(index_name, sizeof(index_name), "%s_%s", table_name, "c3"); #endif err = open_sec_index(crsr, index_name); assert(err == DB_SUCCESS); err = ib_cursor_close(crsr); assert(err == DB_SUCCESS); err = ib_trx_commit(ib_trx); assert(err == DB_SUCCESS); return(err); }
int main(int argc, char* argv[]) { int i; ib_err_t err; ib_crsr_t crsr; ib_trx_t ib_trx; (void) argc; (void) argv; err = ib_init(); assert(err == DB_SUCCESS); test_configure(); err = ib_startup("barracuda"); assert(err == DB_SUCCESS); err = create_database(DATABASE); assert(err == DB_SUCCESS); /* Create the tables. */ for (i = 0; i < 10; i++) { err = create_table(DATABASE, TABLE, i); assert(err == DB_SUCCESS); } ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); assert(ib_trx != NULL); /* Open and close the cursor. */ for (i = 0; i < 10; i++) { err = open_table(DATABASE, TABLE, i, ib_trx, &crsr); assert(err == DB_SUCCESS); err = ib_cursor_close(crsr); assert(err == DB_SUCCESS); crsr = NULL; } err = ib_trx_commit(ib_trx); assert(err == DB_SUCCESS); err = ib_database_drop(DATABASE); assert(err == DB_SUCCESS); err = ib_shutdown(IB_SHUTDOWN_NORMAL); assert(err == DB_SUCCESS); #ifdef UNIV_DEBUG_VALGRIND VALGRIND_DO_LEAK_CHECK; #endif return(EXIT_SUCCESS); }
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; }
/** * 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 ib_err_t test_phase_I(void) /*==============*/ { int i; ib_err_t err; int dups = 0; err = create_database(DATABASE); assert(err == DB_SUCCESS); err = create_table(DATABASE, TABLE); assert(err == DB_SUCCESS); for (i = 0; i < N_TRX; ++i) { ib_crsr_t crsr; ib_trx_t ib_trx; ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); assert(ib_trx != NULL); err = open_table(DATABASE, TABLE, ib_trx, &crsr); assert(err == DB_SUCCESS); err = ib_cursor_lock(crsr, IB_LOCK_IX); assert(err == DB_SUCCESS); err = insert_rows(crsr, i * N_RECS, N_RECS); assert(err == DB_SUCCESS || err == DB_DUPLICATE_KEY); if (err == DB_DUPLICATE_KEY) { ++dups; } err = ib_cursor_close(crsr); assert(err == DB_SUCCESS); crsr = NULL; err = ib_trx_commit(ib_trx); assert(err == DB_SUCCESS); } assert(dups == 0 || dups == N_TRX); return(dups == N_TRX ? DB_DUPLICATE_KEY : DB_SUCCESS); }
/********************************************************************* Open the secondary index. */ static ib_err_t open_sec_index( /*===========*/ ib_crsr_t crsr, /*!< in: table cusor */ const char* index_name) /*!< in: sec. index to open */ { ib_err_t err; ib_crsr_t idx_crsr; err = ib_cursor_open_index_using_name(crsr, index_name, &idx_crsr); assert(err == DB_SUCCESS); err = ib_cursor_close(idx_crsr); assert(err == DB_SUCCESS); return(err); }
/** * Delete an item from the cache * @param trx the transaction to use * @param key the key of the item to delete * @param nkey the length of the key * @return true if we should go ahead and commit the transaction * or false if we should roll back (if the key didn't exists) */ static bool do_delete_item(ib_trx_t trx, const void* key, size_t nkey) { ib_crsr_t cursor= NULL; bool retval= false; if (do_locate_item(trx, key, nkey, &cursor)) { checked(ib_cursor_lock(cursor, IB_LOCK_X)); checked(ib_cursor_delete_row(cursor)); retval= true; } /* Release resources */ /* FALLTHROUGH */ error_exit: if (cursor != NULL) ib_cursor_close(cursor); return retval; }
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 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); }
/********************************************************************** 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); }
int main(int argc, char* argv[]) { int i; ib_err_t err; ib_crsr_t crsr; ib_trx_t ib_trx; #ifdef __WIN__ srand((int) time(NULL)); #else srandom(time(NULL)); #endif err = ib_init(); assert(err == DB_SUCCESS); test_configure(); #ifndef __WIN__ set_options(argc, argv); #endif /* __WIN__ */ err = ib_startup("barracuda"); assert(err == DB_SUCCESS); err = create_database(DATABASE); assert(err == DB_SUCCESS); for (i = 0; i < 10; ++i) { int j; printf("Create table\n"); err = create_table(DATABASE, TABLE); assert(err == DB_SUCCESS); for (j = 0; j < 10; ++j) { ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); assert(ib_trx != NULL); err = open_table(DATABASE, TABLE, ib_trx, &crsr); assert(err == DB_SUCCESS); err = ib_cursor_lock(crsr, IB_LOCK_IX); assert(err == DB_SUCCESS); insert_random_rows(crsr); update_random_rows(crsr); err = ib_cursor_close(crsr); assert(err == DB_SUCCESS); crsr = NULL; err = ib_trx_commit(ib_trx); assert(err == DB_SUCCESS); } printf("Drop table\n"); err = drop_table(DATABASE, TABLE); assert(err == DB_SUCCESS); } err = ib_shutdown(IB_SHUTDOWN_NORMAL); assert(err == DB_SUCCESS); #ifdef UNIV_DEBUG_VALGRIND VALGRIND_DO_LEAK_CHECK; #endif return(EXIT_SUCCESS); }
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; }
int main(int argc, char* argv[]) { ib_err_t err; ib_crsr_t crsr; ib_trx_t ib_trx; (void) argc; (void) argv; err = ib_init(); assert(err == DB_SUCCESS); test_configure(); err = ib_startup("barracuda"); assert(err == DB_SUCCESS); err = create_database(DATABASE); assert(err == DB_SUCCESS); err = create_table(DATABASE, TABLE); assert(err == DB_SUCCESS); ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); assert(ib_trx != NULL); err = open_table(DATABASE, TABLE, ib_trx, &crsr); assert(err == DB_SUCCESS); err = ib_cursor_lock(crsr, IB_LOCK_IX); assert(err == DB_SUCCESS); err = insert_random_rows(crsr); assert(err == DB_SUCCESS); err = ib_cursor_close(crsr); assert(err == DB_SUCCESS); crsr = NULL; err = ib_trx_commit(ib_trx); assert(err == DB_SUCCESS); err = create_sec_index_1(DATABASE, TABLE); assert(err == DB_SUCCESS); err = test_create_temp_index(DATABASE, TABLE, "c2"); err = open_sec_index_1(DATABASE, TABLE); assert(err == DB_SUCCESS); err = drop_table(DATABASE, TABLE); assert(err == DB_SUCCESS); err = ib_shutdown(IB_SHUTDOWN_NORMAL); assert(err == DB_SUCCESS); #ifdef UNIV_DEBUG_VALGRIND VALGRIND_DO_LEAK_CHECK; #endif return(EXIT_SUCCESS); }
/********************************************************************** 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); }
/** * Try to get an item from the database * * @param trx the transaction to use * @param key the key to get * @param nkey the lenght of the key * @return a pointer to the item if I found it in the database */ static struct item* do_get_item(ib_trx_t trx, const void* key, size_t nkey) { ib_crsr_t cursor= NULL; ib_tpl_t tuple= NULL; struct item* retval= NULL; if (do_locate_item(trx, key, nkey, &cursor)) { tuple= ib_clust_read_tuple_create(cursor); if (tuple == NULL) { fprintf(stderr, "Failed to create read tuple\n"); goto error_exit; } checked(ib_cursor_read_row(cursor, tuple)); ib_col_meta_t meta; ib_ulint_t datalen= ib_col_get_meta(tuple, data_col_idx, &meta); ib_ulint_t flaglen= ib_col_get_meta(tuple, flags_col_idx, &meta); ib_ulint_t caslen= ib_col_get_meta(tuple, cas_col_idx, &meta); ib_ulint_t explen= ib_col_get_meta(tuple, exp_col_idx, &meta); const void *dataptr= ib_col_get_value(tuple, data_col_idx); retval= create_item(key, nkey, dataptr, datalen, 0, 0); if (retval == NULL) { fprintf(stderr, "Failed to allocate memory\n"); goto error_exit; } if (flaglen != 0) { ib_u32_t val; checked(ib_tuple_read_u32(tuple, flags_col_idx, &val)); retval->flags= (uint32_t)val; } if (caslen != 0) { ib_u64_t val; checked(ib_tuple_read_u64(tuple, cas_col_idx, &val)); retval->cas= (uint64_t)val; } if (explen != 0) { ib_u32_t val; checked(ib_tuple_read_u32(tuple, exp_col_idx, &val)); retval->exp= (time_t)val; } } /* Release resources */ /* 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; } return retval; }
/********************************************************************* 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); }
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; }
int main(int argc, char* argv[]) { ib_err_t err; ib_crsr_t crsr; ib_trx_t ib_trx; (void)argc; (void)argv; err = ib_init(); assert(err == DB_SUCCESS); test_configure(); err = ib_startup("barracuda"); assert(err == DB_SUCCESS); err = create_database(DATABASE); assert(err == DB_SUCCESS); printf("Create table\n"); err = create_table(DATABASE, TABLE); assert(err == DB_SUCCESS); printf("Begin transaction\n"); ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ); assert(ib_trx != NULL); printf("Open cursor\n"); err = open_table(DATABASE, TABLE, ib_trx, &crsr); assert(err == DB_SUCCESS); printf("Lock table in IX\n"); err = ib_cursor_lock(crsr, IB_LOCK_IX); assert(err == DB_SUCCESS); printf("Insert rows\n"); err = insert_rows(crsr); assert(err == DB_SUCCESS); printf("Query table\n"); err = do_query(crsr); assert(err == DB_SUCCESS); printf("Close cursor\n"); err = ib_cursor_close(crsr); assert(err == DB_SUCCESS); crsr = NULL; printf("Commit transaction\n"); err = ib_trx_commit(ib_trx); assert(err == DB_SUCCESS); printf("Drop table\n"); err = drop_table(DATABASE, TABLE); assert(err == DB_SUCCESS); err = ib_shutdown(IB_SHUTDOWN_NORMAL); assert(err == DB_SUCCESS); #ifdef UNIV_DEBUG_VALGRIND VALGRIND_DO_LEAK_CHECK; #endif return(EXIT_SUCCESS); }