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]++;
}
}
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);
}
int4 trigger_delete(char *trigvn, int trigvn_len, mval *trigger_count, int index)
{
int count;
mval mv_val;
mval *mv_val_ptr;
char *ptr1;
int4 result;
int4 retval;
stringkey kill_hash, set_hash;
int sub_indx;
char tmp_trig_str[MAX_BUFF_SIZE];
int4 trig_len;
char trig_name[MAX_TRIGNAME_LEN];
int trig_name_len;
int tmp_len;
char *tt_val[NUM_SUBS];
uint4 tt_val_len[NUM_SUBS];
mval trigger_value;
mval trigger_index;
mval xecute_index;
uint4 xecute_idx;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!gv_cur_region->read_only); /* caller should have already checked this */
assert(cs_addrs->hasht_tree == gv_target); /* should have been set up by caller */
assert(gv_target->root); /* should have been ensured by caller */
mv_val_ptr = &mv_val;
MV_FORCE_UMVAL(&trigger_index, index);
count = MV_FORCE_UINT(trigger_count);
/* build up array of values - needed for comparison in hash stuff */
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
tmp_len = trigvn_len + 1;
/* Assert that BHASH and LHASH are not part of NUM_SUBS calculation (confirms the -2 done in the #define of NUM_SUBS) */
assert(BHASH_SUB == NUM_SUBS);
assert(LHASH_SUB == (NUM_SUBS + 1));
for (sub_indx = 0; sub_indx < NUM_SUBS; sub_indx++)
{
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
trig_len = gvcst_get(&trigger_value) ? trigger_value.str.len : 0;
if (0 == trig_len)
{
if (((TRIGNAME_SUB == sub_indx) || (CMD_SUB == sub_indx) || (CHSET_SUB == sub_indx)))
{ /* CMD, NAME and CHSET cannot be zero length */
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(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD, 6, trigvn_len, trigvn,
trigvn_len, trigvn, STRLEN(trigger_subs[sub_indx]), trigger_subs[sub_indx]);
}
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
if (TRIGNAME_SUB == sub_indx)
{
trig_name_len = MIN(trig_len, MAX_TRIGNAME_LEN);
assert(MAX_TRIGNAME_LEN >= trig_len);
memcpy(trig_name, trigger_value.str.addr, trig_name_len);
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
tmp_len += trig_len;
if (0 < trig_len)
{
if (MAX_BUFF_SIZE <= tmp_len)
return VAL_TOO_LONG;
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
tmp_len++;
}
/* Get trigger name, set hash value, and kill hash values from trigger before we delete it.
* The values will be used in clean ups associated with the deletion
*/
/* $get(^#t(GVN,trigger_index,"LHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (gvcst_get(mv_val_ptr))
kill_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
else
{
util_out_print_gtmio("The LHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
kill_hash.hash_code = 0;
}
/* $get(^#t(GVN,trigger_index,"BHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (gvcst_get(mv_val_ptr))
set_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
else
{
util_out_print_gtmio("The BHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
set_hash.hash_code = 0;
}
/* kill ^#t(GVN,trigger_index) */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, trigger_index);
gvcst_kill(TRUE);
assert(0 == gvcst_data());
if (1 == count)
{ /* This is the last trigger for "trigvn" - clean up trigger name, remove #LABEL and #COUNT */
assert(1 == index);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHLABEL, STRLEN(LITERAL_HASHLABEL));
gvcst_kill(TRUE);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
gvcst_kill(TRUE);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, index);
} else
{
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, index);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
if (index != count)
{ /* Shift the last trigger (index is #COUNT value) to the just deleted trigger's index.
* This way count is always accurate and can still be used as the index for new triggers.
* Note - there is no dependence on the trigger order, or this technique wouldn't work.
*/
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
tmp_len = trigvn_len + 1;
for (sub_indx = 0; sub_indx < NUM_TOTAL_SUBS; sub_indx++)
{
/* $get(^#t(GVN,trigger_count,sub_indx) */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
if (gvcst_get(&trigger_value))
{
trig_len = trigger_value.str.len;
/* set ^#t(GVN,trigger_index,sub_indx)=^#t(GVN,trigger_count,sub_indx) */
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), trigger_value, result);
assert(PUT_SUCCESS == result);
} else if (XECUTE_SUB == sub_indx)
{ /* multi line trigger broken up because it exceeds record size */
for (xecute_idx = 0; ; xecute_idx++)
{
i2mval(&xecute_index, xecute_idx);
BUILD_HASHT_SUB_MSUB_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index);
if (!gvcst_get(&trigger_value))
break;
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MSUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index,
trigger_value, result);
assert(PUT_SUCCESS == result);
}
assert (xecute_idx >= 2); /* multi-line trigger, indices 0, 1 and 2 MUST be defined */
} else
{
if (((TRIGNAME_SUB == sub_indx) || (CMD_SUB == sub_indx) ||
(CHSET_SUB == sub_indx)))
{ /* CMD, NAME and CHSET cannot be zero length */
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(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD,
6, trigvn_len, trigvn, trigvn_len, trigvn,
STRLEN(trigger_subs[sub_indx]), trigger_subs[sub_indx]);
}
/* OPTIONS, PIECES and DELIM can be zero */
trig_len = 0;
}
if (NUM_SUBS > sub_indx)
{
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
tmp_len += trig_len;
if (0 < trig_len)
{
if (MAX_BUFF_SIZE <= tmp_len)
{ /* Exceeding the temporary buffer is impossible, restart*/
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(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD,
6, trigvn_len, trigvn, trigvn_len, trigvn,
STRLEN(trigger_subs[sub_indx]), trigger_subs[sub_indx]);
}
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
tmp_len++;
}
}
/* $get(^#t(GVN,trigger_count,"LHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
kill_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
/* $get(^#t(GVN,trigger_count,"BHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
set_hash.hash_code = (uint4)MV_FORCE_UINT(mv_val_ptr);
/* update hash values from above */
if (VAL_TOO_LONG == (retval = update_trigger_hash_value(trigvn, trigvn_len, tt_val, tt_val_len,
&set_hash, &kill_hash, count, index)))
return VAL_TOO_LONG;
/* fix the value ^#t("#TNAME",^#t(GVN,index,"#TRIGNAME")) to point to the correct "index" */
if (VAL_TOO_LONG == (retval = update_trigger_name_value(tt_val[TRIGNAME_SUB],
tt_val_len[TRIGNAME_SUB], index)))
return VAL_TOO_LONG;
/* kill ^#t(GVN,COUNT) which was just shifted to trigger_index */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count);
gvcst_kill(TRUE);
}
/* Update #COUNT */
count--;
MV_FORCE_UMVAL(trigger_count, count);
SET_TRIGGER_GLOBAL_SUB_SUB_MVAL(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT), *trigger_count,
result);
assert(PUT_SUCCESS == result); /* Size of count can only get shorter or stay the same */
}
return PUT_SUCCESS;
}
int4 trigger_delete(char *trigvn, int trigvn_len, mval *trigger_count, int index)
{
int count;
mval *mv_cnt_ptr;
mval mv_val;
mval *mv_val_ptr;
int num_len;
char *ptr1;
int4 result;
int4 retval;
char save_currkey[SIZEOF(gv_key) + DBKEYSIZE(MAX_KEY_SZ)];
gv_key *save_gv_currkey;
stringkey kill_hash, set_hash;
int sub_indx;
char tmp_trig_str[MAX_BUFF_SIZE];
int4 trig_len;
char trig_name[MAX_TRIGNAME_LEN];
int trig_name_len;
int tmp_len;
char *tt_val[NUM_SUBS];
uint4 tt_val_len[NUM_SUBS];
mval trigger_value;
mval trigger_index;
mval xecute_index;
uint4 xecute_idx;
uint4 used_trigvn_len;
mval val;
char val_str[MAX_DIGITS_IN_INT + 1];
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
mv_val_ptr = &mv_val;
MV_FORCE_MVAL(&trigger_index, index);
count = MV_FORCE_INT(trigger_count);
/* build up array of values - needed for comparison in hash stuff */
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
tmp_len = trigvn_len + 1;
for (sub_indx = 0; sub_indx < NUM_SUBS; sub_indx++)
{
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
trig_len = gvcst_get(&trigger_value) ? trigger_value.str.len : 0;
if (0 == trig_len)
{
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
if (TRIGNAME_SUB == sub_indx)
{
trig_name_len = trig_len;
assert(MAX_TRIGNAME_LEN >= trig_len);
memcpy(trig_name, trigger_value.str.addr, trig_name_len);
tt_val[sub_indx] = NULL;
tt_val_len[sub_indx] = 0;
continue;
}
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
tmp_len += trig_len;
if (0 < trig_len)
{
if (MAX_BUFF_SIZE <= tmp_len)
return VAL_TOO_LONG;
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
tmp_len++;
}
/* Get trigger name, set hash value, and kill hash values from trigger before we delete it.
* The values will be used in clean ups associated with the deletion
*/
/* $get(^#t(GVN,trigger_index,"LHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (gvcst_get(mv_val_ptr))
kill_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
else {
util_out_print_gtmio("The LHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
kill_hash.hash_code = 0;
}
/* $get(^#t(GVN,trigger_index,"BHASH") for deletion in cleanup_trigger_hash */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, trigger_index, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (gvcst_get(mv_val_ptr))
set_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
else {
util_out_print_gtmio("The BHASH for global ^!AD does not exist", FLUSH, trigvn_len, trigvn);
set_hash.hash_code = 0;
}
/* kill ^#t(GVN,trigger_index) */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, trigger_index);
gvcst_kill(TRUE);
assert(0 == gvcst_data());
if (1 == count)
{ /* This is the last trigger for "trigvn" - clean up trigger name, remove #LABEL and #COUNT */
assert(1 == index);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHLABEL, STRLEN(LITERAL_HASHLABEL));
gvcst_kill(TRUE);
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
gvcst_kill(TRUE);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, 0);
} else
{
cleanup_trigger_hash(trigvn, trigvn_len, tt_val, tt_val_len, &set_hash, &kill_hash, TRUE, index);
cleanup_trigger_name(trigvn, trigvn_len, trig_name, trig_name_len);
if (index != count)
{ /* Shift the last trigger (index is #COUNT value) to the just deleted trigger's index.
* This way count is always accurate and can still be used as the index for new triggers.
* Note - there is no dependence on the trigger order, or this technique wouldn't work.
*/
ptr1 = tmp_trig_str;
memcpy(ptr1, trigvn, trigvn_len);
ptr1 += trigvn_len;
*ptr1++ = '\0';
for (sub_indx = 0; sub_indx < NUM_TOTAL_SUBS; sub_indx++)
{
/* $get(^#t(GVN,trigger_count,sub_indx) */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[sub_indx],
STRLEN(trigger_subs[sub_indx]));
if (gvcst_get(&trigger_value))
{
trig_len = trigger_value.str.len;
/* set ^#t(GVN,trigger_index,sub_indx)=^#t(GVN,trigger_count,sub_indx) */
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), trigger_value, result);
assert(PUT_SUCCESS == result);
} else if (XECUTE_SUB == sub_indx)
{ /* multi line trigger broken up because it exceeds record size */
for (xecute_idx = 0; ; xecute_idx++)
{
i2mval(&xecute_index, xecute_idx);
BUILD_HASHT_SUB_MSUB_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index);
if (!gvcst_get(&trigger_value))
break;
SET_TRIGGER_GLOBAL_SUB_MSUB_SUB_MSUB_MVAL(trigvn, trigvn_len, trigger_index,
trigger_subs[sub_indx], STRLEN(trigger_subs[sub_indx]), xecute_index,
trigger_value, result);
assert(PUT_SUCCESS == result);
}
assert (xecute_idx >= 2); /* multi-line trigger, indices 0, 1 and 2 MUST be defined */
} else
{
/* in PRO this is a nasty case that will result in an access violation
* because data that should be present is not. In the next go around
* with trigger installation this case should be handled better */
assert(!((TRIGNAME_SUB == sub_indx) || (CMD_SUB == sub_indx) ||
(CHSET_SUB == sub_indx))); /* these should not be zero length */
trig_len = 0;
}
if (NUM_SUBS > sub_indx)
{
tt_val[sub_indx] = ptr1;
tt_val_len[sub_indx] = trig_len;
if (0 < trig_len)
{
memcpy(ptr1, trigger_value.str.addr, trig_len);
ptr1 += trig_len;
}
*ptr1++ = '\0';
}
}
/* $get(^#t(GVN,trigger_count,"LHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[LHASH_SUB],
STRLEN(trigger_subs[LHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
kill_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
/* $get(^#t(GVN,trigger_count,"BHASH") for update_trigger_hash_value */
BUILD_HASHT_SUB_MSUB_SUB_CURRKEY(trigvn, trigvn_len, *trigger_count, trigger_subs[BHASH_SUB],
STRLEN(trigger_subs[BHASH_SUB]));
if (!gvcst_get(mv_val_ptr))
return PUT_SUCCESS;
set_hash.hash_code = (uint4)MV_FORCE_INT(mv_val_ptr);
/* update hash values from above */
if (VAL_TOO_LONG == (retval = update_trigger_hash_value(trigvn, trigvn_len, tt_val, tt_val_len,
&set_hash, &kill_hash, count, index)))
return VAL_TOO_LONG;
/* fix the value ^#t("#TNAME",^#t(GVN,index,"#TRIGNAME")) to point to the correct "index" */
if (VAL_TOO_LONG == (retval = update_trigger_name_value(trigvn_len, tt_val[TRIGNAME_SUB],
tt_val_len[TRIGNAME_SUB], index)))
return VAL_TOO_LONG;
/* kill ^#t(GVN,COUNT) which was just shifted to trigger_index */
BUILD_HASHT_SUB_MSUB_CURRKEY(trigvn, trigvn_len, *trigger_count);
gvcst_kill(TRUE);
}
/* Update #COUNT */
count--;
MV_FORCE_MVAL(trigger_count, count);
SET_TRIGGER_GLOBAL_SUB_SUB_MVAL(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT), *trigger_count,
result);
assert(PUT_SUCCESS == result); /* Size of count can only get shorter or stay the same */
}
trigger_incr_cycle(trigvn, trigvn_len);
return PUT_SUCCESS;
}
