persistentstorage/sql/SQLite/insert.c
changeset 0 08ec8eefde2f
child 17 55f2396f6d25
equal deleted inserted replaced
-1:000000000000 0:08ec8eefde2f
       
     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.c,v 1.248 2008/07/28 19:34:53 drh Exp $
       
    16 */
       
    17 #include "sqliteInt.h"
       
    18 
       
    19 /*
       
    20 ** Set P4 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 ** An extra 'b' is appended to the end of the string to cover the
       
    33 ** rowid that appears as the last column in every index.
       
    34 */
       
    35 void sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
       
    36   if( !pIdx->zColAff ){
       
    37     /* The first time a column affinity string for a particular index is
       
    38     ** required, it is allocated and populated here. It is then stored as
       
    39     ** a member of the Index structure for subsequent use.
       
    40     **
       
    41     ** The column affinity string will eventually be deleted by
       
    42     ** sqliteDeleteIndex() when the Index structure itself is cleaned
       
    43     ** up.
       
    44     */
       
    45     int n;
       
    46     Table *pTab = pIdx->pTable;
       
    47     sqlite3 *db = sqlite3VdbeDb(v);
       
    48     pIdx->zColAff = (char *)sqlite3Malloc(pIdx->nColumn+2);
       
    49     if( !pIdx->zColAff ){
       
    50       db->mallocFailed = 1;
       
    51       return;
       
    52     }
       
    53     for(n=0; n<pIdx->nColumn; n++){
       
    54       pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
       
    55     }
       
    56     pIdx->zColAff[n++] = SQLITE_AFF_NONE;
       
    57     pIdx->zColAff[n] = 0;
       
    58   }
       
    59  
       
    60   sqlite3VdbeChangeP4(v, -1, pIdx->zColAff, 0);
       
    61 }
       
    62 
       
    63 /*
       
    64 ** Set P4 of the most recently inserted opcode to a column affinity
       
    65 ** string for table pTab. A column affinity string has one character
       
    66 ** for each column indexed by the index, according to the affinity of the
       
    67 ** column:
       
    68 **
       
    69 **  Character      Column affinity
       
    70 **  ------------------------------
       
    71 **  'a'            TEXT
       
    72 **  'b'            NONE
       
    73 **  'c'            NUMERIC
       
    74 **  'd'            INTEGER
       
    75 **  'e'            REAL
       
    76 */
       
    77 void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
       
    78   /* The first time a column affinity string for a particular table
       
    79   ** is required, it is allocated and populated here. It is then 
       
    80   ** stored as a member of the Table structure for subsequent use.
       
    81   **
       
    82   ** The column affinity string will eventually be deleted by
       
    83   ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
       
    84   */
       
    85   if( !pTab->zColAff ){
       
    86     char *zColAff;
       
    87     int i;
       
    88     sqlite3 *db = sqlite3VdbeDb(v);
       
    89 
       
    90     zColAff = (char *)sqlite3Malloc(pTab->nCol+1);
       
    91     if( !zColAff ){
       
    92       db->mallocFailed = 1;
       
    93       return;
       
    94     }
       
    95 
       
    96     for(i=0; i<pTab->nCol; i++){
       
    97       zColAff[i] = pTab->aCol[i].affinity;
       
    98     }
       
    99     zColAff[pTab->nCol] = '\0';
       
   100 
       
   101     pTab->zColAff = zColAff;
       
   102   }
       
   103 
       
   104   sqlite3VdbeChangeP4(v, -1, pTab->zColAff, 0);
       
   105 }
       
   106 
       
   107 /*
       
   108 ** Return non-zero if the table pTab in database iDb or any of its indices
       
   109 ** have been opened at any point in the VDBE program beginning at location
       
   110 ** iStartAddr throught the end of the program.  This is used to see if 
       
   111 ** a statement of the form  "INSERT INTO <iDb, pTab> SELECT ..." can 
       
   112 ** run without using temporary table for the results of the SELECT. 
       
   113 */
       
   114 static int readsTable(Vdbe *v, int iStartAddr, int iDb, Table *pTab){
       
   115   int i;
       
   116   int iEnd = sqlite3VdbeCurrentAddr(v);
       
   117   for(i=iStartAddr; i<iEnd; i++){
       
   118     VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
       
   119     assert( pOp!=0 );
       
   120     if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
       
   121       Index *pIndex;
       
   122       int tnum = pOp->p2;
       
   123       if( tnum==pTab->tnum ){
       
   124         return 1;
       
   125       }
       
   126       for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
       
   127         if( tnum==pIndex->tnum ){
       
   128           return 1;
       
   129         }
       
   130       }
       
   131     }
       
   132 #ifndef SQLITE_OMIT_VIRTUALTABLE
       
   133     if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pTab->pVtab ){
       
   134       assert( pOp->p4.pVtab!=0 );
       
   135       assert( pOp->p4type==P4_VTAB );
       
   136       return 1;
       
   137     }
       
   138 #endif
       
   139   }
       
   140   return 0;
       
   141 }
       
   142 
       
   143 #ifndef SQLITE_OMIT_AUTOINCREMENT
       
   144 /*
       
   145 ** Write out code to initialize the autoincrement logic.  This code
       
   146 ** looks up the current autoincrement value in the sqlite_sequence
       
   147 ** table and stores that value in a register.  Code generated by
       
   148 ** autoIncStep() will keep that register holding the largest
       
   149 ** rowid value.  Code generated by autoIncEnd() will write the new
       
   150 ** largest value of the counter back into the sqlite_sequence table.
       
   151 **
       
   152 ** This routine returns the index of the mem[] cell that contains
       
   153 ** the maximum rowid counter.
       
   154 **
       
   155 ** Three consecutive registers are allocated by this routine.  The
       
   156 ** first two hold the name of the target table and the maximum rowid 
       
   157 ** inserted into the target table, respectively.
       
   158 ** The third holds the rowid in sqlite_sequence where we will
       
   159 ** write back the revised maximum rowid.  This routine returns the
       
   160 ** index of the second of these three registers.
       
   161 */
       
   162 static int autoIncBegin(
       
   163   Parse *pParse,      /* Parsing context */
       
   164   int iDb,            /* Index of the database holding pTab */
       
   165   Table *pTab         /* The table we are writing to */
       
   166 ){
       
   167   int memId = 0;      /* Register holding maximum rowid */
       
   168   if( pTab->autoInc ){
       
   169     Vdbe *v = pParse->pVdbe;
       
   170     Db *pDb = &pParse->db->aDb[iDb];
       
   171     int iCur = pParse->nTab;
       
   172     int addr;               /* Address of the top of the loop */
       
   173     assert( v );
       
   174     pParse->nMem++;         /* Holds name of table */
       
   175     memId = ++pParse->nMem;
       
   176     pParse->nMem++;
       
   177     sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
       
   178     addr = sqlite3VdbeCurrentAddr(v);
       
   179     sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, pTab->zName, 0);
       
   180     sqlite3VdbeAddOp2(v, OP_Rewind, iCur, addr+9);
       
   181     sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, memId);
       
   182     sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);
       
   183     sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
       
   184     sqlite3VdbeAddOp2(v, OP_Rowid, iCur, memId+1);
       
   185     sqlite3VdbeAddOp3(v, OP_Column, iCur, 1, memId);
       
   186     sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+9);
       
   187     sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+2);
       
   188     sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);
       
   189     sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
       
   190   }
       
   191   return memId;
       
   192 }
       
   193 
       
   194 /*
       
   195 ** Update the maximum rowid for an autoincrement calculation.
       
   196 **
       
   197 ** This routine should be called when the top of the stack holds a
       
   198 ** new rowid that is about to be inserted.  If that new rowid is
       
   199 ** larger than the maximum rowid in the memId memory cell, then the
       
   200 ** memory cell is updated.  The stack is unchanged.
       
   201 */
       
   202 static void autoIncStep(Parse *pParse, int memId, int regRowid){
       
   203   if( memId>0 ){
       
   204     sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
       
   205   }
       
   206 }
       
   207 
       
   208 /*
       
   209 ** After doing one or more inserts, the maximum rowid is stored
       
   210 ** in reg[memId].  Generate code to write this value back into the
       
   211 ** the sqlite_sequence table.
       
   212 */
       
   213 static void autoIncEnd(
       
   214   Parse *pParse,     /* The parsing context */
       
   215   int iDb,           /* Index of the database holding pTab */
       
   216   Table *pTab,       /* Table we are inserting into */
       
   217   int memId          /* Memory cell holding the maximum rowid */
       
   218 ){
       
   219   if( pTab->autoInc ){
       
   220     int iCur = pParse->nTab;
       
   221     Vdbe *v = pParse->pVdbe;
       
   222     Db *pDb = &pParse->db->aDb[iDb];
       
   223     int j1;
       
   224     int iRec = ++pParse->nMem;    /* Memory cell used for record */
       
   225 
       
   226     assert( v );
       
   227     sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
       
   228     j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);
       
   229     sqlite3VdbeAddOp2(v, OP_NewRowid, iCur, memId+1);
       
   230     sqlite3VdbeJumpHere(v, j1);
       
   231     sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
       
   232     sqlite3VdbeAddOp3(v, OP_Insert, iCur, iRec, memId+1);
       
   233     sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
       
   234     sqlite3VdbeAddOp1(v, OP_Close, iCur);
       
   235   }
       
   236 }
       
   237 #else
       
   238 /*
       
   239 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
       
   240 ** above are all no-ops
       
   241 */
       
   242 # define autoIncBegin(A,B,C) (0)
       
   243 # define autoIncStep(A,B,C)
       
   244 # define autoIncEnd(A,B,C,D)
       
   245 #endif /* SQLITE_OMIT_AUTOINCREMENT */
       
   246 
       
   247 
       
   248 /* Forward declaration */
       
   249 static int xferOptimization(
       
   250   Parse *pParse,        /* Parser context */
       
   251   Table *pDest,         /* The table we are inserting into */
       
   252   Select *pSelect,      /* A SELECT statement to use as the data source */
       
   253   int onError,          /* How to handle constraint errors */
       
   254   int iDbDest           /* The database of pDest */
       
   255 );
       
   256 
       
   257 /*
       
   258 ** This routine is call to handle SQL of the following forms:
       
   259 **
       
   260 **    insert into TABLE (IDLIST) values(EXPRLIST)
       
   261 **    insert into TABLE (IDLIST) select
       
   262 **
       
   263 ** The IDLIST following the table name is always optional.  If omitted,
       
   264 ** then a list of all columns for the table is substituted.  The IDLIST
       
   265 ** appears in the pColumn parameter.  pColumn is NULL if IDLIST is omitted.
       
   266 **
       
   267 ** The pList parameter holds EXPRLIST in the first form of the INSERT
       
   268 ** statement above, and pSelect is NULL.  For the second form, pList is
       
   269 ** NULL and pSelect is a pointer to the select statement used to generate
       
   270 ** data for the insert.
       
   271 **
       
   272 ** The code generated follows one of four templates.  For a simple
       
   273 ** select with data coming from a VALUES clause, the code executes
       
   274 ** once straight down through.  Pseudo-code follows (we call this
       
   275 ** the "1st template"):
       
   276 **
       
   277 **         open write cursor to <table> and its indices
       
   278 **         puts VALUES clause expressions onto the stack
       
   279 **         write the resulting record into <table>
       
   280 **         cleanup
       
   281 **
       
   282 ** The three remaining templates assume the statement is of the form
       
   283 **
       
   284 **   INSERT INTO <table> SELECT ...
       
   285 **
       
   286 ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
       
   287 ** in other words if the SELECT pulls all columns from a single table
       
   288 ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
       
   289 ** if <table2> and <table1> are distinct tables but have identical
       
   290 ** schemas, including all the same indices, then a special optimization
       
   291 ** is invoked that copies raw records from <table2> over to <table1>.
       
   292 ** See the xferOptimization() function for the implementation of this
       
   293 ** template.  This is the 2nd template.
       
   294 **
       
   295 **         open a write cursor to <table>
       
   296 **         open read cursor on <table2>
       
   297 **         transfer all records in <table2> over to <table>
       
   298 **         close cursors
       
   299 **         foreach index on <table>
       
   300 **           open a write cursor on the <table> index
       
   301 **           open a read cursor on the corresponding <table2> index
       
   302 **           transfer all records from the read to the write cursors
       
   303 **           close cursors
       
   304 **         end foreach
       
   305 **
       
   306 ** The 3rd template is for when the second template does not apply
       
   307 ** and the SELECT clause does not read from <table> at any time.
       
   308 ** The generated code follows this template:
       
   309 **
       
   310 **         EOF <- 0
       
   311 **         X <- A
       
   312 **         goto B
       
   313 **      A: setup for the SELECT
       
   314 **         loop over the rows in the SELECT
       
   315 **           load values into registers R..R+n
       
   316 **           yield X
       
   317 **         end loop
       
   318 **         cleanup after the SELECT
       
   319 **         EOF <- 1
       
   320 **         yield X
       
   321 **         goto A
       
   322 **      B: open write cursor to <table> and its indices
       
   323 **      C: yield X
       
   324 **         if EOF goto D
       
   325 **         insert the select result into <table> from R..R+n
       
   326 **         goto C
       
   327 **      D: cleanup
       
   328 **
       
   329 ** The 4th template is used if the insert statement takes its
       
   330 ** values from a SELECT but the data is being inserted into a table
       
   331 ** that is also read as part of the SELECT.  In the third form,
       
   332 ** we have to use a intermediate table to store the results of
       
   333 ** the select.  The template is like this:
       
   334 **
       
   335 **         EOF <- 0
       
   336 **         X <- A
       
   337 **         goto B
       
   338 **      A: setup for the SELECT
       
   339 **         loop over the tables in the SELECT
       
   340 **           load value into register R..R+n
       
   341 **           yield X
       
   342 **         end loop
       
   343 **         cleanup after the SELECT
       
   344 **         EOF <- 1
       
   345 **         yield X
       
   346 **         halt-error
       
   347 **      B: open temp table
       
   348 **      L: yield X
       
   349 **         if EOF goto M
       
   350 **         insert row from R..R+n into temp table
       
   351 **         goto L
       
   352 **      M: open write cursor to <table> and its indices
       
   353 **         rewind temp table
       
   354 **      C: loop over rows of intermediate table
       
   355 **           transfer values form intermediate table into <table>
       
   356 **         end loop
       
   357 **      D: cleanup
       
   358 */
       
   359 void sqlite3Insert(
       
   360   Parse *pParse,        /* Parser context */
       
   361   SrcList *pTabList,    /* Name of table into which we are inserting */
       
   362   ExprList *pList,      /* List of values to be inserted */
       
   363   Select *pSelect,      /* A SELECT statement to use as the data source */
       
   364   IdList *pColumn,      /* Column names corresponding to IDLIST. */
       
   365   int onError           /* How to handle constraint errors */
       
   366 ){
       
   367   sqlite3 *db;          /* The main database structure */
       
   368   Table *pTab;          /* The table to insert into.  aka TABLE */
       
   369   char *zTab;           /* Name of the table into which we are inserting */
       
   370   const char *zDb;      /* Name of the database holding this table */
       
   371   int i, j, idx;        /* Loop counters */
       
   372   Vdbe *v;              /* Generate code into this virtual machine */
       
   373   Index *pIdx;          /* For looping over indices of the table */
       
   374   int nColumn;          /* Number of columns in the data */
       
   375   int nHidden = 0;      /* Number of hidden columns if TABLE is virtual */
       
   376   int baseCur = 0;      /* VDBE Cursor number for pTab */
       
   377   int keyColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
       
   378   int endOfLoop;        /* Label for the end of the insertion loop */
       
   379   int useTempTable = 0; /* Store SELECT results in intermediate table */
       
   380   int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */
       
   381   int addrInsTop = 0;   /* Jump to label "D" */
       
   382   int addrCont = 0;     /* Top of insert loop. Label "C" in templates 3 and 4 */
       
   383   int addrSelect = 0;   /* Address of coroutine that implements the SELECT */
       
   384   SelectDest dest;      /* Destination for SELECT on rhs of INSERT */
       
   385   int newIdx = -1;      /* Cursor for the NEW pseudo-table */
       
   386   int iDb;              /* Index of database holding TABLE */
       
   387   Db *pDb;              /* The database containing table being inserted into */
       
   388   int appendFlag = 0;   /* True if the insert is likely to be an append */
       
   389 
       
   390   /* Register allocations */
       
   391   int regFromSelect;    /* Base register for data coming from SELECT */
       
   392   int regAutoinc = 0;   /* Register holding the AUTOINCREMENT counter */
       
   393   int regRowCount = 0;  /* Memory cell used for the row counter */
       
   394   int regIns;           /* Block of regs holding rowid+data being inserted */
       
   395   int regRowid;         /* registers holding insert rowid */
       
   396   int regData;          /* register holding first column to insert */
       
   397   int regRecord;        /* Holds the assemblied row record */
       
   398   int regEof;           /* Register recording end of SELECT data */
       
   399   int *aRegIdx = 0;     /* One register allocated to each index */
       
   400 
       
   401 
       
   402 #ifndef SQLITE_OMIT_TRIGGER
       
   403   int isView;                 /* True if attempting to insert into a view */
       
   404   int triggers_exist = 0;     /* True if there are FOR EACH ROW triggers */
       
   405 #endif
       
   406 
       
   407   db = pParse->db;
       
   408   if( pParse->nErr || db->mallocFailed ){
       
   409     goto insert_cleanup;
       
   410   }
       
   411 
       
   412   /* Locate the table into which we will be inserting new information.
       
   413   */
       
   414   assert( pTabList->nSrc==1 );
       
   415   zTab = pTabList->a[0].zName;
       
   416   if( zTab==0 ) goto insert_cleanup;
       
   417   pTab = sqlite3SrcListLookup(pParse, pTabList);
       
   418   if( pTab==0 ){
       
   419     goto insert_cleanup;
       
   420   }
       
   421   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
       
   422   assert( iDb<db->nDb );
       
   423   pDb = &db->aDb[iDb];
       
   424   zDb = pDb->zName;
       
   425   if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
       
   426     goto insert_cleanup;
       
   427   }
       
   428 
       
   429   /* Figure out if we have any triggers and if the table being
       
   430   ** inserted into is a view
       
   431   */
       
   432 #ifndef SQLITE_OMIT_TRIGGER
       
   433   triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0);
       
   434   isView = pTab->pSelect!=0;
       
   435 #else
       
   436 # define triggers_exist 0
       
   437 # define isView 0
       
   438 #endif
       
   439 #ifdef SQLITE_OMIT_VIEW
       
   440 # undef isView
       
   441 # define isView 0
       
   442 #endif
       
   443 
       
   444   /* Ensure that:
       
   445   *  (a) the table is not read-only, 
       
   446   *  (b) that if it is a view then ON INSERT triggers exist
       
   447   */
       
   448   if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){
       
   449     goto insert_cleanup;
       
   450   }
       
   451   assert( pTab!=0 );
       
   452 
       
   453   /* If pTab is really a view, make sure it has been initialized.
       
   454   ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual 
       
   455   ** module table).
       
   456   */
       
   457   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
       
   458     goto insert_cleanup;
       
   459   }
       
   460 
       
   461   /* Allocate a VDBE
       
   462   */
       
   463   v = sqlite3GetVdbe(pParse);
       
   464   if( v==0 ) goto insert_cleanup;
       
   465   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
       
   466   sqlite3BeginWriteOperation(pParse, pSelect || triggers_exist, iDb);
       
   467 
       
   468   /* if there are row triggers, allocate a temp table for new.* references. */
       
   469   if( triggers_exist ){
       
   470     newIdx = pParse->nTab++;
       
   471   }
       
   472 
       
   473 #ifndef SQLITE_OMIT_XFER_OPT
       
   474   /* If the statement is of the form
       
   475   **
       
   476   **       INSERT INTO <table1> SELECT * FROM <table2>;
       
   477   **
       
   478   ** Then special optimizations can be applied that make the transfer
       
   479   ** very fast and which reduce fragmentation of indices.
       
   480   **
       
   481   ** This is the 2nd template.
       
   482   */
       
   483   if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
       
   484     assert( !triggers_exist );
       
   485     assert( pList==0 );
       
   486     goto insert_cleanup;
       
   487   }
       
   488 #endif /* SQLITE_OMIT_XFER_OPT */
       
   489 
       
   490   /* If this is an AUTOINCREMENT table, look up the sequence number in the
       
   491   ** sqlite_sequence table and store it in memory cell regAutoinc.
       
   492   */
       
   493   regAutoinc = autoIncBegin(pParse, iDb, pTab);
       
   494 
       
   495   /* Figure out how many columns of data are supplied.  If the data
       
   496   ** is coming from a SELECT statement, then generate a co-routine that
       
   497   ** produces a single row of the SELECT on each invocation.  The
       
   498   ** co-routine is the common header to the 3rd and 4th templates.
       
   499   */
       
   500   if( pSelect ){
       
   501     /* Data is coming from a SELECT.  Generate code to implement that SELECT
       
   502     ** as a co-routine.  The code is common to both the 3rd and 4th
       
   503     ** templates:
       
   504     **
       
   505     **         EOF <- 0
       
   506     **         X <- A
       
   507     **         goto B
       
   508     **      A: setup for the SELECT
       
   509     **         loop over the tables in the SELECT
       
   510     **           load value into register R..R+n
       
   511     **           yield X
       
   512     **         end loop
       
   513     **         cleanup after the SELECT
       
   514     **         EOF <- 1
       
   515     **         yield X
       
   516     **         halt-error
       
   517     **
       
   518     ** On each invocation of the co-routine, it puts a single row of the
       
   519     ** SELECT result into registers dest.iMem...dest.iMem+dest.nMem-1.
       
   520     ** (These output registers are allocated by sqlite3Select().)  When
       
   521     ** the SELECT completes, it sets the EOF flag stored in regEof.
       
   522     */
       
   523     int rc, j1;
       
   524 
       
   525     regEof = ++pParse->nMem;
       
   526     sqlite3VdbeAddOp2(v, OP_Integer, 0, regEof);      /* EOF <- 0 */
       
   527     VdbeComment((v, "SELECT eof flag"));
       
   528     sqlite3SelectDestInit(&dest, SRT_Coroutine, ++pParse->nMem);
       
   529     addrSelect = sqlite3VdbeCurrentAddr(v)+2;
       
   530     sqlite3VdbeAddOp2(v, OP_Integer, addrSelect-1, dest.iParm);
       
   531     j1 = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
       
   532     VdbeComment((v, "Jump over SELECT coroutine"));
       
   533 
       
   534     /* Resolve the expressions in the SELECT statement and execute it. */
       
   535     rc = sqlite3Select(pParse, pSelect, &dest, 0, 0, 0);
       
   536     if( rc || pParse->nErr || db->mallocFailed ){
       
   537       goto insert_cleanup;
       
   538     }
       
   539     sqlite3VdbeAddOp2(v, OP_Integer, 1, regEof);         /* EOF <- 1 */
       
   540     sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);   /* yield X */
       
   541     sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_INTERNAL, OE_Abort);
       
   542     VdbeComment((v, "End of SELECT coroutine"));
       
   543     sqlite3VdbeJumpHere(v, j1);                          /* label B: */
       
   544 
       
   545     regFromSelect = dest.iMem;
       
   546     assert( pSelect->pEList );
       
   547     nColumn = pSelect->pEList->nExpr;
       
   548     assert( dest.nMem==nColumn );
       
   549 
       
   550     /* Set useTempTable to TRUE if the result of the SELECT statement
       
   551     ** should be written into a temporary table (template 4).  Set to
       
   552     ** FALSE if each* row of the SELECT can be written directly into
       
   553     ** the destination table (template 3).
       
   554     **
       
   555     ** A temp table must be used if the table being updated is also one
       
   556     ** of the tables being read by the SELECT statement.  Also use a 
       
   557     ** temp table in the case of row triggers.
       
   558     */
       
   559     if( triggers_exist || readsTable(v, addrSelect, iDb, pTab) ){
       
   560       useTempTable = 1;
       
   561     }
       
   562 
       
   563     if( useTempTable ){
       
   564       /* Invoke the coroutine to extract information from the SELECT
       
   565       ** and add it to a transient table srcTab.  The code generated
       
   566       ** here is from the 4th template:
       
   567       **
       
   568       **      B: open temp table
       
   569       **      L: yield X
       
   570       **         if EOF goto M
       
   571       **         insert row from R..R+n into temp table
       
   572       **         goto L
       
   573       **      M: ...
       
   574       */
       
   575       int regRec;      /* Register to hold packed record */
       
   576       int regRowid;    /* Register to hold temp table ROWID */
       
   577       int addrTop;     /* Label "L" */
       
   578       int addrIf;      /* Address of jump to M */
       
   579 
       
   580       srcTab = pParse->nTab++;
       
   581       regRec = sqlite3GetTempReg(pParse);
       
   582       regRowid = sqlite3GetTempReg(pParse);
       
   583       sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
       
   584       addrTop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);
       
   585       addrIf = sqlite3VdbeAddOp1(v, OP_If, regEof);
       
   586       sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
       
   587       sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regRowid);
       
   588       sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regRowid);
       
   589       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);
       
   590       sqlite3VdbeJumpHere(v, addrIf);
       
   591       sqlite3ReleaseTempReg(pParse, regRec);
       
   592       sqlite3ReleaseTempReg(pParse, regRowid);
       
   593     }
       
   594   }else{
       
   595     /* This is the case if the data for the INSERT is coming from a VALUES
       
   596     ** clause
       
   597     */
       
   598     NameContext sNC;
       
   599     memset(&sNC, 0, sizeof(sNC));
       
   600     sNC.pParse = pParse;
       
   601     srcTab = -1;
       
   602     assert( useTempTable==0 );
       
   603     nColumn = pList ? pList->nExpr : 0;
       
   604     for(i=0; i<nColumn; i++){
       
   605       if( sqlite3ExprResolveNames(&sNC, pList->a[i].pExpr) ){
       
   606         goto insert_cleanup;
       
   607       }
       
   608     }
       
   609   }
       
   610 
       
   611   /* Make sure the number of columns in the source data matches the number
       
   612   ** of columns to be inserted into the table.
       
   613   */
       
   614   if( IsVirtual(pTab) ){
       
   615     for(i=0; i<pTab->nCol; i++){
       
   616       nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
       
   617     }
       
   618   }
       
   619   if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
       
   620     sqlite3ErrorMsg(pParse, 
       
   621        "table %S has %d columns but %d values were supplied",
       
   622        pTabList, 0, pTab->nCol, nColumn);
       
   623     goto insert_cleanup;
       
   624   }
       
   625   if( pColumn!=0 && nColumn!=pColumn->nId ){
       
   626     sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
       
   627     goto insert_cleanup;
       
   628   }
       
   629 
       
   630   /* If the INSERT statement included an IDLIST term, then make sure
       
   631   ** all elements of the IDLIST really are columns of the table and 
       
   632   ** remember the column indices.
       
   633   **
       
   634   ** If the table has an INTEGER PRIMARY KEY column and that column
       
   635   ** is named in the IDLIST, then record in the keyColumn variable
       
   636   ** the index into IDLIST of the primary key column.  keyColumn is
       
   637   ** the index of the primary key as it appears in IDLIST, not as
       
   638   ** is appears in the original table.  (The index of the primary
       
   639   ** key in the original table is pTab->iPKey.)
       
   640   */
       
   641   if( pColumn ){
       
   642     for(i=0; i<pColumn->nId; i++){
       
   643       pColumn->a[i].idx = -1;
       
   644     }
       
   645     for(i=0; i<pColumn->nId; i++){
       
   646       for(j=0; j<pTab->nCol; j++){
       
   647         if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
       
   648           pColumn->a[i].idx = j;
       
   649           if( j==pTab->iPKey ){
       
   650             keyColumn = i;
       
   651           }
       
   652           break;
       
   653         }
       
   654       }
       
   655       if( j>=pTab->nCol ){
       
   656         if( sqlite3IsRowid(pColumn->a[i].zName) ){
       
   657           keyColumn = i;
       
   658         }else{
       
   659           sqlite3ErrorMsg(pParse, "table %S has no column named %s",
       
   660               pTabList, 0, pColumn->a[i].zName);
       
   661           pParse->nErr++;
       
   662           goto insert_cleanup;
       
   663         }
       
   664       }
       
   665     }
       
   666   }
       
   667 
       
   668   /* If there is no IDLIST term but the table has an integer primary
       
   669   ** key, the set the keyColumn variable to the primary key column index
       
   670   ** in the original table definition.
       
   671   */
       
   672   if( pColumn==0 && nColumn>0 ){
       
   673     keyColumn = pTab->iPKey;
       
   674   }
       
   675 
       
   676   /* Open the temp table for FOR EACH ROW triggers
       
   677   */
       
   678   if( triggers_exist ){
       
   679     sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pTab->nCol);
       
   680     sqlite3VdbeAddOp2(v, OP_OpenPseudo, newIdx, 0);
       
   681   }
       
   682     
       
   683   /* Initialize the count of rows to be inserted
       
   684   */
       
   685   if( db->flags & SQLITE_CountRows ){
       
   686     regRowCount = ++pParse->nMem;
       
   687     sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
       
   688   }
       
   689 
       
   690   /* If this is not a view, open the table and and all indices */
       
   691   if( !isView ){
       
   692     int nIdx;
       
   693     int i;
       
   694 
       
   695     baseCur = pParse->nTab;
       
   696     nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
       
   697     aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
       
   698     if( aRegIdx==0 ){
       
   699       goto insert_cleanup;
       
   700     }
       
   701     for(i=0; i<nIdx; i++){
       
   702       aRegIdx[i] = ++pParse->nMem;
       
   703     }
       
   704   }
       
   705 
       
   706   /* This is the top of the main insertion loop */
       
   707   if( useTempTable ){
       
   708     /* This block codes the top of loop only.  The complete loop is the
       
   709     ** following pseudocode (template 4):
       
   710     **
       
   711     **         rewind temp table
       
   712     **      C: loop over rows of intermediate table
       
   713     **           transfer values form intermediate table into <table>
       
   714     **         end loop
       
   715     **      D: ...
       
   716     */
       
   717     addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab);
       
   718     addrCont = sqlite3VdbeCurrentAddr(v);
       
   719   }else if( pSelect ){
       
   720     /* This block codes the top of loop only.  The complete loop is the
       
   721     ** following pseudocode (template 3):
       
   722     **
       
   723     **      C: yield X
       
   724     **         if EOF goto D
       
   725     **         insert the select result into <table> from R..R+n
       
   726     **         goto C
       
   727     **      D: ...
       
   728     */
       
   729     addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);
       
   730     addrInsTop = sqlite3VdbeAddOp1(v, OP_If, regEof);
       
   731   }
       
   732 
       
   733   /* Allocate registers for holding the rowid of the new row,
       
   734   ** the content of the new row, and the assemblied row record.
       
   735   */
       
   736   regRecord = ++pParse->nMem;
       
   737   regRowid = regIns = pParse->nMem+1;
       
   738   pParse->nMem += pTab->nCol + 1;
       
   739   if( IsVirtual(pTab) ){
       
   740     regRowid++;
       
   741     pParse->nMem++;
       
   742   }
       
   743   regData = regRowid+1;
       
   744 
       
   745   /* Run the BEFORE and INSTEAD OF triggers, if there are any
       
   746   */
       
   747   endOfLoop = sqlite3VdbeMakeLabel(v);
       
   748   if( triggers_exist & TRIGGER_BEFORE ){
       
   749     int regRowid;
       
   750     int regCols;
       
   751     int regRec;
       
   752 
       
   753     /* build the NEW.* reference row.  Note that if there is an INTEGER
       
   754     ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
       
   755     ** translated into a unique ID for the row.  But on a BEFORE trigger,
       
   756     ** we do not know what the unique ID will be (because the insert has
       
   757     ** not happened yet) so we substitute a rowid of -1
       
   758     */
       
   759     regRowid = sqlite3GetTempReg(pParse);
       
   760     if( keyColumn<0 ){
       
   761       sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
       
   762     }else if( useTempTable ){
       
   763       sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
       
   764     }else{
       
   765       int j1;
       
   766       assert( pSelect==0 );  /* Otherwise useTempTable is true */
       
   767       sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
       
   768       j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
       
   769       sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
       
   770       sqlite3VdbeJumpHere(v, j1);
       
   771       sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
       
   772     }
       
   773 
       
   774     /* Cannot have triggers on a virtual table. If it were possible,
       
   775     ** this block would have to account for hidden column.
       
   776     */
       
   777     assert(!IsVirtual(pTab));
       
   778 
       
   779     /* Create the new column data
       
   780     */
       
   781     regCols = sqlite3GetTempRange(pParse, pTab->nCol);
       
   782     for(i=0; i<pTab->nCol; i++){
       
   783       if( pColumn==0 ){
       
   784         j = i;
       
   785       }else{
       
   786         for(j=0; j<pColumn->nId; j++){
       
   787           if( pColumn->a[j].idx==i ) break;
       
   788         }
       
   789       }
       
   790       if( pColumn && j>=pColumn->nId ){
       
   791         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i);
       
   792       }else if( useTempTable ){
       
   793         sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i); 
       
   794       }else{
       
   795         assert( pSelect==0 ); /* Otherwise useTempTable is true */
       
   796         sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i);
       
   797       }
       
   798     }
       
   799     regRec = sqlite3GetTempReg(pParse);
       
   800     sqlite3VdbeAddOp3(v, OP_MakeRecord, regCols, pTab->nCol, regRec);
       
   801 
       
   802     /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
       
   803     ** do not attempt any conversions before assembling the record.
       
   804     ** If this is a real table, attempt conversions as required by the
       
   805     ** table column affinities.
       
   806     */
       
   807     if( !isView ){
       
   808       sqlite3TableAffinityStr(v, pTab);
       
   809     }
       
   810     sqlite3VdbeAddOp3(v, OP_Insert, newIdx, regRec, regRowid);
       
   811     sqlite3ReleaseTempReg(pParse, regRec);
       
   812     sqlite3ReleaseTempReg(pParse, regRowid);
       
   813     sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol);
       
   814 
       
   815     /* Fire BEFORE or INSTEAD OF triggers */
       
   816     if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_BEFORE, pTab, 
       
   817         newIdx, -1, onError, endOfLoop, 0, 0) ){
       
   818       goto insert_cleanup;
       
   819     }
       
   820   }
       
   821 
       
   822   /* Push the record number for the new entry onto the stack.  The
       
   823   ** record number is a randomly generate integer created by NewRowid
       
   824   ** except when the table has an INTEGER PRIMARY KEY column, in which
       
   825   ** case the record number is the same as that column. 
       
   826   */
       
   827   if( !isView ){
       
   828     if( IsVirtual(pTab) ){
       
   829       /* The row that the VUpdate opcode will delete: none */
       
   830       sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
       
   831     }
       
   832     if( keyColumn>=0 ){
       
   833       if( useTempTable ){
       
   834         sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
       
   835       }else if( pSelect ){
       
   836         sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);
       
   837       }else{
       
   838         VdbeOp *pOp;
       
   839         sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
       
   840         pOp = sqlite3VdbeGetOp(v, sqlite3VdbeCurrentAddr(v) - 1);
       
   841         if( pOp && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
       
   842           appendFlag = 1;
       
   843           pOp->opcode = OP_NewRowid;
       
   844           pOp->p1 = baseCur;
       
   845           pOp->p2 = regRowid;
       
   846           pOp->p3 = regAutoinc;
       
   847         }
       
   848       }
       
   849       /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
       
   850       ** to generate a unique primary key value.
       
   851       */
       
   852       if( !appendFlag ){
       
   853         int j1;
       
   854         if( !IsVirtual(pTab) ){
       
   855           j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
       
   856           sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
       
   857           sqlite3VdbeJumpHere(v, j1);
       
   858         }else{
       
   859           j1 = sqlite3VdbeCurrentAddr(v);
       
   860           sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2);
       
   861         }
       
   862         sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
       
   863       }
       
   864     }else if( IsVirtual(pTab) ){
       
   865       sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
       
   866     }else{
       
   867       sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
       
   868       appendFlag = 1;
       
   869     }
       
   870     autoIncStep(pParse, regAutoinc, regRowid);
       
   871 
       
   872     /* Push onto the stack, data for all columns of the new entry, beginning
       
   873     ** with the first column.
       
   874     */
       
   875     nHidden = 0;
       
   876     for(i=0; i<pTab->nCol; i++){
       
   877       int iRegStore = regRowid+1+i;
       
   878       if( i==pTab->iPKey ){
       
   879         /* The value of the INTEGER PRIMARY KEY column is always a NULL.
       
   880         ** Whenever this column is read, the record number will be substituted
       
   881         ** in its place.  So will fill this column with a NULL to avoid
       
   882         ** taking up data space with information that will never be used. */
       
   883         sqlite3VdbeAddOp2(v, OP_Null, 0, iRegStore);
       
   884         continue;
       
   885       }
       
   886       if( pColumn==0 ){
       
   887         if( IsHiddenColumn(&pTab->aCol[i]) ){
       
   888           assert( IsVirtual(pTab) );
       
   889           j = -1;
       
   890           nHidden++;
       
   891         }else{
       
   892           j = i - nHidden;
       
   893         }
       
   894       }else{
       
   895         for(j=0; j<pColumn->nId; j++){
       
   896           if( pColumn->a[j].idx==i ) break;
       
   897         }
       
   898       }
       
   899       if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){
       
   900         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
       
   901       }else if( useTempTable ){
       
   902         sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore); 
       
   903       }else if( pSelect ){
       
   904         sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
       
   905       }else{
       
   906         sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
       
   907       }
       
   908     }
       
   909 
       
   910     /* Generate code to check constraints and generate index keys and
       
   911     ** do the insertion.
       
   912     */
       
   913 #ifndef SQLITE_OMIT_VIRTUALTABLE
       
   914     if( IsVirtual(pTab) ){
       
   915       sqlite3VtabMakeWritable(pParse, pTab);
       
   916       sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns,
       
   917                      (const char*)pTab->pVtab, P4_VTAB);
       
   918     }else
       
   919 #endif
       
   920     {
       
   921       sqlite3GenerateConstraintChecks(
       
   922           pParse,
       
   923           pTab,
       
   924           baseCur,
       
   925           regIns,
       
   926           aRegIdx,
       
   927           keyColumn>=0,
       
   928           0,
       
   929           onError,
       
   930           endOfLoop
       
   931       );
       
   932       sqlite3CompleteInsertion(
       
   933           pParse,
       
   934           pTab,
       
   935           baseCur,
       
   936           regIns,
       
   937           aRegIdx,
       
   938           0,
       
   939           0,
       
   940           (triggers_exist & TRIGGER_AFTER)!=0 ? newIdx : -1,
       
   941           appendFlag
       
   942        );
       
   943     }
       
   944   }
       
   945 
       
   946   /* Update the count of rows that are inserted
       
   947   */
       
   948   if( (db->flags & SQLITE_CountRows)!=0 ){
       
   949     sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
       
   950   }
       
   951 
       
   952   if( triggers_exist ){
       
   953     /* Code AFTER triggers */
       
   954     if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_AFTER, pTab,
       
   955           newIdx, -1, onError, endOfLoop, 0, 0) ){
       
   956       goto insert_cleanup;
       
   957     }
       
   958   }
       
   959 
       
   960   /* The bottom of the main insertion loop, if the data source
       
   961   ** is a SELECT statement.
       
   962   */
       
   963   sqlite3VdbeResolveLabel(v, endOfLoop);
       
   964   if( useTempTable ){
       
   965     sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont);
       
   966     sqlite3VdbeJumpHere(v, addrInsTop);
       
   967     sqlite3VdbeAddOp1(v, OP_Close, srcTab);
       
   968   }else if( pSelect ){
       
   969     sqlite3VdbeAddOp2(v, OP_Goto, 0, addrCont);
       
   970     sqlite3VdbeJumpHere(v, addrInsTop);
       
   971   }
       
   972 
       
   973   if( !IsVirtual(pTab) && !isView ){
       
   974     /* Close all tables opened */
       
   975     sqlite3VdbeAddOp1(v, OP_Close, baseCur);
       
   976     for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
       
   977       sqlite3VdbeAddOp1(v, OP_Close, idx+baseCur);
       
   978     }
       
   979   }
       
   980 
       
   981   /* Update the sqlite_sequence table by storing the content of the
       
   982   ** counter value in memory regAutoinc back into the sqlite_sequence
       
   983   ** table.
       
   984   */
       
   985   autoIncEnd(pParse, iDb, pTab, regAutoinc);
       
   986 
       
   987   /*
       
   988   ** Return the number of rows inserted. If this routine is 
       
   989   ** generating code because of a call to sqlite3NestedParse(), do not
       
   990   ** invoke the callback function.
       
   991   */
       
   992   if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){
       
   993     sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
       
   994     sqlite3VdbeSetNumCols(v, 1);
       
   995     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", P4_STATIC);
       
   996   }
       
   997 
       
   998 insert_cleanup:
       
   999   sqlite3SrcListDelete(db, pTabList);
       
  1000   sqlite3ExprListDelete(db, pList);
       
  1001   sqlite3SelectDelete(db, pSelect);
       
  1002   sqlite3IdListDelete(db, pColumn);
       
  1003   sqlite3DbFree(db, aRegIdx);
       
  1004 }
       
  1005 
       
  1006 /*
       
  1007 ** Generate code to do constraint checks prior to an INSERT or an UPDATE.
       
  1008 **
       
  1009 ** The input is a range of consecutive registers as follows:
       
  1010 **
       
  1011 **    1.  The rowid of the row to be updated before the update.  This
       
  1012 **        value is omitted unless we are doing an UPDATE that involves a
       
  1013 **        change to the record number or writing to a virtual table.
       
  1014 **
       
  1015 **    2.  The rowid of the row after the update.
       
  1016 **
       
  1017 **    3.  The data in the first column of the entry after the update.
       
  1018 **
       
  1019 **    i.  Data from middle columns...
       
  1020 **
       
  1021 **    N.  The data in the last column of the entry after the update.
       
  1022 **
       
  1023 ** The regRowid parameter is the index of the register containing (2).
       
  1024 **
       
  1025 ** The old rowid shown as entry (1) above is omitted unless both isUpdate
       
  1026 ** and rowidChng are 1.  isUpdate is true for UPDATEs and false for
       
  1027 ** INSERTs.  RowidChng means that the new rowid is explicitly specified by
       
  1028 ** the update or insert statement.  If rowidChng is false, it means that
       
  1029 ** the rowid is computed automatically in an insert or that the rowid value
       
  1030 ** is not modified by the update.
       
  1031 **
       
  1032 ** The code generated by this routine store new index entries into
       
  1033 ** registers identified by aRegIdx[].  No index entry is created for
       
  1034 ** indices where aRegIdx[i]==0.  The order of indices in aRegIdx[] is
       
  1035 ** the same as the order of indices on the linked list of indices
       
  1036 ** attached to the table.
       
  1037 **
       
  1038 ** This routine also generates code to check constraints.  NOT NULL,
       
  1039 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
       
  1040 ** then the appropriate action is performed.  There are five possible
       
  1041 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
       
  1042 **
       
  1043 **  Constraint type  Action       What Happens
       
  1044 **  ---------------  ----------   ----------------------------------------
       
  1045 **  any              ROLLBACK     The current transaction is rolled back and
       
  1046 **                                sqlite3_exec() returns immediately with a
       
  1047 **                                return code of SQLITE_CONSTRAINT.
       
  1048 **
       
  1049 **  any              ABORT        Back out changes from the current command
       
  1050 **                                only (do not do a complete rollback) then
       
  1051 **                                cause sqlite3_exec() to return immediately
       
  1052 **                                with SQLITE_CONSTRAINT.
       
  1053 **
       
  1054 **  any              FAIL         Sqlite_exec() returns immediately with a
       
  1055 **                                return code of SQLITE_CONSTRAINT.  The
       
  1056 **                                transaction is not rolled back and any
       
  1057 **                                prior changes are retained.
       
  1058 **
       
  1059 **  any              IGNORE       The record number and data is popped from
       
  1060 **                                the stack and there is an immediate jump
       
  1061 **                                to label ignoreDest.
       
  1062 **
       
  1063 **  NOT NULL         REPLACE      The NULL value is replace by the default
       
  1064 **                                value for that column.  If the default value
       
  1065 **                                is NULL, the action is the same as ABORT.
       
  1066 **
       
  1067 **  UNIQUE           REPLACE      The other row that conflicts with the row
       
  1068 **                                being inserted is removed.
       
  1069 **
       
  1070 **  CHECK            REPLACE      Illegal.  The results in an exception.
       
  1071 **
       
  1072 ** Which action to take is determined by the overrideError parameter.
       
  1073 ** Or if overrideError==OE_Default, then the pParse->onError parameter
       
  1074 ** is used.  Or if pParse->onError==OE_Default then the onError value
       
  1075 ** for the constraint is used.
       
  1076 **
       
  1077 ** The calling routine must open a read/write cursor for pTab with
       
  1078 ** cursor number "baseCur".  All indices of pTab must also have open
       
  1079 ** read/write cursors with cursor number baseCur+i for the i-th cursor.
       
  1080 ** Except, if there is no possibility of a REPLACE action then
       
  1081 ** cursors do not need to be open for indices where aRegIdx[i]==0.
       
  1082 */
       
  1083 void sqlite3GenerateConstraintChecks(
       
  1084   Parse *pParse,      /* The parser context */
       
  1085   Table *pTab,        /* the table into which we are inserting */
       
  1086   int baseCur,        /* Index of a read/write cursor pointing at pTab */
       
  1087   int regRowid,       /* Index of the range of input registers */
       
  1088   int *aRegIdx,       /* Register used by each index.  0 for unused indices */
       
  1089   int rowidChng,      /* True if the rowid might collide with existing entry */
       
  1090   int isUpdate,       /* True for UPDATE, False for INSERT */
       
  1091   int overrideError,  /* Override onError to this if not OE_Default */
       
  1092   int ignoreDest      /* Jump to this label on an OE_Ignore resolution */
       
  1093 ){
       
  1094   int i;
       
  1095   Vdbe *v;
       
  1096   int nCol;
       
  1097   int onError;
       
  1098   int j1, j2, j3;     /* Addresses of jump instructions */
       
  1099   int regData;        /* Register containing first data column */
       
  1100   int iCur;
       
  1101   Index *pIdx;
       
  1102   int seenReplace = 0;
       
  1103   int hasTwoRowids = (isUpdate && rowidChng);
       
  1104 
       
  1105   v = sqlite3GetVdbe(pParse);
       
  1106   assert( v!=0 );
       
  1107   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
       
  1108   nCol = pTab->nCol;
       
  1109   regData = regRowid + 1;
       
  1110 
       
  1111 
       
  1112   /* Test all NOT NULL constraints.
       
  1113   */
       
  1114   for(i=0; i<nCol; i++){
       
  1115     if( i==pTab->iPKey ){
       
  1116       continue;
       
  1117     }
       
  1118     onError = pTab->aCol[i].notNull;
       
  1119     if( onError==OE_None ) continue;
       
  1120     if( overrideError!=OE_Default ){
       
  1121       onError = overrideError;
       
  1122     }else if( onError==OE_Default ){
       
  1123       onError = OE_Abort;
       
  1124     }
       
  1125     if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
       
  1126       onError = OE_Abort;
       
  1127     }
       
  1128     j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regData+i);
       
  1129     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
       
  1130         || onError==OE_Ignore || onError==OE_Replace );
       
  1131     switch( onError ){
       
  1132       case OE_Rollback:
       
  1133       case OE_Abort:
       
  1134       case OE_Fail: {
       
  1135         char *zMsg;
       
  1136         sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_CONSTRAINT, onError);
       
  1137         zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
       
  1138                               pTab->zName, pTab->aCol[i].zName);
       
  1139         sqlite3VdbeChangeP4(v, -1, zMsg, P4_DYNAMIC);
       
  1140         break;
       
  1141       }
       
  1142       case OE_Ignore: {
       
  1143         sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
       
  1144         break;
       
  1145       }
       
  1146       case OE_Replace: {
       
  1147         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
       
  1148         break;
       
  1149       }
       
  1150     }
       
  1151     sqlite3VdbeJumpHere(v, j1);
       
  1152   }
       
  1153 
       
  1154   /* Test all CHECK constraints
       
  1155   */
       
  1156 #ifndef SQLITE_OMIT_CHECK
       
  1157   if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){
       
  1158     int allOk = sqlite3VdbeMakeLabel(v);
       
  1159     pParse->ckBase = regData;
       
  1160     sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLITE_JUMPIFNULL);
       
  1161     onError = overrideError!=OE_Default ? overrideError : OE_Abort;
       
  1162     if( onError==OE_Ignore ){
       
  1163       sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
       
  1164     }else{
       
  1165       sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_CONSTRAINT, onError);
       
  1166     }
       
  1167     sqlite3VdbeResolveLabel(v, allOk);
       
  1168   }
       
  1169 #endif /* !defined(SQLITE_OMIT_CHECK) */
       
  1170 
       
  1171   /* If we have an INTEGER PRIMARY KEY, make sure the primary key
       
  1172   ** of the new record does not previously exist.  Except, if this
       
  1173   ** is an UPDATE and the primary key is not changing, that is OK.
       
  1174   */
       
  1175   if( rowidChng ){
       
  1176     onError = pTab->keyConf;
       
  1177     if( overrideError!=OE_Default ){
       
  1178       onError = overrideError;
       
  1179     }else if( onError==OE_Default ){
       
  1180       onError = OE_Abort;
       
  1181     }
       
  1182     
       
  1183     if( onError!=OE_Replace || pTab->pIndex ){
       
  1184       if( isUpdate ){
       
  1185         j2 = sqlite3VdbeAddOp3(v, OP_Eq, regRowid, 0, regRowid-1);
       
  1186       }
       
  1187       j3 = sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
       
  1188       switch( onError ){
       
  1189         default: {
       
  1190           onError = OE_Abort;
       
  1191           /* Fall thru into the next case */
       
  1192         }
       
  1193         case OE_Rollback:
       
  1194         case OE_Abort:
       
  1195         case OE_Fail: {
       
  1196           sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0,
       
  1197                            "PRIMARY KEY must be unique", P4_STATIC);
       
  1198           break;
       
  1199         }
       
  1200         case OE_Replace: {
       
  1201           sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
       
  1202           seenReplace = 1;
       
  1203           break;
       
  1204         }
       
  1205         case OE_Ignore: {
       
  1206           assert( seenReplace==0 );
       
  1207           sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
       
  1208           break;
       
  1209         }
       
  1210       }
       
  1211       sqlite3VdbeJumpHere(v, j3);
       
  1212       if( isUpdate ){
       
  1213         sqlite3VdbeJumpHere(v, j2);
       
  1214       }
       
  1215     }
       
  1216   }
       
  1217 
       
  1218   /* Test all UNIQUE constraints by creating entries for each UNIQUE
       
  1219   ** index and making sure that duplicate entries do not already exist.
       
  1220   ** Add the new records to the indices as we go.
       
  1221   */
       
  1222   for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
       
  1223     int regIdx;
       
  1224     int regR;
       
  1225 
       
  1226     if( aRegIdx[iCur]==0 ) continue;  /* Skip unused indices */
       
  1227 
       
  1228     /* Create a key for accessing the index entry */
       
  1229     regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
       
  1230     for(i=0; i<pIdx->nColumn; i++){
       
  1231       int idx = pIdx->aiColumn[i];
       
  1232       if( idx==pTab->iPKey ){
       
  1233         sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
       
  1234       }else{
       
  1235         sqlite3VdbeAddOp2(v, OP_SCopy, regData+idx, regIdx+i);
       
  1236       }
       
  1237     }
       
  1238     sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
       
  1239     sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn+1, aRegIdx[iCur]);
       
  1240     sqlite3IndexAffinityStr(v, pIdx);
       
  1241     sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn+1);
       
  1242     sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
       
  1243 
       
  1244     /* Find out what action to take in case there is an indexing conflict */
       
  1245     onError = pIdx->onError;
       
  1246     if( onError==OE_None ) continue;  /* pIdx is not a UNIQUE index */
       
  1247     if( overrideError!=OE_Default ){
       
  1248       onError = overrideError;
       
  1249     }else if( onError==OE_Default ){
       
  1250       onError = OE_Abort;
       
  1251     }
       
  1252     if( seenReplace ){
       
  1253       if( onError==OE_Ignore ) onError = OE_Replace;
       
  1254       else if( onError==OE_Fail ) onError = OE_Abort;
       
  1255     }
       
  1256     
       
  1257 
       
  1258     /* Check to see if the new index entry will be unique */
       
  1259     j2 = sqlite3VdbeAddOp3(v, OP_IsNull, regIdx, 0, pIdx->nColumn);
       
  1260     regR = sqlite3GetTempReg(pParse);
       
  1261     sqlite3VdbeAddOp2(v, OP_SCopy, regRowid-hasTwoRowids, regR);
       
  1262     j3 = sqlite3VdbeAddOp4(v, OP_IsUnique, baseCur+iCur+1, 0,
       
  1263                            regR, SQLITE_INT_TO_PTR(aRegIdx[iCur]),
       
  1264                            P4_INT32);
       
  1265 
       
  1266     /* Generate code that executes if the new index entry is not unique */
       
  1267     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
       
  1268         || onError==OE_Ignore || onError==OE_Replace );
       
  1269     switch( onError ){
       
  1270       case OE_Rollback:
       
  1271       case OE_Abort:
       
  1272       case OE_Fail: {
       
  1273         int j, n1, n2;
       
  1274         char zErrMsg[200];
       
  1275         sqlite3_snprintf(sizeof(zErrMsg), zErrMsg,
       
  1276                          pIdx->nColumn>1 ? "columns " : "column ");
       
  1277         n1 = strlen(zErrMsg);
       
  1278         for(j=0; j<pIdx->nColumn && n1<sizeof(zErrMsg)-30; j++){
       
  1279           char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
       
  1280           n2 = strlen(zCol);
       
  1281           if( j>0 ){
       
  1282             sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], ", ");
       
  1283             n1 += 2;
       
  1284           }
       
  1285           if( n1+n2>sizeof(zErrMsg)-30 ){
       
  1286             sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], "...");
       
  1287             n1 += 3;
       
  1288             break;
       
  1289           }else{
       
  1290             sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], "%s", zCol);
       
  1291             n1 += n2;
       
  1292           }
       
  1293         }
       
  1294         sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], 
       
  1295             pIdx->nColumn>1 ? " are not unique" : " is not unique");
       
  1296         sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0, zErrMsg,0);
       
  1297         break;
       
  1298       }
       
  1299       case OE_Ignore: {
       
  1300         assert( seenReplace==0 );
       
  1301         sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
       
  1302         break;
       
  1303       }
       
  1304       case OE_Replace: {
       
  1305         sqlite3GenerateRowDelete(pParse, pTab, baseCur, regR, 0);
       
  1306         seenReplace = 1;
       
  1307         break;
       
  1308       }
       
  1309     }
       
  1310     sqlite3VdbeJumpHere(v, j2);
       
  1311     sqlite3VdbeJumpHere(v, j3);
       
  1312     sqlite3ReleaseTempReg(pParse, regR);
       
  1313   }
       
  1314 }
       
  1315 
       
  1316 /*
       
  1317 ** This routine generates code to finish the INSERT or UPDATE operation
       
  1318 ** that was started by a prior call to sqlite3GenerateConstraintChecks.
       
  1319 ** A consecutive range of registers starting at regRowid contains the
       
  1320 ** rowid and the content to be inserted.
       
  1321 **
       
  1322 ** The arguments to this routine should be the same as the first six
       
  1323 ** arguments to sqlite3GenerateConstraintChecks.
       
  1324 */
       
  1325 void sqlite3CompleteInsertion(
       
  1326   Parse *pParse,      /* The parser context */
       
  1327   Table *pTab,        /* the table into which we are inserting */
       
  1328   int baseCur,        /* Index of a read/write cursor pointing at pTab */
       
  1329   int regRowid,       /* Range of content */
       
  1330   int *aRegIdx,       /* Register used by each index.  0 for unused indices */
       
  1331   int rowidChng,      /* True if the record number will change */
       
  1332   int isUpdate,       /* True for UPDATE, False for INSERT */
       
  1333   int newIdx,         /* Index of NEW table for triggers.  -1 if none */
       
  1334   int appendBias      /* True if this is likely to be an append */
       
  1335 ){
       
  1336   int i;
       
  1337   Vdbe *v;
       
  1338   int nIdx;
       
  1339   Index *pIdx;
       
  1340   int pik_flags;
       
  1341   int regData;
       
  1342   int regRec;
       
  1343 
       
  1344   v = sqlite3GetVdbe(pParse);
       
  1345   assert( v!=0 );
       
  1346   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
       
  1347   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
       
  1348   for(i=nIdx-1; i>=0; i--){
       
  1349     if( aRegIdx[i]==0 ) continue;
       
  1350     sqlite3VdbeAddOp2(v, OP_IdxInsert, baseCur+i+1, aRegIdx[i]);
       
  1351   }
       
  1352   regData = regRowid + 1;
       
  1353   regRec = sqlite3GetTempReg(pParse);
       
  1354   sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
       
  1355   sqlite3TableAffinityStr(v, pTab);
       
  1356   sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
       
  1357 #ifndef SQLITE_OMIT_TRIGGER
       
  1358   if( newIdx>=0 ){
       
  1359     sqlite3VdbeAddOp3(v, OP_Insert, newIdx, regRec, regRowid);
       
  1360   }
       
  1361 #endif
       
  1362   if( pParse->nested ){
       
  1363     pik_flags = 0;
       
  1364   }else{
       
  1365     pik_flags = OPFLAG_NCHANGE;
       
  1366     pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID);
       
  1367   }
       
  1368   if( appendBias ){
       
  1369     pik_flags |= OPFLAG_APPEND;
       
  1370   }
       
  1371   sqlite3VdbeAddOp3(v, OP_Insert, baseCur, regRec, regRowid);
       
  1372   if( !pParse->nested ){
       
  1373     sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
       
  1374   }
       
  1375   sqlite3VdbeChangeP5(v, pik_flags);
       
  1376 }
       
  1377 
       
  1378 /*
       
  1379 ** Generate code that will open cursors for a table and for all
       
  1380 ** indices of that table.  The "baseCur" parameter is the cursor number used
       
  1381 ** for the table.  Indices are opened on subsequent cursors.
       
  1382 **
       
  1383 ** Return the number of indices on the table.
       
  1384 */
       
  1385 int sqlite3OpenTableAndIndices(
       
  1386   Parse *pParse,   /* Parsing context */
       
  1387   Table *pTab,     /* Table to be opened */
       
  1388   int baseCur,        /* Cursor number assigned to the table */
       
  1389   int op           /* OP_OpenRead or OP_OpenWrite */
       
  1390 ){
       
  1391   int i;
       
  1392   int iDb;
       
  1393   Index *pIdx;
       
  1394   Vdbe *v;
       
  1395 
       
  1396   if( IsVirtual(pTab) ) return 0;
       
  1397   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
       
  1398   v = sqlite3GetVdbe(pParse);
       
  1399   assert( v!=0 );
       
  1400   sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
       
  1401   for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
       
  1402     KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
       
  1403     assert( pIdx->pSchema==pTab->pSchema );
       
  1404     sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
       
  1405                       (char*)pKey, P4_KEYINFO_HANDOFF);
       
  1406     VdbeComment((v, "%s", pIdx->zName));
       
  1407   }
       
  1408   if( pParse->nTab<=baseCur+i ){
       
  1409     pParse->nTab = baseCur+i;
       
  1410   }
       
  1411   return i-1;
       
  1412 }
       
  1413 
       
  1414 
       
  1415 #ifdef SQLITE_TEST
       
  1416 /*
       
  1417 ** The following global variable is incremented whenever the
       
  1418 ** transfer optimization is used.  This is used for testing
       
  1419 ** purposes only - to make sure the transfer optimization really
       
  1420 ** is happening when it is suppose to.
       
  1421 */
       
  1422 int sqlite3_xferopt_count;
       
  1423 #endif /* SQLITE_TEST */
       
  1424 
       
  1425 
       
  1426 #ifndef SQLITE_OMIT_XFER_OPT
       
  1427 /*
       
  1428 ** Check to collation names to see if they are compatible.
       
  1429 */
       
  1430 static int xferCompatibleCollation(const char *z1, const char *z2){
       
  1431   if( z1==0 ){
       
  1432     return z2==0;
       
  1433   }
       
  1434   if( z2==0 ){
       
  1435     return 0;
       
  1436   }
       
  1437   return sqlite3StrICmp(z1, z2)==0;
       
  1438 }
       
  1439 
       
  1440 
       
  1441 /*
       
  1442 ** Check to see if index pSrc is compatible as a source of data
       
  1443 ** for index pDest in an insert transfer optimization.  The rules
       
  1444 ** for a compatible index:
       
  1445 **
       
  1446 **    *   The index is over the same set of columns
       
  1447 **    *   The same DESC and ASC markings occurs on all columns
       
  1448 **    *   The same onError processing (OE_Abort, OE_Ignore, etc)
       
  1449 **    *   The same collating sequence on each column
       
  1450 */
       
  1451 static int xferCompatibleIndex(Index *pDest, Index *pSrc){
       
  1452   int i;
       
  1453   assert( pDest && pSrc );
       
  1454   assert( pDest->pTable!=pSrc->pTable );
       
  1455   if( pDest->nColumn!=pSrc->nColumn ){
       
  1456     return 0;   /* Different number of columns */
       
  1457   }
       
  1458   if( pDest->onError!=pSrc->onError ){
       
  1459     return 0;   /* Different conflict resolution strategies */
       
  1460   }
       
  1461   for(i=0; i<pSrc->nColumn; i++){
       
  1462     if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
       
  1463       return 0;   /* Different columns indexed */
       
  1464     }
       
  1465     if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
       
  1466       return 0;   /* Different sort orders */
       
  1467     }
       
  1468     if( pSrc->azColl[i]!=pDest->azColl[i] ){
       
  1469       return 0;   /* Different collating sequences */
       
  1470     }
       
  1471   }
       
  1472 
       
  1473   /* If no test above fails then the indices must be compatible */
       
  1474   return 1;
       
  1475 }
       
  1476 
       
  1477 /*
       
  1478 ** Attempt the transfer optimization on INSERTs of the form
       
  1479 **
       
  1480 **     INSERT INTO tab1 SELECT * FROM tab2;
       
  1481 **
       
  1482 ** This optimization is only attempted if
       
  1483 **
       
  1484 **    (1)  tab1 and tab2 have identical schemas including all the
       
  1485 **         same indices and constraints
       
  1486 **
       
  1487 **    (2)  tab1 and tab2 are different tables
       
  1488 **
       
  1489 **    (3)  There must be no triggers on tab1
       
  1490 **
       
  1491 **    (4)  The result set of the SELECT statement is "*"
       
  1492 **
       
  1493 **    (5)  The SELECT statement has no WHERE, HAVING, ORDER BY, GROUP BY,
       
  1494 **         or LIMIT clause.
       
  1495 **
       
  1496 **    (6)  The SELECT statement is a simple (not a compound) select that
       
  1497 **         contains only tab2 in its FROM clause
       
  1498 **
       
  1499 ** This method for implementing the INSERT transfers raw records from
       
  1500 ** tab2 over to tab1.  The columns are not decoded.  Raw records from
       
  1501 ** the indices of tab2 are transfered to tab1 as well.  In so doing,
       
  1502 ** the resulting tab1 has much less fragmentation.
       
  1503 **
       
  1504 ** This routine returns TRUE if the optimization is attempted.  If any
       
  1505 ** of the conditions above fail so that the optimization should not
       
  1506 ** be attempted, then this routine returns FALSE.
       
  1507 */
       
  1508 static int xferOptimization(
       
  1509   Parse *pParse,        /* Parser context */
       
  1510   Table *pDest,         /* The table we are inserting into */
       
  1511   Select *pSelect,      /* A SELECT statement to use as the data source */
       
  1512   int onError,          /* How to handle constraint errors */
       
  1513   int iDbDest           /* The database of pDest */
       
  1514 ){
       
  1515   ExprList *pEList;                /* The result set of the SELECT */
       
  1516   Table *pSrc;                     /* The table in the FROM clause of SELECT */
       
  1517   Index *pSrcIdx, *pDestIdx;       /* Source and destination indices */
       
  1518   struct SrcList_item *pItem;      /* An element of pSelect->pSrc */
       
  1519   int i;                           /* Loop counter */
       
  1520   int iDbSrc;                      /* The database of pSrc */
       
  1521   int iSrc, iDest;                 /* Cursors from source and destination */
       
  1522   int addr1, addr2;                /* Loop addresses */
       
  1523   int emptyDestTest;               /* Address of test for empty pDest */
       
  1524   int emptySrcTest;                /* Address of test for empty pSrc */
       
  1525   Vdbe *v;                         /* The VDBE we are building */
       
  1526   KeyInfo *pKey;                   /* Key information for an index */
       
  1527   int regAutoinc;                  /* Memory register used by AUTOINC */
       
  1528   int destHasUniqueIdx = 0;        /* True if pDest has a UNIQUE index */
       
  1529   int regData, regRowid;           /* Registers holding data and rowid */
       
  1530 
       
  1531   if( pSelect==0 ){
       
  1532     return 0;   /* Must be of the form  INSERT INTO ... SELECT ... */
       
  1533   }
       
  1534   if( pDest->pTrigger ){
       
  1535     return 0;   /* tab1 must not have triggers */
       
  1536   }
       
  1537 #ifndef SQLITE_OMIT_VIRTUALTABLE
       
  1538   if( pDest->isVirtual ){
       
  1539     return 0;   /* tab1 must not be a virtual table */
       
  1540   }
       
  1541 #endif
       
  1542   if( onError==OE_Default ){
       
  1543     onError = OE_Abort;
       
  1544   }
       
  1545   if( onError!=OE_Abort && onError!=OE_Rollback ){
       
  1546     return 0;   /* Cannot do OR REPLACE or OR IGNORE or OR FAIL */
       
  1547   }
       
  1548   assert(pSelect->pSrc);   /* allocated even if there is no FROM clause */
       
  1549   if( pSelect->pSrc->nSrc!=1 ){
       
  1550     return 0;   /* FROM clause must have exactly one term */
       
  1551   }
       
  1552   if( pSelect->pSrc->a[0].pSelect ){
       
  1553     return 0;   /* FROM clause cannot contain a subquery */
       
  1554   }
       
  1555   if( pSelect->pWhere ){
       
  1556     return 0;   /* SELECT may not have a WHERE clause */
       
  1557   }
       
  1558   if( pSelect->pOrderBy ){
       
  1559     return 0;   /* SELECT may not have an ORDER BY clause */
       
  1560   }
       
  1561   /* Do not need to test for a HAVING clause.  If HAVING is present but
       
  1562   ** there is no ORDER BY, we will get an error. */
       
  1563   if( pSelect->pGroupBy ){
       
  1564     return 0;   /* SELECT may not have a GROUP BY clause */
       
  1565   }
       
  1566   if( pSelect->pLimit ){
       
  1567     return 0;   /* SELECT may not have a LIMIT clause */
       
  1568   }
       
  1569   assert( pSelect->pOffset==0 );  /* Must be so if pLimit==0 */
       
  1570   if( pSelect->pPrior ){
       
  1571     return 0;   /* SELECT may not be a compound query */
       
  1572   }
       
  1573   if( pSelect->isDistinct ){
       
  1574     return 0;   /* SELECT may not be DISTINCT */
       
  1575   }
       
  1576   pEList = pSelect->pEList;
       
  1577   assert( pEList!=0 );
       
  1578   if( pEList->nExpr!=1 ){
       
  1579     return 0;   /* The result set must have exactly one column */
       
  1580   }
       
  1581   assert( pEList->a[0].pExpr );
       
  1582   if( pEList->a[0].pExpr->op!=TK_ALL ){
       
  1583     return 0;   /* The result set must be the special operator "*" */
       
  1584   }
       
  1585 
       
  1586   /* At this point we have established that the statement is of the
       
  1587   ** correct syntactic form to participate in this optimization.  Now
       
  1588   ** we have to check the semantics.
       
  1589   */
       
  1590   pItem = pSelect->pSrc->a;
       
  1591   pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
       
  1592   if( pSrc==0 ){
       
  1593     return 0;   /* FROM clause does not contain a real table */
       
  1594   }
       
  1595   if( pSrc==pDest ){
       
  1596     return 0;   /* tab1 and tab2 may not be the same table */
       
  1597   }
       
  1598 #ifndef SQLITE_OMIT_VIRTUALTABLE
       
  1599   if( pSrc->isVirtual ){
       
  1600     return 0;   /* tab2 must not be a virtual table */
       
  1601   }
       
  1602 #endif
       
  1603   if( pSrc->pSelect ){
       
  1604     return 0;   /* tab2 may not be a view */
       
  1605   }
       
  1606   if( pDest->nCol!=pSrc->nCol ){
       
  1607     return 0;   /* Number of columns must be the same in tab1 and tab2 */
       
  1608   }
       
  1609   if( pDest->iPKey!=pSrc->iPKey ){
       
  1610     return 0;   /* Both tables must have the same INTEGER PRIMARY KEY */
       
  1611   }
       
  1612   for(i=0; i<pDest->nCol; i++){
       
  1613     if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
       
  1614       return 0;    /* Affinity must be the same on all columns */
       
  1615     }
       
  1616     if( !xferCompatibleCollation(pDest->aCol[i].zColl, pSrc->aCol[i].zColl) ){
       
  1617       return 0;    /* Collating sequence must be the same on all columns */
       
  1618     }
       
  1619     if( pDest->aCol[i].notNull && !pSrc->aCol[i].notNull ){
       
  1620       return 0;    /* tab2 must be NOT NULL if tab1 is */
       
  1621     }
       
  1622   }
       
  1623   for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
       
  1624     if( pDestIdx->onError!=OE_None ){
       
  1625       destHasUniqueIdx = 1;
       
  1626     }
       
  1627     for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
       
  1628       if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
       
  1629     }
       
  1630     if( pSrcIdx==0 ){
       
  1631       return 0;    /* pDestIdx has no corresponding index in pSrc */
       
  1632     }
       
  1633   }
       
  1634 #ifndef SQLITE_OMIT_CHECK
       
  1635   if( pDest->pCheck && !sqlite3ExprCompare(pSrc->pCheck, pDest->pCheck) ){
       
  1636     return 0;   /* Tables have different CHECK constraints.  Ticket #2252 */
       
  1637   }
       
  1638 #endif
       
  1639 
       
  1640   /* If we get this far, it means either:
       
  1641   **
       
  1642   **    *   We can always do the transfer if the table contains an
       
  1643   **        an integer primary key
       
  1644   **
       
  1645   **    *   We can conditionally do the transfer if the destination
       
  1646   **        table is empty.
       
  1647   */
       
  1648 #ifdef SQLITE_TEST
       
  1649   sqlite3_xferopt_count++;
       
  1650 #endif
       
  1651   iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema);
       
  1652   v = sqlite3GetVdbe(pParse);
       
  1653   sqlite3CodeVerifySchema(pParse, iDbSrc);
       
  1654   iSrc = pParse->nTab++;
       
  1655   iDest = pParse->nTab++;
       
  1656   regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
       
  1657   sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
       
  1658   if( (pDest->iPKey<0 && pDest->pIndex!=0) || destHasUniqueIdx ){
       
  1659     /* If tables do not have an INTEGER PRIMARY KEY and there
       
  1660     ** are indices to be copied and the destination is not empty,
       
  1661     ** we have to disallow the transfer optimization because the
       
  1662     ** the rowids might change which will mess up indexing.
       
  1663     **
       
  1664     ** Or if the destination has a UNIQUE index and is not empty,
       
  1665     ** we also disallow the transfer optimization because we cannot
       
  1666     ** insure that all entries in the union of DEST and SRC will be
       
  1667     ** unique.
       
  1668     */
       
  1669     addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0);
       
  1670     emptyDestTest = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
       
  1671     sqlite3VdbeJumpHere(v, addr1);
       
  1672   }else{
       
  1673     emptyDestTest = 0;
       
  1674   }
       
  1675   sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
       
  1676   emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
       
  1677   regData = sqlite3GetTempReg(pParse);
       
  1678   regRowid = sqlite3GetTempReg(pParse);
       
  1679   if( pDest->iPKey>=0 ){
       
  1680     addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
       
  1681     addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
       
  1682     sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0,
       
  1683                       "PRIMARY KEY must be unique", P4_STATIC);
       
  1684     sqlite3VdbeJumpHere(v, addr2);
       
  1685     autoIncStep(pParse, regAutoinc, regRowid);
       
  1686   }else if( pDest->pIndex==0 ){
       
  1687     addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
       
  1688   }else{
       
  1689     addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
       
  1690     assert( pDest->autoInc==0 );
       
  1691   }
       
  1692   sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
       
  1693   sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
       
  1694   sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
       
  1695   sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
       
  1696   sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1);
       
  1697   autoIncEnd(pParse, iDbDest, pDest, regAutoinc);
       
  1698   for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
       
  1699     for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
       
  1700       if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
       
  1701     }
       
  1702     assert( pSrcIdx );
       
  1703     sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
       
  1704     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
       
  1705     pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
       
  1706     sqlite3VdbeAddOp4(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc,
       
  1707                       (char*)pKey, P4_KEYINFO_HANDOFF);
       
  1708     VdbeComment((v, "%s", pSrcIdx->zName));
       
  1709     pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
       
  1710     sqlite3VdbeAddOp4(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest,
       
  1711                       (char*)pKey, P4_KEYINFO_HANDOFF);
       
  1712     VdbeComment((v, "%s", pDestIdx->zName));
       
  1713     addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
       
  1714     sqlite3VdbeAddOp2(v, OP_RowKey, iSrc, regData);
       
  1715     sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
       
  1716     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1);
       
  1717     sqlite3VdbeJumpHere(v, addr1);
       
  1718   }
       
  1719   sqlite3VdbeJumpHere(v, emptySrcTest);
       
  1720   sqlite3ReleaseTempReg(pParse, regRowid);
       
  1721   sqlite3ReleaseTempReg(pParse, regData);
       
  1722   sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
       
  1723   sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
       
  1724   if( emptyDestTest ){
       
  1725     sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
       
  1726     sqlite3VdbeJumpHere(v, emptyDestTest);
       
  1727     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
       
  1728     return 0;
       
  1729   }else{
       
  1730     return 1;
       
  1731   }
       
  1732 }
       
  1733 #endif /* SQLITE_OMIT_XFER_OPT */
       
  1734 
       
  1735 /* Make sure "isView" gets undefined in case this file becomes part of
       
  1736 ** the amalgamation - so that subsequent files do not see isView as a
       
  1737 ** macro. */
       
  1738 #undef isView