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 */
sqlite3SrcListLookup(Parse * pParse,SrcList * pSrc)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 = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
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 */
sqlite3IsReadOnly(Parse * pParse,Table * pTab,int viewOk)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 */
sqlite3MaterializeView(Parse * pParse,Table * pView,Expr * pWhere,int iCur)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 */
94 ){
95 SelectDest dest;
96 Select *pDup;
97 sqlite3 *db = pParse->db;
98
99 pDup = sqlite3SelectDup(db, pView->pSelect, 0);
100 if( pWhere ){
101 SrcList *pFrom;
102
103 pWhere = sqlite3ExprDup(db, pWhere, 0);
104 pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
105 if( pFrom ){
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 );
111 }else{
112 sqlite3SelectDelete(db, pDup);
113 }
114 pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
115 }
116 sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
117 sqlite3Select(pParse, pDup, &dest);
118 sqlite3SelectDelete(db, pDup);
119 }
120 #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
121
122 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
123 /*
124 ** Generate an expression tree to implement the WHERE, ORDER BY,
125 ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
126 **
127 ** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
128 ** \__________________________/
129 ** pLimitWhere (pInClause)
130 */
sqlite3LimitWhere(Parse * pParse,SrcList * pSrc,Expr * pWhere,ExprList * pOrderBy,Expr * pLimit,Expr * pOffset,char * zStmtType)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. */
139 ){
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 */
146
147 /* Check that there isn't an ORDER BY without a LIMIT clause.
148 */
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;
153 }
154
155 /* We only need to generate a select expression if there
156 ** is a limit/offset term to enforce.
157 */
158 if( pLimit == 0 ) {
159 /* if pLimit is null, pOffset will always be null as well. */
160 assert( pOffset == 0 );
161 return pWhere;
162 }
163
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
167 ** becomes:
168 ** DELETE FROM table_a WHERE rowid IN (
169 ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
170 ** );
171 */
172
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;
177
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;
184 }
185
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;
190
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;
196
197 pInClause->x.pSelect = pSelect;
198 pInClause->flags |= EP_xIsSelect;
199 sqlite3ExprSetHeight(pParse, pInClause);
200 return pInClause;
201
202 /* something went wrong. clean up anything allocated. */
203 limit_where_cleanup_1:
204 sqlite3SelectDelete(pParse->db, pSelect);
205 return 0;
206
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);
212 return 0;
213 }
214 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
215
216 /*
217 ** Generate code for a DELETE FROM statement.
218 **
219 ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
220 ** \________/ \________________/
221 ** pTabList pWhere
222 */
sqlite3DeleteFrom(Parse * pParse,SrcList * pTabList,Expr * pWhere)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 */
227 ){
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 */
242
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 */
246 #endif
247
248 memset(&sContext, 0, sizeof(sContext));
249 db = pParse->db;
250 if( pParse->nErr || db->mallocFailed ){
251 goto delete_from_cleanup;
252 }
253 assert( pTabList->nSrc==1 );
254
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.
259 */
260 pTab = sqlite3SrcListLookup(pParse, pTabList);
261 if( pTab==0 ) goto delete_from_cleanup;
262
263 /* Figure out if we have any triggers and if the table being
264 ** deleted from is a view
265 */
266 #ifndef SQLITE_OMIT_TRIGGER
267 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
268 isView = pTab->pSelect!=0;
269 #else
270 # define pTrigger 0
271 # define isView 0
272 #endif
273 #ifdef SQLITE_OMIT_VIEW
274 # undef isView
275 # define isView 0
276 #endif
277
278 /* If pTab is really a view, make sure it has been initialized.
279 */
280 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
281 goto delete_from_cleanup;
282 }
283
284 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
285 goto delete_from_cleanup;
286 }
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;
294 }
295 assert(!isView || pTrigger);
296
297 /* Assign cursor number to the table and all its indices.
298 */
299 assert( pTabList->nSrc==1 );
300 iCur = pTabList->a[0].iCursor = pParse->nTab++;
301 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
302 pParse->nTab++;
303 }
304
305 /* Start the view context
306 */
307 if( isView ){
308 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
309 }
310
311 /* Begin generating code.
312 */
313 v = sqlite3GetVdbe(pParse);
314 if( v==0 ){
315 goto delete_from_cleanup;
316 }
317 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
318 sqlite3BeginWriteOperation(pParse, 1, iDb);
319
320 /* If we are trying to delete from a view, realize that view into
321 ** a ephemeral table.
322 */
323 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
324 if( isView ){
325 sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
326 }
327 #endif
328
329 /* Resolve the column names in the WHERE clause.
330 */
331 memset(&sNC, 0, sizeof(sNC));
332 sNC.pParse = pParse;
333 sNC.pSrcList = pTabList;
334 if( sqlite3ResolveExprNames(&sNC, pWhere) ){
335 goto delete_from_cleanup;
336 }
337
338 /* Initialize the counter of the number of rows deleted, if
339 ** we are counting rows.
340 */
341 if( db->flags & SQLITE_CountRows ){
342 memCnt = ++pParse->nMem;
343 sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
344 }
345
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)
353 ){
354 assert( !isView );
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);
360 }
361 }else
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.
365 */
366 {
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 */
370
371 /* Collect rowids of every row to be deleted.
372 */
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);
380 }
381 sqlite3WhereEnd(pWInfo);
382
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);
387
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
391 ** triggers. */
392 if( !isView ){
393 sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
394 }
395
396 addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);
397
398 /* Delete the row */
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);
405 }else
406 #endif
407 {
408 int count = (pParse->nested==0); /* True to count changes */
409 sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
410 }
411
412 /* End of the delete loop */
413 sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
414 sqlite3VdbeResolveLabel(v, end);
415
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);
420 }
421 sqlite3VdbeAddOp1(v, OP_Close, iCur);
422 }
423 }
424
425 /* Update the sqlite_sequence table by storing the content of the
426 ** maximum rowid counter values recorded while inserting into
427 ** autoincrement tables.
428 */
429 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
430 sqlite3AutoincrementEnd(pParse);
431 }
432
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.
436 */
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);
441 }
442
443 delete_from_cleanup:
444 sqlite3AuthContextPop(&sContext);
445 sqlite3SrcListDelete(db, pTabList);
446 sqlite3ExprDelete(db, pWhere);
447 return;
448 }
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). */
452 #ifdef isView
453 #undef isView
454 #endif
455 #ifdef pTrigger
456 #undef pTrigger
457 #endif
458
459 /*
460 ** This routine generates VDBE code that causes a single row of a
461 ** single table to be deleted.
462 **
463 ** The VDBE must be in a particular state when this routine is called.
464 ** These are the requirements:
465 **
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.
468 **
469 ** 2. Read/write cursors for all indices of pTab must be open as
470 ** cursor number base+i for the i-th index.
471 **
472 ** 3. The record number of the row to be deleted must be stored in
473 ** memory cell iRowid.
474 **
475 ** This routine generates code to remove both the table record and all
476 ** index entries that point to that record.
477 */
sqlite3GenerateRowDelete(Parse * pParse,Table * pTab,int iCur,int iRowid,int count,Trigger * pTrigger,int onconf)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 */
486 ){
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 */
490
491 /* Vdbe is guaranteed to have been allocated by this stage. */
492 assert( v );
493
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);
499
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.* */
505
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
510 );
511 mask |= sqlite3FkOldmask(pParse, pTab);
512 iOld = pParse->nMem+1;
513 pParse->nMem += (1 + pTab->nCol);
514
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);
521 }
522 }
523
524 /* Invoke BEFORE DELETE trigger programs. */
525 sqlite3CodeRowTrigger(pParse, pTrigger,
526 TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
527 );
528
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);
534
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);
539 }
540
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));
547 if( count ){
548 sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
549 }
550 }
551
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);
556
557 /* Invoke AFTER DELETE trigger programs. */
558 sqlite3CodeRowTrigger(pParse, pTrigger,
559 TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
560 );
561
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);
566 }
567
568 /*
569 ** This routine generates VDBE code that causes the deletion of all
570 ** index entries associated with a single row of a single table.
571 **
572 ** The VDBE must be in a particular state when this routine is called.
573 ** These are the requirements:
574 **
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".
577 **
578 ** 2. Read/write cursors for all indices of pTab must be open as
579 ** cursor number iCur+i for the i-th index.
580 **
581 ** 3. The "iCur" cursor must be pointing to the row that is to be
582 ** deleted.
583 */
sqlite3GenerateRowIndexDelete(Parse * pParse,Table * pTab,int iCur,int * aRegIdx)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 */
589 ){
590 int i;
591 Index *pIdx;
592 int r1;
593
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);
598 }
599 }
600
601 /*
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.
606 **
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.
611 */
sqlite3GenerateIndexKey(Parse * pParse,Index * pIdx,int iCur,int regOut,int doMakeRec)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 */
618 ){
619 Vdbe *v = pParse->pVdbe;
620 int j;
621 Table *pTab = pIdx->pTable;
622 int regBase;
623 int nCol;
624
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);
632 }else{
633 sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
634 sqlite3ColumnDefault(v, pTab, idx, -1);
635 }
636 }
637 if( doMakeRec ){
638 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
639 sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), P4_TRANSIENT);
640 }
641 sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
642 return regBase;
643 }
644