mirror of
https://github.com/sqlite/sqlite.git
synced 2025-08-08 14:02:16 +03:00
7b14b65d20
during an UPDATE to modify the the table being updated. Otherwise, those triggers might delete content out from under the update operation, leading to all kinds of problems. Ticket [314cc133e5ada126] FossilOrigin-Name: db4b7e1dc399c1f16b827ac087aa37c0815f4b2f41f1ffad59963eead2ab5562
2864 lines
108 KiB
C
2864 lines
108 KiB
C
/*
|
|
** 2001 September 15
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
** This file contains C code routines that are called by the parser
|
|
** to handle INSERT statements in SQLite.
|
|
*/
|
|
#include "sqliteInt.h"
|
|
|
|
/*
|
|
** Generate code that will
|
|
**
|
|
** (1) acquire a lock for table pTab then
|
|
** (2) open pTab as cursor iCur.
|
|
**
|
|
** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
|
|
** for that table that is actually opened.
|
|
*/
|
|
void sqlite3OpenTable(
|
|
Parse *pParse, /* Generate code into this VDBE */
|
|
int iCur, /* The cursor number of the table */
|
|
int iDb, /* The database index in sqlite3.aDb[] */
|
|
Table *pTab, /* The table to be opened */
|
|
int opcode /* OP_OpenRead or OP_OpenWrite */
|
|
){
|
|
Vdbe *v;
|
|
assert( !IsVirtual(pTab) );
|
|
v = sqlite3GetVdbe(pParse);
|
|
assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
|
|
sqlite3TableLock(pParse, iDb, pTab->tnum,
|
|
(opcode==OP_OpenWrite)?1:0, pTab->zName);
|
|
if( HasRowid(pTab) ){
|
|
sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
|
|
VdbeComment((v, "%s", pTab->zName));
|
|
}else{
|
|
Index *pPk = sqlite3PrimaryKeyIndex(pTab);
|
|
assert( pPk!=0 );
|
|
assert( pPk->tnum==pTab->tnum );
|
|
sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
|
|
sqlite3VdbeSetP4KeyInfo(pParse, pPk);
|
|
VdbeComment((v, "%s", pTab->zName));
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Return a pointer to the column affinity string associated with index
|
|
** pIdx. A column affinity string has one character for each column in
|
|
** the table, according to the affinity of the column:
|
|
**
|
|
** Character Column affinity
|
|
** ------------------------------
|
|
** 'A' BLOB
|
|
** 'B' TEXT
|
|
** 'C' NUMERIC
|
|
** 'D' INTEGER
|
|
** 'F' REAL
|
|
**
|
|
** An extra 'D' is appended to the end of the string to cover the
|
|
** rowid that appears as the last column in every index.
|
|
**
|
|
** Memory for the buffer containing the column index affinity string
|
|
** is managed along with the rest of the Index structure. It will be
|
|
** released when sqlite3DeleteIndex() is called.
|
|
*/
|
|
const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
|
|
if( !pIdx->zColAff ){
|
|
/* The first time a column affinity string for a particular index is
|
|
** required, it is allocated and populated here. It is then stored as
|
|
** a member of the Index structure for subsequent use.
|
|
**
|
|
** The column affinity string will eventually be deleted by
|
|
** sqliteDeleteIndex() when the Index structure itself is cleaned
|
|
** up.
|
|
*/
|
|
int n;
|
|
Table *pTab = pIdx->pTable;
|
|
pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
|
|
if( !pIdx->zColAff ){
|
|
sqlite3OomFault(db);
|
|
return 0;
|
|
}
|
|
for(n=0; n<pIdx->nColumn; n++){
|
|
i16 x = pIdx->aiColumn[n];
|
|
char aff;
|
|
if( x>=0 ){
|
|
aff = pTab->aCol[x].affinity;
|
|
}else if( x==XN_ROWID ){
|
|
aff = SQLITE_AFF_INTEGER;
|
|
}else{
|
|
assert( x==XN_EXPR );
|
|
assert( pIdx->aColExpr!=0 );
|
|
aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
|
|
}
|
|
if( aff<SQLITE_AFF_BLOB ) aff = SQLITE_AFF_BLOB;
|
|
if( aff>SQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC;
|
|
pIdx->zColAff[n] = aff;
|
|
}
|
|
pIdx->zColAff[n] = 0;
|
|
}
|
|
|
|
return pIdx->zColAff;
|
|
}
|
|
|
|
/*
|
|
** Compute the affinity string for table pTab, if it has not already been
|
|
** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities.
|
|
**
|
|
** If the affinity exists (if it is no entirely SQLITE_AFF_BLOB values) and
|
|
** if iReg>0 then code an OP_Affinity opcode that will set the affinities
|
|
** for register iReg and following. Or if affinities exists and iReg==0,
|
|
** then just set the P4 operand of the previous opcode (which should be
|
|
** an OP_MakeRecord) to the affinity string.
|
|
**
|
|
** A column affinity string has one character per column:
|
|
**
|
|
** Character Column affinity
|
|
** ------------------------------
|
|
** 'A' BLOB
|
|
** 'B' TEXT
|
|
** 'C' NUMERIC
|
|
** 'D' INTEGER
|
|
** 'E' REAL
|
|
*/
|
|
void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
|
|
int i, j;
|
|
char *zColAff = pTab->zColAff;
|
|
if( zColAff==0 ){
|
|
sqlite3 *db = sqlite3VdbeDb(v);
|
|
zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
|
|
if( !zColAff ){
|
|
sqlite3OomFault(db);
|
|
return;
|
|
}
|
|
|
|
for(i=j=0; i<pTab->nCol; i++){
|
|
assert( pTab->aCol[i].affinity!=0 );
|
|
if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
|
|
zColAff[j++] = pTab->aCol[i].affinity;
|
|
}
|
|
}
|
|
do{
|
|
zColAff[j--] = 0;
|
|
}while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB );
|
|
pTab->zColAff = zColAff;
|
|
}
|
|
assert( zColAff!=0 );
|
|
i = sqlite3Strlen30NN(zColAff);
|
|
if( i ){
|
|
if( iReg ){
|
|
sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
|
|
}else{
|
|
sqlite3VdbeChangeP4(v, -1, zColAff, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Return non-zero if the table pTab in database iDb or any of its indices
|
|
** have been opened at any point in the VDBE program. This is used to see if
|
|
** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
|
|
** run without using a temporary table for the results of the SELECT.
|
|
*/
|
|
static int readsTable(Parse *p, int iDb, Table *pTab){
|
|
Vdbe *v = sqlite3GetVdbe(p);
|
|
int i;
|
|
int iEnd = sqlite3VdbeCurrentAddr(v);
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
|
|
#endif
|
|
|
|
for(i=1; i<iEnd; i++){
|
|
VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
|
|
assert( pOp!=0 );
|
|
if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
|
|
Index *pIndex;
|
|
int tnum = pOp->p2;
|
|
if( tnum==pTab->tnum ){
|
|
return 1;
|
|
}
|
|
for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
|
|
if( tnum==pIndex->tnum ){
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
|
|
assert( pOp->p4.pVtab!=0 );
|
|
assert( pOp->p4type==P4_VTAB );
|
|
return 1;
|
|
}
|
|
#endif
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* This walker callback will compute the union of colFlags flags for all
|
|
** referenced columns in a CHECK constraint or generated column expression.
|
|
*/
|
|
static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
|
|
if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
|
|
assert( pExpr->iColumn < pWalker->u.pTab->nCol );
|
|
pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
|
|
}
|
|
return WRC_Continue;
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
/*
|
|
** All regular columns for table pTab have been puts into registers
|
|
** starting with iRegStore. The registers that correspond to STORED
|
|
** or VIRTUAL columns have not yet been initialized. This routine goes
|
|
** back and computes the values for those columns based on the previously
|
|
** computed normal columns.
|
|
*/
|
|
void sqlite3ComputeGeneratedColumns(
|
|
Parse *pParse, /* Parsing context */
|
|
int iRegStore, /* Register holding the first column */
|
|
Table *pTab /* The table */
|
|
){
|
|
int i;
|
|
Walker w;
|
|
Column *pRedo;
|
|
int eProgress;
|
|
VdbeOp *pOp;
|
|
|
|
assert( pTab->tabFlags & TF_HasGenerated );
|
|
testcase( pTab->tabFlags & TF_HasVirtual );
|
|
testcase( pTab->tabFlags & TF_HasStored );
|
|
|
|
/* Before computing generated columns, first go through and make sure
|
|
** that appropriate affinity has been applied to the regular columns
|
|
*/
|
|
sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
|
|
if( (pTab->tabFlags & TF_HasStored)!=0
|
|
&& (pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1))->opcode==OP_Affinity
|
|
){
|
|
/* Change the OP_Affinity argument to '@' (NONE) for all stored
|
|
** columns. '@' is the no-op affinity and those columns have not
|
|
** yet been computed. */
|
|
int ii, jj;
|
|
char *zP4 = pOp->p4.z;
|
|
assert( zP4!=0 );
|
|
assert( pOp->p4type==P4_DYNAMIC );
|
|
for(ii=jj=0; zP4[jj]; ii++){
|
|
if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
|
|
continue;
|
|
}
|
|
if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
|
|
zP4[jj] = SQLITE_AFF_NONE;
|
|
}
|
|
jj++;
|
|
}
|
|
}
|
|
|
|
/* Because there can be multiple generated columns that refer to one another,
|
|
** this is a two-pass algorithm. On the first pass, mark all generated
|
|
** columns as "not available".
|
|
*/
|
|
for(i=0; i<pTab->nCol; i++){
|
|
if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
|
|
testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
|
|
testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
|
|
pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL;
|
|
}
|
|
}
|
|
|
|
w.u.pTab = pTab;
|
|
w.xExprCallback = exprColumnFlagUnion;
|
|
w.xSelectCallback = 0;
|
|
w.xSelectCallback2 = 0;
|
|
|
|
/* On the second pass, compute the value of each NOT-AVAILABLE column.
|
|
** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will
|
|
** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as
|
|
** they are needed.
|
|
*/
|
|
pParse->iSelfTab = -iRegStore;
|
|
do{
|
|
eProgress = 0;
|
|
pRedo = 0;
|
|
for(i=0; i<pTab->nCol; i++){
|
|
Column *pCol = pTab->aCol + i;
|
|
if( (pCol->colFlags & COLFLAG_NOTAVAIL)!=0 ){
|
|
int x;
|
|
pCol->colFlags |= COLFLAG_BUSY;
|
|
w.eCode = 0;
|
|
sqlite3WalkExpr(&w, pCol->pDflt);
|
|
pCol->colFlags &= ~COLFLAG_BUSY;
|
|
if( w.eCode & COLFLAG_NOTAVAIL ){
|
|
pRedo = pCol;
|
|
continue;
|
|
}
|
|
eProgress = 1;
|
|
assert( pCol->colFlags & COLFLAG_GENERATED );
|
|
x = sqlite3TableColumnToStorage(pTab, i) + iRegStore;
|
|
sqlite3ExprCodeGeneratedColumn(pParse, pCol, x);
|
|
pCol->colFlags &= ~COLFLAG_NOTAVAIL;
|
|
}
|
|
}
|
|
}while( pRedo && eProgress );
|
|
if( pRedo ){
|
|
sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zName);
|
|
}
|
|
pParse->iSelfTab = 0;
|
|
}
|
|
#endif /* SQLITE_OMIT_GENERATED_COLUMNS */
|
|
|
|
|
|
#ifndef SQLITE_OMIT_AUTOINCREMENT
|
|
/*
|
|
** Locate or create an AutoincInfo structure associated with table pTab
|
|
** which is in database iDb. Return the register number for the register
|
|
** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT
|
|
** table. (Also return zero when doing a VACUUM since we do not want to
|
|
** update the AUTOINCREMENT counters during a VACUUM.)
|
|
**
|
|
** There is at most one AutoincInfo structure per table even if the
|
|
** same table is autoincremented multiple times due to inserts within
|
|
** triggers. A new AutoincInfo structure is created if this is the
|
|
** first use of table pTab. On 2nd and subsequent uses, the original
|
|
** AutoincInfo structure is used.
|
|
**
|
|
** Four consecutive registers are allocated:
|
|
**
|
|
** (1) The name of the pTab table.
|
|
** (2) The maximum ROWID of pTab.
|
|
** (3) The rowid in sqlite_sequence of pTab
|
|
** (4) The original value of the max ROWID in pTab, or NULL if none
|
|
**
|
|
** The 2nd register is the one that is returned. That is all the
|
|
** insert routine needs to know about.
|
|
*/
|
|
static int autoIncBegin(
|
|
Parse *pParse, /* Parsing context */
|
|
int iDb, /* Index of the database holding pTab */
|
|
Table *pTab /* The table we are writing to */
|
|
){
|
|
int memId = 0; /* Register holding maximum rowid */
|
|
assert( pParse->db->aDb[iDb].pSchema!=0 );
|
|
if( (pTab->tabFlags & TF_Autoincrement)!=0
|
|
&& (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
|
|
){
|
|
Parse *pToplevel = sqlite3ParseToplevel(pParse);
|
|
AutoincInfo *pInfo;
|
|
Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
|
|
|
|
/* Verify that the sqlite_sequence table exists and is an ordinary
|
|
** rowid table with exactly two columns.
|
|
** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
|
|
if( pSeqTab==0
|
|
|| !HasRowid(pSeqTab)
|
|
|| IsVirtual(pSeqTab)
|
|
|| pSeqTab->nCol!=2
|
|
){
|
|
pParse->nErr++;
|
|
pParse->rc = SQLITE_CORRUPT_SEQUENCE;
|
|
return 0;
|
|
}
|
|
|
|
pInfo = pToplevel->pAinc;
|
|
while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
|
|
if( pInfo==0 ){
|
|
pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
|
|
if( pInfo==0 ) return 0;
|
|
pInfo->pNext = pToplevel->pAinc;
|
|
pToplevel->pAinc = pInfo;
|
|
pInfo->pTab = pTab;
|
|
pInfo->iDb = iDb;
|
|
pToplevel->nMem++; /* Register to hold name of table */
|
|
pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */
|
|
pToplevel->nMem +=2; /* Rowid in sqlite_sequence + orig max val */
|
|
}
|
|
memId = pInfo->regCtr;
|
|
}
|
|
return memId;
|
|
}
|
|
|
|
/*
|
|
** This routine generates code that will initialize all of the
|
|
** register used by the autoincrement tracker.
|
|
*/
|
|
void sqlite3AutoincrementBegin(Parse *pParse){
|
|
AutoincInfo *p; /* Information about an AUTOINCREMENT */
|
|
sqlite3 *db = pParse->db; /* The database connection */
|
|
Db *pDb; /* Database only autoinc table */
|
|
int memId; /* Register holding max rowid */
|
|
Vdbe *v = pParse->pVdbe; /* VDBE under construction */
|
|
|
|
/* This routine is never called during trigger-generation. It is
|
|
** only called from the top-level */
|
|
assert( pParse->pTriggerTab==0 );
|
|
assert( sqlite3IsToplevel(pParse) );
|
|
|
|
assert( v ); /* We failed long ago if this is not so */
|
|
for(p = pParse->pAinc; p; p = p->pNext){
|
|
static const int iLn = VDBE_OFFSET_LINENO(2);
|
|
static const VdbeOpList autoInc[] = {
|
|
/* 0 */ {OP_Null, 0, 0, 0},
|
|
/* 1 */ {OP_Rewind, 0, 10, 0},
|
|
/* 2 */ {OP_Column, 0, 0, 0},
|
|
/* 3 */ {OP_Ne, 0, 9, 0},
|
|
/* 4 */ {OP_Rowid, 0, 0, 0},
|
|
/* 5 */ {OP_Column, 0, 1, 0},
|
|
/* 6 */ {OP_AddImm, 0, 0, 0},
|
|
/* 7 */ {OP_Copy, 0, 0, 0},
|
|
/* 8 */ {OP_Goto, 0, 11, 0},
|
|
/* 9 */ {OP_Next, 0, 2, 0},
|
|
/* 10 */ {OP_Integer, 0, 0, 0},
|
|
/* 11 */ {OP_Close, 0, 0, 0}
|
|
};
|
|
VdbeOp *aOp;
|
|
pDb = &db->aDb[p->iDb];
|
|
memId = p->regCtr;
|
|
assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
|
|
sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
|
|
sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
|
|
aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
|
|
if( aOp==0 ) break;
|
|
aOp[0].p2 = memId;
|
|
aOp[0].p3 = memId+2;
|
|
aOp[2].p3 = memId;
|
|
aOp[3].p1 = memId-1;
|
|
aOp[3].p3 = memId;
|
|
aOp[3].p5 = SQLITE_JUMPIFNULL;
|
|
aOp[4].p2 = memId+1;
|
|
aOp[5].p3 = memId;
|
|
aOp[6].p1 = memId;
|
|
aOp[7].p2 = memId+2;
|
|
aOp[7].p1 = memId;
|
|
aOp[10].p2 = memId;
|
|
if( pParse->nTab==0 ) pParse->nTab = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Update the maximum rowid for an autoincrement calculation.
|
|
**
|
|
** This routine should be called when the regRowid register holds a
|
|
** new rowid that is about to be inserted. If that new rowid is
|
|
** larger than the maximum rowid in the memId memory cell, then the
|
|
** memory cell is updated.
|
|
*/
|
|
static void autoIncStep(Parse *pParse, int memId, int regRowid){
|
|
if( memId>0 ){
|
|
sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** This routine generates the code needed to write autoincrement
|
|
** maximum rowid values back into the sqlite_sequence register.
|
|
** Every statement that might do an INSERT into an autoincrement
|
|
** table (either directly or through triggers) needs to call this
|
|
** routine just before the "exit" code.
|
|
*/
|
|
static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
|
|
AutoincInfo *p;
|
|
Vdbe *v = pParse->pVdbe;
|
|
sqlite3 *db = pParse->db;
|
|
|
|
assert( v );
|
|
for(p = pParse->pAinc; p; p = p->pNext){
|
|
static const int iLn = VDBE_OFFSET_LINENO(2);
|
|
static const VdbeOpList autoIncEnd[] = {
|
|
/* 0 */ {OP_NotNull, 0, 2, 0},
|
|
/* 1 */ {OP_NewRowid, 0, 0, 0},
|
|
/* 2 */ {OP_MakeRecord, 0, 2, 0},
|
|
/* 3 */ {OP_Insert, 0, 0, 0},
|
|
/* 4 */ {OP_Close, 0, 0, 0}
|
|
};
|
|
VdbeOp *aOp;
|
|
Db *pDb = &db->aDb[p->iDb];
|
|
int iRec;
|
|
int memId = p->regCtr;
|
|
|
|
iRec = sqlite3GetTempReg(pParse);
|
|
assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
|
|
sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
|
|
VdbeCoverage(v);
|
|
sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
|
|
aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
|
|
if( aOp==0 ) break;
|
|
aOp[0].p1 = memId+1;
|
|
aOp[1].p2 = memId+1;
|
|
aOp[2].p1 = memId-1;
|
|
aOp[2].p3 = iRec;
|
|
aOp[3].p2 = iRec;
|
|
aOp[3].p3 = memId+1;
|
|
aOp[3].p5 = OPFLAG_APPEND;
|
|
sqlite3ReleaseTempReg(pParse, iRec);
|
|
}
|
|
}
|
|
void sqlite3AutoincrementEnd(Parse *pParse){
|
|
if( pParse->pAinc ) autoIncrementEnd(pParse);
|
|
}
|
|
#else
|
|
/*
|
|
** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
|
|
** above are all no-ops
|
|
*/
|
|
# define autoIncBegin(A,B,C) (0)
|
|
# define autoIncStep(A,B,C)
|
|
#endif /* SQLITE_OMIT_AUTOINCREMENT */
|
|
|
|
|
|
/* Forward declaration */
|
|
static int xferOptimization(
|
|
Parse *pParse, /* Parser context */
|
|
Table *pDest, /* The table we are inserting into */
|
|
Select *pSelect, /* A SELECT statement to use as the data source */
|
|
int onError, /* How to handle constraint errors */
|
|
int iDbDest /* The database of pDest */
|
|
);
|
|
|
|
/*
|
|
** This routine is called to handle SQL of the following forms:
|
|
**
|
|
** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),...
|
|
** insert into TABLE (IDLIST) select
|
|
** insert into TABLE (IDLIST) default values
|
|
**
|
|
** The IDLIST following the table name is always optional. If omitted,
|
|
** then a list of all (non-hidden) columns for the table is substituted.
|
|
** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST
|
|
** is omitted.
|
|
**
|
|
** For the pSelect parameter holds the values to be inserted for the
|
|
** first two forms shown above. A VALUES clause is really just short-hand
|
|
** for a SELECT statement that omits the FROM clause and everything else
|
|
** that follows. If the pSelect parameter is NULL, that means that the
|
|
** DEFAULT VALUES form of the INSERT statement is intended.
|
|
**
|
|
** The code generated follows one of four templates. For a simple
|
|
** insert with data coming from a single-row VALUES clause, the code executes
|
|
** once straight down through. Pseudo-code follows (we call this
|
|
** the "1st template"):
|
|
**
|
|
** open write cursor to <table> and its indices
|
|
** put VALUES clause expressions into registers
|
|
** write the resulting record into <table>
|
|
** cleanup
|
|
**
|
|
** The three remaining templates assume the statement is of the form
|
|
**
|
|
** INSERT INTO <table> SELECT ...
|
|
**
|
|
** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
|
|
** in other words if the SELECT pulls all columns from a single table
|
|
** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
|
|
** if <table2> and <table1> are distinct tables but have identical
|
|
** schemas, including all the same indices, then a special optimization
|
|
** is invoked that copies raw records from <table2> over to <table1>.
|
|
** See the xferOptimization() function for the implementation of this
|
|
** template. This is the 2nd template.
|
|
**
|
|
** open a write cursor to <table>
|
|
** open read cursor on <table2>
|
|
** transfer all records in <table2> over to <table>
|
|
** close cursors
|
|
** foreach index on <table>
|
|
** open a write cursor on the <table> index
|
|
** open a read cursor on the corresponding <table2> index
|
|
** transfer all records from the read to the write cursors
|
|
** close cursors
|
|
** end foreach
|
|
**
|
|
** The 3rd template is for when the second template does not apply
|
|
** and the SELECT clause does not read from <table> at any time.
|
|
** The generated code follows this template:
|
|
**
|
|
** X <- A
|
|
** goto B
|
|
** A: setup for the SELECT
|
|
** loop over the rows in the SELECT
|
|
** load values into registers R..R+n
|
|
** yield X
|
|
** end loop
|
|
** cleanup after the SELECT
|
|
** end-coroutine X
|
|
** B: open write cursor to <table> and its indices
|
|
** C: yield X, at EOF goto D
|
|
** insert the select result into <table> from R..R+n
|
|
** goto C
|
|
** D: cleanup
|
|
**
|
|
** The 4th template is used if the insert statement takes its
|
|
** values from a SELECT but the data is being inserted into a table
|
|
** that is also read as part of the SELECT. In the third form,
|
|
** we have to use an intermediate table to store the results of
|
|
** the select. The template is like this:
|
|
**
|
|
** X <- A
|
|
** goto B
|
|
** A: setup for the SELECT
|
|
** loop over the tables in the SELECT
|
|
** load value into register R..R+n
|
|
** yield X
|
|
** end loop
|
|
** cleanup after the SELECT
|
|
** end co-routine R
|
|
** B: open temp table
|
|
** L: yield X, at EOF goto M
|
|
** insert row from R..R+n into temp table
|
|
** goto L
|
|
** M: open write cursor to <table> and its indices
|
|
** rewind temp table
|
|
** C: loop over rows of intermediate table
|
|
** transfer values form intermediate table into <table>
|
|
** end loop
|
|
** D: cleanup
|
|
*/
|
|
void sqlite3Insert(
|
|
Parse *pParse, /* Parser context */
|
|
SrcList *pTabList, /* Name of table into which we are inserting */
|
|
Select *pSelect, /* A SELECT statement to use as the data source */
|
|
IdList *pColumn, /* Column names corresponding to IDLIST, or NULL. */
|
|
int onError, /* How to handle constraint errors */
|
|
Upsert *pUpsert /* ON CONFLICT clauses for upsert, or NULL */
|
|
){
|
|
sqlite3 *db; /* The main database structure */
|
|
Table *pTab; /* The table to insert into. aka TABLE */
|
|
int i, j; /* Loop counters */
|
|
Vdbe *v; /* Generate code into this virtual machine */
|
|
Index *pIdx; /* For looping over indices of the table */
|
|
int nColumn; /* Number of columns in the data */
|
|
int nHidden = 0; /* Number of hidden columns if TABLE is virtual */
|
|
int iDataCur = 0; /* VDBE cursor that is the main data repository */
|
|
int iIdxCur = 0; /* First index cursor */
|
|
int ipkColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
|
|
int endOfLoop; /* Label for the end of the insertion loop */
|
|
int srcTab = 0; /* Data comes from this temporary cursor if >=0 */
|
|
int addrInsTop = 0; /* Jump to label "D" */
|
|
int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */
|
|
SelectDest dest; /* Destination for SELECT on rhs of INSERT */
|
|
int iDb; /* Index of database holding TABLE */
|
|
u8 useTempTable = 0; /* Store SELECT results in intermediate table */
|
|
u8 appendFlag = 0; /* True if the insert is likely to be an append */
|
|
u8 withoutRowid; /* 0 for normal table. 1 for WITHOUT ROWID table */
|
|
u8 bIdListInOrder; /* True if IDLIST is in table order */
|
|
ExprList *pList = 0; /* List of VALUES() to be inserted */
|
|
int iRegStore; /* Register in which to store next column */
|
|
|
|
/* Register allocations */
|
|
int regFromSelect = 0;/* Base register for data coming from SELECT */
|
|
int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */
|
|
int regRowCount = 0; /* Memory cell used for the row counter */
|
|
int regIns; /* Block of regs holding rowid+data being inserted */
|
|
int regRowid; /* registers holding insert rowid */
|
|
int regData; /* register holding first column to insert */
|
|
int *aRegIdx = 0; /* One register allocated to each index */
|
|
|
|
#ifndef SQLITE_OMIT_TRIGGER
|
|
int isView; /* True if attempting to insert into a view */
|
|
Trigger *pTrigger; /* List of triggers on pTab, if required */
|
|
int tmask; /* Mask of trigger times */
|
|
#endif
|
|
|
|
db = pParse->db;
|
|
if( pParse->nErr || db->mallocFailed ){
|
|
goto insert_cleanup;
|
|
}
|
|
dest.iSDParm = 0; /* Suppress a harmless compiler warning */
|
|
|
|
/* If the Select object is really just a simple VALUES() list with a
|
|
** single row (the common case) then keep that one row of values
|
|
** and discard the other (unused) parts of the pSelect object
|
|
*/
|
|
if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
|
|
pList = pSelect->pEList;
|
|
pSelect->pEList = 0;
|
|
sqlite3SelectDelete(db, pSelect);
|
|
pSelect = 0;
|
|
}
|
|
|
|
/* Locate the table into which we will be inserting new information.
|
|
*/
|
|
assert( pTabList->nSrc==1 );
|
|
pTab = sqlite3SrcListLookup(pParse, pTabList);
|
|
if( pTab==0 ){
|
|
goto insert_cleanup;
|
|
}
|
|
iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
|
|
assert( iDb<db->nDb );
|
|
if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
|
|
db->aDb[iDb].zDbSName) ){
|
|
goto insert_cleanup;
|
|
}
|
|
withoutRowid = !HasRowid(pTab);
|
|
|
|
/* Figure out if we have any triggers and if the table being
|
|
** inserted into is a view
|
|
*/
|
|
#ifndef SQLITE_OMIT_TRIGGER
|
|
pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
|
|
isView = pTab->pSelect!=0;
|
|
#else
|
|
# define pTrigger 0
|
|
# define tmask 0
|
|
# define isView 0
|
|
#endif
|
|
#ifdef SQLITE_OMIT_VIEW
|
|
# undef isView
|
|
# define isView 0
|
|
#endif
|
|
assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
|
|
|
|
/* If pTab is really a view, make sure it has been initialized.
|
|
** ViewGetColumnNames() is a no-op if pTab is not a view.
|
|
*/
|
|
if( sqlite3ViewGetColumnNames(pParse, pTab) ){
|
|
goto insert_cleanup;
|
|
}
|
|
|
|
/* Cannot insert into a read-only table.
|
|
*/
|
|
if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
|
|
goto insert_cleanup;
|
|
}
|
|
|
|
/* Allocate a VDBE
|
|
*/
|
|
v = sqlite3GetVdbe(pParse);
|
|
if( v==0 ) goto insert_cleanup;
|
|
if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
|
|
sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
|
|
|
|
#ifndef SQLITE_OMIT_XFER_OPT
|
|
/* If the statement is of the form
|
|
**
|
|
** INSERT INTO <table1> SELECT * FROM <table2>;
|
|
**
|
|
** Then special optimizations can be applied that make the transfer
|
|
** very fast and which reduce fragmentation of indices.
|
|
**
|
|
** This is the 2nd template.
|
|
*/
|
|
if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
|
|
assert( !pTrigger );
|
|
assert( pList==0 );
|
|
goto insert_end;
|
|
}
|
|
#endif /* SQLITE_OMIT_XFER_OPT */
|
|
|
|
/* If this is an AUTOINCREMENT table, look up the sequence number in the
|
|
** sqlite_sequence table and store it in memory cell regAutoinc.
|
|
*/
|
|
regAutoinc = autoIncBegin(pParse, iDb, pTab);
|
|
|
|
/* Allocate a block registers to hold the rowid and the values
|
|
** for all columns of the new row.
|
|
*/
|
|
regRowid = regIns = pParse->nMem+1;
|
|
pParse->nMem += pTab->nCol + 1;
|
|
if( IsVirtual(pTab) ){
|
|
regRowid++;
|
|
pParse->nMem++;
|
|
}
|
|
regData = regRowid+1;
|
|
|
|
/* If the INSERT statement included an IDLIST term, then make sure
|
|
** all elements of the IDLIST really are columns of the table and
|
|
** remember the column indices.
|
|
**
|
|
** If the table has an INTEGER PRIMARY KEY column and that column
|
|
** is named in the IDLIST, then record in the ipkColumn variable
|
|
** the index into IDLIST of the primary key column. ipkColumn is
|
|
** the index of the primary key as it appears in IDLIST, not as
|
|
** is appears in the original table. (The index of the INTEGER
|
|
** PRIMARY KEY in the original table is pTab->iPKey.) After this
|
|
** loop, if ipkColumn==(-1), that means that integer primary key
|
|
** is unspecified, and hence the table is either WITHOUT ROWID or
|
|
** it will automatically generated an integer primary key.
|
|
**
|
|
** bIdListInOrder is true if the columns in IDLIST are in storage
|
|
** order. This enables an optimization that avoids shuffling the
|
|
** columns into storage order. False negatives are harmless,
|
|
** but false positives will cause database corruption.
|
|
*/
|
|
bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0;
|
|
if( pColumn ){
|
|
for(i=0; i<pColumn->nId; i++){
|
|
pColumn->a[i].idx = -1;
|
|
}
|
|
for(i=0; i<pColumn->nId; i++){
|
|
for(j=0; j<pTab->nCol; j++){
|
|
if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
|
|
pColumn->a[i].idx = j;
|
|
if( i!=j ) bIdListInOrder = 0;
|
|
if( j==pTab->iPKey ){
|
|
ipkColumn = i; assert( !withoutRowid );
|
|
}
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"cannot INSERT into generated column \"%s\"",
|
|
pTab->aCol[j].zName);
|
|
goto insert_cleanup;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
if( j>=pTab->nCol ){
|
|
if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
|
|
ipkColumn = i;
|
|
bIdListInOrder = 0;
|
|
}else{
|
|
sqlite3ErrorMsg(pParse, "table %S has no column named %s",
|
|
pTabList, 0, pColumn->a[i].zName);
|
|
pParse->checkSchema = 1;
|
|
goto insert_cleanup;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Figure out how many columns of data are supplied. If the data
|
|
** is coming from a SELECT statement, then generate a co-routine that
|
|
** produces a single row of the SELECT on each invocation. The
|
|
** co-routine is the common header to the 3rd and 4th templates.
|
|
*/
|
|
if( pSelect ){
|
|
/* Data is coming from a SELECT or from a multi-row VALUES clause.
|
|
** Generate a co-routine to run the SELECT. */
|
|
int regYield; /* Register holding co-routine entry-point */
|
|
int addrTop; /* Top of the co-routine */
|
|
int rc; /* Result code */
|
|
|
|
regYield = ++pParse->nMem;
|
|
addrTop = sqlite3VdbeCurrentAddr(v) + 1;
|
|
sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
|
|
sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
|
|
dest.iSdst = bIdListInOrder ? regData : 0;
|
|
dest.nSdst = pTab->nCol;
|
|
rc = sqlite3Select(pParse, pSelect, &dest);
|
|
regFromSelect = dest.iSdst;
|
|
if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup;
|
|
sqlite3VdbeEndCoroutine(v, regYield);
|
|
sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
|
|
assert( pSelect->pEList );
|
|
nColumn = pSelect->pEList->nExpr;
|
|
|
|
/* Set useTempTable to TRUE if the result of the SELECT statement
|
|
** should be written into a temporary table (template 4). Set to
|
|
** FALSE if each output row of the SELECT can be written directly into
|
|
** the destination table (template 3).
|
|
**
|
|
** A temp table must be used if the table being updated is also one
|
|
** of the tables being read by the SELECT statement. Also use a
|
|
** temp table in the case of row triggers.
|
|
*/
|
|
if( pTrigger || readsTable(pParse, iDb, pTab) ){
|
|
useTempTable = 1;
|
|
}
|
|
|
|
if( useTempTable ){
|
|
/* Invoke the coroutine to extract information from the SELECT
|
|
** and add it to a transient table srcTab. The code generated
|
|
** here is from the 4th template:
|
|
**
|
|
** B: open temp table
|
|
** L: yield X, goto M at EOF
|
|
** insert row from R..R+n into temp table
|
|
** goto L
|
|
** M: ...
|
|
*/
|
|
int regRec; /* Register to hold packed record */
|
|
int regTempRowid; /* Register to hold temp table ROWID */
|
|
int addrL; /* Label "L" */
|
|
|
|
srcTab = pParse->nTab++;
|
|
regRec = sqlite3GetTempReg(pParse);
|
|
regTempRowid = sqlite3GetTempReg(pParse);
|
|
sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
|
|
addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v);
|
|
sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
|
|
sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
|
|
sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
|
|
sqlite3VdbeGoto(v, addrL);
|
|
sqlite3VdbeJumpHere(v, addrL);
|
|
sqlite3ReleaseTempReg(pParse, regRec);
|
|
sqlite3ReleaseTempReg(pParse, regTempRowid);
|
|
}
|
|
}else{
|
|
/* This is the case if the data for the INSERT is coming from a
|
|
** single-row VALUES clause
|
|
*/
|
|
NameContext sNC;
|
|
memset(&sNC, 0, sizeof(sNC));
|
|
sNC.pParse = pParse;
|
|
srcTab = -1;
|
|
assert( useTempTable==0 );
|
|
if( pList ){
|
|
nColumn = pList->nExpr;
|
|
if( sqlite3ResolveExprListNames(&sNC, pList) ){
|
|
goto insert_cleanup;
|
|
}
|
|
}else{
|
|
nColumn = 0;
|
|
}
|
|
}
|
|
|
|
/* If there is no IDLIST term but the table has an integer primary
|
|
** key, the set the ipkColumn variable to the integer primary key
|
|
** column index in the original table definition.
|
|
*/
|
|
if( pColumn==0 && nColumn>0 ){
|
|
ipkColumn = pTab->iPKey;
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
|
|
testcase( pTab->tabFlags & TF_HasVirtual );
|
|
testcase( pTab->tabFlags & TF_HasStored );
|
|
for(i=ipkColumn-1; i>=0; i--){
|
|
if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
|
|
testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
|
|
testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
|
|
ipkColumn--;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* Make sure the number of columns in the source data matches the number
|
|
** of columns to be inserted into the table.
|
|
*/
|
|
for(i=0; i<pTab->nCol; i++){
|
|
if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
|
|
}
|
|
if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
|
|
sqlite3ErrorMsg(pParse,
|
|
"table %S has %d columns but %d values were supplied",
|
|
pTabList, 0, pTab->nCol-nHidden, nColumn);
|
|
goto insert_cleanup;
|
|
}
|
|
if( pColumn!=0 && nColumn!=pColumn->nId ){
|
|
sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
|
|
goto insert_cleanup;
|
|
}
|
|
|
|
/* Initialize the count of rows to be inserted
|
|
*/
|
|
if( (db->flags & SQLITE_CountRows)!=0
|
|
&& !pParse->nested
|
|
&& !pParse->pTriggerTab
|
|
){
|
|
regRowCount = ++pParse->nMem;
|
|
sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
|
|
}
|
|
|
|
/* If this is not a view, open the table and and all indices */
|
|
if( !isView ){
|
|
int nIdx;
|
|
nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
|
|
&iDataCur, &iIdxCur);
|
|
aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2));
|
|
if( aRegIdx==0 ){
|
|
goto insert_cleanup;
|
|
}
|
|
for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
|
|
assert( pIdx );
|
|
aRegIdx[i] = ++pParse->nMem;
|
|
pParse->nMem += pIdx->nColumn;
|
|
}
|
|
aRegIdx[i] = ++pParse->nMem; /* Register to store the table record */
|
|
}
|
|
#ifndef SQLITE_OMIT_UPSERT
|
|
if( pUpsert ){
|
|
if( IsVirtual(pTab) ){
|
|
sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
|
|
pTab->zName);
|
|
goto insert_cleanup;
|
|
}
|
|
if( pTab->pSelect ){
|
|
sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
|
|
goto insert_cleanup;
|
|
}
|
|
if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
|
|
goto insert_cleanup;
|
|
}
|
|
pTabList->a[0].iCursor = iDataCur;
|
|
pUpsert->pUpsertSrc = pTabList;
|
|
pUpsert->regData = regData;
|
|
pUpsert->iDataCur = iDataCur;
|
|
pUpsert->iIdxCur = iIdxCur;
|
|
if( pUpsert->pUpsertTarget ){
|
|
sqlite3UpsertAnalyzeTarget(pParse, pTabList, pUpsert);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/* This is the top of the main insertion loop */
|
|
if( useTempTable ){
|
|
/* This block codes the top of loop only. The complete loop is the
|
|
** following pseudocode (template 4):
|
|
**
|
|
** rewind temp table, if empty goto D
|
|
** C: loop over rows of intermediate table
|
|
** transfer values form intermediate table into <table>
|
|
** end loop
|
|
** D: ...
|
|
*/
|
|
addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v);
|
|
addrCont = sqlite3VdbeCurrentAddr(v);
|
|
}else if( pSelect ){
|
|
/* This block codes the top of loop only. The complete loop is the
|
|
** following pseudocode (template 3):
|
|
**
|
|
** C: yield X, at EOF goto D
|
|
** insert the select result into <table> from R..R+n
|
|
** goto C
|
|
** D: ...
|
|
*/
|
|
sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0);
|
|
addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
|
|
VdbeCoverage(v);
|
|
if( ipkColumn>=0 ){
|
|
/* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
|
|
** SELECT, go ahead and copy the value into the rowid slot now, so that
|
|
** the value does not get overwritten by a NULL at tag-20191021-002. */
|
|
sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);
|
|
}
|
|
}
|
|
|
|
/* Compute data for ordinary columns of the new entry. Values
|
|
** are written in storage order into registers starting with regData.
|
|
** Only ordinary columns are computed in this loop. The rowid
|
|
** (if there is one) is computed later and generated columns are
|
|
** computed after the rowid since they might depend on the value
|
|
** of the rowid.
|
|
*/
|
|
nHidden = 0;
|
|
iRegStore = regData; assert( regData==regRowid+1 );
|
|
for(i=0; i<pTab->nCol; i++, iRegStore++){
|
|
int k;
|
|
u32 colFlags;
|
|
assert( i>=nHidden );
|
|
if( i==pTab->iPKey ){
|
|
/* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
|
|
** using the rowid. So put a NULL in the IPK slot of the record to avoid
|
|
** using excess space. The file format definition requires this extra
|
|
** NULL - we cannot optimize further by skipping the column completely */
|
|
sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
|
|
continue;
|
|
}
|
|
if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){
|
|
nHidden++;
|
|
if( (colFlags & COLFLAG_VIRTUAL)!=0 ){
|
|
/* Virtual columns do not participate in OP_MakeRecord. So back up
|
|
** iRegStore by one slot to compensate for the iRegStore++ in the
|
|
** outer for() loop */
|
|
iRegStore--;
|
|
continue;
|
|
}else if( (colFlags & COLFLAG_STORED)!=0 ){
|
|
/* Stored columns are computed later. But if there are BEFORE
|
|
** triggers, the slots used for stored columns will be OP_Copy-ed
|
|
** to a second block of registers, so the register needs to be
|
|
** initialized to NULL to avoid an uninitialized register read */
|
|
if( tmask & TRIGGER_BEFORE ){
|
|
sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
|
|
}
|
|
continue;
|
|
}else if( pColumn==0 ){
|
|
/* Hidden columns that are not explicitly named in the INSERT
|
|
** get there default value */
|
|
sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
|
|
continue;
|
|
}
|
|
}
|
|
if( pColumn ){
|
|
for(j=0; j<pColumn->nId && pColumn->a[j].idx!=i; j++){}
|
|
if( j>=pColumn->nId ){
|
|
/* A column not named in the insert column list gets its
|
|
** default value */
|
|
sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
|
|
continue;
|
|
}
|
|
k = j;
|
|
}else if( nColumn==0 ){
|
|
/* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */
|
|
sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
|
|
continue;
|
|
}else{
|
|
k = i - nHidden;
|
|
}
|
|
|
|
if( useTempTable ){
|
|
sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore);
|
|
}else if( pSelect ){
|
|
if( regFromSelect!=regData ){
|
|
sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore);
|
|
}
|
|
}else{
|
|
sqlite3ExprCode(pParse, pList->a[k].pExpr, iRegStore);
|
|
}
|
|
}
|
|
|
|
|
|
/* Run the BEFORE and INSTEAD OF triggers, if there are any
|
|
*/
|
|
endOfLoop = sqlite3VdbeMakeLabel(pParse);
|
|
if( tmask & TRIGGER_BEFORE ){
|
|
int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
|
|
|
|
/* build the NEW.* reference row. Note that if there is an INTEGER
|
|
** PRIMARY KEY into which a NULL is being inserted, that NULL will be
|
|
** translated into a unique ID for the row. But on a BEFORE trigger,
|
|
** we do not know what the unique ID will be (because the insert has
|
|
** not happened yet) so we substitute a rowid of -1
|
|
*/
|
|
if( ipkColumn<0 ){
|
|
sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
|
|
}else{
|
|
int addr1;
|
|
assert( !withoutRowid );
|
|
if( useTempTable ){
|
|
sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols);
|
|
}else{
|
|
assert( pSelect==0 ); /* Otherwise useTempTable is true */
|
|
sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
|
|
}
|
|
addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v);
|
|
sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
|
|
}
|
|
|
|
/* Cannot have triggers on a virtual table. If it were possible,
|
|
** this block would have to account for hidden column.
|
|
*/
|
|
assert( !IsVirtual(pTab) );
|
|
|
|
/* Copy the new data already generated. */
|
|
assert( pTab->nNVCol>0 );
|
|
sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
|
|
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
/* Compute the new value for generated columns after all other
|
|
** columns have already been computed. This must be done after
|
|
** computing the ROWID in case one of the generated columns
|
|
** refers to the ROWID. */
|
|
if( pTab->tabFlags & TF_HasGenerated ){
|
|
testcase( pTab->tabFlags & TF_HasVirtual );
|
|
testcase( pTab->tabFlags & TF_HasStored );
|
|
sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab);
|
|
}
|
|
#endif
|
|
|
|
/* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
|
|
** do not attempt any conversions before assembling the record.
|
|
** If this is a real table, attempt conversions as required by the
|
|
** table column affinities.
|
|
*/
|
|
if( !isView ){
|
|
sqlite3TableAffinity(v, pTab, regCols+1);
|
|
}
|
|
|
|
/* Fire BEFORE or INSTEAD OF triggers */
|
|
sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
|
|
pTab, regCols-pTab->nCol-1, onError, endOfLoop);
|
|
|
|
sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
|
|
}
|
|
|
|
if( !isView ){
|
|
if( IsVirtual(pTab) ){
|
|
/* The row that the VUpdate opcode will delete: none */
|
|
sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
|
|
}
|
|
if( ipkColumn>=0 ){
|
|
/* Compute the new rowid */
|
|
if( useTempTable ){
|
|
sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid);
|
|
}else if( pSelect ){
|
|
/* Rowid already initialized at tag-20191021-001 */
|
|
}else{
|
|
Expr *pIpk = pList->a[ipkColumn].pExpr;
|
|
if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
|
|
sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
|
|
appendFlag = 1;
|
|
}else{
|
|
sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
|
|
}
|
|
}
|
|
/* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
|
|
** to generate a unique primary key value.
|
|
*/
|
|
if( !appendFlag ){
|
|
int addr1;
|
|
if( !IsVirtual(pTab) ){
|
|
addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v);
|
|
sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
}else{
|
|
addr1 = sqlite3VdbeCurrentAddr(v);
|
|
sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v);
|
|
}
|
|
sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v);
|
|
}
|
|
}else if( IsVirtual(pTab) || withoutRowid ){
|
|
sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
|
|
}else{
|
|
sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
|
|
appendFlag = 1;
|
|
}
|
|
autoIncStep(pParse, regAutoinc, regRowid);
|
|
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
/* Compute the new value for generated columns after all other
|
|
** columns have already been computed. This must be done after
|
|
** computing the ROWID in case one of the generated columns
|
|
** is derived from the INTEGER PRIMARY KEY. */
|
|
if( pTab->tabFlags & TF_HasGenerated ){
|
|
sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab);
|
|
}
|
|
#endif
|
|
|
|
/* Generate code to check constraints and generate index keys and
|
|
** do the insertion.
|
|
*/
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( IsVirtual(pTab) ){
|
|
const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
|
|
sqlite3VtabMakeWritable(pParse, pTab);
|
|
sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
|
|
sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
|
|
sqlite3MayAbort(pParse);
|
|
}else
|
|
#endif
|
|
{
|
|
int isReplace; /* Set to true if constraints may cause a replace */
|
|
int bUseSeek; /* True to use OPFLAG_SEEKRESULT */
|
|
sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
|
|
regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert
|
|
);
|
|
sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
|
|
|
|
/* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
|
|
** constraints or (b) there are no triggers and this table is not a
|
|
** parent table in a foreign key constraint. It is safe to set the
|
|
** flag in the second case as if any REPLACE constraint is hit, an
|
|
** OP_Delete or OP_IdxDelete instruction will be executed on each
|
|
** cursor that is disturbed. And these instructions both clear the
|
|
** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
|
|
** functionality. */
|
|
bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v));
|
|
sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
|
|
regIns, aRegIdx, 0, appendFlag, bUseSeek
|
|
);
|
|
}
|
|
}
|
|
|
|
/* Update the count of rows that are inserted
|
|
*/
|
|
if( regRowCount ){
|
|
sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
|
|
}
|
|
|
|
if( pTrigger ){
|
|
/* Code AFTER triggers */
|
|
sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
|
|
pTab, regData-2-pTab->nCol, onError, endOfLoop);
|
|
}
|
|
|
|
/* The bottom of the main insertion loop, if the data source
|
|
** is a SELECT statement.
|
|
*/
|
|
sqlite3VdbeResolveLabel(v, endOfLoop);
|
|
if( useTempTable ){
|
|
sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
|
|
sqlite3VdbeJumpHere(v, addrInsTop);
|
|
sqlite3VdbeAddOp1(v, OP_Close, srcTab);
|
|
}else if( pSelect ){
|
|
sqlite3VdbeGoto(v, addrCont);
|
|
#ifdef SQLITE_DEBUG
|
|
/* If we are jumping back to an OP_Yield that is preceded by an
|
|
** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
|
|
** OP_ReleaseReg will be included in the loop. */
|
|
if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){
|
|
assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield );
|
|
sqlite3VdbeChangeP5(v, 1);
|
|
}
|
|
#endif
|
|
sqlite3VdbeJumpHere(v, addrInsTop);
|
|
}
|
|
|
|
insert_end:
|
|
/* Update the sqlite_sequence table by storing the content of the
|
|
** maximum rowid counter values recorded while inserting into
|
|
** autoincrement tables.
|
|
*/
|
|
if( pParse->nested==0 && pParse->pTriggerTab==0 ){
|
|
sqlite3AutoincrementEnd(pParse);
|
|
}
|
|
|
|
/*
|
|
** Return the number of rows inserted. If this routine is
|
|
** generating code because of a call to sqlite3NestedParse(), do not
|
|
** invoke the callback function.
|
|
*/
|
|
if( regRowCount ){
|
|
sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
|
|
sqlite3VdbeSetNumCols(v, 1);
|
|
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
|
|
}
|
|
|
|
insert_cleanup:
|
|
sqlite3SrcListDelete(db, pTabList);
|
|
sqlite3ExprListDelete(db, pList);
|
|
sqlite3UpsertDelete(db, pUpsert);
|
|
sqlite3SelectDelete(db, pSelect);
|
|
sqlite3IdListDelete(db, pColumn);
|
|
sqlite3DbFree(db, aRegIdx);
|
|
}
|
|
|
|
/* Make sure "isView" and other macros defined above are undefined. Otherwise
|
|
** they may interfere with compilation of other functions in this file
|
|
** (or in another file, if this file becomes part of the amalgamation). */
|
|
#ifdef isView
|
|
#undef isView
|
|
#endif
|
|
#ifdef pTrigger
|
|
#undef pTrigger
|
|
#endif
|
|
#ifdef tmask
|
|
#undef tmask
|
|
#endif
|
|
|
|
/*
|
|
** Meanings of bits in of pWalker->eCode for
|
|
** sqlite3ExprReferencesUpdatedColumn()
|
|
*/
|
|
#define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */
|
|
#define CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */
|
|
|
|
/* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn().
|
|
* Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this
|
|
** expression node references any of the
|
|
** columns that are being modifed by an UPDATE statement.
|
|
*/
|
|
static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
|
|
if( pExpr->op==TK_COLUMN ){
|
|
assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
|
|
if( pExpr->iColumn>=0 ){
|
|
if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
|
|
pWalker->eCode |= CKCNSTRNT_COLUMN;
|
|
}
|
|
}else{
|
|
pWalker->eCode |= CKCNSTRNT_ROWID;
|
|
}
|
|
}
|
|
return WRC_Continue;
|
|
}
|
|
|
|
/*
|
|
** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
|
|
** only columns that are modified by the UPDATE are those for which
|
|
** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
|
|
**
|
|
** Return true if CHECK constraint pExpr uses any of the
|
|
** changing columns (or the rowid if it is changing). In other words,
|
|
** return true if this CHECK constraint must be validated for
|
|
** the new row in the UPDATE statement.
|
|
**
|
|
** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
|
|
** The operation of this routine is the same - return true if an only if
|
|
** the expression uses one or more of columns identified by the second and
|
|
** third arguments.
|
|
*/
|
|
int sqlite3ExprReferencesUpdatedColumn(
|
|
Expr *pExpr, /* The expression to be checked */
|
|
int *aiChng, /* aiChng[x]>=0 if column x changed by the UPDATE */
|
|
int chngRowid /* True if UPDATE changes the rowid */
|
|
){
|
|
Walker w;
|
|
memset(&w, 0, sizeof(w));
|
|
w.eCode = 0;
|
|
w.xExprCallback = checkConstraintExprNode;
|
|
w.u.aiCol = aiChng;
|
|
sqlite3WalkExpr(&w, pExpr);
|
|
if( !chngRowid ){
|
|
testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
|
|
w.eCode &= ~CKCNSTRNT_ROWID;
|
|
}
|
|
testcase( w.eCode==0 );
|
|
testcase( w.eCode==CKCNSTRNT_COLUMN );
|
|
testcase( w.eCode==CKCNSTRNT_ROWID );
|
|
testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
|
|
return w.eCode!=0;
|
|
}
|
|
|
|
/*
|
|
** Generate code to do constraint checks prior to an INSERT or an UPDATE
|
|
** on table pTab.
|
|
**
|
|
** The regNewData parameter is the first register in a range that contains
|
|
** the data to be inserted or the data after the update. There will be
|
|
** pTab->nCol+1 registers in this range. The first register (the one
|
|
** that regNewData points to) will contain the new rowid, or NULL in the
|
|
** case of a WITHOUT ROWID table. The second register in the range will
|
|
** contain the content of the first table column. The third register will
|
|
** contain the content of the second table column. And so forth.
|
|
**
|
|
** The regOldData parameter is similar to regNewData except that it contains
|
|
** the data prior to an UPDATE rather than afterwards. regOldData is zero
|
|
** for an INSERT. This routine can distinguish between UPDATE and INSERT by
|
|
** checking regOldData for zero.
|
|
**
|
|
** For an UPDATE, the pkChng boolean is true if the true primary key (the
|
|
** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
|
|
** might be modified by the UPDATE. If pkChng is false, then the key of
|
|
** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
|
|
**
|
|
** For an INSERT, the pkChng boolean indicates whether or not the rowid
|
|
** was explicitly specified as part of the INSERT statement. If pkChng
|
|
** is zero, it means that the either rowid is computed automatically or
|
|
** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT,
|
|
** pkChng will only be true if the INSERT statement provides an integer
|
|
** value for either the rowid column or its INTEGER PRIMARY KEY alias.
|
|
**
|
|
** The code generated by this routine will store new index entries into
|
|
** registers identified by aRegIdx[]. No index entry is created for
|
|
** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
|
|
** the same as the order of indices on the linked list of indices
|
|
** at pTab->pIndex.
|
|
**
|
|
** (2019-05-07) The generated code also creates a new record for the
|
|
** main table, if pTab is a rowid table, and stores that record in the
|
|
** register identified by aRegIdx[nIdx] - in other words in the first
|
|
** entry of aRegIdx[] past the last index. It is important that the
|
|
** record be generated during constraint checks to avoid affinity changes
|
|
** to the register content that occur after constraint checks but before
|
|
** the new record is inserted.
|
|
**
|
|
** The caller must have already opened writeable cursors on the main
|
|
** table and all applicable indices (that is to say, all indices for which
|
|
** aRegIdx[] is not zero). iDataCur is the cursor for the main table when
|
|
** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
|
|
** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor
|
|
** for the first index in the pTab->pIndex list. Cursors for other indices
|
|
** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
|
|
**
|
|
** This routine also generates code to check constraints. NOT NULL,
|
|
** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
|
|
** then the appropriate action is performed. There are five possible
|
|
** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
|
|
**
|
|
** Constraint type Action What Happens
|
|
** --------------- ---------- ----------------------------------------
|
|
** any ROLLBACK The current transaction is rolled back and
|
|
** sqlite3_step() returns immediately with a
|
|
** return code of SQLITE_CONSTRAINT.
|
|
**
|
|
** any ABORT Back out changes from the current command
|
|
** only (do not do a complete rollback) then
|
|
** cause sqlite3_step() to return immediately
|
|
** with SQLITE_CONSTRAINT.
|
|
**
|
|
** any FAIL Sqlite3_step() returns immediately with a
|
|
** return code of SQLITE_CONSTRAINT. The
|
|
** transaction is not rolled back and any
|
|
** changes to prior rows are retained.
|
|
**
|
|
** any IGNORE The attempt in insert or update the current
|
|
** row is skipped, without throwing an error.
|
|
** Processing continues with the next row.
|
|
** (There is an immediate jump to ignoreDest.)
|
|
**
|
|
** NOT NULL REPLACE The NULL value is replace by the default
|
|
** value for that column. If the default value
|
|
** is NULL, the action is the same as ABORT.
|
|
**
|
|
** UNIQUE REPLACE The other row that conflicts with the row
|
|
** being inserted is removed.
|
|
**
|
|
** CHECK REPLACE Illegal. The results in an exception.
|
|
**
|
|
** Which action to take is determined by the overrideError parameter.
|
|
** Or if overrideError==OE_Default, then the pParse->onError parameter
|
|
** is used. Or if pParse->onError==OE_Default then the onError value
|
|
** for the constraint is used.
|
|
*/
|
|
void sqlite3GenerateConstraintChecks(
|
|
Parse *pParse, /* The parser context */
|
|
Table *pTab, /* The table being inserted or updated */
|
|
int *aRegIdx, /* Use register aRegIdx[i] for index i. 0 for unused */
|
|
int iDataCur, /* Canonical data cursor (main table or PK index) */
|
|
int iIdxCur, /* First index cursor */
|
|
int regNewData, /* First register in a range holding values to insert */
|
|
int regOldData, /* Previous content. 0 for INSERTs */
|
|
u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */
|
|
u8 overrideError, /* Override onError to this if not OE_Default */
|
|
int ignoreDest, /* Jump to this label on an OE_Ignore resolution */
|
|
int *pbMayReplace, /* OUT: Set to true if constraint may cause a replace */
|
|
int *aiChng, /* column i is unchanged if aiChng[i]<0 */
|
|
Upsert *pUpsert /* ON CONFLICT clauses, if any. NULL otherwise */
|
|
){
|
|
Vdbe *v; /* VDBE under constrution */
|
|
Index *pIdx; /* Pointer to one of the indices */
|
|
Index *pPk = 0; /* The PRIMARY KEY index */
|
|
sqlite3 *db; /* Database connection */
|
|
int i; /* loop counter */
|
|
int ix; /* Index loop counter */
|
|
int nCol; /* Number of columns */
|
|
int onError; /* Conflict resolution strategy */
|
|
int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
|
|
int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
|
|
Index *pUpIdx = 0; /* Index to which to apply the upsert */
|
|
u8 isUpdate; /* True if this is an UPDATE operation */
|
|
u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */
|
|
int upsertBypass = 0; /* Address of Goto to bypass upsert subroutine */
|
|
int upsertJump = 0; /* Address of Goto that jumps into upsert subroutine */
|
|
int ipkTop = 0; /* Top of the IPK uniqueness check */
|
|
int ipkBottom = 0; /* OP_Goto at the end of the IPK uniqueness check */
|
|
/* Variables associated with retesting uniqueness constraints after
|
|
** replace triggers fire have run */
|
|
int regTrigCnt; /* Register used to count replace trigger invocations */
|
|
int addrRecheck = 0; /* Jump here to recheck all uniqueness constraints */
|
|
int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */
|
|
Trigger *pTrigger; /* List of DELETE triggers on the table pTab */
|
|
int nReplaceTrig = 0; /* Number of replace triggers coded */
|
|
|
|
isUpdate = regOldData!=0;
|
|
db = pParse->db;
|
|
v = sqlite3GetVdbe(pParse);
|
|
assert( v!=0 );
|
|
assert( pTab->pSelect==0 ); /* This table is not a VIEW */
|
|
nCol = pTab->nCol;
|
|
|
|
/* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
|
|
** normal rowid tables. nPkField is the number of key fields in the
|
|
** pPk index or 1 for a rowid table. In other words, nPkField is the
|
|
** number of fields in the true primary key of the table. */
|
|
if( HasRowid(pTab) ){
|
|
pPk = 0;
|
|
nPkField = 1;
|
|
}else{
|
|
pPk = sqlite3PrimaryKeyIndex(pTab);
|
|
nPkField = pPk->nKeyCol;
|
|
}
|
|
|
|
/* Record that this module has started */
|
|
VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
|
|
iDataCur, iIdxCur, regNewData, regOldData, pkChng));
|
|
|
|
/* Test all NOT NULL constraints.
|
|
*/
|
|
if( pTab->tabFlags & TF_HasNotNull ){
|
|
int b2ndPass = 0; /* True if currently running 2nd pass */
|
|
int nSeenReplace = 0; /* Number of ON CONFLICT REPLACE operations */
|
|
int nGenerated = 0; /* Number of generated columns with NOT NULL */
|
|
while(1){ /* Make 2 passes over columns. Exit loop via "break" */
|
|
for(i=0; i<nCol; i++){
|
|
int iReg; /* Register holding column value */
|
|
Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
|
|
int isGenerated; /* non-zero if column is generated */
|
|
onError = pCol->notNull;
|
|
if( onError==OE_None ) continue; /* No NOT NULL on this column */
|
|
if( i==pTab->iPKey ){
|
|
continue; /* ROWID is never NULL */
|
|
}
|
|
isGenerated = pCol->colFlags & COLFLAG_GENERATED;
|
|
if( isGenerated && !b2ndPass ){
|
|
nGenerated++;
|
|
continue; /* Generated columns processed on 2nd pass */
|
|
}
|
|
if( aiChng && aiChng[i]<0 && !isGenerated ){
|
|
/* Do not check NOT NULL on columns that do not change */
|
|
continue;
|
|
}
|
|
if( overrideError!=OE_Default ){
|
|
onError = overrideError;
|
|
}else if( onError==OE_Default ){
|
|
onError = OE_Abort;
|
|
}
|
|
if( onError==OE_Replace ){
|
|
if( b2ndPass /* REPLACE becomes ABORT on the 2nd pass */
|
|
|| pCol->pDflt==0 /* REPLACE is ABORT if no DEFAULT value */
|
|
){
|
|
testcase( pCol->colFlags & COLFLAG_VIRTUAL );
|
|
testcase( pCol->colFlags & COLFLAG_STORED );
|
|
testcase( pCol->colFlags & COLFLAG_GENERATED );
|
|
onError = OE_Abort;
|
|
}else{
|
|
assert( !isGenerated );
|
|
}
|
|
}else if( b2ndPass && !isGenerated ){
|
|
continue;
|
|
}
|
|
assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
|
|
|| onError==OE_Ignore || onError==OE_Replace );
|
|
testcase( i!=sqlite3TableColumnToStorage(pTab, i) );
|
|
iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1;
|
|
switch( onError ){
|
|
case OE_Replace: {
|
|
int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg);
|
|
VdbeCoverage(v);
|
|
assert( (pCol->colFlags & COLFLAG_GENERATED)==0 );
|
|
nSeenReplace++;
|
|
sqlite3ExprCode(pParse, pCol->pDflt, iReg);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
break;
|
|
}
|
|
case OE_Abort:
|
|
sqlite3MayAbort(pParse);
|
|
/* Fall through */
|
|
case OE_Rollback:
|
|
case OE_Fail: {
|
|
char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
|
|
pCol->zName);
|
|
sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,
|
|
onError, iReg);
|
|
sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
|
|
sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
|
|
VdbeCoverage(v);
|
|
break;
|
|
}
|
|
default: {
|
|
assert( onError==OE_Ignore );
|
|
sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest);
|
|
VdbeCoverage(v);
|
|
break;
|
|
}
|
|
} /* end switch(onError) */
|
|
} /* end loop i over columns */
|
|
if( nGenerated==0 && nSeenReplace==0 ){
|
|
/* If there are no generated columns with NOT NULL constraints
|
|
** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
|
|
** pass is sufficient */
|
|
break;
|
|
}
|
|
if( b2ndPass ) break; /* Never need more than 2 passes */
|
|
b2ndPass = 1;
|
|
if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
|
|
/* If any NOT NULL ON CONFLICT REPLACE constraints fired on the
|
|
** first pass, recomputed values for all generated columns, as
|
|
** those values might depend on columns affected by the REPLACE.
|
|
*/
|
|
sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab);
|
|
}
|
|
} /* end of 2-pass loop */
|
|
} /* end if( has-not-null-constraints ) */
|
|
|
|
/* Test all CHECK constraints
|
|
*/
|
|
#ifndef SQLITE_OMIT_CHECK
|
|
if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
|
|
ExprList *pCheck = pTab->pCheck;
|
|
pParse->iSelfTab = -(regNewData+1);
|
|
onError = overrideError!=OE_Default ? overrideError : OE_Abort;
|
|
for(i=0; i<pCheck->nExpr; i++){
|
|
int allOk;
|
|
Expr *pExpr = pCheck->a[i].pExpr;
|
|
if( aiChng
|
|
&& !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
|
|
){
|
|
/* The check constraints do not reference any of the columns being
|
|
** updated so there is no point it verifying the check constraint */
|
|
continue;
|
|
}
|
|
allOk = sqlite3VdbeMakeLabel(pParse);
|
|
sqlite3VdbeVerifyAbortable(v, onError);
|
|
sqlite3ExprIfTrue(pParse, pExpr, allOk, SQLITE_JUMPIFNULL);
|
|
if( onError==OE_Ignore ){
|
|
sqlite3VdbeGoto(v, ignoreDest);
|
|
}else{
|
|
char *zName = pCheck->a[i].zName;
|
|
if( zName==0 ) zName = pTab->zName;
|
|
if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */
|
|
sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
|
|
onError, zName, P4_TRANSIENT,
|
|
P5_ConstraintCheck);
|
|
}
|
|
sqlite3VdbeResolveLabel(v, allOk);
|
|
}
|
|
pParse->iSelfTab = 0;
|
|
}
|
|
#endif /* !defined(SQLITE_OMIT_CHECK) */
|
|
|
|
/* UNIQUE and PRIMARY KEY constraints should be handled in the following
|
|
** order:
|
|
**
|
|
** (1) OE_Update
|
|
** (2) OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
|
|
** (3) OE_Replace
|
|
**
|
|
** OE_Fail and OE_Ignore must happen before any changes are made.
|
|
** OE_Update guarantees that only a single row will change, so it
|
|
** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback
|
|
** could happen in any order, but they are grouped up front for
|
|
** convenience.
|
|
**
|
|
** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
|
|
** The order of constraints used to have OE_Update as (2) and OE_Abort
|
|
** and so forth as (1). But apparently PostgreSQL checks the OE_Update
|
|
** constraint before any others, so it had to be moved.
|
|
**
|
|
** Constraint checking code is generated in this order:
|
|
** (A) The rowid constraint
|
|
** (B) Unique index constraints that do not have OE_Replace as their
|
|
** default conflict resolution strategy
|
|
** (C) Unique index that do use OE_Replace by default.
|
|
**
|
|
** The ordering of (2) and (3) is accomplished by making sure the linked
|
|
** list of indexes attached to a table puts all OE_Replace indexes last
|
|
** in the list. See sqlite3CreateIndex() for where that happens.
|
|
*/
|
|
|
|
if( pUpsert ){
|
|
if( pUpsert->pUpsertTarget==0 ){
|
|
/* An ON CONFLICT DO NOTHING clause, without a constraint-target.
|
|
** Make all unique constraint resolution be OE_Ignore */
|
|
assert( pUpsert->pUpsertSet==0 );
|
|
overrideError = OE_Ignore;
|
|
pUpsert = 0;
|
|
}else if( (pUpIdx = pUpsert->pUpsertIdx)!=0 ){
|
|
/* If the constraint-target uniqueness check must be run first.
|
|
** Jump to that uniqueness check now */
|
|
upsertJump = sqlite3VdbeAddOp0(v, OP_Goto);
|
|
VdbeComment((v, "UPSERT constraint goes first"));
|
|
}
|
|
}
|
|
|
|
/* Determine if it is possible that triggers (either explicitly coded
|
|
** triggers or FK resolution actions) might run as a result of deletes
|
|
** that happen when OE_Replace conflict resolution occurs. (Call these
|
|
** "replace triggers".) If any replace triggers run, we will need to
|
|
** recheck all of the uniqueness constraints after they have all run.
|
|
** But on the recheck, the resolution is OE_Abort instead of OE_Replace.
|
|
**
|
|
** If replace triggers are a possibility, then
|
|
**
|
|
** (1) Allocate register regTrigCnt and initialize it to zero.
|
|
** That register will count the number of replace triggers that
|
|
** fire. Constraint recheck only occurs if the number is positive.
|
|
** (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
|
|
** (3) Initialize addrRecheck and lblRecheckOk
|
|
**
|
|
** The uniqueness rechecking code will create a series of tests to run
|
|
** in a second pass. The addrRecheck and lblRecheckOk variables are
|
|
** used to link together these tests which are separated from each other
|
|
** in the generate bytecode.
|
|
*/
|
|
if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){
|
|
/* There are not DELETE triggers nor FK constraints. No constraint
|
|
** rechecks are needed. */
|
|
pTrigger = 0;
|
|
regTrigCnt = 0;
|
|
}else{
|
|
if( db->flags&SQLITE_RecTriggers ){
|
|
pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
|
|
regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0);
|
|
}else{
|
|
pTrigger = 0;
|
|
regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0);
|
|
}
|
|
if( regTrigCnt ){
|
|
/* Replace triggers might exist. Allocate the counter and
|
|
** initialize it to zero. */
|
|
regTrigCnt = ++pParse->nMem;
|
|
sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt);
|
|
VdbeComment((v, "trigger count"));
|
|
lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
|
|
addrRecheck = lblRecheckOk;
|
|
}
|
|
}
|
|
|
|
/* If rowid is changing, make sure the new rowid does not previously
|
|
** exist in the table.
|
|
*/
|
|
if( pkChng && pPk==0 ){
|
|
int addrRowidOk = sqlite3VdbeMakeLabel(pParse);
|
|
|
|
/* Figure out what action to take in case of a rowid collision */
|
|
onError = pTab->keyConf;
|
|
if( overrideError!=OE_Default ){
|
|
onError = overrideError;
|
|
}else if( onError==OE_Default ){
|
|
onError = OE_Abort;
|
|
}
|
|
|
|
/* figure out whether or not upsert applies in this case */
|
|
if( pUpsert && pUpsert->pUpsertIdx==0 ){
|
|
if( pUpsert->pUpsertSet==0 ){
|
|
onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */
|
|
}else{
|
|
onError = OE_Update; /* DO UPDATE */
|
|
}
|
|
}
|
|
|
|
/* If the response to a rowid conflict is REPLACE but the response
|
|
** to some other UNIQUE constraint is FAIL or IGNORE, then we need
|
|
** to defer the running of the rowid conflict checking until after
|
|
** the UNIQUE constraints have run.
|
|
*/
|
|
if( onError==OE_Replace /* IPK rule is REPLACE */
|
|
&& onError!=overrideError /* Rules for other contraints are different */
|
|
&& pTab->pIndex /* There exist other constraints */
|
|
){
|
|
ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
|
|
VdbeComment((v, "defer IPK REPLACE until last"));
|
|
}
|
|
|
|
if( isUpdate ){
|
|
/* pkChng!=0 does not mean that the rowid has changed, only that
|
|
** it might have changed. Skip the conflict logic below if the rowid
|
|
** is unchanged. */
|
|
sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
|
|
sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
|
VdbeCoverage(v);
|
|
}
|
|
|
|
/* Check to see if the new rowid already exists in the table. Skip
|
|
** the following conflict logic if it does not. */
|
|
VdbeNoopComment((v, "uniqueness check for ROWID"));
|
|
sqlite3VdbeVerifyAbortable(v, onError);
|
|
sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
|
|
VdbeCoverage(v);
|
|
|
|
switch( onError ){
|
|
default: {
|
|
onError = OE_Abort;
|
|
/* Fall thru into the next case */
|
|
}
|
|
case OE_Rollback:
|
|
case OE_Abort:
|
|
case OE_Fail: {
|
|
testcase( onError==OE_Rollback );
|
|
testcase( onError==OE_Abort );
|
|
testcase( onError==OE_Fail );
|
|
sqlite3RowidConstraint(pParse, onError, pTab);
|
|
break;
|
|
}
|
|
case OE_Replace: {
|
|
/* If there are DELETE triggers on this table and the
|
|
** recursive-triggers flag is set, call GenerateRowDelete() to
|
|
** remove the conflicting row from the table. This will fire
|
|
** the triggers and remove both the table and index b-tree entries.
|
|
**
|
|
** Otherwise, if there are no triggers or the recursive-triggers
|
|
** flag is not set, but the table has one or more indexes, call
|
|
** GenerateRowIndexDelete(). This removes the index b-tree entries
|
|
** only. The table b-tree entry will be replaced by the new entry
|
|
** when it is inserted.
|
|
**
|
|
** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
|
|
** also invoke MultiWrite() to indicate that this VDBE may require
|
|
** statement rollback (if the statement is aborted after the delete
|
|
** takes place). Earlier versions called sqlite3MultiWrite() regardless,
|
|
** but being more selective here allows statements like:
|
|
**
|
|
** REPLACE INTO t(rowid) VALUES($newrowid)
|
|
**
|
|
** to run without a statement journal if there are no indexes on the
|
|
** table.
|
|
*/
|
|
if( regTrigCnt ){
|
|
sqlite3MultiWrite(pParse);
|
|
sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
|
|
regNewData, 1, 0, OE_Replace, 1, -1);
|
|
sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
|
|
nReplaceTrig++;
|
|
}else{
|
|
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
|
|
assert( HasRowid(pTab) );
|
|
/* This OP_Delete opcode fires the pre-update-hook only. It does
|
|
** not modify the b-tree. It is more efficient to let the coming
|
|
** OP_Insert replace the existing entry than it is to delete the
|
|
** existing entry and then insert a new one. */
|
|
sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
|
|
sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
|
|
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
|
|
if( pTab->pIndex ){
|
|
sqlite3MultiWrite(pParse);
|
|
sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
|
|
}
|
|
}
|
|
seenReplace = 1;
|
|
break;
|
|
}
|
|
#ifndef SQLITE_OMIT_UPSERT
|
|
case OE_Update: {
|
|
sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
|
|
/* Fall through */
|
|
}
|
|
#endif
|
|
case OE_Ignore: {
|
|
testcase( onError==OE_Ignore );
|
|
sqlite3VdbeGoto(v, ignoreDest);
|
|
break;
|
|
}
|
|
}
|
|
sqlite3VdbeResolveLabel(v, addrRowidOk);
|
|
if( ipkTop ){
|
|
ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
|
|
sqlite3VdbeJumpHere(v, ipkTop-1);
|
|
}
|
|
}
|
|
|
|
/* Test all UNIQUE constraints by creating entries for each UNIQUE
|
|
** index and making sure that duplicate entries do not already exist.
|
|
** Compute the revised record entries for indices as we go.
|
|
**
|
|
** This loop also handles the case of the PRIMARY KEY index for a
|
|
** WITHOUT ROWID table.
|
|
*/
|
|
for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){
|
|
int regIdx; /* Range of registers hold conent for pIdx */
|
|
int regR; /* Range of registers holding conflicting PK */
|
|
int iThisCur; /* Cursor for this UNIQUE index */
|
|
int addrUniqueOk; /* Jump here if the UNIQUE constraint is satisfied */
|
|
int addrConflictCk; /* First opcode in the conflict check logic */
|
|
|
|
if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */
|
|
if( pUpIdx==pIdx ){
|
|
addrUniqueOk = upsertJump+1;
|
|
upsertBypass = sqlite3VdbeGoto(v, 0);
|
|
VdbeComment((v, "Skip upsert subroutine"));
|
|
sqlite3VdbeJumpHere(v, upsertJump);
|
|
}else{
|
|
addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
|
|
}
|
|
if( bAffinityDone==0 && (pUpIdx==0 || pUpIdx==pIdx) ){
|
|
sqlite3TableAffinity(v, pTab, regNewData+1);
|
|
bAffinityDone = 1;
|
|
}
|
|
VdbeNoopComment((v, "uniqueness check for %s", pIdx->zName));
|
|
iThisCur = iIdxCur+ix;
|
|
|
|
|
|
/* Skip partial indices for which the WHERE clause is not true */
|
|
if( pIdx->pPartIdxWhere ){
|
|
sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
|
|
pParse->iSelfTab = -(regNewData+1);
|
|
sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
|
|
SQLITE_JUMPIFNULL);
|
|
pParse->iSelfTab = 0;
|
|
}
|
|
|
|
/* Create a record for this index entry as it should appear after
|
|
** the insert or update. Store that record in the aRegIdx[ix] register
|
|
*/
|
|
regIdx = aRegIdx[ix]+1;
|
|
for(i=0; i<pIdx->nColumn; i++){
|
|
int iField = pIdx->aiColumn[i];
|
|
int x;
|
|
if( iField==XN_EXPR ){
|
|
pParse->iSelfTab = -(regNewData+1);
|
|
sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
|
|
pParse->iSelfTab = 0;
|
|
VdbeComment((v, "%s column %d", pIdx->zName, i));
|
|
}else if( iField==XN_ROWID || iField==pTab->iPKey ){
|
|
x = regNewData;
|
|
sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i);
|
|
VdbeComment((v, "rowid"));
|
|
}else{
|
|
testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
|
|
x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1;
|
|
sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
|
|
VdbeComment((v, "%s", pTab->aCol[iField].zName));
|
|
}
|
|
}
|
|
sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
|
|
VdbeComment((v, "for %s", pIdx->zName));
|
|
#ifdef SQLITE_ENABLE_NULL_TRIM
|
|
if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
|
|
sqlite3SetMakeRecordP5(v, pIdx->pTable);
|
|
}
|
|
#endif
|
|
|
|
/* In an UPDATE operation, if this index is the PRIMARY KEY index
|
|
** of a WITHOUT ROWID table and there has been no change the
|
|
** primary key, then no collision is possible. The collision detection
|
|
** logic below can all be skipped. */
|
|
if( isUpdate && pPk==pIdx && pkChng==0 ){
|
|
sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
|
continue;
|
|
}
|
|
|
|
/* Find out what action to take in case there is a uniqueness conflict */
|
|
onError = pIdx->onError;
|
|
if( onError==OE_None ){
|
|
sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
|
continue; /* pIdx is not a UNIQUE index */
|
|
}
|
|
if( overrideError!=OE_Default ){
|
|
onError = overrideError;
|
|
}else if( onError==OE_Default ){
|
|
onError = OE_Abort;
|
|
}
|
|
|
|
/* Figure out if the upsert clause applies to this index */
|
|
if( pUpIdx==pIdx ){
|
|
if( pUpsert->pUpsertSet==0 ){
|
|
onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */
|
|
}else{
|
|
onError = OE_Update; /* DO UPDATE */
|
|
}
|
|
}
|
|
|
|
/* Collision detection may be omitted if all of the following are true:
|
|
** (1) The conflict resolution algorithm is REPLACE
|
|
** (2) The table is a WITHOUT ROWID table
|
|
** (3) There are no secondary indexes on the table
|
|
** (4) No delete triggers need to be fired if there is a conflict
|
|
** (5) No FK constraint counters need to be updated if a conflict occurs.
|
|
**
|
|
** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
|
|
** must be explicitly deleted in order to ensure any pre-update hook
|
|
** is invoked. */
|
|
#ifndef SQLITE_ENABLE_PREUPDATE_HOOK
|
|
if( (ix==0 && pIdx->pNext==0) /* Condition 3 */
|
|
&& pPk==pIdx /* Condition 2 */
|
|
&& onError==OE_Replace /* Condition 1 */
|
|
&& ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */
|
|
0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
|
|
&& ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */
|
|
(0==pTab->pFKey && 0==sqlite3FkReferences(pTab)))
|
|
){
|
|
sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
|
continue;
|
|
}
|
|
#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */
|
|
|
|
/* Check to see if the new index entry will be unique */
|
|
sqlite3VdbeVerifyAbortable(v, onError);
|
|
addrConflictCk =
|
|
sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
|
|
regIdx, pIdx->nKeyCol); VdbeCoverage(v);
|
|
|
|
/* Generate code to handle collisions */
|
|
regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField);
|
|
if( isUpdate || onError==OE_Replace ){
|
|
if( HasRowid(pTab) ){
|
|
sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
|
|
/* Conflict only if the rowid of the existing index entry
|
|
** is different from old-rowid */
|
|
if( isUpdate ){
|
|
sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
|
|
sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
|
VdbeCoverage(v);
|
|
}
|
|
}else{
|
|
int x;
|
|
/* Extract the PRIMARY KEY from the end of the index entry and
|
|
** store it in registers regR..regR+nPk-1 */
|
|
if( pIdx!=pPk ){
|
|
for(i=0; i<pPk->nKeyCol; i++){
|
|
assert( pPk->aiColumn[i]>=0 );
|
|
x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
|
|
sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
|
|
VdbeComment((v, "%s.%s", pTab->zName,
|
|
pTab->aCol[pPk->aiColumn[i]].zName));
|
|
}
|
|
}
|
|
if( isUpdate ){
|
|
/* If currently processing the PRIMARY KEY of a WITHOUT ROWID
|
|
** table, only conflict if the new PRIMARY KEY values are actually
|
|
** different from the old.
|
|
**
|
|
** For a UNIQUE index, only conflict if the PRIMARY KEY values
|
|
** of the matched index row are different from the original PRIMARY
|
|
** KEY values of this row before the update. */
|
|
int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
|
|
int op = OP_Ne;
|
|
int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR);
|
|
|
|
for(i=0; i<pPk->nKeyCol; i++){
|
|
char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
|
|
x = pPk->aiColumn[i];
|
|
assert( x>=0 );
|
|
if( i==(pPk->nKeyCol-1) ){
|
|
addrJump = addrUniqueOk;
|
|
op = OP_Eq;
|
|
}
|
|
x = sqlite3TableColumnToStorage(pTab, x);
|
|
sqlite3VdbeAddOp4(v, op,
|
|
regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ
|
|
);
|
|
sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
|
VdbeCoverageIf(v, op==OP_Eq);
|
|
VdbeCoverageIf(v, op==OP_Ne);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Generate code that executes if the new index entry is not unique */
|
|
assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
|
|
|| onError==OE_Ignore || onError==OE_Replace || onError==OE_Update );
|
|
switch( onError ){
|
|
case OE_Rollback:
|
|
case OE_Abort:
|
|
case OE_Fail: {
|
|
testcase( onError==OE_Rollback );
|
|
testcase( onError==OE_Abort );
|
|
testcase( onError==OE_Fail );
|
|
sqlite3UniqueConstraint(pParse, onError, pIdx);
|
|
break;
|
|
}
|
|
#ifndef SQLITE_OMIT_UPSERT
|
|
case OE_Update: {
|
|
sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
|
|
/* Fall through */
|
|
}
|
|
#endif
|
|
case OE_Ignore: {
|
|
testcase( onError==OE_Ignore );
|
|
sqlite3VdbeGoto(v, ignoreDest);
|
|
break;
|
|
}
|
|
default: {
|
|
int nConflictCk; /* Number of opcodes in conflict check logic */
|
|
|
|
assert( onError==OE_Replace );
|
|
nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
|
|
assert( nConflictCk>0 );
|
|
testcase( nConflictCk>1 );
|
|
if( regTrigCnt ){
|
|
sqlite3MultiWrite(pParse);
|
|
nReplaceTrig++;
|
|
}
|
|
if( pTrigger && isUpdate ){
|
|
sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur);
|
|
}
|
|
sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
|
|
regR, nPkField, 0, OE_Replace,
|
|
(pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
|
|
if( pTrigger && isUpdate ){
|
|
sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur);
|
|
}
|
|
if( regTrigCnt ){
|
|
int addrBypass; /* Jump destination to bypass recheck logic */
|
|
|
|
sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
|
|
addrBypass = sqlite3VdbeAddOp0(v, OP_Goto); /* Bypass recheck */
|
|
VdbeComment((v, "bypass recheck"));
|
|
|
|
/* Here we insert code that will be invoked after all constraint
|
|
** checks have run, if and only if one or more replace triggers
|
|
** fired. */
|
|
sqlite3VdbeResolveLabel(v, lblRecheckOk);
|
|
lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
|
|
if( pIdx->pPartIdxWhere ){
|
|
/* Bypass the recheck if this partial index is not defined
|
|
** for the current row */
|
|
sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk);
|
|
VdbeCoverage(v);
|
|
}
|
|
/* Copy the constraint check code from above, except change
|
|
** the constraint-ok jump destination to be the address of
|
|
** the next retest block */
|
|
while( nConflictCk>0 ){
|
|
VdbeOp x; /* Conflict check opcode to copy */
|
|
/* The sqlite3VdbeAddOp4() call might reallocate the opcode array.
|
|
** Hence, make a complete copy of the opcode, rather than using
|
|
** a pointer to the opcode. */
|
|
x = *sqlite3VdbeGetOp(v, addrConflictCk);
|
|
if( x.opcode!=OP_IdxRowid ){
|
|
int p2; /* New P2 value for copied conflict check opcode */
|
|
if( sqlite3OpcodeProperty[x.opcode]&OPFLG_JUMP ){
|
|
p2 = lblRecheckOk;
|
|
}else{
|
|
p2 = x.p2;
|
|
}
|
|
sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, x.p4.z, x.p4type);
|
|
sqlite3VdbeChangeP5(v, x.p5);
|
|
VdbeCoverageIf(v, p2!=x.p2);
|
|
}
|
|
nConflictCk--;
|
|
addrConflictCk++;
|
|
}
|
|
/* If the retest fails, issue an abort */
|
|
sqlite3UniqueConstraint(pParse, OE_Abort, pIdx);
|
|
|
|
sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */
|
|
}
|
|
seenReplace = 1;
|
|
break;
|
|
}
|
|
}
|
|
if( pUpIdx==pIdx ){
|
|
sqlite3VdbeGoto(v, upsertJump+1);
|
|
sqlite3VdbeJumpHere(v, upsertBypass);
|
|
}else{
|
|
sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
|
}
|
|
if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
|
|
}
|
|
|
|
/* If the IPK constraint is a REPLACE, run it last */
|
|
if( ipkTop ){
|
|
sqlite3VdbeGoto(v, ipkTop);
|
|
VdbeComment((v, "Do IPK REPLACE"));
|
|
sqlite3VdbeJumpHere(v, ipkBottom);
|
|
}
|
|
|
|
/* Recheck all uniqueness constraints after replace triggers have run */
|
|
testcase( regTrigCnt!=0 && nReplaceTrig==0 );
|
|
assert( regTrigCnt!=0 || nReplaceTrig==0 );
|
|
if( nReplaceTrig ){
|
|
sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v);
|
|
if( !pPk ){
|
|
if( isUpdate ){
|
|
sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData);
|
|
sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
|
VdbeCoverage(v);
|
|
}
|
|
sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData);
|
|
VdbeCoverage(v);
|
|
sqlite3RowidConstraint(pParse, OE_Abort, pTab);
|
|
}else{
|
|
sqlite3VdbeGoto(v, addrRecheck);
|
|
}
|
|
sqlite3VdbeResolveLabel(v, lblRecheckOk);
|
|
}
|
|
|
|
/* Generate the table record */
|
|
if( HasRowid(pTab) ){
|
|
int regRec = aRegIdx[ix];
|
|
sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
|
|
sqlite3SetMakeRecordP5(v, pTab);
|
|
if( !bAffinityDone ){
|
|
sqlite3TableAffinity(v, pTab, 0);
|
|
}
|
|
}
|
|
|
|
*pbMayReplace = seenReplace;
|
|
VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
|
|
}
|
|
|
|
#ifdef SQLITE_ENABLE_NULL_TRIM
|
|
/*
|
|
** Change the P5 operand on the last opcode (which should be an OP_MakeRecord)
|
|
** to be the number of columns in table pTab that must not be NULL-trimmed.
|
|
**
|
|
** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
|
|
*/
|
|
void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
|
|
u16 i;
|
|
|
|
/* Records with omitted columns are only allowed for schema format
|
|
** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
|
|
if( pTab->pSchema->file_format<2 ) return;
|
|
|
|
for(i=pTab->nCol-1; i>0; i--){
|
|
if( pTab->aCol[i].pDflt!=0 ) break;
|
|
if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
|
|
}
|
|
sqlite3VdbeChangeP5(v, i+1);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** This routine generates code to finish the INSERT or UPDATE operation
|
|
** that was started by a prior call to sqlite3GenerateConstraintChecks.
|
|
** A consecutive range of registers starting at regNewData contains the
|
|
** rowid and the content to be inserted.
|
|
**
|
|
** The arguments to this routine should be the same as the first six
|
|
** arguments to sqlite3GenerateConstraintChecks.
|
|
*/
|
|
void sqlite3CompleteInsertion(
|
|
Parse *pParse, /* The parser context */
|
|
Table *pTab, /* the table into which we are inserting */
|
|
int iDataCur, /* Cursor of the canonical data source */
|
|
int iIdxCur, /* First index cursor */
|
|
int regNewData, /* Range of content */
|
|
int *aRegIdx, /* Register used by each index. 0 for unused indices */
|
|
int update_flags, /* True for UPDATE, False for INSERT */
|
|
int appendBias, /* True if this is likely to be an append */
|
|
int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
|
|
){
|
|
Vdbe *v; /* Prepared statements under construction */
|
|
Index *pIdx; /* An index being inserted or updated */
|
|
u8 pik_flags; /* flag values passed to the btree insert */
|
|
int i; /* Loop counter */
|
|
|
|
assert( update_flags==0
|
|
|| update_flags==OPFLAG_ISUPDATE
|
|
|| update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION)
|
|
);
|
|
|
|
v = sqlite3GetVdbe(pParse);
|
|
assert( v!=0 );
|
|
assert( pTab->pSelect==0 ); /* This table is not a VIEW */
|
|
for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
|
|
/* All REPLACE indexes are at the end of the list */
|
|
assert( pIdx->onError!=OE_Replace
|
|
|| pIdx->pNext==0
|
|
|| pIdx->pNext->onError==OE_Replace );
|
|
if( aRegIdx[i]==0 ) continue;
|
|
if( pIdx->pPartIdxWhere ){
|
|
sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
|
|
VdbeCoverage(v);
|
|
}
|
|
pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0);
|
|
if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
|
|
assert( pParse->nested==0 );
|
|
pik_flags |= OPFLAG_NCHANGE;
|
|
pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);
|
|
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
|
|
if( update_flags==0 ){
|
|
int r = sqlite3GetTempReg(pParse);
|
|
sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
|
|
sqlite3VdbeAddOp4(v, OP_Insert,
|
|
iIdxCur+i, aRegIdx[i], r, (char*)pTab, P4_TABLE
|
|
);
|
|
sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
|
|
sqlite3ReleaseTempReg(pParse, r);
|
|
}
|
|
#endif
|
|
}
|
|
sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
|
|
aRegIdx[i]+1,
|
|
pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
|
|
sqlite3VdbeChangeP5(v, pik_flags);
|
|
}
|
|
if( !HasRowid(pTab) ) return;
|
|
if( pParse->nested ){
|
|
pik_flags = 0;
|
|
}else{
|
|
pik_flags = OPFLAG_NCHANGE;
|
|
pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID);
|
|
}
|
|
if( appendBias ){
|
|
pik_flags |= OPFLAG_APPEND;
|
|
}
|
|
if( useSeekResult ){
|
|
pik_flags |= OPFLAG_USESEEKRESULT;
|
|
}
|
|
sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData);
|
|
if( !pParse->nested ){
|
|
sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
|
|
}
|
|
sqlite3VdbeChangeP5(v, pik_flags);
|
|
}
|
|
|
|
/*
|
|
** Allocate cursors for the pTab table and all its indices and generate
|
|
** code to open and initialized those cursors.
|
|
**
|
|
** The cursor for the object that contains the complete data (normally
|
|
** the table itself, but the PRIMARY KEY index in the case of a WITHOUT
|
|
** ROWID table) is returned in *piDataCur. The first index cursor is
|
|
** returned in *piIdxCur. The number of indices is returned.
|
|
**
|
|
** Use iBase as the first cursor (either the *piDataCur for rowid tables
|
|
** or the first index for WITHOUT ROWID tables) if it is non-negative.
|
|
** If iBase is negative, then allocate the next available cursor.
|
|
**
|
|
** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
|
|
** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
|
|
** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the
|
|
** pTab->pIndex list.
|
|
**
|
|
** If pTab is a virtual table, then this routine is a no-op and the
|
|
** *piDataCur and *piIdxCur values are left uninitialized.
|
|
*/
|
|
int sqlite3OpenTableAndIndices(
|
|
Parse *pParse, /* Parsing context */
|
|
Table *pTab, /* Table to be opened */
|
|
int op, /* OP_OpenRead or OP_OpenWrite */
|
|
u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */
|
|
int iBase, /* Use this for the table cursor, if there is one */
|
|
u8 *aToOpen, /* If not NULL: boolean for each table and index */
|
|
int *piDataCur, /* Write the database source cursor number here */
|
|
int *piIdxCur /* Write the first index cursor number here */
|
|
){
|
|
int i;
|
|
int iDb;
|
|
int iDataCur;
|
|
Index *pIdx;
|
|
Vdbe *v;
|
|
|
|
assert( op==OP_OpenRead || op==OP_OpenWrite );
|
|
assert( op==OP_OpenWrite || p5==0 );
|
|
if( IsVirtual(pTab) ){
|
|
/* This routine is a no-op for virtual tables. Leave the output
|
|
** variables *piDataCur and *piIdxCur uninitialized so that valgrind
|
|
** can detect if they are used by mistake in the caller. */
|
|
return 0;
|
|
}
|
|
iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
|
|
v = sqlite3GetVdbe(pParse);
|
|
assert( v!=0 );
|
|
if( iBase<0 ) iBase = pParse->nTab;
|
|
iDataCur = iBase++;
|
|
if( piDataCur ) *piDataCur = iDataCur;
|
|
if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
|
|
sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
|
|
}else{
|
|
sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
|
|
}
|
|
if( piIdxCur ) *piIdxCur = iBase;
|
|
for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
|
|
int iIdxCur = iBase++;
|
|
assert( pIdx->pSchema==pTab->pSchema );
|
|
if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
|
|
if( piDataCur ) *piDataCur = iIdxCur;
|
|
p5 = 0;
|
|
}
|
|
if( aToOpen==0 || aToOpen[i+1] ){
|
|
sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
|
|
sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
|
|
sqlite3VdbeChangeP5(v, p5);
|
|
VdbeComment((v, "%s", pIdx->zName));
|
|
}
|
|
}
|
|
if( iBase>pParse->nTab ) pParse->nTab = iBase;
|
|
return i;
|
|
}
|
|
|
|
|
|
#ifdef SQLITE_TEST
|
|
/*
|
|
** The following global variable is incremented whenever the
|
|
** transfer optimization is used. This is used for testing
|
|
** purposes only - to make sure the transfer optimization really
|
|
** is happening when it is supposed to.
|
|
*/
|
|
int sqlite3_xferopt_count;
|
|
#endif /* SQLITE_TEST */
|
|
|
|
|
|
#ifndef SQLITE_OMIT_XFER_OPT
|
|
/*
|
|
** Check to see if index pSrc is compatible as a source of data
|
|
** for index pDest in an insert transfer optimization. The rules
|
|
** for a compatible index:
|
|
**
|
|
** * The index is over the same set of columns
|
|
** * The same DESC and ASC markings occurs on all columns
|
|
** * The same onError processing (OE_Abort, OE_Ignore, etc)
|
|
** * The same collating sequence on each column
|
|
** * The index has the exact same WHERE clause
|
|
*/
|
|
static int xferCompatibleIndex(Index *pDest, Index *pSrc){
|
|
int i;
|
|
assert( pDest && pSrc );
|
|
assert( pDest->pTable!=pSrc->pTable );
|
|
if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){
|
|
return 0; /* Different number of columns */
|
|
}
|
|
if( pDest->onError!=pSrc->onError ){
|
|
return 0; /* Different conflict resolution strategies */
|
|
}
|
|
for(i=0; i<pSrc->nKeyCol; i++){
|
|
if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
|
|
return 0; /* Different columns indexed */
|
|
}
|
|
if( pSrc->aiColumn[i]==XN_EXPR ){
|
|
assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
|
|
if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
|
|
pDest->aColExpr->a[i].pExpr, -1)!=0 ){
|
|
return 0; /* Different expressions in the index */
|
|
}
|
|
}
|
|
if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
|
|
return 0; /* Different sort orders */
|
|
}
|
|
if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){
|
|
return 0; /* Different collating sequences */
|
|
}
|
|
}
|
|
if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){
|
|
return 0; /* Different WHERE clauses */
|
|
}
|
|
|
|
/* If no test above fails then the indices must be compatible */
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
** Attempt the transfer optimization on INSERTs of the form
|
|
**
|
|
** INSERT INTO tab1 SELECT * FROM tab2;
|
|
**
|
|
** The xfer optimization transfers raw records from tab2 over to tab1.
|
|
** Columns are not decoded and reassembled, which greatly improves
|
|
** performance. Raw index records are transferred in the same way.
|
|
**
|
|
** The xfer optimization is only attempted if tab1 and tab2 are compatible.
|
|
** There are lots of rules for determining compatibility - see comments
|
|
** embedded in the code for details.
|
|
**
|
|
** This routine returns TRUE if the optimization is guaranteed to be used.
|
|
** Sometimes the xfer optimization will only work if the destination table
|
|
** is empty - a factor that can only be determined at run-time. In that
|
|
** case, this routine generates code for the xfer optimization but also
|
|
** does a test to see if the destination table is empty and jumps over the
|
|
** xfer optimization code if the test fails. In that case, this routine
|
|
** returns FALSE so that the caller will know to go ahead and generate
|
|
** an unoptimized transfer. This routine also returns FALSE if there
|
|
** is no chance that the xfer optimization can be applied.
|
|
**
|
|
** This optimization is particularly useful at making VACUUM run faster.
|
|
*/
|
|
static int xferOptimization(
|
|
Parse *pParse, /* Parser context */
|
|
Table *pDest, /* The table we are inserting into */
|
|
Select *pSelect, /* A SELECT statement to use as the data source */
|
|
int onError, /* How to handle constraint errors */
|
|
int iDbDest /* The database of pDest */
|
|
){
|
|
sqlite3 *db = pParse->db;
|
|
ExprList *pEList; /* The result set of the SELECT */
|
|
Table *pSrc; /* The table in the FROM clause of SELECT */
|
|
Index *pSrcIdx, *pDestIdx; /* Source and destination indices */
|
|
struct SrcList_item *pItem; /* An element of pSelect->pSrc */
|
|
int i; /* Loop counter */
|
|
int iDbSrc; /* The database of pSrc */
|
|
int iSrc, iDest; /* Cursors from source and destination */
|
|
int addr1, addr2; /* Loop addresses */
|
|
int emptyDestTest = 0; /* Address of test for empty pDest */
|
|
int emptySrcTest = 0; /* Address of test for empty pSrc */
|
|
Vdbe *v; /* The VDBE we are building */
|
|
int regAutoinc; /* Memory register used by AUTOINC */
|
|
int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */
|
|
int regData, regRowid; /* Registers holding data and rowid */
|
|
|
|
if( pSelect==0 ){
|
|
return 0; /* Must be of the form INSERT INTO ... SELECT ... */
|
|
}
|
|
if( pParse->pWith || pSelect->pWith ){
|
|
/* Do not attempt to process this query if there are an WITH clauses
|
|
** attached to it. Proceeding may generate a false "no such table: xxx"
|
|
** error if pSelect reads from a CTE named "xxx". */
|
|
return 0;
|
|
}
|
|
if( sqlite3TriggerList(pParse, pDest) ){
|
|
return 0; /* tab1 must not have triggers */
|
|
}
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( IsVirtual(pDest) ){
|
|
return 0; /* tab1 must not be a virtual table */
|
|
}
|
|
#endif
|
|
if( onError==OE_Default ){
|
|
if( pDest->iPKey>=0 ) onError = pDest->keyConf;
|
|
if( onError==OE_Default ) onError = OE_Abort;
|
|
}
|
|
assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
|
|
if( pSelect->pSrc->nSrc!=1 ){
|
|
return 0; /* FROM clause must have exactly one term */
|
|
}
|
|
if( pSelect->pSrc->a[0].pSelect ){
|
|
return 0; /* FROM clause cannot contain a subquery */
|
|
}
|
|
if( pSelect->pWhere ){
|
|
return 0; /* SELECT may not have a WHERE clause */
|
|
}
|
|
if( pSelect->pOrderBy ){
|
|
return 0; /* SELECT may not have an ORDER BY clause */
|
|
}
|
|
/* Do not need to test for a HAVING clause. If HAVING is present but
|
|
** there is no ORDER BY, we will get an error. */
|
|
if( pSelect->pGroupBy ){
|
|
return 0; /* SELECT may not have a GROUP BY clause */
|
|
}
|
|
if( pSelect->pLimit ){
|
|
return 0; /* SELECT may not have a LIMIT clause */
|
|
}
|
|
if( pSelect->pPrior ){
|
|
return 0; /* SELECT may not be a compound query */
|
|
}
|
|
if( pSelect->selFlags & SF_Distinct ){
|
|
return 0; /* SELECT may not be DISTINCT */
|
|
}
|
|
pEList = pSelect->pEList;
|
|
assert( pEList!=0 );
|
|
if( pEList->nExpr!=1 ){
|
|
return 0; /* The result set must have exactly one column */
|
|
}
|
|
assert( pEList->a[0].pExpr );
|
|
if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
|
|
return 0; /* The result set must be the special operator "*" */
|
|
}
|
|
|
|
/* At this point we have established that the statement is of the
|
|
** correct syntactic form to participate in this optimization. Now
|
|
** we have to check the semantics.
|
|
*/
|
|
pItem = pSelect->pSrc->a;
|
|
pSrc = sqlite3LocateTableItem(pParse, 0, pItem);
|
|
if( pSrc==0 ){
|
|
return 0; /* FROM clause does not contain a real table */
|
|
}
|
|
if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){
|
|
testcase( pSrc!=pDest ); /* Possible due to bad sqlite_master.rootpage */
|
|
return 0; /* tab1 and tab2 may not be the same table */
|
|
}
|
|
if( HasRowid(pDest)!=HasRowid(pSrc) ){
|
|
return 0; /* source and destination must both be WITHOUT ROWID or not */
|
|
}
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
if( IsVirtual(pSrc) ){
|
|
return 0; /* tab2 must not be a virtual table */
|
|
}
|
|
#endif
|
|
if( pSrc->pSelect ){
|
|
return 0; /* tab2 may not be a view */
|
|
}
|
|
if( pDest->nCol!=pSrc->nCol ){
|
|
return 0; /* Number of columns must be the same in tab1 and tab2 */
|
|
}
|
|
if( pDest->iPKey!=pSrc->iPKey ){
|
|
return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
|
|
}
|
|
for(i=0; i<pDest->nCol; i++){
|
|
Column *pDestCol = &pDest->aCol[i];
|
|
Column *pSrcCol = &pSrc->aCol[i];
|
|
#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
|
|
if( (db->mDbFlags & DBFLAG_Vacuum)==0
|
|
&& (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN
|
|
){
|
|
return 0; /* Neither table may have __hidden__ columns */
|
|
}
|
|
#endif
|
|
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
|
|
/* Even if tables t1 and t2 have identical schemas, if they contain
|
|
** generated columns, then this statement is semantically incorrect:
|
|
**
|
|
** INSERT INTO t2 SELECT * FROM t1;
|
|
**
|
|
** The reason is that generated column values are returned by the
|
|
** the SELECT statement on the right but the INSERT statement on the
|
|
** left wants them to be omitted.
|
|
**
|
|
** Nevertheless, this is a useful notational shorthand to tell SQLite
|
|
** to do a bulk transfer all of the content from t1 over to t2.
|
|
**
|
|
** We could, in theory, disable this (except for internal use by the
|
|
** VACUUM command where it is actually needed). But why do that? It
|
|
** seems harmless enough, and provides a useful service.
|
|
*/
|
|
if( (pDestCol->colFlags & COLFLAG_GENERATED) !=
|
|
(pSrcCol->colFlags & COLFLAG_GENERATED) ){
|
|
return 0; /* Both columns have the same generated-column type */
|
|
}
|
|
/* But the transfer is only allowed if both the source and destination
|
|
** tables have the exact same expressions for generated columns.
|
|
** This requirement could be relaxed for VIRTUAL columns, I suppose.
|
|
*/
|
|
if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){
|
|
if( sqlite3ExprCompare(0, pSrcCol->pDflt, pDestCol->pDflt, -1)!=0 ){
|
|
testcase( pDestCol->colFlags & COLFLAG_VIRTUAL );
|
|
testcase( pDestCol->colFlags & COLFLAG_STORED );
|
|
return 0; /* Different generator expressions */
|
|
}
|
|
}
|
|
#endif
|
|
if( pDestCol->affinity!=pSrcCol->affinity ){
|
|
return 0; /* Affinity must be the same on all columns */
|
|
}
|
|
if( sqlite3_stricmp(pDestCol->zColl, pSrcCol->zColl)!=0 ){
|
|
return 0; /* Collating sequence must be the same on all columns */
|
|
}
|
|
if( pDestCol->notNull && !pSrcCol->notNull ){
|
|
return 0; /* tab2 must be NOT NULL if tab1 is */
|
|
}
|
|
/* Default values for second and subsequent columns need to match. */
|
|
if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){
|
|
assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN );
|
|
assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN );
|
|
if( (pDestCol->pDflt==0)!=(pSrcCol->pDflt==0)
|
|
|| (pDestCol->pDflt && strcmp(pDestCol->pDflt->u.zToken,
|
|
pSrcCol->pDflt->u.zToken)!=0)
|
|
){
|
|
return 0; /* Default values must be the same for all columns */
|
|
}
|
|
}
|
|
}
|
|
for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
|
|
if( IsUniqueIndex(pDestIdx) ){
|
|
destHasUniqueIdx = 1;
|
|
}
|
|
for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
|
|
if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
|
|
}
|
|
if( pSrcIdx==0 ){
|
|
return 0; /* pDestIdx has no corresponding index in pSrc */
|
|
}
|
|
if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema
|
|
&& sqlite3FaultSim(411)==SQLITE_OK ){
|
|
/* The sqlite3FaultSim() call allows this corruption test to be
|
|
** bypassed during testing, in order to exercise other corruption tests
|
|
** further downstream. */
|
|
return 0; /* Corrupt schema - two indexes on the same btree */
|
|
}
|
|
}
|
|
#ifndef SQLITE_OMIT_CHECK
|
|
if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){
|
|
return 0; /* Tables have different CHECK constraints. Ticket #2252 */
|
|
}
|
|
#endif
|
|
#ifndef SQLITE_OMIT_FOREIGN_KEY
|
|
/* Disallow the transfer optimization if the destination table constains
|
|
** any foreign key constraints. This is more restrictive than necessary.
|
|
** But the main beneficiary of the transfer optimization is the VACUUM
|
|
** command, and the VACUUM command disables foreign key constraints. So
|
|
** the extra complication to make this rule less restrictive is probably
|
|
** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
|
|
*/
|
|
if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
|
|
return 0;
|
|
}
|
|
#endif
|
|
if( (db->flags & SQLITE_CountRows)!=0 ){
|
|
return 0; /* xfer opt does not play well with PRAGMA count_changes */
|
|
}
|
|
|
|
/* If we get this far, it means that the xfer optimization is at
|
|
** least a possibility, though it might only work if the destination
|
|
** table (tab1) is initially empty.
|
|
*/
|
|
#ifdef SQLITE_TEST
|
|
sqlite3_xferopt_count++;
|
|
#endif
|
|
iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
|
|
v = sqlite3GetVdbe(pParse);
|
|
sqlite3CodeVerifySchema(pParse, iDbSrc);
|
|
iSrc = pParse->nTab++;
|
|
iDest = pParse->nTab++;
|
|
regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
|
|
regData = sqlite3GetTempReg(pParse);
|
|
regRowid = sqlite3GetTempReg(pParse);
|
|
sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
|
|
assert( HasRowid(pDest) || destHasUniqueIdx );
|
|
if( (db->mDbFlags & DBFLAG_Vacuum)==0 && (
|
|
(pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */
|
|
|| destHasUniqueIdx /* (2) */
|
|
|| (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */
|
|
)){
|
|
/* In some circumstances, we are able to run the xfer optimization
|
|
** only if the destination table is initially empty. Unless the
|
|
** DBFLAG_Vacuum flag is set, this block generates code to make
|
|
** that determination. If DBFLAG_Vacuum is set, then the destination
|
|
** table is always empty.
|
|
**
|
|
** Conditions under which the destination must be empty:
|
|
**
|
|
** (1) There is no INTEGER PRIMARY KEY but there are indices.
|
|
** (If the destination is not initially empty, the rowid fields
|
|
** of index entries might need to change.)
|
|
**
|
|
** (2) The destination has a unique index. (The xfer optimization
|
|
** is unable to test uniqueness.)
|
|
**
|
|
** (3) onError is something other than OE_Abort and OE_Rollback.
|
|
*/
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
|
|
emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
}
|
|
if( HasRowid(pSrc) ){
|
|
u8 insFlags;
|
|
sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
|
|
emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
|
|
if( pDest->iPKey>=0 ){
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
|
|
sqlite3VdbeVerifyAbortable(v, onError);
|
|
addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
|
|
VdbeCoverage(v);
|
|
sqlite3RowidConstraint(pParse, onError, pDest);
|
|
sqlite3VdbeJumpHere(v, addr2);
|
|
autoIncStep(pParse, regAutoinc, regRowid);
|
|
}else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
|
|
}else{
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
|
|
assert( (pDest->tabFlags & TF_Autoincrement)==0 );
|
|
}
|
|
sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
|
|
if( db->mDbFlags & DBFLAG_Vacuum ){
|
|
sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
|
|
insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|
|
|
OPFLAG_APPEND|OPFLAG_USESEEKRESULT;
|
|
}else{
|
|
insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND;
|
|
}
|
|
sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid,
|
|
(char*)pDest, P4_TABLE);
|
|
sqlite3VdbeChangeP5(v, insFlags);
|
|
sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
|
|
sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
|
|
sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
|
|
}else{
|
|
sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
|
|
sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
|
|
}
|
|
for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
|
|
u8 idxInsFlags = 0;
|
|
for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
|
|
if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
|
|
}
|
|
assert( pSrcIdx );
|
|
sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
|
|
sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
|
|
VdbeComment((v, "%s", pSrcIdx->zName));
|
|
sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
|
|
sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
|
|
sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
|
|
VdbeComment((v, "%s", pDestIdx->zName));
|
|
addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
|
|
sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
|
|
if( db->mDbFlags & DBFLAG_Vacuum ){
|
|
/* This INSERT command is part of a VACUUM operation, which guarantees
|
|
** that the destination table is empty. If all indexed columns use
|
|
** collation sequence BINARY, then it can also be assumed that the
|
|
** index will be populated by inserting keys in strictly sorted
|
|
** order. In this case, instead of seeking within the b-tree as part
|
|
** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the
|
|
** OP_IdxInsert to seek to the point within the b-tree where each key
|
|
** should be inserted. This is faster.
|
|
**
|
|
** If any of the indexed columns use a collation sequence other than
|
|
** BINARY, this optimization is disabled. This is because the user
|
|
** might change the definition of a collation sequence and then run
|
|
** a VACUUM command. In that case keys may not be written in strictly
|
|
** sorted order. */
|
|
for(i=0; i<pSrcIdx->nColumn; i++){
|
|
const char *zColl = pSrcIdx->azColl[i];
|
|
if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
|
|
}
|
|
if( i==pSrcIdx->nColumn ){
|
|
idxInsFlags = OPFLAG_USESEEKRESULT;
|
|
sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
|
|
}
|
|
}
|
|
if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
|
|
idxInsFlags |= OPFLAG_NCHANGE;
|
|
}
|
|
sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
|
|
sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
|
|
sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
|
|
sqlite3VdbeJumpHere(v, addr1);
|
|
sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
|
|
sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
|
|
}
|
|
if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
|
|
sqlite3ReleaseTempReg(pParse, regRowid);
|
|
sqlite3ReleaseTempReg(pParse, regData);
|
|
if( emptyDestTest ){
|
|
sqlite3AutoincrementEnd(pParse);
|
|
sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
|
|
sqlite3VdbeJumpHere(v, emptyDestTest);
|
|
sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
|
|
return 0;
|
|
}else{
|
|
return 1;
|
|
}
|
|
}
|
|
#endif /* SQLITE_OMIT_XFER_OPT */
|