000001  /*
000002  ** 2001 September 15
000003  **
000004  ** The author disclaims copyright to this source code.  In place of
000005  ** a legal notice, here is a blessing:
000006  **
000007  **    May you do good and not evil.
000008  **    May you find forgiveness for yourself and forgive others.
000009  **    May you share freely, never taking more than you give.
000010  **
000011  *************************************************************************
000012  ** This file contains C code routines that are called by the parser
000013  ** in order to generate code for DELETE FROM statements.
000014  */
000015  #include "sqliteInt.h"
000016  
000017  /*
000018  ** While a SrcList can in general represent multiple tables and subqueries
000019  ** (as in the FROM clause of a SELECT statement) in this case it contains
000020  ** the name of a single table, as one might find in an INSERT, DELETE,
000021  ** or UPDATE statement.  Look up that table in the symbol table and
000022  ** return a pointer.  Set an error message and return NULL if the table 
000023  ** name is not found or if any other error occurs.
000024  **
000025  ** The following fields are initialized appropriate in pSrc:
000026  **
000027  **    pSrc->a[0].pTab       Pointer to the Table object
000028  **    pSrc->a[0].pIndex     Pointer to the INDEXED BY index, if there is one
000029  **
000030  */
000031  Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
000032    struct SrcList_item *pItem = pSrc->a;
000033    Table *pTab;
000034    assert( pItem && pSrc->nSrc==1 );
000035    pTab = sqlite3LocateTableItem(pParse, 0, pItem);
000036    sqlite3DeleteTable(pParse->db, pItem->pTab);
000037    pItem->pTab = pTab;
000038    if( pTab ){
000039      pTab->nTabRef++;
000040    }
000041    if( sqlite3IndexedByLookup(pParse, pItem) ){
000042      pTab = 0;
000043    }
000044    return pTab;
000045  }
000046  
000047  /*
000048  ** Check to make sure the given table is writable.  If it is not
000049  ** writable, generate an error message and return 1.  If it is
000050  ** writable return 0;
000051  */
000052  int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
000053    /* A table is not writable under the following circumstances:
000054    **
000055    **   1) It is a virtual table and no implementation of the xUpdate method
000056    **      has been provided, or
000057    **   2) It is a system table (i.e. sqlite_master), this call is not
000058    **      part of a nested parse and writable_schema pragma has not 
000059    **      been specified.
000060    **
000061    ** In either case leave an error message in pParse and return non-zero.
000062    */
000063    if( ( IsVirtual(pTab) 
000064       && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
000065     || ( (pTab->tabFlags & TF_Readonly)!=0
000066       && (pParse->db->flags & SQLITE_WriteSchema)==0
000067       && pParse->nested==0 )
000068    ){
000069      sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
000070      return 1;
000071    }
000072  
000073  #ifndef SQLITE_OMIT_VIEW
000074    if( !viewOk && pTab->pSelect ){
000075      sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
000076      return 1;
000077    }
000078  #endif
000079    return 0;
000080  }
000081  
000082  
000083  #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
000084  /*
000085  ** Evaluate a view and store its result in an ephemeral table.  The
000086  ** pWhere argument is an optional WHERE clause that restricts the
000087  ** set of rows in the view that are to be added to the ephemeral table.
000088  */
000089  void sqlite3MaterializeView(
000090    Parse *pParse,       /* Parsing context */
000091    Table *pView,        /* View definition */
000092    Expr *pWhere,        /* Optional WHERE clause to be added */
000093    int iCur             /* Cursor number for ephemeral table */
000094  ){
000095    SelectDest dest;
000096    Select *pSel;
000097    SrcList *pFrom;
000098    sqlite3 *db = pParse->db;
000099    int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
000100    pWhere = sqlite3ExprDup(db, pWhere, 0);
000101    pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
000102    if( pFrom ){
000103      assert( pFrom->nSrc==1 );
000104      pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
000105      pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
000106      assert( pFrom->a[0].pOn==0 );
000107      assert( pFrom->a[0].pUsing==0 );
000108    }
000109    pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 
000110                            SF_IncludeHidden, 0, 0);
000111    sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
000112    sqlite3Select(pParse, pSel, &dest);
000113    sqlite3SelectDelete(db, pSel);
000114  }
000115  #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
000116  
000117  #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
000118  /*
000119  ** Generate an expression tree to implement the WHERE, ORDER BY,
000120  ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
000121  **
000122  **     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
000123  **                            \__________________________/
000124  **                               pLimitWhere (pInClause)
000125  */
000126  Expr *sqlite3LimitWhere(
000127    Parse *pParse,               /* The parser context */
000128    SrcList *pSrc,               /* the FROM clause -- which tables to scan */
000129    Expr *pWhere,                /* The WHERE clause.  May be null */
000130    ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */
000131    Expr *pLimit,                /* The LIMIT clause.  May be null */
000132    Expr *pOffset,               /* The OFFSET clause.  May be null */
000133    char *zStmtType              /* Either DELETE or UPDATE.  For err msgs. */
000134  ){
000135    Expr *pWhereRowid = NULL;    /* WHERE rowid .. */
000136    Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */
000137    Expr *pSelectRowid = NULL;   /* SELECT rowid ... */
000138    ExprList *pEList = NULL;     /* Expression list contaning only pSelectRowid */
000139    SrcList *pSelectSrc = NULL;  /* SELECT rowid FROM x ... (dup of pSrc) */
000140    Select *pSelect = NULL;      /* Complete SELECT tree */
000141  
000142    /* Check that there isn't an ORDER BY without a LIMIT clause.
000143    */
000144    if( pOrderBy && (pLimit == 0) ) {
000145      sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
000146      goto limit_where_cleanup;
000147    }
000148  
000149    /* We only need to generate a select expression if there
000150    ** is a limit/offset term to enforce.
000151    */
000152    if( pLimit == 0 ) {
000153      /* if pLimit is null, pOffset will always be null as well. */
000154      assert( pOffset == 0 );
000155      return pWhere;
000156    }
000157  
000158    /* Generate a select expression tree to enforce the limit/offset 
000159    ** term for the DELETE or UPDATE statement.  For example:
000160    **   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
000161    ** becomes:
000162    **   DELETE FROM table_a WHERE rowid IN ( 
000163    **     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
000164    **   );
000165    */
000166  
000167    pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0);
000168    if( pSelectRowid == 0 ) goto limit_where_cleanup;
000169    pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);
000170    if( pEList == 0 ) goto limit_where_cleanup;
000171  
000172    /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
000173    ** and the SELECT subtree. */
000174    pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
000175    if( pSelectSrc == 0 ) {
000176      sqlite3ExprListDelete(pParse->db, pEList);
000177      goto limit_where_cleanup;
000178    }
000179  
000180    /* generate the SELECT expression tree. */
000181    pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
000182                               pOrderBy,0,pLimit,pOffset);
000183    if( pSelect == 0 ) return 0;
000184  
000185    /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
000186    pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0);
000187    pInClause = pWhereRowid ? sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0) : 0;
000188    sqlite3PExprAddSelect(pParse, pInClause, pSelect);
000189    return pInClause;
000190  
000191  limit_where_cleanup:
000192    sqlite3ExprDelete(pParse->db, pWhere);
000193    sqlite3ExprListDelete(pParse->db, pOrderBy);
000194    sqlite3ExprDelete(pParse->db, pLimit);
000195    sqlite3ExprDelete(pParse->db, pOffset);
000196    return 0;
000197  }
000198  #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */
000199         /*      && !defined(SQLITE_OMIT_SUBQUERY) */
000200  
000201  /*
000202  ** Generate code for a DELETE FROM statement.
000203  **
000204  **     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
000205  **                 \________/       \________________/
000206  **                  pTabList              pWhere
000207  */
000208  void sqlite3DeleteFrom(
000209    Parse *pParse,         /* The parser context */
000210    SrcList *pTabList,     /* The table from which we should delete things */
000211    Expr *pWhere           /* The WHERE clause.  May be null */
000212  ){
000213    Vdbe *v;               /* The virtual database engine */
000214    Table *pTab;           /* The table from which records will be deleted */
000215    int i;                 /* Loop counter */
000216    WhereInfo *pWInfo;     /* Information about the WHERE clause */
000217    Index *pIdx;           /* For looping over indices of the table */
000218    int iTabCur;           /* Cursor number for the table */
000219    int iDataCur = 0;      /* VDBE cursor for the canonical data source */
000220    int iIdxCur = 0;       /* Cursor number of the first index */
000221    int nIdx;              /* Number of indices */
000222    sqlite3 *db;           /* Main database structure */
000223    AuthContext sContext;  /* Authorization context */
000224    NameContext sNC;       /* Name context to resolve expressions in */
000225    int iDb;               /* Database number */
000226    int memCnt = -1;       /* Memory cell used for change counting */
000227    int rcauth;            /* Value returned by authorization callback */
000228    int eOnePass;          /* ONEPASS_OFF or _SINGLE or _MULTI */
000229    int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
000230    u8 *aToOpen = 0;       /* Open cursor iTabCur+j if aToOpen[j] is true */
000231    Index *pPk;            /* The PRIMARY KEY index on the table */
000232    int iPk = 0;           /* First of nPk registers holding PRIMARY KEY value */
000233    i16 nPk = 1;           /* Number of columns in the PRIMARY KEY */
000234    int iKey;              /* Memory cell holding key of row to be deleted */
000235    i16 nKey;              /* Number of memory cells in the row key */
000236    int iEphCur = 0;       /* Ephemeral table holding all primary key values */
000237    int iRowSet = 0;       /* Register for rowset of rows to delete */
000238    int addrBypass = 0;    /* Address of jump over the delete logic */
000239    int addrLoop = 0;      /* Top of the delete loop */
000240    int addrEphOpen = 0;   /* Instruction to open the Ephemeral table */
000241    int bComplex;          /* True if there are triggers or FKs or
000242                           ** subqueries in the WHERE clause */
000243   
000244  #ifndef SQLITE_OMIT_TRIGGER
000245    int isView;                  /* True if attempting to delete from a view */
000246    Trigger *pTrigger;           /* List of table triggers, if required */
000247  #endif
000248  
000249    memset(&sContext, 0, sizeof(sContext));
000250    db = pParse->db;
000251    if( pParse->nErr || db->mallocFailed ){
000252      goto delete_from_cleanup;
000253    }
000254    assert( pTabList->nSrc==1 );
000255  
000256    /* Locate the table which we want to delete.  This table has to be
000257    ** put in an SrcList structure because some of the subroutines we
000258    ** will be calling are designed to work with multiple tables and expect
000259    ** an SrcList* parameter instead of just a Table* parameter.
000260    */
000261    pTab = sqlite3SrcListLookup(pParse, pTabList);
000262    if( pTab==0 )  goto delete_from_cleanup;
000263  
000264    /* Figure out if we have any triggers and if the table being
000265    ** deleted from is a view
000266    */
000267  #ifndef SQLITE_OMIT_TRIGGER
000268    pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
000269    isView = pTab->pSelect!=0;
000270    bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0);
000271  #else
000272  # define pTrigger 0
000273  # define isView 0
000274  #endif
000275  #ifdef SQLITE_OMIT_VIEW
000276  # undef isView
000277  # define isView 0
000278  #endif
000279  
000280    /* If pTab is really a view, make sure it has been initialized.
000281    */
000282    if( sqlite3ViewGetColumnNames(pParse, pTab) ){
000283      goto delete_from_cleanup;
000284    }
000285  
000286    if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
000287      goto delete_from_cleanup;
000288    }
000289    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
000290    assert( iDb<db->nDb );
000291    rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, 
000292                              db->aDb[iDb].zDbSName);
000293    assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
000294    if( rcauth==SQLITE_DENY ){
000295      goto delete_from_cleanup;
000296    }
000297    assert(!isView || pTrigger);
000298  
000299    /* Assign cursor numbers to the table and all its indices.
000300    */
000301    assert( pTabList->nSrc==1 );
000302    iTabCur = pTabList->a[0].iCursor = pParse->nTab++;
000303    for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
000304      pParse->nTab++;
000305    }
000306  
000307    /* Start the view context
000308    */
000309    if( isView ){
000310      sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
000311    }
000312  
000313    /* Begin generating code.
000314    */
000315    v = sqlite3GetVdbe(pParse);
000316    if( v==0 ){
000317      goto delete_from_cleanup;
000318    }
000319    if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
000320    sqlite3BeginWriteOperation(pParse, 1, iDb);
000321  
000322    /* If we are trying to delete from a view, realize that view into
000323    ** an ephemeral table.
000324    */
000325  #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
000326    if( isView ){
000327      sqlite3MaterializeView(pParse, pTab, pWhere, iTabCur);
000328      iDataCur = iIdxCur = iTabCur;
000329    }
000330  #endif
000331  
000332    /* Resolve the column names in the WHERE clause.
000333    */
000334    memset(&sNC, 0, sizeof(sNC));
000335    sNC.pParse = pParse;
000336    sNC.pSrcList = pTabList;
000337    if( sqlite3ResolveExprNames(&sNC, pWhere) ){
000338      goto delete_from_cleanup;
000339    }
000340  
000341    /* Initialize the counter of the number of rows deleted, if
000342    ** we are counting rows.
000343    */
000344    if( db->flags & SQLITE_CountRows ){
000345      memCnt = ++pParse->nMem;
000346      sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
000347    }
000348  
000349  #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
000350    /* Special case: A DELETE without a WHERE clause deletes everything.
000351    ** It is easier just to erase the whole table. Prior to version 3.6.5,
000352    ** this optimization caused the row change count (the value returned by 
000353    ** API function sqlite3_count_changes) to be set incorrectly.
000354    **
000355    ** The "rcauth==SQLITE_OK" terms is the
000356    ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and
000357    ** the callback returns SQLITE_IGNORE then the DELETE operation proceeds but
000358    ** the truncate optimization is disabled and all rows are deleted
000359    ** individually.
000360    */
000361    if( rcauth==SQLITE_OK
000362     && pWhere==0
000363     && !bComplex
000364     && !IsVirtual(pTab)
000365  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
000366     && db->xPreUpdateCallback==0
000367  #endif
000368    ){
000369      assert( !isView );
000370      sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
000371      if( HasRowid(pTab) ){
000372        sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
000373                          pTab->zName, P4_STATIC);
000374      }
000375      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
000376        assert( pIdx->pSchema==pTab->pSchema );
000377        sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
000378      }
000379    }else
000380  #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
000381    {
000382      u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK|WHERE_SEEK_TABLE;
000383      if( sNC.ncFlags & NC_VarSelect ) bComplex = 1;
000384      wcf |= (bComplex ? 0 : WHERE_ONEPASS_MULTIROW);
000385      if( HasRowid(pTab) ){
000386        /* For a rowid table, initialize the RowSet to an empty set */
000387        pPk = 0;
000388        nPk = 1;
000389        iRowSet = ++pParse->nMem;
000390        sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
000391      }else{
000392        /* For a WITHOUT ROWID table, create an ephemeral table used to
000393        ** hold all primary keys for rows to be deleted. */
000394        pPk = sqlite3PrimaryKeyIndex(pTab);
000395        assert( pPk!=0 );
000396        nPk = pPk->nKeyCol;
000397        iPk = pParse->nMem+1;
000398        pParse->nMem += nPk;
000399        iEphCur = pParse->nTab++;
000400        addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk);
000401        sqlite3VdbeSetP4KeyInfo(pParse, pPk);
000402      }
000403    
000404      /* Construct a query to find the rowid or primary key for every row
000405      ** to be deleted, based on the WHERE clause. Set variable eOnePass
000406      ** to indicate the strategy used to implement this delete:
000407      **
000408      **  ONEPASS_OFF:    Two-pass approach - use a FIFO for rowids/PK values.
000409      **  ONEPASS_SINGLE: One-pass approach - at most one row deleted.
000410      **  ONEPASS_MULTI:  One-pass approach - any number of rows may be deleted.
000411      */
000412      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, wcf, iTabCur+1);
000413      if( pWInfo==0 ) goto delete_from_cleanup;
000414      eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
000415      assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
000416      assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF );
000417    
000418      /* Keep track of the number of rows to be deleted */
000419      if( db->flags & SQLITE_CountRows ){
000420        sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
000421      }
000422    
000423      /* Extract the rowid or primary key for the current row */
000424      if( pPk ){
000425        for(i=0; i<nPk; i++){
000426          assert( pPk->aiColumn[i]>=0 );
000427          sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
000428                                          pPk->aiColumn[i], iPk+i);
000429        }
000430        iKey = iPk;
000431      }else{
000432        iKey = pParse->nMem + 1;
000433        iKey = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iTabCur, iKey, 0);
000434        if( iKey>pParse->nMem ) pParse->nMem = iKey;
000435      }
000436    
000437      if( eOnePass!=ONEPASS_OFF ){
000438        /* For ONEPASS, no need to store the rowid/primary-key. There is only
000439        ** one, so just keep it in its register(s) and fall through to the
000440        ** delete code.  */
000441        nKey = nPk; /* OP_Found will use an unpacked key */
000442        aToOpen = sqlite3DbMallocRawNN(db, nIdx+2);
000443        if( aToOpen==0 ){
000444          sqlite3WhereEnd(pWInfo);
000445          goto delete_from_cleanup;
000446        }
000447        memset(aToOpen, 1, nIdx+1);
000448        aToOpen[nIdx+1] = 0;
000449        if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0;
000450        if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0;
000451        if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen);
000452      }else{
000453        if( pPk ){
000454          /* Add the PK key for this row to the temporary table */
000455          iKey = ++pParse->nMem;
000456          nKey = 0;   /* Zero tells OP_Found to use a composite key */
000457          sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey,
000458              sqlite3IndexAffinityStr(pParse->db, pPk), nPk);
000459          sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEphCur, iKey, iPk, nPk);
000460        }else{
000461          /* Add the rowid of the row to be deleted to the RowSet */
000462          nKey = 1;  /* OP_DeferredSeek always uses a single rowid */
000463          sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey);
000464        }
000465      }
000466    
000467      /* If this DELETE cannot use the ONEPASS strategy, this is the 
000468      ** end of the WHERE loop */
000469      if( eOnePass!=ONEPASS_OFF ){
000470        addrBypass = sqlite3VdbeMakeLabel(v);
000471      }else{
000472        sqlite3WhereEnd(pWInfo);
000473      }
000474    
000475      /* Unless this is a view, open cursors for the table we are 
000476      ** deleting from and all its indices. If this is a view, then the
000477      ** only effect this statement has is to fire the INSTEAD OF 
000478      ** triggers.
000479      */
000480      if( !isView ){
000481        int iAddrOnce = 0;
000482        if( eOnePass==ONEPASS_MULTI ){
000483          iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
000484        }
000485        testcase( IsVirtual(pTab) );
000486        sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,
000487                                   iTabCur, aToOpen, &iDataCur, &iIdxCur);
000488        assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
000489        assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
000490        if( eOnePass==ONEPASS_MULTI ) sqlite3VdbeJumpHere(v, iAddrOnce);
000491      }
000492    
000493      /* Set up a loop over the rowids/primary-keys that were found in the
000494      ** where-clause loop above.
000495      */
000496      if( eOnePass!=ONEPASS_OFF ){
000497        assert( nKey==nPk );  /* OP_Found will use an unpacked key */
000498        if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){
000499          assert( pPk!=0 || pTab->pSelect!=0 );
000500          sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);
000501          VdbeCoverage(v);
000502        }
000503      }else if( pPk ){
000504        addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v);
000505        if( IsVirtual(pTab) ){
000506          sqlite3VdbeAddOp3(v, OP_Column, iEphCur, 0, iKey);
000507        }else{
000508          sqlite3VdbeAddOp2(v, OP_RowData, iEphCur, iKey);
000509        }
000510        assert( nKey==0 );  /* OP_Found will use a composite key */
000511      }else{
000512        addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey);
000513        VdbeCoverage(v);
000514        assert( nKey==1 );
000515      }  
000516    
000517      /* Delete the row */
000518  #ifndef SQLITE_OMIT_VIRTUALTABLE
000519      if( IsVirtual(pTab) ){
000520        const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
000521        sqlite3VtabMakeWritable(pParse, pTab);
000522        sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);
000523        sqlite3VdbeChangeP5(v, OE_Abort);
000524        assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
000525        sqlite3MayAbort(pParse);
000526        if( eOnePass==ONEPASS_SINGLE && sqlite3IsToplevel(pParse) ){
000527          pParse->isMultiWrite = 0;
000528        }
000529      }else
000530  #endif
000531      {
000532        int count = (pParse->nested==0);    /* True to count changes */
000533        sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
000534            iKey, nKey, count, OE_Default, eOnePass, aiCurOnePass[1]);
000535      }
000536    
000537      /* End of the loop over all rowids/primary-keys. */
000538      if( eOnePass!=ONEPASS_OFF ){
000539        sqlite3VdbeResolveLabel(v, addrBypass);
000540        sqlite3WhereEnd(pWInfo);
000541      }else if( pPk ){
000542        sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v);
000543        sqlite3VdbeJumpHere(v, addrLoop);
000544      }else{
000545        sqlite3VdbeGoto(v, addrLoop);
000546        sqlite3VdbeJumpHere(v, addrLoop);
000547      }     
000548    } /* End non-truncate path */
000549  
000550    /* Update the sqlite_sequence table by storing the content of the
000551    ** maximum rowid counter values recorded while inserting into
000552    ** autoincrement tables.
000553    */
000554    if( pParse->nested==0 && pParse->pTriggerTab==0 ){
000555      sqlite3AutoincrementEnd(pParse);
000556    }
000557  
000558    /* Return the number of rows that were deleted. If this routine is 
000559    ** generating code because of a call to sqlite3NestedParse(), do not
000560    ** invoke the callback function.
000561    */
000562    if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
000563      sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
000564      sqlite3VdbeSetNumCols(v, 1);
000565      sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
000566    }
000567  
000568  delete_from_cleanup:
000569    sqlite3AuthContextPop(&sContext);
000570    sqlite3SrcListDelete(db, pTabList);
000571    sqlite3ExprDelete(db, pWhere);
000572    sqlite3DbFree(db, aToOpen);
000573    return;
000574  }
000575  /* Make sure "isView" and other macros defined above are undefined. Otherwise
000576  ** they may interfere with compilation of other functions in this file
000577  ** (or in another file, if this file becomes part of the amalgamation).  */
000578  #ifdef isView
000579   #undef isView
000580  #endif
000581  #ifdef pTrigger
000582   #undef pTrigger
000583  #endif
000584  
000585  /*
000586  ** This routine generates VDBE code that causes a single row of a
000587  ** single table to be deleted.  Both the original table entry and
000588  ** all indices are removed.
000589  **
000590  ** Preconditions:
000591  **
000592  **   1.  iDataCur is an open cursor on the btree that is the canonical data
000593  **       store for the table.  (This will be either the table itself,
000594  **       in the case of a rowid table, or the PRIMARY KEY index in the case
000595  **       of a WITHOUT ROWID table.)
000596  **
000597  **   2.  Read/write cursors for all indices of pTab must be open as
000598  **       cursor number iIdxCur+i for the i-th index.
000599  **
000600  **   3.  The primary key for the row to be deleted must be stored in a
000601  **       sequence of nPk memory cells starting at iPk.  If nPk==0 that means
000602  **       that a search record formed from OP_MakeRecord is contained in the
000603  **       single memory location iPk.
000604  **
000605  ** eMode:
000606  **   Parameter eMode may be passed either ONEPASS_OFF (0), ONEPASS_SINGLE, or
000607  **   ONEPASS_MULTI.  If eMode is not ONEPASS_OFF, then the cursor
000608  **   iDataCur already points to the row to delete. If eMode is ONEPASS_OFF
000609  **   then this function must seek iDataCur to the entry identified by iPk
000610  **   and nPk before reading from it.
000611  **
000612  **   If eMode is ONEPASS_MULTI, then this call is being made as part
000613  **   of a ONEPASS delete that affects multiple rows. In this case, if 
000614  **   iIdxNoSeek is a valid cursor number (>=0) and is not the same as
000615  **   iDataCur, then its position should be preserved following the delete
000616  **   operation. Or, if iIdxNoSeek is not a valid cursor number, the
000617  **   position of iDataCur should be preserved instead.
000618  **
000619  ** iIdxNoSeek:
000620  **   If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur,
000621  **   then it identifies an index cursor (from within array of cursors
000622  **   starting at iIdxCur) that already points to the index entry to be deleted.
000623  **   Except, this optimization is disabled if there are BEFORE triggers since
000624  **   the trigger body might have moved the cursor.
000625  */
000626  void sqlite3GenerateRowDelete(
000627    Parse *pParse,     /* Parsing context */
000628    Table *pTab,       /* Table containing the row to be deleted */
000629    Trigger *pTrigger, /* List of triggers to (potentially) fire */
000630    int iDataCur,      /* Cursor from which column data is extracted */
000631    int iIdxCur,       /* First index cursor */
000632    int iPk,           /* First memory cell containing the PRIMARY KEY */
000633    i16 nPk,           /* Number of PRIMARY KEY memory cells */
000634    u8 count,          /* If non-zero, increment the row change counter */
000635    u8 onconf,         /* Default ON CONFLICT policy for triggers */
000636    u8 eMode,          /* ONEPASS_OFF, _SINGLE, or _MULTI.  See above */
000637    int iIdxNoSeek     /* Cursor number of cursor that does not need seeking */
000638  ){
000639    Vdbe *v = pParse->pVdbe;        /* Vdbe */
000640    int iOld = 0;                   /* First register in OLD.* array */
000641    int iLabel;                     /* Label resolved to end of generated code */
000642    u8 opSeek;                      /* Seek opcode */
000643  
000644    /* Vdbe is guaranteed to have been allocated by this stage. */
000645    assert( v );
000646    VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)",
000647                           iDataCur, iIdxCur, iPk, (int)nPk));
000648  
000649    /* Seek cursor iCur to the row to delete. If this row no longer exists 
000650    ** (this can happen if a trigger program has already deleted it), do
000651    ** not attempt to delete it or fire any DELETE triggers.  */
000652    iLabel = sqlite3VdbeMakeLabel(v);
000653    opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
000654    if( eMode==ONEPASS_OFF ){
000655      sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
000656      VdbeCoverageIf(v, opSeek==OP_NotExists);
000657      VdbeCoverageIf(v, opSeek==OP_NotFound);
000658    }
000659   
000660    /* If there are any triggers to fire, allocate a range of registers to
000661    ** use for the old.* references in the triggers.  */
000662    if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
000663      u32 mask;                     /* Mask of OLD.* columns in use */
000664      int iCol;                     /* Iterator used while populating OLD.* */
000665      int addrStart;                /* Start of BEFORE trigger programs */
000666  
000667      /* TODO: Could use temporary registers here. Also could attempt to
000668      ** avoid copying the contents of the rowid register.  */
000669      mask = sqlite3TriggerColmask(
000670          pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
000671      );
000672      mask |= sqlite3FkOldmask(pParse, pTab);
000673      iOld = pParse->nMem+1;
000674      pParse->nMem += (1 + pTab->nCol);
000675  
000676      /* Populate the OLD.* pseudo-table register array. These values will be 
000677      ** used by any BEFORE and AFTER triggers that exist.  */
000678      sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld);
000679      for(iCol=0; iCol<pTab->nCol; iCol++){
000680        testcase( mask!=0xffffffff && iCol==31 );
000681        testcase( mask!=0xffffffff && iCol==32 );
000682        if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
000683          sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1);
000684        }
000685      }
000686  
000687      /* Invoke BEFORE DELETE trigger programs. */
000688      addrStart = sqlite3VdbeCurrentAddr(v);
000689      sqlite3CodeRowTrigger(pParse, pTrigger, 
000690          TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
000691      );
000692  
000693      /* If any BEFORE triggers were coded, then seek the cursor to the 
000694      ** row to be deleted again. It may be that the BEFORE triggers moved
000695      ** the cursor or already deleted the row that the cursor was
000696      ** pointing to.
000697      **
000698      ** Also disable the iIdxNoSeek optimization since the BEFORE trigger
000699      ** may have moved that cursor.
000700      */
000701      if( addrStart<sqlite3VdbeCurrentAddr(v) ){
000702        sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
000703        VdbeCoverageIf(v, opSeek==OP_NotExists);
000704        VdbeCoverageIf(v, opSeek==OP_NotFound);
000705        testcase( iIdxNoSeek>=0 );
000706        iIdxNoSeek = -1;
000707      }
000708  
000709      /* Do FK processing. This call checks that any FK constraints that
000710      ** refer to this table (i.e. constraints attached to other tables) 
000711      ** are not violated by deleting this row.  */
000712      sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
000713    }
000714  
000715    /* Delete the index and table entries. Skip this step if pTab is really
000716    ** a view (in which case the only effect of the DELETE statement is to
000717    ** fire the INSTEAD OF triggers).  
000718    **
000719    ** If variable 'count' is non-zero, then this OP_Delete instruction should
000720    ** invoke the update-hook. The pre-update-hook, on the other hand should
000721    ** be invoked unless table pTab is a system table. The difference is that
000722    ** the update-hook is not invoked for rows removed by REPLACE, but the 
000723    ** pre-update-hook is.
000724    */ 
000725    if( pTab->pSelect==0 ){
000726      u8 p5 = 0;
000727      sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
000728      sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
000729      if( pParse->nested==0 ){
000730        sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE);
000731      }
000732      if( eMode!=ONEPASS_OFF ){
000733        sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);
000734      }
000735      if( iIdxNoSeek>=0 && iIdxNoSeek!=iDataCur ){
000736        sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);
000737      }
000738      if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION;
000739      sqlite3VdbeChangeP5(v, p5);
000740    }
000741  
000742    /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
000743    ** handle rows (possibly in other tables) that refer via a foreign key
000744    ** to the row just deleted. */ 
000745    sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
000746  
000747    /* Invoke AFTER DELETE trigger programs. */
000748    sqlite3CodeRowTrigger(pParse, pTrigger, 
000749        TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
000750    );
000751  
000752    /* Jump here if the row had already been deleted before any BEFORE
000753    ** trigger programs were invoked. Or if a trigger program throws a 
000754    ** RAISE(IGNORE) exception.  */
000755    sqlite3VdbeResolveLabel(v, iLabel);
000756    VdbeModuleComment((v, "END: GenRowDel()"));
000757  }
000758  
000759  /*
000760  ** This routine generates VDBE code that causes the deletion of all
000761  ** index entries associated with a single row of a single table, pTab
000762  **
000763  ** Preconditions:
000764  **
000765  **   1.  A read/write cursor "iDataCur" must be open on the canonical storage
000766  **       btree for the table pTab.  (This will be either the table itself
000767  **       for rowid tables or to the primary key index for WITHOUT ROWID
000768  **       tables.)
000769  **
000770  **   2.  Read/write cursors for all indices of pTab must be open as
000771  **       cursor number iIdxCur+i for the i-th index.  (The pTab->pIndex
000772  **       index is the 0-th index.)
000773  **
000774  **   3.  The "iDataCur" cursor must be already be positioned on the row
000775  **       that is to be deleted.
000776  */
000777  void sqlite3GenerateRowIndexDelete(
000778    Parse *pParse,     /* Parsing and code generating context */
000779    Table *pTab,       /* Table containing the row to be deleted */
000780    int iDataCur,      /* Cursor of table holding data. */
000781    int iIdxCur,       /* First index cursor */
000782    int *aRegIdx,      /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
000783    int iIdxNoSeek     /* Do not delete from this cursor */
000784  ){
000785    int i;             /* Index loop counter */
000786    int r1 = -1;       /* Register holding an index key */
000787    int iPartIdxLabel; /* Jump destination for skipping partial index entries */
000788    Index *pIdx;       /* Current index */
000789    Index *pPrior = 0; /* Prior index */
000790    Vdbe *v;           /* The prepared statement under construction */
000791    Index *pPk;        /* PRIMARY KEY index, or NULL for rowid tables */
000792  
000793    v = pParse->pVdbe;
000794    pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
000795    for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
000796      assert( iIdxCur+i!=iDataCur || pPk==pIdx );
000797      if( aRegIdx!=0 && aRegIdx[i]==0 ) continue;
000798      if( pIdx==pPk ) continue;
000799      if( iIdxCur+i==iIdxNoSeek ) continue;
000800      VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
000801      r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1,
000802          &iPartIdxLabel, pPrior, r1);
000803      sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,
000804          pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn);
000805      sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
000806      pPrior = pIdx;
000807    }
000808  }
000809  
000810  /*
000811  ** Generate code that will assemble an index key and stores it in register
000812  ** regOut.  The key with be for index pIdx which is an index on pTab.
000813  ** iCur is the index of a cursor open on the pTab table and pointing to
000814  ** the entry that needs indexing.  If pTab is a WITHOUT ROWID table, then
000815  ** iCur must be the cursor of the PRIMARY KEY index.
000816  **
000817  ** Return a register number which is the first in a block of
000818  ** registers that holds the elements of the index key.  The
000819  ** block of registers has already been deallocated by the time
000820  ** this routine returns.
000821  **
000822  ** If *piPartIdxLabel is not NULL, fill it in with a label and jump
000823  ** to that label if pIdx is a partial index that should be skipped.
000824  ** The label should be resolved using sqlite3ResolvePartIdxLabel().
000825  ** A partial index should be skipped if its WHERE clause evaluates
000826  ** to false or null.  If pIdx is not a partial index, *piPartIdxLabel
000827  ** will be set to zero which is an empty label that is ignored by
000828  ** sqlite3ResolvePartIdxLabel().
000829  **
000830  ** The pPrior and regPrior parameters are used to implement a cache to
000831  ** avoid unnecessary register loads.  If pPrior is not NULL, then it is
000832  ** a pointer to a different index for which an index key has just been
000833  ** computed into register regPrior.  If the current pIdx index is generating
000834  ** its key into the same sequence of registers and if pPrior and pIdx share
000835  ** a column in common, then the register corresponding to that column already
000836  ** holds the correct value and the loading of that register is skipped.
000837  ** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK 
000838  ** on a table with multiple indices, and especially with the ROWID or
000839  ** PRIMARY KEY columns of the index.
000840  */
000841  int sqlite3GenerateIndexKey(
000842    Parse *pParse,       /* Parsing context */
000843    Index *pIdx,         /* The index for which to generate a key */
000844    int iDataCur,        /* Cursor number from which to take column data */
000845    int regOut,          /* Put the new key into this register if not 0 */
000846    int prefixOnly,      /* Compute only a unique prefix of the key */
000847    int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */
000848    Index *pPrior,       /* Previously generated index key */
000849    int regPrior         /* Register holding previous generated key */
000850  ){
000851    Vdbe *v = pParse->pVdbe;
000852    int j;
000853    int regBase;
000854    int nCol;
000855  
000856    if( piPartIdxLabel ){
000857      if( pIdx->pPartIdxWhere ){
000858        *piPartIdxLabel = sqlite3VdbeMakeLabel(v);
000859        pParse->iSelfTab = iDataCur + 1;
000860        sqlite3ExprCachePush(pParse);
000861        sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel, 
000862                              SQLITE_JUMPIFNULL);
000863        pParse->iSelfTab = 0;
000864      }else{
000865        *piPartIdxLabel = 0;
000866      }
000867    }
000868    nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
000869    regBase = sqlite3GetTempRange(pParse, nCol);
000870    if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;
000871    for(j=0; j<nCol; j++){
000872      if( pPrior
000873       && pPrior->aiColumn[j]==pIdx->aiColumn[j]
000874       && pPrior->aiColumn[j]!=XN_EXPR
000875      ){
000876        /* This column was already computed by the previous index */
000877        continue;
000878      }
000879      sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j);
000880      /* If the column affinity is REAL but the number is an integer, then it
000881      ** might be stored in the table as an integer (using a compact
000882      ** representation) then converted to REAL by an OP_RealAffinity opcode.
000883      ** But we are getting ready to store this value back into an index, where
000884      ** it should be converted by to INTEGER again.  So omit the OP_RealAffinity
000885      ** opcode if it is present */
000886      sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
000887    }
000888    if( regOut ){
000889      sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
000890      if( pIdx->pTable->pSelect ){
000891        const char *zAff = sqlite3IndexAffinityStr(pParse->db, pIdx);
000892        sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);
000893      }
000894    }
000895    sqlite3ReleaseTempRange(pParse, regBase, nCol);
000896    return regBase;
000897  }
000898  
000899  /*
000900  ** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label
000901  ** because it was a partial index, then this routine should be called to
000902  ** resolve that label.
000903  */
000904  void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){
000905    if( iLabel ){
000906      sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel);
000907      sqlite3ExprCachePop(pParse);
000908    }
000909  }