| OLD | NEW |
|---|
| (Empty) |
| 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 code used by the compiler to add foreign key | |
| 12 ** support to compiled SQL statements. | |
| 13 */ | |
| 14 #include "sqliteInt.h" | |
| 15 | |
| 16 #ifndef SQLITE_OMIT_FOREIGN_KEY | |
| 17 #ifndef SQLITE_OMIT_TRIGGER | |
| 18 | |
| 19 /* | |
| 20 ** Deferred and Immediate FKs | |
| 21 ** -------------------------- | |
| 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 current | |
| 26 ** 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 associated | |
| 32 ** 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. Each | |
| 35 ** time a statement is executed that removes an existing violation from | |
| 36 ** the database, the counter is decremented. When the transaction is | |
| 37 ** committed, the commit fails if the current value of the counter is | |
| 38 ** 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 simpler | |
| 48 ** than the alternatives. | |
| 49 ** | |
| 50 ** INSERT operations: | |
| 51 ** | |
| 52 ** I.1) For each FK for which the table is the child table, search | |
| 53 ** the parent table for a match. If none is found increment the | |
| 54 ** 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 new | |
| 58 ** row in the parent table. Decrement the counter for each row | |
| 59 ** 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 only | |
| 75 ** 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 conflict | |
| 82 ** 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 exception | |
| 84 ** 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 statement | |
| 89 ** object (struct Vdbe). If, after the statement has run, its immediate | |
| 90 ** constraint counter is greater than zero, | |
| 91 ** it returns SQLITE_CONSTRAINT_FOREIGNKEY | |
| 92 ** and the statement transaction is rolled back. An exception is an INSERT | |
| 93 ** statement that inserts a single row only (no triggers). In this case, | |
| 94 ** instead of using a counter, an exception is thrown immediately if the | |
| 95 ** INSERT violates a foreign key constraint. This is necessary as such | |
| 96 ** 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 Notes | |
| 103 ** --------------- | |
| 104 ** | |
| 105 ** Before coding an UPDATE or DELETE row operation, the code-generator | |
| 106 ** for those two operations needs to know whether or not the operation | |
| 107 ** requires any FK processing and, if so, which columns of the original | |
| 108 ** row are required by the FK processing VDBE code (i.e. if FKs were | |
| 109 ** implemented using triggers, which of the old.* columns would be | |
| 110 ** accessed). No information is required by the code-generator before | |
| 111 ** coding an INSERT operation. The functions used by the UPDATE/DELETE | |
| 112 ** 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 functions | |
| 119 ** -------------------------------------- | |
| 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 Convention | |
| 128 ** ----------------------- | |
| 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 parent | |
| 145 ** 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 constraint | |
| 154 ** 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, where | |
| 156 ** N is the number of columns in the parent key. The first element of the | |
| 157 ** array is the index of the child table column that is mapped by the FK | |
| 158 ** constraint to the parent table column stored in the left-most column | |
| 159 ** of index *ppIdx. The second element of the array is the index of the | |
| 160 ** child table column that corresponds to the second left-most column of | |
| 161 ** *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, or | |
| 166 ** | |
| 167 ** 2) The named parent key columns do exist, but are not subject to a | |
| 168 ** UNIQUE or PRIMARY KEY constraint, or | |
| 169 ** | |
| 170 ** 3) No parent key columns were provided explicitly as part of the | |
| 171 ** foreign key definition, and the parent table does not have a | |
| 172 ** PRIMARY KEY, or | |
| 173 ** | |
| 174 ** 4) No parent key columns were provided explicitly as part of the | |
| 175 ** 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 loaded | |
| 180 ** into pParse. If an OOM error occurs, non-zero is returned and the | |
| 181 ** pParse->db->mallocFailed flag is set. | |
| 182 */ | |
| 183 int 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), allocate | |
| 205 ** 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, or | |
| 213 ** 2) The FK is explicitly mapped to a column declared as INTEGER | |
| 214 ** PRIMARY KEY. | |
| 215 */ | |
| 216 if( pParent->iPKey>=0 ){ | |
| 217 if( !zKey ) return 0; | |
| 218 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0; | |
| 219 } | |
| 220 }else if( paiCol ){ | |
| 221 assert( nCol>1 ); | |
| 222 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int)); | |
| 223 if( !aiCol ) return 1; | |
| 224 *paiCol = aiCol; | |
| 225 } | |
| 226 | |
| 227 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){ | |
| 228 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){ | |
| 229 /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number | |
| 230 ** of columns. If each indexed column corresponds to a foreign key | |
| 231 ** column of pFKey, then this index is a winner. */ | |
| 232 | |
| 233 if( zKey==0 ){ | |
| 234 /* If zKey is NULL, then this foreign key is implicitly mapped to | |
| 235 ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be | |
| 236 ** identified by the test. */ | |
| 237 if( IsPrimaryKeyIndex(pIdx) ){ | |
| 238 if( aiCol ){ | |
| 239 int i; | |
| 240 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom; | |
| 241 } | |
| 242 break; | |
| 243 } | |
| 244 }else{ | |
| 245 /* If zKey is non-NULL, then this foreign key was declared to | |
| 246 ** map to an explicit list of columns in table pParent. Check if this | |
| 247 ** index matches those columns. Also, check that the index uses | |
| 248 ** the default collation sequences for each column. */ | |
| 249 int i, j; | |
| 250 for(i=0; i<nCol; i++){ | |
| 251 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */ | |
| 252 const char *zDfltColl; /* Def. collation for column */ | |
| 253 char *zIdxCol; /* Name of indexed column */ | |
| 254 | |
| 255 if( iCol<0 ) break; /* No foreign keys against expression indexes */ | |
| 256 | |
| 257 /* If the index uses a collation sequence that is different from | |
| 258 ** the default collation sequence for the column, this index is | |
| 259 ** unusable. Bail out early in this case. */ | |
| 260 zDfltColl = pParent->aCol[iCol].zColl; | |
| 261 if( !zDfltColl ) zDfltColl = sqlite3StrBINARY; | |
| 262 if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break; | |
| 263 | |
| 264 zIdxCol = pParent->aCol[iCol].zName; | |
| 265 for(j=0; j<nCol; j++){ | |
| 266 if( sqlite3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){ | |
| 267 if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom; | |
| 268 break; | |
| 269 } | |
| 270 } | |
| 271 if( j==nCol ) break; | |
| 272 } | |
| 273 if( i==nCol ) break; /* pIdx is usable */ | |
| 274 } | |
| 275 } | |
| 276 } | |
| 277 | |
| 278 if( !pIdx ){ | |
| 279 if( !pParse->disableTriggers ){ | |
| 280 sqlite3ErrorMsg(pParse, | |
| 281 "foreign key mismatch - \"%w\" referencing \"%w\"", | |
| 282 pFKey->pFrom->zName, pFKey->zTo); | |
| 283 } | |
| 284 sqlite3DbFree(pParse->db, aiCol); | |
| 285 return 1; | |
| 286 } | |
| 287 | |
| 288 *ppIdx = pIdx; | |
| 289 return 0; | |
| 290 } | |
| 291 | |
| 292 /* | |
| 293 ** This function is called when a row is inserted into or deleted from the | |
| 294 ** child table of foreign key constraint pFKey. If an SQL UPDATE is executed | |
| 295 ** on the child table of pFKey, this function is invoked twice for each row | |
| 296 ** affected - once to "delete" the old row, and then again to "insert" the | |
| 297 ** new row. | |
| 298 ** | |
| 299 ** Each time it is called, this function generates VDBE code to locate the | |
| 300 ** row in the parent table that corresponds to the row being inserted into | |
| 301 ** or deleted from the child table. If the parent row can be found, no | |
| 302 ** special action is taken. Otherwise, if the parent row can *not* be | |
| 303 ** found in the parent table: | |
| 304 ** | |
| 305 ** Operation | FK type | Action taken | |
| 306 ** -------------------------------------------------------------------------- | |
| 307 ** INSERT immediate Increment the "immediate constraint counter". | |
| 308 ** | |
| 309 ** DELETE immediate Decrement the "immediate constraint counter". | |
| 310 ** | |
| 311 ** INSERT deferred Increment the "deferred constraint counter". | |
| 312 ** | |
| 313 ** DELETE deferred Decrement the "deferred constraint counter". | |
| 314 ** | |
| 315 ** These operations are identified in the comment at the top of this file | |
| 316 ** (fkey.c) as "I.1" and "D.1". | |
| 317 */ | |
| 318 static void fkLookupParent( | |
| 319 Parse *pParse, /* Parse context */ | |
| 320 int iDb, /* Index of database housing pTab */ | |
| 321 Table *pTab, /* Parent table of FK pFKey */ | |
| 322 Index *pIdx, /* Unique index on parent key columns in pTab */ | |
| 323 FKey *pFKey, /* Foreign key constraint */ | |
| 324 int *aiCol, /* Map from parent key columns to child table columns */ | |
| 325 int regData, /* Address of array containing child table row */ | |
| 326 int nIncr, /* Increment constraint counter by this */ | |
| 327 int isIgnore /* If true, pretend pTab contains all NULL values */ | |
| 328 ){ | |
| 329 int i; /* Iterator variable */ | |
| 330 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */ | |
| 331 int iCur = pParse->nTab - 1; /* Cursor number to use */ | |
| 332 int iOk = sqlite3VdbeMakeLabel(v); /* jump here if parent key found */ | |
| 333 | |
| 334 /* If nIncr is less than zero, then check at runtime if there are any | |
| 335 ** outstanding constraints to resolve. If there are not, there is no need | |
| 336 ** to check if deleting this row resolves any outstanding violations. | |
| 337 ** | |
| 338 ** Check if any of the key columns in the child table row are NULL. If | |
| 339 ** any are, then the constraint is considered satisfied. No need to | |
| 340 ** search for a matching row in the parent table. */ | |
| 341 if( nIncr<0 ){ | |
| 342 sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk); | |
| 343 VdbeCoverage(v); | |
| 344 } | |
| 345 for(i=0; i<pFKey->nCol; i++){ | |
| 346 int iReg = aiCol[i] + regData + 1; | |
| 347 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v); | |
| 348 } | |
| 349 | |
| 350 if( isIgnore==0 ){ | |
| 351 if( pIdx==0 ){ | |
| 352 /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY | |
| 353 ** column of the parent table (table pTab). */ | |
| 354 int iMustBeInt; /* Address of MustBeInt instruction */ | |
| 355 int regTemp = sqlite3GetTempReg(pParse); | |
| 356 | |
| 357 /* Invoke MustBeInt to coerce the child key value to an integer (i.e. | |
| 358 ** apply the affinity of the parent key). If this fails, then there | |
| 359 ** is no matching parent key. Before using MustBeInt, make a copy of | |
| 360 ** the value. Otherwise, the value inserted into the child key column | |
| 361 ** will have INTEGER affinity applied to it, which may not be correct. */ | |
| 362 sqlite3VdbeAddOp2(v, OP_SCopy, aiCol[0]+1+regData, regTemp); | |
| 363 iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0); | |
| 364 VdbeCoverage(v); | |
| 365 | |
| 366 /* If the parent table is the same as the child table, and we are about | |
| 367 ** to increment the constraint-counter (i.e. this is an INSERT operation), | |
| 368 ** then check if the row being inserted matches itself. If so, do not | |
| 369 ** increment the constraint-counter. */ | |
| 370 if( pTab==pFKey->pFrom && nIncr==1 ){ | |
| 371 sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v); | |
| 372 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); | |
| 373 } | |
| 374 | |
| 375 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); | |
| 376 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v); | |
| 377 sqlite3VdbeGoto(v, iOk); | |
| 378 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); | |
| 379 sqlite3VdbeJumpHere(v, iMustBeInt); | |
| 380 sqlite3ReleaseTempReg(pParse, regTemp); | |
| 381 }else{ | |
| 382 int nCol = pFKey->nCol; | |
| 383 int regTemp = sqlite3GetTempRange(pParse, nCol); | |
| 384 int regRec = sqlite3GetTempReg(pParse); | |
| 385 | |
| 386 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb); | |
| 387 sqlite3VdbeSetP4KeyInfo(pParse, pIdx); | |
| 388 for(i=0; i<nCol; i++){ | |
| 389 sqlite3VdbeAddOp2(v, OP_Copy, aiCol[i]+1+regData, regTemp+i); | |
| 390 } | |
| 391 | |
| 392 /* If the parent table is the same as the child table, and we are about | |
| 393 ** to increment the constraint-counter (i.e. this is an INSERT operation), | |
| 394 ** then check if the row being inserted matches itself. If so, do not | |
| 395 ** increment the constraint-counter. | |
| 396 ** | |
| 397 ** If any of the parent-key values are NULL, then the row cannot match | |
| 398 ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any | |
| 399 ** of the parent-key values are NULL (at this point it is known that | |
| 400 ** none of the child key values are). | |
| 401 */ | |
| 402 if( pTab==pFKey->pFrom && nIncr==1 ){ | |
| 403 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1; | |
| 404 for(i=0; i<nCol; i++){ | |
| 405 int iChild = aiCol[i]+1+regData; | |
| 406 int iParent = pIdx->aiColumn[i]+1+regData; | |
| 407 assert( pIdx->aiColumn[i]>=0 ); | |
| 408 assert( aiCol[i]!=pTab->iPKey ); | |
| 409 if( pIdx->aiColumn[i]==pTab->iPKey ){ | |
| 410 /* The parent key is a composite key that includes the IPK column */ | |
| 411 iParent = regData; | |
| 412 } | |
| 413 sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v); | |
| 414 sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL); | |
| 415 } | |
| 416 sqlite3VdbeGoto(v, iOk); | |
| 417 } | |
| 418 | |
| 419 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec, | |
| 420 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol); | |
| 421 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0); VdbeCoverage(v); | |
| 422 | |
| 423 sqlite3ReleaseTempReg(pParse, regRec); | |
| 424 sqlite3ReleaseTempRange(pParse, regTemp, nCol); | |
| 425 } | |
| 426 } | |
| 427 | |
| 428 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs) | |
| 429 && !pParse->pToplevel | |
| 430 && !pParse->isMultiWrite | |
| 431 ){ | |
| 432 /* Special case: If this is an INSERT statement that will insert exactly | |
| 433 ** one row into the table, raise a constraint immediately instead of | |
| 434 ** incrementing a counter. This is necessary as the VM code is being | |
| 435 ** generated for will not open a statement transaction. */ | |
| 436 assert( nIncr==1 ); | |
| 437 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, | |
| 438 OE_Abort, 0, P4_STATIC, P5_ConstraintFK); | |
| 439 }else{ | |
| 440 if( nIncr>0 && pFKey->isDeferred==0 ){ | |
| 441 sqlite3MayAbort(pParse); | |
| 442 } | |
| 443 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); | |
| 444 } | |
| 445 | |
| 446 sqlite3VdbeResolveLabel(v, iOk); | |
| 447 sqlite3VdbeAddOp1(v, OP_Close, iCur); | |
| 448 } | |
| 449 | |
| 450 | |
| 451 /* | |
| 452 ** Return an Expr object that refers to a memory register corresponding | |
| 453 ** to column iCol of table pTab. | |
| 454 ** | |
| 455 ** regBase is the first of an array of register that contains the data | |
| 456 ** for pTab. regBase itself holds the rowid. regBase+1 holds the first | |
| 457 ** column. regBase+2 holds the second column, and so forth. | |
| 458 */ | |
| 459 static Expr *exprTableRegister( | |
| 460 Parse *pParse, /* Parsing and code generating context */ | |
| 461 Table *pTab, /* The table whose content is at r[regBase]... */ | |
| 462 int regBase, /* Contents of table pTab */ | |
| 463 i16 iCol /* Which column of pTab is desired */ | |
| 464 ){ | |
| 465 Expr *pExpr; | |
| 466 Column *pCol; | |
| 467 const char *zColl; | |
| 468 sqlite3 *db = pParse->db; | |
| 469 | |
| 470 pExpr = sqlite3Expr(db, TK_REGISTER, 0); | |
| 471 if( pExpr ){ | |
| 472 if( iCol>=0 && iCol!=pTab->iPKey ){ | |
| 473 pCol = &pTab->aCol[iCol]; | |
| 474 pExpr->iTable = regBase + iCol + 1; | |
| 475 pExpr->affinity = pCol->affinity; | |
| 476 zColl = pCol->zColl; | |
| 477 if( zColl==0 ) zColl = db->pDfltColl->zName; | |
| 478 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl); | |
| 479 }else{ | |
| 480 pExpr->iTable = regBase; | |
| 481 pExpr->affinity = SQLITE_AFF_INTEGER; | |
| 482 } | |
| 483 } | |
| 484 return pExpr; | |
| 485 } | |
| 486 | |
| 487 /* | |
| 488 ** Return an Expr object that refers to column iCol of table pTab which | |
| 489 ** has cursor iCur. | |
| 490 */ | |
| 491 static Expr *exprTableColumn( | |
| 492 sqlite3 *db, /* The database connection */ | |
| 493 Table *pTab, /* The table whose column is desired */ | |
| 494 int iCursor, /* The open cursor on the table */ | |
| 495 i16 iCol /* The column that is wanted */ | |
| 496 ){ | |
| 497 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0); | |
| 498 if( pExpr ){ | |
| 499 pExpr->pTab = pTab; | |
| 500 pExpr->iTable = iCursor; | |
| 501 pExpr->iColumn = iCol; | |
| 502 } | |
| 503 return pExpr; | |
| 504 } | |
| 505 | |
| 506 /* | |
| 507 ** This function is called to generate code executed when a row is deleted | |
| 508 ** from the parent table of foreign key constraint pFKey and, if pFKey is | |
| 509 ** deferred, when a row is inserted into the same table. When generating | |
| 510 ** code for an SQL UPDATE operation, this function may be called twice - | |
| 511 ** once to "delete" the old row and once to "insert" the new row. | |
| 512 ** | |
| 513 ** Parameter nIncr is passed -1 when inserting a row (as this may decrease | |
| 514 ** the number of FK violations in the db) or +1 when deleting one (as this | |
| 515 ** may increase the number of FK constraint problems). | |
| 516 ** | |
| 517 ** The code generated by this function scans through the rows in the child | |
| 518 ** table that correspond to the parent table row being deleted or inserted. | |
| 519 ** For each child row found, one of the following actions is taken: | |
| 520 ** | |
| 521 ** Operation | FK type | Action taken | |
| 522 ** -------------------------------------------------------------------------- | |
| 523 ** DELETE immediate Increment the "immediate constraint counter". | |
| 524 ** Or, if the ON (UPDATE|DELETE) action is RESTRICT, | |
| 525 ** throw a "FOREIGN KEY constraint failed" exception. | |
| 526 ** | |
| 527 ** INSERT immediate Decrement the "immediate constraint counter". | |
| 528 ** | |
| 529 ** DELETE deferred Increment the "deferred constraint counter". | |
| 530 ** Or, if the ON (UPDATE|DELETE) action is RESTRICT, | |
| 531 ** throw a "FOREIGN KEY constraint failed" exception. | |
| 532 ** | |
| 533 ** INSERT deferred Decrement the "deferred constraint counter". | |
| 534 ** | |
| 535 ** These operations are identified in the comment at the top of this file | |
| 536 ** (fkey.c) as "I.2" and "D.2". | |
| 537 */ | |
| 538 static void fkScanChildren( | |
| 539 Parse *pParse, /* Parse context */ | |
| 540 SrcList *pSrc, /* The child table to be scanned */ | |
| 541 Table *pTab, /* The parent table */ | |
| 542 Index *pIdx, /* Index on parent covering the foreign key */ | |
| 543 FKey *pFKey, /* The foreign key linking pSrc to pTab */ | |
| 544 int *aiCol, /* Map from pIdx cols to child table cols */ | |
| 545 int regData, /* Parent row data starts here */ | |
| 546 int nIncr /* Amount to increment deferred counter by */ | |
| 547 ){ | |
| 548 sqlite3 *db = pParse->db; /* Database handle */ | |
| 549 int i; /* Iterator variable */ | |
| 550 Expr *pWhere = 0; /* WHERE clause to scan with */ | |
| 551 NameContext sNameContext; /* Context used to resolve WHERE clause */ | |
| 552 WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */ | |
| 553 int iFkIfZero = 0; /* Address of OP_FkIfZero */ | |
| 554 Vdbe *v = sqlite3GetVdbe(pParse); | |
| 555 | |
| 556 assert( pIdx==0 || pIdx->pTable==pTab ); | |
| 557 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol ); | |
| 558 assert( pIdx!=0 || pFKey->nCol==1 ); | |
| 559 assert( pIdx!=0 || HasRowid(pTab) ); | |
| 560 | |
| 561 if( nIncr<0 ){ | |
| 562 iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0); | |
| 563 VdbeCoverage(v); | |
| 564 } | |
| 565 | |
| 566 /* Create an Expr object representing an SQL expression like: | |
| 567 ** | |
| 568 ** <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ... | |
| 569 ** | |
| 570 ** The collation sequence used for the comparison should be that of | |
| 571 ** the parent key columns. The affinity of the parent key column should | |
| 572 ** be applied to each child key value before the comparison takes place. | |
| 573 */ | |
| 574 for(i=0; i<pFKey->nCol; i++){ | |
| 575 Expr *pLeft; /* Value from parent table row */ | |
| 576 Expr *pRight; /* Column ref to child table */ | |
| 577 Expr *pEq; /* Expression (pLeft = pRight) */ | |
| 578 i16 iCol; /* Index of column in child table */ | |
| 579 const char *zCol; /* Name of column in child table */ | |
| 580 | |
| 581 iCol = pIdx ? pIdx->aiColumn[i] : -1; | |
| 582 pLeft = exprTableRegister(pParse, pTab, regData, iCol); | |
| 583 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; | |
| 584 assert( iCol>=0 ); | |
| 585 zCol = pFKey->pFrom->aCol[iCol].zName; | |
| 586 pRight = sqlite3Expr(db, TK_ID, zCol); | |
| 587 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0); | |
| 588 pWhere = sqlite3ExprAnd(db, pWhere, pEq); | |
| 589 } | |
| 590 | |
| 591 /* If the child table is the same as the parent table, then add terms | |
| 592 ** to the WHERE clause that prevent this entry from being scanned. | |
| 593 ** The added WHERE clause terms are like this: | |
| 594 ** | |
| 595 ** $current_rowid!=rowid | |
| 596 ** NOT( $current_a==a AND $current_b==b AND ... ) | |
| 597 ** | |
| 598 ** The first form is used for rowid tables. The second form is used | |
| 599 ** for WITHOUT ROWID tables. In the second form, the primary key is | |
| 600 ** (a,b,...) | |
| 601 */ | |
| 602 if( pTab==pFKey->pFrom && nIncr>0 ){ | |
| 603 Expr *pNe; /* Expression (pLeft != pRight) */ | |
| 604 Expr *pLeft; /* Value from parent table row */ | |
| 605 Expr *pRight; /* Column ref to child table */ | |
| 606 if( HasRowid(pTab) ){ | |
| 607 pLeft = exprTableRegister(pParse, pTab, regData, -1); | |
| 608 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1); | |
| 609 pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0); | |
| 610 }else{ | |
| 611 Expr *pEq, *pAll = 0; | |
| 612 Index *pPk = sqlite3PrimaryKeyIndex(pTab); | |
| 613 assert( pIdx!=0 ); | |
| 614 for(i=0; i<pPk->nKeyCol; i++){ | |
| 615 i16 iCol = pIdx->aiColumn[i]; | |
| 616 assert( iCol>=0 ); | |
| 617 pLeft = exprTableRegister(pParse, pTab, regData, iCol); | |
| 618 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, iCol); | |
| 619 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0); | |
| 620 pAll = sqlite3ExprAnd(db, pAll, pEq); | |
| 621 } | |
| 622 pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0, 0); | |
| 623 } | |
| 624 pWhere = sqlite3ExprAnd(db, pWhere, pNe); | |
| 625 } | |
| 626 | |
| 627 /* Resolve the references in the WHERE clause. */ | |
| 628 memset(&sNameContext, 0, sizeof(NameContext)); | |
| 629 sNameContext.pSrcList = pSrc; | |
| 630 sNameContext.pParse = pParse; | |
| 631 sqlite3ResolveExprNames(&sNameContext, pWhere); | |
| 632 | |
| 633 /* Create VDBE to loop through the entries in pSrc that match the WHERE | |
| 634 ** clause. For each row found, increment either the deferred or immediate | |
| 635 ** foreign key constraint counter. */ | |
| 636 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0); | |
| 637 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); | |
| 638 if( pWInfo ){ | |
| 639 sqlite3WhereEnd(pWInfo); | |
| 640 } | |
| 641 | |
| 642 /* Clean up the WHERE clause constructed above. */ | |
| 643 sqlite3ExprDelete(db, pWhere); | |
| 644 if( iFkIfZero ){ | |
| 645 sqlite3VdbeJumpHere(v, iFkIfZero); | |
| 646 } | |
| 647 } | |
| 648 | |
| 649 /* | |
| 650 ** This function returns a linked list of FKey objects (connected by | |
| 651 ** FKey.pNextTo) holding all children of table pTab. For example, | |
| 652 ** given the following schema: | |
| 653 ** | |
| 654 ** CREATE TABLE t1(a PRIMARY KEY); | |
| 655 ** CREATE TABLE t2(b REFERENCES t1(a); | |
| 656 ** | |
| 657 ** Calling this function with table "t1" as an argument returns a pointer | |
| 658 ** to the FKey structure representing the foreign key constraint on table | |
| 659 ** "t2". Calling this function with "t2" as the argument would return a | |
| 660 ** NULL pointer (as there are no FK constraints for which t2 is the parent | |
| 661 ** table). | |
| 662 */ | |
| 663 FKey *sqlite3FkReferences(Table *pTab){ | |
| 664 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName); | |
| 665 } | |
| 666 | |
| 667 /* | |
| 668 ** The second argument is a Trigger structure allocated by the | |
| 669 ** fkActionTrigger() routine. This function deletes the Trigger structure | |
| 670 ** and all of its sub-components. | |
| 671 ** | |
| 672 ** The Trigger structure or any of its sub-components may be allocated from | |
| 673 ** the lookaside buffer belonging to database handle dbMem. | |
| 674 */ | |
| 675 static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ | |
| 676 if( p ){ | |
| 677 TriggerStep *pStep = p->step_list; | |
| 678 sqlite3ExprDelete(dbMem, pStep->pWhere); | |
| 679 sqlite3ExprListDelete(dbMem, pStep->pExprList); | |
| 680 sqlite3SelectDelete(dbMem, pStep->pSelect); | |
| 681 sqlite3ExprDelete(dbMem, p->pWhen); | |
| 682 sqlite3DbFree(dbMem, p); | |
| 683 } | |
| 684 } | |
| 685 | |
| 686 /* | |
| 687 ** This function is called to generate code that runs when table pTab is | |
| 688 ** being dropped from the database. The SrcList passed as the second argument | |
| 689 ** to this function contains a single entry guaranteed to resolve to | |
| 690 ** table pTab. | |
| 691 ** | |
| 692 ** Normally, no code is required. However, if either | |
| 693 ** | |
| 694 ** (a) The table is the parent table of a FK constraint, or | |
| 695 ** (b) The table is the child table of a deferred FK constraint and it is | |
| 696 ** determined at runtime that there are outstanding deferred FK | |
| 697 ** constraint violations in the database, | |
| 698 ** | |
| 699 ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping | |
| 700 ** the table from the database. Triggers are disabled while running this | |
| 701 ** DELETE, but foreign key actions are not. | |
| 702 */ | |
| 703 void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){ | |
| 704 sqlite3 *db = pParse->db; | |
| 705 if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){ | |
| 706 int iSkip = 0; | |
| 707 Vdbe *v = sqlite3GetVdbe(pParse); | |
| 708 | |
| 709 assert( v ); /* VDBE has already been allocated */ | |
| 710 if( sqlite3FkReferences(pTab)==0 ){ | |
| 711 /* Search for a deferred foreign key constraint for which this table | |
| 712 ** is the child table. If one cannot be found, return without | |
| 713 ** generating any VDBE code. If one can be found, then jump over | |
| 714 ** the entire DELETE if there are no outstanding deferred constraints | |
| 715 ** when this statement is run. */ | |
| 716 FKey *p; | |
| 717 for(p=pTab->pFKey; p; p=p->pNextFrom){ | |
| 718 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break; | |
| 719 } | |
| 720 if( !p ) return; | |
| 721 iSkip = sqlite3VdbeMakeLabel(v); | |
| 722 sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v); | |
| 723 } | |
| 724 | |
| 725 pParse->disableTriggers = 1; | |
| 726 sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0); | |
| 727 pParse->disableTriggers = 0; | |
| 728 | |
| 729 /* If the DELETE has generated immediate foreign key constraint | |
| 730 ** violations, halt the VDBE and return an error at this point, before | |
| 731 ** any modifications to the schema are made. This is because statement | |
| 732 ** transactions are not able to rollback schema changes. | |
| 733 ** | |
| 734 ** If the SQLITE_DeferFKs flag is set, then this is not required, as | |
| 735 ** the statement transaction will not be rolled back even if FK | |
| 736 ** constraints are violated. | |
| 737 */ | |
| 738 if( (db->flags & SQLITE_DeferFKs)==0 ){ | |
| 739 sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2); | |
| 740 VdbeCoverage(v); | |
| 741 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, | |
| 742 OE_Abort, 0, P4_STATIC, P5_ConstraintFK); | |
| 743 } | |
| 744 | |
| 745 if( iSkip ){ | |
| 746 sqlite3VdbeResolveLabel(v, iSkip); | |
| 747 } | |
| 748 } | |
| 749 } | |
| 750 | |
| 751 | |
| 752 /* | |
| 753 ** The second argument points to an FKey object representing a foreign key | |
| 754 ** for which pTab is the child table. An UPDATE statement against pTab | |
| 755 ** is currently being processed. For each column of the table that is | |
| 756 ** actually updated, the corresponding element in the aChange[] array | |
| 757 ** is zero or greater (if a column is unmodified the corresponding element | |
| 758 ** is set to -1). If the rowid column is modified by the UPDATE statement | |
| 759 ** the bChngRowid argument is non-zero. | |
| 760 ** | |
| 761 ** This function returns true if any of the columns that are part of the | |
| 762 ** child key for FK constraint *p are modified. | |
| 763 */ | |
| 764 static int fkChildIsModified( | |
| 765 Table *pTab, /* Table being updated */ | |
| 766 FKey *p, /* Foreign key for which pTab is the child */ | |
| 767 int *aChange, /* Array indicating modified columns */ | |
| 768 int bChngRowid /* True if rowid is modified by this update */ | |
| 769 ){ | |
| 770 int i; | |
| 771 for(i=0; i<p->nCol; i++){ | |
| 772 int iChildKey = p->aCol[i].iFrom; | |
| 773 if( aChange[iChildKey]>=0 ) return 1; | |
| 774 if( iChildKey==pTab->iPKey && bChngRowid ) return 1; | |
| 775 } | |
| 776 return 0; | |
| 777 } | |
| 778 | |
| 779 /* | |
| 780 ** The second argument points to an FKey object representing a foreign key | |
| 781 ** for which pTab is the parent table. An UPDATE statement against pTab | |
| 782 ** is currently being processed. For each column of the table that is | |
| 783 ** actually updated, the corresponding element in the aChange[] array | |
| 784 ** is zero or greater (if a column is unmodified the corresponding element | |
| 785 ** is set to -1). If the rowid column is modified by the UPDATE statement | |
| 786 ** the bChngRowid argument is non-zero. | |
| 787 ** | |
| 788 ** This function returns true if any of the columns that are part of the | |
| 789 ** parent key for FK constraint *p are modified. | |
| 790 */ | |
| 791 static int fkParentIsModified( | |
| 792 Table *pTab, | |
| 793 FKey *p, | |
| 794 int *aChange, | |
| 795 int bChngRowid | |
| 796 ){ | |
| 797 int i; | |
| 798 for(i=0; i<p->nCol; i++){ | |
| 799 char *zKey = p->aCol[i].zCol; | |
| 800 int iKey; | |
| 801 for(iKey=0; iKey<pTab->nCol; iKey++){ | |
| 802 if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){ | |
| 803 Column *pCol = &pTab->aCol[iKey]; | |
| 804 if( zKey ){ | |
| 805 if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1; | |
| 806 }else if( pCol->colFlags & COLFLAG_PRIMKEY ){ | |
| 807 return 1; | |
| 808 } | |
| 809 } | |
| 810 } | |
| 811 } | |
| 812 return 0; | |
| 813 } | |
| 814 | |
| 815 /* | |
| 816 ** Return true if the parser passed as the first argument is being | |
| 817 ** used to code a trigger that is really a "SET NULL" action belonging | |
| 818 ** to trigger pFKey. | |
| 819 */ | |
| 820 static int isSetNullAction(Parse *pParse, FKey *pFKey){ | |
| 821 Parse *pTop = sqlite3ParseToplevel(pParse); | |
| 822 if( pTop->pTriggerPrg ){ | |
| 823 Trigger *p = pTop->pTriggerPrg->pTrigger; | |
| 824 if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull) | |
| 825 || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull) | |
| 826 ){ | |
| 827 return 1; | |
| 828 } | |
| 829 } | |
| 830 return 0; | |
| 831 } | |
| 832 | |
| 833 /* | |
| 834 ** This function is called when inserting, deleting or updating a row of | |
| 835 ** table pTab to generate VDBE code to perform foreign key constraint | |
| 836 ** processing for the operation. | |
| 837 ** | |
| 838 ** For a DELETE operation, parameter regOld is passed the index of the | |
| 839 ** first register in an array of (pTab->nCol+1) registers containing the | |
| 840 ** rowid of the row being deleted, followed by each of the column values | |
| 841 ** of the row being deleted, from left to right. Parameter regNew is passed | |
| 842 ** zero in this case. | |
| 843 ** | |
| 844 ** For an INSERT operation, regOld is passed zero and regNew is passed the | |
| 845 ** first register of an array of (pTab->nCol+1) registers containing the new | |
| 846 ** row data. | |
| 847 ** | |
| 848 ** For an UPDATE operation, this function is called twice. Once before | |
| 849 ** the original record is deleted from the table using the calling convention | |
| 850 ** described for DELETE. Then again after the original record is deleted | |
| 851 ** but before the new record is inserted using the INSERT convention. | |
| 852 */ | |
| 853 void sqlite3FkCheck( | |
| 854 Parse *pParse, /* Parse context */ | |
| 855 Table *pTab, /* Row is being deleted from this table */ | |
| 856 int regOld, /* Previous row data is stored here */ | |
| 857 int regNew, /* New row data is stored here */ | |
| 858 int *aChange, /* Array indicating UPDATEd columns (or 0) */ | |
| 859 int bChngRowid /* True if rowid is UPDATEd */ | |
| 860 ){ | |
| 861 sqlite3 *db = pParse->db; /* Database handle */ | |
| 862 FKey *pFKey; /* Used to iterate through FKs */ | |
| 863 int iDb; /* Index of database containing pTab */ | |
| 864 const char *zDb; /* Name of database containing pTab */ | |
| 865 int isIgnoreErrors = pParse->disableTriggers; | |
| 866 | |
| 867 /* Exactly one of regOld and regNew should be non-zero. */ | |
| 868 assert( (regOld==0)!=(regNew==0) ); | |
| 869 | |
| 870 /* If foreign-keys are disabled, this function is a no-op. */ | |
| 871 if( (db->flags&SQLITE_ForeignKeys)==0 ) return; | |
| 872 | |
| 873 iDb = sqlite3SchemaToIndex(db, pTab->pSchema); | |
| 874 zDb = db->aDb[iDb].zName; | |
| 875 | |
| 876 /* Loop through all the foreign key constraints for which pTab is the | |
| 877 ** child table (the table that the foreign key definition is part of). */ | |
| 878 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ | |
| 879 Table *pTo; /* Parent table of foreign key pFKey */ | |
| 880 Index *pIdx = 0; /* Index on key columns in pTo */ | |
| 881 int *aiFree = 0; | |
| 882 int *aiCol; | |
| 883 int iCol; | |
| 884 int i; | |
| 885 int bIgnore = 0; | |
| 886 | |
| 887 if( aChange | |
| 888 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0 | |
| 889 && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0 | |
| 890 ){ | |
| 891 continue; | |
| 892 } | |
| 893 | |
| 894 /* Find the parent table of this foreign key. Also find a unique index | |
| 895 ** on the parent key columns in the parent table. If either of these | |
| 896 ** schema items cannot be located, set an error in pParse and return | |
| 897 ** early. */ | |
| 898 if( pParse->disableTriggers ){ | |
| 899 pTo = sqlite3FindTable(db, pFKey->zTo, zDb); | |
| 900 }else{ | |
| 901 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb); | |
| 902 } | |
| 903 if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){ | |
| 904 assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) ); | |
| 905 if( !isIgnoreErrors || db->mallocFailed ) return; | |
| 906 if( pTo==0 ){ | |
| 907 /* If isIgnoreErrors is true, then a table is being dropped. In this | |
| 908 ** case SQLite runs a "DELETE FROM xxx" on the table being dropped | |
| 909 ** before actually dropping it in order to check FK constraints. | |
| 910 ** If the parent table of an FK constraint on the current table is | |
| 911 ** missing, behave as if it is empty. i.e. decrement the relevant | |
| 912 ** FK counter for each row of the current table with non-NULL keys. | |
| 913 */ | |
| 914 Vdbe *v = sqlite3GetVdbe(pParse); | |
| 915 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1; | |
| 916 for(i=0; i<pFKey->nCol; i++){ | |
| 917 int iReg = pFKey->aCol[i].iFrom + regOld + 1; | |
| 918 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v); | |
| 919 } | |
| 920 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1); | |
| 921 } | |
| 922 continue; | |
| 923 } | |
| 924 assert( pFKey->nCol==1 || (aiFree && pIdx) ); | |
| 925 | |
| 926 if( aiFree ){ | |
| 927 aiCol = aiFree; | |
| 928 }else{ | |
| 929 iCol = pFKey->aCol[0].iFrom; | |
| 930 aiCol = &iCol; | |
| 931 } | |
| 932 for(i=0; i<pFKey->nCol; i++){ | |
| 933 if( aiCol[i]==pTab->iPKey ){ | |
| 934 aiCol[i] = -1; | |
| 935 } | |
| 936 assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); | |
| 937 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 938 /* Request permission to read the parent key columns. If the | |
| 939 ** authorization callback returns SQLITE_IGNORE, behave as if any | |
| 940 ** values read from the parent table are NULL. */ | |
| 941 if( db->xAuth ){ | |
| 942 int rcauth; | |
| 943 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName; | |
| 944 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb); | |
| 945 bIgnore = (rcauth==SQLITE_IGNORE); | |
| 946 } | |
| 947 #endif | |
| 948 } | |
| 949 | |
| 950 /* Take a shared-cache advisory read-lock on the parent table. Allocate | |
| 951 ** a cursor to use to search the unique index on the parent key columns | |
| 952 ** in the parent table. */ | |
| 953 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName); | |
| 954 pParse->nTab++; | |
| 955 | |
| 956 if( regOld!=0 ){ | |
| 957 /* A row is being removed from the child table. Search for the parent. | |
| 958 ** If the parent does not exist, removing the child row resolves an | |
| 959 ** outstanding foreign key constraint violation. */ | |
| 960 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore); | |
| 961 } | |
| 962 if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){ | |
| 963 /* A row is being added to the child table. If a parent row cannot | |
| 964 ** be found, adding the child row has violated the FK constraint. | |
| 965 ** | |
| 966 ** If this operation is being performed as part of a trigger program | |
| 967 ** that is actually a "SET NULL" action belonging to this very | |
| 968 ** foreign key, then omit this scan altogether. As all child key | |
| 969 ** values are guaranteed to be NULL, it is not possible for adding | |
| 970 ** this row to cause an FK violation. */ | |
| 971 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore); | |
| 972 } | |
| 973 | |
| 974 sqlite3DbFree(db, aiFree); | |
| 975 } | |
| 976 | |
| 977 /* Loop through all the foreign key constraints that refer to this table. | |
| 978 ** (the "child" constraints) */ | |
| 979 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ | |
| 980 Index *pIdx = 0; /* Foreign key index for pFKey */ | |
| 981 SrcList *pSrc; | |
| 982 int *aiCol = 0; | |
| 983 | |
| 984 if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){ | |
| 985 continue; | |
| 986 } | |
| 987 | |
| 988 if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs) | |
| 989 && !pParse->pToplevel && !pParse->isMultiWrite | |
| 990 ){ | |
| 991 assert( regOld==0 && regNew!=0 ); | |
| 992 /* Inserting a single row into a parent table cannot cause (or fix) | |
| 993 ** an immediate foreign key violation. So do nothing in this case. */ | |
| 994 continue; | |
| 995 } | |
| 996 | |
| 997 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){ | |
| 998 if( !isIgnoreErrors || db->mallocFailed ) return; | |
| 999 continue; | |
| 1000 } | |
| 1001 assert( aiCol || pFKey->nCol==1 ); | |
| 1002 | |
| 1003 /* Create a SrcList structure containing the child table. We need the | |
| 1004 ** child table as a SrcList for sqlite3WhereBegin() */ | |
| 1005 pSrc = sqlite3SrcListAppend(db, 0, 0, 0); | |
| 1006 if( pSrc ){ | |
| 1007 struct SrcList_item *pItem = pSrc->a; | |
| 1008 pItem->pTab = pFKey->pFrom; | |
| 1009 pItem->zName = pFKey->pFrom->zName; | |
| 1010 pItem->pTab->nRef++; | |
| 1011 pItem->iCursor = pParse->nTab++; | |
| 1012 | |
| 1013 if( regNew!=0 ){ | |
| 1014 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1); | |
| 1015 } | |
| 1016 if( regOld!=0 ){ | |
| 1017 int eAction = pFKey->aAction[aChange!=0]; | |
| 1018 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1); | |
| 1019 /* If this is a deferred FK constraint, or a CASCADE or SET NULL | |
| 1020 ** action applies, then any foreign key violations caused by | |
| 1021 ** removing the parent key will be rectified by the action trigger. | |
| 1022 ** So do not set the "may-abort" flag in this case. | |
| 1023 ** | |
| 1024 ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the | |
| 1025 ** may-abort flag will eventually be set on this statement anyway | |
| 1026 ** (when this function is called as part of processing the UPDATE | |
| 1027 ** within the action trigger). | |
| 1028 ** | |
| 1029 ** Note 2: At first glance it may seem like SQLite could simply omit | |
| 1030 ** all OP_FkCounter related scans when either CASCADE or SET NULL | |
| 1031 ** applies. The trouble starts if the CASCADE or SET NULL action | |
| 1032 ** trigger causes other triggers or action rules attached to the | |
| 1033 ** child table to fire. In these cases the fk constraint counters | |
| 1034 ** might be set incorrectly if any OP_FkCounter related scans are | |
| 1035 ** omitted. */ | |
| 1036 if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){ | |
| 1037 sqlite3MayAbort(pParse); | |
| 1038 } | |
| 1039 } | |
| 1040 pItem->zName = 0; | |
| 1041 sqlite3SrcListDelete(db, pSrc); | |
| 1042 } | |
| 1043 sqlite3DbFree(db, aiCol); | |
| 1044 } | |
| 1045 } | |
| 1046 | |
| 1047 #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x))) | |
| 1048 | |
| 1049 /* | |
| 1050 ** This function is called before generating code to update or delete a | |
| 1051 ** row contained in table pTab. | |
| 1052 */ | |
| 1053 u32 sqlite3FkOldmask( | |
| 1054 Parse *pParse, /* Parse context */ | |
| 1055 Table *pTab /* Table being modified */ | |
| 1056 ){ | |
| 1057 u32 mask = 0; | |
| 1058 if( pParse->db->flags&SQLITE_ForeignKeys ){ | |
| 1059 FKey *p; | |
| 1060 int i; | |
| 1061 for(p=pTab->pFKey; p; p=p->pNextFrom){ | |
| 1062 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom); | |
| 1063 } | |
| 1064 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ | |
| 1065 Index *pIdx = 0; | |
| 1066 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0); | |
| 1067 if( pIdx ){ | |
| 1068 for(i=0; i<pIdx->nKeyCol; i++){ | |
| 1069 assert( pIdx->aiColumn[i]>=0 ); | |
| 1070 mask |= COLUMN_MASK(pIdx->aiColumn[i]); | |
| 1071 } | |
| 1072 } | |
| 1073 } | |
| 1074 } | |
| 1075 return mask; | |
| 1076 } | |
| 1077 | |
| 1078 | |
| 1079 /* | |
| 1080 ** This function is called before generating code to update or delete a | |
| 1081 ** row contained in table pTab. If the operation is a DELETE, then | |
| 1082 ** parameter aChange is passed a NULL value. For an UPDATE, aChange points | |
| 1083 ** to an array of size N, where N is the number of columns in table pTab. | |
| 1084 ** If the i'th column is not modified by the UPDATE, then the corresponding | |
| 1085 ** entry in the aChange[] array is set to -1. If the column is modified, | |
| 1086 ** the value is 0 or greater. Parameter chngRowid is set to true if the | |
| 1087 ** UPDATE statement modifies the rowid fields of the table. | |
| 1088 ** | |
| 1089 ** If any foreign key processing will be required, this function returns | |
| 1090 ** true. If there is no foreign key related processing, this function | |
| 1091 ** returns false. | |
| 1092 */ | |
| 1093 int sqlite3FkRequired( | |
| 1094 Parse *pParse, /* Parse context */ | |
| 1095 Table *pTab, /* Table being modified */ | |
| 1096 int *aChange, /* Non-NULL for UPDATE operations */ | |
| 1097 int chngRowid /* True for UPDATE that affects rowid */ | |
| 1098 ){ | |
| 1099 if( pParse->db->flags&SQLITE_ForeignKeys ){ | |
| 1100 if( !aChange ){ | |
| 1101 /* A DELETE operation. Foreign key processing is required if the | |
| 1102 ** table in question is either the child or parent table for any | |
| 1103 ** foreign key constraint. */ | |
| 1104 return (sqlite3FkReferences(pTab) || pTab->pFKey); | |
| 1105 }else{ | |
| 1106 /* This is an UPDATE. Foreign key processing is only required if the | |
| 1107 ** operation modifies one or more child or parent key columns. */ | |
| 1108 FKey *p; | |
| 1109 | |
| 1110 /* Check if any child key columns are being modified. */ | |
| 1111 for(p=pTab->pFKey; p; p=p->pNextFrom){ | |
| 1112 if( fkChildIsModified(pTab, p, aChange, chngRowid) ) return 1; | |
| 1113 } | |
| 1114 | |
| 1115 /* Check if any parent key columns are being modified. */ | |
| 1116 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ | |
| 1117 if( fkParentIsModified(pTab, p, aChange, chngRowid) ) return 1; | |
| 1118 } | |
| 1119 } | |
| 1120 } | |
| 1121 return 0; | |
| 1122 } | |
| 1123 | |
| 1124 /* | |
| 1125 ** This function is called when an UPDATE or DELETE operation is being | |
| 1126 ** compiled on table pTab, which is the parent table of foreign-key pFKey. | |
| 1127 ** If the current operation is an UPDATE, then the pChanges parameter is | |
| 1128 ** passed a pointer to the list of columns being modified. If it is a | |
| 1129 ** DELETE, pChanges is passed a NULL pointer. | |
| 1130 ** | |
| 1131 ** It returns a pointer to a Trigger structure containing a trigger | |
| 1132 ** equivalent to the ON UPDATE or ON DELETE action specified by pFKey. | |
| 1133 ** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is | |
| 1134 ** returned (these actions require no special handling by the triggers | |
| 1135 ** sub-system, code for them is created by fkScanChildren()). | |
| 1136 ** | |
| 1137 ** For example, if pFKey is the foreign key and pTab is table "p" in | |
| 1138 ** the following schema: | |
| 1139 ** | |
| 1140 ** CREATE TABLE p(pk PRIMARY KEY); | |
| 1141 ** CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE); | |
| 1142 ** | |
| 1143 ** then the returned trigger structure is equivalent to: | |
| 1144 ** | |
| 1145 ** CREATE TRIGGER ... DELETE ON p BEGIN | |
| 1146 ** DELETE FROM c WHERE ck = old.pk; | |
| 1147 ** END; | |
| 1148 ** | |
| 1149 ** The returned pointer is cached as part of the foreign key object. It | |
| 1150 ** is eventually freed along with the rest of the foreign key object by | |
| 1151 ** sqlite3FkDelete(). | |
| 1152 */ | |
| 1153 static Trigger *fkActionTrigger( | |
| 1154 Parse *pParse, /* Parse context */ | |
| 1155 Table *pTab, /* Table being updated or deleted from */ | |
| 1156 FKey *pFKey, /* Foreign key to get action for */ | |
| 1157 ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */ | |
| 1158 ){ | |
| 1159 sqlite3 *db = pParse->db; /* Database handle */ | |
| 1160 int action; /* One of OE_None, OE_Cascade etc. */ | |
| 1161 Trigger *pTrigger; /* Trigger definition to return */ | |
| 1162 int iAction = (pChanges!=0); /* 1 for UPDATE, 0 for DELETE */ | |
| 1163 | |
| 1164 action = pFKey->aAction[iAction]; | |
| 1165 pTrigger = pFKey->apTrigger[iAction]; | |
| 1166 | |
| 1167 if( action!=OE_None && !pTrigger ){ | |
| 1168 u8 enableLookaside; /* Copy of db->lookaside.bEnabled */ | |
| 1169 char const *zFrom; /* Name of child table */ | |
| 1170 int nFrom; /* Length in bytes of zFrom */ | |
| 1171 Index *pIdx = 0; /* Parent key index for this FK */ | |
| 1172 int *aiCol = 0; /* child table cols -> parent key cols */ | |
| 1173 TriggerStep *pStep = 0; /* First (only) step of trigger program */ | |
| 1174 Expr *pWhere = 0; /* WHERE clause of trigger step */ | |
| 1175 ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */ | |
| 1176 Select *pSelect = 0; /* If RESTRICT, "SELECT RAISE(...)" */ | |
| 1177 int i; /* Iterator variable */ | |
| 1178 Expr *pWhen = 0; /* WHEN clause for the trigger */ | |
| 1179 | |
| 1180 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0; | |
| 1181 assert( aiCol || pFKey->nCol==1 ); | |
| 1182 | |
| 1183 for(i=0; i<pFKey->nCol; i++){ | |
| 1184 Token tOld = { "old", 3 }; /* Literal "old" token */ | |
| 1185 Token tNew = { "new", 3 }; /* Literal "new" token */ | |
| 1186 Token tFromCol; /* Name of column in child table */ | |
| 1187 Token tToCol; /* Name of column in parent table */ | |
| 1188 int iFromCol; /* Idx of column in child table */ | |
| 1189 Expr *pEq; /* tFromCol = OLD.tToCol */ | |
| 1190 | |
| 1191 iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; | |
| 1192 assert( iFromCol>=0 ); | |
| 1193 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) ); | |
| 1194 assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); | |
| 1195 tToCol.z = pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName; | |
| 1196 tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName; | |
| 1197 | |
| 1198 tToCol.n = sqlite3Strlen30(tToCol.z); | |
| 1199 tFromCol.n = sqlite3Strlen30(tFromCol.z); | |
| 1200 | |
| 1201 /* Create the expression "OLD.zToCol = zFromCol". It is important | |
| 1202 ** that the "OLD.zToCol" term is on the LHS of the = operator, so | |
| 1203 ** that the affinity and collation sequence associated with the | |
| 1204 ** parent table are used for the comparison. */ | |
| 1205 pEq = sqlite3PExpr(pParse, TK_EQ, | |
| 1206 sqlite3PExpr(pParse, TK_DOT, | |
| 1207 sqlite3ExprAlloc(db, TK_ID, &tOld, 0), | |
| 1208 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0) | |
| 1209 , 0), | |
| 1210 sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0) | |
| 1211 , 0); | |
| 1212 pWhere = sqlite3ExprAnd(db, pWhere, pEq); | |
| 1213 | |
| 1214 /* For ON UPDATE, construct the next term of the WHEN clause. | |
| 1215 ** The final WHEN clause will be like this: | |
| 1216 ** | |
| 1217 ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN) | |
| 1218 */ | |
| 1219 if( pChanges ){ | |
| 1220 pEq = sqlite3PExpr(pParse, TK_IS, | |
| 1221 sqlite3PExpr(pParse, TK_DOT, | |
| 1222 sqlite3ExprAlloc(db, TK_ID, &tOld, 0), | |
| 1223 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0), | |
| 1224 0), | |
| 1225 sqlite3PExpr(pParse, TK_DOT, | |
| 1226 sqlite3ExprAlloc(db, TK_ID, &tNew, 0), | |
| 1227 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0), | |
| 1228 0), | |
| 1229 0); | |
| 1230 pWhen = sqlite3ExprAnd(db, pWhen, pEq); | |
| 1231 } | |
| 1232 | |
| 1233 if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){ | |
| 1234 Expr *pNew; | |
| 1235 if( action==OE_Cascade ){ | |
| 1236 pNew = sqlite3PExpr(pParse, TK_DOT, | |
| 1237 sqlite3ExprAlloc(db, TK_ID, &tNew, 0), | |
| 1238 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0) | |
| 1239 , 0); | |
| 1240 }else if( action==OE_SetDflt ){ | |
| 1241 Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt; | |
| 1242 if( pDflt ){ | |
| 1243 pNew = sqlite3ExprDup(db, pDflt, 0); | |
| 1244 }else{ | |
| 1245 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0); | |
| 1246 } | |
| 1247 }else{ | |
| 1248 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0); | |
| 1249 } | |
| 1250 pList = sqlite3ExprListAppend(pParse, pList, pNew); | |
| 1251 sqlite3ExprListSetName(pParse, pList, &tFromCol, 0); | |
| 1252 } | |
| 1253 } | |
| 1254 sqlite3DbFree(db, aiCol); | |
| 1255 | |
| 1256 zFrom = pFKey->pFrom->zName; | |
| 1257 nFrom = sqlite3Strlen30(zFrom); | |
| 1258 | |
| 1259 if( action==OE_Restrict ){ | |
| 1260 Token tFrom; | |
| 1261 Expr *pRaise; | |
| 1262 | |
| 1263 tFrom.z = zFrom; | |
| 1264 tFrom.n = nFrom; | |
| 1265 pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed"); | |
| 1266 if( pRaise ){ | |
| 1267 pRaise->affinity = OE_Abort; | |
| 1268 } | |
| 1269 pSelect = sqlite3SelectNew(pParse, | |
| 1270 sqlite3ExprListAppend(pParse, 0, pRaise), | |
| 1271 sqlite3SrcListAppend(db, 0, &tFrom, 0), | |
| 1272 pWhere, | |
| 1273 0, 0, 0, 0, 0, 0 | |
| 1274 ); | |
| 1275 pWhere = 0; | |
| 1276 } | |
| 1277 | |
| 1278 /* Disable lookaside memory allocation */ | |
| 1279 enableLookaside = db->lookaside.bEnabled; | |
| 1280 db->lookaside.bEnabled = 0; | |
| 1281 | |
| 1282 pTrigger = (Trigger *)sqlite3DbMallocZero(db, | |
| 1283 sizeof(Trigger) + /* struct Trigger */ | |
| 1284 sizeof(TriggerStep) + /* Single step in trigger program */ | |
| 1285 nFrom + 1 /* Space for pStep->zTarget */ | |
| 1286 ); | |
| 1287 if( pTrigger ){ | |
| 1288 pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1]; | |
| 1289 pStep->zTarget = (char *)&pStep[1]; | |
| 1290 memcpy((char *)pStep->zTarget, zFrom, nFrom); | |
| 1291 | |
| 1292 pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); | |
| 1293 pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); | |
| 1294 pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); | |
| 1295 if( pWhen ){ | |
| 1296 pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0); | |
| 1297 pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); | |
| 1298 } | |
| 1299 } | |
| 1300 | |
| 1301 /* Re-enable the lookaside buffer, if it was disabled earlier. */ | |
| 1302 db->lookaside.bEnabled = enableLookaside; | |
| 1303 | |
| 1304 sqlite3ExprDelete(db, pWhere); | |
| 1305 sqlite3ExprDelete(db, pWhen); | |
| 1306 sqlite3ExprListDelete(db, pList); | |
| 1307 sqlite3SelectDelete(db, pSelect); | |
| 1308 if( db->mallocFailed==1 ){ | |
| 1309 fkTriggerDelete(db, pTrigger); | |
| 1310 return 0; | |
| 1311 } | |
| 1312 assert( pStep!=0 ); | |
| 1313 | |
| 1314 switch( action ){ | |
| 1315 case OE_Restrict: | |
| 1316 pStep->op = TK_SELECT; | |
| 1317 break; | |
| 1318 case OE_Cascade: | |
| 1319 if( !pChanges ){ | |
| 1320 pStep->op = TK_DELETE; | |
| 1321 break; | |
| 1322 } | |
| 1323 default: | |
| 1324 pStep->op = TK_UPDATE; | |
| 1325 } | |
| 1326 pStep->pTrig = pTrigger; | |
| 1327 pTrigger->pSchema = pTab->pSchema; | |
| 1328 pTrigger->pTabSchema = pTab->pSchema; | |
| 1329 pFKey->apTrigger[iAction] = pTrigger; | |
| 1330 pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE); | |
| 1331 } | |
| 1332 | |
| 1333 return pTrigger; | |
| 1334 } | |
| 1335 | |
| 1336 /* | |
| 1337 ** This function is called when deleting or updating a row to implement | |
| 1338 ** any required CASCADE, SET NULL or SET DEFAULT actions. | |
| 1339 */ | |
| 1340 void sqlite3FkActions( | |
| 1341 Parse *pParse, /* Parse context */ | |
| 1342 Table *pTab, /* Table being updated or deleted from */ | |
| 1343 ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */ | |
| 1344 int regOld, /* Address of array containing old row */ | |
| 1345 int *aChange, /* Array indicating UPDATEd columns (or 0) */ | |
| 1346 int bChngRowid /* True if rowid is UPDATEd */ | |
| 1347 ){ | |
| 1348 /* If foreign-key support is enabled, iterate through all FKs that | |
| 1349 ** refer to table pTab. If there is an action associated with the FK | |
| 1350 ** for this operation (either update or delete), invoke the associated | |
| 1351 ** trigger sub-program. */ | |
| 1352 if( pParse->db->flags&SQLITE_ForeignKeys ){ | |
| 1353 FKey *pFKey; /* Iterator variable */ | |
| 1354 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ | |
| 1355 if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){ | |
| 1356 Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges); | |
| 1357 if( pAct ){ | |
| 1358 sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0); | |
| 1359 } | |
| 1360 } | |
| 1361 } | |
| 1362 } | |
| 1363 } | |
| 1364 | |
| 1365 #endif /* ifndef SQLITE_OMIT_TRIGGER */ | |
| 1366 | |
| 1367 /* | |
| 1368 ** Free all memory associated with foreign key definitions attached to | |
| 1369 ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash | |
| 1370 ** hash table. | |
| 1371 */ | |
| 1372 void sqlite3FkDelete(sqlite3 *db, Table *pTab){ | |
| 1373 FKey *pFKey; /* Iterator variable */ | |
| 1374 FKey *pNext; /* Copy of pFKey->pNextFrom */ | |
| 1375 | |
| 1376 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); | |
| 1377 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){ | |
| 1378 | |
| 1379 /* Remove the FK from the fkeyHash hash table. */ | |
| 1380 if( !db || db->pnBytesFreed==0 ){ | |
| 1381 if( pFKey->pPrevTo ){ | |
| 1382 pFKey->pPrevTo->pNextTo = pFKey->pNextTo; | |
| 1383 }else{ | |
| 1384 void *p = (void *)pFKey->pNextTo; | |
| 1385 const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo); | |
| 1386 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p); | |
| 1387 } | |
| 1388 if( pFKey->pNextTo ){ | |
| 1389 pFKey->pNextTo->pPrevTo = pFKey->pPrevTo; | |
| 1390 } | |
| 1391 } | |
| 1392 | |
| 1393 /* EV: R-30323-21917 Each foreign key constraint in SQLite is | |
| 1394 ** classified as either immediate or deferred. | |
| 1395 */ | |
| 1396 assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 ); | |
| 1397 | |
| 1398 /* Delete any triggers created to implement actions for this FK. */ | |
| 1399 #ifndef SQLITE_OMIT_TRIGGER | |
| 1400 fkTriggerDelete(db, pFKey->apTrigger[0]); | |
| 1401 fkTriggerDelete(db, pFKey->apTrigger[1]); | |
| 1402 #endif | |
| 1403 | |
| 1404 pNext = pFKey->pNextFrom; | |
| 1405 sqlite3DbFree(db, pFKey); | |
| 1406 } | |
| 1407 } | |
| 1408 #endif /* ifndef SQLITE_OMIT_FOREIGN_KEY */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
