| /* |
| ** 2001 September 15 |
| ** |
| ** The author disclaims copyright to this source code. In place of |
| ** a legal notice, here is a blessing: |
| ** |
| ** May you do good and not evil. |
| ** May you find forgiveness for yourself and forgive others. |
| ** May you share freely, never taking more than you give. |
| ** |
| ************************************************************************* |
| ** This file contains C code routines that are called by the parser |
| ** in order to generate code for DELETE FROM statements. |
| */ |
| #include "sqliteInt.h" |
| |
| /* |
| ** While a SrcList can in general represent multiple tables and subqueries |
| ** (as in the FROM clause of a SELECT statement) in this case it contains |
| ** the name of a single table, as one might find in an INSERT, DELETE, |
| ** or UPDATE statement. Look up that table in the symbol table and |
| ** return a pointer. Set an error message and return NULL if the table |
| ** name is not found or if any other error occurs. |
| ** |
| ** The following fields are initialized appropriate in pSrc: |
| ** |
| ** pSrc->a[0].pTab Pointer to the Table object |
| ** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one |
| ** |
| */ |
| Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ |
| struct SrcList_item *pItem = pSrc->a; |
| Table *pTab; |
| assert( pItem && pSrc->nSrc==1 ); |
| pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase); |
| sqlite3DeleteTable(pParse->db, pItem->pTab); |
| pItem->pTab = pTab; |
| if( pTab ){ |
| pTab->nRef++; |
| } |
| if( sqlite3IndexedByLookup(pParse, pItem) ){ |
| pTab = 0; |
| } |
| return pTab; |
| } |
| |
| /* |
| ** Check to make sure the given table is writable. If it is not |
| ** writable, generate an error message and return 1. If it is |
| ** writable return 0; |
| */ |
| int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ |
| /* A table is not writable under the following circumstances: |
| ** |
| ** 1) It is a virtual table and no implementation of the xUpdate method |
| ** has been provided, or |
| ** 2) It is a system table (i.e. sqlite_master), this call is not |
| ** part of a nested parse and writable_schema pragma has not |
| ** been specified. |
| ** |
| ** In either case leave an error message in pParse and return non-zero. |
| */ |
| if( ( IsVirtual(pTab) |
| && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ) |
| || ( (pTab->tabFlags & TF_Readonly)!=0 |
| && (pParse->db->flags & SQLITE_WriteSchema)==0 |
| && pParse->nested==0 ) |
| ){ |
| sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); |
| return 1; |
| } |
| |
| #ifndef SQLITE_OMIT_VIEW |
| if( !viewOk && pTab->pSelect ){ |
| sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); |
| return 1; |
| } |
| #endif |
| return 0; |
| } |
| |
| |
| #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) |
| /* |
| ** Evaluate a view and store its result in an ephemeral table. The |
| ** pWhere argument is an optional WHERE clause that restricts the |
| ** set of rows in the view that are to be added to the ephemeral table. |
| */ |
| void sqlite3MaterializeView( |
| Parse *pParse, /* Parsing context */ |
| Table *pView, /* View definition */ |
| Expr *pWhere, /* Optional WHERE clause to be added */ |
| int iCur /* Cursor number for ephemerial table */ |
| ){ |
| SelectDest dest; |
| Select *pDup; |
| sqlite3 *db = pParse->db; |
| |
| pDup = sqlite3SelectDup(db, pView->pSelect, 0); |
| if( pWhere ){ |
| SrcList *pFrom; |
| |
| pWhere = sqlite3ExprDup(db, pWhere, 0); |
| pFrom = sqlite3SrcListAppend(db, 0, 0, 0); |
| if( pFrom ){ |
| assert( pFrom->nSrc==1 ); |
| pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName); |
| pFrom->a[0].pSelect = pDup; |
| assert( pFrom->a[0].pOn==0 ); |
| assert( pFrom->a[0].pUsing==0 ); |
| }else{ |
| sqlite3SelectDelete(db, pDup); |
| } |
| pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0); |
| } |
| sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur); |
| sqlite3Select(pParse, pDup, &dest); |
| sqlite3SelectDelete(db, pDup); |
| } |
| #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */ |
| |
| #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) |
| /* |
| ** Generate an expression tree to implement the WHERE, ORDER BY, |
| ** and LIMIT/OFFSET portion of DELETE and UPDATE statements. |
| ** |
| ** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1; |
| ** \__________________________/ |
| ** pLimitWhere (pInClause) |
| */ |
| Expr *sqlite3LimitWhere( |
| Parse *pParse, /* The parser context */ |
| SrcList *pSrc, /* the FROM clause -- which tables to scan */ |
| Expr *pWhere, /* The WHERE clause. May be null */ |
| ExprList *pOrderBy, /* The ORDER BY clause. May be null */ |
| Expr *pLimit, /* The LIMIT clause. May be null */ |
| Expr *pOffset, /* The OFFSET clause. May be null */ |
| char *zStmtType /* Either DELETE or UPDATE. For error messages. */ |
| ){ |
| Expr *pWhereRowid = NULL; /* WHERE rowid .. */ |
| Expr *pInClause = NULL; /* WHERE rowid IN ( select ) */ |
| Expr *pSelectRowid = NULL; /* SELECT rowid ... */ |
| ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */ |
| SrcList *pSelectSrc = NULL; /* SELECT rowid FROM x ... (dup of pSrc) */ |
| Select *pSelect = NULL; /* Complete SELECT tree */ |
| |
| /* Check that there isn't an ORDER BY without a LIMIT clause. |
| */ |
| if( pOrderBy && (pLimit == 0) ) { |
| sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType); |
| pParse->parseError = 1; |
| goto limit_where_cleanup_2; |
| } |
| |
| /* We only need to generate a select expression if there |
| ** is a limit/offset term to enforce. |
| */ |
| if( pLimit == 0 ) { |
| /* if pLimit is null, pOffset will always be null as well. */ |
| assert( pOffset == 0 ); |
| return pWhere; |
| } |
| |
| /* Generate a select expression tree to enforce the limit/offset |
| ** term for the DELETE or UPDATE statement. For example: |
| ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 |
| ** becomes: |
| ** DELETE FROM table_a WHERE rowid IN ( |
| ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 |
| ** ); |
| */ |
| |
| pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0); |
| if( pSelectRowid == 0 ) goto limit_where_cleanup_2; |
| pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid); |
| if( pEList == 0 ) goto limit_where_cleanup_2; |
| |
| /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree |
| ** and the SELECT subtree. */ |
| pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0); |
| if( pSelectSrc == 0 ) { |
| sqlite3ExprListDelete(pParse->db, pEList); |
| goto limit_where_cleanup_2; |
| } |
| |
| /* generate the SELECT expression tree. */ |
| pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0, |
| pOrderBy,0,pLimit,pOffset); |
| if( pSelect == 0 ) return 0; |
| |
| /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */ |
| pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0); |
| if( pWhereRowid == 0 ) goto limit_where_cleanup_1; |
| pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0); |
| if( pInClause == 0 ) goto limit_where_cleanup_1; |
| |
| pInClause->x.pSelect = pSelect; |
| pInClause->flags |= EP_xIsSelect; |
| sqlite3ExprSetHeight(pParse, pInClause); |
| return pInClause; |
| |
| /* something went wrong. clean up anything allocated. */ |
| limit_where_cleanup_1: |
| sqlite3SelectDelete(pParse->db, pSelect); |
| return 0; |
| |
| limit_where_cleanup_2: |
| sqlite3ExprDelete(pParse->db, pWhere); |
| sqlite3ExprListDelete(pParse->db, pOrderBy); |
| sqlite3ExprDelete(pParse->db, pLimit); |
| sqlite3ExprDelete(pParse->db, pOffset); |
| return 0; |
| } |
| #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */ |
| |
| /* |
| ** Generate code for a DELETE FROM statement. |
| ** |
| ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; |
| ** \________/ \________________/ |
| ** pTabList pWhere |
| */ |
| void sqlite3DeleteFrom( |
| Parse *pParse, /* The parser context */ |
| SrcList *pTabList, /* The table from which we should delete things */ |
| Expr *pWhere /* The WHERE clause. May be null */ |
| ){ |
| Vdbe *v; /* The virtual database engine */ |
| Table *pTab; /* The table from which records will be deleted */ |
| const char *zDb; /* Name of database holding pTab */ |
| int end, addr = 0; /* A couple addresses of generated code */ |
| int i; /* Loop counter */ |
| WhereInfo *pWInfo; /* Information about the WHERE clause */ |
| Index *pIdx; /* For looping over indices of the table */ |
| int iCur; /* VDBE Cursor number for pTab */ |
| sqlite3 *db; /* Main database structure */ |
| AuthContext sContext; /* Authorization context */ |
| NameContext sNC; /* Name context to resolve expressions in */ |
| int iDb; /* Database number */ |
| int memCnt = -1; /* Memory cell used for change counting */ |
| int rcauth; /* Value returned by authorization callback */ |
| |
| #ifndef SQLITE_OMIT_TRIGGER |
| int isView; /* True if attempting to delete from a view */ |
| Trigger *pTrigger; /* List of table triggers, if required */ |
| #endif |
| |
| memset(&sContext, 0, sizeof(sContext)); |
| db = pParse->db; |
| if( pParse->nErr || db->mallocFailed ){ |
| goto delete_from_cleanup; |
| } |
| assert( pTabList->nSrc==1 ); |
| |
| /* Locate the table which we want to delete. This table has to be |
| ** put in an SrcList structure because some of the subroutines we |
| ** will be calling are designed to work with multiple tables and expect |
| ** an SrcList* parameter instead of just a Table* parameter. |
| */ |
| pTab = sqlite3SrcListLookup(pParse, pTabList); |
| if( pTab==0 ) goto delete_from_cleanup; |
| |
| /* Figure out if we have any triggers and if the table being |
| ** deleted from is a view |
| */ |
| #ifndef SQLITE_OMIT_TRIGGER |
| pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); |
| isView = pTab->pSelect!=0; |
| #else |
| # define pTrigger 0 |
| # define isView 0 |
| #endif |
| #ifdef SQLITE_OMIT_VIEW |
| # undef isView |
| # define isView 0 |
| #endif |
| |
| /* If pTab is really a view, make sure it has been initialized. |
| */ |
| if( sqlite3ViewGetColumnNames(pParse, pTab) ){ |
| goto delete_from_cleanup; |
| } |
| |
| if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){ |
| goto delete_from_cleanup; |
| } |
| iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
| assert( iDb<db->nDb ); |
| zDb = db->aDb[iDb].zName; |
| rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb); |
| assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE ); |
| if( rcauth==SQLITE_DENY ){ |
| goto delete_from_cleanup; |
| } |
| assert(!isView || pTrigger); |
| |
| /* Assign cursor number to the table and all its indices. |
| */ |
| assert( pTabList->nSrc==1 ); |
| iCur = pTabList->a[0].iCursor = pParse->nTab++; |
| for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
| pParse->nTab++; |
| } |
| |
| /* Start the view context |
| */ |
| if( isView ){ |
| sqlite3AuthContextPush(pParse, &sContext, pTab->zName); |
| } |
| |
| /* Begin generating code. |
| */ |
| v = sqlite3GetVdbe(pParse); |
| if( v==0 ){ |
| goto delete_from_cleanup; |
| } |
| if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); |
| sqlite3BeginWriteOperation(pParse, 1, iDb); |
| |
| /* If we are trying to delete from a view, realize that view into |
| ** a ephemeral table. |
| */ |
| #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) |
| if( isView ){ |
| sqlite3MaterializeView(pParse, pTab, pWhere, iCur); |
| } |
| #endif |
| |
| /* Resolve the column names in the WHERE clause. |
| */ |
| memset(&sNC, 0, sizeof(sNC)); |
| sNC.pParse = pParse; |
| sNC.pSrcList = pTabList; |
| if( sqlite3ResolveExprNames(&sNC, pWhere) ){ |
| goto delete_from_cleanup; |
| } |
| |
| /* Initialize the counter of the number of rows deleted, if |
| ** we are counting rows. |
| */ |
| if( db->flags & SQLITE_CountRows ){ |
| memCnt = ++pParse->nMem; |
| sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt); |
| } |
| |
| #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION |
| /* Special case: A DELETE without a WHERE clause deletes everything. |
| ** It is easier just to erase the whole table. Prior to version 3.6.5, |
| ** this optimization caused the row change count (the value returned by |
| ** API function sqlite3_count_changes) to be set incorrectly. */ |
| if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab) |
| && 0==sqlite3FkRequired(pParse, pTab, 0, 0) |
| ){ |
| assert( !isView ); |
| sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt, |
| pTab->zName, P4_STATIC); |
| for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
| assert( pIdx->pSchema==pTab->pSchema ); |
| sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb); |
| } |
| }else |
| #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */ |
| /* The usual case: There is a WHERE clause so we have to scan through |
| ** the table and pick which records to delete. |
| */ |
| { |
| int iRowSet = ++pParse->nMem; /* Register for rowset of rows to delete */ |
| int iRowid = ++pParse->nMem; /* Used for storing rowid values. */ |
| int regRowid; /* Actual register containing rowids */ |
| |
| /* Collect rowids of every row to be deleted. |
| */ |
| sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet); |
| pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,WHERE_DUPLICATES_OK); |
| if( pWInfo==0 ) goto delete_from_cleanup; |
| regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid); |
| sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid); |
| if( db->flags & SQLITE_CountRows ){ |
| sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1); |
| } |
| sqlite3WhereEnd(pWInfo); |
| |
| /* Delete every item whose key was written to the list during the |
| ** database scan. We have to delete items after the scan is complete |
| ** because deleting an item can change the scan order. */ |
| end = sqlite3VdbeMakeLabel(v); |
| |
| /* Unless this is a view, open cursors for the table we are |
| ** deleting from and all its indices. If this is a view, then the |
| ** only effect this statement has is to fire the INSTEAD OF |
| ** triggers. */ |
| if( !isView ){ |
| sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite); |
| } |
| |
| addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid); |
| |
| /* Delete the row */ |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| if( IsVirtual(pTab) ){ |
| const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); |
| sqlite3VtabMakeWritable(pParse, pTab); |
| sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB); |
| sqlite3MayAbort(pParse); |
| }else |
| #endif |
| { |
| int count = (pParse->nested==0); /* True to count changes */ |
| sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default); |
| } |
| |
| /* End of the delete loop */ |
| sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); |
| sqlite3VdbeResolveLabel(v, end); |
| |
| /* Close the cursors open on the table and its indexes. */ |
| if( !isView && !IsVirtual(pTab) ){ |
| for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ |
| sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum); |
| } |
| sqlite3VdbeAddOp1(v, OP_Close, iCur); |
| } |
| } |
| |
| /* Update the sqlite_sequence table by storing the content of the |
| ** maximum rowid counter values recorded while inserting into |
| ** autoincrement tables. |
| */ |
| if( pParse->nested==0 && pParse->pTriggerTab==0 ){ |
| sqlite3AutoincrementEnd(pParse); |
| } |
| |
| /* Return the number of rows that were deleted. If this routine is |
| ** generating code because of a call to sqlite3NestedParse(), do not |
| ** invoke the callback function. |
| */ |
| if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){ |
| sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1); |
| sqlite3VdbeSetNumCols(v, 1); |
| sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC); |
| } |
| |
| delete_from_cleanup: |
| sqlite3AuthContextPop(&sContext); |
| sqlite3SrcListDelete(db, pTabList); |
| sqlite3ExprDelete(db, pWhere); |
| return; |
| } |
| /* Make sure "isView" and other macros defined above are undefined. Otherwise |
| ** thely may interfere with compilation of other functions in this file |
| ** (or in another file, if this file becomes part of the amalgamation). */ |
| #ifdef isView |
| #undef isView |
| #endif |
| #ifdef pTrigger |
| #undef pTrigger |
| #endif |
| |
| /* |
| ** This routine generates VDBE code that causes a single row of a |
| ** single table to be deleted. |
| ** |
| ** The VDBE must be in a particular state when this routine is called. |
| ** These are the requirements: |
| ** |
| ** 1. A read/write cursor pointing to pTab, the table containing the row |
| ** to be deleted, must be opened as cursor number $iCur. |
| ** |
| ** 2. Read/write cursors for all indices of pTab must be open as |
| ** cursor number base+i for the i-th index. |
| ** |
| ** 3. The record number of the row to be deleted must be stored in |
| ** memory cell iRowid. |
| ** |
| ** This routine generates code to remove both the table record and all |
| ** index entries that point to that record. |
| */ |
| void sqlite3GenerateRowDelete( |
| Parse *pParse, /* Parsing context */ |
| Table *pTab, /* Table containing the row to be deleted */ |
| int iCur, /* Cursor number for the table */ |
| int iRowid, /* Memory cell that contains the rowid to delete */ |
| int count, /* If non-zero, increment the row change counter */ |
| Trigger *pTrigger, /* List of triggers to (potentially) fire */ |
| int onconf /* Default ON CONFLICT policy for triggers */ |
| ){ |
| Vdbe *v = pParse->pVdbe; /* Vdbe */ |
| int iOld = 0; /* First register in OLD.* array */ |
| int iLabel; /* Label resolved to end of generated code */ |
| |
| /* Vdbe is guaranteed to have been allocated by this stage. */ |
| assert( v ); |
| |
| /* Seek cursor iCur to the row to delete. If this row no longer exists |
| ** (this can happen if a trigger program has already deleted it), do |
| ** not attempt to delete it or fire any DELETE triggers. */ |
| iLabel = sqlite3VdbeMakeLabel(v); |
| sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid); |
| |
| /* If there are any triggers to fire, allocate a range of registers to |
| ** use for the old.* references in the triggers. */ |
| if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){ |
| u32 mask; /* Mask of OLD.* columns in use */ |
| int iCol; /* Iterator used while populating OLD.* */ |
| |
| /* TODO: Could use temporary registers here. Also could attempt to |
| ** avoid copying the contents of the rowid register. */ |
| mask = sqlite3TriggerColmask( |
| pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf |
| ); |
| mask |= sqlite3FkOldmask(pParse, pTab); |
| iOld = pParse->nMem+1; |
| pParse->nMem += (1 + pTab->nCol); |
| |
| /* Populate the OLD.* pseudo-table register array. These values will be |
| ** used by any BEFORE and AFTER triggers that exist. */ |
| sqlite3VdbeAddOp2(v, OP_Copy, iRowid, iOld); |
| for(iCol=0; iCol<pTab->nCol; iCol++){ |
| if( mask==0xffffffff || mask&(1<<iCol) ){ |
| sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1); |
| } |
| } |
| |
| /* Invoke BEFORE DELETE trigger programs. */ |
| sqlite3CodeRowTrigger(pParse, pTrigger, |
| TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel |
| ); |
| |
| /* Seek the cursor to the row to be deleted again. It may be that |
| ** the BEFORE triggers coded above have already removed the row |
| ** being deleted. Do not attempt to delete the row a second time, and |
| ** do not fire AFTER triggers. */ |
| sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid); |
| |
| /* Do FK processing. This call checks that any FK constraints that |
| ** refer to this table (i.e. constraints attached to other tables) |
| ** are not violated by deleting this row. */ |
| sqlite3FkCheck(pParse, pTab, iOld, 0); |
| } |
| |
| /* Delete the index and table entries. Skip this step if pTab is really |
| ** a view (in which case the only effect of the DELETE statement is to |
| ** fire the INSTEAD OF triggers). */ |
| if( pTab->pSelect==0 ){ |
| sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0); |
| sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0)); |
| if( count ){ |
| sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT); |
| } |
| } |
| |
| /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to |
| ** handle rows (possibly in other tables) that refer via a foreign key |
| ** to the row just deleted. */ |
| sqlite3FkActions(pParse, pTab, 0, iOld); |
| |
| /* Invoke AFTER DELETE trigger programs. */ |
| sqlite3CodeRowTrigger(pParse, pTrigger, |
| TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel |
| ); |
| |
| /* Jump here if the row had already been deleted before any BEFORE |
| ** trigger programs were invoked. Or if a trigger program throws a |
| ** RAISE(IGNORE) exception. */ |
| sqlite3VdbeResolveLabel(v, iLabel); |
| } |
| |
| /* |
| ** This routine generates VDBE code that causes the deletion of all |
| ** index entries associated with a single row of a single table. |
| ** |
| ** The VDBE must be in a particular state when this routine is called. |
| ** These are the requirements: |
| ** |
| ** 1. A read/write cursor pointing to pTab, the table containing the row |
| ** to be deleted, must be opened as cursor number "iCur". |
| ** |
| ** 2. Read/write cursors for all indices of pTab must be open as |
| ** cursor number iCur+i for the i-th index. |
| ** |
| ** 3. The "iCur" cursor must be pointing to the row that is to be |
| ** deleted. |
| */ |
| void sqlite3GenerateRowIndexDelete( |
| Parse *pParse, /* Parsing and code generating context */ |
| Table *pTab, /* Table containing the row to be deleted */ |
| int iCur, /* Cursor number for the table */ |
| int *aRegIdx /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */ |
| ){ |
| int i; |
| Index *pIdx; |
| int r1; |
| |
| for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ |
| if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue; |
| r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0); |
| sqlite3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1); |
| } |
| } |
| |
| /* |
| ** Generate code that will assemble an index key and put it in register |
| ** regOut. The key with be for index pIdx which is an index on pTab. |
| ** iCur is the index of a cursor open on the pTab table and pointing to |
| ** the entry that needs indexing. |
| ** |
| ** Return a register number which is the first in a block of |
| ** registers that holds the elements of the index key. The |
| ** block of registers has already been deallocated by the time |
| ** this routine returns. |
| */ |
| int sqlite3GenerateIndexKey( |
| Parse *pParse, /* Parsing context */ |
| Index *pIdx, /* The index for which to generate a key */ |
| int iCur, /* Cursor number for the pIdx->pTable table */ |
| int regOut, /* Write the new index key to this register */ |
| int doMakeRec /* Run the OP_MakeRecord instruction if true */ |
| ){ |
| Vdbe *v = pParse->pVdbe; |
| int j; |
| Table *pTab = pIdx->pTable; |
| int regBase; |
| int nCol; |
| |
| nCol = pIdx->nColumn; |
| regBase = sqlite3GetTempRange(pParse, nCol+1); |
| sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol); |
| for(j=0; j<nCol; j++){ |
| int idx = pIdx->aiColumn[j]; |
| if( idx==pTab->iPKey ){ |
| sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j); |
| }else{ |
| sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j); |
| sqlite3ColumnDefault(v, pTab, idx, -1); |
| } |
| } |
| if( doMakeRec ){ |
| sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut); |
| sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), P4_TRANSIENT); |
| } |
| sqlite3ReleaseTempRange(pParse, regBase, nCol+1); |
| return regBase; |
| } |