insert.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:58k
源码类别:

数据库系统

开发平台:

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