4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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_schema 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 column as REAL affinity and the table is an ordinary b-tree table
57 ** (not a virtual table) then the value might have been stored as an
58 ** integer. In that case, add an OP_RealAffinity opcode to make sure
59 ** it has been converted into REAL.
61 void sqlite3ColumnDefault(Vdbe
*v
, Table
*pTab
, int i
, int iReg
){
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
);
72 sqlite3VdbeAppendP4(v
, pValue
, P4_MEM
);
75 #ifndef SQLITE_OMIT_FLOATING_POINT
76 if( pTab
->aCol
[i
].affinity
==SQLITE_AFF_REAL
&& !IsVirtual(pTab
) ){
77 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, iReg
);
83 ** Check to see if column iCol of index pIdx references any of the
84 ** columns defined by aXRef and chngRowid. Return true if it does
85 ** and false if not. This is an optimization. False-positives are a
86 ** performance degradation, but false-negatives can result in a corrupt
87 ** index and incorrect answers.
89 ** aXRef[j] will be non-negative if column j of the original table is
90 ** being updated. chngRowid will be true if the rowid of the table is
93 static int indexColumnIsBeingUpdated(
94 Index
*pIdx
, /* The index to check */
95 int iCol
, /* Which column of the index to check */
96 int *aXRef
, /* aXRef[j]>=0 if column j is being updated */
97 int chngRowid
/* true if the rowid is being updated */
99 i16 iIdxCol
= pIdx
->aiColumn
[iCol
];
100 assert( iIdxCol
!=XN_ROWID
); /* Cannot index rowid */
102 return aXRef
[iIdxCol
]>=0;
104 assert( iIdxCol
==XN_EXPR
);
105 assert( pIdx
->aColExpr
!=0 );
106 assert( pIdx
->aColExpr
->a
[iCol
].pExpr
!=0 );
107 return sqlite3ExprReferencesUpdatedColumn(pIdx
->aColExpr
->a
[iCol
].pExpr
,
112 ** Check to see if index pIdx is a partial index whose conditional
113 ** expression might change values due to an UPDATE. Return true if
114 ** the index is subject to change and false if the index is guaranteed
115 ** to be unchanged. This is an optimization. False-positives are a
116 ** performance degradation, but false-negatives can result in a corrupt
117 ** index and incorrect answers.
119 ** aXRef[j] will be non-negative if column j of the original table is
120 ** being updated. chngRowid will be true if the rowid of the table is
123 static int indexWhereClauseMightChange(
124 Index
*pIdx
, /* The index to check */
125 int *aXRef
, /* aXRef[j]>=0 if column j is being updated */
126 int chngRowid
/* true if the rowid is being updated */
128 if( pIdx
->pPartIdxWhere
==0 ) return 0;
129 return sqlite3ExprReferencesUpdatedColumn(pIdx
->pPartIdxWhere
,
134 ** Allocate and return a pointer to an expression of type TK_ROW with
135 ** Expr.iColumn set to value (iCol+1). The resolver will modify the
136 ** expression to be a TK_COLUMN reading column iCol of the first
137 ** table in the source-list (pSrc->a[0]).
139 static Expr
*exprRowColumn(Parse
*pParse
, int iCol
){
140 Expr
*pRet
= sqlite3PExpr(pParse
, TK_ROW
, 0, 0);
141 if( pRet
) pRet
->iColumn
= iCol
+1;
146 ** Assuming both the pLimit and pOrderBy parameters are NULL, this function
147 ** generates VM code to run the query:
149 ** SELECT <other-columns>, pChanges FROM pTabList WHERE pWhere
151 ** and write the results to the ephemeral table already opened as cursor
152 ** iEph. None of pChanges, pTabList or pWhere are modified or consumed by
153 ** this function, they must be deleted by the caller.
155 ** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view:
157 ** SELECT <other-columns>, pChanges FROM pTabList
159 ** GROUP BY <other-columns>
160 ** ORDER BY pOrderBy LIMIT pLimit
162 ** If pTab is a view, the GROUP BY clause is omitted.
164 ** Exactly how results are written to table iEph, and exactly what
165 ** the <other-columns> in the query above are is determined by the type
166 ** of table pTabList->a[0].pTab.
168 ** If the table is a WITHOUT ROWID table, then argument pPk must be its
169 ** PRIMARY KEY. In this case <other-columns> are the primary key columns
170 ** of the table, in order. The results of the query are written to ephemeral
171 ** table iEph as index keys, using OP_IdxInsert.
173 ** If the table is actually a view, then <other-columns> are all columns of
174 ** the view. The results are written to the ephemeral table iEph as records
175 ** with automatically assigned integer keys.
177 ** If the table is a virtual or ordinary intkey table, then <other-columns>
178 ** is its rowid. For a virtual table, the results are written to iEph as
179 ** records with automatically assigned integer keys For intkey tables, the
180 ** rowid value in <other-columns> is used as the integer key, and the
181 ** remaining fields make up the table record.
183 static void updateFromSelect(
184 Parse
*pParse
, /* Parse context */
185 int iEph
, /* Cursor for open eph. table */
186 Index
*pPk
, /* PK if table 0 is WITHOUT ROWID */
187 ExprList
*pChanges
, /* List of expressions to return */
188 SrcList
*pTabList
, /* List of tables to select from */
189 Expr
*pWhere
, /* WHERE clause for query */
190 ExprList
*pOrderBy
, /* ORDER BY clause */
191 Expr
*pLimit
/* LIMIT clause */
199 ExprList
*pOrderBy2
= 0;
200 sqlite3
*db
= pParse
->db
;
201 Table
*pTab
= pTabList
->a
[0].pTab
;
206 #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
207 if( pOrderBy
&& pLimit
==0 ) {
208 sqlite3ErrorMsg(pParse
, "ORDER BY without LIMIT on UPDATE");
211 pOrderBy2
= sqlite3ExprListDup(db
, pOrderBy
, 0);
212 pLimit2
= sqlite3ExprDup(db
, pLimit
, 0);
214 UNUSED_PARAMETER(pOrderBy
);
215 UNUSED_PARAMETER(pLimit
);
218 pSrc
= sqlite3SrcListDup(db
, pTabList
, 0);
219 pWhere2
= sqlite3ExprDup(db
, pWhere
, 0);
221 assert( pTabList
->nSrc
>1 );
223 pSrc
->a
[0].iCursor
= -1;
224 pSrc
->a
[0].pTab
->nTabRef
--;
228 for(i
=0; i
<pPk
->nKeyCol
; i
++){
229 Expr
*pNew
= exprRowColumn(pParse
, pPk
->aiColumn
[i
]);
230 #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
232 pGrp
= sqlite3ExprListAppend(pParse
, pGrp
, sqlite3ExprDup(db
, pNew
, 0));
235 pList
= sqlite3ExprListAppend(pParse
, pList
, pNew
);
238 }else if( pTab
->pSelect
){
239 for(i
=0; i
<pTab
->nCol
; i
++){
240 pList
= sqlite3ExprListAppend(pParse
, pList
, exprRowColumn(pParse
, i
));
244 eDest
= IsVirtual(pTab
) ? SRT_Table
: SRT_Upfrom
;
245 pList
= sqlite3ExprListAppend(pParse
, 0, sqlite3PExpr(pParse
,TK_ROW
,0,0));
246 #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
248 pGrp
= sqlite3ExprListAppend(pParse
, 0, sqlite3PExpr(pParse
,TK_ROW
,0,0));
252 if( ALWAYS(pChanges
) ){
253 for(i
=0; i
<pChanges
->nExpr
; i
++){
254 pList
= sqlite3ExprListAppend(pParse
, pList
,
255 sqlite3ExprDup(db
, pChanges
->a
[i
].pExpr
, 0)
259 pSelect
= sqlite3SelectNew(pParse
, pList
,
260 pSrc
, pWhere2
, pGrp
, 0, pOrderBy2
, SF_UpdateFrom
|SF_IncludeHidden
, pLimit2
262 sqlite3SelectDestInit(&dest
, eDest
, iEph
);
263 dest
.iSDParm2
= (pPk
? pPk
->nKeyCol
: -1);
264 sqlite3Select(pParse
, pSelect
, &dest
);
265 sqlite3SelectDelete(db
, pSelect
);
269 ** Process an UPDATE statement.
271 ** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL;
272 ** \_______/ \_/ \______/ \_____/ \________________/
273 ** onError | pChanges | pWhere
274 ** \_______________________/
278 Parse
*pParse
, /* The parser context */
279 SrcList
*pTabList
, /* The table in which we should change things */
280 ExprList
*pChanges
, /* Things to be changed */
281 Expr
*pWhere
, /* The WHERE clause. May be null */
282 int onError
, /* How to handle constraint errors */
283 ExprList
*pOrderBy
, /* ORDER BY clause. May be null */
284 Expr
*pLimit
, /* LIMIT clause. May be null */
285 Upsert
*pUpsert
/* ON CONFLICT clause, or null */
287 int i
, j
, k
; /* Loop counters */
288 Table
*pTab
; /* The table to be updated */
289 int addrTop
= 0; /* VDBE instruction address of the start of the loop */
290 WhereInfo
*pWInfo
= 0; /* Information about the WHERE clause */
291 Vdbe
*v
; /* The virtual database engine */
292 Index
*pIdx
; /* For looping over indices */
293 Index
*pPk
; /* The PRIMARY KEY index for WITHOUT ROWID tables */
294 int nIdx
; /* Number of indices that need updating */
295 int nAllIdx
; /* Total number of indexes */
296 int iBaseCur
; /* Base cursor number */
297 int iDataCur
; /* Cursor for the canonical data btree */
298 int iIdxCur
; /* Cursor for the first index */
299 sqlite3
*db
; /* The database structure */
300 int *aRegIdx
= 0; /* Registers for to each index and the main table */
301 int *aXRef
= 0; /* aXRef[i] is the index in pChanges->a[] of the
302 ** an expression for the i-th column of the table.
303 ** aXRef[i]==-1 if the i-th column is not changed. */
304 u8
*aToOpen
; /* 1 for tables and indices to be opened */
305 u8 chngPk
; /* PRIMARY KEY changed in a WITHOUT ROWID table */
306 u8 chngRowid
; /* Rowid changed in a normal table */
307 u8 chngKey
; /* Either chngPk or chngRowid */
308 Expr
*pRowidExpr
= 0; /* Expression defining the new record number */
309 int iRowidExpr
= -1; /* Index of "rowid=" (or IPK) assignment in pChanges */
310 AuthContext sContext
; /* The authorization context */
311 NameContext sNC
; /* The name-context to resolve expressions in */
312 int iDb
; /* Database containing the table being updated */
313 int eOnePass
; /* ONEPASS_XXX value from where.c */
314 int hasFK
; /* True if foreign key processing is required */
315 int labelBreak
; /* Jump here to break out of UPDATE loop */
316 int labelContinue
; /* Jump here to continue next step of UPDATE loop */
317 int flags
; /* Flags for sqlite3WhereBegin() */
319 #ifndef SQLITE_OMIT_TRIGGER
320 int isView
; /* True when updating a view (INSTEAD OF trigger) */
321 Trigger
*pTrigger
; /* List of triggers on pTab, if required */
322 int tmask
; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
324 int newmask
; /* Mask of NEW.* columns accessed by BEFORE triggers */
325 int iEph
= 0; /* Ephemeral table holding all primary key values */
326 int nKey
= 0; /* Number of elements in regKey for WITHOUT ROWID */
327 int aiCurOnePass
[2]; /* The write cursors opened by WHERE_ONEPASS */
328 int addrOpen
= 0; /* Address of OP_OpenEphemeral */
329 int iPk
= 0; /* First of nPk cells holding PRIMARY KEY value */
330 i16 nPk
= 0; /* Number of components of the PRIMARY KEY */
331 int bReplace
= 0; /* True if REPLACE conflict resolution might happen */
332 int bFinishSeek
= 1; /* The OP_FinishSeek opcode is needed */
333 int nChangeFrom
= 0; /* If there is a FROM, pChanges->nExpr, else 0 */
335 /* Register Allocations */
336 int regRowCount
= 0; /* A count of rows changed */
337 int regOldRowid
= 0; /* The old rowid */
338 int regNewRowid
= 0; /* The new rowid */
339 int regNew
= 0; /* Content of the NEW.* table in triggers */
340 int regOld
= 0; /* Content of OLD.* table in triggers */
341 int regRowSet
= 0; /* Rowset of rows to be updated */
342 int regKey
= 0; /* composite PRIMARY KEY value */
344 memset(&sContext
, 0, sizeof(sContext
));
346 if( pParse
->nErr
|| db
->mallocFailed
){
350 /* Locate the table which we want to update.
352 pTab
= sqlite3SrcListLookup(pParse
, pTabList
);
353 if( pTab
==0 ) goto update_cleanup
;
354 iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
356 /* Figure out if we have any triggers and if the table being
357 ** updated is a view.
359 #ifndef SQLITE_OMIT_TRIGGER
360 pTrigger
= sqlite3TriggersExist(pParse
, pTab
, TK_UPDATE
, pChanges
, &tmask
);
361 isView
= pTab
->pSelect
!=0;
362 assert( pTrigger
|| tmask
==0 );
368 #ifdef SQLITE_OMIT_VIEW
373 /* If there was a FROM clause, set nChangeFrom to the number of expressions
374 ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
375 ** clause if this function is being called to generate code for part of
376 ** an UPSERT statement. */
377 nChangeFrom
= (pTabList
->nSrc
>1) ? pChanges
->nExpr
: 0;
378 assert( nChangeFrom
==0 || pUpsert
==0 );
380 #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
381 if( !isView
&& nChangeFrom
==0 ){
382 pWhere
= sqlite3LimitWhere(
383 pParse
, pTabList
, pWhere
, pOrderBy
, pLimit
, "UPDATE"
390 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ){
393 if( sqlite3IsReadOnly(pParse
, pTab
, tmask
) ){
397 /* Allocate a cursors for the main database table and for all indices.
398 ** The index cursors might not be used, but if they are used they
399 ** need to occur right after the database cursor. So go ahead and
400 ** allocate enough space, just in case.
402 iBaseCur
= iDataCur
= pParse
->nTab
++;
403 iIdxCur
= iDataCur
+1;
404 pPk
= HasRowid(pTab
) ? 0 : sqlite3PrimaryKeyIndex(pTab
);
405 testcase( pPk
!=0 && pPk
!=pTab
->pIndex
);
406 for(nIdx
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, nIdx
++){
408 iDataCur
= pParse
->nTab
;
413 /* On an UPSERT, reuse the same cursors already opened by INSERT */
414 iDataCur
= pUpsert
->iDataCur
;
415 iIdxCur
= pUpsert
->iIdxCur
;
416 pParse
->nTab
= iBaseCur
;
418 pTabList
->a
[0].iCursor
= iDataCur
;
420 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
421 ** Initialize aXRef[] and aToOpen[] to their default values.
423 aXRef
= sqlite3DbMallocRawNN(db
, sizeof(int) * (pTab
->nCol
+nIdx
+1) + nIdx
+2 );
424 if( aXRef
==0 ) goto update_cleanup
;
425 aRegIdx
= aXRef
+pTab
->nCol
;
426 aToOpen
= (u8
*)(aRegIdx
+nIdx
+1);
427 memset(aToOpen
, 1, nIdx
+1);
429 for(i
=0; i
<pTab
->nCol
; i
++) aXRef
[i
] = -1;
431 /* Initialize the name-context */
432 memset(&sNC
, 0, sizeof(sNC
));
434 sNC
.pSrcList
= pTabList
;
435 sNC
.uNC
.pUpsert
= pUpsert
;
436 sNC
.ncFlags
= NC_UUpsert
;
438 /* Begin generating code. */
439 v
= sqlite3GetVdbe(pParse
);
440 if( v
==0 ) goto update_cleanup
;
442 /* Resolve the column names in all the expressions of the
443 ** of the UPDATE statement. Also find the column index
444 ** for each column to be updated in the pChanges array. For each
445 ** column to be updated, make sure we have authorization to change
448 chngRowid
= chngPk
= 0;
449 for(i
=0; i
<pChanges
->nExpr
; i
++){
450 /* If this is an UPDATE with a FROM clause, do not resolve expressions
451 ** here. The call to sqlite3Select() below will do that. */
452 if( nChangeFrom
==0 && sqlite3ResolveExprNames(&sNC
, pChanges
->a
[i
].pExpr
) ){
455 for(j
=0; j
<pTab
->nCol
; j
++){
456 if( sqlite3StrICmp(pTab
->aCol
[j
].zName
, pChanges
->a
[i
].zEName
)==0 ){
457 if( j
==pTab
->iPKey
){
459 pRowidExpr
= pChanges
->a
[i
].pExpr
;
461 }else if( pPk
&& (pTab
->aCol
[j
].colFlags
& COLFLAG_PRIMKEY
)!=0 ){
464 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
465 else if( pTab
->aCol
[j
].colFlags
& COLFLAG_GENERATED
){
466 testcase( pTab
->aCol
[j
].colFlags
& COLFLAG_VIRTUAL
);
467 testcase( pTab
->aCol
[j
].colFlags
& COLFLAG_STORED
);
468 sqlite3ErrorMsg(pParse
,
469 "cannot UPDATE generated column \"%s\"",
470 pTab
->aCol
[j
].zName
);
479 if( pPk
==0 && sqlite3IsRowid(pChanges
->a
[i
].zEName
) ){
482 pRowidExpr
= pChanges
->a
[i
].pExpr
;
485 sqlite3ErrorMsg(pParse
, "no such column: %s", pChanges
->a
[i
].zEName
);
486 pParse
->checkSchema
= 1;
490 #ifndef SQLITE_OMIT_AUTHORIZATION
493 rc
= sqlite3AuthCheck(pParse
, SQLITE_UPDATE
, pTab
->zName
,
494 j
<0 ? "ROWID" : pTab
->aCol
[j
].zName
,
495 db
->aDb
[iDb
].zDbSName
);
496 if( rc
==SQLITE_DENY
){
498 }else if( rc
==SQLITE_IGNORE
){
504 assert( (chngRowid
& chngPk
)==0 );
505 assert( chngRowid
==0 || chngRowid
==1 );
506 assert( chngPk
==0 || chngPk
==1 );
507 chngKey
= chngRowid
+ chngPk
;
509 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
510 /* Mark generated columns as changing if their generator expressions
511 ** reference any changing column. The actual aXRef[] value for
512 ** generated expressions is not used, other than to check to see that it
513 ** is non-negative, so the value of aXRef[] for generated columns can be
514 ** set to any non-negative number. We use 99999 so that the value is
515 ** obvious when looking at aXRef[] in a symbolic debugger.
517 if( pTab
->tabFlags
& TF_HasGenerated
){
519 testcase( pTab
->tabFlags
& TF_HasVirtual
);
520 testcase( pTab
->tabFlags
& TF_HasStored
);
523 for(i
=0; i
<pTab
->nCol
; i
++){
524 if( aXRef
[i
]>=0 ) continue;
525 if( (pTab
->aCol
[i
].colFlags
& COLFLAG_GENERATED
)==0 ) continue;
526 if( sqlite3ExprReferencesUpdatedColumn(pTab
->aCol
[i
].pDflt
,
536 /* The SET expressions are not actually used inside the WHERE loop.
537 ** So reset the colUsed mask. Unless this is a virtual table. In that
538 ** case, set all bits of the colUsed mask (to ensure that the virtual
539 ** table implementation makes all columns available).
541 pTabList
->a
[0].colUsed
= IsVirtual(pTab
) ? ALLBITS
: 0;
543 hasFK
= sqlite3FkRequired(pParse
, pTab
, aXRef
, chngKey
);
545 /* There is one entry in the aRegIdx[] array for each index on the table
546 ** being updated. Fill in aRegIdx[] with a register number that will hold
547 ** the key for accessing each index.
549 if( onError
==OE_Replace
) bReplace
= 1;
550 for(nAllIdx
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, nAllIdx
++){
552 if( chngKey
|| hasFK
>1 || pIdx
==pPk
553 || indexWhereClauseMightChange(pIdx
,aXRef
,chngRowid
)
555 reg
= ++pParse
->nMem
;
556 pParse
->nMem
+= pIdx
->nColumn
;
559 for(i
=0; i
<pIdx
->nKeyCol
; i
++){
560 if( indexColumnIsBeingUpdated(pIdx
, i
, aXRef
, chngRowid
) ){
561 reg
= ++pParse
->nMem
;
562 pParse
->nMem
+= pIdx
->nColumn
;
563 if( onError
==OE_Default
&& pIdx
->onError
==OE_Replace
){
570 if( reg
==0 ) aToOpen
[nAllIdx
+1] = 0;
571 aRegIdx
[nAllIdx
] = reg
;
573 aRegIdx
[nAllIdx
] = ++pParse
->nMem
; /* Register storing the table record */
575 /* If REPLACE conflict resolution might be invoked, open cursors on all
576 ** indexes in case they are needed to delete records. */
577 memset(aToOpen
, 1, nIdx
+1);
580 if( pParse
->nested
==0 ) sqlite3VdbeCountChanges(v
);
581 sqlite3BeginWriteOperation(pParse
, pTrigger
|| hasFK
, iDb
);
583 /* Allocate required registers. */
584 if( !IsVirtual(pTab
) ){
585 /* For now, regRowSet and aRegIdx[nAllIdx] share the same register.
586 ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
587 ** reallocated. aRegIdx[nAllIdx] is the register in which the main
588 ** table record is written. regRowSet holds the RowSet for the
589 ** two-pass update algorithm. */
590 assert( aRegIdx
[nAllIdx
]==pParse
->nMem
);
591 regRowSet
= aRegIdx
[nAllIdx
];
592 regOldRowid
= regNewRowid
= ++pParse
->nMem
;
593 if( chngPk
|| pTrigger
|| hasFK
){
594 regOld
= pParse
->nMem
+ 1;
595 pParse
->nMem
+= pTab
->nCol
;
597 if( chngKey
|| pTrigger
|| hasFK
){
598 regNewRowid
= ++pParse
->nMem
;
600 regNew
= pParse
->nMem
+ 1;
601 pParse
->nMem
+= pTab
->nCol
;
604 /* Start the view context. */
606 sqlite3AuthContextPush(pParse
, &sContext
, pTab
->zName
);
609 /* If we are trying to update a view, realize that view into
610 ** an ephemeral table.
612 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
613 if( nChangeFrom
==0 && isView
){
614 sqlite3MaterializeView(pParse
, pTab
,
615 pWhere
, pOrderBy
, pLimit
, iDataCur
622 /* Resolve the column names in all the expressions in the
625 if( nChangeFrom
==0 && sqlite3ResolveExprNames(&sNC
, pWhere
) ){
629 #ifndef SQLITE_OMIT_VIRTUALTABLE
630 /* Virtual tables must be handled separately */
631 if( IsVirtual(pTab
) ){
632 updateVirtualTable(pParse
, pTabList
, pTab
, pChanges
, pRowidExpr
, aXRef
,
638 /* Jump to labelBreak to abandon further processing of this UPDATE */
639 labelContinue
= labelBreak
= sqlite3VdbeMakeLabel(pParse
);
641 /* Not an UPSERT. Normal processing. Begin by
642 ** initialize the count of updated rows */
643 if( (db
->flags
&SQLITE_CountRows
)!=0
644 && !pParse
->pTriggerTab
648 regRowCount
= ++pParse
->nMem
;
649 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regRowCount
);
652 if( nChangeFrom
==0 && HasRowid(pTab
) ){
653 sqlite3VdbeAddOp3(v
, OP_Null
, 0, regRowSet
, regOldRowid
);
655 assert( pPk
!=0 || HasRowid(pTab
) );
656 nPk
= pPk
? pPk
->nKeyCol
: 0;
657 iPk
= pParse
->nMem
+1;
659 pParse
->nMem
+= nChangeFrom
;
660 regKey
= ++pParse
->nMem
;
662 int nEphCol
= nPk
+ nChangeFrom
+ (isView
? pTab
->nCol
: 0);
663 iEph
= pParse
->nTab
++;
664 if( pPk
) sqlite3VdbeAddOp3(v
, OP_Null
, 0, iPk
, iPk
+nPk
-1);
665 addrOpen
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iEph
, nEphCol
);
667 KeyInfo
*pKeyInfo
= sqlite3KeyInfoOfIndex(pParse
, pPk
);
669 pKeyInfo
->nAllField
= nEphCol
;
670 sqlite3VdbeAppendP4(v
, pKeyInfo
, P4_KEYINFO
);
675 pParse
, iEph
, pPk
, pChanges
, pTabList
, pWhere
, pOrderBy
, pLimit
677 #ifndef SQLITE_OMIT_SUBQUERY
678 if( isView
) iDataCur
= iEph
;
685 sqlite3MultiWrite(pParse
);
686 eOnePass
= ONEPASS_OFF
;
691 /* If this is an UPSERT, then all cursors have already been opened by
692 ** the outer INSERT and the data cursor should be pointing at the row
693 ** that is to be updated. So bypass the code that searches for the
694 ** row(s) to be updated.
697 eOnePass
= ONEPASS_SINGLE
;
698 sqlite3ExprIfFalse(pParse
, pWhere
, labelBreak
, SQLITE_JUMPIFNULL
);
701 /* Begin the database scan.
703 ** Do not consider a single-pass strategy for a multi-row update if
704 ** there are any triggers or foreign keys to process, or rows may
705 ** be deleted as a result of REPLACE conflict handling. Any of these
706 ** things might disturb a cursor being used to scan through the table
707 ** or index, causing a single-pass approach to malfunction. */
708 flags
= WHERE_ONEPASS_DESIRED
|WHERE_SEEK_UNIQ_TABLE
;
709 if( !pParse
->nested
&& !pTrigger
&& !hasFK
&& !chngKey
&& !bReplace
){
710 flags
|= WHERE_ONEPASS_MULTIROW
;
712 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, 0, 0, flags
,iIdxCur
);
713 if( pWInfo
==0 ) goto update_cleanup
;
715 /* A one-pass strategy that might update more than one row may not
716 ** be used if any column of the index used for the scan is being
717 ** updated. Otherwise, if there is an index on "b", statements like
718 ** the following could create an infinite loop:
720 ** UPDATE t1 SET b=b+1 WHERE b>?
722 ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
723 ** strategy that uses an index for which one or more columns are being
725 eOnePass
= sqlite3WhereOkOnePass(pWInfo
, aiCurOnePass
);
726 bFinishSeek
= sqlite3WhereUsesDeferredSeek(pWInfo
);
727 if( eOnePass
!=ONEPASS_SINGLE
){
728 sqlite3MultiWrite(pParse
);
729 if( eOnePass
==ONEPASS_MULTI
){
730 int iCur
= aiCurOnePass
[1];
731 if( iCur
>=0 && iCur
!=iDataCur
&& aToOpen
[iCur
-iBaseCur
] ){
732 eOnePass
= ONEPASS_OFF
;
734 assert( iCur
!=iDataCur
|| !HasRowid(pTab
) );
739 if( HasRowid(pTab
) ){
740 /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
741 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
742 ** leave it in register regOldRowid. */
743 sqlite3VdbeAddOp2(v
, OP_Rowid
, iDataCur
, regOldRowid
);
744 if( eOnePass
==ONEPASS_OFF
){
745 /* We need to use regRowSet, so reallocate aRegIdx[nAllIdx] */
746 aRegIdx
[nAllIdx
] = ++pParse
->nMem
;
747 sqlite3VdbeAddOp2(v
, OP_RowSetAdd
, regRowSet
, regOldRowid
);
750 /* Read the PK of the current row into an array of registers. In
751 ** ONEPASS_OFF mode, serialize the array into a record and store it in
752 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
753 ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table
754 ** is not required) and leave the PK fields in the array of registers. */
755 for(i
=0; i
<nPk
; i
++){
756 assert( pPk
->aiColumn
[i
]>=0 );
757 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
,
758 pPk
->aiColumn
[i
], iPk
+i
);
761 if( addrOpen
) sqlite3VdbeChangeToNoop(v
, addrOpen
);
765 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, iPk
, nPk
, regKey
,
766 sqlite3IndexAffinityStr(db
, pPk
), nPk
);
767 sqlite3VdbeAddOp4Int(v
, OP_IdxInsert
, iEph
, regKey
, iPk
, nPk
);
773 if( nChangeFrom
==0 && eOnePass
!=ONEPASS_MULTI
){
774 sqlite3WhereEnd(pWInfo
);
780 /* Open every index that needs updating. */
781 if( eOnePass
!=ONEPASS_OFF
){
782 if( aiCurOnePass
[0]>=0 ) aToOpen
[aiCurOnePass
[0]-iBaseCur
] = 0;
783 if( aiCurOnePass
[1]>=0 ) aToOpen
[aiCurOnePass
[1]-iBaseCur
] = 0;
786 if( eOnePass
==ONEPASS_MULTI
&& (nIdx
-(aiCurOnePass
[1]>=0))>0 ){
787 addrOnce
= sqlite3VdbeAddOp0(v
, OP_Once
); VdbeCoverage(v
);
789 sqlite3OpenTableAndIndices(pParse
, pTab
, OP_OpenWrite
, 0, iBaseCur
,
792 sqlite3VdbeJumpHereOrPopInst(v
, addrOnce
);
796 /* Top of the update loop */
797 if( eOnePass
!=ONEPASS_OFF
){
798 if( !isView
&& aiCurOnePass
[0]!=iDataCur
&& aiCurOnePass
[1]!=iDataCur
){
800 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, labelBreak
, regKey
,nKey
);
803 if( eOnePass
!=ONEPASS_SINGLE
){
804 labelContinue
= sqlite3VdbeMakeLabel(pParse
);
806 sqlite3VdbeAddOp2(v
, OP_IsNull
, pPk
? regKey
: regOldRowid
, labelBreak
);
807 VdbeCoverageIf(v
, pPk
==0);
808 VdbeCoverageIf(v
, pPk
!=0);
809 }else if( pPk
|| nChangeFrom
){
810 labelContinue
= sqlite3VdbeMakeLabel(pParse
);
811 sqlite3VdbeAddOp2(v
, OP_Rewind
, iEph
, labelBreak
); VdbeCoverage(v
);
812 addrTop
= sqlite3VdbeCurrentAddr(v
);
816 for(i
=0; i
<nPk
; i
++){
817 sqlite3VdbeAddOp3(v
, OP_Column
, iEph
, i
, iPk
+i
);
819 sqlite3VdbeAddOp4Int(
820 v
, OP_NotFound
, iDataCur
, labelContinue
, iPk
, nPk
823 sqlite3VdbeAddOp2(v
, OP_Rowid
, iEph
, regOldRowid
);
825 v
, OP_NotExists
, iDataCur
, labelContinue
, regOldRowid
830 sqlite3VdbeAddOp2(v
, OP_RowData
, iEph
, regKey
);
831 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, labelContinue
, regKey
,0);
835 labelContinue
= sqlite3VdbeAddOp3(v
, OP_RowSetRead
, regRowSet
,labelBreak
,
838 sqlite3VdbeAddOp3(v
, OP_NotExists
, iDataCur
, labelContinue
, regOldRowid
);
843 /* If the rowid value will change, set register regNewRowid to
844 ** contain the new value. If the rowid is not being modified,
845 ** then regNewRowid is the same register as regOldRowid, which is
846 ** already populated. */
847 assert( chngKey
|| pTrigger
|| hasFK
|| regOldRowid
==regNewRowid
);
849 assert( iRowidExpr
>=0 );
850 if( nChangeFrom
==0 ){
851 sqlite3ExprCode(pParse
, pRowidExpr
, regNewRowid
);
853 sqlite3VdbeAddOp3(v
, OP_Column
, iEph
, iRowidExpr
, regNewRowid
);
855 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, regNewRowid
); VdbeCoverage(v
);
858 /* Compute the old pre-UPDATE content of the row being changed, if that
859 ** information is needed */
860 if( chngPk
|| hasFK
|| pTrigger
){
861 u32 oldmask
= (hasFK
? sqlite3FkOldmask(pParse
, pTab
) : 0);
862 oldmask
|= sqlite3TriggerColmask(pParse
,
863 pTrigger
, pChanges
, 0, TRIGGER_BEFORE
|TRIGGER_AFTER
, pTab
, onError
865 for(i
=0; i
<pTab
->nCol
; i
++){
866 u32 colFlags
= pTab
->aCol
[i
].colFlags
;
867 k
= sqlite3TableColumnToStorage(pTab
, i
) + regOld
;
868 if( oldmask
==0xffffffff
869 || (i
<32 && (oldmask
& MASKBIT32(i
))!=0)
870 || (colFlags
& COLFLAG_PRIMKEY
)!=0
872 testcase( oldmask
!=0xffffffff && i
==31 );
873 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, i
, k
);
875 sqlite3VdbeAddOp2(v
, OP_Null
, 0, k
);
878 if( chngRowid
==0 && pPk
==0 ){
879 sqlite3VdbeAddOp2(v
, OP_Copy
, regOldRowid
, regNewRowid
);
883 /* Populate the array of registers beginning at regNew with the new
884 ** row data. This array is used to check constants, create the new
885 ** table and index records, and as the values for any new.* references
888 ** If there are one or more BEFORE triggers, then do not populate the
889 ** registers associated with columns that are (a) not modified by
890 ** this UPDATE statement and (b) not accessed by new.* references. The
891 ** values for registers not modified by the UPDATE must be reloaded from
892 ** the database after the BEFORE triggers are fired anyway (as the trigger
893 ** may have modified them). So not loading those that are not going to
894 ** be used eliminates some redundant opcodes.
896 newmask
= sqlite3TriggerColmask(
897 pParse
, pTrigger
, pChanges
, 1, TRIGGER_BEFORE
, pTab
, onError
899 for(i
=0, k
=regNew
; i
<pTab
->nCol
; i
++, k
++){
900 if( i
==pTab
->iPKey
){
901 sqlite3VdbeAddOp2(v
, OP_Null
, 0, k
);
902 }else if( (pTab
->aCol
[i
].colFlags
& COLFLAG_GENERATED
)!=0 ){
903 if( pTab
->aCol
[i
].colFlags
& COLFLAG_VIRTUAL
) k
--;
908 int nOff
= (isView
? pTab
->nCol
: nPk
);
909 assert( eOnePass
==ONEPASS_OFF
);
910 sqlite3VdbeAddOp3(v
, OP_Column
, iEph
, nOff
+j
, k
);
912 sqlite3ExprCode(pParse
, pChanges
->a
[j
].pExpr
, k
);
914 }else if( 0==(tmask
&TRIGGER_BEFORE
) || i
>31 || (newmask
& MASKBIT32(i
)) ){
915 /* This branch loads the value of a column that will not be changed
916 ** into a register. This is done if there are no BEFORE triggers, or
917 ** if there are one or more BEFORE triggers that use this value via
918 ** a new.* reference in a trigger program.
922 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, i
, k
);
925 sqlite3VdbeAddOp2(v
, OP_Null
, 0, k
);
929 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
930 if( pTab
->tabFlags
& TF_HasGenerated
){
931 testcase( pTab
->tabFlags
& TF_HasVirtual
);
932 testcase( pTab
->tabFlags
& TF_HasStored
);
933 sqlite3ComputeGeneratedColumns(pParse
, regNew
, pTab
);
937 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
938 ** verified. One could argue that this is wrong.
940 if( tmask
&TRIGGER_BEFORE
){
941 sqlite3TableAffinity(v
, pTab
, regNew
);
942 sqlite3CodeRowTrigger(pParse
, pTrigger
, TK_UPDATE
, pChanges
,
943 TRIGGER_BEFORE
, pTab
, regOldRowid
, onError
, labelContinue
);
946 /* The row-trigger may have deleted the row being updated. In this
947 ** case, jump to the next row. No updates or AFTER triggers are
948 ** required. This behavior - what happens when the row being updated
949 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
953 sqlite3VdbeAddOp4Int(v
, OP_NotFound
,iDataCur
,labelContinue
,regKey
,nKey
);
956 sqlite3VdbeAddOp3(v
, OP_NotExists
, iDataCur
, labelContinue
,regOldRowid
);
960 /* After-BEFORE-trigger-reload-loop:
961 ** If it did not delete it, the BEFORE trigger may still have modified
962 ** some of the columns of the row being updated. Load the values for
963 ** all columns not modified by the update statement into their registers
964 ** in case this has happened. Only unmodified columns are reloaded.
965 ** The values computed for modified columns use the values before the
966 ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26)
969 for(i
=0, k
=regNew
; i
<pTab
->nCol
; i
++, k
++){
970 if( pTab
->aCol
[i
].colFlags
& COLFLAG_GENERATED
){
971 if( pTab
->aCol
[i
].colFlags
& COLFLAG_VIRTUAL
) k
--;
972 }else if( aXRef
[i
]<0 && i
!=pTab
->iPKey
){
973 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, i
, k
);
976 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
977 if( pTab
->tabFlags
& TF_HasGenerated
){
978 testcase( pTab
->tabFlags
& TF_HasVirtual
);
979 testcase( pTab
->tabFlags
& TF_HasStored
);
980 sqlite3ComputeGeneratedColumns(pParse
, regNew
, pTab
);
987 /* Do constraint checks. */
988 assert( regOldRowid
>0 );
989 sqlite3GenerateConstraintChecks(pParse
, pTab
, aRegIdx
, iDataCur
, iIdxCur
,
990 regNewRowid
, regOldRowid
, chngKey
, onError
, labelContinue
, &bReplace
,
993 /* If REPLACE conflict handling may have been used, or if the PK of the
994 ** row is changing, then the GenerateConstraintChecks() above may have
995 ** moved cursor iDataCur. Reseek it. */
996 if( bReplace
|| chngKey
){
998 sqlite3VdbeAddOp4Int(v
, OP_NotFound
,iDataCur
,labelContinue
,regKey
,nKey
);
1000 sqlite3VdbeAddOp3(v
, OP_NotExists
, iDataCur
, labelContinue
,regOldRowid
);
1002 VdbeCoverageNeverTaken(v
);
1005 /* Do FK constraint checks. */
1007 sqlite3FkCheck(pParse
, pTab
, regOldRowid
, 0, aXRef
, chngKey
);
1010 /* Delete the index entries associated with the current record. */
1011 sqlite3GenerateRowIndexDelete(pParse
, pTab
, iDataCur
, iIdxCur
, aRegIdx
, -1);
1013 /* We must run the OP_FinishSeek opcode to resolve a prior
1014 ** OP_DeferredSeek if there is any possibility that there have been
1015 ** no OP_Column opcodes since the OP_DeferredSeek was issued. But
1016 ** we want to avoid the OP_FinishSeek if possible, as running it
1017 ** costs CPU cycles. */
1019 sqlite3VdbeAddOp1(v
, OP_FinishSeek
, iDataCur
);
1022 /* If changing the rowid value, or if there are foreign key constraints
1023 ** to process, delete the old record. Otherwise, add a noop OP_Delete
1024 ** to invoke the pre-update hook.
1026 ** That (regNew==regnewRowid+1) is true is also important for the
1027 ** pre-update hook. If the caller invokes preupdate_new(), the returned
1028 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
1029 ** is the column index supplied by the user.
1031 assert( regNew
==regNewRowid
+1 );
1032 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1033 sqlite3VdbeAddOp3(v
, OP_Delete
, iDataCur
,
1034 OPFLAG_ISUPDATE
| ((hasFK
>1 || chngKey
) ? 0 : OPFLAG_ISNOOP
),
1037 if( eOnePass
==ONEPASS_MULTI
){
1038 assert( hasFK
==0 && chngKey
==0 );
1039 sqlite3VdbeChangeP5(v
, OPFLAG_SAVEPOSITION
);
1041 if( !pParse
->nested
){
1042 sqlite3VdbeAppendP4(v
, pTab
, P4_TABLE
);
1045 if( hasFK
>1 || chngKey
){
1046 sqlite3VdbeAddOp2(v
, OP_Delete
, iDataCur
, 0);
1051 sqlite3FkCheck(pParse
, pTab
, 0, regNewRowid
, aXRef
, chngKey
);
1054 /* Insert the new index entries and the new record. */
1055 sqlite3CompleteInsertion(
1056 pParse
, pTab
, iDataCur
, iIdxCur
, regNewRowid
, aRegIdx
,
1057 OPFLAG_ISUPDATE
| (eOnePass
==ONEPASS_MULTI
? OPFLAG_SAVEPOSITION
: 0),
1061 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
1062 ** handle rows (possibly in other tables) that refer via a foreign key
1063 ** to the row just updated. */
1065 sqlite3FkActions(pParse
, pTab
, pChanges
, regOldRowid
, aXRef
, chngKey
);
1069 /* Increment the row counter
1072 sqlite3VdbeAddOp2(v
, OP_AddImm
, regRowCount
, 1);
1075 sqlite3CodeRowTrigger(pParse
, pTrigger
, TK_UPDATE
, pChanges
,
1076 TRIGGER_AFTER
, pTab
, regOldRowid
, onError
, labelContinue
);
1078 /* Repeat the above with the next record to be updated, until
1079 ** all record selected by the WHERE clause have been updated.
1081 if( eOnePass
==ONEPASS_SINGLE
){
1082 /* Nothing to do at end-of-loop for a single-pass */
1083 }else if( eOnePass
==ONEPASS_MULTI
){
1084 sqlite3VdbeResolveLabel(v
, labelContinue
);
1085 sqlite3WhereEnd(pWInfo
);
1086 }else if( pPk
|| nChangeFrom
){
1087 sqlite3VdbeResolveLabel(v
, labelContinue
);
1088 sqlite3VdbeAddOp2(v
, OP_Next
, iEph
, addrTop
); VdbeCoverage(v
);
1090 sqlite3VdbeGoto(v
, labelContinue
);
1092 sqlite3VdbeResolveLabel(v
, labelBreak
);
1094 /* Update the sqlite_sequence table by storing the content of the
1095 ** maximum rowid counter values recorded while inserting into
1096 ** autoincrement tables.
1098 if( pParse
->nested
==0 && pParse
->pTriggerTab
==0 && pUpsert
==0 ){
1099 sqlite3AutoincrementEnd(pParse
);
1103 ** Return the number of rows that were changed, if we are tracking
1104 ** that information.
1107 sqlite3VdbeAddOp2(v
, OP_ResultRow
, regRowCount
, 1);
1108 sqlite3VdbeSetNumCols(v
, 1);
1109 sqlite3VdbeSetColName(v
, 0, COLNAME_NAME
, "rows updated", SQLITE_STATIC
);
1113 sqlite3AuthContextPop(&sContext
);
1114 sqlite3DbFree(db
, aXRef
); /* Also frees aRegIdx[] and aToOpen[] */
1115 sqlite3SrcListDelete(db
, pTabList
);
1116 sqlite3ExprListDelete(db
, pChanges
);
1117 sqlite3ExprDelete(db
, pWhere
);
1118 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
1119 sqlite3ExprListDelete(db
, pOrderBy
);
1120 sqlite3ExprDelete(db
, pLimit
);
1124 /* Make sure "isView" and other macros defined above are undefined. Otherwise
1125 ** they may interfere with compilation of other functions in this file
1126 ** (or in another file, if this file becomes part of the amalgamation). */
1134 #ifndef SQLITE_OMIT_VIRTUALTABLE
1136 ** Generate code for an UPDATE of a virtual table.
1138 ** There are two possible strategies - the default and the special
1139 ** "onepass" strategy. Onepass is only used if the virtual table
1140 ** implementation indicates that pWhere may match at most one row.
1142 ** The default strategy is to create an ephemeral table that contains
1143 ** for each row to be changed:
1145 ** (A) The original rowid of that row.
1146 ** (B) The revised rowid for the row.
1147 ** (C) The content of every column in the row.
1149 ** Then loop through the contents of this ephemeral table executing a
1150 ** VUpdate for each row. When finished, drop the ephemeral table.
1152 ** The "onepass" strategy does not use an ephemeral table. Instead, it
1153 ** stores the same values (A, B and C above) in a register array and
1154 ** makes a single invocation of VUpdate.
1156 static void updateVirtualTable(
1157 Parse
*pParse
, /* The parsing context */
1158 SrcList
*pSrc
, /* The virtual table to be modified */
1159 Table
*pTab
, /* The virtual table */
1160 ExprList
*pChanges
, /* The columns to change in the UPDATE statement */
1161 Expr
*pRowid
, /* Expression used to recompute the rowid */
1162 int *aXRef
, /* Mapping from columns of pTab to entries in pChanges */
1163 Expr
*pWhere
, /* WHERE clause of the UPDATE statement */
1164 int onError
/* ON CONFLICT strategy */
1166 Vdbe
*v
= pParse
->pVdbe
; /* Virtual machine under construction */
1167 int ephemTab
; /* Table holding the result of the SELECT */
1168 int i
; /* Loop counter */
1169 sqlite3
*db
= pParse
->db
; /* Database connection */
1170 const char *pVTab
= (const char*)sqlite3GetVTable(db
, pTab
);
1171 WhereInfo
*pWInfo
= 0;
1172 int nArg
= 2 + pTab
->nCol
; /* Number of arguments to VUpdate */
1173 int regArg
; /* First register in VUpdate arg array */
1174 int regRec
; /* Register in which to assemble record */
1175 int regRowid
; /* Register for ephem table rowid */
1176 int iCsr
= pSrc
->a
[0].iCursor
; /* Cursor used for virtual table scan */
1177 int aDummy
[2]; /* Unused arg for sqlite3WhereOkOnePass() */
1178 int eOnePass
; /* True to use onepass strategy */
1179 int addr
; /* Address of OP_OpenEphemeral */
1181 /* Allocate nArg registers in which to gather the arguments for VUpdate. Then
1182 ** create and open the ephemeral table in which the records created from
1183 ** these arguments will be temporarily stored. */
1185 ephemTab
= pParse
->nTab
++;
1186 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, ephemTab
, nArg
);
1187 regArg
= pParse
->nMem
+ 1;
1188 pParse
->nMem
+= nArg
;
1193 pRow
= sqlite3ExprDup(db
, pRowid
, 0);
1195 pRow
= sqlite3PExpr(pParse
, TK_ROW
, 0, 0);
1197 pList
= sqlite3ExprListAppend(pParse
, 0, pRow
);
1199 for(i
=0; i
<pTab
->nCol
; i
++){
1201 pList
= sqlite3ExprListAppend(pParse
, pList
,
1202 sqlite3ExprDup(db
, pChanges
->a
[aXRef
[i
]].pExpr
, 0)
1205 pList
= sqlite3ExprListAppend(pParse
, pList
, exprRowColumn(pParse
, i
));
1209 updateFromSelect(pParse
, ephemTab
, 0, pList
, pSrc
, pWhere
, 0, 0);
1210 sqlite3ExprListDelete(db
, pList
);
1211 eOnePass
= ONEPASS_OFF
;
1213 regRec
= ++pParse
->nMem
;
1214 regRowid
= ++pParse
->nMem
;
1216 /* Start scanning the virtual table */
1217 pWInfo
= sqlite3WhereBegin(pParse
, pSrc
,pWhere
,0,0,WHERE_ONEPASS_DESIRED
,0);
1218 if( pWInfo
==0 ) return;
1220 /* Populate the argument registers. */
1221 for(i
=0; i
<pTab
->nCol
; i
++){
1222 assert( (pTab
->aCol
[i
].colFlags
& COLFLAG_GENERATED
)==0 );
1224 sqlite3ExprCode(pParse
, pChanges
->a
[aXRef
[i
]].pExpr
, regArg
+2+i
);
1226 sqlite3VdbeAddOp3(v
, OP_VColumn
, iCsr
, i
, regArg
+2+i
);
1227 sqlite3VdbeChangeP5(v
, OPFLAG_NOCHNG
);/* For sqlite3_vtab_nochange() */
1230 if( HasRowid(pTab
) ){
1231 sqlite3VdbeAddOp2(v
, OP_Rowid
, iCsr
, regArg
);
1233 sqlite3ExprCode(pParse
, pRowid
, regArg
+1);
1235 sqlite3VdbeAddOp2(v
, OP_Rowid
, iCsr
, regArg
+1);
1238 Index
*pPk
; /* PRIMARY KEY index */
1239 i16 iPk
; /* PRIMARY KEY column */
1240 pPk
= sqlite3PrimaryKeyIndex(pTab
);
1242 assert( pPk
->nKeyCol
==1 );
1243 iPk
= pPk
->aiColumn
[0];
1244 sqlite3VdbeAddOp3(v
, OP_VColumn
, iCsr
, iPk
, regArg
);
1245 sqlite3VdbeAddOp2(v
, OP_SCopy
, regArg
+2+iPk
, regArg
+1);
1248 eOnePass
= sqlite3WhereOkOnePass(pWInfo
, aDummy
);
1250 /* There is no ONEPASS_MULTI on virtual tables */
1251 assert( eOnePass
==ONEPASS_OFF
|| eOnePass
==ONEPASS_SINGLE
);
1254 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
1256 sqlite3VdbeChangeToNoop(v
, addr
);
1257 sqlite3VdbeAddOp1(v
, OP_Close
, iCsr
);
1259 /* Create a record from the argument register contents and insert it into
1260 ** the ephemeral table. */
1261 sqlite3MultiWrite(pParse
);
1262 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regArg
, nArg
, regRec
);
1263 #if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM)
1264 /* Signal an assert() within OP_MakeRecord that it is allowed to
1265 ** accept no-change records with serial_type 10 */
1266 sqlite3VdbeChangeP5(v
, OPFLAG_NOCHNG_MAGIC
);
1268 sqlite3VdbeAddOp2(v
, OP_NewRowid
, ephemTab
, regRowid
);
1269 sqlite3VdbeAddOp3(v
, OP_Insert
, ephemTab
, regRec
, regRowid
);
1274 if( eOnePass
==ONEPASS_OFF
){
1275 /* End the virtual table scan */
1276 if( pSrc
->nSrc
==1 ){
1277 sqlite3WhereEnd(pWInfo
);
1280 /* Begin scannning through the ephemeral table. */
1281 addr
= sqlite3VdbeAddOp1(v
, OP_Rewind
, ephemTab
); VdbeCoverage(v
);
1283 /* Extract arguments from the current row of the ephemeral table and
1284 ** invoke the VUpdate method. */
1285 for(i
=0; i
<nArg
; i
++){
1286 sqlite3VdbeAddOp3(v
, OP_Column
, ephemTab
, i
, regArg
+i
);
1289 sqlite3VtabMakeWritable(pParse
, pTab
);
1290 sqlite3VdbeAddOp4(v
, OP_VUpdate
, 0, nArg
, regArg
, pVTab
, P4_VTAB
);
1291 sqlite3VdbeChangeP5(v
, onError
==OE_Default
? OE_Abort
: onError
);
1292 sqlite3MayAbort(pParse
);
1294 /* End of the ephemeral table scan. Or, if using the onepass strategy,
1295 ** jump to here if the scan visited zero rows. */
1296 if( eOnePass
==ONEPASS_OFF
){
1297 sqlite3VdbeAddOp2(v
, OP_Next
, ephemTab
, addr
+1); VdbeCoverage(v
);
1298 sqlite3VdbeJumpHere(v
, addr
);
1299 sqlite3VdbeAddOp2(v
, OP_Close
, ephemTab
, 0);
1301 sqlite3WhereEnd(pWInfo
);
1304 #endif /* SQLITE_OMIT_VIRTUALTABLE */