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_schema 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 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. |
60 | */ |
61 | void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){ |
62 | Column *pCol; |
63 | assert( pTab!=0 ); |
64 | assert( pTab->nCol>i ); |
65 | pCol = &pTab->aCol[i]; |
66 | if( pCol->iDflt ){ |
67 | sqlite3_value *pValue = 0; |
68 | u8 enc = ENC(sqlite3VdbeDb(v)); |
69 | assert( !IsView(pTab) ); |
70 | VdbeComment((v, "%s.%s" , pTab->zName, pCol->zCnName)); |
71 | assert( i<pTab->nCol ); |
72 | sqlite3ValueFromExpr(sqlite3VdbeDb(v), |
73 | sqlite3ColumnExpr(pTab,pCol), enc, |
74 | pCol->affinity, &pValue); |
75 | if( pValue ){ |
76 | sqlite3VdbeAppendP4(v, pValue, P4_MEM); |
77 | } |
78 | } |
79 | #ifndef SQLITE_OMIT_FLOATING_POINT |
80 | if( pCol->affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){ |
81 | sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg); |
82 | } |
83 | #endif |
84 | } |
85 | |
86 | /* |
87 | ** Check to see if column iCol of index pIdx references any of the |
88 | ** columns defined by aXRef and chngRowid. Return true if it does |
89 | ** and false if not. This is an optimization. False-positives are a |
90 | ** performance degradation, but false-negatives can result in a corrupt |
91 | ** index and incorrect answers. |
92 | ** |
93 | ** aXRef[j] will be non-negative if column j of the original table is |
94 | ** being updated. chngRowid will be true if the rowid of the table is |
95 | ** being updated. |
96 | */ |
97 | static int indexColumnIsBeingUpdated( |
98 | Index *pIdx, /* The index to check */ |
99 | int iCol, /* Which column of the index to check */ |
100 | int *aXRef, /* aXRef[j]>=0 if column j is being updated */ |
101 | int chngRowid /* true if the rowid is being updated */ |
102 | ){ |
103 | i16 iIdxCol = pIdx->aiColumn[iCol]; |
104 | assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */ |
105 | if( iIdxCol>=0 ){ |
106 | return aXRef[iIdxCol]>=0; |
107 | } |
108 | assert( iIdxCol==XN_EXPR ); |
109 | assert( pIdx->aColExpr!=0 ); |
110 | assert( pIdx->aColExpr->a[iCol].pExpr!=0 ); |
111 | return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr, |
112 | aXRef,chngRowid); |
113 | } |
114 | |
115 | /* |
116 | ** Check to see if index pIdx is a partial index whose conditional |
117 | ** expression might change values due to an UPDATE. Return true if |
118 | ** the index is subject to change and false if the index is guaranteed |
119 | ** to be unchanged. This is an optimization. False-positives are a |
120 | ** performance degradation, but false-negatives can result in a corrupt |
121 | ** index and incorrect answers. |
122 | ** |
123 | ** aXRef[j] will be non-negative if column j of the original table is |
124 | ** being updated. chngRowid will be true if the rowid of the table is |
125 | ** being updated. |
126 | */ |
127 | static int indexWhereClauseMightChange( |
128 | Index *pIdx, /* The index to check */ |
129 | int *aXRef, /* aXRef[j]>=0 if column j is being updated */ |
130 | int chngRowid /* true if the rowid is being updated */ |
131 | ){ |
132 | if( pIdx->pPartIdxWhere==0 ) return 0; |
133 | return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere, |
134 | aXRef, chngRowid); |
135 | } |
136 | |
137 | /* |
138 | ** Allocate and return a pointer to an expression of type TK_ROW with |
139 | ** Expr.iColumn set to value (iCol+1). The resolver will modify the |
140 | ** expression to be a TK_COLUMN reading column iCol of the first |
141 | ** table in the source-list (pSrc->a[0]). |
142 | */ |
143 | static Expr *exprRowColumn(Parse *pParse, int iCol){ |
144 | Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0); |
145 | if( pRet ) pRet->iColumn = iCol+1; |
146 | return pRet; |
147 | } |
148 | |
149 | /* |
150 | ** Assuming both the pLimit and pOrderBy parameters are NULL, this function |
151 | ** generates VM code to run the query: |
152 | ** |
153 | ** SELECT <other-columns>, pChanges FROM pTabList WHERE pWhere |
154 | ** |
155 | ** and write the results to the ephemeral table already opened as cursor |
156 | ** iEph. None of pChanges, pTabList or pWhere are modified or consumed by |
157 | ** this function, they must be deleted by the caller. |
158 | ** |
159 | ** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view: |
160 | ** |
161 | ** SELECT <other-columns>, pChanges FROM pTabList |
162 | ** WHERE pWhere |
163 | ** GROUP BY <other-columns> |
164 | ** ORDER BY pOrderBy LIMIT pLimit |
165 | ** |
166 | ** If pTab is a view, the GROUP BY clause is omitted. |
167 | ** |
168 | ** Exactly how results are written to table iEph, and exactly what |
169 | ** the <other-columns> in the query above are is determined by the type |
170 | ** of table pTabList->a[0].pTab. |
171 | ** |
172 | ** If the table is a WITHOUT ROWID table, then argument pPk must be its |
173 | ** PRIMARY KEY. In this case <other-columns> are the primary key columns |
174 | ** of the table, in order. The results of the query are written to ephemeral |
175 | ** table iEph as index keys, using OP_IdxInsert. |
176 | ** |
177 | ** If the table is actually a view, then <other-columns> are all columns of |
178 | ** the view. The results are written to the ephemeral table iEph as records |
179 | ** with automatically assigned integer keys. |
180 | ** |
181 | ** If the table is a virtual or ordinary intkey table, then <other-columns> |
182 | ** is its rowid. For a virtual table, the results are written to iEph as |
183 | ** records with automatically assigned integer keys For intkey tables, the |
184 | ** rowid value in <other-columns> is used as the integer key, and the |
185 | ** remaining fields make up the table record. |
186 | */ |
187 | static void updateFromSelect( |
188 | Parse *pParse, /* Parse context */ |
189 | int iEph, /* Cursor for open eph. table */ |
190 | Index *pPk, /* PK if table 0 is WITHOUT ROWID */ |
191 | ExprList *pChanges, /* List of expressions to return */ |
192 | SrcList *pTabList, /* List of tables to select from */ |
193 | Expr *pWhere, /* WHERE clause for query */ |
194 | ExprList *pOrderBy, /* ORDER BY clause */ |
195 | Expr *pLimit /* LIMIT clause */ |
196 | ){ |
197 | int i; |
198 | SelectDest dest; |
199 | Select *pSelect = 0; |
200 | ExprList *pList = 0; |
201 | ExprList *pGrp = 0; |
202 | Expr *pLimit2 = 0; |
203 | ExprList *pOrderBy2 = 0; |
204 | sqlite3 *db = pParse->db; |
205 | Table *pTab = pTabList->a[0].pTab; |
206 | SrcList *pSrc; |
207 | Expr *pWhere2; |
208 | int eDest; |
209 | |
210 | #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT |
211 | if( pOrderBy && pLimit==0 ) { |
212 | sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE" ); |
213 | return; |
214 | } |
215 | pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0); |
216 | pLimit2 = sqlite3ExprDup(db, pLimit, 0); |
217 | #else |
218 | UNUSED_PARAMETER(pOrderBy); |
219 | UNUSED_PARAMETER(pLimit); |
220 | #endif |
221 | |
222 | pSrc = sqlite3SrcListDup(db, pTabList, 0); |
223 | pWhere2 = sqlite3ExprDup(db, pWhere, 0); |
224 | |
225 | assert( pTabList->nSrc>1 ); |
226 | if( pSrc ){ |
227 | pSrc->a[0].fg.notCte = 1; |
228 | pSrc->a[0].iCursor = -1; |
229 | pSrc->a[0].pTab->nTabRef--; |
230 | pSrc->a[0].pTab = 0; |
231 | } |
232 | if( pPk ){ |
233 | for(i=0; i<pPk->nKeyCol; i++){ |
234 | Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]); |
235 | #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT |
236 | if( pLimit ){ |
237 | pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0)); |
238 | } |
239 | #endif |
240 | pList = sqlite3ExprListAppend(pParse, pList, pNew); |
241 | } |
242 | eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; |
243 | }else if( IsView(pTab) ){ |
244 | for(i=0; i<pTab->nCol; i++){ |
245 | pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); |
246 | } |
247 | eDest = SRT_Table; |
248 | }else{ |
249 | eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; |
250 | pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); |
251 | #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT |
252 | if( pLimit ){ |
253 | pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); |
254 | } |
255 | #endif |
256 | } |
257 | assert( pChanges!=0 || pParse->db->mallocFailed ); |
258 | if( pChanges ){ |
259 | for(i=0; i<pChanges->nExpr; i++){ |
260 | pList = sqlite3ExprListAppend(pParse, pList, |
261 | sqlite3ExprDup(db, pChanges->a[i].pExpr, 0) |
262 | ); |
263 | } |
264 | } |
265 | pSelect = sqlite3SelectNew(pParse, pList, |
266 | pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UFSrcCheck|SF_IncludeHidden, pLimit2 |
267 | ); |
268 | if( pSelect ) pSelect->selFlags |= SF_OrderByReqd; |
269 | sqlite3SelectDestInit(&dest, eDest, iEph); |
270 | dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1); |
271 | sqlite3Select(pParse, pSelect, &dest); |
272 | sqlite3SelectDelete(db, pSelect); |
273 | } |
274 | |
275 | /* |
276 | ** Process an UPDATE statement. |
277 | ** |
278 | ** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL; |
279 | ** \_______/ \_/ \______/ \_____/ \________________/ |
280 | ** onError | pChanges | pWhere |
281 | ** \_______________________/ |
282 | ** pTabList |
283 | */ |
284 | void sqlite3Update( |
285 | Parse *pParse, /* The parser context */ |
286 | SrcList *pTabList, /* The table in which we should change things */ |
287 | ExprList *pChanges, /* Things to be changed */ |
288 | Expr *pWhere, /* The WHERE clause. May be null */ |
289 | int onError, /* How to handle constraint errors */ |
290 | ExprList *pOrderBy, /* ORDER BY clause. May be null */ |
291 | Expr *pLimit, /* LIMIT clause. May be null */ |
292 | Upsert *pUpsert /* ON CONFLICT clause, or null */ |
293 | ){ |
294 | int i, j, k; /* Loop counters */ |
295 | Table *pTab; /* The table to be updated */ |
296 | int addrTop = 0; /* VDBE instruction address of the start of the loop */ |
297 | WhereInfo *pWInfo = 0; /* Information about the WHERE clause */ |
298 | Vdbe *v; /* The virtual database engine */ |
299 | Index *pIdx; /* For looping over indices */ |
300 | Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */ |
301 | int nIdx; /* Number of indices that need updating */ |
302 | int nAllIdx; /* Total number of indexes */ |
303 | int iBaseCur; /* Base cursor number */ |
304 | int iDataCur; /* Cursor for the canonical data btree */ |
305 | int iIdxCur; /* Cursor for the first index */ |
306 | sqlite3 *db; /* The database structure */ |
307 | int *aRegIdx = 0; /* Registers for to each index and the main table */ |
308 | int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the |
309 | ** an expression for the i-th column of the table. |
310 | ** aXRef[i]==-1 if the i-th column is not changed. */ |
311 | u8 *aToOpen; /* 1 for tables and indices to be opened */ |
312 | u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ |
313 | u8 chngRowid; /* Rowid changed in a normal table */ |
314 | u8 chngKey; /* Either chngPk or chngRowid */ |
315 | Expr *pRowidExpr = 0; /* Expression defining the new record number */ |
316 | int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */ |
317 | AuthContext sContext; /* The authorization context */ |
318 | NameContext sNC; /* The name-context to resolve expressions in */ |
319 | int iDb; /* Database containing the table being updated */ |
320 | int eOnePass; /* ONEPASS_XXX value from where.c */ |
321 | int hasFK; /* True if foreign key processing is required */ |
322 | int labelBreak; /* Jump here to break out of UPDATE loop */ |
323 | int labelContinue; /* Jump here to continue next step of UPDATE loop */ |
324 | int flags; /* Flags for sqlite3WhereBegin() */ |
325 | |
326 | #ifndef SQLITE_OMIT_TRIGGER |
327 | int isView; /* True when updating a view (INSTEAD OF trigger) */ |
328 | Trigger *pTrigger; /* List of triggers on pTab, if required */ |
329 | int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ |
330 | #endif |
331 | int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */ |
332 | int iEph = 0; /* Ephemeral table holding all primary key values */ |
333 | int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ |
334 | int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ |
335 | int addrOpen = 0; /* Address of OP_OpenEphemeral */ |
336 | int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */ |
337 | i16 nPk = 0; /* Number of components of the PRIMARY KEY */ |
338 | int bReplace = 0; /* True if REPLACE conflict resolution might happen */ |
339 | int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */ |
340 | int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */ |
341 | |
342 | /* Register Allocations */ |
343 | int regRowCount = 0; /* A count of rows changed */ |
344 | int regOldRowid = 0; /* The old rowid */ |
345 | int regNewRowid = 0; /* The new rowid */ |
346 | int regNew = 0; /* Content of the NEW.* table in triggers */ |
347 | int regOld = 0; /* Content of OLD.* table in triggers */ |
348 | int regRowSet = 0; /* Rowset of rows to be updated */ |
349 | int regKey = 0; /* composite PRIMARY KEY value */ |
350 | |
351 | memset(&sContext, 0, sizeof(sContext)); |
352 | db = pParse->db; |
353 | assert( db->pParse==pParse ); |
354 | if( pParse->nErr ){ |
355 | goto update_cleanup; |
356 | } |
357 | assert( db->mallocFailed==0 ); |
358 | |
359 | /* Locate the table which we want to update. |
360 | */ |
361 | pTab = sqlite3SrcListLookup(pParse, pTabList); |
362 | if( pTab==0 ) goto update_cleanup; |
363 | iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); |
364 | |
365 | /* Figure out if we have any triggers and if the table being |
366 | ** updated is a view. |
367 | */ |
368 | #ifndef SQLITE_OMIT_TRIGGER |
369 | pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask); |
370 | isView = IsView(pTab); |
371 | assert( pTrigger || tmask==0 ); |
372 | #else |
373 | # define pTrigger 0 |
374 | # define isView 0 |
375 | # define tmask 0 |
376 | #endif |
377 | #ifdef SQLITE_OMIT_VIEW |
378 | # undef isView |
379 | # define isView 0 |
380 | #endif |
381 | |
382 | #if TREETRACE_ENABLED |
383 | if( sqlite3TreeTrace & 0x10000 ){ |
384 | sqlite3TreeViewLine(0, "In sqlite3Update() at %s:%d" , __FILE__, __LINE__); |
385 | sqlite3TreeViewUpdate(pParse->pWith, pTabList, pChanges, pWhere, |
386 | onError, pOrderBy, pLimit, pUpsert, pTrigger); |
387 | } |
388 | #endif |
389 | |
390 | /* If there was a FROM clause, set nChangeFrom to the number of expressions |
391 | ** in the change-list. Otherwise, set it to 0. There cannot be a FROM |
392 | ** clause if this function is being called to generate code for part of |
393 | ** an UPSERT statement. */ |
394 | nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0; |
395 | assert( nChangeFrom==0 || pUpsert==0 ); |
396 | |
397 | #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT |
398 | if( !isView && nChangeFrom==0 ){ |
399 | pWhere = sqlite3LimitWhere( |
400 | pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE" |
401 | ); |
402 | pOrderBy = 0; |
403 | pLimit = 0; |
404 | } |
405 | #endif |
406 | |
407 | if( sqlite3ViewGetColumnNames(pParse, pTab) ){ |
408 | goto update_cleanup; |
409 | } |
410 | if( sqlite3IsReadOnly(pParse, pTab, tmask) ){ |
411 | goto update_cleanup; |
412 | } |
413 | |
414 | /* Allocate a cursors for the main database table and for all indices. |
415 | ** The index cursors might not be used, but if they are used they |
416 | ** need to occur right after the database cursor. So go ahead and |
417 | ** allocate enough space, just in case. |
418 | */ |
419 | iBaseCur = iDataCur = pParse->nTab++; |
420 | iIdxCur = iDataCur+1; |
421 | pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); |
422 | testcase( pPk!=0 && pPk!=pTab->pIndex ); |
423 | for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ |
424 | if( pPk==pIdx ){ |
425 | iDataCur = pParse->nTab; |
426 | } |
427 | pParse->nTab++; |
428 | } |
429 | if( pUpsert ){ |
430 | /* On an UPSERT, reuse the same cursors already opened by INSERT */ |
431 | iDataCur = pUpsert->iDataCur; |
432 | iIdxCur = pUpsert->iIdxCur; |
433 | pParse->nTab = iBaseCur; |
434 | } |
435 | pTabList->a[0].iCursor = iDataCur; |
436 | |
437 | /* Allocate space for aXRef[], aRegIdx[], and aToOpen[]. |
438 | ** Initialize aXRef[] and aToOpen[] to their default values. |
439 | */ |
440 | aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 ); |
441 | if( aXRef==0 ) goto update_cleanup; |
442 | aRegIdx = aXRef+pTab->nCol; |
443 | aToOpen = (u8*)(aRegIdx+nIdx+1); |
444 | memset(aToOpen, 1, nIdx+1); |
445 | aToOpen[nIdx+1] = 0; |
446 | for(i=0; i<pTab->nCol; i++) aXRef[i] = -1; |
447 | |
448 | /* Initialize the name-context */ |
449 | memset(&sNC, 0, sizeof(sNC)); |
450 | sNC.pParse = pParse; |
451 | sNC.pSrcList = pTabList; |
452 | sNC.uNC.pUpsert = pUpsert; |
453 | sNC.ncFlags = NC_UUpsert; |
454 | |
455 | /* Begin generating code. */ |
456 | v = sqlite3GetVdbe(pParse); |
457 | if( v==0 ) goto update_cleanup; |
458 | |
459 | /* Resolve the column names in all the expressions of the |
460 | ** of the UPDATE statement. Also find the column index |
461 | ** for each column to be updated in the pChanges array. For each |
462 | ** column to be updated, make sure we have authorization to change |
463 | ** that column. |
464 | */ |
465 | chngRowid = chngPk = 0; |
466 | for(i=0; i<pChanges->nExpr; i++){ |
467 | u8 hCol = sqlite3StrIHash(pChanges->a[i].zEName); |
468 | /* If this is an UPDATE with a FROM clause, do not resolve expressions |
469 | ** here. The call to sqlite3Select() below will do that. */ |
470 | if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ |
471 | goto update_cleanup; |
472 | } |
473 | for(j=0; j<pTab->nCol; j++){ |
474 | if( pTab->aCol[j].hName==hCol |
475 | && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0 |
476 | ){ |
477 | if( j==pTab->iPKey ){ |
478 | chngRowid = 1; |
479 | pRowidExpr = pChanges->a[i].pExpr; |
480 | iRowidExpr = i; |
481 | }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){ |
482 | chngPk = 1; |
483 | } |
484 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
485 | else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){ |
486 | testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ); |
487 | testcase( pTab->aCol[j].colFlags & COLFLAG_STORED ); |
488 | sqlite3ErrorMsg(pParse, |
489 | "cannot UPDATE generated column \"%s\"" , |
490 | pTab->aCol[j].zCnName); |
491 | goto update_cleanup; |
492 | } |
493 | #endif |
494 | aXRef[j] = i; |
495 | break; |
496 | } |
497 | } |
498 | if( j>=pTab->nCol ){ |
499 | if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){ |
500 | j = -1; |
501 | chngRowid = 1; |
502 | pRowidExpr = pChanges->a[i].pExpr; |
503 | iRowidExpr = i; |
504 | }else{ |
505 | sqlite3ErrorMsg(pParse, "no such column: %s" , pChanges->a[i].zEName); |
506 | pParse->checkSchema = 1; |
507 | goto update_cleanup; |
508 | } |
509 | } |
510 | #ifndef SQLITE_OMIT_AUTHORIZATION |
511 | { |
512 | int rc; |
513 | rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, |
514 | j<0 ? "ROWID" : pTab->aCol[j].zCnName, |
515 | db->aDb[iDb].zDbSName); |
516 | if( rc==SQLITE_DENY ){ |
517 | goto update_cleanup; |
518 | }else if( rc==SQLITE_IGNORE ){ |
519 | aXRef[j] = -1; |
520 | } |
521 | } |
522 | #endif |
523 | } |
524 | assert( (chngRowid & chngPk)==0 ); |
525 | assert( chngRowid==0 || chngRowid==1 ); |
526 | assert( chngPk==0 || chngPk==1 ); |
527 | chngKey = chngRowid + chngPk; |
528 | |
529 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
530 | /* Mark generated columns as changing if their generator expressions |
531 | ** reference any changing column. The actual aXRef[] value for |
532 | ** generated expressions is not used, other than to check to see that it |
533 | ** is non-negative, so the value of aXRef[] for generated columns can be |
534 | ** set to any non-negative number. We use 99999 so that the value is |
535 | ** obvious when looking at aXRef[] in a symbolic debugger. |
536 | */ |
537 | if( pTab->tabFlags & TF_HasGenerated ){ |
538 | int bProgress; |
539 | testcase( pTab->tabFlags & TF_HasVirtual ); |
540 | testcase( pTab->tabFlags & TF_HasStored ); |
541 | do{ |
542 | bProgress = 0; |
543 | for(i=0; i<pTab->nCol; i++){ |
544 | if( aXRef[i]>=0 ) continue; |
545 | if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue; |
546 | if( sqlite3ExprReferencesUpdatedColumn( |
547 | sqlite3ColumnExpr(pTab, &pTab->aCol[i]), |
548 | aXRef, chngRowid) |
549 | ){ |
550 | aXRef[i] = 99999; |
551 | bProgress = 1; |
552 | } |
553 | } |
554 | }while( bProgress ); |
555 | } |
556 | #endif |
557 | |
558 | /* The SET expressions are not actually used inside the WHERE loop. |
559 | ** So reset the colUsed mask. Unless this is a virtual table. In that |
560 | ** case, set all bits of the colUsed mask (to ensure that the virtual |
561 | ** table implementation makes all columns available). |
562 | */ |
563 | pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0; |
564 | |
565 | hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey); |
566 | |
567 | /* There is one entry in the aRegIdx[] array for each index on the table |
568 | ** being updated. Fill in aRegIdx[] with a register number that will hold |
569 | ** the key for accessing each index. |
570 | */ |
571 | if( onError==OE_Replace ) bReplace = 1; |
572 | for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){ |
573 | int reg; |
574 | if( chngKey || hasFK>1 || pIdx==pPk |
575 | || indexWhereClauseMightChange(pIdx,aXRef,chngRowid) |
576 | ){ |
577 | reg = ++pParse->nMem; |
578 | pParse->nMem += pIdx->nColumn; |
579 | }else{ |
580 | reg = 0; |
581 | for(i=0; i<pIdx->nKeyCol; i++){ |
582 | if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){ |
583 | reg = ++pParse->nMem; |
584 | pParse->nMem += pIdx->nColumn; |
585 | if( onError==OE_Default && pIdx->onError==OE_Replace ){ |
586 | bReplace = 1; |
587 | } |
588 | break; |
589 | } |
590 | } |
591 | } |
592 | if( reg==0 ) aToOpen[nAllIdx+1] = 0; |
593 | aRegIdx[nAllIdx] = reg; |
594 | } |
595 | aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */ |
596 | if( bReplace ){ |
597 | /* If REPLACE conflict resolution might be invoked, open cursors on all |
598 | ** indexes in case they are needed to delete records. */ |
599 | memset(aToOpen, 1, nIdx+1); |
600 | } |
601 | |
602 | if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); |
603 | sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb); |
604 | |
605 | /* Allocate required registers. */ |
606 | if( !IsVirtual(pTab) ){ |
607 | /* For now, regRowSet and aRegIdx[nAllIdx] share the same register. |
608 | ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be |
609 | ** reallocated. aRegIdx[nAllIdx] is the register in which the main |
610 | ** table record is written. regRowSet holds the RowSet for the |
611 | ** two-pass update algorithm. */ |
612 | assert( aRegIdx[nAllIdx]==pParse->nMem ); |
613 | regRowSet = aRegIdx[nAllIdx]; |
614 | regOldRowid = regNewRowid = ++pParse->nMem; |
615 | if( chngPk || pTrigger || hasFK ){ |
616 | regOld = pParse->nMem + 1; |
617 | pParse->nMem += pTab->nCol; |
618 | } |
619 | if( chngKey || pTrigger || hasFK ){ |
620 | regNewRowid = ++pParse->nMem; |
621 | } |
622 | regNew = pParse->nMem + 1; |
623 | pParse->nMem += pTab->nCol; |
624 | } |
625 | |
626 | /* Start the view context. */ |
627 | if( isView ){ |
628 | sqlite3AuthContextPush(pParse, &sContext, pTab->zName); |
629 | } |
630 | |
631 | /* If we are trying to update a view, realize that view into |
632 | ** an ephemeral table. |
633 | */ |
634 | #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) |
635 | if( nChangeFrom==0 && isView ){ |
636 | sqlite3MaterializeView(pParse, pTab, |
637 | pWhere, pOrderBy, pLimit, iDataCur |
638 | ); |
639 | pOrderBy = 0; |
640 | pLimit = 0; |
641 | } |
642 | #endif |
643 | |
644 | /* Resolve the column names in all the expressions in the |
645 | ** WHERE clause. |
646 | */ |
647 | if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){ |
648 | goto update_cleanup; |
649 | } |
650 | |
651 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
652 | /* Virtual tables must be handled separately */ |
653 | if( IsVirtual(pTab) ){ |
654 | updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, |
655 | pWhere, onError); |
656 | goto update_cleanup; |
657 | } |
658 | #endif |
659 | |
660 | /* Jump to labelBreak to abandon further processing of this UPDATE */ |
661 | labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse); |
662 | |
663 | /* Not an UPSERT. Normal processing. Begin by |
664 | ** initialize the count of updated rows */ |
665 | if( (db->flags&SQLITE_CountRows)!=0 |
666 | && !pParse->pTriggerTab |
667 | && !pParse->nested |
668 | && !pParse->bReturning |
669 | && pUpsert==0 |
670 | ){ |
671 | regRowCount = ++pParse->nMem; |
672 | sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); |
673 | } |
674 | |
675 | if( nChangeFrom==0 && HasRowid(pTab) ){ |
676 | sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); |
677 | iEph = pParse->nTab++; |
678 | addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet); |
679 | }else{ |
680 | assert( pPk!=0 || HasRowid(pTab) ); |
681 | nPk = pPk ? pPk->nKeyCol : 0; |
682 | iPk = pParse->nMem+1; |
683 | pParse->nMem += nPk; |
684 | pParse->nMem += nChangeFrom; |
685 | regKey = ++pParse->nMem; |
686 | if( pUpsert==0 ){ |
687 | int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0); |
688 | iEph = pParse->nTab++; |
689 | if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1); |
690 | addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol); |
691 | if( pPk ){ |
692 | KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk); |
693 | if( pKeyInfo ){ |
694 | pKeyInfo->nAllField = nEphCol; |
695 | sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); |
696 | } |
697 | } |
698 | if( nChangeFrom ){ |
699 | updateFromSelect( |
700 | pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit |
701 | ); |
702 | #ifndef SQLITE_OMIT_SUBQUERY |
703 | if( isView ) iDataCur = iEph; |
704 | #endif |
705 | } |
706 | } |
707 | } |
708 | |
709 | if( nChangeFrom ){ |
710 | sqlite3MultiWrite(pParse); |
711 | eOnePass = ONEPASS_OFF; |
712 | nKey = nPk; |
713 | regKey = iPk; |
714 | }else{ |
715 | if( pUpsert ){ |
716 | /* If this is an UPSERT, then all cursors have already been opened by |
717 | ** the outer INSERT and the data cursor should be pointing at the row |
718 | ** that is to be updated. So bypass the code that searches for the |
719 | ** row(s) to be updated. |
720 | */ |
721 | pWInfo = 0; |
722 | eOnePass = ONEPASS_SINGLE; |
723 | sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL); |
724 | bFinishSeek = 0; |
725 | }else{ |
726 | /* Begin the database scan. |
727 | ** |
728 | ** Do not consider a single-pass strategy for a multi-row update if |
729 | ** there are any triggers or foreign keys to process, or rows may |
730 | ** be deleted as a result of REPLACE conflict handling. Any of these |
731 | ** things might disturb a cursor being used to scan through the table |
732 | ** or index, causing a single-pass approach to malfunction. */ |
733 | flags = WHERE_ONEPASS_DESIRED; |
734 | if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){ |
735 | flags |= WHERE_ONEPASS_MULTIROW; |
736 | } |
737 | pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,0,0,flags,iIdxCur); |
738 | if( pWInfo==0 ) goto update_cleanup; |
739 | |
740 | /* A one-pass strategy that might update more than one row may not |
741 | ** be used if any column of the index used for the scan is being |
742 | ** updated. Otherwise, if there is an index on "b", statements like |
743 | ** the following could create an infinite loop: |
744 | ** |
745 | ** UPDATE t1 SET b=b+1 WHERE b>? |
746 | ** |
747 | ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI |
748 | ** strategy that uses an index for which one or more columns are being |
749 | ** updated. */ |
750 | eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); |
751 | bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo); |
752 | if( eOnePass!=ONEPASS_SINGLE ){ |
753 | sqlite3MultiWrite(pParse); |
754 | if( eOnePass==ONEPASS_MULTI ){ |
755 | int iCur = aiCurOnePass[1]; |
756 | if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){ |
757 | eOnePass = ONEPASS_OFF; |
758 | } |
759 | assert( iCur!=iDataCur || !HasRowid(pTab) ); |
760 | } |
761 | } |
762 | } |
763 | |
764 | if( HasRowid(pTab) ){ |
765 | /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF |
766 | ** mode, write the rowid into the FIFO. In either of the one-pass modes, |
767 | ** leave it in register regOldRowid. */ |
768 | sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); |
769 | if( eOnePass==ONEPASS_OFF ){ |
770 | aRegIdx[nAllIdx] = ++pParse->nMem; |
771 | sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid); |
772 | }else{ |
773 | if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen); |
774 | } |
775 | }else{ |
776 | /* Read the PK of the current row into an array of registers. In |
777 | ** ONEPASS_OFF mode, serialize the array into a record and store it in |
778 | ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change |
779 | ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table |
780 | ** is not required) and leave the PK fields in the array of registers. */ |
781 | for(i=0; i<nPk; i++){ |
782 | assert( pPk->aiColumn[i]>=0 ); |
783 | sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, |
784 | pPk->aiColumn[i], iPk+i); |
785 | } |
786 | if( eOnePass ){ |
787 | if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen); |
788 | nKey = nPk; |
789 | regKey = iPk; |
790 | }else{ |
791 | sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, |
792 | sqlite3IndexAffinityStr(db, pPk), nPk); |
793 | sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk); |
794 | } |
795 | } |
796 | } |
797 | |
798 | if( pUpsert==0 ){ |
799 | if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){ |
800 | sqlite3WhereEnd(pWInfo); |
801 | } |
802 | |
803 | if( !isView ){ |
804 | int addrOnce = 0; |
805 | |
806 | /* Open every index that needs updating. */ |
807 | if( eOnePass!=ONEPASS_OFF ){ |
808 | if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; |
809 | if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; |
810 | } |
811 | |
812 | if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){ |
813 | addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); |
814 | } |
815 | sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, |
816 | aToOpen, 0, 0); |
817 | if( addrOnce ){ |
818 | sqlite3VdbeJumpHereOrPopInst(v, addrOnce); |
819 | } |
820 | } |
821 | |
822 | /* Top of the update loop */ |
823 | if( eOnePass!=ONEPASS_OFF ){ |
824 | if( aiCurOnePass[0]!=iDataCur |
825 | && aiCurOnePass[1]!=iDataCur |
826 | #ifdef SQLITE_ALLOW_ROWID_IN_VIEW |
827 | && !isView |
828 | #endif |
829 | ){ |
830 | assert( pPk ); |
831 | sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey); |
832 | VdbeCoverage(v); |
833 | } |
834 | if( eOnePass!=ONEPASS_SINGLE ){ |
835 | labelContinue = sqlite3VdbeMakeLabel(pParse); |
836 | } |
837 | sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); |
838 | VdbeCoverageIf(v, pPk==0); |
839 | VdbeCoverageIf(v, pPk!=0); |
840 | }else if( pPk || nChangeFrom ){ |
841 | labelContinue = sqlite3VdbeMakeLabel(pParse); |
842 | sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); |
843 | addrTop = sqlite3VdbeCurrentAddr(v); |
844 | if( nChangeFrom ){ |
845 | if( !isView ){ |
846 | if( pPk ){ |
847 | for(i=0; i<nPk; i++){ |
848 | sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i); |
849 | } |
850 | sqlite3VdbeAddOp4Int( |
851 | v, OP_NotFound, iDataCur, labelContinue, iPk, nPk |
852 | ); VdbeCoverage(v); |
853 | }else{ |
854 | sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid); |
855 | sqlite3VdbeAddOp3( |
856 | v, OP_NotExists, iDataCur, labelContinue, regOldRowid |
857 | ); VdbeCoverage(v); |
858 | } |
859 | } |
860 | }else{ |
861 | sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey); |
862 | sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0); |
863 | VdbeCoverage(v); |
864 | } |
865 | }else{ |
866 | sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); |
867 | labelContinue = sqlite3VdbeMakeLabel(pParse); |
868 | addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid); |
869 | VdbeCoverage(v); |
870 | sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); |
871 | VdbeCoverage(v); |
872 | } |
873 | } |
874 | |
875 | /* If the rowid value will change, set register regNewRowid to |
876 | ** contain the new value. If the rowid is not being modified, |
877 | ** then regNewRowid is the same register as regOldRowid, which is |
878 | ** already populated. */ |
879 | assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid ); |
880 | if( chngRowid ){ |
881 | assert( iRowidExpr>=0 ); |
882 | if( nChangeFrom==0 ){ |
883 | sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); |
884 | }else{ |
885 | sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid); |
886 | } |
887 | sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); |
888 | } |
889 | |
890 | /* Compute the old pre-UPDATE content of the row being changed, if that |
891 | ** information is needed */ |
892 | if( chngPk || hasFK || pTrigger ){ |
893 | u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); |
894 | oldmask |= sqlite3TriggerColmask(pParse, |
895 | pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError |
896 | ); |
897 | for(i=0; i<pTab->nCol; i++){ |
898 | u32 colFlags = pTab->aCol[i].colFlags; |
899 | k = sqlite3TableColumnToStorage(pTab, i) + regOld; |
900 | if( oldmask==0xffffffff |
901 | || (i<32 && (oldmask & MASKBIT32(i))!=0) |
902 | || (colFlags & COLFLAG_PRIMKEY)!=0 |
903 | ){ |
904 | testcase( oldmask!=0xffffffff && i==31 ); |
905 | sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); |
906 | }else{ |
907 | sqlite3VdbeAddOp2(v, OP_Null, 0, k); |
908 | } |
909 | } |
910 | if( chngRowid==0 && pPk==0 ){ |
911 | sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid); |
912 | } |
913 | } |
914 | |
915 | /* Populate the array of registers beginning at regNew with the new |
916 | ** row data. This array is used to check constants, create the new |
917 | ** table and index records, and as the values for any new.* references |
918 | ** made by triggers. |
919 | ** |
920 | ** If there are one or more BEFORE triggers, then do not populate the |
921 | ** registers associated with columns that are (a) not modified by |
922 | ** this UPDATE statement and (b) not accessed by new.* references. The |
923 | ** values for registers not modified by the UPDATE must be reloaded from |
924 | ** the database after the BEFORE triggers are fired anyway (as the trigger |
925 | ** may have modified them). So not loading those that are not going to |
926 | ** be used eliminates some redundant opcodes. |
927 | */ |
928 | newmask = sqlite3TriggerColmask( |
929 | pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError |
930 | ); |
931 | for(i=0, k=regNew; i<pTab->nCol; i++, k++){ |
932 | if( i==pTab->iPKey ){ |
933 | sqlite3VdbeAddOp2(v, OP_Null, 0, k); |
934 | }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){ |
935 | if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; |
936 | }else{ |
937 | j = aXRef[i]; |
938 | if( j>=0 ){ |
939 | if( nChangeFrom ){ |
940 | int nOff = (isView ? pTab->nCol : nPk); |
941 | assert( eOnePass==ONEPASS_OFF ); |
942 | sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k); |
943 | }else{ |
944 | sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k); |
945 | } |
946 | }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ |
947 | /* This branch loads the value of a column that will not be changed |
948 | ** into a register. This is done if there are no BEFORE triggers, or |
949 | ** if there are one or more BEFORE triggers that use this value via |
950 | ** a new.* reference in a trigger program. |
951 | */ |
952 | testcase( i==31 ); |
953 | testcase( i==32 ); |
954 | sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); |
955 | bFinishSeek = 0; |
956 | }else{ |
957 | sqlite3VdbeAddOp2(v, OP_Null, 0, k); |
958 | } |
959 | } |
960 | } |
961 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
962 | if( pTab->tabFlags & TF_HasGenerated ){ |
963 | testcase( pTab->tabFlags & TF_HasVirtual ); |
964 | testcase( pTab->tabFlags & TF_HasStored ); |
965 | sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); |
966 | } |
967 | #endif |
968 | |
969 | /* Fire any BEFORE UPDATE triggers. This happens before constraints are |
970 | ** verified. One could argue that this is wrong. |
971 | */ |
972 | if( tmask&TRIGGER_BEFORE ){ |
973 | sqlite3TableAffinity(v, pTab, regNew); |
974 | sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, |
975 | TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); |
976 | |
977 | if( !isView ){ |
978 | /* The row-trigger may have deleted the row being updated. In this |
979 | ** case, jump to the next row. No updates or AFTER triggers are |
980 | ** required. This behavior - what happens when the row being updated |
981 | ** is deleted or renamed by a BEFORE trigger - is left undefined in the |
982 | ** documentation. |
983 | */ |
984 | if( pPk ){ |
985 | sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); |
986 | VdbeCoverage(v); |
987 | }else{ |
988 | sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); |
989 | VdbeCoverage(v); |
990 | } |
991 | |
992 | /* After-BEFORE-trigger-reload-loop: |
993 | ** If it did not delete it, the BEFORE trigger may still have modified |
994 | ** some of the columns of the row being updated. Load the values for |
995 | ** all columns not modified by the update statement into their registers |
996 | ** in case this has happened. Only unmodified columns are reloaded. |
997 | ** The values computed for modified columns use the values before the |
998 | ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26) |
999 | ** for an example. |
1000 | */ |
1001 | for(i=0, k=regNew; i<pTab->nCol; i++, k++){ |
1002 | if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ |
1003 | if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; |
1004 | }else if( aXRef[i]<0 && i!=pTab->iPKey ){ |
1005 | sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); |
1006 | } |
1007 | } |
1008 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS |
1009 | if( pTab->tabFlags & TF_HasGenerated ){ |
1010 | testcase( pTab->tabFlags & TF_HasVirtual ); |
1011 | testcase( pTab->tabFlags & TF_HasStored ); |
1012 | sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); |
1013 | } |
1014 | #endif |
1015 | } |
1016 | } |
1017 | |
1018 | if( !isView ){ |
1019 | /* Do constraint checks. */ |
1020 | assert( regOldRowid>0 ); |
1021 | sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, |
1022 | regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace, |
1023 | aXRef, 0); |
1024 | |
1025 | /* If REPLACE conflict handling may have been used, or if the PK of the |
1026 | ** row is changing, then the GenerateConstraintChecks() above may have |
1027 | ** moved cursor iDataCur. Reseek it. */ |
1028 | if( bReplace || chngKey ){ |
1029 | if( pPk ){ |
1030 | sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); |
1031 | }else{ |
1032 | sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); |
1033 | } |
1034 | VdbeCoverage(v); |
1035 | } |
1036 | |
1037 | /* Do FK constraint checks. */ |
1038 | if( hasFK ){ |
1039 | sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey); |
1040 | } |
1041 | |
1042 | /* Delete the index entries associated with the current record. */ |
1043 | sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1); |
1044 | |
1045 | /* We must run the OP_FinishSeek opcode to resolve a prior |
1046 | ** OP_DeferredSeek if there is any possibility that there have been |
1047 | ** no OP_Column opcodes since the OP_DeferredSeek was issued. But |
1048 | ** we want to avoid the OP_FinishSeek if possible, as running it |
1049 | ** costs CPU cycles. */ |
1050 | if( bFinishSeek ){ |
1051 | sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur); |
1052 | } |
1053 | |
1054 | /* If changing the rowid value, or if there are foreign key constraints |
1055 | ** to process, delete the old record. Otherwise, add a noop OP_Delete |
1056 | ** to invoke the pre-update hook. |
1057 | ** |
1058 | ** That (regNew==regnewRowid+1) is true is also important for the |
1059 | ** pre-update hook. If the caller invokes preupdate_new(), the returned |
1060 | ** value is copied from memory cell (regNewRowid+1+iCol), where iCol |
1061 | ** is the column index supplied by the user. |
1062 | */ |
1063 | assert( regNew==regNewRowid+1 ); |
1064 | #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
1065 | sqlite3VdbeAddOp3(v, OP_Delete, iDataCur, |
1066 | OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP), |
1067 | regNewRowid |
1068 | ); |
1069 | if( eOnePass==ONEPASS_MULTI ){ |
1070 | assert( hasFK==0 && chngKey==0 ); |
1071 | sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); |
1072 | } |
1073 | if( !pParse->nested ){ |
1074 | sqlite3VdbeAppendP4(v, pTab, P4_TABLE); |
1075 | } |
1076 | #else |
1077 | if( hasFK>1 || chngKey ){ |
1078 | sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0); |
1079 | } |
1080 | #endif |
1081 | |
1082 | if( hasFK ){ |
1083 | sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey); |
1084 | } |
1085 | |
1086 | /* Insert the new index entries and the new record. */ |
1087 | sqlite3CompleteInsertion( |
1088 | pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx, |
1089 | OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0), |
1090 | 0, 0 |
1091 | ); |
1092 | |
1093 | /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to |
1094 | ** handle rows (possibly in other tables) that refer via a foreign key |
1095 | ** to the row just updated. */ |
1096 | if( hasFK ){ |
1097 | sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey); |
1098 | } |
1099 | } |
1100 | |
1101 | /* Increment the row counter |
1102 | */ |
1103 | if( regRowCount ){ |
1104 | sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); |
1105 | } |
1106 | |
1107 | sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, |
1108 | TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue); |
1109 | |
1110 | /* Repeat the above with the next record to be updated, until |
1111 | ** all record selected by the WHERE clause have been updated. |
1112 | */ |
1113 | if( eOnePass==ONEPASS_SINGLE ){ |
1114 | /* Nothing to do at end-of-loop for a single-pass */ |
1115 | }else if( eOnePass==ONEPASS_MULTI ){ |
1116 | sqlite3VdbeResolveLabel(v, labelContinue); |
1117 | sqlite3WhereEnd(pWInfo); |
1118 | }else{ |
1119 | sqlite3VdbeResolveLabel(v, labelContinue); |
1120 | sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); |
1121 | } |
1122 | sqlite3VdbeResolveLabel(v, labelBreak); |
1123 | |
1124 | /* Update the sqlite_sequence table by storing the content of the |
1125 | ** maximum rowid counter values recorded while inserting into |
1126 | ** autoincrement tables. |
1127 | */ |
1128 | if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){ |
1129 | sqlite3AutoincrementEnd(pParse); |
1130 | } |
1131 | |
1132 | /* |
1133 | ** Return the number of rows that were changed, if we are tracking |
1134 | ** that information. |
1135 | */ |
1136 | if( regRowCount ){ |
1137 | sqlite3CodeChangeCount(v, regRowCount, "rows updated" ); |
1138 | } |
1139 | |
1140 | update_cleanup: |
1141 | sqlite3AuthContextPop(&sContext); |
1142 | sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ |
1143 | sqlite3SrcListDelete(db, pTabList); |
1144 | sqlite3ExprListDelete(db, pChanges); |
1145 | sqlite3ExprDelete(db, pWhere); |
1146 | #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) |
1147 | sqlite3ExprListDelete(db, pOrderBy); |
1148 | sqlite3ExprDelete(db, pLimit); |
1149 | #endif |
1150 | return; |
1151 | } |
1152 | /* Make sure "isView" and other macros defined above are undefined. Otherwise |
1153 | ** they may interfere with compilation of other functions in this file |
1154 | ** (or in another file, if this file becomes part of the amalgamation). */ |
1155 | #ifdef isView |
1156 | #undef isView |
1157 | #endif |
1158 | #ifdef pTrigger |
1159 | #undef pTrigger |
1160 | #endif |
1161 | |
1162 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
1163 | /* |
1164 | ** Generate code for an UPDATE of a virtual table. |
1165 | ** |
1166 | ** There are two possible strategies - the default and the special |
1167 | ** "onepass" strategy. Onepass is only used if the virtual table |
1168 | ** implementation indicates that pWhere may match at most one row. |
1169 | ** |
1170 | ** The default strategy is to create an ephemeral table that contains |
1171 | ** for each row to be changed: |
1172 | ** |
1173 | ** (A) The original rowid of that row. |
1174 | ** (B) The revised rowid for the row. |
1175 | ** (C) The content of every column in the row. |
1176 | ** |
1177 | ** Then loop through the contents of this ephemeral table executing a |
1178 | ** VUpdate for each row. When finished, drop the ephemeral table. |
1179 | ** |
1180 | ** The "onepass" strategy does not use an ephemeral table. Instead, it |
1181 | ** stores the same values (A, B and C above) in a register array and |
1182 | ** makes a single invocation of VUpdate. |
1183 | */ |
1184 | static void updateVirtualTable( |
1185 | Parse *pParse, /* The parsing context */ |
1186 | SrcList *pSrc, /* The virtual table to be modified */ |
1187 | Table *pTab, /* The virtual table */ |
1188 | ExprList *pChanges, /* The columns to change in the UPDATE statement */ |
1189 | Expr *pRowid, /* Expression used to recompute the rowid */ |
1190 | int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ |
1191 | Expr *pWhere, /* WHERE clause of the UPDATE statement */ |
1192 | int onError /* ON CONFLICT strategy */ |
1193 | ){ |
1194 | Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ |
1195 | int ephemTab; /* Table holding the result of the SELECT */ |
1196 | int i; /* Loop counter */ |
1197 | sqlite3 *db = pParse->db; /* Database connection */ |
1198 | const char *pVTab = (const char*)sqlite3GetVTable(db, pTab); |
1199 | WhereInfo *pWInfo = 0; |
1200 | int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */ |
1201 | int regArg; /* First register in VUpdate arg array */ |
1202 | int regRec; /* Register in which to assemble record */ |
1203 | int regRowid; /* Register for ephem table rowid */ |
1204 | int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */ |
1205 | int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */ |
1206 | int eOnePass; /* True to use onepass strategy */ |
1207 | int addr; /* Address of OP_OpenEphemeral */ |
1208 | |
1209 | /* Allocate nArg registers in which to gather the arguments for VUpdate. Then |
1210 | ** create and open the ephemeral table in which the records created from |
1211 | ** these arguments will be temporarily stored. */ |
1212 | assert( v ); |
1213 | ephemTab = pParse->nTab++; |
1214 | addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); |
1215 | regArg = pParse->nMem + 1; |
1216 | pParse->nMem += nArg; |
1217 | if( pSrc->nSrc>1 ){ |
1218 | Index *pPk = 0; |
1219 | Expr *pRow; |
1220 | ExprList *pList; |
1221 | if( HasRowid(pTab) ){ |
1222 | if( pRowid ){ |
1223 | pRow = sqlite3ExprDup(db, pRowid, 0); |
1224 | }else{ |
1225 | pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0); |
1226 | } |
1227 | }else{ |
1228 | i16 iPk; /* PRIMARY KEY column */ |
1229 | pPk = sqlite3PrimaryKeyIndex(pTab); |
1230 | assert( pPk!=0 ); |
1231 | assert( pPk->nKeyCol==1 ); |
1232 | iPk = pPk->aiColumn[0]; |
1233 | if( aXRef[iPk]>=0 ){ |
1234 | pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0); |
1235 | }else{ |
1236 | pRow = exprRowColumn(pParse, iPk); |
1237 | } |
1238 | } |
1239 | pList = sqlite3ExprListAppend(pParse, 0, pRow); |
1240 | |
1241 | for(i=0; i<pTab->nCol; i++){ |
1242 | if( aXRef[i]>=0 ){ |
1243 | pList = sqlite3ExprListAppend(pParse, pList, |
1244 | sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0) |
1245 | ); |
1246 | }else{ |
1247 | pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); |
1248 | } |
1249 | } |
1250 | |
1251 | updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0); |
1252 | sqlite3ExprListDelete(db, pList); |
1253 | eOnePass = ONEPASS_OFF; |
1254 | }else{ |
1255 | regRec = ++pParse->nMem; |
1256 | regRowid = ++pParse->nMem; |
1257 | |
1258 | /* Start scanning the virtual table */ |
1259 | pWInfo = sqlite3WhereBegin( |
1260 | pParse, pSrc, pWhere, 0, 0, 0, WHERE_ONEPASS_DESIRED, 0 |
1261 | ); |
1262 | if( pWInfo==0 ) return; |
1263 | |
1264 | /* Populate the argument registers. */ |
1265 | for(i=0; i<pTab->nCol; i++){ |
1266 | assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ); |
1267 | if( aXRef[i]>=0 ){ |
1268 | sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i); |
1269 | }else{ |
1270 | sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i); |
1271 | sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */ |
1272 | } |
1273 | } |
1274 | if( HasRowid(pTab) ){ |
1275 | sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg); |
1276 | if( pRowid ){ |
1277 | sqlite3ExprCode(pParse, pRowid, regArg+1); |
1278 | }else{ |
1279 | sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1); |
1280 | } |
1281 | }else{ |
1282 | Index *pPk; /* PRIMARY KEY index */ |
1283 | i16 iPk; /* PRIMARY KEY column */ |
1284 | pPk = sqlite3PrimaryKeyIndex(pTab); |
1285 | assert( pPk!=0 ); |
1286 | assert( pPk->nKeyCol==1 ); |
1287 | iPk = pPk->aiColumn[0]; |
1288 | sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg); |
1289 | sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1); |
1290 | } |
1291 | |
1292 | eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy); |
1293 | |
1294 | /* There is no ONEPASS_MULTI on virtual tables */ |
1295 | assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); |
1296 | |
1297 | if( eOnePass ){ |
1298 | /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded |
1299 | ** above. */ |
1300 | sqlite3VdbeChangeToNoop(v, addr); |
1301 | sqlite3VdbeAddOp1(v, OP_Close, iCsr); |
1302 | }else{ |
1303 | /* Create a record from the argument register contents and insert it into |
1304 | ** the ephemeral table. */ |
1305 | sqlite3MultiWrite(pParse); |
1306 | sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec); |
1307 | #if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM) |
1308 | /* Signal an assert() within OP_MakeRecord that it is allowed to |
1309 | ** accept no-change records with serial_type 10 */ |
1310 | sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC); |
1311 | #endif |
1312 | sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid); |
1313 | sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid); |
1314 | } |
1315 | } |
1316 | |
1317 | |
1318 | if( eOnePass==ONEPASS_OFF ){ |
1319 | /* End the virtual table scan */ |
1320 | if( pSrc->nSrc==1 ){ |
1321 | sqlite3WhereEnd(pWInfo); |
1322 | } |
1323 | |
1324 | /* Begin scannning through the ephemeral table. */ |
1325 | addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v); |
1326 | |
1327 | /* Extract arguments from the current row of the ephemeral table and |
1328 | ** invoke the VUpdate method. */ |
1329 | for(i=0; i<nArg; i++){ |
1330 | sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i); |
1331 | } |
1332 | } |
1333 | sqlite3VtabMakeWritable(pParse, pTab); |
1334 | sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB); |
1335 | sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError); |
1336 | sqlite3MayAbort(pParse); |
1337 | |
1338 | /* End of the ephemeral table scan. Or, if using the onepass strategy, |
1339 | ** jump to here if the scan visited zero rows. */ |
1340 | if( eOnePass==ONEPASS_OFF ){ |
1341 | sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v); |
1342 | sqlite3VdbeJumpHere(v, addr); |
1343 | sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0); |
1344 | }else{ |
1345 | sqlite3WhereEnd(pWInfo); |
1346 | } |
1347 | } |
1348 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
1349 | |