3 ** The author disclaims copyright to this source code. In place of
4 ** a legal notice, here is a blessing:
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.
10 *************************************************************************
11 ** This file contains the implementation for TRIGGERs
13 #include "sqliteInt.h"
15 #ifndef SQLITE_OMIT_TRIGGER
17 ** Delete a linked list of TriggerStep structures.
19 void sqlite3DeleteTriggerStep(sqlite3
*db
, TriggerStep
*pTriggerStep
){
20 while( pTriggerStep
){
21 TriggerStep
* pTmp
= pTriggerStep
;
22 pTriggerStep
= pTriggerStep
->pNext
;
24 sqlite3ExprDelete(db
, pTmp
->pWhere
);
25 sqlite3ExprListDelete(db
, pTmp
->pExprList
);
26 sqlite3SelectDelete(db
, pTmp
->pSelect
);
27 sqlite3IdListDelete(db
, pTmp
->pIdList
);
28 sqlite3UpsertDelete(db
, pTmp
->pUpsert
);
29 sqlite3DbFree(db
, pTmp
->zSpan
);
31 sqlite3DbFree(db
, pTmp
);
36 ** Given table pTab, return a list of all the triggers attached to
37 ** the table. The list is connected by Trigger.pNext pointers.
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.
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.
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 */
53 if( pParse
->disableTriggers
){
57 if( pTmpSchema
!=pTab
->pSchema
){
59 assert( sqlite3SchemaMutexHeld(pParse
->db
, 0, pTmpSchema
) );
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
)
65 pTrig
->pNext
= (pList
? pList
: pTab
->pTrigger
);
71 return (pList
? pList
: pTab
->pTrigger
);
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
79 ** sqlite3FinishTrigger() function is called to complete the trigger
80 ** construction process.
82 void sqlite3BeginTrigger(
83 Parse
*pParse
, /* The parse context of the CREATE TRIGGER statement */
84 Token
*pName1
, /* The name of the trigger */
85 Token
*pName2
, /* The name of the trigger */
86 int tr_tm
, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */
87 int op
, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
88 IdList
*pColumns
, /* column list if this is an UPDATE OF trigger */
89 SrcList
*pTableName
,/* The name of the table/view the trigger applies to */
90 Expr
*pWhen
, /* WHEN clause */
91 int isTemp
, /* True if the TEMPORARY keyword is present */
92 int noErr
/* Suppress errors if the trigger already exists */
94 Trigger
*pTrigger
= 0; /* The new trigger */
95 Table
*pTab
; /* Table that the trigger fires off of */
96 char *zName
= 0; /* Name of the trigger */
97 sqlite3
*db
= pParse
->db
; /* The database connection */
98 int iDb
; /* The database to store the trigger in */
99 Token
*pName
; /* The unqualified db name */
100 DbFixer sFix
; /* State vector for the DB fixer */
102 assert( pName1
!=0 ); /* pName1->z might be NULL, but not pName1 itself */
104 assert( op
==TK_INSERT
|| op
==TK_UPDATE
|| op
==TK_DELETE
);
105 assert( op
>0 && op
<0xff );
107 /* If TEMP was specified, then the trigger name may not be qualified. */
109 sqlite3ErrorMsg(pParse
, "temporary trigger may not have qualified name");
110 goto trigger_cleanup
;
115 /* Figure out the db that the trigger will be created in */
116 iDb
= sqlite3TwoPartName(pParse
, pName1
, pName2
, &pName
);
118 goto trigger_cleanup
;
121 if( !pTableName
|| db
->mallocFailed
){
122 goto trigger_cleanup
;
125 /* A long-standing parser bug is that this syntax was allowed:
127 ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
130 ** To maintain backwards compatibility, ignore the database
131 ** name on pTableName if we are reparsing out of SQLITE_MASTER.
133 if( db
->init
.busy
&& iDb
!=1 ){
134 sqlite3DbFree(db
, pTableName
->a
[0].zDatabase
);
135 pTableName
->a
[0].zDatabase
= 0;
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.
143 pTab
= sqlite3SrcListLookup(pParse
, pTableName
);
144 if( db
->init
.busy
==0 && pName2
->n
==0 && pTab
145 && pTab
->pSchema
==db
->aDb
[1].pSchema
){
149 /* Ensure the table name matches database name and that the table exists */
150 if( db
->mallocFailed
) goto trigger_cleanup
;
151 assert( pTableName
->nSrc
==1 );
152 sqlite3FixInit(&sFix
, pParse
, iDb
, "trigger", pName
);
153 if( sqlite3FixSrcList(&sFix
, pTableName
) ){
154 goto trigger_cleanup
;
156 pTab
= sqlite3SrcListLookup(pParse
, pTableName
);
158 /* The table does not exist. */
159 if( db
->init
.iDb
==1 ){
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.
168 db
->init
.orphanTrigger
= 1;
170 goto trigger_cleanup
;
172 if( IsVirtual(pTab
) ){
173 sqlite3ErrorMsg(pParse
, "cannot create triggers on virtual tables");
174 goto trigger_cleanup
;
177 /* Check that the trigger name is not reserved and that no trigger of the
178 ** specified name exists */
179 zName
= sqlite3NameFromToken(db
, pName
);
181 assert( db
->mallocFailed
);
182 goto trigger_cleanup
;
184 if( sqlite3CheckObjectName(pParse
, zName
, "trigger", pTab
->zName
) ){
185 goto trigger_cleanup
;
187 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
188 if( !IN_RENAME_OBJECT
){
189 if( sqlite3HashFind(&(db
->aDb
[iDb
].pSchema
->trigHash
),zName
) ){
191 sqlite3ErrorMsg(pParse
, "trigger %T already exists", pName
);
193 assert( !db
->init
.busy
);
194 sqlite3CodeVerifySchema(pParse
, iDb
);
196 goto trigger_cleanup
;
200 /* Do not create a trigger on a system table */
201 if( sqlite3StrNICmp(pTab
->zName
, "sqlite_", 7)==0 ){
202 sqlite3ErrorMsg(pParse
, "cannot create trigger on system table");
203 goto trigger_cleanup
;
206 /* INSTEAD of triggers are only for views and views only support INSTEAD
209 if( pTab
->pSelect
&& tr_tm
!=TK_INSTEAD
){
210 sqlite3ErrorMsg(pParse
, "cannot create %s trigger on view: %S",
211 (tr_tm
== TK_BEFORE
)?"BEFORE":"AFTER", pTableName
, 0);
212 goto trigger_cleanup
;
214 if( !pTab
->pSelect
&& tr_tm
==TK_INSTEAD
){
215 sqlite3ErrorMsg(pParse
, "cannot create INSTEAD OF"
216 " trigger on table: %S", pTableName
, 0);
217 goto trigger_cleanup
;
220 #ifndef SQLITE_OMIT_AUTHORIZATION
221 if( !IN_RENAME_OBJECT
){
222 int iTabDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
223 int code
= SQLITE_CREATE_TRIGGER
;
224 const char *zDb
= db
->aDb
[iTabDb
].zDbSName
;
225 const char *zDbTrig
= isTemp
? db
->aDb
[1].zDbSName
: zDb
;
226 if( iTabDb
==1 || isTemp
) code
= SQLITE_CREATE_TEMP_TRIGGER
;
227 if( sqlite3AuthCheck(pParse
, code
, zName
, pTab
->zName
, zDbTrig
) ){
228 goto trigger_cleanup
;
230 if( sqlite3AuthCheck(pParse
, SQLITE_INSERT
, SCHEMA_TABLE(iTabDb
),0,zDb
)){
231 goto trigger_cleanup
;
236 /* INSTEAD OF triggers can only appear on views and BEFORE triggers
237 ** cannot appear on views. So we might as well translate every
238 ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code
241 if (tr_tm
== TK_INSTEAD
){
245 /* Build the Trigger object */
246 pTrigger
= (Trigger
*)sqlite3DbMallocZero(db
, sizeof(Trigger
));
247 if( pTrigger
==0 ) goto trigger_cleanup
;
248 pTrigger
->zName
= zName
;
250 pTrigger
->table
= sqlite3DbStrDup(db
, pTableName
->a
[0].zName
);
251 pTrigger
->pSchema
= db
->aDb
[iDb
].pSchema
;
252 pTrigger
->pTabSchema
= pTab
->pSchema
;
253 pTrigger
->op
= (u8
)op
;
254 pTrigger
->tr_tm
= tr_tm
==TK_BEFORE
? TRIGGER_BEFORE
: TRIGGER_AFTER
;
255 if( IN_RENAME_OBJECT
){
256 sqlite3RenameTokenRemap(pParse
, pTrigger
->table
, pTableName
->a
[0].zName
);
257 pTrigger
->pWhen
= pWhen
;
260 pTrigger
->pWhen
= sqlite3ExprDup(db
, pWhen
, EXPRDUP_REDUCE
);
262 pTrigger
->pColumns
= pColumns
;
264 assert( pParse
->pNewTrigger
==0 );
265 pParse
->pNewTrigger
= pTrigger
;
268 sqlite3DbFree(db
, zName
);
269 sqlite3SrcListDelete(db
, pTableName
);
270 sqlite3IdListDelete(db
, pColumns
);
271 sqlite3ExprDelete(db
, pWhen
);
272 if( !pParse
->pNewTrigger
){
273 sqlite3DeleteTrigger(db
, pTrigger
);
275 assert( pParse
->pNewTrigger
==pTrigger
);
280 ** This routine is called after all of the trigger actions have been parsed
281 ** in order to complete the process of building the trigger.
283 void sqlite3FinishTrigger(
284 Parse
*pParse
, /* Parser context */
285 TriggerStep
*pStepList
, /* The triggered program */
286 Token
*pAll
/* Token that describes the complete CREATE TRIGGER */
288 Trigger
*pTrig
= pParse
->pNewTrigger
; /* Trigger being finished */
289 char *zName
; /* Name of trigger */
290 sqlite3
*db
= pParse
->db
; /* The database */
291 DbFixer sFix
; /* Fixer object */
292 int iDb
; /* Database containing the trigger */
293 Token nameToken
; /* Trigger name for error reporting */
295 pParse
->pNewTrigger
= 0;
296 if( NEVER(pParse
->nErr
) || !pTrig
) goto triggerfinish_cleanup
;
297 zName
= pTrig
->zName
;
298 iDb
= sqlite3SchemaToIndex(pParse
->db
, pTrig
->pSchema
);
299 pTrig
->step_list
= pStepList
;
301 pStepList
->pTrig
= pTrig
;
302 pStepList
= pStepList
->pNext
;
304 sqlite3TokenInit(&nameToken
, pTrig
->zName
);
305 sqlite3FixInit(&sFix
, pParse
, iDb
, "trigger", &nameToken
);
306 if( sqlite3FixTriggerStep(&sFix
, pTrig
->step_list
)
307 || sqlite3FixExpr(&sFix
, pTrig
->pWhen
)
309 goto triggerfinish_cleanup
;
312 #ifndef SQLITE_OMIT_ALTERTABLE
313 if( IN_RENAME_OBJECT
){
314 assert( !db
->init
.busy
);
315 pParse
->pNewTrigger
= pTrig
;
320 /* if we are not initializing,
321 ** build the sqlite_master entry
323 if( !db
->init
.busy
){
327 /* Make an entry in the sqlite_master table */
328 v
= sqlite3GetVdbe(pParse
);
329 if( v
==0 ) goto triggerfinish_cleanup
;
330 sqlite3BeginWriteOperation(pParse
, 0, iDb
);
331 z
= sqlite3DbStrNDup(db
, (char*)pAll
->z
, pAll
->n
);
333 sqlite3NestedParse(pParse
,
334 "INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
335 db
->aDb
[iDb
].zDbSName
, MASTER_NAME
, zName
,
337 sqlite3DbFree(db
, z
);
338 sqlite3ChangeCookie(pParse
, iDb
);
339 sqlite3VdbeAddParseSchemaOp(v
, iDb
,
340 sqlite3MPrintf(db
, "type='trigger' AND name='%q'", zName
));
344 Trigger
*pLink
= pTrig
;
345 Hash
*pHash
= &db
->aDb
[iDb
].pSchema
->trigHash
;
346 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
348 pTrig
= sqlite3HashInsert(pHash
, zName
, pTrig
);
351 }else if( pLink
->pSchema
==pLink
->pTabSchema
){
353 pTab
= sqlite3HashFind(&pLink
->pTabSchema
->tblHash
, pLink
->table
);
355 pLink
->pNext
= pTab
->pTrigger
;
356 pTab
->pTrigger
= pLink
;
360 triggerfinish_cleanup
:
361 sqlite3DeleteTrigger(db
, pTrig
);
362 assert( IN_RENAME_OBJECT
|| !pParse
->pNewTrigger
);
363 sqlite3DeleteTriggerStep(db
, pStepList
);
367 ** Duplicate a range of text from an SQL statement, then convert all
368 ** whitespace characters into ordinary space characters.
370 static char *triggerSpanDup(sqlite3
*db
, const char *zStart
, const char *zEnd
){
371 char *z
= sqlite3DbSpanDup(db
, zStart
, zEnd
);
373 if( z
) for(i
=0; z
[i
]; i
++) if( sqlite3Isspace(z
[i
]) ) z
[i
] = ' ';
378 ** Turn a SELECT statement (that the pSelect parameter points to) into
379 ** a trigger step. Return a pointer to a TriggerStep structure.
381 ** The parser calls this routine when it finds a SELECT statement in
382 ** body of a TRIGGER.
384 TriggerStep
*sqlite3TriggerSelectStep(
385 sqlite3
*db
, /* Database connection */
386 Select
*pSelect
, /* The SELECT statement */
387 const char *zStart
, /* Start of SQL text */
388 const char *zEnd
/* End of SQL text */
390 TriggerStep
*pTriggerStep
= sqlite3DbMallocZero(db
, sizeof(TriggerStep
));
391 if( pTriggerStep
==0 ) {
392 sqlite3SelectDelete(db
, pSelect
);
395 pTriggerStep
->op
= TK_SELECT
;
396 pTriggerStep
->pSelect
= pSelect
;
397 pTriggerStep
->orconf
= OE_Default
;
398 pTriggerStep
->zSpan
= triggerSpanDup(db
, zStart
, zEnd
);
403 ** Allocate space to hold a new trigger step. The allocated space
404 ** holds both the TriggerStep object and the TriggerStep.target.z string.
406 ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
408 static TriggerStep
*triggerStepAllocate(
409 Parse
*pParse
, /* Parser context */
410 u8 op
, /* Trigger opcode */
411 Token
*pName
, /* The target name */
412 const char *zStart
, /* Start of SQL text */
413 const char *zEnd
/* End of SQL text */
415 sqlite3
*db
= pParse
->db
;
416 TriggerStep
*pTriggerStep
;
418 pTriggerStep
= sqlite3DbMallocZero(db
, sizeof(TriggerStep
) + pName
->n
+ 1);
420 char *z
= (char*)&pTriggerStep
[1];
421 memcpy(z
, pName
->z
, pName
->n
);
423 pTriggerStep
->zTarget
= z
;
424 pTriggerStep
->op
= op
;
425 pTriggerStep
->zSpan
= triggerSpanDup(db
, zStart
, zEnd
);
426 if( IN_RENAME_OBJECT
){
427 sqlite3RenameTokenMap(pParse
, pTriggerStep
->zTarget
, pName
);
434 ** Build a trigger step out of an INSERT statement. Return a pointer
435 ** to the new trigger step.
437 ** The parser calls this routine when it sees an INSERT inside the
438 ** body of a trigger.
440 TriggerStep
*sqlite3TriggerInsertStep(
441 Parse
*pParse
, /* Parser */
442 Token
*pTableName
, /* Name of the table into which we insert */
443 IdList
*pColumn
, /* List of columns in pTableName to insert into */
444 Select
*pSelect
, /* A SELECT statement that supplies values */
445 u8 orconf
, /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
446 Upsert
*pUpsert
, /* ON CONFLICT clauses for upsert */
447 const char *zStart
, /* Start of SQL text */
448 const char *zEnd
/* End of SQL text */
450 sqlite3
*db
= pParse
->db
;
451 TriggerStep
*pTriggerStep
;
453 assert(pSelect
!= 0 || db
->mallocFailed
);
455 pTriggerStep
= triggerStepAllocate(pParse
, TK_INSERT
, pTableName
,zStart
,zEnd
);
457 if( IN_RENAME_OBJECT
){
458 pTriggerStep
->pSelect
= pSelect
;
461 pTriggerStep
->pSelect
= sqlite3SelectDup(db
, pSelect
, EXPRDUP_REDUCE
);
463 pTriggerStep
->pIdList
= pColumn
;
464 pTriggerStep
->pUpsert
= pUpsert
;
465 pTriggerStep
->orconf
= orconf
;
467 sqlite3HasExplicitNulls(pParse
, pUpsert
->pUpsertTarget
);
471 sqlite3IdListDelete(db
, pColumn
);
473 sqlite3UpsertDelete(db
, pUpsert
);
475 sqlite3SelectDelete(db
, pSelect
);
481 ** Construct a trigger step that implements an UPDATE statement and return
482 ** a pointer to that trigger step. The parser calls this routine when it
483 ** sees an UPDATE statement inside the body of a CREATE TRIGGER.
485 TriggerStep
*sqlite3TriggerUpdateStep(
486 Parse
*pParse
, /* Parser */
487 Token
*pTableName
, /* Name of the table to be updated */
488 ExprList
*pEList
, /* The SET clause: list of column and new values */
489 Expr
*pWhere
, /* The WHERE clause */
490 u8 orconf
, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
491 const char *zStart
, /* Start of SQL text */
492 const char *zEnd
/* End of SQL text */
494 sqlite3
*db
= pParse
->db
;
495 TriggerStep
*pTriggerStep
;
497 pTriggerStep
= triggerStepAllocate(pParse
, TK_UPDATE
, pTableName
,zStart
,zEnd
);
499 if( IN_RENAME_OBJECT
){
500 pTriggerStep
->pExprList
= pEList
;
501 pTriggerStep
->pWhere
= pWhere
;
505 pTriggerStep
->pExprList
= sqlite3ExprListDup(db
, pEList
, EXPRDUP_REDUCE
);
506 pTriggerStep
->pWhere
= sqlite3ExprDup(db
, pWhere
, EXPRDUP_REDUCE
);
508 pTriggerStep
->orconf
= orconf
;
510 sqlite3ExprListDelete(db
, pEList
);
511 sqlite3ExprDelete(db
, pWhere
);
516 ** Construct a trigger step that implements a DELETE statement and return
517 ** a pointer to that trigger step. The parser calls this routine when it
518 ** sees a DELETE statement inside the body of a CREATE TRIGGER.
520 TriggerStep
*sqlite3TriggerDeleteStep(
521 Parse
*pParse
, /* Parser */
522 Token
*pTableName
, /* The table from which rows are deleted */
523 Expr
*pWhere
, /* The WHERE clause */
524 const char *zStart
, /* Start of SQL text */
525 const char *zEnd
/* End of SQL text */
527 sqlite3
*db
= pParse
->db
;
528 TriggerStep
*pTriggerStep
;
530 pTriggerStep
= triggerStepAllocate(pParse
, TK_DELETE
, pTableName
,zStart
,zEnd
);
532 if( IN_RENAME_OBJECT
){
533 pTriggerStep
->pWhere
= pWhere
;
536 pTriggerStep
->pWhere
= sqlite3ExprDup(db
, pWhere
, EXPRDUP_REDUCE
);
538 pTriggerStep
->orconf
= OE_Default
;
540 sqlite3ExprDelete(db
, pWhere
);
545 ** Recursively delete a Trigger structure
547 void sqlite3DeleteTrigger(sqlite3
*db
, Trigger
*pTrigger
){
548 if( pTrigger
==0 ) return;
549 sqlite3DeleteTriggerStep(db
, pTrigger
->step_list
);
550 sqlite3DbFree(db
, pTrigger
->zName
);
551 sqlite3DbFree(db
, pTrigger
->table
);
552 sqlite3ExprDelete(db
, pTrigger
->pWhen
);
553 sqlite3IdListDelete(db
, pTrigger
->pColumns
);
554 sqlite3DbFree(db
, pTrigger
);
558 ** This function is called to drop a trigger from the database schema.
560 ** This may be called directly from the parser and therefore identifies
561 ** the trigger by name. The sqlite3DropTriggerPtr() routine does the
562 ** same job as this routine except it takes a pointer to the trigger
563 ** instead of the trigger name.
565 void sqlite3DropTrigger(Parse
*pParse
, SrcList
*pName
, int noErr
){
566 Trigger
*pTrigger
= 0;
570 sqlite3
*db
= pParse
->db
;
572 if( db
->mallocFailed
) goto drop_trigger_cleanup
;
573 if( SQLITE_OK
!=sqlite3ReadSchema(pParse
) ){
574 goto drop_trigger_cleanup
;
577 assert( pName
->nSrc
==1 );
578 zDb
= pName
->a
[0].zDatabase
;
579 zName
= pName
->a
[0].zName
;
580 assert( zDb
!=0 || sqlite3BtreeHoldsAllMutexes(db
) );
581 for(i
=OMIT_TEMPDB
; i
<db
->nDb
; i
++){
582 int j
= (i
<2) ? i
^1 : i
; /* Search TEMP before MAIN */
583 if( zDb
&& sqlite3DbIsNamed(db
, j
, zDb
)==0 ) continue;
584 assert( sqlite3SchemaMutexHeld(db
, j
, 0) );
585 pTrigger
= sqlite3HashFind(&(db
->aDb
[j
].pSchema
->trigHash
), zName
);
586 if( pTrigger
) break;
590 sqlite3ErrorMsg(pParse
, "no such trigger: %S", pName
, 0);
592 sqlite3CodeVerifyNamedSchema(pParse
, zDb
);
594 pParse
->checkSchema
= 1;
595 goto drop_trigger_cleanup
;
597 sqlite3DropTriggerPtr(pParse
, pTrigger
);
599 drop_trigger_cleanup
:
600 sqlite3SrcListDelete(db
, pName
);
604 ** Return a pointer to the Table structure for the table that a trigger
607 static Table
*tableOfTrigger(Trigger
*pTrigger
){
608 return sqlite3HashFind(&pTrigger
->pTabSchema
->tblHash
, pTrigger
->table
);
613 ** Drop a trigger given a pointer to that trigger.
615 void sqlite3DropTriggerPtr(Parse
*pParse
, Trigger
*pTrigger
){
618 sqlite3
*db
= pParse
->db
;
621 iDb
= sqlite3SchemaToIndex(pParse
->db
, pTrigger
->pSchema
);
622 assert( iDb
>=0 && iDb
<db
->nDb
);
623 pTable
= tableOfTrigger(pTrigger
);
624 assert( (pTable
&& pTable
->pSchema
==pTrigger
->pSchema
) || iDb
==1 );
625 #ifndef SQLITE_OMIT_AUTHORIZATION
627 int code
= SQLITE_DROP_TRIGGER
;
628 const char *zDb
= db
->aDb
[iDb
].zDbSName
;
629 const char *zTab
= SCHEMA_TABLE(iDb
);
630 if( iDb
==1 ) code
= SQLITE_DROP_TEMP_TRIGGER
;
631 if( sqlite3AuthCheck(pParse
, code
, pTrigger
->zName
, pTable
->zName
, zDb
) ||
632 sqlite3AuthCheck(pParse
, SQLITE_DELETE
, zTab
, 0, zDb
) ){
638 /* Generate code to destroy the database record of the trigger.
640 if( (v
= sqlite3GetVdbe(pParse
))!=0 ){
641 sqlite3NestedParse(pParse
,
642 "DELETE FROM %Q.%s WHERE name=%Q AND type='trigger'",
643 db
->aDb
[iDb
].zDbSName
, MASTER_NAME
, pTrigger
->zName
645 sqlite3ChangeCookie(pParse
, iDb
);
646 sqlite3VdbeAddOp4(v
, OP_DropTrigger
, iDb
, 0, 0, pTrigger
->zName
, 0);
651 ** Remove a trigger from the hash tables of the sqlite* pointer.
653 void sqlite3UnlinkAndDeleteTrigger(sqlite3
*db
, int iDb
, const char *zName
){
657 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
658 pHash
= &(db
->aDb
[iDb
].pSchema
->trigHash
);
659 pTrigger
= sqlite3HashInsert(pHash
, zName
, 0);
660 if( ALWAYS(pTrigger
) ){
661 if( pTrigger
->pSchema
==pTrigger
->pTabSchema
){
662 Table
*pTab
= tableOfTrigger(pTrigger
);
665 for(pp
=&pTab
->pTrigger
; *pp
; pp
=&((*pp
)->pNext
)){
673 sqlite3DeleteTrigger(db
, pTrigger
);
674 db
->mDbFlags
|= DBFLAG_SchemaChange
;
679 ** pEList is the SET clause of an UPDATE statement. Each entry
680 ** in pEList is of the format <id>=<expr>. If any of the entries
681 ** in pEList have an <id> which matches an identifier in pIdList,
682 ** then return TRUE. If pIdList==NULL, then it is considered a
683 ** wildcard that matches anything. Likewise if pEList==NULL then
684 ** it matches anything so always return true. Return false only
685 ** if there is no match.
687 static int checkColumnOverlap(IdList
*pIdList
, ExprList
*pEList
){
689 if( pIdList
==0 || NEVER(pEList
==0) ) return 1;
690 for(e
=0; e
<pEList
->nExpr
; e
++){
691 if( sqlite3IdListIndex(pIdList
, pEList
->a
[e
].zEName
)>=0 ) return 1;
697 ** Return a list of all triggers on table pTab if there exists at least
698 ** one trigger that must be fired when an operation of type 'op' is
699 ** performed on the table, and, if that operation is an UPDATE, if at
700 ** least one of the columns in pChanges is being modified.
702 Trigger
*sqlite3TriggersExist(
703 Parse
*pParse
, /* Parse context */
704 Table
*pTab
, /* The table the contains the triggers */
705 int op
, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
706 ExprList
*pChanges
, /* Columns that change in an UPDATE statement */
707 int *pMask
/* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
713 if( (pParse
->db
->flags
& SQLITE_EnableTrigger
)!=0 ){
714 pList
= sqlite3TriggerList(pParse
, pTab
);
716 assert( pList
==0 || IsVirtual(pTab
)==0 );
717 for(p
=pList
; p
; p
=p
->pNext
){
718 if( p
->op
==op
&& checkColumnOverlap(p
->pColumns
, pChanges
) ){
725 return (mask
? pList
: 0);
729 ** Convert the pStep->zTarget string into a SrcList and return a pointer
732 ** This routine adds a specific database name, if needed, to the target when
733 ** forming the SrcList. This prevents a trigger in one database from
734 ** referring to a target in another database. An exception is when the
735 ** trigger is in TEMP in which case it can refer to any other database it
738 static SrcList
*targetSrcList(
739 Parse
*pParse
, /* The parsing context */
740 TriggerStep
*pStep
/* The trigger containing the target token */
742 sqlite3
*db
= pParse
->db
;
743 int iDb
; /* Index of the database to use */
744 SrcList
*pSrc
; /* SrcList to be returned */
746 pSrc
= sqlite3SrcListAppend(pParse
, 0, 0, 0);
748 assert( pSrc
->nSrc
>0 );
749 pSrc
->a
[pSrc
->nSrc
-1].zName
= sqlite3DbStrDup(db
, pStep
->zTarget
);
750 iDb
= sqlite3SchemaToIndex(db
, pStep
->pTrig
->pSchema
);
751 if( iDb
==0 || iDb
>=2 ){
753 assert( iDb
<db
->nDb
);
754 zDb
= db
->aDb
[iDb
].zDbSName
;
755 pSrc
->a
[pSrc
->nSrc
-1].zDatabase
= sqlite3DbStrDup(db
, zDb
);
762 ** Generate VDBE code for the statements inside the body of a single
765 static int codeTriggerProgram(
766 Parse
*pParse
, /* The parser context */
767 TriggerStep
*pStepList
, /* List of statements inside the trigger body */
768 int orconf
/* Conflict algorithm. (OE_Abort, etc) */
771 Vdbe
*v
= pParse
->pVdbe
;
772 sqlite3
*db
= pParse
->db
;
774 assert( pParse
->pTriggerTab
&& pParse
->pToplevel
);
777 for(pStep
=pStepList
; pStep
; pStep
=pStep
->pNext
){
778 /* Figure out the ON CONFLICT policy that will be used for this step
779 ** of the trigger program. If the statement that caused this trigger
780 ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
781 ** the ON CONFLICT policy that was specified as part of the trigger
782 ** step statement. Example:
784 ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
785 ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
788 ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy
789 ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy
791 pParse
->eOrconf
= (orconf
==OE_Default
)?pStep
->orconf
:(u8
)orconf
;
792 assert( pParse
->okConstFactor
==0 );
794 #ifndef SQLITE_OMIT_TRACE
796 sqlite3VdbeAddOp4(v
, OP_Trace
, 0x7fffffff, 1, 0,
797 sqlite3MPrintf(db
, "-- %s", pStep
->zSpan
),
804 sqlite3Update(pParse
,
805 targetSrcList(pParse
, pStep
),
806 sqlite3ExprListDup(db
, pStep
->pExprList
, 0),
807 sqlite3ExprDup(db
, pStep
->pWhere
, 0),
808 pParse
->eOrconf
, 0, 0, 0
813 sqlite3Insert(pParse
,
814 targetSrcList(pParse
, pStep
),
815 sqlite3SelectDup(db
, pStep
->pSelect
, 0),
816 sqlite3IdListDup(db
, pStep
->pIdList
),
818 sqlite3UpsertDup(db
, pStep
->pUpsert
)
823 sqlite3DeleteFrom(pParse
,
824 targetSrcList(pParse
, pStep
),
825 sqlite3ExprDup(db
, pStep
->pWhere
, 0), 0, 0
829 default: assert( pStep
->op
==TK_SELECT
); {
831 Select
*pSelect
= sqlite3SelectDup(db
, pStep
->pSelect
, 0);
832 sqlite3SelectDestInit(&sDest
, SRT_Discard
, 0);
833 sqlite3Select(pParse
, pSelect
, &sDest
);
834 sqlite3SelectDelete(db
, pSelect
);
838 if( pStep
->op
!=TK_SELECT
){
839 sqlite3VdbeAddOp0(v
, OP_ResetCount
);
846 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
848 ** This function is used to add VdbeComment() annotations to a VDBE
849 ** program. It is not used in production code, only for debugging.
851 static const char *onErrorText(int onError
){
853 case OE_Abort
: return "abort";
854 case OE_Rollback
: return "rollback";
855 case OE_Fail
: return "fail";
856 case OE_Replace
: return "replace";
857 case OE_Ignore
: return "ignore";
858 case OE_Default
: return "default";
865 ** Parse context structure pFrom has just been used to create a sub-vdbe
866 ** (trigger program). If an error has occurred, transfer error information
867 ** from pFrom to pTo.
869 static void transferParseError(Parse
*pTo
, Parse
*pFrom
){
870 assert( pFrom
->zErrMsg
==0 || pFrom
->nErr
);
871 assert( pTo
->zErrMsg
==0 || pTo
->nErr
);
873 pTo
->zErrMsg
= pFrom
->zErrMsg
;
874 pTo
->nErr
= pFrom
->nErr
;
877 sqlite3DbFree(pFrom
->db
, pFrom
->zErrMsg
);
882 ** Create and populate a new TriggerPrg object with a sub-program
883 ** implementing trigger pTrigger with ON CONFLICT policy orconf.
885 static TriggerPrg
*codeRowTrigger(
886 Parse
*pParse
, /* Current parse context */
887 Trigger
*pTrigger
, /* Trigger to code */
888 Table
*pTab
, /* The table pTrigger is attached to */
889 int orconf
/* ON CONFLICT policy to code trigger program with */
891 Parse
*pTop
= sqlite3ParseToplevel(pParse
);
892 sqlite3
*db
= pParse
->db
; /* Database handle */
893 TriggerPrg
*pPrg
; /* Value to return */
894 Expr
*pWhen
= 0; /* Duplicate of trigger WHEN expression */
895 Vdbe
*v
; /* Temporary VM */
896 NameContext sNC
; /* Name context for sub-vdbe */
897 SubProgram
*pProgram
= 0; /* Sub-vdbe for trigger program */
898 Parse
*pSubParse
; /* Parse context for sub-vdbe */
899 int iEndTrigger
= 0; /* Label to jump to if WHEN is false */
901 assert( pTrigger
->zName
==0 || pTab
==tableOfTrigger(pTrigger
) );
902 assert( pTop
->pVdbe
);
904 /* Allocate the TriggerPrg and SubProgram objects. To ensure that they
905 ** are freed if an error occurs, link them into the Parse.pTriggerPrg
906 ** list of the top-level Parse object sooner rather than later. */
907 pPrg
= sqlite3DbMallocZero(db
, sizeof(TriggerPrg
));
908 if( !pPrg
) return 0;
909 pPrg
->pNext
= pTop
->pTriggerPrg
;
910 pTop
->pTriggerPrg
= pPrg
;
911 pPrg
->pProgram
= pProgram
= sqlite3DbMallocZero(db
, sizeof(SubProgram
));
912 if( !pProgram
) return 0;
913 sqlite3VdbeLinkSubProgram(pTop
->pVdbe
, pProgram
);
914 pPrg
->pTrigger
= pTrigger
;
915 pPrg
->orconf
= orconf
;
916 pPrg
->aColmask
[0] = 0xffffffff;
917 pPrg
->aColmask
[1] = 0xffffffff;
919 /* Allocate and populate a new Parse context to use for coding the
920 ** trigger sub-program. */
921 pSubParse
= sqlite3StackAllocZero(db
, sizeof(Parse
));
922 if( !pSubParse
) return 0;
923 memset(&sNC
, 0, sizeof(sNC
));
924 sNC
.pParse
= pSubParse
;
926 pSubParse
->pTriggerTab
= pTab
;
927 pSubParse
->pToplevel
= pTop
;
928 pSubParse
->zAuthContext
= pTrigger
->zName
;
929 pSubParse
->eTriggerOp
= pTrigger
->op
;
930 pSubParse
->nQueryLoop
= pParse
->nQueryLoop
;
931 pSubParse
->disableVtab
= pParse
->disableVtab
;
933 v
= sqlite3GetVdbe(pSubParse
);
935 VdbeComment((v
, "Start: %s.%s (%s %s%s%s ON %s)",
936 pTrigger
->zName
, onErrorText(orconf
),
937 (pTrigger
->tr_tm
==TRIGGER_BEFORE
? "BEFORE" : "AFTER"),
938 (pTrigger
->op
==TK_UPDATE
? "UPDATE" : ""),
939 (pTrigger
->op
==TK_INSERT
? "INSERT" : ""),
940 (pTrigger
->op
==TK_DELETE
? "DELETE" : ""),
943 #ifndef SQLITE_OMIT_TRACE
944 if( pTrigger
->zName
){
945 sqlite3VdbeChangeP4(v
, -1,
946 sqlite3MPrintf(db
, "-- TRIGGER %s", pTrigger
->zName
), P4_DYNAMIC
951 /* If one was specified, code the WHEN clause. If it evaluates to false
952 ** (or NULL) the sub-vdbe is immediately halted by jumping to the
953 ** OP_Halt inserted at the end of the program. */
954 if( pTrigger
->pWhen
){
955 pWhen
= sqlite3ExprDup(db
, pTrigger
->pWhen
, 0);
956 if( SQLITE_OK
==sqlite3ResolveExprNames(&sNC
, pWhen
)
957 && db
->mallocFailed
==0
959 iEndTrigger
= sqlite3VdbeMakeLabel(pSubParse
);
960 sqlite3ExprIfFalse(pSubParse
, pWhen
, iEndTrigger
, SQLITE_JUMPIFNULL
);
962 sqlite3ExprDelete(db
, pWhen
);
965 /* Code the trigger program into the sub-vdbe. */
966 codeTriggerProgram(pSubParse
, pTrigger
->step_list
, orconf
);
968 /* Insert an OP_Halt at the end of the sub-program. */
970 sqlite3VdbeResolveLabel(v
, iEndTrigger
);
972 sqlite3VdbeAddOp0(v
, OP_Halt
);
973 VdbeComment((v
, "End: %s.%s", pTrigger
->zName
, onErrorText(orconf
)));
975 transferParseError(pParse
, pSubParse
);
976 if( db
->mallocFailed
==0 && pParse
->nErr
==0 ){
977 pProgram
->aOp
= sqlite3VdbeTakeOpArray(v
, &pProgram
->nOp
, &pTop
->nMaxArg
);
979 pProgram
->nMem
= pSubParse
->nMem
;
980 pProgram
->nCsr
= pSubParse
->nTab
;
981 pProgram
->token
= (void *)pTrigger
;
982 pPrg
->aColmask
[0] = pSubParse
->oldmask
;
983 pPrg
->aColmask
[1] = pSubParse
->newmask
;
984 sqlite3VdbeDelete(v
);
987 assert( !pSubParse
->pAinc
&& !pSubParse
->pZombieTab
);
988 assert( !pSubParse
->pTriggerPrg
&& !pSubParse
->nMaxArg
);
989 sqlite3ParserReset(pSubParse
);
990 sqlite3StackFree(db
, pSubParse
);
996 ** Return a pointer to a TriggerPrg object containing the sub-program for
997 ** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such
998 ** TriggerPrg object exists, a new object is allocated and populated before
1001 static TriggerPrg
*getRowTrigger(
1002 Parse
*pParse
, /* Current parse context */
1003 Trigger
*pTrigger
, /* Trigger to code */
1004 Table
*pTab
, /* The table trigger pTrigger is attached to */
1005 int orconf
/* ON CONFLICT algorithm. */
1007 Parse
*pRoot
= sqlite3ParseToplevel(pParse
);
1010 assert( pTrigger
->zName
==0 || pTab
==tableOfTrigger(pTrigger
) );
1012 /* It may be that this trigger has already been coded (or is in the
1013 ** process of being coded). If this is the case, then an entry with
1014 ** a matching TriggerPrg.pTrigger field will be present somewhere
1015 ** in the Parse.pTriggerPrg list. Search for such an entry. */
1016 for(pPrg
=pRoot
->pTriggerPrg
;
1017 pPrg
&& (pPrg
->pTrigger
!=pTrigger
|| pPrg
->orconf
!=orconf
);
1021 /* If an existing TriggerPrg could not be located, create a new one. */
1023 pPrg
= codeRowTrigger(pParse
, pTrigger
, pTab
, orconf
);
1030 ** Generate code for the trigger program associated with trigger p on
1031 ** table pTab. The reg, orconf and ignoreJump parameters passed to this
1032 ** function are the same as those described in the header function for
1033 ** sqlite3CodeRowTrigger()
1035 void sqlite3CodeRowTriggerDirect(
1036 Parse
*pParse
, /* Parse context */
1037 Trigger
*p
, /* Trigger to code */
1038 Table
*pTab
, /* The table to code triggers from */
1039 int reg
, /* Reg array containing OLD.* and NEW.* values */
1040 int orconf
, /* ON CONFLICT policy */
1041 int ignoreJump
/* Instruction to jump to for RAISE(IGNORE) */
1043 Vdbe
*v
= sqlite3GetVdbe(pParse
); /* Main VM */
1045 pPrg
= getRowTrigger(pParse
, p
, pTab
, orconf
);
1046 assert( pPrg
|| pParse
->nErr
|| pParse
->db
->mallocFailed
);
1048 /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program
1049 ** is a pointer to the sub-vdbe containing the trigger program. */
1051 int bRecursive
= (p
->zName
&& 0==(pParse
->db
->flags
&SQLITE_RecTriggers
));
1053 sqlite3VdbeAddOp4(v
, OP_Program
, reg
, ignoreJump
, ++pParse
->nMem
,
1054 (const char *)pPrg
->pProgram
, P4_SUBPROGRAM
);
1056 (v
, "Call: %s.%s", (p
->zName
?p
->zName
:"fkey"), onErrorText(orconf
)));
1058 /* Set the P5 operand of the OP_Program instruction to non-zero if
1059 ** recursive invocation of this trigger program is disallowed. Recursive
1060 ** invocation is disallowed if (a) the sub-program is really a trigger,
1061 ** not a foreign key action, and (b) the flag to enable recursive triggers
1063 sqlite3VdbeChangeP5(v
, (u8
)bRecursive
);
1068 ** This is called to code the required FOR EACH ROW triggers for an operation
1069 ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
1070 ** is given by the op parameter. The tr_tm parameter determines whether the
1071 ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
1072 ** parameter pChanges is passed the list of columns being modified.
1074 ** If there are no triggers that fire at the specified time for the specified
1075 ** operation on pTab, this function is a no-op.
1077 ** The reg argument is the address of the first in an array of registers
1078 ** that contain the values substituted for the new.* and old.* references
1079 ** in the trigger program. If N is the number of columns in table pTab
1080 ** (a copy of pTab->nCol), then registers are populated as follows:
1082 ** Register Contains
1083 ** ------------------------------------------------------
1085 ** reg+1 OLD.* value of left-most column of pTab
1087 ** reg+N OLD.* value of right-most column of pTab
1088 ** reg+N+1 NEW.rowid
1089 ** reg+N+2 OLD.* value of left-most column of pTab
1091 ** reg+N+N+1 NEW.* value of right-most column of pTab
1093 ** For ON DELETE triggers, the registers containing the NEW.* values will
1094 ** never be accessed by the trigger program, so they are not allocated or
1095 ** populated by the caller (there is no data to populate them with anyway).
1096 ** Similarly, for ON INSERT triggers the values stored in the OLD.* registers
1097 ** are never accessed, and so are not allocated by the caller. So, for an
1098 ** ON INSERT trigger, the value passed to this function as parameter reg
1099 ** is not a readable register, although registers (reg+N) through
1102 ** Parameter orconf is the default conflict resolution algorithm for the
1103 ** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump
1104 ** is the instruction that control should jump to if a trigger program
1105 ** raises an IGNORE exception.
1107 void sqlite3CodeRowTrigger(
1108 Parse
*pParse
, /* Parse context */
1109 Trigger
*pTrigger
, /* List of triggers on table pTab */
1110 int op
, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
1111 ExprList
*pChanges
, /* Changes list for any UPDATE OF triggers */
1112 int tr_tm
, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
1113 Table
*pTab
, /* The table to code triggers from */
1114 int reg
, /* The first in an array of registers (see above) */
1115 int orconf
, /* ON CONFLICT policy */
1116 int ignoreJump
/* Instruction to jump to for RAISE(IGNORE) */
1118 Trigger
*p
; /* Used to iterate through pTrigger list */
1120 assert( op
==TK_UPDATE
|| op
==TK_INSERT
|| op
==TK_DELETE
);
1121 assert( tr_tm
==TRIGGER_BEFORE
|| tr_tm
==TRIGGER_AFTER
);
1122 assert( (op
==TK_UPDATE
)==(pChanges
!=0) );
1124 for(p
=pTrigger
; p
; p
=p
->pNext
){
1126 /* Sanity checking: The schema for the trigger and for the table are
1127 ** always defined. The trigger must be in the same schema as the table
1128 ** or else it must be a TEMP trigger. */
1129 assert( p
->pSchema
!=0 );
1130 assert( p
->pTabSchema
!=0 );
1131 assert( p
->pSchema
==p
->pTabSchema
1132 || p
->pSchema
==pParse
->db
->aDb
[1].pSchema
);
1134 /* Determine whether we should code this trigger */
1137 && checkColumnOverlap(p
->pColumns
, pChanges
)
1139 sqlite3CodeRowTriggerDirect(pParse
, p
, pTab
, reg
, orconf
, ignoreJump
);
1145 ** Triggers may access values stored in the old.* or new.* pseudo-table.
1146 ** This function returns a 32-bit bitmask indicating which columns of the
1147 ** old.* or new.* tables actually are used by triggers. This information
1148 ** may be used by the caller, for example, to avoid having to load the entire
1149 ** old.* record into memory when executing an UPDATE or DELETE command.
1151 ** Bit 0 of the returned mask is set if the left-most column of the
1152 ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
1153 ** the second leftmost column value is required, and so on. If there
1154 ** are more than 32 columns in the table, and at least one of the columns
1155 ** with an index greater than 32 may be accessed, 0xffffffff is returned.
1157 ** It is not possible to determine if the old.rowid or new.rowid column is
1158 ** accessed by triggers. The caller must always assume that it is.
1160 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
1161 ** applies to the old.* table. If 1, the new.* table.
1163 ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
1164 ** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only
1165 ** included in the returned mask if the TRIGGER_BEFORE bit is set in the
1166 ** tr_tm parameter. Similarly, values accessed by AFTER triggers are only
1167 ** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
1169 u32
sqlite3TriggerColmask(
1170 Parse
*pParse
, /* Parse context */
1171 Trigger
*pTrigger
, /* List of triggers on table pTab */
1172 ExprList
*pChanges
, /* Changes list for any UPDATE OF triggers */
1173 int isNew
, /* 1 for new.* ref mask, 0 for old.* ref mask */
1174 int tr_tm
, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
1175 Table
*pTab
, /* The table to code triggers from */
1176 int orconf
/* Default ON CONFLICT policy for trigger steps */
1178 const int op
= pChanges
? TK_UPDATE
: TK_DELETE
;
1182 assert( isNew
==1 || isNew
==0 );
1183 for(p
=pTrigger
; p
; p
=p
->pNext
){
1184 if( p
->op
==op
&& (tr_tm
&p
->tr_tm
)
1185 && checkColumnOverlap(p
->pColumns
,pChanges
)
1188 pPrg
= getRowTrigger(pParse
, p
, pTab
, orconf
);
1190 mask
|= pPrg
->aColmask
[isNew
];
1198 #endif /* !defined(SQLITE_OMIT_TRIGGER) */