/*

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

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

if( x>=0 ){

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

}else if( x==XN_ROWID ){

pIdx->zColAff[n] = SQLITE_AFF_INTEGER;

}else{

char aff;

assert( x==XN_EXPR );

assert( pIdx->aColExpr!=0 );

aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);

if( aff==0 ) aff = SQLITE_AFF_BLOB;

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;

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=0; i<pTab->nCol; i++){

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

}

do{

zColAff[i--] = 0;

}while( i>=0 && zColAff[i]==SQLITE_AFF_BLOB );

pTab->zColAff = zColAff;

}

i = sqlite3Strlen30(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;

}

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

**

** 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)!=0

&& (pParse->db->flags & SQLITE_Vacuum)==0

){

Parse *pToplevel = sqlite3ParseToplevel(pParse);

AutoincInfo *pInfo;

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

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, 9, 0},

/* 2 */ {OP_Column, 0, 0, 0},

/* 3 */ {OP_Ne, 0, 7, 0},

/* 4 */ {OP_Rowid, 0, 0, 0},

/* 5 */ {OP_Column, 0, 1, 0},

/* 6 */ {OP_Goto, 0, 9, 0},

/* 7 */ {OP_Next, 0, 2, 0},

/* 8 */ {OP_Integer, 0, 0, 0},

/* 9 */ {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+1;

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[8].p2 = memId;

}

}

/*

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

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

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

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

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

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

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 registers for holding the rowid of the new row,

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

*/

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

*/

bIdListInOrder = (pTab->tabFlags & TF_OOOHidden)==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 );

}

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;

}

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

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;

}

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

nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,

&iDataCur, &iIdxCur);

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

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;

}

}

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

*/

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

VdbeCoverage(v);

}

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

/* Create the new column data

*/

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

if( pColumn ){

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

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

}

}

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

|| (pColumn==0 && IsOrdinaryHiddenColumn(&pTab->aCol[i])) ){

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( pColumn==0 && !IsOrdinaryHiddenColumn(&pTab->aCol[i]) ) j++;

}

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

}

/* Compute the content of the next row to insert into a range of

** registers beginning at regIns.

*/

if( !isView ){

if( IsVirtual(pTab) ){

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

sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);

}

if( ipkColumn>=0 ){

if( useTempTable ){

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

}else if( pSelect ){

sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);

}else{

VdbeOp *pOp;

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

pOp = sqlite3VdbeGetOp(v, -1);

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

appendFlag = 1;

pOp->opcode = OP_NewRowid;

pOp->p1 = iDataCur;

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

/* Compute 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 rowid will be substituted

** in its place. Hence, fill this column with a NULL to avoid

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

** As there may be shallow copies of this value, make it a soft-NULL */

sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);

continue;

}

if( pColumn==0 ){

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

j = -1;

nHidden++;

}else{

j = i - nHidden;

}

}else{

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

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

}

}

if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){

sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);

}else if( useTempTable ){

sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore);

}else if( pSelect ){

if( regFromSelect!=regData ){

sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);

}

}else{

sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);

}

}

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