/*

** 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 open a table for reading.

*/

void sqlite3OpenTable(

Parse *p, /* 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(p);

assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );

sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);

sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);

sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);

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' TEXT

** 'b' NONE

** 'c' NUMERIC

** 'd' INTEGER

** 'e' 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(Vdbe *v, 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;

sqlite3 *db = sqlite3VdbeDb(v);

pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+2);

if( !pIdx->zColAff ){

db->mallocFailed = 1;

return 0;

}

for(n=0; n<pIdx->nColumn; n++){

pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;

}

pIdx->zColAff[n++] = SQLITE_AFF_INTEGER;

pIdx->zColAff[n] = 0;

}

return pIdx->zColAff;

}

/*

** Set P4 of the most recently inserted opcode to a column affinity

** string for table pTab. A column affinity string has one character

** for each column indexed by the index, according to the affinity of the

** column:

**

** Character Column affinity

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

** 'a' TEXT

** 'b' NONE

** 'c' NUMERIC

** 'd' INTEGER

** 'e' REAL

*/

void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){

/* The first time a column affinity string for a particular table

** is required, it is allocated and populated here. It is then

** stored as a member of the Table structure for subsequent use.

**

** The column affinity string will eventually be deleted by

** sqlite3DeleteTable() when the Table structure itself is cleaned up.

*/

if( !pTab->zColAff ){

char *zColAff;

int i;

sqlite3 *db = sqlite3VdbeDb(v);

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

if( !zColAff ){

db->mallocFailed = 1;

return;

}

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

zColAff[i] = pTab->aCol[i].affinity;

}

zColAff[pTab->nCol] = '\0';

pTab->zColAff = zColAff;

}

sqlite3VdbeChangeP4(v, -1, pTab->zColAff, P4_TRANSIENT);

}

/*

** 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 beginning at location

** iStartAddr throught the end of the program. This is used to see if

** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can

** run without using temporary table for the results of the SELECT.

*/

static int readsTable(Parse *p, int iStartAddr, 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=iStartAddr; 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;

}

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

**

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

**

** Three memory locations are allocated:

**

** (1) Register to hold the name of the pTab table.

** (2) Register to hold the maximum ROWID of pTab.

** (3) Register to hold the rowid in sqlite_sequence of pTab

**

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

if( pTab->tabFlags & TF_Autoincrement ){

Parse *pToplevel = sqlite3ParseToplevel(pParse);

AutoincInfo *pInfo;

pInfo = pToplevel->pAinc;

while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }

if( pInfo==0 ){

pInfo = sqlite3DbMallocRaw(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++; /* Rowid in sqlite_sequence */

}

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

int addr; /* A VDBE address */

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( pParse==sqlite3ParseToplevel(pParse) );

assert( v ); /* We failed long ago if this is not so */

for(p = pParse->pAinc; p; p = p->pNext){

pDb = &db->aDb[p->iDb];

memId = p->regCtr;

assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );

sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);

sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1);

addr = sqlite3VdbeCurrentAddr(v);

sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);

sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9);

sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId);

sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);

sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);

sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);

sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId);

sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+9);

sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2);

sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);

sqlite3VdbeAddOp0(v, OP_Close);

}

}

/*

** Update the maximum rowid for an autoincrement calculation.

**

** This routine should be called when the top of the stack 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. The stack is unchanged.

*/

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.

*/

void sqlite3AutoincrementEnd(Parse *pParse){

AutoincInfo *p;

Vdbe *v = pParse->pVdbe;

sqlite3 *db = pParse->db;

assert( v );

for(p = pParse->pAinc; p; p = p->pNext){

Db *pDb = &db->aDb[p->iDb];

int j1, j2, j3, j4, j5;

int iRec;

int memId = p->regCtr;

iRec = sqlite3GetTempReg(pParse);

assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );

sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);

j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);

j2 = sqlite3VdbeAddOp0(v, OP_Rewind);

j3 = sqlite3VdbeAddOp3(v, OP_Column, 0, 0, iRec);

j4 = sqlite3VdbeAddOp3(v, OP_Eq, memId-1, 0, iRec);

sqlite3VdbeAddOp2(v, OP_Next, 0, j3);

sqlite3VdbeJumpHere(v, j2);

sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);

j5 = sqlite3VdbeAddOp0(v, OP_Goto);

sqlite3VdbeJumpHere(v, j4);

sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);

sqlite3VdbeJumpHere(v, j1);

sqlite3VdbeJumpHere(v, j5);

sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);

sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);

sqlite3VdbeChangeP5(v, OPFLAG_APPEND);

sqlite3VdbeAddOp0(v, OP_Close);

sqlite3ReleaseTempReg(pParse, iRec);

}

}

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

/*

** Generate code for a co-routine that will evaluate a subquery one

** row at a time.

**

** The pSelect parameter is the subquery that the co-routine will evaluation.

** Information about the location of co-routine and the registers it will use

** is returned by filling in the pDest object.

**

** Registers are allocated as follows:

**

** pDest->iSDParm The register holding the next entry-point of the

** co-routine. Run the co-routine to its next breakpoint

** by calling "OP_Yield $X" where $X is pDest->iSDParm.

**

** pDest->iSDParm+1 The register holding the "completed" flag for the

** co-routine. This register is 0 if the previous Yield

** generated a new result row, or 1 if the subquery

** has completed. If the Yield is called again

** after this register becomes 1, then the VDBE will

** halt with an SQLITE_INTERNAL error.

**

** pDest->iSdst First result register.

**

** pDest->nSdst Number of result registers.

**

** This routine handles all of the register allocation and fills in the

** pDest structure appropriately.

**

** Here is a schematic of the generated code assuming that X is the

** co-routine entry-point register reg[pDest->iSDParm], that EOF is the

** completed flag reg[pDest->iSDParm+1], and R and S are the range of

** registers that hold the result set, reg[pDest->iSdst] through

** reg[pDest->iSdst+pDest->nSdst-1]:

**

** X <- A

** EOF <- 0

** goto B

** A: setup for the SELECT

** loop rows in the SELECT

** load results into registers R..S

** yield X

** end loop

** cleanup after the SELECT

** EOF <- 1

** yield X

** halt-error

** B:

**

** To use this subroutine, the caller generates code as follows:

**

** [ Co-routine generated by this subroutine, shown above ]

** S: yield X

** if EOF goto E

** if skip this row, goto C

** if terminate loop, goto E

** deal with this row

** C: goto S

** E:

*/

int sqlite3CodeCoroutine(Parse *pParse, Select *pSelect, SelectDest *pDest){

int regYield; /* Register holding co-routine entry-point */

int regEof; /* Register holding co-routine completion flag */

int addrTop; /* Top of the co-routine */

int j1; /* Jump instruction */

int rc; /* Result code */

Vdbe *v; /* VDBE under construction */

regYield = ++pParse->nMem;

regEof = ++pParse->nMem;

v = sqlite3GetVdbe(pParse);

addrTop = sqlite3VdbeCurrentAddr(v);

sqlite3VdbeAddOp2(v, OP_Integer, addrTop+2, regYield); /* X <- A */

VdbeComment((v, "Co-routine entry point"));

sqlite3VdbeAddOp2(v, OP_Integer, 0, regEof); /* EOF <- 0 */

VdbeComment((v, "Co-routine completion flag"));

sqlite3SelectDestInit(pDest, SRT_Coroutine, regYield);

j1 = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);

rc = sqlite3Select(pParse, pSelect, pDest);

assert( pParse->nErr==0 || rc );

if( pParse->db->mallocFailed && rc==SQLITE_OK ) rc = SQLITE_NOMEM;

if( rc ) return rc;

sqlite3VdbeAddOp2(v, OP_Integer, 1, regEof); /* EOF <- 1 */

sqlite3VdbeAddOp1(v, OP_Yield, regYield); /* yield X */

sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_INTERNAL, OE_Abort);

VdbeComment((v, "End of coroutine"));

sqlite3VdbeJumpHere(v, j1); /* label B: */

return rc;

}

/* 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 call to handle SQL of the following forms:

**

** insert into TABLE (IDLIST) values(EXPRLIST)

** insert into TABLE (IDLIST) select

**

** The IDLIST following the table name is always optional. If omitted,

** then a list of all columns for the table is substituted. The IDLIST

** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted.

**

** The pList parameter holds EXPRLIST in the first form of the INSERT

** statement above, and pSelect is NULL. For the second form, pList is

** NULL and pSelect is a pointer to the select statement used to generate

** data for the insert.

**

** The code generated follows one of four templates. For a simple

** select with data coming from a 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

** puts VALUES clause expressions onto the stack

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

**

** EOF <- 0

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

** EOF <- 1

** yield X

** goto A

** B: open write cursor to <table> and its indices

** C: yield X

** if 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 a intermediate table to store the results of

** the select. The template is like this:

**

** EOF <- 0

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

** EOF <- 1

** yield X

** halt-error

** B: open temp table

** L: yield X

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

ExprList *pList, /* List of values to be inserted */

Select *pSelect, /* A SELECT statement to use as the data source */

IdList *pColumn, /* Column names corresponding to IDLIST. */

int onError /* How to handle constraint errors */

){

sqlite3 *db; /* The main database structure */

Table *pTab; /* The table to insert into. aka TABLE */

char *zTab; /* Name of the table into which we are inserting */

const char *zDb; /* Name of the database holding this table */

int i, j, idx; /* 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 baseCur = 0; /* VDBE Cursor number for pTab */

int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */

int endOfLoop; /* Label for the end of the insertion loop */

int useTempTable = 0; /* Store SELECT results in intermediate table */

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

int addrSelect = 0; /* Address of coroutine that implements the SELECT */

SelectDest dest; /* Destination for SELECT on rhs of INSERT */

int iDb; /* Index of database holding TABLE */

Db *pDb; /* The database containing table being inserted into */

int appendFlag = 0; /* True if the insert is likely to be an append */

/* 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 regEof = 0; /* Register recording end of SELECT data */

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;

memset(&dest, 0, sizeof(dest));

if( pParse->nErr || db->mallocFailed ){

goto insert_cleanup;

}

/* Locate the table into which we will be inserting new information.

*/

assert( pTabList->nSrc==1 );

zTab = pTabList->a[0].zName;

if( NEVER(zTab==0) ) goto insert_cleanup;

pTab = sqlite3SrcListLookup(pParse, pTabList);

if( pTab==0 ){

goto insert_cleanup;

}

iDb = sqlite3SchemaToIndex(db, pTab->pSchema);

assert( iDb<db->nDb );

pDb = &db->aDb[iDb];

zDb = pDb->zName;

if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){

goto insert_cleanup;

}

/* 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 (or virtual

** module table).

*/

if( sqlite3ViewGetColumnNames(pParse, pTab) ){

goto insert_cleanup;

}

/* Ensure that:

* (a) the table is not read-only,

* (b) that if it is a view then ON INSERT triggers exist

*/

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

/* 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. Generate a co-routine to run that

** SELECT. */

int rc = sqlite3CodeCoroutine(pParse, pSelect, &dest);

if( rc ) goto insert_cleanup;

regEof = dest.iSDParm + 1;

regFromSelect = dest.iSdst;

assert( pSelect->pEList );

nColumn = pSelect->pEList->nExpr;

assert( dest.nSdst==nColumn );

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

** if EOF goto M

** 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 addrTop; /* Label "L" */

int addrIf; /* Address of jump to M */

srcTab = pParse->nTab++;

regRec = sqlite3GetTempReg(pParse);

regTempRowid = sqlite3GetTempReg(pParse);

sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);

addrTop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);

addrIf = sqlite3VdbeAddOp1(v, OP_If, regEof);

sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);

sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);

sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);

sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);

sqlite3VdbeJumpHere(v, addrIf);

sqlite3ReleaseTempReg(pParse, regRec);

sqlite3ReleaseTempReg(pParse, regTempRowid);

}

}else{

/* This is the case if the data for the INSERT is coming from a VALUES

** clause

*/

NameContext sNC;

memset(&sNC, 0, sizeof(sNC));

sNC.pParse = pParse;

srcTab = -1;

assert( useTempTable==0 );

nColumn = pList ? pList->nExpr : 0;

for(i=0; i<nColumn; i++){

if( sqlite3ResolveExprNames(&sNC, pList->a[i].pExpr) ){

goto insert_cleanup;

}

}

}

/* Make sure the number of columns in the source data matches the number

** of columns to be inserted into the table.

*/

if( IsVirtual(pTab) ){

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

nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);

}

}

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;

}

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

** the index into IDLIST of the primary key column. keyColumn is

** the index of the primary key as it appears in IDLIST, not as

** is appears in the original table. (The index of the primary

** key in the original table is pTab->iPKey.)

*/

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( j==pTab->iPKey ){

keyColumn = i;

}

break;

}

}

if( j>=pTab->nCol ){

if( sqlite3IsRowid(pColumn->a[i].zName) ){

keyColumn = i;

}else{

sqlite3ErrorMsg(pParse, "table %S has no column named %s",

pTabList, 0, pColumn->a[i].zName);

pParse->checkSchema = 1;

goto insert_cleanup;

}

}

}

}

/* If there is no IDLIST term but the table has an integer primary

** key, the set the keyColumn variable to the primary key column index

** in the original table definition.

*/

if( pColumn==0 && nColumn>0 ){

keyColumn = pTab->iPKey;

}

/* Initialize the count of rows to be inserted

*/

if( db->flags & SQLITE_CountRows ){

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;

baseCur = pParse->nTab;

nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);

aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));

if( aRegIdx==0 ){

goto insert_cleanup;

}

for(i=0; i<nIdx; i++){

aRegIdx[i] = ++pParse->nMem;

}

}

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

** C: loop over rows of intermediate table

** transfer values form intermediate table into <table>

** end loop

** D: ...

*/

addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab);

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

** if EOF goto D

** insert the select result into <table> from R..R+n

** goto C

** D: ...

*/

addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);

addrInsTop = sqlite3VdbeAddOp1(v, OP_If, regEof);

}

/* Allocate registers for holding the rowid of the new row,

** the content of the new row, and the assemblied row record.

*/

regRowid = regIns = pParse->nMem+1;

pParse->nMem += pTab->nCol + 1;

if( IsVirtual(pTab) ){

regRowid++;

pParse->nMem++;

}

regData = regRowid+1;

/* Run the BEFORE and INSTEAD OF triggers, if there are any

*/

endOfLoop = sqlite3VdbeMakeLabel(v);

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( keyColumn<0 ){

sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);

}else{

int j1;

if( useTempTable ){

sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regCols);

}else{

assert( pSelect==0 ); /* Otherwise useTempTable is true */

sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);

}

j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols);

sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);

sqlite3VdbeJumpHere(v, j1);

sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols);

}

/* Cannot have triggers on a virtual table. If it were possible,

** this block would have to account for hidden column.

*/

assert( !IsVirtual(pTab) );

/* Create the new column data

*/

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

if( pColumn==0 ){

j = i;

}else{

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

if( pColumn->a[j].idx==i ) break;

}

}

if( (!useTempTable && !pList) || (pColumn && j>=pColumn->nId) ){

sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);

}else if( useTempTable ){

sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i+1);

}else{

assert( pSelect==0 ); /* Otherwise useTempTable is true */

sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);

}

}

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

sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);

sqlite3TableAffinityStr(v, pTab);

}

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

}

/* Push the record number for the new entry onto the stack. The

** record number is a randomly generate integer created by NewRowid

** except when the table has an INTEGER PRIMARY KEY column, in which

** case the record number is the same as that column.

*/

if( !isView ){

if( IsVirtual(pTab) ){

/* The row that the VUpdate opcode will delete: none */

sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);

}

if( keyColumn>=0 ){

if( useTempTable ){

sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);

}else if( pSelect ){

sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);

}else{

VdbeOp *pOp;

sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);

pOp = sqlite3VdbeGetOp(v, -1);

if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){

appendFlag = 1;

pOp->opcode = OP_NewRowid;

pOp->p1 = baseCur;

pOp->p2 = regRowid;

pOp->p3 = regAutoinc;

}

}

/* If the PRIMARY KEY expression is NULL, then use OP_NewRowid

** to generate a unique primary key value.

*/

if( !appendFlag ){

int j1;

if( !IsVirtual(pTab) ){

j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);

sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);

sqlite3VdbeJumpHere(v, j1);

}else{

j1 = sqlite3VdbeCurrentAddr(v);

sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2);

}

sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);

}

}else if( IsVirtual(pTab) ){

sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);

}else{

sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);

appendFlag = 1;

}

autoIncStep(pParse, regAutoinc, regRowid);

/* Push onto the stack, data for all columns of the new entry, beginning

** with the first column.

*/

nHidden = 0;

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

int iRegStore = regRowid+1+i;

if( i==pTab->iPKey ){

/* The value of the INTEGER PRIMARY KEY column is always a NULL.

** Whenever this column is read, the record number will be substituted

** in its place. So will fill this column with a NULL to avoid

** taking up data space with information that will never be used. */

sqlite3VdbeAddOp2(v, OP_Null, 0, iRegStore);

continue;

}

if( pColumn==0 ){

if( IsHiddenColumn(&pTab->aCol[i]) ){

assert( IsVirtual(pTab) );

j = -1;

nHidden++;

}else{

j = i - nHidden;

}