void tls_cmd_init_socket_cfg(void)
{
int timeout = 0, host_len;
struct tls_param_socket remote_socket_cfg;
tls_param_get(TLS_PARAM_ID_DEFSOCKET, &remote_socket_cfg, FALSE);
/* read default socket params */
socket_cfg.proto = remote_socket_cfg.protocol;
socket_cfg.client = remote_socket_cfg.client_or_server ? 0 : 1;
socket_cfg.port = remote_socket_cfg.port_num;
TLS_DBGPRT_INFO("socket_cfg.proto = %d, socket_cfg.client = %d, socket_cfg.port = %d\n", socket_cfg.proto, socket_cfg.client, socket_cfg.port);
host_len = strlen((char *)remote_socket_cfg.host);
if (socket_cfg.client) {
/* host name */
if (host_len){
MEMCPY(socket_cfg.host,
remote_socket_cfg.host, host_len);
string_to_ipaddr((char *)remote_socket_cfg.host, &socket_cfg.ip_addr[0]);
}
} else if (!socket_cfg.client && socket_cfg.proto == 0) {
if (strtodec(&timeout, (char *)remote_socket_cfg.host)<0){
timeout = 0;
}
socket_cfg.timeout = timeout;
} else
;
}
/*
* mk_store_sales
*/
static void
mk_master (void *row, ds_key_t index)
{
struct W_STORE_SALES_TBL *r;
static decimal_t dMin,
dMax;
static int bInit = 0,
nMaxItemCount;
static ds_key_t kNewDateIndex = 0;
if (row == NULL)
r = &g_w_store_sales;
else
r = row;
if (!bInit)
{
strtodec (&dMin, "1.00");
strtodec (&dMax, "100000.00");
nMaxItemCount = 20;
jDate = skipDays(STORE_SALES, &kNewDateIndex);
pItemPermutation = makePermutation(NULL, nItemCount = (int)getIDCount(ITEM), SS_PERMUTATION);
bInit = 1;
}
while (index > kNewDateIndex) /* need to move to a new date */
{
jDate += 1;
kNewDateIndex += dateScaling(STORE_SALES, jDate);
}
r->ss_sold_store_sk = mk_join (SS_SOLD_STORE_SK, STORE, 1);
r->ss_sold_time_sk = mk_join (SS_SOLD_TIME_SK, TIME, 1);
r->ss_sold_date_sk = mk_join (SS_SOLD_DATE_SK, DATE, 1);
r->ss_sold_customer_sk = mk_join (SS_SOLD_CUSTOMER_SK, CUSTOMER, 1);
r->ss_sold_cdemo_sk = mk_join (SS_SOLD_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1);
r->ss_sold_hdemo_sk = mk_join (SS_SOLD_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1);
r->ss_sold_addr_sk = mk_join (SS_SOLD_ADDR_SK, CUSTOMER_ADDRESS, 1);
r->ss_ticket_number = index;
genrand_integer(&nItemIndex, DIST_UNIFORM, 1, nItemCount, 0, SS_SOLD_ITEM_SK);
return;
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
mk_s_customer (void *pDest, ds_key_t kIndex)
{
static int bInit = 0;
struct S_CUSTOMER_TBL *r;
static date_t dtMin,
dtMax, dtBirthMin, dtBirthMax, dtToday, dt1YearAgo, dt10YearsAgo;
static decimal_t dMinIncome, dMaxIncome;
int nTemp;
ds_key_t kTempDemographic;
char *szTemp;
static int *pPermutation;
if (pDest == NULL)
r = &g_s_customer;
else
r = pDest;
if (!bInit)
{
memset (&g_s_customer, 0, sizeof (struct S_CUSTOMER_TBL));
setUpdateDateRange (S_CUSTOMER, &dtMin, &dtMax);
strtodec (&dMinIncome, "0.00");
strtodec (&dMaxIncome, "200000.00");
r->pBirthCountry = strdup ("<UNKNOWN>");
strtodt (&dtBirthMin, "1924-01-01");
strtodt (&dtBirthMax, "1992-12-31");
strtodt (&dtToday, TODAYS_DATE);
jtodt (&dt1YearAgo, dtToday.julian - 365);
jtodt (&dt10YearsAgo, dtToday.julian - 365);
pPermutation =
makePermutation (NULL, (int) getIDCount (CUSTOMER), S_CUST_ID);
bInit = 1;
}
r->kID = getPermutationEntry (pPermutation, (int) kIndex);
kTempDemographic = mk_join (S_CUST_GENDER, CUSTOMER_DEMOGRAPHICS, 1) - 1;
bitmap_to_dist (&szTemp, "gender", &kTempDemographic, 1,
CUSTOMER_DEMOGRAPHICS);
switch (*szTemp)
{
case 'M': /* male */
r->sGender[0] = 'M';
pick_distribution (&r->pFirstName, "first_names", 1, 1,
S_CUST_FIRST_NAME);
pick_distribution (&r->pSalutation, "salutations", 1, 2,
S_CUST_SALUTATION);
break;
case 'F': /* female */
r->sGender[0] = 'F';
pick_distribution (&r->pFirstName, "first_names", 1, 2,
S_CUST_FIRST_NAME);
pick_distribution (&r->pSalutation, "salutations", 1, 3,
S_CUST_SALUTATION);
break;
default: /* gender neutral */
r->sGender[0] = 'U';
pick_distribution (&r->pFirstName, "first_names", 1, 3,
S_CUST_FIRST_NAME);
pick_distribution (&r->pSalutation, "salutations", 1, 1,
S_CUST_SALUTATION);
break;
}
bitmap_to_dist (&r->pMaritalStatus, "marital_status", &kTempDemographic, 1,
CUSTOMER_DEMOGRAPHICS);
bitmap_to_dist (&r->pEducation, "education", &kTempDemographic, 1,
CUSTOMER_DEMOGRAPHICS);
bitmap_to_dist (&r->nPurchaseEstimate, "purchase_band", &kTempDemographic,
1, CUSTOMER_DEMOGRAPHICS);
bitmap_to_dist (&r->pCreditRating, "credit_rating", &kTempDemographic, 1,
CUSTOMER_DEMOGRAPHICS);
r->nDependents = (int) (kTempDemographic % (ds_key_t) CD_MAX_CHILDREN);
kTempDemographic /= (ds_key_t) CD_MAX_CHILDREN;
r->nEmployed = (int) (kTempDemographic % (ds_key_t) CD_MAX_EMPLOYED);
kTempDemographic /= (ds_key_t) CD_MAX_EMPLOYED;
r->nCollege = (int) (kTempDemographic % (ds_key_t) CD_MAX_COLLEGE);
pick_distribution (&r->pLastName, "last_names", 1, 1, S_CUST_LAST_NAME);
r->bPreferredFlag =
(genrand_integer (NULL, DIST_UNIFORM, 1, 100, 0, S_CUST_PREFERRED_FLAG) >
50) ? 1 : 0;
genrand_date (&r->dtBirthDate, DIST_UNIFORM, &dtBirthMin, &dtBirthMax, NULL,
S_CUST_BIRTH_DATE);
genrand_date (&r->dtFirstPurchaseDate, DIST_UNIFORM, &dt10YearsAgo,
&dt1YearAgo, NULL, S_CUST_FIRST_PURCHASE_DATE);
genrand_integer (&nTemp, DIST_UNIFORM, 1, 30, 0, S_CUST_FIRST_SHIPTO_DATE);
jtodt (&r->dtFirstShipToDate, r->dtFirstPurchaseDate.julian + nTemp);
gen_charset (r->szLogin, ALPHANUM, 5, RS_S_CUST_LOGIN, S_CUST_LOGIN);
genrand_email (r->szEmail, r->pFirstName, r->pLastName, S_CUST_EMAIL);
genrand_date (&r->dtLastLogin, DIST_UNIFORM, &dt1YearAgo, &dtToday, NULL,
S_CUST_LAST_LOGIN);
genrand_date (&r->dtReview, DIST_UNIFORM, &dt1YearAgo, &dtToday, NULL,
S_CUST_LAST_REVIEW);
genrand_ipaddr (r->szPrimaryMachine, S_CUST_PRIMARY_MACHINE);
genrand_ipaddr (r->szSecondaryMachine, S_CUST_SECONDARY_MACHINE);
pick_distribution (&r->pLocationType, "location_type", 1, 1,
S_CUST_LOCATION_TYPE);
pick_distribution (&r->nVehicle, "vehicle_count", 1, 1, S_CUST_VEHICLE_CNT);
genrand_decimal (&r->dIncome, DIST_UNIFORM, &dMinIncome, &dMaxIncome, NULL,
S_CUST_INCOME);
pick_distribution (&r->pBuyPotential, "buy_potential", 1, 1,
S_CUST_PURCHASE_ESTIMATE);
mk_w_customer_address (NULL, kIndex);
return (0);
}
/*
* the validation process requires generating a single lineitem
* so the main mk_xxx routine has been split into a master record portion
* and a detail/lineitem portion.
*/
static void
mk_master (void *row, ds_key_t index)
{
static decimal_t dMin,
dMax;
int nGiftPct;
struct W_WEB_SALES_TBL *r;
static int bInit = 0,
nItemCount;
if (row == NULL)
r = &g_w_web_sales;
else
r = row;
if (!bInit)
{
strtodec (&dMin, "1.00");
strtodec (&dMax, "100000.00");
jDate = skipDays(WEB_SALES, &kNewDateIndex);
nItemCount = (int)getIDCount(ITEM);
bInit = 1;
}
/***
* some attributes reamin the same for each lineitem in an order; others are different
* for each lineitem. Since the number of lineitems per order is static, we can use a
* modulo to determine when to change the semi-static values
*/
while (index > kNewDateIndex) /* need to move to a new date */
{
jDate += 1;
kNewDateIndex += dateScaling(WEB_SALES, jDate);
}
r->ws_sold_date_sk = mk_join (WS_SOLD_DATE_SK, DATE, 1);
r->ws_sold_time_sk = mk_join(WS_SOLD_TIME_SK, TIME, 1);
r->ws_bill_customer_sk = mk_join (WS_BILL_CUSTOMER_SK, CUSTOMER, 1);
r->ws_bill_cdemo_sk = mk_join (WS_BILL_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1);
r->ws_bill_hdemo_sk = mk_join (WS_BILL_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1);
r->ws_bill_addr_sk = mk_join (WS_BILL_ADDR_SK, CUSTOMER_ADDRESS, 1);
/* most orders are for the ordering customers, some are not */
genrand_integer(&nGiftPct, DIST_UNIFORM, 0, 99, 0, WS_SHIP_CUSTOMER_SK);
if (nGiftPct > WS_GIFT_PCT)
{
r->ws_ship_customer_sk =
mk_join (WS_SHIP_CUSTOMER_SK, CUSTOMER, 2);
r->ws_ship_cdemo_sk =
mk_join (WS_SHIP_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 2);
r->ws_ship_hdemo_sk =
mk_join (WS_SHIP_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 2);
r->ws_ship_addr_sk =
mk_join (WS_SHIP_ADDR_SK, CUSTOMER_ADDRESS, 2);
}
else
{
r->ws_ship_customer_sk = r->ws_bill_customer_sk;
r->ws_ship_cdemo_sk = r->ws_bill_cdemo_sk;
r->ws_ship_hdemo_sk = r->ws_bill_hdemo_sk;
r->ws_ship_addr_sk = r->ws_bill_addr_sk;
}
r->ws_order_number = index;
genrand_integer(&nItemIndex, DIST_UNIFORM, 1, nItemCount, 0, WS_ITEM_SK);
return;
}
/*
* Routine: set_pricing(int nTabId, ds_pricing_t *pPricing)
* Purpose: handle the various pricing calculations for the fact tables
* Notes:
* the RNG usage is not kept in sync between sales pricing and returns pricing. If the calculations look wrong, it may
* be necessary to "waste" some RNG calls on one side or the other to bring things back in line
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void set_pricing(int nTabId, ds_pricing_t *pPricing)
{
static int nLastId = -1,
init = 0,
nQuantityMax,
nQuantityMin = 1;
static decimal_t dQuantity, dMarkupMin, dDiscountMin, dWholesaleMin,
dMarkupMax, dDiscountMax, dWholesaleMax, dCouponMin, dCouponMax,
dZero, dOneHalf, d9pct, dOne, dTemp, dHundred;
decimal_t dMarkup, dCoupon, dShipping, dDiscount, dTemp2;
int i,
nCashPct,
nCreditPct,
nCouponUsage;
if (!init)
{
strtodec(&dMarkupMin, "0.00");
strtodec(&dDiscountMin, "0.00");
strtodec(&dWholesaleMin, "1.00");
strtodec(&dCouponMin, "0.00");
strtodec(&dZero, "0.00");
strtodec(&dOneHalf, "0.50");
strtodec(&d9pct, "0.09");
strtodec(&dWholesaleMin, "1.00");
strtodec(&dHundred, "100.00");
strtodec(&dOne, "1.00");
init = 1;
}
if (nTabId != nLastId)
{
nLastId = -1;
for (i=0; i < MAX_LIMIT; i++)
{
if (nTabId == aPriceLimits[i].nId)
nLastId = i;
}
if (nLastId == -1)
INTERNAL("No pricing limits defined");
nQuantityMax = atoi(aPriceLimits[nLastId].szQuantity);
strtodec(&dDiscountMax, aPriceLimits[nLastId].szDiscount);
strtodec(&dMarkupMax, aPriceLimits[nLastId].szMarkUp);
strtodec(&dWholesaleMax, aPriceLimits[nLastId].szWholesale);
strtodec(&dCouponMax, aPriceLimits[nLastId].szCoupon);
}
switch(nTabId)
{
case SS_PRICING:
case CS_PRICING:
case WS_PRICING:
case S_PLINE_PRICING:
case S_CLIN_PRICING:
case S_WLIN_PRICING:
genrand_integer(&pPricing->quantity, DIST_UNIFORM, nQuantityMin, nQuantityMax, 0, nTabId);
itodec(&dQuantity, pPricing->quantity);
genrand_decimal(&pPricing->wholesale_cost, DIST_UNIFORM, &dWholesaleMin, &dWholesaleMax, NULL, nTabId);
/* ext_wholesale_cost = wholesale_cost * quantity */
decimal_t_op(&pPricing->ext_wholesale_cost, OP_MULT, &dQuantity, &pPricing->wholesale_cost);
/* list_price = wholesale_cost * (1 + markup) */
genrand_decimal(&dMarkup, DIST_UNIFORM, &dMarkupMin, &dMarkupMax, NULL, nTabId);
decimal_t_op(&dMarkup, OP_PLUS, &dMarkup, &dOne);
decimal_t_op(&pPricing->list_price, OP_MULT, &pPricing->wholesale_cost, &dMarkup);
/* sales_price = list_price * (1 - discount)*/
genrand_decimal(&dDiscount, DIST_UNIFORM, &dDiscountMin, &dDiscountMax, NULL, nTabId);
NegateDecimal(&dDiscount);
decimal_t_op(&pPricing->ext_discount_amt, OP_PLUS, &dDiscount, &dOne);
decimal_t_op(&pPricing->sales_price, OP_MULT, &pPricing->list_price, &pPricing->ext_discount_amt);
/* ext_list_price = list_price * quantity */
decimal_t_op(&pPricing->ext_list_price, OP_MULT, &pPricing->list_price, &dQuantity);
/* ext_sales_price = sales_price * quantity */
decimal_t_op(&pPricing->ext_sales_price, OP_MULT, &pPricing->sales_price, &dQuantity);
/* ext_discount_amt = ext_list_price - ext_sales_price */
decimal_t_op(&pPricing->ext_discount_amt, OP_MINUS, &pPricing->ext_list_price, &pPricing->ext_sales_price);
/* coupon_amt = ext_sales_price * coupon */
genrand_decimal(&dCoupon, DIST_UNIFORM, &dZero, &dOne, NULL, nTabId);
genrand_integer(&nCouponUsage, DIST_UNIFORM, 1, 100, 0, nTabId);
if (nCouponUsage <= 20) /* 20% of sales employ a coupon */
decimal_t_op(&pPricing->coupon_amt, OP_MULT, &pPricing->ext_sales_price, &dCoupon);
else
memcpy(&pPricing->coupon_amt, &dZero, sizeof(decimal_t));
/* net_paid = ext_sales_price - coupon_amt */
decimal_t_op(&pPricing->net_paid, OP_MINUS, &pPricing->ext_sales_price, &pPricing->coupon_amt);
/* shipping_cost = list_price * shipping */
genrand_decimal(&dShipping, DIST_UNIFORM, &dZero, &dOneHalf, NULL, nTabId);
decimal_t_op(&pPricing->ship_cost, OP_MULT, &pPricing->list_price, &dShipping);
/* ext_shipping_cost = shipping_cost * quantity */
decimal_t_op(&pPricing->ext_ship_cost, OP_MULT, &pPricing->ship_cost, &dQuantity);
/* net_paid_inc_ship = net_paid + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship, OP_PLUS, &pPricing->net_paid, &pPricing->ext_ship_cost);
/* ext_tax = tax * net_paid */
genrand_decimal(&pPricing->tax_pct, DIST_UNIFORM, &dZero, &d9pct, NULL, nTabId);
decimal_t_op(&pPricing->ext_tax, OP_MULT, &pPricing->net_paid, &pPricing->tax_pct);
/* net_paid_inc_tax = net_paid + ext_tax */
decimal_t_op(&pPricing->net_paid_inc_tax, OP_PLUS, &pPricing->net_paid, &pPricing->ext_tax);
/* net_paid_inc_ship_tax = net_paid_inc_tax + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship_tax, OP_PLUS, &pPricing->net_paid_inc_ship, &pPricing->ext_tax);
/* net_profit = net_paid - ext_wholesale_cost */
decimal_t_op(&pPricing->net_profit, OP_MINUS, &pPricing->net_paid, &pPricing->ext_wholesale_cost);
break;
case CR_PRICING:
case SR_PRICING:
case WR_PRICING:
/* quantity is determined before we are called */
/* ext_wholesale_cost = wholesale_cost * quantity */
itodec(&dQuantity, pPricing->quantity);
decimal_t_op(&pPricing->ext_wholesale_cost, OP_MULT, &dQuantity, &pPricing->wholesale_cost);
/* ext_list_price = list_price * quantity */
decimal_t_op(&pPricing->ext_list_price, OP_MULT, &pPricing->list_price, &dQuantity);
/* ext_sales_price = sales_price * quantity */
decimal_t_op(&pPricing->ext_sales_price, OP_MULT, &pPricing->sales_price, &dQuantity);
/* net_paid = ext_list_price (couppons don't effect returns) */
memcpy(&pPricing->net_paid, &pPricing->ext_sales_price, sizeof(decimal_t));
/* shipping_cost = list_price * shipping */
genrand_decimal(&dShipping, DIST_UNIFORM, &dZero, &dOneHalf, NULL, nTabId);
decimal_t_op(&pPricing->ship_cost, OP_MULT, &pPricing->list_price, &dShipping);
/* ext_shipping_cost = shipping_cost * quantity */
decimal_t_op(&pPricing->ext_ship_cost, OP_MULT, &pPricing->ship_cost, &dQuantity);
/* net_paid_inc_ship = net_paid + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship, OP_PLUS, &pPricing->net_paid, &pPricing->ext_ship_cost);
/* ext_tax = tax * net_paid */
decimal_t_op(&pPricing->ext_tax, OP_MULT, &pPricing->net_paid, &pPricing->tax_pct);
/* net_paid_inc_tax = net_paid + ext_tax */
decimal_t_op(&pPricing->net_paid_inc_tax, OP_PLUS, &pPricing->net_paid, &pPricing->ext_tax);
/* net_paid_inc_ship_tax = net_paid_inc_tax + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship_tax, OP_PLUS, &pPricing->net_paid_inc_ship, &pPricing->ext_tax);
/* net_profit = net_paid - ext_wholesale_cost */
decimal_t_op(&pPricing->net_profit, OP_MINUS, &pPricing->net_paid, &pPricing->ext_wholesale_cost);
/* see to it that the returned amounts add up to the total returned */
/* allocate some of return to cash */
genrand_integer(&nCashPct, DIST_UNIFORM, 0, 100, 0, nTabId);
itodec(&dTemp, nCashPct);
decimal_t_op(&pPricing->refunded_cash, OP_DIV, &dTemp, &dHundred);
decimal_t_op(&pPricing->refunded_cash, OP_MULT, &pPricing->refunded_cash, &pPricing->net_paid);
/* allocate some to reversed charges */
genrand_integer(&nCreditPct, DIST_UNIFORM, 1, 100, 0, nTabId);
itodec(&dTemp2, nCreditPct);
decimal_t_op(&dTemp, OP_DIV, &dTemp2, &dHundred);
decimal_t_op(&dTemp2, OP_MINUS, &pPricing->net_paid, &pPricing->refunded_cash);
decimal_t_op(&pPricing->reversed_charge, OP_MULT, &dTemp2, &dTemp);
/* the rest is store credit */
decimal_t_op(&pPricing->store_credit, OP_MINUS, &pPricing->net_paid, &pPricing->reversed_charge);
decimal_t_op(&pPricing->store_credit, OP_MINUS, &pPricing->store_credit, &pPricing->refunded_cash);
/* pick a fee for the return */
genrand_decimal(&pPricing->fee, DIST_UNIFORM, &dOneHalf, &dHundred, &dZero, nTabId);
/* and calculate the net effect */
decimal_t_op(&pPricing->net_loss, OP_MINUS, &pPricing->net_paid_inc_ship_tax, &pPricing->store_credit);
decimal_t_op(&pPricing->net_loss, OP_MINUS, &pPricing->net_loss, &pPricing->refunded_cash);
decimal_t_op(&pPricing->net_loss, OP_MINUS, &pPricing->net_loss, &pPricing->reversed_charge);
decimal_t_op(&pPricing->net_loss, OP_PLUS, &pPricing->net_loss, &pPricing->fee);
break;
}
return;
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int MatchDistWeight(void *dest, char *szDist, int nWeight, int nWeightSet, int ValueSet)
{
d_idx_t *d;
dist_t *dist;
int index = 0,
dt,
i_res,
nRetcode;
char *char_val;
if ((d = find_dist(szDist)) == NULL)
{
char msg[80];
sprintf(msg, "Invalid distribution name '%s'", szDist);
INTERNAL(msg);
}
dist = d->dist;
nWeight %= dist->maximums[nWeightSet - 1];
while (nWeight > dist->weight_sets[nWeightSet - 1][index] &&
index < d->length)
index += 1;
dt = ValueSet - 1;
if (index >= d->length)
index = d->length - 1;
char_val = dist->strings + dist->value_sets[dt][index];
switch(dist->type_vector[dt])
{
case TKN_VARCHAR:
if (dest)
*(char **)dest = (char *)char_val;
break;
case TKN_INT:
i_res = atoi(char_val);
if (dest)
*(int *)dest = i_res;
break;
case TKN_DATE:
if (dest == NULL)
{
dest = (date_t *)malloc(sizeof(date_t));
MALLOC_CHECK(dest);
}
strtodt(*(date_t **)dest, char_val);
break;
case TKN_DECIMAL:
if (dest == NULL)
{
dest = (decimal_t *)malloc(sizeof(decimal_t));
MALLOC_CHECK(dest);
}
strtodec(*(decimal_t **)dest,char_val);
break;
}
nRetcode = 1;
index = 1;
while (index < dist->maximums[nWeightSet - 1])
{
nRetcode += 1;
index *= 2;
}
return(nRetcode);
}
/*
* Routine: void *dist_op()
* Purpose: select a value/weight from a distribution
* Algorithm:
* Data Structures:
*
* Params: char *d_name
* int vset: which set of values
* int wset: which set of weights
* Returns: appropriate data type cast as a void *
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: 20000317 Need to be sure this is portable to NT and others
*/
int
dist_op(void *dest, int op, char *d_name, int vset, int wset, int stream)
{
d_idx_t *d;
dist_t *dist;
int level,
index = 0,
dt;
char *char_val;
int i_res = 1;
if ((d = find_dist(d_name)) == NULL)
{
char msg[80];
sprintf(msg, "Invalid distribution name '%s'", d_name);
INTERNAL(msg);
assert(d != NULL);
}
dist = d->dist;
if (op == 0)
{
genrand_integer(&level, DIST_UNIFORM, 1,
dist->maximums[wset - 1], 0, stream);
while (level > dist->weight_sets[wset - 1][index] &&
index < d->length)
index += 1;
dt = vset - 1;
if ((index >= d->length) || (dt > d->v_width))
INTERNAL("Distribution overrun");
char_val = dist->strings + dist->value_sets[dt][index];
}
else
{
index = vset - 1;
dt = wset - 1;
if (index >= d->length || index < 0)
{
fprintf(stderr, "Runtime ERROR: Distribution over-run/under-run\n");
fprintf(stderr, "Check distribution definitions and usage for %s.\n",
d->name);
fprintf(stderr, "index = %d, length=%d.\n",
index, d->length);
exit(1);
}
char_val = dist->strings + dist->value_sets[dt][index];
}
switch(dist->type_vector[dt])
{
case TKN_VARCHAR:
if (dest)
*(char **)dest = (char *)char_val;
break;
case TKN_INT:
i_res = atoi(char_val);
if (dest)
*(int *)dest = i_res;
break;
case TKN_DATE:
if (dest == NULL)
{
dest = (date_t *)malloc(sizeof(date_t));
MALLOC_CHECK(dest);
}
strtodt(*(date_t **)dest, char_val);
break;
case TKN_DECIMAL:
if (dest == NULL)
{
dest = (decimal_t *)malloc(sizeof(decimal_t));
MALLOC_CHECK(dest);
}
strtodec(*(decimal_t **)dest,char_val);
break;
}
return((dest == NULL)?i_res:index + 1); /* shift back to the 1-based indexing scheme */
}
/*
* Routine: mk_store_returns()
* Purpose: populate a return fact *sync'd with a sales fact*
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
mk_w_store_returns (void * row, ds_key_t index)
{
int res = 0,
nTemp;
struct W_STORE_RETURNS_TBL *r;
struct W_STORE_SALES_TBL *sale = &g_w_store_sales;
static int bInit = 0;
tdef *pT = getSimpleTdefsByNumber(STORE_RETURNS);
static decimal_t dMin,
dMax;
/* begin locals declarations */
if (row == NULL)
r = &g_w_store_returns;
else
r = row;
if (!bInit)
{
strtodec (&dMin, "1.00");
strtodec (&dMax, "100000.00");
}
nullSet(&pT->kNullBitMap, SR_NULLS);
/*
* Some of the information in the return is taken from the original sale
* which has been regenerated
*/
r->sr_ticket_number = sale->ss_ticket_number;
r->sr_item_sk = sale->ss_sold_item_sk;
memcpy((void *)&r->sr_pricing, (void *)&sale->ss_pricing, sizeof(ds_pricing_t));
/*
* some of the fields are conditionally taken from the sale
*/
r->sr_customer_sk = mk_join (SR_CUSTOMER_SK, CUSTOMER, 1);
if (genrand_integer(NULL, DIST_UNIFORM, 1, 100, 0, SR_TICKET_NUMBER) < SR_SAME_CUSTOMER)
r->sr_customer_sk = sale->ss_sold_customer_sk;
/*
* the rest of the columns are generated for this specific return
*/
/* the items cannot be returned until they are sold; offset is handled in mk_join, based on sales date */
r->sr_returned_date_sk = mk_join (SR_RETURNED_DATE_SK, DATE, sale->ss_sold_date_sk);
genrand_integer(&nTemp, DIST_UNIFORM, (8 * 3600) - 1, (17 * 3600) - 1, 0, SR_RETURNED_TIME_SK);
r->sr_returned_time_sk = nTemp;
r->sr_cdemo_sk =
mk_join (SR_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1);
r->sr_hdemo_sk =
mk_join (SR_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1);
r->sr_addr_sk = mk_join (SR_ADDR_SK, CUSTOMER_ADDRESS, 1);
r->sr_store_sk = mk_join (SR_STORE_SK, STORE, 1);
r->sr_reason_sk = mk_join (SR_REASON_SK, REASON, 1);
genrand_integer(&r->sr_pricing.quantity, DIST_UNIFORM,
1, sale->ss_pricing.quantity, 0, SR_PRICING);
set_pricing(SR_PRICING, &r->sr_pricing);
return (res);
}
/*
* mk_item
*/
int
mk_w_item (void* row, ds_key_t index)
{
int32_t res = 0;
/* begin locals declarations */
decimal_t dMinPrice,
dMaxPrice,
dMarkdown;
static decimal_t dMinMarkdown, dMaxMarkdown;
int32_t bUseSize,
bFirstRecord = 0,
nFieldChangeFlags,
nMin,
nMax,
nIndex,
nTemp;
char *cp;
struct W_ITEM_TBL *r;
static int32_t bInit = 0;
struct W_ITEM_TBL *rOldValues = &g_OldValues;
char *szMinPrice = NULL,
*szMaxPrice = NULL;
tdef *pT = getSimpleTdefsByNumber(ITEM);
if (row == NULL)
r = &g_w_item;
else
r = row;
if (!bInit)
{
/* some fields are static throughout the data set */
strtodec(&dMinMarkdown, MIN_ITEM_MARKDOWN_PCT);
strtodec(&dMaxMarkdown, MAX_ITEM_MARKDOWN_PCT);
bInit = 1;
}
memset(r, 0, sizeof(struct W_ITEM_TBL));
/* build the new value */
nullSet(&pT->kNullBitMap, I_NULLS);
r->i_item_sk = index;
nIndex = pick_distribution(&nMin, "i_manager_id", 2, 1, I_MANAGER_ID);
dist_member(&nMax, "i_manager_id", nIndex, 3);
genrand_key(&r->i_manager_id, DIST_UNIFORM,
(ds_key_t)nMin,
(ds_key_t)nMax,
0, I_MANAGER_ID);
/* if we have generated the required history for this business key and generate a new one
* then reset associated fields (e.g., rec_start_date minimums)
*/
if (setSCDKeys(I_ITEM_ID, index, r->i_item_id, &r->i_rec_start_date_id, &r->i_rec_end_date_id))
{
/*
* some fields are not changed, even when a new version of the row is written
*/
bFirstRecord = 1;
}
/*
* this is where we select the random number that controls if a field changes from
* one record to the next.
*/
nFieldChangeFlags = next_random(I_SCD);
/* the rest of the record in a history-keeping dimension can either be a new data value or not;
* use a random number and its bit pattern to determine which fields to replace and which to retain
*/
gen_text (r->i_item_desc, 1, RS_I_ITEM_DESC, I_ITEM_DESC);
changeSCD(SCD_CHAR, &r->i_item_desc, &rOldValues->i_item_desc, &nFieldChangeFlags, bFirstRecord);
nIndex = pick_distribution(&szMinPrice, "i_current_price", 2, 1, I_CURRENT_PRICE);
dist_member(&szMaxPrice, "i_current_price", nIndex, 3);
strtodec(&dMinPrice, szMinPrice);
strtodec(&dMaxPrice, szMaxPrice);
genrand_decimal(&r->i_current_price, DIST_UNIFORM, &dMinPrice, &dMaxPrice, NULL, I_CURRENT_PRICE);
changeSCD(SCD_INT, &r->i_current_price, &rOldValues->i_current_price, &nFieldChangeFlags, bFirstRecord);
genrand_decimal(&dMarkdown, DIST_UNIFORM, &dMinMarkdown, &dMaxMarkdown, NULL, I_WHOLESALE_COST);
decimal_t_op(&r->i_wholesale_cost, OP_MULT, &r->i_current_price, &dMarkdown);
changeSCD(SCD_DEC, &r->i_wholesale_cost, &rOldValues->i_wholesale_cost, &nFieldChangeFlags, bFirstRecord);
hierarchy_item (I_CATEGORY, &r->i_category_id, &r->i_category, index);
/*
* changeSCD(SCD_INT, &r->i_category_id, &rOldValues->i_category_id, &nFieldChangeFlags, bFirstRecord);
*/
hierarchy_item (I_CLASS, &r->i_class_id, &r->i_class, index);
changeSCD(SCD_KEY, &r->i_class_id, &rOldValues->i_class_id, &nFieldChangeFlags, bFirstRecord);
cp = &r->i_brand[0];
hierarchy_item (I_BRAND, &r->i_brand_id, &cp, index);
changeSCD(SCD_KEY, &r->i_brand_id, &rOldValues->i_brand_id, &nFieldChangeFlags, bFirstRecord);
/* some categories have meaningful sizes, some don't */
if (r->i_category_id)
{
dist_member(&bUseSize, "categories", (int)r->i_category_id, 3);
pick_distribution (&r->i_size, "sizes", 1, bUseSize + 2, I_SIZE);
changeSCD(SCD_PTR, &r->i_size, &rOldValues->i_size, &nFieldChangeFlags, bFirstRecord);
}
else
{
bUseSize = 0;
r->i_size = NULL;
}
nIndex = pick_distribution(&nMin, "i_manufact_id", 2, 1, I_MANUFACT_ID);
genrand_integer(&nTemp, DIST_UNIFORM,
nMin,
dist_member(NULL, "i_manufact_id", nIndex, 3),
0, I_MANUFACT_ID);
r->i_manufact_id = nTemp;
changeSCD(SCD_KEY, &r->i_manufact_id, &rOldValues->i_manufact_id, &nFieldChangeFlags, bFirstRecord);
mk_word (r->i_manufact, "syllables", (int) r->i_manufact_id, RS_I_MANUFACT, ITEM);
changeSCD(SCD_CHAR, &r->i_manufact, &rOldValues->i_manufact, &nFieldChangeFlags, bFirstRecord);
gen_charset(r->i_formulation, DIGITS, RS_I_FORMULATION, RS_I_FORMULATION, I_FORMULATION);
embed_string(r->i_formulation, "colors", 1, 2, I_FORMULATION);
changeSCD(SCD_CHAR, &r->i_formulation, &rOldValues->i_formulation, &nFieldChangeFlags, bFirstRecord);
pick_distribution (&r->i_color, "colors", 1, 2, I_COLOR);
changeSCD(SCD_PTR, &r->i_color, &rOldValues->i_color, &nFieldChangeFlags, bFirstRecord);
pick_distribution (&r->i_units, "units", 1, 1, I_UNITS);
changeSCD(SCD_PTR, &r->i_units, &rOldValues->i_units, &nFieldChangeFlags, bFirstRecord);
pick_distribution (&r->i_container, "container", 1, 1, ITEM);
changeSCD(SCD_PTR, &r->i_container, &rOldValues->i_container, &nFieldChangeFlags, bFirstRecord);
mk_word (r->i_product_name, "syllables", (int) index, RS_I_PRODUCT_NAME,
ITEM);
r->i_promo_sk = mk_join(I_PROMO_SK, PROMOTION, 1);
genrand_integer(&nTemp, DIST_UNIFORM, 1, 100, 0, I_PROMO_SK);
if (nTemp > I_PROMO_PERCENTAGE)
r->i_promo_sk = -1;
/*
* if this is the first of a set of revisions, then baseline the old values
*/
if (bFirstRecord)
memcpy(&g_OldValues, r, sizeof(struct W_ITEM_TBL));
if (index == 1)
memcpy(&g_OldValues, r, sizeof(struct W_ITEM_TBL));
return (res);
}
uint process_monitor(DeviceInfo info, MYSQL *mysql, RRDInfo rrd)
{
debuglogger(DEBUG_MONITOR, LEVEL_INFO, &info, "Starting Monitor.");
info.parameters.push_front(ValuePair("parameters", info.test_params));
switch (info.test_type)
{
case 1: info.curr_val = process_script_monitor(info, mysql);
break;
case 2: info.curr_val = process_snmp_monitor(info, mysql);
break;
case 3: info.curr_val = process_sql_monitor(info, mysql);
break;
case 4: info.curr_val = process_internal_monitor(info, mysql);
break;
default: debuglogger(DEBUG_MONITOR, LEVEL_WARNING, &info, "Unknown test type (" + inttostr(info.test_type) + ").");
info.curr_val = "U";
} // end switch
debuglogger(DEBUG_MONITOR, LEVEL_INFO, &info, "Value: " + strstripnl(info.curr_val));
// strip out anything not numeric
info.curr_val = remove_nonnumerics(info.curr_val);
if (rrd.data_type != "")
{
update_monitor_rrd(info, rrd);
}
// what type of value are we dealing with?
if (info.curr_val == "U")
{
// value is unknown
debuglogger(DEBUG_MONITOR, LEVEL_INFO, &info, "Value is unknown.");
}
else if (info.curr_val == inttostr(strtoint(info.curr_val)))
{
// value is an integer
// (do nothing)
debuglogger(DEBUG_MONITOR, LEVEL_INFO, &info, "Value is an integer.");
}
else if (info.curr_val == "")
{
// value is non-numeric
debuglogger(DEBUG_MONITOR, LEVEL_INFO, &info, "Value is not numeric.");
info.curr_val = "U";
}
else
{
//value is probably decimal
debuglogger(DEBUG_MONITOR, LEVEL_INFO, &info, "Value is a decimal.");
info.curr_val = inttostr(ROUND_VAL(strtodec(info.curr_val)));
}
if ((info.curr_val == "U") || (info.last_val == "U"))
{
info.delta_val = "U";
info.rate_val = "U";
}
else
{
info.delta_val = inttostr(strtoint(info.curr_val) - strtoint(info.last_val));
if (info.delta_time != 0)
{
info.rate_val = inttostr(strtoint(info.delta_val) / info.delta_time);
}
else
{
info.rate_val = "U";
}
}
// populate parameters
info.parameters.push_front(ValuePair("current_value", info.curr_val));
info.parameters.push_front(ValuePair("delta_value", info.delta_val));
info.parameters.push_front(ValuePair("rate_value", info.rate_val));
info.parameters.push_front(ValuePair("last_value", info.last_val));
uint status = process_events(info, mysql);
info.status = status;
update_monitor_db(info, mysql, rrd);
return status;
}
