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