1 /*

     2 ** 2001 September 15

     3 **

     4 ** The author disclaims copyright to this source code.  In place of

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

     8 **    May you find forgiveness for yourself and forgive others.

     9 **    May you share freely, never taking more than you give.

    10 **

    11 *************************************************************************

    12 ** This file contains C code routines that are called by the parser

    13 ** to handle INSERT statements in SQLite.

    14 **

    15 ** $Id: insert.cpp 1282 2008-11-13 09:31:33Z LarsPson $

    16 */

    17 #include "sqliteInt.h"

    18 

    19 /*

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

    21 ** string for index pIdx. A column affinity string has one character

    22 ** for each column in the table, according to the affinity of the column:

    23 **

    24 **  Character      Column affinity

    25 **  ------------------------------

    26 **  'a'            TEXT

    27 **  'b'            NONE

    28 **  'c'            NUMERIC

    29 **  'd'            INTEGER

    30 **  'e'            REAL

    31 */

    32 void sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){

    33   if( !pIdx->zColAff ){

    34     /* The first time a column affinity string for a particular index is

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

    36     ** a member of the Index structure for subsequent use.

    37     **

    38     ** The column affinity string will eventually be deleted by

    39     ** sqliteDeleteIndex() when the Index structure itself is cleaned

    40     ** up.

    41     */

    42     int n;

    43     Table *pTab = pIdx->pTable;

    44     sqlite3 *db = sqlite3VdbeDb(v);

    45     pIdx->zColAff = (char *)sqlite3DbMallocZero(db, pIdx->nColumn+1);

    46     if( !pIdx->zColAff ){

    47       return;

    48     }

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

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

    51     }

    52     pIdx->zColAff[pIdx->nColumn] = '\0';

    53   }

    54  

    55   sqlite3VdbeChangeP3(v, -1, pIdx->zColAff, 0);

    56 }

    57 

    58 /*

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

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

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

    62 ** column:

    63 **

    64 **  Character      Column affinity

    65 **  ------------------------------

    66 **  'a'            TEXT

    67 **  'b'            NONE

    68 **  'c'            NUMERIC

    69 **  'd'            INTEGER

    70 **  'e'            REAL

    71 */

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

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

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

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

    76   **

    77   ** The column affinity string will eventually be deleted by

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

    79   */

    80   if( !pTab->zColAff ){

    81     char *zColAff;

    82     int i;

    83     sqlite3 *db = sqlite3VdbeDb(v);

    84 

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

    86     if( !zColAff ){

    87       return;

    88     }

    89 

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

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

    92     }

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

    94 

    95     pTab->zColAff = zColAff;

    96   }

    97 

    98   sqlite3VdbeChangeP3(v, -1, pTab->zColAff, 0);

    99 }

   100 

   101 /*

   102 ** Return non-zero if the table pTab in database iDb or any of its indices

   103 ** have been opened at any point in the VDBE program beginning at location

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

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

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

   107 */

   108 static int readsTable(Vdbe *v, int iStartAddr, int iDb, Table *pTab){

   109   int i;

   110   int iEnd = sqlite3VdbeCurrentAddr(v);

   111   for(i=iStartAddr; i<iEnd; i++){

   112     VdbeOp *pOp = sqlite3VdbeGetOp(v, i);

   113     assert( pOp!=0 );

   114     if( pOp->opcode==OP_OpenRead ){

   115       VdbeOp *pPrior = &pOp[-1];

   116       int tnum = pOp->p2;

   117       assert( i>iStartAddr );

   118       assert( pPrior->opcode==OP_Integer );

   119       if( pPrior->p1==iDb ){

   120         Index *pIndex;

   121         if( tnum==pTab->tnum ){

   122           return 1;

   123         }

   124         for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){

   125           if( tnum==pIndex->tnum ){

   126             return 1;

   127           }

   128         }

   129       }

   130     }

   131 #ifndef SQLITE_OMIT_VIRTUALTABLE

   132     if( pOp->opcode==OP_VOpen && pOp->p3==(const char*)pTab->pVtab ){

   133       assert( pOp->p3!=0 );

   134       assert( pOp->p3type==P3_VTAB );

   135       return 1;

   136     }

   137 #endif

   138   }

   139   return 0;

   140 }

   141 

   142 #ifndef SQLITE_OMIT_AUTOINCREMENT

   143 /*

   144 ** Write out code to initialize the autoincrement logic.  This code

   145 ** looks up the current autoincrement value in the sqlite_sequence

   146 ** table and stores that value in a memory cell.  Code generated by

   147 ** autoIncStep() will keep that memory cell holding the largest

   148 ** rowid value.  Code generated by autoIncEnd() will write the new

   149 ** largest value of the counter back into the sqlite_sequence table.

   150 **

   151 ** This routine returns the index of the mem[] cell that contains

   152 ** the maximum rowid counter.

   153 **

   154 ** Two memory cells are allocated.  The next memory cell after the

   155 ** one returned holds the rowid in sqlite_sequence where we will

   156 ** write back the revised maximum rowid.

   157 */

   158 static int autoIncBegin(

   159   Parse *pParse,      /* Parsing context */

   160   int iDb,            /* Index of the database holding pTab */

   161   Table *pTab         /* The table we are writing to */

   162 ){

   163   int memId = 0;

   164   if( pTab->autoInc ){

   165     Vdbe *v = pParse->pVdbe;

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

   167     int iCur = pParse->nTab;

   168     int addr;

   169     assert( v );

   170     addr = sqlite3VdbeCurrentAddr(v);

   171     memId = pParse->nMem+1;

   172     pParse->nMem += 2;

   173     sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenRead);

   174     sqlite3VdbeAddOp(v, OP_Rewind, iCur, addr+13);

   175     sqlite3VdbeAddOp(v, OP_Column, iCur, 0);

   176     sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0);

   177     sqlite3VdbeAddOp(v, OP_Ne, 0x100, addr+12);

   178     sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0);

   179     sqlite3VdbeAddOp(v, OP_MemStore, memId-1, 1);

   180     sqlite3VdbeAddOp(v, OP_Column, iCur, 1);

   181     sqlite3VdbeAddOp(v, OP_MemStore, memId, 1);

   182     sqlite3VdbeAddOp(v, OP_Goto, 0, addr+13);

   183     sqlite3VdbeAddOp(v, OP_Next, iCur, addr+4);

   184     sqlite3VdbeAddOp(v, OP_Close, iCur, 0);

   185   }

   186   return memId;

   187 }

   188 

   189 /*

   190 ** Update the maximum rowid for an autoincrement calculation.

   191 **

   192 ** This routine should be called when the top of the stack holds a

   193 ** new rowid that is about to be inserted.  If that new rowid is

   194 ** larger than the maximum rowid in the memId memory cell, then the

   195 ** memory cell is updated.  The stack is unchanged.

   196 */

   197 static void autoIncStep(Parse *pParse, int memId){

   198   if( memId>0 ){

   199     sqlite3VdbeAddOp(pParse->pVdbe, OP_MemMax, memId, 0);

   200   }

   201 }

   202 

   203 /*

   204 ** After doing one or more inserts, the maximum rowid is stored

   205 ** in mem[memId].  Generate code to write this value back into the

   206 ** the sqlite_sequence table.

   207 */

   208 static void autoIncEnd(

   209   Parse *pParse,     /* The parsing context */

   210   int iDb,           /* Index of the database holding pTab */

   211   Table *pTab,       /* Table we are inserting into */

   212   int memId          /* Memory cell holding the maximum rowid */

   213 ){

   214   if( pTab->autoInc ){

   215     int iCur = pParse->nTab;

   216     Vdbe *v = pParse->pVdbe;

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

   218     int addr;

   219     assert( v );

   220     addr = sqlite3VdbeCurrentAddr(v);

   221     sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);

   222     sqlite3VdbeAddOp(v, OP_MemLoad, memId-1, 0);

   223     sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+7);

   224     sqlite3VdbeAddOp(v, OP_Pop, 1, 0);

   225     sqlite3VdbeAddOp(v, OP_NewRowid, iCur, 0);

   226     sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0);

   227     sqlite3VdbeAddOp(v, OP_MemLoad, memId, 0);

   228     sqlite3VdbeAddOp(v, OP_MakeRecord, 2, 0);

   229     sqlite3VdbeAddOp(v, OP_Insert, iCur, OPFLAG_APPEND);

   230     sqlite3VdbeAddOp(v, OP_Close, iCur, 0);

   231   }

   232 }

   233 #else

   234 /*

   235 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines

   236 ** above are all no-ops

   237 */

   238 # define autoIncBegin(A,B,C) (0)

   239 # define autoIncStep(A,B)

   240 # define autoIncEnd(A,B,C,D)

   241 #endif /* SQLITE_OMIT_AUTOINCREMENT */

   242 

   243 

   244 /* Forward declaration */

   245 static int xferOptimization(

   246   Parse *pParse,        /* Parser context */

   247   Table *pDest,         /* The table we are inserting into */

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

   249   int onError,          /* How to handle constraint errors */

   250   int iDbDest           /* The database of pDest */

   251 );

   252 

   253 /*

   254 ** This routine is call to handle SQL of the following forms:

   255 **

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

   257 **    insert into TABLE (IDLIST) select

   258 **

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

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

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

   262 **

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

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

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

   266 ** data for the insert.

   267 **

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

   269 ** select with data coming from a VALUES clause, the code executes

   270 ** once straight down through.  The template looks like this:

   271 **

   272 **         open write cursor to <table> and its indices

   273 **         puts VALUES clause expressions onto the stack

   274 **         write the resulting record into <table>

   275 **         cleanup

   276 **

   277 ** The three remaining templates assume the statement is of the form

   278 **

   279 **   INSERT INTO <table> SELECT ...

   280 **

   281 ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -

   282 ** in other words if the SELECT pulls all columns from a single table

   283 ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and

   284 ** if <table2> and <table1> are distinct tables but have identical

   285 ** schemas, including all the same indices, then a special optimization

   286 ** is invoked that copies raw records from <table2> over to <table1>.

   287 ** See the xferOptimization() function for the implementation of this

   288 ** template.  This is the second template.

   289 **

   290 **         open a write cursor to <table>

   291 **         open read cursor on <table2>

   292 **         transfer all records in <table2> over to <table>

   293 **         close cursors

   294 **         foreach index on <table>

   295 **           open a write cursor on the <table> index

   296 **           open a read cursor on the corresponding <table2> index

   297 **           transfer all records from the read to the write cursors

   298 **           close cursors

   299 **         end foreach

   300 **

   301 ** The third template is for when the second template does not apply

   302 ** and the SELECT clause does not read from <table> at any time.

   303 ** The generated code follows this template:

   304 **

   305 **         goto B

   306 **      A: setup for the SELECT

   307 **         loop over the rows in the SELECT

   308 **           gosub C

   309 **         end loop

   310 **         cleanup after the SELECT

   311 **         goto D

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

   313 **         goto A

   314 **      C: insert the select result into <table>

   315 **         return

   316 **      D: cleanup

   317 **

   318 ** The fourth template is used if the insert statement takes its

   319 ** values from a SELECT but the data is being inserted into a table

   320 ** that is also read as part of the SELECT.  In the third form,

   321 ** we have to use a intermediate table to store the results of

   322 ** the select.  The template is like this:

   323 **

   324 **         goto B

   325 **      A: setup for the SELECT

   326 **         loop over the tables in the SELECT

   327 **           gosub C

   328 **         end loop

   329 **         cleanup after the SELECT

   330 **         goto D

   331 **      C: insert the select result into the intermediate table

   332 **         return

   333 **      B: open a cursor to an intermediate table

   334 **         goto A

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

   336 **         loop over the intermediate table

   337 **           transfer values form intermediate table into <table>

   338 **         end the loop

   339 **         cleanup

   340 */

   341 void sqlite3Insert(

   342   Parse *pParse,        /* Parser context */

   343   SrcList *pTabList,    /* Name of table into which we are inserting */

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

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

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

   347   int onError           /* How to handle constraint errors */

   348 ){

   349   Table *pTab;          /* The table to insert into */

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

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

   352   int i, j, idx;        /* Loop counters */

   353   Vdbe *v;              /* Generate code into this virtual machine */

   354   Index *pIdx;          /* For looping over indices of the table */

   355   int nColumn;          /* Number of columns in the data */

   356   int base = 0;         /* VDBE Cursor number for pTab */

   357   int iCont=0,iBreak=0; /* Beginning and end of the loop over srcTab */

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

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

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

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

   362   int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */

   363   int iSelectLoop = 0;  /* Address of code that implements the SELECT */

   364   int iCleanup = 0;     /* Address of the cleanup code */

   365   int iInsertBlock = 0; /* Address of the subroutine used to insert data */

   366   int iCntMem = 0;      /* Memory cell used for the row counter */

   367   int newIdx = -1;      /* Cursor for the NEW table */

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

   369   int counterMem = 0;   /* Memory cell holding AUTOINCREMENT counter */

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

   371   int iDb;

   372 

   373   int nHidden = 0;

   374 

   375 #ifndef SQLITE_OMIT_TRIGGER

   376   int isView;                 /* True if attempting to insert into a view */

   377   int triggers_exist = 0;     /* True if there are FOR EACH ROW triggers */

   378 #endif

   379 

   380   db = pParse->db;

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

   382     goto insert_cleanup;

   383   }

   384 

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

   386   */

   387   assert( pTabList->nSrc==1 );

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

   389   if( zTab==0 ) goto insert_cleanup;

   390   pTab = sqlite3SrcListLookup(pParse, pTabList);

   391   if( pTab==0 ){

   392     goto insert_cleanup;

   393   }

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

   395   assert( iDb<db->nDb );

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

   397   zDb = pDb->zName;

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

   399     goto insert_cleanup;

   400   }

   401 

   402   /* Figure out if we have any triggers and if the table being

   403   ** inserted into is a view

   404   */

   405 #ifndef SQLITE_OMIT_TRIGGER

   406   triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0);

   407   isView = pTab->pSelect!=0;

   408 #else

   409 # define triggers_exist 0

   410 # define isView 0

   411 #endif

   412 #ifdef SQLITE_OMIT_VIEW

   413 # undef isView

   414 # define isView 0

   415 #endif

   416 

   417   /* Ensure that:

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

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

   420   */

   421   if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){

   422     goto insert_cleanup;

   423   }

   424   assert( pTab!=0 );

   425 

   426   /* If pTab is really a view, make sure it has been initialized.

   427   ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual 

   428   ** module table).

   429   */

   430   if( sqlite3ViewGetColumnNames(pParse, pTab) ){

   431     goto insert_cleanup;

   432   }

   433 

   434   /* Allocate a VDBE

   435   */

   436   v = sqlite3GetVdbe(pParse);

   437   if( v==0 ) goto insert_cleanup;

   438   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);

   439   sqlite3BeginWriteOperation(pParse, pSelect || triggers_exist, iDb);

   440 

   441   /* if there are row triggers, allocate a temp table for new.* references. */

   442   if( triggers_exist ){

   443     newIdx = pParse->nTab++;

   444   }

   445 

   446 #ifndef SQLITE_OMIT_XFER_OPT

   447   /* If the statement is of the form

   448   **

   449   **       INSERT INTO <table1> SELECT * FROM <table2>;

   450   **

   451   ** Then special optimizations can be applied that make the transfer

   452   ** very fast and which reduce fragmentation of indices.

   453   */

   454   if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){

   455     assert( !triggers_exist );

   456     assert( pList==0 );

   457     goto insert_cleanup;

   458   }

   459 #endif /* SQLITE_OMIT_XFER_OPT */

   460 

   461   /* If this is an AUTOINCREMENT table, look up the sequence number in the

   462   ** sqlite_sequence table and store it in memory cell counterMem.  Also

   463   ** remember the rowid of the sqlite_sequence table entry in memory cell

   464   ** counterRowid.

   465   */

   466   counterMem = autoIncBegin(pParse, iDb, pTab);

   467 

   468   /* Figure out how many columns of data are supplied.  If the data

   469   ** is coming from a SELECT statement, then this step also generates

   470   ** all the code to implement the SELECT statement and invoke a subroutine

   471   ** to process each row of the result. (Template 2.) If the SELECT

   472   ** statement uses the the table that is being inserted into, then the

   473   ** subroutine is also coded here.  That subroutine stores the SELECT

   474   ** results in a temporary table. (Template 3.)

   475   */

   476   if( pSelect ){

   477     /* Data is coming from a SELECT.  Generate code to implement that SELECT

   478     */

   479     int rc, iInitCode;

   480     iInitCode = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);

   481     iSelectLoop = sqlite3VdbeCurrentAddr(v);

   482     iInsertBlock = sqlite3VdbeMakeLabel(v);

   483 

   484     /* Resolve the expressions in the SELECT statement and execute it. */

   485     rc = sqlite3Select(pParse, pSelect, SRT_Subroutine, iInsertBlock,0,0,0,0);

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

   487       goto insert_cleanup;

   488     }

   489 

   490     iCleanup = sqlite3VdbeMakeLabel(v);

   491     sqlite3VdbeAddOp(v, OP_Goto, 0, iCleanup);

   492     assert( pSelect->pEList );

   493     nColumn = pSelect->pEList->nExpr;

   494 

   495     /* Set useTempTable to TRUE if the result of the SELECT statement

   496     ** should be written into a temporary table.  Set to FALSE if each

   497     ** row of the SELECT can be written directly into the result table.

   498     **

   499     ** A temp table must be used if the table being updated is also one

   500     ** of the tables being read by the SELECT statement.  Also use a 

   501     ** temp table in the case of row triggers.

   502     */

   503     if( triggers_exist || readsTable(v, iSelectLoop, iDb, pTab) ){

   504       useTempTable = 1;

   505     }

   506 

   507     if( useTempTable ){

   508       /* Generate the subroutine that SELECT calls to process each row of

   509       ** the result.  Store the result in a temporary table

   510       */

   511       srcTab = pParse->nTab++;

   512       sqlite3VdbeResolveLabel(v, iInsertBlock);

   513       sqlite3VdbeAddOp(v, OP_StackDepth, -1, 0);

   514       sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);

   515       sqlite3VdbeAddOp(v, OP_NewRowid, srcTab, 0);

   516       sqlite3VdbeAddOp(v, OP_Pull, 1, 0);

   517       sqlite3VdbeAddOp(v, OP_Insert, srcTab, OPFLAG_APPEND);

   518       sqlite3VdbeAddOp(v, OP_Return, 0, 0);

   519 

   520       /* The following code runs first because the GOTO at the very top

   521       ** of the program jumps to it.  Create the temporary table, then jump

   522       ** back up and execute the SELECT code above.

   523       */

   524       sqlite3VdbeJumpHere(v, iInitCode);

   525       sqlite3VdbeAddOp(v, OP_OpenEphemeral, srcTab, 0);

   526       sqlite3VdbeAddOp(v, OP_SetNumColumns, srcTab, nColumn);

   527       sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop);

   528       sqlite3VdbeResolveLabel(v, iCleanup);

   529     }else{

   530       sqlite3VdbeJumpHere(v, iInitCode);

   531     }

   532   }else{

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

   534     ** clause

   535     */

   536     NameContext sNC;

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

   538     sNC.pParse = pParse;

   539     srcTab = -1;

   540     assert( useTempTable==0 );

   541     nColumn = pList ? pList->nExpr : 0;

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

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

   544         goto insert_cleanup;

   545       }

   546     }

   547   }

   548 

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

   550   ** of columns to be inserted into the table.

   551   */

   552   if( IsVirtual(pTab) ){

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

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

   555     }

   556   }

   557   if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){

   558     sqlite3ErrorMsg(pParse, 

   559        "table %S has %d columns but %d values were supplied",

   560        pTabList, 0, pTab->nCol, nColumn);

   561     goto insert_cleanup;

   562   }

   563   if( pColumn!=0 && nColumn!=pColumn->nId ){

   564     sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);

   565     goto insert_cleanup;

   566   }

   567 

   568   /* If the INSERT statement included an IDLIST term, then make sure

   569   ** all elements of the IDLIST really are columns of the table and 

   570   ** remember the column indices.

   571   **

   572   ** If the table has an INTEGER PRIMARY KEY column and that column

   573   ** is named in the IDLIST, then record in the keyColumn variable

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

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

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

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

   578   */

   579   if( pColumn ){

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

   581       pColumn->a[i].idx = -1;

   582     }

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

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

   585         if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){

   586           pColumn->a[i].idx = j;

   587           if( j==pTab->iPKey ){

   588             keyColumn = i;

   589           }

   590           break;

   591         }

   592       }

   593       if( j>=pTab->nCol ){

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

   595           keyColumn = i;

   596         }else{

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

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

   599           pParse->nErr++;

   600           goto insert_cleanup;

   601         }

   602       }

   603     }

   604   }

   605 

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

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

   608   ** in the original table definition.

   609   */

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

   611     keyColumn = pTab->iPKey;

   612   }

   613 

   614   /* Open the temp table for FOR EACH ROW triggers

   615   */

   616   if( triggers_exist ){

   617     sqlite3VdbeAddOp(v, OP_OpenPseudo, newIdx, 0);

   618     sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol);

   619   }

   620     

   621   /* Initialize the count of rows to be inserted

   622   */

   623   if( db->flags & SQLITE_CountRows ){

   624     iCntMem = pParse->nMem++;

   625     sqlite3VdbeAddOp(v, OP_MemInt, 0, iCntMem);

   626   }

   627 

   628   /* Open tables and indices if there are no row triggers */

   629   if( !triggers_exist ){

   630     base = pParse->nTab;

   631     sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite);

   632   }

   633 

   634   /* If the data source is a temporary table, then we have to create

   635   ** a loop because there might be multiple rows of data.  If the data

   636   ** source is a subroutine call from the SELECT statement, then we need

   637   ** to launch the SELECT statement processing.

   638   */

   639   if( useTempTable ){

   640     iBreak = sqlite3VdbeMakeLabel(v);

   641     sqlite3VdbeAddOp(v, OP_Rewind, srcTab, iBreak);

   642     iCont = sqlite3VdbeCurrentAddr(v);

   643   }else if( pSelect ){

   644     sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop);

   645     sqlite3VdbeResolveLabel(v, iInsertBlock);

   646     sqlite3VdbeAddOp(v, OP_StackDepth, -1, 0);

   647   }

   648 

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

   650   */

   651   endOfLoop = sqlite3VdbeMakeLabel(v);

   652   if( triggers_exist & TRIGGER_BEFORE ){

   653 

   654     /* build the NEW.* reference row.  Note that if there is an INTEGER

   655     ** PRIMARY KEY into which a NULL is being inserted, that NULL will be

   656     ** translated into a unique ID for the row.  But on a BEFORE trigger,

   657     ** we do not know what the unique ID will be (because the insert has

   658     ** not happened yet) so we substitute a rowid of -1

   659     */

   660     if( keyColumn<0 ){

   661       sqlite3VdbeAddOp(v, OP_Integer, -1, 0);

   662     }else if( useTempTable ){

   663       sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn);

   664     }else{

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

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

   667       sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3);

   668       sqlite3VdbeAddOp(v, OP_Pop, 1, 0);

   669       sqlite3VdbeAddOp(v, OP_Integer, -1, 0);

   670       sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);

   671     }

   672 

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

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

   675     */

   676     assert(!IsVirtual(pTab));

   677 

   678     /* Create the new column data

   679     */

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

   681       if( pColumn==0 ){

   682         j = i;

   683       }else{

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

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

   686         }

   687       }

   688       if( pColumn && j>=pColumn->nId ){

   689         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);

   690       }else if( useTempTable ){

   691         sqlite3VdbeAddOp(v, OP_Column, srcTab, j); 

   692       }else{

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

   694         sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr);

   695       }

   696     }

   697     sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);

   698 

   699     /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,

   700     ** do not attempt any conversions before assembling the record.

   701     ** If this is a real table, attempt conversions as required by the

   702     ** table column affinities.

   703     */

   704     if( !isView ){

   705       sqlite3TableAffinityStr(v, pTab);

   706     }

   707     sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0);

   708 

   709     /* Fire BEFORE or INSTEAD OF triggers */

   710     if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_BEFORE, pTab, 

   711         newIdx, -1, onError, endOfLoop) ){

   712       goto insert_cleanup;

   713     }

   714   }

   715 

   716   /* If any triggers exists, the opening of tables and indices is deferred

   717   ** until now.

   718   */

   719   if( triggers_exist && !isView ){

   720     base = pParse->nTab;

   721     sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite);

   722   }

   723 

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

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

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

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

   728   */

   729   if( !isView ){

   730     if( IsVirtual(pTab) ){

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

   732       sqlite3VdbeAddOp(v, OP_Null, 0, 0);

   733     }

   734     if( keyColumn>=0 ){

   735       if( useTempTable ){

   736         sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn);

   737       }else if( pSelect ){

   738         sqlite3VdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1);

   739       }else{

   740         VdbeOp *pOp;

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

   742         pOp = sqlite3VdbeGetOp(v, sqlite3VdbeCurrentAddr(v) - 1);

   743         if( pOp && pOp->opcode==OP_Null ){

   744           appendFlag = 1;

   745           pOp->opcode = OP_NewRowid;

   746           pOp->p1 = base;

   747           pOp->p2 = counterMem;

   748         }

   749       }

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

   751       ** to generate a unique primary key value.

   752       */

   753       if( !appendFlag ){

   754         sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3);

   755         sqlite3VdbeAddOp(v, OP_Pop, 1, 0);

   756         sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem);

   757         sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);

   758       }

   759     }else if( IsVirtual(pTab) ){

   760       sqlite3VdbeAddOp(v, OP_Null, 0, 0);

   761     }else{

   762       sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem);

   763       appendFlag = 1;

   764     }

   765     autoIncStep(pParse, counterMem);

   766 

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

   768     ** with the first column.

   769     */

   770     nHidden = 0;

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

   772       if( i==pTab->iPKey ){

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

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

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

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

   777         sqlite3VdbeAddOp(v, OP_Null, 0, 0);

   778         continue;

   779       }

   780       if( pColumn==0 ){

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

   782           assert( IsVirtual(pTab) );

   783           j = -1;

   784           nHidden++;

   785         }else{

   786           j = i - nHidden;

   787         }

   788       }else{

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

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

   791         }

   792       }

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

   794         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);

   795       }else if( useTempTable ){

   796         sqlite3VdbeAddOp(v, OP_Column, srcTab, j); 

   797       }else if( pSelect ){

   798         sqlite3VdbeAddOp(v, OP_Dup, i+nColumn-j+IsVirtual(pTab), 1);

   799       }else{

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

   801       }

   802     }

   803 

   804     /* Generate code to check constraints and generate index keys and

   805     ** do the insertion.

   806     */

   807 #ifndef SQLITE_OMIT_VIRTUALTABLE

   808     if( IsVirtual(pTab) ){

   809       pParse->pVirtualLock = pTab;

   810       sqlite3VdbeOp3(v, OP_VUpdate, 1, pTab->nCol+2,

   811                      (const char*)pTab->pVtab, P3_VTAB);

   812     }else

   813 #endif

   814     {

   815       sqlite3GenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0,

   816                                      0, onError, endOfLoop);

   817       sqlite3CompleteInsertion(pParse, pTab, base, 0,0,0,

   818                             (triggers_exist & TRIGGER_AFTER)!=0 ? newIdx : -1,

   819                             appendFlag);

   820     }

   821   }

   822 

   823   /* Update the count of rows that are inserted

   824   */

   825   if( (db->flags & SQLITE_CountRows)!=0 ){

   826     sqlite3VdbeAddOp(v, OP_MemIncr, 1, iCntMem);

   827   }

   828 

   829   if( triggers_exist ){

   830     /* Close all tables opened */

   831     if( !isView ){

   832       sqlite3VdbeAddOp(v, OP_Close, base, 0);

   833       for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){

   834         sqlite3VdbeAddOp(v, OP_Close, idx+base, 0);

   835       }

   836     }

   837 

   838     /* Code AFTER triggers */

   839     if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_AFTER, pTab,

   840           newIdx, -1, onError, endOfLoop) ){

   841       goto insert_cleanup;

   842     }

   843   }

   844 

   845   /* The bottom of the loop, if the data source is a SELECT statement

   846   */

   847   sqlite3VdbeResolveLabel(v, endOfLoop);

   848   if( useTempTable ){

   849     sqlite3VdbeAddOp(v, OP_Next, srcTab, iCont);

   850     sqlite3VdbeResolveLabel(v, iBreak);

   851     sqlite3VdbeAddOp(v, OP_Close, srcTab, 0);

   852   }else if( pSelect ){

   853     sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0);

   854     sqlite3VdbeAddOp(v, OP_Return, 0, 0);

   855     sqlite3VdbeResolveLabel(v, iCleanup);

   856   }

   857 

   858   if( !triggers_exist && !IsVirtual(pTab) ){

   859     /* Close all tables opened */

   860     sqlite3VdbeAddOp(v, OP_Close, base, 0);

   861     for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){

   862       sqlite3VdbeAddOp(v, OP_Close, idx+base, 0);

   863     }

   864   }

   865 

   866   /* Update the sqlite_sequence table by storing the content of the

   867   ** counter value in memory counterMem back into the sqlite_sequence

   868   ** table.

   869   */

   870   autoIncEnd(pParse, iDb, pTab, counterMem);

   871 

   872   /*

   873   ** Return the number of rows inserted. If this routine is 

   874   ** generating code because of a call to sqlite3NestedParse(), do not

   875   ** invoke the callback function.

   876   */

   877   if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){

   878     sqlite3VdbeAddOp(v, OP_MemLoad, iCntMem, 0);

   879     sqlite3VdbeAddOp(v, OP_Callback, 1, 0);

   880     sqlite3VdbeSetNumCols(v, 1);

   881     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", P3_STATIC);

   882   }

   883 

   884 insert_cleanup:

   885   sqlite3SrcListDelete(pTabList);

   886   sqlite3ExprListDelete(pList);

   887   sqlite3SelectDelete(pSelect);

   888   sqlite3IdListDelete(pColumn);

   889 }

   890 

   891 /*

   892 ** Generate code to do a constraint check prior to an INSERT or an UPDATE.

   893 **

   894 ** When this routine is called, the stack contains (from bottom to top)

   895 ** the following values:

   896 **

   897 **    1.  The rowid of the row to be updated before the update.  This

   898 **        value is omitted unless we are doing an UPDATE that involves a

   899 **        change to the record number.

   900 **

   901 **    2.  The rowid of the row after the update.

   902 **

   903 **    3.  The data in the first column of the entry after the update.

   904 **

   905 **    i.  Data from middle columns...

   906 **

   907 **    N.  The data in the last column of the entry after the update.

   908 **

   909 ** The old rowid shown as entry (1) above is omitted unless both isUpdate

   910 ** and rowidChng are 1.  isUpdate is true for UPDATEs and false for

   911 ** INSERTs and rowidChng is true if the record number is being changed.

   912 **

   913 ** The code generated by this routine pushes additional entries onto

   914 ** the stack which are the keys for new index entries for the new record.

   915 ** The order of index keys is the same as the order of the indices on

   916 ** the pTable->pIndex list.  A key is only created for index i if 

   917 ** aIdxUsed!=0 and aIdxUsed[i]!=0.

   918 **

   919 ** This routine also generates code to check constraints.  NOT NULL,

   920 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,

   921 ** then the appropriate action is performed.  There are five possible

   922 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.

   923 **

   924 **  Constraint type  Action       What Happens

   925 **  ---------------  ----------   ----------------------------------------

   926 **  any              ROLLBACK     The current transaction is rolled back and

   927 **                                sqlite3_exec() returns immediately with a

   928 **                                return code of SQLITE_CONSTRAINT.

   929 **

   930 **  any              ABORT        Back out changes from the current command

   931 **                                only (do not do a complete rollback) then

   932 **                                cause sqlite3_exec() to return immediately

   933 **                                with SQLITE_CONSTRAINT.

   934 **

   935 **  any              FAIL         Sqlite_exec() returns immediately with a

   936 **                                return code of SQLITE_CONSTRAINT.  The

   937 **                                transaction is not rolled back and any

   938 **                                prior changes are retained.

   939 **

   940 **  any              IGNORE       The record number and data is popped from

   941 **                                the stack and there is an immediate jump

   942 **                                to label ignoreDest.

   943 **

   944 **  NOT NULL         REPLACE      The NULL value is replace by the default

   945 **                                value for that column.  If the default value

   946 **                                is NULL, the action is the same as ABORT.

   947 **

   948 **  UNIQUE           REPLACE      The other row that conflicts with the row

   949 **                                being inserted is removed.

   950 **

   951 **  CHECK            REPLACE      Illegal.  The results in an exception.

   952 **

   953 ** Which action to take is determined by the overrideError parameter.

   954 ** Or if overrideError==OE_Default, then the pParse->onError parameter

   955 ** is used.  Or if pParse->onError==OE_Default then the onError value

   956 ** for the constraint is used.

   957 **

   958 ** The calling routine must open a read/write cursor for pTab with

   959 ** cursor number "base".  All indices of pTab must also have open

   960 ** read/write cursors with cursor number base+i for the i-th cursor.

   961 ** Except, if there is no possibility of a REPLACE action then

   962 ** cursors do not need to be open for indices where aIdxUsed[i]==0.

   963 **

   964 ** If the isUpdate flag is true, it means that the "base" cursor is

   965 ** initially pointing to an entry that is being updated.  The isUpdate

   966 ** flag causes extra code to be generated so that the "base" cursor

   967 ** is still pointing at the same entry after the routine returns.

   968 ** Without the isUpdate flag, the "base" cursor might be moved.

   969 */

   970 void sqlite3GenerateConstraintChecks(

   971   Parse *pParse,      /* The parser context */

   972   Table *pTab,        /* the table into which we are inserting */

   973   int base,           /* Index of a read/write cursor pointing at pTab */

   974   char *aIdxUsed,     /* Which indices are used.  NULL means all are used */

   975   int rowidChng,      /* True if the record number will change */

   976   int isUpdate,       /* True for UPDATE, False for INSERT */

   977   int overrideError,  /* Override onError to this if not OE_Default */

   978   int ignoreDest      /* Jump to this label on an OE_Ignore resolution */

   979 ){

   980   int i;

   981   Vdbe *v;

   982   int nCol;

   983   int onError;

   984   int addr;

   985   int extra;

   986   int iCur;

   987   Index *pIdx;

   988   int seenReplace = 0;

   989   int jumpInst1=0, jumpInst2;

   990   int hasTwoRowids = (isUpdate && rowidChng);

   991 

   992   v = sqlite3GetVdbe(pParse);

   993   assert( v!=0 );

   994   assert( pTab->pSelect==0 );  /* This table is not a VIEW */

   995   nCol = pTab->nCol;

   996 

   997   /* Test all NOT NULL constraints.

   998   */

   999   for(i=0; i<nCol; i++){

  1000     if( i==pTab->iPKey ){

  1001       continue;

  1002     }

  1003     onError = pTab->aCol[i].notNull;

  1004     if( onError==OE_None ) continue;

  1005     if( overrideError!=OE_Default ){

  1006       onError = overrideError;

  1007     }else if( onError==OE_Default ){

  1008       onError = OE_Abort;

  1009     }

  1010     if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){

  1011       onError = OE_Abort;

  1012     }

  1013     sqlite3VdbeAddOp(v, OP_Dup, nCol-1-i, 1);

  1014     addr = sqlite3VdbeAddOp(v, OP_NotNull, 1, 0);

  1015     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail

  1016         || onError==OE_Ignore || onError==OE_Replace );

  1017     switch( onError ){

  1018       case OE_Rollback:

  1019       case OE_Abort:

  1020       case OE_Fail: {

  1021         char *zMsg = 0;

  1022         sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);

  1023         sqlite3SetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName,

  1024                         " may not be NULL", (char*)0);

  1025         sqlite3VdbeChangeP3(v, -1, zMsg, P3_DYNAMIC);

  1026         break;

  1027       }

  1028       case OE_Ignore: {

  1029         sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0);

  1030         sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);

  1031         break;

  1032       }

  1033       case OE_Replace: {

  1034         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);

  1035         sqlite3VdbeAddOp(v, OP_Push, nCol-i, 0);

  1036         break;

  1037       }

  1038     }

  1039     sqlite3VdbeJumpHere(v, addr);

  1040   }

  1041 

  1042   /* Test all CHECK constraints

  1043   */

  1044 #ifndef SQLITE_OMIT_CHECK

  1045   if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){

  1046     int allOk = sqlite3VdbeMakeLabel(v);

  1047     assert( pParse->ckOffset==0 );

  1048     pParse->ckOffset = nCol;

  1049     sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, 1);

  1050     assert( pParse->ckOffset==nCol );

  1051     pParse->ckOffset = 0;

  1052     onError = overrideError!=OE_Default ? overrideError : OE_Abort;

  1053     if( onError==OE_Ignore ){

  1054       sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0);

  1055       sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);

  1056     }else{

  1057       sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);

  1058     }

  1059     sqlite3VdbeResolveLabel(v, allOk);

  1060   }

  1061 #endif /* !defined(SQLITE_OMIT_CHECK) */

  1062 

  1063   /* If we have an INTEGER PRIMARY KEY, make sure the primary key

  1064   ** of the new record does not previously exist.  Except, if this

  1065   ** is an UPDATE and the primary key is not changing, that is OK.

  1066   */

  1067   if( rowidChng ){

  1068     onError = pTab->keyConf;

  1069     if( overrideError!=OE_Default ){

  1070       onError = overrideError;

  1071     }else if( onError==OE_Default ){

  1072       onError = OE_Abort;

  1073     }

  1074     

  1075     if( isUpdate ){

  1076       sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);

  1077       sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);

  1078       jumpInst1 = sqlite3VdbeAddOp(v, OP_Eq, 0, 0);

  1079     }

  1080     sqlite3VdbeAddOp(v, OP_Dup, nCol, 1);

  1081     jumpInst2 = sqlite3VdbeAddOp(v, OP_NotExists, base, 0);

  1082     switch( onError ){

  1083       default: {

  1084         onError = OE_Abort;

  1085         /* Fall thru into the next case */

  1086       }

  1087       case OE_Rollback:

  1088       case OE_Abort:

  1089       case OE_Fail: {

  1090         sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError,

  1091                          "PRIMARY KEY must be unique", P3_STATIC);

  1092         break;

  1093       }

  1094       case OE_Replace: {

  1095         sqlite3GenerateRowIndexDelete(v, pTab, base, 0);

  1096         if( isUpdate ){

  1097           sqlite3VdbeAddOp(v, OP_Dup, nCol+hasTwoRowids, 1);

  1098           sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);

  1099         }

  1100         seenReplace = 1;

  1101         break;

  1102       }

  1103       case OE_Ignore: {

  1104         assert( seenReplace==0 );

  1105         sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0);

  1106         sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);

  1107         break;

  1108       }

  1109     }

  1110     sqlite3VdbeJumpHere(v, jumpInst2);

  1111     if( isUpdate ){

  1112       sqlite3VdbeJumpHere(v, jumpInst1);

  1113       sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);

  1114       sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);

  1115     }

  1116   }

  1117 

  1118   /* Test all UNIQUE constraints by creating entries for each UNIQUE

  1119   ** index and making sure that duplicate entries do not already exist.

  1120   ** Add the new records to the indices as we go.

  1121   */

  1122   extra = -1;

  1123   for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){

  1124     if( aIdxUsed && aIdxUsed[iCur]==0 ) continue;  /* Skip unused indices */

  1125     extra++;

  1126 

  1127     /* Create a key for accessing the index entry */

  1128     sqlite3VdbeAddOp(v, OP_Dup, nCol+extra, 1);

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

  1130       int idx = pIdx->aiColumn[i];

  1131       if( idx==pTab->iPKey ){

  1132         sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1);

  1133       }else{

  1134         sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1);