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