| Index: third_party/sqlite/sqlite-src-3170000/src/insert.c
|
| diff --git a/third_party/sqlite/sqlite-src-3170000/src/insert.c b/third_party/sqlite/sqlite-src-3170000/src/insert.c
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..894bfc2cc17b3e81b5629e822460288e771729f7
|
| --- /dev/null
|
| +++ b/third_party/sqlite/sqlite-src-3170000/src/insert.c
|
| @@ -0,0 +1,2256 @@
|
| +/*
|
| +** 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;
|
| + memset(&dest, 0, sizeof(dest));
|
| + if( pParse->nErr || db->mallocFailed ){
|
| + goto insert_cleanup;
|
| + }
|
| +
|
| + /* 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 */
|
| + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
|
| + regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0
|
| + );
|
| + sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
|
| +
|
| + /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
|
| + ** constraints or (b) there are no triggers and this table is not a
|
| + ** parent table in a foreign key constraint. It is safe to set the
|
| + ** flag in the second case as if any REPLACE constraint is hit, an
|
| + ** OP_Delete or OP_IdxDelete instruction will be executed on each
|
| + ** cursor that is disturbed. And these instructions both clear the
|
| + ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
|
| + ** functionality. */
|
| + bUseSeek = (isReplace==0 || (pTrigger==0 &&
|
| + ((db->flags & SQLITE_ForeignKeys)==0 || sqlite3FkReferences(pTab)==0)
|
| + ));
|
| + sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
|
| + regIns, aRegIdx, 0, appendFlag, bUseSeek
|
| + );
|
| + }
|
| + }
|
| +
|
| + /* Update the count of rows that are inserted
|
| + */
|
| + if( (db->flags & SQLITE_CountRows)!=0 ){
|
| + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
|
| + }
|
| +
|
| + if( pTrigger ){
|
| + /* Code AFTER triggers */
|
| + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
|
| + pTab, regData-2-pTab->nCol, onError, endOfLoop);
|
| + }
|
| +
|
| + /* The bottom of the main insertion loop, if the data source
|
| + ** is a SELECT statement.
|
| + */
|
| + sqlite3VdbeResolveLabel(v, endOfLoop);
|
| + if( useTempTable ){
|
| + sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
|
| + sqlite3VdbeJumpHere(v, addrInsTop);
|
| + sqlite3VdbeAddOp1(v, OP_Close, srcTab);
|
| + }else if( pSelect ){
|
| + sqlite3VdbeGoto(v, addrCont);
|
| + sqlite3VdbeJumpHere(v, addrInsTop);
|
| + }
|
| +
|
| +insert_end:
|
| + /* Update the sqlite_sequence table by storing the content of the
|
| + ** maximum rowid counter values recorded while inserting into
|
| + ** autoincrement tables.
|
| + */
|
| + if( pParse->nested==0 && pParse->pTriggerTab==0 ){
|
| + sqlite3AutoincrementEnd(pParse);
|
| + }
|
| +
|
| + /*
|
| + ** Return the number of rows inserted. If this routine is
|
| + ** generating code because of a call to sqlite3NestedParse(), do not
|
| + ** invoke the callback function.
|
| + */
|
| + if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
|
| + sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
|
| + sqlite3VdbeSetNumCols(v, 1);
|
| + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
|
| + }
|
| +
|
| +insert_cleanup:
|
| + sqlite3SrcListDelete(db, pTabList);
|
| + sqlite3ExprListDelete(db, pList);
|
| + sqlite3SelectDelete(db, pSelect);
|
| + sqlite3IdListDelete(db, pColumn);
|
| + sqlite3DbFree(db, aRegIdx);
|
| +}
|
| +
|
| +/* Make sure "isView" and other macros defined above are undefined. Otherwise
|
| +** they may interfere with compilation of other functions in this file
|
| +** (or in another file, if this file becomes part of the amalgamation). */
|
| +#ifdef isView
|
| + #undef isView
|
| +#endif
|
| +#ifdef pTrigger
|
| + #undef pTrigger
|
| +#endif
|
| +#ifdef tmask
|
| + #undef tmask
|
| +#endif
|
| +
|
| +/*
|
| +** Meanings of bits in of pWalker->eCode for checkConstraintUnchanged()
|
| +*/
|
| +#define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */
|
| +#define CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */
|
| +
|
| +/* This is the Walker callback from checkConstraintUnchanged(). Set
|
| +** bit 0x01 of pWalker->eCode if
|
| +** pWalker->eCode to 0 if this expression node references any of the
|
| +** columns that are being modifed by an UPDATE statement.
|
| +*/
|
| +static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
|
| + if( pExpr->op==TK_COLUMN ){
|
| + assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
|
| + if( pExpr->iColumn>=0 ){
|
| + if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
|
| + pWalker->eCode |= CKCNSTRNT_COLUMN;
|
| + }
|
| + }else{
|
| + pWalker->eCode |= CKCNSTRNT_ROWID;
|
| + }
|
| + }
|
| + return WRC_Continue;
|
| +}
|
| +
|
| +/*
|
| +** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
|
| +** only columns that are modified by the UPDATE are those for which
|
| +** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
|
| +**
|
| +** Return true if CHECK constraint pExpr does not use any of the
|
| +** changing columns (or the rowid if it is changing). In other words,
|
| +** return true if this CHECK constraint can be skipped when validating
|
| +** the new row in the UPDATE statement.
|
| +*/
|
| +static int checkConstraintUnchanged(Expr *pExpr, int *aiChng, int chngRowid){
|
| + Walker w;
|
| + memset(&w, 0, sizeof(w));
|
| + w.eCode = 0;
|
| + w.xExprCallback = checkConstraintExprNode;
|
| + w.u.aiCol = aiChng;
|
| + sqlite3WalkExpr(&w, pExpr);
|
| + if( !chngRowid ){
|
| + testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
|
| + w.eCode &= ~CKCNSTRNT_ROWID;
|
| + }
|
| + testcase( w.eCode==0 );
|
| + testcase( w.eCode==CKCNSTRNT_COLUMN );
|
| + testcase( w.eCode==CKCNSTRNT_ROWID );
|
| + testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
|
| + return !w.eCode;
|
| +}
|
| +
|
| +/*
|
| +** Generate code to do constraint checks prior to an INSERT or an UPDATE
|
| +** on table pTab.
|
| +**
|
| +** The regNewData parameter is the first register in a range that contains
|
| +** the data to be inserted or the data after the update. There will be
|
| +** pTab->nCol+1 registers in this range. The first register (the one
|
| +** that regNewData points to) will contain the new rowid, or NULL in the
|
| +** case of a WITHOUT ROWID table. The second register in the range will
|
| +** contain the content of the first table column. The third register will
|
| +** contain the content of the second table column. And so forth.
|
| +**
|
| +** The regOldData parameter is similar to regNewData except that it contains
|
| +** the data prior to an UPDATE rather than afterwards. regOldData is zero
|
| +** for an INSERT. This routine can distinguish between UPDATE and INSERT by
|
| +** checking regOldData for zero.
|
| +**
|
| +** For an UPDATE, the pkChng boolean is true if the true primary key (the
|
| +** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
|
| +** might be modified by the UPDATE. If pkChng is false, then the key of
|
| +** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
|
| +**
|
| +** For an INSERT, the pkChng boolean indicates whether or not the rowid
|
| +** was explicitly specified as part of the INSERT statement. If pkChng
|
| +** is zero, it means that the either rowid is computed automatically or
|
| +** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT,
|
| +** pkChng will only be true if the INSERT statement provides an integer
|
| +** value for either the rowid column or its INTEGER PRIMARY KEY alias.
|
| +**
|
| +** The code generated by this routine will store new index entries into
|
| +** registers identified by aRegIdx[]. No index entry is created for
|
| +** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
|
| +** the same as the order of indices on the linked list of indices
|
| +** at pTab->pIndex.
|
| +**
|
| +** The caller must have already opened writeable cursors on the main
|
| +** table and all applicable indices (that is to say, all indices for which
|
| +** aRegIdx[] is not zero). iDataCur is the cursor for the main table when
|
| +** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
|
| +** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor
|
| +** for the first index in the pTab->pIndex list. Cursors for other indices
|
| +** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
|
| +**
|
| +** This routine also generates code to check constraints. NOT NULL,
|
| +** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
|
| +** then the appropriate action is performed. There are five possible
|
| +** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
|
| +**
|
| +** Constraint type Action What Happens
|
| +** --------------- ---------- ----------------------------------------
|
| +** any ROLLBACK The current transaction is rolled back and
|
| +** sqlite3_step() returns immediately with a
|
| +** return code of SQLITE_CONSTRAINT.
|
| +**
|
| +** any ABORT Back out changes from the current command
|
| +** only (do not do a complete rollback) then
|
| +** cause sqlite3_step() to return immediately
|
| +** with SQLITE_CONSTRAINT.
|
| +**
|
| +** any FAIL Sqlite3_step() returns immediately with a
|
| +** return code of SQLITE_CONSTRAINT. The
|
| +** transaction is not rolled back and any
|
| +** changes to prior rows are retained.
|
| +**
|
| +** any IGNORE The attempt in insert or update the current
|
| +** row is skipped, without throwing an error.
|
| +** Processing continues with the next row.
|
| +** (There is an immediate jump to ignoreDest.)
|
| +**
|
| +** NOT NULL REPLACE The NULL value is replace by the default
|
| +** value for that column. If the default value
|
| +** is NULL, the action is the same as ABORT.
|
| +**
|
| +** UNIQUE REPLACE The other row that conflicts with the row
|
| +** being inserted is removed.
|
| +**
|
| +** CHECK REPLACE Illegal. The results in an exception.
|
| +**
|
| +** Which action to take is determined by the overrideError parameter.
|
| +** Or if overrideError==OE_Default, then the pParse->onError parameter
|
| +** is used. Or if pParse->onError==OE_Default then the onError value
|
| +** for the constraint is used.
|
| +*/
|
| +void sqlite3GenerateConstraintChecks(
|
| + Parse *pParse, /* The parser context */
|
| + Table *pTab, /* The table being inserted or updated */
|
| + int *aRegIdx, /* Use register aRegIdx[i] for index i. 0 for unused */
|
| + int iDataCur, /* Canonical data cursor (main table or PK index) */
|
| + int iIdxCur, /* First index cursor */
|
| + int regNewData, /* First register in a range holding values to insert */
|
| + int regOldData, /* Previous content. 0 for INSERTs */
|
| + u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */
|
| + u8 overrideError, /* Override onError to this if not OE_Default */
|
| + int ignoreDest, /* Jump to this label on an OE_Ignore resolution */
|
| + int *pbMayReplace, /* OUT: Set to true if constraint may cause a replace */
|
| + int *aiChng /* column i is unchanged if aiChng[i]<0 */
|
| +){
|
| + Vdbe *v; /* VDBE under constrution */
|
| + Index *pIdx; /* Pointer to one of the indices */
|
| + Index *pPk = 0; /* The PRIMARY KEY index */
|
| + sqlite3 *db; /* Database connection */
|
| + int i; /* loop counter */
|
| + int ix; /* Index loop counter */
|
| + int nCol; /* Number of columns */
|
| + int onError; /* Conflict resolution strategy */
|
| + int addr1; /* Address of jump instruction */
|
| + int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
|
| + int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
|
| + int ipkTop = 0; /* Top of the rowid change constraint check */
|
| + int ipkBottom = 0; /* Bottom of the rowid change constraint check */
|
| + u8 isUpdate; /* True if this is an UPDATE operation */
|
| + u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */
|
| +
|
| + isUpdate = regOldData!=0;
|
| + db = pParse->db;
|
| + v = sqlite3GetVdbe(pParse);
|
| + assert( v!=0 );
|
| + assert( pTab->pSelect==0 ); /* This table is not a VIEW */
|
| + nCol = pTab->nCol;
|
| +
|
| + /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
|
| + ** normal rowid tables. nPkField is the number of key fields in the
|
| + ** pPk index or 1 for a rowid table. In other words, nPkField is the
|
| + ** number of fields in the true primary key of the table. */
|
| + if( HasRowid(pTab) ){
|
| + pPk = 0;
|
| + nPkField = 1;
|
| + }else{
|
| + pPk = sqlite3PrimaryKeyIndex(pTab);
|
| + nPkField = pPk->nKeyCol;
|
| + }
|
| +
|
| + /* Record that this module has started */
|
| + VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
|
| + iDataCur, iIdxCur, regNewData, regOldData, pkChng));
|
| +
|
| + /* Test all NOT NULL constraints.
|
| + */
|
| + for(i=0; i<nCol; i++){
|
| + if( i==pTab->iPKey ){
|
| + continue; /* ROWID is never NULL */
|
| + }
|
| + if( aiChng && aiChng[i]<0 ){
|
| + /* Don't bother checking for NOT NULL on columns that do not change */
|
| + continue;
|
| + }
|
| + onError = pTab->aCol[i].notNull;
|
| + if( onError==OE_None ) continue; /* This column is allowed to be NULL */
|
| + if( overrideError!=OE_Default ){
|
| + onError = overrideError;
|
| + }else if( onError==OE_Default ){
|
| + onError = OE_Abort;
|
| + }
|
| + if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
|
| + onError = OE_Abort;
|
| + }
|
| + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
|
| + || onError==OE_Ignore || onError==OE_Replace );
|
| + switch( onError ){
|
| + case OE_Abort:
|
| + sqlite3MayAbort(pParse);
|
| + /* Fall through */
|
| + case OE_Rollback:
|
| + case OE_Fail: {
|
| + char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
|
| + pTab->aCol[i].zName);
|
| + sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL, onError,
|
| + regNewData+1+i);
|
| + sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
|
| + sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
|
| + VdbeCoverage(v);
|
| + break;
|
| + }
|
| + case OE_Ignore: {
|
| + sqlite3VdbeAddOp2(v, OP_IsNull, regNewData+1+i, ignoreDest);
|
| + VdbeCoverage(v);
|
| + break;
|
| + }
|
| + default: {
|
| + assert( onError==OE_Replace );
|
| + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regNewData+1+i);
|
| + VdbeCoverage(v);
|
| + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regNewData+1+i);
|
| + sqlite3VdbeJumpHere(v, addr1);
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + /* Test all CHECK constraints
|
| + */
|
| +#ifndef SQLITE_OMIT_CHECK
|
| + if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
|
| + ExprList *pCheck = pTab->pCheck;
|
| + pParse->ckBase = regNewData+1;
|
| + onError = overrideError!=OE_Default ? overrideError : OE_Abort;
|
| + for(i=0; i<pCheck->nExpr; i++){
|
| + int allOk;
|
| + Expr *pExpr = pCheck->a[i].pExpr;
|
| + if( aiChng && checkConstraintUnchanged(pExpr, aiChng, pkChng) ) continue;
|
| + allOk = sqlite3VdbeMakeLabel(v);
|
| + sqlite3ExprIfTrue(pParse, pExpr, allOk, SQLITE_JUMPIFNULL);
|
| + if( onError==OE_Ignore ){
|
| + sqlite3VdbeGoto(v, ignoreDest);
|
| + }else{
|
| + char *zName = pCheck->a[i].zName;
|
| + if( zName==0 ) zName = pTab->zName;
|
| + if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-15569-63625 */
|
| + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
|
| + onError, zName, P4_TRANSIENT,
|
| + P5_ConstraintCheck);
|
| + }
|
| + sqlite3VdbeResolveLabel(v, allOk);
|
| + }
|
| + }
|
| +#endif /* !defined(SQLITE_OMIT_CHECK) */
|
| +
|
| + /* If rowid is changing, make sure the new rowid does not previously
|
| + ** exist in the table.
|
| + */
|
| + if( pkChng && pPk==0 ){
|
| + int addrRowidOk = sqlite3VdbeMakeLabel(v);
|
| +
|
| + /* Figure out what action to take in case of a rowid collision */
|
| + onError = pTab->keyConf;
|
| + if( overrideError!=OE_Default ){
|
| + onError = overrideError;
|
| + }else if( onError==OE_Default ){
|
| + onError = OE_Abort;
|
| + }
|
| +
|
| + if( isUpdate ){
|
| + /* pkChng!=0 does not mean that the rowid has changed, only that
|
| + ** it might have changed. Skip the conflict logic below if the rowid
|
| + ** is unchanged. */
|
| + sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
|
| + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
| + VdbeCoverage(v);
|
| + }
|
| +
|
| + /* If the response to a rowid conflict is REPLACE but the response
|
| + ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
|
| + ** to defer the running of the rowid conflict checking until after
|
| + ** the UNIQUE constraints have run.
|
| + */
|
| + if( onError==OE_Replace && overrideError!=OE_Replace ){
|
| + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
|
| + if( pIdx->onError==OE_Ignore || pIdx->onError==OE_Fail ){
|
| + ipkTop = sqlite3VdbeAddOp0(v, OP_Goto);
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + /* Check to see if the new rowid already exists in the table. Skip
|
| + ** the following conflict logic if it does not. */
|
| + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
|
| + VdbeCoverage(v);
|
| +
|
| + /* Generate code that deals with a rowid collision */
|
| + switch( onError ){
|
| + default: {
|
| + onError = OE_Abort;
|
| + /* Fall thru into the next case */
|
| + }
|
| + case OE_Rollback:
|
| + case OE_Abort:
|
| + case OE_Fail: {
|
| + sqlite3RowidConstraint(pParse, onError, pTab);
|
| + break;
|
| + }
|
| + case OE_Replace: {
|
| + /* If there are DELETE triggers on this table and the
|
| + ** recursive-triggers flag is set, call GenerateRowDelete() to
|
| + ** remove the conflicting row from the table. This will fire
|
| + ** the triggers and remove both the table and index b-tree entries.
|
| + **
|
| + ** Otherwise, if there are no triggers or the recursive-triggers
|
| + ** flag is not set, but the table has one or more indexes, call
|
| + ** GenerateRowIndexDelete(). This removes the index b-tree entries
|
| + ** only. The table b-tree entry will be replaced by the new entry
|
| + ** when it is inserted.
|
| + **
|
| + ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
|
| + ** also invoke MultiWrite() to indicate that this VDBE may require
|
| + ** statement rollback (if the statement is aborted after the delete
|
| + ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
|
| + ** but being more selective here allows statements like:
|
| + **
|
| + ** REPLACE INTO t(rowid) VALUES($newrowid)
|
| + **
|
| + ** to run without a statement journal if there are no indexes on the
|
| + ** table.
|
| + */
|
| + Trigger *pTrigger = 0;
|
| + if( db->flags&SQLITE_RecTriggers ){
|
| + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
|
| + }
|
| + if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
|
| + sqlite3MultiWrite(pParse);
|
| + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
|
| + regNewData, 1, 0, OE_Replace, 1, -1);
|
| + }else{
|
| +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
|
| + if( HasRowid(pTab) ){
|
| + /* This OP_Delete opcode fires the pre-update-hook only. It does
|
| + ** not modify the b-tree. It is more efficient to let the coming
|
| + ** OP_Insert replace the existing entry than it is to delete the
|
| + ** existing entry and then insert a new one. */
|
| + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
|
| + sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
|
| + }
|
| +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
|
| + if( pTab->pIndex ){
|
| + sqlite3MultiWrite(pParse);
|
| + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
|
| + }
|
| + }
|
| + seenReplace = 1;
|
| + break;
|
| + }
|
| + case OE_Ignore: {
|
| + /*assert( seenReplace==0 );*/
|
| + sqlite3VdbeGoto(v, ignoreDest);
|
| + break;
|
| + }
|
| + }
|
| + sqlite3VdbeResolveLabel(v, addrRowidOk);
|
| + if( ipkTop ){
|
| + ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
|
| + sqlite3VdbeJumpHere(v, ipkTop);
|
| + }
|
| + }
|
| +
|
| + /* Test all UNIQUE constraints by creating entries for each UNIQUE
|
| + ** index and making sure that duplicate entries do not already exist.
|
| + ** Compute the revised record entries for indices as we go.
|
| + **
|
| + ** This loop also handles the case of the PRIMARY KEY index for a
|
| + ** WITHOUT ROWID table.
|
| + */
|
| + for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){
|
| + int regIdx; /* Range of registers hold conent for pIdx */
|
| + int regR; /* Range of registers holding conflicting PK */
|
| + int iThisCur; /* Cursor for this UNIQUE index */
|
| + int addrUniqueOk; /* Jump here if the UNIQUE constraint is satisfied */
|
| +
|
| + if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */
|
| + if( bAffinityDone==0 ){
|
| + sqlite3TableAffinity(v, pTab, regNewData+1);
|
| + bAffinityDone = 1;
|
| + }
|
| + iThisCur = iIdxCur+ix;
|
| + addrUniqueOk = sqlite3VdbeMakeLabel(v);
|
| +
|
| + /* Skip partial indices for which the WHERE clause is not true */
|
| + if( pIdx->pPartIdxWhere ){
|
| + sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
|
| + pParse->ckBase = regNewData+1;
|
| + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
|
| + SQLITE_JUMPIFNULL);
|
| + pParse->ckBase = 0;
|
| + }
|
| +
|
| + /* Create a record for this index entry as it should appear after
|
| + ** the insert or update. Store that record in the aRegIdx[ix] register
|
| + */
|
| + regIdx = aRegIdx[ix]+1;
|
| + for(i=0; i<pIdx->nColumn; i++){
|
| + int iField = pIdx->aiColumn[i];
|
| + int x;
|
| + if( iField==XN_EXPR ){
|
| + pParse->ckBase = regNewData+1;
|
| + sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
|
| + pParse->ckBase = 0;
|
| + VdbeComment((v, "%s column %d", pIdx->zName, i));
|
| + }else{
|
| + if( iField==XN_ROWID || iField==pTab->iPKey ){
|
| + x = regNewData;
|
| + }else{
|
| + x = iField + regNewData + 1;
|
| + }
|
| + sqlite3VdbeAddOp2(v, iField<0 ? OP_IntCopy : OP_SCopy, x, regIdx+i);
|
| + VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
|
| + }
|
| + }
|
| + sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
|
| + VdbeComment((v, "for %s", pIdx->zName));
|
| +
|
| + /* In an UPDATE operation, if this index is the PRIMARY KEY index
|
| + ** of a WITHOUT ROWID table and there has been no change the
|
| + ** primary key, then no collision is possible. The collision detection
|
| + ** logic below can all be skipped. */
|
| + if( isUpdate && pPk==pIdx && pkChng==0 ){
|
| + sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
| + continue;
|
| + }
|
| +
|
| + /* Find out what action to take in case there is a uniqueness conflict */
|
| + onError = pIdx->onError;
|
| + if( onError==OE_None ){
|
| + sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
| + continue; /* pIdx is not a UNIQUE index */
|
| + }
|
| + if( overrideError!=OE_Default ){
|
| + onError = overrideError;
|
| + }else if( onError==OE_Default ){
|
| + onError = OE_Abort;
|
| + }
|
| +
|
| + /* Collision detection may be omitted if all of the following are true:
|
| + ** (1) The conflict resolution algorithm is REPLACE
|
| + ** (2) The table is a WITHOUT ROWID table
|
| + ** (3) There are no secondary indexes on the table
|
| + ** (4) No delete triggers need to be fired if there is a conflict
|
| + ** (5) No FK constraint counters need to be updated if a conflict occurs.
|
| + */
|
| + if( (ix==0 && pIdx->pNext==0) /* Condition 3 */
|
| + && pPk==pIdx /* Condition 2 */
|
| + && onError==OE_Replace /* Condition 1 */
|
| + && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */
|
| + 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
|
| + && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */
|
| + (0==pTab->pFKey && 0==sqlite3FkReferences(pTab)))
|
| + ){
|
| + sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
| + continue;
|
| + }
|
| +
|
| + /* Check to see if the new index entry will be unique */
|
| + sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
|
| + regIdx, pIdx->nKeyCol); VdbeCoverage(v);
|
| +
|
| + /* Generate code to handle collisions */
|
| + regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField);
|
| + if( isUpdate || onError==OE_Replace ){
|
| + if( HasRowid(pTab) ){
|
| + sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
|
| + /* Conflict only if the rowid of the existing index entry
|
| + ** is different from old-rowid */
|
| + if( isUpdate ){
|
| + sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
|
| + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
| + VdbeCoverage(v);
|
| + }
|
| + }else{
|
| + int x;
|
| + /* Extract the PRIMARY KEY from the end of the index entry and
|
| + ** store it in registers regR..regR+nPk-1 */
|
| + if( pIdx!=pPk ){
|
| + for(i=0; i<pPk->nKeyCol; i++){
|
| + assert( pPk->aiColumn[i]>=0 );
|
| + x = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[i]);
|
| + sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
|
| + VdbeComment((v, "%s.%s", pTab->zName,
|
| + pTab->aCol[pPk->aiColumn[i]].zName));
|
| + }
|
| + }
|
| + if( isUpdate ){
|
| + /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
|
| + ** table, only conflict if the new PRIMARY KEY values are actually
|
| + ** different from the old.
|
| + **
|
| + ** For a UNIQUE index, only conflict if the PRIMARY KEY values
|
| + ** of the matched index row are different from the original PRIMARY
|
| + ** KEY values of this row before the update. */
|
| + int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
|
| + int op = OP_Ne;
|
| + int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR);
|
| +
|
| + for(i=0; i<pPk->nKeyCol; i++){
|
| + char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
|
| + x = pPk->aiColumn[i];
|
| + assert( x>=0 );
|
| + if( i==(pPk->nKeyCol-1) ){
|
| + addrJump = addrUniqueOk;
|
| + op = OP_Eq;
|
| + }
|
| + sqlite3VdbeAddOp4(v, op,
|
| + regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ
|
| + );
|
| + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
|
| + VdbeCoverageIf(v, op==OP_Eq);
|
| + VdbeCoverageIf(v, op==OP_Ne);
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + /* Generate code that executes if the new index entry is not unique */
|
| + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
|
| + || onError==OE_Ignore || onError==OE_Replace );
|
| + switch( onError ){
|
| + case OE_Rollback:
|
| + case OE_Abort:
|
| + case OE_Fail: {
|
| + sqlite3UniqueConstraint(pParse, onError, pIdx);
|
| + break;
|
| + }
|
| + case OE_Ignore: {
|
| + sqlite3VdbeGoto(v, ignoreDest);
|
| + break;
|
| + }
|
| + default: {
|
| + Trigger *pTrigger = 0;
|
| + assert( onError==OE_Replace );
|
| + sqlite3MultiWrite(pParse);
|
| + if( db->flags&SQLITE_RecTriggers ){
|
| + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
|
| + }
|
| + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
|
| + regR, nPkField, 0, OE_Replace,
|
| + (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
|
| + seenReplace = 1;
|
| + break;
|
| + }
|
| + }
|
| + sqlite3VdbeResolveLabel(v, addrUniqueOk);
|
| + if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
|
| + }
|
| + if( ipkTop ){
|
| + sqlite3VdbeGoto(v, ipkTop+1);
|
| + sqlite3VdbeJumpHere(v, ipkBottom);
|
| + }
|
| +
|
| + *pbMayReplace = seenReplace;
|
| + VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
|
| +}
|
| +
|
| +#ifdef SQLITE_ENABLE_NULL_TRIM
|
| +/*
|
| +** Change the P5 operand on the last opcode (which should be an OP_MakeRecord)
|
| +** to be the number of columns in table pTab that must not be NULL-trimmed.
|
| +**
|
| +** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
|
| +*/
|
| +void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
|
| + u16 i;
|
| +
|
| + /* Records with omitted columns are only allowed for schema format
|
| + ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
|
| + if( pTab->pSchema->file_format<2 ) return;
|
| +
|
| + for(i=pTab->nCol; i>1 && pTab->aCol[i-1].pDflt==0; i--){}
|
| + sqlite3VdbeChangeP5(v, i);
|
| +}
|
| +#endif
|
| +
|
| +/*
|
| +** This routine generates code to finish the INSERT or UPDATE operation
|
| +** that was started by a prior call to sqlite3GenerateConstraintChecks.
|
| +** A consecutive range of registers starting at regNewData contains the
|
| +** rowid and the content to be inserted.
|
| +**
|
| +** The arguments to this routine should be the same as the first six
|
| +** arguments to sqlite3GenerateConstraintChecks.
|
| +*/
|
| +void sqlite3CompleteInsertion(
|
| + Parse *pParse, /* The parser context */
|
| + Table *pTab, /* the table into which we are inserting */
|
| + int iDataCur, /* Cursor of the canonical data source */
|
| + int iIdxCur, /* First index cursor */
|
| + int regNewData, /* Range of content */
|
| + int *aRegIdx, /* Register used by each index. 0 for unused indices */
|
| + int update_flags, /* True for UPDATE, False for INSERT */
|
| + int appendBias, /* True if this is likely to be an append */
|
| + int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
|
| +){
|
| + Vdbe *v; /* Prepared statements under construction */
|
| + Index *pIdx; /* An index being inserted or updated */
|
| + u8 pik_flags; /* flag values passed to the btree insert */
|
| + int regData; /* Content registers (after the rowid) */
|
| + int regRec; /* Register holding assembled record for the table */
|
| + int i; /* Loop counter */
|
| + u8 bAffinityDone = 0; /* True if OP_Affinity has been run already */
|
| +
|
| + assert( update_flags==0
|
| + || update_flags==OPFLAG_ISUPDATE
|
| + || update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION)
|
| + );
|
| +
|
| + v = sqlite3GetVdbe(pParse);
|
| + assert( v!=0 );
|
| + assert( pTab->pSelect==0 ); /* This table is not a VIEW */
|
| + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
|
| + if( aRegIdx[i]==0 ) continue;
|
| + bAffinityDone = 1;
|
| + if( pIdx->pPartIdxWhere ){
|
| + sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
|
| + VdbeCoverage(v);
|
| + }
|
| + pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0);
|
| + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
|
| + assert( pParse->nested==0 );
|
| + pik_flags |= OPFLAG_NCHANGE;
|
| + pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);
|
| +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
|
| + if( update_flags==0 ){
|
| + sqlite3VdbeAddOp4(v, OP_InsertInt,
|
| + iIdxCur+i, aRegIdx[i], 0, (char*)pTab, P4_TABLE
|
| + );
|
| + sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
|
| + }
|
| +#endif
|
| + }
|
| + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
|
| + aRegIdx[i]+1,
|
| + pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
|
| + sqlite3VdbeChangeP5(v, pik_flags);
|
| + }
|
| + if( !HasRowid(pTab) ) return;
|
| + regData = regNewData + 1;
|
| + regRec = sqlite3GetTempReg(pParse);
|
| + sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
|
| + sqlite3SetMakeRecordP5(v, pTab);
|
| + if( !bAffinityDone ){
|
| + sqlite3TableAffinity(v, pTab, 0);
|
| + sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
|
| + }
|
| + if( pParse->nested ){
|
| + pik_flags = 0;
|
| + }else{
|
| + pik_flags = OPFLAG_NCHANGE;
|
| + pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID);
|
| + }
|
| + if( appendBias ){
|
| + pik_flags |= OPFLAG_APPEND;
|
| + }
|
| + if( useSeekResult ){
|
| + pik_flags |= OPFLAG_USESEEKRESULT;
|
| + }
|
| + sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, regRec, regNewData);
|
| + if( !pParse->nested ){
|
| + sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
|
| + }
|
| + sqlite3VdbeChangeP5(v, pik_flags);
|
| +}
|
| +
|
| +/*
|
| +** Allocate cursors for the pTab table and all its indices and generate
|
| +** code to open and initialized those cursors.
|
| +**
|
| +** The cursor for the object that contains the complete data (normally
|
| +** the table itself, but the PRIMARY KEY index in the case of a WITHOUT
|
| +** ROWID table) is returned in *piDataCur. The first index cursor is
|
| +** returned in *piIdxCur. The number of indices is returned.
|
| +**
|
| +** Use iBase as the first cursor (either the *piDataCur for rowid tables
|
| +** or the first index for WITHOUT ROWID tables) if it is non-negative.
|
| +** If iBase is negative, then allocate the next available cursor.
|
| +**
|
| +** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
|
| +** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
|
| +** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the
|
| +** pTab->pIndex list.
|
| +**
|
| +** If pTab is a virtual table, then this routine is a no-op and the
|
| +** *piDataCur and *piIdxCur values are left uninitialized.
|
| +*/
|
| +int sqlite3OpenTableAndIndices(
|
| + Parse *pParse, /* Parsing context */
|
| + Table *pTab, /* Table to be opened */
|
| + int op, /* OP_OpenRead or OP_OpenWrite */
|
| + u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */
|
| + int iBase, /* Use this for the table cursor, if there is one */
|
| + u8 *aToOpen, /* If not NULL: boolean for each table and index */
|
| + int *piDataCur, /* Write the database source cursor number here */
|
| + int *piIdxCur /* Write the first index cursor number here */
|
| +){
|
| + int i;
|
| + int iDb;
|
| + int iDataCur;
|
| + Index *pIdx;
|
| + Vdbe *v;
|
| +
|
| + assert( op==OP_OpenRead || op==OP_OpenWrite );
|
| + assert( op==OP_OpenWrite || p5==0 );
|
| + if( IsVirtual(pTab) ){
|
| + /* This routine is a no-op for virtual tables. Leave the output
|
| + ** variables *piDataCur and *piIdxCur uninitialized so that valgrind
|
| + ** can detect if they are used by mistake in the caller. */
|
| + return 0;
|
| + }
|
| + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
|
| + v = sqlite3GetVdbe(pParse);
|
| + assert( v!=0 );
|
| + if( iBase<0 ) iBase = pParse->nTab;
|
| + iDataCur = iBase++;
|
| + if( piDataCur ) *piDataCur = iDataCur;
|
| + if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
|
| + sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
|
| + }else{
|
| + sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
|
| + }
|
| + if( piIdxCur ) *piIdxCur = iBase;
|
| + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
|
| + int iIdxCur = iBase++;
|
| + assert( pIdx->pSchema==pTab->pSchema );
|
| + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
|
| + if( piDataCur ) *piDataCur = iIdxCur;
|
| + p5 = 0;
|
| + }
|
| + if( aToOpen==0 || aToOpen[i+1] ){
|
| + sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
|
| + sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
|
| + sqlite3VdbeChangeP5(v, p5);
|
| + VdbeComment((v, "%s", pIdx->zName));
|
| + }
|
| + }
|
| + if( iBase>pParse->nTab ) pParse->nTab = iBase;
|
| + return i;
|
| +}
|
| +
|
| +
|
| +#ifdef SQLITE_TEST
|
| +/*
|
| +** The following global variable is incremented whenever the
|
| +** transfer optimization is used. This is used for testing
|
| +** purposes only - to make sure the transfer optimization really
|
| +** is happening when it is supposed to.
|
| +*/
|
| +int sqlite3_xferopt_count;
|
| +#endif /* SQLITE_TEST */
|
| +
|
| +
|
| +#ifndef SQLITE_OMIT_XFER_OPT
|
| +/*
|
| +** Check to see if index pSrc is compatible as a source of data
|
| +** for index pDest in an insert transfer optimization. The rules
|
| +** for a compatible index:
|
| +**
|
| +** * The index is over the same set of columns
|
| +** * The same DESC and ASC markings occurs on all columns
|
| +** * The same onError processing (OE_Abort, OE_Ignore, etc)
|
| +** * The same collating sequence on each column
|
| +** * The index has the exact same WHERE clause
|
| +*/
|
| +static int xferCompatibleIndex(Index *pDest, Index *pSrc){
|
| + int i;
|
| + assert( pDest && pSrc );
|
| + assert( pDest->pTable!=pSrc->pTable );
|
| + if( pDest->nKeyCol!=pSrc->nKeyCol ){
|
| + return 0; /* Different number of columns */
|
| + }
|
| + if( pDest->onError!=pSrc->onError ){
|
| + return 0; /* Different conflict resolution strategies */
|
| + }
|
| + for(i=0; i<pSrc->nKeyCol; i++){
|
| + if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
|
| + return 0; /* Different columns indexed */
|
| + }
|
| + if( pSrc->aiColumn[i]==XN_EXPR ){
|
| + assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
|
| + if( sqlite3ExprCompare(pSrc->aColExpr->a[i].pExpr,
|
| + pDest->aColExpr->a[i].pExpr, -1)!=0 ){
|
| + return 0; /* Different expressions in the index */
|
| + }
|
| + }
|
| + if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
|
| + return 0; /* Different sort orders */
|
| + }
|
| + if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){
|
| + return 0; /* Different collating sequences */
|
| + }
|
| + }
|
| + if( sqlite3ExprCompare(pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){
|
| + return 0; /* Different WHERE clauses */
|
| + }
|
| +
|
| + /* If no test above fails then the indices must be compatible */
|
| + return 1;
|
| +}
|
| +
|
| +/*
|
| +** Attempt the transfer optimization on INSERTs of the form
|
| +**
|
| +** INSERT INTO tab1 SELECT * FROM tab2;
|
| +**
|
| +** The xfer optimization transfers raw records from tab2 over to tab1.
|
| +** Columns are not decoded and reassembled, which greatly improves
|
| +** performance. Raw index records are transferred in the same way.
|
| +**
|
| +** The xfer optimization is only attempted if tab1 and tab2 are compatible.
|
| +** There are lots of rules for determining compatibility - see comments
|
| +** embedded in the code for details.
|
| +**
|
| +** This routine returns TRUE if the optimization is guaranteed to be used.
|
| +** Sometimes the xfer optimization will only work if the destination table
|
| +** is empty - a factor that can only be determined at run-time. In that
|
| +** case, this routine generates code for the xfer optimization but also
|
| +** does a test to see if the destination table is empty and jumps over the
|
| +** xfer optimization code if the test fails. In that case, this routine
|
| +** returns FALSE so that the caller will know to go ahead and generate
|
| +** an unoptimized transfer. This routine also returns FALSE if there
|
| +** is no chance that the xfer optimization can be applied.
|
| +**
|
| +** This optimization is particularly useful at making VACUUM run faster.
|
| +*/
|
| +static int xferOptimization(
|
| + Parse *pParse, /* Parser context */
|
| + Table *pDest, /* The table we are inserting into */
|
| + Select *pSelect, /* A SELECT statement to use as the data source */
|
| + int onError, /* How to handle constraint errors */
|
| + int iDbDest /* The database of pDest */
|
| +){
|
| + sqlite3 *db = pParse->db;
|
| + ExprList *pEList; /* The result set of the SELECT */
|
| + Table *pSrc; /* The table in the FROM clause of SELECT */
|
| + Index *pSrcIdx, *pDestIdx; /* Source and destination indices */
|
| + struct SrcList_item *pItem; /* An element of pSelect->pSrc */
|
| + int i; /* Loop counter */
|
| + int iDbSrc; /* The database of pSrc */
|
| + int iSrc, iDest; /* Cursors from source and destination */
|
| + int addr1, addr2; /* Loop addresses */
|
| + int emptyDestTest = 0; /* Address of test for empty pDest */
|
| + int emptySrcTest = 0; /* Address of test for empty pSrc */
|
| + Vdbe *v; /* The VDBE we are building */
|
| + int regAutoinc; /* Memory register used by AUTOINC */
|
| + int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */
|
| + int regData, regRowid; /* Registers holding data and rowid */
|
| +
|
| + if( pSelect==0 ){
|
| + return 0; /* Must be of the form INSERT INTO ... SELECT ... */
|
| + }
|
| + if( pParse->pWith || pSelect->pWith ){
|
| + /* Do not attempt to process this query if there are an WITH clauses
|
| + ** attached to it. Proceeding may generate a false "no such table: xxx"
|
| + ** error if pSelect reads from a CTE named "xxx". */
|
| + return 0;
|
| + }
|
| + if( sqlite3TriggerList(pParse, pDest) ){
|
| + return 0; /* tab1 must not have triggers */
|
| + }
|
| +#ifndef SQLITE_OMIT_VIRTUALTABLE
|
| + if( pDest->tabFlags & TF_Virtual ){
|
| + return 0; /* tab1 must not be a virtual table */
|
| + }
|
| +#endif
|
| + if( onError==OE_Default ){
|
| + if( pDest->iPKey>=0 ) onError = pDest->keyConf;
|
| + if( onError==OE_Default ) onError = OE_Abort;
|
| + }
|
| + assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
|
| + if( pSelect->pSrc->nSrc!=1 ){
|
| + return 0; /* FROM clause must have exactly one term */
|
| + }
|
| + if( pSelect->pSrc->a[0].pSelect ){
|
| + return 0; /* FROM clause cannot contain a subquery */
|
| + }
|
| + if( pSelect->pWhere ){
|
| + return 0; /* SELECT may not have a WHERE clause */
|
| + }
|
| + if( pSelect->pOrderBy ){
|
| + return 0; /* SELECT may not have an ORDER BY clause */
|
| + }
|
| + /* Do not need to test for a HAVING clause. If HAVING is present but
|
| + ** there is no ORDER BY, we will get an error. */
|
| + if( pSelect->pGroupBy ){
|
| + return 0; /* SELECT may not have a GROUP BY clause */
|
| + }
|
| + if( pSelect->pLimit ){
|
| + return 0; /* SELECT may not have a LIMIT clause */
|
| + }
|
| + assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */
|
| + if( pSelect->pPrior ){
|
| + return 0; /* SELECT may not be a compound query */
|
| + }
|
| + if( pSelect->selFlags & SF_Distinct ){
|
| + return 0; /* SELECT may not be DISTINCT */
|
| + }
|
| + pEList = pSelect->pEList;
|
| + assert( pEList!=0 );
|
| + if( pEList->nExpr!=1 ){
|
| + return 0; /* The result set must have exactly one column */
|
| + }
|
| + assert( pEList->a[0].pExpr );
|
| + if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
|
| + return 0; /* The result set must be the special operator "*" */
|
| + }
|
| +
|
| + /* At this point we have established that the statement is of the
|
| + ** correct syntactic form to participate in this optimization. Now
|
| + ** we have to check the semantics.
|
| + */
|
| + pItem = pSelect->pSrc->a;
|
| + pSrc = sqlite3LocateTableItem(pParse, 0, pItem);
|
| + if( pSrc==0 ){
|
| + return 0; /* FROM clause does not contain a real table */
|
| + }
|
| + if( pSrc==pDest ){
|
| + return 0; /* tab1 and tab2 may not be the same table */
|
| + }
|
| + if( HasRowid(pDest)!=HasRowid(pSrc) ){
|
| + return 0; /* source and destination must both be WITHOUT ROWID or not */
|
| + }
|
| +#ifndef SQLITE_OMIT_VIRTUALTABLE
|
| + if( pSrc->tabFlags & TF_Virtual ){
|
| + return 0; /* tab2 must not be a virtual table */
|
| + }
|
| +#endif
|
| + if( pSrc->pSelect ){
|
| + return 0; /* tab2 may not be a view */
|
| + }
|
| + if( pDest->nCol!=pSrc->nCol ){
|
| + return 0; /* Number of columns must be the same in tab1 and tab2 */
|
| + }
|
| + if( pDest->iPKey!=pSrc->iPKey ){
|
| + return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
|
| + }
|
| + for(i=0; i<pDest->nCol; i++){
|
| + Column *pDestCol = &pDest->aCol[i];
|
| + Column *pSrcCol = &pSrc->aCol[i];
|
| +#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
|
| + if( (db->flags & SQLITE_Vacuum)==0
|
| + && (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN
|
| + ){
|
| + return 0; /* Neither table may have __hidden__ columns */
|
| + }
|
| +#endif
|
| + if( pDestCol->affinity!=pSrcCol->affinity ){
|
| + return 0; /* Affinity must be the same on all columns */
|
| + }
|
| + if( sqlite3_stricmp(pDestCol->zColl, pSrcCol->zColl)!=0 ){
|
| + return 0; /* Collating sequence must be the same on all columns */
|
| + }
|
| + if( pDestCol->notNull && !pSrcCol->notNull ){
|
| + return 0; /* tab2 must be NOT NULL if tab1 is */
|
| + }
|
| + /* Default values for second and subsequent columns need to match. */
|
| + if( i>0 ){
|
| + assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN );
|
| + assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN );
|
| + if( (pDestCol->pDflt==0)!=(pSrcCol->pDflt==0)
|
| + || (pDestCol->pDflt && strcmp(pDestCol->pDflt->u.zToken,
|
| + pSrcCol->pDflt->u.zToken)!=0)
|
| + ){
|
| + return 0; /* Default values must be the same for all columns */
|
| + }
|
| + }
|
| + }
|
| + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
|
| + if( IsUniqueIndex(pDestIdx) ){
|
| + destHasUniqueIdx = 1;
|
| + }
|
| + for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
|
| + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
|
| + }
|
| + if( pSrcIdx==0 ){
|
| + return 0; /* pDestIdx has no corresponding index in pSrc */
|
| + }
|
| + }
|
| +#ifndef SQLITE_OMIT_CHECK
|
| + if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){
|
| + return 0; /* Tables have different CHECK constraints. Ticket #2252 */
|
| + }
|
| +#endif
|
| +#ifndef SQLITE_OMIT_FOREIGN_KEY
|
| + /* Disallow the transfer optimization if the destination table constains
|
| + ** any foreign key constraints. This is more restrictive than necessary.
|
| + ** But the main beneficiary of the transfer optimization is the VACUUM
|
| + ** command, and the VACUUM command disables foreign key constraints. So
|
| + ** the extra complication to make this rule less restrictive is probably
|
| + ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
|
| + */
|
| + if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
|
| + return 0;
|
| + }
|
| +#endif
|
| + if( (db->flags & SQLITE_CountRows)!=0 ){
|
| + return 0; /* xfer opt does not play well with PRAGMA count_changes */
|
| + }
|
| +
|
| + /* If we get this far, it means that the xfer optimization is at
|
| + ** least a possibility, though it might only work if the destination
|
| + ** table (tab1) is initially empty.
|
| + */
|
| +#ifdef SQLITE_TEST
|
| + sqlite3_xferopt_count++;
|
| +#endif
|
| + iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
|
| + v = sqlite3GetVdbe(pParse);
|
| + sqlite3CodeVerifySchema(pParse, iDbSrc);
|
| + iSrc = pParse->nTab++;
|
| + iDest = pParse->nTab++;
|
| + regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
|
| + regData = sqlite3GetTempReg(pParse);
|
| + regRowid = sqlite3GetTempReg(pParse);
|
| + sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
|
| + assert( HasRowid(pDest) || destHasUniqueIdx );
|
| + if( (db->flags & SQLITE_Vacuum)==0 && (
|
| + (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */
|
| + || destHasUniqueIdx /* (2) */
|
| + || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */
|
| + )){
|
| + /* In some circumstances, we are able to run the xfer optimization
|
| + ** only if the destination table is initially empty. Unless the
|
| + ** SQLITE_Vacuum flag is set, this block generates code to make
|
| + ** that determination. If SQLITE_Vacuum is set, then the destination
|
| + ** table is always empty.
|
| + **
|
| + ** Conditions under which the destination must be empty:
|
| + **
|
| + ** (1) There is no INTEGER PRIMARY KEY but there are indices.
|
| + ** (If the destination is not initially empty, the rowid fields
|
| + ** of index entries might need to change.)
|
| + **
|
| + ** (2) The destination has a unique index. (The xfer optimization
|
| + ** is unable to test uniqueness.)
|
| + **
|
| + ** (3) onError is something other than OE_Abort and OE_Rollback.
|
| + */
|
| + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
|
| + emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto);
|
| + sqlite3VdbeJumpHere(v, addr1);
|
| + }
|
| + if( HasRowid(pSrc) ){
|
| + u8 insFlags;
|
| + sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
|
| + emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
|
| + if( pDest->iPKey>=0 ){
|
| + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
|
| + addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
|
| + VdbeCoverage(v);
|
| + sqlite3RowidConstraint(pParse, onError, pDest);
|
| + sqlite3VdbeJumpHere(v, addr2);
|
| + autoIncStep(pParse, regAutoinc, regRowid);
|
| + }else if( pDest->pIndex==0 ){
|
| + addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
|
| + }else{
|
| + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
|
| + assert( (pDest->tabFlags & TF_Autoincrement)==0 );
|
| + }
|
| + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
|
| + if( db->flags & SQLITE_Vacuum ){
|
| + sqlite3VdbeAddOp3(v, OP_Last, iDest, 0, -1);
|
| + insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|
|
| + OPFLAG_APPEND|OPFLAG_USESEEKRESULT;
|
| + }else{
|
| + insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND;
|
| + }
|
| + sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid,
|
| + (char*)pDest, P4_TABLE);
|
| + sqlite3VdbeChangeP5(v, insFlags);
|
| + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
|
| + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
|
| + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
|
| + }else{
|
| + sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
|
| + sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
|
| + }
|
| + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
|
| + u8 idxInsFlags = 0;
|
| + for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
|
| + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
|
| + }
|
| + assert( pSrcIdx );
|
| + sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
|
| + sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
|
| + VdbeComment((v, "%s", pSrcIdx->zName));
|
| + sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
|
| + sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
|
| + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
|
| + VdbeComment((v, "%s", pDestIdx->zName));
|
| + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
|
| + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
|
| + if( db->flags & SQLITE_Vacuum ){
|
| + /* This INSERT command is part of a VACUUM operation, which guarantees
|
| + ** that the destination table is empty. If all indexed columns use
|
| + ** collation sequence BINARY, then it can also be assumed that the
|
| + ** index will be populated by inserting keys in strictly sorted
|
| + ** order. In this case, instead of seeking within the b-tree as part
|
| + ** of every OP_IdxInsert opcode, an OP_Last is added before the
|
| + ** OP_IdxInsert to seek to the point within the b-tree where each key
|
| + ** should be inserted. This is faster.
|
| + **
|
| + ** If any of the indexed columns use a collation sequence other than
|
| + ** BINARY, this optimization is disabled. This is because the user
|
| + ** might change the definition of a collation sequence and then run
|
| + ** a VACUUM command. In that case keys may not be written in strictly
|
| + ** sorted order. */
|
| + for(i=0; i<pSrcIdx->nColumn; i++){
|
| + const char *zColl = pSrcIdx->azColl[i];
|
| + assert( sqlite3_stricmp(sqlite3StrBINARY, zColl)!=0
|
| + || sqlite3StrBINARY==zColl );
|
| + if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
|
| + }
|
| + if( i==pSrcIdx->nColumn ){
|
| + idxInsFlags = OPFLAG_USESEEKRESULT;
|
| + sqlite3VdbeAddOp3(v, OP_Last, iDest, 0, -1);
|
| + }
|
| + }
|
| + if( !HasRowid(pSrc) && pDestIdx->idxType==2 ){
|
| + idxInsFlags |= OPFLAG_NCHANGE;
|
| + }
|
| + sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
|
| + sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
|
| + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
|
| + sqlite3VdbeJumpHere(v, addr1);
|
| + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
|
| + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
|
| + }
|
| + if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
|
| + sqlite3ReleaseTempReg(pParse, regRowid);
|
| + sqlite3ReleaseTempReg(pParse, regData);
|
| + if( emptyDestTest ){
|
| + sqlite3AutoincrementEnd(pParse);
|
| + sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
|
| + sqlite3VdbeJumpHere(v, emptyDestTest);
|
| + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
|
| + return 0;
|
| + }else{
|
| + return 1;
|
| + }
|
| +}
|
| +#endif /* SQLITE_OMIT_XFER_OPT */
|
|
|
Chromium Code Reviews
Issue 2747283002:
[sql] Import reference version of SQLite 3.17.. (Closed)
