void
test_mem_index_read
(void)
{
redirect_stderr();
index_t * index = index_build("examples/repeats.fa", "test_base30");
test_assert_critical(index != NULL);
test_assert(index_ann_new(25, 1, 1, index) == 0);
// Set alloc failure rate to 0.1.
set_alloc_failure_rate_to(0.1);
for (int i = 0; i < 1000; i++) {
index_t * index_i = index_read("test_base30");
index_free(index_i);
}
reset_alloc();
// Set alloc countdown 0->10.
for (int i = 0; i <= 200; i++) {
set_alloc_failure_countdown_to(i);
index_t * index_i = index_read("test_base30");
index_free(index_i);
}
reset_alloc();
index_free(index);
unredirect_stderr();
}
RC
index_btree::index_read(idx_key_t key,
itemid_t *& item,
int part_id) {
return index_read(key, item, 0, part_id);
}
inline RC TPCCTxnManager::run_payment_0(uint64_t w_id, uint64_t d_id, uint64_t d_w_id, double h_amount, row_t *& r_wh_local) {
uint64_t key;
itemid_t * item;
/*====================================================+
EXEC SQL UPDATE warehouse SET w_ytd = w_ytd + :h_amount
WHERE w_id=:w_id;
+====================================================*/
/*===================================================================+
EXEC SQL SELECT w_street_1, w_street_2, w_city, w_state, w_zip, w_name
INTO :w_street_1, :w_street_2, :w_city, :w_state, :w_zip, :w_name
FROM warehouse
WHERE w_id=:w_id;
+===================================================================*/
RC rc;
key = w_id;
INDEX * index = _wl->i_warehouse;
item = index_read(index, key, wh_to_part(w_id));
assert(item != NULL);
row_t * r_wh = ((row_t *)item->location);
if (g_wh_update)
rc = get_row(r_wh, WR, r_wh_local);
else
rc = get_row(r_wh, RD, r_wh_local);
return rc;
}
// new_order 2
inline RC TPCCTxnManager::new_order_8(uint64_t w_id,uint64_t d_id,bool remote, uint64_t ol_i_id, uint64_t ol_supply_w_id, uint64_t ol_quantity,uint64_t ol_number,uint64_t o_id, row_t *& r_stock_local) {
uint64_t key;
itemid_t * item;
/*===================================================================+
EXEC SQL SELECT s_quantity, s_data,
s_dist_01, s_dist_02, s_dist_03, s_dist_04, s_dist_05,
s_dist_06, s_dist_07, s_dist_08, s_dist_09, s_dist_10
INTO :s_quantity, :s_data,
:s_dist_01, :s_dist_02, :s_dist_03, :s_dist_04, :s_dist_05,
:s_dist_06, :s_dist_07, :s_dist_08, :s_dist_09, :s_dist_10
FROM stock
WHERE s_i_id = :ol_i_id AND s_w_id = :ol_supply_w_id;
EXEC SQL UPDATE stock SET s_quantity = :s_quantity
WHERE s_i_id = :ol_i_id
AND s_w_id = :ol_supply_w_id;
+===============================================*/
key = stockKey(ol_i_id, ol_supply_w_id);
INDEX * index = _wl->i_stock;
item = index_read(index, key, wh_to_part(ol_supply_w_id));
assert(item != NULL);
row_t * r_stock = ((row_t *)item->location);
RC rc = get_row(r_stock, WR, r_stock_local);
return rc;
}
struct backentry *
uniqueid2entry(
backend *be,
const char *uniqueid,
back_txn *txn,
int *err
)
{
#ifdef UUIDCACHE_ON
ldbm_instance *inst = (ldbm_instance *) be->be_instance_info;
#endif
struct berval idv;
IDList *idl = NULL;
struct backentry *e = NULL;
slapi_log_err(SLAPI_LOG_TRACE, "uniqueid2entry", "=> \"%s\"\n", uniqueid);
#ifdef UUIDCACHE_ON
e = cache_find_uuid(&inst->inst_cache, uniqueid);
#endif
if (e == NULL) {
/* convert dn to entry id */
PR_ASSERT(uniqueid);
*err = 0;
idv.bv_val = (void*)uniqueid;
idv.bv_len = strlen( idv.bv_val );
if ( (idl = index_read( be, SLAPI_ATTR_UNIQUEID, indextype_EQUALITY, &idv, txn,
err )) == NULL ) {
if ( *err != 0 && *err != DB_NOTFOUND ) {
goto ext;
}
} else {
/* convert entry id to entry */
if ( (e = id2entry( be, idl_firstid( idl ), txn, err ))
!= NULL ) {
goto ext;
} else {
if ( *err != 0 && *err != DB_NOTFOUND ) {
goto ext;
}
/*
* this is pretty bad anyway. the dn was in the
* SLAPI_ATTR_UNIQUEID index, but we could not
* read the entry from the id2entry index.
* what should we do?
*/
}
}
} else {
goto ext;
}
ext:
if (NULL != idl) {
slapi_ch_free( (void**)&idl);
}
slapi_log_err(SLAPI_LOG_TRACE, "uniqueid2entry", "<= %p\n", e);
return( e );
}
bool index_read_data(index_data *data, std::size_t n, int idxfd, int logfd) {
index_record rec;
if ( !index_read(&rec, n, idxfd) )
return false;
return index_read_data(data, rec, logfd);
}
inline RC TPCCTxnManager::new_order_2(uint64_t w_id, uint64_t d_id, uint64_t c_id, bool remote, uint64_t ol_cnt,uint64_t o_entry_d, uint64_t * o_id, row_t *& r_cust_local) {
uint64_t key;
itemid_t * item;
key = custKey(c_id, d_id, w_id);
INDEX * index = _wl->i_customer_id;
item = index_read(index, key, wh_to_part(w_id));
assert(item != NULL);
row_t * r_cust = (row_t *) item->location;
RC rc = get_row(r_cust, RD, r_cust_local);
return rc;
}
/* Read and initialize global index */
int
index_initialize(char *path)
{
FILE *fp;
WINDOW *w = NULL;
if (!index_initted) {
w = savescr();
dialog_clear_norefresh();
have_volumes = FALSE;
low_volume = high_volume = 0;
/* Got any media? */
if (!mediaVerify()) {
restorescr(w);
return DITEM_FAILURE;
}
/* Does it move when you kick it? */
if (!DEVICE_INIT(mediaDevice)) {
restorescr(w);
return DITEM_FAILURE;
}
dialog_clear_norefresh();
msgNotify("Attempting to fetch %s file from selected media.", path);
fp = DEVICE_GET(mediaDevice, path, TRUE);
if (!fp) {
msgConfirm("Unable to get packages/INDEX file from selected media.\n\n"
"This may be because the packages collection is not available\n"
"on the distribution media you've chosen, most likely an FTP site\n"
"without the packages collection mirrored. Please verify that\n"
"your media, or your path to the media, is correct and try again.");
DEVICE_SHUTDOWN(mediaDevice);
restorescr(w);
return DITEM_FAILURE;
}
dialog_clear_norefresh();
msgNotify("Located INDEX, now reading package data from it...");
index_init(&Top, &Plist);
if (index_read(fp, &Top)) {
msgConfirm("I/O or format error on packages/INDEX file.\n"
"Please verify media (or path to media) and try again.");
fclose(fp);
restorescr(w);
return DITEM_FAILURE;
}
fclose(fp);
index_sort(&Top);
index_initted = TRUE;
restorescr(w);
}
return DITEM_SUCCESS;
}
inline RC TPCCTxnManager::run_payment_2(uint64_t w_id, uint64_t d_id, uint64_t d_w_id, double h_amount, row_t *& r_dist_local) {
/*=====================================================+
EXEC SQL UPDATE district SET d_ytd = d_ytd + :h_amount
WHERE d_w_id=:w_id AND d_id=:d_id;
+=====================================================*/
uint64_t key;
itemid_t * item;
key = distKey(d_id, d_w_id);
item = index_read(_wl->i_district, key, wh_to_part(w_id));
assert(item != NULL);
row_t * r_dist = ((row_t *)item->location);
RC rc = get_row(r_dist, WR, r_dist_local);
return rc;
}
RC YCSBTxnManager::run_ycsb_0(ycsb_request * req,row_t *& row_local) {
RC rc = RCOK;
int part_id = _wl->key_to_part( req->key );
access_t type = req->acctype;
itemid_t * m_item;
m_item = index_read(_wl->the_index, req->key, part_id);
row_t * row = ((row_t *)m_item->location);
rc = get_row(row, type,row_local);
return rc;
}
// new_order 1
// Read from replicated read-only item table
inline RC TPCCTxnManager::new_order_6(uint64_t ol_i_id, row_t *& r_item_local) {
uint64_t key;
itemid_t * item;
/*===========================================+
EXEC SQL SELECT i_price, i_name , i_data
INTO :i_price, :i_name, :i_data
FROM item
WHERE i_id = :ol_i_id;
+===========================================*/
key = ol_i_id;
item = index_read(_wl->i_item, key, 0);
assert(item != NULL);
row_t * r_item = ((row_t *)item->location);
RC rc = get_row(r_item, RD, r_item_local);
return rc;
}
inline RC TPCCTxnManager::new_order_4(uint64_t w_id, uint64_t d_id, uint64_t c_id, bool remote, uint64_t ol_cnt,uint64_t o_entry_d, uint64_t * o_id, row_t *& r_dist_local) {
uint64_t key;
itemid_t * item;
/*==================================================+
EXEC SQL SELECT d_next_o_id, d_tax
INTO :d_next_o_id, :d_tax
FROM district WHERE d_id = :d_id AND d_w_id = :w_id;
EXEC SQL UPDATE d istrict SET d _next_o_id = :d _next_o_id + 1
WH ERE d _id = :d_id AN D d _w _id = :w _id ;
+===================================================*/
key = distKey(d_id, w_id);
item = index_read(_wl->i_district, key, wh_to_part(w_id));
assert(item != NULL);
row_t * r_dist = ((row_t *)item->location);
RC rc = get_row(r_dist, WR, r_dist_local);
return rc;
}
// new_order 0
inline RC TPCCTxnManager::new_order_0(uint64_t w_id, uint64_t d_id, uint64_t c_id, bool remote, uint64_t ol_cnt,uint64_t o_entry_d, uint64_t * o_id, row_t *& r_wh_local) {
uint64_t key;
itemid_t * item;
/*=======================================================================+
EXEC SQL SELECT c_discount, c_last, c_credit, w_tax
INTO :c_discount, :c_last, :c_credit, :w_tax
FROM customer, warehouse
WHERE w_id = :w_id AND c_w_id = w_id AND c_d_id = :d_id AND c_id = :c_id;
+========================================================================*/
key = w_id;
INDEX * index = _wl->i_warehouse;
item = index_read(index, key, wh_to_part(w_id));
assert(item != NULL);
row_t * r_wh = ((row_t *)item->location);
RC rc = get_row(r_wh, RD, r_wh_local);
return rc;
}
RC YCSBTxnManager::acquire_locks() {
uint64_t starttime = get_sys_clock();
assert(CC_ALG == CALVIN);
YCSBQuery* ycsb_query = (YCSBQuery*) query;
locking_done = false;
RC rc = RCOK;
incr_lr();
assert(ycsb_query->requests.size() == g_req_per_query);
assert(phase == CALVIN_RW_ANALYSIS);
for (uint32_t rid = 0; rid < ycsb_query->requests.size(); rid ++) {
ycsb_request * req = ycsb_query->requests[rid];
uint64_t part_id = _wl->key_to_part( req->key );
DEBUG("LK Acquire (%ld,%ld) %d,%ld -> %ld\n",get_txn_id(),get_batch_id(),req->acctype,req->key,GET_NODE_ID(part_id));
if(GET_NODE_ID(part_id) != g_node_id)
continue;
INDEX * index = _wl->the_index;
itemid_t * item;
item = index_read(index, req->key, part_id);
row_t * row = ((row_t *)item->location);
RC rc2 = get_lock(row,req->acctype);
if(rc2 != RCOK) {
rc = rc2;
}
}
if(decr_lr() == 0) {
if(ATOM_CAS(lock_ready,false,true))
rc = RCOK;
}
txn_stats.wait_starttime = get_sys_clock();
/*
if(rc == WAIT && lock_ready_cnt == 0) {
if(ATOM_CAS(lock_ready,false,true))
//lock_ready = true;
rc = RCOK;
}
*/
INC_STATS(get_thd_id(),calvin_sched_time,get_sys_clock() - starttime);
locking_done = true;
return rc;
}
RC TPCCTxnManager::acquire_locks() {
uint64_t starttime = get_sys_clock();
assert(CC_ALG == CALVIN);
locking_done = false;
RC rc = RCOK;
RC rc2;
INDEX * index;
itemid_t * item;
row_t* row;
uint64_t key;
incr_lr();
TPCCQuery* tpcc_query = (TPCCQuery*) query;
uint64_t w_id = tpcc_query->w_id;
uint64_t d_id = tpcc_query->d_id;
uint64_t c_id = tpcc_query->c_id;
uint64_t d_w_id = tpcc_query->d_w_id;
uint64_t c_w_id = tpcc_query->c_w_id;
uint64_t c_d_id = tpcc_query->c_d_id;
char * c_last = tpcc_query->c_last;
uint64_t part_id_w = wh_to_part(w_id);
uint64_t part_id_c_w = wh_to_part(c_w_id);
switch(tpcc_query->txn_type) {
case TPCC_PAYMENT:
if(GET_NODE_ID(part_id_w) == g_node_id) {
// WH
index = _wl->i_warehouse;
item = index_read(index, w_id, part_id_w);
row_t * row = ((row_t *)item->location);
rc2 = get_lock(row,g_wh_update? WR:RD);
if(rc2 != RCOK)
rc = rc2;
// Dist
key = distKey(d_id, d_w_id);
item = index_read(_wl->i_district, key, part_id_w);
row = ((row_t *)item->location);
rc2 = get_lock(row, WR);
if(rc2 != RCOK)
rc = rc2;
}
if(GET_NODE_ID(part_id_c_w) == g_node_id) {
// Cust
if (tpcc_query->by_last_name) {
key = custNPKey(c_last, c_d_id, c_w_id);
index = _wl->i_customer_last;
item = index_read(index, key, part_id_c_w);
int cnt = 0;
itemid_t * it = item;
itemid_t * mid = item;
while (it != NULL) {
cnt ++;
it = it->next;
if (cnt % 2 == 0)
mid = mid->next;
}
row = ((row_t *)mid->location);
}
else {
key = custKey(c_id, c_d_id, c_w_id);
index = _wl->i_customer_id;
item = index_read(index, key, part_id_c_w);
row = (row_t *) item->location;
}
rc2 = get_lock(row, WR);
if(rc2 != RCOK)
rc = rc2;
}
break;
case TPCC_NEW_ORDER:
if(GET_NODE_ID(part_id_w) == g_node_id) {
// WH
index = _wl->i_warehouse;
item = index_read(index, w_id, part_id_w);
row_t * row = ((row_t *)item->location);
rc2 = get_lock(row,RD);
if(rc2 != RCOK)
rc = rc2;
// Cust
index = _wl->i_customer_id;
key = custKey(c_id, d_id, w_id);
item = index_read(index, key, wh_to_part(w_id));
row = (row_t *) item->location;
rc2 = get_lock(row, RD);
if(rc2 != RCOK)
rc = rc2;
// Dist
key = distKey(d_id, w_id);
item = index_read(_wl->i_district, key, wh_to_part(w_id));
row = ((row_t *)item->location);
rc2 = get_lock(row, WR);
if(rc2 != RCOK)
rc = rc2;
}
// Items
for(uint64_t i = 0; i < tpcc_query->ol_cnt; i++) {
if(GET_NODE_ID(wh_to_part(tpcc_query->items[i]->ol_supply_w_id)) != g_node_id)
continue;
key = tpcc_query->items[i]->ol_i_id;
item = index_read(_wl->i_item, key, 0);
row = ((row_t *)item->location);
rc2 = get_lock(row, RD);
if(rc2 != RCOK)
rc = rc2;
key = stockKey(tpcc_query->items[i]->ol_i_id, tpcc_query->items[i]->ol_supply_w_id);
index = _wl->i_stock;
item = index_read(index, key, wh_to_part(tpcc_query->items[i]->ol_supply_w_id));
row = ((row_t *)item->location);
rc2 = get_lock(row, WR);
if(rc2 != RCOK)
rc = rc2;
}
break;
default: assert(false);
}
if(decr_lr() == 0) {
if(ATOM_CAS(lock_ready,false,true))
rc = RCOK;
}
txn_stats.wait_starttime = get_sys_clock();
locking_done = true;
INC_STATS(get_thd_id(),calvin_sched_time,get_sys_clock() - starttime);
return rc;
}
inline RC TPCCTxnManager::run_payment_4(uint64_t w_id, uint64_t d_id,uint64_t c_id,uint64_t c_w_id, uint64_t c_d_id, char * c_last, double h_amount, bool by_last_name, row_t *& r_cust_local) {
/*====================================================================+
EXEC SQL SELECT d_street_1, d_street_2, d_city, d_state, d_zip, d_name
INTO :d_street_1, :d_street_2, :d_city, :d_state, :d_zip, :d_name
FROM district
WHERE d_w_id=:w_id AND d_id=:d_id;
+====================================================================*/
itemid_t * item;
uint64_t key;
row_t * r_cust;
if (by_last_name) {
/*==========================================================+
EXEC SQL SELECT count(c_id) INTO :namecnt
FROM customer
WHERE c_last=:c_last AND c_d_id=:c_d_id AND c_w_id=:c_w_id;
+==========================================================*/
/*==========================================================================+
EXEC SQL DECLARE c_byname CURSOR FOR
SELECT c_first, c_middle, c_id, c_street_1, c_street_2, c_city, c_state,
c_zip, c_phone, c_credit, c_credit_lim, c_discount, c_balance, c_since
FROM customer
WHERE c_w_id=:c_w_id AND c_d_id=:c_d_id AND c_last=:c_last
ORDER BY c_first;
EXEC SQL OPEN c_byname;
+===========================================================================*/
key = custNPKey(c_last, c_d_id, c_w_id);
// XXX: the list is not sorted. But let's assume it's sorted...
// The performance won't be much different.
INDEX * index = _wl->i_customer_last;
item = index_read(index, key, wh_to_part(c_w_id));
assert(item != NULL);
int cnt = 0;
itemid_t * it = item;
itemid_t * mid = item;
while (it != NULL) {
cnt ++;
it = it->next;
if (cnt % 2 == 0)
mid = mid->next;
}
r_cust = ((row_t *)mid->location);
/*============================================================================+
for (n=0; n<namecnt/2; n++) {
EXEC SQL FETCH c_byname
INTO :c_first, :c_middle, :c_id,
:c_street_1, :c_street_2, :c_city, :c_state, :c_zip,
:c_phone, :c_credit, :c_credit_lim, :c_discount, :c_balance, :c_since;
}
EXEC SQL CLOSE c_byname;
+=============================================================================*/
// XXX: we don't retrieve all the info, just the tuple we are interested in
}
else { // search customers by cust_id
/*=====================================================================+
EXEC SQL SELECT c_first, c_middle, c_last, c_street_1, c_street_2,
c_city, c_state, c_zip, c_phone, c_credit, c_credit_lim,
c_discount, c_balance, c_since
INTO :c_first, :c_middle, :c_last, :c_street_1, :c_street_2,
:c_city, :c_state, :c_zip, :c_phone, :c_credit, :c_credit_lim,
:c_discount, :c_balance, :c_since
FROM customer
WHERE c_w_id=:c_w_id AND c_d_id=:c_d_id AND c_id=:c_id;
+======================================================================*/
key = custKey(c_id, c_d_id, c_w_id);
INDEX * index = _wl->i_customer_id;
item = index_read(index, key, wh_to_part(c_w_id));
assert(item != NULL);
r_cust = (row_t *) item->location;
}
/*======================================================================+
EXEC SQL UPDATE customer SET c_balance = :c_balance, c_data = :c_new_data
WHERE c_w_id = :c_w_id AND c_d_id = :c_d_id AND c_id = :c_id;
+======================================================================*/
RC rc = get_row(r_cust, WR, r_cust_local);
return rc;
}
int
cmd_status (const char *path, bool recursive)
{
state_t ur = STATE_INITIALIZER;
struct index index = INDEX_INITIALIZER;
struct stat64 st_buf;
DIR *dp;
struct dirent *ep;
struct list_elem *e;
char *branchname = NULL;
if (lstat64 (path, &st_buf) != 0) fail("%s does not exist", path);
ASSERT (st_buf.st_mode & S_IFDIR);
if (ur_check (path) == 0)
{
if (state_init (&ur, path) != 0) fail ("fail reading state of %s", path);
if (index_read (&ur, &index) != 0) fail ("fail reading index of %s", path);
index_update (&ur, &index);
branchname = branch_get_head_name (&ur);
printf ("*** %s \n (branch: %s)\n", ur.path, branchname);
free (branchname); branchname = NULL;
// reading added dirty files
for (e = list_begin (&index.entries); e != list_end (&index.entries);
e = list_next (e))
{
struct index_entry *en = list_entry (e, struct index_entry, elem);
if ((en->status & S_IPST) &&
(en->status & S_IADD) &&
(en->status & S_IDRT)) {
printf ("# added : %s/%s\n", path, en->name);
}
}
// reading dirty but not added
for (e = list_begin (&index.entries); e != list_end (&index.entries);
e = list_next (e))
{
struct index_entry *en = list_entry (e, struct index_entry, elem);
if ((en->status & S_IPST) &&
!(en->status & S_IADD) &&
(en->status & S_IDRT) &&
(en->status & S_ITRK)) {
printf ("# dirty : %s/%s\n", path, en->name);
}
}
// reading untracked files
for (e = list_begin (&index.entries); e != list_end (&index.entries);
e = list_next (e))
{
struct index_entry *en = list_entry (e, struct index_entry, elem);
if ((en->status & S_IPST) &&
!(en->status & S_ITRK) &&
!(en->status & S_IADD)) {
printf ("# untracked : %s/%s\n", path, en->name);
}
}
index_destroy (&index);
state_destroy (&ur);
}
else {
int
cmd_add (const char *path, bool recursive)
{
char *prt_dir = NULL, *fname = NULL, *dname = NULL;
struct stat64 st_buf;
state_t ur = STATE_INITIALIZER;
struct index index = INDEX_INITIALIZER;
int status;
if (lstat64 (path, &st_buf) != 0) fail("%s does not exist", path);
prt_dir = (char *) malloc (strlen (path) + 4);
parent_dir (path, prt_dir);
if (st_buf.st_mode & S_IFREG) {
fname = (char *) malloc (strlen (path) + 4);
filename (path, fname);
if (ur_check (prt_dir) == 0)
{
if (state_init (&ur, prt_dir) != 0) fail ("fail reading state of %s", prt_dir);
if (index_read (&ur, &index) != 0) fail ("fail reading index of %s", prt_dir);
status = index_entry_get_status (&index, fname);
status |= S_IADD;
if (!(status & S_IPST))
status |= S_IPST;
index_entry_set_status (&index, fname, status);
if (index_write (&ur, &index) != 0) fail ("fail writing index of %s", prt_dir);
index_destroy (&index);
state_destroy (&ur);
}
else
fail ("%s initialization failed", prt_dir);
free (fname); fname = NULL;
}
if (st_buf.st_mode & S_IFDIR)
{
dname = (char *) malloc (strlen (path) + 4);
dirname (path, dname);
if (ur_check (path) == 0) {
if (ur_check (prt_dir) == 0)
{
if (state_init (&ur, prt_dir) != 0) fail ("fail reading state of %s", prt_dir);
if (index_read (&ur, &index) != 0) fail ("fail reading index of %s", prt_dir);
status = index_entry_get_status (&index, dname);
status |= S_IADD;
if (!(status & S_IPST))
status |= S_IPST;
index_entry_set_status (&index, dname, status);
if (index_write (&ur, &index) != 0) fail ("fail writing index of %s", prt_dir);
index_destroy (&index);
state_destroy (&ur);
}
}
else {
if (ur_create (path) != 0) fail ("%s initialization failed", path);
output ("init: %s", path);
if (ur_check (prt_dir) == 0) {
if (state_init (&ur, prt_dir) != 0) fail ("fail reading state of %s", prt_dir);
if (index_read (&ur, &index) != 0) fail ("fail reading index of %s", prt_dir);
status = index_entry_get_status (&index, dname);
status |= S_IADD;
if (!(status & S_IPST))
status |= S_IPST;
index_entry_set_status (&index, dname, status);
if (index_write (&ur, &index) != 0) fail ("fail writing index of %s", prt_dir);
index_destroy (&index);
state_destroy (&ur);
}
}
free (dname); dname = NULL;
}
free (prt_dir); prt_dir = NULL;
/*
* recursion
*/
if ((st_buf.st_mode & S_IFDIR) && recursive)
{
DIR *dp;
struct dirent *ep;
dp = opendir (path);
if (dp != NULL)
{
while ((ep = readdir (dp))) {
if (ep->d_name[0] != '.')
{
char *npath;
npath = (char *) malloc (strlen (path) +
strlen (ep->d_name) + 2);
if (path[strlen (path) -1] == '/')
sprintf (npath, "%s%s", path, ep->d_name);
else
sprintf (npath, "%s/%s", path, ep->d_name);
cmd_add (npath, recursive);
free (npath);
}
}
(void) closedir (dp);
}
else
fail ("could not open directory %s", path);
}
return 0;
}
RC tpcc_txn_man::run_payment(tpcc_query * query) {
RC rc = RCOK;
uint64_t key;
itemid_t * item;
uint64_t w_id = query->w_id;
uint64_t d_id = query->d_id;
uint64_t c_w_id = query->c_w_id;
uint64_t c_d_id = query->c_d_id;
uint64_t c_id = query->c_id;
double h_amount = query->h_amount;
row_t * r_cust;
if (query->by_last_name) {
/*==========================================================+
EXEC SQL SELECT count(c_id) INTO :namecnt
FROM customer
WHERE c_last=:c_last AND c_d_id=:c_d_id AND c_w_id=:c_w_id;
+==========================================================*/
/*==========================================================================+
EXEC SQL DECLARE c_byname CURSOR FOR
SELECT c_first, c_middle, c_id, c_street_1, c_street_2, c_city, c_state,
c_zip, c_phone, c_credit, c_credit_lim, c_discount, c_balance, c_since
FROM customer
WHERE c_w_id=:c_w_id AND c_d_id=:c_d_id AND c_last=:c_last
ORDER BY c_first;
EXEC SQL OPEN c_byname;
+===========================================================================*/
uint64_t key = custNPKey(query->c_last, query->c_d_id, query->c_w_id);
// XXX: the list is not sorted. But let's assume it's sorted...
// The performance won't be much different.
INDEX * index = _wl->i_customer_last;
item = index_read(index, key, wh_to_part(c_w_id));
assert(item != NULL);
int cnt = 0;
itemid_t * it = item;
itemid_t * mid = item;
while (it != NULL) {
cnt ++;
it = it->next;
if (cnt % 2 == 0)
mid = mid->next;
}
r_cust = ((row_t *)mid->location);
/*============================================================================+
for (n=0; n<namecnt/2; n++) {
EXEC SQL FETCH c_byname
INTO :c_first, :c_middle, :c_id,
:c_street_1, :c_street_2, :c_city, :c_state, :c_zip,
:c_phone, :c_credit, :c_credit_lim, :c_discount, :c_balance, :c_since;
}
EXEC SQL CLOSE c_byname;
+=============================================================================*/
// XXX: we don't retrieve all the info, just the tuple we are interested in
}
else { // search customers by cust_id
/*=====================================================================+
EXEC SQL SELECT c_first, c_middle, c_last, c_street_1, c_street_2,
c_city, c_state, c_zip, c_phone, c_credit, c_credit_lim,
c_discount, c_balance, c_since
INTO :c_first, :c_middle, :c_last, :c_street_1, :c_street_2,
:c_city, :c_state, :c_zip, :c_phone, :c_credit, :c_credit_lim,
:c_discount, :c_balance, :c_since
FROM customer
WHERE c_w_id=:c_w_id AND c_d_id=:c_d_id AND c_id=:c_id;
+======================================================================*/
key = custKey(query->c_id, query->c_d_id, query->c_w_id);
INDEX * index = _wl->i_customer_id;
item = index_read(index, key, wh_to_part(c_w_id));
assert(item != NULL);
// rc = index->index_read(key, item, wh_to_part(c_w_id));
// assert(rc == RCOK);
r_cust = (row_t *) item->location;
}
/*======================================================================+
EXEC SQL UPDATE customer SET c_balance = :c_balance, c_data = :c_new_data
WHERE c_w_id = :c_w_id AND c_d_id = :c_d_id AND c_id = :c_id;
+======================================================================*/
row_t * r_cust_local = get_row(r_cust, WR);
if (r_cust_local == NULL) {
return finish(Abort);
}
double c_balance;
double c_ytd_payment;
double c_payment_cnt;
r_cust_local->get_value(C_BALANCE, c_balance);
r_cust_local->set_value(C_BALANCE, c_balance - query->h_amount);
r_cust_local->get_value(C_YTD_PAYMENT, c_ytd_payment);
r_cust_local->set_value(C_YTD_PAYMENT, c_ytd_payment + query->h_amount);
r_cust_local->get_value(C_PAYMENT_CNT, c_payment_cnt);
r_cust_local->set_value(C_PAYMENT_CNT, c_payment_cnt + 1);
char * c_credit = r_cust_local->get_value(C_CREDIT);
if ( strstr(c_credit, "BC") ) {
/*=====================================================+
EXEC SQL SELECT c_data
INTO :c_data
FROM customer
WHERE c_w_id=:c_w_id AND c_d_id=:c_d_id AND c_id=:c_id;
+=====================================================*/
// char c_new_data[501];
// sprintf(c_new_data,"| %4d %2d %4d %2d %4d $%7.2f",
// c_id, c_d_id, c_w_id, d_id, w_id, query->h_amount);
// char * c_data = r_cust->get_value("C_DATA");
// strncat(c_new_data, c_data, 500 - strlen(c_new_data));
// r_cust->set_value("C_DATA", c_new_data);
}
/*=====================================================+
EXEC SQL UPDATE district SET d_ytd = d_ytd + :h_amount
WHERE d_w_id=:w_id AND d_id=:d_id;
+=====================================================*/
uint64_t t3 = get_sys_clock();
key = distKey(query->d_id, query->d_w_id);
item = index_read(_wl->i_district, key, wh_to_part(w_id));
assert(item != NULL);
// rc = _wl->i_district->index_read(key, item, wh_to_part(w_id));
// assert(rc == RCOK);
row_t * r_dist = ((row_t *)item->location);
row_t * r_dist_local = get_row(r_dist, WR);
if (r_dist_local == NULL) {
return finish(Abort);
}
uint64_t tt3 = get_sys_clock() - t3;
INC_STATS(get_thd_id(), debug3, tt3);
double d_ytd;
r_dist_local->get_value(D_YTD, d_ytd);
r_dist_local->set_value(D_YTD, d_ytd + query->h_amount);
/*====================================================+
EXEC SQL UPDATE warehouse SET w_ytd = w_ytd + :h_amount
WHERE w_id=:w_id;
+====================================================*/
/*===================================================================+
EXEC SQL SELECT w_street_1, w_street_2, w_city, w_state, w_zip, w_name
INTO :w_street_1, :w_street_2, :w_city, :w_state, :w_zip, :w_name
FROM warehouse
WHERE w_id=:w_id;
+===================================================================*/
key = query->w_id;
INDEX * index = _wl->i_warehouse;
item = index_read(index, key, wh_to_part(w_id));
assert(item != NULL);
// rc = index->index_read(key, item, wh_to_part(w_id));
// assert(rc == RCOK);
row_t * r_wh = ((row_t *)item->location);
row_t * r_wh_local;
uint64_t t5 = get_sys_clock();
if (g_wh_update)
r_wh_local = get_row(r_wh, WR);
else
r_wh_local = get_row(r_wh, RD);
uint64_t tt5 = get_sys_clock() - t5;
INC_STATS(get_thd_id(), debug5, tt5);
if (r_wh_local == NULL) {
return finish(Abort);
}
double w_ytd;
uint64_t t1 = get_sys_clock();
r_wh_local->get_value(W_YTD, w_ytd);
/*=============================================================================+
EXEC SQL INSERT INTO
history (h_c_d_id, h_c_w_id, h_c_id, h_d_id, h_w_id, h_date, h_amount, h_data)
VALUES (:c_d_id, :c_w_id, :c_id, :d_id, :w_id, :datetime, :h_amount, :h_data);
+=============================================================================*/
row_t * r_hist;
uint64_t row_id;
_wl->t_history->get_new_row(r_hist, 0, row_id);
r_hist->set_value(H_C_ID, c_id);
r_hist->set_value(H_C_D_ID, c_d_id);
r_hist->set_value(H_C_W_ID, c_w_id);
r_hist->set_value(H_D_ID, d_id);
r_hist->set_value(H_W_ID, w_id);
int64_t date = 2013;
r_hist->set_value(H_DATE, date);
r_hist->set_value(H_AMOUNT, h_amount);
insert_row(r_hist, _wl->t_history);
if (g_wh_update) {
r_wh_local->set_value(W_YTD, w_ytd + query->h_amount);
}
uint64_t tt1 = get_sys_clock() - t1;
INC_STATS(get_thd_id(), debug1, tt1);
assert( rc == RCOK );
return finish(rc);
}
RC tpcc_txn_man::run_new_order(tpcc_query * query) {
RC rc = RCOK;
uint64_t key;
itemid_t * item;
INDEX * index;
bool remote = query->remote;
uint64_t w_id = query->w_id;
uint64_t d_id = query->d_id;
uint64_t c_id = query->c_id;
uint64_t ol_cnt = query->ol_cnt;
uint64_t o_entry_d = query->o_entry_d;
for (UInt32 ol_number = 0; ol_number < ol_cnt; ol_number++) {
uint64_t ol_i_id = query->items[ol_number].ol_i_id;
/*===========================================+
EXEC SQL SELECT i_price, i_name , i_data
INTO :i_price, :i_name, :i_data
FROM item
WHERE i_id = :ol_i_id;
+===========================================*/
key = ol_i_id;
item = index_read(_wl->i_item, key, 0);
assert(item != NULL);
// rc = _wl->i_item->index_read(key, item, 0);
// assert(rc == RCOK);
row_t * r_item = ((row_t *)item->location);
row_t * r_item_local = get_row(r_item, RD);
if (r_item_local == NULL) {
return finish(Abort);
}
int64_t i_price;
//char * i_name;
//char * i_data;
r_item_local->get_value(I_PRICE, i_price);
}
/*=======================================================================+
EXEC SQL SELECT c_discount, c_last, c_credit, w_tax
INTO :c_discount, :c_last, :c_credit, :w_tax
FROM customer, warehouse
WHERE w_id = :w_id AND c_w_id = w_id AND c_d_id = :d_id AND c_id = :c_id;
+========================================================================*/
key = custKey(c_id, d_id, w_id);
index = _wl->i_customer_id;
item = index_read(index, key, wh_to_part(w_id));
assert(item != NULL);
// rc = index->index_read(key, item, wh_to_part(w_id));
// assert(rc == RCOK);
row_t * r_cust = (row_t *) item->location;
row_t * r_cust_local = get_row(r_cust, RD);
if (r_cust_local == NULL) {
return finish(Abort);
}
uint64_t c_discount;
//char * c_last;
//char * c_credit;
r_cust_local->get_value(C_DISCOUNT, c_discount);
//c_last = r_cust_local->get_value(C_LAST);
//c_credit = r_cust_local->get_value(C_CREDIT);
/*==================================================+
EXEC SQL SELECT d_next_o_id, d_tax
INTO :d_next_o_id, :d_tax
FROM district WHERE d_id = :d_id AND d_w_id = :w_id;
EXEC SQL UPDATE d istrict SET d _next_o_id = :d _next_o_id + 1
WH ERE d _id = :d_id AN D d _w _id = :w _id ;
+===================================================*/
key = distKey(d_id, w_id);
item = index_read(_wl->i_district, key, wh_to_part(w_id));
assert(item != NULL);
// rc = _wl->i_district->index_read(key, item, wh_to_part(w_id));
// assert(rc == RCOK);
row_t * r_dist = ((row_t *)item->location);
row_t * r_dist_local = get_row(r_dist, WR);
if (r_dist_local == NULL) {
return finish(Abort);
}
//double d_tax;
int64_t o_id;
//d_tax = *(double *) r_dist_local->get_value(D_TAX);
o_id = *(int64_t *) r_dist_local->get_value(D_NEXT_O_ID);
o_id ++;
/*========================================================================================+
EXEC SQL INSERT INTO ORDERS (o_id, o_d_id, o_w_id, o_c_id, o_entry_d, o_ol_cnt, o_all_local)
VALUES (:o_id, :d_id, :w_id, :c_id, :datetime, :o_ol_cnt, :o_all_local);
+========================================================================================*/
row_t * r_order;
uint64_t row_id;
_wl->t_order->get_new_row(r_order, 0, row_id);
r_order->set_value(O_ID, o_id);
r_order->set_value(O_C_ID, c_id);
r_order->set_value(O_D_ID, d_id);
r_order->set_value(O_W_ID, w_id);
r_order->set_value(O_ENTRY_D, o_entry_d);
r_order->set_value(O_OL_CNT, ol_cnt);
int64_t all_local = (remote? 0 : 1);
r_order->set_value(O_ALL_LOCAL, all_local);
insert_row(r_order, _wl->t_order);
/*=======================================================+
EXEC SQL INSERT INTO NEW_ORDER (no_o_id, no_d_id, no_w_id)
VALUES (:o_id, :d_id, :w_id);
+=======================================================*/
row_t * r_no;
_wl->t_neworder->get_new_row(r_no, 0, row_id);
r_no->set_value(NO_O_ID, o_id);
r_no->set_value(NO_D_ID, d_id);
r_no->set_value(NO_W_ID, w_id);
insert_row(r_no, _wl->t_neworder);
for (UInt32 ol_number = 0; ol_number < ol_cnt; ol_number++) {
uint64_t ol_i_id = query->items[ol_number].ol_i_id;
uint64_t ol_supply_w_id = query->items[ol_number].ol_supply_w_id;
uint64_t ol_quantity = query->items[ol_number].ol_quantity;
/*===================================================================+
EXEC SQL SELECT s_quantity, s_data,
s_dist_01, s_dist_02, s_dist_03, s_dist_04, s_dist_05,
s_dist_06, s_dist_07, s_dist_08, s_dist_09, s_dist_10
INTO :s_quantity, :s_data,
:s_dist_01, :s_dist_02, :s_dist_03, :s_dist_04, :s_dist_05,
:s_dist_06, :s_dist_07, :s_dist_08, :s_dist_09, :s_dist_10
FROM stock
WHERE s_i_id = :ol_i_id AND s_w_id = :ol_supply_w_id;
EXEC SQL UPDATE stock SET s_quantity = :s_quantity
WHERE s_i_id = :ol_i_id
AND s_w_id = :ol_supply_w_id;
+===============================================*/
key = stockKey(ol_i_id, ol_supply_w_id);
index = _wl->i_stock;
item = index_read(index, key, wh_to_part(ol_supply_w_id));
assert(item != NULL);
// rc = index->index_read(key, item, wh_to_part(ol_supply_w_id));
// assert(rc == RCOK);
row_t * r_stock = ((row_t *)item->location);
row_t * r_stock_local = get_row(r_stock, WR);
if (r_stock_local == NULL) {
return finish(Abort);
}
// XXX s_dist_xx are not retrieved.
UInt64 s_quantity;
int64_t s_remote_cnt;
s_quantity = *(int64_t *)r_stock_local->get_value(S_QUANTITY);
#if !TPCC_SMALL
int64_t s_ytd;
int64_t s_order_cnt;
char * s_data;
r_stock_local->get_value(S_YTD, s_ytd);
r_stock_local->set_value(S_YTD, s_ytd + ol_quantity);
r_stock_local->get_value(S_ORDER_CNT, s_order_cnt);
r_stock_local->set_value(S_ORDER_CNT, s_order_cnt + 1);
s_data = r_stock_local->get_value(S_DATA);
#endif
if (remote) {
s_remote_cnt = *(int64_t*)r_stock_local->get_value(S_REMOTE_CNT);
s_remote_cnt ++;
r_stock_local->set_value(S_REMOTE_CNT, &s_remote_cnt);
}
uint64_t quantity;
if (s_quantity > ol_quantity + 10) {
quantity = s_quantity - ol_quantity;
} else {
quantity = s_quantity - ol_quantity + 91;
}
r_stock_local->set_value(S_QUANTITY, &quantity);
/*====================================================+
EXEC SQL INSERT
INTO order_line(ol_o_id, ol_d_id, ol_w_id, ol_number,
ol_i_id, ol_supply_w_id,
ol_quantity, ol_amount, ol_dist_info)
VALUES(:o_id, :d_id, :w_id, :ol_number,
:ol_i_id, :ol_supply_w_id,
:ol_quantity, :ol_amount, :ol_dist_info);
+====================================================*/
// XXX district info is not inserted.
//int64_t ol_amount = ol_quantity * i_price * (1 + w_tax + d_tax) * (1 - c_discount);
row_t * r_ol;
uint64_t row_id;
_wl->t_orderline->get_new_row(r_ol, 0, row_id);
r_ol->set_value(OL_O_ID, &o_id);
r_ol->set_value(OL_D_ID, &d_id);
r_ol->set_value(OL_W_ID, &w_id);
r_ol->set_value(OL_NUMBER, &ol_number);
r_ol->set_value(OL_I_ID, &ol_i_id);
#if !TPCC_SMALL
r_ol->set_value(OL_SUPPLY_W_ID, &ol_supply_w_id);
r_ol->set_value(OL_QUANTITY, &ol_quantity);
r_ol->set_value(OL_AMOUNT, &ol_amount);
#endif
insert_row(r_ol, _wl->t_orderline);
}
r_dist_local->set_value(D_NEXT_O_ID, o_id);
key = w_id;
index = _wl->i_warehouse;
// rc = index->index_read(key, item, wh_to_part(w_id));
item = index_read(index, key, wh_to_part(w_id));
assert(item != NULL);
row_t * r_wh = ((row_t *)item->location);
row_t * r_wh_local = get_row(r_wh, RD);
if (r_wh_local == NULL) {
return finish(Abort);
}
double w_tax;
r_wh_local->get_value(W_TAX, w_tax);
assert( rc == RCOK );
return finish(rc);
}
