sqlite3/insert.c

   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$
  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 **  'n'            NUMERIC
  27 **  'i'            INTEGER
  28 **  't'            TEXT
  29 **  'o'            NONE
  30 */
  31 void sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
  32   if( !pIdx->zColAff ){
  33     /* The first time a column affinity string for a particular index is
  34     ** required, it is allocated and populated here. It is then stored as
  35     ** a member of the Index structure for subsequent use.
  36     **
  37     ** The column affinity string will eventually be deleted by
  38     ** sqliteDeleteIndex() when the Index structure itself is cleaned
  39     ** up.
  40     */
  41     int n;
  42     Table *pTab = pIdx->pTable;
  43     pIdx->zColAff = (char *)sqliteMalloc(pIdx->nColumn+1);
  44     if( !pIdx->zColAff ){
  45       return;
  46     }
  47     for(n=0; n<pIdx->nColumn; n++){
  48       pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
  49     }
  50     pIdx->zColAff[pIdx->nColumn] = '\0';
  51   }
  52
  53   sqlite3VdbeChangeP3(v, -1, pIdx->zColAff, 0);
  54 }
  55
  56 /*
  57 ** Set P3 of the most recently inserted opcode to a column affinity
  58 ** string for table pTab. A column affinity string has one character
  59 ** for each column indexed by the index, according to the affinity of the
  60 ** column:
  61 **
  62 **  Character      Column affinity
  63 **  ------------------------------
  64 **  'n'            NUMERIC
  65 **  'i'            INTEGER
  66 **  't'            TEXT
  67 **  'o'            NONE
  68 */
  69 void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
  70   /* The first time a column affinity string for a particular table
  71   ** is required, it is allocated and populated here. It is then
  72   ** stored as a member of the Table structure for subsequent use.
  73   **
  74   ** The column affinity string will eventually be deleted by
  75   ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
  76   */
  77   if( !pTab->zColAff ){
  78     char *zColAff;
  79     int i;
  80
  81     zColAff = (char *)sqliteMalloc(pTab->nCol+1);
  82     if( !zColAff ){
  83       return;
  84     }
  85
  86     for(i=0; i<pTab->nCol; i++){
  87       zColAff[i] = pTab->aCol[i].affinity;
  88     }
  89     zColAff[pTab->nCol] = '\0';
  90
  91     pTab->zColAff = zColAff;
  92   }
  93
  94   sqlite3VdbeChangeP3(v, -1, pTab->zColAff, 0);
  95 }
  96
  97 /*
  98 ** Return non-zero if SELECT statement p opens the table with rootpage
  99 ** iTab in database iDb.  This is used to see if a statement of the form
 100 ** "INSERT INTO <iDb, iTab> SELECT ..." can run without using temporary
 101 ** table for the results of the SELECT.
 102 **
 103 ** No checking is done for sub-selects that are part of expressions.
 104 */
 105 static int selectReadsTable(Select *p, int iDb, int iTab){
 106   int i;
 107   struct SrcList_item *pItem;
 108   if( p->pSrc==0 ) return 0;
 109   for(i=0, pItem=p->pSrc->a; i<p->pSrc->nSrc; i++, pItem++){
 110     if( pItem->pSelect ){
 111       if( selectReadsTable(pItem->pSelect, iDb, iTab) ) return 1;
 112     }else{
 113       if( pItem->pTab->iDb==iDb && pItem->pTab->tnum==iTab ) return 1;
 114     }
 115   }
 116   return 0;
 117 }
 118
 119 /*
 120 ** This routine is call to handle SQL of the following forms:
 121 **
 122 **    insert into TABLE (IDLIST) values(EXPRLIST)
 123 **    insert into TABLE (IDLIST) select
 124 **
 125 ** The IDLIST following the table name is always optional.  If omitted,
 126 ** then a list of all columns for the table is substituted.  The IDLIST
 127 ** appears in the pColumn parameter.  pColumn is NULL if IDLIST is omitted.
 128 **
 129 ** The pList parameter holds EXPRLIST in the first form of the INSERT
 130 ** statement above, and pSelect is NULL.  For the second form, pList is
 131 ** NULL and pSelect is a pointer to the select statement used to generate
 132 ** data for the insert.
 133 **
 134 ** The code generated follows one of three templates.  For a simple
 135 ** select with data coming from a VALUES clause, the code executes
 136 ** once straight down through.  The template looks like this:
 137 **
 138 **         open write cursor to <table> and its indices
 139 **         puts VALUES clause expressions onto the stack
 140 **         write the resulting record into <table>
 141 **         cleanup
 142 **
 143 ** If the statement is of the form
 144 **
 145 **   INSERT INTO <table> SELECT ...
 146 **
 147 ** And the SELECT clause does not read from <table> at any time, then
 148 ** the generated code follows this template:
 149 **
 150 **         goto B
 151 **      A: setup for the SELECT
 152 **         loop over the tables in the SELECT
 153 **           gosub C
 154 **         end loop
 155 **         cleanup after the SELECT
 156 **         goto D
 157 **      B: open write cursor to <table> and its indices
 158 **         goto A
 159 **      C: insert the select result into <table>
 160 **         return
 161 **      D: cleanup
 162 **
 163 ** The third template is used if the insert statement takes its
 164 ** values from a SELECT but the data is being inserted into a table
 165 ** that is also read as part of the SELECT.  In the third form,
 166 ** we have to use a intermediate table to store the results of
 167 ** the select.  The template is like this:
 168 **
 169 **         goto B
 170 **      A: setup for the SELECT
 171 **         loop over the tables in the SELECT
 172 **           gosub C
 173 **         end loop
 174 **         cleanup after the SELECT
 175 **         goto D
 176 **      C: insert the select result into the intermediate table
 177 **         return
 178 **      B: open a cursor to an intermediate table
 179 **         goto A
 180 **      D: open write cursor to <table> and its indices
 181 **         loop over the intermediate table
 182 **           transfer values form intermediate table into <table>
 183 **         end the loop
 184 **         cleanup
 185 */
 186 void sqlite3Insert(
 187   Parse *pParse,        /* Parser context */
 188   SrcList *pTabList,    /* Name of table into which we are inserting */
 189   ExprList *pList,      /* List of values to be inserted */
 190   Select *pSelect,      /* A SELECT statement to use as the data source */
 191   IdList *pColumn,      /* Column names corresponding to IDLIST. */
 192   int onError           /* How to handle constraint errors */
 193 ){
 194   Table *pTab;          /* The table to insert into */
 195   char *zTab;           /* Name of the table into which we are inserting */
 196   const char *zDb;      /* Name of the database holding this table */
 197   int i, j, idx;        /* Loop counters */
 198   Vdbe *v;              /* Generate code into this virtual machine */
 199   Index *pIdx;          /* For looping over indices of the table */
 200   int nColumn;          /* Number of columns in the data */
 201   int base = 0;         /* VDBE Cursor number for pTab */
 202   int iCont=0,iBreak=0; /* Beginning and end of the loop over srcTab */
 203   sqlite3 *db;          /* The main database structure */
 204   int keyColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
 205   int endOfLoop;        /* Label for the end of the insertion loop */
 206   int useTempTable = 0; /* Store SELECT results in intermediate table */
 207   int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */
 208   int iSelectLoop = 0;  /* Address of code that implements the SELECT */
 209   int iCleanup = 0;     /* Address of the cleanup code */
 210   int iInsertBlock = 0; /* Address of the subroutine used to insert data */
 211   int iCntMem = 0;      /* Memory cell used for the row counter */
 212   int newIdx = -1;      /* Cursor for the NEW table */
 213   Db *pDb;              /* The database containing table being inserted into */
 214   int counterMem = 0;   /* Memory cell holding AUTOINCREMENT counter */
 215
 216 #ifndef SQLITE_OMIT_TRIGGER
 217   int isView;                 /* True if attempting to insert into a view */
 218   int triggers_exist = 0;     /* True if there are FOR EACH ROW triggers */
 219 #endif
 220
 221 #ifndef SQLITE_OMIT_AUTOINCREMENT
 222   int counterRowid;     /* Memory cell holding rowid of autoinc counter */
 223 #endif
 224
 225   if( pParse->nErr || sqlite3_malloc_failed ) goto insert_cleanup;
 226   db = pParse->db;
 227
 228   /* Locate the table into which we will be inserting new information.
 229   */
 230   assert( pTabList->nSrc==1 );
 231   zTab = pTabList->a[0].zName;
 232   if( zTab==0 ) goto insert_cleanup;
 233   pTab = sqlite3SrcListLookup(pParse, pTabList);
 234   if( pTab==0 ){
 235     goto insert_cleanup;
 236   }
 237   assert( pTab->iDb<db->nDb );
 238   pDb = &db->aDb[pTab->iDb];
 239   zDb = pDb->zName;
 240   if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
 241     goto insert_cleanup;
 242   }
 243
 244   /* Figure out if we have any triggers and if the table being
 245   ** inserted into is a view
 246   */
 247 #ifndef SQLITE_OMIT_TRIGGER
 248   triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0);
 249   isView = pTab->pSelect!=0;
 250 #else
 251 # define triggers_exist 0
 252 # define isView 0
 253 #endif
 254 #ifdef SQLITE_OMIT_VIEW
 255 # undef isView
 256 # define isView 0
 257 #endif
 258
 259   /* Ensure that:
 260   *  (a) the table is not read-only,
 261   *  (b) that if it is a view then ON INSERT triggers exist
 262   */
 263   if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){
 264     goto insert_cleanup;
 265   }
 266   if( pTab==0 ) goto insert_cleanup;
 267
 268   /* If pTab is really a view, make sure it has been initialized.
 269   */
 270   if( isView && sqlite3ViewGetColumnNames(pParse, pTab) ){
 271     goto insert_cleanup;
 272   }
 273
 274   /* Ensure all required collation sequences are available. */
 275   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
 276     if( sqlite3CheckIndexCollSeq(pParse, pIdx) ){
 277       goto insert_cleanup;
 278     }
 279   }
 280
 281   /* Allocate a VDBE
 282   */
 283   v = sqlite3GetVdbe(pParse);
 284   if( v==0 ) goto insert_cleanup;
 285   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
 286   sqlite3BeginWriteOperation(pParse, pSelect || triggers_exist, pTab->iDb);
 287
 288   /* if there are row triggers, allocate a temp table for new.* references. */
 289   if( triggers_exist ){
 290     newIdx = pParse->nTab++;
 291   }
 292
 293 #ifndef SQLITE_OMIT_AUTOINCREMENT
 294   /* If this is an AUTOINCREMENT table, look up the sequence number in the
 295   ** sqlite_sequence table and store it in memory cell counterMem.  Also
 296   ** remember the rowid of the sqlite_sequence table entry in memory cell
 297   ** counterRowid.
 298   */
 299   if( pTab->autoInc ){
 300     int iCur = pParse->nTab;
 301     int base = sqlite3VdbeCurrentAddr(v);
 302     counterRowid = pParse->nMem++;
 303     counterMem = pParse->nMem++;
 304     sqlite3VdbeAddOp(v, OP_Integer, pTab->iDb, 0);
 305     sqlite3VdbeAddOp(v, OP_OpenRead, iCur, pDb->pSeqTab->tnum);
 306     sqlite3VdbeAddOp(v, OP_SetNumColumns, iCur, 2);
 307     sqlite3VdbeAddOp(v, OP_Rewind, iCur, base+13);
 308     sqlite3VdbeAddOp(v, OP_Column, iCur, 0);
 309     sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0);
 310     sqlite3VdbeAddOp(v, OP_Ne, 28417, base+12);
 311     sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0);
 312     sqlite3VdbeAddOp(v, OP_MemStore, counterRowid, 1);
 313     sqlite3VdbeAddOp(v, OP_Column, iCur, 1);
 314     sqlite3VdbeAddOp(v, OP_MemStore, counterMem, 1);
 315     sqlite3VdbeAddOp(v, OP_Goto, 0, base+13);
 316     sqlite3VdbeAddOp(v, OP_Next, iCur, base+4);
 317     sqlite3VdbeAddOp(v, OP_Close, iCur, 0);
 318   }
 319 #endif /* SQLITE_OMIT_AUTOINCREMENT */
 320
 321   /* Figure out how many columns of data are supplied.  If the data
 322   ** is coming from a SELECT statement, then this step also generates
 323   ** all the code to implement the SELECT statement and invoke a subroutine
 324   ** to process each row of the result. (Template 2.) If the SELECT
 325   ** statement uses the the table that is being inserted into, then the
 326   ** subroutine is also coded here.  That subroutine stores the SELECT
 327   ** results in a temporary table. (Template 3.)
 328   */
 329   if( pSelect ){
 330     /* Data is coming from a SELECT.  Generate code to implement that SELECT
 331     */
 332     int rc, iInitCode;
 333     iInitCode = sqlite3VdbeAddOp(v, OP_Goto, 0, 0);
 334     iSelectLoop = sqlite3VdbeCurrentAddr(v);
 335     iInsertBlock = sqlite3VdbeMakeLabel(v);
 336
 337     /* Resolve the expressions in the SELECT statement and execute it. */
 338     rc = sqlite3Select(pParse, pSelect, SRT_Subroutine, iInsertBlock,0,0,0,0);
 339     if( rc || pParse->nErr || sqlite3_malloc_failed ) goto insert_cleanup;
 340
 341     iCleanup = sqlite3VdbeMakeLabel(v);
 342     sqlite3VdbeAddOp(v, OP_Goto, 0, iCleanup);
 343     assert( pSelect->pEList );
 344     nColumn = pSelect->pEList->nExpr;
 345
 346     /* Set useTempTable to TRUE if the result of the SELECT statement
 347     ** should be written into a temporary table.  Set to FALSE if each
 348     ** row of the SELECT can be written directly into the result table.
 349     **
 350     ** A temp table must be used if the table being updated is also one
 351     ** of the tables being read by the SELECT statement.  Also use a
 352     ** temp table in the case of row triggers.
 353     */
 354     if( triggers_exist || selectReadsTable(pSelect, pTab->iDb, pTab->tnum) ){
 355       useTempTable = 1;
 356     }
 357
 358     if( useTempTable ){
 359       /* Generate the subroutine that SELECT calls to process each row of
 360       ** the result.  Store the result in a temporary table
 361       */
 362       srcTab = pParse->nTab++;
 363       sqlite3VdbeResolveLabel(v, iInsertBlock);
 364       sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0);
 365       sqlite3TableAffinityStr(v, pTab);
 366       sqlite3VdbeAddOp(v, OP_NewRowid, srcTab, 0);
 367       sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
 368       sqlite3VdbeAddOp(v, OP_Insert, srcTab, 0);
 369       sqlite3VdbeAddOp(v, OP_Return, 0, 0);
 370
 371       /* The following code runs first because the GOTO at the very top
 372       ** of the program jumps to it.  Create the temporary table, then jump
 373       ** back up and execute the SELECT code above.
 374       */
 375       sqlite3VdbeChangeP2(v, iInitCode, sqlite3VdbeCurrentAddr(v));
 376       sqlite3VdbeAddOp(v, OP_OpenTemp, srcTab, 0);
 377       sqlite3VdbeAddOp(v, OP_SetNumColumns, srcTab, nColumn);
 378       sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop);
 379       sqlite3VdbeResolveLabel(v, iCleanup);
 380     }else{
 381       sqlite3VdbeChangeP2(v, iInitCode, sqlite3VdbeCurrentAddr(v));
 382     }
 383   }else{
 384     /* This is the case if the data for the INSERT is coming from a VALUES
 385     ** clause
 386     */
 387     NameContext sNC;
 388     memset(&sNC, 0, sizeof(sNC));
 389     sNC.pParse = pParse;
 390     assert( pList!=0 );
 391     srcTab = -1;
 392     useTempTable = 0;
 393     assert( pList );
 394     nColumn = pList->nExpr;
 395     for(i=0; i<nColumn; i++){
 396       if( sqlite3ExprResolveNames(&sNC, pList->a[i].pExpr) ){
 397         goto insert_cleanup;
 398       }
 399     }
 400   }
 401
 402   /* Make sure the number of columns in the source data matches the number
 403   ** of columns to be inserted into the table.
 404   */
 405   if( pColumn==0 && nColumn!=pTab->nCol ){
 406     sqlite3ErrorMsg(pParse,
 407        "table %S has %d columns but %d values were supplied",
 408        pTabList, 0, pTab->nCol, nColumn);
 409     goto insert_cleanup;
 410   }
 411   if( pColumn!=0 && nColumn!=pColumn->nId ){
 412     sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
 413     goto insert_cleanup;
 414   }
 415
 416   /* If the INSERT statement included an IDLIST term, then make sure
 417   ** all elements of the IDLIST really are columns of the table and
 418   ** remember the column indices.
 419   **
 420   ** If the table has an INTEGER PRIMARY KEY column and that column
 421   ** is named in the IDLIST, then record in the keyColumn variable
 422   ** the index into IDLIST of the primary key column.  keyColumn is
 423   ** the index of the primary key as it appears in IDLIST, not as
 424   ** is appears in the original table.  (The index of the primary
 425   ** key in the original table is pTab->iPKey.)
 426   */
 427   if( pColumn ){
 428     for(i=0; i<pColumn->nId; i++){
 429       pColumn->a[i].idx = -1;
 430     }
 431     for(i=0; i<pColumn->nId; i++){
 432       for(j=0; j<pTab->nCol; j++){
 433         if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
 434           pColumn->a[i].idx = j;
 435           if( j==pTab->iPKey ){
 436             keyColumn = i;
 437           }
 438           break;
 439         }
 440       }
 441       if( j>=pTab->nCol ){
 442         if( sqlite3IsRowid(pColumn->a[i].zName) ){
 443           keyColumn = i;
 444         }else{
 445           sqlite3ErrorMsg(pParse, "table %S has no column named %s",
 446               pTabList, 0, pColumn->a[i].zName);
 447           pParse->nErr++;
 448           goto insert_cleanup;
 449         }
 450       }
 451     }
 452   }
 453
 454   /* If there is no IDLIST term but the table has an integer primary
 455   ** key, the set the keyColumn variable to the primary key column index
 456   ** in the original table definition.
 457   */
 458   if( pColumn==0 ){
 459     keyColumn = pTab->iPKey;
 460   }
 461
 462   /* Open the temp table for FOR EACH ROW triggers
 463   */
 464   if( triggers_exist ){
 465     sqlite3VdbeAddOp(v, OP_OpenPseudo, newIdx, 0);
 466     sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol);
 467   }
 468
 469   /* Initialize the count of rows to be inserted
 470   */
 471   if( db->flags & SQLITE_CountRows ){
 472     iCntMem = pParse->nMem++;
 473     sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
 474     sqlite3VdbeAddOp(v, OP_MemStore, iCntMem, 1);
 475   }
 476
 477   /* Open tables and indices if there are no row triggers */
 478   if( !triggers_exist ){
 479     base = pParse->nTab;
 480     sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite);
 481   }
 482
 483   /* If the data source is a temporary table, then we have to create
 484   ** a loop because there might be multiple rows of data.  If the data
 485   ** source is a subroutine call from the SELECT statement, then we need
 486   ** to launch the SELECT statement processing.
 487   */
 488   if( useTempTable ){
 489     iBreak = sqlite3VdbeMakeLabel(v);
 490     sqlite3VdbeAddOp(v, OP_Rewind, srcTab, iBreak);
 491     iCont = sqlite3VdbeCurrentAddr(v);
 492   }else if( pSelect ){
 493     sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop);
 494     sqlite3VdbeResolveLabel(v, iInsertBlock);
 495   }
 496
 497   /* Run the BEFORE and INSTEAD OF triggers, if there are any
 498   */
 499   endOfLoop = sqlite3VdbeMakeLabel(v);
 500   if( triggers_exist & TRIGGER_BEFORE ){
 501
 502     /* build the NEW.* reference row.  Note that if there is an INTEGER
 503     ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
 504     ** translated into a unique ID for the row.  But on a BEFORE trigger,
 505     ** we do not know what the unique ID will be (because the insert has
 506     ** not happened yet) so we substitute a rowid of -1
 507     */
 508     if( keyColumn<0 ){
 509       sqlite3VdbeAddOp(v, OP_Integer, -1, 0);
 510     }else if( useTempTable ){
 511       sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn);
 512     }else{
 513       assert( pSelect==0 );  /* Otherwise useTempTable is true */
 514       sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr);
 515       sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3);
 516       sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
 517       sqlite3VdbeAddOp(v, OP_Integer, -1, 0);
 518       sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
 519     }
 520
 521     /* Create the new column data
 522     */
 523     for(i=0; i<pTab->nCol; i++){
 524       if( pColumn==0 ){
 525         j = i;
 526       }else{
 527         for(j=0; j<pColumn->nId; j++){
 528           if( pColumn->a[j].idx==i ) break;
 529         }
 530       }
 531       if( pColumn && j>=pColumn->nId ){
 532         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);
 533       }else if( useTempTable ){
 534         sqlite3VdbeAddOp(v, OP_Column, srcTab, j);
 535       }else{
 536         assert( pSelect==0 ); /* Otherwise useTempTable is true */
 537         sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr);
 538       }
 539     }
 540     sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
 541
 542     /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
 543     ** do not attempt any conversions before assembling the record.
 544     ** If this is a real table, attempt conversions as required by the
 545     ** table column affinities.
 546     */
 547     if( !isView ){
 548       sqlite3TableAffinityStr(v, pTab);
 549     }
 550     sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0);
 551
 552     /* Fire BEFORE or INSTEAD OF triggers */
 553     if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_BEFORE, pTab,
 554         newIdx, -1, onError, endOfLoop) ){
 555       goto insert_cleanup;
 556     }
 557   }
 558
 559   /* If any triggers exists, the opening of tables and indices is deferred
 560   ** until now.
 561   */
 562   if( triggers_exist && !isView ){
 563     base = pParse->nTab;
 564     sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite);
 565   }
 566
 567   /* Push the record number for the new entry onto the stack.  The
 568   ** record number is a randomly generate integer created by NewRowid
 569   ** except when the table has an INTEGER PRIMARY KEY column, in which
 570   ** case the record number is the same as that column.
 571   */
 572   if( !isView ){
 573     if( keyColumn>=0 ){
 574       if( useTempTable ){
 575         sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn);
 576       }else if( pSelect ){
 577         sqlite3VdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1);
 578       }else{
 579         sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr);
 580       }
 581       /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
 582       ** to generate a unique primary key value.
 583       */
 584       sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3);
 585       sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
 586       sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem);
 587       sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);
 588     }else{
 589       sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem);
 590     }
 591 #ifndef SQLITE_OMIT_AUTOINCREMENT
 592     if( pTab->autoInc ){
 593       sqlite3VdbeAddOp(v, OP_MemMax, counterMem, 0);
 594     }
 595 #endif /* SQLITE_OMIT_AUTOINCREMENT */
 596
 597     /* Push onto the stack, data for all columns of the new entry, beginning
 598     ** with the first column.
 599     */
 600     for(i=0; i<pTab->nCol; i++){
 601       if( i==pTab->iPKey ){
 602         /* The value of the INTEGER PRIMARY KEY column is always a NULL.
 603         ** Whenever this column is read, the record number will be substituted
 604         ** in its place.  So will fill this column with a NULL to avoid
 605         ** taking up data space with information that will never be used. */
 606         sqlite3VdbeAddOp(v, OP_Null, 0, 0);
 607         continue;
 608       }
 609       if( pColumn==0 ){
 610         j = i;
 611       }else{
 612         for(j=0; j<pColumn->nId; j++){
 613           if( pColumn->a[j].idx==i ) break;
 614         }
 615       }
 616       if( pColumn && j>=pColumn->nId ){
 617         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);
 618       }else if( useTempTable ){
 619         sqlite3VdbeAddOp(v, OP_Column, srcTab, j);
 620       }else if( pSelect ){
 621         sqlite3VdbeAddOp(v, OP_Dup, i+nColumn-j, 1);
 622       }else{
 623         sqlite3ExprCode(pParse, pList->a[j].pExpr);
 624       }
 625     }
 626
 627     /* Generate code to check constraints and generate index keys and
 628     ** do the insertion.
 629     */
 630     sqlite3GenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0,
 631                                    0, onError, endOfLoop);
 632     sqlite3CompleteInsertion(pParse, pTab, base, 0,0,0,
 633                             (triggers_exist & TRIGGER_AFTER)!=0 ? newIdx : -1);
 634   }
 635
 636   /* Update the count of rows that are inserted
 637   */
 638   if( (db->flags & SQLITE_CountRows)!=0 ){
 639     sqlite3VdbeAddOp(v, OP_MemIncr, iCntMem, 0);
 640   }
 641
 642   if( triggers_exist ){
 643     /* Close all tables opened */
 644     if( !isView ){
 645       sqlite3VdbeAddOp(v, OP_Close, base, 0);
 646       for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
 647         sqlite3VdbeAddOp(v, OP_Close, idx+base, 0);
 648       }
 649     }
 650
 651     /* Code AFTER triggers */
 652     if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_AFTER, pTab,
 653           newIdx, -1, onError, endOfLoop) ){
 654       goto insert_cleanup;
 655     }
 656   }
 657
 658   /* The bottom of the loop, if the data source is a SELECT statement
 659   */
 660   sqlite3VdbeResolveLabel(v, endOfLoop);
 661   if( useTempTable ){
 662     sqlite3VdbeAddOp(v, OP_Next, srcTab, iCont);
 663     sqlite3VdbeResolveLabel(v, iBreak);
 664     sqlite3VdbeAddOp(v, OP_Close, srcTab, 0);
 665   }else if( pSelect ){
 666     sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0);
 667     sqlite3VdbeAddOp(v, OP_Return, 0, 0);
 668     sqlite3VdbeResolveLabel(v, iCleanup);
 669   }
 670
 671   if( !triggers_exist ){
 672     /* Close all tables opened */
 673     sqlite3VdbeAddOp(v, OP_Close, base, 0);
 674     for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
 675       sqlite3VdbeAddOp(v, OP_Close, idx+base, 0);
 676     }
 677   }
 678
 679 #ifndef SQLITE_OMIT_AUTOINCREMENT
 680   /* Update the sqlite_sequence table by storing the content of the
 681   ** counter value in memory counterMem back into the sqlite_sequence
 682   ** table.
 683   */
 684   if( pTab->autoInc ){
 685     int iCur = pParse->nTab;
 686     int base = sqlite3VdbeCurrentAddr(v);
 687     sqlite3VdbeAddOp(v, OP_Integer, pTab->iDb, 0);
 688     sqlite3VdbeAddOp(v, OP_OpenWrite, iCur, pDb->pSeqTab->tnum);
 689     sqlite3VdbeAddOp(v, OP_SetNumColumns, iCur, 2);
 690     sqlite3VdbeAddOp(v, OP_MemLoad, counterRowid, 0);
 691     sqlite3VdbeAddOp(v, OP_NotNull, -1, base+7);
 692     sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
 693     sqlite3VdbeAddOp(v, OP_NewRowid, iCur, 0);
 694     sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0);
 695     sqlite3VdbeAddOp(v, OP_MemLoad, counterMem, 0);
 696     sqlite3VdbeAddOp(v, OP_MakeRecord, 2, 0);
 697     sqlite3VdbeAddOp(v, OP_Insert, iCur, 0);
 698     sqlite3VdbeAddOp(v, OP_Close, iCur, 0);
 699   }
 700 #endif
 701
 702   /*
 703   ** Return the number of rows inserted. If this routine is
 704   ** generating code because of a call to sqlite3NestedParse(), do not
 705   ** invoke the callback function.
 706   */
 707   if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){
 708     sqlite3VdbeAddOp(v, OP_MemLoad, iCntMem, 0);
 709     sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
 710     sqlite3VdbeSetNumCols(v, 1);
 711     sqlite3VdbeSetColName(v, 0, "rows inserted", P3_STATIC);
 712   }
 713
 714 insert_cleanup:
 715   sqlite3SrcListDelete(pTabList);
 716   sqlite3ExprListDelete(pList);
 717   sqlite3SelectDelete(pSelect);
 718   sqlite3IdListDelete(pColumn);
 719 }
 720
 721 /*
 722 ** Generate code to do a constraint check prior to an INSERT or an UPDATE.
 723 **
 724 ** When this routine is called, the stack contains (from bottom to top)
 725 ** the following values:
 726 **
 727 **    1.  The rowid of the row to be updated before the update.  This
 728 **        value is omitted unless we are doing an UPDATE that involves a
 729 **        change to the record number.
 730 **
 731 **    2.  The rowid of the row after the update.
 732 **
 733 **    3.  The data in the first column of the entry after the update.
 734 **
 735 **    i.  Data from middle columns...
 736 **
 737 **    N.  The data in the last column of the entry after the update.
 738 **
 739 ** The old rowid shown as entry (1) above is omitted unless both isUpdate
 740 ** and rowidChng are 1.  isUpdate is true for UPDATEs and false for
 741 ** INSERTs and rowidChng is true if the record number is being changed.
 742 **
 743 ** The code generated by this routine pushes additional entries onto
 744 ** the stack which are the keys for new index entries for the new record.
 745 ** The order of index keys is the same as the order of the indices on
 746 ** the pTable->pIndex list.  A key is only created for index i if
 747 ** aIdxUsed!=0 and aIdxUsed[i]!=0.
 748 **
 749 ** This routine also generates code to check constraints.  NOT NULL,
 750 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
 751 ** then the appropriate action is performed.  There are five possible
 752 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
 753 **
 754 **  Constraint type  Action       What Happens
 755 **  ---------------  ----------   ----------------------------------------
 756 **  any              ROLLBACK     The current transaction is rolled back and
 757 **                                sqlite3_exec() returns immediately with a
 758 **                                return code of SQLITE_CONSTRAINT.
 759 **
 760 **  any              ABORT        Back out changes from the current command
 761 **                                only (do not do a complete rollback) then
 762 **                                cause sqlite3_exec() to return immediately
 763 **                                with SQLITE_CONSTRAINT.
 764 **
 765 **  any              FAIL         Sqlite_exec() returns immediately with a
 766 **                                return code of SQLITE_CONSTRAINT.  The
 767 **                                transaction is not rolled back and any
 768 **                                prior changes are retained.
 769 **
 770 **  any              IGNORE       The record number and data is popped from
 771 **                                the stack and there is an immediate jump
 772 **                                to label ignoreDest.
 773 **
 774 **  NOT NULL         REPLACE      The NULL value is replace by the default
 775 **                                value for that column.  If the default value
 776 **                                is NULL, the action is the same as ABORT.
 777 **
 778 **  UNIQUE           REPLACE      The other row that conflicts with the row
 779 **                                being inserted is removed.
 780 **
 781 **  CHECK            REPLACE      Illegal.  The results in an exception.
 782 **
 783 ** Which action to take is determined by the overrideError parameter.
 784 ** Or if overrideError==OE_Default, then the pParse->onError parameter
 785 ** is used.  Or if pParse->onError==OE_Default then the onError value
 786 ** for the constraint is used.
 787 **
 788 ** The calling routine must open a read/write cursor for pTab with
 789 ** cursor number "base".  All indices of pTab must also have open
 790 ** read/write cursors with cursor number base+i for the i-th cursor.
 791 ** Except, if there is no possibility of a REPLACE action then
 792 ** cursors do not need to be open for indices where aIdxUsed[i]==0.
 793 **
 794 ** If the isUpdate flag is true, it means that the "base" cursor is
 795 ** initially pointing to an entry that is being updated.  The isUpdate
 796 ** flag causes extra code to be generated so that the "base" cursor
 797 ** is still pointing at the same entry after the routine returns.
 798 ** Without the isUpdate flag, the "base" cursor might be moved.
 799 */
 800 void sqlite3GenerateConstraintChecks(
 801   Parse *pParse,      /* The parser context */
 802   Table *pTab,        /* the table into which we are inserting */
 803   int base,           /* Index of a read/write cursor pointing at pTab */
 804   char *aIdxUsed,     /* Which indices are used.  NULL means all are used */
 805   int rowidChng,      /* True if the record number will change */
 806   int isUpdate,       /* True for UPDATE, False for INSERT */
 807   int overrideError,  /* Override onError to this if not OE_Default */
 808   int ignoreDest      /* Jump to this label on an OE_Ignore resolution */
 809 ){
 810   int i;
 811   Vdbe *v;
 812   int nCol;
 813   int onError;
 814   int addr;
 815   int extra;
 816   int iCur;
 817   Index *pIdx;
 818   int seenReplace = 0;
 819   int jumpInst1=0, jumpInst2;
 820   int contAddr;
 821   int hasTwoRowids = (isUpdate && rowidChng);
 822
 823   v = sqlite3GetVdbe(pParse);
 824   assert( v!=0 );
 825   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
 826   nCol = pTab->nCol;
 827
 828   /* Test all NOT NULL constraints.
 829   */
 830   for(i=0; i<nCol; i++){
 831     if( i==pTab->iPKey ){
 832       continue;
 833     }
 834     onError = pTab->aCol[i].notNull;
 835     if( onError==OE_None ) continue;
 836     if( overrideError!=OE_Default ){
 837       onError = overrideError;
 838     }else if( onError==OE_Default ){
 839       onError = OE_Abort;
 840     }
 841     if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
 842       onError = OE_Abort;
 843     }
 844     sqlite3VdbeAddOp(v, OP_Dup, nCol-1-i, 1);
 845     addr = sqlite3VdbeAddOp(v, OP_NotNull, 1, 0);
 846     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
 847         || onError==OE_Ignore || onError==OE_Replace );
 848     switch( onError ){
 849       case OE_Rollback:
 850       case OE_Abort:
 851       case OE_Fail: {
 852         STRPTR zMsg = NULL;
 853         sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
 854         sqlite3SetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName,
 855                         " may not be NULL", (char*)0);
 856         sqlite3VdbeChangeP3(v, -1, zMsg, P3_DYNAMIC);
 857         break;
 858       }
 859       case OE_Ignore: {
 860         sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0);
 861         sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);
 862         break;
 863       }
 864       case OE_Replace: {
 865         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);
 866         sqlite3VdbeAddOp(v, OP_Push, nCol-i, 0);
 867         break;
 868       }
 869     }
 870     sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));
 871   }
 872
 873   /* Test all CHECK constraints
 874   */
 875   /**** TBD ****/
 876
 877   /* If we have an INTEGER PRIMARY KEY, make sure the primary key
 878   ** of the new record does not previously exist.  Except, if this
 879   ** is an UPDATE and the primary key is not changing, that is OK.
 880   */
 881   if( rowidChng ){
 882     onError = pTab->keyConf;
 883     if( overrideError!=OE_Default ){
 884       onError = overrideError;
 885     }else if( onError==OE_Default ){
 886       onError = OE_Abort;
 887     }
 888
 889     if( isUpdate ){
 890       sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);
 891       sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);
 892       jumpInst1 = sqlite3VdbeAddOp(v, OP_Eq, 0, 0);
 893     }
 894     sqlite3VdbeAddOp(v, OP_Dup, nCol, 1);
 895     jumpInst2 = sqlite3VdbeAddOp(v, OP_NotExists, base, 0);
 896     switch( onError ){
 897       default: {
 898         onError = OE_Abort;
 899         /* Fall thru into the next case */
 900       }
 901       case OE_Rollback:
 902       case OE_Abort:
 903       case OE_Fail: {
 904         sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError,
 905                          "PRIMARY KEY must be unique", P3_STATIC);
 906         break;
 907       }
 908       case OE_Replace: {
 909         sqlite3GenerateRowIndexDelete(pParse->db, v, pTab, base, 0);
 910         if( isUpdate ){
 911           sqlite3VdbeAddOp(v, OP_Dup, nCol+hasTwoRowids, 1);
 912           sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
 913         }
 914         seenReplace = 1;
 915         break;
 916       }
 917       case OE_Ignore: {
 918         assert( seenReplace==0 );
 919         sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0);
 920         sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);
 921         break;
 922       }
 923     }
 924     contAddr = sqlite3VdbeCurrentAddr(v);
 925     sqlite3VdbeChangeP2(v, jumpInst2, contAddr);
 926     if( isUpdate ){
 927       sqlite3VdbeChangeP2(v, jumpInst1, contAddr);
 928       sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);
 929       sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
 930     }
 931   }
 932
 933   /* Test all UNIQUE constraints by creating entries for each UNIQUE
 934   ** index and making sure that duplicate entries do not already exist.
 935   ** Add the new records to the indices as we go.
 936   */
 937   extra = -1;
 938   for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
 939     if( aIdxUsed && aIdxUsed[iCur]==0 ) continue;  /* Skip unused indices */
 940     extra++;
 941
 942     /* Create a key for accessing the index entry */
 943     sqlite3VdbeAddOp(v, OP_Dup, nCol+extra, 1);
 944     for(i=0; i<pIdx->nColumn; i++){
 945       int idx = pIdx->aiColumn[i];
 946       if( idx==pTab->iPKey ){
 947         sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1);
 948       }else{
 949         sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1);
 950       }
 951     }
 952     jumpInst1 = sqlite3VdbeAddOp(v, OP_MakeRecord, pIdx->nColumn, (1<<24));
 953     sqlite3IndexAffinityStr(v, pIdx);
 954
 955     /* Find out what action to take in case there is an indexing conflict */
 956     onError = pIdx->onError;
 957     if( onError==OE_None ) continue;  /* pIdx is not a UNIQUE index */
 958     if( overrideError!=OE_Default ){
 959       onError = overrideError;
 960     }else if( onError==OE_Default ){
 961       onError = OE_Abort;
 962     }
 963     if( seenReplace ){
 964       if( onError==OE_Ignore ) onError = OE_Replace;
 965       else if( onError==OE_Fail ) onError = OE_Abort;
 966     }
 967
 968
 969     /* Check to see if the new index entry will be unique */
 970     sqlite3VdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRowids, 1);
 971     jumpInst2 = sqlite3VdbeAddOp(v, OP_IsUnique, base+iCur+1, 0);
 972
 973     /* Generate code that executes if the new index entry is not unique */
 974     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
 975         || onError==OE_Ignore || onError==OE_Replace );
 976     switch( onError ){
 977       case OE_Rollback:
 978       case OE_Abort:
 979       case OE_Fail: {
 980         int j, n1, n2;
 981         char zErrMsg[200];
 982         strcpy(zErrMsg, pIdx->nColumn>1 ? "columns " : "column ");
 983         n1 = strlen(zErrMsg);
 984         for(j=0; j<pIdx->nColumn && n1<sizeof(zErrMsg)-30; j++){
 985           char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
 986           n2 = strlen(zCol);
 987           if( j>0 ){
 988             strcpy(&zErrMsg[n1], ", ");
 989             n1 += 2;
 990           }
 991           if( n1+n2>sizeof(zErrMsg)-30 ){
 992             strcpy(&zErrMsg[n1], "...");
 993             n1 += 3;
 994             break;
 995           }else{
 996             strcpy(&zErrMsg[n1], zCol);
 997             n1 += n2;
 998           }
 999         }
1000         strcpy(&zErrMsg[n1],
1001             pIdx->nColumn>1 ? " are not unique" : " is not unique");
1002         sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, zErrMsg, 0);
1003         break;
1004       }
1005       case OE_Ignore: {
1006         assert( seenReplace==0 );
1007         sqlite3VdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRowids, 0);
1008         sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);
1009         break;
1010       }
1011       case OE_Replace: {
1012         sqlite3GenerateRowDelete(pParse->db, v, pTab, base, 0);
1013         if( isUpdate ){
1014           sqlite3VdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRowids, 1);
1015           sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
1016         }
1017         seenReplace = 1;
1018         break;
1019       }
1020     }
1021     contAddr = sqlite3VdbeCurrentAddr(v);
1022     assert( contAddr<(1<<24) );
1023 #if NULL_DISTINCT_FOR_UNIQUE
1024     sqlite3VdbeChangeP2(v, jumpInst1, contAddr | (1<<24));
1025 #endif
1026     sqlite3VdbeChangeP2(v, jumpInst2, contAddr);
1027   }
1028 }
1029
1030 /*
1031 ** This routine generates code to finish the INSERT or UPDATE operation
1032 ** that was started by a prior call to sqlite3GenerateConstraintChecks.
1033 ** The stack must contain keys for all active indices followed by data
1034 ** and the rowid for the new entry.  This routine creates the new
1035 ** entries in all indices and in the main table.
1036 **
1037 ** The arguments to this routine should be the same as the first six
1038 ** arguments to sqlite3GenerateConstraintChecks.
1039 */
1040 void sqlite3CompleteInsertion(
1041   Parse *pParse,      /* The parser context */
1042   Table *pTab,        /* the table into which we are inserting */
1043   int base,           /* Index of a read/write cursor pointing at pTab */
1044   char *aIdxUsed,     /* Which indices are used.  NULL means all are used */
1045   int rowidChng,      /* True if the record number will change */
1046   int isUpdate,       /* True for UPDATE, False for INSERT */
1047   int newIdx          /* Index of NEW table for triggers.  -1 if none */
1048 ){
1049   int i;
1050   Vdbe *v;
1051   int nIdx;
1052   Index *pIdx;
1053   int pik_flags;
1054
1055   v = sqlite3GetVdbe(pParse);
1056   assert( v!=0 );
1057   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
1058   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
1059   for(i=nIdx-1; i>=0; i--){
1060     if( aIdxUsed && aIdxUsed[i]==0 ) continue;
1061     sqlite3VdbeAddOp(v, OP_IdxInsert, base+i+1, 0);
1062   }
1063   sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
1064   sqlite3TableAffinityStr(v, pTab);
1065 #ifndef SQLITE_OMIT_TRIGGER
1066   if( newIdx>=0 ){
1067     sqlite3VdbeAddOp(v, OP_Dup, 1, 0);
1068     sqlite3VdbeAddOp(v, OP_Dup, 1, 0);
1069     sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0);
1070   }
1071 #endif
1072   if( pParse->nested ){
1073     pik_flags = 0;
1074   }else{
1075     pik_flags = (OPFLAG_NCHANGE|(isUpdate?0:OPFLAG_LASTROWID));
1076   }
1077   sqlite3VdbeAddOp(v, OP_Insert, base, pik_flags);
1078
1079   if( isUpdate && rowidChng ){
1080     sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
1081   }
1082 }
1083
1084 /*
1085 ** Generate code that will open cursors for a table and for all
1086 ** indices of that table.  The "base" parameter is the cursor number used
1087 ** for the table.  Indices are opened on subsequent cursors.
1088 */
1089 void sqlite3OpenTableAndIndices(
1090   Parse *pParse,   /* Parsing context */
1091   Table *pTab,     /* Table to be opened */
1092   int base,        /* Cursor number assigned to the table */
1093   int op           /* OP_OpenRead or OP_OpenWrite */
1094 ){
1095   int i;
1096   Index *pIdx;
1097   Vdbe *v = sqlite3GetVdbe(pParse);
1098   assert( v!=0 );
1099   sqlite3VdbeAddOp(v, OP_Integer, pTab->iDb, 0);
1100   sqlite3VdbeAddOp(v, op, base, pTab->tnum);
1101   VdbeComment((v, "# %s", pTab->zName));
1102   sqlite3VdbeAddOp(v, OP_SetNumColumns, base, pTab->nCol);
1103   for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
1104     sqlite3VdbeAddOp(v, OP_Integer, pIdx->iDb, 0);
1105     sqlite3VdbeOp3(v, op, i+base, pIdx->tnum,
1106                    (char*)&pIdx->keyInfo, P3_KEYINFO);
1107   }
1108   if( pParse->nTab<=base+i ){
1109     pParse->nTab = base+i;
1110   }
1111 }