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 INSERT statements in SQLite.
14*/
15#include "sqliteInt.h"
16
17/*
18** Generate code that will
19**
20** (1) acquire a lock for table pTab then
21** (2) open pTab as cursor iCur.
22**
23** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
24** for that table that is actually opened.
25*/
26void sqlite3OpenTable(
27 Parse *pParse, /* Generate code into this VDBE */
28 int iCur, /* The cursor number of the table */
29 int iDb, /* The database index in sqlite3.aDb[] */
30 Table *pTab, /* The table to be opened */
31 int opcode /* OP_OpenRead or OP_OpenWrite */
32){
33 Vdbe *v;
34 assert( !IsVirtual(pTab) );
35 assert( pParse->pVdbe!=0 );
36 v = pParse->pVdbe;
37 assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
38 sqlite3TableLock(pParse, iDb, pTab->tnum,
39 (opcode==OP_OpenWrite)?1:0, pTab->zName);
40 if( HasRowid(pTab) ){
41 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
42 VdbeComment((v, "%s", pTab->zName));
43 }else{
44 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
45 assert( pPk!=0 );
46 assert( pPk->tnum==pTab->tnum || CORRUPT_DB );
47 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
48 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
49 VdbeComment((v, "%s", pTab->zName));
50 }
51}
52
53/*
54** Return a pointer to the column affinity string associated with index
55** pIdx. A column affinity string has one character for each column in
56** the table, according to the affinity of the column:
57**
58** Character Column affinity
59** ------------------------------
60** 'A' BLOB
61** 'B' TEXT
62** 'C' NUMERIC
63** 'D' INTEGER
64** 'F' REAL
65**
66** An extra 'D' is appended to the end of the string to cover the
67** rowid that appears as the last column in every index.
68**
69** Memory for the buffer containing the column index affinity string
70** is managed along with the rest of the Index structure. It will be
71** released when sqlite3DeleteIndex() is called.
72*/
73const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
74 if( !pIdx->zColAff ){
75 /* The first time a column affinity string for a particular index is
76 ** required, it is allocated and populated here. It is then stored as
77 ** a member of the Index structure for subsequent use.
78 **
79 ** The column affinity string will eventually be deleted by
80 ** sqliteDeleteIndex() when the Index structure itself is cleaned
81 ** up.
82 */
83 int n;
84 Table *pTab = pIdx->pTable;
85 pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
86 if( !pIdx->zColAff ){
87 sqlite3OomFault(db);
88 return 0;
89 }
90 for(n=0; n<pIdx->nColumn; n++){
91 i16 x = pIdx->aiColumn[n];
92 char aff;
93 if( x>=0 ){
94 aff = pTab->aCol[x].affinity;
95 }else if( x==XN_ROWID ){
96 aff = SQLITE_AFF_INTEGER;
97 }else{
98 assert( x==XN_EXPR );
99 assert( pIdx->bHasExpr );
100 assert( pIdx->aColExpr!=0 );
101 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
102 }
103 if( aff<SQLITE_AFF_BLOB ) aff = SQLITE_AFF_BLOB;
104 if( aff>SQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC;
105 pIdx->zColAff[n] = aff;
106 }
107 pIdx->zColAff[n] = 0;
108 }
109
110 return pIdx->zColAff;
111}
112
113/*
114** Compute an affinity string for a table. Space is obtained
115** from sqlite3DbMalloc(). The caller is responsible for freeing
116** the space when done.
117*/
118char *sqlite3TableAffinityStr(sqlite3 *db, const Table *pTab){
119 char *zColAff;
120 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
121 if( zColAff ){
122 int i, j;
123 for(i=j=0; i<pTab->nCol; i++){
124 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
125 zColAff[j++] = pTab->aCol[i].affinity;
126 }
127 }
128 do{
129 zColAff[j--] = 0;
130 }while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB );
131 }
132 return zColAff;
133}
134
135/*
136** Make changes to the evolving bytecode to do affinity transformations
137** of values that are about to be gathered into a row for table pTab.
138**
139** For ordinary (legacy, non-strict) tables:
140** -----------------------------------------
141**
142** Compute the affinity string for table pTab, if it has not already been
143** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities.
144**
145** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries
146** which were then optimized out) then this routine becomes a no-op.
147**
148** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the
149** affinities for register iReg and following. Or if iReg==0,
150** then just set the P4 operand of the previous opcode (which should be
151** an OP_MakeRecord) to the affinity string.
152**
153** A column affinity string has one character per column:
154**
155** Character Column affinity
156** --------- ---------------
157** 'A' BLOB
158** 'B' TEXT
159** 'C' NUMERIC
160** 'D' INTEGER
161** 'E' REAL
162**
163** For STRICT tables:
164** ------------------
165**
166** Generate an appropropriate OP_TypeCheck opcode that will verify the
167** datatypes against the column definitions in pTab. If iReg==0, that
168** means an OP_MakeRecord opcode has already been generated and should be
169** the last opcode generated. The new OP_TypeCheck needs to be inserted
170** before the OP_MakeRecord. The new OP_TypeCheck should use the same
171** register set as the OP_MakeRecord. If iReg>0 then register iReg is
172** the first of a series of registers that will form the new record.
173** Apply the type checking to that array of registers.
174*/
175void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
176 int i;
177 char *zColAff;
178 if( pTab->tabFlags & TF_Strict ){
179 if( iReg==0 ){
180 /* Move the previous opcode (which should be OP_MakeRecord) forward
181 ** by one slot and insert a new OP_TypeCheck where the current
182 ** OP_MakeRecord is found */
183 VdbeOp *pPrev;
184 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
185 pPrev = sqlite3VdbeGetLastOp(v);
186 assert( pPrev!=0 );
187 assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );
188 pPrev->opcode = OP_TypeCheck;
189 sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3);
190 }else{
191 /* Insert an isolated OP_Typecheck */
192 sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
193 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
194 }
195 return;
196 }
197 zColAff = pTab->zColAff;
198 if( zColAff==0 ){
199 zColAff = sqlite3TableAffinityStr(0, pTab);
200 if( !zColAff ){
201 sqlite3OomFault(sqlite3VdbeDb(v));
202 return;
203 }
204 pTab->zColAff = zColAff;
205 }
206 assert( zColAff!=0 );
207 i = sqlite3Strlen30NN(zColAff);
208 if( i ){
209 if( iReg ){
210 sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
211 }else{
212 assert( sqlite3VdbeGetLastOp(v)->opcode==OP_MakeRecord
213 || sqlite3VdbeDb(v)->mallocFailed );
214 sqlite3VdbeChangeP4(v, -1, zColAff, i);
215 }
216 }
217}
218
219/*
220** Return non-zero if the table pTab in database iDb or any of its indices
221** have been opened at any point in the VDBE program. This is used to see if
222** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
223** run without using a temporary table for the results of the SELECT.
224*/
225static int readsTable(Parse *p, int iDb, Table *pTab){
226 Vdbe *v = sqlite3GetVdbe(p);
227 int i;
228 int iEnd = sqlite3VdbeCurrentAddr(v);
229#ifndef SQLITE_OMIT_VIRTUALTABLE
230 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
231#endif
232
233 for(i=1; i<iEnd; i++){
234 VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
235 assert( pOp!=0 );
236 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
237 Index *pIndex;
238 Pgno tnum = pOp->p2;
239 if( tnum==pTab->tnum ){
240 return 1;
241 }
242 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
243 if( tnum==pIndex->tnum ){
244 return 1;
245 }
246 }
247 }
248#ifndef SQLITE_OMIT_VIRTUALTABLE
249 if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
250 assert( pOp->p4.pVtab!=0 );
251 assert( pOp->p4type==P4_VTAB );
252 return 1;
253 }
254#endif
255 }
256 return 0;
257}
258
259/* This walker callback will compute the union of colFlags flags for all
260** referenced columns in a CHECK constraint or generated column expression.
261*/
262static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
263 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
264 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
265 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
266 }
267 return WRC_Continue;
268}
269
270#ifndef SQLITE_OMIT_GENERATED_COLUMNS
271/*
272** All regular columns for table pTab have been puts into registers
273** starting with iRegStore. The registers that correspond to STORED
274** or VIRTUAL columns have not yet been initialized. This routine goes
275** back and computes the values for those columns based on the previously
276** computed normal columns.
277*/
278void sqlite3ComputeGeneratedColumns(
279 Parse *pParse, /* Parsing context */
280 int iRegStore, /* Register holding the first column */
281 Table *pTab /* The table */
282){
283 int i;
284 Walker w;
285 Column *pRedo;
286 int eProgress;
287 VdbeOp *pOp;
288
289 assert( pTab->tabFlags & TF_HasGenerated );
290 testcase( pTab->tabFlags & TF_HasVirtual );
291 testcase( pTab->tabFlags & TF_HasStored );
292
293 /* Before computing generated columns, first go through and make sure
294 ** that appropriate affinity has been applied to the regular columns
295 */
296 sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
297 if( (pTab->tabFlags & TF_HasStored)!=0 ){
298 pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
299 if( pOp->opcode==OP_Affinity ){
300 /* Change the OP_Affinity argument to '@' (NONE) for all stored
301 ** columns. '@' is the no-op affinity and those columns have not
302 ** yet been computed. */
303 int ii, jj;
304 char *zP4 = pOp->p4.z;
305 assert( zP4!=0 );
306 assert( pOp->p4type==P4_DYNAMIC );
307 for(ii=jj=0; zP4[jj]; ii++){
308 if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
309 continue;
310 }
311 if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
312 zP4[jj] = SQLITE_AFF_NONE;
313 }
314 jj++;
315 }
316 }else if( pOp->opcode==OP_TypeCheck ){
317 /* If an OP_TypeCheck was generated because the table is STRICT,
318 ** then set the P3 operand to indicate that generated columns should
319 ** not be checked */
320 pOp->p3 = 1;
321 }
322 }
323
324 /* Because there can be multiple generated columns that refer to one another,
325 ** this is a two-pass algorithm. On the first pass, mark all generated
326 ** columns as "not available".
327 */
328 for(i=0; i<pTab->nCol; i++){
329 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
330 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
331 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
332 pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL;
333 }
334 }
335
336 w.u.pTab = pTab;
337 w.xExprCallback = exprColumnFlagUnion;
338 w.xSelectCallback = 0;
339 w.xSelectCallback2 = 0;
340
341 /* On the second pass, compute the value of each NOT-AVAILABLE column.
342 ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will
343 ** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as
344 ** they are needed.
345 */
346 pParse->iSelfTab = -iRegStore;
347 do{
348 eProgress = 0;
349 pRedo = 0;
350 for(i=0; i<pTab->nCol; i++){
351 Column *pCol = pTab->aCol + i;
352 if( (pCol->colFlags & COLFLAG_NOTAVAIL)!=0 ){
353 int x;
354 pCol->colFlags |= COLFLAG_BUSY;
355 w.eCode = 0;
356 sqlite3WalkExpr(&w, sqlite3ColumnExpr(pTab, pCol));
357 pCol->colFlags &= ~COLFLAG_BUSY;
358 if( w.eCode & COLFLAG_NOTAVAIL ){
359 pRedo = pCol;
360 continue;
361 }
362 eProgress = 1;
363 assert( pCol->colFlags & COLFLAG_GENERATED );
364 x = sqlite3TableColumnToStorage(pTab, i) + iRegStore;
365 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x);
366 pCol->colFlags &= ~COLFLAG_NOTAVAIL;
367 }
368 }
369 }while( pRedo && eProgress );
370 if( pRedo ){
371 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName);
372 }
373 pParse->iSelfTab = 0;
374}
375#endif /* SQLITE_OMIT_GENERATED_COLUMNS */
376
377
378#ifndef SQLITE_OMIT_AUTOINCREMENT
379/*
380** Locate or create an AutoincInfo structure associated with table pTab
381** which is in database iDb. Return the register number for the register
382** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT
383** table. (Also return zero when doing a VACUUM since we do not want to
384** update the AUTOINCREMENT counters during a VACUUM.)
385**
386** There is at most one AutoincInfo structure per table even if the
387** same table is autoincremented multiple times due to inserts within
388** triggers. A new AutoincInfo structure is created if this is the
389** first use of table pTab. On 2nd and subsequent uses, the original
390** AutoincInfo structure is used.
391**
392** Four consecutive registers are allocated:
393**
394** (1) The name of the pTab table.
395** (2) The maximum ROWID of pTab.
396** (3) The rowid in sqlite_sequence of pTab
397** (4) The original value of the max ROWID in pTab, or NULL if none
398**
399** The 2nd register is the one that is returned. That is all the
400** insert routine needs to know about.
401*/
402static int autoIncBegin(
403 Parse *pParse, /* Parsing context */
404 int iDb, /* Index of the database holding pTab */
405 Table *pTab /* The table we are writing to */
406){
407 int memId = 0; /* Register holding maximum rowid */
408 assert( pParse->db->aDb[iDb].pSchema!=0 );
409 if( (pTab->tabFlags & TF_Autoincrement)!=0
410 && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
411 ){
412 Parse *pToplevel = sqlite3ParseToplevel(pParse);
413 AutoincInfo *pInfo;
414 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
415
416 /* Verify that the sqlite_sequence table exists and is an ordinary
417 ** rowid table with exactly two columns.
418 ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
419 if( pSeqTab==0
420 || !HasRowid(pSeqTab)
421 || NEVER(IsVirtual(pSeqTab))
422 || pSeqTab->nCol!=2
423 ){
424 pParse->nErr++;
425 pParse->rc = SQLITE_CORRUPT_SEQUENCE;
426 return 0;
427 }
428
429 pInfo = pToplevel->pAinc;
430 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
431 if( pInfo==0 ){
432 pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
433 sqlite3ParserAddCleanup(pToplevel, sqlite3DbFree, pInfo);
434 testcase( pParse->earlyCleanup );
435 if( pParse->db->mallocFailed ) return 0;
436 pInfo->pNext = pToplevel->pAinc;
437 pToplevel->pAinc = pInfo;
438 pInfo->pTab = pTab;
439 pInfo->iDb = iDb;
440 pToplevel->nMem++; /* Register to hold name of table */
441 pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */
442 pToplevel->nMem +=2; /* Rowid in sqlite_sequence + orig max val */
443 }
444 memId = pInfo->regCtr;
445 }
446 return memId;
447}
448
449/*
450** This routine generates code that will initialize all of the
451** register used by the autoincrement tracker.
452*/
453void sqlite3AutoincrementBegin(Parse *pParse){
454 AutoincInfo *p; /* Information about an AUTOINCREMENT */
455 sqlite3 *db = pParse->db; /* The database connection */
456 Db *pDb; /* Database only autoinc table */
457 int memId; /* Register holding max rowid */
458 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
459
460 /* This routine is never called during trigger-generation. It is
461 ** only called from the top-level */
462 assert( pParse->pTriggerTab==0 );
463 assert( sqlite3IsToplevel(pParse) );
464
465 assert( v ); /* We failed long ago if this is not so */
466 for(p = pParse->pAinc; p; p = p->pNext){
467 static const int iLn = VDBE_OFFSET_LINENO(2);
468 static const VdbeOpList autoInc[] = {
469 /* 0 */ {OP_Null, 0, 0, 0},
470 /* 1 */ {OP_Rewind, 0, 10, 0},
471 /* 2 */ {OP_Column, 0, 0, 0},
472 /* 3 */ {OP_Ne, 0, 9, 0},
473 /* 4 */ {OP_Rowid, 0, 0, 0},
474 /* 5 */ {OP_Column, 0, 1, 0},
475 /* 6 */ {OP_AddImm, 0, 0, 0},
476 /* 7 */ {OP_Copy, 0, 0, 0},
477 /* 8 */ {OP_Goto, 0, 11, 0},
478 /* 9 */ {OP_Next, 0, 2, 0},
479 /* 10 */ {OP_Integer, 0, 0, 0},
480 /* 11 */ {OP_Close, 0, 0, 0}
481 };
482 VdbeOp *aOp;
483 pDb = &db->aDb[p->iDb];
484 memId = p->regCtr;
485 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
486 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
487 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
488 aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
489 if( aOp==0 ) break;
490 aOp[0].p2 = memId;
491 aOp[0].p3 = memId+2;
492 aOp[2].p3 = memId;
493 aOp[3].p1 = memId-1;
494 aOp[3].p3 = memId;
495 aOp[3].p5 = SQLITE_JUMPIFNULL;
496 aOp[4].p2 = memId+1;
497 aOp[5].p3 = memId;
498 aOp[6].p1 = memId;
499 aOp[7].p2 = memId+2;
500 aOp[7].p1 = memId;
501 aOp[10].p2 = memId;
502 if( pParse->nTab==0 ) pParse->nTab = 1;
503 }
504}
505
506/*
507** Update the maximum rowid for an autoincrement calculation.
508**
509** This routine should be called when the regRowid register holds a
510** new rowid that is about to be inserted. If that new rowid is
511** larger than the maximum rowid in the memId memory cell, then the
512** memory cell is updated.
513*/
514static void autoIncStep(Parse *pParse, int memId, int regRowid){
515 if( memId>0 ){
516 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
517 }
518}
519
520/*
521** This routine generates the code needed to write autoincrement
522** maximum rowid values back into the sqlite_sequence register.
523** Every statement that might do an INSERT into an autoincrement
524** table (either directly or through triggers) needs to call this
525** routine just before the "exit" code.
526*/
527static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
528 AutoincInfo *p;
529 Vdbe *v = pParse->pVdbe;
530 sqlite3 *db = pParse->db;
531
532 assert( v );
533 for(p = pParse->pAinc; p; p = p->pNext){
534 static const int iLn = VDBE_OFFSET_LINENO(2);
535 static const VdbeOpList autoIncEnd[] = {
536 /* 0 */ {OP_NotNull, 0, 2, 0},
537 /* 1 */ {OP_NewRowid, 0, 0, 0},
538 /* 2 */ {OP_MakeRecord, 0, 2, 0},
539 /* 3 */ {OP_Insert, 0, 0, 0},
540 /* 4 */ {OP_Close, 0, 0, 0}
541 };
542 VdbeOp *aOp;
543 Db *pDb = &db->aDb[p->iDb];
544 int iRec;
545 int memId = p->regCtr;
546
547 iRec = sqlite3GetTempReg(pParse);
548 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
549 sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
550 VdbeCoverage(v);
551 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
552 aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
553 if( aOp==0 ) break;
554 aOp[0].p1 = memId+1;
555 aOp[1].p2 = memId+1;
556 aOp[2].p1 = memId-1;
557 aOp[2].p3 = iRec;
558 aOp[3].p2 = iRec;
559 aOp[3].p3 = memId+1;
560 aOp[3].p5 = OPFLAG_APPEND;
561 sqlite3ReleaseTempReg(pParse, iRec);
562 }
563}
564void sqlite3AutoincrementEnd(Parse *pParse){
565 if( pParse->pAinc ) autoIncrementEnd(pParse);
566}
567#else
568/*
569** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
570** above are all no-ops
571*/
572# define autoIncBegin(A,B,C) (0)
573# define autoIncStep(A,B,C)
574#endif /* SQLITE_OMIT_AUTOINCREMENT */
575
576
577/* Forward declaration */
578static int xferOptimization(
579 Parse *pParse, /* Parser context */
580 Table *pDest, /* The table we are inserting into */
581 Select *pSelect, /* A SELECT statement to use as the data source */
582 int onError, /* How to handle constraint errors */
583 int iDbDest /* The database of pDest */
584);
585
586/*
587** This routine is called to handle SQL of the following forms:
588**
589** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),...
590** insert into TABLE (IDLIST) select
591** insert into TABLE (IDLIST) default values
592**
593** The IDLIST following the table name is always optional. If omitted,
594** then a list of all (non-hidden) columns for the table is substituted.
595** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST
596** is omitted.
597**
598** For the pSelect parameter holds the values to be inserted for the
599** first two forms shown above. A VALUES clause is really just short-hand
600** for a SELECT statement that omits the FROM clause and everything else
601** that follows. If the pSelect parameter is NULL, that means that the
602** DEFAULT VALUES form of the INSERT statement is intended.
603**
604** The code generated follows one of four templates. For a simple
605** insert with data coming from a single-row VALUES clause, the code executes
606** once straight down through. Pseudo-code follows (we call this
607** the "1st template"):
608**
609** open write cursor to <table> and its indices
610** put VALUES clause expressions into registers
611** write the resulting record into <table>
612** cleanup
613**
614** The three remaining templates assume the statement is of the form
615**
616** INSERT INTO <table> SELECT ...
617**
618** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
619** in other words if the SELECT pulls all columns from a single table
620** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
621** if <table2> and <table1> are distinct tables but have identical
622** schemas, including all the same indices, then a special optimization
623** is invoked that copies raw records from <table2> over to <table1>.
624** See the xferOptimization() function for the implementation of this
625** template. This is the 2nd template.
626**
627** open a write cursor to <table>
628** open read cursor on <table2>
629** transfer all records in <table2> over to <table>
630** close cursors
631** foreach index on <table>
632** open a write cursor on the <table> index
633** open a read cursor on the corresponding <table2> index
634** transfer all records from the read to the write cursors
635** close cursors
636** end foreach
637**
638** The 3rd template is for when the second template does not apply
639** and the SELECT clause does not read from <table> at any time.
640** The generated code follows this template:
641**
642** X <- A
643** goto B
644** A: setup for the SELECT
645** loop over the rows in the SELECT
646** load values into registers R..R+n
647** yield X
648** end loop
649** cleanup after the SELECT
650** end-coroutine X
651** B: open write cursor to <table> and its indices
652** C: yield X, at EOF goto D
653** insert the select result into <table> from R..R+n
654** goto C
655** D: cleanup
656**
657** The 4th template is used if the insert statement takes its
658** values from a SELECT but the data is being inserted into a table
659** that is also read as part of the SELECT. In the third form,
660** we have to use an intermediate table to store the results of
661** the select. The template is like this:
662**
663** X <- A
664** goto B
665** A: setup for the SELECT
666** loop over the tables in the SELECT
667** load value into register R..R+n
668** yield X
669** end loop
670** cleanup after the SELECT
671** end co-routine R
672** B: open temp table
673** L: yield X, at EOF goto M
674** insert row from R..R+n into temp table
675** goto L
676** M: open write cursor to <table> and its indices
677** rewind temp table
678** C: loop over rows of intermediate table
679** transfer values form intermediate table into <table>
680** end loop
681** D: cleanup
682*/
683void sqlite3Insert(
684 Parse *pParse, /* Parser context */
685 SrcList *pTabList, /* Name of table into which we are inserting */
686 Select *pSelect, /* A SELECT statement to use as the data source */
687 IdList *pColumn, /* Column names corresponding to IDLIST, or NULL. */
688 int onError, /* How to handle constraint errors */
689 Upsert *pUpsert /* ON CONFLICT clauses for upsert, or NULL */
690){
691 sqlite3 *db; /* The main database structure */
692 Table *pTab; /* The table to insert into. aka TABLE */
693 int i, j; /* Loop counters */
694 Vdbe *v; /* Generate code into this virtual machine */
695 Index *pIdx; /* For looping over indices of the table */
696 int nColumn; /* Number of columns in the data */
697 int nHidden = 0; /* Number of hidden columns if TABLE is virtual */
698 int iDataCur = 0; /* VDBE cursor that is the main data repository */
699 int iIdxCur = 0; /* First index cursor */
700 int ipkColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
701 int endOfLoop; /* Label for the end of the insertion loop */
702 int srcTab = 0; /* Data comes from this temporary cursor if >=0 */
703 int addrInsTop = 0; /* Jump to label "D" */
704 int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */
705 SelectDest dest; /* Destination for SELECT on rhs of INSERT */
706 int iDb; /* Index of database holding TABLE */
707 u8 useTempTable = 0; /* Store SELECT results in intermediate table */
708 u8 appendFlag = 0; /* True if the insert is likely to be an append */
709 u8 withoutRowid; /* 0 for normal table. 1 for WITHOUT ROWID table */
710 u8 bIdListInOrder; /* True if IDLIST is in table order */
711 ExprList *pList = 0; /* List of VALUES() to be inserted */
712 int iRegStore; /* Register in which to store next column */
713
714 /* Register allocations */
715 int regFromSelect = 0;/* Base register for data coming from SELECT */
716 int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */
717 int regRowCount = 0; /* Memory cell used for the row counter */
718 int regIns; /* Block of regs holding rowid+data being inserted */
719 int regRowid; /* registers holding insert rowid */
720 int regData; /* register holding first column to insert */
721 int *aRegIdx = 0; /* One register allocated to each index */
722
723#ifndef SQLITE_OMIT_TRIGGER
724 int isView; /* True if attempting to insert into a view */
725 Trigger *pTrigger; /* List of triggers on pTab, if required */
726 int tmask; /* Mask of trigger times */
727#endif
728
729 db = pParse->db;
730 assert( db->pParse==pParse );
731 if( pParse->nErr ){
732 goto insert_cleanup;
733 }
734 assert( db->mallocFailed==0 );
735 dest.iSDParm = 0; /* Suppress a harmless compiler warning */
736
737 /* If the Select object is really just a simple VALUES() list with a
738 ** single row (the common case) then keep that one row of values
739 ** and discard the other (unused) parts of the pSelect object
740 */
741 if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
742 pList = pSelect->pEList;
743 pSelect->pEList = 0;
744 sqlite3SelectDelete(db, pSelect);
745 pSelect = 0;
746 }
747
748 /* Locate the table into which we will be inserting new information.
749 */
750 assert( pTabList->nSrc==1 );
751 pTab = sqlite3SrcListLookup(pParse, pTabList);
752 if( pTab==0 ){
753 goto insert_cleanup;
754 }
755 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
756 assert( iDb<db->nDb );
757 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
758 db->aDb[iDb].zDbSName) ){
759 goto insert_cleanup;
760 }
761 withoutRowid = !HasRowid(pTab);
762
763 /* Figure out if we have any triggers and if the table being
764 ** inserted into is a view
765 */
766#ifndef SQLITE_OMIT_TRIGGER
767 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
768 isView = IsView(pTab);
769#else
770# define pTrigger 0
771# define tmask 0
772# define isView 0
773#endif
774#ifdef SQLITE_OMIT_VIEW
775# undef isView
776# define isView 0
777#endif
778 assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
779
780#if TREETRACE_ENABLED
781 if( sqlite3TreeTrace & 0x10000 ){
782 sqlite3TreeViewLine(0, "In sqlite3Insert() at %s:%d", __FILE__, __LINE__);
783 sqlite3TreeViewInsert(pParse->pWith, pTabList, pColumn, pSelect, pList,
784 onError, pUpsert, pTrigger);
785 }
786#endif
787
788 /* If pTab is really a view, make sure it has been initialized.
789 ** ViewGetColumnNames() is a no-op if pTab is not a view.
790 */
791 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
792 goto insert_cleanup;
793 }
794
795 /* Cannot insert into a read-only table.
796 */
797 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
798 goto insert_cleanup;
799 }
800
801 /* Allocate a VDBE
802 */
803 v = sqlite3GetVdbe(pParse);
804 if( v==0 ) goto insert_cleanup;
805 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
806 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
807
808#ifndef SQLITE_OMIT_XFER_OPT
809 /* If the statement is of the form
810 **
811 ** INSERT INTO <table1> SELECT * FROM <table2>;
812 **
813 ** Then special optimizations can be applied that make the transfer
814 ** very fast and which reduce fragmentation of indices.
815 **
816 ** This is the 2nd template.
817 */
818 if( pColumn==0
819 && pSelect!=0
820 && pTrigger==0
821 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
822 ){
823 assert( !pTrigger );
824 assert( pList==0 );
825 goto insert_end;
826 }
827#endif /* SQLITE_OMIT_XFER_OPT */
828
829 /* If this is an AUTOINCREMENT table, look up the sequence number in the
830 ** sqlite_sequence table and store it in memory cell regAutoinc.
831 */
832 regAutoinc = autoIncBegin(pParse, iDb, pTab);
833
834 /* Allocate a block registers to hold the rowid and the values
835 ** for all columns of the new row.
836 */
837 regRowid = regIns = pParse->nMem+1;
838 pParse->nMem += pTab->nCol + 1;
839 if( IsVirtual(pTab) ){
840 regRowid++;
841 pParse->nMem++;
842 }
843 regData = regRowid+1;
844
845 /* If the INSERT statement included an IDLIST term, then make sure
846 ** all elements of the IDLIST really are columns of the table and
847 ** remember the column indices.
848 **
849 ** If the table has an INTEGER PRIMARY KEY column and that column
850 ** is named in the IDLIST, then record in the ipkColumn variable
851 ** the index into IDLIST of the primary key column. ipkColumn is
852 ** the index of the primary key as it appears in IDLIST, not as
853 ** is appears in the original table. (The index of the INTEGER
854 ** PRIMARY KEY in the original table is pTab->iPKey.) After this
855 ** loop, if ipkColumn==(-1), that means that integer primary key
856 ** is unspecified, and hence the table is either WITHOUT ROWID or
857 ** it will automatically generated an integer primary key.
858 **
859 ** bIdListInOrder is true if the columns in IDLIST are in storage
860 ** order. This enables an optimization that avoids shuffling the
861 ** columns into storage order. False negatives are harmless,
862 ** but false positives will cause database corruption.
863 */
864 bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0;
865 if( pColumn ){
866 assert( pColumn->eU4!=EU4_EXPR );
867 pColumn->eU4 = EU4_IDX;
868 for(i=0; i<pColumn->nId; i++){
869 pColumn->a[i].u4.idx = -1;
870 }
871 for(i=0; i<pColumn->nId; i++){
872 for(j=0; j<pTab->nCol; j++){
873 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
874 pColumn->a[i].u4.idx = j;
875 if( i!=j ) bIdListInOrder = 0;
876 if( j==pTab->iPKey ){
877 ipkColumn = i; assert( !withoutRowid );
878 }
879#ifndef SQLITE_OMIT_GENERATED_COLUMNS
880 if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
881 sqlite3ErrorMsg(pParse,
882 "cannot INSERT into generated column \"%s\"",
883 pTab->aCol[j].zCnName);
884 goto insert_cleanup;
885 }
886#endif
887 break;
888 }
889 }
890 if( j>=pTab->nCol ){
891 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
892 ipkColumn = i;
893 bIdListInOrder = 0;
894 }else{
895 sqlite3ErrorMsg(pParse, "table %S has no column named %s",
896 pTabList->a, pColumn->a[i].zName);
897 pParse->checkSchema = 1;
898 goto insert_cleanup;
899 }
900 }
901 }
902 }
903
904 /* Figure out how many columns of data are supplied. If the data
905 ** is coming from a SELECT statement, then generate a co-routine that
906 ** produces a single row of the SELECT on each invocation. The
907 ** co-routine is the common header to the 3rd and 4th templates.
908 */
909 if( pSelect ){
910 /* Data is coming from a SELECT or from a multi-row VALUES clause.
911 ** Generate a co-routine to run the SELECT. */
912 int regYield; /* Register holding co-routine entry-point */
913 int addrTop; /* Top of the co-routine */
914 int rc; /* Result code */
915
916 regYield = ++pParse->nMem;
917 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
918 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
919 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
920 dest.iSdst = bIdListInOrder ? regData : 0;
921 dest.nSdst = pTab->nCol;
922 rc = sqlite3Select(pParse, pSelect, &dest);
923 regFromSelect = dest.iSdst;
924 assert( db->pParse==pParse );
925 if( rc || pParse->nErr ) goto insert_cleanup;
926 assert( db->mallocFailed==0 );
927 sqlite3VdbeEndCoroutine(v, regYield);
928 sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
929 assert( pSelect->pEList );
930 nColumn = pSelect->pEList->nExpr;
931
932 /* Set useTempTable to TRUE if the result of the SELECT statement
933 ** should be written into a temporary table (template 4). Set to
934 ** FALSE if each output row of the SELECT can be written directly into
935 ** the destination table (template 3).
936 **
937 ** A temp table must be used if the table being updated is also one
938 ** of the tables being read by the SELECT statement. Also use a
939 ** temp table in the case of row triggers.
940 */
941 if( pTrigger || readsTable(pParse, iDb, pTab) ){
942 useTempTable = 1;
943 }
944
945 if( useTempTable ){
946 /* Invoke the coroutine to extract information from the SELECT
947 ** and add it to a transient table srcTab. The code generated
948 ** here is from the 4th template:
949 **
950 ** B: open temp table
951 ** L: yield X, goto M at EOF
952 ** insert row from R..R+n into temp table
953 ** goto L
954 ** M: ...
955 */
956 int regRec; /* Register to hold packed record */
957 int regTempRowid; /* Register to hold temp table ROWID */
958 int addrL; /* Label "L" */
959
960 srcTab = pParse->nTab++;
961 regRec = sqlite3GetTempReg(pParse);
962 regTempRowid = sqlite3GetTempReg(pParse);
963 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
964 addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v);
965 sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
966 sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
967 sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
968 sqlite3VdbeGoto(v, addrL);
969 sqlite3VdbeJumpHere(v, addrL);
970 sqlite3ReleaseTempReg(pParse, regRec);
971 sqlite3ReleaseTempReg(pParse, regTempRowid);
972 }
973 }else{
974 /* This is the case if the data for the INSERT is coming from a
975 ** single-row VALUES clause
976 */
977 NameContext sNC;
978 memset(&sNC, 0, sizeof(sNC));
979 sNC.pParse = pParse;
980 srcTab = -1;
981 assert( useTempTable==0 );
982 if( pList ){
983 nColumn = pList->nExpr;
984 if( sqlite3ResolveExprListNames(&sNC, pList) ){
985 goto insert_cleanup;
986 }
987 }else{
988 nColumn = 0;
989 }
990 }
991
992 /* If there is no IDLIST term but the table has an integer primary
993 ** key, the set the ipkColumn variable to the integer primary key
994 ** column index in the original table definition.
995 */
996 if( pColumn==0 && nColumn>0 ){
997 ipkColumn = pTab->iPKey;
998#ifndef SQLITE_OMIT_GENERATED_COLUMNS
999 if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
1000 testcase( pTab->tabFlags & TF_HasVirtual );
1001 testcase( pTab->tabFlags & TF_HasStored );
1002 for(i=ipkColumn-1; i>=0; i--){
1003 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
1004 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
1005 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
1006 ipkColumn--;
1007 }
1008 }
1009 }
1010#endif
1011
1012 /* Make sure the number of columns in the source data matches the number
1013 ** of columns to be inserted into the table.
1014 */
1015 assert( TF_HasHidden==COLFLAG_HIDDEN );
1016 assert( TF_HasGenerated==COLFLAG_GENERATED );
1017 assert( COLFLAG_NOINSERT==(COLFLAG_GENERATED|COLFLAG_HIDDEN) );
1018 if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){
1019 for(i=0; i<pTab->nCol; i++){
1020 if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
1021 }
1022 }
1023 if( nColumn!=(pTab->nCol-nHidden) ){
1024 sqlite3ErrorMsg(pParse,
1025 "table %S has %d columns but %d values were supplied",
1026 pTabList->a, pTab->nCol-nHidden, nColumn);
1027 goto insert_cleanup;
1028 }
1029 }
1030 if( pColumn!=0 && nColumn!=pColumn->nId ){
1031 sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
1032 goto insert_cleanup;
1033 }
1034
1035 /* Initialize the count of rows to be inserted
1036 */
1037 if( (db->flags & SQLITE_CountRows)!=0
1038 && !pParse->nested
1039 && !pParse->pTriggerTab
1040 && !pParse->bReturning
1041 ){
1042 regRowCount = ++pParse->nMem;
1043 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
1044 }
1045
1046 /* If this is not a view, open the table and and all indices */
1047 if( !isView ){
1048 int nIdx;
1049 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
1050 &iDataCur, &iIdxCur);
1051 aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2));
1052 if( aRegIdx==0 ){
1053 goto insert_cleanup;
1054 }
1055 for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
1056 assert( pIdx );
1057 aRegIdx[i] = ++pParse->nMem;
1058 pParse->nMem += pIdx->nColumn;
1059 }
1060 aRegIdx[i] = ++pParse->nMem; /* Register to store the table record */
1061 }
1062#ifndef SQLITE_OMIT_UPSERT
1063 if( pUpsert ){
1064 Upsert *pNx;
1065 if( IsVirtual(pTab) ){
1066 sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
1067 pTab->zName);
1068 goto insert_cleanup;
1069 }
1070 if( IsView(pTab) ){
1071 sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
1072 goto insert_cleanup;
1073 }
1074 if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
1075 goto insert_cleanup;
1076 }
1077 pTabList->a[0].iCursor = iDataCur;
1078 pNx = pUpsert;
1079 do{
1080 pNx->pUpsertSrc = pTabList;
1081 pNx->regData = regData;
1082 pNx->iDataCur = iDataCur;
1083 pNx->iIdxCur = iIdxCur;
1084 if( pNx->pUpsertTarget ){
1085 if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx) ){
1086 goto insert_cleanup;
1087 }
1088 }
1089 pNx = pNx->pNextUpsert;
1090 }while( pNx!=0 );
1091 }
1092#endif
1093
1094
1095 /* This is the top of the main insertion loop */
1096 if( useTempTable ){
1097 /* This block codes the top of loop only. The complete loop is the
1098 ** following pseudocode (template 4):
1099 **
1100 ** rewind temp table, if empty goto D
1101 ** C: loop over rows of intermediate table
1102 ** transfer values form intermediate table into <table>
1103 ** end loop
1104 ** D: ...
1105 */
1106 addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v);
1107 addrCont = sqlite3VdbeCurrentAddr(v);
1108 }else if( pSelect ){
1109 /* This block codes the top of loop only. The complete loop is the
1110 ** following pseudocode (template 3):
1111 **
1112 ** C: yield X, at EOF goto D
1113 ** insert the select result into <table> from R..R+n
1114 ** goto C
1115 ** D: ...
1116 */
1117 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
1118 addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
1119 VdbeCoverage(v);
1120 if( ipkColumn>=0 ){
1121 /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
1122 ** SELECT, go ahead and copy the value into the rowid slot now, so that
1123 ** the value does not get overwritten by a NULL at tag-20191021-002. */
1124 sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);
1125 }
1126 }
1127
1128 /* Compute data for ordinary columns of the new entry. Values
1129 ** are written in storage order into registers starting with regData.
1130 ** Only ordinary columns are computed in this loop. The rowid
1131 ** (if there is one) is computed later and generated columns are
1132 ** computed after the rowid since they might depend on the value
1133 ** of the rowid.
1134 */
1135 nHidden = 0;
1136 iRegStore = regData; assert( regData==regRowid+1 );
1137 for(i=0; i<pTab->nCol; i++, iRegStore++){
1138 int k;
1139 u32 colFlags;
1140 assert( i>=nHidden );
1141 if( i==pTab->iPKey ){
1142 /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
1143 ** using the rowid. So put a NULL in the IPK slot of the record to avoid
1144 ** using excess space. The file format definition requires this extra
1145 ** NULL - we cannot optimize further by skipping the column completely */
1146 sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
1147 continue;
1148 }
1149 if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){
1150 nHidden++;
1151 if( (colFlags & COLFLAG_VIRTUAL)!=0 ){
1152 /* Virtual columns do not participate in OP_MakeRecord. So back up
1153 ** iRegStore by one slot to compensate for the iRegStore++ in the
1154 ** outer for() loop */
1155 iRegStore--;
1156 continue;
1157 }else if( (colFlags & COLFLAG_STORED)!=0 ){
1158 /* Stored columns are computed later. But if there are BEFORE
1159 ** triggers, the slots used for stored columns will be OP_Copy-ed
1160 ** to a second block of registers, so the register needs to be
1161 ** initialized to NULL to avoid an uninitialized register read */
1162 if( tmask & TRIGGER_BEFORE ){
1163 sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
1164 }
1165 continue;
1166 }else if( pColumn==0 ){
1167 /* Hidden columns that are not explicitly named in the INSERT
1168 ** get there default value */
1169 sqlite3ExprCodeFactorable(pParse,
1170 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
1171 iRegStore);
1172 continue;
1173 }
1174 }
1175 if( pColumn ){
1176 assert( pColumn->eU4==EU4_IDX );
1177 for(j=0; j<pColumn->nId && pColumn->a[j].u4.idx!=i; j++){}
1178 if( j>=pColumn->nId ){
1179 /* A column not named in the insert column list gets its
1180 ** default value */
1181 sqlite3ExprCodeFactorable(pParse,
1182 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
1183 iRegStore);
1184 continue;
1185 }
1186 k = j;
1187 }else if( nColumn==0 ){
1188 /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */
1189 sqlite3ExprCodeFactorable(pParse,
1190 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
1191 iRegStore);
1192 continue;
1193 }else{
1194 k = i - nHidden;
1195 }
1196
1197 if( useTempTable ){
1198 sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore);
1199 }else if( pSelect ){
1200 if( regFromSelect!=regData ){
1201 sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore);
1202 }
1203 }else{
1204 Expr *pX = pList->a[k].pExpr;
1205 int y = sqlite3ExprCodeTarget(pParse, pX, iRegStore);
1206 if( y!=iRegStore ){
1207 sqlite3VdbeAddOp2(v,
1208 ExprHasProperty(pX, EP_Subquery) ? OP_Copy : OP_SCopy, y, iRegStore);
1209 }
1210 }
1211 }
1212
1213
1214 /* Run the BEFORE and INSTEAD OF triggers, if there are any
1215 */
1216 endOfLoop = sqlite3VdbeMakeLabel(pParse);
1217 if( tmask & TRIGGER_BEFORE ){
1218 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
1219
1220 /* build the NEW.* reference row. Note that if there is an INTEGER
1221 ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
1222 ** translated into a unique ID for the row. But on a BEFORE trigger,
1223 ** we do not know what the unique ID will be (because the insert has
1224 ** not happened yet) so we substitute a rowid of -1
1225 */
1226 if( ipkColumn<0 ){
1227 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
1228 }else{
1229 int addr1;
1230 assert( !withoutRowid );
1231 if( useTempTable ){
1232 sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols);
1233 }else{
1234 assert( pSelect==0 ); /* Otherwise useTempTable is true */
1235 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
1236 }
1237 addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v);
1238 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
1239 sqlite3VdbeJumpHere(v, addr1);
1240 sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
1241 }
1242
1243 /* Copy the new data already generated. */
1244 assert( pTab->nNVCol>0 );
1245 sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
1246
1247#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1248 /* Compute the new value for generated columns after all other
1249 ** columns have already been computed. This must be done after
1250 ** computing the ROWID in case one of the generated columns
1251 ** refers to the ROWID. */
1252 if( pTab->tabFlags & TF_HasGenerated ){
1253 testcase( pTab->tabFlags & TF_HasVirtual );
1254 testcase( pTab->tabFlags & TF_HasStored );
1255 sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab);
1256 }
1257#endif
1258
1259 /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
1260 ** do not attempt any conversions before assembling the record.
1261 ** If this is a real table, attempt conversions as required by the
1262 ** table column affinities.
1263 */
1264 if( !isView ){
1265 sqlite3TableAffinity(v, pTab, regCols+1);
1266 }
1267
1268 /* Fire BEFORE or INSTEAD OF triggers */
1269 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
1270 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
1271
1272 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
1273 }
1274
1275 if( !isView ){
1276 if( IsVirtual(pTab) ){
1277 /* The row that the VUpdate opcode will delete: none */
1278 sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
1279 }
1280 if( ipkColumn>=0 ){
1281 /* Compute the new rowid */
1282 if( useTempTable ){
1283 sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid);
1284 }else if( pSelect ){
1285 /* Rowid already initialized at tag-20191021-001 */
1286 }else{
1287 Expr *pIpk = pList->a[ipkColumn].pExpr;
1288 if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
1289 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
1290 appendFlag = 1;
1291 }else{
1292 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
1293 }
1294 }
1295 /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
1296 ** to generate a unique primary key value.
1297 */
1298 if( !appendFlag ){
1299 int addr1;
1300 if( !IsVirtual(pTab) ){
1301 addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v);
1302 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
1303 sqlite3VdbeJumpHere(v, addr1);
1304 }else{
1305 addr1 = sqlite3VdbeCurrentAddr(v);
1306 sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v);
1307 }
1308 sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v);
1309 }
1310 }else if( IsVirtual(pTab) || withoutRowid ){
1311 sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
1312 }else{
1313 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
1314 appendFlag = 1;
1315 }
1316 autoIncStep(pParse, regAutoinc, regRowid);
1317
1318#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1319 /* Compute the new value for generated columns after all other
1320 ** columns have already been computed. This must be done after
1321 ** computing the ROWID in case one of the generated columns
1322 ** is derived from the INTEGER PRIMARY KEY. */
1323 if( pTab->tabFlags & TF_HasGenerated ){
1324 sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab);
1325 }
1326#endif
1327
1328 /* Generate code to check constraints and generate index keys and
1329 ** do the insertion.
1330 */
1331#ifndef SQLITE_OMIT_VIRTUALTABLE
1332 if( IsVirtual(pTab) ){
1333 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
1334 sqlite3VtabMakeWritable(pParse, pTab);
1335 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
1336 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
1337 sqlite3MayAbort(pParse);
1338 }else
1339#endif
1340 {
1341 int isReplace = 0;/* Set to true if constraints may cause a replace */
1342 int bUseSeek; /* True to use OPFLAG_SEEKRESULT */
1343 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
1344 regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert
1345 );
1346 if( db->flags & SQLITE_ForeignKeys ){
1347 sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
1348 }
1349
1350 /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
1351 ** constraints or (b) there are no triggers and this table is not a
1352 ** parent table in a foreign key constraint. It is safe to set the
1353 ** flag in the second case as if any REPLACE constraint is hit, an
1354 ** OP_Delete or OP_IdxDelete instruction will be executed on each
1355 ** cursor that is disturbed. And these instructions both clear the
1356 ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
1357 ** functionality. */
1358 bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v));
1359 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
1360 regIns, aRegIdx, 0, appendFlag, bUseSeek
1361 );
1362 }
1363#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
1364 }else if( pParse->bReturning ){
1365 /* If there is a RETURNING clause, populate the rowid register with
1366 ** constant value -1, in case one or more of the returned expressions
1367 ** refer to the "rowid" of the view. */
1368 sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
1369#endif
1370 }
1371
1372 /* Update the count of rows that are inserted
1373 */
1374 if( regRowCount ){
1375 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
1376 }
1377
1378 if( pTrigger ){
1379 /* Code AFTER triggers */
1380 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
1381 pTab, regData-2-pTab->nCol, onError, endOfLoop);
1382 }
1383
1384 /* The bottom of the main insertion loop, if the data source
1385 ** is a SELECT statement.
1386 */
1387 sqlite3VdbeResolveLabel(v, endOfLoop);
1388 if( useTempTable ){
1389 sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
1390 sqlite3VdbeJumpHere(v, addrInsTop);
1391 sqlite3VdbeAddOp1(v, OP_Close, srcTab);
1392 }else if( pSelect ){
1393 sqlite3VdbeGoto(v, addrCont);
1394#ifdef SQLITE_DEBUG
1395 /* If we are jumping back to an OP_Yield that is preceded by an
1396 ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
1397 ** OP_ReleaseReg will be included in the loop. */
1398 if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){
1399 assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield );
1400 sqlite3VdbeChangeP5(v, 1);
1401 }
1402#endif
1403 sqlite3VdbeJumpHere(v, addrInsTop);
1404 }
1405
1406#ifndef SQLITE_OMIT_XFER_OPT
1407insert_end:
1408#endif /* SQLITE_OMIT_XFER_OPT */
1409 /* Update the sqlite_sequence table by storing the content of the
1410 ** maximum rowid counter values recorded while inserting into
1411 ** autoincrement tables.
1412 */
1413 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
1414 sqlite3AutoincrementEnd(pParse);
1415 }
1416
1417 /*
1418 ** Return the number of rows inserted. If this routine is
1419 ** generating code because of a call to sqlite3NestedParse(), do not
1420 ** invoke the callback function.
1421 */
1422 if( regRowCount ){
1423 sqlite3CodeChangeCount(v, regRowCount, "rows inserted");
1424 }
1425
1426insert_cleanup:
1427 sqlite3SrcListDelete(db, pTabList);
1428 sqlite3ExprListDelete(db, pList);
1429 sqlite3UpsertDelete(db, pUpsert);
1430 sqlite3SelectDelete(db, pSelect);
1431 sqlite3IdListDelete(db, pColumn);
1432 if( aRegIdx ) sqlite3DbNNFreeNN(db, aRegIdx);
1433}
1434
1435/* Make sure "isView" and other macros defined above are undefined. Otherwise
1436** they may interfere with compilation of other functions in this file
1437** (or in another file, if this file becomes part of the amalgamation). */
1438#ifdef isView
1439 #undef isView
1440#endif
1441#ifdef pTrigger
1442 #undef pTrigger
1443#endif
1444#ifdef tmask
1445 #undef tmask
1446#endif
1447
1448/*
1449** Meanings of bits in of pWalker->eCode for
1450** sqlite3ExprReferencesUpdatedColumn()
1451*/
1452#define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */
1453#define CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */
1454
1455/* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn().
1456* Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this
1457** expression node references any of the
1458** columns that are being modifed by an UPDATE statement.
1459*/
1460static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
1461 if( pExpr->op==TK_COLUMN ){
1462 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
1463 if( pExpr->iColumn>=0 ){
1464 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
1465 pWalker->eCode |= CKCNSTRNT_COLUMN;
1466 }
1467 }else{
1468 pWalker->eCode |= CKCNSTRNT_ROWID;
1469 }
1470 }
1471 return WRC_Continue;
1472}
1473
1474/*
1475** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
1476** only columns that are modified by the UPDATE are those for which
1477** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
1478**
1479** Return true if CHECK constraint pExpr uses any of the
1480** changing columns (or the rowid if it is changing). In other words,
1481** return true if this CHECK constraint must be validated for
1482** the new row in the UPDATE statement.
1483**
1484** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
1485** The operation of this routine is the same - return true if an only if
1486** the expression uses one or more of columns identified by the second and
1487** third arguments.
1488*/
1489int sqlite3ExprReferencesUpdatedColumn(
1490 Expr *pExpr, /* The expression to be checked */
1491 int *aiChng, /* aiChng[x]>=0 if column x changed by the UPDATE */
1492 int chngRowid /* True if UPDATE changes the rowid */
1493){
1494 Walker w;
1495 memset(&w, 0, sizeof(w));
1496 w.eCode = 0;
1497 w.xExprCallback = checkConstraintExprNode;
1498 w.u.aiCol = aiChng;
1499 sqlite3WalkExpr(&w, pExpr);
1500 if( !chngRowid ){
1501 testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
1502 w.eCode &= ~CKCNSTRNT_ROWID;
1503 }
1504 testcase( w.eCode==0 );
1505 testcase( w.eCode==CKCNSTRNT_COLUMN );
1506 testcase( w.eCode==CKCNSTRNT_ROWID );
1507 testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
1508 return w.eCode!=0;
1509}
1510
1511/*
1512** The sqlite3GenerateConstraintChecks() routine usually wants to visit
1513** the indexes of a table in the order provided in the Table->pIndex list.
1514** However, sometimes (rarely - when there is an upsert) it wants to visit
1515** the indexes in a different order. The following data structures accomplish
1516** this.
1517**
1518** The IndexIterator object is used to walk through all of the indexes
1519** of a table in either Index.pNext order, or in some other order established
1520** by an array of IndexListTerm objects.
1521*/
1522typedef struct IndexListTerm IndexListTerm;
1523typedef struct IndexIterator IndexIterator;
1524struct IndexIterator {
1525 int eType; /* 0 for Index.pNext list. 1 for an array of IndexListTerm */
1526 int i; /* Index of the current item from the list */
1527 union {
1528 struct { /* Use this object for eType==0: A Index.pNext list */
1529 Index *pIdx; /* The current Index */
1530 } lx;
1531 struct { /* Use this object for eType==1; Array of IndexListTerm */
1532 int nIdx; /* Size of the array */
1533 IndexListTerm *aIdx; /* Array of IndexListTerms */
1534 } ax;
1535 } u;
1536};
1537
1538/* When IndexIterator.eType==1, then each index is an array of instances
1539** of the following object
1540*/
1541struct IndexListTerm {
1542 Index *p; /* The index */
1543 int ix; /* Which entry in the original Table.pIndex list is this index*/
1544};
1545
1546/* Return the first index on the list */
1547static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
1548 assert( pIter->i==0 );
1549 if( pIter->eType ){
1550 *pIx = pIter->u.ax.aIdx[0].ix;
1551 return pIter->u.ax.aIdx[0].p;
1552 }else{
1553 *pIx = 0;
1554 return pIter->u.lx.pIdx;
1555 }
1556}
1557
1558/* Return the next index from the list. Return NULL when out of indexes */
1559static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
1560 if( pIter->eType ){
1561 int i = ++pIter->i;
1562 if( i>=pIter->u.ax.nIdx ){
1563 *pIx = i;
1564 return 0;
1565 }
1566 *pIx = pIter->u.ax.aIdx[i].ix;
1567 return pIter->u.ax.aIdx[i].p;
1568 }else{
1569 ++(*pIx);
1570 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
1571 return pIter->u.lx.pIdx;
1572 }
1573}
1574
1575/*
1576** Generate code to do constraint checks prior to an INSERT or an UPDATE
1577** on table pTab.
1578**
1579** The regNewData parameter is the first register in a range that contains
1580** the data to be inserted or the data after the update. There will be
1581** pTab->nCol+1 registers in this range. The first register (the one
1582** that regNewData points to) will contain the new rowid, or NULL in the
1583** case of a WITHOUT ROWID table. The second register in the range will
1584** contain the content of the first table column. The third register will
1585** contain the content of the second table column. And so forth.
1586**
1587** The regOldData parameter is similar to regNewData except that it contains
1588** the data prior to an UPDATE rather than afterwards. regOldData is zero
1589** for an INSERT. This routine can distinguish between UPDATE and INSERT by
1590** checking regOldData for zero.
1591**
1592** For an UPDATE, the pkChng boolean is true if the true primary key (the
1593** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
1594** might be modified by the UPDATE. If pkChng is false, then the key of
1595** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
1596**
1597** For an INSERT, the pkChng boolean indicates whether or not the rowid
1598** was explicitly specified as part of the INSERT statement. If pkChng
1599** is zero, it means that the either rowid is computed automatically or
1600** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT,
1601** pkChng will only be true if the INSERT statement provides an integer
1602** value for either the rowid column or its INTEGER PRIMARY KEY alias.
1603**
1604** The code generated by this routine will store new index entries into
1605** registers identified by aRegIdx[]. No index entry is created for
1606** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
1607** the same as the order of indices on the linked list of indices
1608** at pTab->pIndex.
1609**
1610** (2019-05-07) The generated code also creates a new record for the
1611** main table, if pTab is a rowid table, and stores that record in the
1612** register identified by aRegIdx[nIdx] - in other words in the first
1613** entry of aRegIdx[] past the last index. It is important that the
1614** record be generated during constraint checks to avoid affinity changes
1615** to the register content that occur after constraint checks but before
1616** the new record is inserted.
1617**
1618** The caller must have already opened writeable cursors on the main
1619** table and all applicable indices (that is to say, all indices for which
1620** aRegIdx[] is not zero). iDataCur is the cursor for the main table when
1621** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
1622** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor
1623** for the first index in the pTab->pIndex list. Cursors for other indices
1624** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
1625**
1626** This routine also generates code to check constraints. NOT NULL,
1627** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
1628** then the appropriate action is performed. There are five possible
1629** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
1630**
1631** Constraint type Action What Happens
1632** --------------- ---------- ----------------------------------------
1633** any ROLLBACK The current transaction is rolled back and
1634** sqlite3_step() returns immediately with a
1635** return code of SQLITE_CONSTRAINT.
1636**
1637** any ABORT Back out changes from the current command
1638** only (do not do a complete rollback) then
1639** cause sqlite3_step() to return immediately
1640** with SQLITE_CONSTRAINT.
1641**
1642** any FAIL Sqlite3_step() returns immediately with a
1643** return code of SQLITE_CONSTRAINT. The
1644** transaction is not rolled back and any
1645** changes to prior rows are retained.
1646**
1647** any IGNORE The attempt in insert or update the current
1648** row is skipped, without throwing an error.
1649** Processing continues with the next row.
1650** (There is an immediate jump to ignoreDest.)
1651**
1652** NOT NULL REPLACE The NULL value is replace by the default
1653** value for that column. If the default value
1654** is NULL, the action is the same as ABORT.
1655**
1656** UNIQUE REPLACE The other row that conflicts with the row
1657** being inserted is removed.
1658**
1659** CHECK REPLACE Illegal. The results in an exception.
1660**
1661** Which action to take is determined by the overrideError parameter.
1662** Or if overrideError==OE_Default, then the pParse->onError parameter
1663** is used. Or if pParse->onError==OE_Default then the onError value
1664** for the constraint is used.
1665*/
1666void sqlite3GenerateConstraintChecks(
1667 Parse *pParse, /* The parser context */
1668 Table *pTab, /* The table being inserted or updated */
1669 int *aRegIdx, /* Use register aRegIdx[i] for index i. 0 for unused */
1670 int iDataCur, /* Canonical data cursor (main table or PK index) */
1671 int iIdxCur, /* First index cursor */
1672 int regNewData, /* First register in a range holding values to insert */
1673 int regOldData, /* Previous content. 0 for INSERTs */
1674 u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */
1675 u8 overrideError, /* Override onError to this if not OE_Default */
1676 int ignoreDest, /* Jump to this label on an OE_Ignore resolution */
1677 int *pbMayReplace, /* OUT: Set to true if constraint may cause a replace */
1678 int *aiChng, /* column i is unchanged if aiChng[i]<0 */
1679 Upsert *pUpsert /* ON CONFLICT clauses, if any. NULL otherwise */
1680){
1681 Vdbe *v; /* VDBE under constrution */
1682 Index *pIdx; /* Pointer to one of the indices */
1683 Index *pPk = 0; /* The PRIMARY KEY index for WITHOUT ROWID tables */
1684 sqlite3 *db; /* Database connection */
1685 int i; /* loop counter */
1686 int ix; /* Index loop counter */
1687 int nCol; /* Number of columns */
1688 int onError; /* Conflict resolution strategy */
1689 int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
1690 int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
1691 Upsert *pUpsertClause = 0; /* The specific ON CONFLICT clause for pIdx */
1692 u8 isUpdate; /* True if this is an UPDATE operation */
1693 u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */
1694 int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */
1695 int upsertIpkDelay = 0; /* Address of Goto to bypass initial IPK check */
1696 int ipkTop = 0; /* Top of the IPK uniqueness check */
1697 int ipkBottom = 0; /* OP_Goto at the end of the IPK uniqueness check */
1698 /* Variables associated with retesting uniqueness constraints after
1699 ** replace triggers fire have run */
1700 int regTrigCnt; /* Register used to count replace trigger invocations */
1701 int addrRecheck = 0; /* Jump here to recheck all uniqueness constraints */
1702 int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */
1703 Trigger *pTrigger; /* List of DELETE triggers on the table pTab */
1704 int nReplaceTrig = 0; /* Number of replace triggers coded */
1705 IndexIterator sIdxIter; /* Index iterator */
1706
1707 isUpdate = regOldData!=0;
1708 db = pParse->db;
1709 v = pParse->pVdbe;
1710 assert( v!=0 );
1711 assert( !IsView(pTab) ); /* This table is not a VIEW */
1712 nCol = pTab->nCol;
1713
1714 /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
1715 ** normal rowid tables. nPkField is the number of key fields in the
1716 ** pPk index or 1 for a rowid table. In other words, nPkField is the
1717 ** number of fields in the true primary key of the table. */
1718 if( HasRowid(pTab) ){
1719 pPk = 0;
1720 nPkField = 1;
1721 }else{
1722 pPk = sqlite3PrimaryKeyIndex(pTab);
1723 nPkField = pPk->nKeyCol;
1724 }
1725
1726 /* Record that this module has started */
1727 VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
1728 iDataCur, iIdxCur, regNewData, regOldData, pkChng));
1729
1730 /* Test all NOT NULL constraints.
1731 */
1732 if( pTab->tabFlags & TF_HasNotNull ){
1733 int b2ndPass = 0; /* True if currently running 2nd pass */
1734 int nSeenReplace = 0; /* Number of ON CONFLICT REPLACE operations */
1735 int nGenerated = 0; /* Number of generated columns with NOT NULL */
1736 while(1){ /* Make 2 passes over columns. Exit loop via "break" */
1737 for(i=0; i<nCol; i++){
1738 int iReg; /* Register holding column value */
1739 Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
1740 int isGenerated; /* non-zero if column is generated */
1741 onError = pCol->notNull;
1742 if( onError==OE_None ) continue; /* No NOT NULL on this column */
1743 if( i==pTab->iPKey ){
1744 continue; /* ROWID is never NULL */
1745 }
1746 isGenerated = pCol->colFlags & COLFLAG_GENERATED;
1747 if( isGenerated && !b2ndPass ){
1748 nGenerated++;
1749 continue; /* Generated columns processed on 2nd pass */
1750 }
1751 if( aiChng && aiChng[i]<0 && !isGenerated ){
1752 /* Do not check NOT NULL on columns that do not change */
1753 continue;
1754 }
1755 if( overrideError!=OE_Default ){
1756 onError = overrideError;
1757 }else if( onError==OE_Default ){
1758 onError = OE_Abort;
1759 }
1760 if( onError==OE_Replace ){
1761 if( b2ndPass /* REPLACE becomes ABORT on the 2nd pass */
1762 || pCol->iDflt==0 /* REPLACE is ABORT if no DEFAULT value */
1763 ){
1764 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
1765 testcase( pCol->colFlags & COLFLAG_STORED );
1766 testcase( pCol->colFlags & COLFLAG_GENERATED );
1767 onError = OE_Abort;
1768 }else{
1769 assert( !isGenerated );
1770 }
1771 }else if( b2ndPass && !isGenerated ){
1772 continue;
1773 }
1774 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
1775 || onError==OE_Ignore || onError==OE_Replace );
1776 testcase( i!=sqlite3TableColumnToStorage(pTab, i) );
1777 iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1;
1778 switch( onError ){
1779 case OE_Replace: {
1780 int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg);
1781 VdbeCoverage(v);
1782 assert( (pCol->colFlags & COLFLAG_GENERATED)==0 );
1783 nSeenReplace++;
1784 sqlite3ExprCodeCopy(pParse,
1785 sqlite3ColumnExpr(pTab, pCol), iReg);
1786 sqlite3VdbeJumpHere(v, addr1);
1787 break;
1788 }
1789 case OE_Abort:
1790 sqlite3MayAbort(pParse);
1791 /* no break */ deliberate_fall_through
1792 case OE_Rollback:
1793 case OE_Fail: {
1794 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
1795 pCol->zCnName);
1796 sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,
1797 onError, iReg);
1798 sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
1799 sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
1800 VdbeCoverage(v);
1801 break;
1802 }
1803 default: {
1804 assert( onError==OE_Ignore );
1805 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest);
1806 VdbeCoverage(v);
1807 break;
1808 }
1809 } /* end switch(onError) */
1810 } /* end loop i over columns */
1811 if( nGenerated==0 && nSeenReplace==0 ){
1812 /* If there are no generated columns with NOT NULL constraints
1813 ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
1814 ** pass is sufficient */
1815 break;
1816 }
1817 if( b2ndPass ) break; /* Never need more than 2 passes */
1818 b2ndPass = 1;
1819#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1820 if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
1821 /* If any NOT NULL ON CONFLICT REPLACE constraints fired on the
1822 ** first pass, recomputed values for all generated columns, as
1823 ** those values might depend on columns affected by the REPLACE.
1824 */
1825 sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab);
1826 }
1827#endif
1828 } /* end of 2-pass loop */
1829 } /* end if( has-not-null-constraints ) */
1830
1831 /* Test all CHECK constraints
1832 */
1833#ifndef SQLITE_OMIT_CHECK
1834 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
1835 ExprList *pCheck = pTab->pCheck;
1836 pParse->iSelfTab = -(regNewData+1);
1837 onError = overrideError!=OE_Default ? overrideError : OE_Abort;
1838 for(i=0; i<pCheck->nExpr; i++){
1839 int allOk;
1840 Expr *pCopy;
1841 Expr *pExpr = pCheck->a[i].pExpr;
1842 if( aiChng
1843 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
1844 ){
1845 /* The check constraints do not reference any of the columns being
1846 ** updated so there is no point it verifying the check constraint */
1847 continue;
1848 }
1849 if( bAffinityDone==0 ){
1850 sqlite3TableAffinity(v, pTab, regNewData+1);
1851 bAffinityDone = 1;
1852 }
1853 allOk = sqlite3VdbeMakeLabel(pParse);
1854 sqlite3VdbeVerifyAbortable(v, onError);
1855 pCopy = sqlite3ExprDup(db, pExpr, 0);
1856 if( !db->mallocFailed ){
1857 sqlite3ExprIfTrue(pParse, pCopy, allOk, SQLITE_JUMPIFNULL);
1858 }
1859 sqlite3ExprDelete(db, pCopy);
1860 if( onError==OE_Ignore ){
1861 sqlite3VdbeGoto(v, ignoreDest);
1862 }else{
1863 char *zName = pCheck->a[i].zEName;
1864 assert( zName!=0 || pParse->db->mallocFailed );
1865 if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */
1866 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
1867 onError, zName, P4_TRANSIENT,
1868 P5_ConstraintCheck);
1869 }
1870 sqlite3VdbeResolveLabel(v, allOk);
1871 }
1872 pParse->iSelfTab = 0;
1873 }
1874#endif /* !defined(SQLITE_OMIT_CHECK) */
1875
1876 /* UNIQUE and PRIMARY KEY constraints should be handled in the following
1877 ** order:
1878 **
1879 ** (1) OE_Update
1880 ** (2) OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
1881 ** (3) OE_Replace
1882 **
1883 ** OE_Fail and OE_Ignore must happen before any changes are made.
1884 ** OE_Update guarantees that only a single row will change, so it
1885 ** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback
1886 ** could happen in any order, but they are grouped up front for
1887 ** convenience.
1888 **
1889 ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
1890 ** The order of constraints used to have OE_Update as (2) and OE_Abort
1891 ** and so forth as (1). But apparently PostgreSQL checks the OE_Update
1892 ** constraint before any others, so it had to be moved.
1893 **
1894 ** Constraint checking code is generated in this order:
1895 ** (A) The rowid constraint
1896 ** (B) Unique index constraints that do not have OE_Replace as their
1897 ** default conflict resolution strategy
1898 ** (C) Unique index that do use OE_Replace by default.
1899 **
1900 ** The ordering of (2) and (3) is accomplished by making sure the linked
1901 ** list of indexes attached to a table puts all OE_Replace indexes last
1902 ** in the list. See sqlite3CreateIndex() for where that happens.
1903 */
1904 sIdxIter.eType = 0;
1905 sIdxIter.i = 0;
1906 sIdxIter.u.ax.aIdx = 0; /* Silence harmless compiler warning */
1907 sIdxIter.u.lx.pIdx = pTab->pIndex;
1908 if( pUpsert ){
1909 if( pUpsert->pUpsertTarget==0 ){
1910 /* There is just on ON CONFLICT clause and it has no constraint-target */
1911 assert( pUpsert->pNextUpsert==0 );
1912 if( pUpsert->isDoUpdate==0 ){
1913 /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
1914 ** Make all unique constraint resolution be OE_Ignore */
1915 overrideError = OE_Ignore;
1916 pUpsert = 0;
1917 }else{
1918 /* A single ON CONFLICT DO UPDATE. Make all resolutions OE_Update */
1919 overrideError = OE_Update;
1920 }
1921 }else if( pTab->pIndex!=0 ){
1922 /* Otherwise, we'll need to run the IndexListTerm array version of the
1923 ** iterator to ensure that all of the ON CONFLICT conditions are
1924 ** checked first and in order. */
1925 int nIdx, jj;
1926 u64 nByte;
1927 Upsert *pTerm;
1928 u8 *bUsed;
1929 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
1930 assert( aRegIdx[nIdx]>0 );
1931 }
1932 sIdxIter.eType = 1;
1933 sIdxIter.u.ax.nIdx = nIdx;
1934 nByte = (sizeof(IndexListTerm)+1)*nIdx + nIdx;
1935 sIdxIter.u.ax.aIdx = sqlite3DbMallocZero(db, nByte);
1936 if( sIdxIter.u.ax.aIdx==0 ) return; /* OOM */
1937 bUsed = (u8*)&sIdxIter.u.ax.aIdx[nIdx];
1938 pUpsert->pToFree = sIdxIter.u.ax.aIdx;
1939 for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){
1940 if( pTerm->pUpsertTarget==0 ) break;
1941 if( pTerm->pUpsertIdx==0 ) continue; /* Skip ON CONFLICT for the IPK */
1942 jj = 0;
1943 pIdx = pTab->pIndex;
1944 while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){
1945 pIdx = pIdx->pNext;
1946 jj++;
1947 }
1948 if( bUsed[jj] ) continue; /* Duplicate ON CONFLICT clause ignored */
1949 bUsed[jj] = 1;
1950 sIdxIter.u.ax.aIdx[i].p = pIdx;
1951 sIdxIter.u.ax.aIdx[i].ix = jj;
1952 i++;
1953 }
1954 for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
1955 if( bUsed[jj] ) continue;
1956 sIdxIter.u.ax.aIdx[i].p = pIdx;
1957 sIdxIter.u.ax.aIdx[i].ix = jj;
1958 i++;
1959 }
1960 assert( i==nIdx );
1961 }
1962 }
1963
1964 /* Determine if it is possible that triggers (either explicitly coded
1965 ** triggers or FK resolution actions) might run as a result of deletes
1966 ** that happen when OE_Replace conflict resolution occurs. (Call these
1967 ** "replace triggers".) If any replace triggers run, we will need to
1968 ** recheck all of the uniqueness constraints after they have all run.
1969 ** But on the recheck, the resolution is OE_Abort instead of OE_Replace.
1970 **
1971 ** If replace triggers are a possibility, then
1972 **
1973 ** (1) Allocate register regTrigCnt and initialize it to zero.
1974 ** That register will count the number of replace triggers that
1975 ** fire. Constraint recheck only occurs if the number is positive.
1976 ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
1977 ** (3) Initialize addrRecheck and lblRecheckOk
1978 **
1979 ** The uniqueness rechecking code will create a series of tests to run
1980 ** in a second pass. The addrRecheck and lblRecheckOk variables are
1981 ** used to link together these tests which are separated from each other
1982 ** in the generate bytecode.
1983 */
1984 if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){
1985 /* There are not DELETE triggers nor FK constraints. No constraint
1986 ** rechecks are needed. */
1987 pTrigger = 0;
1988 regTrigCnt = 0;
1989 }else{
1990 if( db->flags&SQLITE_RecTriggers ){
1991 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
1992 regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0);
1993 }else{
1994 pTrigger = 0;
1995 regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0);
1996 }
1997 if( regTrigCnt ){
1998 /* Replace triggers might exist. Allocate the counter and
1999 ** initialize it to zero. */
2000 regTrigCnt = ++pParse->nMem;
2001 sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt);
2002 VdbeComment((v, "trigger count"));
2003 lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
2004 addrRecheck = lblRecheckOk;
2005 }
2006 }
2007
2008 /* If rowid is changing, make sure the new rowid does not previously
2009 ** exist in the table.
2010 */
2011 if( pkChng && pPk==0 ){
2012 int addrRowidOk = sqlite3VdbeMakeLabel(pParse);
2013
2014 /* Figure out what action to take in case of a rowid collision */
2015 onError = pTab->keyConf;
2016 if( overrideError!=OE_Default ){
2017 onError = overrideError;
2018 }else if( onError==OE_Default ){
2019 onError = OE_Abort;
2020 }
2021
2022 /* figure out whether or not upsert applies in this case */
2023 if( pUpsert ){
2024 pUpsertClause = sqlite3UpsertOfIndex(pUpsert,0);
2025 if( pUpsertClause!=0 ){
2026 if( pUpsertClause->isDoUpdate==0 ){
2027 onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */
2028 }else{
2029 onError = OE_Update; /* DO UPDATE */
2030 }
2031 }
2032 if( pUpsertClause!=pUpsert ){
2033 /* The first ON CONFLICT clause has a conflict target other than
2034 ** the IPK. We have to jump ahead to that first ON CONFLICT clause
2035 ** and then come back here and deal with the IPK afterwards */
2036 upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto);
2037 }
2038 }
2039
2040 /* If the response to a rowid conflict is REPLACE but the response
2041 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
2042 ** to defer the running of the rowid conflict checking until after
2043 ** the UNIQUE constraints have run.
2044 */
2045 if( onError==OE_Replace /* IPK rule is REPLACE */
2046 && onError!=overrideError /* Rules for other constraints are different */
2047 && pTab->pIndex /* There exist other constraints */
2048 && !upsertIpkDelay /* IPK check already deferred by UPSERT */
2049 ){
2050 ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
2051 VdbeComment((v, "defer IPK REPLACE until last"));
2052 }
2053
2054 if( isUpdate ){
2055 /* pkChng!=0 does not mean that the rowid has changed, only that
2056 ** it might have changed. Skip the conflict logic below if the rowid
2057 ** is unchanged. */
2058 sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
2059 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
2060 VdbeCoverage(v);
2061 }
2062
2063 /* Check to see if the new rowid already exists in the table. Skip
2064 ** the following conflict logic if it does not. */
2065 VdbeNoopComment((v, "uniqueness check for ROWID"));
2066 sqlite3VdbeVerifyAbortable(v, onError);
2067 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
2068 VdbeCoverage(v);
2069
2070 switch( onError ){
2071 default: {
2072 onError = OE_Abort;
2073 /* no break */ deliberate_fall_through
2074 }
2075 case OE_Rollback:
2076 case OE_Abort:
2077 case OE_Fail: {
2078 testcase( onError==OE_Rollback );
2079 testcase( onError==OE_Abort );
2080 testcase( onError==OE_Fail );
2081 sqlite3RowidConstraint(pParse, onError, pTab);
2082 break;
2083 }
2084 case OE_Replace: {
2085 /* If there are DELETE triggers on this table and the
2086 ** recursive-triggers flag is set, call GenerateRowDelete() to
2087 ** remove the conflicting row from the table. This will fire
2088 ** the triggers and remove both the table and index b-tree entries.
2089 **
2090 ** Otherwise, if there are no triggers or the recursive-triggers
2091 ** flag is not set, but the table has one or more indexes, call
2092 ** GenerateRowIndexDelete(). This removes the index b-tree entries
2093 ** only. The table b-tree entry will be replaced by the new entry
2094 ** when it is inserted.
2095 **
2096 ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
2097 ** also invoke MultiWrite() to indicate that this VDBE may require
2098 ** statement rollback (if the statement is aborted after the delete
2099 ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
2100 ** but being more selective here allows statements like:
2101 **
2102 ** REPLACE INTO t(rowid) VALUES($newrowid)
2103 **
2104 ** to run without a statement journal if there are no indexes on the
2105 ** table.
2106 */
2107 if( regTrigCnt ){
2108 sqlite3MultiWrite(pParse);
2109 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
2110 regNewData, 1, 0, OE_Replace, 1, -1);
2111 sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
2112 nReplaceTrig++;
2113 }else{
2114#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2115 assert( HasRowid(pTab) );
2116 /* This OP_Delete opcode fires the pre-update-hook only. It does
2117 ** not modify the b-tree. It is more efficient to let the coming
2118 ** OP_Insert replace the existing entry than it is to delete the
2119 ** existing entry and then insert a new one. */
2120 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
2121 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
2122#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
2123 if( pTab->pIndex ){
2124 sqlite3MultiWrite(pParse);
2125 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
2126 }
2127 }
2128 seenReplace = 1;
2129 break;
2130 }
2131#ifndef SQLITE_OMIT_UPSERT
2132 case OE_Update: {
2133 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
2134 /* no break */ deliberate_fall_through
2135 }
2136#endif
2137 case OE_Ignore: {
2138 testcase( onError==OE_Ignore );
2139 sqlite3VdbeGoto(v, ignoreDest);
2140 break;
2141 }
2142 }
2143 sqlite3VdbeResolveLabel(v, addrRowidOk);
2144 if( pUpsert && pUpsertClause!=pUpsert ){
2145 upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto);
2146 }else if( ipkTop ){
2147 ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
2148 sqlite3VdbeJumpHere(v, ipkTop-1);
2149 }
2150 }
2151
2152 /* Test all UNIQUE constraints by creating entries for each UNIQUE
2153 ** index and making sure that duplicate entries do not already exist.
2154 ** Compute the revised record entries for indices as we go.
2155 **
2156 ** This loop also handles the case of the PRIMARY KEY index for a
2157 ** WITHOUT ROWID table.
2158 */
2159 for(pIdx = indexIteratorFirst(&sIdxIter, &ix);
2160 pIdx;
2161 pIdx = indexIteratorNext(&sIdxIter, &ix)
2162 ){
2163 int regIdx; /* Range of registers hold conent for pIdx */
2164 int regR; /* Range of registers holding conflicting PK */
2165 int iThisCur; /* Cursor for this UNIQUE index */
2166 int addrUniqueOk; /* Jump here if the UNIQUE constraint is satisfied */
2167 int addrConflictCk; /* First opcode in the conflict check logic */
2168
2169 if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */
2170 if( pUpsert ){
2171 pUpsertClause = sqlite3UpsertOfIndex(pUpsert, pIdx);
2172 if( upsertIpkDelay && pUpsertClause==pUpsert ){
2173 sqlite3VdbeJumpHere(v, upsertIpkDelay);
2174 }
2175 }
2176 addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
2177 if( bAffinityDone==0 ){
2178 sqlite3TableAffinity(v, pTab, regNewData+1);
2179 bAffinityDone = 1;
2180 }
2181 VdbeNoopComment((v, "prep index %s", pIdx->zName));
2182 iThisCur = iIdxCur+ix;
2183
2184
2185 /* Skip partial indices for which the WHERE clause is not true */
2186 if( pIdx->pPartIdxWhere ){
2187 sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
2188 pParse->iSelfTab = -(regNewData+1);
2189 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
2190 SQLITE_JUMPIFNULL);
2191 pParse->iSelfTab = 0;
2192 }
2193
2194 /* Create a record for this index entry as it should appear after
2195 ** the insert or update. Store that record in the aRegIdx[ix] register
2196 */
2197 regIdx = aRegIdx[ix]+1;
2198 for(i=0; i<pIdx->nColumn; i++){
2199 int iField = pIdx->aiColumn[i];
2200 int x;
2201 if( iField==XN_EXPR ){
2202 pParse->iSelfTab = -(regNewData+1);
2203 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
2204 pParse->iSelfTab = 0;
2205 VdbeComment((v, "%s column %d", pIdx->zName, i));
2206 }else if( iField==XN_ROWID || iField==pTab->iPKey ){
2207 x = regNewData;
2208 sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i);
2209 VdbeComment((v, "rowid"));
2210 }else{
2211 testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
2212 x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1;
2213 sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
2214 VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
2215 }
2216 }
2217 sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
2218 VdbeComment((v, "for %s", pIdx->zName));
2219#ifdef SQLITE_ENABLE_NULL_TRIM
2220 if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
2221 sqlite3SetMakeRecordP5(v, pIdx->pTable);
2222 }
2223#endif
2224 sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0);
2225
2226 /* In an UPDATE operation, if this index is the PRIMARY KEY index
2227 ** of a WITHOUT ROWID table and there has been no change the
2228 ** primary key, then no collision is possible. The collision detection
2229 ** logic below can all be skipped. */
2230 if( isUpdate && pPk==pIdx && pkChng==0 ){
2231 sqlite3VdbeResolveLabel(v, addrUniqueOk);
2232 continue;
2233 }
2234
2235 /* Find out what action to take in case there is a uniqueness conflict */
2236 onError = pIdx->onError;
2237 if( onError==OE_None ){
2238 sqlite3VdbeResolveLabel(v, addrUniqueOk);
2239 continue; /* pIdx is not a UNIQUE index */
2240 }
2241 if( overrideError!=OE_Default ){
2242 onError = overrideError;
2243 }else if( onError==OE_Default ){
2244 onError = OE_Abort;
2245 }
2246
2247 /* Figure out if the upsert clause applies to this index */
2248 if( pUpsertClause ){
2249 if( pUpsertClause->isDoUpdate==0 ){
2250 onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */
2251 }else{
2252 onError = OE_Update; /* DO UPDATE */
2253 }
2254 }
2255
2256 /* Collision detection may be omitted if all of the following are true:
2257 ** (1) The conflict resolution algorithm is REPLACE
2258 ** (2) The table is a WITHOUT ROWID table
2259 ** (3) There are no secondary indexes on the table
2260 ** (4) No delete triggers need to be fired if there is a conflict
2261 ** (5) No FK constraint counters need to be updated if a conflict occurs.
2262 **
2263 ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
2264 ** must be explicitly deleted in order to ensure any pre-update hook
2265 ** is invoked. */
2266 assert( IsOrdinaryTable(pTab) );
2267#ifndef SQLITE_ENABLE_PREUPDATE_HOOK
2268 if( (ix==0 && pIdx->pNext==0) /* Condition 3 */
2269 && pPk==pIdx /* Condition 2 */
2270 && onError==OE_Replace /* Condition 1 */
2271 && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */
2272 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
2273 && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */
2274 (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab)))
2275 ){
2276 sqlite3VdbeResolveLabel(v, addrUniqueOk);
2277 continue;
2278 }
2279#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */
2280
2281 /* Check to see if the new index entry will be unique */
2282 sqlite3VdbeVerifyAbortable(v, onError);
2283 addrConflictCk =
2284 sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
2285 regIdx, pIdx->nKeyCol); VdbeCoverage(v);
2286
2287 /* Generate code to handle collisions */
2288 regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField);
2289 if( isUpdate || onError==OE_Replace ){
2290 if( HasRowid(pTab) ){
2291 sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
2292 /* Conflict only if the rowid of the existing index entry
2293 ** is different from old-rowid */
2294 if( isUpdate ){
2295 sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
2296 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
2297 VdbeCoverage(v);
2298 }
2299 }else{
2300 int x;
2301 /* Extract the PRIMARY KEY from the end of the index entry and
2302 ** store it in registers regR..regR+nPk-1 */
2303 if( pIdx!=pPk ){
2304 for(i=0; i<pPk->nKeyCol; i++){
2305 assert( pPk->aiColumn[i]>=0 );
2306 x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
2307 sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
2308 VdbeComment((v, "%s.%s", pTab->zName,
2309 pTab->aCol[pPk->aiColumn[i]].zCnName));
2310 }
2311 }
2312 if( isUpdate ){
2313 /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
2314 ** table, only conflict if the new PRIMARY KEY values are actually
2315 ** different from the old. See TH3 withoutrowid04.test.
2316 **
2317 ** For a UNIQUE index, only conflict if the PRIMARY KEY values
2318 ** of the matched index row are different from the original PRIMARY
2319 ** KEY values of this row before the update. */
2320 int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
2321 int op = OP_Ne;
2322 int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR);
2323
2324 for(i=0; i<pPk->nKeyCol; i++){
2325 char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
2326 x = pPk->aiColumn[i];
2327 assert( x>=0 );
2328 if( i==(pPk->nKeyCol-1) ){
2329 addrJump = addrUniqueOk;
2330 op = OP_Eq;
2331 }
2332 x = sqlite3TableColumnToStorage(pTab, x);
2333 sqlite3VdbeAddOp4(v, op,
2334 regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ
2335 );
2336 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
2337 VdbeCoverageIf(v, op==OP_Eq);
2338 VdbeCoverageIf(v, op==OP_Ne);
2339 }
2340 }
2341 }
2342 }
2343
2344 /* Generate code that executes if the new index entry is not unique */
2345 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
2346 || onError==OE_Ignore || onError==OE_Replace || onError==OE_Update );
2347 switch( onError ){
2348 case OE_Rollback:
2349 case OE_Abort:
2350 case OE_Fail: {
2351 testcase( onError==OE_Rollback );
2352 testcase( onError==OE_Abort );
2353 testcase( onError==OE_Fail );
2354 sqlite3UniqueConstraint(pParse, onError, pIdx);
2355 break;
2356 }
2357#ifndef SQLITE_OMIT_UPSERT
2358 case OE_Update: {
2359 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
2360 /* no break */ deliberate_fall_through
2361 }
2362#endif
2363 case OE_Ignore: {
2364 testcase( onError==OE_Ignore );
2365 sqlite3VdbeGoto(v, ignoreDest);
2366 break;
2367 }
2368 default: {
2369 int nConflictCk; /* Number of opcodes in conflict check logic */
2370
2371 assert( onError==OE_Replace );
2372 nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
2373 assert( nConflictCk>0 || db->mallocFailed );
2374 testcase( nConflictCk<=0 );
2375 testcase( nConflictCk>1 );
2376 if( regTrigCnt ){
2377 sqlite3MultiWrite(pParse);
2378 nReplaceTrig++;
2379 }
2380 if( pTrigger && isUpdate ){
2381 sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur);
2382 }
2383 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
2384 regR, nPkField, 0, OE_Replace,
2385 (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
2386 if( pTrigger && isUpdate ){
2387 sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur);
2388 }
2389 if( regTrigCnt ){
2390 int addrBypass; /* Jump destination to bypass recheck logic */
2391
2392 sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
2393 addrBypass = sqlite3VdbeAddOp0(v, OP_Goto); /* Bypass recheck */
2394 VdbeComment((v, "bypass recheck"));
2395
2396 /* Here we insert code that will be invoked after all constraint
2397 ** checks have run, if and only if one or more replace triggers
2398 ** fired. */
2399 sqlite3VdbeResolveLabel(v, lblRecheckOk);
2400 lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
2401 if( pIdx->pPartIdxWhere ){
2402 /* Bypass the recheck if this partial index is not defined
2403 ** for the current row */
2404 sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk);
2405 VdbeCoverage(v);
2406 }
2407 /* Copy the constraint check code from above, except change
2408 ** the constraint-ok jump destination to be the address of
2409 ** the next retest block */
2410 while( nConflictCk>0 ){
2411 VdbeOp x; /* Conflict check opcode to copy */
2412 /* The sqlite3VdbeAddOp4() call might reallocate the opcode array.
2413 ** Hence, make a complete copy of the opcode, rather than using
2414 ** a pointer to the opcode. */
2415 x = *sqlite3VdbeGetOp(v, addrConflictCk);
2416 if( x.opcode!=OP_IdxRowid ){
2417 int p2; /* New P2 value for copied conflict check opcode */
2418 const char *zP4;
2419 if( sqlite3OpcodeProperty[x.opcode]&OPFLG_JUMP ){
2420 p2 = lblRecheckOk;
2421 }else{
2422 p2 = x.p2;
2423 }
2424 zP4 = x.p4type==P4_INT32 ? SQLITE_INT_TO_PTR(x.p4.i) : x.p4.z;
2425 sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type);
2426 sqlite3VdbeChangeP5(v, x.p5);
2427 VdbeCoverageIf(v, p2!=x.p2);
2428 }
2429 nConflictCk--;
2430 addrConflictCk++;
2431 }
2432 /* If the retest fails, issue an abort */
2433 sqlite3UniqueConstraint(pParse, OE_Abort, pIdx);
2434
2435 sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */
2436 }
2437 seenReplace = 1;
2438 break;
2439 }
2440 }
2441 sqlite3VdbeResolveLabel(v, addrUniqueOk);
2442 if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
2443 if( pUpsertClause
2444 && upsertIpkReturn
2445 && sqlite3UpsertNextIsIPK(pUpsertClause)
2446 ){
2447 sqlite3VdbeGoto(v, upsertIpkDelay+1);
2448 sqlite3VdbeJumpHere(v, upsertIpkReturn);
2449 upsertIpkReturn = 0;
2450 }
2451 }
2452
2453 /* If the IPK constraint is a REPLACE, run it last */
2454 if( ipkTop ){
2455 sqlite3VdbeGoto(v, ipkTop);
2456 VdbeComment((v, "Do IPK REPLACE"));
2457 assert( ipkBottom>0 );
2458 sqlite3VdbeJumpHere(v, ipkBottom);
2459 }
2460
2461 /* Recheck all uniqueness constraints after replace triggers have run */
2462 testcase( regTrigCnt!=0 && nReplaceTrig==0 );
2463 assert( regTrigCnt!=0 || nReplaceTrig==0 );
2464 if( nReplaceTrig ){
2465 sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v);
2466 if( !pPk ){
2467 if( isUpdate ){
2468 sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData);
2469 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
2470 VdbeCoverage(v);
2471 }
2472 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData);
2473 VdbeCoverage(v);
2474 sqlite3RowidConstraint(pParse, OE_Abort, pTab);
2475 }else{
2476 sqlite3VdbeGoto(v, addrRecheck);
2477 }
2478 sqlite3VdbeResolveLabel(v, lblRecheckOk);
2479 }
2480
2481 /* Generate the table record */
2482 if( HasRowid(pTab) ){
2483 int regRec = aRegIdx[ix];
2484 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
2485 sqlite3SetMakeRecordP5(v, pTab);
2486 if( !bAffinityDone ){
2487 sqlite3TableAffinity(v, pTab, 0);
2488 }
2489 }
2490
2491 *pbMayReplace = seenReplace;
2492 VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
2493}
2494
2495#ifdef SQLITE_ENABLE_NULL_TRIM
2496/*
2497** Change the P5 operand on the last opcode (which should be an OP_MakeRecord)
2498** to be the number of columns in table pTab that must not be NULL-trimmed.
2499**
2500** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
2501*/
2502void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
2503 u16 i;
2504
2505 /* Records with omitted columns are only allowed for schema format
2506 ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
2507 if( pTab->pSchema->file_format<2 ) return;
2508
2509 for(i=pTab->nCol-1; i>0; i--){
2510 if( pTab->aCol[i].iDflt!=0 ) break;
2511 if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
2512 }
2513 sqlite3VdbeChangeP5(v, i+1);
2514}
2515#endif
2516
2517/*
2518** Table pTab is a WITHOUT ROWID table that is being written to. The cursor
2519** number is iCur, and register regData contains the new record for the
2520** PK index. This function adds code to invoke the pre-update hook,
2521** if one is registered.
2522*/
2523#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2524static void codeWithoutRowidPreupdate(
2525 Parse *pParse, /* Parse context */
2526 Table *pTab, /* Table being updated */
2527 int iCur, /* Cursor number for table */
2528 int regData /* Data containing new record */
2529){
2530 Vdbe *v = pParse->pVdbe;
2531 int r = sqlite3GetTempReg(pParse);
2532 assert( !HasRowid(pTab) );
2533 assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) || CORRUPT_DB );
2534 sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
2535 sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
2536 sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
2537 sqlite3ReleaseTempReg(pParse, r);
2538}
2539#else
2540# define codeWithoutRowidPreupdate(a,b,c,d)
2541#endif
2542
2543/*
2544** This routine generates code to finish the INSERT or UPDATE operation
2545** that was started by a prior call to sqlite3GenerateConstraintChecks.
2546** A consecutive range of registers starting at regNewData contains the
2547** rowid and the content to be inserted.
2548**
2549** The arguments to this routine should be the same as the first six
2550** arguments to sqlite3GenerateConstraintChecks.
2551*/
2552void sqlite3CompleteInsertion(
2553 Parse *pParse, /* The parser context */
2554 Table *pTab, /* the table into which we are inserting */
2555 int iDataCur, /* Cursor of the canonical data source */
2556 int iIdxCur, /* First index cursor */
2557 int regNewData, /* Range of content */
2558 int *aRegIdx, /* Register used by each index. 0 for unused indices */
2559 int update_flags, /* True for UPDATE, False for INSERT */
2560 int appendBias, /* True if this is likely to be an append */
2561 int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
2562){
2563 Vdbe *v; /* Prepared statements under construction */
2564 Index *pIdx; /* An index being inserted or updated */
2565 u8 pik_flags; /* flag values passed to the btree insert */
2566 int i; /* Loop counter */
2567
2568 assert( update_flags==0
2569 || update_flags==OPFLAG_ISUPDATE
2570 || update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION)
2571 );
2572
2573 v = pParse->pVdbe;
2574 assert( v!=0 );
2575 assert( !IsView(pTab) ); /* This table is not a VIEW */
2576 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
2577 /* All REPLACE indexes are at the end of the list */
2578 assert( pIdx->onError!=OE_Replace
2579 || pIdx->pNext==0
2580 || pIdx->pNext->onError==OE_Replace );
2581 if( aRegIdx[i]==0 ) continue;
2582 if( pIdx->pPartIdxWhere ){
2583 sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
2584 VdbeCoverage(v);
2585 }
2586 pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0);
2587 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
2588 pik_flags |= OPFLAG_NCHANGE;
2589 pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);
2590 if( update_flags==0 ){
2591 codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]);
2592 }
2593 }
2594 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
2595 aRegIdx[i]+1,
2596 pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
2597 sqlite3VdbeChangeP5(v, pik_flags);
2598 }
2599 if( !HasRowid(pTab) ) return;
2600 if( pParse->nested ){
2601 pik_flags = 0;
2602 }else{
2603 pik_flags = OPFLAG_NCHANGE;
2604 pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID);
2605 }
2606 if( appendBias ){
2607 pik_flags |= OPFLAG_APPEND;
2608 }
2609 if( useSeekResult ){
2610 pik_flags |= OPFLAG_USESEEKRESULT;
2611 }
2612 sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData);
2613 if( !pParse->nested ){
2614 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
2615 }
2616 sqlite3VdbeChangeP5(v, pik_flags);
2617}
2618
2619/*
2620** Allocate cursors for the pTab table and all its indices and generate
2621** code to open and initialized those cursors.
2622**
2623** The cursor for the object that contains the complete data (normally
2624** the table itself, but the PRIMARY KEY index in the case of a WITHOUT
2625** ROWID table) is returned in *piDataCur. The first index cursor is
2626** returned in *piIdxCur. The number of indices is returned.
2627**
2628** Use iBase as the first cursor (either the *piDataCur for rowid tables
2629** or the first index for WITHOUT ROWID tables) if it is non-negative.
2630** If iBase is negative, then allocate the next available cursor.
2631**
2632** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
2633** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
2634** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the
2635** pTab->pIndex list.
2636**
2637** If pTab is a virtual table, then this routine is a no-op and the
2638** *piDataCur and *piIdxCur values are left uninitialized.
2639*/
2640int sqlite3OpenTableAndIndices(
2641 Parse *pParse, /* Parsing context */
2642 Table *pTab, /* Table to be opened */
2643 int op, /* OP_OpenRead or OP_OpenWrite */
2644 u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */
2645 int iBase, /* Use this for the table cursor, if there is one */
2646 u8 *aToOpen, /* If not NULL: boolean for each table and index */
2647 int *piDataCur, /* Write the database source cursor number here */
2648 int *piIdxCur /* Write the first index cursor number here */
2649){
2650 int i;
2651 int iDb;
2652 int iDataCur;
2653 Index *pIdx;
2654 Vdbe *v;
2655
2656 assert( op==OP_OpenRead || op==OP_OpenWrite );
2657 assert( op==OP_OpenWrite || p5==0 );
2658 if( IsVirtual(pTab) ){
2659 /* This routine is a no-op for virtual tables. Leave the output
2660 ** variables *piDataCur and *piIdxCur set to illegal cursor numbers
2661 ** for improved error detection. */
2662 *piDataCur = *piIdxCur = -999;
2663 return 0;
2664 }
2665 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
2666 v = pParse->pVdbe;
2667 assert( v!=0 );
2668 if( iBase<0 ) iBase = pParse->nTab;
2669 iDataCur = iBase++;
2670 if( piDataCur ) *piDataCur = iDataCur;
2671 if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
2672 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
2673 }else{
2674 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
2675 }
2676 if( piIdxCur ) *piIdxCur = iBase;
2677 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
2678 int iIdxCur = iBase++;
2679 assert( pIdx->pSchema==pTab->pSchema );
2680 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
2681 if( piDataCur ) *piDataCur = iIdxCur;
2682 p5 = 0;
2683 }
2684 if( aToOpen==0 || aToOpen[i+1] ){
2685 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
2686 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
2687 sqlite3VdbeChangeP5(v, p5);
2688 VdbeComment((v, "%s", pIdx->zName));
2689 }
2690 }
2691 if( iBase>pParse->nTab ) pParse->nTab = iBase;
2692 return i;
2693}
2694
2695
2696#ifdef SQLITE_TEST
2697/*
2698** The following global variable is incremented whenever the
2699** transfer optimization is used. This is used for testing
2700** purposes only - to make sure the transfer optimization really
2701** is happening when it is supposed to.
2702*/
2703int sqlite3_xferopt_count;
2704#endif /* SQLITE_TEST */
2705
2706
2707#ifndef SQLITE_OMIT_XFER_OPT
2708/*
2709** Check to see if index pSrc is compatible as a source of data
2710** for index pDest in an insert transfer optimization. The rules
2711** for a compatible index:
2712**
2713** * The index is over the same set of columns
2714** * The same DESC and ASC markings occurs on all columns
2715** * The same onError processing (OE_Abort, OE_Ignore, etc)
2716** * The same collating sequence on each column
2717** * The index has the exact same WHERE clause
2718*/
2719static int xferCompatibleIndex(Index *pDest, Index *pSrc){
2720 int i;
2721 assert( pDest && pSrc );
2722 assert( pDest->pTable!=pSrc->pTable );
2723 if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){
2724 return 0; /* Different number of columns */
2725 }
2726 if( pDest->onError!=pSrc->onError ){
2727 return 0; /* Different conflict resolution strategies */
2728 }
2729 for(i=0; i<pSrc->nKeyCol; i++){
2730 if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
2731 return 0; /* Different columns indexed */
2732 }
2733 if( pSrc->aiColumn[i]==XN_EXPR ){
2734 assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
2735 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
2736 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
2737 return 0; /* Different expressions in the index */
2738 }
2739 }
2740 if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
2741 return 0; /* Different sort orders */
2742 }
2743 if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){
2744 return 0; /* Different collating sequences */
2745 }
2746 }
2747 if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){
2748 return 0; /* Different WHERE clauses */
2749 }
2750
2751 /* If no test above fails then the indices must be compatible */
2752 return 1;
2753}
2754
2755/*
2756** Attempt the transfer optimization on INSERTs of the form
2757**
2758** INSERT INTO tab1 SELECT * FROM tab2;
2759**
2760** The xfer optimization transfers raw records from tab2 over to tab1.
2761** Columns are not decoded and reassembled, which greatly improves
2762** performance. Raw index records are transferred in the same way.
2763**
2764** The xfer optimization is only attempted if tab1 and tab2 are compatible.
2765** There are lots of rules for determining compatibility - see comments
2766** embedded in the code for details.
2767**
2768** This routine returns TRUE if the optimization is guaranteed to be used.
2769** Sometimes the xfer optimization will only work if the destination table
2770** is empty - a factor that can only be determined at run-time. In that
2771** case, this routine generates code for the xfer optimization but also
2772** does a test to see if the destination table is empty and jumps over the
2773** xfer optimization code if the test fails. In that case, this routine
2774** returns FALSE so that the caller will know to go ahead and generate
2775** an unoptimized transfer. This routine also returns FALSE if there
2776** is no chance that the xfer optimization can be applied.
2777**
2778** This optimization is particularly useful at making VACUUM run faster.
2779*/
2780static int xferOptimization(
2781 Parse *pParse, /* Parser context */
2782 Table *pDest, /* The table we are inserting into */
2783 Select *pSelect, /* A SELECT statement to use as the data source */
2784 int onError, /* How to handle constraint errors */
2785 int iDbDest /* The database of pDest */
2786){
2787 sqlite3 *db = pParse->db;
2788 ExprList *pEList; /* The result set of the SELECT */
2789 Table *pSrc; /* The table in the FROM clause of SELECT */
2790 Index *pSrcIdx, *pDestIdx; /* Source and destination indices */
2791 SrcItem *pItem; /* An element of pSelect->pSrc */
2792 int i; /* Loop counter */
2793 int iDbSrc; /* The database of pSrc */
2794 int iSrc, iDest; /* Cursors from source and destination */
2795 int addr1, addr2; /* Loop addresses */
2796 int emptyDestTest = 0; /* Address of test for empty pDest */
2797 int emptySrcTest = 0; /* Address of test for empty pSrc */
2798 Vdbe *v; /* The VDBE we are building */
2799 int regAutoinc; /* Memory register used by AUTOINC */
2800 int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */
2801 int regData, regRowid; /* Registers holding data and rowid */
2802
2803 assert( pSelect!=0 );
2804 if( pParse->pWith || pSelect->pWith ){
2805 /* Do not attempt to process this query if there are an WITH clauses
2806 ** attached to it. Proceeding may generate a false "no such table: xxx"
2807 ** error if pSelect reads from a CTE named "xxx". */
2808 return 0;
2809 }
2810#ifndef SQLITE_OMIT_VIRTUALTABLE
2811 if( IsVirtual(pDest) ){
2812 return 0; /* tab1 must not be a virtual table */
2813 }
2814#endif
2815 if( onError==OE_Default ){
2816 if( pDest->iPKey>=0 ) onError = pDest->keyConf;
2817 if( onError==OE_Default ) onError = OE_Abort;
2818 }
2819 assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
2820 if( pSelect->pSrc->nSrc!=1 ){
2821 return 0; /* FROM clause must have exactly one term */
2822 }
2823 if( pSelect->pSrc->a[0].pSelect ){
2824 return 0; /* FROM clause cannot contain a subquery */
2825 }
2826 if( pSelect->pWhere ){
2827 return 0; /* SELECT may not have a WHERE clause */
2828 }
2829 if( pSelect->pOrderBy ){
2830 return 0; /* SELECT may not have an ORDER BY clause */
2831 }
2832 /* Do not need to test for a HAVING clause. If HAVING is present but
2833 ** there is no ORDER BY, we will get an error. */
2834 if( pSelect->pGroupBy ){
2835 return 0; /* SELECT may not have a GROUP BY clause */
2836 }
2837 if( pSelect->pLimit ){
2838 return 0; /* SELECT may not have a LIMIT clause */
2839 }
2840 if( pSelect->pPrior ){
2841 return 0; /* SELECT may not be a compound query */
2842 }
2843 if( pSelect->selFlags & SF_Distinct ){
2844 return 0; /* SELECT may not be DISTINCT */
2845 }
2846 pEList = pSelect->pEList;
2847 assert( pEList!=0 );
2848 if( pEList->nExpr!=1 ){
2849 return 0; /* The result set must have exactly one column */
2850 }
2851 assert( pEList->a[0].pExpr );
2852 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
2853 return 0; /* The result set must be the special operator "*" */
2854 }
2855
2856 /* At this point we have established that the statement is of the
2857 ** correct syntactic form to participate in this optimization. Now
2858 ** we have to check the semantics.
2859 */
2860 pItem = pSelect->pSrc->a;
2861 pSrc = sqlite3LocateTableItem(pParse, 0, pItem);
2862 if( pSrc==0 ){
2863 return 0; /* FROM clause does not contain a real table */
2864 }
2865 if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){
2866 testcase( pSrc!=pDest ); /* Possible due to bad sqlite_schema.rootpage */
2867 return 0; /* tab1 and tab2 may not be the same table */
2868 }
2869 if( HasRowid(pDest)!=HasRowid(pSrc) ){
2870 return 0; /* source and destination must both be WITHOUT ROWID or not */
2871 }
2872 if( !IsOrdinaryTable(pSrc) ){
2873 return 0; /* tab2 may not be a view or virtual table */
2874 }
2875 if( pDest->nCol!=pSrc->nCol ){
2876 return 0; /* Number of columns must be the same in tab1 and tab2 */
2877 }
2878 if( pDest->iPKey!=pSrc->iPKey ){
2879 return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
2880 }
2881 if( (pDest->tabFlags & TF_Strict)!=0 && (pSrc->tabFlags & TF_Strict)==0 ){
2882 return 0; /* Cannot feed from a non-strict into a strict table */
2883 }
2884 for(i=0; i<pDest->nCol; i++){
2885 Column *pDestCol = &pDest->aCol[i];
2886 Column *pSrcCol = &pSrc->aCol[i];
2887#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
2888 if( (db->mDbFlags & DBFLAG_Vacuum)==0
2889 && (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN
2890 ){
2891 return 0; /* Neither table may have __hidden__ columns */
2892 }
2893#endif
2894#ifndef SQLITE_OMIT_GENERATED_COLUMNS
2895 /* Even if tables t1 and t2 have identical schemas, if they contain
2896 ** generated columns, then this statement is semantically incorrect:
2897 **
2898 ** INSERT INTO t2 SELECT * FROM t1;
2899 **
2900 ** The reason is that generated column values are returned by the
2901 ** the SELECT statement on the right but the INSERT statement on the
2902 ** left wants them to be omitted.
2903 **
2904 ** Nevertheless, this is a useful notational shorthand to tell SQLite
2905 ** to do a bulk transfer all of the content from t1 over to t2.
2906 **
2907 ** We could, in theory, disable this (except for internal use by the
2908 ** VACUUM command where it is actually needed). But why do that? It
2909 ** seems harmless enough, and provides a useful service.
2910 */
2911 if( (pDestCol->colFlags & COLFLAG_GENERATED) !=
2912 (pSrcCol->colFlags & COLFLAG_GENERATED) ){
2913 return 0; /* Both columns have the same generated-column type */
2914 }
2915 /* But the transfer is only allowed if both the source and destination
2916 ** tables have the exact same expressions for generated columns.
2917 ** This requirement could be relaxed for VIRTUAL columns, I suppose.
2918 */
2919 if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){
2920 if( sqlite3ExprCompare(0,
2921 sqlite3ColumnExpr(pSrc, pSrcCol),
2922 sqlite3ColumnExpr(pDest, pDestCol), -1)!=0 ){
2923 testcase( pDestCol->colFlags & COLFLAG_VIRTUAL );
2924 testcase( pDestCol->colFlags & COLFLAG_STORED );
2925 return 0; /* Different generator expressions */
2926 }
2927 }
2928#endif
2929 if( pDestCol->affinity!=pSrcCol->affinity ){
2930 return 0; /* Affinity must be the same on all columns */
2931 }
2932 if( sqlite3_stricmp(sqlite3ColumnColl(pDestCol),
2933 sqlite3ColumnColl(pSrcCol))!=0 ){
2934 return 0; /* Collating sequence must be the same on all columns */
2935 }
2936 if( pDestCol->notNull && !pSrcCol->notNull ){
2937 return 0; /* tab2 must be NOT NULL if tab1 is */
2938 }
2939 /* Default values for second and subsequent columns need to match. */
2940 if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){
2941 Expr *pDestExpr = sqlite3ColumnExpr(pDest, pDestCol);
2942 Expr *pSrcExpr = sqlite3ColumnExpr(pSrc, pSrcCol);
2943 assert( pDestExpr==0 || pDestExpr->op==TK_SPAN );
2944 assert( pDestExpr==0 || !ExprHasProperty(pDestExpr, EP_IntValue) );
2945 assert( pSrcExpr==0 || pSrcExpr->op==TK_SPAN );
2946 assert( pSrcExpr==0 || !ExprHasProperty(pSrcExpr, EP_IntValue) );
2947 if( (pDestExpr==0)!=(pSrcExpr==0)
2948 || (pDestExpr!=0 && strcmp(pDestExpr->u.zToken,
2949 pSrcExpr->u.zToken)!=0)
2950 ){
2951 return 0; /* Default values must be the same for all columns */
2952 }
2953 }
2954 }
2955 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
2956 if( IsUniqueIndex(pDestIdx) ){
2957 destHasUniqueIdx = 1;
2958 }
2959 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
2960 if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
2961 }
2962 if( pSrcIdx==0 ){
2963 return 0; /* pDestIdx has no corresponding index in pSrc */
2964 }
2965 if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema
2966 && sqlite3FaultSim(411)==SQLITE_OK ){
2967 /* The sqlite3FaultSim() call allows this corruption test to be
2968 ** bypassed during testing, in order to exercise other corruption tests
2969 ** further downstream. */
2970 return 0; /* Corrupt schema - two indexes on the same btree */
2971 }
2972 }
2973#ifndef SQLITE_OMIT_CHECK
2974 if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){
2975 return 0; /* Tables have different CHECK constraints. Ticket #2252 */
2976 }
2977#endif
2978#ifndef SQLITE_OMIT_FOREIGN_KEY
2979 /* Disallow the transfer optimization if the destination table constains
2980 ** any foreign key constraints. This is more restrictive than necessary.
2981 ** But the main beneficiary of the transfer optimization is the VACUUM
2982 ** command, and the VACUUM command disables foreign key constraints. So
2983 ** the extra complication to make this rule less restrictive is probably
2984 ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
2985 */
2986 assert( IsOrdinaryTable(pDest) );
2987 if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->u.tab.pFKey!=0 ){
2988 return 0;
2989 }
2990#endif
2991 if( (db->flags & SQLITE_CountRows)!=0 ){
2992 return 0; /* xfer opt does not play well with PRAGMA count_changes */
2993 }
2994
2995 /* If we get this far, it means that the xfer optimization is at
2996 ** least a possibility, though it might only work if the destination
2997 ** table (tab1) is initially empty.
2998 */
2999#ifdef SQLITE_TEST
3000 sqlite3_xferopt_count++;
3001#endif
3002 iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
3003 v = sqlite3GetVdbe(pParse);
3004 sqlite3CodeVerifySchema(pParse, iDbSrc);
3005 iSrc = pParse->nTab++;
3006 iDest = pParse->nTab++;
3007 regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
3008 regData = sqlite3GetTempReg(pParse);
3009 sqlite3VdbeAddOp2(v, OP_Null, 0, regData);
3010 regRowid = sqlite3GetTempReg(pParse);
3011 sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
3012 assert( HasRowid(pDest) || destHasUniqueIdx );
3013 if( (db->mDbFlags & DBFLAG_Vacuum)==0 && (
3014 (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */
3015 || destHasUniqueIdx /* (2) */
3016 || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */
3017 )){
3018 /* In some circumstances, we are able to run the xfer optimization
3019 ** only if the destination table is initially empty. Unless the
3020 ** DBFLAG_Vacuum flag is set, this block generates code to make
3021 ** that determination. If DBFLAG_Vacuum is set, then the destination
3022 ** table is always empty.
3023 **
3024 ** Conditions under which the destination must be empty:
3025 **
3026 ** (1) There is no INTEGER PRIMARY KEY but there are indices.
3027 ** (If the destination is not initially empty, the rowid fields
3028 ** of index entries might need to change.)
3029 **
3030 ** (2) The destination has a unique index. (The xfer optimization
3031 ** is unable to test uniqueness.)
3032 **
3033 ** (3) onError is something other than OE_Abort and OE_Rollback.
3034 */
3035 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
3036 emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto);
3037 sqlite3VdbeJumpHere(v, addr1);
3038 }
3039 if( HasRowid(pSrc) ){
3040 u8 insFlags;
3041 sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
3042 emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
3043 if( pDest->iPKey>=0 ){
3044 addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
3045 if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
3046 sqlite3VdbeVerifyAbortable(v, onError);
3047 addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
3048 VdbeCoverage(v);
3049 sqlite3RowidConstraint(pParse, onError, pDest);
3050 sqlite3VdbeJumpHere(v, addr2);
3051 }
3052 autoIncStep(pParse, regAutoinc, regRowid);
3053 }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
3054 addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
3055 }else{
3056 addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
3057 assert( (pDest->tabFlags & TF_Autoincrement)==0 );
3058 }
3059
3060 if( db->mDbFlags & DBFLAG_Vacuum ){
3061 sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
3062 insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
3063 }else{
3064 insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND|OPFLAG_PREFORMAT;
3065 }
3066#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
3067 if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
3068 sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
3069 insFlags &= ~OPFLAG_PREFORMAT;
3070 }else
3071#endif
3072 {
3073 sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid);
3074 }
3075 sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
3076 if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
3077 sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE);
3078 }
3079 sqlite3VdbeChangeP5(v, insFlags);
3080
3081 sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
3082 sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
3083 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
3084 }else{
3085 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
3086 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
3087 }
3088 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
3089 u8 idxInsFlags = 0;
3090 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
3091 if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
3092 }
3093 assert( pSrcIdx );
3094 sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
3095 sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
3096 VdbeComment((v, "%s", pSrcIdx->zName));
3097 sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
3098 sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
3099 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
3100 VdbeComment((v, "%s", pDestIdx->zName));
3101 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
3102 if( db->mDbFlags & DBFLAG_Vacuum ){
3103 /* This INSERT command is part of a VACUUM operation, which guarantees
3104 ** that the destination table is empty. If all indexed columns use
3105 ** collation sequence BINARY, then it can also be assumed that the
3106 ** index will be populated by inserting keys in strictly sorted
3107 ** order. In this case, instead of seeking within the b-tree as part
3108 ** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the
3109 ** OP_IdxInsert to seek to the point within the b-tree where each key
3110 ** should be inserted. This is faster.
3111 **
3112 ** If any of the indexed columns use a collation sequence other than
3113 ** BINARY, this optimization is disabled. This is because the user
3114 ** might change the definition of a collation sequence and then run
3115 ** a VACUUM command. In that case keys may not be written in strictly
3116 ** sorted order. */
3117 for(i=0; i<pSrcIdx->nColumn; i++){
3118 const char *zColl = pSrcIdx->azColl[i];
3119 if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
3120 }
3121 if( i==pSrcIdx->nColumn ){
3122 idxInsFlags = OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
3123 sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
3124 sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc);
3125 }
3126 }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
3127 idxInsFlags |= OPFLAG_NCHANGE;
3128 }
3129 if( idxInsFlags!=(OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT) ){
3130 sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
3131 if( (db->mDbFlags & DBFLAG_Vacuum)==0
3132 && !HasRowid(pDest)
3133 && IsPrimaryKeyIndex(pDestIdx)
3134 ){
3135 codeWithoutRowidPreupdate(pParse, pDest, iDest, regData);
3136 }
3137 }
3138 sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
3139 sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
3140 sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
3141 sqlite3VdbeJumpHere(v, addr1);
3142 sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
3143 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
3144 }
3145 if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
3146 sqlite3ReleaseTempReg(pParse, regRowid);
3147 sqlite3ReleaseTempReg(pParse, regData);
3148 if( emptyDestTest ){
3149 sqlite3AutoincrementEnd(pParse);
3150 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
3151 sqlite3VdbeJumpHere(v, emptyDestTest);
3152 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
3153 return 0;
3154 }else{
3155 return 1;
3156 }
3157}
3158#endif /* SQLITE_OMIT_XFER_OPT */
3159