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
= sqlite3LocateTable(pParse
, 0, pItem
->zName
, pItem
->zDatabase
);
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 ephemerial table */
97 sqlite3
*db
= pParse
->db
;
99 pDup
= sqlite3SelectDup(db
, pView
->pSelect
, 0);
103 pWhere
= sqlite3ExprDup(db
, pWhere
, 0);
104 pFrom
= sqlite3SrcListAppend(db
, 0, 0, 0);
106 assert( pFrom
->nSrc
==1 );
107 pFrom
->a
[0].zAlias
= sqlite3DbStrDup(db
, pView
->zName
);
108 pFrom
->a
[0].pSelect
= pDup
;
109 assert( pFrom
->a
[0].pOn
==0 );
110 assert( pFrom
->a
[0].pUsing
==0 );
112 sqlite3SelectDelete(db
, pDup
);
114 pDup
= sqlite3SelectNew(pParse
, 0, pFrom
, pWhere
, 0, 0, 0, 0, 0, 0);
116 sqlite3SelectDestInit(&dest
, SRT_EphemTab
, iCur
);
117 sqlite3Select(pParse
, pDup
, &dest
);
118 sqlite3SelectDelete(db
, pDup
);
120 #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
122 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
124 ** Generate an expression tree to implement the WHERE, ORDER BY,
125 ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
127 ** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
128 ** \__________________________/
129 ** pLimitWhere (pInClause)
131 Expr
*sqlite3LimitWhere(
132 Parse
*pParse
, /* The parser context */
133 SrcList
*pSrc
, /* the FROM clause -- which tables to scan */
134 Expr
*pWhere
, /* The WHERE clause. May be null */
135 ExprList
*pOrderBy
, /* The ORDER BY clause. May be null */
136 Expr
*pLimit
, /* The LIMIT clause. May be null */
137 Expr
*pOffset
, /* The OFFSET clause. May be null */
138 char *zStmtType
/* Either DELETE or UPDATE. For error messages. */
140 Expr
*pWhereRowid
= NULL
; /* WHERE rowid .. */
141 Expr
*pInClause
= NULL
; /* WHERE rowid IN ( select ) */
142 Expr
*pSelectRowid
= NULL
; /* SELECT rowid ... */
143 ExprList
*pEList
= NULL
; /* Expression list contaning only pSelectRowid */
144 SrcList
*pSelectSrc
= NULL
; /* SELECT rowid FROM x ... (dup of pSrc) */
145 Select
*pSelect
= NULL
; /* Complete SELECT tree */
147 /* Check that there isn't an ORDER BY without a LIMIT clause.
149 if( pOrderBy
&& (pLimit
== 0) ) {
150 sqlite3ErrorMsg(pParse
, "ORDER BY without LIMIT on %s", zStmtType
);
151 pParse
->parseError
= 1;
152 goto limit_where_cleanup_2
;
155 /* We only need to generate a select expression if there
156 ** is a limit/offset term to enforce.
159 /* if pLimit is null, pOffset will always be null as well. */
160 assert( pOffset
== 0 );
164 /* Generate a select expression tree to enforce the limit/offset
165 ** term for the DELETE or UPDATE statement. For example:
166 ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
168 ** DELETE FROM table_a WHERE rowid IN (
169 ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
173 pSelectRowid
= sqlite3PExpr(pParse
, TK_ROW
, 0, 0, 0);
174 if( pSelectRowid
== 0 ) goto limit_where_cleanup_2
;
175 pEList
= sqlite3ExprListAppend(pParse
, 0, pSelectRowid
);
176 if( pEList
== 0 ) goto limit_where_cleanup_2
;
178 /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
179 ** and the SELECT subtree. */
180 pSelectSrc
= sqlite3SrcListDup(pParse
->db
, pSrc
, 0);
181 if( pSelectSrc
== 0 ) {
182 sqlite3ExprListDelete(pParse
->db
, pEList
);
183 goto limit_where_cleanup_2
;
186 /* generate the SELECT expression tree. */
187 pSelect
= sqlite3SelectNew(pParse
,pEList
,pSelectSrc
,pWhere
,0,0,
188 pOrderBy
,0,pLimit
,pOffset
);
189 if( pSelect
== 0 ) return 0;
191 /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
192 pWhereRowid
= sqlite3PExpr(pParse
, TK_ROW
, 0, 0, 0);
193 if( pWhereRowid
== 0 ) goto limit_where_cleanup_1
;
194 pInClause
= sqlite3PExpr(pParse
, TK_IN
, pWhereRowid
, 0, 0);
195 if( pInClause
== 0 ) goto limit_where_cleanup_1
;
197 pInClause
->x
.pSelect
= pSelect
;
198 pInClause
->flags
|= EP_xIsSelect
;
199 sqlite3ExprSetHeight(pParse
, pInClause
);
202 /* something went wrong. clean up anything allocated. */
203 limit_where_cleanup_1
:
204 sqlite3SelectDelete(pParse
->db
, pSelect
);
207 limit_where_cleanup_2
:
208 sqlite3ExprDelete(pParse
->db
, pWhere
);
209 sqlite3ExprListDelete(pParse
->db
, pOrderBy
);
210 sqlite3ExprDelete(pParse
->db
, pLimit
);
211 sqlite3ExprDelete(pParse
->db
, pOffset
);
214 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
217 ** Generate code for a DELETE FROM statement.
219 ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
220 ** \________/ \________________/
223 void sqlite3DeleteFrom(
224 Parse
*pParse
, /* The parser context */
225 SrcList
*pTabList
, /* The table from which we should delete things */
226 Expr
*pWhere
/* The WHERE clause. May be null */
228 Vdbe
*v
; /* The virtual database engine */
229 Table
*pTab
; /* The table from which records will be deleted */
230 const char *zDb
; /* Name of database holding pTab */
231 int end
, addr
= 0; /* A couple addresses of generated code */
232 int i
; /* Loop counter */
233 WhereInfo
*pWInfo
; /* Information about the WHERE clause */
234 Index
*pIdx
; /* For looping over indices of the table */
235 int iCur
; /* VDBE Cursor number for pTab */
236 sqlite3
*db
; /* Main database structure */
237 AuthContext sContext
; /* Authorization context */
238 NameContext sNC
; /* Name context to resolve expressions in */
239 int iDb
; /* Database number */
240 int memCnt
= -1; /* Memory cell used for change counting */
241 int rcauth
; /* Value returned by authorization callback */
243 #ifndef SQLITE_OMIT_TRIGGER
244 int isView
; /* True if attempting to delete from a view */
245 Trigger
*pTrigger
; /* List of table triggers, if required */
248 memset(&sContext
, 0, sizeof(sContext
));
250 if( pParse
->nErr
|| db
->mallocFailed
){
251 goto delete_from_cleanup
;
253 assert( pTabList
->nSrc
==1 );
255 /* Locate the table which we want to delete. This table has to be
256 ** put in an SrcList structure because some of the subroutines we
257 ** will be calling are designed to work with multiple tables and expect
258 ** an SrcList* parameter instead of just a Table* parameter.
260 pTab
= sqlite3SrcListLookup(pParse
, pTabList
);
261 if( pTab
==0 ) goto delete_from_cleanup
;
263 /* Figure out if we have any triggers and if the table being
264 ** deleted from is a view
266 #ifndef SQLITE_OMIT_TRIGGER
267 pTrigger
= sqlite3TriggersExist(pParse
, pTab
, TK_DELETE
, 0, 0);
268 isView
= pTab
->pSelect
!=0;
273 #ifdef SQLITE_OMIT_VIEW
278 /* If pTab is really a view, make sure it has been initialized.
280 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ){
281 goto delete_from_cleanup
;
284 if( sqlite3IsReadOnly(pParse
, pTab
, (pTrigger
?1:0)) ){
285 goto delete_from_cleanup
;
287 iDb
= sqlite3SchemaToIndex(db
, pTab
->pSchema
);
288 assert( iDb
<db
->nDb
);
289 zDb
= db
->aDb
[iDb
].zName
;
290 rcauth
= sqlite3AuthCheck(pParse
, SQLITE_DELETE
, pTab
->zName
, 0, zDb
);
291 assert( rcauth
==SQLITE_OK
|| rcauth
==SQLITE_DENY
|| rcauth
==SQLITE_IGNORE
);
292 if( rcauth
==SQLITE_DENY
){
293 goto delete_from_cleanup
;
295 assert(!isView
|| pTrigger
);
297 /* Assign cursor number to the table and all its indices.
299 assert( pTabList
->nSrc
==1 );
300 iCur
= pTabList
->a
[0].iCursor
= pParse
->nTab
++;
301 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
305 /* Start the view context
308 sqlite3AuthContextPush(pParse
, &sContext
, pTab
->zName
);
311 /* Begin generating code.
313 v
= sqlite3GetVdbe(pParse
);
315 goto delete_from_cleanup
;
317 if( pParse
->nested
==0 ) sqlite3VdbeCountChanges(v
);
318 sqlite3BeginWriteOperation(pParse
, 1, iDb
);
320 /* If we are trying to delete from a view, realize that view into
321 ** a ephemeral table.
323 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
325 sqlite3MaterializeView(pParse
, pTab
, pWhere
, iCur
);
329 /* Resolve the column names in the WHERE clause.
331 memset(&sNC
, 0, sizeof(sNC
));
333 sNC
.pSrcList
= pTabList
;
334 if( sqlite3ResolveExprNames(&sNC
, pWhere
) ){
335 goto delete_from_cleanup
;
338 /* Initialize the counter of the number of rows deleted, if
339 ** we are counting rows.
341 if( db
->flags
& SQLITE_CountRows
){
342 memCnt
= ++pParse
->nMem
;
343 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, memCnt
);
346 #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
347 /* Special case: A DELETE without a WHERE clause deletes everything.
348 ** It is easier just to erase the whole table. Prior to version 3.6.5,
349 ** this optimization caused the row change count (the value returned by
350 ** API function sqlite3_count_changes) to be set incorrectly. */
351 if( rcauth
==SQLITE_OK
&& pWhere
==0 && !pTrigger
&& !IsVirtual(pTab
)
352 && 0==sqlite3FkRequired(pParse
, pTab
, 0, 0)
355 sqlite3VdbeAddOp4(v
, OP_Clear
, pTab
->tnum
, iDb
, memCnt
,
356 pTab
->zName
, P4_STATIC
);
357 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
358 assert( pIdx
->pSchema
==pTab
->pSchema
);
359 sqlite3VdbeAddOp2(v
, OP_Clear
, pIdx
->tnum
, iDb
);
362 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
363 /* The usual case: There is a WHERE clause so we have to scan through
364 ** the table and pick which records to delete.
367 int iRowSet
= ++pParse
->nMem
; /* Register for rowset of rows to delete */
368 int iRowid
= ++pParse
->nMem
; /* Used for storing rowid values. */
369 int regRowid
; /* Actual register containing rowids */
371 /* Collect rowids of every row to be deleted.
373 sqlite3VdbeAddOp2(v
, OP_Null
, 0, iRowSet
);
374 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
,0,WHERE_DUPLICATES_OK
);
375 if( pWInfo
==0 ) goto delete_from_cleanup
;
376 regRowid
= sqlite3ExprCodeGetColumn(pParse
, pTab
, -1, iCur
, iRowid
);
377 sqlite3VdbeAddOp2(v
, OP_RowSetAdd
, iRowSet
, regRowid
);
378 if( db
->flags
& SQLITE_CountRows
){
379 sqlite3VdbeAddOp2(v
, OP_AddImm
, memCnt
, 1);
381 sqlite3WhereEnd(pWInfo
);
383 /* Delete every item whose key was written to the list during the
384 ** database scan. We have to delete items after the scan is complete
385 ** because deleting an item can change the scan order. */
386 end
= sqlite3VdbeMakeLabel(v
);
388 /* Unless this is a view, open cursors for the table we are
389 ** deleting from and all its indices. If this is a view, then the
390 ** only effect this statement has is to fire the INSTEAD OF
393 sqlite3OpenTableAndIndices(pParse
, pTab
, iCur
, OP_OpenWrite
);
396 addr
= sqlite3VdbeAddOp3(v
, OP_RowSetRead
, iRowSet
, end
, iRowid
);
399 #ifndef SQLITE_OMIT_VIRTUALTABLE
400 if( IsVirtual(pTab
) ){
401 const char *pVTab
= (const char *)sqlite3GetVTable(db
, pTab
);
402 sqlite3VtabMakeWritable(pParse
, pTab
);
403 sqlite3VdbeAddOp4(v
, OP_VUpdate
, 0, 1, iRowid
, pVTab
, P4_VTAB
);
404 sqlite3MayAbort(pParse
);
408 int count
= (pParse
->nested
==0); /* True to count changes */
409 sqlite3GenerateRowDelete(pParse
, pTab
, iCur
, iRowid
, count
, pTrigger
, OE_Default
);
412 /* End of the delete loop */
413 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, addr
);
414 sqlite3VdbeResolveLabel(v
, end
);
416 /* Close the cursors open on the table and its indexes. */
417 if( !isView
&& !IsVirtual(pTab
) ){
418 for(i
=1, pIdx
=pTab
->pIndex
; pIdx
; i
++, pIdx
=pIdx
->pNext
){
419 sqlite3VdbeAddOp2(v
, OP_Close
, iCur
+ i
, pIdx
->tnum
);
421 sqlite3VdbeAddOp1(v
, OP_Close
, iCur
);
425 /* Update the sqlite_sequence table by storing the content of the
426 ** maximum rowid counter values recorded while inserting into
427 ** autoincrement tables.
429 if( pParse
->nested
==0 && pParse
->pTriggerTab
==0 ){
430 sqlite3AutoincrementEnd(pParse
);
433 /* Return the number of rows that were deleted. If this routine is
434 ** generating code because of a call to sqlite3NestedParse(), do not
435 ** invoke the callback function.
437 if( (db
->flags
&SQLITE_CountRows
) && !pParse
->nested
&& !pParse
->pTriggerTab
){
438 sqlite3VdbeAddOp2(v
, OP_ResultRow
, memCnt
, 1);
439 sqlite3VdbeSetNumCols(v
, 1);
440 sqlite3VdbeSetColName(v
, 0, COLNAME_NAME
, "rows deleted", SQLITE_STATIC
);
444 sqlite3AuthContextPop(&sContext
);
445 sqlite3SrcListDelete(db
, pTabList
);
446 sqlite3ExprDelete(db
, pWhere
);
449 /* Make sure "isView" and other macros defined above are undefined. Otherwise
450 ** thely may interfere with compilation of other functions in this file
451 ** (or in another file, if this file becomes part of the amalgamation). */
460 ** This routine generates VDBE code that causes a single row of a
461 ** single table to be deleted.
463 ** The VDBE must be in a particular state when this routine is called.
464 ** These are the requirements:
466 ** 1. A read/write cursor pointing to pTab, the table containing the row
467 ** to be deleted, must be opened as cursor number $iCur.
469 ** 2. Read/write cursors for all indices of pTab must be open as
470 ** cursor number base+i for the i-th index.
472 ** 3. The record number of the row to be deleted must be stored in
473 ** memory cell iRowid.
475 ** This routine generates code to remove both the table record and all
476 ** index entries that point to that record.
478 void sqlite3GenerateRowDelete(
479 Parse
*pParse
, /* Parsing context */
480 Table
*pTab
, /* Table containing the row to be deleted */
481 int iCur
, /* Cursor number for the table */
482 int iRowid
, /* Memory cell that contains the rowid to delete */
483 int count
, /* If non-zero, increment the row change counter */
484 Trigger
*pTrigger
, /* List of triggers to (potentially) fire */
485 int onconf
/* Default ON CONFLICT policy for triggers */
487 Vdbe
*v
= pParse
->pVdbe
; /* Vdbe */
488 int iOld
= 0; /* First register in OLD.* array */
489 int iLabel
; /* Label resolved to end of generated code */
491 /* Vdbe is guaranteed to have been allocated by this stage. */
494 /* Seek cursor iCur to the row to delete. If this row no longer exists
495 ** (this can happen if a trigger program has already deleted it), do
496 ** not attempt to delete it or fire any DELETE triggers. */
497 iLabel
= sqlite3VdbeMakeLabel(v
);
498 sqlite3VdbeAddOp3(v
, OP_NotExists
, iCur
, iLabel
, iRowid
);
500 /* If there are any triggers to fire, allocate a range of registers to
501 ** use for the old.* references in the triggers. */
502 if( sqlite3FkRequired(pParse
, pTab
, 0, 0) || pTrigger
){
503 u32 mask
; /* Mask of OLD.* columns in use */
504 int iCol
; /* Iterator used while populating OLD.* */
506 /* TODO: Could use temporary registers here. Also could attempt to
507 ** avoid copying the contents of the rowid register. */
508 mask
= sqlite3TriggerColmask(
509 pParse
, pTrigger
, 0, 0, TRIGGER_BEFORE
|TRIGGER_AFTER
, pTab
, onconf
511 mask
|= sqlite3FkOldmask(pParse
, pTab
);
512 iOld
= pParse
->nMem
+1;
513 pParse
->nMem
+= (1 + pTab
->nCol
);
515 /* Populate the OLD.* pseudo-table register array. These values will be
516 ** used by any BEFORE and AFTER triggers that exist. */
517 sqlite3VdbeAddOp2(v
, OP_Copy
, iRowid
, iOld
);
518 for(iCol
=0; iCol
<pTab
->nCol
; iCol
++){
519 if( mask
==0xffffffff || mask
&(1<<iCol
) ){
520 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iCur
, iCol
, iOld
+iCol
+1);
524 /* Invoke BEFORE DELETE trigger programs. */
525 sqlite3CodeRowTrigger(pParse
, pTrigger
,
526 TK_DELETE
, 0, TRIGGER_BEFORE
, pTab
, iOld
, onconf
, iLabel
529 /* Seek the cursor to the row to be deleted again. It may be that
530 ** the BEFORE triggers coded above have already removed the row
531 ** being deleted. Do not attempt to delete the row a second time, and
532 ** do not fire AFTER triggers. */
533 sqlite3VdbeAddOp3(v
, OP_NotExists
, iCur
, iLabel
, iRowid
);
535 /* Do FK processing. This call checks that any FK constraints that
536 ** refer to this table (i.e. constraints attached to other tables)
537 ** are not violated by deleting this row. */
538 sqlite3FkCheck(pParse
, pTab
, iOld
, 0);
541 /* Delete the index and table entries. Skip this step if pTab is really
542 ** a view (in which case the only effect of the DELETE statement is to
543 ** fire the INSTEAD OF triggers). */
544 if( pTab
->pSelect
==0 ){
545 sqlite3GenerateRowIndexDelete(pParse
, pTab
, iCur
, 0);
546 sqlite3VdbeAddOp2(v
, OP_Delete
, iCur
, (count
?OPFLAG_NCHANGE
:0));
548 sqlite3VdbeChangeP4(v
, -1, pTab
->zName
, P4_TRANSIENT
);
552 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
553 ** handle rows (possibly in other tables) that refer via a foreign key
554 ** to the row just deleted. */
555 sqlite3FkActions(pParse
, pTab
, 0, iOld
);
557 /* Invoke AFTER DELETE trigger programs. */
558 sqlite3CodeRowTrigger(pParse
, pTrigger
,
559 TK_DELETE
, 0, TRIGGER_AFTER
, pTab
, iOld
, onconf
, iLabel
562 /* Jump here if the row had already been deleted before any BEFORE
563 ** trigger programs were invoked. Or if a trigger program throws a
564 ** RAISE(IGNORE) exception. */
565 sqlite3VdbeResolveLabel(v
, iLabel
);
569 ** This routine generates VDBE code that causes the deletion of all
570 ** index entries associated with a single row of a single table.
572 ** The VDBE must be in a particular state when this routine is called.
573 ** These are the requirements:
575 ** 1. A read/write cursor pointing to pTab, the table containing the row
576 ** to be deleted, must be opened as cursor number "iCur".
578 ** 2. Read/write cursors for all indices of pTab must be open as
579 ** cursor number iCur+i for the i-th index.
581 ** 3. The "iCur" cursor must be pointing to the row that is to be
584 void sqlite3GenerateRowIndexDelete(
585 Parse
*pParse
, /* Parsing and code generating context */
586 Table
*pTab
, /* Table containing the row to be deleted */
587 int iCur
, /* Cursor number for the table */
588 int *aRegIdx
/* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
594 for(i
=1, pIdx
=pTab
->pIndex
; pIdx
; i
++, pIdx
=pIdx
->pNext
){
595 if( aRegIdx
!=0 && aRegIdx
[i
-1]==0 ) continue;
596 r1
= sqlite3GenerateIndexKey(pParse
, pIdx
, iCur
, 0, 0);
597 sqlite3VdbeAddOp3(pParse
->pVdbe
, OP_IdxDelete
, iCur
+i
, r1
,pIdx
->nColumn
+1);
602 ** Generate code that will assemble an index key and put it in register
603 ** regOut. The key with be for index pIdx which is an index on pTab.
604 ** iCur is the index of a cursor open on the pTab table and pointing to
605 ** the entry that needs indexing.
607 ** Return a register number which is the first in a block of
608 ** registers that holds the elements of the index key. The
609 ** block of registers has already been deallocated by the time
610 ** this routine returns.
612 int sqlite3GenerateIndexKey(
613 Parse
*pParse
, /* Parsing context */
614 Index
*pIdx
, /* The index for which to generate a key */
615 int iCur
, /* Cursor number for the pIdx->pTable table */
616 int regOut
, /* Write the new index key to this register */
617 int doMakeRec
/* Run the OP_MakeRecord instruction if true */
619 Vdbe
*v
= pParse
->pVdbe
;
621 Table
*pTab
= pIdx
->pTable
;
625 nCol
= pIdx
->nColumn
;
626 regBase
= sqlite3GetTempRange(pParse
, nCol
+1);
627 sqlite3VdbeAddOp2(v
, OP_Rowid
, iCur
, regBase
+nCol
);
628 for(j
=0; j
<nCol
; j
++){
629 int idx
= pIdx
->aiColumn
[j
];
630 if( idx
==pTab
->iPKey
){
631 sqlite3VdbeAddOp2(v
, OP_SCopy
, regBase
+nCol
, regBase
+j
);
633 sqlite3VdbeAddOp3(v
, OP_Column
, iCur
, idx
, regBase
+j
);
634 sqlite3ColumnDefault(v
, pTab
, idx
, -1);
638 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regBase
, nCol
+1, regOut
);
639 sqlite3VdbeChangeP4(v
, -1, sqlite3IndexAffinityStr(v
, pIdx
), P4_TRANSIENT
);
641 sqlite3ReleaseTempRange(pParse
, regBase
, nCol
+1);