boolean_t gvcst_query(void)
{ /* Similar to gvcst_order and gvcst_zprevious. In each case we skip over hidden subscripts as needed.
*
* 1 2 3 NULL <--- order/zprev...
* 1 2 3 NULL NULL
* 1 2 3 NULL NULL NULL <--- query from here...
* 1 2 3 NULL NULL NULL hidden
* 1 2 3 NULL NULL hidden
* 1 2 3 NULL hidden
* 1 2 3 hidden <--- ... skip this guy and go to bottom/top, respectively
* 1 2 3 7 <--- ... needs to end up here
*/
boolean_t found, is_hidden, sn_tpwrapped;
boolean_t est_first_pass;
gv_key save_currkey[DBKEYALLOC(MAX_KEY_SZ)];
int i;
int save_dollar_tlevel;
DEBUG_ONLY(save_dollar_tlevel = dollar_tlevel);
found = gvcst_query2();
# ifdef UNIX
assert(save_dollar_tlevel == dollar_tlevel);
CHECK_HIDDEN_SUBSCRIPT_AND_RETURN(found, gv_altkey, is_hidden);
IF_SN_DISALLOWED_AND_NO_SPAN_IN_DB(return found);
assert(found && is_hidden);
SAVE_GV_CURRKEY(save_currkey);
if (!dollar_tlevel)
{
sn_tpwrapped = TRUE;
op_tstart((IMPLICIT_TSTART), TRUE, &literal_batch, 0);
ESTABLISH_NORET(gvcst_query_ch, est_first_pass);
GVCST_ROOT_SEARCH_AND_PREP(est_first_pass);
} else
sn_tpwrapped = FALSE;
for (i = 0; i <= MAX_GVSUBSCRIPTS; i++)
{
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_query, (gtm_uint64_t) -1);
found = gvcst_query2();
CHECK_HIDDEN_SUBSCRIPT_AND_BREAK(found, gv_altkey, is_hidden);
assert(found && is_hidden);
/* Replace last subscript to be the highest possible hidden subscript so another
* gvcst_query2 will give us the next non-hidden subscript.
*/
REPLACE_HIDDEN_SUB_TO_HIGHEST(gv_altkey, gv_currkey); /* uses gv_altkey to modify gv_currkey */
}
if (sn_tpwrapped)
{
op_tcommit();
REVERT; /* remove our condition handler */
}
RESTORE_GV_CURRKEY(save_currkey);
assert(save_dollar_tlevel == dollar_tlevel);
# endif
return found;
}
boolean_t gvcst_order(void)
{ /* See gvcst_query.c */
boolean_t found, is_hidden, sn_tpwrapped;
boolean_t est_first_pass;
gv_key save_currkey[DBKEYALLOC(MAX_KEY_SZ)];
int end, prev, oldend;
int save_dollar_tlevel;
DEBUG_ONLY(save_dollar_tlevel = dollar_tlevel);
found = gvcst_order2();
# ifdef UNIX
assert(save_dollar_tlevel == dollar_tlevel);
CHECK_HIDDEN_SUBSCRIPT_AND_RETURN(found, gv_altkey, is_hidden);
assert(found && is_hidden);
IF_SN_DISALLOWED_AND_NO_SPAN_IN_DB(return found);
SAVE_GV_CURRKEY_LAST_SUBSCRIPT(save_currkey, prev, oldend);
if (!dollar_tlevel)
{
sn_tpwrapped = TRUE;
op_tstart((IMPLICIT_TSTART), TRUE, &literal_batch, 0);
ESTABLISH_NORET(gvcst_order_ch, est_first_pass);
GVCST_ROOT_SEARCH_AND_PREP(est_first_pass);
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_order, (gtm_uint64_t) -1);
found = gvcst_order2();
} else
sn_tpwrapped = FALSE;
if (found)
{
CHECK_HIDDEN_SUBSCRIPT(gv_altkey, is_hidden);
if (is_hidden)
{ /* Replace last subscript to be the highest possible hidden subscript so another
* gvcst_order2 will give us the next non-hidden subscript.
*/
REPLACE_HIDDEN_SUB_TO_HIGHEST(gv_altkey, gv_currkey); /* uses gv_altkey to modify gv_currkey */
/* fix up since it should only be externally counted as one $order */
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_order, (gtm_uint64_t) -1);
found = gvcst_order2();
}
}
if (sn_tpwrapped)
{
op_tcommit();
REVERT; /* remove our condition handler */
}
RESTORE_GV_CURRKEY_LAST_SUBSCRIPT(save_currkey, prev, oldend);
assert(save_dollar_tlevel == dollar_tlevel);
# endif
return found;
}
boolean_t gvcst_queryget(mval *val)
{
bool found, is_hidden, is_dummy = FALSE, sn_tpwrapped;
boolean_t est_first_pass;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
int save_dollar_tlevel;
DEBUG_ONLY(save_dollar_tlevel = dollar_tlevel);
found = gvcst_queryget2(val, NULL);
# ifdef UNIX
assert(save_dollar_tlevel == dollar_tlevel);
CHECK_HIDDEN_SUBSCRIPT(gv_altkey, is_hidden);
if (found && IS_SN_DUMMY(val->str.len, val->str.addr))
is_dummy = TRUE;
if (!found || (!is_dummy && !is_hidden))
return found;
IF_SN_DISALLOWED_AND_NO_SPAN_IN_DB(return found);
SAVE_GV_CURRKEY;
if (!dollar_tlevel)
{
sn_tpwrapped = TRUE;
op_tstart((IMPLICIT_TSTART), TRUE, &literal_batch, 0);
ESTABLISH_NORET(gvcst_queryget_ch, est_first_pass);
GVCST_ROOT_SEARCH_AND_PREP(est_first_pass);
} else
sn_tpwrapped = FALSE;
found = gvcst_query();
COPY_KEY(gv_currkey, gv_altkey); /* set gv_currkey to gv_altkey */
found = gvcst_get(val);
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_get, (gtm_uint64_t) -1); /* only counted externally as one get */
INCR_GVSTATS_COUNTER(cs_addrs, cs_addrs->nl, n_query, (gtm_uint64_t) -1);
if (sn_tpwrapped)
{
op_tcommit();
REVERT; /* remove our condition handler */
}
RESTORE_GV_CURRKEY;
assert(save_dollar_tlevel == dollar_tlevel);
# endif
return found;
}
void gvcst_spr_kill(void)
{
boolean_t spr_tpwrapped;
boolean_t est_first_pass;
int reg_index;
gd_binding *start_map, *end_map, *map;
gd_region *reg, *gd_reg_start;
gd_addr *addr;
gv_namehead *start_map_gvt;
gvnh_reg_t *gvnh_reg;
trans_num gd_targ_tn, *tn_array;
# ifdef DEBUG
int save_dollar_tlevel;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
start_map = TREF(gd_targ_map); /* set up by op_gvname/op_gvnaked/op_gvextnam done just before invoking op_gvkill */
start_map_gvt = gv_target; /* save gv_target corresponding to start_map so we can restore at end */
/* Find out if the next (in terms of $order) key maps to same map as currkey. If so, no spanning activity needed */
GVKEY_INCREMENT_ORDER(gv_currkey);
end_map = gv_srch_map_linear(start_map, (char *)&gv_currkey->base[0], gv_currkey->end - 1);
BACK_OFF_ONE_MAP_ENTRY_IF_EDGECASE(gv_currkey->base, gv_currkey->end - 1, end_map);
GVKEY_UNDO_INCREMENT_ORDER(gv_currkey);
if (start_map == end_map)
{
assert(gv_target == start_map_gvt);
if (IS_OK_TO_INVOKE_GVCST_KILL(start_map_gvt))
gvcst_kill(TRUE);
return;
}
/* Do any initialization that is independent of retries BEFORE the op_tstart */
addr = TREF(gd_targ_addr);
assert(NULL != addr);
gd_reg_start = &addr->regions[0];
tn_array = TREF(gd_targ_reg_array);
gvnh_reg = TREF(gd_targ_gvnh_reg);
assert(NULL != gvnh_reg);
assert(NULL != gvnh_reg->gvspan);
/* Now that we know the keyrange maps to more than one region, go through each of them and do the kill.
* Since multiple regions are potentially involved, need a TP fence.
*/
DEBUG_ONLY(save_dollar_tlevel = dollar_tlevel);
if (!dollar_tlevel)
{
spr_tpwrapped = TRUE;
op_tstart((IMPLICIT_TSTART), TRUE, &literal_batch, 0);
ESTABLISH_NORET(gvcst_spr_kill_ch, est_first_pass);
GVCST_ROOT_SEARCH_AND_PREP(est_first_pass);
} else
spr_tpwrapped = FALSE;
assert(gv_cur_region == start_map->reg.addr);
DBG_CHECK_GVTARGET_GVCURRKEY_IN_SYNC(CHECK_CSA_TRUE);
/* Do any initialization that is dependent on retries AFTER the op_tstart */
map = start_map;
INCREMENT_GD_TARG_TN(gd_targ_tn); /* takes a copy of incremented "TREF(gd_targ_tn)" into local variable "gd_targ_tn" */
/* Verify that initializations that happened before op_tstart are still unchanged */
assert(addr == TREF(gd_targ_addr));
assert(tn_array == TREF(gd_targ_reg_array));
assert(gvnh_reg == TREF(gd_targ_gvnh_reg));
for ( ; map <= end_map; map++)
{
reg = map->reg.addr;
GET_REG_INDEX(addr, gd_reg_start, reg, reg_index); /* sets "reg_index" */
assert((map != start_map) || (tn_array[reg_index] != gd_targ_tn));
assert(TREF(gd_targ_reg_array_size) > reg_index);
if (tn_array[reg_index] == gd_targ_tn)
continue;
if (map != start_map)
GV_BIND_SUBSREG(addr, reg, gvnh_reg); /* sets gv_target/gv_cur_region/cs_addrs */
assert(reg->open);
if (IS_OK_TO_INVOKE_GVCST_KILL(gv_target))
gvcst_kill(TRUE);
tn_array[reg_index] = gd_targ_tn;
}
if (gv_target != start_map_gvt)
{ /* Restore gv_cur_region/gv_target etc. */
gv_target = start_map_gvt;
gv_cur_region = start_map->reg.addr;
change_reg();
}
DBG_CHECK_GVTARGET_GVCURRKEY_IN_SYNC(CHECK_CSA_TRUE);
if (spr_tpwrapped)
{
op_tcommit();
REVERT; /* remove our condition handler */
}
assert(save_dollar_tlevel == dollar_tlevel);
return;
}
