AryaWu/sqlite
0
1/*2**3** The author disclaims copyright to this source code. In place of4** 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 code used by the compiler to add foreign key12** support to compiled SQL statements.13*/14#include "sqliteInt.h"15 16#ifndef SQLITE_OMIT_FOREIGN_KEY17#ifndef SQLITE_OMIT_TRIGGER18 19/*20** Deferred and Immediate FKs21** --------------------------22**23** Foreign keys in SQLite come in two flavours: deferred and immediate.24** If an immediate foreign key constraint is violated,25** SQLITE_CONSTRAINT_FOREIGNKEY is returned and the current26** statement transaction rolled back. If a 27** deferred foreign key constraint is violated, no action is taken 28** immediately. However if the application attempts to commit the 29** transaction before fixing the constraint violation, the attempt fails.30**31** Deferred constraints are implemented using a simple counter associated32** with the database handle. The counter is set to zero each time a 33** database transaction is opened. Each time a statement is executed 34** that causes a foreign key violation, the counter is incremented. Each35** time a statement is executed that removes an existing violation from36** the database, the counter is decremented. When the transaction is37** committed, the commit fails if the current value of the counter is38** greater than zero. This scheme has two big drawbacks:39**40** * When a commit fails due to a deferred foreign key constraint, 41** there is no way to tell which foreign constraint is not satisfied,42** or which row it is not satisfied for.43**44** * If the database contains foreign key violations when the 45** transaction is opened, this may cause the mechanism to malfunction.46**47** Despite these problems, this approach is adopted as it seems simpler48** than the alternatives.49**50** INSERT operations:51**52** I.1) For each FK for which the table is the child table, search53** the parent table for a match. If none is found increment the54** constraint counter.55**56** I.2) For each FK for which the table is the parent table, 57** search the child table for rows that correspond to the new58** row in the parent table. Decrement the counter for each row59** found (as the constraint is now satisfied).60**61** DELETE operations:62**63** D.1) For each FK for which the table is the child table, 64** search the parent table for a row that corresponds to the 65** deleted row in the child table. If such a row is not found, 66** decrement the counter.67**68** D.2) For each FK for which the table is the parent table, search 69** the child table for rows that correspond to the deleted row 70** in the parent table. For each found increment the counter.71**72** UPDATE operations:73**74** An UPDATE command requires that all 4 steps above are taken, but only75** for FK constraints for which the affected columns are actually 76** modified (values must be compared at runtime).77**78** Note that I.1 and D.1 are very similar operations, as are I.2 and D.2.79** This simplifies the implementation a bit.80**81** For the purposes of immediate FK constraints, the OR REPLACE conflict82** resolution is considered to delete rows before the new row is inserted.83** If a delete caused by OR REPLACE violates an FK constraint, an exception84** is thrown, even if the FK constraint would be satisfied after the new 85** row is inserted.86**87** Immediate constraints are usually handled similarly. The only difference 88** is that the counter used is stored as part of each individual statement89** object (struct Vdbe). If, after the statement has run, its immediate90** constraint counter is greater than zero,91** it returns SQLITE_CONSTRAINT_FOREIGNKEY92** and the statement transaction is rolled back. An exception is an INSERT93** statement that inserts a single row only (no triggers). In this case,94** instead of using a counter, an exception is thrown immediately if the95** INSERT violates a foreign key constraint. This is necessary as such96** an INSERT does not open a statement transaction.97**98** TODO: How should dropping a table be handled? How should renaming a 99** table be handled?100**101**102** Query API Notes103** ---------------104**105** Before coding an UPDATE or DELETE row operation, the code-generator106** for those two operations needs to know whether or not the operation107** requires any FK processing and, if so, which columns of the original108** row are required by the FK processing VDBE code (i.e. if FKs were109** implemented using triggers, which of the old.* columns would be 110** accessed). No information is required by the code-generator before111** coding an INSERT operation. The functions used by the UPDATE/DELETE112** generation code to query for this information are:113**114** sqlite3FkRequired() - Test to see if FK processing is required.115** sqlite3FkOldmask() - Query for the set of required old.* columns.116**117**118** Externally accessible module functions119** --------------------------------------120**121** sqlite3FkCheck() - Check for foreign key violations.122** sqlite3FkActions() - Code triggers for ON UPDATE/ON DELETE actions.123** sqlite3FkDelete() - Delete an FKey structure.124*/125 126/*127** VDBE Calling Convention128** -----------------------129**130** Example:131**132** For the following INSERT statement:133**134** CREATE TABLE t1(a, b INTEGER PRIMARY KEY, c);135** INSERT INTO t1 VALUES(1, 2, 3.1);136**137** Register (x): 2 (type integer)138** Register (x+1): 1 (type integer)139** Register (x+2): NULL (type NULL)140** Register (x+3): 3.1 (type real)141*/142 143/*144** A foreign key constraint requires that the key columns in the parent145** table are collectively subject to a UNIQUE or PRIMARY KEY constraint.146** Given that pParent is the parent table for foreign key constraint pFKey, 147** search the schema for a unique index on the parent key columns. 148**149** If successful, zero is returned. If the parent key is an INTEGER PRIMARY 150** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx 151** is set to point to the unique index. 152** 153** If the parent key consists of a single column (the foreign key constraint154** is not a composite foreign key), output variable *paiCol is set to NULL.155** Otherwise, it is set to point to an allocated array of size N, where156** N is the number of columns in the parent key. The first element of the157** array is the index of the child table column that is mapped by the FK158** constraint to the parent table column stored in the left-most column159** of index *ppIdx. The second element of the array is the index of the160** child table column that corresponds to the second left-most column of161** *ppIdx, and so on.162**163** If the required index cannot be found, either because:164**165** 1) The named parent key columns do not exist, or166**167** 2) The named parent key columns do exist, but are not subject to a168** UNIQUE or PRIMARY KEY constraint, or169**170** 3) No parent key columns were provided explicitly as part of the171** foreign key definition, and the parent table does not have a172** PRIMARY KEY, or173**174** 4) No parent key columns were provided explicitly as part of the175** foreign key definition, and the PRIMARY KEY of the parent table 176** consists of a different number of columns to the child key in 177** the child table.178**179** then non-zero is returned, and a "foreign key mismatch" error loaded180** into pParse. If an OOM error occurs, non-zero is returned and the181** pParse->db->mallocFailed flag is set.182*/183int sqlite3FkLocateIndex(184 Parse *pParse, /* Parse context to store any error in */185 Table *pParent, /* Parent table of FK constraint pFKey */186 FKey *pFKey, /* Foreign key to find index for */187 Index **ppIdx, /* OUT: Unique index on parent table */188 int **paiCol /* OUT: Map of index columns in pFKey */189){190 Index *pIdx = 0; /* Value to return via *ppIdx */191 int *aiCol = 0; /* Value to return via *paiCol */192 int nCol = pFKey->nCol; /* Number of columns in parent key */193 char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */194 195 /* The caller is responsible for zeroing output parameters. */196 assert( ppIdx && *ppIdx==0 );197 assert( !paiCol || *paiCol==0 );198 assert( pParse );199 200 /* If this is a non-composite (single column) foreign key, check if it 201 ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx 202 ** and *paiCol set to zero and return early. 203 **204 ** Otherwise, for a composite foreign key (more than one column), allocate205 ** space for the aiCol array (returned via output parameter *paiCol).206 ** Non-composite foreign keys do not require the aiCol array.207 */208 if( nCol==1 ){209 /* The FK maps to the IPK if any of the following are true:210 **211 ** 1) There is an INTEGER PRIMARY KEY column and the FK is implicitly 212 ** mapped to the primary key of table pParent, or213 ** 2) The FK is explicitly mapped to a column declared as INTEGER214 ** PRIMARY KEY.215 */216 if( pParent->iPKey>=0 ){217 if( !zKey ) return 0;218 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zCnName, zKey) ){219 return 0;220 }221 }222 }else if( paiCol ){223 assert( nCol>1 );224 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));225 if( !aiCol ) return 1;226 *paiCol = aiCol;227 }228 229 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){230 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){ 231 /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number232 ** of columns. If each indexed column corresponds to a foreign key233 ** column of pFKey, then this index is a winner. */234 235 if( zKey==0 ){236 /* If zKey is NULL, then this foreign key is implicitly mapped to 237 ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be 238 ** identified by the test. */239 if( IsPrimaryKeyIndex(pIdx) ){240 if( aiCol ){241 int i;242 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;243 }244 break;245 }246 }else{247 /* If zKey is non-NULL, then this foreign key was declared to248 ** map to an explicit list of columns in table pParent. Check if this249 ** index matches those columns. Also, check that the index uses250 ** the default collation sequences for each column. */251 int i, j;252 for(i=0; i<nCol; i++){253 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */254 const char *zDfltColl; /* Def. collation for column */255 char *zIdxCol; /* Name of indexed column */256 257 if( iCol<0 ) break; /* No foreign keys against expression indexes */258 259 /* If the index uses a collation sequence that is different from260 ** the default collation sequence for the column, this index is261 ** unusable. Bail out early in this case. */262 zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);263 if( !zDfltColl ) zDfltColl = sqlite3StrBINARY;264 if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break;265 266 zIdxCol = pParent->aCol[iCol].zCnName;267 for(j=0; j<nCol; j++){268 if( sqlite3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){269 if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom;270 break;271 }272 }273 if( j==nCol ) break;274 }275 if( i==nCol ) break; /* pIdx is usable */276 }277 }278 }279 280 if( !pIdx ){281 if( !pParse->disableTriggers ){282 sqlite3ErrorMsg(pParse,283 "foreign key mismatch - \"%w\" referencing \"%w\"",284 pFKey->pFrom->zName, pFKey->zTo);285 }286 sqlite3DbFree(pParse->db, aiCol);287 return 1;288 }289 290 *ppIdx = pIdx;291 return 0;292}293 294/*295** This function is called when a row is inserted into or deleted from the 296** child table of foreign key constraint pFKey. If an SQL UPDATE is executed 297** on the child table of pFKey, this function is invoked twice for each row298** affected - once to "delete" the old row, and then again to "insert" the299** new row.300**301** Each time it is called, this function generates VDBE code to locate the302** row in the parent table that corresponds to the row being inserted into 303** or deleted from the child table. If the parent row can be found, no 304** special action is taken. Otherwise, if the parent row can *not* be305** found in the parent table:306**307** Operation | FK type | Action taken308** --------------------------------------------------------------------------309** INSERT immediate Increment the "immediate constraint counter".310**311** DELETE immediate Decrement the "immediate constraint counter".312**313** INSERT deferred Increment the "deferred constraint counter".314**315** DELETE deferred Decrement the "deferred constraint counter".316**317** These operations are identified in the comment at the top of this file 318** (fkey.c) as "I.1" and "D.1".319*/320static void fkLookupParent(321 Parse *pParse, /* Parse context */322 int iDb, /* Index of database housing pTab */323 Table *pTab, /* Parent table of FK pFKey */324 Index *pIdx, /* Unique index on parent key columns in pTab */325 FKey *pFKey, /* Foreign key constraint */326 int *aiCol, /* Map from parent key columns to child table columns */327 int regData, /* Address of array containing child table row */328 int nIncr, /* Increment constraint counter by this */329 int isIgnore /* If true, pretend pTab contains all NULL values */330){331 int i; /* Iterator variable */332 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */333 int iCur = pParse->nTab - 1; /* Cursor number to use */334 int iOk = sqlite3VdbeMakeLabel(pParse); /* jump here if parent key found */335 336 sqlite3VdbeVerifyAbortable(v,337 (!pFKey->isDeferred338 && !(pParse->db->flags & SQLITE_DeferFKs)339 && !pParse->pToplevel 340 && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore);341 342 /* If nIncr is less than zero, then check at runtime if there are any343 ** outstanding constraints to resolve. If there are not, there is no need344 ** to check if deleting this row resolves any outstanding violations.345 **346 ** Check if any of the key columns in the child table row are NULL. If 347 ** any are, then the constraint is considered satisfied. No need to 348 ** search for a matching row in the parent table. */349 if( nIncr<0 ){350 sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);351 VdbeCoverage(v);352 }353 for(i=0; i<pFKey->nCol; i++){354 int iReg = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i]) + regData + 1;355 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v);356 }357 358 if( isIgnore==0 ){359 if( pIdx==0 ){360 /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY361 ** column of the parent table (table pTab). */362 int iMustBeInt; /* Address of MustBeInt instruction */363 int regTemp = sqlite3GetTempReg(pParse);364 365 /* Invoke MustBeInt to coerce the child key value to an integer (i.e. 366 ** apply the affinity of the parent key). If this fails, then there367 ** is no matching parent key. Before using MustBeInt, make a copy of368 ** the value. Otherwise, the value inserted into the child key column369 ** will have INTEGER affinity applied to it, which may not be correct. */370 sqlite3VdbeAddOp2(v, OP_SCopy, 371 sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[0])+1+regData, regTemp);372 iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);373 VdbeCoverage(v);374 375 /* If the parent table is the same as the child table, and we are about376 ** to increment the constraint-counter (i.e. this is an INSERT operation),377 ** then check if the row being inserted matches itself. If so, do not378 ** increment the constraint-counter. */379 if( pTab==pFKey->pFrom && nIncr==1 ){380 sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v);381 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);382 }383 384 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);385 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v);386 sqlite3VdbeGoto(v, iOk);387 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);388 sqlite3VdbeJumpHere(v, iMustBeInt);389 sqlite3ReleaseTempReg(pParse, regTemp);390 }else{391 int nCol = pFKey->nCol;392 int regTemp = sqlite3GetTempRange(pParse, nCol);393 394 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);395 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);396 for(i=0; i<nCol; i++){397 sqlite3VdbeAddOp2(v, OP_Copy, 398 sqlite3TableColumnToStorage(pFKey->pFrom, aiCol[i])+1+regData,399 regTemp+i);400 }401 402 /* If the parent table is the same as the child table, and we are about403 ** to increment the constraint-counter (i.e. this is an INSERT operation),404 ** then check if the row being inserted matches itself. If so, do not405 ** increment the constraint-counter. 406 **407 ** If any of the parent-key values are NULL, then the row cannot match 408 ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any409 ** of the parent-key values are NULL (at this point it is known that410 ** none of the child key values are).411 */412 if( pTab==pFKey->pFrom && nIncr==1 ){413 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;414 for(i=0; i<nCol; i++){415 int iChild = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i])416 +1+regData;417 int iParent = 1+regData;418 iParent += sqlite3TableColumnToStorage(pIdx->pTable,419 pIdx->aiColumn[i]);420 assert( pIdx->aiColumn[i]>=0 );421 assert( aiCol[i]!=pTab->iPKey );422 if( pIdx->aiColumn[i]==pTab->iPKey ){423 /* The parent key is a composite key that includes the IPK column */424 iParent = regData;425 }426 sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v);427 sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);428 }429 sqlite3VdbeGoto(v, iOk);430 }431 432 sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0,433 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);434 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);435 VdbeCoverage(v);436 sqlite3ReleaseTempRange(pParse, regTemp, nCol);437 }438 }439 440 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)441 && !pParse->pToplevel 442 && !pParse->isMultiWrite 443 ){444 /* Special case: If this is an INSERT statement that will insert exactly445 ** one row into the table, raise a constraint immediately instead of446 ** incrementing a counter. This is necessary as the VM code is being447 ** generated for will not open a statement transaction. */448 assert( nIncr==1 );449 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,450 OE_Abort, 0, P4_STATIC, P5_ConstraintFK);451 }else{452 if( nIncr>0 && pFKey->isDeferred==0 ){453 sqlite3MayAbort(pParse);454 }455 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);456 }457 458 sqlite3VdbeResolveLabel(v, iOk);459 sqlite3VdbeAddOp1(v, OP_Close, iCur);460}461 462 463/*464** Return an Expr object that refers to a memory register corresponding465** to column iCol of table pTab.466**467** regBase is the first of an array of register that contains the data468** for pTab. regBase itself holds the rowid. regBase+1 holds the first469** column. regBase+2 holds the second column, and so forth.470*/471static Expr *exprTableRegister(472 Parse *pParse, /* Parsing and code generating context */473 Table *pTab, /* The table whose content is at r[regBase]... */474 int regBase, /* Contents of table pTab */475 i16 iCol /* Which column of pTab is desired */476){477 Expr *pExpr;478 Column *pCol;479 const char *zColl;480 sqlite3 *db = pParse->db;481 482 pExpr = sqlite3Expr(db, TK_REGISTER, 0);483 if( pExpr ){484 if( iCol>=0 && iCol!=pTab->iPKey ){485 pCol = &pTab->aCol[iCol];486 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;487 pExpr->affExpr = pCol->affinity;488 zColl = sqlite3ColumnColl(pCol);489 if( zColl==0 ) zColl = db->pDfltColl->zName;490 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);491 }else{492 pExpr->iTable = regBase;493 pExpr->affExpr = SQLITE_AFF_INTEGER;494 }495 }496 return pExpr;497}498 499/*500** Return an Expr object that refers to column iCol of table pTab which501** has cursor iCur.502*/503static Expr *exprTableColumn(504 sqlite3 *db, /* The database connection */505 Table *pTab, /* The table whose column is desired */506 int iCursor, /* The open cursor on the table */507 i16 iCol /* The column that is wanted */508){509 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);510 if( pExpr ){511 assert( ExprUseYTab(pExpr) );512 pExpr->y.pTab = pTab;513 pExpr->iTable = iCursor;514 pExpr->iColumn = iCol;515 }516 return pExpr;517}518 519/*520** This function is called to generate code executed when a row is deleted521** from the parent table of foreign key constraint pFKey and, if pFKey is 522** deferred, when a row is inserted into the same table. When generating523** code for an SQL UPDATE operation, this function may be called twice -524** once to "delete" the old row and once to "insert" the new row.525**526** Parameter nIncr is passed -1 when inserting a row (as this may decrease527** the number of FK violations in the db) or +1 when deleting one (as this528** may increase the number of FK constraint problems).529**530** The code generated by this function scans through the rows in the child531** table that correspond to the parent table row being deleted or inserted.532** For each child row found, one of the following actions is taken:533**534** Operation | FK type | Action taken535** --------------------------------------------------------------------------536** DELETE immediate Increment the "immediate constraint counter".537**538** INSERT immediate Decrement the "immediate constraint counter".539**540** DELETE deferred Increment the "deferred constraint counter".541**542** INSERT deferred Decrement the "deferred constraint counter".543**544** These operations are identified in the comment at the top of this file 545** (fkey.c) as "I.2" and "D.2".546*/547static void fkScanChildren(548 Parse *pParse, /* Parse context */549 SrcList *pSrc, /* The child table to be scanned */550 Table *pTab, /* The parent table */551 Index *pIdx, /* Index on parent covering the foreign key */552 FKey *pFKey, /* The foreign key linking pSrc to pTab */553 int *aiCol, /* Map from pIdx cols to child table cols */554 int regData, /* Parent row data starts here */555 int nIncr /* Amount to increment deferred counter by */556){557 sqlite3 *db = pParse->db; /* Database handle */558 int i; /* Iterator variable */559 Expr *pWhere = 0; /* WHERE clause to scan with */560 NameContext sNameContext; /* Context used to resolve WHERE clause */561 WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */562 int iFkIfZero = 0; /* Address of OP_FkIfZero */563 Vdbe *v = sqlite3GetVdbe(pParse);564 565 assert( pIdx==0 || pIdx->pTable==pTab );566 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );567 assert( pIdx!=0 || pFKey->nCol==1 );568 assert( pIdx!=0 || HasRowid(pTab) );569 570 if( nIncr<0 ){571 iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);572 VdbeCoverage(v);573 }574 575 /* Create an Expr object representing an SQL expression like:576 **577 ** <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...578 **579 ** The collation sequence used for the comparison should be that of580 ** the parent key columns. The affinity of the parent key column should581 ** be applied to each child key value before the comparison takes place.582 */583 for(i=0; i<pFKey->nCol; i++){584 Expr *pLeft; /* Value from parent table row */585 Expr *pRight; /* Column ref to child table */586 Expr *pEq; /* Expression (pLeft = pRight) */587 i16 iCol; /* Index of column in child table */ 588 const char *zCol; /* Name of column in child table */589 590 iCol = pIdx ? pIdx->aiColumn[i] : -1;591 pLeft = exprTableRegister(pParse, pTab, regData, iCol);592 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;593 assert( iCol>=0 );594 zCol = pFKey->pFrom->aCol[iCol].zCnName;595 pRight = sqlite3Expr(db, TK_ID, zCol);596 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight);597 pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);598 }599 600 /* If the child table is the same as the parent table, then add terms601 ** to the WHERE clause that prevent this entry from being scanned.602 ** The added WHERE clause terms are like this:603 **604 ** $current_rowid!=rowid605 ** NOT( $current_a==a AND $current_b==b AND ... )606 **607 ** The first form is used for rowid tables. The second form is used608 ** for WITHOUT ROWID tables. In the second form, the *parent* key is609 ** (a,b,...). Either the parent or primary key could be used to 610 ** uniquely identify the current row, but the parent key is more convenient611 ** as the required values have already been loaded into registers612 ** by the caller.613 */614 if( pTab==pFKey->pFrom && nIncr>0 ){615 Expr *pNe; /* Expression (pLeft != pRight) */616 Expr *pLeft; /* Value from parent table row */617 Expr *pRight; /* Column ref to child table */618 if( HasRowid(pTab) ){619 pLeft = exprTableRegister(pParse, pTab, regData, -1);620 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);621 pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight);622 }else{623 Expr *pEq, *pAll = 0;624 assert( pIdx!=0 );625 for(i=0; i<pIdx->nKeyCol; i++){626 i16 iCol = pIdx->aiColumn[i];627 assert( iCol>=0 );628 pLeft = exprTableRegister(pParse, pTab, regData, iCol);629 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);630 pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight);631 pAll = sqlite3ExprAnd(pParse, pAll, pEq);632 }633 pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0);634 }635 pWhere = sqlite3ExprAnd(pParse, pWhere, pNe);636 }637 638 /* Resolve the references in the WHERE clause. */639 memset(&sNameContext, 0, sizeof(NameContext));640 sNameContext.pSrcList = pSrc;641 sNameContext.pParse = pParse;642 sqlite3ResolveExprNames(&sNameContext, pWhere);643 644 /* Create VDBE to loop through the entries in pSrc that match the WHERE645 ** clause. For each row found, increment either the deferred or immediate646 ** foreign key constraint counter. */647 if( pParse->nErr==0 ){648 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0, 0);649 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);650 if( pWInfo ){651 sqlite3WhereEnd(pWInfo);652 }653 }654 655 /* Clean up the WHERE clause constructed above. */656 sqlite3ExprDelete(db, pWhere);657 if( iFkIfZero ){658 sqlite3VdbeJumpHereOrPopInst(v, iFkIfZero);659 }660}661 662/*663** This function returns a linked list of FKey objects (connected by664** FKey.pNextTo) holding all children of table pTab. For example,665** given the following schema:666**667** CREATE TABLE t1(a PRIMARY KEY);668** CREATE TABLE t2(b REFERENCES t1(a);669**670** Calling this function with table "t1" as an argument returns a pointer671** to the FKey structure representing the foreign key constraint on table672** "t2". Calling this function with "t2" as the argument would return a673** NULL pointer (as there are no FK constraints for which t2 is the parent674** table).675*/676FKey *sqlite3FkReferences(Table *pTab){677 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);678}679 680/*681** The second argument is a Trigger structure allocated by the 682** fkActionTrigger() routine. This function deletes the Trigger structure683** and all of its sub-components.684**685** The Trigger structure or any of its sub-components may be allocated from686** the lookaside buffer belonging to database handle dbMem.687*/688static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){689 if( p ){690 TriggerStep *pStep = p->step_list;691 sqlite3SrcListDelete(dbMem, pStep->pSrc);692 sqlite3ExprDelete(dbMem, pStep->pWhere);693 sqlite3ExprListDelete(dbMem, pStep->pExprList);694 sqlite3SelectDelete(dbMem, pStep->pSelect);695 sqlite3ExprDelete(dbMem, p->pWhen);696 sqlite3DbFree(dbMem, p);697 }698}699 700/*701** Clear the apTrigger[] cache of CASCADE triggers for all foreign keys702** in a particular database. This needs to happen when the schema703** changes.704*/705void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){706 HashElem *k;707 Hash *pHash = &db->aDb[iDb].pSchema->tblHash;708 for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k)){709 Table *pTab = sqliteHashData(k);710 FKey *pFKey;711 if( !IsOrdinaryTable(pTab) ) continue;712 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){713 fkTriggerDelete(db, pFKey->apTrigger[0]); pFKey->apTrigger[0] = 0;714 fkTriggerDelete(db, pFKey->apTrigger[1]); pFKey->apTrigger[1] = 0;715 }716 }717}718 719/*720** This function is called to generate code that runs when table pTab is721** being dropped from the database. The SrcList passed as the second argument722** to this function contains a single entry guaranteed to resolve to723** table pTab.724**725** Normally, no code is required. However, if either726**727** (a) The table is the parent table of a FK constraint, or728** (b) The table is the child table of a deferred FK constraint and it is729** determined at runtime that there are outstanding deferred FK 730** constraint violations in the database,731**732** then the equivalent of "DELETE FROM <tbl>" is executed before dropping733** the table from the database. Triggers are disabled while running this734** DELETE, but foreign key actions are not.735*/736void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){737 sqlite3 *db = pParse->db;738 if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){739 int iSkip = 0;740 Vdbe *v = sqlite3GetVdbe(pParse);741 742 assert( v ); /* VDBE has already been allocated */743 assert( IsOrdinaryTable(pTab) );744 if( sqlite3FkReferences(pTab)==0 ){745 /* Search for a deferred foreign key constraint for which this table746 ** is the child table. If one cannot be found, return without 747 ** generating any VDBE code. If one can be found, then jump over748 ** the entire DELETE if there are no outstanding deferred constraints749 ** when this statement is run. */750 FKey *p;751 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){752 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;753 }754 if( !p ) return;755 iSkip = sqlite3VdbeMakeLabel(pParse);756 sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v);757 }758 759 pParse->disableTriggers = 1;760 sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0, 0, 0);761 pParse->disableTriggers = 0;762 763 /* If the DELETE has generated immediate foreign key constraint 764 ** violations, halt the VDBE and return an error at this point, before765 ** any modifications to the schema are made. This is because statement766 ** transactions are not able to rollback schema changes. 767 **768 ** If the SQLITE_DeferFKs flag is set, then this is not required, as769 ** the statement transaction will not be rolled back even if FK770 ** constraints are violated.771 */772 if( (db->flags & SQLITE_DeferFKs)==0 ){773 sqlite3VdbeVerifyAbortable(v, OE_Abort);774 sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);775 VdbeCoverage(v);776 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,777 OE_Abort, 0, P4_STATIC, P5_ConstraintFK);778 }779 780 if( iSkip ){781 sqlite3VdbeResolveLabel(v, iSkip);782 }783 }784}785 786 787/*788** The second argument points to an FKey object representing a foreign key789** for which pTab is the child table. An UPDATE statement against pTab790** is currently being processed. For each column of the table that is 791** actually updated, the corresponding element in the aChange[] array792** is zero or greater (if a column is unmodified the corresponding element793** is set to -1). If the rowid column is modified by the UPDATE statement794** the bChngRowid argument is non-zero.795**796** This function returns true if any of the columns that are part of the797** child key for FK constraint *p are modified.798*/799static int fkChildIsModified(800 Table *pTab, /* Table being updated */801 FKey *p, /* Foreign key for which pTab is the child */802 int *aChange, /* Array indicating modified columns */803 int bChngRowid /* True if rowid is modified by this update */804){805 int i;806 for(i=0; i<p->nCol; i++){807 int iChildKey = p->aCol[i].iFrom;808 if( aChange[iChildKey]>=0 ) return 1;809 if( iChildKey==pTab->iPKey && bChngRowid ) return 1;810 }811 return 0;812}813 814/*815** The second argument points to an FKey object representing a foreign key816** for which pTab is the parent table. An UPDATE statement against pTab817** is currently being processed. For each column of the table that is 818** actually updated, the corresponding element in the aChange[] array819** is zero or greater (if a column is unmodified the corresponding element820** is set to -1). If the rowid column is modified by the UPDATE statement821** the bChngRowid argument is non-zero.822**823** This function returns true if any of the columns that are part of the824** parent key for FK constraint *p are modified.825*/826static int fkParentIsModified(827 Table *pTab, 828 FKey *p, 829 int *aChange, 830 int bChngRowid831){832 int i;833 for(i=0; i<p->nCol; i++){834 char *zKey = p->aCol[i].zCol;835 int iKey;836 for(iKey=0; iKey<pTab->nCol; iKey++){837 if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){838 Column *pCol = &pTab->aCol[iKey];839 if( zKey ){840 if( 0==sqlite3StrICmp(pCol->zCnName, zKey) ) return 1;841 }else if( pCol->colFlags & COLFLAG_PRIMKEY ){842 return 1;843 }844 }845 }846 }847 return 0;848}849 850/*851** Return true if the parser passed as the first argument is being852** used to code a trigger that is really a "SET NULL" action belonging853** to trigger pFKey.854*/855static int isSetNullAction(Parse *pParse, FKey *pFKey){856 Parse *pTop = sqlite3ParseToplevel(pParse);857 if( pTop->pTriggerPrg ){858 Trigger *p = pTop->pTriggerPrg->pTrigger;859 if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull)860 || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull)861 ){862 assert( (pTop->db->flags & SQLITE_FkNoAction)==0 );863 return 1;864 }865 }866 return 0;867}868 869/*870** This function is called when inserting, deleting or updating a row of871** table pTab to generate VDBE code to perform foreign key constraint 872** processing for the operation.873**874** For a DELETE operation, parameter regOld is passed the index of the875** first register in an array of (pTab->nCol+1) registers containing the876** rowid of the row being deleted, followed by each of the column values877** of the row being deleted, from left to right. Parameter regNew is passed878** zero in this case.879**880** For an INSERT operation, regOld is passed zero and regNew is passed the881** first register of an array of (pTab->nCol+1) registers containing the new882** row data.883**884** For an UPDATE operation, this function is called twice. Once before885** the original record is deleted from the table using the calling convention886** described for DELETE. Then again after the original record is deleted887** but before the new record is inserted using the INSERT convention. 888*/889void sqlite3FkCheck(890 Parse *pParse, /* Parse context */891 Table *pTab, /* Row is being deleted from this table */ 892 int regOld, /* Previous row data is stored here */893 int regNew, /* New row data is stored here */894 int *aChange, /* Array indicating UPDATEd columns (or 0) */895 int bChngRowid /* True if rowid is UPDATEd */896){897 sqlite3 *db = pParse->db; /* Database handle */898 FKey *pFKey; /* Used to iterate through FKs */899 int iDb; /* Index of database containing pTab */900 const char *zDb; /* Name of database containing pTab */901 int isIgnoreErrors = pParse->disableTriggers;902 903 /* Exactly one of regOld and regNew should be non-zero. */904 assert( (regOld==0)!=(regNew==0) );905 906 /* If foreign-keys are disabled, this function is a no-op. */907 if( (db->flags&SQLITE_ForeignKeys)==0 ) return;908 if( !IsOrdinaryTable(pTab) ) return;909 910 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);911 zDb = db->aDb[iDb].zDbSName;912 913 /* Loop through all the foreign key constraints for which pTab is the914 ** child table (the table that the foreign key definition is part of). */915 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){916 Table *pTo; /* Parent table of foreign key pFKey */917 Index *pIdx = 0; /* Index on key columns in pTo */918 int *aiFree = 0;919 int *aiCol;920 int iCol;921 int i;922 int bIgnore = 0;923 924 if( aChange 925 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0926 && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0 927 ){928 continue;929 }930 931 /* Find the parent table of this foreign key. Also find a unique index 932 ** on the parent key columns in the parent table. If either of these 933 ** schema items cannot be located, set an error in pParse and return 934 ** early. */935 if( pParse->disableTriggers ){936 pTo = sqlite3FindTable(db, pFKey->zTo, zDb);937 }else{938 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);939 }940 if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){941 assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );942 if( !isIgnoreErrors || db->mallocFailed ) return;943 if( pTo==0 ){944 /* If isIgnoreErrors is true, then a table is being dropped. In this945 ** case SQLite runs a "DELETE FROM xxx" on the table being dropped946 ** before actually dropping it in order to check FK constraints.947 ** If the parent table of an FK constraint on the current table is948 ** missing, behave as if it is empty. i.e. decrement the relevant949 ** FK counter for each row of the current table with non-NULL keys.950 */951 Vdbe *v = sqlite3GetVdbe(pParse);952 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;953 for(i=0; i<pFKey->nCol; i++){954 int iFromCol, iReg;955 iFromCol = pFKey->aCol[i].iFrom;956 iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1;957 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v);958 }959 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);960 }961 continue;962 }963 assert( pFKey->nCol==1 || (aiFree && pIdx) );964 965 if( aiFree ){966 aiCol = aiFree;967 }else{968 iCol = pFKey->aCol[0].iFrom;969 aiCol = &iCol;970 }971 for(i=0; i<pFKey->nCol; i++){972 if( aiCol[i]==pTab->iPKey ){973 aiCol[i] = -1;974 }975 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );976#ifndef SQLITE_OMIT_AUTHORIZATION977 /* Request permission to read the parent key columns. If the 978 ** authorization callback returns SQLITE_IGNORE, behave as if any979 ** values read from the parent table are NULL. */980 if( db->xAuth ){981 int rcauth;982 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName;983 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);984 bIgnore = (rcauth==SQLITE_IGNORE);985 }986#endif987 }988 989 /* Take a shared-cache advisory read-lock on the parent table. Allocate 990 ** a cursor to use to search the unique index on the parent key columns 991 ** in the parent table. */992 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);993 pParse->nTab++;994 995 if( regOld!=0 ){996 /* A row is being removed from the child table. Search for the parent.997 ** If the parent does not exist, removing the child row resolves an 998 ** outstanding foreign key constraint violation. */999 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);1000 }1001 if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){1002 /* A row is being added to the child table. If a parent row cannot1003 ** be found, adding the child row has violated the FK constraint. 1004 **1005 ** If this operation is being performed as part of a trigger program1006 ** that is actually a "SET NULL" action belonging to this very 1007 ** foreign key, then omit this scan altogether. As all child key1008 ** values are guaranteed to be NULL, it is not possible for adding1009 ** this row to cause an FK violation. */1010 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);1011 }1012 1013 sqlite3DbFree(db, aiFree);1014 }1015 1016 /* Loop through all the foreign key constraints that refer to this table.1017 ** (the "child" constraints) */1018 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){1019 Index *pIdx = 0; /* Foreign key index for pFKey */1020 SrcList *pSrc;1021 int *aiCol = 0;1022 1023 if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){1024 continue;1025 }1026 1027 if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs) 1028 && !pParse->pToplevel && !pParse->isMultiWrite 1029 ){1030 assert( regOld==0 && regNew!=0 );1031 /* Inserting a single row into a parent table cannot cause (or fix)1032 ** an immediate foreign key violation. So do nothing in this case. */1033 continue;1034 }1035 1036 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){1037 if( !isIgnoreErrors || db->mallocFailed ) return;1038 continue;1039 }1040 assert( aiCol || pFKey->nCol==1 );1041 1042 /* Create a SrcList structure containing the child table. We need the1043 ** child table as a SrcList for sqlite3WhereBegin() */1044 pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);1045 if( pSrc ){1046 SrcItem *pItem = pSrc->a;1047 pItem->pSTab = pFKey->pFrom;1048 pItem->zName = pFKey->pFrom->zName;1049 pItem->pSTab->nTabRef++;1050 pItem->iCursor = pParse->nTab++;1051 1052 if( regNew!=0 ){1053 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);1054 }1055 if( regOld!=0 ){1056 int eAction = pFKey->aAction[aChange!=0];1057 if( (db->flags & SQLITE_FkNoAction) ) eAction = OE_None;1058 1059 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);1060 /* If this is a deferred FK constraint, or a CASCADE or SET NULL1061 ** action applies, then any foreign key violations caused by1062 ** removing the parent key will be rectified by the action trigger.1063 ** So do not set the "may-abort" flag in this case.1064 **1065 ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the1066 ** may-abort flag will eventually be set on this statement anyway1067 ** (when this function is called as part of processing the UPDATE1068 ** within the action trigger).1069 **1070 ** Note 2: At first glance it may seem like SQLite could simply omit1071 ** all OP_FkCounter related scans when either CASCADE or SET NULL1072 ** applies. The trouble starts if the CASCADE or SET NULL action 1073 ** trigger causes other triggers or action rules attached to the 1074 ** child table to fire. In these cases the fk constraint counters1075 ** might be set incorrectly if any OP_FkCounter related scans are 1076 ** omitted. */1077 if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){1078 sqlite3MayAbort(pParse);1079 }1080 }1081 pItem->zName = 0;1082 sqlite3SrcListDelete(db, pSrc);1083 }1084 sqlite3DbFree(db, aiCol);1085 }1086}1087 1088#define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))1089 1090/*1091** This function is called before generating code to update or delete a 1092** row contained in table pTab.1093*/1094u32 sqlite3FkOldmask(1095 Parse *pParse, /* Parse context */1096 Table *pTab /* Table being modified */1097){1098 u32 mask = 0;1099 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){1100 FKey *p;1101 int i;1102 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){1103 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);1104 }1105 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){1106 Index *pIdx = 0;1107 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);1108 if( pIdx ){1109 for(i=0; i<pIdx->nKeyCol; i++){1110 assert( pIdx->aiColumn[i]>=0 );1111 mask |= COLUMN_MASK(pIdx->aiColumn[i]);1112 }1113 }1114 }1115 }1116 return mask;1117}1118 1119 1120/*1121** This function is called before generating code to update or delete a 1122** row contained in table pTab. If the operation is a DELETE, then1123** parameter aChange is passed a NULL value. For an UPDATE, aChange points1124** to an array of size N, where N is the number of columns in table pTab.1125** If the i'th column is not modified by the UPDATE, then the corresponding 1126** entry in the aChange[] array is set to -1. If the column is modified,1127** the value is 0 or greater. Parameter chngRowid is set to true if the1128** UPDATE statement modifies the rowid fields of the table.1129**1130** If any foreign key processing will be required, this function returns1131** non-zero. If there is no foreign key related processing, this function 1132** returns zero.1133**1134** For an UPDATE, this function returns 2 if:1135**1136** * There are any FKs for which pTab is the child and the parent table1137** and any FK processing at all is required (even of a different FK), or1138**1139** * the UPDATE modifies one or more parent keys for which the action is1140** not "NO ACTION" (i.e. is CASCADE, SET DEFAULT or SET NULL).1141**1142** Or, assuming some other foreign key processing is required, 1.1143*/1144int sqlite3FkRequired(1145 Parse *pParse, /* Parse context */1146 Table *pTab, /* Table being modified */1147 int *aChange, /* Non-NULL for UPDATE operations */1148 int chngRowid /* True for UPDATE that affects rowid */1149){1150 int eRet = 1; /* Value to return if bHaveFK is true */1151 int bHaveFK = 0; /* If FK processing is required */1152 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){1153 if( !aChange ){1154 /* A DELETE operation. Foreign key processing is required if the 1155 ** table in question is either the child or parent table for any 1156 ** foreign key constraint. */1157 bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey);1158 }else{1159 /* This is an UPDATE. Foreign key processing is only required if the1160 ** operation modifies one or more child or parent key columns. */1161 FKey *p;1162 1163 /* Check if any child key columns are being modified. */1164 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){1165 if( fkChildIsModified(pTab, p, aChange, chngRowid) ){1166 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;1167 bHaveFK = 1;1168 }1169 }1170 1171 /* Check if any parent key columns are being modified. */1172 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){1173 if( fkParentIsModified(pTab, p, aChange, chngRowid) ){1174 if( (pParse->db->flags & SQLITE_FkNoAction)==0 1175 && p->aAction[1]!=OE_None 1176 ){1177 return 2;1178 }1179 bHaveFK = 1;1180 }1181 }1182 }1183 }1184 return bHaveFK ? eRet : 0;1185}1186 1187/*1188** This function is called when an UPDATE or DELETE operation is being 1189** compiled on table pTab, which is the parent table of foreign-key pFKey.1190** If the current operation is an UPDATE, then the pChanges parameter is1191** passed a pointer to the list of columns being modified. If it is a1192** DELETE, pChanges is passed a NULL pointer.1193**1194** It returns a pointer to a Trigger structure containing a trigger1195** equivalent to the ON UPDATE or ON DELETE action specified by pFKey.1196** If the action is "NO ACTION" then a NULL pointer is returned (these actions1197** require no special handling by the triggers sub-system, code for them is1198** created by fkScanChildren()).1199**1200** For example, if pFKey is the foreign key and pTab is table "p" in