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