void tpcc_wl::init_tab_dist(uint64_t wid) {
for (uint64_t did = 1; did <= DIST_PER_WARE; did++) {
row_t * row;
uint64_t row_id;
t_district->get_new_row(row, 0, row_id);
row->set_primary_key(did);
row->set_value(D_ID, did);
row->set_value(D_W_ID, wid);
char name[10];
MakeAlphaString(6, 10, name);
row->set_value(D_NAME, name);
char street[20];
MakeAlphaString(10, 20, street);
row->set_value(D_STREET_1, street);
MakeAlphaString(10, 20, street);
row->set_value(D_STREET_2, street);
MakeAlphaString(10, 20, street);
row->set_value(D_CITY, street);
char state[2];
MakeAlphaString(2, 2, state); /* State */
row->set_value(D_STATE, state);
char zip[9];
MakeNumberString(9, 9, zip); /* Zip */
row->set_value(D_ZIP, zip);
double tax = (double)URand(0L,200L)/1000.0;
double w_ytd=30000.00;
row->set_value(D_TAX, tax);
row->set_value(D_YTD, w_ytd);
row->set_value(D_NEXT_O_ID, 3001);
index_insert(i_district, distKey(did, wid), row, wh_to_part(wid));
}
}
void tpcc_wl::init_tab_wh(uint32_t wid) {
assert(wid >= 1 && wid <= g_num_wh);
row_t * row;
uint64_t row_id;
t_warehouse->get_new_row(row, 0, row_id);
row->set_primary_key(wid);
row->set_value(W_ID, wid);
char name[10];
MakeAlphaString(6, 10, name, wid-1);
row->set_value(W_NAME, name);
char street[20];
MakeAlphaString(10, 20, street, wid-1);
row->set_value(W_STREET_1, street);
MakeAlphaString(10, 20, street, wid-1);
row->set_value(W_STREET_2, street);
MakeAlphaString(10, 20, street, wid-1);
row->set_value(W_CITY, street);
char state[2];
MakeAlphaString(2, 2, state, wid-1); /* State */
row->set_value(W_STATE, state);
char zip[9];
MakeNumberString(9, 9, zip, wid-1); /* Zip */
row->set_value(W_ZIP, zip);
double tax = (double)URand(0L,200L,wid-1)/1000.0;
double w_ytd=300000.00;
row->set_value(W_TAX, tax);
row->set_value(W_YTD, w_ytd);
index_insert(i_warehouse, wid, row, wh_to_part(wid));
return;
}
void
MakeAddress(char *str1, char *str2, char *city, char *state, char *zip)
{
MakeAlphaString(10,20,str1); /* Street 1*/
MakeAlphaString(10,20,str2); /* Street 2*/
MakeAlphaString(10,20,city); /* City */
MakeAlphaString(2,2,state); /* State */
MakeNumberString(9,9,zip); /* Zip */
}
void tpcc_wl::init_tab_order(uint64_t did, uint64_t wid) {
uint64_t perm[g_cust_per_dist];
init_permutation(perm, wid); /* initialize permutation of customer numbers */
for (UInt32 oid = 1; oid <= g_cust_per_dist; oid++) {
row_t * row;
uint64_t row_id;
t_order->get_new_row(row, 0, row_id);
row->set_primary_key(oid);
uint64_t o_ol_cnt = 1;
uint64_t cid = perm[oid - 1]; //get_permutation();
row->set_value(O_ID, oid);
row->set_value(O_C_ID, cid);
row->set_value(O_D_ID, did);
row->set_value(O_W_ID, wid);
uint64_t o_entry = 2013;
row->set_value(O_ENTRY_D, o_entry);
if (oid < 2101)
row->set_value(O_CARRIER_ID, URand(1, 10, wid-1));
else
row->set_value(O_CARRIER_ID, 0);
o_ol_cnt = URand(5, 15, wid-1);
row->set_value(O_OL_CNT, o_ol_cnt);
row->set_value(O_ALL_LOCAL, 1);
// ORDER-LINE
#if !TPCC_SMALL
for (uint32_t ol = 1; ol <= o_ol_cnt; ol++) {
t_orderline->get_new_row(row, 0, row_id);
row->set_value(OL_O_ID, oid);
row->set_value(OL_D_ID, did);
row->set_value(OL_W_ID, wid);
row->set_value(OL_NUMBER, ol);
row->set_value(OL_I_ID, URand(1, 100000, wid-1));
row->set_value(OL_SUPPLY_W_ID, wid);
if (oid < 2101) {
row->set_value(OL_DELIVERY_D, o_entry);
row->set_value(OL_AMOUNT, 0);
} else {
row->set_value(OL_DELIVERY_D, 0);
row->set_value(OL_AMOUNT, (double)URand(1, 999999, wid-1)/100);
}
row->set_value(OL_QUANTITY, 5);
char ol_dist_info[24];
MakeAlphaString(24, 24, ol_dist_info, wid-1);
row->set_value(OL_DIST_INFO, ol_dist_info);
}
#endif
// NEW ORDER
if (oid > 2100) {
t_neworder->get_new_row(row, 0, row_id);
row->set_value(NO_O_ID, oid);
row->set_value(NO_D_ID, did);
row->set_value(NO_W_ID, wid);
}
}
}
void tpcc_wl::init_tab_stock(uint64_t wid) {
for (UInt32 sid = 1; sid <= g_max_items; sid++) {
row_t * row;
uint64_t row_id;
t_stock->get_new_row(row, 0, row_id);
row->set_primary_key(sid);
row->set_value(S_I_ID, sid);
row->set_value(S_W_ID, wid);
row->set_value(S_QUANTITY, URand(10, 100));
row->set_value(S_REMOTE_CNT, 0);
#if !TPCC_SMALL
char s_dist[25];
char row_name[10] = "S_DIST_";
for (int i = 1; i <= 10; i++) {
if (i < 10) {
row_name[7] = '0';
row_name[8] = i + '0';
} else {
row_name[7] = '1';
row_name[8] = '0';
}
row_name[9] = '\0';
MakeAlphaString(24, 24, s_dist);
row->set_value(row_name, s_dist);
}
row->set_value(S_YTD, 0);
row->set_value(S_ORDER_CNT, 0);
char s_data[50];
int len = MakeAlphaString(26, 50, s_data);
if (rand() % 100 < 10) {
int idx = URand(0, len - 8);
strcpy(&s_data[idx], "original");
}
row->set_value(S_DATA, s_data);
#endif
index_insert(i_stock, stockKey(sid, wid), row, wh_to_part(wid));
}
}
// TODO ITEM table is assumed to be in partition 0
void tpcc_wl::init_tab_item() {
for (UInt32 i = 1; i <= g_max_items; i++) {
row_t * row;
uint64_t row_id;
t_item->get_new_row(row, 0, row_id);
row->set_primary_key(i);
row->set_value(I_ID, i);
row->set_value(I_IM_ID, URand(1L,10000L, 0));
char name[24];
MakeAlphaString(14, 24, name, 0);
row->set_value(I_NAME, name);
row->set_value(I_PRICE, URand(1, 100, 0));
char data[50];
MakeAlphaString(26, 50, data, 0);
// TODO in TPCC, "original" should start at a random position
if (RAND(10, 0) == 0)
strcpy(data, "original");
row->set_value(I_DATA, data);
index_insert(i_item, i, row, 0);
}
}
void tpcc_wl::init_tab_wh() {
if (WL_VERB)
printf("[init] workload table.\n");
for (UInt32 wid = 1; wid <= g_num_wh; wid ++) {
row_t * row;
uint64_t row_id;
t_warehouse->get_new_row(row, 0, row_id);
row->set_primary_key(wid);
row->set_value(W_ID, wid);
char name[10];
MakeAlphaString(6, 10, name);
row->set_value(W_NAME, name);
char street[20];
MakeAlphaString(10, 20, street);
row->set_value(W_STREET_1, street);
MakeAlphaString(10, 20, street);
row->set_value(W_STREET_2, street);
MakeAlphaString(10, 20, street);
row->set_value(W_CITY, street);
char state[2];
MakeAlphaString(2, 2, state); /* State */
row->set_value(W_STATE, state);
char zip[9];
MakeNumberString(9, 9, zip); /* Zip */
row->set_value(W_ZIP, zip);
double tax = (double)URand(0L,200L)/1000.0;
double w_ytd=300000.00;
row->set_value(W_TAX, tax);
row->set_value(W_YTD, w_ytd);
index_insert(i_warehouse, wid, row, wh_to_part(wid));
}
return;
}
void tpcc_wl::init_tab_hist(uint64_t c_id, uint64_t d_id, uint64_t w_id) {
row_t * row;
uint64_t row_id;
t_history->get_new_row(row, 0, row_id);
row->set_primary_key(0);
row->set_value(H_C_ID, c_id);
row->set_value(H_C_D_ID, d_id);
row->set_value(H_D_ID, d_id);
row->set_value(H_C_W_ID, w_id);
row->set_value(H_W_ID, w_id);
row->set_value(H_DATE, 0);
row->set_value(H_AMOUNT, 10.0);
#if !TPCC_SMALL
char h_data[24];
MakeAlphaString(12, 24, h_data);
row->set_value(H_DATA, h_data);
#endif
}
/*
* Loads the Orders table
* Also loads the Order_Line table on the fly
*
* w_id - warehouse id
* d_id - district id
*/
int
Orders(long d_id, long w_id)
{
long o_id;
long o_c_id;
long o_d_id;
long o_w_id;
long o_carrier_id;
long o_ol_cnt;
long ol;
long ol_i_id;
long ol_supply_w_id;
long ol_quantity;
long ol_amount;
char ol_dist_info[25];
float i_price;
float c_discount;
int err;
DBT key, data;
ORDER_PRIMARY_KEY o_key;
ORDER_PRIMARY_DATA o_data;
ORDERLINE_PRIMARY_KEY ol_key;
ORDERLINE_PRIMARY_DATA ol_data;
NEWORDER_PRIMARY_KEY no_key;
printf("Loading Orders for D=%ld, W= %ld\n", d_id, w_id);
o_d_id=d_id;
o_w_id=w_id;
InitPermutation(); /* initialize permutation of customer numbers */
for (o_id=1; o_id<=ORD_PER_DIST; o_id++)
{
memset(&o_key, 0, sizeof(ORDER_PRIMARY_KEY));
memset(&o_data, 0, sizeof(ORDER_PRIMARY_DATA));
o_key.O_D_ID = o_d_id;
o_key.O_W_ID = o_w_id;
o_key.O_ID = o_id;
/* Generate Order Data */
o_c_id = GetPermutation();
o_carrier_id = random1(1L,10L);
o_ol_cnt=random1(5L,15L);
o_data.O_C_ID = o_c_id;
o_data.O_ALL_LOCAL = 1;
o_data.O_OL_CNT = o_ol_cnt;
memcpy(&o_data.O_ENTRY_D, timestamp, 26);
if (o_id > 2100) /* the last 900 orders have not been delivered) */
{
memset(&no_key, 0, sizeof(NEWORDER_PRIMARY_KEY));
o_data.O_CARRIER_ID = 0;
memset(&key, 0, sizeof(DBT));
key.data = &o_key;
key.size = sizeof(ORDER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &o_data;
data.size = sizeof(ORDER_PRIMARY_DATA);
if((err=dbp_order->put(dbp_order, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
no_key.NO_O_ID = o_id;
no_key.NO_D_ID = o_d_id;
no_key.NO_W_ID = o_w_id;
memset(&key, 0, sizeof(DBT));
key.data = &no_key;
key.size = sizeof(NEWORDER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
if((err=dbp_neworder->put(dbp_neworder, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
else
{
o_data.O_CARRIER_ID = o_carrier_id;
memset(&key, 0, sizeof(DBT));
key.data = &o_key;
key.size = sizeof(ORDER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &o_data;
data.size = sizeof(ORDER_PRIMARY_DATA);
if((err=dbp_order->put(dbp_order, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
if ( option_debug )
printf( "OID = %ld, CID = %ld, DID = %ld, WID = %ld\n",
o_id, o_c_id, o_d_id, o_w_id);
for (ol=1; ol<=o_ol_cnt; ol++)
{
memset(&ol_key, 0, sizeof(ORDERLINE_PRIMARY_KEY));
memset(&ol_data, 0, sizeof(ORDERLINE_PRIMARY_DATA));
/* Generate Order Line Data */
ol_i_id=random1(1L,MAXITEMS);
ol_supply_w_id=o_w_id;
ol_quantity=5;
ol_amount=0.0;
MakeAlphaString(24,24,ol_dist_info);
ol_key.OL_W_ID = o_w_id;
ol_key.OL_D_ID = o_d_id;
ol_key.OL_O_ID = o_id;
ol_key.OL_NUMBER = ol;
ol_data.OL_I_ID = ol_i_id;
ol_data.OL_SUPPLY_W_ID = o_w_id;
ol_data.OL_QUANTITY = ol_quantity;
memcpy(&ol_data.OL_DIST_INFO, &ol_dist_info, 25);
if (o_id > 2100)
{
ol_data.OL_AMOUNT = ol_amount;
memset(&key, 0, sizeof(DBT));
key.data = &ol_key;
key.size = sizeof(ORDERLINE_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &ol_data;
data.size = sizeof(ORDERLINE_PRIMARY_DATA);
if((err=dbp_orderline->put(dbp_orderline, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
else
{
const int dt_size = 26;
char datetime[dt_size];
time_t t_clock;
if((int)time(&t_clock) == -1)
{
error("time");
exit(1);
}
ctime_r(&t_clock, (char*)datetime);
ol_data.OL_AMOUNT =(float)(random1(10L, 10000L))/100.0;
memcpy(&ol_data.OL_DELIVERY_D, datetime, dt_size);
memset(&key, 0, sizeof(DBT));
key.data = &ol_key;
key.size = sizeof(ORDERLINE_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &ol_data;
data.size = sizeof(ORDERLINE_PRIMARY_DATA);
if((err=dbp_orderline->put(dbp_orderline, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
if ( option_debug )
printf( "OL = %ld, IID = %ld, QUAN = %ld, AMT = %8.2f\n",
ol, ol_i_id, ol_quantity, ol_data.OL_AMOUNT);
}
if ( !(o_id % 100) ) {
printf(".");
if ( !(o_id % 1000) ) printf(" %ld\n",o_id);
}
}
printf("Orders Done.\n");
return 0;
}
/*
* Loads Customer Table
* Also inserts corresponding history record
*
* id - customer id
* d_id - district id
* w_id - warehouse id
*/
int
Customer(long d_id, long w_id )
{
long c_id;
long c_d_id;
long c_w_id;
char c_first[17];
char c_middle[3];
char c_last[17];
char c_street_1[21];
char c_street_2[21];
char c_city[21];
char c_state[3];
char c_zip[10];
char c_phone[17];
char c_since[12];
char c_credit[3];
long c_credit_lim;
float c_discount;
float c_balance;
char c_data[501];
float h_amount;
char h_data[25];
int err;
printf("Loading Customer for DID=%ld, WID=%ld\n",d_id,w_id);
for (c_id=1; c_id<=CUST_PER_DIST; c_id++)
{
DBT key, data;
CUSTOMER_PRIMARY_KEY c_key;
CUSTOMER_PRIMARY_DATA c_primdata;
HISTORY_PRIMARY_KEY h_key;
memset(&c_key, 0, sizeof(CUSTOMER_PRIMARY_KEY));
memset(&c_primdata, 0, sizeof(CUSTOMER_PRIMARY_DATA));
memset(&h_key, 0, sizeof(HISTORY_PRIMARY_KEY));
/* Generate Customer Data */
c_d_id=d_id;
c_w_id=w_id;
MakeAlphaString( 8, 16, c_first );
c_middle[0]='O'; c_middle[1]='E'; c_middle[2] = '\0';
if (c_id <= 1000)
Lastname(c_id-1,c_last);
else
Lastname(NURand(255,0,999),c_last);
MakeAddress( c_street_1, c_street_2, c_city, c_state, c_zip );
MakeNumberString( 16, 16, c_phone );
if (random1(0L,1L))
c_credit[0]='G';
else
c_credit[0]='B';
c_credit[1]='C'; c_credit[2]='\0';
c_credit_lim=50000;
c_discount=((float)random1(0L,50L))/100.0;
c_balance= -10.0;
MakeAlphaString(300,500,c_data);
/* Prepare for putting into the database */
c_key.C_W_ID = c_w_id;
c_key.C_D_ID = c_d_id;
c_key.C_ID = c_id;
memcpy(&c_primdata.C_FIRST, &c_first, 17);
memcpy(&c_primdata.C_MIDDLE, &c_middle, 3);
memcpy(&c_primdata.C_LAST, &c_last, 17);
memcpy(&c_primdata.C_STREET_1, &c_street_1, 21);
memcpy(&c_primdata.C_STREET_2, &c_street_2, 21);
memcpy(&c_primdata.C_CITY, &c_city, 21);
memcpy(&c_primdata.C_STATE, &c_state, 3);
memcpy(&c_primdata.C_ZIP, &c_zip, 10);
memcpy(&c_primdata.C_PHONE, &c_phone, 17);
memcpy(&c_primdata.C_DATA, &c_data, 501);
memcpy(&c_primdata.C_CREDIT, &c_credit, 3);
memcpy(c_primdata.C_CREDIT, &c_credit, 3);
c_primdata.C_DISCOUNT = c_discount;
c_primdata.C_BALANCE = c_balance;
memset(&key, 0, sizeof(DBT));
key.data = &c_key;
key.size = sizeof(CUSTOMER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &c_primdata;
data.size = sizeof(CUSTOMER_PRIMARY_DATA);
if((err=dbp_customer->put(dbp_customer, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
h_amount = 10.0;
MakeAlphaString(12,24,h_data);
memset(&key, 0, sizeof(DBT));
key.data = &h_key;
key.size = sizeof(HISTORY_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
h_key.H_C_ID = c_id;
h_key.H_C_D_ID = c_d_id;
h_key.H_C_W_ID = c_w_id;
h_key.H_W_ID = c_w_id;
h_key.H_D_ID = c_d_id;
h_key.H_AMOUNT = h_amount;
memcpy(&h_key.H_DATE, ×tamp, 26);
memcpy(&h_key.H_DATA, &h_data, 24);
if((err=dbp_history->put(dbp_history, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
if ( option_debug )
printf( "CID = %ld, LST = %s, P# = %s\n",
c_id, c_last, c_phone );
if ( !(c_id % 100) )
{
printf(".");
if ( !(c_id % 1000) ) printf(" %ld\n",c_id);
}
}
printf("Customer Done.\n");
return 0;
}
/*
* Loads the District table
* w_id - warehouse id
*/
int
District(long w_id)
{
long d_id;
long d_w_id;
char d_name[11];
char d_street_1[21];
char d_street_2[21];
char d_city[21];
char d_state[3];
char d_zip[10];
float d_tax;
float d_ytd;
long d_next_o_id;
DBT key, data;
DISTRICT_PRIMARY_KEY d_key;
DISTRICT_PRIMARY_DATA d_data;
int err;
printf("Loading District\n");
for (d_id=1; d_id<=DIST_PER_WARE; d_id++)
{
memset(&d_key, 0, sizeof(DISTRICT_PRIMARY_KEY));
memset(&d_data, 0, sizeof(DISTRICT_PRIMARY_DATA));
d_w_id=w_id;
d_ytd=30000.0;
d_next_o_id=3001L;
d_key.D_W_ID = d_w_id;
d_key.D_ID = d_id;
d_data.D_YTD = d_ytd;
d_data.D_NEXT_O_ID = d_next_o_id;
/* Generate District Data */
MakeAlphaString(6L,10L,d_name);
MakeAddress( d_street_1, d_street_2, d_city, d_state, d_zip );
d_tax=((float)random1(10L,20L))/100.0;
memcpy(&d_data.D_NAME, &d_name, 11);
memcpy(&d_data.D_STREET_1, &d_street_1, 21);
memcpy(&d_data.D_STREET_2, &d_street_2, 21);
memcpy(&d_data.D_CITY, &d_city, 21);
memcpy(&d_data.D_STATE, &d_state, 3);
memcpy(&d_data.D_ZIP, &d_zip, 10);
d_data.D_TAX = d_tax;
memset(&key, 0, sizeof(DBT));
key.data = &d_key;
key.size = sizeof(DISTRICT_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &d_data;
data.size = sizeof(DISTRICT_PRIMARY_DATA);
if((err=dbp_district->put(dbp_district, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
if ( option_debug )
printf( "DID = %ld, WID = %ld, Name = %10s, Tax = %5.2f\n",
d_id, d_w_id, d_name, d_tax );
}
return 0;
}
/*
* Loads the Stock table
*
* w_id - warehouse id
*/
int
Stock(long w_id)
{
long s_i_id;
long s_w_id;
long s_quantity;
char s_dist_01[25];
char s_dist_02[25];
char s_dist_03[25];
char s_dist_04[25];
char s_dist_05[25];
char s_dist_06[25];
char s_dist_07[25];
char s_dist_08[25];
char s_dist_09[25];
char s_dist_10[25];
char s_data[51];
int sdatasiz;
long orig[MAXITEMS];
long pos;
int i, err;
DBT key, data;
STOCK_PRIMARY_DATA s_primdata;
STOCK_PRIMARY_KEY s_key;
printf("Loading Stock Wid=%ld\n",w_id);
s_w_id=w_id;
memset(orig, 0, MAXITEMS * sizeof(long));
for (i=0; i<MAXITEMS/10; i++)
{
do
{
pos=random1(0L,MAXITEMS);
} while (orig[pos]);
orig[pos] = 1;
}
for (s_i_id=1; s_i_id<=MAXITEMS; s_i_id++)
{
memset(&s_key, 0, sizeof(STOCK_PRIMARY_KEY));
memset(&s_primdata, 0, sizeof(STOCK_PRIMARY_DATA));
s_key.S_W_ID = s_w_id;
s_key.S_I_ID = s_i_id;
/* Generate Stock Data */
s_quantity=random1(10L,100L);
MakeAlphaString(24,24,s_dist_01);
MakeAlphaString(24,24,s_dist_02);
MakeAlphaString(24,24,s_dist_03);
MakeAlphaString(24,24,s_dist_04);
MakeAlphaString(24,24,s_dist_05);
MakeAlphaString(24,24,s_dist_06);
MakeAlphaString(24,24,s_dist_07);
MakeAlphaString(24,24,s_dist_08);
MakeAlphaString(24,24,s_dist_09);
MakeAlphaString(24,24,s_dist_10);
sdatasiz=MakeAlphaString(26,50,s_data);
memcpy(s_primdata.S_DIST_01, &s_dist_01, 25);
memcpy(s_primdata.S_DIST_02, &s_dist_02, 25);
memcpy(s_primdata.S_DIST_03, &s_dist_03, 25);
memcpy(s_primdata.S_DIST_04, &s_dist_04, 25);
memcpy(s_primdata.S_DIST_05, &s_dist_05, 25);
memcpy(s_primdata.S_DIST_06, &s_dist_06, 25);
memcpy(s_primdata.S_DIST_07, &s_dist_07, 25);
memcpy(s_primdata.S_DIST_08, &s_dist_08, 25);
memcpy(s_primdata.S_DIST_09, &s_dist_09, 25);
memcpy(s_primdata.S_DIST_10, &s_dist_10, 25);
if (orig[s_i_id-1])
{
pos=random1(0L,sdatasiz-8);
s_data[pos]='o';
s_data[pos+1]='r';
s_data[pos+2]='i';
s_data[pos+3]='g';
s_data[pos+4]='i';
s_data[pos+5]='n';
s_data[pos+6]='a';
s_data[pos+7]='l';
}
s_primdata.S_QUANTITY = s_quantity;
memcpy(s_primdata.S_DATA, &s_data, 51);
s_primdata.S_YTD = 0;
s_primdata.S_ORDER_CNT = 0;
s_primdata.S_REMOTE_CNT = 0;
memset(&key, 0, sizeof(DBT));
key.data = &s_key;
key.size = sizeof(STOCK_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &s_primdata;
data.size = sizeof(STOCK_PRIMARY_DATA);
if((err=dbp_stock->put(dbp_stock, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
if ( option_debug )
printf( "SID = %ld, WID = %ld, Quan = %ld\n",
s_i_id, s_w_id, s_quantity );
if ( !(s_i_id % 100) )
{
printf(".");
if ( !(s_i_id % 5000) ) printf(" %ld\n",s_i_id);
}
}
printf(" Stock Done.\n");
return 0;
}
/*
* Loads the Warehouse table
* Loads Stock, District as Warehouses are created
*/
void
LoadWare(void)
{
long w_id;
char w_name[11];
char w_street_1[21];
char w_street_2[21];
char w_city[21];
char w_state[3];
char w_zip[10];
float w_tax;
float w_ytd;
DB *dbp;
char *name = WAREHOUSE_INDEX_NAME;
char *stock_name = STOCK_INDEX_NAME;
char *district_name = DISTRICT_INDEX_NAME;
int err;
if(create_db(db_env, &dbp, DB_WH_PAGE_SIZE, 0) || open_db(dbp, name, 0))
return;
if(create_db(db_env, &dbp_stock, DB_COMMON_PAGE_SIZE, 0) || open_db(dbp_stock, stock_name, 0))
goto done;
if(create_db(db_env, &dbp_district, DB_DS_PAGE_SIZE, 0))
goto done;
if((err = dbp_district->set_bt_compare(dbp_district, district_comparison_func)))
{
db_error("DB->set_bt_compare", err);
goto done;
}
if(open_db(dbp_district, district_name, 0))
{
goto done;
}
printf("Loading Warehouse \n");
for (w_id=1L; w_id<=count_ware; w_id++)
{
DBT key, data;
WAREHOUSE_PRIMARY_KEY w_key;
WAREHOUSE_PRIMARY_DATA w_data;
memset(&w_key, 0, sizeof(WAREHOUSE_PRIMARY_KEY));
memset(&w_data, 0, sizeof(WAREHOUSE_PRIMARY_DATA));
/* Generate Warehouse Data */
MakeAlphaString( 6, 10, w_name);
MakeAddress( w_street_1, w_street_2, w_city, w_state, w_zip );
w_tax=((float)random1(10L,20L))/100.0;
w_ytd=3000000.00;
w_key.W_ID = w_id;
memcpy(&w_data.W_NAME, &w_name, 11);
memcpy(&w_data.W_STREET_1, &w_street_1, 21);
memcpy(&w_data.W_STREET_2, &w_street_2, 21);
memcpy(&w_data.W_CITY, &w_city, 21);
memcpy(&w_data.W_STATE, &w_state, 3);
memcpy(&w_data.W_ZIP, &w_zip, 10);
w_data.W_TAX = w_tax;
w_data.W_YTD = w_ytd;
/* Initialize the key */
memset(&key, 0, sizeof(key));
key.data = &w_key;
key.size = sizeof(WAREHOUSE_PRIMARY_KEY);
/* Initialize the data */
memset(&data, 0, sizeof(data));
data.data = &w_data;
data.size = sizeof(WAREHOUSE_PRIMARY_DATA);
if ( option_debug )
printf( "WID = %ld, Name= %16s, Tax = %5.2f\n",
w_id, w_name, w_tax );
if((err=dbp->put(dbp, 0, &key, &data, 0)))
{
db_error("DB->put", err);
goto done;
}
/** Make Rows associated with Warehouse **/
if(Stock(w_id) || District(w_id))
{
goto done;
}
}
done:
if(dbp)
dbp->close(dbp, 0);
if(dbp_stock)
dbp_stock->close(dbp_stock, 0);
if(dbp_district)
dbp_district->close(dbp_district, 0);
}
/*
* Loads the Item table
*/
void
LoadItems(void)
{
long i_id;
char i_name[25];
char i_data[51];
float i_price;
int idatasiz, orig[MAXITEMS], i, err, pos;
DB *db, *db_sec;
/* Create/open a new Berkeley DB for the Item index */
if(create_db(db_env, &db, DB_COMMON_PAGE_SIZE, 0) || open_db(db, ITEM_INDEX_NAME, 0))
{
exit(1);
}
printf("Loading Item \n");
for (i=0; i<MAXITEMS; i++)
{
orig[i]=0;
}
for (i=0; i<MAXITEMS/10; i++)
{
do
{
pos = random1(0L,MAXITEMS);
} while (orig[pos]);
orig[pos] = 1;
}
for (i_id=1; i_id<=MAXITEMS; i_id++)
{
DBT key, data;
ITEM_PRIMARY_KEY i_key;
ITEM_PRIMARY_DATA i_primdata;
memset(&i_key, 0, sizeof(ITEM_PRIMARY_KEY));
memset(&i_primdata, 0, sizeof(ITEM_PRIMARY_DATA));
/* Generate Item Data */
MakeAlphaString( 14, 24, i_name);
i_price=((float) random1(100L,10000L))/100.0;
idatasiz=MakeAlphaString(26,50,i_data);
if (orig[i_id-1])
{
pos = random1(0,idatasiz-8);
i_data[pos]= 'o';
i_data[pos+1] = 'r';
i_data[pos+2] = 'i';
i_data[pos+3] = 'g';
i_data[pos+4] = 'i';
i_data[pos+5] = 'n';
i_data[pos+6] = 'a';
i_data[pos+7] = 'l';
}
if ( option_debug )
{
printf( "IID = %ld, Name= %16s, Price = %5.2f\n",
i_id, i_name, i_price );
}
/* Initialize the key */
memset(&key, 0, sizeof(key));
i_key.I_ID = i_id;
key.data = &i_key;
key.size = sizeof(ITEM_PRIMARY_KEY);
/* Initialize the data */
memset(&data, 0, sizeof(data));
i_primdata.I_IM_ID = 0;
i_primdata.I_PRICE = i_price;
strncpy(i_primdata.I_NAME, i_name, 25);
strncpy(i_primdata.I_DATA, i_data, 51);
data.data = &i_primdata;
data.size = sizeof(ITEM_PRIMARY_DATA);
if((err=db->put(db, 0, &key, &data, 0)))
{
db_error("DB->put", err);
goto done;
}
if ( !(i_id % 100) )
{
printf(".");
if ( !(i_id % 5000) ) printf(" %ld\n",i_id);
}
}
printf("Item Done. \n");
done:
if((err = db->close(db, 0)))
{
db_error("DB->close", err);
}
return;
}
void tpcc_wl::init_tab_order(uint64_t did, uint64_t wid) {
init_permutation(); /* initialize permutation of customer numbers */
for (UInt32 oid = 1; oid <= g_cust_per_dist; oid++) {
row_t * row;
uint64_t row_id;
t_order->get_new_row(row, 0, row_id);
row->set_primary_key(oid);
uint64_t o_ol_cnt = 1;
uint64_t cid = get_permutation();
row->set_value(O_ID, oid);
row->set_value(O_C_ID, cid);
row->set_value(O_D_ID, did);
row->set_value(O_W_ID, wid);
uint64_t o_entry = 2013;
row->set_value(O_ENTRY_D, o_entry);
if (oid < 2101)
row->set_value(O_CARRIER_ID, URand(1, 10));
else
row->set_value(O_CARRIER_ID, 0);
o_ol_cnt = URand(5, 15);
row->set_value(O_OL_CNT, o_ol_cnt);
row->set_value(O_ALL_LOCAL, 1);
// Insert to indexes
// uint64_t key = custKey(cid, did, wid);
// index_insert(i_order_wdc, key, row, wh_to_part(wid));
// key = orderPrimaryKey(wid, did, oid);
// index_insert(i_order_wdo, key, row, wh_to_part(wid));
// ORDER-LINE
#if !TPCC_SMALL
for (int ol = 1; ol <= o_ol_cnt; ol++) {
t_orderline->get_new_row(row, 0, row_id);
row->set_value(OL_O_ID, oid);
row->set_value(OL_D_ID, did);
row->set_value(OL_W_ID, wid);
row->set_value(OL_NUMBER, ol);
row->set_value(OL_I_ID, URand(1, 100000));
row->set_value(OL_SUPPLY_W_ID, wid);
if (oid < 2101) {
row->set_value(OL_DELIVERY_D, o_entry);
row->set_value(OL_AMOUNT, 0);
} else {
row->set_value(OL_DELIVERY_D, 0);
row->set_value(OL_AMOUNT, (double)URand(1, 999999)/100);
}
row->set_value(OL_QUANTITY, 5);
char ol_dist_info[24];
MakeAlphaString(24, 24, ol_dist_info);
row->set_value(OL_DIST_INFO, ol_dist_info);
// uint64_t key = orderlineKey(wid, did, oid);
// index_insert(i_orderline, key, row, wh_to_part(wid));
// key = distKey(did, wid);
// index_insert(i_orderline_wd, key, row, wh_to_part(wid));
}
#endif
// NEW ORDER
if (oid > 2100) {
t_neworder->get_new_row(row, 0, row_id);
row->set_value(NO_O_ID, oid);
row->set_value(NO_D_ID, did);
row->set_value(NO_W_ID, wid);
}
}
}
void tpcc_wl::init_tab_cust(uint64_t did, uint64_t wid) {
assert(g_cust_per_dist >= 1000);
for (UInt32 cid = 1; cid <= g_cust_per_dist; cid++) {
row_t * row;
uint64_t row_id;
t_customer->get_new_row(row, 0, row_id);
row->set_primary_key(cid);
row->set_value(C_ID, cid);
row->set_value(C_D_ID, did);
row->set_value(C_W_ID, wid);
char c_last[LASTNAME_LEN];
if (cid <= 1000)
Lastname(cid - 1, c_last);
else
Lastname(NURand(255,0,999), c_last);
row->set_value(C_LAST, c_last);
#if !TPCC_SMALL
char * tmp = "OE";
row->set_value(C_MIDDLE, tmp);
char c_first[FIRSTNAME_LEN];
MakeAlphaString(FIRSTNAME_MINLEN, sizeof(c_first), c_first);
row->set_value(C_FIRST, c_first);
char street[20];
MakeAlphaString(10, 20, street);
row->set_value(C_STREET_1, street);
MakeAlphaString(10, 20, street);
row->set_value(C_STREET_2, street);
MakeAlphaString(10, 20, street);
row->set_value(C_CITY, street);
char state[2];
MakeAlphaString(2, 2, state); /* State */
row->set_value(C_STATE, state);
char zip[9];
MakeNumberString(9, 9, zip); /* Zip */
row->set_value(C_ZIP, zip);
char phone[16];
MakeNumberString(16, 16, phone); /* Zip */
row->set_value(C_PHONE, phone);
row->set_value(C_SINCE, 0);
row->set_value(C_CREDIT_LIM, 50000);
row->set_value(C_DELIVERY_CNT, 0);
char c_data[500];
MakeAlphaString(300, 500, c_data);
row->set_value(C_DATA, c_data);
#endif
if (RAND(10) == 0) {
char tmp[] = "GC";
row->set_value(C_CREDIT, tmp);
} else {
char tmp[] = "BC";
row->set_value(C_CREDIT, tmp);
}
row->set_value(C_DISCOUNT, (double)RAND(5000) / 10000);
row->set_value(C_BALANCE, -10.0);
row->set_value(C_YTD_PAYMENT, 10.0);
row->set_value(C_PAYMENT_CNT, 1);
uint64_t key;
key = custNPKey(c_last, did, wid);
index_insert(i_customer_last, key, row, wh_to_part(wid));
key = custKey(cid, did, wid);
index_insert(i_customer_id, key, row, wh_to_part(wid));
}
}
