sl@0: /*
sl@0: ** 2001 September 15
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains C code routines that are called by the parser
sl@0: ** in order to generate code for DELETE FROM statements.
sl@0: **
sl@0: ** $Id: delete.c,v 1.182 2008/10/10 23:48:26 drh Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: 
sl@0: /*
sl@0: ** Look up every table that is named in pSrc.  If any table is not found,
sl@0: ** add an error message to pParse->zErrMsg and return NULL.  If all tables
sl@0: ** are found, return a pointer to the last table.
sl@0: */
sl@0: Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
sl@0:   struct SrcList_item *pItem = pSrc->a;
sl@0:   Table *pTab;
sl@0:   assert( pItem && pSrc->nSrc==1 );
sl@0:   pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
sl@0:   sqlite3DeleteTable(pItem->pTab);
sl@0:   pItem->pTab = pTab;
sl@0:   if( pTab ){
sl@0:     pTab->nRef++;
sl@0:   }
sl@0:   if( sqlite3IndexedByLookup(pParse, pItem) ){
sl@0:     pTab = 0;
sl@0:   }
sl@0:   return pTab;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Check to make sure the given table is writable.  If it is not
sl@0: ** writable, generate an error message and return 1.  If it is
sl@0: ** writable return 0;
sl@0: */
sl@0: int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
sl@0:   if( ((pTab->tabFlags & TF_Readonly)!=0
sl@0:         && (pParse->db->flags & SQLITE_WriteSchema)==0
sl@0:         && pParse->nested==0) 
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0:       || (pTab->pMod && pTab->pMod->pModule->xUpdate==0)
sl@0: #endif
sl@0:   ){
sl@0:     sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
sl@0:     return 1;
sl@0:   }
sl@0: #ifndef SQLITE_OMIT_VIEW
sl@0:   if( !viewOk && pTab->pSelect ){
sl@0:     sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
sl@0:     return 1;
sl@0:   }
sl@0: #endif
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Generate code that will open a table for reading.
sl@0: */
sl@0: void sqlite3OpenTable(
sl@0:   Parse *p,       /* Generate code into this VDBE */
sl@0:   int iCur,       /* The cursor number of the table */
sl@0:   int iDb,        /* The database index in sqlite3.aDb[] */
sl@0:   Table *pTab,    /* The table to be opened */
sl@0:   int opcode      /* OP_OpenRead or OP_OpenWrite */
sl@0: ){
sl@0:   Vdbe *v;
sl@0:   if( IsVirtual(pTab) ) return;
sl@0:   v = sqlite3GetVdbe(p);
sl@0:   assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
sl@0:   sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite), pTab->zName);
sl@0:   sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pTab->nCol);
sl@0:   sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
sl@0:   VdbeComment((v, "%s", pTab->zName));
sl@0: }
sl@0: 
sl@0: 
sl@0: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
sl@0: /*
sl@0: ** Evaluate a view and store its result in an ephemeral table.  The
sl@0: ** pWhere argument is an optional WHERE clause that restricts the
sl@0: ** set of rows in the view that are to be added to the ephemeral table.
sl@0: */
sl@0: void sqlite3MaterializeView(
sl@0:   Parse *pParse,       /* Parsing context */
sl@0:   Table *pView,        /* View definition */
sl@0:   Expr *pWhere,        /* Optional WHERE clause to be added */
sl@0:   int iCur             /* Cursor number for ephemerial table */
sl@0: ){
sl@0:   SelectDest dest;
sl@0:   Select *pDup;
sl@0:   sqlite3 *db = pParse->db;
sl@0: 
sl@0:   pDup = sqlite3SelectDup(db, pView->pSelect);
sl@0:   if( pWhere ){
sl@0:     SrcList *pFrom;
sl@0:     Token viewName;
sl@0:     
sl@0:     pWhere = sqlite3ExprDup(db, pWhere);
sl@0:     viewName.z = (u8*)pView->zName;
sl@0:     viewName.n = (unsigned int)strlen((const char*)viewName.z);
sl@0:     pFrom = sqlite3SrcListAppendFromTerm(pParse, 0, 0, 0, &viewName, pDup, 0,0);
sl@0:     pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
sl@0:   }
sl@0:   sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
sl@0:   sqlite3Select(pParse, pDup, &dest);
sl@0:   sqlite3SelectDelete(db, pDup);
sl@0: }
sl@0: #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
sl@0: 
sl@0: #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
sl@0: /*
sl@0: ** Generate an expression tree to implement the WHERE, ORDER BY,
sl@0: ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
sl@0: **
sl@0: **     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
sl@0: **                            \__________________________/
sl@0: **                               pLimitWhere (pInClause)
sl@0: */
sl@0: Expr *sqlite3LimitWhere(
sl@0:   Parse *pParse,               /* The parser context */
sl@0:   SrcList *pSrc,               /* the FROM clause -- which tables to scan */
sl@0:   Expr *pWhere,                /* The WHERE clause.  May be null */
sl@0:   ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */
sl@0:   Expr *pLimit,                /* The LIMIT clause.  May be null */
sl@0:   Expr *pOffset,               /* The OFFSET clause.  May be null */
sl@0:   char *zStmtType              /* Either DELETE or UPDATE.  For error messages. */
sl@0: ){
sl@0:   Expr *pWhereRowid = NULL;    /* WHERE rowid .. */
sl@0:   Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */
sl@0:   Expr *pSelectRowid = NULL;   /* SELECT rowid ... */
sl@0:   ExprList *pEList = NULL;     /* Expression list contaning only pSelectRowid */
sl@0:   SrcList *pSelectSrc = NULL;  /* SELECT rowid FROM x ... (dup of pSrc) */
sl@0:   Select *pSelect = NULL;      /* Complete SELECT tree */
sl@0: 
sl@0:   /* Check that there isn't an ORDER BY without a LIMIT clause.
sl@0:   */
sl@0:   if( pOrderBy && (pLimit == 0) ) {
sl@0:     sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
sl@0:     pParse->parseError = 1;
sl@0:     goto limit_where_cleanup_2;
sl@0:   }
sl@0: 
sl@0:   /* We only need to generate a select expression if there
sl@0:   ** is a limit/offset term to enforce.
sl@0:   */
sl@0:   if( pLimit == 0 ) {
sl@0:     /* if pLimit is null, pOffset will always be null as well. */
sl@0:     assert( pOffset == 0 );
sl@0:     return pWhere;
sl@0:   }
sl@0: 
sl@0:   /* Generate a select expression tree to enforce the limit/offset 
sl@0:   ** term for the DELETE or UPDATE statement.  For example:
sl@0:   **   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
sl@0:   ** becomes:
sl@0:   **   DELETE FROM table_a WHERE rowid IN ( 
sl@0:   **     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
sl@0:   **   );
sl@0:   */
sl@0: 
sl@0:   pSelectRowid = sqlite3Expr(pParse->db, TK_ROW, 0, 0, 0);
sl@0:   if( pSelectRowid == 0 ) goto limit_where_cleanup_2;
sl@0:   pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid, 0);
sl@0:   if( pEList == 0 ) goto limit_where_cleanup_2;
sl@0: 
sl@0:   /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
sl@0:   ** and the SELECT subtree. */
sl@0:   pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc);
sl@0:   if( pSelectSrc == 0 ) {
sl@0:     sqlite3ExprListDelete(pParse->db, pEList);
sl@0:     goto limit_where_cleanup_2;
sl@0:   }
sl@0: 
sl@0:   /* generate the SELECT expression tree. */
sl@0:   pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,pOrderBy,0,pLimit,pOffset);
sl@0:   if( pSelect == 0 ) return 0;
sl@0: 
sl@0:   /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
sl@0:   pWhereRowid = sqlite3Expr(pParse->db, TK_ROW, 0, 0, 0);
sl@0:   if( pWhereRowid == 0 ) goto limit_where_cleanup_1;
sl@0:   pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
sl@0:   if( pInClause == 0 ) goto limit_where_cleanup_1;
sl@0: 
sl@0:   pInClause->pSelect = pSelect;
sl@0:   sqlite3ExprSetHeight(pParse, pInClause);
sl@0:   return pInClause;
sl@0: 
sl@0:   /* something went wrong. clean up anything allocated. */
sl@0: limit_where_cleanup_1:
sl@0:   sqlite3SelectDelete(pParse->db, pSelect);
sl@0:   return 0;
sl@0: 
sl@0: limit_where_cleanup_2:
sl@0:   sqlite3ExprDelete(pParse->db, pWhere);
sl@0:   sqlite3ExprListDelete(pParse->db, pOrderBy);
sl@0:   sqlite3ExprDelete(pParse->db, pLimit);
sl@0:   sqlite3ExprDelete(pParse->db, pOffset);
sl@0:   return 0;
sl@0: }
sl@0: #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
sl@0: 
sl@0: /*
sl@0: ** Generate code for a DELETE FROM statement.
sl@0: **
sl@0: **     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
sl@0: **                 \________/       \________________/
sl@0: **                  pTabList              pWhere
sl@0: */
sl@0: void sqlite3DeleteFrom(
sl@0:   Parse *pParse,         /* The parser context */
sl@0:   SrcList *pTabList,     /* The table from which we should delete things */
sl@0:   Expr *pWhere           /* The WHERE clause.  May be null */
sl@0: ){
sl@0:   Vdbe *v;               /* The virtual database engine */
sl@0:   Table *pTab;           /* The table from which records will be deleted */
sl@0:   const char *zDb;       /* Name of database holding pTab */
sl@0:   int end, addr = 0;     /* A couple addresses of generated code */
sl@0:   int i;                 /* Loop counter */
sl@0:   WhereInfo *pWInfo;     /* Information about the WHERE clause */
sl@0:   Index *pIdx;           /* For looping over indices of the table */
sl@0:   int iCur;              /* VDBE Cursor number for pTab */
sl@0:   sqlite3 *db;           /* Main database structure */
sl@0:   AuthContext sContext;  /* Authorization context */
sl@0:   int oldIdx = -1;       /* Cursor for the OLD table of AFTER triggers */
sl@0:   NameContext sNC;       /* Name context to resolve expressions in */
sl@0:   int iDb;               /* Database number */
sl@0:   int memCnt = 0;        /* Memory cell used for change counting */
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   int isView;                  /* True if attempting to delete from a view */
sl@0:   int triggers_exist = 0;      /* True if any triggers exist */
sl@0: #endif
sl@0:   int iBeginAfterTrigger;      /* Address of after trigger program */
sl@0:   int iEndAfterTrigger;        /* Exit of after trigger program */
sl@0:   int iBeginBeforeTrigger;     /* Address of before trigger program */
sl@0:   int iEndBeforeTrigger;       /* Exit of before trigger program */
sl@0:   u32 old_col_mask = 0;        /* Mask of OLD.* columns in use */
sl@0: 
sl@0:   sContext.pParse = 0;
sl@0:   db = pParse->db;
sl@0:   if( pParse->nErr || db->mallocFailed ){
sl@0:     goto delete_from_cleanup;
sl@0:   }
sl@0:   assert( pTabList->nSrc==1 );
sl@0: 
sl@0:   /* Locate the table which we want to delete.  This table has to be
sl@0:   ** put in an SrcList structure because some of the subroutines we
sl@0:   ** will be calling are designed to work with multiple tables and expect
sl@0:   ** an SrcList* parameter instead of just a Table* parameter.
sl@0:   */
sl@0:   pTab = sqlite3SrcListLookup(pParse, pTabList);
sl@0:   if( pTab==0 )  goto delete_from_cleanup;
sl@0: 
sl@0:   /* Figure out if we have any triggers and if the table being
sl@0:   ** deleted from is a view
sl@0:   */
sl@0: #ifndef SQLITE_OMIT_TRIGGER
sl@0:   triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0);
sl@0:   isView = pTab->pSelect!=0;
sl@0: #else
sl@0: # define triggers_exist 0
sl@0: # define isView 0
sl@0: #endif
sl@0: #ifdef SQLITE_OMIT_VIEW
sl@0: # undef isView
sl@0: # define isView 0
sl@0: #endif
sl@0: 
sl@0:   if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){
sl@0:     goto delete_from_cleanup;
sl@0:   }
sl@0:   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
sl@0:   assert( iDb<db->nDb );
sl@0:   zDb = db->aDb[iDb].zName;
sl@0:   if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
sl@0:     goto delete_from_cleanup;
sl@0:   }
sl@0: 
sl@0:   /* If pTab is really a view, make sure it has been initialized.
sl@0:   */
sl@0:   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
sl@0:     goto delete_from_cleanup;
sl@0:   }
sl@0: 
sl@0:   /* Allocate a cursor used to store the old.* data for a trigger.
sl@0:   */
sl@0:   if( triggers_exist ){ 
sl@0:     oldIdx = pParse->nTab++;
sl@0:   }
sl@0: 
sl@0:   /* Assign  cursor number to the table and all its indices.
sl@0:   */
sl@0:   assert( pTabList->nSrc==1 );
sl@0:   iCur = pTabList->a[0].iCursor = pParse->nTab++;
sl@0:   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
sl@0:     pParse->nTab++;
sl@0:   }
sl@0: 
sl@0:   /* Start the view context
sl@0:   */
sl@0:   if( isView ){
sl@0:     sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
sl@0:   }
sl@0: 
sl@0:   /* Begin generating code.
sl@0:   */
sl@0:   v = sqlite3GetVdbe(pParse);
sl@0:   if( v==0 ){
sl@0:     goto delete_from_cleanup;
sl@0:   }
sl@0:   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
sl@0:   sqlite3BeginWriteOperation(pParse, triggers_exist, iDb);
sl@0: 
sl@0:   if( triggers_exist ){
sl@0:     int orconf = ((pParse->trigStack)?pParse->trigStack->orconf:OE_Default);
sl@0:     int iGoto = sqlite3VdbeAddOp0(v, OP_Goto);
sl@0:     addr = sqlite3VdbeMakeLabel(v);
sl@0: 
sl@0:     iBeginBeforeTrigger = sqlite3VdbeCurrentAddr(v);
sl@0:     (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_BEFORE, pTab,
sl@0:         -1, oldIdx, orconf, addr, &old_col_mask, 0);
sl@0:     iEndBeforeTrigger = sqlite3VdbeAddOp0(v, OP_Goto);
sl@0: 
sl@0:     iBeginAfterTrigger = sqlite3VdbeCurrentAddr(v);
sl@0:     (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_AFTER, pTab, -1,
sl@0:         oldIdx, orconf, addr, &old_col_mask, 0);
sl@0:     iEndAfterTrigger = sqlite3VdbeAddOp0(v, OP_Goto);
sl@0: 
sl@0:     sqlite3VdbeJumpHere(v, iGoto);
sl@0:   }
sl@0: 
sl@0:   /* If we are trying to delete from a view, realize that view into
sl@0:   ** a ephemeral table.
sl@0:   */
sl@0: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
sl@0:   if( isView ){
sl@0:     sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   /* Resolve the column names in the WHERE clause.
sl@0:   */
sl@0:   memset(&sNC, 0, sizeof(sNC));
sl@0:   sNC.pParse = pParse;
sl@0:   sNC.pSrcList = pTabList;
sl@0:   if( sqlite3ResolveExprNames(&sNC, pWhere) ){
sl@0:     goto delete_from_cleanup;
sl@0:   }
sl@0: 
sl@0:   /* Initialize the counter of the number of rows deleted, if
sl@0:   ** we are counting rows.
sl@0:   */
sl@0:   if( db->flags & SQLITE_CountRows ){
sl@0:     memCnt = ++pParse->nMem;
sl@0:     sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
sl@0:   }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
sl@0:   /* Special case: A DELETE without a WHERE clause deletes everything.
sl@0:   ** It is easier just to erase the whole table.  Note, however, that
sl@0:   ** this means that the row change count will be incorrect.
sl@0:   */
sl@0:   if( pWhere==0 && !triggers_exist && !IsVirtual(pTab) ){
sl@0:     if( db->flags & SQLITE_CountRows ){
sl@0:       /* If counting rows deleted, just count the total number of
sl@0:       ** entries in the table. */
sl@0:       int addr2;
sl@0:       if( !isView ){
sl@0:         sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
sl@0:       }
sl@0:       sqlite3VdbeAddOp2(v, OP_Rewind, iCur, sqlite3VdbeCurrentAddr(v)+2);
sl@0:       addr2 = sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
sl@0:       sqlite3VdbeAddOp2(v, OP_Next, iCur, addr2);
sl@0:       sqlite3VdbeAddOp1(v, OP_Close, iCur);
sl@0:     }
sl@0:     if( !isView ){
sl@0:       sqlite3VdbeAddOp2(v, OP_Clear, pTab->tnum, iDb);
sl@0:       if( !pParse->nested ){
sl@0:         sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
sl@0:       }
sl@0:       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
sl@0:         assert( pIdx->pSchema==pTab->pSchema );
sl@0:         sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
sl@0:       }
sl@0:     }
sl@0:   }else
sl@0: #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
sl@0:   /* The usual case: There is a WHERE clause so we have to scan through
sl@0:   ** the table and pick which records to delete.
sl@0:   */
sl@0:   {
sl@0:     int iRowid = ++pParse->nMem;    /* Used for storing rowid values. */
sl@0: 
sl@0:     /* Begin the database scan
sl@0:     */
sl@0:     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0);
sl@0:     if( pWInfo==0 ) goto delete_from_cleanup;
sl@0: 
sl@0:     /* Remember the rowid of every item to be deleted.
sl@0:     */
sl@0:     sqlite3VdbeAddOp2(v, IsVirtual(pTab) ? OP_VRowid : OP_Rowid, iCur, iRowid);
sl@0:     sqlite3VdbeAddOp1(v, OP_FifoWrite, iRowid);
sl@0:     if( db->flags & SQLITE_CountRows ){
sl@0:       sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
sl@0:     }
sl@0: 
sl@0:     /* End the database scan loop.
sl@0:     */
sl@0:     sqlite3WhereEnd(pWInfo);
sl@0: 
sl@0:     /* Open the pseudo-table used to store OLD if there are triggers.
sl@0:     */
sl@0:     if( triggers_exist ){
sl@0:       sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pTab->nCol);
sl@0:       sqlite3VdbeAddOp1(v, OP_OpenPseudo, oldIdx);
sl@0:     }
sl@0: 
sl@0:     /* Delete every item whose key was written to the list during the
sl@0:     ** database scan.  We have to delete items after the scan is complete
sl@0:     ** because deleting an item can change the scan order.
sl@0:     */
sl@0:     end = sqlite3VdbeMakeLabel(v);
sl@0: 
sl@0:     if( !isView ){
sl@0:       /* Open cursors for the table we are deleting from and 
sl@0:       ** all its indices.
sl@0:       */
sl@0:       sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
sl@0:     }
sl@0: 
sl@0:     /* This is the beginning of the delete loop. If a trigger encounters
sl@0:     ** an IGNORE constraint, it jumps back to here.
sl@0:     */
sl@0:     if( triggers_exist ){
sl@0:       sqlite3VdbeResolveLabel(v, addr);
sl@0:     }
sl@0:     addr = sqlite3VdbeAddOp2(v, OP_FifoRead, iRowid, end);
sl@0: 
sl@0:     if( triggers_exist ){
sl@0:       int iData = ++pParse->nMem;   /* For storing row data of OLD table */
sl@0: 
sl@0:       /* If the record is no longer present in the table, jump to the
sl@0:       ** next iteration of the loop through the contents of the fifo.
sl@0:       */
sl@0:       sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, iRowid);
sl@0: 
sl@0:       /* Populate the OLD.* pseudo-table */
sl@0:       if( old_col_mask ){
sl@0:         sqlite3VdbeAddOp2(v, OP_RowData, iCur, iData);
sl@0:       }else{
sl@0:         sqlite3VdbeAddOp2(v, OP_Null, 0, iData);
sl@0:       }
sl@0:       sqlite3VdbeAddOp3(v, OP_Insert, oldIdx, iData, iRowid);
sl@0: 
sl@0:       /* Jump back and run the BEFORE triggers */
sl@0:       sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginBeforeTrigger);
sl@0:       sqlite3VdbeJumpHere(v, iEndBeforeTrigger);
sl@0:     }
sl@0: 
sl@0:     if( !isView ){
sl@0:       /* Delete the row */
sl@0: #ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0:       if( IsVirtual(pTab) ){
sl@0:         const char *pVtab = (const char *)pTab->pVtab;
sl@0:         sqlite3VtabMakeWritable(pParse, pTab);
sl@0:         sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVtab, P4_VTAB);
sl@0:       }else
sl@0: #endif
sl@0:       {
sl@0:         sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, pParse->nested==0);
sl@0:       }
sl@0:     }
sl@0: 
sl@0:     /* If there are row triggers, close all cursors then invoke
sl@0:     ** the AFTER triggers
sl@0:     */
sl@0:     if( triggers_exist ){
sl@0:       /* Jump back and run the AFTER triggers */
sl@0:       sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginAfterTrigger);
sl@0:       sqlite3VdbeJumpHere(v, iEndAfterTrigger);
sl@0:     }
sl@0: 
sl@0:     /* End of the delete loop */
sl@0:     sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
sl@0:     sqlite3VdbeResolveLabel(v, end);
sl@0: 
sl@0:     /* Close the cursors after the loop if there are no row triggers */
sl@0:     if( !isView  && !IsVirtual(pTab) ){
sl@0:       for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
sl@0:         sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
sl@0:       }
sl@0:       sqlite3VdbeAddOp1(v, OP_Close, iCur);
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /*
sl@0:   ** Return the number of rows that were deleted. If this routine is 
sl@0:   ** generating code because of a call to sqlite3NestedParse(), do not
sl@0:   ** invoke the callback function.
sl@0:   */
sl@0:   if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){
sl@0:     sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
sl@0:     sqlite3VdbeSetNumCols(v, 1);
sl@0:     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", P4_STATIC);
sl@0:   }
sl@0: 
sl@0: delete_from_cleanup:
sl@0:   sqlite3AuthContextPop(&sContext);
sl@0:   sqlite3SrcListDelete(db, pTabList);
sl@0:   sqlite3ExprDelete(db, pWhere);
sl@0:   return;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This routine generates VDBE code that causes a single row of a
sl@0: ** single table to be deleted.
sl@0: **
sl@0: ** The VDBE must be in a particular state when this routine is called.
sl@0: ** These are the requirements:
sl@0: **
sl@0: **   1.  A read/write cursor pointing to pTab, the table containing the row
sl@0: **       to be deleted, must be opened as cursor number "base".
sl@0: **
sl@0: **   2.  Read/write cursors for all indices of pTab must be open as
sl@0: **       cursor number base+i for the i-th index.
sl@0: **
sl@0: **   3.  The record number of the row to be deleted must be stored in
sl@0: **       memory cell iRowid.
sl@0: **
sl@0: ** This routine pops the top of the stack to remove the record number
sl@0: ** and then generates code to remove both the table record and all index
sl@0: ** entries that point to that record.
sl@0: */
sl@0: void sqlite3GenerateRowDelete(
sl@0:   Parse *pParse,     /* Parsing context */
sl@0:   Table *pTab,       /* Table containing the row to be deleted */
sl@0:   int iCur,          /* Cursor number for the table */
sl@0:   int iRowid,        /* Memory cell that contains the rowid to delete */
sl@0:   int count          /* Increment the row change counter */
sl@0: ){
sl@0:   int addr;
sl@0:   Vdbe *v;
sl@0: 
sl@0:   v = pParse->pVdbe;
sl@0:   addr = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowid);
sl@0:   sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
sl@0:   sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
sl@0:   if( count ){
sl@0:     sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
sl@0:   }
sl@0:   sqlite3VdbeJumpHere(v, addr);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This routine generates VDBE code that causes the deletion of all
sl@0: ** index entries associated with a single row of a single table.
sl@0: **
sl@0: ** The VDBE must be in a particular state when this routine is called.
sl@0: ** These are the requirements:
sl@0: **
sl@0: **   1.  A read/write cursor pointing to pTab, the table containing the row
sl@0: **       to be deleted, must be opened as cursor number "iCur".
sl@0: **
sl@0: **   2.  Read/write cursors for all indices of pTab must be open as
sl@0: **       cursor number iCur+i for the i-th index.
sl@0: **
sl@0: **   3.  The "iCur" cursor must be pointing to the row that is to be
sl@0: **       deleted.
sl@0: */
sl@0: void sqlite3GenerateRowIndexDelete(
sl@0:   Parse *pParse,     /* Parsing and code generating context */
sl@0:   Table *pTab,       /* Table containing the row to be deleted */
sl@0:   int iCur,          /* Cursor number for the table */
sl@0:   int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
sl@0: ){
sl@0:   int i;
sl@0:   Index *pIdx;
sl@0:   int r1;
sl@0: 
sl@0:   for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
sl@0:     if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
sl@0:     r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0);
sl@0:     sqlite3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Generate code that will assemble an index key and put it in register
sl@0: ** regOut.  The key with be for index pIdx which is an index on pTab.
sl@0: ** iCur is the index of a cursor open on the pTab table and pointing to
sl@0: ** the entry that needs indexing.
sl@0: **
sl@0: ** Return a register number which is the first in a block of
sl@0: ** registers that holds the elements of the index key.  The
sl@0: ** block of registers has already been deallocated by the time
sl@0: ** this routine returns.
sl@0: */
sl@0: int sqlite3GenerateIndexKey(
sl@0:   Parse *pParse,     /* Parsing context */
sl@0:   Index *pIdx,       /* The index for which to generate a key */
sl@0:   int iCur,          /* Cursor number for the pIdx->pTable table */
sl@0:   int regOut,        /* Write the new index key to this register */
sl@0:   int doMakeRec      /* Run the OP_MakeRecord instruction if true */
sl@0: ){
sl@0:   Vdbe *v = pParse->pVdbe;
sl@0:   int j;
sl@0:   Table *pTab = pIdx->pTable;
sl@0:   int regBase;
sl@0:   int nCol;
sl@0: 
sl@0:   nCol = pIdx->nColumn;
sl@0:   regBase = sqlite3GetTempRange(pParse, nCol+1);
sl@0:   sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
sl@0:   for(j=0; j<nCol; j++){
sl@0:     int idx = pIdx->aiColumn[j];
sl@0:     if( idx==pTab->iPKey ){
sl@0:       sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
sl@0:     }else{
sl@0:       sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
sl@0:       sqlite3ColumnDefault(v, pTab, idx);
sl@0:     }
sl@0:   }
sl@0:   if( doMakeRec ){
sl@0:     sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
sl@0:     sqlite3IndexAffinityStr(v, pIdx);
sl@0:     sqlite3ExprCacheAffinityChange(pParse, regBase, nCol+1);
sl@0:   }
sl@0:   sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
sl@0:   return regBase;
sl@0: }
sl@0: 
sl@0: /* Make sure "isView" gets undefined in case this file becomes part of
sl@0: ** the amalgamation - so that subsequent files do not see isView as a
sl@0: ** macro. */
sl@0: #undef isView