| 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 #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 = 0; | |
| 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( 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 addrTop = 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 Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */ | |
| 103 int nIdx; /* Number of indices that need updating */ | |
| 104 int iBaseCur; /* Base cursor number */ | |
| 105 int iDataCur; /* Cursor for the canonical data btree */ | |
| 106 int iIdxCur; /* Cursor for the first index */ | |
| 107 sqlite3 *db; /* The database structure */ | |
| 108 int *aRegIdx = 0; /* One register assigned to each index to be updated */ | |
| 109 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the | |
| 110 ** an expression for the i-th column of the table. | |
| 111 ** aXRef[i]==-1 if the i-th column is not changed. */ | |
| 112 u8 *aToOpen; /* 1 for tables and indices to be opened */ | |
| 113 u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ | |
| 114 u8 chngRowid; /* Rowid changed in a normal table */ | |
| 115 u8 chngKey; /* Either chngPk or chngRowid */ | |
| 116 Expr *pRowidExpr = 0; /* Expression defining the new record number */ | |
| 117 AuthContext sContext; /* The authorization context */ | |
| 118 NameContext sNC; /* The name-context to resolve expressions in */ | |
| 119 int iDb; /* Database containing the table being updated */ | |
| 120 int okOnePass; /* True for one-pass algorithm without the FIFO */ | |
| 121 int hasFK; /* True if foreign key processing is required */ | |
| 122 int labelBreak; /* Jump here to break out of UPDATE loop */ | |
| 123 int labelContinue; /* Jump here to continue next step of UPDATE loop */ | |
| 124 | |
| 125 #ifndef SQLITE_OMIT_TRIGGER | |
| 126 int isView; /* True when updating a view (INSTEAD OF trigger) */ | |
| 127 Trigger *pTrigger; /* List of triggers on pTab, if required */ | |
| 128 int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ | |
| 129 #endif | |
| 130 int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */ | |
| 131 int iEph = 0; /* Ephemeral table holding all primary key values */ | |
| 132 int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ | |
| 133 int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ | |
| 134 | |
| 135 /* Register Allocations */ | |
| 136 int regRowCount = 0; /* A count of rows changed */ | |
| 137 int regOldRowid; /* The old rowid */ | |
| 138 int regNewRowid; /* The new rowid */ | |
| 139 int regNew; /* Content of the NEW.* table in triggers */ | |
| 140 int regOld = 0; /* Content of OLD.* table in triggers */ | |
| 141 int regRowSet = 0; /* Rowset of rows to be updated */ | |
| 142 int regKey = 0; /* composite PRIMARY KEY value */ | |
| 143 | |
| 144 memset(&sContext, 0, sizeof(sContext)); | |
| 145 db = pParse->db; | |
| 146 if( pParse->nErr || db->mallocFailed ){ | |
| 147 goto update_cleanup; | |
| 148 } | |
| 149 assert( pTabList->nSrc==1 ); | |
| 150 | |
| 151 /* Locate the table which we want to update. | |
| 152 */ | |
| 153 pTab = sqlite3SrcListLookup(pParse, pTabList); | |
| 154 if( pTab==0 ) goto update_cleanup; | |
| 155 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); | |
| 156 | |
| 157 /* Figure out if we have any triggers and if the table being | |
| 158 ** updated is a view. | |
| 159 */ | |
| 160 #ifndef SQLITE_OMIT_TRIGGER | |
| 161 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask); | |
| 162 isView = pTab->pSelect!=0; | |
| 163 assert( pTrigger || tmask==0 ); | |
| 164 #else | |
| 165 # define pTrigger 0 | |
| 166 # define isView 0 | |
| 167 # define tmask 0 | |
| 168 #endif | |
| 169 #ifdef SQLITE_OMIT_VIEW | |
| 170 # undef isView | |
| 171 # define isView 0 | |
| 172 #endif | |
| 173 | |
| 174 if( sqlite3ViewGetColumnNames(pParse, pTab) ){ | |
| 175 goto update_cleanup; | |
| 176 } | |
| 177 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){ | |
| 178 goto update_cleanup; | |
| 179 } | |
| 180 | |
| 181 /* Allocate a cursors for the main database table and for all indices. | |
| 182 ** The index cursors might not be used, but if they are used they | |
| 183 ** need to occur right after the database cursor. So go ahead and | |
| 184 ** allocate enough space, just in case. | |
| 185 */ | |
| 186 pTabList->a[0].iCursor = iBaseCur = iDataCur = pParse->nTab++; | |
| 187 iIdxCur = iDataCur+1; | |
| 188 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); | |
| 189 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ | |
| 190 if( IsPrimaryKeyIndex(pIdx) && pPk!=0 ){ | |
| 191 iDataCur = pParse->nTab; | |
| 192 pTabList->a[0].iCursor = iDataCur; | |
| 193 } | |
| 194 pParse->nTab++; | |
| 195 } | |
| 196 | |
| 197 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[]. | |
| 198 ** Initialize aXRef[] and aToOpen[] to their default values. | |
| 199 */ | |
| 200 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 ); | |
| 201 if( aXRef==0 ) goto update_cleanup; | |
| 202 aRegIdx = aXRef+pTab->nCol; | |
| 203 aToOpen = (u8*)(aRegIdx+nIdx); | |
| 204 memset(aToOpen, 1, nIdx+1); | |
| 205 aToOpen[nIdx+1] = 0; | |
| 206 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1; | |
| 207 | |
| 208 /* Initialize the name-context */ | |
| 209 memset(&sNC, 0, sizeof(sNC)); | |
| 210 sNC.pParse = pParse; | |
| 211 sNC.pSrcList = pTabList; | |
| 212 | |
| 213 /* Resolve the column names in all the expressions of the | |
| 214 ** of the UPDATE statement. Also find the column index | |
| 215 ** for each column to be updated in the pChanges array. For each | |
| 216 ** column to be updated, make sure we have authorization to change | |
| 217 ** that column. | |
| 218 */ | |
| 219 chngRowid = chngPk = 0; | |
| 220 for(i=0; i<pChanges->nExpr; i++){ | |
| 221 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ | |
| 222 goto update_cleanup; | |
| 223 } | |
| 224 for(j=0; j<pTab->nCol; j++){ | |
| 225 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){ | |
| 226 if( j==pTab->iPKey ){ | |
| 227 chngRowid = 1; | |
| 228 pRowidExpr = pChanges->a[i].pExpr; | |
| 229 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){ | |
| 230 chngPk = 1; | |
| 231 } | |
| 232 aXRef[j] = i; | |
| 233 break; | |
| 234 } | |
| 235 } | |
| 236 if( j>=pTab->nCol ){ | |
| 237 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){ | |
| 238 j = -1; | |
| 239 chngRowid = 1; | |
| 240 pRowidExpr = pChanges->a[i].pExpr; | |
| 241 }else{ | |
| 242 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName); | |
| 243 pParse->checkSchema = 1; | |
| 244 goto update_cleanup; | |
| 245 } | |
| 246 } | |
| 247 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 248 { | |
| 249 int rc; | |
| 250 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, | |
| 251 j<0 ? "ROWID" : pTab->aCol[j].zName, | |
| 252 db->aDb[iDb].zName); | |
| 253 if( rc==SQLITE_DENY ){ | |
| 254 goto update_cleanup; | |
| 255 }else if( rc==SQLITE_IGNORE ){ | |
| 256 aXRef[j] = -1; | |
| 257 } | |
| 258 } | |
| 259 #endif | |
| 260 } | |
| 261 assert( (chngRowid & chngPk)==0 ); | |
| 262 assert( chngRowid==0 || chngRowid==1 ); | |
| 263 assert( chngPk==0 || chngPk==1 ); | |
| 264 chngKey = chngRowid + chngPk; | |
| 265 | |
| 266 /* The SET expressions are not actually used inside the WHERE loop. | |
| 267 ** So reset the colUsed mask | |
| 268 */ | |
| 269 pTabList->a[0].colUsed = 0; | |
| 270 | |
| 271 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey); | |
| 272 | |
| 273 /* There is one entry in the aRegIdx[] array for each index on the table | |
| 274 ** being updated. Fill in aRegIdx[] with a register number that will hold | |
| 275 ** the key for accessing each index. | |
| 276 */ | |
| 277 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ | |
| 278 int reg; | |
| 279 if( chngKey || hasFK || pIdx->pPartIdxWhere || pIdx==pPk ){ | |
| 280 reg = ++pParse->nMem; | |
| 281 }else{ | |
| 282 reg = 0; | |
| 283 for(i=0; i<pIdx->nKeyCol; i++){ | |
| 284 if( aXRef[pIdx->aiColumn[i]]>=0 ){ | |
| 285 reg = ++pParse->nMem; | |
| 286 break; | |
| 287 } | |
| 288 } | |
| 289 } | |
| 290 if( reg==0 ) aToOpen[j+1] = 0; | |
| 291 aRegIdx[j] = reg; | |
| 292 } | |
| 293 | |
| 294 /* Begin generating code. */ | |
| 295 v = sqlite3GetVdbe(pParse); | |
| 296 if( v==0 ) goto update_cleanup; | |
| 297 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); | |
| 298 sqlite3BeginWriteOperation(pParse, 1, iDb); | |
| 299 | |
| 300 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 301 /* Virtual tables must be handled separately */ | |
| 302 if( IsVirtual(pTab) ){ | |
| 303 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, | |
| 304 pWhere, onError); | |
| 305 pWhere = 0; | |
| 306 pTabList = 0; | |
| 307 goto update_cleanup; | |
| 308 } | |
| 309 #endif | |
| 310 | |
| 311 /* Allocate required registers. */ | |
| 312 regRowSet = ++pParse->nMem; | |
| 313 regOldRowid = regNewRowid = ++pParse->nMem; | |
| 314 if( chngPk || pTrigger || hasFK ){ | |
| 315 regOld = pParse->nMem + 1; | |
| 316 pParse->nMem += pTab->nCol; | |
| 317 } | |
| 318 if( chngKey || pTrigger || hasFK ){ | |
| 319 regNewRowid = ++pParse->nMem; | |
| 320 } | |
| 321 regNew = pParse->nMem + 1; | |
| 322 pParse->nMem += pTab->nCol; | |
| 323 | |
| 324 /* Start the view context. */ | |
| 325 if( isView ){ | |
| 326 sqlite3AuthContextPush(pParse, &sContext, pTab->zName); | |
| 327 } | |
| 328 | |
| 329 /* If we are trying to update a view, realize that view into | |
| 330 ** an ephemeral table. | |
| 331 */ | |
| 332 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) | |
| 333 if( isView ){ | |
| 334 sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur); | |
| 335 } | |
| 336 #endif | |
| 337 | |
| 338 /* Resolve the column names in all the expressions in the | |
| 339 ** WHERE clause. | |
| 340 */ | |
| 341 if( sqlite3ResolveExprNames(&sNC, pWhere) ){ | |
| 342 goto update_cleanup; | |
| 343 } | |
| 344 | |
| 345 /* Begin the database scan | |
| 346 */ | |
| 347 if( HasRowid(pTab) ){ | |
| 348 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); | |
| 349 pWInfo = sqlite3WhereBegin( | |
| 350 pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, iIdxCur | |
| 351 ); | |
| 352 if( pWInfo==0 ) goto update_cleanup; | |
| 353 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); | |
| 354 | |
| 355 /* Remember the rowid of every item to be updated. | |
| 356 */ | |
| 357 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); | |
| 358 if( !okOnePass ){ | |
| 359 sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid); | |
| 360 } | |
| 361 | |
| 362 /* End the database scan loop. | |
| 363 */ | |
| 364 sqlite3WhereEnd(pWInfo); | |
| 365 }else{ | |
| 366 int iPk; /* First of nPk memory cells holding PRIMARY KEY value */ | |
| 367 i16 nPk; /* Number of components of the PRIMARY KEY */ | |
| 368 int addrOpen; /* Address of the OpenEphemeral instruction */ | |
| 369 | |
| 370 assert( pPk!=0 ); | |
| 371 nPk = pPk->nKeyCol; | |
| 372 iPk = pParse->nMem+1; | |
| 373 pParse->nMem += nPk; | |
| 374 regKey = ++pParse->nMem; | |
| 375 iEph = pParse->nTab++; | |
| 376 sqlite3VdbeAddOp2(v, OP_Null, 0, iPk); | |
| 377 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk); | |
| 378 sqlite3VdbeSetP4KeyInfo(pParse, pPk); | |
| 379 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, | |
| 380 WHERE_ONEPASS_DESIRED, iIdxCur); | |
| 381 if( pWInfo==0 ) goto update_cleanup; | |
| 382 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); | |
| 383 for(i=0; i<nPk; i++){ | |
| 384 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i], | |
| 385 iPk+i); | |
| 386 } | |
| 387 if( okOnePass ){ | |
| 388 sqlite3VdbeChangeToNoop(v, addrOpen); | |
| 389 nKey = nPk; | |
| 390 regKey = iPk; | |
| 391 }else{ | |
| 392 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, | |
| 393 sqlite3IndexAffinityStr(v, pPk), nPk); | |
| 394 sqlite3VdbeAddOp2(v, OP_IdxInsert, iEph, regKey); | |
| 395 } | |
| 396 sqlite3WhereEnd(pWInfo); | |
| 397 } | |
| 398 | |
| 399 /* Initialize the count of updated rows | |
| 400 */ | |
| 401 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){ | |
| 402 regRowCount = ++pParse->nMem; | |
| 403 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); | |
| 404 } | |
| 405 | |
| 406 labelBreak = sqlite3VdbeMakeLabel(v); | |
| 407 if( !isView ){ | |
| 408 /* | |
| 409 ** Open every index that needs updating. Note that if any | |
| 410 ** index could potentially invoke a REPLACE conflict resolution | |
| 411 ** action, then we need to open all indices because we might need | |
| 412 ** to be deleting some records. | |
| 413 */ | |
| 414 if( onError==OE_Replace ){ | |
| 415 memset(aToOpen, 1, nIdx+1); | |
| 416 }else{ | |
| 417 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ | |
| 418 if( pIdx->onError==OE_Replace ){ | |
| 419 memset(aToOpen, 1, nIdx+1); | |
| 420 break; | |
| 421 } | |
| 422 } | |
| 423 } | |
| 424 if( okOnePass ){ | |
| 425 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; | |
| 426 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; | |
| 427 } | |
| 428 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iBaseCur, aToOpen, | |
| 429 0, 0); | |
| 430 } | |
| 431 | |
| 432 /* Top of the update loop */ | |
| 433 if( okOnePass ){ | |
| 434 if( aToOpen[iDataCur-iBaseCur] && !isView ){ | |
| 435 assert( pPk ); | |
| 436 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey); | |
| 437 VdbeCoverageNeverTaken(v); | |
| 438 } | |
| 439 labelContinue = labelBreak; | |
| 440 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); | |
| 441 VdbeCoverageIf(v, pPk==0); | |
| 442 VdbeCoverageIf(v, pPk!=0); | |
| 443 }else if( pPk ){ | |
| 444 labelContinue = sqlite3VdbeMakeLabel(v); | |
| 445 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); | |
| 446 addrTop = sqlite3VdbeAddOp2(v, OP_RowKey, iEph, regKey); | |
| 447 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0); | |
| 448 VdbeCoverage(v); | |
| 449 }else{ | |
| 450 labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, labelBreak, | |
| 451 regOldRowid); | |
| 452 VdbeCoverage(v); | |
| 453 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); | |
| 454 VdbeCoverage(v); | |
| 455 } | |
| 456 | |
| 457 /* If the record number will change, set register regNewRowid to | |
| 458 ** contain the new value. If the record number is not being modified, | |
| 459 ** then regNewRowid is the same register as regOldRowid, which is | |
| 460 ** already populated. */ | |
| 461 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid ); | |
| 462 if( chngRowid ){ | |
| 463 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); | |
| 464 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); | |
| 465 } | |
| 466 | |
| 467 /* Compute the old pre-UPDATE content of the row being changed, if that | |
| 468 ** information is needed */ | |
| 469 if( chngPk || hasFK || pTrigger ){ | |
| 470 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); | |
| 471 oldmask |= sqlite3TriggerColmask(pParse, | |
| 472 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError | |
| 473 ); | |
| 474 for(i=0; i<pTab->nCol; i++){ | |
| 475 if( oldmask==0xffffffff | |
| 476 || (i<32 && (oldmask & MASKBIT32(i))!=0) | |
| 477 || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 | |
| 478 ){ | |
| 479 testcase( oldmask!=0xffffffff && i==31 ); | |
| 480 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i); | |
| 481 }else{ | |
| 482 sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i); | |
| 483 } | |
| 484 } | |
| 485 if( chngRowid==0 && pPk==0 ){ | |
| 486 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid); | |
| 487 } | |
| 488 } | |
| 489 | |
| 490 /* Populate the array of registers beginning at regNew with the new | |
| 491 ** row data. This array is used to check constants, create the new | |
| 492 ** table and index records, and as the values for any new.* references | |
| 493 ** made by triggers. | |
| 494 ** | |
| 495 ** If there are one or more BEFORE triggers, then do not populate the | |
| 496 ** registers associated with columns that are (a) not modified by | |
| 497 ** this UPDATE statement and (b) not accessed by new.* references. The | |
| 498 ** values for registers not modified by the UPDATE must be reloaded from | |
| 499 ** the database after the BEFORE triggers are fired anyway (as the trigger | |
| 500 ** may have modified them). So not loading those that are not going to | |
| 501 ** be used eliminates some redundant opcodes. | |
| 502 */ | |
| 503 newmask = sqlite3TriggerColmask( | |
| 504 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError | |
| 505 ); | |
| 506 /*sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);*/ | |
| 507 for(i=0; i<pTab->nCol; i++){ | |
| 508 if( i==pTab->iPKey ){ | |
| 509 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i); | |
| 510 }else{ | |
| 511 j = aXRef[i]; | |
| 512 if( j>=0 ){ | |
| 513 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i); | |
| 514 }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ | |
| 515 /* This branch loads the value of a column that will not be changed | |
| 516 ** into a register. This is done if there are no BEFORE triggers, or | |
| 517 ** if there are one or more BEFORE triggers that use this value via | |
| 518 ** a new.* reference in a trigger program. | |
| 519 */ | |
| 520 testcase( i==31 ); | |
| 521 testcase( i==32 ); | |
| 522 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i); | |
| 523 }else{ | |
| 524 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i); | |
| 525 } | |
| 526 } | |
| 527 } | |
| 528 | |
| 529 /* Fire any BEFORE UPDATE triggers. This happens before constraints are | |
| 530 ** verified. One could argue that this is wrong. | |
| 531 */ | |
| 532 if( tmask&TRIGGER_BEFORE ){ | |
| 533 sqlite3TableAffinity(v, pTab, regNew); | |
| 534 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, | |
| 535 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); | |
| 536 | |
| 537 /* The row-trigger may have deleted the row being updated. In this | |
| 538 ** case, jump to the next row. No updates or AFTER triggers are | |
| 539 ** required. This behavior - what happens when the row being updated | |
| 540 ** is deleted or renamed by a BEFORE trigger - is left undefined in the | |
| 541 ** documentation. | |
| 542 */ | |
| 543 if( pPk ){ | |
| 544 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey); | |
| 545 VdbeCoverage(v); | |
| 546 }else{ | |
| 547 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); | |
| 548 VdbeCoverage(v); | |
| 549 } | |
| 550 | |
| 551 /* If it did not delete it, the row-trigger may still have modified | |
| 552 ** some of the columns of the row being updated. Load the values for | |
| 553 ** all columns not modified by the update statement into their | |
| 554 ** registers in case this has happened. | |
| 555 */ | |
| 556 for(i=0; i<pTab->nCol; i++){ | |
| 557 if( aXRef[i]<0 && i!=pTab->iPKey ){ | |
| 558 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i); | |
| 559 } | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 if( !isView ){ | |
| 564 int j1 = 0; /* Address of jump instruction */ | |
| 565 int bReplace = 0; /* True if REPLACE conflict resolution might happen */ | |
| 566 | |
| 567 /* Do constraint checks. */ | |
| 568 assert( regOldRowid>0 ); | |
| 569 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, | |
| 570 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace); | |
| 571 | |
| 572 /* Do FK constraint checks. */ | |
| 573 if( hasFK ){ | |
| 574 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey); | |
| 575 } | |
| 576 | |
| 577 /* Delete the index entries associated with the current record. */ | |
| 578 if( bReplace || chngKey ){ | |
| 579 if( pPk ){ | |
| 580 j1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey); | |
| 581 }else{ | |
| 582 j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid); | |
| 583 } | |
| 584 VdbeCoverageNeverTaken(v); | |
| 585 } | |
| 586 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx); | |
| 587 | |
| 588 /* If changing the record number, delete the old record. */ | |
| 589 if( hasFK || chngKey || pPk!=0 ){ | |
| 590 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0); | |
| 591 } | |
| 592 if( bReplace || chngKey ){ | |
| 593 sqlite3VdbeJumpHere(v, j1); | |
| 594 } | |
| 595 | |
| 596 if( hasFK ){ | |
| 597 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey); | |
| 598 } | |
| 599 | |
| 600 /* Insert the new index entries and the new record. */ | |
| 601 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur, | |
| 602 regNewRowid, aRegIdx, 1, 0, 0); | |
| 603 | |
| 604 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to | |
| 605 ** handle rows (possibly in other tables) that refer via a foreign key | |
| 606 ** to the row just updated. */ | |
| 607 if( hasFK ){ | |
| 608 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey); | |
| 609 } | |
| 610 } | |
| 611 | |
| 612 /* Increment the row counter | |
| 613 */ | |
| 614 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){ | |
| 615 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); | |
| 616 } | |
| 617 | |
| 618 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, | |
| 619 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue); | |
| 620 | |
| 621 /* Repeat the above with the next record to be updated, until | |
| 622 ** all record selected by the WHERE clause have been updated. | |
| 623 */ | |
| 624 if( okOnePass ){ | |
| 625 /* Nothing to do at end-of-loop for a single-pass */ | |
| 626 }else if( pPk ){ | |
| 627 sqlite3VdbeResolveLabel(v, labelContinue); | |
| 628 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); | |
| 629 }else{ | |
| 630 sqlite3VdbeAddOp2(v, OP_Goto, 0, labelContinue); | |
| 631 } | |
| 632 sqlite3VdbeResolveLabel(v, labelBreak); | |
| 633 | |
| 634 /* Close all tables */ | |
| 635 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ | |
| 636 assert( aRegIdx ); | |
| 637 if( aToOpen[i+1] ){ | |
| 638 sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0); | |
| 639 } | |
| 640 } | |
| 641 if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0); | |
| 642 | |
| 643 /* Update the sqlite_sequence table by storing the content of the | |
| 644 ** maximum rowid counter values recorded while inserting into | |
| 645 ** autoincrement tables. | |
| 646 */ | |
| 647 if( pParse->nested==0 && pParse->pTriggerTab==0 ){ | |
| 648 sqlite3AutoincrementEnd(pParse); | |
| 649 } | |
| 650 | |
| 651 /* | |
| 652 ** Return the number of rows that were changed. If this routine is | |
| 653 ** generating code because of a call to sqlite3NestedParse(), do not | |
| 654 ** invoke the callback function. | |
| 655 */ | |
| 656 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){ | |
| 657 sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); | |
| 658 sqlite3VdbeSetNumCols(v, 1); | |
| 659 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC); | |
| 660 } | |
| 661 | |
| 662 update_cleanup: | |
| 663 sqlite3AuthContextPop(&sContext); | |
| 664 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ | |
| 665 sqlite3SrcListDelete(db, pTabList); | |
| 666 sqlite3ExprListDelete(db, pChanges); | |
| 667 sqlite3ExprDelete(db, pWhere); | |
| 668 return; | |
| 669 } | |
| 670 /* Make sure "isView" and other macros defined above are undefined. Otherwise | |
| 671 ** they may interfere with compilation of other functions in this file | |
| 672 ** (or in another file, if this file becomes part of the amalgamation). */ | |
| 673 #ifdef isView | |
| 674 #undef isView | |
| 675 #endif | |
| 676 #ifdef pTrigger | |
| 677 #undef pTrigger | |
| 678 #endif | |
| 679 | |
| 680 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 681 /* | |
| 682 ** Generate code for an UPDATE of a virtual table. | |
| 683 ** | |
| 684 ** The strategy is that we create an ephemeral table that contains | |
| 685 ** for each row to be changed: | |
| 686 ** | |
| 687 ** (A) The original rowid of that row. | |
| 688 ** (B) The revised rowid for the row. (note1) | |
| 689 ** (C) The content of every column in the row. | |
| 690 ** | |
| 691 ** Then we loop over this ephemeral table and for each row in | |
| 692 ** the ephemeral table call VUpdate. | |
| 693 ** | |
| 694 ** When finished, drop the ephemeral table. | |
| 695 ** | |
| 696 ** (note1) Actually, if we know in advance that (A) is always the same | |
| 697 ** as (B) we only store (A), then duplicate (A) when pulling | |
| 698 ** it out of the ephemeral table before calling VUpdate. | |
| 699 */ | |
| 700 static void updateVirtualTable( | |
| 701 Parse *pParse, /* The parsing context */ | |
| 702 SrcList *pSrc, /* The virtual table to be modified */ | |
| 703 Table *pTab, /* The virtual table */ | |
| 704 ExprList *pChanges, /* The columns to change in the UPDATE statement */ | |
| 705 Expr *pRowid, /* Expression used to recompute the rowid */ | |
| 706 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ | |
| 707 Expr *pWhere, /* WHERE clause of the UPDATE statement */ | |
| 708 int onError /* ON CONFLICT strategy */ | |
| 709 ){ | |
| 710 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ | |
| 711 ExprList *pEList = 0; /* The result set of the SELECT statement */ | |
| 712 Select *pSelect = 0; /* The SELECT statement */ | |
| 713 Expr *pExpr; /* Temporary expression */ | |
| 714 int ephemTab; /* Table holding the result of the SELECT */ | |
| 715 int i; /* Loop counter */ | |
| 716 int addr; /* Address of top of loop */ | |
| 717 int iReg; /* First register in set passed to OP_VUpdate */ | |
| 718 sqlite3 *db = pParse->db; /* Database connection */ | |
| 719 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab); | |
| 720 SelectDest dest; | |
| 721 | |
| 722 /* Construct the SELECT statement that will find the new values for | |
| 723 ** all updated rows. | |
| 724 */ | |
| 725 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_")); | |
| 726 if( pRowid ){ | |
| 727 pEList = sqlite3ExprListAppend(pParse, pEList, | |
| 728 sqlite3ExprDup(db, pRowid, 0)); | |
| 729 } | |
| 730 assert( pTab->iPKey<0 ); | |
| 731 for(i=0; i<pTab->nCol; i++){ | |
| 732 if( aXRef[i]>=0 ){ | |
| 733 pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0); | |
| 734 }else{ | |
| 735 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName); | |
| 736 } | |
| 737 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr); | |
| 738 } | |
| 739 pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0); | |
| 740 | |
| 741 /* Create the ephemeral table into which the update results will | |
| 742 ** be stored. | |
| 743 */ | |
| 744 assert( v ); | |
| 745 ephemTab = pParse->nTab++; | |
| 746 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0)); | |
| 747 sqlite3VdbeChangeP5(v, BTREE_UNORDERED); | |
| 748 | |
| 749 /* fill the ephemeral table | |
| 750 */ | |
| 751 sqlite3SelectDestInit(&dest, SRT_Table, ephemTab); | |
| 752 sqlite3Select(pParse, pSelect, &dest); | |
| 753 | |
| 754 /* Generate code to scan the ephemeral table and call VUpdate. */ | |
| 755 iReg = ++pParse->nMem; | |
| 756 pParse->nMem += pTab->nCol+1; | |
| 757 addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0); VdbeCoverage(v); | |
| 758 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, 0, iReg); | |
| 759 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1); | |
| 760 for(i=0; i<pTab->nCol; i++){ | |
| 761 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i); | |
| 762 } | |
| 763 sqlite3VtabMakeWritable(pParse, pTab); | |
| 764 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB); | |
| 765 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError); | |
| 766 sqlite3MayAbort(pParse); | |
| 767 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v); | |
| 768 sqlite3VdbeJumpHere(v, addr); | |
| 769 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0); | |
| 770 | |
| 771 /* Cleanup */ | |
| 772 sqlite3SelectDelete(db, pSelect); | |
| 773 } | |
| 774 #endif /* SQLITE_OMIT_VIRTUALTABLE */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
