src/delete.c

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