blob: 5508e4d151014de7185555b1dc45e7c332e1225b [file] [log] [blame]
danielk1977c3f9bad2002-05-15 08:30:12 +00001/*
danielk1977633ed082002-05-17 00:05:58 +00002**
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*************************************************************************
drhc81c11f2009-11-10 01:30:52 +000011** This file contains the implementation for TRIGGERs
drh9adf9ac2002-05-15 11:44:13 +000012*/
danielk1977c3f9bad2002-05-15 08:30:12 +000013#include "sqliteInt.h"
drh9adf9ac2002-05-15 11:44:13 +000014
drhb7f91642004-10-31 02:22:47 +000015#ifndef SQLITE_OMIT_TRIGGER
danielk1977c3f9bad2002-05-15 08:30:12 +000016/*
drh4b59ab52002-08-24 18:24:51 +000017** Delete a linked list of TriggerStep structures.
18*/
drh633e6d52008-07-28 19:34:53 +000019void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
drh4b59ab52002-08-24 18:24:51 +000020 while( pTriggerStep ){
21 TriggerStep * pTmp = pTriggerStep;
22 pTriggerStep = pTriggerStep->pNext;
23
drh633e6d52008-07-28 19:34:53 +000024 sqlite3ExprDelete(db, pTmp->pWhere);
25 sqlite3ExprListDelete(db, pTmp->pExprList);
26 sqlite3SelectDelete(db, pTmp->pSelect);
27 sqlite3IdListDelete(db, pTmp->pIdList);
drh46d2e5c2018-04-12 13:15:43 +000028 sqlite3UpsertDelete(db, pTmp->pUpsert);
dane7877b22020-07-14 19:51:01 +000029 sqlite3SrcListDelete(db, pTmp->pFrom);
drhf259df52017-12-27 20:38:35 +000030 sqlite3DbFree(db, pTmp->zSpan);
drh4b59ab52002-08-24 18:24:51 +000031
drh633e6d52008-07-28 19:34:53 +000032 sqlite3DbFree(db, pTmp);
drh4b59ab52002-08-24 18:24:51 +000033 }
34}
35
36/*
danielk19772f886d12009-02-28 10:47:41 +000037** Given table pTab, return a list of all the triggers attached to
38** the table. The list is connected by Trigger.pNext pointers.
drh9ab4c2e2009-05-09 00:18:38 +000039**
40** All of the triggers on pTab that are in the same database as pTab
41** are already attached to pTab->pTrigger. But there might be additional
42** triggers on pTab in the TEMP schema. This routine prepends all
43** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
44** and returns the combined list.
45**
46** To state it another way: This routine returns a list of all triggers
47** that fire off of pTab. The list will include any TEMP triggers on
48** pTab as well as the triggers lised in pTab->pTrigger.
danielk19772f886d12009-02-28 10:47:41 +000049*/
50Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
drhf54a80f2021-01-29 13:47:36 +000051 Schema *pTmpSchema; /* Schema of the pTab table */
52 Trigger *pList; /* List of triggers to return */
53 HashElem *p; /* Loop variable for TEMP triggers */
danielk19772f886d12009-02-28 10:47:41 +000054
dand66c8302009-09-28 14:49:01 +000055 if( pParse->disableTriggers ){
56 return 0;
57 }
drhf54a80f2021-01-29 13:47:36 +000058 pTmpSchema = pParse->db->aDb[1].pSchema;
59 p = sqliteHashFirst(&pTmpSchema->trigHash);
60 if( p==0 ){
61 return pTab->pTrigger;
62 }
63 pList = pTab->pTrigger;
danielk19772f886d12009-02-28 10:47:41 +000064 if( pTmpSchema!=pTab->pSchema ){
drhf54a80f2021-01-29 13:47:36 +000065 while( p ){
danielk19772f886d12009-02-28 10:47:41 +000066 Trigger *pTrig = (Trigger *)sqliteHashData(p);
67 if( pTrig->pTabSchema==pTab->pSchema
drhb8352472021-01-29 19:32:17 +000068 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
danielk19772f886d12009-02-28 10:47:41 +000069 ){
drhf54a80f2021-01-29 13:47:36 +000070 pTrig->pNext = pList;
danielk19772f886d12009-02-28 10:47:41 +000071 pList = pTrig;
drhb8352472021-01-29 19:32:17 +000072 }else if( pTrig->op==TK_RETURNING ){
73 pTrig->table = pTab->zName;
74 pTrig->pTabSchema = pTab->pSchema;
75 pTrig->pNext = pList;
76 pList = pTrig;
77 }
drhf54a80f2021-01-29 13:47:36 +000078 p = sqliteHashNext(p);
danielk19772f886d12009-02-28 10:47:41 +000079 }
80 }
drhf54a80f2021-01-29 13:47:36 +000081 return pList;
danielk19772f886d12009-02-28 10:47:41 +000082}
83
84/*
drhf0f258b2003-04-21 18:48:45 +000085** This is called by the parser when it sees a CREATE TRIGGER statement
86** up to the point of the BEGIN before the trigger actions. A Trigger
87** structure is generated based on the information available and stored
88** in pParse->pNewTrigger. After the trigger actions have been parsed, the
danielk19774adee202004-05-08 08:23:19 +000089** sqlite3FinishTrigger() function is called to complete the trigger
drhf0f258b2003-04-21 18:48:45 +000090** construction process.
drh9adf9ac2002-05-15 11:44:13 +000091*/
danielk19774adee202004-05-08 08:23:19 +000092void sqlite3BeginTrigger(
drh9adf9ac2002-05-15 11:44:13 +000093 Parse *pParse, /* The parse context of the CREATE TRIGGER statement */
danielk1977ef2cb632004-05-29 02:37:19 +000094 Token *pName1, /* The name of the trigger */
95 Token *pName2, /* The name of the trigger */
drh5cf590c2003-04-24 01:45:04 +000096 int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */
drh9adf9ac2002-05-15 11:44:13 +000097 int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
danielk1977633ed082002-05-17 00:05:58 +000098 IdList *pColumns, /* column list if this is an UPDATE OF trigger */
drhd24cc422003-03-27 12:51:24 +000099 SrcList *pTableName,/* The name of the table/view the trigger applies to */
drh9adf9ac2002-05-15 11:44:13 +0000100 Expr *pWhen, /* WHEN clause */
drhfdd48a72006-09-11 23:45:48 +0000101 int isTemp, /* True if the TEMPORARY keyword is present */
102 int noErr /* Suppress errors if the trigger already exists */
drh9adf9ac2002-05-15 11:44:13 +0000103){
drh3d5f74b2009-08-06 17:43:31 +0000104 Trigger *pTrigger = 0; /* The new trigger */
105 Table *pTab; /* Table that the trigger fires off of */
drhf0f258b2003-04-21 18:48:45 +0000106 char *zName = 0; /* Name of the trigger */
drh3d5f74b2009-08-06 17:43:31 +0000107 sqlite3 *db = pParse->db; /* The database connection */
danielk1977ef2cb632004-05-29 02:37:19 +0000108 int iDb; /* The database to store the trigger in */
109 Token *pName; /* The unqualified db name */
drh3d5f74b2009-08-06 17:43:31 +0000110 DbFixer sFix; /* State vector for the DB fixer */
drhed6c8672003-01-12 18:02:16 +0000111
drh43617e92006-03-06 20:55:46 +0000112 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
113 assert( pName2!=0 );
drhaa78bec2008-12-09 03:55:14 +0000114 assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
115 assert( op>0 && op<0xff );
danielk1977ef2cb632004-05-29 02:37:19 +0000116 if( isTemp ){
117 /* If TEMP was specified, then the trigger name may not be qualified. */
drh43617e92006-03-06 20:55:46 +0000118 if( pName2->n>0 ){
danielk1977ef2cb632004-05-29 02:37:19 +0000119 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
120 goto trigger_cleanup;
121 }
122 iDb = 1;
123 pName = pName1;
124 }else{
mistachkind5578432012-08-25 10:01:29 +0000125 /* Figure out the db that the trigger will be created in */
danielk1977ef2cb632004-05-29 02:37:19 +0000126 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
127 if( iDb<0 ){
128 goto trigger_cleanup;
129 }
130 }
drh6fea83e2011-07-01 13:50:44 +0000131 if( !pTableName || db->mallocFailed ){
132 goto trigger_cleanup;
133 }
134
135 /* A long-standing parser bug is that this syntax was allowed:
136 **
137 ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
138 ** ^^^^^^^^
139 **
140 ** To maintain backwards compatibility, ignore the database
drh346a70c2020-06-15 20:27:35 +0000141 ** name on pTableName if we are reparsing out of the schema table
drh6fea83e2011-07-01 13:50:44 +0000142 */
143 if( db->init.busy && iDb!=1 ){
144 sqlite3DbFree(db, pTableName->a[0].zDatabase);
145 pTableName->a[0].zDatabase = 0;
146 }
danielk1977ef2cb632004-05-29 02:37:19 +0000147
148 /* If the trigger name was unqualified, and the table is a temp table,
149 ** then set iDb to 1 to create the trigger in the temporary database.
150 ** If sqlite3SrcListLookup() returns 0, indicating the table does not
151 ** exist, the error is caught by the block below.
drh9adf9ac2002-05-15 11:44:13 +0000152 */
danielk1977ef2cb632004-05-29 02:37:19 +0000153 pTab = sqlite3SrcListLookup(pParse, pTableName);
drh622d2882010-02-15 16:54:55 +0000154 if( db->init.busy==0 && pName2->n==0 && pTab
155 && pTab->pSchema==db->aDb[1].pSchema ){
danielk1977ef2cb632004-05-29 02:37:19 +0000156 iDb = 1;
157 }
158
159 /* Ensure the table name matches database name and that the table exists */
drh17435752007-08-16 04:30:38 +0000160 if( db->mallocFailed ) goto trigger_cleanup;
drhd24cc422003-03-27 12:51:24 +0000161 assert( pTableName->nSrc==1 );
drhd100f692013-10-03 15:39:44 +0000162 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
163 if( sqlite3FixSrcList(&sFix, pTableName) ){
drh4312db52003-06-03 01:47:11 +0000164 goto trigger_cleanup;
drhf26e09c2003-05-31 16:21:12 +0000165 }
danielk1977ef2cb632004-05-29 02:37:19 +0000166 pTab = sqlite3SrcListLookup(pParse, pTableName);
167 if( !pTab ){
168 /* The table does not exist. */
drh4e451aa2020-11-05 19:13:44 +0000169 goto trigger_orphan_error;
drhd24cc422003-03-27 12:51:24 +0000170 }
drh4cbdda92006-06-14 19:00:20 +0000171 if( IsVirtual(pTab) ){
172 sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
drh4e451aa2020-11-05 19:13:44 +0000173 goto trigger_orphan_error;
drh4cbdda92006-06-14 19:00:20 +0000174 }
drhd24cc422003-03-27 12:51:24 +0000175
danielk1977d8123362004-06-12 09:25:12 +0000176 /* Check that the trigger name is not reserved and that no trigger of the
177 ** specified name exists */
drh17435752007-08-16 04:30:38 +0000178 zName = sqlite3NameFromToken(db, pName);
drhc5a93d42019-08-12 00:08:07 +0000179 if( zName==0 ){
180 assert( db->mallocFailed );
181 goto trigger_cleanup;
182 }
183 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
danielk1977d8123362004-06-12 09:25:12 +0000184 goto trigger_cleanup;
185 }
drh21206082011-04-04 18:22:02 +0000186 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danc9461ec2018-08-29 21:00:16 +0000187 if( !IN_RENAME_OBJECT ){
dan5496d6a2018-08-13 17:14:26 +0000188 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
189 if( !noErr ){
190 sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
191 }else{
192 assert( !db->init.busy );
193 sqlite3CodeVerifySchema(pParse, iDb);
194 }
195 goto trigger_cleanup;
drhfdd48a72006-09-11 23:45:48 +0000196 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000197 }
danielk1977ef2cb632004-05-29 02:37:19 +0000198
199 /* Do not create a trigger on a system table */
drhdca76842004-12-07 14:06:13 +0000200 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
danielk19774adee202004-05-08 08:23:19 +0000201 sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
drhd24cc422003-03-27 12:51:24 +0000202 goto trigger_cleanup;
danielk1977d702fcc2002-05-26 23:24:40 +0000203 }
danielk1977ef2cb632004-05-29 02:37:19 +0000204
205 /* INSTEAD of triggers are only for views and views only support INSTEAD
206 ** of triggers.
207 */
208 if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
danielk19774adee202004-05-08 08:23:19 +0000209 sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
drhda93d232003-03-31 02:12:46 +0000210 (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
drh4e451aa2020-11-05 19:13:44 +0000211 goto trigger_orphan_error;
drhd24cc422003-03-27 12:51:24 +0000212 }
danielk1977ef2cb632004-05-29 02:37:19 +0000213 if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
danielk19774adee202004-05-08 08:23:19 +0000214 sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
drhda93d232003-03-31 02:12:46 +0000215 " trigger on table: %S", pTableName, 0);
drh4e451aa2020-11-05 19:13:44 +0000216 goto trigger_orphan_error;
drhd24cc422003-03-27 12:51:24 +0000217 }
danielk1977ef2cb632004-05-29 02:37:19 +0000218
drhd24cc422003-03-27 12:51:24 +0000219#ifndef SQLITE_OMIT_AUTHORIZATION
danc9461ec2018-08-29 21:00:16 +0000220 if( !IN_RENAME_OBJECT ){
drha0daa752016-09-16 11:53:10 +0000221 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drhd24cc422003-03-27 12:51:24 +0000222 int code = SQLITE_CREATE_TRIGGER;
drh69c33822016-08-18 14:33:11 +0000223 const char *zDb = db->aDb[iTabDb].zDbSName;
224 const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb;
danielk1977da184232006-01-05 11:34:32 +0000225 if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
danielk1977ef2cb632004-05-29 02:37:19 +0000226 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
drhd24cc422003-03-27 12:51:24 +0000227 goto trigger_cleanup;
228 }
danielk1977da184232006-01-05 11:34:32 +0000229 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
drhd24cc422003-03-27 12:51:24 +0000230 goto trigger_cleanup;
231 }
232 }
233#endif
danielk1977d702fcc2002-05-26 23:24:40 +0000234
danielk1977ef2cb632004-05-29 02:37:19 +0000235 /* INSTEAD OF triggers can only appear on views and BEFORE triggers
drh5cf590c2003-04-24 01:45:04 +0000236 ** cannot appear on views. So we might as well translate every
237 ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code
238 ** elsewhere.
239 */
danielk1977d702fcc2002-05-26 23:24:40 +0000240 if (tr_tm == TK_INSTEAD){
241 tr_tm = TK_BEFORE;
danielk1977c3f9bad2002-05-15 08:30:12 +0000242 }
243
244 /* Build the Trigger object */
drh17435752007-08-16 04:30:38 +0000245 pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
danielk1977ef2cb632004-05-29 02:37:19 +0000246 if( pTrigger==0 ) goto trigger_cleanup;
dan165921a2009-08-28 18:53:45 +0000247 pTrigger->zName = zName;
drhe5f9c642003-01-13 23:27:31 +0000248 zName = 0;
drh17435752007-08-16 04:30:38 +0000249 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
danielk1977da184232006-01-05 11:34:32 +0000250 pTrigger->pSchema = db->aDb[iDb].pSchema;
danielk1977aaf22682006-01-06 15:03:48 +0000251 pTrigger->pTabSchema = pTab->pSchema;
drhaa78bec2008-12-09 03:55:14 +0000252 pTrigger->op = (u8)op;
drhdca76842004-12-07 14:06:13 +0000253 pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
danc9461ec2018-08-29 21:00:16 +0000254 if( IN_RENAME_OBJECT ){
255 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
dan5496d6a2018-08-13 17:14:26 +0000256 pTrigger->pWhen = pWhen;
257 pWhen = 0;
258 }else{
259 pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
260 }
261 pTrigger->pColumns = pColumns;
262 pColumns = 0;
drhf0f258b2003-04-21 18:48:45 +0000263 assert( pParse->pNewTrigger==0 );
danielk1977ef2cb632004-05-29 02:37:19 +0000264 pParse->pNewTrigger = pTrigger;
drhf0f258b2003-04-21 18:48:45 +0000265
266trigger_cleanup:
drh633e6d52008-07-28 19:34:53 +0000267 sqlite3DbFree(db, zName);
268 sqlite3SrcListDelete(db, pTableName);
269 sqlite3IdListDelete(db, pColumns);
270 sqlite3ExprDelete(db, pWhen);
danielk1977d5d56522005-03-16 12:15:20 +0000271 if( !pParse->pNewTrigger ){
drh633e6d52008-07-28 19:34:53 +0000272 sqlite3DeleteTrigger(db, pTrigger);
danielk1977d5d56522005-03-16 12:15:20 +0000273 }else{
274 assert( pParse->pNewTrigger==pTrigger );
275 }
drh4e451aa2020-11-05 19:13:44 +0000276 return;
277
278trigger_orphan_error:
279 if( db->init.iDb==1 ){
280 /* Ticket #3810.
281 ** Normally, whenever a table is dropped, all associated triggers are
282 ** dropped too. But if a TEMP trigger is created on a non-TEMP table
283 ** and the table is dropped by a different database connection, the
284 ** trigger is not visible to the database connection that does the
285 ** drop so the trigger cannot be dropped. This results in an
286 ** "orphaned trigger" - a trigger whose associated table is missing.
287 **
288 ** 2020-11-05 see also https://sqlite.org/forum/forumpost/157dc791df
289 */
290 db->init.orphanTrigger = 1;
291 }
292 goto trigger_cleanup;
drhf0f258b2003-04-21 18:48:45 +0000293}
294
295/*
296** This routine is called after all of the trigger actions have been parsed
297** in order to complete the process of building the trigger.
298*/
danielk19774adee202004-05-08 08:23:19 +0000299void sqlite3FinishTrigger(
drhf0f258b2003-04-21 18:48:45 +0000300 Parse *pParse, /* Parser context */
301 TriggerStep *pStepList, /* The triggered program */
302 Token *pAll /* Token that describes the complete CREATE TRIGGER */
303){
drha8c62df2010-02-15 15:47:18 +0000304 Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */
305 char *zName; /* Name of trigger */
306 sqlite3 *db = pParse->db; /* The database */
307 DbFixer sFix; /* Fixer object */
308 int iDb; /* Database containing the trigger */
309 Token nameToken; /* Trigger name for error reporting */
drhf0f258b2003-04-21 18:48:45 +0000310
drhf0f258b2003-04-21 18:48:45 +0000311 pParse->pNewTrigger = 0;
drh9ab4c2e2009-05-09 00:18:38 +0000312 if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
dan165921a2009-08-28 18:53:45 +0000313 zName = pTrig->zName;
danielk1977da184232006-01-05 11:34:32 +0000314 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
danielk1977bfb9e352005-01-24 13:03:32 +0000315 pTrig->step_list = pStepList;
drha69d9162003-04-17 22:57:53 +0000316 while( pStepList ){
danielk1977bfb9e352005-01-24 13:03:32 +0000317 pStepList->pTrig = pTrig;
drha69d9162003-04-17 22:57:53 +0000318 pStepList = pStepList->pNext;
319 }
drh40aced52016-01-22 17:48:09 +0000320 sqlite3TokenInit(&nameToken, pTrig->zName);
drhd100f692013-10-03 15:39:44 +0000321 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
322 if( sqlite3FixTriggerStep(&sFix, pTrig->step_list)
dan46539d72013-10-03 12:29:38 +0000323 || sqlite3FixExpr(&sFix, pTrig->pWhen)
drhd100f692013-10-03 15:39:44 +0000324 ){
drhf26e09c2003-05-31 16:21:12 +0000325 goto triggerfinish_cleanup;
326 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000327
dan5496d6a2018-08-13 17:14:26 +0000328#ifndef SQLITE_OMIT_ALTERTABLE
danc9461ec2018-08-29 21:00:16 +0000329 if( IN_RENAME_OBJECT ){
dan5496d6a2018-08-13 17:14:26 +0000330 assert( !db->init.busy );
331 pParse->pNewTrigger = pTrig;
332 pTrig = 0;
333 }else
334#endif
335
drha8c62df2010-02-15 15:47:18 +0000336 /* if we are not initializing,
drh1e32bed2020-06-19 13:33:53 +0000337 ** build the sqlite_schema entry
drh9adf9ac2002-05-15 11:44:13 +0000338 */
drh1d85d932004-02-14 23:05:52 +0000339 if( !db->init.busy ){
drhc977f7f2002-05-21 11:38:11 +0000340 Vdbe *v;
drh2d401ab2008-01-10 23:50:11 +0000341 char *z;
danielk1977c3f9bad2002-05-15 08:30:12 +0000342
drh1e32bed2020-06-19 13:33:53 +0000343 /* Make an entry in the sqlite_schema table */
danielk19774adee202004-05-08 08:23:19 +0000344 v = sqlite3GetVdbe(pParse);
drhf0f258b2003-04-21 18:48:45 +0000345 if( v==0 ) goto triggerfinish_cleanup;
danielk1977da184232006-01-05 11:34:32 +0000346 sqlite3BeginWriteOperation(pParse, 0, iDb);
drh2d401ab2008-01-10 23:50:11 +0000347 z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
drhd96cc6f2017-06-08 14:35:21 +0000348 testcase( z==0 );
drh2d401ab2008-01-10 23:50:11 +0000349 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +0000350 "INSERT INTO %Q." DFLT_SCHEMA_TABLE
351 " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
352 db->aDb[iDb].zDbSName, zName,
drh2d401ab2008-01-10 23:50:11 +0000353 pTrig->table, z);
drh633e6d52008-07-28 19:34:53 +0000354 sqlite3DbFree(db, z);
drh9cbf3422008-01-17 16:22:13 +0000355 sqlite3ChangeCookie(pParse, iDb);
drh5d9c9da2011-06-03 20:11:17 +0000356 sqlite3VdbeAddParseSchemaOp(v, iDb,
357 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
danielk1977c3f9bad2002-05-15 08:30:12 +0000358 }
359
drh956bc922004-07-24 17:38:29 +0000360 if( db->init.busy ){
danielk19772f886d12009-02-28 10:47:41 +0000361 Trigger *pLink = pTrig;
362 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
drh21206082011-04-04 18:22:02 +0000363 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh55f66b32019-07-16 19:44:32 +0000364 assert( pLink!=0 );
drhacbcb7e2014-08-21 20:26:37 +0000365 pTrig = sqlite3HashInsert(pHash, zName, pTrig);
danielk19772f886d12009-02-28 10:47:41 +0000366 if( pTrig ){
drh4a642b62016-02-05 01:55:27 +0000367 sqlite3OomFault(db);
danielk19772f886d12009-02-28 10:47:41 +0000368 }else if( pLink->pSchema==pLink->pTabSchema ){
369 Table *pTab;
drhacbcb7e2014-08-21 20:26:37 +0000370 pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
danielk19772f886d12009-02-28 10:47:41 +0000371 assert( pTab!=0 );
372 pLink->pNext = pTab->pTrigger;
373 pTab->pTrigger = pLink;
danielk1977d5d56522005-03-16 12:15:20 +0000374 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000375 }
376
drhf0f258b2003-04-21 18:48:45 +0000377triggerfinish_cleanup:
drh633e6d52008-07-28 19:34:53 +0000378 sqlite3DeleteTrigger(db, pTrig);
danc9461ec2018-08-29 21:00:16 +0000379 assert( IN_RENAME_OBJECT || !pParse->pNewTrigger );
drh633e6d52008-07-28 19:34:53 +0000380 sqlite3DeleteTriggerStep(db, pStepList);
drh4b59ab52002-08-24 18:24:51 +0000381}
danielk1977c3f9bad2002-05-15 08:30:12 +0000382
drh4b59ab52002-08-24 18:24:51 +0000383/*
drhf259df52017-12-27 20:38:35 +0000384** Duplicate a range of text from an SQL statement, then convert all
385** whitespace characters into ordinary space characters.
386*/
387static char *triggerSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){
388 char *z = sqlite3DbSpanDup(db, zStart, zEnd);
389 int i;
390 if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' ';
391 return z;
392}
393
394/*
drhc977f7f2002-05-21 11:38:11 +0000395** Turn a SELECT statement (that the pSelect parameter points to) into
396** a trigger step. Return a pointer to a TriggerStep structure.
397**
398** The parser calls this routine when it finds a SELECT statement in
399** body of a TRIGGER.
400*/
drhf259df52017-12-27 20:38:35 +0000401TriggerStep *sqlite3TriggerSelectStep(
402 sqlite3 *db, /* Database connection */
403 Select *pSelect, /* The SELECT statement */
404 const char *zStart, /* Start of SQL text */
405 const char *zEnd /* End of SQL text */
406){
drh17435752007-08-16 04:30:38 +0000407 TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
danielk19772e588c72005-12-09 14:25:08 +0000408 if( pTriggerStep==0 ) {
drh633e6d52008-07-28 19:34:53 +0000409 sqlite3SelectDelete(db, pSelect);
danielk19772e588c72005-12-09 14:25:08 +0000410 return 0;
411 }
danielk1977633ed082002-05-17 00:05:58 +0000412 pTriggerStep->op = TK_SELECT;
drhb8352472021-01-29 19:32:17 +0000413 pTriggerStep->eTrigDest = SRT_Discard;
danielk1977633ed082002-05-17 00:05:58 +0000414 pTriggerStep->pSelect = pSelect;
415 pTriggerStep->orconf = OE_Default;
drhf259df52017-12-27 20:38:35 +0000416 pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
drhb7916a72009-05-27 10:31:29 +0000417 return pTriggerStep;
418}
danielk1977c3f9bad2002-05-15 08:30:12 +0000419
drhb7916a72009-05-27 10:31:29 +0000420/*
421** Allocate space to hold a new trigger step. The allocated space
422** holds both the TriggerStep object and the TriggerStep.target.z string.
423**
424** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
425*/
426static TriggerStep *triggerStepAllocate(
danc9461ec2018-08-29 21:00:16 +0000427 Parse *pParse, /* Parser context */
shane5eff7cf2009-08-10 03:57:58 +0000428 u8 op, /* Trigger opcode */
drhf259df52017-12-27 20:38:35 +0000429 Token *pName, /* The target name */
430 const char *zStart, /* Start of SQL text */
431 const char *zEnd /* End of SQL text */
drhb7916a72009-05-27 10:31:29 +0000432){
danc9461ec2018-08-29 21:00:16 +0000433 sqlite3 *db = pParse->db;
drhb7916a72009-05-27 10:31:29 +0000434 TriggerStep *pTriggerStep;
435
dan46408352015-04-21 16:38:49 +0000436 pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
drhb7916a72009-05-27 10:31:29 +0000437 if( pTriggerStep ){
438 char *z = (char*)&pTriggerStep[1];
439 memcpy(z, pName->z, pName->n);
dan46408352015-04-21 16:38:49 +0000440 sqlite3Dequote(z);
441 pTriggerStep->zTarget = z;
drhb7916a72009-05-27 10:31:29 +0000442 pTriggerStep->op = op;
drhf259df52017-12-27 20:38:35 +0000443 pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
danc9461ec2018-08-29 21:00:16 +0000444 if( IN_RENAME_OBJECT ){
445 sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName);
446 }
drhb7916a72009-05-27 10:31:29 +0000447 }
danielk1977633ed082002-05-17 00:05:58 +0000448 return pTriggerStep;
danielk1977c3f9bad2002-05-15 08:30:12 +0000449}
450
drhc977f7f2002-05-21 11:38:11 +0000451/*
452** Build a trigger step out of an INSERT statement. Return a pointer
453** to the new trigger step.
454**
455** The parser calls this routine when it sees an INSERT inside the
456** body of a trigger.
457*/
danielk19774adee202004-05-08 08:23:19 +0000458TriggerStep *sqlite3TriggerInsertStep(
dan5be60c52018-08-15 20:28:39 +0000459 Parse *pParse, /* Parser */
drhc977f7f2002-05-21 11:38:11 +0000460 Token *pTableName, /* Name of the table into which we insert */
461 IdList *pColumn, /* List of columns in pTableName to insert into */
drhc977f7f2002-05-21 11:38:11 +0000462 Select *pSelect, /* A SELECT statement that supplies values */
drhf259df52017-12-27 20:38:35 +0000463 u8 orconf, /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
drh46d2e5c2018-04-12 13:15:43 +0000464 Upsert *pUpsert, /* ON CONFLICT clauses for upsert */
drhf259df52017-12-27 20:38:35 +0000465 const char *zStart, /* Start of SQL text */
466 const char *zEnd /* End of SQL text */
danielk1977633ed082002-05-17 00:05:58 +0000467){
dan5be60c52018-08-15 20:28:39 +0000468 sqlite3 *db = pParse->db;
drhf3a65f72007-08-22 20:18:21 +0000469 TriggerStep *pTriggerStep;
danielk1977c3f9bad2002-05-15 08:30:12 +0000470
drh75593d92014-01-10 20:46:55 +0000471 assert(pSelect != 0 || db->mallocFailed);
danielk1977c3f9bad2002-05-15 08:30:12 +0000472
danc9461ec2018-08-29 21:00:16 +0000473 pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd);
danielk1977d5d56522005-03-16 12:15:20 +0000474 if( pTriggerStep ){
danc9461ec2018-08-29 21:00:16 +0000475 if( IN_RENAME_OBJECT ){
dan5be60c52018-08-15 20:28:39 +0000476 pTriggerStep->pSelect = pSelect;
477 pSelect = 0;
478 }else{
479 pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
480 }
danielk1977d5d56522005-03-16 12:15:20 +0000481 pTriggerStep->pIdList = pColumn;
drh46d2e5c2018-04-12 13:15:43 +0000482 pTriggerStep->pUpsert = pUpsert;
danielk1977d5d56522005-03-16 12:15:20 +0000483 pTriggerStep->orconf = orconf;
dan9105fd52019-08-19 17:26:32 +0000484 if( pUpsert ){
485 sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget);
486 }
danielk1977d5d56522005-03-16 12:15:20 +0000487 }else{
drh99160482018-04-18 01:34:39 +0000488 testcase( pColumn );
drh633e6d52008-07-28 19:34:53 +0000489 sqlite3IdListDelete(db, pColumn);
drh99160482018-04-18 01:34:39 +0000490 testcase( pUpsert );
drh46d2e5c2018-04-12 13:15:43 +0000491 sqlite3UpsertDelete(db, pUpsert);
danielk1977d5d56522005-03-16 12:15:20 +0000492 }
drh33e619f2009-05-28 01:00:55 +0000493 sqlite3SelectDelete(db, pSelect);
danielk1977c3f9bad2002-05-15 08:30:12 +0000494
danielk1977633ed082002-05-17 00:05:58 +0000495 return pTriggerStep;
danielk1977c3f9bad2002-05-15 08:30:12 +0000496}
497
drhc977f7f2002-05-21 11:38:11 +0000498/*
499** Construct a trigger step that implements an UPDATE statement and return
500** a pointer to that trigger step. The parser calls this routine when it
501** sees an UPDATE statement inside the body of a CREATE TRIGGER.
502*/
danielk19774adee202004-05-08 08:23:19 +0000503TriggerStep *sqlite3TriggerUpdateStep(
dan5be60c52018-08-15 20:28:39 +0000504 Parse *pParse, /* Parser */
drhc977f7f2002-05-21 11:38:11 +0000505 Token *pTableName, /* Name of the table to be updated */
dane7877b22020-07-14 19:51:01 +0000506 SrcList *pFrom,
drhc977f7f2002-05-21 11:38:11 +0000507 ExprList *pEList, /* The SET clause: list of column and new values */
508 Expr *pWhere, /* The WHERE clause */
drhf259df52017-12-27 20:38:35 +0000509 u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
510 const char *zStart, /* Start of SQL text */
511 const char *zEnd /* End of SQL text */
drhc977f7f2002-05-21 11:38:11 +0000512){
dan5be60c52018-08-15 20:28:39 +0000513 sqlite3 *db = pParse->db;
drhb7916a72009-05-27 10:31:29 +0000514 TriggerStep *pTriggerStep;
515
danc9461ec2018-08-29 21:00:16 +0000516 pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd);
drh33e619f2009-05-28 01:00:55 +0000517 if( pTriggerStep ){
danc9461ec2018-08-29 21:00:16 +0000518 if( IN_RENAME_OBJECT ){
dan5be60c52018-08-15 20:28:39 +0000519 pTriggerStep->pExprList = pEList;
520 pTriggerStep->pWhere = pWhere;
dane7877b22020-07-14 19:51:01 +0000521 pTriggerStep->pFrom = pFrom;
dan5be60c52018-08-15 20:28:39 +0000522 pEList = 0;
523 pWhere = 0;
dane7877b22020-07-14 19:51:01 +0000524 pFrom = 0;
dan5be60c52018-08-15 20:28:39 +0000525 }else{
526 pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
527 pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
dane7877b22020-07-14 19:51:01 +0000528 pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
dan5be60c52018-08-15 20:28:39 +0000529 }
drh33e619f2009-05-28 01:00:55 +0000530 pTriggerStep->orconf = orconf;
drh0e3a6f32007-03-30 20:40:34 +0000531 }
drh33e619f2009-05-28 01:00:55 +0000532 sqlite3ExprListDelete(db, pEList);
533 sqlite3ExprDelete(db, pWhere);
dane7877b22020-07-14 19:51:01 +0000534 sqlite3SrcListDelete(db, pFrom);
danielk1977633ed082002-05-17 00:05:58 +0000535 return pTriggerStep;
danielk1977c3f9bad2002-05-15 08:30:12 +0000536}
537
drhc977f7f2002-05-21 11:38:11 +0000538/*
539** Construct a trigger step that implements a DELETE statement and return
540** a pointer to that trigger step. The parser calls this routine when it
541** sees a DELETE statement inside the body of a CREATE TRIGGER.
542*/
drh17435752007-08-16 04:30:38 +0000543TriggerStep *sqlite3TriggerDeleteStep(
dan5be60c52018-08-15 20:28:39 +0000544 Parse *pParse, /* Parser */
drh17435752007-08-16 04:30:38 +0000545 Token *pTableName, /* The table from which rows are deleted */
drhf259df52017-12-27 20:38:35 +0000546 Expr *pWhere, /* The WHERE clause */
547 const char *zStart, /* Start of SQL text */
548 const char *zEnd /* End of SQL text */
drh17435752007-08-16 04:30:38 +0000549){
dan5be60c52018-08-15 20:28:39 +0000550 sqlite3 *db = pParse->db;
drhb7916a72009-05-27 10:31:29 +0000551 TriggerStep *pTriggerStep;
552
danc9461ec2018-08-29 21:00:16 +0000553 pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd);
drh33e619f2009-05-28 01:00:55 +0000554 if( pTriggerStep ){
danc9461ec2018-08-29 21:00:16 +0000555 if( IN_RENAME_OBJECT ){
dan5be60c52018-08-15 20:28:39 +0000556 pTriggerStep->pWhere = pWhere;
557 pWhere = 0;
558 }else{
559 pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
560 }
drh33e619f2009-05-28 01:00:55 +0000561 pTriggerStep->orconf = OE_Default;
drhb63a53d2007-03-31 01:34:44 +0000562 }
drh33e619f2009-05-28 01:00:55 +0000563 sqlite3ExprDelete(db, pWhere);
danielk1977633ed082002-05-17 00:05:58 +0000564 return pTriggerStep;
danielk1977c3f9bad2002-05-15 08:30:12 +0000565}
566
danielk1977633ed082002-05-17 00:05:58 +0000567/*
568** Recursively delete a Trigger structure
569*/
drh633e6d52008-07-28 19:34:53 +0000570void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
drhf0f258b2003-04-21 18:48:45 +0000571 if( pTrigger==0 ) return;
drhb8352472021-01-29 19:32:17 +0000572 assert( !pTrigger->bReturning );
drh633e6d52008-07-28 19:34:53 +0000573 sqlite3DeleteTriggerStep(db, pTrigger->step_list);
dan165921a2009-08-28 18:53:45 +0000574 sqlite3DbFree(db, pTrigger->zName);
drh633e6d52008-07-28 19:34:53 +0000575 sqlite3DbFree(db, pTrigger->table);
576 sqlite3ExprDelete(db, pTrigger->pWhen);
577 sqlite3IdListDelete(db, pTrigger->pColumns);
drh633e6d52008-07-28 19:34:53 +0000578 sqlite3DbFree(db, pTrigger);
danielk1977c3f9bad2002-05-15 08:30:12 +0000579}
580
581/*
danielk19778a414492004-06-29 08:59:35 +0000582** This function is called to drop a trigger from the database schema.
583**
584** This may be called directly from the parser and therefore identifies
585** the trigger by name. The sqlite3DropTriggerPtr() routine does the
586** same job as this routine except it takes a pointer to the trigger
587** instead of the trigger name.
588**/
drhfdd48a72006-09-11 23:45:48 +0000589void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
danielk1977742f9472004-06-16 12:02:43 +0000590 Trigger *pTrigger = 0;
drhd24cc422003-03-27 12:51:24 +0000591 int i;
592 const char *zDb;
593 const char *zName;
drh9bb575f2004-09-06 17:24:11 +0000594 sqlite3 *db = pParse->db;
danielk1977c3f9bad2002-05-15 08:30:12 +0000595
drh17435752007-08-16 04:30:38 +0000596 if( db->mallocFailed ) goto drop_trigger_cleanup;
danielk19778a414492004-06-29 08:59:35 +0000597 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977c0391392004-06-09 12:30:04 +0000598 goto drop_trigger_cleanup;
599 }
danielk19778e227872004-06-07 07:52:17 +0000600
drhd24cc422003-03-27 12:51:24 +0000601 assert( pName->nSrc==1 );
602 zDb = pName->a[0].zDatabase;
603 zName = pName->a[0].zName;
drh21206082011-04-04 18:22:02 +0000604 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
danielk197753c0f742005-03-29 03:10:59 +0000605 for(i=OMIT_TEMPDB; i<db->nDb; i++){
drh812d7a22003-03-27 13:50:00 +0000606 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
dan465c2b82020-03-21 15:10:40 +0000607 if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
drh21206082011-04-04 18:22:02 +0000608 assert( sqlite3SchemaMutexHeld(db, j, 0) );
drhacbcb7e2014-08-21 20:26:37 +0000609 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
drhd24cc422003-03-27 12:51:24 +0000610 if( pTrigger ) break;
danielk1977c3f9bad2002-05-15 08:30:12 +0000611 }
drhd24cc422003-03-27 12:51:24 +0000612 if( !pTrigger ){
drhfdd48a72006-09-11 23:45:48 +0000613 if( !noErr ){
614 sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
dan57966752011-04-09 17:32:58 +0000615 }else{
616 sqlite3CodeVerifyNamedSchema(pParse, zDb);
drhfdd48a72006-09-11 23:45:48 +0000617 }
dan1db95102010-06-28 10:15:19 +0000618 pParse->checkSchema = 1;
drhd24cc422003-03-27 12:51:24 +0000619 goto drop_trigger_cleanup;
620 }
drh74161702006-02-24 02:53:49 +0000621 sqlite3DropTriggerPtr(pParse, pTrigger);
drh79a519c2003-05-17 19:04:03 +0000622
623drop_trigger_cleanup:
drh633e6d52008-07-28 19:34:53 +0000624 sqlite3SrcListDelete(db, pName);
drh79a519c2003-05-17 19:04:03 +0000625}
626
627/*
drh956bc922004-07-24 17:38:29 +0000628** Return a pointer to the Table structure for the table that a trigger
629** is set on.
630*/
drh74161702006-02-24 02:53:49 +0000631static Table *tableOfTrigger(Trigger *pTrigger){
drhacbcb7e2014-08-21 20:26:37 +0000632 return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table);
drh956bc922004-07-24 17:38:29 +0000633}
634
635
636/*
drh74161702006-02-24 02:53:49 +0000637** Drop a trigger given a pointer to that trigger.
drh79a519c2003-05-17 19:04:03 +0000638*/
drh74161702006-02-24 02:53:49 +0000639void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
drh79a519c2003-05-17 19:04:03 +0000640 Table *pTable;
641 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +0000642 sqlite3 *db = pParse->db;
drh956bc922004-07-24 17:38:29 +0000643 int iDb;
drh79a519c2003-05-17 19:04:03 +0000644
danielk1977da184232006-01-05 11:34:32 +0000645 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
drh956bc922004-07-24 17:38:29 +0000646 assert( iDb>=0 && iDb<db->nDb );
drh74161702006-02-24 02:53:49 +0000647 pTable = tableOfTrigger(pTrigger);
drh6397a782019-08-27 10:05:45 +0000648 assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
drhe5f9c642003-01-13 23:27:31 +0000649#ifndef SQLITE_OMIT_AUTHORIZATION
drh6397a782019-08-27 10:05:45 +0000650 if( pTable ){
drhe5f9c642003-01-13 23:27:31 +0000651 int code = SQLITE_DROP_TRIGGER;
drh69c33822016-08-18 14:33:11 +0000652 const char *zDb = db->aDb[iDb].zDbSName;
drh956bc922004-07-24 17:38:29 +0000653 const char *zTab = SCHEMA_TABLE(iDb);
654 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
dan2bd93512009-08-31 08:22:46 +0000655 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
danielk19774adee202004-05-08 08:23:19 +0000656 sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
drh79a519c2003-05-17 19:04:03 +0000657 return;
drhe5f9c642003-01-13 23:27:31 +0000658 }
drhed6c8672003-01-12 18:02:16 +0000659 }
drhe5f9c642003-01-13 23:27:31 +0000660#endif
danielk1977c3f9bad2002-05-15 08:30:12 +0000661
drhf0f258b2003-04-21 18:48:45 +0000662 /* Generate code to destroy the database record of the trigger.
663 */
drh43617e92006-03-06 20:55:46 +0000664 if( (v = sqlite3GetVdbe(pParse))!=0 ){
drh8c8dddc2015-12-09 16:26:38 +0000665 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +0000666 "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'",
667 db->aDb[iDb].zDbSName, pTrigger->zName
drh8c8dddc2015-12-09 16:26:38 +0000668 );
drh9cbf3422008-01-17 16:22:13 +0000669 sqlite3ChangeCookie(pParse, iDb);
dan165921a2009-08-28 18:53:45 +0000670 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
drhf0f258b2003-04-21 18:48:45 +0000671 }
drh956bc922004-07-24 17:38:29 +0000672}
drhf0f258b2003-04-21 18:48:45 +0000673
drh956bc922004-07-24 17:38:29 +0000674/*
675** Remove a trigger from the hash tables of the sqlite* pointer.
676*/
677void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
678 Trigger *pTrigger;
drh21206082011-04-04 18:22:02 +0000679 Hash *pHash;
680
681 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
682 pHash = &(db->aDb[iDb].pSchema->trigHash);
drhacbcb7e2014-08-21 20:26:37 +0000683 pTrigger = sqlite3HashInsert(pHash, zName, 0);
drh9ab4c2e2009-05-09 00:18:38 +0000684 if( ALWAYS(pTrigger) ){
danielk19772f886d12009-02-28 10:47:41 +0000685 if( pTrigger->pSchema==pTrigger->pTabSchema ){
686 Table *pTab = tableOfTrigger(pTrigger);
drh6397a782019-08-27 10:05:45 +0000687 if( pTab ){
688 Trigger **pp;
dan0232dad2019-12-03 03:34:06 +0000689 for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
690 if( *pp==pTrigger ){
691 *pp = (*pp)->pNext;
692 break;
693 }
694 }
drh6397a782019-08-27 10:05:45 +0000695 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000696 }
drh633e6d52008-07-28 19:34:53 +0000697 sqlite3DeleteTrigger(db, pTrigger);
drh8257aa82017-07-26 19:59:13 +0000698 db->mDbFlags |= DBFLAG_SchemaChange;
danielk1977c3f9bad2002-05-15 08:30:12 +0000699 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000700}
701
drhc977f7f2002-05-21 11:38:11 +0000702/*
703** pEList is the SET clause of an UPDATE statement. Each entry
704** in pEList is of the format <id>=<expr>. If any of the entries
705** in pEList have an <id> which matches an identifier in pIdList,
706** then return TRUE. If pIdList==NULL, then it is considered a
707** wildcard that matches anything. Likewise if pEList==NULL then
708** it matches anything so always return true. Return false only
709** if there is no match.
710*/
drh9ab4c2e2009-05-09 00:18:38 +0000711static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){
drhad2d8302002-05-24 20:31:36 +0000712 int e;
drh9ab4c2e2009-05-09 00:18:38 +0000713 if( pIdList==0 || NEVER(pEList==0) ) return 1;
drhad2d8302002-05-24 20:31:36 +0000714 for(e=0; e<pEList->nExpr; e++){
drh41cee662019-12-12 20:22:34 +0000715 if( sqlite3IdListIndex(pIdList, pEList->a[e].zEName)>=0 ) return 1;
danielk1977f29ce552002-05-19 23:43:12 +0000716 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000717 return 0;
718}
719
danielk1977c3f9bad2002-05-15 08:30:12 +0000720/*
danielk19772f886d12009-02-28 10:47:41 +0000721** Return a list of all triggers on table pTab if there exists at least
722** one trigger that must be fired when an operation of type 'op' is
723** performed on the table, and, if that operation is an UPDATE, if at
724** least one of the columns in pChanges is being modified.
drhdca76842004-12-07 14:06:13 +0000725*/
danielk19772f886d12009-02-28 10:47:41 +0000726Trigger *sqlite3TriggersExist(
727 Parse *pParse, /* Parse context */
drhdca76842004-12-07 14:06:13 +0000728 Table *pTab, /* The table the contains the triggers */
danielk1977633ed082002-05-17 00:05:58 +0000729 int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
danielk19772f886d12009-02-28 10:47:41 +0000730 ExprList *pChanges, /* Columns that change in an UPDATE statement */
731 int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
drhc977f7f2002-05-21 11:38:11 +0000732){
drhdca76842004-12-07 14:06:13 +0000733 int mask = 0;
drhe83cafd2011-03-21 17:15:58 +0000734 Trigger *pList = 0;
danielk19772f886d12009-02-28 10:47:41 +0000735 Trigger *p;
drhe83cafd2011-03-21 17:15:58 +0000736
737 if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
738 pList = sqlite3TriggerList(pParse, pTab);
739 }
danielk19772f886d12009-02-28 10:47:41 +0000740 assert( pList==0 || IsVirtual(pTab)==0 );
741 for(p=pList; p; p=p->pNext){
drh9ab4c2e2009-05-09 00:18:38 +0000742 if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
danielk19772f886d12009-02-28 10:47:41 +0000743 mask |= p->tr_tm;
drhb8352472021-01-29 19:32:17 +0000744 }else if( p->op==TK_RETURNING ){
745 p->op = op;
746 mask |= TRIGGER_AFTER;
danielk1977c3f9bad2002-05-15 08:30:12 +0000747 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000748 }
danielk19772f886d12009-02-28 10:47:41 +0000749 if( pMask ){
750 *pMask = mask;
751 }
752 return (mask ? pList : 0);
danielk1977c3f9bad2002-05-15 08:30:12 +0000753}
754
drhc977f7f2002-05-21 11:38:11 +0000755/*
dan46408352015-04-21 16:38:49 +0000756** Convert the pStep->zTarget string into a SrcList and return a pointer
drhf26e09c2003-05-31 16:21:12 +0000757** to that SrcList.
758**
759** This routine adds a specific database name, if needed, to the target when
760** forming the SrcList. This prevents a trigger in one database from
761** referring to a target in another database. An exception is when the
762** trigger is in TEMP in which case it can refer to any other database it
763** wants.
764*/
dane7877b22020-07-14 19:51:01 +0000765SrcList *sqlite3TriggerStepSrc(
drhf26e09c2003-05-31 16:21:12 +0000766 Parse *pParse, /* The parsing context */
767 TriggerStep *pStep /* The trigger containing the target token */
768){
dan46408352015-04-21 16:38:49 +0000769 sqlite3 *db = pParse->db;
dane7877b22020-07-14 19:51:01 +0000770 SrcList *pSrc; /* SrcList to be returned */
771 char *zName = sqlite3DbStrDup(db, pStep->zTarget);
drh29c992c2019-01-17 15:40:41 +0000772 pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
dane7877b22020-07-14 19:51:01 +0000773 assert( pSrc==0 || pSrc->nSrc==1 );
774 assert( zName || pSrc==0 );
drhb7916a72009-05-27 10:31:29 +0000775 if( pSrc ){
dane7877b22020-07-14 19:51:01 +0000776 Schema *pSchema = pStep->pTrig->pSchema;
777 pSrc->a[0].zName = zName;
778 if( pSchema!=db->aDb[1].pSchema ){
779 pSrc->a[0].pSchema = pSchema;
drhb7916a72009-05-27 10:31:29 +0000780 }
dane7877b22020-07-14 19:51:01 +0000781 if( pStep->pFrom ){
782 SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
783 pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup);
784 }
785 }else{
786 sqlite3DbFree(db, zName);
drhf26e09c2003-05-31 16:21:12 +0000787 }
788 return pSrc;
789}
790
791/*
dan65a7cd12009-09-01 12:16:01 +0000792** Generate VDBE code for the statements inside the body of a single
793** trigger.
drhc977f7f2002-05-21 11:38:11 +0000794*/
danielk1977c3f9bad2002-05-15 08:30:12 +0000795static int codeTriggerProgram(
drhc977f7f2002-05-21 11:38:11 +0000796 Parse *pParse, /* The parser context */
797 TriggerStep *pStepList, /* List of statements inside the trigger body */
dan65a7cd12009-09-01 12:16:01 +0000798 int orconf /* Conflict algorithm. (OE_Abort, etc) */
danielk1977633ed082002-05-17 00:05:58 +0000799){
dan65a7cd12009-09-01 12:16:01 +0000800 TriggerStep *pStep;
drh344737f2004-09-19 00:50:20 +0000801 Vdbe *v = pParse->pVdbe;
drh17435752007-08-16 04:30:38 +0000802 sqlite3 *db = pParse->db;
danielk1977c3f9bad2002-05-15 08:30:12 +0000803
dan65a7cd12009-09-01 12:16:01 +0000804 assert( pParse->pTriggerTab && pParse->pToplevel );
805 assert( pStepList );
drh344737f2004-09-19 00:50:20 +0000806 assert( v!=0 );
dan65a7cd12009-09-01 12:16:01 +0000807 for(pStep=pStepList; pStep; pStep=pStep->pNext){
dan165921a2009-08-28 18:53:45 +0000808 /* Figure out the ON CONFLICT policy that will be used for this step
809 ** of the trigger program. If the statement that caused this trigger
810 ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
811 ** the ON CONFLICT policy that was specified as part of the trigger
812 ** step statement. Example:
813 **
814 ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
815 ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
816 ** END;
817 **
818 ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy
819 ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy
820 */
shanecea72b22009-09-07 04:38:36 +0000821 pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
drhaceb31b2014-02-08 01:40:27 +0000822 assert( pParse->okConstFactor==0 );
danf78baaf2012-12-06 19:37:22 +0000823
drhf259df52017-12-27 20:38:35 +0000824#ifndef SQLITE_OMIT_TRACE
drhe307e112017-12-27 21:30:34 +0000825 if( pStep->zSpan ){
826 sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0,
827 sqlite3MPrintf(db, "-- %s", pStep->zSpan),
828 P4_DYNAMIC);
829 }
drhf259df52017-12-27 20:38:35 +0000830#endif
831
dan165921a2009-08-28 18:53:45 +0000832 switch( pStep->op ){
danielk1977633ed082002-05-17 00:05:58 +0000833 case TK_UPDATE: {
dan165921a2009-08-28 18:53:45 +0000834 sqlite3Update(pParse,
dane7877b22020-07-14 19:51:01 +0000835 sqlite3TriggerStepSrc(pParse, pStep),
dan165921a2009-08-28 18:53:45 +0000836 sqlite3ExprListDup(db, pStep->pExprList, 0),
837 sqlite3ExprDup(db, pStep->pWhere, 0),
drheac9fab2018-04-16 13:00:50 +0000838 pParse->eOrconf, 0, 0, 0
dan165921a2009-08-28 18:53:45 +0000839 );
danielk1977633ed082002-05-17 00:05:58 +0000840 break;
841 }
842 case TK_INSERT: {
dan165921a2009-08-28 18:53:45 +0000843 sqlite3Insert(pParse,
dane7877b22020-07-14 19:51:01 +0000844 sqlite3TriggerStepSrc(pParse, pStep),
dan165921a2009-08-28 18:53:45 +0000845 sqlite3SelectDup(db, pStep->pSelect, 0),
846 sqlite3IdListDup(db, pStep->pIdList),
drh46d2e5c2018-04-12 13:15:43 +0000847 pParse->eOrconf,
848 sqlite3UpsertDup(db, pStep->pUpsert)
dan165921a2009-08-28 18:53:45 +0000849 );
danielk1977633ed082002-05-17 00:05:58 +0000850 break;
851 }
852 case TK_DELETE: {
dan165921a2009-08-28 18:53:45 +0000853 sqlite3DeleteFrom(pParse,
dane7877b22020-07-14 19:51:01 +0000854 sqlite3TriggerStepSrc(pParse, pStep),
drh8c0833f2017-11-14 23:48:23 +0000855 sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0
dan165921a2009-08-28 18:53:45 +0000856 );
danielk1977633ed082002-05-17 00:05:58 +0000857 break;
858 }
dan165921a2009-08-28 18:53:45 +0000859 default: assert( pStep->op==TK_SELECT ); {
860 SelectDest sDest;
861 Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0);
drhb8352472021-01-29 19:32:17 +0000862 sqlite3SelectDestInit(&sDest, pStep->eTrigDest, 0);
dan165921a2009-08-28 18:53:45 +0000863 sqlite3Select(pParse, pSelect, &sDest);
864 sqlite3SelectDelete(db, pSelect);
drh9ab4c2e2009-05-09 00:18:38 +0000865 break;
866 }
danielk1977633ed082002-05-17 00:05:58 +0000867 }
dan76d462e2009-08-30 11:42:51 +0000868 if( pStep->op!=TK_SELECT ){
drhb7f1d9a2009-09-08 02:27:58 +0000869 sqlite3VdbeAddOp0(v, OP_ResetCount);
dan76d462e2009-08-30 11:42:51 +0000870 }
danielk1977633ed082002-05-17 00:05:58 +0000871 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000872
danielk1977633ed082002-05-17 00:05:58 +0000873 return 0;
danielk1977c3f9bad2002-05-15 08:30:12 +0000874}
875
drhc7379ce2013-10-30 02:28:23 +0000876#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
dan165921a2009-08-28 18:53:45 +0000877/*
878** This function is used to add VdbeComment() annotations to a VDBE
879** program. It is not used in production code, only for debugging.
880*/
881static const char *onErrorText(int onError){
882 switch( onError ){
883 case OE_Abort: return "abort";
884 case OE_Rollback: return "rollback";
885 case OE_Fail: return "fail";
886 case OE_Replace: return "replace";
887 case OE_Ignore: return "ignore";
888 case OE_Default: return "default";
889 }
890 return "n/a";
891}
892#endif
893
894/*
895** Parse context structure pFrom has just been used to create a sub-vdbe
896** (trigger program). If an error has occurred, transfer error information
897** from pFrom to pTo.
898*/
899static void transferParseError(Parse *pTo, Parse *pFrom){
900 assert( pFrom->zErrMsg==0 || pFrom->nErr );
901 assert( pTo->zErrMsg==0 || pTo->nErr );
902 if( pTo->nErr==0 ){
903 pTo->zErrMsg = pFrom->zErrMsg;
904 pTo->nErr = pFrom->nErr;
drhe06874e2015-04-16 15:47:06 +0000905 pTo->rc = pFrom->rc;
dan165921a2009-08-28 18:53:45 +0000906 }else{
907 sqlite3DbFree(pFrom->db, pFrom->zErrMsg);
908 }
909}
910
dan65a7cd12009-09-01 12:16:01 +0000911/*
912** Create and populate a new TriggerPrg object with a sub-program
913** implementing trigger pTrigger with ON CONFLICT policy orconf.
914*/
dan2832ad42009-08-31 15:27:27 +0000915static TriggerPrg *codeRowTrigger(
dan165921a2009-08-28 18:53:45 +0000916 Parse *pParse, /* Current parse context */
917 Trigger *pTrigger, /* Trigger to code */
dan65a7cd12009-09-01 12:16:01 +0000918 Table *pTab, /* The table pTrigger is attached to */
919 int orconf /* ON CONFLICT policy to code trigger program with */
dan165921a2009-08-28 18:53:45 +0000920){
dan65a7cd12009-09-01 12:16:01 +0000921 Parse *pTop = sqlite3ParseToplevel(pParse);
922 sqlite3 *db = pParse->db; /* Database handle */
923 TriggerPrg *pPrg; /* Value to return */
dan165921a2009-08-28 18:53:45 +0000924 Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */
925 Vdbe *v; /* Temporary VM */
dan165921a2009-08-28 18:53:45 +0000926 NameContext sNC; /* Name context for sub-vdbe */
927 SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */
928 Parse *pSubParse; /* Parse context for sub-vdbe */
929 int iEndTrigger = 0; /* Label to jump to if WHEN is false */
930
dan1da40a32009-09-19 17:00:31 +0000931 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
dand19c9332010-07-26 12:05:17 +0000932 assert( pTop->pVdbe );
dan65a7cd12009-09-01 12:16:01 +0000933
934 /* Allocate the TriggerPrg and SubProgram objects. To ensure that they
935 ** are freed if an error occurs, link them into the Parse.pTriggerPrg
936 ** list of the top-level Parse object sooner rather than later. */
dan2832ad42009-08-31 15:27:27 +0000937 pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg));
938 if( !pPrg ) return 0;
dan65a7cd12009-09-01 12:16:01 +0000939 pPrg->pNext = pTop->pTriggerPrg;
940 pTop->pTriggerPrg = pPrg;
dan2832ad42009-08-31 15:27:27 +0000941 pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));
dan165921a2009-08-28 18:53:45 +0000942 if( !pProgram ) return 0;
dand19c9332010-07-26 12:05:17 +0000943 sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram);
dan2832ad42009-08-31 15:27:27 +0000944 pPrg->pTrigger = pTrigger;
945 pPrg->orconf = orconf;
danbb5f1682009-11-27 12:12:34 +0000946 pPrg->aColmask[0] = 0xffffffff;
947 pPrg->aColmask[1] = 0xffffffff;
dan165921a2009-08-28 18:53:45 +0000948
dan65a7cd12009-09-01 12:16:01 +0000949 /* Allocate and populate a new Parse context to use for coding the
950 ** trigger sub-program. */
951 pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
952 if( !pSubParse ) return 0;
dan165921a2009-08-28 18:53:45 +0000953 memset(&sNC, 0, sizeof(sNC));
954 sNC.pParse = pSubParse;
955 pSubParse->db = db;
956 pSubParse->pTriggerTab = pTab;
dan65a7cd12009-09-01 12:16:01 +0000957 pSubParse->pToplevel = pTop;
dan2bd93512009-08-31 08:22:46 +0000958 pSubParse->zAuthContext = pTrigger->zName;
dan65a7cd12009-09-01 12:16:01 +0000959 pSubParse->eTriggerOp = pTrigger->op;
drhb8352472021-01-29 19:32:17 +0000960 pSubParse->bReturning = pTrigger->bReturning;
drh8b307fb2010-04-06 15:57:05 +0000961 pSubParse->nQueryLoop = pParse->nQueryLoop;
dan1ea04432018-12-21 19:29:11 +0000962 pSubParse->disableVtab = pParse->disableVtab;
dan165921a2009-08-28 18:53:45 +0000963
964 v = sqlite3GetVdbe(pSubParse);
965 if( v ){
dan76d462e2009-08-30 11:42:51 +0000966 VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",
967 pTrigger->zName, onErrorText(orconf),
dan165921a2009-08-28 18:53:45 +0000968 (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
dan65a7cd12009-09-01 12:16:01 +0000969 (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
970 (pTrigger->op==TK_INSERT ? "INSERT" : ""),
971 (pTrigger->op==TK_DELETE ? "DELETE" : ""),
dan76d462e2009-08-30 11:42:51 +0000972 pTab->zName
dan165921a2009-08-28 18:53:45 +0000973 ));
dan76d462e2009-08-30 11:42:51 +0000974#ifndef SQLITE_OMIT_TRACE
drhe307e112017-12-27 21:30:34 +0000975 if( pTrigger->zName ){
976 sqlite3VdbeChangeP4(v, -1,
977 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
978 );
979 }
dan76d462e2009-08-30 11:42:51 +0000980#endif
dan165921a2009-08-28 18:53:45 +0000981
dan65a7cd12009-09-01 12:16:01 +0000982 /* If one was specified, code the WHEN clause. If it evaluates to false
983 ** (or NULL) the sub-vdbe is immediately halted by jumping to the
984 ** OP_Halt inserted at the end of the program. */
dan165921a2009-08-28 18:53:45 +0000985 if( pTrigger->pWhen ){
dan165921a2009-08-28 18:53:45 +0000986 pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
dan523a0872009-08-31 05:23:32 +0000987 if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
988 && db->mallocFailed==0
989 ){
drhec4ccdb2018-12-29 02:26:59 +0000990 iEndTrigger = sqlite3VdbeMakeLabel(pSubParse);
dan165921a2009-08-28 18:53:45 +0000991 sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
992 }
993 sqlite3ExprDelete(db, pWhen);
994 }
995
996 /* Code the trigger program into the sub-vdbe. */
dan76d462e2009-08-30 11:42:51 +0000997 codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);
dan65a7cd12009-09-01 12:16:01 +0000998
999 /* Insert an OP_Halt at the end of the sub-program. */
dan165921a2009-08-28 18:53:45 +00001000 if( iEndTrigger ){
1001 sqlite3VdbeResolveLabel(v, iEndTrigger);
1002 }
1003 sqlite3VdbeAddOp0(v, OP_Halt);
dan76d462e2009-08-30 11:42:51 +00001004 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
1005
dan165921a2009-08-28 18:53:45 +00001006 transferParseError(pParse, pSubParse);
dan08951172017-11-28 20:43:40 +00001007 if( db->mallocFailed==0 && pParse->nErr==0 ){
dan65a7cd12009-09-01 12:16:01 +00001008 pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
dan523a0872009-08-31 05:23:32 +00001009 }
drhb8352472021-01-29 19:32:17 +00001010 if( pTrigger->bReturning ){
1011 sqlite3VdbeColumnInfoXfer(pParse->pVdbe, v);
1012 }
dan165921a2009-08-28 18:53:45 +00001013 pProgram->nMem = pSubParse->nMem;
1014 pProgram->nCsr = pSubParse->nTab;
1015 pProgram->token = (void *)pTrigger;
danbb5f1682009-11-27 12:12:34 +00001016 pPrg->aColmask[0] = pSubParse->oldmask;
1017 pPrg->aColmask[1] = pSubParse->newmask;
dan165921a2009-08-28 18:53:45 +00001018 sqlite3VdbeDelete(v);
dan165921a2009-08-28 18:53:45 +00001019 }
dan65a7cd12009-09-01 12:16:01 +00001020
dan65a7cd12009-09-01 12:16:01 +00001021 assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
drhf30a9692013-11-15 01:10:18 +00001022 sqlite3ParserReset(pSubParse);
dan165921a2009-08-28 18:53:45 +00001023 sqlite3StackFree(db, pSubParse);
1024
dan2832ad42009-08-31 15:27:27 +00001025 return pPrg;
dan165921a2009-08-28 18:53:45 +00001026}
1027
dan65a7cd12009-09-01 12:16:01 +00001028/*
1029** Return a pointer to a TriggerPrg object containing the sub-program for
1030** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such
1031** TriggerPrg object exists, a new object is allocated and populated before
1032** being returned.
1033*/
dan2832ad42009-08-31 15:27:27 +00001034static TriggerPrg *getRowTrigger(
dan65a7cd12009-09-01 12:16:01 +00001035 Parse *pParse, /* Current parse context */
dan165921a2009-08-28 18:53:45 +00001036 Trigger *pTrigger, /* Trigger to code */
dan65a7cd12009-09-01 12:16:01 +00001037 Table *pTab, /* The table trigger pTrigger is attached to */
1038 int orconf /* ON CONFLICT algorithm. */
dan165921a2009-08-28 18:53:45 +00001039){
dan65a7cd12009-09-01 12:16:01 +00001040 Parse *pRoot = sqlite3ParseToplevel(pParse);
dan2832ad42009-08-31 15:27:27 +00001041 TriggerPrg *pPrg;
dan65a7cd12009-09-01 12:16:01 +00001042
dan1da40a32009-09-19 17:00:31 +00001043 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
dan165921a2009-08-28 18:53:45 +00001044
1045 /* It may be that this trigger has already been coded (or is in the
1046 ** process of being coded). If this is the case, then an entry with
dan2832ad42009-08-31 15:27:27 +00001047 ** a matching TriggerPrg.pTrigger field will be present somewhere
1048 ** in the Parse.pTriggerPrg list. Search for such an entry. */
dan2832ad42009-08-31 15:27:27 +00001049 for(pPrg=pRoot->pTriggerPrg;
1050 pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf);
1051 pPrg=pPrg->pNext
dan165921a2009-08-28 18:53:45 +00001052 );
1053
dan65a7cd12009-09-01 12:16:01 +00001054 /* If an existing TriggerPrg could not be located, create a new one. */
dan2832ad42009-08-31 15:27:27 +00001055 if( !pPrg ){
dan65a7cd12009-09-01 12:16:01 +00001056 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
dan165921a2009-08-28 18:53:45 +00001057 }
1058
dan2832ad42009-08-31 15:27:27 +00001059 return pPrg;
dan165921a2009-08-28 18:53:45 +00001060}
1061
dan94d7f502009-09-24 09:05:49 +00001062/*
1063** Generate code for the trigger program associated with trigger p on
1064** table pTab. The reg, orconf and ignoreJump parameters passed to this
1065** function are the same as those described in the header function for
1066** sqlite3CodeRowTrigger()
1067*/
dan1da40a32009-09-19 17:00:31 +00001068void sqlite3CodeRowTriggerDirect(
1069 Parse *pParse, /* Parse context */
1070 Trigger *p, /* Trigger to code */
1071 Table *pTab, /* The table to code triggers from */
dan94d7f502009-09-24 09:05:49 +00001072 int reg, /* Reg array containing OLD.* and NEW.* values */
dan1da40a32009-09-19 17:00:31 +00001073 int orconf, /* ON CONFLICT policy */
1074 int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */
1075){
1076 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
1077 TriggerPrg *pPrg;
1078 pPrg = getRowTrigger(pParse, p, pTab, orconf);
1079 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
1080
1081 /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program
1082 ** is a pointer to the sub-vdbe containing the trigger program. */
1083 if( pPrg ){
dand19c9332010-07-26 12:05:17 +00001084 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
1085
drh9b34abe2016-01-16 15:12:35 +00001086 sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
1087 (const char *)pPrg->pProgram, P4_SUBPROGRAM);
dan1da40a32009-09-19 17:00:31 +00001088 VdbeComment(
1089 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
1090
1091 /* Set the P5 operand of the OP_Program instruction to non-zero if
1092 ** recursive invocation of this trigger program is disallowed. Recursive
1093 ** invocation is disallowed if (a) the sub-program is really a trigger,
1094 ** not a foreign key action, and (b) the flag to enable recursive triggers
1095 ** is clear. */
dand19c9332010-07-26 12:05:17 +00001096 sqlite3VdbeChangeP5(v, (u8)bRecursive);
dan1da40a32009-09-19 17:00:31 +00001097 }
1098}
1099
danielk1977633ed082002-05-17 00:05:58 +00001100/*
dan94d7f502009-09-24 09:05:49 +00001101** This is called to code the required FOR EACH ROW triggers for an operation
1102** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
drhf7b54962013-05-28 12:11:54 +00001103** is given by the op parameter. The tr_tm parameter determines whether the
dan94d7f502009-09-24 09:05:49 +00001104** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
1105** parameter pChanges is passed the list of columns being modified.
danielk1977633ed082002-05-17 00:05:58 +00001106**
dan94d7f502009-09-24 09:05:49 +00001107** If there are no triggers that fire at the specified time for the specified
1108** operation on pTab, this function is a no-op.
drhc977f7f2002-05-21 11:38:11 +00001109**
dan94d7f502009-09-24 09:05:49 +00001110** The reg argument is the address of the first in an array of registers
1111** that contain the values substituted for the new.* and old.* references
1112** in the trigger program. If N is the number of columns in table pTab
1113** (a copy of pTab->nCol), then registers are populated as follows:
drhc977f7f2002-05-21 11:38:11 +00001114**
dan94d7f502009-09-24 09:05:49 +00001115** Register Contains
1116** ------------------------------------------------------
1117** reg+0 OLD.rowid
1118** reg+1 OLD.* value of left-most column of pTab
1119** ... ...
1120** reg+N OLD.* value of right-most column of pTab
1121** reg+N+1 NEW.rowid
1122** reg+N+2 OLD.* value of left-most column of pTab
1123** ... ...
1124** reg+N+N+1 NEW.* value of right-most column of pTab
drhc977f7f2002-05-21 11:38:11 +00001125**
dan94d7f502009-09-24 09:05:49 +00001126** For ON DELETE triggers, the registers containing the NEW.* values will
1127** never be accessed by the trigger program, so they are not allocated or
1128** populated by the caller (there is no data to populate them with anyway).
1129** Similarly, for ON INSERT triggers the values stored in the OLD.* registers
1130** are never accessed, and so are not allocated by the caller. So, for an
1131** ON INSERT trigger, the value passed to this function as parameter reg
1132** is not a readable register, although registers (reg+N) through
1133** (reg+N+N+1) are.
danielk1977633ed082002-05-17 00:05:58 +00001134**
dan94d7f502009-09-24 09:05:49 +00001135** Parameter orconf is the default conflict resolution algorithm for the
1136** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump
1137** is the instruction that control should jump to if a trigger program
1138** raises an IGNORE exception.
danielk1977633ed082002-05-17 00:05:58 +00001139*/
dan165921a2009-08-28 18:53:45 +00001140void sqlite3CodeRowTrigger(
danielk1977633ed082002-05-17 00:05:58 +00001141 Parse *pParse, /* Parse context */
danielk19772f886d12009-02-28 10:47:41 +00001142 Trigger *pTrigger, /* List of triggers on table pTab */
danielk1977633ed082002-05-17 00:05:58 +00001143 int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
1144 ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
drhdca76842004-12-07 14:06:13 +00001145 int tr_tm, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
danielk1977633ed082002-05-17 00:05:58 +00001146 Table *pTab, /* The table to code triggers from */
dan94d7f502009-09-24 09:05:49 +00001147 int reg, /* The first in an array of registers (see above) */
danielk19776f349032002-06-11 02:25:40 +00001148 int orconf, /* ON CONFLICT policy */
dan165921a2009-08-28 18:53:45 +00001149 int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */
drhc977f7f2002-05-21 11:38:11 +00001150){
dan94d7f502009-09-24 09:05:49 +00001151 Trigger *p; /* Used to iterate through pTrigger list */
danielk19778f2c54e2008-01-01 19:02:09 +00001152
dan94d7f502009-09-24 09:05:49 +00001153 assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
1154 assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
1155 assert( (op==TK_UPDATE)==(pChanges!=0) );
danielk1977c3f9bad2002-05-15 08:30:12 +00001156
danielk19772f886d12009-02-28 10:47:41 +00001157 for(p=pTrigger; p; p=p->pNext){
danielk1977c3f9bad2002-05-15 08:30:12 +00001158
drh9ab4c2e2009-05-09 00:18:38 +00001159 /* Sanity checking: The schema for the trigger and for the table are
1160 ** always defined. The trigger must be in the same schema as the table
1161 ** or else it must be a TEMP trigger. */
1162 assert( p->pSchema!=0 );
1163 assert( p->pTabSchema!=0 );
dan165921a2009-08-28 18:53:45 +00001164 assert( p->pSchema==p->pTabSchema
1165 || p->pSchema==pParse->db->aDb[1].pSchema );
drh9ab4c2e2009-05-09 00:18:38 +00001166
danielk1977eecfb3e2006-01-10 12:31:39 +00001167 /* Determine whether we should code this trigger */
dan165921a2009-08-28 18:53:45 +00001168 if( p->op==op
1169 && p->tr_tm==tr_tm
dan94d7f502009-09-24 09:05:49 +00001170 && checkColumnOverlap(p->pColumns, pChanges)
danielk1977eecfb3e2006-01-10 12:31:39 +00001171 ){
dan94d7f502009-09-24 09:05:49 +00001172 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
danielk1977c3f9bad2002-05-15 08:30:12 +00001173 }
danielk1977c3f9bad2002-05-15 08:30:12 +00001174 }
danielk1977c3f9bad2002-05-15 08:30:12 +00001175}
dan165921a2009-08-28 18:53:45 +00001176
dan2832ad42009-08-31 15:27:27 +00001177/*
danbb5f1682009-11-27 12:12:34 +00001178** Triggers may access values stored in the old.* or new.* pseudo-table.
1179** This function returns a 32-bit bitmask indicating which columns of the
1180** old.* or new.* tables actually are used by triggers. This information
1181** may be used by the caller, for example, to avoid having to load the entire
1182** old.* record into memory when executing an UPDATE or DELETE command.
dan2832ad42009-08-31 15:27:27 +00001183**
1184** Bit 0 of the returned mask is set if the left-most column of the
danbb5f1682009-11-27 12:12:34 +00001185** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
dan2832ad42009-08-31 15:27:27 +00001186** the second leftmost column value is required, and so on. If there
1187** are more than 32 columns in the table, and at least one of the columns
1188** with an index greater than 32 may be accessed, 0xffffffff is returned.
1189**
danbb5f1682009-11-27 12:12:34 +00001190** It is not possible to determine if the old.rowid or new.rowid column is
1191** accessed by triggers. The caller must always assume that it is.
dan2832ad42009-08-31 15:27:27 +00001192**
danbb5f1682009-11-27 12:12:34 +00001193** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
1194** applies to the old.* table. If 1, the new.* table.
1195**
1196** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
1197** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only
1198** included in the returned mask if the TRIGGER_BEFORE bit is set in the
1199** tr_tm parameter. Similarly, values accessed by AFTER triggers are only
1200** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
dan2832ad42009-08-31 15:27:27 +00001201*/
danbb5f1682009-11-27 12:12:34 +00001202u32 sqlite3TriggerColmask(
dan165921a2009-08-28 18:53:45 +00001203 Parse *pParse, /* Parse context */
1204 Trigger *pTrigger, /* List of triggers on table pTab */
dan165921a2009-08-28 18:53:45 +00001205 ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
danbb5f1682009-11-27 12:12:34 +00001206 int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */
1207 int tr_tm, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
dan165921a2009-08-28 18:53:45 +00001208 Table *pTab, /* The table to code triggers from */
dan2832ad42009-08-31 15:27:27 +00001209 int orconf /* Default ON CONFLICT policy for trigger steps */
dan165921a2009-08-28 18:53:45 +00001210){
dan1da40a32009-09-19 17:00:31 +00001211 const int op = pChanges ? TK_UPDATE : TK_DELETE;
dan2832ad42009-08-31 15:27:27 +00001212 u32 mask = 0;
dan165921a2009-08-28 18:53:45 +00001213 Trigger *p;
dan165921a2009-08-28 18:53:45 +00001214
danbb5f1682009-11-27 12:12:34 +00001215 assert( isNew==1 || isNew==0 );
dan165921a2009-08-28 18:53:45 +00001216 for(p=pTrigger; p; p=p->pNext){
danbb5f1682009-11-27 12:12:34 +00001217 if( p->op==op && (tr_tm&p->tr_tm)
1218 && checkColumnOverlap(p->pColumns,pChanges)
1219 ){
dan2832ad42009-08-31 15:27:27 +00001220 TriggerPrg *pPrg;
dan65a7cd12009-09-01 12:16:01 +00001221 pPrg = getRowTrigger(pParse, p, pTab, orconf);
dan2832ad42009-08-31 15:27:27 +00001222 if( pPrg ){
danbb5f1682009-11-27 12:12:34 +00001223 mask |= pPrg->aColmask[isNew];
dan165921a2009-08-28 18:53:45 +00001224 }
1225 }
1226 }
dan2832ad42009-08-31 15:27:27 +00001227
1228 return mask;
dan165921a2009-08-28 18:53:45 +00001229}
1230
drhb7f91642004-10-31 02:22:47 +00001231#endif /* !defined(SQLITE_OMIT_TRIGGER) */