Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / update.c
blob3af4017f1ba9a3143bbe2c9d0dd78b50aab3bd54
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.
11 *************************************************************************
12 ** This file contains C code routines that are called by the parser
13 ** to handle UPDATE statements.
15 #include "sqliteInt.h"
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 */
29 #endif /* SQLITE_OMIT_VIRTUALTABLE */
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.
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.
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.)
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.
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.
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);
74 #ifndef SQLITE_OMIT_FLOATING_POINT
75 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
76 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
78 #endif
83 ** Process an UPDATE statement.
85 ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
86 ** \_______/ \________/ \______/ \________________/
87 * onError pTabList pChanges pWhere
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 */
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 */
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 */
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 */
144 memset(&sContext, 0, sizeof(sContext));
145 db = pParse->db;
146 if( pParse->nErr || db->mallocFailed ){
147 goto update_cleanup;
149 assert( pTabList->nSrc==1 );
151 /* Locate the table which we want to update.
153 pTab = sqlite3SrcListLookup(pParse, pTabList);
154 if( pTab==0 ) goto update_cleanup;
155 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
157 /* Figure out if we have any triggers and if the table being
158 ** updated is a view.
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
174 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
175 goto update_cleanup;
177 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
178 goto update_cleanup;
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.
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;
194 pParse->nTab++;
197 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
198 ** Initialize aXRef[] and aToOpen[] to their default values.
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;
208 /* Initialize the name-context */
209 memset(&sNC, 0, sizeof(sNC));
210 sNC.pParse = pParse;
211 sNC.pSrcList = pTabList;
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.
219 chngRowid = chngPk = 0;
220 for(i=0; i<pChanges->nExpr; i++){
221 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
222 goto update_cleanup;
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;
232 aXRef[j] = i;
233 break;
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;
247 #ifndef SQLITE_OMIT_AUTHORIZATION
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;
259 #endif
261 assert( (chngRowid & chngPk)==0 );
262 assert( chngRowid==0 || chngRowid==1 );
263 assert( chngPk==0 || chngPk==1 );
264 chngKey = chngRowid + chngPk;
266 /* The SET expressions are not actually used inside the WHERE loop.
267 ** So reset the colUsed mask
269 pTabList->a[0].colUsed = 0;
271 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
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.
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;
290 if( reg==0 ) aToOpen[j+1] = 0;
291 aRegIdx[j] = reg;
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);
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;
309 #endif
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;
318 if( chngKey || pTrigger || hasFK ){
319 regNewRowid = ++pParse->nMem;
321 regNew = pParse->nMem + 1;
322 pParse->nMem += pTab->nCol;
324 /* Start the view context. */
325 if( isView ){
326 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
329 /* If we are trying to update a view, realize that view into
330 ** an ephemeral table.
332 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
333 if( isView ){
334 sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur);
336 #endif
338 /* Resolve the column names in all the expressions in the
339 ** WHERE clause.
341 if( sqlite3ResolveExprNames(&sNC, pWhere) ){
342 goto update_cleanup;
345 /* Begin the database scan
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
352 if( pWInfo==0 ) goto update_cleanup;
353 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
355 /* Remember the rowid of every item to be updated.
357 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
358 if( !okOnePass ){
359 sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
362 /* End the database scan loop.
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 */
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);
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);
396 sqlite3WhereEnd(pWInfo);
399 /* Initialize the count of updated rows
401 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
402 regRowCount = ++pParse->nMem;
403 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
406 labelBreak = sqlite3VdbeMakeLabel(v);
407 if( !isView ){
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.
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;
424 if( okOnePass ){
425 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
426 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
428 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iBaseCur, aToOpen,
429 0, 0);
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);
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);
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);
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
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
479 testcase( oldmask!=0xffffffff && i==31 );
480 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i);
481 }else{
482 sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
485 if( chngRowid==0 && pPk==0 ){
486 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
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.
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.
503 newmask = sqlite3TriggerColmask(
504 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
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.
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);
529 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
530 ** verified. One could argue that this is wrong.
532 if( tmask&TRIGGER_BEFORE ){
533 sqlite3TableAffinity(v, pTab, regNew);
534 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
535 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
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.
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);
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.
556 for(i=0; i<pTab->nCol; i++){
557 if( aXRef[i]<0 && i!=pTab->iPKey ){
558 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
563 if( !isView ){
564 int j1 = 0; /* Address of jump instruction */
565 int bReplace = 0; /* True if REPLACE conflict resolution might happen */
567 /* Do constraint checks. */
568 assert( regOldRowid>0 );
569 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
570 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace);
572 /* Do FK constraint checks. */
573 if( hasFK ){
574 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
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);
584 VdbeCoverageNeverTaken(v);
586 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx);
588 /* If changing the record number, delete the old record. */
589 if( hasFK || chngKey || pPk!=0 ){
590 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
592 if( bReplace || chngKey ){
593 sqlite3VdbeJumpHere(v, j1);
596 if( hasFK ){
597 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
600 /* Insert the new index entries and the new record. */
601 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
602 regNewRowid, aRegIdx, 1, 0, 0);
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);
612 /* Increment the row counter
614 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
615 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
618 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
619 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
621 /* Repeat the above with the next record to be updated, until
622 ** all record selected by the WHERE clause have been updated.
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);
632 sqlite3VdbeResolveLabel(v, labelBreak);
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);
641 if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0);
643 /* Update the sqlite_sequence table by storing the content of the
644 ** maximum rowid counter values recorded while inserting into
645 ** autoincrement tables.
647 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
648 sqlite3AutoincrementEnd(pParse);
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.
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);
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;
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
680 #ifndef SQLITE_OMIT_VIRTUALTABLE
682 ** Generate code for an UPDATE of a virtual table.
684 ** The strategy is that we create an ephemeral table that contains
685 ** for each row to be changed:
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.
691 ** Then we loop over this ephemeral table and for each row in
692 ** the ephemeral table call VUpdate.
694 ** When finished, drop the ephemeral table.
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.
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 */
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;
722 /* Construct the SELECT statement that will find the new values for
723 ** all updated rows.
725 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
726 if( pRowid ){
727 pEList = sqlite3ExprListAppend(pParse, pEList,
728 sqlite3ExprDup(db, pRowid, 0));
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);
737 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
739 pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
741 /* Create the ephemeral table into which the update results will
742 ** be stored.
744 assert( v );
745 ephemTab = pParse->nTab++;
746 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
747 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
749 /* fill the ephemeral table
751 sqlite3SelectDestInit(&dest, SRT_Table, ephemTab);
752 sqlite3Select(pParse, pSelect, &dest);
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);
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);
771 /* Cleanup */
772 sqlite3SelectDelete(db, pSelect);
774 #endif /* SQLITE_OMIT_VIRTUALTABLE */