int mu_extr_getblk(unsigned char *ptr)
{
error_def(ERR_GVGETFAIL);
enum cdb_sc status;
rec_hdr_ptr_t rp;
bool two_histories, end_of_tree;
blk_hdr_ptr_t bp;
srch_blk_status *bh;
srch_hist *rt_history;
t_begin(ERR_GVGETFAIL, FALSE);
for (;;)
{
if (cdb_sc_normal != (status = gvcst_search(gv_currkey, NULL)))
{
t_retry(status);
continue;
}
end_of_tree = two_histories
= FALSE;
bh = gv_target->hist.h;
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
if (rp >= (rec_hdr_ptr_t)CST_TOB(bp))
{
rt_history = gv_target->alt_hist;
if (cdb_sc_normal == (status = gvcst_rtsib(rt_history, 0)))
{
two_histories = TRUE;
if (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, rt_history->h)))
{
t_retry(status);
continue;
}
bp = (blk_hdr_ptr_t)rt_history->h[0].buffaddr;
} else if (cdb_sc_endtree == status)
end_of_tree = TRUE;
else
{
t_retry(status);
continue;
}
}
memcpy(ptr, bp, bp->bsiz);
if (t_end(&gv_target->hist, two_histories ? rt_history : NULL) != 0)
{
if (two_histories)
memcpy(gv_target->hist.h, rt_history->h, sizeof(srch_blk_status) * (rt_history->depth + 1));
return !end_of_tree;
}
}
}
boolean_t gvcst_query2(void)
{
boolean_t found, two_histories;
enum cdb_sc status;
blk_hdr_ptr_t bp;
rec_hdr_ptr_t rp;
unsigned char *c1, *c2;
srch_blk_status *bh;
srch_hist *rt_history;
T_BEGIN_READ_NONTP_OR_TP(ERR_GVQUERYFAIL);
assert(t_tries < CDB_STAGNATE || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
for (;;)
{
two_histories = FALSE;
# if defined(DEBUG) && defined(UNIX)
if (gtm_white_box_test_case_enabled && (WBTEST_ANTIFREEZE_GVQUERYFAIL == gtm_white_box_test_case_number))
{
t_retry(cdb_sc_blknumerr);
continue;
}
# endif
if (cdb_sc_normal == (status = gvcst_search(gv_currkey, 0)))
{
found = TRUE;
bh = &gv_target->hist.h[0];
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
if (rp >= (rec_hdr_ptr_t)CST_TOB(bp))
{
two_histories = TRUE;
rt_history = gv_target->alt_hist;
status = gvcst_rtsib(rt_history, 0);
if (cdb_sc_endtree == status) /* end of tree */
{
found = FALSE;
two_histories = FALSE; /* second history not valid */
} else if (cdb_sc_normal != status)
{
t_retry(status);
continue;
} else
{
bh = &rt_history->h[0];
if (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, bh)))
{
t_retry(status);
continue;
}
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
}
}
if (found)
{ /* !found indicates that the end of tree has been reached (see call to
* gvcst_rtsib). If there is no more tree, don't bother doing expansion.
*/
status = gvcst_expand_curr_key(bh, gv_currkey, gv_altkey);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
if (!dollar_tlevel)
{
if ((trans_num)0 == t_end(&gv_target->hist, !two_histories ? NULL : rt_history, TN_NOT_SPECIFIED))
continue;
} else
{
status = tp_hist(!two_histories ? NULL : rt_history);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
assert(cs_data == cs_addrs->hdr);
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_query, 1);
if (found)
{
c1 = &gv_altkey->base[0];
c2 = &gv_currkey->base[0];
for ( ; *c2; )
{
if (*c2++ != *c1++)
break;
}
if (!*c2 && !*c1)
return TRUE;
}
return FALSE;
}
t_retry(status);
}
}
mint gvcst_data(void)
{
blk_hdr_ptr_t bp;
enum cdb_sc status;
mint val;
rec_hdr_ptr_t rp;
unsigned short rec_size;
srch_blk_status *bh;
srch_hist *rt_history;
sm_uc_ptr_t b_top;
assert((gv_target->root < cs_addrs->ti->total_blks) || (0 < dollar_tlevel));
T_BEGIN_READ_NONTP_OR_TP(ERR_GVDATAFAIL);
assert(t_tries < CDB_STAGNATE || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
for (;;)
{
rt_history = gv_target->alt_hist;
rt_history->h[0].blk_num = 0;
if ((status = gvcst_search(gv_currkey, NULL)) != cdb_sc_normal)
{
t_retry(status);
continue;
}
bh = gv_target->hist.h;
bp = (blk_hdr_ptr_t)bh->buffaddr;
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
b_top = bh->buffaddr + bp->bsiz;
val = 0;
if (gv_currkey->end + 1 == bh->curr_rec.match)
val = 1;
else if (bh->curr_rec.match >= gv_currkey->end)
val = 10;
if (1 == val || rp == (rec_hdr_ptr_t)b_top)
{
GET_USHORT(rec_size, &rp->rsiz);
if (rp == (rec_hdr_ptr_t)b_top || (sm_uc_ptr_t)rp + rec_size == b_top)
{
if (cdb_sc_endtree != (status = gvcst_rtsib(rt_history, 0)))
{
if ((cdb_sc_normal != status)
|| (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, rt_history->h))))
{
t_retry(status);
continue;
}
if (rt_history->h[0].curr_rec.match >= gv_currkey->end)
val += 10;
}
} else
{
if ((sm_uc_ptr_t)rp + rec_size > b_top)
{
t_retry(cdb_sc_rmisalign);
continue;
}
rp = (rec_hdr_ptr_t)((sm_uc_ptr_t)rp + rec_size);
if (rp->cmpc >= gv_currkey->end)
val += 10;
}
}
if (0 == dollar_tlevel)
{
if ((trans_num)0 == t_end(&gv_target->hist, 0 == rt_history->h[0].blk_num ? NULL : rt_history))
continue;
} else
{
status = tp_hist(0 == rt_history->h[0].blk_num ? NULL : rt_history);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_data, 1);
return val;
}
}
boolean_t gvcst_order2(void)
{
blk_hdr_ptr_t bp;
boolean_t found, two_histories;
enum cdb_sc status;
rec_hdr_ptr_t rp;
unsigned short rec_size;
srch_blk_status *bh;
srch_hist *rt_history;
sm_uc_ptr_t c1, c2, ctop, alt_top;
int tmp_cmpc;
T_BEGIN_READ_NONTP_OR_TP(ERR_GVORDERFAIL);
for (;;)
{
assert(t_tries < CDB_STAGNATE || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
two_histories = FALSE;
#if defined(DEBUG) && defined(UNIX)
if (gtm_white_box_test_case_enabled && (WBTEST_ANTIFREEZE_GVORDERFAIL == gtm_white_box_test_case_number))
{
status = cdb_sc_blknumerr;
t_retry(status);
continue;
}
#endif
if (cdb_sc_normal == (status = gvcst_search(gv_currkey, NULL)))
{
found = TRUE;
bh = gv_target->hist.h;
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
if ((rec_hdr_ptr_t)CST_TOB(bp) <= rp)
{
two_histories = TRUE;
rt_history = gv_target->alt_hist;
status = gvcst_rtsib(rt_history, 0);
if (cdb_sc_normal == status)
{
bh = rt_history->h;
if (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, bh)))
{
t_retry(status);
continue;
}
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
} else
{
if (cdb_sc_endtree == status)
{
found = FALSE;
two_histories = FALSE; /* second history not valid */
} else
{
t_retry(status);
continue;
}
}
}
if (found)
{
assert(gv_altkey->top == gv_currkey->top);
assert(gv_altkey->top == gv_keysize);
assert(gv_altkey->end < gv_altkey->top);
/* store new subscipt */
c1 = gv_altkey->base;
alt_top = gv_altkey->base + gv_altkey->top - 1;
/* Make alt_top one less than gv_altkey->top to allow double-null at end of a key-name */
/* 4/17/96
* HP compiler bug work-around. The original statement was
* c2 = (unsigned char *)CST_BOK(rp) + bh->curr_rec.match - rp->cmpc;
*
* ...but this was sometimes compiled incorrectly (the lower 4 bits
* of rp->cmpc, sign extended, were subtracted from bh->curr_rec.match).
* I separated out the subtraction of rp->cmpc.
*
* -VTF.
*/
c2 = (sm_uc_ptr_t)CST_BOK(rp) + bh->curr_rec.match;
memcpy(c1, gv_currkey->base, bh->curr_rec.match);
c1 += bh->curr_rec.match;
c2 -= EVAL_CMPC(rp);
GET_USHORT(rec_size, &rp->rsiz);
ctop = (sm_uc_ptr_t)rp + rec_size;
for (;;)
{
if (c2 >= ctop || c1 >= alt_top)
{
assert(CDB_STAGNATE > t_tries);
status = cdb_sc_rmisalign;
goto restart; /* goto needed because of nested FOR loop */
}
if (0 == (*c1++ = *c2++))
{
*c1 = 0;
break;
}
}
gv_altkey->end = c1 - gv_altkey->base;
assert(gv_altkey->end < gv_altkey->top);
}
if (!dollar_tlevel)
{
if ((trans_num)0 == t_end(&gv_target->hist, two_histories ? rt_history : NULL, TN_NOT_SPECIFIED))
continue;
} else
{
status = tp_hist(two_histories ? rt_history : NULL);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
assert(cs_data == cs_addrs->hdr);
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_order, 1);
return (found && (bh->curr_rec.match >= gv_currkey->prev));
}
restart: t_retry(status);
}
}
/* This function is the equivalent of invoking gvcst_data & gvcst_get at the same time.
* One crucial difference is that this function does NOT handle restarts by automatically invoking t_retry.
* Instead, it returns the restart code to the caller so that it can handle the restart accordingly.
* This is important in the case of triggers because we do NOT want to call t_retry in case of a implicit tstart
* wrapped gvcst_put or gvcst_kill trigger-invoking update transaction. Additionally, this function assumes
* that it is called always inside of TP (i.e. dollar_tlevel is non-zero).
*/
enum cdb_sc gvcst_dataget(mint *dollar_data, mval *val)
{
blk_hdr_ptr_t bp;
boolean_t do_rtsib;
enum cdb_sc status;
mint dlr_data;
rec_hdr_ptr_t rp;
unsigned short match, rsiz;
srch_blk_status *bh;
srch_hist *rt_history;
sm_uc_ptr_t b_top;
int key_size, data_len;
uint4 save_t_err;
error_def(ERR_GVDATAGETFAIL);
error_def(ERR_GVKILLFAIL);
/* The following code is lifted from gvcst_data. Any changes here might need to be reflected there as well */
assert(dollar_tlevel);
assert((CDB_STAGNATE > t_tries) || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
save_t_err = t_err;
assert(ERR_GVKILLFAIL == save_t_err); /* this function should currently be called only from gvcst_kill */
t_err = ERR_GVDATAGETFAIL; /* switch t_err to reflect dataget sub-operation (under the KILL operation) */
/* In case of a failure return, it is ok to return with t_err set to ERR_GVDATAGETFAIL as that gives a better
* picture of exactly where in the transaction the failure occurred.
*/
rt_history = gv_target->alt_hist;
rt_history->h[0].blk_num = 0;
if (cdb_sc_normal != (status = gvcst_search(gv_currkey, NULL)))
return status;
bh = gv_target->hist.h;
bp = (blk_hdr_ptr_t)bh->buffaddr;
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
b_top = bh->buffaddr + bp->bsiz;
match = bh->curr_rec.match;
key_size = gv_currkey->end + 1;
do_rtsib = FALSE;
/* Even if key does not exist, return null string in "val". Caller can use dollar_data to distinguish
* whether the key is undefined or defined and set to the null string.
*/
val->mvtype = MV_STR;
val->str.len = 0;
if (key_size == match)
{
dlr_data = 1;
/* the following code is lifted from gvcst_get. any changes here might need to be reflected there as well */
GET_USHORT(rsiz, &rp->rsiz);
data_len = rsiz + rp->cmpc - SIZEOF(rec_hdr) - key_size;
if ((0 > data_len) || ((sm_uc_ptr_t)rp + rsiz > b_top))
{
assert(CDB_STAGNATE > t_tries);
status = cdb_sc_rmisalign1;
return status;
} else
{
ENSURE_STP_FREE_SPACE(data_len);
memcpy(stringpool.free, (sm_uc_ptr_t)rp + rsiz - data_len, data_len);
val->str.addr = (char *)stringpool.free;
val->str.len = data_len;
stringpool.free += data_len;
}
/* --------------------- end code lifted from gvcst_get ---------------------------- */
rp = (rec_hdr_ptr_t)((sm_uc_ptr_t)rp + rsiz);
if ((sm_uc_ptr_t)rp > b_top)
{
status = cdb_sc_rmisalign;
return status;
} else if ((sm_uc_ptr_t)rp == b_top)
do_rtsib = TRUE;
else if (rp->cmpc >= gv_currkey->end)
dlr_data += 10;
} else if (match >= gv_currkey->end)
dlr_data = 10;
else
{
dlr_data = 0;
if (rp == (rec_hdr_ptr_t)b_top)
do_rtsib = TRUE;
}
if (do_rtsib && (cdb_sc_endtree != (status = gvcst_rtsib(rt_history, 0))))
{
if ((cdb_sc_normal != status) || (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, rt_history->h))))
return status;
if (rt_history->h[0].curr_rec.match >= gv_currkey->end)
{
assert(1 >= dlr_data);
dlr_data += 10;
}
}
status = tp_hist(0 == rt_history->h[0].blk_num ? NULL : rt_history);
if (cdb_sc_normal != status)
return status;
*dollar_data = dlr_data;
t_err = save_t_err; /* restore t_err to what it was at function entry */
return status;
}
mint gvcst_data(void)
{
blk_hdr_ptr_t bp;
boolean_t do_rtsib;
enum cdb_sc status;
mint val;
rec_hdr_ptr_t rp;
unsigned short match, rsiz;
srch_blk_status *bh;
srch_hist *rt_history;
sm_uc_ptr_t b_top;
assert((gv_target->root < cs_addrs->ti->total_blks) || dollar_tlevel);
T_BEGIN_READ_NONTP_OR_TP(ERR_GVDATAFAIL);
assert(t_tries < CDB_STAGNATE || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
for (;;)
{
/* The following code is duplicated in gvcst_dataget. Any changes here might need to be reflected there as well */
rt_history = gv_target->alt_hist;
rt_history->h[0].blk_num = 0;
if (cdb_sc_normal != (status = gvcst_search(gv_currkey, NULL)))
{
t_retry(status);
continue;
}
bh = gv_target->hist.h;
bp = (blk_hdr_ptr_t)bh->buffaddr;
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
b_top = bh->buffaddr + bp->bsiz;
match = bh->curr_rec.match;
do_rtsib = FALSE;
if (gv_currkey->end + 1 == match)
{
val = 1;
GET_USHORT(rsiz, &rp->rsiz);
rp = (rec_hdr_ptr_t)((sm_uc_ptr_t)rp + rsiz);
if ((sm_uc_ptr_t)rp > b_top)
{
t_retry(cdb_sc_rmisalign);
continue;
} else if ((sm_uc_ptr_t)rp == b_top)
do_rtsib = TRUE;
else if (rp->cmpc >= gv_currkey->end)
val += 10;
} else if (match >= gv_currkey->end)
val = 10;
else
{
val = 0;
if (rp == (rec_hdr_ptr_t)b_top)
do_rtsib = TRUE;
}
if (do_rtsib && (cdb_sc_endtree != (status = gvcst_rtsib(rt_history, 0))))
{
if ((cdb_sc_normal != status) || (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, rt_history->h))))
{
t_retry(status);
continue;
}
if (rt_history->h[0].curr_rec.match >= gv_currkey->end)
{
assert(1 >= val);
val += 10;
}
}
if (!dollar_tlevel)
{
if ((trans_num)0 == t_end(&gv_target->hist, 0 == rt_history->h[0].blk_num ? NULL : rt_history,
TN_NOT_SPECIFIED))
continue;
} else
{
status = tp_hist(0 == rt_history->h[0].blk_num ? NULL : rt_history);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_data, 1);
return val;
}
}
/* search_tail is the "start anywhere" version of search_blk
getting started is a bit awkward, so excuse the gotos */
enum cdb_sc gvcst_search_tail (gv_key *pKey, srch_blk_status *pStat, gv_key *pOldKey)
{
/* register variables named in perceived order of declining impact */
register int nFlg, nTargLen, nMatchCnt, nTmp;
sm_uc_ptr_t pBlkBase, pRecBase, pRec, pTop, pPrevRec;
unsigned char *pCurrTarg, *pTargKeyBase, *pOldKeyBase, *pCurrTargPos;
unsigned short nRecLen;
/* see comment in gvcst_search_blk above on coding style */
if (pStat->prev_rec.offset == 0)
return gvcst_search_blk(pKey, pStat); /* nice clean start at the begining of a block */
pBlkBase = pStat->buffaddr;
pRecBase = pBlkBase + pStat->curr_rec.offset;
pRec = pRecBase;
pTop = pBlkBase + ((blk_hdr_ptr_t)pBlkBase)->bsiz;
nMatchCnt = pStat->prev_rec.match;
pCurrTarg = pKey->base;
pTargKeyBase = pCurrTarg;
pOldKeyBase = pOldKey->base;
pPrevRec = pBlkBase + pStat->prev_rec.offset;
nTargLen = pKey->end;
nTargLen++; /* for the NUL that terminates the key */
if (pRec >= pTop)
{ /* Terminated at end of block */
/* eob_tail: */ if (pRec > pTop)
{
INVOKE_GVCST_SEARCH_FAIL_IF_NEEDED(pStat);
assert(CDB_STAGNATE > t_tries);
return cdb_sc_blklenerr;
}
if ((nTargLen = nMatchCnt) != 0)
{
do
{
if (*pCurrTarg++ != *pOldKeyBase++)
break;
} while (--nTargLen);
}
if (((blk_hdr_ptr_t)pBlkBase)->levl != 0)
nMatchCnt = 0; /* star key */
else
nMatchCnt -= nTargLen;
nTargLen = 0;
} else
{
GET_USHORT(nRecLen, &((rec_hdr_ptr_t)pRec)->rsiz);
if ((nFlg = nTmp = ((rec_hdr_ptr_t)pRec)->cmpc) != 0)
{
do
{
if ((nFlg = *pCurrTarg - *pOldKeyBase++) != 0)
break;
pCurrTarg++;
} while (--nTmp);
if (nFlg > 0)
{
nMatchCnt = pCurrTarg - pTargKeyBase;
nTargLen -= nMatchCnt;
}
if (nFlg < 0)
{
nTargLen += pTargKeyBase - pCurrTarg;
goto match_term;
}
}
if (nFlg == 0)
{
nTmp = nMatchCnt;
nMatchCnt = pCurrTarg - pTargKeyBase;
nTargLen -= nMatchCnt;
nTmp -= nMatchCnt;
if (nTmp > 0)
{
pCurrTargPos = pCurrTarg;
do
{
if (*pCurrTargPos++ != *pOldKeyBase++)
break;
nMatchCnt++;
} while (--nTmp);
}
goto alt_loop_entry;
}
for (;;)
{
pRec = pRecBase + nRecLen;
if (pRec >= pTop)
{ /* Terminated at end of block */
if (pRec > pTop) /* If record goes off the end, then block must be bad */
{
INVOKE_GVCST_SEARCH_FAIL_IF_NEEDED(pStat);
assert(CDB_STAGNATE > t_tries);
return cdb_sc_blklenerr;
}
nTargLen = 0;
if (((blk_hdr_ptr_t)pBlkBase)->levl == 0)
{ /* data block */
pPrevRec = pRecBase;
pRecBase = pRec;
}
else
nMatchCnt = 0; /* star key */
break;
}
GET_USHORT(nRecLen, &((rec_hdr_ptr_t)pRec)->rsiz);
if (nRecLen == 0) /* If record length is 0, then block must be bad */
{
INVOKE_GVCST_SEARCH_FAIL_IF_NEEDED(pStat);
assert(CDB_STAGNATE > t_tries);
return cdb_sc_badoffset;
}
pPrevRec = pRecBase;
pRecBase = pRec;
/* If current compression count > last match, then this record
also matches on 'last match' characters; keep looping */
if ((nTmp = ((rec_hdr_ptr_t)pRec)->cmpc) > nMatchCnt)
continue;
if (nTmp < nMatchCnt)
/* cc_term: */ { /* Terminated on compression count < previous match,
this key is after the target */
if (nRecLen == BSTAR_REC_SIZE && ((blk_hdr_ptr_t)pBlkBase)->levl != 0)
/* Star key has size of sizeof(rec_hdr) + sizeof(block_id), make match = 0 */
nTargLen = 0;
else
/* Data block, make match = current compression count */
nTargLen = nTmp;
break;
}
alt_loop_entry: /* Compression count == match count; Compare current target with current record */
pRec += sizeof(rec_hdr);
do
{
if ((nFlg = *pCurrTarg - *pRec++) != 0)
break;
pCurrTarg++;
} while (--nTargLen);
if (nFlg > 0)
nMatchCnt = pCurrTarg - pTargKeyBase;
else
match_term: { /* Key is after target*/
if (nRecLen == BSTAR_REC_SIZE && (((blk_hdr_ptr_t)pBlkBase)->levl != 0))
/* Star key has size of sizeof(rec_hdr) + sizeof(block_id), make match = 0 */
nTargLen = 0;
else
nTargLen = pCurrTarg - pTargKeyBase;
break;
}
}
}
/* clean_up: */
pStat->prev_rec.offset = (short)(pPrevRec - pBlkBase);
pStat->prev_rec.match = (short)nMatchCnt;
pStat->curr_rec.offset = (short)(pRecBase - pBlkBase);
pStat->curr_rec.match = (short)nTargLen;
return cdb_sc_normal;
}
boolean_t gvcst_queryget2(mval *val, unsigned char *sn_ptr)
{
blk_hdr_ptr_t bp;
boolean_t found, two_histories;
enum cdb_sc status;
int rsiz, key_size, data_len;
rec_hdr_ptr_t rp;
srch_blk_status *bh;
srch_hist *rt_history;
unsigned short temp_ushort;
int tmp_cmpc;
DEBUG_ONLY(unsigned char *save_strp = NULL);
T_BEGIN_READ_NONTP_OR_TP(ERR_GVQUERYGETFAIL);
assert((CDB_STAGNATE > t_tries) || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
for (;;)
{
two_histories = FALSE;
#if defined(DEBUG) && defined(UNIX)
if (gtm_white_box_test_case_enabled && (WBTEST_ANTIFREEZE_GVQUERYGETFAIL == gtm_white_box_test_case_number))
{
status = cdb_sc_blknumerr;
t_retry(status);
continue;
}
#endif
if (cdb_sc_normal == (status = gvcst_search(gv_currkey, 0)))
{
found = TRUE;
bh = &gv_target->hist.h[0];
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
if (rp >= (rec_hdr_ptr_t)CST_TOB(bp))
{
two_histories = TRUE;
rt_history = gv_target->alt_hist;
status = gvcst_rtsib(rt_history, 0);
if (cdb_sc_endtree == status) /* end of tree */
{
found = FALSE;
two_histories = FALSE; /* second history not valid */
} else if (cdb_sc_normal != status)
{
t_retry(status);
continue;
} else
{
bh = &rt_history->h[0];
if (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, bh)))
{
t_retry(status);
continue;
}
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->curr_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
}
}
/* !found indicates that the end of tree has been reached (see call to
* gvcst_rtsib). If there is no more tree, don't bother doing expansion.
*/
if (found)
{
status = gvcst_expand_key((blk_hdr_ptr_t)bh->buffaddr, (int4)((sm_uc_ptr_t)rp - bh->buffaddr),
gv_altkey);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
key_size = gv_altkey->end + 1;
GET_RSIZ(rsiz, rp);
data_len = rsiz + EVAL_CMPC(rp) - SIZEOF(rec_hdr) - key_size;
if (data_len < 0 || (sm_uc_ptr_t)rp + rsiz > (sm_uc_ptr_t)bp + ((blk_hdr_ptr_t)bp)->bsiz)
{
assert(CDB_STAGNATE > t_tries);
t_retry(cdb_sc_rmisalign1);
continue;
}
ENSURE_STP_FREE_SPACE(data_len);
DEBUG_ONLY (
if (!save_strp)
save_strp = stringpool.free);
assert(stringpool.top - stringpool.free >= data_len);
memcpy(stringpool.free, (sm_uc_ptr_t)rp + rsiz - data_len, data_len);
/* Assumption: t_end/tp_hist will never cause stp_gcol() call BYPASSOK */
}
if (!dollar_tlevel)
{
if ((trans_num)0 == t_end(&gv_target->hist, !two_histories ? NULL : rt_history, TN_NOT_SPECIFIED))
continue;
} else
{
status = tp_hist(!two_histories ? NULL : rt_history);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
if (found)
{
DEBUG_ONLY(assert(save_strp == stringpool.free));
/* Process val first. Already copied to string pool. */
val->mvtype = MV_STR;
val->str.addr = (char *)stringpool.free;
val->str.len = data_len;
stringpool.free += data_len;
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_get, 1);
}
return found;
}
t_retry(status);
}
bool gvcst_zprevious(void)
{
static gv_key *zprev_temp_key;
static int4 zprev_temp_keysize = 0;
blk_hdr_ptr_t bp;
bool found, two_histories;
enum cdb_sc status;
rec_hdr_ptr_t rp;
unsigned char *c1, *c2, *ctop;
srch_blk_status *bh;
srch_hist *lft_history;
T_BEGIN_READ_NONTP_OR_TP(ERR_GVORDERFAIL);
for (;;)
{
assert(t_tries < CDB_STAGNATE || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
two_histories = FALSE;
if (cdb_sc_normal == (status = gvcst_search(gv_currkey, NULL)))
{
found = TRUE;
bh = gv_target->hist.h;
if (0 == bh->prev_rec.offset)
{
two_histories = TRUE;
lft_history = gv_target->alt_hist;
status = gvcst_lftsib(lft_history);
if (cdb_sc_normal == status)
{
bh = lft_history->h;
if (cdb_sc_normal != (status = gvcst_search_blk(gv_currkey, bh)))
{
t_retry(status);
continue;
}
} else if (cdb_sc_endtree == status)
{
found = FALSE;
two_histories = FALSE; /* second history not valid */
} else
{
t_retry(status);
continue;
}
}
if (found)
{ /* store new subscipt */
assert(gv_altkey->top == gv_currkey->top);
assert(gv_altkey->top == gv_keysize);
assert(gv_currkey->end < gv_currkey->top);
rp = (rec_hdr_ptr_t)(bh->buffaddr + bh->prev_rec.offset);
bp = (blk_hdr_ptr_t)bh->buffaddr;
c1 = gv_altkey->base;
memcpy(c1, gv_currkey->base, bh->prev_rec.match);
c1 += bh->prev_rec.match;
assert(zprev_temp_keysize <= gv_keysize);
if (zprev_temp_keysize < gv_keysize)
{
zprev_temp_keysize = gv_keysize;
GVKEY_INIT(zprev_temp_key, zprev_temp_keysize);
}
assert(zprev_temp_key->top >= gv_currkey->top);
if (cdb_sc_normal != (status = gvcst_expand_key((blk_hdr_ptr_t)bh->buffaddr, bh->prev_rec.offset,
zprev_temp_key)))
{
t_retry(status);
continue;
}
if ((zprev_temp_key->end < gv_currkey->end) && (zprev_temp_key->end <= gv_currkey->prev))
found = FALSE;
else
{
c2 = zprev_temp_key->base + bh->prev_rec.match;
ctop = zprev_temp_key->base + zprev_temp_key->end;
for (;;)
{
if (c2 >= ctop)
{
assert(CDB_STAGNATE > t_tries);
status = cdb_sc_rmisalign;
goto restart; /* goto needed because of nested FOR loop */
}
if (0 == (*c1++ = *c2++))
{
*c1 = 0;
break;
}
}
}
gv_altkey->end = c1 - gv_altkey->base;
assert(gv_altkey->end < gv_altkey->top);
}
if (!dollar_tlevel)
{
if ((trans_num)0 == t_end(&gv_target->hist, two_histories ? lft_history : NULL, TN_NOT_SPECIFIED))
continue;
} else
{
status = tp_hist(two_histories ? lft_history : NULL);
if (cdb_sc_normal != status)
{
t_retry(status);
continue;
}
}
assert(cs_data == cs_addrs->hdr);
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_zprev, 1);
return (found && (bh->prev_rec.match >= gv_currkey->prev));
}
restart: t_retry(status);
}
}
