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: {