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].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 number |
232 | ** of columns. If each indexed column corresponds to a foreign key |
233 | ** 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 to |
248 | ** map to an explicit list of columns in table pParent. Check if this |
249 | ** index matches those columns. Also, check that the index uses |
250 | ** 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 from |
260 | ** the default collation sequence for the column, this index is |
261 | ** 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 row |
298 | ** affected - once to "delete" the old row, and then again to "insert" the |
299 | ** new row. |
300 | ** |
301 | ** Each time it is called, this function generates VDBE code to locate the |
302 | ** 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* be |
305 | ** found in the parent table: |
306 | ** |
307 | ** Operation | FK type | Action taken |
308 | ** -------------------------------------------------------------------------- |
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 | */ |
320 | static 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->isDeferred |
338 | && !(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 any |
343 | ** outstanding constraints to resolve. If there are not, there is no need |
344 | ** 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 KEY |
361 | ** 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 there |
367 | ** is no matching parent key. Before using MustBeInt, make a copy of |
368 | ** the value. Otherwise, the value inserted into the child key column |
369 | ** 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 about |
376 | ** 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 not |
378 | ** 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 about |
403 | ** 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 not |
405 | ** 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 any |
409 | ** of the parent-key values are NULL (at this point it is known that |
410 | ** 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 exactly |
445 | ** one row into the table, raise a constraint immediately instead of |
446 | ** incrementing a counter. This is necessary as the VM code is being |
447 | ** 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 corresponding |
465 | ** to column iCol of table pTab. |
466 | ** |
467 | ** regBase is the first of an array of register that contains the data |
468 | ** for pTab. regBase itself holds the rowid. regBase+1 holds the first |
469 | ** column. regBase+2 holds the second column, and so forth. |
470 | */ |
471 | static 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 which |
501 | ** has cursor iCur. |
502 | */ |
503 | static 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 deleted |
521 | ** 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 generating |
523 | ** 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 decrease |
527 | ** the number of FK violations in the db) or +1 when deleting one (as this |
528 | ** may increase the number of FK constraint problems). |
529 | ** |
530 | ** The code generated by this function scans through the rows in the child |
531 | ** 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 taken |
535 | ** -------------------------------------------------------------------------- |
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 | */ |
547 | static 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 of |
580 | ** the parent key columns. The affinity of the parent key column should |
581 | ** 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 terms |
601 | ** to the WHERE clause that prevent this entry from being scanned. |
602 | ** The added WHERE clause terms are like this: |
603 | ** |
604 | ** $current_rowid!=rowid |
605 | ** NOT( $current_a==a AND $current_b==b AND ... ) |
606 | ** |
607 | ** The first form is used for rowid tables. The second form is used |
608 | ** for WITHOUT ROWID tables. In the second form, the *parent* key is |
609 | ** (a,b,...). Either the parent or primary key could be used to |
610 | ** uniquely identify the current row, but the parent key is more convenient |
611 | ** as the required values have already been loaded into registers |
612 | ** 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 WHERE |
645 | ** clause. For each row found, increment either the deferred or immediate |
646 | ** 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 by |
664 | ** 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 pointer |
671 | ** to the FKey structure representing the foreign key constraint on table |
672 | ** "t2". Calling this function with "t2" as the argument would return a |
673 | ** NULL pointer (as there are no FK constraints for which t2 is the parent |
674 | ** table). |
675 | */ |
676 | FKey *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 structure |
683 | ** and all of its sub-components. |
684 | ** |
685 | ** The Trigger structure or any of its sub-components may be allocated from |
686 | ** the lookaside buffer belonging to database handle dbMem. |
687 | */ |
688 | static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ |
689 | if( p ){ |
690 | TriggerStep *pStep = p->step_list; |
691 | sqlite3ExprDelete(dbMem, pStep->pWhere); |
692 | sqlite3ExprListDelete(dbMem, pStep->pExprList); |
693 | sqlite3SelectDelete(dbMem, pStep->pSelect); |
694 | sqlite3ExprDelete(dbMem, p->pWhen); |
695 | sqlite3DbFree(dbMem, p); |
696 | } |
697 | } |
698 | |
699 | /* |
700 | ** Clear the apTrigger[] cache of CASCADE triggers for all foreign keys |
701 | ** in a particular database. This needs to happen when the schema |
702 | ** changes. |
703 | */ |
704 | void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){ |
705 | HashElem *k; |
706 | Hash *pHash = &db->aDb[iDb].pSchema->tblHash; |
707 | for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k)){ |
708 | Table *pTab = sqliteHashData(k); |
709 | FKey *pFKey; |
710 | if( !IsOrdinaryTable(pTab) ) continue; |
711 | for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ |
712 | fkTriggerDelete(db, pFKey->apTrigger[0]); pFKey->apTrigger[0] = 0; |
713 | fkTriggerDelete(db, pFKey->apTrigger[1]); pFKey->apTrigger[1] = 0; |
714 | } |
715 | } |
716 | } |
717 | |
718 | /* |
719 | ** This function is called to generate code that runs when table pTab is |
720 | ** being dropped from the database. The SrcList passed as the second argument |
721 | ** to this function contains a single entry guaranteed to resolve to |
722 | ** table pTab. |
723 | ** |
724 | ** Normally, no code is required. However, if either |
725 | ** |
726 | ** (a) The table is the parent table of a FK constraint, or |
727 | ** (b) The table is the child table of a deferred FK constraint and it is |
728 | ** determined at runtime that there are outstanding deferred FK |
729 | ** constraint violations in the database, |
730 | ** |
731 | ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping |
732 | ** the table from the database. Triggers are disabled while running this |
733 | ** DELETE, but foreign key actions are not. |
734 | */ |
735 | void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){ |
736 | sqlite3 *db = pParse->db; |
737 | if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){ |
738 | int iSkip = 0; |
739 | Vdbe *v = sqlite3GetVdbe(pParse); |
740 | |
741 | assert( v ); /* VDBE has already been allocated */ |
742 | assert( IsOrdinaryTable(pTab) ); |
743 | if( sqlite3FkReferences(pTab)==0 ){ |
744 | /* Search for a deferred foreign key constraint for which this table |
745 | ** is the child table. If one cannot be found, return without |
746 | ** generating any VDBE code. If one can be found, then jump over |
747 | ** the entire DELETE if there are no outstanding deferred constraints |
748 | ** when this statement is run. */ |
749 | FKey *p; |
750 | for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ |
751 | if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break; |
752 | } |
753 | if( !p ) return; |
754 | iSkip = sqlite3VdbeMakeLabel(pParse); |
755 | sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v); |
756 | } |
757 | |
758 | pParse->disableTriggers = 1; |
759 | sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0, 0, 0); |
760 | pParse->disableTriggers = 0; |
761 | |
762 | /* If the DELETE has generated immediate foreign key constraint |
763 | ** violations, halt the VDBE and return an error at this point, before |
764 | ** any modifications to the schema are made. This is because statement |
765 | ** transactions are not able to rollback schema changes. |
766 | ** |
767 | ** If the SQLITE_DeferFKs flag is set, then this is not required, as |
768 | ** the statement transaction will not be rolled back even if FK |
769 | ** constraints are violated. |
770 | */ |
771 | if( (db->flags & SQLITE_DeferFKs)==0 ){ |
772 | sqlite3VdbeVerifyAbortable(v, OE_Abort); |
773 | sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2); |
774 | VdbeCoverage(v); |
775 | sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, |
776 | OE_Abort, 0, P4_STATIC, P5_ConstraintFK); |
777 | } |
778 | |
779 | if( iSkip ){ |
780 | sqlite3VdbeResolveLabel(v, iSkip); |
781 | } |
782 | } |
783 | } |
784 | |
785 | |
786 | /* |
787 | ** The second argument points to an FKey object representing a foreign key |
788 | ** for which pTab is the child table. An UPDATE statement against pTab |
789 | ** is currently being processed. For each column of the table that is |
790 | ** actually updated, the corresponding element in the aChange[] array |
791 | ** is zero or greater (if a column is unmodified the corresponding element |
792 | ** is set to -1). If the rowid column is modified by the UPDATE statement |
793 | ** the bChngRowid argument is non-zero. |
794 | ** |
795 | ** This function returns true if any of the columns that are part of the |
796 | ** child key for FK constraint *p are modified. |
797 | */ |
798 | static int fkChildIsModified( |
799 | Table *pTab, /* Table being updated */ |
800 | FKey *p, /* Foreign key for which pTab is the child */ |
801 | int *aChange, /* Array indicating modified columns */ |
802 | int bChngRowid /* True if rowid is modified by this update */ |
803 | ){ |
804 | int i; |
805 | for(i=0; i<p->nCol; i++){ |
806 | int iChildKey = p->aCol[i].iFrom; |
807 | if( aChange[iChildKey]>=0 ) return 1; |
808 | if( iChildKey==pTab->iPKey && bChngRowid ) return 1; |
809 | } |
810 | return 0; |
811 | } |
812 | |
813 | /* |
814 | ** The second argument points to an FKey object representing a foreign key |
815 | ** for which pTab is the parent table. An UPDATE statement against pTab |
816 | ** is currently being processed. For each column of the table that is |
817 | ** actually updated, the corresponding element in the aChange[] array |
818 | ** is zero or greater (if a column is unmodified the corresponding element |
819 | ** is set to -1). If the rowid column is modified by the UPDATE statement |
820 | ** the bChngRowid argument is non-zero. |
821 | ** |
822 | ** This function returns true if any of the columns that are part of the |
823 | ** parent key for FK constraint *p are modified. |
824 | */ |
825 | static int fkParentIsModified( |
826 | Table *pTab, |
827 | FKey *p, |
828 | int *aChange, |
829 | int bChngRowid |
830 | ){ |
831 | int i; |
832 | for(i=0; i<p->nCol; i++){ |
833 | char *zKey = p->aCol[i].zCol; |
834 | int iKey; |
835 | for(iKey=0; iKey<pTab->nCol; iKey++){ |
836 | if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){ |
837 | Column *pCol = &pTab->aCol[iKey]; |
838 | if( zKey ){ |
839 | if( 0==sqlite3StrICmp(pCol->zCnName, zKey) ) return 1; |
840 | }else if( pCol->colFlags & COLFLAG_PRIMKEY ){ |
841 | return 1; |
842 | } |
843 | } |
844 | } |
845 | } |
846 | return 0; |
847 | } |
848 | |
849 | /* |
850 | ** Return true if the parser passed as the first argument is being |
851 | ** used to code a trigger that is really a "SET NULL" action belonging |
852 | ** to trigger pFKey. |
853 | */ |
854 | static int isSetNullAction(Parse *pParse, FKey *pFKey){ |
855 | Parse *pTop = sqlite3ParseToplevel(pParse); |
856 | if( pTop->pTriggerPrg ){ |
857 | Trigger *p = pTop->pTriggerPrg->pTrigger; |
858 | if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull) |
859 | || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull) |
860 | ){ |
861 | return 1; |
862 | } |
863 | } |
864 | return 0; |
865 | } |
866 | |
867 | /* |
868 | ** This function is called when inserting, deleting or updating a row of |
869 | ** table pTab to generate VDBE code to perform foreign key constraint |
870 | ** processing for the operation. |
871 | ** |
872 | ** For a DELETE operation, parameter regOld is passed the index of the |
873 | ** first register in an array of (pTab->nCol+1) registers containing the |
874 | ** rowid of the row being deleted, followed by each of the column values |
875 | ** of the row being deleted, from left to right. Parameter regNew is passed |
876 | ** zero in this case. |
877 | ** |
878 | ** For an INSERT operation, regOld is passed zero and regNew is passed the |
879 | ** first register of an array of (pTab->nCol+1) registers containing the new |
880 | ** row data. |
881 | ** |
882 | ** For an UPDATE operation, this function is called twice. Once before |
883 | ** the original record is deleted from the table using the calling convention |
884 | ** described for DELETE. Then again after the original record is deleted |
885 | ** but before the new record is inserted using the INSERT convention. |
886 | */ |
887 | void sqlite3FkCheck( |
888 | Parse *pParse, /* Parse context */ |
889 | Table *pTab, /* Row is being deleted from this table */ |
890 | int regOld, /* Previous row data is stored here */ |
891 | int regNew, /* New row data is stored here */ |
892 | int *aChange, /* Array indicating UPDATEd columns (or 0) */ |
893 | int bChngRowid /* True if rowid is UPDATEd */ |
894 | ){ |
895 | sqlite3 *db = pParse->db; /* Database handle */ |
896 | FKey *pFKey; /* Used to iterate through FKs */ |
897 | int iDb; /* Index of database containing pTab */ |
898 | const char *zDb; /* Name of database containing pTab */ |
899 | int isIgnoreErrors = pParse->disableTriggers; |
900 | |
901 | /* Exactly one of regOld and regNew should be non-zero. */ |
902 | assert( (regOld==0)!=(regNew==0) ); |
903 | |
904 | /* If foreign-keys are disabled, this function is a no-op. */ |
905 | if( (db->flags&SQLITE_ForeignKeys)==0 ) return; |
906 | if( !IsOrdinaryTable(pTab) ) return; |
907 | |
908 | iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
909 | zDb = db->aDb[iDb].zDbSName; |
910 | |
911 | /* Loop through all the foreign key constraints for which pTab is the |
912 | ** child table (the table that the foreign key definition is part of). */ |
913 | for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ |
914 | Table *pTo; /* Parent table of foreign key pFKey */ |
915 | Index *pIdx = 0; /* Index on key columns in pTo */ |
916 | int *aiFree = 0; |
917 | int *aiCol; |
918 | int iCol; |
919 | int i; |
920 | int bIgnore = 0; |
921 | |
922 | if( aChange |
923 | && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0 |
924 | && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0 |
925 | ){ |
926 | continue; |
927 | } |
928 | |
929 | /* Find the parent table of this foreign key. Also find a unique index |
930 | ** on the parent key columns in the parent table. If either of these |
931 | ** schema items cannot be located, set an error in pParse and return |
932 | ** early. */ |
933 | if( pParse->disableTriggers ){ |
934 | pTo = sqlite3FindTable(db, pFKey->zTo, zDb); |
935 | }else{ |
936 | pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb); |
937 | } |
938 | if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){ |
939 | assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) ); |
940 | if( !isIgnoreErrors || db->mallocFailed ) return; |
941 | if( pTo==0 ){ |
942 | /* If isIgnoreErrors is true, then a table is being dropped. In this |
943 | ** case SQLite runs a "DELETE FROM xxx" on the table being dropped |
944 | ** before actually dropping it in order to check FK constraints. |
945 | ** If the parent table of an FK constraint on the current table is |
946 | ** missing, behave as if it is empty. i.e. decrement the relevant |
947 | ** FK counter for each row of the current table with non-NULL keys. |
948 | */ |
949 | Vdbe *v = sqlite3GetVdbe(pParse); |
950 | int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1; |
951 | for(i=0; i<pFKey->nCol; i++){ |
952 | int iFromCol, iReg; |
953 | iFromCol = pFKey->aCol[i].iFrom; |
954 | iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1; |
955 | sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v); |
956 | } |
957 | sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1); |
958 | } |
959 | continue; |
960 | } |
961 | assert( pFKey->nCol==1 || (aiFree && pIdx) ); |
962 | |
963 | if( aiFree ){ |
964 | aiCol = aiFree; |
965 | }else{ |
966 | iCol = pFKey->aCol[0].iFrom; |
967 | aiCol = &iCol; |
968 | } |
969 | for(i=0; i<pFKey->nCol; i++){ |
970 | if( aiCol[i]==pTab->iPKey ){ |
971 | aiCol[i] = -1; |
972 | } |
973 | assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); |
974 | #ifndef SQLITE_OMIT_AUTHORIZATION |
975 | /* Request permission to read the parent key columns. If the |
976 | ** authorization callback returns SQLITE_IGNORE, behave as if any |
977 | ** values read from the parent table are NULL. */ |
978 | if( db->xAuth ){ |
979 | int rcauth; |
980 | char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName; |
981 | rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb); |
982 | bIgnore = (rcauth==SQLITE_IGNORE); |
983 | } |
984 | #endif |
985 | } |
986 | |
987 | /* Take a shared-cache advisory read-lock on the parent table. Allocate |
988 | ** a cursor to use to search the unique index on the parent key columns |
989 | ** in the parent table. */ |
990 | sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName); |
991 | pParse->nTab++; |
992 | |
993 | if( regOld!=0 ){ |
994 | /* A row is being removed from the child table. Search for the parent. |
995 | ** If the parent does not exist, removing the child row resolves an |
996 | ** outstanding foreign key constraint violation. */ |
997 | fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore); |
998 | } |
999 | if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){ |
1000 | /* A row is being added to the child table. If a parent row cannot |
1001 | ** be found, adding the child row has violated the FK constraint. |
1002 | ** |
1003 | ** If this operation is being performed as part of a trigger program |
1004 | ** that is actually a "SET NULL" action belonging to this very |
1005 | ** foreign key, then omit this scan altogether. As all child key |
1006 | ** values are guaranteed to be NULL, it is not possible for adding |
1007 | ** this row to cause an FK violation. */ |
1008 | fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore); |
1009 | } |
1010 | |
1011 | sqlite3DbFree(db, aiFree); |
1012 | } |
1013 | |
1014 | /* Loop through all the foreign key constraints that refer to this table. |
1015 | ** (the "child" constraints) */ |
1016 | for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ |
1017 | Index *pIdx = 0; /* Foreign key index for pFKey */ |
1018 | SrcList *pSrc; |
1019 | int *aiCol = 0; |
1020 | |
1021 | if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){ |
1022 | continue; |
1023 | } |
1024 | |
1025 | if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs) |
1026 | && !pParse->pToplevel && !pParse->isMultiWrite |
1027 | ){ |
1028 | assert( regOld==0 && regNew!=0 ); |
1029 | /* Inserting a single row into a parent table cannot cause (or fix) |
1030 | ** an immediate foreign key violation. So do nothing in this case. */ |
1031 | continue; |
1032 | } |
1033 | |
1034 | if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){ |
1035 | if( !isIgnoreErrors || db->mallocFailed ) return; |
1036 | continue; |
1037 | } |
1038 | assert( aiCol || pFKey->nCol==1 ); |
1039 | |
1040 | /* Create a SrcList structure containing the child table. We need the |
1041 | ** child table as a SrcList for sqlite3WhereBegin() */ |
1042 | pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); |
1043 | if( pSrc ){ |
1044 | SrcItem *pItem = pSrc->a; |
1045 | pItem->pTab = pFKey->pFrom; |
1046 | pItem->zName = pFKey->pFrom->zName; |
1047 | pItem->pTab->nTabRef++; |
1048 | pItem->iCursor = pParse->nTab++; |
1049 | |
1050 | if( regNew!=0 ){ |
1051 | fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1); |
1052 | } |
1053 | if( regOld!=0 ){ |
1054 | int eAction = pFKey->aAction[aChange!=0]; |
1055 | fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1); |
1056 | /* If this is a deferred FK constraint, or a CASCADE or SET NULL |
1057 | ** action applies, then any foreign key violations caused by |
1058 | ** removing the parent key will be rectified by the action trigger. |
1059 | ** So do not set the "may-abort" flag in this case. |
1060 | ** |
1061 | ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the |
1062 | ** may-abort flag will eventually be set on this statement anyway |
1063 | ** (when this function is called as part of processing the UPDATE |
1064 | ** within the action trigger). |
1065 | ** |
1066 | ** Note 2: At first glance it may seem like SQLite could simply omit |
1067 | ** all OP_FkCounter related scans when either CASCADE or SET NULL |
1068 | ** applies. The trouble starts if the CASCADE or SET NULL action |
1069 | ** trigger causes other triggers or action rules attached to the |
1070 | ** child table to fire. In these cases the fk constraint counters |
1071 | ** might be set incorrectly if any OP_FkCounter related scans are |
1072 | ** omitted. */ |
1073 | if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){ |
1074 | sqlite3MayAbort(pParse); |
1075 | } |
1076 | } |
1077 | pItem->zName = 0; |
1078 | sqlite3SrcListDelete(db, pSrc); |
1079 | } |
1080 | sqlite3DbFree(db, aiCol); |
1081 | } |
1082 | } |
1083 | |
1084 | #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x))) |
1085 | |
1086 | /* |
1087 | ** This function is called before generating code to update or delete a |
1088 | ** row contained in table pTab. |
1089 | */ |
1090 | u32 sqlite3FkOldmask( |
1091 | Parse *pParse, /* Parse context */ |
1092 | Table *pTab /* Table being modified */ |
1093 | ){ |
1094 | u32 mask = 0; |
1095 | if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){ |
1096 | FKey *p; |
1097 | int i; |
1098 | for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ |
1099 | for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom); |
1100 | } |
1101 | for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ |
1102 | Index *pIdx = 0; |
1103 | sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0); |
1104 | if( pIdx ){ |
1105 | for(i=0; i<pIdx->nKeyCol; i++){ |
1106 | assert( pIdx->aiColumn[i]>=0 ); |
1107 | mask |= COLUMN_MASK(pIdx->aiColumn[i]); |
1108 | } |
1109 | } |
1110 | } |
1111 | } |
1112 | return mask; |
1113 | } |
1114 | |
1115 | |
1116 | /* |
1117 | ** This function is called before generating code to update or delete a |
1118 | ** row contained in table pTab. If the operation is a DELETE, then |
1119 | ** parameter aChange is passed a NULL value. For an UPDATE, aChange points |
1120 | ** to an array of size N, where N is the number of columns in table pTab. |
1121 | ** If the i'th column is not modified by the UPDATE, then the corresponding |
1122 | ** entry in the aChange[] array is set to -1. If the column is modified, |
1123 | ** the value is 0 or greater. Parameter chngRowid is set to true if the |
1124 | ** UPDATE statement modifies the rowid fields of the table. |
1125 | ** |
1126 | ** If any foreign key processing will be required, this function returns |
1127 | ** non-zero. If there is no foreign key related processing, this function |
1128 | ** returns zero. |
1129 | ** |
1130 | ** For an UPDATE, this function returns 2 if: |
1131 | ** |
1132 | ** * There are any FKs for which pTab is the child and the parent table |
1133 | ** and any FK processing at all is required (even of a different FK), or |
1134 | ** |
1135 | ** * the UPDATE modifies one or more parent keys for which the action is |
1136 | ** not "NO ACTION" (i.e. is CASCADE, SET DEFAULT or SET NULL). |
1137 | ** |
1138 | ** Or, assuming some other foreign key processing is required, 1. |
1139 | */ |
1140 | int sqlite3FkRequired( |
1141 | Parse *pParse, /* Parse context */ |
1142 | Table *pTab, /* Table being modified */ |
1143 | int *aChange, /* Non-NULL for UPDATE operations */ |
1144 | int chngRowid /* True for UPDATE that affects rowid */ |
1145 | ){ |
1146 | int eRet = 1; /* Value to return if bHaveFK is true */ |
1147 | int bHaveFK = 0; /* If FK processing is required */ |
1148 | if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){ |
1149 | if( !aChange ){ |
1150 | /* A DELETE operation. Foreign key processing is required if the |
1151 | ** table in question is either the child or parent table for any |
1152 | ** foreign key constraint. */ |
1153 | bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey); |
1154 | }else{ |
1155 | /* This is an UPDATE. Foreign key processing is only required if the |
1156 | ** operation modifies one or more child or parent key columns. */ |
1157 | FKey *p; |
1158 | |
1159 | /* Check if any child key columns are being modified. */ |
1160 | for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ |
1161 | if( fkChildIsModified(pTab, p, aChange, chngRowid) ){ |
1162 | if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2; |
1163 | bHaveFK = 1; |
1164 | } |
1165 | } |
1166 | |
1167 | /* Check if any parent key columns are being modified. */ |
1168 | for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ |
1169 | if( fkParentIsModified(pTab, p, aChange, chngRowid) ){ |
1170 | if( p->aAction[1]!=OE_None ) return 2; |
1171 | bHaveFK = 1; |
1172 | } |
1173 | } |
1174 | } |
1175 | } |
1176 | return bHaveFK ? eRet : 0; |
1177 | } |
1178 | |
1179 | /* |
1180 | ** This function is called when an UPDATE or DELETE operation is being |
1181 | ** compiled on table pTab, which is the parent table of foreign-key pFKey. |
1182 | ** If the current operation is an UPDATE, then the pChanges parameter is |
1183 | ** passed a pointer to the list of columns being modified. If it is a |
1184 | ** DELETE, pChanges is passed a NULL pointer. |
1185 | ** |
1186 | ** It returns a pointer to a Trigger structure containing a trigger |
1187 | ** equivalent to the ON UPDATE or ON DELETE action specified by pFKey. |
1188 | ** If the action is "NO ACTION" then a NULL pointer is returned (these actions |
1189 | ** require no special handling by the triggers sub-system, code for them is |
1190 | ** created by fkScanChildren()). |
1191 | ** |
1192 | ** For example, if pFKey is the foreign key and pTab is table "p" in |
1193 | ** the following schema: |
1194 | ** |
1195 | ** CREATE TABLE p(pk PRIMARY KEY); |
1196 | ** CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE); |
1197 | ** |
1198 | ** then the returned trigger structure is equivalent to: |
1199 | ** |
1200 | ** CREATE TRIGGER ... DELETE ON p BEGIN |
1201 | ** DELETE FROM c WHERE ck = old.pk; |
1202 | ** END; |
1203 | ** |
1204 | ** The returned pointer is cached as part of the foreign key object. It |
1205 | ** is eventually freed along with the rest of the foreign key object by |
1206 | ** sqlite3FkDelete(). |
1207 | */ |
1208 | static Trigger *fkActionTrigger( |
1209 | Parse *pParse, /* Parse context */ |
1210 | Table *pTab, /* Table being updated or deleted from */ |
1211 | FKey *pFKey, /* Foreign key to get action for */ |
1212 | ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */ |
1213 | ){ |
1214 | sqlite3 *db = pParse->db; /* Database handle */ |
1215 | int action; /* One of OE_None, OE_Cascade etc. */ |
1216 | Trigger *pTrigger; /* Trigger definition to return */ |
1217 | int iAction = (pChanges!=0); /* 1 for UPDATE, 0 for DELETE */ |
1218 | |
1219 | action = pFKey->aAction[iAction]; |
1220 | if( action==OE_Restrict && (db->flags & SQLITE_DeferFKs) ){ |
1221 | return 0; |
1222 | } |
1223 | pTrigger = pFKey->apTrigger[iAction]; |
1224 | |
1225 | if( action!=OE_None && !pTrigger ){ |
1226 | char const *zFrom; /* Name of child table */ |
1227 | int nFrom; /* Length in bytes of zFrom */ |
1228 | Index *pIdx = 0; /* Parent key index for this FK */ |
1229 | int *aiCol = 0; /* child table cols -> parent key cols */ |
1230 | TriggerStep *pStep = 0; /* First (only) step of trigger program */ |
1231 | Expr *pWhere = 0; /* WHERE clause of trigger step */ |
1232 | ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */ |
1233 | Select *pSelect = 0; /* If RESTRICT, "SELECT RAISE(...)" */ |
1234 | int i; /* Iterator variable */ |
1235 | Expr *pWhen = 0; /* WHEN clause for the trigger */ |
1236 | |
1237 | if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0; |
1238 | assert( aiCol || pFKey->nCol==1 ); |
1239 | |
1240 | for(i=0; i<pFKey->nCol; i++){ |
1241 | Token tOld = { "old" , 3 }; /* Literal "old" token */ |
1242 | Token tNew = { "new" , 3 }; /* Literal "new" token */ |
1243 | Token tFromCol; /* Name of column in child table */ |
1244 | Token tToCol; /* Name of column in parent table */ |
1245 | int iFromCol; /* Idx of column in child table */ |
1246 | Expr *pEq; /* tFromCol = OLD.tToCol */ |
1247 | |
1248 | iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; |
1249 | assert( iFromCol>=0 ); |
1250 | assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) ); |
1251 | assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); |
1252 | sqlite3TokenInit(&tToCol, |
1253 | pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName); |
1254 | sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zCnName); |
1255 | |
1256 | /* Create the expression "OLD.zToCol = zFromCol". It is important |
1257 | ** that the "OLD.zToCol" term is on the LHS of the = operator, so |
1258 | ** that the affinity and collation sequence associated with the |
1259 | ** parent table are used for the comparison. */ |
1260 | pEq = sqlite3PExpr(pParse, TK_EQ, |
1261 | sqlite3PExpr(pParse, TK_DOT, |
1262 | sqlite3ExprAlloc(db, TK_ID, &tOld, 0), |
1263 | sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)), |
1264 | sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0) |
1265 | ); |
1266 | pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); |
1267 | |
1268 | /* For ON UPDATE, construct the next term of the WHEN clause. |
1269 | ** The final WHEN clause will be like this: |
1270 | ** |
1271 | ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN) |
1272 | */ |
1273 | if( pChanges ){ |
1274 | pEq = sqlite3PExpr(pParse, TK_IS, |
1275 | sqlite3PExpr(pParse, TK_DOT, |
1276 | sqlite3ExprAlloc(db, TK_ID, &tOld, 0), |
1277 | sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)), |
1278 | sqlite3PExpr(pParse, TK_DOT, |
1279 | sqlite3ExprAlloc(db, TK_ID, &tNew, 0), |
1280 | sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)) |
1281 | ); |
1282 | pWhen = sqlite3ExprAnd(pParse, pWhen, pEq); |
1283 | } |
1284 | |
1285 | if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){ |
1286 | Expr *pNew; |
1287 | if( action==OE_Cascade ){ |
1288 | pNew = sqlite3PExpr(pParse, TK_DOT, |
1289 | sqlite3ExprAlloc(db, TK_ID, &tNew, 0), |
1290 | sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)); |
1291 | }else if( action==OE_SetDflt ){ |
1292 | Column *pCol = pFKey->pFrom->aCol + iFromCol; |
1293 | Expr *pDflt; |
1294 | if( pCol->colFlags & COLFLAG_GENERATED ){ |
1295 | testcase( pCol->colFlags & COLFLAG_VIRTUAL ); |
1296 | testcase( pCol->colFlags & COLFLAG_STORED ); |
1297 | pDflt = 0; |
1298 | }else{ |
1299 | pDflt = sqlite3ColumnExpr(pFKey->pFrom, pCol); |
1300 | } |
1301 | if( pDflt ){ |
1302 | pNew = sqlite3ExprDup(db, pDflt, 0); |
1303 | }else{ |
1304 | pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0); |
1305 | } |
1306 | }else{ |
1307 | pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0); |
1308 | } |
1309 | pList = sqlite3ExprListAppend(pParse, pList, pNew); |
1310 | sqlite3ExprListSetName(pParse, pList, &tFromCol, 0); |
1311 | } |
1312 | } |
1313 | sqlite3DbFree(db, aiCol); |
1314 | |
1315 | zFrom = pFKey->pFrom->zName; |
1316 | nFrom = sqlite3Strlen30(zFrom); |
1317 | |
1318 | if( action==OE_Restrict ){ |
1319 | int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
1320 | Token tFrom; |
1321 | Token tDb; |
1322 | Expr *pRaise; |
1323 | |
1324 | tFrom.z = zFrom; |
1325 | tFrom.n = nFrom; |
1326 | tDb.z = db->aDb[iDb].zDbSName; |
1327 | tDb.n = sqlite3Strlen30(tDb.z); |
1328 | |
1329 | pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed" ); |
1330 | if( pRaise ){ |
1331 | pRaise->affExpr = OE_Abort; |
1332 | } |
1333 | pSelect = sqlite3SelectNew(pParse, |
1334 | sqlite3ExprListAppend(pParse, 0, pRaise), |
1335 | sqlite3SrcListAppend(pParse, 0, &tDb, &tFrom), |
1336 | pWhere, |
1337 | 0, 0, 0, 0, 0 |
1338 | ); |
1339 | pWhere = 0; |
1340 | } |
1341 | |
1342 | /* Disable lookaside memory allocation */ |
1343 | DisableLookaside; |
1344 | |
1345 | pTrigger = (Trigger *)sqlite3DbMallocZero(db, |
1346 | sizeof(Trigger) + /* struct Trigger */ |
1347 | sizeof(TriggerStep) + /* Single step in trigger program */ |
1348 | nFrom + 1 /* Space for pStep->zTarget */ |
1349 | ); |
1350 | if( pTrigger ){ |
1351 | pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1]; |
1352 | pStep->zTarget = (char *)&pStep[1]; |
1353 | memcpy((char *)pStep->zTarget, zFrom, nFrom); |
1354 | |
1355 | pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); |
1356 | pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); |
1357 | pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); |
1358 | if( pWhen ){ |
1359 | pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0); |
1360 | pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); |
1361 | } |
1362 | } |
1363 | |
1364 | /* Re-enable the lookaside buffer, if it was disabled earlier. */ |
1365 | EnableLookaside; |
1366 | |
1367 | sqlite3ExprDelete(db, pWhere); |
1368 | sqlite3ExprDelete(db, pWhen); |
1369 | sqlite3ExprListDelete(db, pList); |
1370 | sqlite3SelectDelete(db, pSelect); |
1371 | if( db->mallocFailed==1 ){ |
1372 | fkTriggerDelete(db, pTrigger); |
1373 | return 0; |
1374 | } |
1375 | assert( pStep!=0 ); |
1376 | assert( pTrigger!=0 ); |
1377 | |
1378 | switch( action ){ |
1379 | case OE_Restrict: |
1380 | pStep->op = TK_SELECT; |
1381 | break; |
1382 | case OE_Cascade: |
1383 | if( !pChanges ){ |
1384 | pStep->op = TK_DELETE; |
1385 | break; |
1386 | } |
1387 | /* no break */ deliberate_fall_through |
1388 | default: |
1389 | pStep->op = TK_UPDATE; |
1390 | } |
1391 | pStep->pTrig = pTrigger; |
1392 | pTrigger->pSchema = pTab->pSchema; |
1393 | pTrigger->pTabSchema = pTab->pSchema; |
1394 | pFKey->apTrigger[iAction] = pTrigger; |
1395 | pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE); |
1396 | } |
1397 | |
1398 | return pTrigger; |
1399 | } |
1400 | |
1401 | /* |
1402 | ** This function is called when deleting or updating a row to implement |
1403 | ** any required CASCADE, SET NULL or SET DEFAULT actions. |
1404 | */ |
1405 | void sqlite3FkActions( |
1406 | Parse *pParse, /* Parse context */ |
1407 | Table *pTab, /* Table being updated or deleted from */ |
1408 | ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */ |
1409 | int regOld, /* Address of array containing old row */ |
1410 | int *aChange, /* Array indicating UPDATEd columns (or 0) */ |
1411 | int bChngRowid /* True if rowid is UPDATEd */ |
1412 | ){ |
1413 | /* If foreign-key support is enabled, iterate through all FKs that |
1414 | ** refer to table pTab. If there is an action associated with the FK |
1415 | ** for this operation (either update or delete), invoke the associated |
1416 | ** trigger sub-program. */ |
1417 | if( pParse->db->flags&SQLITE_ForeignKeys ){ |
1418 | FKey *pFKey; /* Iterator variable */ |
1419 | for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ |
1420 | if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){ |
1421 | Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges); |
1422 | if( pAct ){ |
1423 | sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0); |
1424 | } |
1425 | } |
1426 | } |
1427 | } |
1428 | } |
1429 | |
1430 | #endif /* ifndef SQLITE_OMIT_TRIGGER */ |
1431 | |
1432 | /* |
1433 | ** Free all memory associated with foreign key definitions attached to |
1434 | ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash |
1435 | ** hash table. |
1436 | */ |
1437 | void sqlite3FkDelete(sqlite3 *db, Table *pTab){ |
1438 | FKey *pFKey; /* Iterator variable */ |
1439 | FKey *pNext; /* Copy of pFKey->pNextFrom */ |
1440 | |
1441 | assert( IsOrdinaryTable(pTab) ); |
1442 | assert( db!=0 ); |
1443 | for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){ |
1444 | assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); |
1445 | |
1446 | /* Remove the FK from the fkeyHash hash table. */ |
1447 | if( db->pnBytesFreed==0 ){ |
1448 | if( pFKey->pPrevTo ){ |
1449 | pFKey->pPrevTo->pNextTo = pFKey->pNextTo; |
1450 | }else{ |
1451 | void *p = (void *)pFKey->pNextTo; |
1452 | const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo); |
1453 | sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p); |
1454 | } |
1455 | if( pFKey->pNextTo ){ |
1456 | pFKey->pNextTo->pPrevTo = pFKey->pPrevTo; |
1457 | } |
1458 | } |
1459 | |
1460 | /* EV: R-30323-21917 Each foreign key constraint in SQLite is |
1461 | ** classified as either immediate or deferred. |
1462 | */ |
1463 | assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 ); |
1464 | |
1465 | /* Delete any triggers created to implement actions for this FK. */ |
1466 | #ifndef SQLITE_OMIT_TRIGGER |
1467 | fkTriggerDelete(db, pFKey->apTrigger[0]); |
1468 | fkTriggerDelete(db, pFKey->apTrigger[1]); |
1469 | #endif |
1470 | |
1471 | pNext = pFKey->pNextFrom; |
1472 | sqlite3DbFree(db, pFKey); |
1473 | } |
1474 | } |
1475 | #endif /* ifndef SQLITE_OMIT_FOREIGN_KEY */ |
1476 | |