| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2001 September 15 | |
| 3 ** | |
| 4 ** The author disclaims copyright to this source code. In place of | |
| 5 ** a legal notice, here is a blessing: | |
| 6 ** | |
| 7 ** May you do good and not evil. | |
| 8 ** May you find forgiveness for yourself and forgive others. | |
| 9 ** May you share freely, never taking more than you give. | |
| 10 ** | |
| 11 ************************************************************************* | |
| 12 ** This file contains C code routines that are called by the parser | |
| 13 ** in order to generate code for DELETE FROM statements. | |
| 14 */ | |
| 15 #include "sqliteInt.h" | |
| 16 | |
| 17 /* | |
| 18 ** While a SrcList can in general represent multiple tables and subqueries | |
| 19 ** (as in the FROM clause of a SELECT statement) in this case it contains | |
| 20 ** the name of a single table, as one might find in an INSERT, DELETE, | |
| 21 ** or UPDATE statement. Look up that table in the symbol table and | |
| 22 ** return a pointer. Set an error message and return NULL if the table | |
| 23 ** name is not found or if any other error occurs. | |
| 24 ** | |
| 25 ** The following fields are initialized appropriate in pSrc: | |
| 26 ** | |
| 27 ** pSrc->a[0].pTab Pointer to the Table object | |
| 28 ** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one | |
| 29 ** | |
| 30 */ | |
| 31 Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ | |
| 32 struct SrcList_item *pItem = pSrc->a; | |
| 33 Table *pTab; | |
| 34 assert( pItem && pSrc->nSrc==1 ); | |
| 35 pTab = sqlite3LocateTableItem(pParse, 0, pItem); | |
| 36 sqlite3DeleteTable(pParse->db, pItem->pTab); | |
| 37 pItem->pTab = pTab; | |
| 38 if( pTab ){ | |
| 39 pTab->nRef++; | |
| 40 } | |
| 41 if( sqlite3IndexedByLookup(pParse, pItem) ){ | |
| 42 pTab = 0; | |
| 43 } | |
| 44 return pTab; | |
| 45 } | |
| 46 | |
| 47 /* | |
| 48 ** Check to make sure the given table is writable. If it is not | |
| 49 ** writable, generate an error message and return 1. If it is | |
| 50 ** writable return 0; | |
| 51 */ | |
| 52 int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ | |
| 53 /* A table is not writable under the following circumstances: | |
| 54 ** | |
| 55 ** 1) It is a virtual table and no implementation of the xUpdate method | |
| 56 ** has been provided, or | |
| 57 ** 2) It is a system table (i.e. sqlite_master), this call is not | |
| 58 ** part of a nested parse and writable_schema pragma has not | |
| 59 ** been specified. | |
| 60 ** | |
| 61 ** In either case leave an error message in pParse and return non-zero. | |
| 62 */ | |
| 63 if( ( IsVirtual(pTab) | |
| 64 && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ) | |
| 65 || ( (pTab->tabFlags & TF_Readonly)!=0 | |
| 66 && (pParse->db->flags & SQLITE_WriteSchema)==0 | |
| 67 && pParse->nested==0 ) | |
| 68 ){ | |
| 69 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); | |
| 70 return 1; | |
| 71 } | |
| 72 | |
| 73 #ifndef SQLITE_OMIT_VIEW | |
| 74 if( !viewOk && pTab->pSelect ){ | |
| 75 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); | |
| 76 return 1; | |
| 77 } | |
| 78 #endif | |
| 79 return 0; | |
| 80 } | |
| 81 | |
| 82 | |
| 83 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) | |
| 84 /* | |
| 85 ** Evaluate a view and store its result in an ephemeral table. The | |
| 86 ** pWhere argument is an optional WHERE clause that restricts the | |
| 87 ** set of rows in the view that are to be added to the ephemeral table. | |
| 88 */ | |
| 89 void sqlite3MaterializeView( | |
| 90 Parse *pParse, /* Parsing context */ | |
| 91 Table *pView, /* View definition */ | |
| 92 Expr *pWhere, /* Optional WHERE clause to be added */ | |
| 93 int iCur /* Cursor number for ephemeral table */ | |
| 94 ){ | |
| 95 SelectDest dest; | |
| 96 Select *pSel; | |
| 97 SrcList *pFrom; | |
| 98 sqlite3 *db = pParse->db; | |
| 99 int iDb = sqlite3SchemaToIndex(db, pView->pSchema); | |
| 100 pWhere = sqlite3ExprDup(db, pWhere, 0); | |
| 101 pFrom = sqlite3SrcListAppend(db, 0, 0, 0); | |
| 102 if( pFrom ){ | |
| 103 assert( pFrom->nSrc==1 ); | |
| 104 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName); | |
| 105 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName); | |
| 106 assert( pFrom->a[0].pOn==0 ); | |
| 107 assert( pFrom->a[0].pUsing==0 ); | |
| 108 } | |
| 109 pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0); | |
| 110 sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur); | |
| 111 sqlite3Select(pParse, pSel, &dest); | |
| 112 sqlite3SelectDelete(db, pSel); | |
| 113 } | |
| 114 #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */ | |
| 115 | |
| 116 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) | |
| 117 /* | |
| 118 ** Generate an expression tree to implement the WHERE, ORDER BY, | |
| 119 ** and LIMIT/OFFSET portion of DELETE and UPDATE statements. | |
| 120 ** | |
| 121 ** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1; | |
| 122 ** \__________________________/ | |
| 123 ** pLimitWhere (pInClause) | |
| 124 */ | |
| 125 Expr *sqlite3LimitWhere( | |
| 126 Parse *pParse, /* The parser context */ | |
| 127 SrcList *pSrc, /* the FROM clause -- which tables to scan */ | |
| 128 Expr *pWhere, /* The WHERE clause. May be null */ | |
| 129 ExprList *pOrderBy, /* The ORDER BY clause. May be null */ | |
| 130 Expr *pLimit, /* The LIMIT clause. May be null */ | |
| 131 Expr *pOffset, /* The OFFSET clause. May be null */ | |
| 132 char *zStmtType /* Either DELETE or UPDATE. For err msgs. */ | |
| 133 ){ | |
| 134 Expr *pWhereRowid = NULL; /* WHERE rowid .. */ | |
| 135 Expr *pInClause = NULL; /* WHERE rowid IN ( select ) */ | |
| 136 Expr *pSelectRowid = NULL; /* SELECT rowid ... */ | |
| 137 ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */ | |
| 138 SrcList *pSelectSrc = NULL; /* SELECT rowid FROM x ... (dup of pSrc) */ | |
| 139 Select *pSelect = NULL; /* Complete SELECT tree */ | |
| 140 | |
| 141 /* Check that there isn't an ORDER BY without a LIMIT clause. | |
| 142 */ | |
| 143 if( pOrderBy && (pLimit == 0) ) { | |
| 144 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType); | |
| 145 goto limit_where_cleanup_2; | |
| 146 } | |
| 147 | |
| 148 /* We only need to generate a select expression if there | |
| 149 ** is a limit/offset term to enforce. | |
| 150 */ | |
| 151 if( pLimit == 0 ) { | |
| 152 /* if pLimit is null, pOffset will always be null as well. */ | |
| 153 assert( pOffset == 0 ); | |
| 154 return pWhere; | |
| 155 } | |
| 156 | |
| 157 /* Generate a select expression tree to enforce the limit/offset | |
| 158 ** term for the DELETE or UPDATE statement. For example: | |
| 159 ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 | |
| 160 ** becomes: | |
| 161 ** DELETE FROM table_a WHERE rowid IN ( | |
| 162 ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 | |
| 163 ** ); | |
| 164 */ | |
| 165 | |
| 166 pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0); | |
| 167 if( pSelectRowid == 0 ) goto limit_where_cleanup_2; | |
| 168 pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid); | |
| 169 if( pEList == 0 ) goto limit_where_cleanup_2; | |
| 170 | |
| 171 /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree | |
| 172 ** and the SELECT subtree. */ | |
| 173 pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0); | |
| 174 if( pSelectSrc == 0 ) { | |
| 175 sqlite3ExprListDelete(pParse->db, pEList); | |
| 176 goto limit_where_cleanup_2; | |
| 177 } | |
| 178 | |
| 179 /* generate the SELECT expression tree. */ | |
| 180 pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0, | |
| 181 pOrderBy,0,pLimit,pOffset); | |
| 182 if( pSelect == 0 ) return 0; | |
| 183 | |
| 184 /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */ | |
| 185 pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0); | |
| 186 if( pWhereRowid == 0 ) goto limit_where_cleanup_1; | |
| 187 pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0); | |
| 188 if( pInClause == 0 ) goto limit_where_cleanup_1; | |
| 189 | |
| 190 pInClause->x.pSelect = pSelect; | |
| 191 pInClause->flags |= EP_xIsSelect; | |
| 192 sqlite3ExprSetHeight(pParse, pInClause); | |
| 193 return pInClause; | |
| 194 | |
| 195 /* something went wrong. clean up anything allocated. */ | |
| 196 limit_where_cleanup_1: | |
| 197 sqlite3SelectDelete(pParse->db, pSelect); | |
| 198 return 0; | |
| 199 | |
| 200 limit_where_cleanup_2: | |
| 201 sqlite3ExprDelete(pParse->db, pWhere); | |
| 202 sqlite3ExprListDelete(pParse->db, pOrderBy); | |
| 203 sqlite3ExprDelete(pParse->db, pLimit); | |
| 204 sqlite3ExprDelete(pParse->db, pOffset); | |
| 205 return 0; | |
| 206 } | |
| 207 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */ | |
| 208 /* && !defined(SQLITE_OMIT_SUBQUERY) */ | |
| 209 | |
| 210 /* | |
| 211 ** Generate code for a DELETE FROM statement. | |
| 212 ** | |
| 213 ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; | |
| 214 ** \________/ \________________/ | |
| 215 ** pTabList pWhere | |
| 216 */ | |
| 217 void sqlite3DeleteFrom( | |
| 218 Parse *pParse, /* The parser context */ | |
| 219 SrcList *pTabList, /* The table from which we should delete things */ | |
| 220 Expr *pWhere /* The WHERE clause. May be null */ | |
| 221 ){ | |
| 222 Vdbe *v; /* The virtual database engine */ | |
| 223 Table *pTab; /* The table from which records will be deleted */ | |
| 224 const char *zDb; /* Name of database holding pTab */ | |
| 225 int i; /* Loop counter */ | |
| 226 WhereInfo *pWInfo; /* Information about the WHERE clause */ | |
| 227 Index *pIdx; /* For looping over indices of the table */ | |
| 228 int iTabCur; /* Cursor number for the table */ | |
| 229 int iDataCur; /* VDBE cursor for the canonical data source */ | |
| 230 int iIdxCur; /* Cursor number of the first index */ | |
| 231 int nIdx; /* Number of indices */ | |
| 232 sqlite3 *db; /* Main database structure */ | |
| 233 AuthContext sContext; /* Authorization context */ | |
| 234 NameContext sNC; /* Name context to resolve expressions in */ | |
| 235 int iDb; /* Database number */ | |
| 236 int memCnt = -1; /* Memory cell used for change counting */ | |
| 237 int rcauth; /* Value returned by authorization callback */ | |
| 238 int okOnePass; /* True for one-pass algorithm without the FIFO */ | |
| 239 int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ | |
| 240 u8 *aToOpen = 0; /* Open cursor iTabCur+j if aToOpen[j] is true */ | |
| 241 Index *pPk; /* The PRIMARY KEY index on the table */ | |
| 242 int iPk = 0; /* First of nPk registers holding PRIMARY KEY value */ | |
| 243 i16 nPk = 1; /* Number of columns in the PRIMARY KEY */ | |
| 244 int iKey; /* Memory cell holding key of row to be deleted */ | |
| 245 i16 nKey; /* Number of memory cells in the row key */ | |
| 246 int iEphCur = 0; /* Ephemeral table holding all primary key values */ | |
| 247 int iRowSet = 0; /* Register for rowset of rows to delete */ | |
| 248 int addrBypass = 0; /* Address of jump over the delete logic */ | |
| 249 int addrLoop = 0; /* Top of the delete loop */ | |
| 250 int addrDelete = 0; /* Jump directly to the delete logic */ | |
| 251 int addrEphOpen = 0; /* Instruction to open the Ephemeral table */ | |
| 252 | |
| 253 #ifndef SQLITE_OMIT_TRIGGER | |
| 254 int isView; /* True if attempting to delete from a view */ | |
| 255 Trigger *pTrigger; /* List of table triggers, if required */ | |
| 256 #endif | |
| 257 | |
| 258 memset(&sContext, 0, sizeof(sContext)); | |
| 259 db = pParse->db; | |
| 260 if( pParse->nErr || db->mallocFailed ){ | |
| 261 goto delete_from_cleanup; | |
| 262 } | |
| 263 assert( pTabList->nSrc==1 ); | |
| 264 | |
| 265 /* Locate the table which we want to delete. This table has to be | |
| 266 ** put in an SrcList structure because some of the subroutines we | |
| 267 ** will be calling are designed to work with multiple tables and expect | |
| 268 ** an SrcList* parameter instead of just a Table* parameter. | |
| 269 */ | |
| 270 pTab = sqlite3SrcListLookup(pParse, pTabList); | |
| 271 if( pTab==0 ) goto delete_from_cleanup; | |
| 272 | |
| 273 /* Figure out if we have any triggers and if the table being | |
| 274 ** deleted from is a view | |
| 275 */ | |
| 276 #ifndef SQLITE_OMIT_TRIGGER | |
| 277 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); | |
| 278 isView = pTab->pSelect!=0; | |
| 279 #else | |
| 280 # define pTrigger 0 | |
| 281 # define isView 0 | |
| 282 #endif | |
| 283 #ifdef SQLITE_OMIT_VIEW | |
| 284 # undef isView | |
| 285 # define isView 0 | |
| 286 #endif | |
| 287 | |
| 288 /* If pTab is really a view, make sure it has been initialized. | |
| 289 */ | |
| 290 if( sqlite3ViewGetColumnNames(pParse, pTab) ){ | |
| 291 goto delete_from_cleanup; | |
| 292 } | |
| 293 | |
| 294 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){ | |
| 295 goto delete_from_cleanup; | |
| 296 } | |
| 297 iDb = sqlite3SchemaToIndex(db, pTab->pSchema); | |
| 298 assert( iDb<db->nDb ); | |
| 299 zDb = db->aDb[iDb].zName; | |
| 300 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb); | |
| 301 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE ); | |
| 302 if( rcauth==SQLITE_DENY ){ | |
| 303 goto delete_from_cleanup; | |
| 304 } | |
| 305 assert(!isView || pTrigger); | |
| 306 | |
| 307 /* Assign cursor numbers to the table and all its indices. | |
| 308 */ | |
| 309 assert( pTabList->nSrc==1 ); | |
| 310 iTabCur = pTabList->a[0].iCursor = pParse->nTab++; | |
| 311 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ | |
| 312 pParse->nTab++; | |
| 313 } | |
| 314 | |
| 315 /* Start the view context | |
| 316 */ | |
| 317 if( isView ){ | |
| 318 sqlite3AuthContextPush(pParse, &sContext, pTab->zName); | |
| 319 } | |
| 320 | |
| 321 /* Begin generating code. | |
| 322 */ | |
| 323 v = sqlite3GetVdbe(pParse); | |
| 324 if( v==0 ){ | |
| 325 goto delete_from_cleanup; | |
| 326 } | |
| 327 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); | |
| 328 sqlite3BeginWriteOperation(pParse, 1, iDb); | |
| 329 | |
| 330 /* If we are trying to delete from a view, realize that view into | |
| 331 ** an ephemeral table. | |
| 332 */ | |
| 333 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) | |
| 334 if( isView ){ | |
| 335 sqlite3MaterializeView(pParse, pTab, pWhere, iTabCur); | |
| 336 iDataCur = iIdxCur = iTabCur; | |
| 337 } | |
| 338 #endif | |
| 339 | |
| 340 /* Resolve the column names in the WHERE clause. | |
| 341 */ | |
| 342 memset(&sNC, 0, sizeof(sNC)); | |
| 343 sNC.pParse = pParse; | |
| 344 sNC.pSrcList = pTabList; | |
| 345 if( sqlite3ResolveExprNames(&sNC, pWhere) ){ | |
| 346 goto delete_from_cleanup; | |
| 347 } | |
| 348 | |
| 349 /* Initialize the counter of the number of rows deleted, if | |
| 350 ** we are counting rows. | |
| 351 */ | |
| 352 if( db->flags & SQLITE_CountRows ){ | |
| 353 memCnt = ++pParse->nMem; | |
| 354 sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt); | |
| 355 } | |
| 356 | |
| 357 #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION | |
| 358 /* Special case: A DELETE without a WHERE clause deletes everything. | |
| 359 ** It is easier just to erase the whole table. Prior to version 3.6.5, | |
| 360 ** this optimization caused the row change count (the value returned by | |
| 361 ** API function sqlite3_count_changes) to be set incorrectly. */ | |
| 362 if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab) | |
| 363 && 0==sqlite3FkRequired(pParse, pTab, 0, 0) | |
| 364 ){ | |
| 365 assert( !isView ); | |
| 366 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); | |
| 367 if( HasRowid(pTab) ){ | |
| 368 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt, | |
| 369 pTab->zName, P4_STATIC); | |
| 370 } | |
| 371 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ | |
| 372 assert( pIdx->pSchema==pTab->pSchema ); | |
| 373 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb); | |
| 374 } | |
| 375 }else | |
| 376 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */ | |
| 377 { | |
| 378 if( HasRowid(pTab) ){ | |
| 379 /* For a rowid table, initialize the RowSet to an empty set */ | |
| 380 pPk = 0; | |
| 381 nPk = 1; | |
| 382 iRowSet = ++pParse->nMem; | |
| 383 sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet); | |
| 384 }else{ | |
| 385 /* For a WITHOUT ROWID table, create an ephemeral table used to | |
| 386 ** hold all primary keys for rows to be deleted. */ | |
| 387 pPk = sqlite3PrimaryKeyIndex(pTab); | |
| 388 assert( pPk!=0 ); | |
| 389 nPk = pPk->nKeyCol; | |
| 390 iPk = pParse->nMem+1; | |
| 391 pParse->nMem += nPk; | |
| 392 iEphCur = pParse->nTab++; | |
| 393 addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk); | |
| 394 sqlite3VdbeSetP4KeyInfo(pParse, pPk); | |
| 395 } | |
| 396 | |
| 397 /* Construct a query to find the rowid or primary key for every row | |
| 398 ** to be deleted, based on the WHERE clause. | |
| 399 */ | |
| 400 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, | |
| 401 WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK, | |
| 402 iTabCur+1); | |
| 403 if( pWInfo==0 ) goto delete_from_cleanup; | |
| 404 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); | |
| 405 | |
| 406 /* Keep track of the number of rows to be deleted */ | |
| 407 if( db->flags & SQLITE_CountRows ){ | |
| 408 sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1); | |
| 409 } | |
| 410 | |
| 411 /* Extract the rowid or primary key for the current row */ | |
| 412 if( pPk ){ | |
| 413 for(i=0; i<nPk; i++){ | |
| 414 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, | |
| 415 pPk->aiColumn[i], iPk+i); | |
| 416 } | |
| 417 iKey = iPk; | |
| 418 }else{ | |
| 419 iKey = pParse->nMem + 1; | |
| 420 iKey = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iTabCur, iKey, 0); | |
| 421 if( iKey>pParse->nMem ) pParse->nMem = iKey; | |
| 422 } | |
| 423 | |
| 424 if( okOnePass ){ | |
| 425 /* For ONEPASS, no need to store the rowid/primary-key. There is only | |
| 426 ** one, so just keep it in its register(s) and fall through to the | |
| 427 ** delete code. | |
| 428 */ | |
| 429 nKey = nPk; /* OP_Found will use an unpacked key */ | |
| 430 aToOpen = sqlite3DbMallocRaw(db, nIdx+2); | |
| 431 if( aToOpen==0 ){ | |
| 432 sqlite3WhereEnd(pWInfo); | |
| 433 goto delete_from_cleanup; | |
| 434 } | |
| 435 memset(aToOpen, 1, nIdx+1); | |
| 436 aToOpen[nIdx+1] = 0; | |
| 437 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0; | |
| 438 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0; | |
| 439 if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen); | |
| 440 addrDelete = sqlite3VdbeAddOp0(v, OP_Goto); /* Jump to DELETE logic */ | |
| 441 }else if( pPk ){ | |
| 442 /* Construct a composite key for the row to be deleted and remember it */ | |
| 443 iKey = ++pParse->nMem; | |
| 444 nKey = 0; /* Zero tells OP_Found to use a composite key */ | |
| 445 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey, | |
| 446 sqlite3IndexAffinityStr(v, pPk), nPk); | |
| 447 sqlite3VdbeAddOp2(v, OP_IdxInsert, iEphCur, iKey); | |
| 448 }else{ | |
| 449 /* Get the rowid of the row to be deleted and remember it in the RowSet */ | |
| 450 nKey = 1; /* OP_Seek always uses a single rowid */ | |
| 451 sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey); | |
| 452 } | |
| 453 | |
| 454 /* End of the WHERE loop */ | |
| 455 sqlite3WhereEnd(pWInfo); | |
| 456 if( okOnePass ){ | |
| 457 /* Bypass the delete logic below if the WHERE loop found zero rows */ | |
| 458 addrBypass = sqlite3VdbeMakeLabel(v); | |
| 459 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrBypass); | |
| 460 sqlite3VdbeJumpHere(v, addrDelete); | |
| 461 } | |
| 462 | |
| 463 /* Unless this is a view, open cursors for the table we are | |
| 464 ** deleting from and all its indices. If this is a view, then the | |
| 465 ** only effect this statement has is to fire the INSTEAD OF | |
| 466 ** triggers. | |
| 467 */ | |
| 468 if( !isView ){ | |
| 469 testcase( IsVirtual(pTab) ); | |
| 470 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iTabCur, aToOpen, | |
| 471 &iDataCur, &iIdxCur); | |
| 472 assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur ); | |
| 473 assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 ); | |
| 474 } | |
| 475 | |
| 476 /* Set up a loop over the rowids/primary-keys that were found in the | |
| 477 ** where-clause loop above. | |
| 478 */ | |
| 479 if( okOnePass ){ | |
| 480 /* Just one row. Hence the top-of-loop is a no-op */ | |
| 481 assert( nKey==nPk ); /* OP_Found will use an unpacked key */ | |
| 482 assert( !IsVirtual(pTab) ); | |
| 483 if( aToOpen[iDataCur-iTabCur] ){ | |
| 484 assert( pPk!=0 || pTab->pSelect!=0 ); | |
| 485 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey); | |
| 486 VdbeCoverage(v); | |
| 487 } | |
| 488 }else if( pPk ){ | |
| 489 addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v); | |
| 490 sqlite3VdbeAddOp2(v, OP_RowKey, iEphCur, iKey); | |
| 491 assert( nKey==0 ); /* OP_Found will use a composite key */ | |
| 492 }else{ | |
| 493 addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey); | |
| 494 VdbeCoverage(v); | |
| 495 assert( nKey==1 ); | |
| 496 } | |
| 497 | |
| 498 /* Delete the row */ | |
| 499 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 500 if( IsVirtual(pTab) ){ | |
| 501 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); | |
| 502 sqlite3VtabMakeWritable(pParse, pTab); | |
| 503 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB); | |
| 504 sqlite3VdbeChangeP5(v, OE_Abort); | |
| 505 sqlite3MayAbort(pParse); | |
| 506 }else | |
| 507 #endif | |
| 508 { | |
| 509 int count = (pParse->nested==0); /* True to count changes */ | |
| 510 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, | |
| 511 iKey, nKey, count, OE_Default, okOnePass); | |
| 512 } | |
| 513 | |
| 514 /* End of the loop over all rowids/primary-keys. */ | |
| 515 if( okOnePass ){ | |
| 516 sqlite3VdbeResolveLabel(v, addrBypass); | |
| 517 }else if( pPk ){ | |
| 518 sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v); | |
| 519 sqlite3VdbeJumpHere(v, addrLoop); | |
| 520 }else{ | |
| 521 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrLoop); | |
| 522 sqlite3VdbeJumpHere(v, addrLoop); | |
| 523 } | |
| 524 | |
| 525 /* Close the cursors open on the table and its indexes. */ | |
| 526 if( !isView && !IsVirtual(pTab) ){ | |
| 527 if( !pPk ) sqlite3VdbeAddOp1(v, OP_Close, iDataCur); | |
| 528 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ | |
| 529 sqlite3VdbeAddOp1(v, OP_Close, iIdxCur + i); | |
| 530 } | |
| 531 } | |
| 532 } /* End non-truncate path */ | |
| 533 | |
| 534 /* Update the sqlite_sequence table by storing the content of the | |
| 535 ** maximum rowid counter values recorded while inserting into | |
| 536 ** autoincrement tables. | |
| 537 */ | |
| 538 if( pParse->nested==0 && pParse->pTriggerTab==0 ){ | |
| 539 sqlite3AutoincrementEnd(pParse); | |
| 540 } | |
| 541 | |
| 542 /* Return the number of rows that were deleted. If this routine is | |
| 543 ** generating code because of a call to sqlite3NestedParse(), do not | |
| 544 ** invoke the callback function. | |
| 545 */ | |
| 546 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){ | |
| 547 sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1); | |
| 548 sqlite3VdbeSetNumCols(v, 1); | |
| 549 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC); | |
| 550 } | |
| 551 | |
| 552 delete_from_cleanup: | |
| 553 sqlite3AuthContextPop(&sContext); | |
| 554 sqlite3SrcListDelete(db, pTabList); | |
| 555 sqlite3ExprDelete(db, pWhere); | |
| 556 sqlite3DbFree(db, aToOpen); | |
| 557 return; | |
| 558 } | |
| 559 /* Make sure "isView" and other macros defined above are undefined. Otherwise | |
| 560 ** they may interfere with compilation of other functions in this file | |
| 561 ** (or in another file, if this file becomes part of the amalgamation). */ | |
| 562 #ifdef isView | |
| 563 #undef isView | |
| 564 #endif | |
| 565 #ifdef pTrigger | |
| 566 #undef pTrigger | |
| 567 #endif | |
| 568 | |
| 569 /* | |
| 570 ** This routine generates VDBE code that causes a single row of a | |
| 571 ** single table to be deleted. Both the original table entry and | |
| 572 ** all indices are removed. | |
| 573 ** | |
| 574 ** Preconditions: | |
| 575 ** | |
| 576 ** 1. iDataCur is an open cursor on the btree that is the canonical data | |
| 577 ** store for the table. (This will be either the table itself, | |
| 578 ** in the case of a rowid table, or the PRIMARY KEY index in the case | |
| 579 ** of a WITHOUT ROWID table.) | |
| 580 ** | |
| 581 ** 2. Read/write cursors for all indices of pTab must be open as | |
| 582 ** cursor number iIdxCur+i for the i-th index. | |
| 583 ** | |
| 584 ** 3. The primary key for the row to be deleted must be stored in a | |
| 585 ** sequence of nPk memory cells starting at iPk. If nPk==0 that means | |
| 586 ** that a search record formed from OP_MakeRecord is contained in the | |
| 587 ** single memory location iPk. | |
| 588 */ | |
| 589 void sqlite3GenerateRowDelete( | |
| 590 Parse *pParse, /* Parsing context */ | |
| 591 Table *pTab, /* Table containing the row to be deleted */ | |
| 592 Trigger *pTrigger, /* List of triggers to (potentially) fire */ | |
| 593 int iDataCur, /* Cursor from which column data is extracted */ | |
| 594 int iIdxCur, /* First index cursor */ | |
| 595 int iPk, /* First memory cell containing the PRIMARY KEY */ | |
| 596 i16 nPk, /* Number of PRIMARY KEY memory cells */ | |
| 597 u8 count, /* If non-zero, increment the row change counter */ | |
| 598 u8 onconf, /* Default ON CONFLICT policy for triggers */ | |
| 599 u8 bNoSeek /* iDataCur is already pointing to the row to delete */ | |
| 600 ){ | |
| 601 Vdbe *v = pParse->pVdbe; /* Vdbe */ | |
| 602 int iOld = 0; /* First register in OLD.* array */ | |
| 603 int iLabel; /* Label resolved to end of generated code */ | |
| 604 u8 opSeek; /* Seek opcode */ | |
| 605 | |
| 606 /* Vdbe is guaranteed to have been allocated by this stage. */ | |
| 607 assert( v ); | |
| 608 VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)", | |
| 609 iDataCur, iIdxCur, iPk, (int)nPk)); | |
| 610 | |
| 611 /* Seek cursor iCur to the row to delete. If this row no longer exists | |
| 612 ** (this can happen if a trigger program has already deleted it), do | |
| 613 ** not attempt to delete it or fire any DELETE triggers. */ | |
| 614 iLabel = sqlite3VdbeMakeLabel(v); | |
| 615 opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound; | |
| 616 if( !bNoSeek ){ | |
| 617 sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk); | |
| 618 VdbeCoverageIf(v, opSeek==OP_NotExists); | |
| 619 VdbeCoverageIf(v, opSeek==OP_NotFound); | |
| 620 } | |
| 621 | |
| 622 /* If there are any triggers to fire, allocate a range of registers to | |
| 623 ** use for the old.* references in the triggers. */ | |
| 624 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){ | |
| 625 u32 mask; /* Mask of OLD.* columns in use */ | |
| 626 int iCol; /* Iterator used while populating OLD.* */ | |
| 627 int addrStart; /* Start of BEFORE trigger programs */ | |
| 628 | |
| 629 /* TODO: Could use temporary registers here. Also could attempt to | |
| 630 ** avoid copying the contents of the rowid register. */ | |
| 631 mask = sqlite3TriggerColmask( | |
| 632 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf | |
| 633 ); | |
| 634 mask |= sqlite3FkOldmask(pParse, pTab); | |
| 635 iOld = pParse->nMem+1; | |
| 636 pParse->nMem += (1 + pTab->nCol); | |
| 637 | |
| 638 /* Populate the OLD.* pseudo-table register array. These values will be | |
| 639 ** used by any BEFORE and AFTER triggers that exist. */ | |
| 640 sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld); | |
| 641 for(iCol=0; iCol<pTab->nCol; iCol++){ | |
| 642 testcase( mask!=0xffffffff && iCol==31 ); | |
| 643 testcase( mask!=0xffffffff && iCol==32 ); | |
| 644 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){ | |
| 645 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1); | |
| 646 } | |
| 647 } | |
| 648 | |
| 649 /* Invoke BEFORE DELETE trigger programs. */ | |
| 650 addrStart = sqlite3VdbeCurrentAddr(v); | |
| 651 sqlite3CodeRowTrigger(pParse, pTrigger, | |
| 652 TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel | |
| 653 ); | |
| 654 | |
| 655 /* If any BEFORE triggers were coded, then seek the cursor to the | |
| 656 ** row to be deleted again. It may be that the BEFORE triggers moved | |
| 657 ** the cursor or of already deleted the row that the cursor was | |
| 658 ** pointing to. | |
| 659 */ | |
| 660 if( addrStart<sqlite3VdbeCurrentAddr(v) ){ | |
| 661 sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk); | |
| 662 VdbeCoverageIf(v, opSeek==OP_NotExists); | |
| 663 VdbeCoverageIf(v, opSeek==OP_NotFound); | |
| 664 } | |
| 665 | |
| 666 /* Do FK processing. This call checks that any FK constraints that | |
| 667 ** refer to this table (i.e. constraints attached to other tables) | |
| 668 ** are not violated by deleting this row. */ | |
| 669 sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0); | |
| 670 } | |
| 671 | |
| 672 /* Delete the index and table entries. Skip this step if pTab is really | |
| 673 ** a view (in which case the only effect of the DELETE statement is to | |
| 674 ** fire the INSTEAD OF triggers). */ | |
| 675 if( pTab->pSelect==0 ){ | |
| 676 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0); | |
| 677 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0)); | |
| 678 if( count ){ | |
| 679 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT); | |
| 680 } | |
| 681 } | |
| 682 | |
| 683 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to | |
| 684 ** handle rows (possibly in other tables) that refer via a foreign key | |
| 685 ** to the row just deleted. */ | |
| 686 sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0); | |
| 687 | |
| 688 /* Invoke AFTER DELETE trigger programs. */ | |
| 689 sqlite3CodeRowTrigger(pParse, pTrigger, | |
| 690 TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel | |
| 691 ); | |
| 692 | |
| 693 /* Jump here if the row had already been deleted before any BEFORE | |
| 694 ** trigger programs were invoked. Or if a trigger program throws a | |
| 695 ** RAISE(IGNORE) exception. */ | |
| 696 sqlite3VdbeResolveLabel(v, iLabel); | |
| 697 VdbeModuleComment((v, "END: GenRowDel()")); | |
| 698 } | |
| 699 | |
| 700 /* | |
| 701 ** This routine generates VDBE code that causes the deletion of all | |
| 702 ** index entries associated with a single row of a single table, pTab | |
| 703 ** | |
| 704 ** Preconditions: | |
| 705 ** | |
| 706 ** 1. A read/write cursor "iDataCur" must be open on the canonical storage | |
| 707 ** btree for the table pTab. (This will be either the table itself | |
| 708 ** for rowid tables or to the primary key index for WITHOUT ROWID | |
| 709 ** tables.) | |
| 710 ** | |
| 711 ** 2. Read/write cursors for all indices of pTab must be open as | |
| 712 ** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex | |
| 713 ** index is the 0-th index.) | |
| 714 ** | |
| 715 ** 3. The "iDataCur" cursor must be already be positioned on the row | |
| 716 ** that is to be deleted. | |
| 717 */ | |
| 718 void sqlite3GenerateRowIndexDelete( | |
| 719 Parse *pParse, /* Parsing and code generating context */ | |
| 720 Table *pTab, /* Table containing the row to be deleted */ | |
| 721 int iDataCur, /* Cursor of table holding data. */ | |
| 722 int iIdxCur, /* First index cursor */ | |
| 723 int *aRegIdx /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */ | |
| 724 ){ | |
| 725 int i; /* Index loop counter */ | |
| 726 int r1 = -1; /* Register holding an index key */ | |
| 727 int iPartIdxLabel; /* Jump destination for skipping partial index entries */ | |
| 728 Index *pIdx; /* Current index */ | |
| 729 Index *pPrior = 0; /* Prior index */ | |
| 730 Vdbe *v; /* The prepared statement under construction */ | |
| 731 Index *pPk; /* PRIMARY KEY index, or NULL for rowid tables */ | |
| 732 | |
| 733 v = pParse->pVdbe; | |
| 734 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); | |
| 735 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ | |
| 736 assert( iIdxCur+i!=iDataCur || pPk==pIdx ); | |
| 737 if( aRegIdx!=0 && aRegIdx[i]==0 ) continue; | |
| 738 if( pIdx==pPk ) continue; | |
| 739 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName)); | |
| 740 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1, | |
| 741 &iPartIdxLabel, pPrior, r1); | |
| 742 sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1, | |
| 743 pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn); | |
| 744 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); | |
| 745 pPrior = pIdx; | |
| 746 } | |
| 747 } | |
| 748 | |
| 749 /* | |
| 750 ** Generate code that will assemble an index key and stores it in register | |
| 751 ** regOut. The key with be for index pIdx which is an index on pTab. | |
| 752 ** iCur is the index of a cursor open on the pTab table and pointing to | |
| 753 ** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then | |
| 754 ** iCur must be the cursor of the PRIMARY KEY index. | |
| 755 ** | |
| 756 ** Return a register number which is the first in a block of | |
| 757 ** registers that holds the elements of the index key. The | |
| 758 ** block of registers has already been deallocated by the time | |
| 759 ** this routine returns. | |
| 760 ** | |
| 761 ** If *piPartIdxLabel is not NULL, fill it in with a label and jump | |
| 762 ** to that label if pIdx is a partial index that should be skipped. | |
| 763 ** The label should be resolved using sqlite3ResolvePartIdxLabel(). | |
| 764 ** A partial index should be skipped if its WHERE clause evaluates | |
| 765 ** to false or null. If pIdx is not a partial index, *piPartIdxLabel | |
| 766 ** will be set to zero which is an empty label that is ignored by | |
| 767 ** sqlite3ResolvePartIdxLabel(). | |
| 768 ** | |
| 769 ** The pPrior and regPrior parameters are used to implement a cache to | |
| 770 ** avoid unnecessary register loads. If pPrior is not NULL, then it is | |
| 771 ** a pointer to a different index for which an index key has just been | |
| 772 ** computed into register regPrior. If the current pIdx index is generating | |
| 773 ** its key into the same sequence of registers and if pPrior and pIdx share | |
| 774 ** a column in common, then the register corresponding to that column already | |
| 775 ** holds the correct value and the loading of that register is skipped. | |
| 776 ** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK | |
| 777 ** on a table with multiple indices, and especially with the ROWID or | |
| 778 ** PRIMARY KEY columns of the index. | |
| 779 */ | |
| 780 int sqlite3GenerateIndexKey( | |
| 781 Parse *pParse, /* Parsing context */ | |
| 782 Index *pIdx, /* The index for which to generate a key */ | |
| 783 int iDataCur, /* Cursor number from which to take column data */ | |
| 784 int regOut, /* Put the new key into this register if not 0 */ | |
| 785 int prefixOnly, /* Compute only a unique prefix of the key */ | |
| 786 int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */ | |
| 787 Index *pPrior, /* Previously generated index key */ | |
| 788 int regPrior /* Register holding previous generated key */ | |
| 789 ){ | |
| 790 Vdbe *v = pParse->pVdbe; | |
| 791 int j; | |
| 792 Table *pTab = pIdx->pTable; | |
| 793 int regBase; | |
| 794 int nCol; | |
| 795 | |
| 796 if( piPartIdxLabel ){ | |
| 797 if( pIdx->pPartIdxWhere ){ | |
| 798 *piPartIdxLabel = sqlite3VdbeMakeLabel(v); | |
| 799 pParse->iPartIdxTab = iDataCur; | |
| 800 sqlite3ExprCachePush(pParse); | |
| 801 sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel, | |
| 802 SQLITE_JUMPIFNULL); | |
| 803 }else{ | |
| 804 *piPartIdxLabel = 0; | |
| 805 } | |
| 806 } | |
| 807 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn; | |
| 808 regBase = sqlite3GetTempRange(pParse, nCol); | |
| 809 if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0; | |
| 810 for(j=0; j<nCol; j++){ | |
| 811 if( pPrior && pPrior->aiColumn[j]==pIdx->aiColumn[j] ) continue; | |
| 812 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pIdx->aiColumn[j], | |
| 813 regBase+j); | |
| 814 /* If the column affinity is REAL but the number is an integer, then it | |
| 815 ** might be stored in the table as an integer (using a compact | |
| 816 ** representation) then converted to REAL by an OP_RealAffinity opcode. | |
| 817 ** But we are getting ready to store this value back into an index, where | |
| 818 ** it should be converted by to INTEGER again. So omit the OP_RealAffinity | |
| 819 ** opcode if it is present */ | |
| 820 sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity); | |
| 821 } | |
| 822 if( regOut ){ | |
| 823 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut); | |
| 824 } | |
| 825 sqlite3ReleaseTempRange(pParse, regBase, nCol); | |
| 826 return regBase; | |
| 827 } | |
| 828 | |
| 829 /* | |
| 830 ** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label | |
| 831 ** because it was a partial index, then this routine should be called to | |
| 832 ** resolve that label. | |
| 833 */ | |
| 834 void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){ | |
| 835 if( iLabel ){ | |
| 836 sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel); | |
| 837 sqlite3ExprCachePop(pParse); | |
| 838 } | |
| 839 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
