| 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 = 0; /* The old rowid */ | |
| 138 int regNewRowid = 0; /* The new rowid */ | |
| 139 int regNew = 0; /* 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. Unless this is a virtual table. In that | |
| 268 ** case, set all bits of the colUsed mask (to ensure that the virtual | |
| 269 ** table implementation makes all columns available). | |
| 270 */ | |
| 271 pTabList->a[0].colUsed = IsVirtual(pTab) ? (Bitmask)-1 : 0; | |
| 272 | |
| 273 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey); | |
| 274 | |
| 275 /* There is one entry in the aRegIdx[] array for each index on the table | |
| 276 ** being updated. Fill in aRegIdx[] with a register number that will hold | |
| 277 ** the key for accessing each index. | |
| 278 ** | |
| 279 ** FIXME: Be smarter about omitting indexes that use expressions. | |
| 280 */ | |
| 281 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ | |
| 282 int reg; | |
| 283 if( chngKey || hasFK || pIdx->pPartIdxWhere || pIdx==pPk ){ | |
| 284 reg = ++pParse->nMem; | |
| 285 }else{ | |
| 286 reg = 0; | |
| 287 for(i=0; i<pIdx->nKeyCol; i++){ | |
| 288 i16 iIdxCol = pIdx->aiColumn[i]; | |
| 289 if( iIdxCol<0 || aXRef[iIdxCol]>=0 ){ | |
| 290 reg = ++pParse->nMem; | |
| 291 break; | |
| 292 } | |
| 293 } | |
| 294 } | |
| 295 if( reg==0 ) aToOpen[j+1] = 0; | |
| 296 aRegIdx[j] = reg; | |
| 297 } | |
| 298 | |
| 299 /* Begin generating code. */ | |
| 300 v = sqlite3GetVdbe(pParse); | |
| 301 if( v==0 ) goto update_cleanup; | |
| 302 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); | |
| 303 sqlite3BeginWriteOperation(pParse, 1, iDb); | |
| 304 | |
| 305 /* Allocate required registers. */ | |
| 306 if( !IsVirtual(pTab) ){ | |
| 307 regRowSet = ++pParse->nMem; | |
| 308 regOldRowid = regNewRowid = ++pParse->nMem; | |
| 309 if( chngPk || pTrigger || hasFK ){ | |
| 310 regOld = pParse->nMem + 1; | |
| 311 pParse->nMem += pTab->nCol; | |
| 312 } | |
| 313 if( chngKey || pTrigger || hasFK ){ | |
| 314 regNewRowid = ++pParse->nMem; | |
| 315 } | |
| 316 regNew = pParse->nMem + 1; | |
| 317 pParse->nMem += pTab->nCol; | |
| 318 } | |
| 319 | |
| 320 /* Start the view context. */ | |
| 321 if( isView ){ | |
| 322 sqlite3AuthContextPush(pParse, &sContext, pTab->zName); | |
| 323 } | |
| 324 | |
| 325 /* If we are trying to update a view, realize that view into | |
| 326 ** an ephemeral table. | |
| 327 */ | |
| 328 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) | |
| 329 if( isView ){ | |
| 330 sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur); | |
| 331 } | |
| 332 #endif | |
| 333 | |
| 334 /* Resolve the column names in all the expressions in the | |
| 335 ** WHERE clause. | |
| 336 */ | |
| 337 if( sqlite3ResolveExprNames(&sNC, pWhere) ){ | |
| 338 goto update_cleanup; | |
| 339 } | |
| 340 | |
| 341 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 342 /* Virtual tables must be handled separately */ | |
| 343 if( IsVirtual(pTab) ){ | |
| 344 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, | |
| 345 pWhere, onError); | |
| 346 goto update_cleanup; | |
| 347 } | |
| 348 #endif | |
| 349 | |
| 350 /* Begin the database scan | |
| 351 */ | |
| 352 if( HasRowid(pTab) ){ | |
| 353 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); | |
| 354 pWInfo = sqlite3WhereBegin( | |
| 355 pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, iIdxCur | |
| 356 ); | |
| 357 if( pWInfo==0 ) goto update_cleanup; | |
| 358 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); | |
| 359 | |
| 360 /* Remember the rowid of every item to be updated. | |
| 361 */ | |
| 362 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); | |
| 363 if( !okOnePass ){ | |
| 364 sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid); | |
| 365 } | |
| 366 | |
| 367 /* End the database scan loop. | |
| 368 */ | |
| 369 sqlite3WhereEnd(pWInfo); | |
| 370 }else{ | |
| 371 int iPk; /* First of nPk memory cells holding PRIMARY KEY value */ | |
| 372 i16 nPk; /* Number of components of the PRIMARY KEY */ | |
| 373 int addrOpen; /* Address of the OpenEphemeral instruction */ | |
| 374 | |
| 375 assert( pPk!=0 ); | |
| 376 nPk = pPk->nKeyCol; | |
| 377 iPk = pParse->nMem+1; | |
| 378 pParse->nMem += nPk; | |
| 379 regKey = ++pParse->nMem; | |
| 380 iEph = pParse->nTab++; | |
| 381 sqlite3VdbeAddOp2(v, OP_Null, 0, iPk); | |
| 382 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk); | |
| 383 sqlite3VdbeSetP4KeyInfo(pParse, pPk); | |
| 384 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, | |
| 385 WHERE_ONEPASS_DESIRED, iIdxCur); | |
| 386 if( pWInfo==0 ) goto update_cleanup; | |
| 387 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); | |
| 388 for(i=0; i<nPk; i++){ | |
| 389 assert( pPk->aiColumn[i]>=0 ); | |
| 390 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i], | |
| 391 iPk+i); | |
| 392 } | |
| 393 if( okOnePass ){ | |
| 394 sqlite3VdbeChangeToNoop(v, addrOpen); | |
| 395 nKey = nPk; | |
| 396 regKey = iPk; | |
| 397 }else{ | |
| 398 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, | |
| 399 sqlite3IndexAffinityStr(db, pPk), nPk); | |
| 400 sqlite3VdbeAddOp2(v, OP_IdxInsert, iEph, regKey); | |
| 401 } | |
| 402 sqlite3WhereEnd(pWInfo); | |
| 403 } | |
| 404 | |
| 405 /* Initialize the count of updated rows | |
| 406 */ | |
| 407 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){ | |
| 408 regRowCount = ++pParse->nMem; | |
| 409 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); | |
| 410 } | |
| 411 | |
| 412 labelBreak = sqlite3VdbeMakeLabel(v); | |
| 413 if( !isView ){ | |
| 414 /* | |
| 415 ** Open every index that needs updating. Note that if any | |
| 416 ** index could potentially invoke a REPLACE conflict resolution | |
| 417 ** action, then we need to open all indices because we might need | |
| 418 ** to be deleting some records. | |
| 419 */ | |
| 420 if( onError==OE_Replace ){ | |
| 421 memset(aToOpen, 1, nIdx+1); | |
| 422 }else{ | |
| 423 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ | |
| 424 if( pIdx->onError==OE_Replace ){ | |
| 425 memset(aToOpen, 1, nIdx+1); | |
| 426 break; | |
| 427 } | |
| 428 } | |
| 429 } | |
| 430 if( okOnePass ){ | |
| 431 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; | |
| 432 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; | |
| 433 } | |
| 434 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, aToOpen, | |
| 435 0, 0); | |
| 436 } | |
| 437 | |
| 438 /* Top of the update loop */ | |
| 439 if( okOnePass ){ | |
| 440 if( aToOpen[iDataCur-iBaseCur] && !isView ){ | |
| 441 assert( pPk ); | |
| 442 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey); | |
| 443 VdbeCoverageNeverTaken(v); | |
| 444 } | |
| 445 labelContinue = labelBreak; | |
| 446 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); | |
| 447 VdbeCoverageIf(v, pPk==0); | |
| 448 VdbeCoverageIf(v, pPk!=0); | |
| 449 }else if( pPk ){ | |
| 450 labelContinue = sqlite3VdbeMakeLabel(v); | |
| 451 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); | |
| 452 addrTop = sqlite3VdbeAddOp2(v, OP_RowKey, iEph, regKey); | |
| 453 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0); | |
| 454 VdbeCoverage(v); | |
| 455 }else{ | |
| 456 labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, labelBreak, | |
| 457 regOldRowid); | |
| 458 VdbeCoverage(v); | |
| 459 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); | |
| 460 VdbeCoverage(v); | |
| 461 } | |
| 462 | |
| 463 /* If the record number will change, set register regNewRowid to | |
| 464 ** contain the new value. If the record number is not being modified, | |
| 465 ** then regNewRowid is the same register as regOldRowid, which is | |
| 466 ** already populated. */ | |
| 467 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid ); | |
| 468 if( chngRowid ){ | |
| 469 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); | |
| 470 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); | |
| 471 } | |
| 472 | |
| 473 /* Compute the old pre-UPDATE content of the row being changed, if that | |
| 474 ** information is needed */ | |
| 475 if( chngPk || hasFK || pTrigger ){ | |
| 476 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); | |
| 477 oldmask |= sqlite3TriggerColmask(pParse, | |
| 478 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError | |
| 479 ); | |
| 480 for(i=0; i<pTab->nCol; i++){ | |
| 481 if( oldmask==0xffffffff | |
| 482 || (i<32 && (oldmask & MASKBIT32(i))!=0) | |
| 483 || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 | |
| 484 ){ | |
| 485 testcase( oldmask!=0xffffffff && i==31 ); | |
| 486 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i); | |
| 487 }else{ | |
| 488 sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i); | |
| 489 } | |
| 490 } | |
| 491 if( chngRowid==0 && pPk==0 ){ | |
| 492 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid); | |
| 493 } | |
| 494 } | |
| 495 | |
| 496 /* Populate the array of registers beginning at regNew with the new | |
| 497 ** row data. This array is used to check constants, create the new | |
| 498 ** table and index records, and as the values for any new.* references | |
| 499 ** made by triggers. | |
| 500 ** | |
| 501 ** If there are one or more BEFORE triggers, then do not populate the | |
| 502 ** registers associated with columns that are (a) not modified by | |
| 503 ** this UPDATE statement and (b) not accessed by new.* references. The | |
| 504 ** values for registers not modified by the UPDATE must be reloaded from | |
| 505 ** the database after the BEFORE triggers are fired anyway (as the trigger | |
| 506 ** may have modified them). So not loading those that are not going to | |
| 507 ** be used eliminates some redundant opcodes. | |
| 508 */ | |
| 509 newmask = sqlite3TriggerColmask( | |
| 510 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError | |
| 511 ); | |
| 512 for(i=0; i<pTab->nCol; i++){ | |
| 513 if( i==pTab->iPKey ){ | |
| 514 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i); | |
| 515 }else{ | |
| 516 j = aXRef[i]; | |
| 517 if( j>=0 ){ | |
| 518 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i); | |
| 519 }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ | |
| 520 /* This branch loads the value of a column that will not be changed | |
| 521 ** into a register. This is done if there are no BEFORE triggers, or | |
| 522 ** if there are one or more BEFORE triggers that use this value via | |
| 523 ** a new.* reference in a trigger program. | |
| 524 */ | |
| 525 testcase( i==31 ); | |
| 526 testcase( i==32 ); | |
| 527 sqlite3ExprCodeGetColumnToReg(pParse, pTab, i, iDataCur, regNew+i); | |
| 528 }else{ | |
| 529 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i); | |
| 530 } | |
| 531 } | |
| 532 } | |
| 533 | |
| 534 /* Fire any BEFORE UPDATE triggers. This happens before constraints are | |
| 535 ** verified. One could argue that this is wrong. | |
| 536 */ | |
| 537 if( tmask&TRIGGER_BEFORE ){ | |
| 538 sqlite3TableAffinity(v, pTab, regNew); | |
| 539 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, | |
| 540 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); | |
| 541 | |
| 542 /* The row-trigger may have deleted the row being updated. In this | |
| 543 ** case, jump to the next row. No updates or AFTER triggers are | |
| 544 ** required. This behavior - what happens when the row being updated | |
| 545 ** is deleted or renamed by a BEFORE trigger - is left undefined in the | |
| 546 ** documentation. | |
| 547 */ | |
| 548 if( pPk ){ | |
| 549 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey); | |
| 550 VdbeCoverage(v); | |
| 551 }else{ | |
| 552 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); | |
| 553 VdbeCoverage(v); | |
| 554 } | |
| 555 | |
| 556 /* If it did not delete it, the row-trigger may still have modified | |
| 557 ** some of the columns of the row being updated. Load the values for | |
| 558 ** all columns not modified by the update statement into their | |
| 559 ** registers in case this has happened. | |
| 560 */ | |
| 561 for(i=0; i<pTab->nCol; i++){ | |
| 562 if( aXRef[i]<0 && i!=pTab->iPKey ){ | |
| 563 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i); | |
| 564 } | |
| 565 } | |
| 566 } | |
| 567 | |
| 568 if( !isView ){ | |
| 569 int addr1 = 0; /* Address of jump instruction */ | |
| 570 int bReplace = 0; /* True if REPLACE conflict resolution might happen */ | |
| 571 | |
| 572 /* Do constraint checks. */ | |
| 573 assert( regOldRowid>0 ); | |
| 574 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, | |
| 575 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace); | |
| 576 | |
| 577 /* Do FK constraint checks. */ | |
| 578 if( hasFK ){ | |
| 579 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey); | |
| 580 } | |
| 581 | |
| 582 /* Delete the index entries associated with the current record. */ | |
| 583 if( bReplace || chngKey ){ | |
| 584 if( pPk ){ | |
| 585 addr1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey); | |
| 586 }else{ | |
| 587 addr1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid); | |
| 588 } | |
| 589 VdbeCoverageNeverTaken(v); | |
| 590 } | |
| 591 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1); | |
| 592 | |
| 593 /* If changing the record number, delete the old record. */ | |
| 594 if( hasFK || chngKey || pPk!=0 ){ | |
| 595 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0); | |
| 596 } | |
| 597 if( bReplace || chngKey ){ | |
| 598 sqlite3VdbeJumpHere(v, addr1); | |
| 599 } | |
| 600 | |
| 601 if( hasFK ){ | |
| 602 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey); | |
| 603 } | |
| 604 | |
| 605 /* Insert the new index entries and the new record. */ | |
| 606 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur, | |
| 607 regNewRowid, aRegIdx, 1, 0, 0); | |
| 608 | |
| 609 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to | |
| 610 ** handle rows (possibly in other tables) that refer via a foreign key | |
| 611 ** to the row just updated. */ | |
| 612 if( hasFK ){ | |
| 613 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey); | |
| 614 } | |
| 615 } | |
| 616 | |
| 617 /* Increment the row counter | |
| 618 */ | |
| 619 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){ | |
| 620 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); | |
| 621 } | |
| 622 | |
| 623 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, | |
| 624 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue); | |
| 625 | |
| 626 /* Repeat the above with the next record to be updated, until | |
| 627 ** all record selected by the WHERE clause have been updated. | |
| 628 */ | |
| 629 if( okOnePass ){ | |
| 630 /* Nothing to do at end-of-loop for a single-pass */ | |
| 631 }else if( pPk ){ | |
| 632 sqlite3VdbeResolveLabel(v, labelContinue); | |
| 633 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); | |
| 634 }else{ | |
| 635 sqlite3VdbeGoto(v, labelContinue); | |
| 636 } | |
| 637 sqlite3VdbeResolveLabel(v, labelBreak); | |
| 638 | |
| 639 /* Close all tables */ | |
| 640 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ | |
| 641 assert( aRegIdx ); | |
| 642 if( aToOpen[i+1] ){ | |
| 643 sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0); | |
| 644 } | |
| 645 } | |
| 646 if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0); | |
| 647 | |
| 648 /* Update the sqlite_sequence table by storing the content of the | |
| 649 ** maximum rowid counter values recorded while inserting into | |
| 650 ** autoincrement tables. | |
| 651 */ | |
| 652 if( pParse->nested==0 && pParse->pTriggerTab==0 ){ | |
| 653 sqlite3AutoincrementEnd(pParse); | |
| 654 } | |
| 655 | |
| 656 /* | |
| 657 ** Return the number of rows that were changed. If this routine is | |
| 658 ** generating code because of a call to sqlite3NestedParse(), do not | |
| 659 ** invoke the callback function. | |
| 660 */ | |
| 661 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){ | |
| 662 sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); | |
| 663 sqlite3VdbeSetNumCols(v, 1); | |
| 664 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC); | |
| 665 } | |
| 666 | |
| 667 update_cleanup: | |
| 668 sqlite3AuthContextPop(&sContext); | |
| 669 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ | |
| 670 sqlite3SrcListDelete(db, pTabList); | |
| 671 sqlite3ExprListDelete(db, pChanges); | |
| 672 sqlite3ExprDelete(db, pWhere); | |
| 673 return; | |
| 674 } | |
| 675 /* Make sure "isView" and other macros defined above are undefined. Otherwise | |
| 676 ** they may interfere with compilation of other functions in this file | |
| 677 ** (or in another file, if this file becomes part of the amalgamation). */ | |
| 678 #ifdef isView | |
| 679 #undef isView | |
| 680 #endif | |
| 681 #ifdef pTrigger | |
| 682 #undef pTrigger | |
| 683 #endif | |
| 684 | |
| 685 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 686 /* | |
| 687 ** Generate code for an UPDATE of a virtual table. | |
| 688 ** | |
| 689 ** There are two possible strategies - the default and the special | |
| 690 ** "onepass" strategy. Onepass is only used if the virtual table | |
| 691 ** implementation indicates that pWhere may match at most one row. | |
| 692 ** | |
| 693 ** The default strategy is to create an ephemeral table that contains | |
| 694 ** for each row to be changed: | |
| 695 ** | |
| 696 ** (A) The original rowid of that row. | |
| 697 ** (B) The revised rowid for the row. | |
| 698 ** (C) The content of every column in the row. | |
| 699 ** | |
| 700 ** Then loop through the contents of this ephemeral table executing a | |
| 701 ** VUpdate for each row. When finished, drop the ephemeral table. | |
| 702 ** | |
| 703 ** The "onepass" strategy does not use an ephemeral table. Instead, it | |
| 704 ** stores the same values (A, B and C above) in a register array and | |
| 705 ** makes a single invocation of VUpdate. | |
| 706 */ | |
| 707 static void updateVirtualTable( | |
| 708 Parse *pParse, /* The parsing context */ | |
| 709 SrcList *pSrc, /* The virtual table to be modified */ | |
| 710 Table *pTab, /* The virtual table */ | |
| 711 ExprList *pChanges, /* The columns to change in the UPDATE statement */ | |
| 712 Expr *pRowid, /* Expression used to recompute the rowid */ | |
| 713 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ | |
| 714 Expr *pWhere, /* WHERE clause of the UPDATE statement */ | |
| 715 int onError /* ON CONFLICT strategy */ | |
| 716 ){ | |
| 717 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ | |
| 718 int ephemTab; /* Table holding the result of the SELECT */ | |
| 719 int i; /* Loop counter */ | |
| 720 sqlite3 *db = pParse->db; /* Database connection */ | |
| 721 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab); | |
| 722 WhereInfo *pWInfo; | |
| 723 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */ | |
| 724 int regArg; /* First register in VUpdate arg array */ | |
| 725 int regRec; /* Register in which to assemble record */ | |
| 726 int regRowid; /* Register for ephem table rowid */ | |
| 727 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */ | |
| 728 int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */ | |
| 729 int bOnePass; /* True to use onepass strategy */ | |
| 730 int addr; /* Address of OP_OpenEphemeral */ | |
| 731 | |
| 732 /* Allocate nArg registers to martial the arguments to VUpdate. Then | |
| 733 ** create and open the ephemeral table in which the records created from | |
| 734 ** these arguments will be temporarily stored. */ | |
| 735 assert( v ); | |
| 736 ephemTab = pParse->nTab++; | |
| 737 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); | |
| 738 regArg = pParse->nMem + 1; | |
| 739 pParse->nMem += nArg; | |
| 740 regRec = ++pParse->nMem; | |
| 741 regRowid = ++pParse->nMem; | |
| 742 | |
| 743 /* Start scanning the virtual table */ | |
| 744 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0,0,WHERE_ONEPASS_DESIRED,0); | |
| 745 if( pWInfo==0 ) return; | |
| 746 | |
| 747 /* Populate the argument registers. */ | |
| 748 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg); | |
| 749 if( pRowid ){ | |
| 750 sqlite3ExprCode(pParse, pRowid, regArg+1); | |
| 751 }else{ | |
| 752 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1); | |
| 753 } | |
| 754 for(i=0; i<pTab->nCol; i++){ | |
| 755 if( aXRef[i]>=0 ){ | |
| 756 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i); | |
| 757 }else{ | |
| 758 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i); | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 bOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy); | |
| 763 | |
| 764 if( bOnePass ){ | |
| 765 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded | |
| 766 ** above. Also, if this is a top-level parse (not a trigger), clear the | |
| 767 ** multi-write flag so that the VM does not open a statement journal */ | |
| 768 sqlite3VdbeChangeToNoop(v, addr); | |
| 769 if( sqlite3IsToplevel(pParse) ){ | |
| 770 pParse->isMultiWrite = 0; | |
| 771 } | |
| 772 }else{ | |
| 773 /* Create a record from the argument register contents and insert it into | |
| 774 ** the ephemeral table. */ | |
| 775 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec); | |
| 776 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid); | |
| 777 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid); | |
| 778 } | |
| 779 | |
| 780 | |
| 781 if( bOnePass==0 ){ | |
| 782 /* End the virtual table scan */ | |
| 783 sqlite3WhereEnd(pWInfo); | |
| 784 | |
| 785 /* Begin scannning through the ephemeral table. */ | |
| 786 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v); | |
| 787 | |
| 788 /* Extract arguments from the current row of the ephemeral table and | |
| 789 ** invoke the VUpdate method. */ | |
| 790 for(i=0; i<nArg; i++){ | |
| 791 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i); | |
| 792 } | |
| 793 } | |
| 794 sqlite3VtabMakeWritable(pParse, pTab); | |
| 795 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB); | |
| 796 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError); | |
| 797 sqlite3MayAbort(pParse); | |
| 798 | |
| 799 /* End of the ephemeral table scan. Or, if using the onepass strategy, | |
| 800 ** jump to here if the scan visited zero rows. */ | |
| 801 if( bOnePass==0 ){ | |
| 802 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v); | |
| 803 sqlite3VdbeJumpHere(v, addr); | |
| 804 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0); | |
| 805 }else{ | |
| 806 sqlite3WhereEnd(pWInfo); | |
| 807 } | |
| 808 } | |
| 809 #endif /* SQLITE_OMIT_VIRTUALTABLE */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
