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 = 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: */
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 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: */
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: goto limit_where_cleanup_2;
152: }
153:
154: /* We only need to generate a select expression if there
155: ** is a limit/offset term to enforce.
156: */
157: if( pLimit == 0 ) {
158: /* if pLimit is null, pOffset will always be null as well. */
159: assert( pOffset == 0 );
160: return pWhere;
161: }
162:
163: /* Generate a select expression tree to enforce the limit/offset
164: ** term for the DELETE or UPDATE statement. For example:
165: ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
166: ** becomes:
167: ** DELETE FROM table_a WHERE rowid IN (
168: ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
169: ** );
170: */
171:
172: pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
173: if( pSelectRowid == 0 ) goto limit_where_cleanup_2;
174: pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);
175: if( pEList == 0 ) goto limit_where_cleanup_2;
176:
177: /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
178: ** and the SELECT subtree. */
179: pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
180: if( pSelectSrc == 0 ) {
181: sqlite3ExprListDelete(pParse->db, pEList);
182: goto limit_where_cleanup_2;
183: }
184:
185: /* generate the SELECT expression tree. */
186: pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
187: pOrderBy,0,pLimit,pOffset);
188: if( pSelect == 0 ) return 0;
189:
190: /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
191: pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
192: if( pWhereRowid == 0 ) goto limit_where_cleanup_1;
193: pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
194: if( pInClause == 0 ) goto limit_where_cleanup_1;
195:
196: pInClause->x.pSelect = pSelect;
197: pInClause->flags |= EP_xIsSelect;
198: sqlite3ExprSetHeight(pParse, pInClause);
199: return pInClause;
200:
201: /* something went wrong. clean up anything allocated. */
202: limit_where_cleanup_1:
203: sqlite3SelectDelete(pParse->db, pSelect);
204: return 0;
205:
206: limit_where_cleanup_2:
207: sqlite3ExprDelete(pParse->db, pWhere);
208: sqlite3ExprListDelete(pParse->db, pOrderBy);
209: sqlite3ExprDelete(pParse->db, pLimit);
210: sqlite3ExprDelete(pParse->db, pOffset);
211: return 0;
212: }
213: #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
214:
215: /*
216: ** Generate code for a DELETE FROM statement.
217: **
218: ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
219: ** \________/ \________________/
220: ** pTabList pWhere
221: */
222: void sqlite3DeleteFrom(
223: Parse *pParse, /* The parser context */
224: SrcList *pTabList, /* The table from which we should delete things */
225: Expr *pWhere /* The WHERE clause. May be null */
226: ){
227: Vdbe *v; /* The virtual database engine */
228: Table *pTab; /* The table from which records will be deleted */
229: const char *zDb; /* Name of database holding pTab */
230: int end, addr = 0; /* A couple addresses of generated code */
231: int i; /* Loop counter */
232: WhereInfo *pWInfo; /* Information about the WHERE clause */
233: Index *pIdx; /* For looping over indices of the table */
234: int iCur; /* VDBE Cursor number for pTab */
235: sqlite3 *db; /* Main database structure */
236: AuthContext sContext; /* Authorization context */
237: NameContext sNC; /* Name context to resolve expressions in */
238: int iDb; /* Database number */
239: int memCnt = -1; /* Memory cell used for change counting */
240: int rcauth; /* Value returned by authorization callback */
241:
242: #ifndef SQLITE_OMIT_TRIGGER
243: int isView; /* True if attempting to delete from a view */
244: Trigger *pTrigger; /* List of table triggers, if required */
245: #endif
246:
247: memset(&sContext, 0, sizeof(sContext));
248: db = pParse->db;
249: if( pParse->nErr || db->mallocFailed ){
250: goto delete_from_cleanup;
251: }
252: assert( pTabList->nSrc==1 );
253:
254: /* Locate the table which we want to delete. This table has to be
255: ** put in an SrcList structure because some of the subroutines we
256: ** will be calling are designed to work with multiple tables and expect
257: ** an SrcList* parameter instead of just a Table* parameter.
258: */
259: pTab = sqlite3SrcListLookup(pParse, pTabList);
260: if( pTab==0 ) goto delete_from_cleanup;
261:
262: /* Figure out if we have any triggers and if the table being
263: ** deleted from is a view
264: */
265: #ifndef SQLITE_OMIT_TRIGGER
266: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
267: isView = pTab->pSelect!=0;
268: #else
269: # define pTrigger 0
270: # define isView 0
271: #endif
272: #ifdef SQLITE_OMIT_VIEW
273: # undef isView
274: # define isView 0
275: #endif
276:
277: /* If pTab is really a view, make sure it has been initialized.
278: */
279: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
280: goto delete_from_cleanup;
281: }
282:
283: if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
284: goto delete_from_cleanup;
285: }
286: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
287: assert( iDb<db->nDb );
288: zDb = db->aDb[iDb].zName;
289: rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
290: assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
291: if( rcauth==SQLITE_DENY ){
292: goto delete_from_cleanup;
293: }
294: assert(!isView || pTrigger);
295:
296: /* Assign cursor number to the table and all its indices.
297: */
298: assert( pTabList->nSrc==1 );
299: iCur = pTabList->a[0].iCursor = pParse->nTab++;
300: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
301: pParse->nTab++;
302: }
303:
304: /* Start the view context
305: */
306: if( isView ){
307: sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
308: }
309:
310: /* Begin generating code.
311: */
312: v = sqlite3GetVdbe(pParse);
313: if( v==0 ){
314: goto delete_from_cleanup;
315: }
316: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
317: sqlite3BeginWriteOperation(pParse, 1, iDb);
318:
319: /* If we are trying to delete from a view, realize that view into
320: ** a ephemeral table.
321: */
322: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
323: if( isView ){
324: sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
325: }
326: #endif
327:
328: /* Resolve the column names in the WHERE clause.
329: */
330: memset(&sNC, 0, sizeof(sNC));
331: sNC.pParse = pParse;
332: sNC.pSrcList = pTabList;
333: if( sqlite3ResolveExprNames(&sNC, pWhere) ){
334: goto delete_from_cleanup;
335: }
336:
337: /* Initialize the counter of the number of rows deleted, if
338: ** we are counting rows.
339: */
340: if( db->flags & SQLITE_CountRows ){
341: memCnt = ++pParse->nMem;
342: sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
343: }
344:
345: #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
346: /* Special case: A DELETE without a WHERE clause deletes everything.
347: ** It is easier just to erase the whole table. Prior to version 3.6.5,
348: ** this optimization caused the row change count (the value returned by
349: ** API function sqlite3_count_changes) to be set incorrectly. */
350: if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
351: && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
352: ){
353: assert( !isView );
354: sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
355: pTab->zName, P4_STATIC);
356: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
357: assert( pIdx->pSchema==pTab->pSchema );
358: sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
359: }
360: }else
361: #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
362: /* The usual case: There is a WHERE clause so we have to scan through
363: ** the table and pick which records to delete.
364: */
365: {
366: int iRowSet = ++pParse->nMem; /* Register for rowset of rows to delete */
367: int iRowid = ++pParse->nMem; /* Used for storing rowid values. */
368: int regRowid; /* Actual register containing rowids */
369:
370: /* Collect rowids of every row to be deleted.
371: */
372: sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
373: pWInfo = sqlite3WhereBegin(
374: pParse, pTabList, pWhere, 0, 0, WHERE_DUPLICATES_OK
375: );
376: if( pWInfo==0 ) goto delete_from_cleanup;
377: regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid);
378: sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid);
379: if( db->flags & SQLITE_CountRows ){
380: sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
381: }
382: sqlite3WhereEnd(pWInfo);
383:
384: /* Delete every item whose key was written to the list during the
385: ** database scan. We have to delete items after the scan is complete
386: ** because deleting an item can change the scan order. */
387: end = sqlite3VdbeMakeLabel(v);
388:
389: /* Unless this is a view, open cursors for the table we are
390: ** deleting from and all its indices. If this is a view, then the
391: ** only effect this statement has is to fire the INSTEAD OF
392: ** triggers. */
393: if( !isView ){
394: sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
395: }
396:
397: addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);
398:
399: /* Delete the row */
400: #ifndef SQLITE_OMIT_VIRTUALTABLE
401: if( IsVirtual(pTab) ){
402: const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
403: sqlite3VtabMakeWritable(pParse, pTab);
404: sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);
405: sqlite3VdbeChangeP5(v, OE_Abort);
406: sqlite3MayAbort(pParse);
407: }else
408: #endif
409: {
410: int count = (pParse->nested==0); /* True to count changes */
411: sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
412: }
413:
414: /* End of the delete loop */
415: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
416: sqlite3VdbeResolveLabel(v, end);
417:
418: /* Close the cursors open on the table and its indexes. */
419: if( !isView && !IsVirtual(pTab) ){
420: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
421: sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
422: }
423: sqlite3VdbeAddOp1(v, OP_Close, iCur);
424: }
425: }
426:
427: /* Update the sqlite_sequence table by storing the content of the
428: ** maximum rowid counter values recorded while inserting into
429: ** autoincrement tables.
430: */
431: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
432: sqlite3AutoincrementEnd(pParse);
433: }
434:
435: /* Return the number of rows that were deleted. If this routine is
436: ** generating code because of a call to sqlite3NestedParse(), do not
437: ** invoke the callback function.
438: */
439: if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
440: sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
441: sqlite3VdbeSetNumCols(v, 1);
442: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
443: }
444:
445: delete_from_cleanup:
446: sqlite3AuthContextPop(&sContext);
447: sqlite3SrcListDelete(db, pTabList);
448: sqlite3ExprDelete(db, pWhere);
449: return;
450: }
451: /* Make sure "isView" and other macros defined above are undefined. Otherwise
452: ** thely may interfere with compilation of other functions in this file
453: ** (or in another file, if this file becomes part of the amalgamation). */
454: #ifdef isView
455: #undef isView
456: #endif
457: #ifdef pTrigger
458: #undef pTrigger
459: #endif
460:
461: /*
462: ** This routine generates VDBE code that causes a single row of a
463: ** single table to be deleted.
464: **
465: ** The VDBE must be in a particular state when this routine is called.
466: ** These are the requirements:
467: **
468: ** 1. A read/write cursor pointing to pTab, the table containing the row
469: ** to be deleted, must be opened as cursor number $iCur.
470: **
471: ** 2. Read/write cursors for all indices of pTab must be open as
472: ** cursor number base+i for the i-th index.
473: **
474: ** 3. The record number of the row to be deleted must be stored in
475: ** memory cell iRowid.
476: **
477: ** This routine generates code to remove both the table record and all
478: ** index entries that point to that record.
479: */
480: void sqlite3GenerateRowDelete(
481: Parse *pParse, /* Parsing context */
482: Table *pTab, /* Table containing the row to be deleted */
483: int iCur, /* Cursor number for the table */
484: int iRowid, /* Memory cell that contains the rowid to delete */
485: int count, /* If non-zero, increment the row change counter */
486: Trigger *pTrigger, /* List of triggers to (potentially) fire */
487: int onconf /* Default ON CONFLICT policy for triggers */
488: ){
489: Vdbe *v = pParse->pVdbe; /* Vdbe */
490: int iOld = 0; /* First register in OLD.* array */
491: int iLabel; /* Label resolved to end of generated code */
492:
493: /* Vdbe is guaranteed to have been allocated by this stage. */
494: assert( v );
495:
496: /* Seek cursor iCur to the row to delete. If this row no longer exists
497: ** (this can happen if a trigger program has already deleted it), do
498: ** not attempt to delete it or fire any DELETE triggers. */
499: iLabel = sqlite3VdbeMakeLabel(v);
500: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
501:
502: /* If there are any triggers to fire, allocate a range of registers to
503: ** use for the old.* references in the triggers. */
504: if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
505: u32 mask; /* Mask of OLD.* columns in use */
506: int iCol; /* Iterator used while populating OLD.* */
507:
508: /* TODO: Could use temporary registers here. Also could attempt to
509: ** avoid copying the contents of the rowid register. */
510: mask = sqlite3TriggerColmask(
511: pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
512: );
513: mask |= sqlite3FkOldmask(pParse, pTab);
514: iOld = pParse->nMem+1;
515: pParse->nMem += (1 + pTab->nCol);
516:
517: /* Populate the OLD.* pseudo-table register array. These values will be
518: ** used by any BEFORE and AFTER triggers that exist. */
519: sqlite3VdbeAddOp2(v, OP_Copy, iRowid, iOld);
520: for(iCol=0; iCol<pTab->nCol; iCol++){
521: if( mask==0xffffffff || mask&(1<<iCol) ){
522: sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);
523: }
524: }
525:
526: /* Invoke BEFORE DELETE trigger programs. */
527: sqlite3CodeRowTrigger(pParse, pTrigger,
528: TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
529: );
530:
531: /* Seek the cursor to the row to be deleted again. It may be that
532: ** the BEFORE triggers coded above have already removed the row
533: ** being deleted. Do not attempt to delete the row a second time, and
534: ** do not fire AFTER triggers. */
535: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
536:
537: /* Do FK processing. This call checks that any FK constraints that
538: ** refer to this table (i.e. constraints attached to other tables)
539: ** are not violated by deleting this row. */
540: sqlite3FkCheck(pParse, pTab, iOld, 0);
541: }
542:
543: /* Delete the index and table entries. Skip this step if pTab is really
544: ** a view (in which case the only effect of the DELETE statement is to
545: ** fire the INSTEAD OF triggers). */
546: if( pTab->pSelect==0 ){
547: sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
548: sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
549: if( count ){
550: sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
551: }
552: }
553:
554: /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
555: ** handle rows (possibly in other tables) that refer via a foreign key
556: ** to the row just deleted. */
557: sqlite3FkActions(pParse, pTab, 0, iOld);
558:
559: /* Invoke AFTER DELETE trigger programs. */
560: sqlite3CodeRowTrigger(pParse, pTrigger,
561: TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
562: );
563:
564: /* Jump here if the row had already been deleted before any BEFORE
565: ** trigger programs were invoked. Or if a trigger program throws a
566: ** RAISE(IGNORE) exception. */
567: sqlite3VdbeResolveLabel(v, iLabel);
568: }
569:
570: /*
571: ** This routine generates VDBE code that causes the deletion of all
572: ** index entries associated with a single row of a single table.
573: **
574: ** The VDBE must be in a particular state when this routine is called.
575: ** These are the requirements:
576: **
577: ** 1. A read/write cursor pointing to pTab, the table containing the row
578: ** to be deleted, must be opened as cursor number "iCur".
579: **
580: ** 2. Read/write cursors for all indices of pTab must be open as
581: ** cursor number iCur+i for the i-th index.
582: **
583: ** 3. The "iCur" cursor must be pointing to the row that is to be
584: ** deleted.
585: */
586: void sqlite3GenerateRowIndexDelete(
587: Parse *pParse, /* Parsing and code generating context */
588: Table *pTab, /* Table containing the row to be deleted */
589: int iCur, /* Cursor number for the table */
590: int *aRegIdx /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
591: ){
592: int i;
593: Index *pIdx;
594: int r1;
595:
596: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
597: if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
598: r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0);
599: sqlite3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1);
600: }
601: }
602:
603: /*
604: ** Generate code that will assemble an index key and put it in register
605: ** regOut. The key with be for index pIdx which is an index on pTab.
606: ** iCur is the index of a cursor open on the pTab table and pointing to
607: ** the entry that needs indexing.
608: **
609: ** Return a register number which is the first in a block of
610: ** registers that holds the elements of the index key. The
611: ** block of registers has already been deallocated by the time
612: ** this routine returns.
613: */
614: int sqlite3GenerateIndexKey(
615: Parse *pParse, /* Parsing context */
616: Index *pIdx, /* The index for which to generate a key */
617: int iCur, /* Cursor number for the pIdx->pTable table */
618: int regOut, /* Write the new index key to this register */
619: int doMakeRec /* Run the OP_MakeRecord instruction if true */
620: ){
621: Vdbe *v = pParse->pVdbe;
622: int j;
623: Table *pTab = pIdx->pTable;
624: int regBase;
625: int nCol;
626:
627: nCol = pIdx->nColumn;
628: regBase = sqlite3GetTempRange(pParse, nCol+1);
629: sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
630: for(j=0; j<nCol; j++){
631: int idx = pIdx->aiColumn[j];
632: if( idx==pTab->iPKey ){
633: sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
634: }else{
635: sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
636: sqlite3ColumnDefault(v, pTab, idx, -1);
637: }
638: }
639: if( doMakeRec ){
640: const char *zAff;
641: if( pTab->pSelect || (pParse->db->flags & SQLITE_IdxRealAsInt)!=0 ){
642: zAff = 0;
643: }else{
644: zAff = sqlite3IndexAffinityStr(v, pIdx);
645: }
646: sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
647: sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);
648: }
649: sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
650: return regBase;
651: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to delete.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src