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