• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code.  In place of
5 ** a legal notice, here is a blessing:
6 **
7 **    May you do good and not evil.
8 **    May you find forgiveness for yourself and forgive others.
9 **    May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains C code routines that are called by the parser
13 ** in order to generate code for DELETE FROM statements.
14 */
15 #include "sqliteInt.h"
16 
17 /*
18 ** While a SrcList can in general represent multiple tables and subqueries
19 ** (as in the FROM clause of a SELECT statement) in this case it contains
20 ** the name of a single table, as one might find in an INSERT, DELETE,
21 ** or UPDATE statement.  Look up that table in the symbol table and
22 ** return a pointer.  Set an error message and return NULL if the table
23 ** name is not found or if any other error occurs.
24 **
25 ** The following fields are initialized appropriate in pSrc:
26 **
27 **    pSrc->a[0].pTab       Pointer to the Table object
28 **    pSrc->a[0].pIndex     Pointer to the INDEXED BY index, if there is one
29 **
30 */
sqlite3SrcListLookup(Parse * pParse,SrcList * pSrc)31 Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
32   struct SrcList_item *pItem = pSrc->a;
33   Table *pTab;
34   assert( pItem && pSrc->nSrc==1 );
35   pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
36   sqlite3DeleteTable(pParse->db, pItem->pTab);
37   pItem->pTab = pTab;
38   if( pTab ){
39     pTab->nRef++;
40   }
41   if( sqlite3IndexedByLookup(pParse, pItem) ){
42     pTab = 0;
43   }
44   return pTab;
45 }
46 
47 /*
48 ** Check to make sure the given table is writable.  If it is not
49 ** writable, generate an error message and return 1.  If it is
50 ** writable return 0;
51 */
sqlite3IsReadOnly(Parse * pParse,Table * pTab,int viewOk)52 int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
53   /* A table is not writable under the following circumstances:
54   **
55   **   1) It is a virtual table and no implementation of the xUpdate method
56   **      has been provided, or
57   **   2) It is a system table (i.e. sqlite_master), this call is not
58   **      part of a nested parse and writable_schema pragma has not
59   **      been specified.
60   **
61   ** In either case leave an error message in pParse and return non-zero.
62   */
63   if( ( IsVirtual(pTab)
64      && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
65    || ( (pTab->tabFlags & TF_Readonly)!=0
66      && (pParse->db->flags & SQLITE_WriteSchema)==0
67      && pParse->nested==0 )
68   ){
69     sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
70     return 1;
71   }
72 
73 #ifndef SQLITE_OMIT_VIEW
74   if( !viewOk && pTab->pSelect ){
75     sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
76     return 1;
77   }
78 #endif
79   return 0;
80 }
81 
82 
83 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
84 /*
85 ** Evaluate a view and store its result in an ephemeral table.  The
86 ** pWhere argument is an optional WHERE clause that restricts the
87 ** set of rows in the view that are to be added to the ephemeral table.
88 */
sqlite3MaterializeView(Parse * pParse,Table * pView,Expr * pWhere,int iCur)89 void sqlite3MaterializeView(
90   Parse *pParse,       /* Parsing context */
91   Table *pView,        /* View definition */
92   Expr *pWhere,        /* Optional WHERE clause to be added */
93   int iCur             /* Cursor number for ephemerial table */
94 ){
95   SelectDest dest;
96   Select *pDup;
97   sqlite3 *db = pParse->db;
98 
99   pDup = sqlite3SelectDup(db, pView->pSelect, 0);
100   if( pWhere ){
101     SrcList *pFrom;
102 
103     pWhere = sqlite3ExprDup(db, pWhere, 0);
104     pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
105     if( pFrom ){
106       assert( pFrom->nSrc==1 );
107       pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName);
108       pFrom->a[0].pSelect = pDup;
109       assert( pFrom->a[0].pOn==0 );
110       assert( pFrom->a[0].pUsing==0 );
111     }else{
112       sqlite3SelectDelete(db, pDup);
113     }
114     pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
115   }
116   sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
117   sqlite3Select(pParse, pDup, &dest);
118   sqlite3SelectDelete(db, pDup);
119 }
120 #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
121 
122 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
123 /*
124 ** Generate an expression tree to implement the WHERE, ORDER BY,
125 ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
126 **
127 **     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
128 **                            \__________________________/
129 **                               pLimitWhere (pInClause)
130 */
sqlite3LimitWhere(Parse * pParse,SrcList * pSrc,Expr * pWhere,ExprList * pOrderBy,Expr * pLimit,Expr * pOffset,char * zStmtType)131 Expr *sqlite3LimitWhere(
132   Parse *pParse,               /* The parser context */
133   SrcList *pSrc,               /* the FROM clause -- which tables to scan */
134   Expr *pWhere,                /* The WHERE clause.  May be null */
135   ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */
136   Expr *pLimit,                /* The LIMIT clause.  May be null */
137   Expr *pOffset,               /* The OFFSET clause.  May be null */
138   char *zStmtType              /* Either DELETE or UPDATE.  For error messages. */
139 ){
140   Expr *pWhereRowid = NULL;    /* WHERE rowid .. */
141   Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */
142   Expr *pSelectRowid = NULL;   /* SELECT rowid ... */
143   ExprList *pEList = NULL;     /* Expression list contaning only pSelectRowid */
144   SrcList *pSelectSrc = NULL;  /* SELECT rowid FROM x ... (dup of pSrc) */
145   Select *pSelect = NULL;      /* Complete SELECT tree */
146 
147   /* Check that there isn't an ORDER BY without a LIMIT clause.
148   */
149   if( pOrderBy && (pLimit == 0) ) {
150     sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
151     pParse->parseError = 1;
152     goto limit_where_cleanup_2;
153   }
154 
155   /* We only need to generate a select expression if there
156   ** is a limit/offset term to enforce.
157   */
158   if( pLimit == 0 ) {
159     /* if pLimit is null, pOffset will always be null as well. */
160     assert( pOffset == 0 );
161     return pWhere;
162   }
163 
164   /* Generate a select expression tree to enforce the limit/offset
165   ** term for the DELETE or UPDATE statement.  For example:
166   **   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
167   ** becomes:
168   **   DELETE FROM table_a WHERE rowid IN (
169   **     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
170   **   );
171   */
172 
173   pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
174   if( pSelectRowid == 0 ) goto limit_where_cleanup_2;
175   pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);
176   if( pEList == 0 ) goto limit_where_cleanup_2;
177 
178   /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
179   ** and the SELECT subtree. */
180   pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
181   if( pSelectSrc == 0 ) {
182     sqlite3ExprListDelete(pParse->db, pEList);
183     goto limit_where_cleanup_2;
184   }
185 
186   /* generate the SELECT expression tree. */
187   pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
188                              pOrderBy,0,pLimit,pOffset);
189   if( pSelect == 0 ) return 0;
190 
191   /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
192   pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
193   if( pWhereRowid == 0 ) goto limit_where_cleanup_1;
194   pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
195   if( pInClause == 0 ) goto limit_where_cleanup_1;
196 
197   pInClause->x.pSelect = pSelect;
198   pInClause->flags |= EP_xIsSelect;
199   sqlite3ExprSetHeight(pParse, pInClause);
200   return pInClause;
201 
202   /* something went wrong. clean up anything allocated. */
203 limit_where_cleanup_1:
204   sqlite3SelectDelete(pParse->db, pSelect);
205   return 0;
206 
207 limit_where_cleanup_2:
208   sqlite3ExprDelete(pParse->db, pWhere);
209   sqlite3ExprListDelete(pParse->db, pOrderBy);
210   sqlite3ExprDelete(pParse->db, pLimit);
211   sqlite3ExprDelete(pParse->db, pOffset);
212   return 0;
213 }
214 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
215 
216 /*
217 ** Generate code for a DELETE FROM statement.
218 **
219 **     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
220 **                 \________/       \________________/
221 **                  pTabList              pWhere
222 */
sqlite3DeleteFrom(Parse * pParse,SrcList * pTabList,Expr * pWhere)223 void sqlite3DeleteFrom(
224   Parse *pParse,         /* The parser context */
225   SrcList *pTabList,     /* The table from which we should delete things */
226   Expr *pWhere           /* The WHERE clause.  May be null */
227 ){
228   Vdbe *v;               /* The virtual database engine */
229   Table *pTab;           /* The table from which records will be deleted */
230   const char *zDb;       /* Name of database holding pTab */
231   int end, addr = 0;     /* A couple addresses of generated code */
232   int i;                 /* Loop counter */
233   WhereInfo *pWInfo;     /* Information about the WHERE clause */
234   Index *pIdx;           /* For looping over indices of the table */
235   int iCur;              /* VDBE Cursor number for pTab */
236   sqlite3 *db;           /* Main database structure */
237   AuthContext sContext;  /* Authorization context */
238   NameContext sNC;       /* Name context to resolve expressions in */
239   int iDb;               /* Database number */
240   int memCnt = -1;       /* Memory cell used for change counting */
241   int rcauth;            /* Value returned by authorization callback */
242 
243 #ifndef SQLITE_OMIT_TRIGGER
244   int isView;                  /* True if attempting to delete from a view */
245   Trigger *pTrigger;           /* List of table triggers, if required */
246 #endif
247 
248   memset(&sContext, 0, sizeof(sContext));
249   db = pParse->db;
250   if( pParse->nErr || db->mallocFailed ){
251     goto delete_from_cleanup;
252   }
253   assert( pTabList->nSrc==1 );
254 
255   /* Locate the table which we want to delete.  This table has to be
256   ** put in an SrcList structure because some of the subroutines we
257   ** will be calling are designed to work with multiple tables and expect
258   ** an SrcList* parameter instead of just a Table* parameter.
259   */
260   pTab = sqlite3SrcListLookup(pParse, pTabList);
261   if( pTab==0 )  goto delete_from_cleanup;
262 
263   /* Figure out if we have any triggers and if the table being
264   ** deleted from is a view
265   */
266 #ifndef SQLITE_OMIT_TRIGGER
267   pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
268   isView = pTab->pSelect!=0;
269 #else
270 # define pTrigger 0
271 # define isView 0
272 #endif
273 #ifdef SQLITE_OMIT_VIEW
274 # undef isView
275 # define isView 0
276 #endif
277 
278   /* If pTab is really a view, make sure it has been initialized.
279   */
280   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
281     goto delete_from_cleanup;
282   }
283 
284   if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
285     goto delete_from_cleanup;
286   }
287   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
288   assert( iDb<db->nDb );
289   zDb = db->aDb[iDb].zName;
290   rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
291   assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
292   if( rcauth==SQLITE_DENY ){
293     goto delete_from_cleanup;
294   }
295   assert(!isView || pTrigger);
296 
297   /* Assign  cursor number to the table and all its indices.
298   */
299   assert( pTabList->nSrc==1 );
300   iCur = pTabList->a[0].iCursor = pParse->nTab++;
301   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
302     pParse->nTab++;
303   }
304 
305   /* Start the view context
306   */
307   if( isView ){
308     sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
309   }
310 
311   /* Begin generating code.
312   */
313   v = sqlite3GetVdbe(pParse);
314   if( v==0 ){
315     goto delete_from_cleanup;
316   }
317   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
318   sqlite3BeginWriteOperation(pParse, 1, iDb);
319 
320   /* If we are trying to delete from a view, realize that view into
321   ** a ephemeral table.
322   */
323 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
324   if( isView ){
325     sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
326   }
327 #endif
328 
329   /* Resolve the column names in the WHERE clause.
330   */
331   memset(&sNC, 0, sizeof(sNC));
332   sNC.pParse = pParse;
333   sNC.pSrcList = pTabList;
334   if( sqlite3ResolveExprNames(&sNC, pWhere) ){
335     goto delete_from_cleanup;
336   }
337 
338   /* Initialize the counter of the number of rows deleted, if
339   ** we are counting rows.
340   */
341   if( db->flags & SQLITE_CountRows ){
342     memCnt = ++pParse->nMem;
343     sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
344   }
345 
346 #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
347   /* Special case: A DELETE without a WHERE clause deletes everything.
348   ** It is easier just to erase the whole table. Prior to version 3.6.5,
349   ** this optimization caused the row change count (the value returned by
350   ** API function sqlite3_count_changes) to be set incorrectly.  */
351   if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
352    && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
353   ){
354     assert( !isView );
355     sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
356                       pTab->zName, P4_STATIC);
357     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
358       assert( pIdx->pSchema==pTab->pSchema );
359       sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
360     }
361   }else
362 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
363   /* The usual case: There is a WHERE clause so we have to scan through
364   ** the table and pick which records to delete.
365   */
366   {
367     int iRowSet = ++pParse->nMem;   /* Register for rowset of rows to delete */
368     int iRowid = ++pParse->nMem;    /* Used for storing rowid values. */
369     int regRowid;                   /* Actual register containing rowids */
370 
371     /* Collect rowids of every row to be deleted.
372     */
373     sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
374     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,WHERE_DUPLICATES_OK);
375     if( pWInfo==0 ) goto delete_from_cleanup;
376     regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid);
377     sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid);
378     if( db->flags & SQLITE_CountRows ){
379       sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
380     }
381     sqlite3WhereEnd(pWInfo);
382 
383     /* Delete every item whose key was written to the list during the
384     ** database scan.  We have to delete items after the scan is complete
385     ** because deleting an item can change the scan order.  */
386     end = sqlite3VdbeMakeLabel(v);
387 
388     /* Unless this is a view, open cursors for the table we are
389     ** deleting from and all its indices. If this is a view, then the
390     ** only effect this statement has is to fire the INSTEAD OF
391     ** triggers.  */
392     if( !isView ){
393       sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
394     }
395 
396     addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);
397 
398     /* Delete the row */
399 #ifndef SQLITE_OMIT_VIRTUALTABLE
400     if( IsVirtual(pTab) ){
401       const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
402       sqlite3VtabMakeWritable(pParse, pTab);
403       sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);
404       sqlite3MayAbort(pParse);
405     }else
406 #endif
407     {
408       int count = (pParse->nested==0);    /* True to count changes */
409       sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
410     }
411 
412     /* End of the delete loop */
413     sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
414     sqlite3VdbeResolveLabel(v, end);
415 
416     /* Close the cursors open on the table and its indexes. */
417     if( !isView && !IsVirtual(pTab) ){
418       for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
419         sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
420       }
421       sqlite3VdbeAddOp1(v, OP_Close, iCur);
422     }
423   }
424 
425   /* Update the sqlite_sequence table by storing the content of the
426   ** maximum rowid counter values recorded while inserting into
427   ** autoincrement tables.
428   */
429   if( pParse->nested==0 && pParse->pTriggerTab==0 ){
430     sqlite3AutoincrementEnd(pParse);
431   }
432 
433   /* Return the number of rows that were deleted. If this routine is
434   ** generating code because of a call to sqlite3NestedParse(), do not
435   ** invoke the callback function.
436   */
437   if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
438     sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
439     sqlite3VdbeSetNumCols(v, 1);
440     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
441   }
442 
443 delete_from_cleanup:
444   sqlite3AuthContextPop(&sContext);
445   sqlite3SrcListDelete(db, pTabList);
446   sqlite3ExprDelete(db, pWhere);
447   return;
448 }
449 /* Make sure "isView" and other macros defined above are undefined. Otherwise
450 ** thely may interfere with compilation of other functions in this file
451 ** (or in another file, if this file becomes part of the amalgamation).  */
452 #ifdef isView
453  #undef isView
454 #endif
455 #ifdef pTrigger
456  #undef pTrigger
457 #endif
458 
459 /*
460 ** This routine generates VDBE code that causes a single row of a
461 ** single table to be deleted.
462 **
463 ** The VDBE must be in a particular state when this routine is called.
464 ** These are the requirements:
465 **
466 **   1.  A read/write cursor pointing to pTab, the table containing the row
467 **       to be deleted, must be opened as cursor number $iCur.
468 **
469 **   2.  Read/write cursors for all indices of pTab must be open as
470 **       cursor number base+i for the i-th index.
471 **
472 **   3.  The record number of the row to be deleted must be stored in
473 **       memory cell iRowid.
474 **
475 ** This routine generates code to remove both the table record and all
476 ** index entries that point to that record.
477 */
sqlite3GenerateRowDelete(Parse * pParse,Table * pTab,int iCur,int iRowid,int count,Trigger * pTrigger,int onconf)478 void sqlite3GenerateRowDelete(
479   Parse *pParse,     /* Parsing context */
480   Table *pTab,       /* Table containing the row to be deleted */
481   int iCur,          /* Cursor number for the table */
482   int iRowid,        /* Memory cell that contains the rowid to delete */
483   int count,         /* If non-zero, increment the row change counter */
484   Trigger *pTrigger, /* List of triggers to (potentially) fire */
485   int onconf         /* Default ON CONFLICT policy for triggers */
486 ){
487   Vdbe *v = pParse->pVdbe;        /* Vdbe */
488   int iOld = 0;                   /* First register in OLD.* array */
489   int iLabel;                     /* Label resolved to end of generated code */
490 
491   /* Vdbe is guaranteed to have been allocated by this stage. */
492   assert( v );
493 
494   /* Seek cursor iCur to the row to delete. If this row no longer exists
495   ** (this can happen if a trigger program has already deleted it), do
496   ** not attempt to delete it or fire any DELETE triggers.  */
497   iLabel = sqlite3VdbeMakeLabel(v);
498   sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
499 
500   /* If there are any triggers to fire, allocate a range of registers to
501   ** use for the old.* references in the triggers.  */
502   if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
503     u32 mask;                     /* Mask of OLD.* columns in use */
504     int iCol;                     /* Iterator used while populating OLD.* */
505 
506     /* TODO: Could use temporary registers here. Also could attempt to
507     ** avoid copying the contents of the rowid register.  */
508     mask = sqlite3TriggerColmask(
509         pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
510     );
511     mask |= sqlite3FkOldmask(pParse, pTab);
512     iOld = pParse->nMem+1;
513     pParse->nMem += (1 + pTab->nCol);
514 
515     /* Populate the OLD.* pseudo-table register array. These values will be
516     ** used by any BEFORE and AFTER triggers that exist.  */
517     sqlite3VdbeAddOp2(v, OP_Copy, iRowid, iOld);
518     for(iCol=0; iCol<pTab->nCol; iCol++){
519       if( mask==0xffffffff || mask&(1<<iCol) ){
520         sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);
521       }
522     }
523 
524     /* Invoke BEFORE DELETE trigger programs. */
525     sqlite3CodeRowTrigger(pParse, pTrigger,
526         TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
527     );
528 
529     /* Seek the cursor to the row to be deleted again. It may be that
530     ** the BEFORE triggers coded above have already removed the row
531     ** being deleted. Do not attempt to delete the row a second time, and
532     ** do not fire AFTER triggers.  */
533     sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
534 
535     /* Do FK processing. This call checks that any FK constraints that
536     ** refer to this table (i.e. constraints attached to other tables)
537     ** are not violated by deleting this row.  */
538     sqlite3FkCheck(pParse, pTab, iOld, 0);
539   }
540 
541   /* Delete the index and table entries. Skip this step if pTab is really
542   ** a view (in which case the only effect of the DELETE statement is to
543   ** fire the INSTEAD OF triggers).  */
544   if( pTab->pSelect==0 ){
545     sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
546     sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
547     if( count ){
548       sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
549     }
550   }
551 
552   /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
553   ** handle rows (possibly in other tables) that refer via a foreign key
554   ** to the row just deleted. */
555   sqlite3FkActions(pParse, pTab, 0, iOld);
556 
557   /* Invoke AFTER DELETE trigger programs. */
558   sqlite3CodeRowTrigger(pParse, pTrigger,
559       TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
560   );
561 
562   /* Jump here if the row had already been deleted before any BEFORE
563   ** trigger programs were invoked. Or if a trigger program throws a
564   ** RAISE(IGNORE) exception.  */
565   sqlite3VdbeResolveLabel(v, iLabel);
566 }
567 
568 /*
569 ** This routine generates VDBE code that causes the deletion of all
570 ** index entries associated with a single row of a single table.
571 **
572 ** The VDBE must be in a particular state when this routine is called.
573 ** These are the requirements:
574 **
575 **   1.  A read/write cursor pointing to pTab, the table containing the row
576 **       to be deleted, must be opened as cursor number "iCur".
577 **
578 **   2.  Read/write cursors for all indices of pTab must be open as
579 **       cursor number iCur+i for the i-th index.
580 **
581 **   3.  The "iCur" cursor must be pointing to the row that is to be
582 **       deleted.
583 */
sqlite3GenerateRowIndexDelete(Parse * pParse,Table * pTab,int iCur,int * aRegIdx)584 void sqlite3GenerateRowIndexDelete(
585   Parse *pParse,     /* Parsing and code generating context */
586   Table *pTab,       /* Table containing the row to be deleted */
587   int iCur,          /* Cursor number for the table */
588   int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
589 ){
590   int i;
591   Index *pIdx;
592   int r1;
593 
594   for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
595     if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
596     r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0);
597     sqlite3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1);
598   }
599 }
600 
601 /*
602 ** Generate code that will assemble an index key and put it in register
603 ** regOut.  The key with be for index pIdx which is an index on pTab.
604 ** iCur is the index of a cursor open on the pTab table and pointing to
605 ** the entry that needs indexing.
606 **
607 ** Return a register number which is the first in a block of
608 ** registers that holds the elements of the index key.  The
609 ** block of registers has already been deallocated by the time
610 ** this routine returns.
611 */
sqlite3GenerateIndexKey(Parse * pParse,Index * pIdx,int iCur,int regOut,int doMakeRec)612 int sqlite3GenerateIndexKey(
613   Parse *pParse,     /* Parsing context */
614   Index *pIdx,       /* The index for which to generate a key */
615   int iCur,          /* Cursor number for the pIdx->pTable table */
616   int regOut,        /* Write the new index key to this register */
617   int doMakeRec      /* Run the OP_MakeRecord instruction if true */
618 ){
619   Vdbe *v = pParse->pVdbe;
620   int j;
621   Table *pTab = pIdx->pTable;
622   int regBase;
623   int nCol;
624 
625   nCol = pIdx->nColumn;
626   regBase = sqlite3GetTempRange(pParse, nCol+1);
627   sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
628   for(j=0; j<nCol; j++){
629     int idx = pIdx->aiColumn[j];
630     if( idx==pTab->iPKey ){
631       sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
632     }else{
633       sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
634       sqlite3ColumnDefault(v, pTab, idx, -1);
635     }
636   }
637   if( doMakeRec ){
638     sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
639     sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), P4_TRANSIENT);
640   }
641   sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
642   return regBase;
643 }
644