danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 1 | /* |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 2 | ** |
| 3 | ** The author disclaims copyright to this source code. In place of |
| 4 | ** a legal notice, here is a blessing: |
| 5 | ** |
| 6 | ** May you do good and not evil. |
| 7 | ** May you find forgiveness for yourself and forgive others. |
| 8 | ** May you share freely, never taking more than you give. |
| 9 | ** |
| 10 | ************************************************************************* |
drh | c81c11f | 2009-11-10 01:30:52 +0000 | [diff] [blame] | 11 | ** This file contains the implementation for TRIGGERs |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 12 | */ |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 13 | #include "sqliteInt.h" |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 14 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 15 | #ifndef SQLITE_OMIT_TRIGGER |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 16 | /* |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 17 | ** Delete a linked list of TriggerStep structures. |
| 18 | */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 19 | void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){ |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 20 | while( pTriggerStep ){ |
| 21 | TriggerStep * pTmp = pTriggerStep; |
| 22 | pTriggerStep = pTriggerStep->pNext; |
| 23 | |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 24 | sqlite3ExprDelete(db, pTmp->pWhere); |
| 25 | sqlite3ExprListDelete(db, pTmp->pExprList); |
| 26 | sqlite3SelectDelete(db, pTmp->pSelect); |
| 27 | sqlite3IdListDelete(db, pTmp->pIdList); |
drh | 46d2e5c | 2018-04-12 13:15:43 +0000 | [diff] [blame] | 28 | sqlite3UpsertDelete(db, pTmp->pUpsert); |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 29 | sqlite3DbFree(db, pTmp->zSpan); |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 30 | |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 31 | sqlite3DbFree(db, pTmp); |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 32 | } |
| 33 | } |
| 34 | |
| 35 | /* |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 36 | ** Given table pTab, return a list of all the triggers attached to |
| 37 | ** the table. The list is connected by Trigger.pNext pointers. |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 38 | ** |
| 39 | ** All of the triggers on pTab that are in the same database as pTab |
| 40 | ** are already attached to pTab->pTrigger. But there might be additional |
| 41 | ** triggers on pTab in the TEMP schema. This routine prepends all |
| 42 | ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list |
| 43 | ** and returns the combined list. |
| 44 | ** |
| 45 | ** To state it another way: This routine returns a list of all triggers |
| 46 | ** that fire off of pTab. The list will include any TEMP triggers on |
| 47 | ** pTab as well as the triggers lised in pTab->pTrigger. |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 48 | */ |
| 49 | Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){ |
| 50 | Schema * const pTmpSchema = pParse->db->aDb[1].pSchema; |
| 51 | Trigger *pList = 0; /* List of triggers to return */ |
| 52 | |
dan | d66c830 | 2009-09-28 14:49:01 +0000 | [diff] [blame] | 53 | if( pParse->disableTriggers ){ |
| 54 | return 0; |
| 55 | } |
| 56 | |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 57 | if( pTmpSchema!=pTab->pSchema ){ |
| 58 | HashElem *p; |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 59 | assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) ); |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 60 | for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){ |
| 61 | Trigger *pTrig = (Trigger *)sqliteHashData(p); |
| 62 | if( pTrig->pTabSchema==pTab->pSchema |
| 63 | && 0==sqlite3StrICmp(pTrig->table, pTab->zName) |
| 64 | ){ |
| 65 | pTrig->pNext = (pList ? pList : pTab->pTrigger); |
| 66 | pList = pTrig; |
| 67 | } |
| 68 | } |
| 69 | } |
| 70 | |
| 71 | return (pList ? pList : pTab->pTrigger); |
| 72 | } |
| 73 | |
| 74 | /* |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 75 | ** This is called by the parser when it sees a CREATE TRIGGER statement |
| 76 | ** up to the point of the BEGIN before the trigger actions. A Trigger |
| 77 | ** structure is generated based on the information available and stored |
| 78 | ** in pParse->pNewTrigger. After the trigger actions have been parsed, the |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 79 | ** sqlite3FinishTrigger() function is called to complete the trigger |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 80 | ** construction process. |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 81 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 82 | void sqlite3BeginTrigger( |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 83 | Parse *pParse, /* The parse context of the CREATE TRIGGER statement */ |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 84 | Token *pName1, /* The name of the trigger */ |
| 85 | Token *pName2, /* The name of the trigger */ |
drh | 5cf590c | 2003-04-24 01:45:04 +0000 | [diff] [blame] | 86 | int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */ |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 87 | int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 88 | IdList *pColumns, /* column list if this is an UPDATE OF trigger */ |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 89 | SrcList *pTableName,/* The name of the table/view the trigger applies to */ |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 90 | Expr *pWhen, /* WHEN clause */ |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 91 | int isTemp, /* True if the TEMPORARY keyword is present */ |
| 92 | int noErr /* Suppress errors if the trigger already exists */ |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 93 | ){ |
drh | 3d5f74b | 2009-08-06 17:43:31 +0000 | [diff] [blame] | 94 | Trigger *pTrigger = 0; /* The new trigger */ |
| 95 | Table *pTab; /* Table that the trigger fires off of */ |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 96 | char *zName = 0; /* Name of the trigger */ |
drh | 3d5f74b | 2009-08-06 17:43:31 +0000 | [diff] [blame] | 97 | sqlite3 *db = pParse->db; /* The database connection */ |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 98 | int iDb; /* The database to store the trigger in */ |
| 99 | Token *pName; /* The unqualified db name */ |
drh | 3d5f74b | 2009-08-06 17:43:31 +0000 | [diff] [blame] | 100 | DbFixer sFix; /* State vector for the DB fixer */ |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 101 | |
drh | 43617e9 | 2006-03-06 20:55:46 +0000 | [diff] [blame] | 102 | assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */ |
| 103 | assert( pName2!=0 ); |
drh | aa78bec | 2008-12-09 03:55:14 +0000 | [diff] [blame] | 104 | assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE ); |
| 105 | assert( op>0 && op<0xff ); |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 106 | if( isTemp ){ |
| 107 | /* If TEMP was specified, then the trigger name may not be qualified. */ |
drh | 43617e9 | 2006-03-06 20:55:46 +0000 | [diff] [blame] | 108 | if( pName2->n>0 ){ |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 109 | sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name"); |
| 110 | goto trigger_cleanup; |
| 111 | } |
| 112 | iDb = 1; |
| 113 | pName = pName1; |
| 114 | }else{ |
mistachkin | d557843 | 2012-08-25 10:01:29 +0000 | [diff] [blame] | 115 | /* Figure out the db that the trigger will be created in */ |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 116 | iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); |
| 117 | if( iDb<0 ){ |
| 118 | goto trigger_cleanup; |
| 119 | } |
| 120 | } |
drh | 6fea83e | 2011-07-01 13:50:44 +0000 | [diff] [blame] | 121 | if( !pTableName || db->mallocFailed ){ |
| 122 | goto trigger_cleanup; |
| 123 | } |
| 124 | |
| 125 | /* A long-standing parser bug is that this syntax was allowed: |
| 126 | ** |
| 127 | ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab .... |
| 128 | ** ^^^^^^^^ |
| 129 | ** |
| 130 | ** To maintain backwards compatibility, ignore the database |
peter.d.reid | 60ec914 | 2014-09-06 16:39:46 +0000 | [diff] [blame] | 131 | ** name on pTableName if we are reparsing out of SQLITE_MASTER. |
drh | 6fea83e | 2011-07-01 13:50:44 +0000 | [diff] [blame] | 132 | */ |
| 133 | if( db->init.busy && iDb!=1 ){ |
| 134 | sqlite3DbFree(db, pTableName->a[0].zDatabase); |
| 135 | pTableName->a[0].zDatabase = 0; |
| 136 | } |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 137 | |
| 138 | /* If the trigger name was unqualified, and the table is a temp table, |
| 139 | ** then set iDb to 1 to create the trigger in the temporary database. |
| 140 | ** If sqlite3SrcListLookup() returns 0, indicating the table does not |
| 141 | ** exist, the error is caught by the block below. |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 142 | */ |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 143 | pTab = sqlite3SrcListLookup(pParse, pTableName); |
drh | 622d288 | 2010-02-15 16:54:55 +0000 | [diff] [blame] | 144 | if( db->init.busy==0 && pName2->n==0 && pTab |
| 145 | && pTab->pSchema==db->aDb[1].pSchema ){ |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 146 | iDb = 1; |
| 147 | } |
| 148 | |
| 149 | /* Ensure the table name matches database name and that the table exists */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 150 | if( db->mallocFailed ) goto trigger_cleanup; |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 151 | assert( pTableName->nSrc==1 ); |
drh | d100f69 | 2013-10-03 15:39:44 +0000 | [diff] [blame] | 152 | sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName); |
| 153 | if( sqlite3FixSrcList(&sFix, pTableName) ){ |
drh | 4312db5 | 2003-06-03 01:47:11 +0000 | [diff] [blame] | 154 | goto trigger_cleanup; |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 155 | } |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 156 | pTab = sqlite3SrcListLookup(pParse, pTableName); |
| 157 | if( !pTab ){ |
| 158 | /* The table does not exist. */ |
drh | 3d5f74b | 2009-08-06 17:43:31 +0000 | [diff] [blame] | 159 | if( db->init.iDb==1 ){ |
| 160 | /* Ticket #3810. |
| 161 | ** Normally, whenever a table is dropped, all associated triggers are |
| 162 | ** dropped too. But if a TEMP trigger is created on a non-TEMP table |
| 163 | ** and the table is dropped by a different database connection, the |
| 164 | ** trigger is not visible to the database connection that does the |
| 165 | ** drop so the trigger cannot be dropped. This results in an |
| 166 | ** "orphaned trigger" - a trigger whose associated table is missing. |
| 167 | */ |
| 168 | db->init.orphanTrigger = 1; |
| 169 | } |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 170 | goto trigger_cleanup; |
| 171 | } |
drh | 4cbdda9 | 2006-06-14 19:00:20 +0000 | [diff] [blame] | 172 | if( IsVirtual(pTab) ){ |
| 173 | sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables"); |
| 174 | goto trigger_cleanup; |
| 175 | } |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 176 | |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 177 | /* Check that the trigger name is not reserved and that no trigger of the |
| 178 | ** specified name exists */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 179 | zName = sqlite3NameFromToken(db, pName); |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 180 | if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ |
| 181 | goto trigger_cleanup; |
| 182 | } |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 183 | assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
drh | acbcb7e | 2014-08-21 20:26:37 +0000 | [diff] [blame] | 184 | if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){ |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 185 | if( !noErr ){ |
| 186 | sqlite3ErrorMsg(pParse, "trigger %T already exists", pName); |
dan | 7687c83 | 2011-04-09 15:39:02 +0000 | [diff] [blame] | 187 | }else{ |
| 188 | assert( !db->init.busy ); |
| 189 | sqlite3CodeVerifySchema(pParse, iDb); |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 190 | } |
drh | e5f9c64 | 2003-01-13 23:27:31 +0000 | [diff] [blame] | 191 | goto trigger_cleanup; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 192 | } |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 193 | |
| 194 | /* Do not create a trigger on a system table */ |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 195 | if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 196 | sqlite3ErrorMsg(pParse, "cannot create trigger on system table"); |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 197 | goto trigger_cleanup; |
danielk1977 | d702fcc | 2002-05-26 23:24:40 +0000 | [diff] [blame] | 198 | } |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 199 | |
| 200 | /* INSTEAD of triggers are only for views and views only support INSTEAD |
| 201 | ** of triggers. |
| 202 | */ |
| 203 | if( pTab->pSelect && tr_tm!=TK_INSTEAD ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 204 | sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", |
drh | da93d23 | 2003-03-31 02:12:46 +0000 | [diff] [blame] | 205 | (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0); |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 206 | goto trigger_cleanup; |
| 207 | } |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 208 | if( !pTab->pSelect && tr_tm==TK_INSTEAD ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 209 | sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF" |
drh | da93d23 | 2003-03-31 02:12:46 +0000 | [diff] [blame] | 210 | " trigger on table: %S", pTableName, 0); |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 211 | goto trigger_cleanup; |
| 212 | } |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 213 | |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 214 | #ifndef SQLITE_OMIT_AUTHORIZATION |
| 215 | { |
drh | a0daa75 | 2016-09-16 11:53:10 +0000 | [diff] [blame] | 216 | int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 217 | int code = SQLITE_CREATE_TRIGGER; |
drh | 69c3382 | 2016-08-18 14:33:11 +0000 | [diff] [blame] | 218 | const char *zDb = db->aDb[iTabDb].zDbSName; |
| 219 | const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb; |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 220 | if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER; |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 221 | if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){ |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 222 | goto trigger_cleanup; |
| 223 | } |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 224 | if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){ |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 225 | goto trigger_cleanup; |
| 226 | } |
| 227 | } |
| 228 | #endif |
danielk1977 | d702fcc | 2002-05-26 23:24:40 +0000 | [diff] [blame] | 229 | |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 230 | /* INSTEAD OF triggers can only appear on views and BEFORE triggers |
drh | 5cf590c | 2003-04-24 01:45:04 +0000 | [diff] [blame] | 231 | ** cannot appear on views. So we might as well translate every |
| 232 | ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code |
| 233 | ** elsewhere. |
| 234 | */ |
danielk1977 | d702fcc | 2002-05-26 23:24:40 +0000 | [diff] [blame] | 235 | if (tr_tm == TK_INSTEAD){ |
| 236 | tr_tm = TK_BEFORE; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | /* Build the Trigger object */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 240 | pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger)); |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 241 | if( pTrigger==0 ) goto trigger_cleanup; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 242 | pTrigger->zName = zName; |
drh | e5f9c64 | 2003-01-13 23:27:31 +0000 | [diff] [blame] | 243 | zName = 0; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 244 | pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName); |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 245 | pTrigger->pSchema = db->aDb[iDb].pSchema; |
danielk1977 | aaf2268 | 2006-01-06 15:03:48 +0000 | [diff] [blame] | 246 | pTrigger->pTabSchema = pTab->pSchema; |
drh | aa78bec | 2008-12-09 03:55:14 +0000 | [diff] [blame] | 247 | pTrigger->op = (u8)op; |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 248 | pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER; |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 249 | pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 250 | pTrigger->pColumns = sqlite3IdListDup(db, pColumns); |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 251 | assert( pParse->pNewTrigger==0 ); |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 252 | pParse->pNewTrigger = pTrigger; |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 253 | |
| 254 | trigger_cleanup: |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 255 | sqlite3DbFree(db, zName); |
| 256 | sqlite3SrcListDelete(db, pTableName); |
| 257 | sqlite3IdListDelete(db, pColumns); |
| 258 | sqlite3ExprDelete(db, pWhen); |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 259 | if( !pParse->pNewTrigger ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 260 | sqlite3DeleteTrigger(db, pTrigger); |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 261 | }else{ |
| 262 | assert( pParse->pNewTrigger==pTrigger ); |
| 263 | } |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 264 | } |
| 265 | |
| 266 | /* |
| 267 | ** This routine is called after all of the trigger actions have been parsed |
| 268 | ** in order to complete the process of building the trigger. |
| 269 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 270 | void sqlite3FinishTrigger( |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 271 | Parse *pParse, /* Parser context */ |
| 272 | TriggerStep *pStepList, /* The triggered program */ |
| 273 | Token *pAll /* Token that describes the complete CREATE TRIGGER */ |
| 274 | ){ |
drh | a8c62df | 2010-02-15 15:47:18 +0000 | [diff] [blame] | 275 | Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */ |
| 276 | char *zName; /* Name of trigger */ |
| 277 | sqlite3 *db = pParse->db; /* The database */ |
| 278 | DbFixer sFix; /* Fixer object */ |
| 279 | int iDb; /* Database containing the trigger */ |
| 280 | Token nameToken; /* Trigger name for error reporting */ |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 281 | |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 282 | pParse->pNewTrigger = 0; |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 283 | if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 284 | zName = pTrig->zName; |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 285 | iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); |
danielk1977 | bfb9e35 | 2005-01-24 13:03:32 +0000 | [diff] [blame] | 286 | pTrig->step_list = pStepList; |
drh | a69d916 | 2003-04-17 22:57:53 +0000 | [diff] [blame] | 287 | while( pStepList ){ |
danielk1977 | bfb9e35 | 2005-01-24 13:03:32 +0000 | [diff] [blame] | 288 | pStepList->pTrig = pTrig; |
drh | a69d916 | 2003-04-17 22:57:53 +0000 | [diff] [blame] | 289 | pStepList = pStepList->pNext; |
| 290 | } |
drh | 40aced5 | 2016-01-22 17:48:09 +0000 | [diff] [blame] | 291 | sqlite3TokenInit(&nameToken, pTrig->zName); |
drh | d100f69 | 2013-10-03 15:39:44 +0000 | [diff] [blame] | 292 | sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken); |
| 293 | if( sqlite3FixTriggerStep(&sFix, pTrig->step_list) |
dan | 46539d7 | 2013-10-03 12:29:38 +0000 | [diff] [blame] | 294 | || sqlite3FixExpr(&sFix, pTrig->pWhen) |
drh | d100f69 | 2013-10-03 15:39:44 +0000 | [diff] [blame] | 295 | ){ |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 296 | goto triggerfinish_cleanup; |
| 297 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 298 | |
drh | a8c62df | 2010-02-15 15:47:18 +0000 | [diff] [blame] | 299 | /* if we are not initializing, |
drh | 9adf9ac | 2002-05-15 11:44:13 +0000 | [diff] [blame] | 300 | ** build the sqlite_master entry |
| 301 | */ |
drh | 1d85d93 | 2004-02-14 23:05:52 +0000 | [diff] [blame] | 302 | if( !db->init.busy ){ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 303 | Vdbe *v; |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 304 | char *z; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 305 | |
| 306 | /* Make an entry in the sqlite_master table */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 307 | v = sqlite3GetVdbe(pParse); |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 308 | if( v==0 ) goto triggerfinish_cleanup; |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 309 | sqlite3BeginWriteOperation(pParse, 0, iDb); |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 310 | z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n); |
drh | d96cc6f | 2017-06-08 14:35:21 +0000 | [diff] [blame] | 311 | testcase( z==0 ); |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 312 | sqlite3NestedParse(pParse, |
| 313 | "INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')", |
drh | e0a04a3 | 2016-12-16 01:00:21 +0000 | [diff] [blame] | 314 | db->aDb[iDb].zDbSName, MASTER_NAME, zName, |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 315 | pTrig->table, z); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 316 | sqlite3DbFree(db, z); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 317 | sqlite3ChangeCookie(pParse, iDb); |
drh | 5d9c9da | 2011-06-03 20:11:17 +0000 | [diff] [blame] | 318 | sqlite3VdbeAddParseSchemaOp(v, iDb, |
| 319 | sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName)); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 320 | } |
| 321 | |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 322 | if( db->init.busy ){ |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 323 | Trigger *pLink = pTrig; |
| 324 | Hash *pHash = &db->aDb[iDb].pSchema->trigHash; |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 325 | assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
drh | acbcb7e | 2014-08-21 20:26:37 +0000 | [diff] [blame] | 326 | pTrig = sqlite3HashInsert(pHash, zName, pTrig); |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 327 | if( pTrig ){ |
drh | 4a642b6 | 2016-02-05 01:55:27 +0000 | [diff] [blame] | 328 | sqlite3OomFault(db); |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 329 | }else if( pLink->pSchema==pLink->pTabSchema ){ |
| 330 | Table *pTab; |
drh | acbcb7e | 2014-08-21 20:26:37 +0000 | [diff] [blame] | 331 | pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table); |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 332 | assert( pTab!=0 ); |
| 333 | pLink->pNext = pTab->pTrigger; |
| 334 | pTab->pTrigger = pLink; |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 335 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 336 | } |
| 337 | |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 338 | triggerfinish_cleanup: |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 339 | sqlite3DeleteTrigger(db, pTrig); |
danielk1977 | bfb9e35 | 2005-01-24 13:03:32 +0000 | [diff] [blame] | 340 | assert( !pParse->pNewTrigger ); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 341 | sqlite3DeleteTriggerStep(db, pStepList); |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 342 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 343 | |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 344 | /* |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 345 | ** Duplicate a range of text from an SQL statement, then convert all |
| 346 | ** whitespace characters into ordinary space characters. |
| 347 | */ |
| 348 | static char *triggerSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){ |
| 349 | char *z = sqlite3DbSpanDup(db, zStart, zEnd); |
| 350 | int i; |
| 351 | if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' '; |
| 352 | return z; |
| 353 | } |
| 354 | |
| 355 | /* |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 356 | ** Turn a SELECT statement (that the pSelect parameter points to) into |
| 357 | ** a trigger step. Return a pointer to a TriggerStep structure. |
| 358 | ** |
| 359 | ** The parser calls this routine when it finds a SELECT statement in |
| 360 | ** body of a TRIGGER. |
| 361 | */ |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 362 | TriggerStep *sqlite3TriggerSelectStep( |
| 363 | sqlite3 *db, /* Database connection */ |
| 364 | Select *pSelect, /* The SELECT statement */ |
| 365 | const char *zStart, /* Start of SQL text */ |
| 366 | const char *zEnd /* End of SQL text */ |
| 367 | ){ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 368 | TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep)); |
danielk1977 | 2e588c7 | 2005-12-09 14:25:08 +0000 | [diff] [blame] | 369 | if( pTriggerStep==0 ) { |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 370 | sqlite3SelectDelete(db, pSelect); |
danielk1977 | 2e588c7 | 2005-12-09 14:25:08 +0000 | [diff] [blame] | 371 | return 0; |
| 372 | } |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 373 | pTriggerStep->op = TK_SELECT; |
| 374 | pTriggerStep->pSelect = pSelect; |
| 375 | pTriggerStep->orconf = OE_Default; |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 376 | pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 377 | return pTriggerStep; |
| 378 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 379 | |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 380 | /* |
| 381 | ** Allocate space to hold a new trigger step. The allocated space |
| 382 | ** holds both the TriggerStep object and the TriggerStep.target.z string. |
| 383 | ** |
| 384 | ** If an OOM error occurs, NULL is returned and db->mallocFailed is set. |
| 385 | */ |
| 386 | static TriggerStep *triggerStepAllocate( |
| 387 | sqlite3 *db, /* Database connection */ |
shane | 5eff7cf | 2009-08-10 03:57:58 +0000 | [diff] [blame] | 388 | u8 op, /* Trigger opcode */ |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 389 | Token *pName, /* The target name */ |
| 390 | const char *zStart, /* Start of SQL text */ |
| 391 | const char *zEnd /* End of SQL text */ |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 392 | ){ |
| 393 | TriggerStep *pTriggerStep; |
| 394 | |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 395 | pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 396 | if( pTriggerStep ){ |
| 397 | char *z = (char*)&pTriggerStep[1]; |
| 398 | memcpy(z, pName->z, pName->n); |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 399 | sqlite3Dequote(z); |
| 400 | pTriggerStep->zTarget = z; |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 401 | pTriggerStep->op = op; |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 402 | pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 403 | } |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 404 | return pTriggerStep; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 405 | } |
| 406 | |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 407 | /* |
| 408 | ** Build a trigger step out of an INSERT statement. Return a pointer |
| 409 | ** to the new trigger step. |
| 410 | ** |
| 411 | ** The parser calls this routine when it sees an INSERT inside the |
| 412 | ** body of a trigger. |
| 413 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 414 | TriggerStep *sqlite3TriggerInsertStep( |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 415 | sqlite3 *db, /* The database connection */ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 416 | Token *pTableName, /* Name of the table into which we insert */ |
| 417 | IdList *pColumn, /* List of columns in pTableName to insert into */ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 418 | Select *pSelect, /* A SELECT statement that supplies values */ |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 419 | u8 orconf, /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */ |
drh | 46d2e5c | 2018-04-12 13:15:43 +0000 | [diff] [blame] | 420 | Upsert *pUpsert, /* ON CONFLICT clauses for upsert */ |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 421 | const char *zStart, /* Start of SQL text */ |
| 422 | const char *zEnd /* End of SQL text */ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 423 | ){ |
drh | f3a65f7 | 2007-08-22 20:18:21 +0000 | [diff] [blame] | 424 | TriggerStep *pTriggerStep; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 425 | |
drh | 75593d9 | 2014-01-10 20:46:55 +0000 | [diff] [blame] | 426 | assert(pSelect != 0 || db->mallocFailed); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 427 | |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 428 | pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName, zStart, zEnd); |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 429 | if( pTriggerStep ){ |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 430 | pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 431 | pTriggerStep->pIdList = pColumn; |
drh | 46d2e5c | 2018-04-12 13:15:43 +0000 | [diff] [blame] | 432 | pTriggerStep->pUpsert = pUpsert; |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 433 | pTriggerStep->orconf = orconf; |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 434 | }else{ |
drh | 9916048 | 2018-04-18 01:34:39 +0000 | [diff] [blame] | 435 | testcase( pColumn ); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 436 | sqlite3IdListDelete(db, pColumn); |
drh | 9916048 | 2018-04-18 01:34:39 +0000 | [diff] [blame] | 437 | testcase( pUpsert ); |
drh | 46d2e5c | 2018-04-12 13:15:43 +0000 | [diff] [blame] | 438 | sqlite3UpsertDelete(db, pUpsert); |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 439 | } |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 440 | sqlite3SelectDelete(db, pSelect); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 441 | |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 442 | return pTriggerStep; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 443 | } |
| 444 | |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 445 | /* |
| 446 | ** Construct a trigger step that implements an UPDATE statement and return |
| 447 | ** a pointer to that trigger step. The parser calls this routine when it |
| 448 | ** sees an UPDATE statement inside the body of a CREATE TRIGGER. |
| 449 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 450 | TriggerStep *sqlite3TriggerUpdateStep( |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 451 | sqlite3 *db, /* The database connection */ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 452 | Token *pTableName, /* Name of the table to be updated */ |
| 453 | ExprList *pEList, /* The SET clause: list of column and new values */ |
| 454 | Expr *pWhere, /* The WHERE clause */ |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 455 | u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ |
| 456 | const char *zStart, /* Start of SQL text */ |
| 457 | const char *zEnd /* End of SQL text */ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 458 | ){ |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 459 | TriggerStep *pTriggerStep; |
| 460 | |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 461 | pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName, zStart, zEnd); |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 462 | if( pTriggerStep ){ |
| 463 | pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); |
| 464 | pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); |
| 465 | pTriggerStep->orconf = orconf; |
drh | 0e3a6f3 | 2007-03-30 20:40:34 +0000 | [diff] [blame] | 466 | } |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 467 | sqlite3ExprListDelete(db, pEList); |
| 468 | sqlite3ExprDelete(db, pWhere); |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 469 | return pTriggerStep; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 470 | } |
| 471 | |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 472 | /* |
| 473 | ** Construct a trigger step that implements a DELETE statement and return |
| 474 | ** a pointer to that trigger step. The parser calls this routine when it |
| 475 | ** sees a DELETE statement inside the body of a CREATE TRIGGER. |
| 476 | */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 477 | TriggerStep *sqlite3TriggerDeleteStep( |
| 478 | sqlite3 *db, /* Database connection */ |
| 479 | Token *pTableName, /* The table from which rows are deleted */ |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 480 | Expr *pWhere, /* The WHERE clause */ |
| 481 | const char *zStart, /* Start of SQL text */ |
| 482 | const char *zEnd /* End of SQL text */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 483 | ){ |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 484 | TriggerStep *pTriggerStep; |
| 485 | |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 486 | pTriggerStep = triggerStepAllocate(db, TK_DELETE, pTableName, zStart, zEnd); |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 487 | if( pTriggerStep ){ |
| 488 | pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); |
| 489 | pTriggerStep->orconf = OE_Default; |
drh | b63a53d | 2007-03-31 01:34:44 +0000 | [diff] [blame] | 490 | } |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 491 | sqlite3ExprDelete(db, pWhere); |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 492 | return pTriggerStep; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 493 | } |
| 494 | |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 495 | /* |
| 496 | ** Recursively delete a Trigger structure |
| 497 | */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 498 | void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){ |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 499 | if( pTrigger==0 ) return; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 500 | sqlite3DeleteTriggerStep(db, pTrigger->step_list); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 501 | sqlite3DbFree(db, pTrigger->zName); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 502 | sqlite3DbFree(db, pTrigger->table); |
| 503 | sqlite3ExprDelete(db, pTrigger->pWhen); |
| 504 | sqlite3IdListDelete(db, pTrigger->pColumns); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 505 | sqlite3DbFree(db, pTrigger); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 506 | } |
| 507 | |
| 508 | /* |
danielk1977 | 8a41449 | 2004-06-29 08:59:35 +0000 | [diff] [blame] | 509 | ** This function is called to drop a trigger from the database schema. |
| 510 | ** |
| 511 | ** This may be called directly from the parser and therefore identifies |
| 512 | ** the trigger by name. The sqlite3DropTriggerPtr() routine does the |
| 513 | ** same job as this routine except it takes a pointer to the trigger |
| 514 | ** instead of the trigger name. |
| 515 | **/ |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 516 | void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){ |
danielk1977 | 742f947 | 2004-06-16 12:02:43 +0000 | [diff] [blame] | 517 | Trigger *pTrigger = 0; |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 518 | int i; |
| 519 | const char *zDb; |
| 520 | const char *zName; |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 521 | sqlite3 *db = pParse->db; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 522 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 523 | if( db->mallocFailed ) goto drop_trigger_cleanup; |
danielk1977 | 8a41449 | 2004-06-29 08:59:35 +0000 | [diff] [blame] | 524 | if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ |
danielk1977 | c039139 | 2004-06-09 12:30:04 +0000 | [diff] [blame] | 525 | goto drop_trigger_cleanup; |
| 526 | } |
danielk1977 | 8e22787 | 2004-06-07 07:52:17 +0000 | [diff] [blame] | 527 | |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 528 | assert( pName->nSrc==1 ); |
| 529 | zDb = pName->a[0].zDatabase; |
| 530 | zName = pName->a[0].zName; |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 531 | assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); |
danielk1977 | 53c0f74 | 2005-03-29 03:10:59 +0000 | [diff] [blame] | 532 | for(i=OMIT_TEMPDB; i<db->nDb; i++){ |
drh | 812d7a2 | 2003-03-27 13:50:00 +0000 | [diff] [blame] | 533 | int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ |
drh | 69c3382 | 2016-08-18 14:33:11 +0000 | [diff] [blame] | 534 | if( zDb && sqlite3StrICmp(db->aDb[j].zDbSName, zDb) ) continue; |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 535 | assert( sqlite3SchemaMutexHeld(db, j, 0) ); |
drh | acbcb7e | 2014-08-21 20:26:37 +0000 | [diff] [blame] | 536 | pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName); |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 537 | if( pTrigger ) break; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 538 | } |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 539 | if( !pTrigger ){ |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 540 | if( !noErr ){ |
| 541 | sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0); |
dan | 5796675 | 2011-04-09 17:32:58 +0000 | [diff] [blame] | 542 | }else{ |
| 543 | sqlite3CodeVerifyNamedSchema(pParse, zDb); |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 544 | } |
dan | 1db9510 | 2010-06-28 10:15:19 +0000 | [diff] [blame] | 545 | pParse->checkSchema = 1; |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 546 | goto drop_trigger_cleanup; |
| 547 | } |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 548 | sqlite3DropTriggerPtr(pParse, pTrigger); |
drh | 79a519c | 2003-05-17 19:04:03 +0000 | [diff] [blame] | 549 | |
| 550 | drop_trigger_cleanup: |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 551 | sqlite3SrcListDelete(db, pName); |
drh | 79a519c | 2003-05-17 19:04:03 +0000 | [diff] [blame] | 552 | } |
| 553 | |
| 554 | /* |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 555 | ** Return a pointer to the Table structure for the table that a trigger |
| 556 | ** is set on. |
| 557 | */ |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 558 | static Table *tableOfTrigger(Trigger *pTrigger){ |
drh | acbcb7e | 2014-08-21 20:26:37 +0000 | [diff] [blame] | 559 | return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table); |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 560 | } |
| 561 | |
| 562 | |
| 563 | /* |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 564 | ** Drop a trigger given a pointer to that trigger. |
drh | 79a519c | 2003-05-17 19:04:03 +0000 | [diff] [blame] | 565 | */ |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 566 | void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){ |
drh | 79a519c | 2003-05-17 19:04:03 +0000 | [diff] [blame] | 567 | Table *pTable; |
| 568 | Vdbe *v; |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 569 | sqlite3 *db = pParse->db; |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 570 | int iDb; |
drh | 79a519c | 2003-05-17 19:04:03 +0000 | [diff] [blame] | 571 | |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 572 | iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema); |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 573 | assert( iDb>=0 && iDb<db->nDb ); |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 574 | pTable = tableOfTrigger(pTrigger); |
drh | 43617e9 | 2006-03-06 20:55:46 +0000 | [diff] [blame] | 575 | assert( pTable ); |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 576 | assert( pTable->pSchema==pTrigger->pSchema || iDb==1 ); |
drh | e5f9c64 | 2003-01-13 23:27:31 +0000 | [diff] [blame] | 577 | #ifndef SQLITE_OMIT_AUTHORIZATION |
| 578 | { |
| 579 | int code = SQLITE_DROP_TRIGGER; |
drh | 69c3382 | 2016-08-18 14:33:11 +0000 | [diff] [blame] | 580 | const char *zDb = db->aDb[iDb].zDbSName; |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 581 | const char *zTab = SCHEMA_TABLE(iDb); |
| 582 | if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER; |
dan | 2bd9351 | 2009-08-31 08:22:46 +0000 | [diff] [blame] | 583 | if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) || |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 584 | sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ |
drh | 79a519c | 2003-05-17 19:04:03 +0000 | [diff] [blame] | 585 | return; |
drh | e5f9c64 | 2003-01-13 23:27:31 +0000 | [diff] [blame] | 586 | } |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 587 | } |
drh | e5f9c64 | 2003-01-13 23:27:31 +0000 | [diff] [blame] | 588 | #endif |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 589 | |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 590 | /* Generate code to destroy the database record of the trigger. |
| 591 | */ |
drh | 43617e9 | 2006-03-06 20:55:46 +0000 | [diff] [blame] | 592 | assert( pTable!=0 ); |
| 593 | if( (v = sqlite3GetVdbe(pParse))!=0 ){ |
drh | 8c8dddc | 2015-12-09 16:26:38 +0000 | [diff] [blame] | 594 | sqlite3NestedParse(pParse, |
| 595 | "DELETE FROM %Q.%s WHERE name=%Q AND type='trigger'", |
drh | e0a04a3 | 2016-12-16 01:00:21 +0000 | [diff] [blame] | 596 | db->aDb[iDb].zDbSName, MASTER_NAME, pTrigger->zName |
drh | 8c8dddc | 2015-12-09 16:26:38 +0000 | [diff] [blame] | 597 | ); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 598 | sqlite3ChangeCookie(pParse, iDb); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 599 | sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0); |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 600 | } |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 601 | } |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 602 | |
drh | 956bc92 | 2004-07-24 17:38:29 +0000 | [diff] [blame] | 603 | /* |
| 604 | ** Remove a trigger from the hash tables of the sqlite* pointer. |
| 605 | */ |
| 606 | void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){ |
| 607 | Trigger *pTrigger; |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 608 | Hash *pHash; |
| 609 | |
| 610 | assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
| 611 | pHash = &(db->aDb[iDb].pSchema->trigHash); |
drh | acbcb7e | 2014-08-21 20:26:37 +0000 | [diff] [blame] | 612 | pTrigger = sqlite3HashInsert(pHash, zName, 0); |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 613 | if( ALWAYS(pTrigger) ){ |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 614 | if( pTrigger->pSchema==pTrigger->pTabSchema ){ |
| 615 | Table *pTab = tableOfTrigger(pTrigger); |
| 616 | Trigger **pp; |
| 617 | for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext)); |
| 618 | *pp = (*pp)->pNext; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 619 | } |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 620 | sqlite3DeleteTrigger(db, pTrigger); |
drh | 8257aa8 | 2017-07-26 19:59:13 +0000 | [diff] [blame] | 621 | db->mDbFlags |= DBFLAG_SchemaChange; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 622 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 623 | } |
| 624 | |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 625 | /* |
| 626 | ** pEList is the SET clause of an UPDATE statement. Each entry |
| 627 | ** in pEList is of the format <id>=<expr>. If any of the entries |
| 628 | ** in pEList have an <id> which matches an identifier in pIdList, |
| 629 | ** then return TRUE. If pIdList==NULL, then it is considered a |
| 630 | ** wildcard that matches anything. Likewise if pEList==NULL then |
| 631 | ** it matches anything so always return true. Return false only |
| 632 | ** if there is no match. |
| 633 | */ |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 634 | static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){ |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 635 | int e; |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 636 | if( pIdList==0 || NEVER(pEList==0) ) return 1; |
drh | ad2d830 | 2002-05-24 20:31:36 +0000 | [diff] [blame] | 637 | for(e=0; e<pEList->nExpr; e++){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 638 | if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1; |
danielk1977 | f29ce55 | 2002-05-19 23:43:12 +0000 | [diff] [blame] | 639 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 640 | return 0; |
| 641 | } |
| 642 | |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 643 | /* |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 644 | ** Return a list of all triggers on table pTab if there exists at least |
| 645 | ** one trigger that must be fired when an operation of type 'op' is |
| 646 | ** performed on the table, and, if that operation is an UPDATE, if at |
| 647 | ** least one of the columns in pChanges is being modified. |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 648 | */ |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 649 | Trigger *sqlite3TriggersExist( |
| 650 | Parse *pParse, /* Parse context */ |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 651 | Table *pTab, /* The table the contains the triggers */ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 652 | int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 653 | ExprList *pChanges, /* Columns that change in an UPDATE statement */ |
| 654 | int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 655 | ){ |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 656 | int mask = 0; |
drh | e83cafd | 2011-03-21 17:15:58 +0000 | [diff] [blame] | 657 | Trigger *pList = 0; |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 658 | Trigger *p; |
drh | e83cafd | 2011-03-21 17:15:58 +0000 | [diff] [blame] | 659 | |
| 660 | if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){ |
| 661 | pList = sqlite3TriggerList(pParse, pTab); |
| 662 | } |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 663 | assert( pList==0 || IsVirtual(pTab)==0 ); |
| 664 | for(p=pList; p; p=p->pNext){ |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 665 | if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){ |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 666 | mask |= p->tr_tm; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 667 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 668 | } |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 669 | if( pMask ){ |
| 670 | *pMask = mask; |
| 671 | } |
| 672 | return (mask ? pList : 0); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 673 | } |
| 674 | |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 675 | /* |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 676 | ** Convert the pStep->zTarget string into a SrcList and return a pointer |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 677 | ** to that SrcList. |
| 678 | ** |
| 679 | ** This routine adds a specific database name, if needed, to the target when |
| 680 | ** forming the SrcList. This prevents a trigger in one database from |
| 681 | ** referring to a target in another database. An exception is when the |
| 682 | ** trigger is in TEMP in which case it can refer to any other database it |
| 683 | ** wants. |
| 684 | */ |
| 685 | static SrcList *targetSrcList( |
| 686 | Parse *pParse, /* The parsing context */ |
| 687 | TriggerStep *pStep /* The trigger containing the target token */ |
| 688 | ){ |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 689 | sqlite3 *db = pParse->db; |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 690 | int iDb; /* Index of the database to use */ |
| 691 | SrcList *pSrc; /* SrcList to be returned */ |
| 692 | |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 693 | pSrc = sqlite3SrcListAppend(db, 0, 0, 0); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 694 | if( pSrc ){ |
| 695 | assert( pSrc->nSrc>0 ); |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 696 | pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget); |
| 697 | iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 698 | if( iDb==0 || iDb>=2 ){ |
drh | 69c3382 | 2016-08-18 14:33:11 +0000 | [diff] [blame] | 699 | const char *zDb; |
dan | 4640835 | 2015-04-21 16:38:49 +0000 | [diff] [blame] | 700 | assert( iDb<db->nDb ); |
drh | 69c3382 | 2016-08-18 14:33:11 +0000 | [diff] [blame] | 701 | zDb = db->aDb[iDb].zDbSName; |
| 702 | pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, zDb); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 703 | } |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 704 | } |
| 705 | return pSrc; |
| 706 | } |
| 707 | |
| 708 | /* |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 709 | ** Generate VDBE code for the statements inside the body of a single |
| 710 | ** trigger. |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 711 | */ |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 712 | static int codeTriggerProgram( |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 713 | Parse *pParse, /* The parser context */ |
| 714 | TriggerStep *pStepList, /* List of statements inside the trigger body */ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 715 | int orconf /* Conflict algorithm. (OE_Abort, etc) */ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 716 | ){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 717 | TriggerStep *pStep; |
drh | 344737f | 2004-09-19 00:50:20 +0000 | [diff] [blame] | 718 | Vdbe *v = pParse->pVdbe; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 719 | sqlite3 *db = pParse->db; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 720 | |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 721 | assert( pParse->pTriggerTab && pParse->pToplevel ); |
| 722 | assert( pStepList ); |
drh | 344737f | 2004-09-19 00:50:20 +0000 | [diff] [blame] | 723 | assert( v!=0 ); |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 724 | for(pStep=pStepList; pStep; pStep=pStep->pNext){ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 725 | /* Figure out the ON CONFLICT policy that will be used for this step |
| 726 | ** of the trigger program. If the statement that caused this trigger |
| 727 | ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use |
| 728 | ** the ON CONFLICT policy that was specified as part of the trigger |
| 729 | ** step statement. Example: |
| 730 | ** |
| 731 | ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN; |
| 732 | ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b); |
| 733 | ** END; |
| 734 | ** |
| 735 | ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy |
| 736 | ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy |
| 737 | */ |
shane | cea72b2 | 2009-09-07 04:38:36 +0000 | [diff] [blame] | 738 | pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf; |
drh | aceb31b | 2014-02-08 01:40:27 +0000 | [diff] [blame] | 739 | assert( pParse->okConstFactor==0 ); |
dan | f78baaf | 2012-12-06 19:37:22 +0000 | [diff] [blame] | 740 | |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 741 | #ifndef SQLITE_OMIT_TRACE |
drh | e307e11 | 2017-12-27 21:30:34 +0000 | [diff] [blame] | 742 | if( pStep->zSpan ){ |
| 743 | sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0, |
| 744 | sqlite3MPrintf(db, "-- %s", pStep->zSpan), |
| 745 | P4_DYNAMIC); |
| 746 | } |
drh | f259df5 | 2017-12-27 20:38:35 +0000 | [diff] [blame] | 747 | #endif |
| 748 | |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 749 | switch( pStep->op ){ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 750 | case TK_UPDATE: { |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 751 | sqlite3Update(pParse, |
| 752 | targetSrcList(pParse, pStep), |
| 753 | sqlite3ExprListDup(db, pStep->pExprList, 0), |
| 754 | sqlite3ExprDup(db, pStep->pWhere, 0), |
drh | eac9fab | 2018-04-16 13:00:50 +0000 | [diff] [blame] | 755 | pParse->eOrconf, 0, 0, 0 |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 756 | ); |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 757 | break; |
| 758 | } |
| 759 | case TK_INSERT: { |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 760 | sqlite3Insert(pParse, |
| 761 | targetSrcList(pParse, pStep), |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 762 | sqlite3SelectDup(db, pStep->pSelect, 0), |
| 763 | sqlite3IdListDup(db, pStep->pIdList), |
drh | 46d2e5c | 2018-04-12 13:15:43 +0000 | [diff] [blame] | 764 | pParse->eOrconf, |
| 765 | sqlite3UpsertDup(db, pStep->pUpsert) |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 766 | ); |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 767 | break; |
| 768 | } |
| 769 | case TK_DELETE: { |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 770 | sqlite3DeleteFrom(pParse, |
| 771 | targetSrcList(pParse, pStep), |
drh | 8c0833f | 2017-11-14 23:48:23 +0000 | [diff] [blame] | 772 | sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0 |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 773 | ); |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 774 | break; |
| 775 | } |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 776 | default: assert( pStep->op==TK_SELECT ); { |
| 777 | SelectDest sDest; |
| 778 | Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0); |
| 779 | sqlite3SelectDestInit(&sDest, SRT_Discard, 0); |
| 780 | sqlite3Select(pParse, pSelect, &sDest); |
| 781 | sqlite3SelectDelete(db, pSelect); |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 782 | break; |
| 783 | } |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 784 | } |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 785 | if( pStep->op!=TK_SELECT ){ |
drh | b7f1d9a | 2009-09-08 02:27:58 +0000 | [diff] [blame] | 786 | sqlite3VdbeAddOp0(v, OP_ResetCount); |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 787 | } |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 788 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 789 | |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 790 | return 0; |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 791 | } |
| 792 | |
drh | c7379ce | 2013-10-30 02:28:23 +0000 | [diff] [blame] | 793 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 794 | /* |
| 795 | ** This function is used to add VdbeComment() annotations to a VDBE |
| 796 | ** program. It is not used in production code, only for debugging. |
| 797 | */ |
| 798 | static const char *onErrorText(int onError){ |
| 799 | switch( onError ){ |
| 800 | case OE_Abort: return "abort"; |
| 801 | case OE_Rollback: return "rollback"; |
| 802 | case OE_Fail: return "fail"; |
| 803 | case OE_Replace: return "replace"; |
| 804 | case OE_Ignore: return "ignore"; |
| 805 | case OE_Default: return "default"; |
| 806 | } |
| 807 | return "n/a"; |
| 808 | } |
| 809 | #endif |
| 810 | |
| 811 | /* |
| 812 | ** Parse context structure pFrom has just been used to create a sub-vdbe |
| 813 | ** (trigger program). If an error has occurred, transfer error information |
| 814 | ** from pFrom to pTo. |
| 815 | */ |
| 816 | static void transferParseError(Parse *pTo, Parse *pFrom){ |
| 817 | assert( pFrom->zErrMsg==0 || pFrom->nErr ); |
| 818 | assert( pTo->zErrMsg==0 || pTo->nErr ); |
| 819 | if( pTo->nErr==0 ){ |
| 820 | pTo->zErrMsg = pFrom->zErrMsg; |
| 821 | pTo->nErr = pFrom->nErr; |
drh | e06874e | 2015-04-16 15:47:06 +0000 | [diff] [blame] | 822 | pTo->rc = pFrom->rc; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 823 | }else{ |
| 824 | sqlite3DbFree(pFrom->db, pFrom->zErrMsg); |
| 825 | } |
| 826 | } |
| 827 | |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 828 | /* |
| 829 | ** Create and populate a new TriggerPrg object with a sub-program |
| 830 | ** implementing trigger pTrigger with ON CONFLICT policy orconf. |
| 831 | */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 832 | static TriggerPrg *codeRowTrigger( |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 833 | Parse *pParse, /* Current parse context */ |
| 834 | Trigger *pTrigger, /* Trigger to code */ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 835 | Table *pTab, /* The table pTrigger is attached to */ |
| 836 | int orconf /* ON CONFLICT policy to code trigger program with */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 837 | ){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 838 | Parse *pTop = sqlite3ParseToplevel(pParse); |
| 839 | sqlite3 *db = pParse->db; /* Database handle */ |
| 840 | TriggerPrg *pPrg; /* Value to return */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 841 | Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */ |
| 842 | Vdbe *v; /* Temporary VM */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 843 | NameContext sNC; /* Name context for sub-vdbe */ |
| 844 | SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */ |
| 845 | Parse *pSubParse; /* Parse context for sub-vdbe */ |
| 846 | int iEndTrigger = 0; /* Label to jump to if WHEN is false */ |
| 847 | |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 848 | assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); |
dan | d19c933 | 2010-07-26 12:05:17 +0000 | [diff] [blame] | 849 | assert( pTop->pVdbe ); |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 850 | |
| 851 | /* Allocate the TriggerPrg and SubProgram objects. To ensure that they |
| 852 | ** are freed if an error occurs, link them into the Parse.pTriggerPrg |
| 853 | ** list of the top-level Parse object sooner rather than later. */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 854 | pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg)); |
| 855 | if( !pPrg ) return 0; |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 856 | pPrg->pNext = pTop->pTriggerPrg; |
| 857 | pTop->pTriggerPrg = pPrg; |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 858 | pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram)); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 859 | if( !pProgram ) return 0; |
dan | d19c933 | 2010-07-26 12:05:17 +0000 | [diff] [blame] | 860 | sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram); |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 861 | pPrg->pTrigger = pTrigger; |
| 862 | pPrg->orconf = orconf; |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 863 | pPrg->aColmask[0] = 0xffffffff; |
| 864 | pPrg->aColmask[1] = 0xffffffff; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 865 | |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 866 | /* Allocate and populate a new Parse context to use for coding the |
| 867 | ** trigger sub-program. */ |
| 868 | pSubParse = sqlite3StackAllocZero(db, sizeof(Parse)); |
| 869 | if( !pSubParse ) return 0; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 870 | memset(&sNC, 0, sizeof(sNC)); |
| 871 | sNC.pParse = pSubParse; |
| 872 | pSubParse->db = db; |
| 873 | pSubParse->pTriggerTab = pTab; |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 874 | pSubParse->pToplevel = pTop; |
dan | 2bd9351 | 2009-08-31 08:22:46 +0000 | [diff] [blame] | 875 | pSubParse->zAuthContext = pTrigger->zName; |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 876 | pSubParse->eTriggerOp = pTrigger->op; |
drh | 8b307fb | 2010-04-06 15:57:05 +0000 | [diff] [blame] | 877 | pSubParse->nQueryLoop = pParse->nQueryLoop; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 878 | |
| 879 | v = sqlite3GetVdbe(pSubParse); |
| 880 | if( v ){ |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 881 | VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)", |
| 882 | pTrigger->zName, onErrorText(orconf), |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 883 | (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"), |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 884 | (pTrigger->op==TK_UPDATE ? "UPDATE" : ""), |
| 885 | (pTrigger->op==TK_INSERT ? "INSERT" : ""), |
| 886 | (pTrigger->op==TK_DELETE ? "DELETE" : ""), |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 887 | pTab->zName |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 888 | )); |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 889 | #ifndef SQLITE_OMIT_TRACE |
drh | e307e11 | 2017-12-27 21:30:34 +0000 | [diff] [blame] | 890 | if( pTrigger->zName ){ |
| 891 | sqlite3VdbeChangeP4(v, -1, |
| 892 | sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC |
| 893 | ); |
| 894 | } |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 895 | #endif |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 896 | |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 897 | /* If one was specified, code the WHEN clause. If it evaluates to false |
| 898 | ** (or NULL) the sub-vdbe is immediately halted by jumping to the |
| 899 | ** OP_Halt inserted at the end of the program. */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 900 | if( pTrigger->pWhen ){ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 901 | pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0); |
dan | 523a087 | 2009-08-31 05:23:32 +0000 | [diff] [blame] | 902 | if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) |
| 903 | && db->mallocFailed==0 |
| 904 | ){ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 905 | iEndTrigger = sqlite3VdbeMakeLabel(v); |
| 906 | sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL); |
| 907 | } |
| 908 | sqlite3ExprDelete(db, pWhen); |
| 909 | } |
| 910 | |
| 911 | /* Code the trigger program into the sub-vdbe. */ |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 912 | codeTriggerProgram(pSubParse, pTrigger->step_list, orconf); |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 913 | |
| 914 | /* Insert an OP_Halt at the end of the sub-program. */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 915 | if( iEndTrigger ){ |
| 916 | sqlite3VdbeResolveLabel(v, iEndTrigger); |
| 917 | } |
| 918 | sqlite3VdbeAddOp0(v, OP_Halt); |
dan | 76d462e | 2009-08-30 11:42:51 +0000 | [diff] [blame] | 919 | VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf))); |
| 920 | |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 921 | transferParseError(pParse, pSubParse); |
dan | 0895117 | 2017-11-28 20:43:40 +0000 | [diff] [blame] | 922 | if( db->mallocFailed==0 && pParse->nErr==0 ){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 923 | pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg); |
dan | 523a087 | 2009-08-31 05:23:32 +0000 | [diff] [blame] | 924 | } |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 925 | pProgram->nMem = pSubParse->nMem; |
| 926 | pProgram->nCsr = pSubParse->nTab; |
| 927 | pProgram->token = (void *)pTrigger; |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 928 | pPrg->aColmask[0] = pSubParse->oldmask; |
| 929 | pPrg->aColmask[1] = pSubParse->newmask; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 930 | sqlite3VdbeDelete(v); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 931 | } |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 932 | |
| 933 | assert( !pSubParse->pAinc && !pSubParse->pZombieTab ); |
| 934 | assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg ); |
drh | f30a969 | 2013-11-15 01:10:18 +0000 | [diff] [blame] | 935 | sqlite3ParserReset(pSubParse); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 936 | sqlite3StackFree(db, pSubParse); |
| 937 | |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 938 | return pPrg; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 939 | } |
| 940 | |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 941 | /* |
| 942 | ** Return a pointer to a TriggerPrg object containing the sub-program for |
| 943 | ** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such |
| 944 | ** TriggerPrg object exists, a new object is allocated and populated before |
| 945 | ** being returned. |
| 946 | */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 947 | static TriggerPrg *getRowTrigger( |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 948 | Parse *pParse, /* Current parse context */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 949 | Trigger *pTrigger, /* Trigger to code */ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 950 | Table *pTab, /* The table trigger pTrigger is attached to */ |
| 951 | int orconf /* ON CONFLICT algorithm. */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 952 | ){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 953 | Parse *pRoot = sqlite3ParseToplevel(pParse); |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 954 | TriggerPrg *pPrg; |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 955 | |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 956 | assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 957 | |
| 958 | /* It may be that this trigger has already been coded (or is in the |
| 959 | ** process of being coded). If this is the case, then an entry with |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 960 | ** a matching TriggerPrg.pTrigger field will be present somewhere |
| 961 | ** in the Parse.pTriggerPrg list. Search for such an entry. */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 962 | for(pPrg=pRoot->pTriggerPrg; |
| 963 | pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf); |
| 964 | pPrg=pPrg->pNext |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 965 | ); |
| 966 | |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 967 | /* If an existing TriggerPrg could not be located, create a new one. */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 968 | if( !pPrg ){ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 969 | pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 970 | } |
| 971 | |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 972 | return pPrg; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 973 | } |
| 974 | |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 975 | /* |
| 976 | ** Generate code for the trigger program associated with trigger p on |
| 977 | ** table pTab. The reg, orconf and ignoreJump parameters passed to this |
| 978 | ** function are the same as those described in the header function for |
| 979 | ** sqlite3CodeRowTrigger() |
| 980 | */ |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 981 | void sqlite3CodeRowTriggerDirect( |
| 982 | Parse *pParse, /* Parse context */ |
| 983 | Trigger *p, /* Trigger to code */ |
| 984 | Table *pTab, /* The table to code triggers from */ |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 985 | int reg, /* Reg array containing OLD.* and NEW.* values */ |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 986 | int orconf, /* ON CONFLICT policy */ |
| 987 | int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ |
| 988 | ){ |
| 989 | Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */ |
| 990 | TriggerPrg *pPrg; |
| 991 | pPrg = getRowTrigger(pParse, p, pTab, orconf); |
| 992 | assert( pPrg || pParse->nErr || pParse->db->mallocFailed ); |
| 993 | |
| 994 | /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program |
| 995 | ** is a pointer to the sub-vdbe containing the trigger program. */ |
| 996 | if( pPrg ){ |
dan | d19c933 | 2010-07-26 12:05:17 +0000 | [diff] [blame] | 997 | int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers)); |
| 998 | |
drh | 9b34abe | 2016-01-16 15:12:35 +0000 | [diff] [blame] | 999 | sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem, |
| 1000 | (const char *)pPrg->pProgram, P4_SUBPROGRAM); |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 1001 | VdbeComment( |
| 1002 | (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf))); |
| 1003 | |
| 1004 | /* Set the P5 operand of the OP_Program instruction to non-zero if |
| 1005 | ** recursive invocation of this trigger program is disallowed. Recursive |
| 1006 | ** invocation is disallowed if (a) the sub-program is really a trigger, |
| 1007 | ** not a foreign key action, and (b) the flag to enable recursive triggers |
| 1008 | ** is clear. */ |
dan | d19c933 | 2010-07-26 12:05:17 +0000 | [diff] [blame] | 1009 | sqlite3VdbeChangeP5(v, (u8)bRecursive); |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 1010 | } |
| 1011 | } |
| 1012 | |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1013 | /* |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1014 | ** This is called to code the required FOR EACH ROW triggers for an operation |
| 1015 | ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE) |
drh | f7b5496 | 2013-05-28 12:11:54 +0000 | [diff] [blame] | 1016 | ** is given by the op parameter. The tr_tm parameter determines whether the |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1017 | ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then |
| 1018 | ** parameter pChanges is passed the list of columns being modified. |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1019 | ** |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1020 | ** If there are no triggers that fire at the specified time for the specified |
| 1021 | ** operation on pTab, this function is a no-op. |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 1022 | ** |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1023 | ** The reg argument is the address of the first in an array of registers |
| 1024 | ** that contain the values substituted for the new.* and old.* references |
| 1025 | ** in the trigger program. If N is the number of columns in table pTab |
| 1026 | ** (a copy of pTab->nCol), then registers are populated as follows: |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 1027 | ** |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1028 | ** Register Contains |
| 1029 | ** ------------------------------------------------------ |
| 1030 | ** reg+0 OLD.rowid |
| 1031 | ** reg+1 OLD.* value of left-most column of pTab |
| 1032 | ** ... ... |
| 1033 | ** reg+N OLD.* value of right-most column of pTab |
| 1034 | ** reg+N+1 NEW.rowid |
| 1035 | ** reg+N+2 OLD.* value of left-most column of pTab |
| 1036 | ** ... ... |
| 1037 | ** reg+N+N+1 NEW.* value of right-most column of pTab |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 1038 | ** |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1039 | ** For ON DELETE triggers, the registers containing the NEW.* values will |
| 1040 | ** never be accessed by the trigger program, so they are not allocated or |
| 1041 | ** populated by the caller (there is no data to populate them with anyway). |
| 1042 | ** Similarly, for ON INSERT triggers the values stored in the OLD.* registers |
| 1043 | ** are never accessed, and so are not allocated by the caller. So, for an |
| 1044 | ** ON INSERT trigger, the value passed to this function as parameter reg |
| 1045 | ** is not a readable register, although registers (reg+N) through |
| 1046 | ** (reg+N+N+1) are. |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1047 | ** |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1048 | ** Parameter orconf is the default conflict resolution algorithm for the |
| 1049 | ** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump |
| 1050 | ** is the instruction that control should jump to if a trigger program |
| 1051 | ** raises an IGNORE exception. |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1052 | */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1053 | void sqlite3CodeRowTrigger( |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1054 | Parse *pParse, /* Parse context */ |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 1055 | Trigger *pTrigger, /* List of triggers on table pTab */ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1056 | int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ |
| 1057 | ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 1058 | int tr_tm, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ |
danielk1977 | 633ed08 | 2002-05-17 00:05:58 +0000 | [diff] [blame] | 1059 | Table *pTab, /* The table to code triggers from */ |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1060 | int reg, /* The first in an array of registers (see above) */ |
danielk1977 | 6f34903 | 2002-06-11 02:25:40 +0000 | [diff] [blame] | 1061 | int orconf, /* ON CONFLICT policy */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1062 | int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ |
drh | c977f7f | 2002-05-21 11:38:11 +0000 | [diff] [blame] | 1063 | ){ |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1064 | Trigger *p; /* Used to iterate through pTrigger list */ |
danielk1977 | 8f2c54e | 2008-01-01 19:02:09 +0000 | [diff] [blame] | 1065 | |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1066 | assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE ); |
| 1067 | assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER ); |
| 1068 | assert( (op==TK_UPDATE)==(pChanges!=0) ); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 1069 | |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 1070 | for(p=pTrigger; p; p=p->pNext){ |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 1071 | |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 1072 | /* Sanity checking: The schema for the trigger and for the table are |
| 1073 | ** always defined. The trigger must be in the same schema as the table |
| 1074 | ** or else it must be a TEMP trigger. */ |
| 1075 | assert( p->pSchema!=0 ); |
| 1076 | assert( p->pTabSchema!=0 ); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1077 | assert( p->pSchema==p->pTabSchema |
| 1078 | || p->pSchema==pParse->db->aDb[1].pSchema ); |
drh | 9ab4c2e | 2009-05-09 00:18:38 +0000 | [diff] [blame] | 1079 | |
danielk1977 | eecfb3e | 2006-01-10 12:31:39 +0000 | [diff] [blame] | 1080 | /* Determine whether we should code this trigger */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1081 | if( p->op==op |
| 1082 | && p->tr_tm==tr_tm |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1083 | && checkColumnOverlap(p->pColumns, pChanges) |
danielk1977 | eecfb3e | 2006-01-10 12:31:39 +0000 | [diff] [blame] | 1084 | ){ |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 1085 | sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump); |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 1086 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 1087 | } |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 1088 | } |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1089 | |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1090 | /* |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1091 | ** Triggers may access values stored in the old.* or new.* pseudo-table. |
| 1092 | ** This function returns a 32-bit bitmask indicating which columns of the |
| 1093 | ** old.* or new.* tables actually are used by triggers. This information |
| 1094 | ** may be used by the caller, for example, to avoid having to load the entire |
| 1095 | ** old.* record into memory when executing an UPDATE or DELETE command. |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1096 | ** |
| 1097 | ** Bit 0 of the returned mask is set if the left-most column of the |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1098 | ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1099 | ** the second leftmost column value is required, and so on. If there |
| 1100 | ** are more than 32 columns in the table, and at least one of the columns |
| 1101 | ** with an index greater than 32 may be accessed, 0xffffffff is returned. |
| 1102 | ** |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1103 | ** It is not possible to determine if the old.rowid or new.rowid column is |
| 1104 | ** accessed by triggers. The caller must always assume that it is. |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1105 | ** |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1106 | ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned |
| 1107 | ** applies to the old.* table. If 1, the new.* table. |
| 1108 | ** |
| 1109 | ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE |
| 1110 | ** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only |
| 1111 | ** included in the returned mask if the TRIGGER_BEFORE bit is set in the |
| 1112 | ** tr_tm parameter. Similarly, values accessed by AFTER triggers are only |
| 1113 | ** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm. |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1114 | */ |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1115 | u32 sqlite3TriggerColmask( |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1116 | Parse *pParse, /* Parse context */ |
| 1117 | Trigger *pTrigger, /* List of triggers on table pTab */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1118 | ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1119 | int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */ |
| 1120 | int tr_tm, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1121 | Table *pTab, /* The table to code triggers from */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1122 | int orconf /* Default ON CONFLICT policy for trigger steps */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1123 | ){ |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 1124 | const int op = pChanges ? TK_UPDATE : TK_DELETE; |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1125 | u32 mask = 0; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1126 | Trigger *p; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1127 | |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1128 | assert( isNew==1 || isNew==0 ); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1129 | for(p=pTrigger; p; p=p->pNext){ |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1130 | if( p->op==op && (tr_tm&p->tr_tm) |
| 1131 | && checkColumnOverlap(p->pColumns,pChanges) |
| 1132 | ){ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1133 | TriggerPrg *pPrg; |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 1134 | pPrg = getRowTrigger(pParse, p, pTab, orconf); |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1135 | if( pPrg ){ |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 1136 | mask |= pPrg->aColmask[isNew]; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1137 | } |
| 1138 | } |
| 1139 | } |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1140 | |
| 1141 | return mask; |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 1142 | } |
| 1143 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 1144 | #endif /* !defined(SQLITE_OMIT_TRIGGER) */ |