database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-07-04 04:22:36 +03:00
Code Activity

Stylistic changes to src/trigger.c (partial fix to ticket #39). Also more comments. (CVS 570)

Browse Source 
FossilOrigin-Name: b1d72cb5847a9f5f08e40b36ad117b5493232ea7
This commit is contained in:
danielk1977
2002-05-17 00:05:58 +00:00
parent d99bc930f7
commit 633ed08d95
3 changed files with 271 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
manifest
View File

@ -1,5 +1,5 @@
C Fix\sfor\sticket\s#42:\sAdded\scomments\sto\sstructs\sTrigger,\sTriggerStep\sand\sTriggerStack.\s(CVS\s569) C Stylistic\schanges\sto\ssrc/trigger.c\s(partial\sfix\sto\sticket\s#39).\sAlso\smore\scomments.\s(CVS\s570)
D 2002-05-16T00:13:12 D 2002-05-17T00:05:59
F Makefile.in 6291a33b87d2a395aafd7646ee1ed562c6f2c28c F Makefile.in 6291a33b87d2a395aafd7646ee1ed562c6f2c28c
F Makefile.template 4e11752e0b5c7a043ca50af4296ec562857ba495 F Makefile.template 4e11752e0b5c7a043ca50af4296ec562857ba495
F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0 F README a4c0ba11354ef6ba0776b400d057c59da47a4cc0
@ -49,7 +49,7 @@ F src/test2.c 669cc22781c6461a273416ec1a7414d25c081730
F src/test3.c 4e52fff8b01f08bd202f7633feda5639b7ba2b5e F src/test3.c 4e52fff8b01f08bd202f7633feda5639b7ba2b5e
F src/threadtest.c 81f0598e0f031c1bd506af337fdc1b7e8dff263f F src/threadtest.c 81f0598e0f031c1bd506af337fdc1b7e8dff263f
F src/tokenize.c f12f78c58b2a79ea4eee880efad63a328e103c62 F src/tokenize.c f12f78c58b2a79ea4eee880efad63a328e103c62
F src/trigger.c 491d5d3b40d737365a1ade7d4039277991208dc3 F src/trigger.c e61b4a9ecdfdef8e5d7d074e720dacf7abe5f361
F src/update.c f9b53d46cc651b9630fc53342b9e792031f6fc5c F src/update.c f9b53d46cc651b9630fc53342b9e792031f6fc5c
F src/util.c 707c30f8c13cddace7c08556ac450c0b786660b3 F src/util.c 707c30f8c13cddace7c08556ac450c0b786660b3
F src/vdbe.c 42281b4e0e0c4a089018a14d6840ada5a1896e51 F src/vdbe.c 42281b4e0e0c4a089018a14d6840ada5a1896e51
@ -134,7 +134,7 @@ F www/speed.tcl da8afcc1d3ccc5696cfb388a68982bc3d9f7f00f
F www/sqlite.tcl 8b5884354cb615049aed83039f8dfe1552a44279 F www/sqlite.tcl 8b5884354cb615049aed83039f8dfe1552a44279
F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331 F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331
F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218 F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
P 454879fa400f8c67456a483e69342bf48e3a02a4 P 9ec8a2b139ce38312284d7b4eb61221b1e1e3052
R 4ce29c61e08ffa335fbe57344d2ed013 R 6c59ff9d8d542bc14ae8632c3c69e144
U danielk1977 U danielk1977
Z 4467b41aebb8cfe3136a58c0b40fd68b Z d967dbf67c63f0da8b2c7467d5b0888a

2
manifest.uuid
View File

@ -1 +1 @@
9ec8a2b139ce38312284d7b4eb61221b1e1e3052 b1d72cb5847a9f5f08e40b36ad117b5493232ea7

470
src/trigger.c
View File

@ -1,23 +1,34 @@
/* /*
** All copyright on this work is disclaimed by the author. **
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
*
*/ */
#include "sqliteInt.h" #include "sqliteInt.h"
/* /*
** This is called by the parser when it sees a CREATE TRIGGER statement ** This is called by the parser when it sees a CREATE TRIGGER statement. See
** comments surrounding struct Trigger in sqliteInt.h for a description of
** how triggers are stored.
*/ */
void sqliteCreateTrigger( void sqliteCreateTrigger(
Parse *pParse, /* The parse context of the CREATE TRIGGER statement */ Parse *pParse, /* The parse context of the CREATE TRIGGER statement */
Token *nm, /* The name of the trigger */ Token *pName, /* The name of the trigger */
int tr_tm, /* One of TK_BEFORE, TK_AFTER */ int tr_tm, /* One of TK_BEFORE, TK_AFTER */
int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */ int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
IdList *cols, /* column list if this is an UPDATE OF trigger */ IdList *pColumns, /* column list if this is an UPDATE OF trigger */
Token *tbl, /* The name of the table/view the trigger applies to */ Token *pTableName, /* The name of the table/view the trigger applies to */
int foreach, /* One of TK_ROW or TK_STATEMENT */ int foreach, /* One of TK_ROW or TK_STATEMENT */
Expr *pWhen, /* WHEN clause */ Expr *pWhen, /* WHEN clause */
TriggerStep *steps, /* The triggered program */ TriggerStep *pStepList, /* The triggered program */
char const *cc, /* The string data to make persistent */ char const *zData, /* The string data to make persistent */
int len int zDataLen
){ ){
Trigger *nt; Trigger *nt;
Table *tab; Table *tab;
@ -29,10 +40,10 @@ void sqliteCreateTrigger(
** 2. the table (or view) does exist. ** 2. the table (or view) does exist.
*/ */
{ {
char *tmp_str = sqliteStrNDup(nm->z, nm->n); char *tmp_str = sqliteStrNDup(pName->z, pName->n);
if( sqliteHashFind(&(pParse->db->trigHash), tmp_str, nm->n + 1) ){ if( sqliteHashFind(&(pParse->db->trigHash), tmp_str, pName->n + 1) ){
sqliteSetNString(&pParse->zErrMsg, "trigger ", -1, sqliteSetNString(&pParse->zErrMsg, "trigger ", -1,
nm->z, nm->n, " already exists", -1, 0); pName->z, pName->n, " already exists", -1, 0);
sqliteFree(tmp_str); sqliteFree(tmp_str);
pParse->nErr++; pParse->nErr++;
goto trigger_cleanup; goto trigger_cleanup;
@ -40,12 +51,12 @@ void sqliteCreateTrigger(
sqliteFree(tmp_str); sqliteFree(tmp_str);
} }
{ {
char *tmp_str = sqliteStrNDup(tbl->z, tbl->n); char *tmp_str = sqliteStrNDup(pTableName->z, pTableName->n);
tab = sqliteFindTable(pParse->db, tmp_str); tab = sqliteFindTable(pParse->db, tmp_str);
sqliteFree(tmp_str); sqliteFree(tmp_str);
if( !tab ){ if( !tab ){
sqliteSetNString(&pParse->zErrMsg, "no such table: ", -1, sqliteSetNString(&pParse->zErrMsg, "no such table: ", -1,
tbl->z, tbl->n, 0); pTableName->z, pTableName->n, 0);
pParse->nErr++; pParse->nErr++;
goto trigger_cleanup; goto trigger_cleanup;
} }
@ -53,18 +64,18 @@ void sqliteCreateTrigger(
/* Build the Trigger object */ /* Build the Trigger object */
nt = (Trigger*)sqliteMalloc(sizeof(Trigger)); nt = (Trigger*)sqliteMalloc(sizeof(Trigger));
nt->name = sqliteStrNDup(nm->z, nm->n); nt->name = sqliteStrNDup(pName->z, pName->n);
nt->table = sqliteStrNDup(tbl->z, tbl->n); nt->table = sqliteStrNDup(pTableName->z, pTableName->n);
nt->op = op; nt->op = op;
nt->tr_tm = tr_tm; nt->tr_tm = tr_tm;
nt->pWhen = pWhen; nt->pWhen = pWhen;
nt->pColumns = cols; nt->pColumns = pColumns;
nt->foreach = foreach; nt->foreach = foreach;
nt->step_list = steps; nt->step_list = pStepList;
nt->isCommit = 0; nt->isCommit = 0;
nt->strings = sqliteStrNDup(cc, len); nt->strings = sqliteStrNDup(zData, zDataLen);
offset = (int)(nt->strings - cc); offset = (int)(nt->strings - zData);
sqliteExprMoveStrings(nt->pWhen, offset); sqliteExprMoveStrings(nt->pWhen, offset);
@ -111,9 +122,9 @@ void sqliteCreateTrigger(
sqliteEndWriteOperation(pParse); sqliteEndWriteOperation(pParse);
} }
if (!pParse->explain) { if( !pParse->explain ){
/* Stick it in the hash-table */ /* Stick it in the hash-table */
sqliteHashInsert(&(pParse->db->trigHash), nt->name, nm->n + 1, nt); sqliteHashInsert(&(pParse->db->trigHash), nt->name, pName->n + 1, nt);
/* Attach it to the table object */ /* Attach it to the table object */
nt->pNext = tab->pTrigger; nt->pNext = tab->pTrigger;
@ -128,13 +139,13 @@ void sqliteCreateTrigger(
trigger_cleanup: trigger_cleanup:
sqliteIdListDelete(cols); sqliteIdListDelete(pColumns);
sqliteExprDelete(pWhen); sqliteExprDelete(pWhen);
{ {
TriggerStep * pp; TriggerStep * pp;
TriggerStep * nn; TriggerStep * nn;
pp = steps; pp = pStepList;
while (pp) { while (pp) {
nn = pp->pNext; nn = pp->pNext;
sqliteExprDelete(pp->pWhere); sqliteExprDelete(pp->pWhere);
@ -147,107 +158,121 @@ trigger_cleanup:
} }
} }
TriggerStep * TriggerStep *sqliteTriggerSelectStep(Select * pSelect)
sqliteTriggerSelectStep(Select * s)
{ {
TriggerStep * tt = sqliteMalloc(sizeof(TriggerStep)); TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep));
tt->op = TK_SELECT; pTriggerStep->op = TK_SELECT;
tt->pSelect = s; pTriggerStep->pSelect = pSelect;
tt->orconf = OE_Default; pTriggerStep->orconf = OE_Default;
return tt; return pTriggerStep;
} }
TriggerStep * TriggerStep *sqliteTriggerInsertStep(
sqliteTriggerInsertStep(Token * tbl, IdList * col, ExprList * val, Select * s, int orconf) Token *pTableName,
{ IdList *pColumn,
TriggerStep * tt = sqliteMalloc(sizeof(TriggerStep)); ExprList *pEList,
Select *pSelect,
int orconf
){
TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep));
assert(val == 0 || s == 0); assert(pEList == 0 || pSelect == 0);
assert(val != 0 || s != 0); assert(pEList != 0 || pSelect != 0);
tt->op = TK_INSERT; pTriggerStep->op = TK_INSERT;
tt->pSelect = s; pTriggerStep->pSelect = pSelect;
tt->target = *tbl; pTriggerStep->target = *pTableName;
tt->pIdList = col; pTriggerStep->pIdList = pColumn;
tt->pExprList = val; pTriggerStep->pExprList = pEList;
tt->orconf = orconf; pTriggerStep->orconf = orconf;
return tt; return pTriggerStep;
} }
TriggerStep * TriggerStep *sqliteTriggerUpdateStep(
sqliteTriggerUpdateStep(Token * tbl, ExprList * val, Expr * w, int orconf) Token *pTableName,
ExprList *pEList,
Expr *pWhere,
int orconf)
{ {
TriggerStep * tt = sqliteMalloc(sizeof(TriggerStep)); TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep));
tt->op = TK_UPDATE; pTriggerStep->op = TK_UPDATE;
tt->target = *tbl; pTriggerStep->target = *pTableName;
tt->pExprList = val; pTriggerStep->pExprList = pEList;
tt->pWhere = w; pTriggerStep->pWhere = pWhere;
tt->orconf = orconf; pTriggerStep->orconf = orconf;
return tt; return pTriggerStep;
} }
TriggerStep * TriggerStep *sqliteTriggerDeleteStep(Token *pTableName, Expr *pWhere)
sqliteTriggerDeleteStep(Token * tbl, Expr * w)
{ {
TriggerStep * tt = sqliteMalloc(sizeof(TriggerStep)); TriggerStep * pTriggerStep = sqliteMalloc(sizeof(TriggerStep));
tt->op = TK_DELETE; pTriggerStep->op = TK_DELETE;
tt->target = *tbl; pTriggerStep->target = *pTableName;
tt->pWhere = w; pTriggerStep->pWhere = pWhere;
tt->orconf = OE_Default; pTriggerStep->orconf = OE_Default;
return tt; return pTriggerStep;
} }
/*
/* This does a recursive delete of the trigger structure */ ** Recursively delete a Trigger structure
void sqliteDeleteTrigger(Trigger * tt) */
void sqliteDeleteTrigger(Trigger *pTrigger)
{ {
TriggerStep * ts, * tc; TriggerStep *pTriggerStep;
ts = tt->step_list;
while (ts) { pTriggerStep = pTrigger->step_list;
tc = ts; while (pTriggerStep) {
ts = ts->pNext; TriggerStep * pTmp = pTriggerStep;
pTriggerStep = pTriggerStep->pNext;
sqliteExprDelete(tc->pWhere); sqliteExprDelete(pTmp->pWhere);
sqliteExprListDelete(tc->pExprList); sqliteExprListDelete(pTmp->pExprList);
sqliteSelectDelete(tc->pSelect); sqliteSelectDelete(pTmp->pSelect);
sqliteIdListDelete(tc->pIdList); sqliteIdListDelete(pTmp->pIdList);
sqliteFree(tc); sqliteFree(pTmp);
} }
sqliteFree(tt->name); sqliteFree(pTrigger->name);
sqliteFree(tt->table); sqliteFree(pTrigger->table);
sqliteExprDelete(tt->pWhen); sqliteExprDelete(pTrigger->pWhen);
sqliteIdListDelete(tt->pColumns); sqliteIdListDelete(pTrigger->pColumns);
sqliteFree(tt->strings); sqliteFree(pTrigger->strings);
sqliteFree(tt); sqliteFree(pTrigger);
} }
/* /*
* "nested" is true if this is begin called as the result of a DROP TABLE * This function is called to drop a trigger from the database schema.
*
* This may be called directly from the parser, or from within
* sqliteDropTable(). In the latter case the "nested" argument is true.
*
* Note that this function does not delete the trigger entirely. Instead it
* removes it from the internal schema and places it in the trigDrop hash
* table. This is so that the trigger can be restored into the database schema
* if the transaction is rolled back.
*/ */
void sqliteDropTrigger(Parse *pParse, Token * trigname, int nested) void sqliteDropTrigger(Parse *pParse, Token *pName, int nested)
{ {
char * tmp_name; char *zName;
Trigger * trig; Trigger *pTrigger;
Table * tbl; Table *pTable;
tmp_name = sqliteStrNDup(trigname->z, trigname->n); zName = sqliteStrNDup(pName->z, pName->n);
/* ensure that the trigger being dropped exists */ /* ensure that the trigger being dropped exists */
trig = sqliteHashFind(&(pParse->db->trigHash), tmp_name, trigname->n + 1); pTrigger = sqliteHashFind(&(pParse->db->trigHash), zName, pName->n + 1);
if (!trig) { if( !pTrigger ){
sqliteSetNString(&pParse->zErrMsg, "no such trigger: ", -1, sqliteSetNString(&pParse->zErrMsg, "no such trigger: ", -1,
tmp_name, -1, 0); zName, -1, 0);
sqliteFree(tmp_name); sqliteFree(zName);
return; return;
} }
@ -256,16 +281,16 @@ void sqliteDropTrigger(Parse *pParse, Token * trigname, int nested)
* 1. Remove the trigger from its associated table structure * 1. Remove the trigger from its associated table structure
* 2. Move the trigger from the trigHash hash to trigDrop * 2. Move the trigger from the trigHash hash to trigDrop
*/ */
if (!pParse->explain) { if( !pParse->explain ){
/* 1 */ /* 1 */
tbl = sqliteFindTable(pParse->db, trig->table); pTable = sqliteFindTable(pParse->db, pTrigger->table);
assert(tbl); assert(pTable);
if (tbl->pTrigger == trig) if( pTable->pTrigger == pTrigger ){
tbl->pTrigger = trig->pNext; pTable->pTrigger = pTrigger->pNext;
else { } else {
Trigger * cc = tbl->pTrigger; Trigger *cc = pTable->pTrigger;
while (cc) { while( cc ){
if (cc->pNext == trig) { if( cc->pNext == pTrigger ){
cc->pNext = cc->pNext->pNext; cc->pNext = cc->pNext->pNext;
break; break;
} }
@ -275,15 +300,15 @@ void sqliteDropTrigger(Parse *pParse, Token * trigname, int nested)
} }
/* 2 */ /* 2 */
sqliteHashInsert(&(pParse->db->trigHash), tmp_name, sqliteHashInsert(&(pParse->db->trigHash), zName,
trigname->n + 1, NULL); pName->n + 1, NULL);
sqliteHashInsert(&(pParse->db->trigDrop), trig->name, sqliteHashInsert(&(pParse->db->trigDrop), pTrigger->name,
trigname->n + 1, trig); pName->n + 1, pTrigger);
} }
/* Unless this is a trigger on a TEMP TABLE, generate code to destroy the /* Unless this is a trigger on a TEMP TABLE, generate code to destroy the
* database record of the trigger */ * database record of the trigger */
if (!tbl->isTemp) { if( !pTable->isTemp ){
int base; int base;
static VdbeOp dropTrigger[] = { static VdbeOp dropTrigger[] = {
{ OP_OpenWrite, 0, 2, MASTER_NAME}, { OP_OpenWrite, 0, 2, MASTER_NAME},
@ -305,7 +330,7 @@ void sqliteDropTrigger(Parse *pParse, Token * trigname, int nested)
} }
base = sqliteVdbeAddOpList(pParse->pVdbe, base = sqliteVdbeAddOpList(pParse->pVdbe,
ArraySize(dropTrigger), dropTrigger); ArraySize(dropTrigger), dropTrigger);
sqliteVdbeChangeP3(pParse->pVdbe, base+2, tmp_name, 0); sqliteVdbeChangeP3(pParse->pVdbe, base+2, zName, 0);
if( !nested ){ if( !nested ){
sqliteChangeCookie(pParse->db); sqliteChangeCookie(pParse->db);
} }
@ -315,18 +340,18 @@ void sqliteDropTrigger(Parse *pParse, Token * trigname, int nested)
} }
} }
sqliteFree(tmp_name); sqliteFree(zName);
} }
static int checkColumnOverLap(IdList * ii, ExprList * ee) static int checkColumnOverLap(IdList * pIdList, ExprList * pEList)
{ {
int i, e; int i, e;
if (!ii) return 1; if (!pIdList) return 1;
if (!ee) return 1; if (!pEList) return 1;
for (i = 0; i < ii->nId; i++) for (i = 0; i < pIdList->nId; i++)
for (e = 0; e < ee->nExpr; e++) for (e = 0; e < pEList->nExpr; e++)
if (!sqliteStrICmp(ii->a[i].zName, ee->a[e].zName)) if (!sqliteStrICmp(pIdList->a[i].zName, pEList->a[e].zName))
return 1; return 1;
return 0; return 0;
@ -348,108 +373,126 @@ int always_code_trigger_setup = 0;
* found in the list specified as pTrigger. * found in the list specified as pTrigger.
*/ */
int sqliteTriggersExist( int sqliteTriggersExist(
Parse * pParse, Parse *pParse,
Trigger * pTrigger, Trigger *pTrigger,
int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
int tr_tm, /* one of TK_BEFORE, TK_AFTER */ int tr_tm, /* one of TK_BEFORE, TK_AFTER */
int foreach, /* one of TK_ROW or TK_STATEMENT */ int foreach, /* one of TK_ROW or TK_STATEMENT */
ExprList * pChanges) ExprList *pChanges)
{ {
Trigger * tt; Trigger * pTriggerCursor;
if (always_code_trigger_setup) return 1; if( always_code_trigger_setup ){
return 1;
}
tt = pTrigger; pTriggerCursor = pTrigger;
while (tt) { while( pTriggerCursor ){
if (tt->op == op && tt->tr_tm == tr_tm && tt->foreach == foreach && if( pTriggerCursor->op == op &&
checkColumnOverLap(tt->pColumns, pChanges)) { pTriggerCursor->tr_tm == tr_tm &&
pTriggerCursor->foreach == foreach &&
checkColumnOverLap(pTriggerCursor->pColumns, pChanges) ){
TriggerStack * ss; TriggerStack * ss;
ss = pParse->trigStack; ss = pParse->trigStack;
while (ss && ss->pTrigger != pTrigger) ss = ss->pNext; while (ss && ss->pTrigger != pTrigger) ss = ss->pNext;
if (!ss) return 1; if (!ss) return 1;
} }
tt = tt->pNext; pTriggerCursor = pTriggerCursor->pNext;
} }
return 0; return 0;
} }
static int codeTriggerProgram( static int codeTriggerProgram(
Parse *pParse, Parse *pParse,
TriggerStep * program, TriggerStep *pStepList,
int onError) int orconfin
{ ){
TriggerStep * step = program; TriggerStep * pTriggerStep = pStepList;
int orconf; int orconf;
while (step) { while( pTriggerStep ){
int saveNTab = pParse->nTab; int saveNTab = pParse->nTab;
orconf = (onError == OE_Default)?step->orconf:onError; orconf = (orconfin == OE_Default)?pTriggerStep->orconf:orconfin;
pParse->trigStack->orconf = orconf; pParse->trigStack->orconf = orconf;
switch(step->op) { switch( pTriggerStep->op ){
case TK_SELECT: { case TK_SELECT: {
int tmp_tbl = pParse->nTab++; int tmp_tbl = pParse->nTab++;
sqliteVdbeAddOp(pParse->pVdbe, OP_OpenTemp, tmp_tbl, 0); sqliteVdbeAddOp(pParse->pVdbe, OP_OpenTemp, tmp_tbl, 0);
sqliteVdbeAddOp(pParse->pVdbe, OP_KeyAsData, tmp_tbl, 1); sqliteVdbeAddOp(pParse->pVdbe, OP_KeyAsData, tmp_tbl, 1);
sqliteSelect(pParse, step->pSelect, sqliteSelect(pParse, pTriggerStep->pSelect, SRT_Union,
SRT_Union, tmp_tbl, 0, 0, 0); tmp_tbl, 0, 0, 0);
sqliteVdbeAddOp(pParse->pVdbe, OP_Close, tmp_tbl, 0); sqliteVdbeAddOp(pParse->pVdbe, OP_Close, tmp_tbl, 0);
pParse->nTab--; pParse->nTab--;
break; break;
} }
case TK_UPDATE: { case TK_UPDATE: {
sqliteVdbeAddOp(pParse->pVdbe, OP_PushList, 0, 0); sqliteVdbeAddOp(pParse->pVdbe, OP_PushList, 0, 0);
sqliteUpdate(pParse, &step->target, sqliteUpdate(pParse, &pTriggerStep->target,
sqliteExprListDup(step->pExprList), sqliteExprListDup(pTriggerStep->pExprList),
sqliteExprDup(step->pWhere), orconf); sqliteExprDup(pTriggerStep->pWhere), orconf);
sqliteVdbeAddOp(pParse->pVdbe, OP_PopList, 0, 0); sqliteVdbeAddOp(pParse->pVdbe, OP_PopList, 0, 0);
break; break;
} }
case TK_INSERT: { case TK_INSERT: {
sqliteInsert(pParse, &step->target, sqliteInsert(pParse, &pTriggerStep->target,
sqliteExprListDup(step->pExprList), sqliteExprListDup(pTriggerStep->pExprList),
sqliteSelectDup(step->pSelect), sqliteSelectDup(pTriggerStep->pSelect),
sqliteIdListDup(step->pIdList), orconf); sqliteIdListDup(pTriggerStep->pIdList), orconf);
break; break;
} }
case TK_DELETE: { case TK_DELETE: {
sqliteVdbeAddOp(pParse->pVdbe, OP_PushList, 0, 0); sqliteVdbeAddOp(pParse->pVdbe, OP_PushList, 0, 0);
sqliteDeleteFrom(pParse, &step->target, sqliteDeleteFrom(pParse, &pTriggerStep->target,
sqliteExprDup(step->pWhere) sqliteExprDup(pTriggerStep->pWhere));
); sqliteVdbeAddOp(pParse->pVdbe, OP_PopList, 0, 0);
sqliteVdbeAddOp(pParse->pVdbe, OP_PopList, 0, 0); break;
break; }
} default:
default: assert(0);
assert(0); }
} pParse->nTab = saveNTab;
pParse->nTab = saveNTab; pTriggerStep = pTriggerStep->pNext;
step = step->pNext; }
}
return 0; return 0;
} }
/*
** This is called to code FOR EACH ROW triggers.
**
** When the code that this function generates is executed, the following
** must be true:
** 1. NO vdbe cursors must be open.
** 2. If the triggers being coded are ON INSERT or ON UPDATE triggers, then
** a temporary vdbe cursor (index newIdx) must be open and pointing at
** a row containing values to be substituted for new.* expressions in the
** trigger program(s).
** 3. If the triggers being coded are ON DELETE or ON UPDATE triggers, then
** a temporary vdbe cursor (index oldIdx) must be open and pointing at
** a row containing values to be substituted for old.* expressions in the
** trigger program(s).
**
*/
int sqliteCodeRowTrigger( int sqliteCodeRowTrigger(
Parse * pParse, /* Parse context */ Parse *pParse, /* Parse context */
int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
ExprList * changes, /* Changes list for any UPDATE OF triggers */ ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
int tr_tm, /* One of TK_BEFORE, TK_AFTER */ int tr_tm, /* One of TK_BEFORE, TK_AFTER */
Table * tbl, /* The table to code triggers from */ Table *pTab, /* The table to code triggers from */
int newTable, /* The indice of the "new" row to access */ int newIdx, /* The indice of the "new" row to access */
int oldTable, /* The indice of the "old" row to access */ int oldIdx, /* The indice of the "old" row to access */
int onError) /* ON CONFLICT policy */ int orconf) /* ON CONFLICT policy */
{ {
Trigger * pTrigger; Trigger * pTrigger;
TriggerStack * pTriggerStack; TriggerStack * pTriggerStack;
assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE); assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);
assert(tr_tm == TK_BEFORE || tr_tm == TK_AFTER); assert(tr_tm == TK_BEFORE || tr_tm == TK_AFTER);
assert(newTable != -1 || oldTable != -1); assert(newIdx != -1 || oldIdx != -1);
pTrigger = tbl->pTrigger; pTrigger = pTab->pTrigger;
while (pTrigger) { while (pTrigger) {
int fire_this = 0; int fire_this = 0;
@ -463,7 +506,7 @@ int sqliteCodeRowTrigger(
pTriggerStack = pTriggerStack->pNext; pTriggerStack = pTriggerStack->pNext;
} }
if (op == TK_UPDATE && pTrigger->pColumns && if (op == TK_UPDATE && pTrigger->pColumns &&
!checkColumnOverLap(pTrigger->pColumns, changes)) !checkColumnOverLap(pTrigger->pColumns, pChanges))
fire_this = 0; fire_this = 0;
} }
@ -478,9 +521,9 @@ int sqliteCodeRowTrigger(
/* Push an entry on to the trigger stack */ /* Push an entry on to the trigger stack */
pTriggerStack = sqliteMalloc(sizeof(TriggerStack)); pTriggerStack = sqliteMalloc(sizeof(TriggerStack));
pTriggerStack->pTrigger = pTrigger; pTriggerStack->pTrigger = pTrigger;
pTriggerStack->newIdx = newTable; pTriggerStack->newIdx = newIdx;
pTriggerStack->oldIdx = oldTable; pTriggerStack->oldIdx = oldIdx;
pTriggerStack->pTab = tbl; pTriggerStack->pTab = pTab;
pTriggerStack->pNext = pParse->trigStack; pTriggerStack->pNext = pParse->trigStack;
pParse->trigStack = pTriggerStack; pParse->trigStack = pTriggerStack;
@ -496,7 +539,7 @@ int sqliteCodeRowTrigger(
sqliteExprIfFalse(pParse, whenExpr, endTrigger); sqliteExprIfFalse(pParse, whenExpr, endTrigger);
sqliteExprDelete(whenExpr); sqliteExprDelete(whenExpr);
codeTriggerProgram(pParse, pTrigger->step_list, onError); codeTriggerProgram(pParse, pTrigger->step_list, orconf);
/* Pop the entry off the trigger stack */ /* Pop the entry off the trigger stack */
pParse->trigStack = pParse->trigStack->pNext; pParse->trigStack = pParse->trigStack->pNext;
@ -511,11 +554,23 @@ int sqliteCodeRowTrigger(
} }
/* /*
* Handle UPDATE and DELETE triggers on views * This function is called to code ON UPDATE and ON DELETE triggers on
* views.
*
* This function deletes the data pointed at by the pWhere and pChanges
* arguments before it completes.
*/ */
void sqliteViewTriggers(Parse *pParse, Table *pTab, void sqliteViewTriggers(
Expr * pWhere, int onError, ExprList * pChanges) Parse *pParse,
{ Table *pTab, /* The view to code triggers on */
Expr *pWhere, /* The WHERE clause of the statement causing triggers*/
int orconf, /* The ON CONFLICT policy specified as part of the
statement causing these triggers */
ExprList *pChanges /* If this is an statement causing triggers to fire
is an UPDATE, then this list holds the columns
to update and the expressions to update them to.
See comments for sqliteUpdate(). */
){
int oldIdx = -1; int oldIdx = -1;
int newIdx = -1; int newIdx = -1;
int *aXRef = 0; int *aXRef = 0;
@ -551,13 +606,13 @@ void sqliteViewTriggers(Parse *pParse, Table *pTab,
/* Allocate temp tables */ /* Allocate temp tables */
oldIdx = pParse->nTab++; oldIdx = pParse->nTab++;
sqliteVdbeAddOp(v, OP_OpenTemp, oldIdx, 0); sqliteVdbeAddOp(v, OP_OpenTemp, oldIdx, 0);
if (pChanges) { if( pChanges ){
newIdx = pParse->nTab++; newIdx = pParse->nTab++;
sqliteVdbeAddOp(v, OP_OpenTemp, newIdx, 0); sqliteVdbeAddOp(v, OP_OpenTemp, newIdx, 0);
} }
/* Snapshot the view */ /* Snapshot the view */
if (sqliteSelect(pParse, &theSelect, SRT_Table, oldIdx, 0, 0, 0)) { if( sqliteSelect(pParse, &theSelect, SRT_Table, oldIdx, 0, 0, 0) ){
goto trigger_cleanup; goto trigger_cleanup;
} }
@ -569,13 +624,14 @@ void sqliteViewTriggers(Parse *pParse, Table *pTab,
startOfLoop = sqliteVdbeCurrentAddr(v); startOfLoop = sqliteVdbeCurrentAddr(v);
/* Build the updated row if required */ /* Build the updated row if required */
if (pChanges) { if( pChanges ){
int ii, jj; int ii, jj;
aXRef = sqliteMalloc( sizeof(int) * pTab->nCol ); aXRef = sqliteMalloc( sizeof(int) * pTab->nCol );
if( aXRef==0 ) goto trigger_cleanup; if( aXRef==0 ) goto trigger_cleanup;
for (ii = 0; ii < pTab->nCol; ii++) for(ii = 0; ii < pTab->nCol; ii++){
aXRef[ii] = -1; aXRef[ii] = -1;
}
for(ii=0; ii<pChanges->nExpr; ii++){ for(ii=0; ii<pChanges->nExpr; ii++){
int jj; int jj;
@ -602,25 +658,27 @@ void sqliteViewTriggers(Parse *pParse, Table *pTab,
sqliteVdbeAddOp(v, OP_Integer, 13, 0); sqliteVdbeAddOp(v, OP_Integer, 13, 0);
for (ii = 0; ii < pTab->nCol; ii++) for(ii = 0; ii<pTab->nCol; ii++){
if( aXRef[ii] < 0 ) if( aXRef[ii] < 0 ){
sqliteVdbeAddOp(v, OP_Column, oldIdx, ii); sqliteVdbeAddOp(v, OP_Column, oldIdx, ii);
else } else {
sqliteExprCode(pParse, pChanges->a[aXRef[ii]].pExpr); sqliteExprCode(pParse, pChanges->a[aXRef[ii]].pExpr);
}
}
sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0);
sqliteVdbeAddOp(v, OP_Rewind, newIdx, 0); sqliteVdbeAddOp(v, OP_Rewind, newIdx, 0);
sqliteCodeRowTrigger(pParse, TK_UPDATE, pChanges, TK_BEFORE, sqliteCodeRowTrigger(pParse, TK_UPDATE, pChanges, TK_BEFORE,
pTab, newIdx, oldIdx, onError); pTab, newIdx, oldIdx, orconf);
sqliteCodeRowTrigger(pParse, TK_UPDATE, pChanges, TK_AFTER, sqliteCodeRowTrigger(pParse, TK_UPDATE, pChanges, TK_AFTER,
pTab, newIdx, oldIdx, onError); pTab, newIdx, oldIdx, orconf);
} else { } else {
sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_BEFORE, pTab, -1, oldIdx, sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_BEFORE, pTab, -1, oldIdx,
onError); orconf);
sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_AFTER, pTab, -1, oldIdx, sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_AFTER, pTab, -1, oldIdx,
onError); orconf);
} }
sqliteVdbeAddOp(v, OP_Next, oldIdx, startOfLoop); sqliteVdbeAddOp(v, OP_Next, oldIdx, startOfLoop);