/*

** 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) );

assert( pParse->pVdbe!=0 );

v = pParse->pVdbe;

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 || CORRUPT_DB );

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->bHasExpr );

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 an affinity string for a table. Space is obtained

** from sqlite3DbMalloc(). The caller is responsible for freeing

** the space when done.

*/

char *sqlite3TableAffinityStr(sqlite3 *db, const Table *pTab){

char *zColAff;

zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);

if( zColAff ){

int i, j;

for(i=j=0; i<pTab->nCol; i++){

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 );

}

return zColAff;

}

/*

** Make changes to the evolving bytecode to do affinity transformations

** of values that are about to be gathered into a row for table pTab.

**

** For ordinary (legacy, non-strict) tables:

** -----------------------------------------

**

** 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 string is empty (because it was all SQLITE_AFF_BLOB entries

** which were then optimized out) then this routine becomes a no-op.

**

** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the

** affinities for register iReg and following. Or if 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

**

** For STRICT tables:

** ------------------

**

** Generate an appropropriate OP_TypeCheck opcode that will verify the

** datatypes against the column definitions in pTab. If iReg==0, that

** means an OP_MakeRecord opcode has already been generated and should be

** the last opcode generated. The new OP_TypeCheck needs to be inserted

** before the OP_MakeRecord. The new OP_TypeCheck should use the same

** register set as the OP_MakeRecord. If iReg>0 then register iReg is

** the first of a series of registers that will form the new record.

** Apply the type checking to that array of registers.

*/

void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){

int i;

char *zColAff;

if( pTab->tabFlags & TF_Strict ){

if( iReg==0 ){

/* Move the previous opcode (which should be OP_MakeRecord) forward

** by one slot and insert a new OP_TypeCheck where the current

** OP_MakeRecord is found */

VdbeOp *pPrev;

sqlite3VdbeAppendP4(v, pTab, P4_TABLE);

pPrev = sqlite3VdbeGetLastOp(v);

assert( pPrev!=0 );

assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );

pPrev->opcode = OP_TypeCheck;

sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3);

}else{

/* Insert an isolated OP_Typecheck */

sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);

sqlite3VdbeAppendP4(v, pTab, P4_TABLE);

}

return;

}

zColAff = pTab->zColAff;

if( zColAff==0 ){

zColAff = sqlite3TableAffinityStr(0, pTab);

if( !zColAff ){

sqlite3OomFault(sqlite3VdbeDb(v));

return;

}

pTab->zColAff = zColAff;

}

assert( zColAff!=0 );

i = sqlite3Strlen30NN(zColAff);

if( i ){

if( iReg ){

sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);

}else{

assert( sqlite3VdbeGetLastOp(v)->opcode==OP_MakeRecord

|| sqlite3VdbeDb(v)->mallocFailed );

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;

Pgno 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 = sqlite3VdbeGetLastOp(pParse->pVdbe);

if( pOp->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++;

}

}else if( pOp->opcode==OP_TypeCheck ){

/* If an OP_TypeCheck was generated because the table is STRICT,

** then set the P3 operand to indicate that generated columns should

** not be checked */

pOp->p3 = 1;

}

}

/* 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, sqlite3ColumnExpr(pTab, pCol));

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, pTab, pCol, x);

pCol->colFlags &= ~COLFLAG_NOTAVAIL;

}

}

}while( pRedo && eProgress );

if( pRedo ){

sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName);

}

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)

|| NEVER(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));

sqlite3ParserAddCleanup(pToplevel, sqlite3DbFree, pInfo);

testcase( pParse->earlyCleanup );

if( pParse->db->mallocFailed ) 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;

assert( db->pParse==pParse );

if( pParse->nErr ){

goto insert_cleanup;

}

assert( db->mallocFailed==0 );

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 = IsView(pTab);

#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 TREETRACE_ENABLED

if( sqlite3TreeTrace & 0x10000 ){

sqlite3TreeViewLine(0, "In sqlite3Insert() at %s:%d", __FILE__, __LINE__);

sqlite3TreeViewInsert(pParse->pWith, pTabList, pColumn, pSelect, pList,

onError, pUpsert, pTrigger);

}

#endif

/* 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

&& pSelect!=0

&& pTrigger==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 ){

assert( pColumn->eU4!=EU4_EXPR );

pColumn->eU4 = EU4_IDX;

for(i=0; i<pColumn->nId; i++){

pColumn->a[i].u4.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].zCnName)==0 ){

pColumn->a[i].u4.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].zCnName);

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->a, 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;

assert( db->pParse==pParse );

if( rc || pParse->nErr ) goto insert_cleanup;

assert( db->mallocFailed==0 );

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 );