Annotation of embedaddon/sqlite3/src/update.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 UPDATE statements.
! 14: */
! 15: #include "sqliteInt.h"
! 16:
! 17: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 18: /* Forward declaration */
! 19: static void updateVirtualTable(
! 20: Parse *pParse, /* The parsing context */
! 21: SrcList *pSrc, /* The virtual table to be modified */
! 22: Table *pTab, /* The virtual table */
! 23: ExprList *pChanges, /* The columns to change in the UPDATE statement */
! 24: Expr *pRowidExpr, /* Expression used to recompute the rowid */
! 25: int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
! 26: Expr *pWhere, /* WHERE clause of the UPDATE statement */
! 27: int onError /* ON CONFLICT strategy */
! 28: );
! 29: #endif /* SQLITE_OMIT_VIRTUALTABLE */
! 30:
! 31: /*
! 32: ** The most recently coded instruction was an OP_Column to retrieve the
! 33: ** i-th column of table pTab. This routine sets the P4 parameter of the
! 34: ** OP_Column to the default value, if any.
! 35: **
! 36: ** The default value of a column is specified by a DEFAULT clause in the
! 37: ** column definition. This was either supplied by the user when the table
! 38: ** was created, or added later to the table definition by an ALTER TABLE
! 39: ** command. If the latter, then the row-records in the table btree on disk
! 40: ** may not contain a value for the column and the default value, taken
! 41: ** from the P4 parameter of the OP_Column instruction, is returned instead.
! 42: ** If the former, then all row-records are guaranteed to include a value
! 43: ** for the column and the P4 value is not required.
! 44: **
! 45: ** Column definitions created by an ALTER TABLE command may only have
! 46: ** literal default values specified: a number, null or a string. (If a more
! 47: ** complicated default expression value was provided, it is evaluated
! 48: ** when the ALTER TABLE is executed and one of the literal values written
! 49: ** into the sqlite_master table.)
! 50: **
! 51: ** Therefore, the P4 parameter is only required if the default value for
! 52: ** the column is a literal number, string or null. The sqlite3ValueFromExpr()
! 53: ** function is capable of transforming these types of expressions into
! 54: ** sqlite3_value objects.
! 55: **
! 56: ** If parameter iReg is not negative, code an OP_RealAffinity instruction
! 57: ** on register iReg. This is used when an equivalent integer value is
! 58: ** stored in place of an 8-byte floating point value in order to save
! 59: ** space.
! 60: */
! 61: void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
! 62: assert( pTab!=0 );
! 63: if( !pTab->pSelect ){
! 64: sqlite3_value *pValue;
! 65: u8 enc = ENC(sqlite3VdbeDb(v));
! 66: Column *pCol = &pTab->aCol[i];
! 67: VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
! 68: assert( i<pTab->nCol );
! 69: sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,
! 70: pCol->affinity, &pValue);
! 71: if( pValue ){
! 72: sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
! 73: }
! 74: #ifndef SQLITE_OMIT_FLOATING_POINT
! 75: if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
! 76: sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
! 77: }
! 78: #endif
! 79: }
! 80: }
! 81:
! 82: /*
! 83: ** Process an UPDATE statement.
! 84: **
! 85: ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
! 86: ** \_______/ \________/ \______/ \________________/
! 87: * onError pTabList pChanges pWhere
! 88: */
! 89: void sqlite3Update(
! 90: Parse *pParse, /* The parser context */
! 91: SrcList *pTabList, /* The table in which we should change things */
! 92: ExprList *pChanges, /* Things to be changed */
! 93: Expr *pWhere, /* The WHERE clause. May be null */
! 94: int onError /* How to handle constraint errors */
! 95: ){
! 96: int i, j; /* Loop counters */
! 97: Table *pTab; /* The table to be updated */
! 98: int addr = 0; /* VDBE instruction address of the start of the loop */
! 99: WhereInfo *pWInfo; /* Information about the WHERE clause */
! 100: Vdbe *v; /* The virtual database engine */
! 101: Index *pIdx; /* For looping over indices */
! 102: int nIdx; /* Number of indices that need updating */
! 103: int iCur; /* VDBE Cursor number of pTab */
! 104: sqlite3 *db; /* The database structure */
! 105: int *aRegIdx = 0; /* One register assigned to each index to be updated */
! 106: int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
! 107: ** an expression for the i-th column of the table.
! 108: ** aXRef[i]==-1 if the i-th column is not changed. */
! 109: int chngRowid; /* True if the record number is being changed */
! 110: Expr *pRowidExpr = 0; /* Expression defining the new record number */
! 111: int openAll = 0; /* True if all indices need to be opened */
! 112: AuthContext sContext; /* The authorization context */
! 113: NameContext sNC; /* The name-context to resolve expressions in */
! 114: int iDb; /* Database containing the table being updated */
! 115: int okOnePass; /* True for one-pass algorithm without the FIFO */
! 116: int hasFK; /* True if foreign key processing is required */
! 117:
! 118: #ifndef SQLITE_OMIT_TRIGGER
! 119: int isView; /* True when updating a view (INSTEAD OF trigger) */
! 120: Trigger *pTrigger; /* List of triggers on pTab, if required */
! 121: int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
! 122: #endif
! 123: int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
! 124:
! 125: /* Register Allocations */
! 126: int regRowCount = 0; /* A count of rows changed */
! 127: int regOldRowid; /* The old rowid */
! 128: int regNewRowid; /* The new rowid */
! 129: int regNew; /* Content of the NEW.* table in triggers */
! 130: int regOld = 0; /* Content of OLD.* table in triggers */
! 131: int regRowSet = 0; /* Rowset of rows to be updated */
! 132:
! 133: memset(&sContext, 0, sizeof(sContext));
! 134: db = pParse->db;
! 135: if( pParse->nErr || db->mallocFailed ){
! 136: goto update_cleanup;
! 137: }
! 138: assert( pTabList->nSrc==1 );
! 139:
! 140: /* Locate the table which we want to update.
! 141: */
! 142: pTab = sqlite3SrcListLookup(pParse, pTabList);
! 143: if( pTab==0 ) goto update_cleanup;
! 144: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
! 145:
! 146: /* Figure out if we have any triggers and if the table being
! 147: ** updated is a view.
! 148: */
! 149: #ifndef SQLITE_OMIT_TRIGGER
! 150: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
! 151: isView = pTab->pSelect!=0;
! 152: assert( pTrigger || tmask==0 );
! 153: #else
! 154: # define pTrigger 0
! 155: # define isView 0
! 156: # define tmask 0
! 157: #endif
! 158: #ifdef SQLITE_OMIT_VIEW
! 159: # undef isView
! 160: # define isView 0
! 161: #endif
! 162:
! 163: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
! 164: goto update_cleanup;
! 165: }
! 166: if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
! 167: goto update_cleanup;
! 168: }
! 169: aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
! 170: if( aXRef==0 ) goto update_cleanup;
! 171: for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
! 172:
! 173: /* Allocate a cursors for the main database table and for all indices.
! 174: ** The index cursors might not be used, but if they are used they
! 175: ** need to occur right after the database cursor. So go ahead and
! 176: ** allocate enough space, just in case.
! 177: */
! 178: pTabList->a[0].iCursor = iCur = pParse->nTab++;
! 179: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
! 180: pParse->nTab++;
! 181: }
! 182:
! 183: /* Initialize the name-context */
! 184: memset(&sNC, 0, sizeof(sNC));
! 185: sNC.pParse = pParse;
! 186: sNC.pSrcList = pTabList;
! 187:
! 188: /* Resolve the column names in all the expressions of the
! 189: ** of the UPDATE statement. Also find the column index
! 190: ** for each column to be updated in the pChanges array. For each
! 191: ** column to be updated, make sure we have authorization to change
! 192: ** that column.
! 193: */
! 194: chngRowid = 0;
! 195: for(i=0; i<pChanges->nExpr; i++){
! 196: if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
! 197: goto update_cleanup;
! 198: }
! 199: for(j=0; j<pTab->nCol; j++){
! 200: if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
! 201: if( j==pTab->iPKey ){
! 202: chngRowid = 1;
! 203: pRowidExpr = pChanges->a[i].pExpr;
! 204: }
! 205: aXRef[j] = i;
! 206: break;
! 207: }
! 208: }
! 209: if( j>=pTab->nCol ){
! 210: if( sqlite3IsRowid(pChanges->a[i].zName) ){
! 211: chngRowid = 1;
! 212: pRowidExpr = pChanges->a[i].pExpr;
! 213: }else{
! 214: sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
! 215: pParse->checkSchema = 1;
! 216: goto update_cleanup;
! 217: }
! 218: }
! 219: #ifndef SQLITE_OMIT_AUTHORIZATION
! 220: {
! 221: int rc;
! 222: rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
! 223: pTab->aCol[j].zName, db->aDb[iDb].zName);
! 224: if( rc==SQLITE_DENY ){
! 225: goto update_cleanup;
! 226: }else if( rc==SQLITE_IGNORE ){
! 227: aXRef[j] = -1;
! 228: }
! 229: }
! 230: #endif
! 231: }
! 232:
! 233: hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid);
! 234:
! 235: /* Allocate memory for the array aRegIdx[]. There is one entry in the
! 236: ** array for each index associated with table being updated. Fill in
! 237: ** the value with a register number for indices that are to be used
! 238: ** and with zero for unused indices.
! 239: */
! 240: for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
! 241: if( nIdx>0 ){
! 242: aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx );
! 243: if( aRegIdx==0 ) goto update_cleanup;
! 244: }
! 245: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
! 246: int reg;
! 247: if( hasFK || chngRowid ){
! 248: reg = ++pParse->nMem;
! 249: }else{
! 250: reg = 0;
! 251: for(i=0; i<pIdx->nColumn; i++){
! 252: if( aXRef[pIdx->aiColumn[i]]>=0 ){
! 253: reg = ++pParse->nMem;
! 254: break;
! 255: }
! 256: }
! 257: }
! 258: aRegIdx[j] = reg;
! 259: }
! 260:
! 261: /* Begin generating code. */
! 262: v = sqlite3GetVdbe(pParse);
! 263: if( v==0 ) goto update_cleanup;
! 264: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
! 265: sqlite3BeginWriteOperation(pParse, 1, iDb);
! 266:
! 267: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 268: /* Virtual tables must be handled separately */
! 269: if( IsVirtual(pTab) ){
! 270: updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
! 271: pWhere, onError);
! 272: pWhere = 0;
! 273: pTabList = 0;
! 274: goto update_cleanup;
! 275: }
! 276: #endif
! 277:
! 278: /* Allocate required registers. */
! 279: regRowSet = ++pParse->nMem;
! 280: regOldRowid = regNewRowid = ++pParse->nMem;
! 281: if( pTrigger || hasFK ){
! 282: regOld = pParse->nMem + 1;
! 283: pParse->nMem += pTab->nCol;
! 284: }
! 285: if( chngRowid || pTrigger || hasFK ){
! 286: regNewRowid = ++pParse->nMem;
! 287: }
! 288: regNew = pParse->nMem + 1;
! 289: pParse->nMem += pTab->nCol;
! 290:
! 291: /* Start the view context. */
! 292: if( isView ){
! 293: sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
! 294: }
! 295:
! 296: /* If we are trying to update a view, realize that view into
! 297: ** a ephemeral table.
! 298: */
! 299: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
! 300: if( isView ){
! 301: sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
! 302: }
! 303: #endif
! 304:
! 305: /* Resolve the column names in all the expressions in the
! 306: ** WHERE clause.
! 307: */
! 308: if( sqlite3ResolveExprNames(&sNC, pWhere) ){
! 309: goto update_cleanup;
! 310: }
! 311:
! 312: /* Begin the database scan
! 313: */
! 314: sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
! 315: pWInfo = sqlite3WhereBegin(
! 316: pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED
! 317: );
! 318: if( pWInfo==0 ) goto update_cleanup;
! 319: okOnePass = pWInfo->okOnePass;
! 320:
! 321: /* Remember the rowid of every item to be updated.
! 322: */
! 323: sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid);
! 324: if( !okOnePass ){
! 325: sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
! 326: }
! 327:
! 328: /* End the database scan loop.
! 329: */
! 330: sqlite3WhereEnd(pWInfo);
! 331:
! 332: /* Initialize the count of updated rows
! 333: */
! 334: if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
! 335: regRowCount = ++pParse->nMem;
! 336: sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
! 337: }
! 338:
! 339: if( !isView ){
! 340: /*
! 341: ** Open every index that needs updating. Note that if any
! 342: ** index could potentially invoke a REPLACE conflict resolution
! 343: ** action, then we need to open all indices because we might need
! 344: ** to be deleting some records.
! 345: */
! 346: if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
! 347: if( onError==OE_Replace ){
! 348: openAll = 1;
! 349: }else{
! 350: openAll = 0;
! 351: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
! 352: if( pIdx->onError==OE_Replace ){
! 353: openAll = 1;
! 354: break;
! 355: }
! 356: }
! 357: }
! 358: for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
! 359: assert( aRegIdx );
! 360: if( openAll || aRegIdx[i]>0 ){
! 361: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
! 362: sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
! 363: (char*)pKey, P4_KEYINFO_HANDOFF);
! 364: assert( pParse->nTab>iCur+i+1 );
! 365: }
! 366: }
! 367: }
! 368:
! 369: /* Top of the update loop */
! 370: if( okOnePass ){
! 371: int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid);
! 372: addr = sqlite3VdbeAddOp0(v, OP_Goto);
! 373: sqlite3VdbeJumpHere(v, a1);
! 374: }else{
! 375: addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);
! 376: }
! 377:
! 378: /* Make cursor iCur point to the record that is being updated. If
! 379: ** this record does not exist for some reason (deleted by a trigger,
! 380: ** for example, then jump to the next iteration of the RowSet loop. */
! 381: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
! 382:
! 383: /* If the record number will change, set register regNewRowid to
! 384: ** contain the new value. If the record number is not being modified,
! 385: ** then regNewRowid is the same register as regOldRowid, which is
! 386: ** already populated. */
! 387: assert( chngRowid || pTrigger || hasFK || regOldRowid==regNewRowid );
! 388: if( chngRowid ){
! 389: sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
! 390: sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
! 391: }
! 392:
! 393: /* If there are triggers on this table, populate an array of registers
! 394: ** with the required old.* column data. */
! 395: if( hasFK || pTrigger ){
! 396: u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
! 397: oldmask |= sqlite3TriggerColmask(pParse,
! 398: pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
! 399: );
! 400: for(i=0; i<pTab->nCol; i++){
! 401: if( aXRef[i]<0 || oldmask==0xffffffff || (i<32 && (oldmask & (1<<i))) ){
! 402: sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOld+i);
! 403: }else{
! 404: sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
! 405: }
! 406: }
! 407: if( chngRowid==0 ){
! 408: sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
! 409: }
! 410: }
! 411:
! 412: /* Populate the array of registers beginning at regNew with the new
! 413: ** row data. This array is used to check constaints, create the new
! 414: ** table and index records, and as the values for any new.* references
! 415: ** made by triggers.
! 416: **
! 417: ** If there are one or more BEFORE triggers, then do not populate the
! 418: ** registers associated with columns that are (a) not modified by
! 419: ** this UPDATE statement and (b) not accessed by new.* references. The
! 420: ** values for registers not modified by the UPDATE must be reloaded from
! 421: ** the database after the BEFORE triggers are fired anyway (as the trigger
! 422: ** may have modified them). So not loading those that are not going to
! 423: ** be used eliminates some redundant opcodes.
! 424: */
! 425: newmask = sqlite3TriggerColmask(
! 426: pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
! 427: );
! 428: sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);
! 429: for(i=0; i<pTab->nCol; i++){
! 430: if( i==pTab->iPKey ){
! 431: /*sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);*/
! 432: }else{
! 433: j = aXRef[i];
! 434: if( j>=0 ){
! 435: sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
! 436: }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask&(1<<i)) ){
! 437: /* This branch loads the value of a column that will not be changed
! 438: ** into a register. This is done if there are no BEFORE triggers, or
! 439: ** if there are one or more BEFORE triggers that use this value via
! 440: ** a new.* reference in a trigger program.
! 441: */
! 442: testcase( i==31 );
! 443: testcase( i==32 );
! 444: sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
! 445: sqlite3ColumnDefault(v, pTab, i, regNew+i);
! 446: }
! 447: }
! 448: }
! 449:
! 450: /* Fire any BEFORE UPDATE triggers. This happens before constraints are
! 451: ** verified. One could argue that this is wrong.
! 452: */
! 453: if( tmask&TRIGGER_BEFORE ){
! 454: sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
! 455: sqlite3TableAffinityStr(v, pTab);
! 456: sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
! 457: TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
! 458:
! 459: /* The row-trigger may have deleted the row being updated. In this
! 460: ** case, jump to the next row. No updates or AFTER triggers are
! 461: ** required. This behaviour - what happens when the row being updated
! 462: ** is deleted or renamed by a BEFORE trigger - is left undefined in the
! 463: ** documentation.
! 464: */
! 465: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
! 466:
! 467: /* If it did not delete it, the row-trigger may still have modified
! 468: ** some of the columns of the row being updated. Load the values for
! 469: ** all columns not modified by the update statement into their
! 470: ** registers in case this has happened.
! 471: */
! 472: for(i=0; i<pTab->nCol; i++){
! 473: if( aXRef[i]<0 && i!=pTab->iPKey ){
! 474: sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
! 475: sqlite3ColumnDefault(v, pTab, i, regNew+i);
! 476: }
! 477: }
! 478: }
! 479:
! 480: if( !isView ){
! 481: int j1; /* Address of jump instruction */
! 482:
! 483: /* Do constraint checks. */
! 484: sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
! 485: aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);
! 486:
! 487: /* Do FK constraint checks. */
! 488: if( hasFK ){
! 489: sqlite3FkCheck(pParse, pTab, regOldRowid, 0);
! 490: }
! 491:
! 492: /* Delete the index entries associated with the current record. */
! 493: j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
! 494: sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
! 495:
! 496: /* If changing the record number, delete the old record. */
! 497: if( hasFK || chngRowid ){
! 498: sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);
! 499: }
! 500: sqlite3VdbeJumpHere(v, j1);
! 501:
! 502: if( hasFK ){
! 503: sqlite3FkCheck(pParse, pTab, 0, regNewRowid);
! 504: }
! 505:
! 506: /* Insert the new index entries and the new record. */
! 507: sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
! 508:
! 509: /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
! 510: ** handle rows (possibly in other tables) that refer via a foreign key
! 511: ** to the row just updated. */
! 512: if( hasFK ){
! 513: sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);
! 514: }
! 515: }
! 516:
! 517: /* Increment the row counter
! 518: */
! 519: if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
! 520: sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
! 521: }
! 522:
! 523: sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
! 524: TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
! 525:
! 526: /* Repeat the above with the next record to be updated, until
! 527: ** all record selected by the WHERE clause have been updated.
! 528: */
! 529: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
! 530: sqlite3VdbeJumpHere(v, addr);
! 531:
! 532: /* Close all tables */
! 533: for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
! 534: assert( aRegIdx );
! 535: if( openAll || aRegIdx[i]>0 ){
! 536: sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);
! 537: }
! 538: }
! 539: sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
! 540:
! 541: /* Update the sqlite_sequence table by storing the content of the
! 542: ** maximum rowid counter values recorded while inserting into
! 543: ** autoincrement tables.
! 544: */
! 545: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
! 546: sqlite3AutoincrementEnd(pParse);
! 547: }
! 548:
! 549: /*
! 550: ** Return the number of rows that were changed. If this routine is
! 551: ** generating code because of a call to sqlite3NestedParse(), do not
! 552: ** invoke the callback function.
! 553: */
! 554: if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
! 555: sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
! 556: sqlite3VdbeSetNumCols(v, 1);
! 557: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
! 558: }
! 559:
! 560: update_cleanup:
! 561: sqlite3AuthContextPop(&sContext);
! 562: sqlite3DbFree(db, aRegIdx);
! 563: sqlite3DbFree(db, aXRef);
! 564: sqlite3SrcListDelete(db, pTabList);
! 565: sqlite3ExprListDelete(db, pChanges);
! 566: sqlite3ExprDelete(db, pWhere);
! 567: return;
! 568: }
! 569: /* Make sure "isView" and other macros defined above are undefined. Otherwise
! 570: ** thely may interfere with compilation of other functions in this file
! 571: ** (or in another file, if this file becomes part of the amalgamation). */
! 572: #ifdef isView
! 573: #undef isView
! 574: #endif
! 575: #ifdef pTrigger
! 576: #undef pTrigger
! 577: #endif
! 578:
! 579: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 580: /*
! 581: ** Generate code for an UPDATE of a virtual table.
! 582: **
! 583: ** The strategy is that we create an ephemerial table that contains
! 584: ** for each row to be changed:
! 585: **
! 586: ** (A) The original rowid of that row.
! 587: ** (B) The revised rowid for the row. (note1)
! 588: ** (C) The content of every column in the row.
! 589: **
! 590: ** Then we loop over this ephemeral table and for each row in
! 591: ** the ephermeral table call VUpdate.
! 592: **
! 593: ** When finished, drop the ephemeral table.
! 594: **
! 595: ** (note1) Actually, if we know in advance that (A) is always the same
! 596: ** as (B) we only store (A), then duplicate (A) when pulling
! 597: ** it out of the ephemeral table before calling VUpdate.
! 598: */
! 599: static void updateVirtualTable(
! 600: Parse *pParse, /* The parsing context */
! 601: SrcList *pSrc, /* The virtual table to be modified */
! 602: Table *pTab, /* The virtual table */
! 603: ExprList *pChanges, /* The columns to change in the UPDATE statement */
! 604: Expr *pRowid, /* Expression used to recompute the rowid */
! 605: int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
! 606: Expr *pWhere, /* WHERE clause of the UPDATE statement */
! 607: int onError /* ON CONFLICT strategy */
! 608: ){
! 609: Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
! 610: ExprList *pEList = 0; /* The result set of the SELECT statement */
! 611: Select *pSelect = 0; /* The SELECT statement */
! 612: Expr *pExpr; /* Temporary expression */
! 613: int ephemTab; /* Table holding the result of the SELECT */
! 614: int i; /* Loop counter */
! 615: int addr; /* Address of top of loop */
! 616: int iReg; /* First register in set passed to OP_VUpdate */
! 617: sqlite3 *db = pParse->db; /* Database connection */
! 618: const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
! 619: SelectDest dest;
! 620:
! 621: /* Construct the SELECT statement that will find the new values for
! 622: ** all updated rows.
! 623: */
! 624: pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
! 625: if( pRowid ){
! 626: pEList = sqlite3ExprListAppend(pParse, pEList,
! 627: sqlite3ExprDup(db, pRowid, 0));
! 628: }
! 629: assert( pTab->iPKey<0 );
! 630: for(i=0; i<pTab->nCol; i++){
! 631: if( aXRef[i]>=0 ){
! 632: pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
! 633: }else{
! 634: pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
! 635: }
! 636: pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
! 637: }
! 638: pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
! 639:
! 640: /* Create the ephemeral table into which the update results will
! 641: ** be stored.
! 642: */
! 643: assert( v );
! 644: ephemTab = pParse->nTab++;
! 645: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
! 646: sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
! 647:
! 648: /* fill the ephemeral table
! 649: */
! 650: sqlite3SelectDestInit(&dest, SRT_Table, ephemTab);
! 651: sqlite3Select(pParse, pSelect, &dest);
! 652:
! 653: /* Generate code to scan the ephemeral table and call VUpdate. */
! 654: iReg = ++pParse->nMem;
! 655: pParse->nMem += pTab->nCol+1;
! 656: addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
! 657: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, 0, iReg);
! 658: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1);
! 659: for(i=0; i<pTab->nCol; i++){
! 660: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i);
! 661: }
! 662: sqlite3VtabMakeWritable(pParse, pTab);
! 663: sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
! 664: sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
! 665: sqlite3MayAbort(pParse);
! 666: sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1);
! 667: sqlite3VdbeJumpHere(v, addr);
! 668: sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
! 669:
! 670: /* Cleanup */
! 671: sqlite3SelectDelete(db, pSelect);
! 672: }
! 673: #endif /* SQLITE_OMIT_VIRTUALTABLE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to update.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