Annotation of embedaddon/php/ext/sqlite/libsqlite/src/delete.c, revision 1.1
1.1 ! misho 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: ** to handle DELETE FROM statements.
! 14: **
! 15: ** $Id: delete.c 195361 2005-09-07 15:11:33Z iliaa $
! 16: */
! 17: #include "sqliteInt.h"
! 18:
! 19: /*
! 20: ** Look up every table that is named in pSrc. If any table is not found,
! 21: ** add an error message to pParse->zErrMsg and return NULL. If all tables
! 22: ** are found, return a pointer to the last table.
! 23: */
! 24: Table *sqliteSrcListLookup(Parse *pParse, SrcList *pSrc){
! 25: Table *pTab = 0;
! 26: int i;
! 27: for(i=0; i<pSrc->nSrc; i++){
! 28: const char *zTab = pSrc->a[i].zName;
! 29: const char *zDb = pSrc->a[i].zDatabase;
! 30: pTab = sqliteLocateTable(pParse, zTab, zDb);
! 31: pSrc->a[i].pTab = pTab;
! 32: }
! 33: return pTab;
! 34: }
! 35:
! 36: /*
! 37: ** Check to make sure the given table is writable. If it is not
! 38: ** writable, generate an error message and return 1. If it is
! 39: ** writable return 0;
! 40: */
! 41: int sqliteIsReadOnly(Parse *pParse, Table *pTab, int viewOk){
! 42: if( pTab->readOnly ){
! 43: sqliteErrorMsg(pParse, "table %s may not be modified", pTab->zName);
! 44: return 1;
! 45: }
! 46: if( !viewOk && pTab->pSelect ){
! 47: sqliteErrorMsg(pParse, "cannot modify %s because it is a view",pTab->zName);
! 48: return 1;
! 49: }
! 50: return 0;
! 51: }
! 52:
! 53: /*
! 54: ** Process a DELETE FROM statement.
! 55: */
! 56: void sqliteDeleteFrom(
! 57: Parse *pParse, /* The parser context */
! 58: SrcList *pTabList, /* The table from which we should delete things */
! 59: Expr *pWhere /* The WHERE clause. May be null */
! 60: ){
! 61: Vdbe *v; /* The virtual database engine */
! 62: Table *pTab; /* The table from which records will be deleted */
! 63: const char *zDb; /* Name of database holding pTab */
! 64: int end, addr; /* A couple addresses of generated code */
! 65: int i; /* Loop counter */
! 66: WhereInfo *pWInfo; /* Information about the WHERE clause */
! 67: Index *pIdx; /* For looping over indices of the table */
! 68: int iCur; /* VDBE Cursor number for pTab */
! 69: sqlite *db; /* Main database structure */
! 70: int isView; /* True if attempting to delete from a view */
! 71: AuthContext sContext; /* Authorization context */
! 72:
! 73: int row_triggers_exist = 0; /* True if any triggers exist */
! 74: int before_triggers; /* True if there are BEFORE triggers */
! 75: int after_triggers; /* True if there are AFTER triggers */
! 76: int oldIdx = -1; /* Cursor for the OLD table of AFTER triggers */
! 77:
! 78: sContext.pParse = 0;
! 79: if( pParse->nErr || sqlite_malloc_failed ){
! 80: pTabList = 0;
! 81: goto delete_from_cleanup;
! 82: }
! 83: db = pParse->db;
! 84: assert( pTabList->nSrc==1 );
! 85:
! 86: /* Locate the table which we want to delete. This table has to be
! 87: ** put in an SrcList structure because some of the subroutines we
! 88: ** will be calling are designed to work with multiple tables and expect
! 89: ** an SrcList* parameter instead of just a Table* parameter.
! 90: */
! 91: pTab = sqliteSrcListLookup(pParse, pTabList);
! 92: if( pTab==0 ) goto delete_from_cleanup;
! 93: before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger,
! 94: TK_DELETE, TK_BEFORE, TK_ROW, 0);
! 95: after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger,
! 96: TK_DELETE, TK_AFTER, TK_ROW, 0);
! 97: row_triggers_exist = before_triggers || after_triggers;
! 98: isView = pTab->pSelect!=0;
! 99: if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){
! 100: goto delete_from_cleanup;
! 101: }
! 102: assert( pTab->iDb<db->nDb );
! 103: zDb = db->aDb[pTab->iDb].zName;
! 104: if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
! 105: goto delete_from_cleanup;
! 106: }
! 107:
! 108: /* If pTab is really a view, make sure it has been initialized.
! 109: */
! 110: if( isView && sqliteViewGetColumnNames(pParse, pTab) ){
! 111: goto delete_from_cleanup;
! 112: }
! 113:
! 114: /* Allocate a cursor used to store the old.* data for a trigger.
! 115: */
! 116: if( row_triggers_exist ){
! 117: oldIdx = pParse->nTab++;
! 118: }
! 119:
! 120: /* Resolve the column names in all the expressions.
! 121: */
! 122: assert( pTabList->nSrc==1 );
! 123: iCur = pTabList->a[0].iCursor = pParse->nTab++;
! 124: if( pWhere ){
! 125: if( sqliteExprResolveIds(pParse, pTabList, 0, pWhere) ){
! 126: goto delete_from_cleanup;
! 127: }
! 128: if( sqliteExprCheck(pParse, pWhere, 0, 0) ){
! 129: goto delete_from_cleanup;
! 130: }
! 131: }
! 132:
! 133: /* Start the view context
! 134: */
! 135: if( isView ){
! 136: sqliteAuthContextPush(pParse, &sContext, pTab->zName);
! 137: }
! 138:
! 139: /* Begin generating code.
! 140: */
! 141: v = sqliteGetVdbe(pParse);
! 142: if( v==0 ){
! 143: goto delete_from_cleanup;
! 144: }
! 145: sqliteBeginWriteOperation(pParse, row_triggers_exist, pTab->iDb);
! 146:
! 147: /* If we are trying to delete from a view, construct that view into
! 148: ** a temporary table.
! 149: */
! 150: if( isView ){
! 151: Select *pView = sqliteSelectDup(pTab->pSelect);
! 152: sqliteSelect(pParse, pView, SRT_TempTable, iCur, 0, 0, 0);
! 153: sqliteSelectDelete(pView);
! 154: }
! 155:
! 156: /* Initialize the counter of the number of rows deleted, if
! 157: ** we are counting rows.
! 158: */
! 159: if( db->flags & SQLITE_CountRows ){
! 160: sqliteVdbeAddOp(v, OP_Integer, 0, 0);
! 161: }
! 162:
! 163: /* Special case: A DELETE without a WHERE clause deletes everything.
! 164: ** It is easier just to erase the whole table. Note, however, that
! 165: ** this means that the row change count will be incorrect.
! 166: */
! 167: if( pWhere==0 && !row_triggers_exist ){
! 168: if( db->flags & SQLITE_CountRows ){
! 169: /* If counting rows deleted, just count the total number of
! 170: ** entries in the table. */
! 171: int endOfLoop = sqliteVdbeMakeLabel(v);
! 172: int addr;
! 173: if( !isView ){
! 174: sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0);
! 175: sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum);
! 176: }
! 177: sqliteVdbeAddOp(v, OP_Rewind, iCur, sqliteVdbeCurrentAddr(v)+2);
! 178: addr = sqliteVdbeAddOp(v, OP_AddImm, 1, 0);
! 179: sqliteVdbeAddOp(v, OP_Next, iCur, addr);
! 180: sqliteVdbeResolveLabel(v, endOfLoop);
! 181: sqliteVdbeAddOp(v, OP_Close, iCur, 0);
! 182: }
! 183: if( !isView ){
! 184: sqliteVdbeAddOp(v, OP_Clear, pTab->tnum, pTab->iDb);
! 185: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
! 186: sqliteVdbeAddOp(v, OP_Clear, pIdx->tnum, pIdx->iDb);
! 187: }
! 188: }
! 189: }
! 190:
! 191: /* The usual case: There is a WHERE clause so we have to scan through
! 192: ** the table and pick which records to delete.
! 193: */
! 194: else{
! 195: /* Begin the database scan
! 196: */
! 197: pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 1, 0);
! 198: if( pWInfo==0 ) goto delete_from_cleanup;
! 199:
! 200: /* Remember the key of every item to be deleted.
! 201: */
! 202: sqliteVdbeAddOp(v, OP_ListWrite, 0, 0);
! 203: if( db->flags & SQLITE_CountRows ){
! 204: sqliteVdbeAddOp(v, OP_AddImm, 1, 0);
! 205: }
! 206:
! 207: /* End the database scan loop.
! 208: */
! 209: sqliteWhereEnd(pWInfo);
! 210:
! 211: /* Open the pseudo-table used to store OLD if there are triggers.
! 212: */
! 213: if( row_triggers_exist ){
! 214: sqliteVdbeAddOp(v, OP_OpenPseudo, oldIdx, 0);
! 215: }
! 216:
! 217: /* Delete every item whose key was written to the list during the
! 218: ** database scan. We have to delete items after the scan is complete
! 219: ** because deleting an item can change the scan order.
! 220: */
! 221: sqliteVdbeAddOp(v, OP_ListRewind, 0, 0);
! 222: end = sqliteVdbeMakeLabel(v);
! 223:
! 224: /* This is the beginning of the delete loop when there are
! 225: ** row triggers.
! 226: */
! 227: if( row_triggers_exist ){
! 228: addr = sqliteVdbeAddOp(v, OP_ListRead, 0, end);
! 229: sqliteVdbeAddOp(v, OP_Dup, 0, 0);
! 230: if( !isView ){
! 231: sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0);
! 232: sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum);
! 233: }
! 234: sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0);
! 235:
! 236: sqliteVdbeAddOp(v, OP_Recno, iCur, 0);
! 237: sqliteVdbeAddOp(v, OP_RowData, iCur, 0);
! 238: sqliteVdbeAddOp(v, OP_PutIntKey, oldIdx, 0);
! 239: if( !isView ){
! 240: sqliteVdbeAddOp(v, OP_Close, iCur, 0);
! 241: }
! 242:
! 243: sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_BEFORE, pTab, -1,
! 244: oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default,
! 245: addr);
! 246: }
! 247:
! 248: if( !isView ){
! 249: /* Open cursors for the table we are deleting from and all its
! 250: ** indices. If there are row triggers, this happens inside the
! 251: ** OP_ListRead loop because the cursor have to all be closed
! 252: ** before the trigger fires. If there are no row triggers, the
! 253: ** cursors are opened only once on the outside the loop.
! 254: */
! 255: pParse->nTab = iCur + 1;
! 256: sqliteOpenTableAndIndices(pParse, pTab, iCur);
! 257:
! 258: /* This is the beginning of the delete loop when there are no
! 259: ** row triggers */
! 260: if( !row_triggers_exist ){
! 261: addr = sqliteVdbeAddOp(v, OP_ListRead, 0, end);
! 262: }
! 263:
! 264: /* Delete the row */
! 265: sqliteGenerateRowDelete(db, v, pTab, iCur, pParse->trigStack==0);
! 266: }
! 267:
! 268: /* If there are row triggers, close all cursors then invoke
! 269: ** the AFTER triggers
! 270: */
! 271: if( row_triggers_exist ){
! 272: if( !isView ){
! 273: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
! 274: sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum);
! 275: }
! 276: sqliteVdbeAddOp(v, OP_Close, iCur, 0);
! 277: }
! 278: sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_AFTER, pTab, -1,
! 279: oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default,
! 280: addr);
! 281: }
! 282:
! 283: /* End of the delete loop */
! 284: sqliteVdbeAddOp(v, OP_Goto, 0, addr);
! 285: sqliteVdbeResolveLabel(v, end);
! 286: sqliteVdbeAddOp(v, OP_ListReset, 0, 0);
! 287:
! 288: /* Close the cursors after the loop if there are no row triggers */
! 289: if( !row_triggers_exist ){
! 290: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
! 291: sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum);
! 292: }
! 293: sqliteVdbeAddOp(v, OP_Close, iCur, 0);
! 294: pParse->nTab = iCur;
! 295: }
! 296: }
! 297: sqliteVdbeAddOp(v, OP_SetCounts, 0, 0);
! 298: sqliteEndWriteOperation(pParse);
! 299:
! 300: /*
! 301: ** Return the number of rows that were deleted.
! 302: */
! 303: if( db->flags & SQLITE_CountRows ){
! 304: sqliteVdbeAddOp(v, OP_ColumnName, 0, 1);
! 305: sqliteVdbeChangeP3(v, -1, "rows deleted", P3_STATIC);
! 306: sqliteVdbeAddOp(v, OP_Callback, 1, 0);
! 307: }
! 308:
! 309: delete_from_cleanup:
! 310: sqliteAuthContextPop(&sContext);
! 311: sqliteSrcListDelete(pTabList);
! 312: sqliteExprDelete(pWhere);
! 313: return;
! 314: }
! 315:
! 316: /*
! 317: ** This routine generates VDBE code that causes a single row of a
! 318: ** single table to be deleted.
! 319: **
! 320: ** The VDBE must be in a particular state when this routine is called.
! 321: ** These are the requirements:
! 322: **
! 323: ** 1. A read/write cursor pointing to pTab, the table containing the row
! 324: ** to be deleted, must be opened as cursor number "base".
! 325: **
! 326: ** 2. Read/write cursors for all indices of pTab must be open as
! 327: ** cursor number base+i for the i-th index.
! 328: **
! 329: ** 3. The record number of the row to be deleted must be on the top
! 330: ** of the stack.
! 331: **
! 332: ** This routine pops the top of the stack to remove the record number
! 333: ** and then generates code to remove both the table record and all index
! 334: ** entries that point to that record.
! 335: */
! 336: void sqliteGenerateRowDelete(
! 337: sqlite *db, /* The database containing the index */
! 338: Vdbe *v, /* Generate code into this VDBE */
! 339: Table *pTab, /* Table containing the row to be deleted */
! 340: int iCur, /* Cursor number for the table */
! 341: int count /* Increment the row change counter */
! 342: ){
! 343: int addr;
! 344: addr = sqliteVdbeAddOp(v, OP_NotExists, iCur, 0);
! 345: sqliteGenerateRowIndexDelete(db, v, pTab, iCur, 0);
! 346: sqliteVdbeAddOp(v, OP_Delete, iCur,
! 347: (count?OPFLAG_NCHANGE:0) | OPFLAG_CSCHANGE);
! 348: sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v));
! 349: }
! 350:
! 351: /*
! 352: ** This routine generates VDBE code that causes the deletion of all
! 353: ** index entries associated with a single row of a single table.
! 354: **
! 355: ** The VDBE must be in a particular state when this routine is called.
! 356: ** These are the requirements:
! 357: **
! 358: ** 1. A read/write cursor pointing to pTab, the table containing the row
! 359: ** to be deleted, must be opened as cursor number "iCur".
! 360: **
! 361: ** 2. Read/write cursors for all indices of pTab must be open as
! 362: ** cursor number iCur+i for the i-th index.
! 363: **
! 364: ** 3. The "iCur" cursor must be pointing to the row that is to be
! 365: ** deleted.
! 366: */
! 367: void sqliteGenerateRowIndexDelete(
! 368: sqlite *db, /* The database containing the index */
! 369: Vdbe *v, /* Generate code into this VDBE */
! 370: Table *pTab, /* Table containing the row to be deleted */
! 371: int iCur, /* Cursor number for the table */
! 372: char *aIdxUsed /* Only delete if aIdxUsed!=0 && aIdxUsed[i]!=0 */
! 373: ){
! 374: int i;
! 375: Index *pIdx;
! 376:
! 377: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
! 378: int j;
! 379: if( aIdxUsed!=0 && aIdxUsed[i-1]==0 ) continue;
! 380: sqliteVdbeAddOp(v, OP_Recno, iCur, 0);
! 381: for(j=0; j<pIdx->nColumn; j++){
! 382: int idx = pIdx->aiColumn[j];
! 383: if( idx==pTab->iPKey ){
! 384: sqliteVdbeAddOp(v, OP_Dup, j, 0);
! 385: }else{
! 386: sqliteVdbeAddOp(v, OP_Column, iCur, idx);
! 387: }
! 388: }
! 389: sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0);
! 390: if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx);
! 391: sqliteVdbeAddOp(v, OP_IdxDelete, iCur+i, 0);
! 392: }
! 393: }
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 / php / ext / sqlite / libsqlite / src