4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains C code routines that are called by the parser
13 ** in order to generate code for DELETE FROM statements.
15 #include "sqliteInt.h"
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.
25 ** The following fields are initialized appropriate in pSrc:
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
31 Table
*sqlite3SrcListLookup(Parse
*pParse
, SrcList
*pSrc
){
32 struct SrcList_item
*pItem
= pSrc
->a
;
34 assert( pItem
&& pSrc
->nSrc
==1 );
35 pTab
= sqlite3LocateTableItem(pParse
, 0, pItem
);
36 sqlite3DeleteTable(pParse
->db
, pItem
->pTab
);
41 if( sqlite3IndexedByLookup(pParse
, pItem
) ){
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
52 int sqlite3IsReadOnly(Parse
*pParse
, Table
*pTab
, int viewOk
){
53 /* A table is not writable under the following circumstances:
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
61 ** In either case leave an error message in pParse and return non-zero.
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 )
69 sqlite3ErrorMsg(pParse
, "table %s may not be modified", pTab
->zName
);
73 #ifndef SQLITE_OMIT_VIEW
74 if( !viewOk
&& pTab
->pSelect
){
75 sqlite3ErrorMsg(pParse
,"cannot modify %s because it is a view",pTab
->zName
);
83 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
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.
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 */
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);
103 assert( pFrom
->nSrc
==1 );
104 pFrom
->a
[0].zName
= sqlite3DbStrDup(db
, pView
->zName
);
105 pFrom
->a
[0].zDatabase
= sqlite3DbStrDup(db
, db
->aDb
[iDb
].zDbSName
);
106 assert( pFrom
->a
[0].pOn
==0 );
107 assert( pFrom
->a
[0].pUsing
==0 );
109 pSel
= sqlite3SelectNew(pParse
, 0, pFrom
, pWhere
, 0, 0, 0,
110 SF_IncludeHidden
, 0, 0);
111 sqlite3SelectDestInit(&dest
, SRT_EphemTab
, iCur
);
112 sqlite3Select(pParse
, pSel
, &dest
);
113 sqlite3SelectDelete(db
, pSel
);
115 #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
117 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
119 ** Generate an expression tree to implement the WHERE, ORDER BY,
120 ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
122 ** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
123 ** \__________________________/
124 ** pLimitWhere (pInClause)
126 Expr
*sqlite3LimitWhere(
127 Parse
*pParse
, /* The parser context */
128 SrcList
*pSrc
, /* the FROM clause -- which tables to scan */
129 Expr
*pWhere
, /* The WHERE clause. May be null */
130 ExprList
*pOrderBy
, /* The ORDER BY clause. May be null */
131 Expr
*pLimit
, /* The LIMIT clause. May be null */
132 Expr
*pOffset
, /* The OFFSET clause. May be null */
133 char *zStmtType
/* Either DELETE or UPDATE. For err msgs. */
135 Expr
*pWhereRowid
= NULL
; /* WHERE rowid .. */
136 Expr
*pInClause
= NULL
; /* WHERE rowid IN ( select ) */
137 Expr
*pSelectRowid
= NULL
; /* SELECT rowid ... */
138 ExprList
*pEList
= NULL
; /* Expression list contaning only pSelectRowid */
139 SrcList
*pSelectSrc
= NULL
; /* SELECT rowid FROM x ... (dup of pSrc) */
140 Select
*pSelect
= NULL
; /* Complete SELECT tree */
142 /* Check that there isn't an ORDER BY without a LIMIT clause.
144 if( pOrderBy
&& (pLimit
== 0) ) {
145 sqlite3ErrorMsg(pParse
, "ORDER BY without LIMIT on %s", zStmtType
);
146 goto limit_where_cleanup
;
149 /* We only need to generate a select expression if there
150 ** is a limit/offset term to enforce.
153 /* if pLimit is null, pOffset will always be null as well. */
154 assert( pOffset
== 0 );
158 /* Generate a select expression tree to enforce the limit/offset
159 ** term for the DELETE or UPDATE statement. For example:
160 ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
162 ** DELETE FROM table_a WHERE rowid IN (
163 ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
167 pSelectRowid
= sqlite3PExpr(pParse
, TK_ROW
, 0, 0);
168 if( pSelectRowid
== 0 ) goto limit_where_cleanup
;
169 pEList
= sqlite3ExprListAppend(pParse
, 0, pSelectRowid
);
170 if( pEList
== 0 ) goto limit_where_cleanup
;
172 /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
173 ** and the SELECT subtree. */
174 pSelectSrc
= sqlite3SrcListDup(pParse
->db
, pSrc
, 0);
175 if( pSelectSrc
== 0 ) {
176 sqlite3ExprListDelete(pParse
->db
, pEList
);
177 goto limit_where_cleanup
;
180 /* generate the SELECT expression tree. */
181 pSelect
= sqlite3SelectNew(pParse
,pEList
,pSelectSrc
,pWhere
,0,0,
182 pOrderBy
,0,pLimit
,pOffset
);
183 if( pSelect
== 0 ) return 0;
185 /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
186 pWhereRowid
= sqlite3PExpr(pParse
, TK_ROW
, 0, 0);
187 pInClause
= pWhereRowid
? sqlite3PExpr(pParse
, TK_IN
, pWhereRowid
, 0) : 0;
188 sqlite3PExprAddSelect(pParse
, pInClause
, pSelect
);
192 sqlite3ExprDelete(pParse
->db
, pWhere
);
193 sqlite3ExprListDelete(pParse
->db
, pOrderBy
);
194 sqlite3ExprDelete(pParse
->db
, pLimit
);
195 sqlite3ExprDelete(pParse
->db
, pOffset
);
198 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */
199 /* && !defined(SQLITE_OMIT_SUBQUERY) */
202 ** Generate code for a DELETE FROM statement.
204 ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
205 ** \________/ \________________/
208 void sqlite3DeleteFrom(
209 Parse
*pParse
, /* The parser context */
210 SrcList
*pTabList
, /* The table from which we should delete things */
211 Expr
*pWhere
/* The WHERE clause. May be null */
213 Vdbe
*v
; /* The virtual database engine */
214 Table
*pTab
; /* The table from which records will be deleted */
215 int i
; /* Loop counter */
216 WhereInfo
*pWInfo
; /* Information about the WHERE clause */
217 Index
*pIdx
; /* For looping over indices of the table */
218 int iTabCur
; /* Cursor number for the table */
219 int iDataCur
= 0; /* VDBE cursor for the canonical data source */
220 int iIdxCur
= 0; /* Cursor number of the first index */
221 int nIdx
; /* Number of indices */
222 sqlite3
*db
; /* Main database structure */
223 AuthContext sContext
; /* Authorization context */
224 NameContext sNC
; /* Name context to resolve expressions in */
225 int iDb
; /* Database number */
226 int memCnt
= -1; /* Memory cell used for change counting */
227 int rcauth
; /* Value returned by authorization callback */
228 int eOnePass
; /* ONEPASS_OFF or _SINGLE or _MULTI */
229 int aiCurOnePass
[2]; /* The write cursors opened by WHERE_ONEPASS */
230 u8
*aToOpen
= 0; /* Open cursor iTabCur+j if aToOpen[j] is true */
231 Index
*pPk
; /* The PRIMARY KEY index on the table */
232 int iPk
= 0; /* First of nPk registers holding PRIMARY KEY value */
233 i16 nPk
= 1; /* Number of columns in the PRIMARY KEY */
234 int iKey
; /* Memory cell holding key of row to be deleted */
235 i16 nKey
; /* Number of memory cells in the row key */
236 int iEphCur
= 0; /* Ephemeral table holding all primary key values */
237 int iRowSet
= 0; /* Register for rowset of rows to delete */
238 int addrBypass
= 0; /* Address of jump over the delete logic */
239 int addrLoop
= 0; /* Top of the delete loop */
240 int addrEphOpen
= 0; /* Instruction to open the Ephemeral table */
241 int bComplex
; /* True if there are triggers or FKs or
242 ** subqueries in the WHERE clause */
244 #ifndef SQLITE_OMIT_TRIGGER
245 int isView
; /* True if attempting to delete from a view */
246 Trigger
*pTrigger
; /* List of table triggers, if required */
249 memset(&sContext
, 0, sizeof(sContext
));
251 if( pParse
->nErr
|| db
->mallocFailed
){
252 goto delete_from_cleanup
;
254 assert( pTabList
->nSrc
==1 );
256 /* Locate the table which we want to delete. This table has to be
257 ** put in an SrcList structure because some of the subroutines we
258 ** will be calling are designed to work with multiple tables and expect
259 ** an SrcList* parameter instead of just a Table* parameter.
261 pTab
= sqlite3SrcListLookup(pParse
, pTabList
);
262 if( pTab
==0 ) goto delete_from_cleanup
;
264 /* Figure out if we have any triggers and if the table being
265 ** deleted from is a view
267 #ifndef SQLITE_OMIT_TRIGGER
268 pTrigger
= sqlite3TriggersExist(pParse
, pTab
, TK_DELETE
, 0, 0);
269 isView
= pTab
->pSelect
!=0;
270 bComplex
= pTrigger
|| sqlite3FkRequired(pParse
, pTab
, 0, 0);
275 #ifdef SQLITE_OMIT_VIEW
280 /* If pTab is really a view, make sure it has been initialized.
282 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ){
283 goto delete_from_cleanup
;
286 if( sqlite3IsReadOnly(pParse
, pTab
, (pTrigger
?1:0)) ){
287 goto delete_from_cleanup
;
289 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
290 assert( iDb
<db
->nDb
);
291 rcauth
= sqlite3AuthCheck(pParse
, SQLITE_DELETE
, pTab
->zName
, 0,
292 db
->aDb
[iDb
].zDbSName
);
293 assert( rcauth
==SQLITE_OK
|| rcauth
==SQLITE_DENY
|| rcauth
==SQLITE_IGNORE
);
294 if( rcauth
==SQLITE_DENY
){
295 goto delete_from_cleanup
;
297 assert(!isView
|| pTrigger
);
299 /* Assign cursor numbers to the table and all its indices.
301 assert( pTabList
->nSrc
==1 );
302 iTabCur
= pTabList
->a
[0].iCursor
= pParse
->nTab
++;
303 for(nIdx
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, nIdx
++){
307 /* Start the view context
310 sqlite3AuthContextPush(pParse
, &sContext
, pTab
->zName
);
313 /* Begin generating code.
315 v
= sqlite3GetVdbe(pParse
);
317 goto delete_from_cleanup
;
319 if( pParse
->nested
==0 ) sqlite3VdbeCountChanges(v
);
320 sqlite3BeginWriteOperation(pParse
, 1, iDb
);
322 /* If we are trying to delete from a view, realize that view into
323 ** an ephemeral table.
325 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
327 sqlite3MaterializeView(pParse
, pTab
, pWhere
, iTabCur
);
328 iDataCur
= iIdxCur
= iTabCur
;
332 /* Resolve the column names in the WHERE clause.
334 memset(&sNC
, 0, sizeof(sNC
));
336 sNC
.pSrcList
= pTabList
;
337 if( sqlite3ResolveExprNames(&sNC
, pWhere
) ){
338 goto delete_from_cleanup
;
341 /* Initialize the counter of the number of rows deleted, if
342 ** we are counting rows.
344 if( db
->flags
& SQLITE_CountRows
){
345 memCnt
= ++pParse
->nMem
;
346 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, memCnt
);
349 #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
350 /* Special case: A DELETE without a WHERE clause deletes everything.
351 ** It is easier just to erase the whole table. Prior to version 3.6.5,
352 ** this optimization caused the row change count (the value returned by
353 ** API function sqlite3_count_changes) to be set incorrectly.
355 ** The "rcauth==SQLITE_OK" terms is the
356 ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and
357 ** the callback returns SQLITE_IGNORE then the DELETE operation proceeds but
358 ** the truncate optimization is disabled and all rows are deleted
361 if( rcauth
==SQLITE_OK
365 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
366 && db
->xPreUpdateCallback
==0
370 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 1, pTab
->zName
);
371 if( HasRowid(pTab
) ){
372 sqlite3VdbeAddOp4(v
, OP_Clear
, pTab
->tnum
, iDb
, memCnt
,
373 pTab
->zName
, P4_STATIC
);
375 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
376 assert( pIdx
->pSchema
==pTab
->pSchema
);
377 sqlite3VdbeAddOp2(v
, OP_Clear
, pIdx
->tnum
, iDb
);
380 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
382 u16 wcf
= WHERE_ONEPASS_DESIRED
|WHERE_DUPLICATES_OK
|WHERE_SEEK_TABLE
;
383 if( sNC
.ncFlags
& NC_VarSelect
) bComplex
= 1;
384 wcf
|= (bComplex
? 0 : WHERE_ONEPASS_MULTIROW
);
385 if( HasRowid(pTab
) ){
386 /* For a rowid table, initialize the RowSet to an empty set */
389 iRowSet
= ++pParse
->nMem
;
390 sqlite3VdbeAddOp2(v
, OP_Null
, 0, iRowSet
);
392 /* For a WITHOUT ROWID table, create an ephemeral table used to
393 ** hold all primary keys for rows to be deleted. */
394 pPk
= sqlite3PrimaryKeyIndex(pTab
);
397 iPk
= pParse
->nMem
+1;
399 iEphCur
= pParse
->nTab
++;
400 addrEphOpen
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iEphCur
, nPk
);
401 sqlite3VdbeSetP4KeyInfo(pParse
, pPk
);
404 /* Construct a query to find the rowid or primary key for every row
405 ** to be deleted, based on the WHERE clause. Set variable eOnePass
406 ** to indicate the strategy used to implement this delete:
408 ** ONEPASS_OFF: Two-pass approach - use a FIFO for rowids/PK values.
409 ** ONEPASS_SINGLE: One-pass approach - at most one row deleted.
410 ** ONEPASS_MULTI: One-pass approach - any number of rows may be deleted.
412 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, 0, 0, wcf
, iTabCur
+1);
413 if( pWInfo
==0 ) goto delete_from_cleanup
;
414 eOnePass
= sqlite3WhereOkOnePass(pWInfo
, aiCurOnePass
);
415 assert( IsVirtual(pTab
)==0 || eOnePass
!=ONEPASS_MULTI
);
416 assert( IsVirtual(pTab
) || bComplex
|| eOnePass
!=ONEPASS_OFF
);
418 /* Keep track of the number of rows to be deleted */
419 if( db
->flags
& SQLITE_CountRows
){
420 sqlite3VdbeAddOp2(v
, OP_AddImm
, memCnt
, 1);
423 /* Extract the rowid or primary key for the current row */
425 for(i
=0; i
<nPk
; i
++){
426 assert( pPk
->aiColumn
[i
]>=0 );
427 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iTabCur
,
428 pPk
->aiColumn
[i
], iPk
+i
);
432 iKey
= pParse
->nMem
+ 1;
433 iKey
= sqlite3ExprCodeGetColumn(pParse
, pTab
, -1, iTabCur
, iKey
, 0);
434 if( iKey
>pParse
->nMem
) pParse
->nMem
= iKey
;
437 if( eOnePass
!=ONEPASS_OFF
){
438 /* For ONEPASS, no need to store the rowid/primary-key. There is only
439 ** one, so just keep it in its register(s) and fall through to the
441 nKey
= nPk
; /* OP_Found will use an unpacked key */
442 aToOpen
= sqlite3DbMallocRawNN(db
, nIdx
+2);
444 sqlite3WhereEnd(pWInfo
);
445 goto delete_from_cleanup
;
447 memset(aToOpen
, 1, nIdx
+1);
449 if( aiCurOnePass
[0]>=0 ) aToOpen
[aiCurOnePass
[0]-iTabCur
] = 0;
450 if( aiCurOnePass
[1]>=0 ) aToOpen
[aiCurOnePass
[1]-iTabCur
] = 0;
451 if( addrEphOpen
) sqlite3VdbeChangeToNoop(v
, addrEphOpen
);
454 /* Add the PK key for this row to the temporary table */
455 iKey
= ++pParse
->nMem
;
456 nKey
= 0; /* Zero tells OP_Found to use a composite key */
457 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, iPk
, nPk
, iKey
,
458 sqlite3IndexAffinityStr(pParse
->db
, pPk
), nPk
);
459 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iEphCur
, iKey
, iPk
, nPk
);
461 /* Add the rowid of the row to be deleted to the RowSet */
462 nKey
= 1; /* OP_DeferredSeek always uses a single rowid */
463 sqlite3VdbeAddOp2(v
, OP_RowSetAdd
, iRowSet
, iKey
);
467 /* If this DELETE cannot use the ONEPASS strategy, this is the
468 ** end of the WHERE loop */
469 if( eOnePass
!=ONEPASS_OFF
){
470 addrBypass
= sqlite3VdbeMakeLabel(v
);
472 sqlite3WhereEnd(pWInfo
);
475 /* Unless this is a view, open cursors for the table we are
476 ** deleting from and all its indices. If this is a view, then the
477 ** only effect this statement has is to fire the INSTEAD OF
482 if( eOnePass
==ONEPASS_MULTI
){
483 iAddrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
485 testcase( IsVirtual(pTab
) );
486 sqlite3OpenTableAndIndices(pParse
, pTab
, OP_OpenWrite
, OPFLAG_FORDELETE
,
487 iTabCur
, aToOpen
, &iDataCur
, &iIdxCur
);
488 assert( pPk
|| IsVirtual(pTab
) || iDataCur
==iTabCur
);
489 assert( pPk
|| IsVirtual(pTab
) || iIdxCur
==iDataCur
+1 );
490 if( eOnePass
==ONEPASS_MULTI
) sqlite3VdbeJumpHere(v
, iAddrOnce
);
493 /* Set up a loop over the rowids/primary-keys that were found in the
494 ** where-clause loop above.
496 if( eOnePass
!=ONEPASS_OFF
){
497 assert( nKey
==nPk
); /* OP_Found will use an unpacked key */
498 if( !IsVirtual(pTab
) && aToOpen
[iDataCur
-iTabCur
] ){
499 assert( pPk
!=0 || pTab
->pSelect
!=0 );
500 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, addrBypass
, iKey
, nKey
);
504 addrLoop
= sqlite3VdbeAddOp1(v
, OP_Rewind
, iEphCur
); VdbeCoverage(v
);
505 if( IsVirtual(pTab
) ){
506 sqlite3VdbeAddOp3(v
, OP_Column
, iEphCur
, 0, iKey
);
508 sqlite3VdbeAddOp2(v
, OP_RowData
, iEphCur
, iKey
);
510 assert( nKey
==0 ); /* OP_Found will use a composite key */
512 addrLoop
= sqlite3VdbeAddOp3(v
, OP_RowSetRead
, iRowSet
, 0, iKey
);
518 #ifndef SQLITE_OMIT_VIRTUALTABLE
519 if( IsVirtual(pTab
) ){
520 const char *pVTab
= (const char *)sqlite3GetVTable(db
, pTab
);
521 sqlite3VtabMakeWritable(pParse
, pTab
);
522 sqlite3VdbeAddOp4(v
, OP_VUpdate
, 0, 1, iKey
, pVTab
, P4_VTAB
);
523 sqlite3VdbeChangeP5(v
, OE_Abort
);
524 assert( eOnePass
==ONEPASS_OFF
|| eOnePass
==ONEPASS_SINGLE
);
525 sqlite3MayAbort(pParse
);
526 if( eOnePass
==ONEPASS_SINGLE
&& sqlite3IsToplevel(pParse
) ){
527 pParse
->isMultiWrite
= 0;
532 int count
= (pParse
->nested
==0); /* True to count changes */
533 sqlite3GenerateRowDelete(pParse
, pTab
, pTrigger
, iDataCur
, iIdxCur
,
534 iKey
, nKey
, count
, OE_Default
, eOnePass
, aiCurOnePass
[1]);
537 /* End of the loop over all rowids/primary-keys. */
538 if( eOnePass
!=ONEPASS_OFF
){
539 sqlite3VdbeResolveLabel(v
, addrBypass
);
540 sqlite3WhereEnd(pWInfo
);
542 sqlite3VdbeAddOp2(v
, OP_Next
, iEphCur
, addrLoop
+1); VdbeCoverage(v
);
543 sqlite3VdbeJumpHere(v
, addrLoop
);
545 sqlite3VdbeGoto(v
, addrLoop
);
546 sqlite3VdbeJumpHere(v
, addrLoop
);
548 } /* End non-truncate path */
550 /* Update the sqlite_sequence table by storing the content of the
551 ** maximum rowid counter values recorded while inserting into
552 ** autoincrement tables.
554 if( pParse
->nested
==0 && pParse
->pTriggerTab
==0 ){
555 sqlite3AutoincrementEnd(pParse
);
558 /* Return the number of rows that were deleted. If this routine is
559 ** generating code because of a call to sqlite3NestedParse(), do not
560 ** invoke the callback function.
562 if( (db
->flags
&SQLITE_CountRows
) && !pParse
->nested
&& !pParse
->pTriggerTab
){
563 sqlite3VdbeAddOp2(v
, OP_ResultRow
, memCnt
, 1);
564 sqlite3VdbeSetNumCols(v
, 1);
565 sqlite3VdbeSetColName(v
, 0, COLNAME_NAME
, "rows deleted", SQLITE_STATIC
);
569 sqlite3AuthContextPop(&sContext
);
570 sqlite3SrcListDelete(db
, pTabList
);
571 sqlite3ExprDelete(db
, pWhere
);
572 sqlite3DbFree(db
, aToOpen
);
575 /* Make sure "isView" and other macros defined above are undefined. Otherwise
576 ** they may interfere with compilation of other functions in this file
577 ** (or in another file, if this file becomes part of the amalgamation). */
586 ** This routine generates VDBE code that causes a single row of a
587 ** single table to be deleted. Both the original table entry and
588 ** all indices are removed.
592 ** 1. iDataCur is an open cursor on the btree that is the canonical data
593 ** store for the table. (This will be either the table itself,
594 ** in the case of a rowid table, or the PRIMARY KEY index in the case
595 ** of a WITHOUT ROWID table.)
597 ** 2. Read/write cursors for all indices of pTab must be open as
598 ** cursor number iIdxCur+i for the i-th index.
600 ** 3. The primary key for the row to be deleted must be stored in a
601 ** sequence of nPk memory cells starting at iPk. If nPk==0 that means
602 ** that a search record formed from OP_MakeRecord is contained in the
603 ** single memory location iPk.
606 ** Parameter eMode may be passed either ONEPASS_OFF (0), ONEPASS_SINGLE, or
607 ** ONEPASS_MULTI. If eMode is not ONEPASS_OFF, then the cursor
608 ** iDataCur already points to the row to delete. If eMode is ONEPASS_OFF
609 ** then this function must seek iDataCur to the entry identified by iPk
610 ** and nPk before reading from it.
612 ** If eMode is ONEPASS_MULTI, then this call is being made as part
613 ** of a ONEPASS delete that affects multiple rows. In this case, if
614 ** iIdxNoSeek is a valid cursor number (>=0) and is not the same as
615 ** iDataCur, then its position should be preserved following the delete
616 ** operation. Or, if iIdxNoSeek is not a valid cursor number, the
617 ** position of iDataCur should be preserved instead.
620 ** If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur,
621 ** then it identifies an index cursor (from within array of cursors
622 ** starting at iIdxCur) that already points to the index entry to be deleted.
623 ** Except, this optimization is disabled if there are BEFORE triggers since
624 ** the trigger body might have moved the cursor.
626 void sqlite3GenerateRowDelete(
627 Parse
*pParse
, /* Parsing context */
628 Table
*pTab
, /* Table containing the row to be deleted */
629 Trigger
*pTrigger
, /* List of triggers to (potentially) fire */
630 int iDataCur
, /* Cursor from which column data is extracted */
631 int iIdxCur
, /* First index cursor */
632 int iPk
, /* First memory cell containing the PRIMARY KEY */
633 i16 nPk
, /* Number of PRIMARY KEY memory cells */
634 u8 count
, /* If non-zero, increment the row change counter */
635 u8 onconf
, /* Default ON CONFLICT policy for triggers */
636 u8 eMode
, /* ONEPASS_OFF, _SINGLE, or _MULTI. See above */
637 int iIdxNoSeek
/* Cursor number of cursor that does not need seeking */
639 Vdbe
*v
= pParse
->pVdbe
; /* Vdbe */
640 int iOld
= 0; /* First register in OLD.* array */
641 int iLabel
; /* Label resolved to end of generated code */
642 u8 opSeek
; /* Seek opcode */
644 /* Vdbe is guaranteed to have been allocated by this stage. */
646 VdbeModuleComment((v
, "BEGIN: GenRowDel(%d,%d,%d,%d)",
647 iDataCur
, iIdxCur
, iPk
, (int)nPk
));
649 /* Seek cursor iCur to the row to delete. If this row no longer exists
650 ** (this can happen if a trigger program has already deleted it), do
651 ** not attempt to delete it or fire any DELETE triggers. */
652 iLabel
= sqlite3VdbeMakeLabel(v
);
653 opSeek
= HasRowid(pTab
) ? OP_NotExists
: OP_NotFound
;
654 if( eMode
==ONEPASS_OFF
){
655 sqlite3VdbeAddOp4Int(v
, opSeek
, iDataCur
, iLabel
, iPk
, nPk
);
656 VdbeCoverageIf(v
, opSeek
==OP_NotExists
);
657 VdbeCoverageIf(v
, opSeek
==OP_NotFound
);
660 /* If there are any triggers to fire, allocate a range of registers to
661 ** use for the old.* references in the triggers. */
662 if( sqlite3FkRequired(pParse
, pTab
, 0, 0) || pTrigger
){
663 u32 mask
; /* Mask of OLD.* columns in use */
664 int iCol
; /* Iterator used while populating OLD.* */
665 int addrStart
; /* Start of BEFORE trigger programs */
667 /* TODO: Could use temporary registers here. Also could attempt to
668 ** avoid copying the contents of the rowid register. */
669 mask
= sqlite3TriggerColmask(
670 pParse
, pTrigger
, 0, 0, TRIGGER_BEFORE
|TRIGGER_AFTER
, pTab
, onconf
672 mask
|= sqlite3FkOldmask(pParse
, pTab
);
673 iOld
= pParse
->nMem
+1;
674 pParse
->nMem
+= (1 + pTab
->nCol
);
676 /* Populate the OLD.* pseudo-table register array. These values will be
677 ** used by any BEFORE and AFTER triggers that exist. */
678 sqlite3VdbeAddOp2(v
, OP_Copy
, iPk
, iOld
);
679 for(iCol
=0; iCol
<pTab
->nCol
; iCol
++){
680 testcase( mask
!=0xffffffff && iCol
==31 );
681 testcase( mask
!=0xffffffff && iCol
==32 );
682 if( mask
==0xffffffff || (iCol
<=31 && (mask
& MASKBIT32(iCol
))!=0) ){
683 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, iCol
, iOld
+iCol
+1);
687 /* Invoke BEFORE DELETE trigger programs. */
688 addrStart
= sqlite3VdbeCurrentAddr(v
);
689 sqlite3CodeRowTrigger(pParse
, pTrigger
,
690 TK_DELETE
, 0, TRIGGER_BEFORE
, pTab
, iOld
, onconf
, iLabel
693 /* If any BEFORE triggers were coded, then seek the cursor to the
694 ** row to be deleted again. It may be that the BEFORE triggers moved
695 ** the cursor or already deleted the row that the cursor was
698 ** Also disable the iIdxNoSeek optimization since the BEFORE trigger
699 ** may have moved that cursor.
701 if( addrStart
<sqlite3VdbeCurrentAddr(v
) ){
702 sqlite3VdbeAddOp4Int(v
, opSeek
, iDataCur
, iLabel
, iPk
, nPk
);
703 VdbeCoverageIf(v
, opSeek
==OP_NotExists
);
704 VdbeCoverageIf(v
, opSeek
==OP_NotFound
);
705 testcase( iIdxNoSeek
>=0 );
709 /* Do FK processing. This call checks that any FK constraints that
710 ** refer to this table (i.e. constraints attached to other tables)
711 ** are not violated by deleting this row. */
712 sqlite3FkCheck(pParse
, pTab
, iOld
, 0, 0, 0);
715 /* Delete the index and table entries. Skip this step if pTab is really
716 ** a view (in which case the only effect of the DELETE statement is to
717 ** fire the INSTEAD OF triggers).
719 ** If variable 'count' is non-zero, then this OP_Delete instruction should
720 ** invoke the update-hook. The pre-update-hook, on the other hand should
721 ** be invoked unless table pTab is a system table. The difference is that
722 ** the update-hook is not invoked for rows removed by REPLACE, but the
723 ** pre-update-hook is.
725 if( pTab
->pSelect
==0 ){
727 sqlite3GenerateRowIndexDelete(pParse
, pTab
, iDataCur
, iIdxCur
,0,iIdxNoSeek
);
728 sqlite3VdbeAddOp2(v
, OP_Delete
, iDataCur
, (count
?OPFLAG_NCHANGE
:0));
729 if( pParse
->nested
==0 ){
730 sqlite3VdbeAppendP4(v
, (char*)pTab
, P4_TABLE
);
732 if( eMode
!=ONEPASS_OFF
){
733 sqlite3VdbeChangeP5(v
, OPFLAG_AUXDELETE
);
735 if( iIdxNoSeek
>=0 && iIdxNoSeek
!=iDataCur
){
736 sqlite3VdbeAddOp1(v
, OP_Delete
, iIdxNoSeek
);
738 if( eMode
==ONEPASS_MULTI
) p5
|= OPFLAG_SAVEPOSITION
;
739 sqlite3VdbeChangeP5(v
, p5
);
742 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
743 ** handle rows (possibly in other tables) that refer via a foreign key
744 ** to the row just deleted. */
745 sqlite3FkActions(pParse
, pTab
, 0, iOld
, 0, 0);
747 /* Invoke AFTER DELETE trigger programs. */
748 sqlite3CodeRowTrigger(pParse
, pTrigger
,
749 TK_DELETE
, 0, TRIGGER_AFTER
, pTab
, iOld
, onconf
, iLabel
752 /* Jump here if the row had already been deleted before any BEFORE
753 ** trigger programs were invoked. Or if a trigger program throws a
754 ** RAISE(IGNORE) exception. */
755 sqlite3VdbeResolveLabel(v
, iLabel
);
756 VdbeModuleComment((v
, "END: GenRowDel()"));
760 ** This routine generates VDBE code that causes the deletion of all
761 ** index entries associated with a single row of a single table, pTab
765 ** 1. A read/write cursor "iDataCur" must be open on the canonical storage
766 ** btree for the table pTab. (This will be either the table itself
767 ** for rowid tables or to the primary key index for WITHOUT ROWID
770 ** 2. Read/write cursors for all indices of pTab must be open as
771 ** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex
772 ** index is the 0-th index.)
774 ** 3. The "iDataCur" cursor must be already be positioned on the row
775 ** that is to be deleted.
777 void sqlite3GenerateRowIndexDelete(
778 Parse
*pParse
, /* Parsing and code generating context */
779 Table
*pTab
, /* Table containing the row to be deleted */
780 int iDataCur
, /* Cursor of table holding data. */
781 int iIdxCur
, /* First index cursor */
782 int *aRegIdx
, /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
783 int iIdxNoSeek
/* Do not delete from this cursor */
785 int i
; /* Index loop counter */
786 int r1
= -1; /* Register holding an index key */
787 int iPartIdxLabel
; /* Jump destination for skipping partial index entries */
788 Index
*pIdx
; /* Current index */
789 Index
*pPrior
= 0; /* Prior index */
790 Vdbe
*v
; /* The prepared statement under construction */
791 Index
*pPk
; /* PRIMARY KEY index, or NULL for rowid tables */
794 pPk
= HasRowid(pTab
) ? 0 : sqlite3PrimaryKeyIndex(pTab
);
795 for(i
=0, pIdx
=pTab
->pIndex
; pIdx
; i
++, pIdx
=pIdx
->pNext
){
796 assert( iIdxCur
+i
!=iDataCur
|| pPk
==pIdx
);
797 if( aRegIdx
!=0 && aRegIdx
[i
]==0 ) continue;
798 if( pIdx
==pPk
) continue;
799 if( iIdxCur
+i
==iIdxNoSeek
) continue;
800 VdbeModuleComment((v
, "GenRowIdxDel for %s", pIdx
->zName
));
801 r1
= sqlite3GenerateIndexKey(pParse
, pIdx
, iDataCur
, 0, 1,
802 &iPartIdxLabel
, pPrior
, r1
);
803 sqlite3VdbeAddOp3(v
, OP_IdxDelete
, iIdxCur
+i
, r1
,
804 pIdx
->uniqNotNull
? pIdx
->nKeyCol
: pIdx
->nColumn
);
805 sqlite3ResolvePartIdxLabel(pParse
, iPartIdxLabel
);
811 ** Generate code that will assemble an index key and stores it in register
812 ** regOut. The key with be for index pIdx which is an index on pTab.
813 ** iCur is the index of a cursor open on the pTab table and pointing to
814 ** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then
815 ** iCur must be the cursor of the PRIMARY KEY index.
817 ** Return a register number which is the first in a block of
818 ** registers that holds the elements of the index key. The
819 ** block of registers has already been deallocated by the time
820 ** this routine returns.
822 ** If *piPartIdxLabel is not NULL, fill it in with a label and jump
823 ** to that label if pIdx is a partial index that should be skipped.
824 ** The label should be resolved using sqlite3ResolvePartIdxLabel().
825 ** A partial index should be skipped if its WHERE clause evaluates
826 ** to false or null. If pIdx is not a partial index, *piPartIdxLabel
827 ** will be set to zero which is an empty label that is ignored by
828 ** sqlite3ResolvePartIdxLabel().
830 ** The pPrior and regPrior parameters are used to implement a cache to
831 ** avoid unnecessary register loads. If pPrior is not NULL, then it is
832 ** a pointer to a different index for which an index key has just been
833 ** computed into register regPrior. If the current pIdx index is generating
834 ** its key into the same sequence of registers and if pPrior and pIdx share
835 ** a column in common, then the register corresponding to that column already
836 ** holds the correct value and the loading of that register is skipped.
837 ** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK
838 ** on a table with multiple indices, and especially with the ROWID or
839 ** PRIMARY KEY columns of the index.
841 int sqlite3GenerateIndexKey(
842 Parse
*pParse
, /* Parsing context */
843 Index
*pIdx
, /* The index for which to generate a key */
844 int iDataCur
, /* Cursor number from which to take column data */
845 int regOut
, /* Put the new key into this register if not 0 */
846 int prefixOnly
, /* Compute only a unique prefix of the key */
847 int *piPartIdxLabel
, /* OUT: Jump to this label to skip partial index */
848 Index
*pPrior
, /* Previously generated index key */
849 int regPrior
/* Register holding previous generated key */
851 Vdbe
*v
= pParse
->pVdbe
;
856 if( piPartIdxLabel
){
857 if( pIdx
->pPartIdxWhere
){
858 *piPartIdxLabel
= sqlite3VdbeMakeLabel(v
);
859 pParse
->iSelfTab
= iDataCur
+ 1;
860 sqlite3ExprCachePush(pParse
);
861 sqlite3ExprIfFalseDup(pParse
, pIdx
->pPartIdxWhere
, *piPartIdxLabel
,
863 pParse
->iSelfTab
= 0;
868 nCol
= (prefixOnly
&& pIdx
->uniqNotNull
) ? pIdx
->nKeyCol
: pIdx
->nColumn
;
869 regBase
= sqlite3GetTempRange(pParse
, nCol
);
870 if( pPrior
&& (regBase
!=regPrior
|| pPrior
->pPartIdxWhere
) ) pPrior
= 0;
871 for(j
=0; j
<nCol
; j
++){
873 && pPrior
->aiColumn
[j
]==pIdx
->aiColumn
[j
]
874 && pPrior
->aiColumn
[j
]!=XN_EXPR
876 /* This column was already computed by the previous index */
879 sqlite3ExprCodeLoadIndexColumn(pParse
, pIdx
, iDataCur
, j
, regBase
+j
);
880 /* If the column affinity is REAL but the number is an integer, then it
881 ** might be stored in the table as an integer (using a compact
882 ** representation) then converted to REAL by an OP_RealAffinity opcode.
883 ** But we are getting ready to store this value back into an index, where
884 ** it should be converted by to INTEGER again. So omit the OP_RealAffinity
885 ** opcode if it is present */
886 sqlite3VdbeDeletePriorOpcode(v
, OP_RealAffinity
);
889 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regBase
, nCol
, regOut
);
890 if( pIdx
->pTable
->pSelect
){
891 const char *zAff
= sqlite3IndexAffinityStr(pParse
->db
, pIdx
);
892 sqlite3VdbeChangeP4(v
, -1, zAff
, P4_TRANSIENT
);
895 sqlite3ReleaseTempRange(pParse
, regBase
, nCol
);
900 ** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label
901 ** because it was a partial index, then this routine should be called to
902 ** resolve that label.
904 void sqlite3ResolvePartIdxLabel(Parse
*pParse
, int iLabel
){
906 sqlite3VdbeResolveLabel(pParse
->pVdbe
, iLabel
);
907 sqlite3ExprCachePop(pParse
);