void op_indo2(mval *dst, uint4 indx, mval *direct)
{
glvn_pool_entry *slot;
int4 dummy_intval;
intszofptr_t n;
lv_val *lv;
mval *key;
opctype oc;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
MV_FORCE_NUM(direct);
if (!MV_IS_TRUEINT(direct, &dummy_intval) || (direct->m[1] != (1 * MV_BIAS) && direct->m[1] != (-1 * MV_BIAS)))
rts_error(VARLSTCNT(1) ERR_ORDER2);
slot = &((TREF(glvn_pool_ptr))->slot[indx]);
oc = slot->sav_opcode;
if (OC_SAVLVN == oc)
{ /* lvn */
n = --slot->glvn_info.n;
if (0 == n)
{ /* lvn name */
slot->glvn_info.n++; /* quick restore count so glvnpop works correctly */
/* like op_fnlvnameo2 */
if ((1 * MV_BIAS) == direct->m[1])
op_fnlvname(slot->lvname, FALSE, dst);
else
op_fnlvprvname(slot->lvname, dst);
} else
{ /* subscripted lv */
key = (mval *)slot->glvn_info.arg[n];
lv = op_rfrshlvn(indx, OC_RFRSHLVN); /* funky opcode prevents UNDEF in rfrlvn */
slot->glvn_info.n++; /* quick restore count so glvnpop works correctly */
/* like op_fnno2 */
if ((1 * MV_BIAS) == direct->m[1])
op_fnorder(lv, key, dst);
else
op_fnzprevious(lv, key, dst);
}
} else if (OC_NOOP != oc) /* if indirect error blew set up, skip this */
{ /* gvn */
op_rfrshgvn(indx, oc);
/* like op_gvno2 */
if ((1 * MV_BIAS) == direct->m[1])
op_gvorder(dst);
else
op_zprevious(dst);
}
return;
}
/* Upgrade ^#t global in "reg" region */
void trigger_upgrade(gd_region *reg)
{
boolean_t est_first_pass, do_upgrade, is_defined;
boolean_t was_null = FALSE, is_null = FALSE;
int seq_num, trig_seq_num;
int currlabel;
mval tmpmval, xecuteimval, *gvname, *tmpmv, *tmpmv2;
int4 result, tmpint4;
uint4 curend, gvname_prev, xecute_curend;
uint4 hash_code, kill_hash_code;
int count, i, xecutei, tncount;
char *trigname, *trigindex, *ptr;
char name_and_index[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
char trigvn[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT], nullbyte[1];
uint4 trigname_len, name_index_len;
int ilen;
sgmnt_addrs *csa;
jnl_private_control *jpc;
uint4 sts;
int close_res;
hash128_state_t hash_state, kill_hash_state;
uint4 hash_totlen, kill_hash_totlen;
int trig_protected_mval_push_count;
# ifdef DEBUG
int save_dollar_tlevel;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(gv_cur_region == reg);
assert(!dollar_tlevel); /* caller should have ensured this. this is needed as otherwise things get complicated. */
assert(!is_replicator); /* caller should have ensured this. this is needed so we dont bump jnl_seqno (if replicating) */
csa = &FILE_INFO(reg)->s_addrs;
assert(csa->hdr->hasht_upgrade_needed);
/* If before-image journaling is turned on in this region (does not matter if replication is turned on or not),
* once this transaction is done, we need to switch to new journal file and cut the back link because
* otherwise it is possible for backward journal recovery (or rollback) or source server to encounter
* the journal records generated in this ^#t-upgrade-transaction in which case they dont know to handle
* it properly (e.g. rollback or backward recovery does not know to restore csa->hdr->hasht_upgrade_needed
* if it rolls back this transaction). To achieve this, we set hold_onto_crit to TRUE and do the jnl link
* cut AFTER the transaction commits but before anyone else can sneak in to do any more updates.
* Since most often we expect databases to be journaled, we do this hold_onto_crit even for the non-journaled case.
*/
grab_crit(reg);
csa->hold_onto_crit = TRUE;
DEBUG_ONLY(save_dollar_tlevel = dollar_tlevel);
assert(!donot_INVOKE_MUMTSTART);
DEBUG_ONLY(donot_INVOKE_MUMTSTART = TRUE);
op_tstart(IMPLICIT_TSTART, TRUE, &literal_batch, 0); /* 0 ==> save no locals but RESTART OK */
ESTABLISH_NORET(trigger_upgrade_ch, est_first_pass);
/* On a TP restart anywhere down below, this line is where the restart resumes execution from */
assert(donot_INVOKE_MUMTSTART); /* Make sure still set for every try/retry of TP transaction */
change_reg(); /* TP_CHANGE_REG wont work as we need to set sgm_info_ptr */
assert(NULL != cs_addrs);
assert(csa == cs_addrs);
SET_GVTARGET_TO_HASHT_GBL(csa); /* sets up gv_target */
assert(NULL != gv_target);
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED; /* Needed to do every retry in case restart was due to an online rollback.
* This also sets up gv_currkey */
/* Do actual upgrade of ^#t global.
*
* Below is a sample layout of the label 2 ^#t global
* -------------------------------------------------------
* ^#t("#TNAME","x")="a"_$C(0)_"1" (present in DEFAULT only)
* ^#t("#TRHASH",89771515,1)="a"_$C(0)_"1" (present in DEFAULT only)
* ^#t("#TRHASH",106937755,1)="a"_$C(0)_"1" (present in DEFAULT only)
* ^#t("a",1,"BHASH")="106937755"
* ^#t("a",1,"CHSET")="M"
* ^#t("a",1,"CMD")="S"
* ^#t("a",1,"LHASH")="89771515"
* ^#t("a",1,"TRIGNAME")="x#"
* ^#t("a",1,"XECUTE")=" do ^twork"
* ^#t("a","#COUNT")="1"
* ^#t("a","#CYCLE")="1"
* ^#t("a","#LABEL")="2"
*
* Below is a sample layout of the label 3 ^#t global
* -------------------------------------------------------
* ^#t("#LABEL")="3" (present only after upgrade, not regular trigger load)
* ^#t("#TNAME","x")="a"_$C(0)_"1" (present in CURRENT region)
* ^#t("a",1,"BHASH")="71945627"
* ^#t("a",1,"CHSET")="M"
* ^#t("a",1,"CMD")="S"
* ^#t("a",1,"LHASH")="71945627"
* ^#t("a",1,"TRIGNAME")="x#"
* ^#t("a",1,"XECUTE")=" do ^twork"
* ^#t("a","#COUNT")="1"
* ^#t("a","#CYCLE")="2"
* ^#t("a","#LABEL")="3"
* ^#t("a","#TRHASH",71945627,1)="a"_$C(0)_"1"
*
* Key aspects of the format change
* ----------------------------------
* 1) New ^#t("#LABEL")="3" to indicate the format of the ^#t global. This is in addition to
* ^#t("a","#LABEL") etc. which is already there. This way we have a #LABEL for not just the installed
* triggers but also for the name information stored in the #TNAME nodes.
* 2) In the BHASH and LHASH fields. The hash computation is different so there are more chances of BHASH and LHASH
* matching in which case we store only one #TRHASH entry (instead of two). So thre is fewer ^#t records in the new
* format in most cases.
* 3) ^#t("a","#LABEL") bumps from 2 to 3. Similarly ^#t("a","#CYCLE") bumps by one (to make sure triggers for this
* global get re-read if and when we implement an -ONLINE upgrade).
* 4) DEFAULT used to have ^#t("#TNAME",...) nodes corresponding to triggers across ALL regions in the gbldir and
* other regions used to have NO ^#t("#TNAME",...) nodes whereas after the upgrade every region have
* ^#t("#TNAME",...) nodes corresponding to triggers installed in that region. So it is safer to kill ^#t("#TNAME")
* nodes and add them as needed.
* 5) #TRHASH has moved from ^#t() to ^#t(<gbl>). So it is safer to kill ^#t("#TRHASH") nodes and add them as needed.
*
* Below is a sample layout of the label 4 ^#t global
* -------------------------------------------------------
* ^#t("#TNAME","x")="a"_$C(0)_"1" (present in CURRENT region)
* ^#t("a",1,"BHASH")="71945627"
* ^#t("a",1,"CHSET")="M"
* ^#t("a",1,"CMD")="S"
* ^#t("a",1,"LHASH")="71945627"
* ^#t("a",1,"TRIGNAME")="x#"
* ^#t("a",1,"XECUTE")=" do ^twork"
* ^#t("a","#COUNT")="1"
* ^#t("a","#CYCLE")="2"
* ^#t("a","#LABEL")="4"
* ^#t("a","#TRHASH",71945627,1)="a"_$C(0)_"1"
*
* Key aspects of the format change
* ----------------------------------
* 1) Removed ^#t("#LABEL") as it is redundant information and trigger load does not include it
* 2) Multiline triggers were incorrectly processed resulting in incorrect BHASH and LHASH values. Upgrade fixes this
* 3) ^#t("a","#LABEL") bumps from 3 to 4. Similarly ^#t("a","#CYCLE") bumps by one (to make sure
* triggers for this global get re-read if and when we implement an -ONLINE upgrade).
*/
tmpmv = &tmpmval; /* At all points maintain this relationship. The two are used interchangeably below */
if (gv_target->root)
do_upgrade = TRUE;
/* The below logic assumes ^#t global does not have any integrity errors */
assert(do_upgrade); /* caller should have not invoked us otherwise */
if (do_upgrade)
{ /* kill ^#t("#TRHASH"), ^#t("#TNAME") and ^#t("#LABEL") first. Regenerate each again as we process ^#t(<gbl>,...) */
csa->incr_db_trigger_cycle = TRUE; /* so that we increment csd->db_trigger_cycle at commit time.
* this forces concurrent processes to read upgraded triggers.
*/
if (JNL_WRITE_LOGICAL_RECS(csa))
{ /* Note that the ^#t upgrade is a physical layout change. But it has no logical change (i.e. users
* see the same MUPIP TRIGGER -SELECT output as before). So write only a dummy LGTRIG journal
* record for this operation. Hence write a string that starts with a trigger comment character ";".
*/
assert(!gv_cur_region->read_only);
jnl_format(JNL_LGTRIG, NULL, (mval *)&literal_trigjnlrec, 0);
}
/* KILL ^#t("#LABEL") unconditionally */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHLABEL, STRLEN(LITERAL_HASHLABEL));
if (0 != gvcst_data())
gvcst_kill(TRUE);
/* KILL ^#t("#TNAME") unconditionally and regenerate */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME));
if (0 != gvcst_data())
gvcst_kill(TRUE);
/* KILL ^#t("#TRHASH") unconditionally and regenerate */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH));
if (0 != gvcst_data())
gvcst_kill(TRUE);
/* Loop through all global names for which ^#t(<gvn>) exists. The only first-level subscripts of ^#t starting
* with # are #TNAME and #TRHASH in collation order. So after #TRHASH we expect to find subscripts that are
* global names. Hence the HASHTRHASH code is placed AFTER the HASHTNAME code above.
*/
TREF(gd_targ_gvnh_reg) = NULL; /* needed so op_gvorder below goes through gvcst_order (i.e. focuses only
* on the current region) and NOT through gvcst_spr_order (which does not
* apply anyways in the case of ^#t).
*/
nullbyte[0] = '\0';
trig_protected_mval_push_count = 0;
INCR_AND_PUSH_MV_STENT(gvname); /* Protect gvname from garbage collection */
do
{
op_gvorder(gvname);
if (0 == gvname->str.len)
break;
assert(ARRAYSIZE(trigvn) > gvname->str.len);
memcpy(&trigvn[0], gvname->str.addr, gvname->str.len);
gvname->str.addr = &trigvn[0]; /* point away from stringpool to avoid stp_gcol issues */
/* Save gv_currkey->prev so it is restored before next call to op_gvorder (which cares about this field).
* gv_currkey->prev gets tampered with in the for loop below (e.g. BUILD_HASHT_SUB_CURRKEY macro).
* No need to do this for gv_currkey->end since the body of the for loop takes care of restoring it.
*/
gvname_prev = gv_currkey->prev;
BUILD_HASHT_SUB_CURRKEY(gvname->str.addr, gvname->str.len);
/* At this point, gv_currkey is ^#t(<gvn>) */
/* Increment ^#t(<gvn>,"#CYCLE") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_hashcycle, tmpmv);
assert(is_defined);
tmpint4 = mval2i(tmpmv);
tmpint4++;
i2mval(tmpmv, tmpint4);
gvtr_set_hasht_gblsubs((mval *)&literal_hashcycle, tmpmv);
/* Read ^#t(<gvn>,"#COUNT") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_hashcount, tmpmv);
if (is_defined)
{
tmpint4 = mval2i(tmpmv);
count = tmpint4;
/* Get ^#t(<gvn>,"#LABEL"), error out for invalid values. Upgrade disallowed for label 1 triggers */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_hashlabel, tmpmv);
assert(is_defined);
currlabel = mval2i(tmpmv);
if ((V19_HASHT_GBL_LABEL_INT >= currlabel) || (HASHT_GBL_CURLABEL_INT <= currlabel))
rts_error_csa(CSA_ARG(csa) VARLSTCNT(8) ERR_TRIGUPBADLABEL, 6, currlabel,
HASHT_GBL_CURLABEL_INT, gvname->str.len, gvname->str.addr,
REG_LEN_STR(reg));
/* Set ^#t(<gvn>,"#LABEL")=HASHT_GBL_CURLABEL */
gvtr_set_hasht_gblsubs((mval *)&literal_hashlabel, (mval *)&literal_curlabel);
} else
count = 0;
/* Kill ^#t(<gvn>,"#TRHASH") unconditionally and regenerate */
gvtr_kill_hasht_gblsubs((mval *)&literal_hashtrhash, TRUE);
/* At this point, gv_currkey is ^#t(<gvn>) */
for (i = 1; i <= count; i++)
{
/* At this point, gv_currkey is ^#t(<gvn>) */
curend = gv_currkey->end; /* note gv_currkey->end before changing it so we can restore it later */
assert(KEY_DELIMITER == gv_currkey->base[curend]);
assert(gv_target->gd_csa == cs_addrs);
i2mval(tmpmv, i);
COPY_SUBS_TO_GVCURRKEY(tmpmv, gv_cur_region, gv_currkey, was_null, is_null);
/* At this point, gv_currkey is ^#t(<gvn>,i) */
/* Compute new LHASH and BHASH hash values.
* LHASH uses : GVSUBS, XECUTE
* BHASH uses : GVSUBS, DELIM, ZDELIM, PIECES, XECUTE
* So reach each of these pieces and compute hash along the way.
*/
STR_PHASH_INIT(hash_state, hash_totlen);
STR_PHASH_PROCESS(hash_state, hash_totlen, gvname->str.addr, gvname->str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
/* Read in ^#t(<gvn>,i,"GVSUBS") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_gvsubs, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Copy over SET hash state (2-tuple <state,totlen>) to KILL hash state before adding
* the PIECES, DELIM, ZDELIM portions (those are only part of the SET hash).
*/
kill_hash_state = hash_state;
kill_hash_totlen = hash_totlen;
/* Read in ^#t(<gvn>,i,"PIECES") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_pieces, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Read in ^#t(<gvn>,i,"DELIM") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_delim, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Read in ^#t(<gvn>,i,"ZDELIM") */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_zdelim, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(hash_state, hash_totlen, nullbyte, 1);
}
/* Read in ^#t(<gvn>,i,"XECUTE").
* Note: The XECUTE portion of the trigger definition is used in SET and KILL hash.
* But since we have started maintaining "hash_state" and "kill_hash_state" separately
* (due to PIECES, DELIM, ZDELIM) we need to update the hash for both using same input string.
*/
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_xecute, tmpmv);
if (is_defined)
{
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(kill_hash_state, kill_hash_totlen, tmpmval.str.addr, tmpmval.str.len);
} else
{ /* Multi-record XECUTE string */
/* At this point, gv_currkey is ^#t(<gvn>,i) */
xecute_curend = gv_currkey->end; /* note gv_currkey->end so we can restore it later */
assert(KEY_DELIMITER == gv_currkey->base[xecute_curend]);
tmpmv2 = (mval *)&literal_xecute;
COPY_SUBS_TO_GVCURRKEY(tmpmv2, gv_cur_region, gv_currkey, was_null, is_null);
xecutei = 1;
do
{
i2mval(&xecuteimval, xecutei);
is_defined = gvtr_get_hasht_gblsubs(&xecuteimval, tmpmv);
if (!is_defined)
break;
STR_PHASH_PROCESS(hash_state, hash_totlen, tmpmval.str.addr, tmpmval.str.len);
STR_PHASH_PROCESS(kill_hash_state, kill_hash_totlen,
tmpmval.str.addr, tmpmval.str.len);
xecutei++;
} while (TRUE);
/* Restore gv_currkey to ^#t(<gvn>,i) */
gv_currkey->end = xecute_curend;
gv_currkey->base[xecute_curend] = KEY_DELIMITER;
}
STR_PHASH_RESULT(hash_state, hash_totlen, hash_code);
STR_PHASH_RESULT(kill_hash_state, kill_hash_totlen, kill_hash_code);
/* Set ^#t(<gvn>,i,"LHASH") */
MV_FORCE_UMVAL(tmpmv, kill_hash_code);
gvtr_set_hasht_gblsubs((mval *)&literal_lhash, tmpmv);
/* Set ^#t(<gvn>,i,"BHASH") */
MV_FORCE_UMVAL(tmpmv, hash_code);
gvtr_set_hasht_gblsubs((mval *)&literal_bhash, tmpmv);
/* Read in ^#t(<gvn>,i,"TRIGNAME") to determine if #SEQNUM/#TNCOUNT needs to be maintained */
is_defined = gvtr_get_hasht_gblsubs((mval *)&literal_trigname, tmpmv);
assert(is_defined);
assert('#' == tmpmval.str.addr[tmpmval.str.len - 1]);
tmpmval.str.len--;
if ((tmpmval.str.len <= ARRAYSIZE(name_and_index)) &&
(NULL != (ptr = memchr(tmpmval.str.addr, '#', tmpmval.str.len))))
{ /* Auto-generated name. Need to maintain #SEQNUM/#TNCOUNT */
/* Take copy of trigger name into non-stringpool location to avoid stp_gcol issues */
trigname_len = ptr - tmpmval.str.addr;
ptr++;
name_index_len = (tmpmval.str.addr + tmpmval.str.len) - ptr;
assert(ARRAYSIZE(name_and_index) >= (trigname_len + 1 + name_index_len));
trigname = &name_and_index[0];
trigindex = ptr;
memcpy(trigname, tmpmval.str.addr, tmpmval.str.len);
A2I(ptr, ptr + name_index_len, trig_seq_num);
/* At this point, gv_currkey is ^#t(<gvn>,i) */
/* $get(^#t("#TNAME",<trigger name>,"#SEQNUM")) */
BUILD_HASHT_SUB_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, LITERAL_HASHSEQNUM, STR_LIT_LEN(LITERAL_HASHSEQNUM));
seq_num = gvcst_get(tmpmv) ? mval2i(tmpmv) : 0;
if (trig_seq_num > seq_num)
{ /* Set ^#t("#TNAME",<trigger name>,"#SEQNUM") = trig_seq_num */
SET_TRIGGER_GLOBAL_SUB_SUB_SUB_STR(LITERAL_HASHTNAME,
STR_LIT_LEN(LITERAL_HASHTNAME), trigname, trigname_len,
LITERAL_HASHSEQNUM, STR_LIT_LEN(LITERAL_HASHSEQNUM),
trigindex, name_index_len, result);
assert(PUT_SUCCESS == result);
}
/* set ^#t("#TNAME",<trigger name>,"#TNCOUNT")++ */
BUILD_HASHT_SUB_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, LITERAL_HASHTNCOUNT, STR_LIT_LEN(LITERAL_HASHTNCOUNT));
tncount = gvcst_get(tmpmv) ? mval2i(tmpmv) + 1 : 1;
i2mval(tmpmv, tncount);
SET_TRIGGER_GLOBAL_SUB_SUB_SUB_MVAL(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, LITERAL_HASHTNCOUNT, STR_LIT_LEN(LITERAL_HASHTNCOUNT),
tmpmval, result);
trigname_len += 1 + name_index_len; /* in preparation for ^#t("#TNAME") set below */
assert(PUT_SUCCESS == result);
BUILD_HASHT_SUB_CURRKEY(gvname->str.addr, gvname->str.len);
/* At this point, gv_currkey is ^#t(<gvn>) */
} else
{
/* Take copy of trigger name into non-stringpool location to avoid stp_gcol issues */
trigname = &name_and_index[0]; /* in preparation for ^#t("#TNAME") set below */
trigname_len = MIN(tmpmval.str.len, ARRAYSIZE(name_and_index));
assert(ARRAYSIZE(name_and_index) >= trigname_len);
memcpy(trigname, tmpmval.str.addr, trigname_len);
/* Restore gv_currkey to what it was at beginning of for loop iteration */
gv_currkey->end = curend;
gv_currkey->base[curend] = KEY_DELIMITER;
}
/* At this point, gv_currkey is ^#t(<gvn>) */
if (kill_hash_code != hash_code)
gvtr_set_hashtrhash(gvname->str.addr, gvname->str.len, kill_hash_code, i);
/* Set ^#t(<gvn>,"#TRHASH",hash_code,i) */
gvtr_set_hashtrhash(gvname->str.addr, gvname->str.len, hash_code, i);
/* Set ^#t("#TNAME",<trigname>)=<gvn>_$c(0)_<trigindx> */
/* The upgrade assumes that the region does not contain two triggers with the same name.
* V62000 and before could potentially have this out of design case. Once implemented
* the trigger integrity check will warn users of this edge case */
ptr = &trigvn[gvname->str.len];
*ptr++ = '\0';
ilen = 0;
I2A(ptr, ilen, i);
ptr += ilen;
assert(ptr <= ARRAYTOP(trigvn));
SET_TRIGGER_GLOBAL_SUB_SUB_STR(LITERAL_HASHTNAME, STR_LIT_LEN(LITERAL_HASHTNAME),
trigname, trigname_len, trigvn, ptr - gvname->str.addr, result);
assert(PUT_SUCCESS == result);
BUILD_HASHT_SUB_CURRKEY(gvname->str.addr, gvname->str.len);
/* At this point, gv_currkey is ^#t(<gvn>) */
}
/* At this point, gv_currkey is ^#t(<gvn>) i.e. gv_currkey->end is correct but gv_currkey->prev
* might have been tampered with. Restore it to proper value first.
*/
gv_currkey->prev = gvname_prev;
gvname->mvtype = 0; /* can now be garbage collected in the next iteration */
} while (TRUE);
}
op_tcommit();
REVERT; /* remove our condition handler */
DEBUG_ONLY(donot_INVOKE_MUMTSTART = FALSE;)
if (csa->hold_onto_crit)
void trigger_delete_all(char *trigger_rec, uint4 len, uint4 *trig_stats)
{
int count;
sgmnt_addrs *csa;
mval curr_gbl_name;
int cycle;
mval *mv_count_ptr;
mval *mv_cycle_ptr;
gd_region *reg, *reg_top;
int4 result;
gd_region *lgtrig_reg;
mval trigger_cycle;
mval trigger_count;
boolean_t this_db_updated;
uint4 triggers_deleted;
mval trigjrec;
boolean_t jnl_format_done;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(0 < dollar_tlevel);
jnl_format_done = FALSE;
lgtrig_reg = NULL;
trigjrec.mvtype = MV_STR;
trigjrec.str.len = len;
trigjrec.str.addr = trigger_rec;
triggers_deleted = 0;
for (reg = gd_header->regions, reg_top = reg + gd_header->n_regions; reg < reg_top; reg++)
{
GVTR_SWITCH_REG_AND_HASHT_BIND_NAME(reg);
csa = cs_addrs;
if (NULL == csa) /* not BG or MM access method */
continue;
/* gv_target now points to ^#t in region "reg" */
/* To write the LGTRIG logical jnl record, choose some region that has journaling enabled */
if (!reg->read_only && !jnl_format_done && JNL_WRITE_LOGICAL_RECS(csa))
lgtrig_reg = reg;
if (!gv_target->root)
continue;
/* kill ^#t("#TNAME") */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME));
if (0 != gvcst_data())
{ /* Issue error if we dont have permissions to touch ^#t global */
if (reg->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_TRIGMODREGNOTRW, 2, REG_LEN_STR(reg));
gvcst_kill(TRUE);
}
/* Kill all descendents of ^#t(trigvn, ...) where trigvn is any global with a trigger,
* but skip the ^#t("#...",...) entries. Setup ^#t("$") as the key for op_gvorder
*/
BUILD_HASHT_SUB_CURRKEY(LITERAL_MAXHASHVAL, STRLEN(LITERAL_MAXHASHVAL));
TREF(gv_last_subsc_null) = FALSE; /* We know its not null, but prior state is unreliable */
this_db_updated = FALSE;
while (TRUE)
{
op_gvorder(&curr_gbl_name);
/* quit:$length(curr_gbl_name)=0 */
if (0 == curr_gbl_name.str.len)
break;
/* $get(^#t(curr_gbl_name,#COUNT)) */
BUILD_HASHT_SUB_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len,
LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
if (gvcst_get(&trigger_count))
{
/* Now that we know there is something to kill, check if we have permissions to touch ^#t global */
if (reg->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_TRIGMODREGNOTRW, 2, REG_LEN_STR(reg));
mv_count_ptr = &trigger_count;
count = MV_FORCE_UINT(mv_count_ptr);
/* $get(^#t(curr_gbl_name,#CYCLE)) */
BUILD_HASHT_SUB_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len,
LITERAL_HASHCYCLE, STRLEN(LITERAL_HASHCYCLE));
if (!gvcst_get(&trigger_cycle))
{ /* Found #COUNT, there must be #CYCLE */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(csa) VARLSTCNT(12) ERR_TRIGDEFBAD, 6,
curr_gbl_name.str.len, curr_gbl_name.str.addr,
curr_gbl_name.str.len, curr_gbl_name.str.addr, LEN_AND_LIT("\"#CYCLE\""),
ERR_TEXT, 2, RTS_ERROR_TEXT("#CYCLE field is missing"));
}
mv_cycle_ptr = &trigger_cycle;
cycle = MV_FORCE_UINT(mv_cycle_ptr);
if (!jnl_format_done && JNL_WRITE_LOGICAL_RECS(csa))
{
jnl_format(JNL_LGTRIG, NULL, &trigjrec, 0);
jnl_format_done = TRUE;
}
/* kill ^#t(curr_gbl_name) */
BUILD_HASHT_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len);
gvcst_kill(TRUE);
/* Note : ^#t(curr_gbl_name,"#TRHASH") is also killed as part of the above */
cycle++;
MV_FORCE_MVAL(&trigger_cycle, cycle);
/* set ^#t(curr_gbl_name,#CYCLE)=trigger_cycle */
SET_TRIGGER_GLOBAL_SUB_SUB_MVAL(curr_gbl_name.str.addr, curr_gbl_name.str.len,
LITERAL_HASHCYCLE, STRLEN(LITERAL_HASHCYCLE), trigger_cycle, result);
assert(PUT_SUCCESS == result);
this_db_updated = TRUE;
triggers_deleted += count;
} /* else there is no #COUNT, then no triggers, leave #CYCLE alone */
/* get ready for op_gvorder() call for next trigger under ^#t */
BUILD_HASHT_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len);
}
if (this_db_updated)
{
csa->incr_db_trigger_cycle = TRUE;
if (dollar_ztrigger_invoked)
{ /* increment db_dztrigger_cycle so that next gvcst_put/gvcst_kill in this transaction,
* on this region, will re-read. See trigger_update.c for a comment on why it is okay
* for db_dztrigger_cycle to be incremented more than once in the same transaction
*/
csa->db_dztrigger_cycle++;
}
}
}
if (!jnl_format_done && (NULL != lgtrig_reg))
{ /* There was no journaled region that had a ^#t update, but found at least one journaled region
* so write a LGTRIG logical jnl record there.
*/
GVTR_SWITCH_REG_AND_HASHT_BIND_NAME(lgtrig_reg);
csa = cs_addrs;
JNLPOOL_INIT_IF_NEEDED(csa, csa->hdr, csa->nl); /* see previous usage for comment on why it is needed */
assert(dollar_tlevel);
T_BEGIN_SETORKILL_NONTP_OR_TP(ERR_TRIGLOADFAIL); /* needed to set update_trans TRUE on this region
* even if NO db updates happen to ^#t nodes. */
jnl_format(JNL_LGTRIG, NULL, &trigjrec, 0);
jnl_format_done = TRUE;
}
if (triggers_deleted)
{
util_out_print_gtmio("All existing triggers (count = !UL) deleted", FLUSH, triggers_deleted);
trig_stats[STATS_DELETED] += triggers_deleted;
trig_stats[STATS_NOERROR_TRIGFILE]++;
} else
{
util_out_print_gtmio("No matching triggers found for deletion", FLUSH);
trig_stats[STATS_UNCHANGED_TRIGFILE]++;
}
}
boolean_t trigger_delete_name(char *trigger_name, uint4 trigger_name_len, uint4 *trig_stats)
{
sgmnt_addrs *csa;
char curr_name[MAX_MIDENT_LEN + 1];
uint4 curr_name_len, orig_name_len;
mval mv_curr_nam;
char *ptr;
char *name_tail_ptr;
char save_name[MAX_MIDENT_LEN + 1];
gv_key save_currkey[DBKEYALLOC(MAX_KEY_SZ)];
gd_region *save_gv_cur_region, *lgtrig_reg;
gv_namehead *save_gv_target;
sgm_info *save_sgm_info_ptr;
mval trig_gbl;
mval *trigger_count;
char trigvn[MAX_MIDENT_LEN + 1];
int trigvn_len;
int trig_indx;
int badpos;
boolean_t wildcard;
char utilprefix[1024];
int utilprefixlen;
boolean_t first_gtmio;
uint4 triggers_deleted;
mval trigjrec;
boolean_t jnl_format_done;
gd_region *reg, *reg_top;
char disp_trigvn[MAX_MIDENT_LEN + SPANREG_REGION_LITLEN + MAX_RN_LEN + 1 + 1];
/* SPANREG_REGION_LITLEN for " (region ", MAX_RN_LEN for region name,
* 1 for ")" and 1 for trailing '\0'.
*/
int disp_trigvn_len;
int trig_protected_mval_push_count;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
badpos = 0;
trigjrec.mvtype = MV_STR;
trigjrec.str.len = trigger_name_len--;
trigjrec.str.addr = trigger_name++;
orig_name_len = trigger_name_len;
if ((0 == trigger_name_len)
|| (trigger_name_len != (badpos = validate_input_trigger_name(trigger_name, trigger_name_len, &wildcard))))
{ /* is the input name valid */
CONV_STR_AND_PRINT("Invalid trigger NAME string: ", orig_name_len, trigger_name);
/* badpos is the string position where the bad character was found, pretty print it */
trig_stats[STATS_ERROR_TRIGFILE]++;
return TRIG_FAILURE;
}
name_tail_ptr = trigger_name + trigger_name_len - 1;
if ((TRIGNAME_SEQ_DELIM == *name_tail_ptr) || wildcard)
trigger_name_len--; /* drop the trailing # sign for wildcard */
jnl_format_done = FALSE;
lgtrig_reg = NULL;
first_gtmio = TRUE;
triggers_deleted = 0;
assert(trigger_name_len < MAX_MIDENT_LEN);
memcpy(save_name, trigger_name, trigger_name_len);
save_name[trigger_name_len] = '\0';
utilprefixlen = ARRAYSIZE(utilprefix);
trig_protected_mval_push_count = 0;
INCR_AND_PUSH_MV_STENT(trigger_count); /* Protect trigger_count from garbage collection */
for (reg = gd_header->regions, reg_top = reg + gd_header->n_regions; reg < reg_top; reg++)
{
GVTR_SWITCH_REG_AND_HASHT_BIND_NAME(reg);
csa = cs_addrs;
if (NULL == csa) /* not BG or MM access method */
continue;
/* gv_target now points to ^#t in region "reg" */
/* To write the LGTRIG logical jnl record, choose some region that has journaling enabled */
if (!reg->read_only && !jnl_format_done && JNL_WRITE_LOGICAL_RECS(csa))
lgtrig_reg = reg;
if (!gv_target->root)
continue;
memcpy(curr_name, save_name, trigger_name_len);
curr_name_len = trigger_name_len;
do {
/* GVN = $get(^#t("#TNAME",curr_name)) */
BUILD_HASHT_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), curr_name, curr_name_len);
if (gvcst_get(&trig_gbl))
{
if (reg->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_TRIGMODREGNOTRW, 2, REG_LEN_STR(reg));
SAVE_TRIGGER_REGION_INFO(save_currkey);
ptr = trig_gbl.str.addr;
trigvn_len = MIN(trig_gbl.str.len, MAX_MIDENT_LEN);
STRNLEN(ptr, trigvn_len, trigvn_len);
ptr += trigvn_len;
if ((trig_gbl.str.len == trigvn_len) || ('\0' != *ptr))
{ /* We expect $c(0) in the middle of ptr. If not found, this is a restartable situation */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
curr_name_len, curr_name);
}
memcpy(trigvn, trig_gbl.str.addr, trigvn_len);
/* the index is just beyond the length of the GVN string */
ptr++;
A2I(ptr, trig_gbl.str.addr + trig_gbl.str.len, trig_indx);
if (1 > trig_indx)
{ /* Trigger indexes start from 1 */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
curr_name_len, curr_name);
}
SET_DISP_TRIGVN(reg, disp_trigvn, disp_trigvn_len, trigvn, trigvn_len);
/* $get(^#t(GVN,"COUNT") */
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
if (!gvcst_get(trigger_count))
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Trigger named !AD exists in the lookup table, "
"but global ^!AD has no triggers",
FLUSH, curr_name_len, curr_name, disp_trigvn_len, disp_trigvn);
trig_stats[STATS_ERROR_TRIGFILE]++;
RETURN_AND_POP_MVALS(TRIG_FAILURE);
}
if (!jnl_format_done && JNL_WRITE_LOGICAL_RECS(csa))
{
jnl_format(JNL_LGTRIG, NULL, &trigjrec, 0);
jnl_format_done = TRUE;
}
/* kill the target trigger for GVN at index trig_indx */
if (PUT_SUCCESS != (trigger_delete(trigvn, trigvn_len, trigger_count, trig_indx)))
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Trigger named !AD exists in the lookup table for global ^!AD," \
" but was not deleted!", FLUSH, orig_name_len, trigger_name,
disp_trigvn_len, disp_trigvn);
trig_stats[STATS_ERROR_TRIGFILE]++;
RETURN_AND_POP_MVALS(TRIG_FAILURE);
} else
{
csa->incr_db_trigger_cycle = TRUE;
trigger_incr_cycle(trigvn, trigvn_len); /* ^#t records changed, increment cycle */
if (dollar_ztrigger_invoked)
{ /* Increment db_dztrigger_cycle so that next gvcst_put/gvcst_kill in this
* transaction, on this region, will re-read triggers. See trigger_update.c
* for a comment on why it is okay for db_dztrigger_cycle to be incremented
* more than once in the same transaction.
*/
csa->db_dztrigger_cycle++;
}
trig_stats[STATS_DELETED]++;
if (0 == trig_stats[STATS_ERROR_TRIGFILE])
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Deleted trigger named '!AD' for global ^!AD",
FLUSH, curr_name_len, curr_name, disp_trigvn_len, disp_trigvn);
}
}
trigger_count->mvtype = 0; /* allow stp_gcol to release the current contents if necessary */
RESTORE_TRIGGER_REGION_INFO(save_currkey);
triggers_deleted++;
}
if (!wildcard)
/* not a wild card, don't $order for the next match */
break;
op_gvorder(&mv_curr_nam);
if (0 == mv_curr_nam.str.len)
break;
assert(mv_curr_nam.str.len < MAX_MIDENT_LEN);
memcpy(curr_name, mv_curr_nam.str.addr, mv_curr_nam.str.len);
curr_name_len = mv_curr_nam.str.len;
if (0 != memcmp(curr_name, save_name, trigger_name_len))
/* stop when gv_order returns a string that no longer starts save_name */
break;
} while (TRUE);
}
DECR_AND_POP_MV_STENT();
if (!jnl_format_done && (NULL != lgtrig_reg))
{ /* There was no journaled region that had a ^#t update, but found at least one journaled region
* so write a LGTRIG logical jnl record there.
*/
GVTR_SWITCH_REG_AND_HASHT_BIND_NAME(lgtrig_reg);
csa = cs_addrs;
/* Attach to jnlpool. Normally SET or KILL of the ^#t records take care of this but in
* case this is a NO-OP trigger operation that wont update any ^#t records and we still
* want to write a TLGTRIG/ULGTRIG journal record. Hence the need to do this.
*/
JNLPOOL_INIT_IF_NEEDED(csa, csa->hdr, csa->nl);
assert(dollar_tlevel);
/* below is needed to set update_trans TRUE on this region even if NO db updates happen to ^#t nodes */
T_BEGIN_SETORKILL_NONTP_OR_TP(ERR_TRIGLOADFAIL);
jnl_format(JNL_LGTRIG, NULL, &trigjrec, 0);
jnl_format_done = TRUE;
}
if (wildcard)
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
if (triggers_deleted)
{
trig_stats[STATS_NOERROR_TRIGFILE]++;
util_out_print_gtmio("All existing triggers named !AD (count = !UL) now deleted",
FLUSH, orig_name_len, trigger_name, triggers_deleted);
} else
{
trig_stats[STATS_UNCHANGED_TRIGFILE]++;
util_out_print_gtmio("No matching triggers of the form !AD found for deletion",
FLUSH, orig_name_len, trigger_name);
}
} else if (triggers_deleted)
{
/* util_out_print_gtmio of "Deleted trigger named ..." already done so no need to do it again */
trig_stats[STATS_NOERROR_TRIGFILE]++;
} else
{ /* No names match. But treat it as a no-op (i.e. success). */
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Trigger named !AD does not exist", FLUSH, orig_name_len, trigger_name);
trig_stats[STATS_UNCHANGED_TRIGFILE]++;
}
return TRIG_SUCCESS;
}
void trigger_delete_all(void)
{
int count;
char count_str[MAX_DIGITS_IN_INT + 1];
sgmnt_addrs *csa;
mval curr_gbl_name;
int cycle;
mstr gbl_name;
mname_entry gvent;
gv_namehead *hasht_tree, *gvt;
mval *mv_count_ptr;
mval *mv_cycle_ptr;
mval mv_indx;
gd_region *reg;
int reg_indx;
int4 result;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
gd_region *save_gv_cur_region;
gv_namehead *save_gv_target;
sgm_info *save_sgm_info_ptr;
int trig_indx;
mval trigger_cycle;
mval trigger_count;
mval val;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(0 < dollar_tlevel);
/* Before we delete any triggers, verify that none of the triggers have been fired in this transaction. If they have,
* this creates an un-commitable transaction that will end in a TPFAIL error. Since that error indicates database
* damage, we'd rather detect this avoidable condition and give a descriptive error instead (TRIGMODINTP).
*/
for (gvt = gv_target_list; NULL != gvt; gvt = gvt->next_gvnh)
{
if (gvt->trig_local_tn == local_tn)
rts_error(VARLSTCNT(1) ERR_TRIGMODINTP);
}
SWITCH_TO_DEFAULT_REGION;
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED;
if (0 != gv_target->root)
{
/* kill ^#t("#TRHASH") */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH));
gvcst_kill(TRUE);
/* kill ^#t("#TNAME") */
BUILD_HASHT_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME));
gvcst_kill(TRUE);
}
for (reg_indx = 0, reg = gd_header->regions; reg_indx < gd_header->n_regions; reg_indx++, reg++)
{
if (!reg->open)
gv_init_reg(reg);
if (!reg->read_only)
{
gv_cur_region = reg;
change_reg();
csa = cs_addrs;
SETUP_TRIGGER_GLOBAL;
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED;
/* There might not be any ^#t in this region, so check */
if (0 != gv_target->root)
{ /* Kill all descendents of ^#t(trigvn, indx) where trigvn is any global with a trigger,
* but skip the "#XYZ" entries. setup ^#t(trigvn,"$") as the PREV key for op_gvorder
*/
BUILD_HASHT_SUB_CURRKEY(LITERAL_MAXHASHVAL, STRLEN(LITERAL_MAXHASHVAL));
TREF(gv_last_subsc_null) = FALSE; /* We know its not null, but prior state is unreliable */
while (TRUE)
{
op_gvorder(&curr_gbl_name);
/* quit:$length(curr_gbl_name)=0 */
if (0 == curr_gbl_name.str.len)
break;
/* $get(^#t(curr_gbl_name,#COUNT)) */
BUILD_HASHT_SUB_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len,
LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
if (gvcst_get(&trigger_count))
{
mv_count_ptr = &trigger_count;
count = MV_FORCE_INT(mv_count_ptr);
/* $get(^#t(curr_gbl_name,#CYCLE)) */
BUILD_HASHT_SUB_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len,
LITERAL_HASHCYCLE, STRLEN(LITERAL_HASHCYCLE));
if (!gvcst_get(&trigger_cycle))
assert(FALSE); /* Found #COUNT, there must be #CYCLE */
mv_cycle_ptr = &trigger_cycle;
cycle = MV_FORCE_INT(mv_cycle_ptr);
/* kill ^#t(curr_gbl_name) */
BUILD_HASHT_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len);
gvcst_kill(TRUE);
cycle++;
MV_FORCE_MVAL(&trigger_cycle, cycle);
/* set ^#t(curr_gbl_name,#CYCLE)=trigger_cycle */
SET_TRIGGER_GLOBAL_SUB_SUB_MVAL(curr_gbl_name.str.addr, curr_gbl_name.str.len,
LITERAL_HASHCYCLE, STRLEN(LITERAL_HASHCYCLE), trigger_cycle, result);
assert(PUT_SUCCESS == result);
} /* else there is no #COUNT, then no triggers, leave #CYCLE alone */
/* get ready for op_gvorder() call for next trigger under ^#t */
BUILD_HASHT_SUB_CURRKEY(curr_gbl_name.str.addr, curr_gbl_name.str.len);
}
csa->incr_db_trigger_cycle = TRUE;
if (dollar_ztrigger_invoked)
{ /* increment db_dztrigger_cycle so that next gvcst_put/gvcst_kill in this transaction,
* on this region, will re-read. See trigger_update.c for a comment on why it is okay
* for db_dztrigger_cycle to be incremented more than once in the same transaction
*/
csa->db_dztrigger_cycle++;
}
}
}
}
util_out_print_gtmio("All existing triggers deleted", FLUSH);
}
boolean_t trigger_delete_name(char *trigger_name, uint4 trigger_name_len, uint4 *trig_stats)
{
sgmnt_addrs *csa;
char curr_name[MAX_MIDENT_LEN + 1];
uint4 curr_name_len, orig_name_len;
mstr gbl_name;
mname_entry gvent;
gv_namehead *hasht_tree;
int len;
mval mv_curr_nam;
boolean_t name_found;
char *ptr;
char *name_tail_ptr;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
gd_region *save_gv_cur_region;
gv_namehead *save_gv_target;
char save_name[MAX_MIDENT_LEN + 1];
sgm_info *save_sgm_info_ptr;
mval trig_gbl;
mval trig_value;
mval trigger_count;
char trigvn[MAX_MIDENT_LEN + 1];
int trigvn_len;
int trig_indx;
int badpos;
boolean_t wildcard;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
badpos = 0;
orig_name_len = trigger_name_len;
if ((0 == trigger_name_len) || (trigger_name_len !=
(badpos = validate_input_trigger_name(trigger_name, trigger_name_len, &wildcard))))
{ /* is the input name valid */
CONV_STR_AND_PRINT("Invalid trigger NAME string: ", orig_name_len, trigger_name);
/* badpos is the string position where the bad character was found, pretty print it */
return TRIG_FAILURE;
}
name_tail_ptr = trigger_name + trigger_name_len - 1;
if (TRIGNAME_SEQ_DELIM == *name_tail_ptr || wildcard )
/* drop the trailing # sign or wildcard */
trigger_name_len--;
/* $data(^#t) */
SWITCH_TO_DEFAULT_REGION;
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED;
if (0 == gv_target->root)
{
util_out_print_gtmio("Trigger named !AD does not exist", FLUSH, orig_name_len, trigger_name);
return TRIG_FAILURE;
}
name_found = FALSE;
assert(trigger_name_len < MAX_MIDENT_LEN);
memcpy(save_name, trigger_name, trigger_name_len);
save_name[trigger_name_len] = '\0';
memcpy(curr_name, save_name, trigger_name_len);
curr_name_len = trigger_name_len;
STR2MVAL(mv_curr_nam, trigger_name, trigger_name_len);
do {
/* GVN = $get(^#t("#TNAME",curr_name) */
BUILD_HASHT_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), curr_name, curr_name_len);
if (gvcst_get(&trig_gbl))
{
SAVE_TRIGGER_REGION_INFO;
ptr = trig_gbl.str.addr;
trigvn_len = STRLEN(trig_gbl.str.addr);
assert(MAX_MIDENT_LEN >= trigvn_len);
memcpy(trigvn, ptr, trigvn_len);
ptr += trigvn_len + 1;
/* the index is just beyon the length of the GVN string */
A2I(ptr, trig_gbl.str.addr + trig_gbl.str.len, trig_indx);
gbl_name.addr = trigvn;
gbl_name.len = trigvn_len;
GV_BIND_NAME_ONLY(gd_header, &gbl_name);
csa = gv_target->gd_csa;
SETUP_TRIGGER_GLOBAL;
INITIAL_HASHT_ROOT_SEARCH_IF_NEEDED;
/* $get(^#t(GVN,"COUNT") */
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
/* if it does not exist, return false */
if (!gvcst_get(&trigger_count))
{
util_out_print_gtmio("Trigger named !AD exists in the lookup table, "
"but global ^!AD has no triggers",
FLUSH, curr_name_len, curr_name, trigvn_len, trigvn);
return TRIG_FAILURE;
}
/* kill the target trigger for GVN at index trig_indx */
if (PUT_SUCCESS != (trigger_delete(trigvn, trigvn_len, &trigger_count, trig_indx)))
{
util_out_print_gtmio("Trigger named !AD exists in the lookup table, but was not deleted!",
FLUSH, orig_name_len, trigger_name);
} else
{
csa->incr_db_trigger_cycle = TRUE;
if (dollar_ztrigger_invoked)
{ /* increment db_dztrigger_cycle so that next gvcst_put/gvcst_kill in this transaction,
* on this region, will re-read triggers. See trigger_update.c for a comment on why
* it is okay for db_dztrigger_cycle to be incremented more than once in the same
* transaction
*/
csa->db_dztrigger_cycle++;
}
trig_stats[STATS_DELETED]++;
if (0 == trig_stats[STATS_ERROR])
util_out_print_gtmio("Deleted trigger named '!AD' for global ^!AD",
FLUSH, curr_name_len, curr_name, trigvn_len, trigvn);
}
RESTORE_TRIGGER_REGION_INFO;
name_found = TRUE;
} else
{ /* no names match, if !wildcard report an error */
if (!wildcard)
{
util_out_print_gtmio("Trigger named !AD does not exist",
FLUSH, orig_name_len, trigger_name);
return TRIG_FAILURE;
}
}
if (!wildcard)
/* not a wild card, don't $order for the next match */
break;
op_gvorder(&mv_curr_nam);
if (0 == mv_curr_nam.str.len)
break;
assert(mv_curr_nam.str.len < MAX_MIDENT_LEN);
memcpy(curr_name, mv_curr_nam.str.addr, mv_curr_nam.str.len);
curr_name_len = mv_curr_nam.str.len;
if (0 != memcmp(curr_name, save_name, trigger_name_len))
/* stop when gv_order returns a string that no longer starts save_name */
break;
} while (wildcard);
if (name_found)
return TRIG_SUCCESS;
util_out_print_gtmio("Trigger named !AD does not exist", FLUSH, orig_name_len, trigger_name);
return TRIG_FAILURE;
}
void gvzwr_fini(zshow_out *out, int pat)
{
char m[SIZEOF(mident_fixed)];
mval local, data;
gv_key *old;
gvnh_reg_t *gvnh_reg;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (!gv_currkey)
gvinit();
ESTABLISH(gvzwrite_ch);
zwr_output = out;
assert(INVALID_GV_TARGET == reset_gv_target);
reset_gv_target = gv_target;
DBG_CHECK_GVTARGET_GVCURRKEY_IN_SYNC(CHECK_CSA_TRUE);
gvzwrite_block->gd_reg = gv_cur_region;
gvzwrite_block->old_targ = (unsigned char *)gv_target;
old = (gv_key *)malloc(SIZEOF(gv_key) + gv_currkey->end);
gvzwrite_block->old_key = (unsigned char *)old;
memcpy(gvzwrite_block->old_key, gv_currkey, SIZEOF(gv_key) + gv_currkey->end);
gvzwrite_block->gv_last_subsc_null = TREF(gv_last_subsc_null);
gvzwrite_block->gv_some_subsc_null = TREF(gv_some_subsc_null);
if (!pat)
{
local = *gvzwrite_block->pat;
if (local.str.len) /* New reference. Will get new gv_target.. */
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
op_gvname(VARLSTCNT(1) &local);
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
{
if (!undef_inhibit)
sgnl_gvundef();
} else
{
gvzwrite_block->fixed = (gvzwrite_block->fixed ? TRUE : FALSE);
gvzwr_var(MV_FORCE_INTD(&data), 0);
}
} else /* Old (naked) reference. Keep previous gv_target reference */
{
if (gv_currkey->prev == 0)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_GVNAKED);
gv_currkey->end = gv_currkey->prev;
gv_currkey->base[gv_currkey->end] = 0;
gv_currkey->prev = 0;
/* If gvnh_reg corresponds to a spanning global, then determine
* gv_cur_region/gv_target/gd_targ_* variables based on updated gv_currkey.
*/
gvnh_reg = TREF(gd_targ_gvnh_reg); /* set by op_gvname in previous call */
GV_BIND_SUBSNAME_FROM_GVNH_REG_IF_GVSPAN(gvnh_reg, gd_header, gv_currkey);
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
{
if (!undef_inhibit)
sgnl_gvundef();
} else
{
gvzwrite_block->fixed = (gvzwrite_block->fixed ? TRUE : FALSE);
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
} else
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
local.mvtype = MV_STR;
local.str.addr = &m[0];
local.str.len = 1;
m[0] = '%';
gvzwrite_block->fixed = FALSE;
for (; ;)
{
op_gvname(VARLSTCNT(1) &local);
if (do_pattern(&local, gvzwrite_block->pat))
{
op_gvdata(&data);
if ((MV_FORCE_INTD(&data)))
{
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
op_gvorder(&local);
if (local.str.len)
{
assert(local.str.len <= MAX_MIDENT_LEN + 1);
local.str.addr++;
local.str.len--;
memcpy(&m[0], local.str.addr, local.str.len);
local.str.addr = &m[0];
} else
break;
}
}
gvzwrite_clnup(); /* this routine is called by gvzwrite_ch() too */
REVERT;
return;
}
int
omi_prc_def(omi_conn *cptr, char *xend, char *buff, char *bend)
{
GBLREF bool undef_inhibit;
char *bptr;
omi_li len;
int rv;
mval vo, vd, vg;
bptr = buff;
/* Global Ref */
OMI_LI_READ(&len, cptr->xptr);
/* Set up a condition handler */
ESTABLISH_RET(omi_dbms_ch,0);
rv = omi_gvextnam(cptr, len.value, cptr->xptr);
/* If true, there was an error finding the global reference in the DBMS */
if (rv < 0)
{
REVERT;
return rv;
}
cptr->xptr += len.value;
/* Bounds checking */
if (cptr->xptr > xend)
{
REVERT;
return -OMI_ER_PR_INVMSGFMT;
}
/* We want to make sure there is plenty of space in the string pool
* for all three operations ($ORDER, $GET, $DATA) */
if (cptr->exts & OMI_XTF_NEWOP)
stp_gcol(0);
/* $DATA */
op_gvdata(&vd);
if (!(vd.mvtype & MV_INT))
{
REVERT;
return -OMI_ER_DB_UNRECOVER;
}
if (cptr->exts & OMI_XTF_NEWOP)
{
/* $GET */
undef_inhibit = TRUE;
rv = op_gvget(&vg);
/* $ORDER */
op_gvorder(&vo);
OMI_SI_WRIT(vo.str.len, bptr);
if (vo.str.len)
{
memcpy(bptr, vo.str.addr, vo.str.len);
bptr += vo.str.len;
}
}
/* $DATA (buffer write) */
OMI_SI_WRIT(vd.m[1] / MV_BIAS, bptr);
if (cptr->exts & OMI_XTF_NEWOP)
{
/* $GET (buffer write) */
OMI_SI_WRIT((rv ? 1 : 0), bptr);
if (!rv || !vg.str.len)
OMI_LI_WRIT(0, bptr);
else
{
OMI_LI_WRIT(vg.str.len, bptr);
memcpy(bptr, vg.str.addr, vg.str.len);
bptr += vg.str.len;
}
}
REVERT;
return (int)(bptr - buff);
}
void gvzwr_fini(zshow_out *out, int pat)
{
char m[sizeof(mident_fixed)];
mval local, data;
gv_key *old;
error_def(ERR_GVNAKED);
if (!gv_currkey)
gvinit();
ESTABLISH(gvzwrite_ch);
zwr_output = out;
assert(INVALID_GV_TARGET == reset_gv_target);
reset_gv_target = gv_target;
DBG_CHECK_GVTARGET_CSADDRS_IN_SYNC;
gvzwrite_block.gd_reg = gv_cur_region;
gvzwrite_block.old_targ = (unsigned char *)gv_target;
old = (gv_key *)malloc(sizeof(gv_key) + gv_currkey->end);
gvzwrite_block.old_key = (unsigned char *)old;
memcpy(gvzwrite_block.old_key, gv_currkey, sizeof(gv_key) + gv_currkey->end);
gvzwrite_block.old_map = gd_map;
gvzwrite_block.old_map_top = gd_map_top;
if (!pat)
{
local = *gvzwrite_block.pat;
if (local.str.len) /* New reference. Will get new gv_target.. */
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
op_gvname(VARLSTCNT(1) &local);
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
sgnl_gvundef();
else
{
gvzwrite_block.fixed = (gvzwrite_block.fixed ? TRUE : FALSE);
gvzwr_var(MV_FORCE_INTD(&data), 0);
}
} else /* Old (naked) reference. Keep previous gv_target reference */
{
if (gv_currkey->prev == 0)
rts_error(VARLSTCNT(1) ERR_GVNAKED);
gv_currkey->end = gv_currkey->prev;
gv_currkey->base[ gv_currkey->end ] = 0;
gv_currkey->prev = 0;
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
sgnl_gvundef();
else
{
gvzwrite_block.fixed = (gvzwrite_block.fixed ? TRUE : FALSE);
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
} else
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
local.mvtype = MV_STR;
local.str.addr = &m[0];
local.str.len = 1;
m[0] = '%';
gvzwrite_block.fixed = FALSE;
for (; ;)
{
op_gvname(VARLSTCNT(1) &local);
if (do_pattern(&local, gvzwrite_block.pat))
{
op_gvdata(&data);
if ((MV_FORCE_INTD(&data)))
{
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
op_gvorder(&local);
if (local.str.len)
{
assert(local.str.len <= MAX_MIDENT_LEN + 1);
local.str.addr++;
local.str.len--;
memcpy(&m[0], local.str.addr, local.str.len);
local.str.addr = &m[0];
} else
break;
}
}
gvzwrite_clnup(); /* this routine is called by gvzwrite_ch() too */
REVERT;
return;
}
int omi_prc_ordr(omi_conn *cptr, char *xend, char *buff, char *bend)
{
char *bptr;
int rv;
omi_li len;
mval vo, vd, vg;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
bptr = buff;
/* Global Ref */
OMI_LI_READ(&len, cptr->xptr);
/* Condition handler for DBMS operations */
ESTABLISH_RET(omi_dbms_ch,0);
rv = omi_gvextnam(cptr, len.value, cptr->xptr);
/* If true, there was an error finding the global reference in the DBMS */
if (rv < 0)
{
REVERT;
return rv;
}
cptr->xptr += len.value;
/* Bounds checking */
if (cptr->xptr > xend)
{
REVERT;
return -OMI_ER_PR_INVMSGFMT;
}
/* We want to make sure there is plenty of space in the string pool for all three operations ($ORDER, $GET, $DATA) */
if (cptr->exts & OMI_XTF_NEWOP)
INVOKE_STP_GCOL(0);
/* $ORDER */
op_gvorder(&vo);
/* $ORDER (buffer write) */
OMI_SI_WRIT(vo.str.len, bptr);
if (vo.str.len)
{
memcpy(bptr, vo.str.addr, vo.str.len);
bptr += vo.str.len;
}
/* Bunching */
if (cptr->exts & OMI_XTF_NEWOP)
{
if (vo.str.len)
{
if (!gv_currkey->prev)
{
if (*vo.str.addr != '^')
{
REVERT;
return -OMI_ER_PR_INVGLOBREF;
}
vo.str.addr++; vo.str.len--;
GV_BIND_NAME_AND_ROOT_SEARCH(cptr->ga, &vo.str);
vo.str.addr--; vo.str.len++;
TREF(gv_last_subsc_null) = FALSE;
} else
{
if (gv_currkey->top != gv_altkey->top)
{
REVERT
return -OMI_ER_DB_UNRECOVER;
}
memcpy(gv_currkey, gv_altkey, gv_altkey->end + SIZEOF(gv_key));
TREF(gv_last_subsc_null) = FALSE;
}
/* $DATA */
op_gvdata(&vd);
if (!(vd.mvtype & MV_INT))
{
REVERT;
return -OMI_ER_DB_UNRECOVER;
}
/* $GET */
undef_inhibit = TRUE;
rv = op_gvget(&vg);
/* $DATA (buffer write) */
OMI_SI_WRIT(vd.m[1] / MV_BIAS, bptr);
/* $GET (buffer write) */
OMI_SI_WRIT((rv ? 1 : 0), bptr);
if (!rv || !vg.str.len)
OMI_LI_WRIT(0, bptr);
else
{
OMI_LI_WRIT(vg.str.len, bptr);
memcpy(bptr, vg.str.addr, vg.str.len);
bptr += vg.str.len;
}
} else
{ /* Otherwise $ORDER returned a null */
void gv_select(char *cli_buff, int n_len, boolean_t freeze, char opname[], glist *gl_head,
int *reg_max_rec, int *reg_max_key, int *reg_max_blk)
{
bool stashed = FALSE;
int num_quote, len;
char *ptr, *ptr1, *c;
mstr gmap[256], *gmap_ptr, gmap_beg, gmap_end;
mval val, curr_gbl_name;
glist *gl_tail, *gl_ptr;
htab_desc *ext_hash;
mname ht_mname;
ht_entry *h;
error_def(ERR_FREEZE);
error_def(ERR_DBRDONLY);
error_def(ERR_SELECTSYNTAX);
error_def(ERR_MUNOFINISH);
error_def(ERR_MUNOACTION);
memset(gmap, 0, sizeof(gmap));
for (ptr = cli_buff; *ptr; ptr = ptr1)
{
for (ptr1 = ptr; ; ptr1++)
{
if (',' == *ptr1)
{
len = ptr1 - ptr;
ptr1++;
break;
}
else if (!*ptr1)
{
len = ptr1 - ptr;
break;
}
}
gmap_beg.addr = ptr;
c = gmap_beg.addr + len - 1;
num_quote = 0;
while ('"' == *c)
{
len--;
c--;
num_quote++;
}
if (0 >= len)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
c = gmap_beg.addr;
while (0 < num_quote)
{
if ('"' == *c)
{
c++;
len--;
}
else
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
num_quote--;
}
gmap_beg.addr = c;
if ('^' == *c)
{
gmap_beg.addr++;
len--;
}
gmap_beg.len = len;
c = mu_extr_ident(&gmap_beg);
len -= (c - gmap_beg.addr);
assert(len >= 0);
if (0 == len)
gmap_end = gmap_beg;
else if (gmap_beg.len == 1 && '*' == *c)
{
gmap_beg.addr = (char*)&percent_lit;
gmap_beg.len = sizeof(percent_lit);
gmap_end.addr = (char*)&tilde_lit;
gmap_end.len = sizeof(tilde_lit);
}
else if (1 == len && '*' == *c)
{
gmap_end = gmap_beg;
gmap_beg.len--;
*c = '~';
}
else if (':' != *c)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
else
{
gmap_beg.len = c - gmap_beg.addr;
c++;
gmap_end.addr = c;
gmap_end.len = len - 1;
if ('^' == *c)
{
gmap_end.addr++;
gmap_end.len--;
}
c = mu_extr_ident(&gmap_end);
if (c - gmap_end.addr != gmap_end.len || mstrcmp(&gmap_beg, &gmap_end) > 0)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
}
global_map(gmap, &gmap_beg, &gmap_end);
}
if (freeze)
{
ext_hash = (htab_desc *)malloc(sizeof(htab_desc));
ht_init(ext_hash, 0);
memset(&ht_mname.txt[0], 0, sizeof(mname));
}
gl_head->next = NULL;
gl_tail = gl_head;
*reg_max_rec = 0;
*reg_max_key = 0;
*reg_max_blk = 0;
for (gmap_ptr = gmap; gmap_ptr->addr ; gmap_ptr++)
{
curr_gbl_name.mvtype = MV_STR;
curr_gbl_name.str = *gmap_ptr++;
op_gvname(VARLSTCNT(1) &curr_gbl_name);
if (dba_cm == gv_cur_region->dyn.addr->acc_meth)
{ util_out_print("Can not select globals from region !AD across network",TRUE,gv_cur_region->rname_len,
gv_cur_region->rname);
mupip_exit(ERR_MUNOFINISH);
}
if (dba_bg != gv_cur_region->dyn.addr->acc_meth && dba_mm != gv_cur_region->dyn.addr->acc_meth)
{
assert(gv_cur_region->dyn.addr->acc_meth == dba_usr);
util_out_print("Can not select globals from non-GTC region !AD",TRUE,gv_cur_region->rname_len,
gv_cur_region->rname);
mupip_exit(ERR_MUNOFINISH);
}
op_gvdata(&val);
if (0 == val.m[1])
{
op_gvname(VARLSTCNT(1) &curr_gbl_name);
op_gvorder(&curr_gbl_name);
if (!curr_gbl_name.str.len)
break;
assert('^' == *curr_gbl_name.str.addr);
curr_gbl_name.str.addr++;
curr_gbl_name.str.len--;
}
for (;;)
{
if (mstrcmp(&curr_gbl_name.str, gmap_ptr) > 0)
break;
if (freeze)
{
memcpy(&ht_mname.txt[0], &gv_cur_region, sizeof(int4));
h = ht_put(ext_hash, &ht_mname, &stashed);
if (stashed)
{
if (cs_addrs->hdr->freeze)
{
gtm_putmsg(VARLSTCNT(4) ERR_FREEZE, 2, gv_cur_region->rname_len,
gv_cur_region->rname);
mupip_exit(ERR_MUNOFINISH);
}
/* Cannot proceed for read-only data files */
if (gv_cur_region->read_only)
{
util_out_print("Cannot freeze the database",TRUE);
gtm_putmsg(VARLSTCNT(4) ERR_DBRDONLY, 2,
DB_LEN_STR(gv_cur_region));
mupip_exit(ERR_MUNOFINISH);
}
while (FALSE == region_freeze(gv_cur_region, TRUE, FALSE))
hiber_start(1000);
wcs_flu(WCSFLU_FLUSH_HDR | WCSFLU_WRITE_EPOCH | WCSFLU_SYNC_EPOCH);
}
}
assert(curr_gbl_name.str.len > 0);
gl_ptr = (glist*)malloc(sizeof(glist) - 1 + curr_gbl_name.str.len);
gl_ptr->name.mvtype = MV_STR;
gl_ptr->name.str.addr = (char*)gl_ptr->nbuf;
gl_ptr->name.str.len = curr_gbl_name.str.len;
memcpy(gl_ptr->nbuf, curr_gbl_name.str.addr, curr_gbl_name.str.len);
gl_ptr->next = 0;
gl_tail->next = gl_ptr;
gl_tail = gl_ptr;
if (*reg_max_rec < cs_data->max_rec_size) *reg_max_rec = cs_data->max_rec_size;
if (*reg_max_key < cs_data->max_key_size) *reg_max_key = cs_data->max_key_size;
if (*reg_max_blk < cs_data->blk_size) *reg_max_blk = cs_data->blk_size;
op_gvname(VARLSTCNT(1) &gl_tail->name);
op_gvorder(&curr_gbl_name);
if (0 == curr_gbl_name.str.len)
{
(gmap_ptr + 1)->addr = 0;
break;
}
assert('^' == *curr_gbl_name.str.addr);
curr_gbl_name.str.addr++;
curr_gbl_name.str.len--;
}
}
}