blob: d03fff7019d8a5509539b6780a9550fb56427ca2 [file] [log] [blame]
drhcce7d172000-05-31 15:34:51 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhcce7d172000-05-31 15:34:51 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhcce7d172000-05-31 15:34:51 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drhcce7d172000-05-31 15:34:51 +000010**
11*************************************************************************
12** This file contains C code routines that are called by the parser
drhb19a2bc2001-09-16 00:13:26 +000013** to handle INSERT statements in SQLite.
drhcce7d172000-05-31 15:34:51 +000014**
drh836faa42003-01-11 13:30:57 +000015** $Id: insert.c,v 1.68 2003/01/11 13:30:58 drh Exp $
drhcce7d172000-05-31 15:34:51 +000016*/
17#include "sqliteInt.h"
18
19/*
drh1ccde152000-06-17 13:12:39 +000020** This routine is call to handle SQL of the following forms:
drhcce7d172000-05-31 15:34:51 +000021**
22** insert into TABLE (IDLIST) values(EXPRLIST)
drh1ccde152000-06-17 13:12:39 +000023** insert into TABLE (IDLIST) select
drhcce7d172000-05-31 15:34:51 +000024**
drh1ccde152000-06-17 13:12:39 +000025** The IDLIST following the table name is always optional. If omitted,
26** then a list of all columns for the table is substituted. The IDLIST
drh967e8b72000-06-21 13:59:10 +000027** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted.
drh1ccde152000-06-17 13:12:39 +000028**
29** The pList parameter holds EXPRLIST in the first form of the INSERT
30** statement above, and pSelect is NULL. For the second form, pList is
31** NULL and pSelect is a pointer to the select statement used to generate
32** data for the insert.
drh142e30d2002-08-28 03:00:58 +000033**
34** The code generated follows one of three templates. For a simple
35** select with data coming from a VALUES clause, the code executes
36** once straight down through. The template looks like this:
37**
38** open write cursor to <table> and its indices
39** puts VALUES clause expressions onto the stack
40** write the resulting record into <table>
41** cleanup
42**
43** If the statement is of the form
44**
45** INSERT INTO <table> SELECT ...
46**
47** And the SELECT clause does not read from <table> at any time, then
48** the generated code follows this template:
49**
50** goto B
51** A: setup for the SELECT
52** loop over the tables in the SELECT
53** gosub C
54** end loop
55** cleanup after the SELECT
56** goto D
57** B: open write cursor to <table> and its indices
58** goto A
59** C: insert the select result into <table>
60** return
61** D: cleanup
62**
63** The third template is used if the insert statement takes its
64** values from a SELECT but the data is being inserted into a table
65** that is also read as part of the SELECT. In the third form,
66** we have to use a intermediate table to store the results of
67** the select. The template is like this:
68**
69** goto B
70** A: setup for the SELECT
71** loop over the tables in the SELECT
72** gosub C
73** end loop
74** cleanup after the SELECT
75** goto D
76** C: insert the select result into the intermediate table
77** return
78** B: open a cursor to an intermediate table
79** goto A
80** D: open write cursor to <table> and its indices
81** loop over the intermediate table
82** transfer values form intermediate table into <table>
83** end the loop
84** cleanup
drhcce7d172000-05-31 15:34:51 +000085*/
86void sqliteInsert(
87 Parse *pParse, /* Parser context */
88 Token *pTableName, /* Name of table into which we are inserting */
89 ExprList *pList, /* List of values to be inserted */
drh5974a302000-06-07 14:42:26 +000090 Select *pSelect, /* A SELECT statement to use as the data source */
drh9cfcf5d2002-01-29 18:41:24 +000091 IdList *pColumn, /* Column names corresponding to IDLIST. */
92 int onError /* How to handle constraint errors */
drhcce7d172000-05-31 15:34:51 +000093){
drh5974a302000-06-07 14:42:26 +000094 Table *pTab; /* The table to insert into */
danielk1977c3f9bad2002-05-15 08:30:12 +000095 char *zTab = 0; /* Name of the table into which we are inserting */
drh5974a302000-06-07 14:42:26 +000096 int i, j, idx; /* Loop counters */
97 Vdbe *v; /* Generate code into this virtual machine */
98 Index *pIdx; /* For looping over indices of the table */
drh967e8b72000-06-21 13:59:10 +000099 int nColumn; /* Number of columns in the data */
drh5974a302000-06-07 14:42:26 +0000100 int base; /* First available cursor */
101 int iCont, iBreak; /* Beginning and end of the loop over srcTab */
drhecdc7532001-09-23 02:35:53 +0000102 sqlite *db; /* The main database structure */
drhf57b3392001-10-08 13:22:32 +0000103 int openOp; /* Opcode used to open cursors */
drh4a324312001-12-21 14:30:42 +0000104 int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
drh0ca3e242002-01-29 23:07:02 +0000105 int endOfLoop; /* Label for the end of the insertion loop */
drh142e30d2002-08-28 03:00:58 +0000106 int useTempTable; /* Store SELECT results in intermediate table */
107 int srcTab; /* Data comes from this temporary cursor if >=0 */
108 int iSelectLoop; /* Address of code that implements the SELECT */
109 int iCleanup; /* Address of the cleanup code */
110 int iInsertBlock; /* Address of the subroutine used to insert data */
111 int iCntMem; /* Memory cell used for the row counter */
drhcce7d172000-05-31 15:34:51 +0000112
danielk1977c3f9bad2002-05-15 08:30:12 +0000113 int row_triggers_exist = 0; /* True if there are FOR EACH ROW triggers */
114 int newIdx = -1;
115
drhdaffd0e2001-04-11 14:28:42 +0000116 if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
drhecdc7532001-09-23 02:35:53 +0000117 db = pParse->db;
drhdaffd0e2001-04-11 14:28:42 +0000118
drh1ccde152000-06-17 13:12:39 +0000119 /* Locate the table into which we will be inserting new information.
120 */
drhcce7d172000-05-31 15:34:51 +0000121 zTab = sqliteTableNameFromToken(pTableName);
drhdaffd0e2001-04-11 14:28:42 +0000122 if( zTab==0 ) goto insert_cleanup;
danielk1977c3f9bad2002-05-15 08:30:12 +0000123 pTab = sqliteFindTable(pParse->db, zTab);
124 if( pTab==0 ){
125 sqliteSetString(&pParse->zErrMsg, "no such table: ", zTab, 0);
126 pParse->nErr++;
127 goto insert_cleanup;
128 }
129
130 /* Ensure that:
131 * (a) the table is not read-only,
132 * (b) that if it is a view then ON INSERT triggers exist
133 */
134 row_triggers_exist =
135 sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT,
drh9adf9ac2002-05-15 11:44:13 +0000136 TK_BEFORE, TK_ROW, 0) ||
danielk1977c3f9bad2002-05-15 08:30:12 +0000137 sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT, TK_AFTER, TK_ROW, 0);
138 if( pTab->readOnly || (pTab->pSelect && !row_triggers_exist) ){
139 sqliteSetString(&pParse->zErrMsg,
140 pTab->pSelect ? "view " : "table ",
141 zTab,
142 " may not be modified", 0);
143 pParse->nErr++;
144 goto insert_cleanup;
145 }
drhcce7d172000-05-31 15:34:51 +0000146 sqliteFree(zTab);
danielk1977c3f9bad2002-05-15 08:30:12 +0000147 zTab = 0;
148
drha76b5df2002-02-23 02:32:10 +0000149 if( pTab==0 ) goto insert_cleanup;
drh1ccde152000-06-17 13:12:39 +0000150
drhf573c992002-07-31 00:32:50 +0000151 /* If pTab is really a view, make sure it has been initialized.
152 */
153 if( pTab->pSelect ){
154 if( sqliteViewGetColumnNames(pParse, pTab) ){
155 goto insert_cleanup;
156 }
157 }
158
drh1ccde152000-06-17 13:12:39 +0000159 /* Allocate a VDBE
160 */
drhd8bc7082000-06-07 23:51:50 +0000161 v = sqliteGetVdbe(pParse);
drh5974a302000-06-07 14:42:26 +0000162 if( v==0 ) goto insert_cleanup;
drhcabb0812002-09-14 13:47:32 +0000163 sqliteBeginWriteOperation(pParse, pSelect || row_triggers_exist,
164 !row_triggers_exist && pTab->isTemp);
drh1ccde152000-06-17 13:12:39 +0000165
danielk1977c3f9bad2002-05-15 08:30:12 +0000166 /* if there are row triggers, allocate a temp table for new.* references. */
danielk1977f29ce552002-05-19 23:43:12 +0000167 if( row_triggers_exist ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000168 newIdx = pParse->nTab++;
danielk1977f29ce552002-05-19 23:43:12 +0000169 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000170
drh1ccde152000-06-17 13:12:39 +0000171 /* Figure out how many columns of data are supplied. If the data
drh142e30d2002-08-28 03:00:58 +0000172 ** is coming from a SELECT statement, then this step also generates
173 ** all the code to implement the SELECT statement and invoke a subroutine
174 ** to process each row of the result. (Template 2.) If the SELECT
175 ** statement uses the the table that is being inserted into, then the
176 ** subroutine is also coded here. That subroutine stores the SELECT
177 ** results in a temporary table. (Template 3.)
drh1ccde152000-06-17 13:12:39 +0000178 */
drh5974a302000-06-07 14:42:26 +0000179 if( pSelect ){
drh142e30d2002-08-28 03:00:58 +0000180 /* Data is coming from a SELECT. Generate code to implement that SELECT
181 */
182 int rc, iInitCode;
183 int opCode;
184 iInitCode = sqliteVdbeAddOp(v, OP_Goto, 0, 0);
185 iSelectLoop = sqliteVdbeCurrentAddr(v);
186 iInsertBlock = sqliteVdbeMakeLabel(v);
187 rc = sqliteSelect(pParse, pSelect, SRT_Subroutine, iInsertBlock, 0,0,0);
drhdaffd0e2001-04-11 14:28:42 +0000188 if( rc || pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
drh142e30d2002-08-28 03:00:58 +0000189 iCleanup = sqliteVdbeMakeLabel(v);
190 sqliteVdbeAddOp(v, OP_Goto, 0, iCleanup);
drh5974a302000-06-07 14:42:26 +0000191 assert( pSelect->pEList );
drh967e8b72000-06-21 13:59:10 +0000192 nColumn = pSelect->pEList->nExpr;
drh142e30d2002-08-28 03:00:58 +0000193
194 /* Set useTempTable to TRUE if the result of the SELECT statement
195 ** should be written into a temporary table. Set to FALSE if each
196 ** row of the SELECT can be written directly into the result table.
197 */
198 opCode = pTab->isTemp ? OP_OpenTemp : OP_Open;
199 useTempTable = row_triggers_exist || sqliteVdbeFindOp(v,opCode,pTab->tnum);
200
201 if( useTempTable ){
202 /* Generate the subroutine that SELECT calls to process each row of
203 ** the result. Store the result in a temporary table
204 */
205 srcTab = pParse->nTab++;
206 sqliteVdbeResolveLabel(v, iInsertBlock);
207 sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0);
208 sqliteVdbeAddOp(v, OP_NewRecno, srcTab, 0);
209 sqliteVdbeAddOp(v, OP_Pull, 1, 0);
210 sqliteVdbeAddOp(v, OP_PutIntKey, srcTab, 0);
211 sqliteVdbeAddOp(v, OP_Return, 0, 0);
212
213 /* The following code runs first because the GOTO at the very top
214 ** of the program jumps to it. Create the temporary table, then jump
215 ** back up and execute the SELECT code above.
216 */
217 sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v));
218 sqliteVdbeAddOp(v, OP_OpenTemp, srcTab, 0);
219 sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop);
220 sqliteVdbeResolveLabel(v, iCleanup);
221 }else{
222 sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v));
223 }
drh5974a302000-06-07 14:42:26 +0000224 }else{
drh142e30d2002-08-28 03:00:58 +0000225 /* This is the case if the data for the INSERT is coming from a VALUES
226 ** clause
227 */
drhad3cab52002-05-24 02:04:32 +0000228 SrcList dummy;
drhdaffd0e2001-04-11 14:28:42 +0000229 assert( pList!=0 );
drh5974a302000-06-07 14:42:26 +0000230 srcTab = -1;
drh142e30d2002-08-28 03:00:58 +0000231 useTempTable = 0;
drh5974a302000-06-07 14:42:26 +0000232 assert( pList );
drh967e8b72000-06-21 13:59:10 +0000233 nColumn = pList->nExpr;
drhad3cab52002-05-24 02:04:32 +0000234 dummy.nSrc = 0;
drhe64e7b22002-02-18 13:56:36 +0000235 for(i=0; i<nColumn; i++){
drh832508b2002-03-02 17:04:07 +0000236 if( sqliteExprResolveIds(pParse, 0, &dummy, 0, pList->a[i].pExpr) ){
drhe64e7b22002-02-18 13:56:36 +0000237 goto insert_cleanup;
238 }
drhb04a5d82002-04-12 03:55:15 +0000239 if( sqliteExprCheck(pParse, pList->a[i].pExpr, 0, 0) ){
240 goto insert_cleanup;
241 }
drhe64e7b22002-02-18 13:56:36 +0000242 }
drh5974a302000-06-07 14:42:26 +0000243 }
drh1ccde152000-06-17 13:12:39 +0000244
245 /* Make sure the number of columns in the source data matches the number
246 ** of columns to be inserted into the table.
247 */
drh967e8b72000-06-21 13:59:10 +0000248 if( pColumn==0 && nColumn!=pTab->nCol ){
drhcce7d172000-05-31 15:34:51 +0000249 char zNum1[30];
250 char zNum2[30];
drh967e8b72000-06-21 13:59:10 +0000251 sprintf(zNum1,"%d", nColumn);
drhcce7d172000-05-31 15:34:51 +0000252 sprintf(zNum2,"%d", pTab->nCol);
253 sqliteSetString(&pParse->zErrMsg, "table ", pTab->zName,
254 " has ", zNum2, " columns but ",
255 zNum1, " values were supplied", 0);
256 pParse->nErr++;
257 goto insert_cleanup;
258 }
drh967e8b72000-06-21 13:59:10 +0000259 if( pColumn!=0 && nColumn!=pColumn->nId ){
drhcce7d172000-05-31 15:34:51 +0000260 char zNum1[30];
261 char zNum2[30];
drh967e8b72000-06-21 13:59:10 +0000262 sprintf(zNum1,"%d", nColumn);
263 sprintf(zNum2,"%d", pColumn->nId);
drhcce7d172000-05-31 15:34:51 +0000264 sqliteSetString(&pParse->zErrMsg, zNum1, " values for ",
265 zNum2, " columns", 0);
266 pParse->nErr++;
267 goto insert_cleanup;
268 }
drh1ccde152000-06-17 13:12:39 +0000269
270 /* If the INSERT statement included an IDLIST term, then make sure
271 ** all elements of the IDLIST really are columns of the table and
272 ** remember the column indices.
drhc8392582001-12-31 02:48:51 +0000273 **
274 ** If the table has an INTEGER PRIMARY KEY column and that column
275 ** is named in the IDLIST, then record in the keyColumn variable
276 ** the index into IDLIST of the primary key column. keyColumn is
277 ** the index of the primary key as it appears in IDLIST, not as
278 ** is appears in the original table. (The index of the primary
279 ** key in the original table is pTab->iPKey.)
drh1ccde152000-06-17 13:12:39 +0000280 */
drh967e8b72000-06-21 13:59:10 +0000281 if( pColumn ){
282 for(i=0; i<pColumn->nId; i++){
283 pColumn->a[i].idx = -1;
drhcce7d172000-05-31 15:34:51 +0000284 }
drh967e8b72000-06-21 13:59:10 +0000285 for(i=0; i<pColumn->nId; i++){
drhcce7d172000-05-31 15:34:51 +0000286 for(j=0; j<pTab->nCol; j++){
drh967e8b72000-06-21 13:59:10 +0000287 if( sqliteStrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
288 pColumn->a[i].idx = j;
drh4a324312001-12-21 14:30:42 +0000289 if( j==pTab->iPKey ){
drh9aa028d2001-12-22 21:48:29 +0000290 keyColumn = i;
drh4a324312001-12-21 14:30:42 +0000291 }
drhcce7d172000-05-31 15:34:51 +0000292 break;
293 }
294 }
295 if( j>=pTab->nCol ){
296 sqliteSetString(&pParse->zErrMsg, "table ", pTab->zName,
drh967e8b72000-06-21 13:59:10 +0000297 " has no column named ", pColumn->a[i].zName, 0);
drhcce7d172000-05-31 15:34:51 +0000298 pParse->nErr++;
299 goto insert_cleanup;
300 }
301 }
302 }
drh1ccde152000-06-17 13:12:39 +0000303
drhaacc5432002-01-06 17:07:40 +0000304 /* If there is no IDLIST term but the table has an integer primary
drhc8392582001-12-31 02:48:51 +0000305 ** key, the set the keyColumn variable to the primary key column index
306 ** in the original table definition.
drh4a324312001-12-21 14:30:42 +0000307 */
308 if( pColumn==0 ){
309 keyColumn = pTab->iPKey;
310 }
311
drh142e30d2002-08-28 03:00:58 +0000312 /* Open the temp table for FOR EACH ROW triggers
313 */
danielk1977f29ce552002-05-19 23:43:12 +0000314 if( row_triggers_exist ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000315 sqliteVdbeAddOp(v, OP_OpenTemp, newIdx, 0);
danielk1977f29ce552002-05-19 23:43:12 +0000316 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000317
drhfeeb1392002-04-09 03:28:01 +0000318 /* Initialize the count of rows to be inserted
319 */
drh142e30d2002-08-28 03:00:58 +0000320 if( db->flags & SQLITE_CountRows ){
321 iCntMem = pParse->nMem++;
322 sqliteVdbeAddOp(v, OP_Integer, 0, 0);
323 sqliteVdbeAddOp(v, OP_MemStore, iCntMem, 1);
drhfeeb1392002-04-09 03:28:01 +0000324 }
325
danielk1977c3f9bad2002-05-15 08:30:12 +0000326 /* Open tables and indices if there are no row triggers */
danielk1977f29ce552002-05-19 23:43:12 +0000327 if( !row_triggers_exist ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000328 base = pParse->nTab;
329 openOp = pTab->isTemp ? OP_OpenWrAux : OP_OpenWrite;
330 sqliteVdbeAddOp(v, openOp, base, pTab->tnum);
331 sqliteVdbeChangeP3(v, -1, pTab->zName, P3_STATIC);
332 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
333 sqliteVdbeAddOp(v, openOp, idx+base, pIdx->tnum);
334 sqliteVdbeChangeP3(v, -1, pIdx->zName, P3_STATIC);
335 }
336 pParse->nTab += idx;
337 }
338
drh142e30d2002-08-28 03:00:58 +0000339 /* If the data source is a temporary table, then we have to create
drh1ccde152000-06-17 13:12:39 +0000340 ** a loop because there might be multiple rows of data. If the data
drh142e30d2002-08-28 03:00:58 +0000341 ** source is a subroutine call from the SELECT statement, then we need
342 ** to launch the SELECT statement processing.
drh1ccde152000-06-17 13:12:39 +0000343 */
drh142e30d2002-08-28 03:00:58 +0000344 if( useTempTable ){
drh5974a302000-06-07 14:42:26 +0000345 iBreak = sqliteVdbeMakeLabel(v);
drh6b563442001-11-07 16:48:26 +0000346 sqliteVdbeAddOp(v, OP_Rewind, srcTab, iBreak);
347 iCont = sqliteVdbeCurrentAddr(v);
drh142e30d2002-08-28 03:00:58 +0000348 }else if( pSelect ){
349 sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop);
350 sqliteVdbeResolveLabel(v, iInsertBlock);
drh5974a302000-06-07 14:42:26 +0000351 }
drh1ccde152000-06-17 13:12:39 +0000352
danielk19776f349032002-06-11 02:25:40 +0000353 endOfLoop = sqliteVdbeMakeLabel(v);
danielk1977f29ce552002-05-19 23:43:12 +0000354 if( row_triggers_exist ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000355
356 /* build the new.* reference row */
357 sqliteVdbeAddOp(v, OP_Integer, 13, 0);
358 for(i=0; i<pTab->nCol; i++){
359 if( pColumn==0 ){
drh9adf9ac2002-05-15 11:44:13 +0000360 j = i;
danielk1977c3f9bad2002-05-15 08:30:12 +0000361 }else{
drh9adf9ac2002-05-15 11:44:13 +0000362 for(j=0; j<pColumn->nId; j++){
363 if( pColumn->a[j].idx==i ) break;
364 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000365 }
366 if( pColumn && j>=pColumn->nId ){
drh9adf9ac2002-05-15 11:44:13 +0000367 sqliteVdbeAddOp(v, OP_String, 0, 0);
368 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
drh142e30d2002-08-28 03:00:58 +0000369 }else if( useTempTable ){
drh9adf9ac2002-05-15 11:44:13 +0000370 sqliteVdbeAddOp(v, OP_Column, srcTab, j);
drh142e30d2002-08-28 03:00:58 +0000371 }else if( pSelect ){
372 sqliteVdbeAddOp(v, OP_Dup, nColumn-j-1, 1);
danielk1977c3f9bad2002-05-15 08:30:12 +0000373 }else{
drh9adf9ac2002-05-15 11:44:13 +0000374 sqliteExprCode(pParse, pList->a[j].pExpr);
danielk1977c3f9bad2002-05-15 08:30:12 +0000375 }
376 }
377 sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
378 sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0);
379 sqliteVdbeAddOp(v, OP_Rewind, newIdx, 0);
380
381 /* Fire BEFORE triggers */
danielk1977f29ce552002-05-19 23:43:12 +0000382 if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_BEFORE, pTab, newIdx, -1,
danielk19776f349032002-06-11 02:25:40 +0000383 onError, endOfLoop) ){
danielk1977f29ce552002-05-19 23:43:12 +0000384 goto insert_cleanup;
385 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000386
387 /* Open the tables and indices for the INSERT */
danielk1977f29ce552002-05-19 23:43:12 +0000388 if( !pTab->pSelect ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000389 base = pParse->nTab;
390 openOp = pTab->isTemp ? OP_OpenWrAux : OP_OpenWrite;
391 sqliteVdbeAddOp(v, openOp, base, pTab->tnum);
392 sqliteVdbeChangeP3(v, -1, pTab->zName, P3_STATIC);
393 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
drh9adf9ac2002-05-15 11:44:13 +0000394 sqliteVdbeAddOp(v, openOp, idx+base, pIdx->tnum);
395 sqliteVdbeChangeP3(v, -1, pIdx->zName, P3_STATIC);
danielk1977c3f9bad2002-05-15 08:30:12 +0000396 }
397 pParse->nTab += idx;
398 }
399 }
400
drh4a324312001-12-21 14:30:42 +0000401 /* Push the record number for the new entry onto the stack. The
402 ** record number is a randomly generate integer created by NewRecno
403 ** except when the table has an INTEGER PRIMARY KEY column, in which
drhb419a922002-01-30 16:17:23 +0000404 ** case the record number is the same as that column.
drh1ccde152000-06-17 13:12:39 +0000405 */
danielk1977f29ce552002-05-19 23:43:12 +0000406 if( !pTab->pSelect ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000407 if( keyColumn>=0 ){
drh142e30d2002-08-28 03:00:58 +0000408 if( useTempTable ){
drh9adf9ac2002-05-15 11:44:13 +0000409 sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn);
drh142e30d2002-08-28 03:00:58 +0000410 }else if( pSelect ){
411 sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1);
danielk1977c3f9bad2002-05-15 08:30:12 +0000412 }else{
drh9adf9ac2002-05-15 11:44:13 +0000413 sqliteExprCode(pParse, pList->a[keyColumn].pExpr);
danielk1977c3f9bad2002-05-15 08:30:12 +0000414 }
drh27a32782002-06-19 20:32:43 +0000415 /* If the PRIMARY KEY expression is NULL, then use OP_NewRecno
416 ** to generate a unique primary key value.
417 */
418 sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3);
419 sqliteVdbeAddOp(v, OP_Pop, 1, 0);
420 sqliteVdbeAddOp(v, OP_NewRecno, base, 0);
danielk1977c3f9bad2002-05-15 08:30:12 +0000421 sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0);
422 }else{
drhe1e68f42002-03-31 18:29:03 +0000423 sqliteVdbeAddOp(v, OP_NewRecno, base, 0);
drh4a324312001-12-21 14:30:42 +0000424 }
drh4a324312001-12-21 14:30:42 +0000425
danielk1977c3f9bad2002-05-15 08:30:12 +0000426 /* Push onto the stack, data for all columns of the new entry, beginning
danielk1977f29ce552002-05-19 23:43:12 +0000427 ** with the first column.
428 */
danielk1977c3f9bad2002-05-15 08:30:12 +0000429 for(i=0; i<pTab->nCol; i++){
430 if( i==pTab->iPKey ){
drh9adf9ac2002-05-15 11:44:13 +0000431 /* The value of the INTEGER PRIMARY KEY column is always a NULL.
danielk1977f29ce552002-05-19 23:43:12 +0000432 ** Whenever this column is read, the record number will be substituted
433 ** in its place. So will fill this column with a NULL to avoid
434 ** taking up data space with information that will never be used. */
drh9adf9ac2002-05-15 11:44:13 +0000435 sqliteVdbeAddOp(v, OP_String, 0, 0);
436 continue;
danielk1977c3f9bad2002-05-15 08:30:12 +0000437 }
438 if( pColumn==0 ){
drh9adf9ac2002-05-15 11:44:13 +0000439 j = i;
danielk1977c3f9bad2002-05-15 08:30:12 +0000440 }else{
drh9adf9ac2002-05-15 11:44:13 +0000441 for(j=0; j<pColumn->nId; j++){
442 if( pColumn->a[j].idx==i ) break;
443 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000444 }
445 if( pColumn && j>=pColumn->nId ){
drh9adf9ac2002-05-15 11:44:13 +0000446 sqliteVdbeAddOp(v, OP_String, 0, 0);
447 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
drh142e30d2002-08-28 03:00:58 +0000448 }else if( useTempTable ){
drh9adf9ac2002-05-15 11:44:13 +0000449 sqliteVdbeAddOp(v, OP_Column, srcTab, j);
drh142e30d2002-08-28 03:00:58 +0000450 }else if( pSelect ){
451 sqliteVdbeAddOp(v, OP_Dup, i+nColumn-j, 1);
danielk1977c3f9bad2002-05-15 08:30:12 +0000452 }else{
drh9adf9ac2002-05-15 11:44:13 +0000453 sqliteExprCode(pParse, pList->a[j].pExpr);
drh5974a302000-06-07 14:42:26 +0000454 }
drhbed86902000-06-02 13:27:59 +0000455 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000456
457 /* Generate code to check constraints and generate index keys and
danielk1977f29ce552002-05-19 23:43:12 +0000458 ** do the insertion.
459 */
danielk1977c3f9bad2002-05-15 08:30:12 +0000460 sqliteGenerateConstraintChecks(pParse, pTab, base, 0,0,0,onError,endOfLoop);
461 sqliteCompleteInsertion(pParse, pTab, base, 0,0,0);
462
463 /* Update the count of rows that are inserted
danielk1977f29ce552002-05-19 23:43:12 +0000464 */
drh142e30d2002-08-28 03:00:58 +0000465 if( (db->flags & SQLITE_CountRows)!=0 ){
466 sqliteVdbeAddOp(v, OP_MemIncr, iCntMem, 0);
drh5974a302000-06-07 14:42:26 +0000467 }
468 }
drh1ccde152000-06-17 13:12:39 +0000469
danielk1977f29ce552002-05-19 23:43:12 +0000470 if( row_triggers_exist ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000471 /* Close all tables opened */
danielk1977f29ce552002-05-19 23:43:12 +0000472 if( !pTab->pSelect ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000473 sqliteVdbeAddOp(v, OP_Close, base, 0);
474 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
drh9adf9ac2002-05-15 11:44:13 +0000475 sqliteVdbeAddOp(v, OP_Close, idx+base, 0);
danielk1977c3f9bad2002-05-15 08:30:12 +0000476 }
477 }
drh1bee3d72001-10-15 00:44:35 +0000478
danielk1977c3f9bad2002-05-15 08:30:12 +0000479 /* Code AFTER triggers */
danielk1977f29ce552002-05-19 23:43:12 +0000480 if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_AFTER, pTab, newIdx, -1,
danielk19776f349032002-06-11 02:25:40 +0000481 onError, endOfLoop) ){
danielk1977f29ce552002-05-19 23:43:12 +0000482 goto insert_cleanup;
483 }
drh1bee3d72001-10-15 00:44:35 +0000484 }
485
drh1ccde152000-06-17 13:12:39 +0000486 /* The bottom of the loop, if the data source is a SELECT statement
danielk1977f29ce552002-05-19 23:43:12 +0000487 */
drh0ca3e242002-01-29 23:07:02 +0000488 sqliteVdbeResolveLabel(v, endOfLoop);
drh142e30d2002-08-28 03:00:58 +0000489 if( useTempTable ){
drh6b563442001-11-07 16:48:26 +0000490 sqliteVdbeAddOp(v, OP_Next, srcTab, iCont);
drh99fcd712001-10-13 01:06:47 +0000491 sqliteVdbeResolveLabel(v, iBreak);
drh6b563442001-11-07 16:48:26 +0000492 sqliteVdbeAddOp(v, OP_Close, srcTab, 0);
drh142e30d2002-08-28 03:00:58 +0000493 }else if( pSelect ){
494 sqliteVdbeAddOp(v, OP_Pop, nColumn, 0);
495 sqliteVdbeAddOp(v, OP_Return, 0, 0);
496 sqliteVdbeResolveLabel(v, iCleanup);
drh6b563442001-11-07 16:48:26 +0000497 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000498
danielk1977f29ce552002-05-19 23:43:12 +0000499 if( !row_triggers_exist ){
danielk1977c3f9bad2002-05-15 08:30:12 +0000500 /* Close all tables opened */
501 sqliteVdbeAddOp(v, OP_Close, base, 0);
502 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
503 sqliteVdbeAddOp(v, OP_Close, idx+base, 0);
504 }
drhcce7d172000-05-31 15:34:51 +0000505 }
danielk1977c3f9bad2002-05-15 08:30:12 +0000506
drh1c928532002-01-31 15:54:21 +0000507 sqliteEndWriteOperation(pParse);
drh5e00f6c2001-09-13 13:46:56 +0000508
drh1bee3d72001-10-15 00:44:35 +0000509 /*
danielk1977f29ce552002-05-19 23:43:12 +0000510 ** Return the number of rows inserted.
drh1bee3d72001-10-15 00:44:35 +0000511 */
drh142e30d2002-08-28 03:00:58 +0000512 if( db->flags & SQLITE_CountRows ){
drh1bee3d72001-10-15 00:44:35 +0000513 sqliteVdbeAddOp(v, OP_ColumnName, 0, 0);
514 sqliteVdbeChangeP3(v, -1, "rows inserted", P3_STATIC);
drh142e30d2002-08-28 03:00:58 +0000515 sqliteVdbeAddOp(v, OP_MemLoad, iCntMem, 0);
drh1bee3d72001-10-15 00:44:35 +0000516 sqliteVdbeAddOp(v, OP_Callback, 1, 0);
517 }
drhcce7d172000-05-31 15:34:51 +0000518
519insert_cleanup:
drh5974a302000-06-07 14:42:26 +0000520 if( pList ) sqliteExprListDelete(pList);
521 if( pSelect ) sqliteSelectDelete(pSelect);
danielk1977c3f9bad2002-05-15 08:30:12 +0000522 if ( zTab ) sqliteFree(zTab);
drh967e8b72000-06-21 13:59:10 +0000523 sqliteIdListDelete(pColumn);
drhcce7d172000-05-31 15:34:51 +0000524}
drh9cfcf5d2002-01-29 18:41:24 +0000525
drh9cfcf5d2002-01-29 18:41:24 +0000526/*
527** Generate code to do a constraint check prior to an INSERT or an UPDATE.
528**
529** When this routine is called, the stack contains (from bottom to top)
drh0ca3e242002-01-29 23:07:02 +0000530** the following values:
531**
drhb419a922002-01-30 16:17:23 +0000532** 1. The recno of the row to be updated before it is updated. This
533** value is omitted unless we are doing an UPDATE that involves a
534** change to the record number.
drh0ca3e242002-01-29 23:07:02 +0000535**
drhb419a922002-01-30 16:17:23 +0000536** 2. The recno of the row after the update.
drh0ca3e242002-01-29 23:07:02 +0000537**
538** 3. The data in the first column of the entry after the update.
539**
540** i. Data from middle columns...
541**
542** N. The data in the last column of the entry after the update.
543**
drhb419a922002-01-30 16:17:23 +0000544** The old recno shown as entry (1) above is omitted unless both isUpdate
drh1c928532002-01-31 15:54:21 +0000545** and recnoChng are 1. isUpdate is true for UPDATEs and false for
546** INSERTs and recnoChng is true if the record number is being changed.
drh0ca3e242002-01-29 23:07:02 +0000547**
548** The code generated by this routine pushes additional entries onto
549** the stack which are the keys for new index entries for the new record.
550** The order of index keys is the same as the order of the indices on
551** the pTable->pIndex list. A key is only created for index i if
552** aIdxUsed!=0 and aIdxUsed[i]!=0.
drh9cfcf5d2002-01-29 18:41:24 +0000553**
554** This routine also generates code to check constraints. NOT NULL,
555** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
drh1c928532002-01-31 15:54:21 +0000556** then the appropriate action is performed. There are five possible
557** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
drh9cfcf5d2002-01-29 18:41:24 +0000558**
559** Constraint type Action What Happens
560** --------------- ---------- ----------------------------------------
drh1c928532002-01-31 15:54:21 +0000561** any ROLLBACK The current transaction is rolled back and
drh9cfcf5d2002-01-29 18:41:24 +0000562** sqlite_exec() returns immediately with a
563** return code of SQLITE_CONSTRAINT.
564**
drh1c928532002-01-31 15:54:21 +0000565** any ABORT Back out changes from the current command
566** only (do not do a complete rollback) then
567** cause sqlite_exec() to return immediately
568** with SQLITE_CONSTRAINT.
569**
570** any FAIL Sqlite_exec() returns immediately with a
571** return code of SQLITE_CONSTRAINT. The
572** transaction is not rolled back and any
573** prior changes are retained.
574**
drh9cfcf5d2002-01-29 18:41:24 +0000575** any IGNORE The record number and data is popped from
576** the stack and there is an immediate jump
577** to label ignoreDest.
578**
579** NOT NULL REPLACE The NULL value is replace by the default
580** value for that column. If the default value
581** is NULL, the action is the same as ABORT.
582**
583** UNIQUE REPLACE The other row that conflicts with the row
584** being inserted is removed.
585**
586** CHECK REPLACE Illegal. The results in an exception.
587**
drh1c928532002-01-31 15:54:21 +0000588** Which action to take is determined by the overrideError parameter.
589** Or if overrideError==OE_Default, then the pParse->onError parameter
590** is used. Or if pParse->onError==OE_Default then the onError value
591** for the constraint is used.
drh9cfcf5d2002-01-29 18:41:24 +0000592**
drhaaab5722002-02-19 13:39:21 +0000593** The calling routine must open a read/write cursor for pTab with
drh9cfcf5d2002-01-29 18:41:24 +0000594** cursor number "base". All indices of pTab must also have open
595** read/write cursors with cursor number base+i for the i-th cursor.
596** Except, if there is no possibility of a REPLACE action then
597** cursors do not need to be open for indices where aIdxUsed[i]==0.
598**
599** If the isUpdate flag is true, it means that the "base" cursor is
600** initially pointing to an entry that is being updated. The isUpdate
601** flag causes extra code to be generated so that the "base" cursor
602** is still pointing at the same entry after the routine returns.
603** Without the isUpdate flag, the "base" cursor might be moved.
604*/
605void sqliteGenerateConstraintChecks(
606 Parse *pParse, /* The parser context */
607 Table *pTab, /* the table into which we are inserting */
608 int base, /* Index of a read/write cursor pointing at pTab */
609 char *aIdxUsed, /* Which indices are used. NULL means all are used */
drh0ca3e242002-01-29 23:07:02 +0000610 int recnoChng, /* True if the record number will change */
drhb419a922002-01-30 16:17:23 +0000611 int isUpdate, /* True for UPDATE, False for INSERT */
drh9cfcf5d2002-01-29 18:41:24 +0000612 int overrideError, /* Override onError to this if not OE_Default */
drhb419a922002-01-30 16:17:23 +0000613 int ignoreDest /* Jump to this label on an OE_Ignore resolution */
drh9cfcf5d2002-01-29 18:41:24 +0000614){
615 int i;
616 Vdbe *v;
617 int nCol;
618 int onError;
619 int addr;
620 int extra;
drh0ca3e242002-01-29 23:07:02 +0000621 int iCur;
622 Index *pIdx;
623 int seenReplace = 0;
drhf5905aa2002-05-26 20:54:33 +0000624 int jumpInst1, jumpInst2;
drh0ca3e242002-01-29 23:07:02 +0000625 int contAddr;
drhb419a922002-01-30 16:17:23 +0000626 int hasTwoRecnos = (isUpdate && recnoChng);
drh9cfcf5d2002-01-29 18:41:24 +0000627
628 v = sqliteGetVdbe(pParse);
629 assert( v!=0 );
drh417be792002-03-03 18:59:40 +0000630 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
drh9cfcf5d2002-01-29 18:41:24 +0000631 nCol = pTab->nCol;
632
633 /* Test all NOT NULL constraints.
634 */
635 for(i=0; i<nCol; i++){
drh0ca3e242002-01-29 23:07:02 +0000636 if( i==pTab->iPKey ){
637 /* Fix me: Make sure the INTEGER PRIMARY KEY is not NULL. */
638 continue;
639 }
drh9cfcf5d2002-01-29 18:41:24 +0000640 onError = pTab->aCol[i].notNull;
drh0ca3e242002-01-29 23:07:02 +0000641 if( onError==OE_None ) continue;
drh9cfcf5d2002-01-29 18:41:24 +0000642 if( overrideError!=OE_Default ){
643 onError = overrideError;
drh1c928532002-01-31 15:54:21 +0000644 }else if( onError==OE_Default ){
drh0d65dc02002-02-03 00:56:09 +0000645 onError = pParse->db->onError;
646 if( onError==OE_Default ) onError = OE_Abort;
drh9cfcf5d2002-01-29 18:41:24 +0000647 }
648 if( onError==OE_Replace && pTab->aCol[i].zDflt==0 ){
649 onError = OE_Abort;
650 }
drhef6764a2002-01-30 04:32:00 +0000651 sqliteVdbeAddOp(v, OP_Dup, nCol-1-i, 1);
drhf5905aa2002-05-26 20:54:33 +0000652 addr = sqliteVdbeAddOp(v, OP_NotNull, 1, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000653 switch( onError ){
drh1c928532002-01-31 15:54:21 +0000654 case OE_Rollback:
655 case OE_Abort:
656 case OE_Fail: {
657 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
drh9cfcf5d2002-01-29 18:41:24 +0000658 break;
659 }
660 case OE_Ignore: {
drhb419a922002-01-30 16:17:23 +0000661 sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0);
drh0ca3e242002-01-29 23:07:02 +0000662 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
drh9cfcf5d2002-01-29 18:41:24 +0000663 break;
664 }
665 case OE_Replace: {
666 sqliteVdbeAddOp(v, OP_String, 0, 0);
667 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
668 sqliteVdbeAddOp(v, OP_Push, nCol-i, 0);
669 break;
670 }
drh0ca3e242002-01-29 23:07:02 +0000671 default: assert(0);
drh9cfcf5d2002-01-29 18:41:24 +0000672 }
drhef6764a2002-01-30 04:32:00 +0000673 sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v));
drh9cfcf5d2002-01-29 18:41:24 +0000674 }
675
676 /* Test all CHECK constraints
677 */
drh0bd1f4e2002-06-06 18:54:39 +0000678 /**** TBD ****/
drh9cfcf5d2002-01-29 18:41:24 +0000679
drh0bd1f4e2002-06-06 18:54:39 +0000680 /* If we have an INTEGER PRIMARY KEY, make sure the primary key
681 ** of the new record does not previously exist. Except, if this
682 ** is an UPDATE and the primary key is not changing, that is OK.
683 ** Also, if the conflict resolution policy is REPLACE, then we
684 ** can skip this test.
drh9cfcf5d2002-01-29 18:41:24 +0000685 */
drh0d65dc02002-02-03 00:56:09 +0000686 if( (recnoChng || !isUpdate) && pTab->iPKey>=0 ){
drh0ca3e242002-01-29 23:07:02 +0000687 onError = pTab->keyConf;
688 if( overrideError!=OE_Default ){
689 onError = overrideError;
drh1c928532002-01-31 15:54:21 +0000690 }else if( onError==OE_Default ){
drh0d65dc02002-02-03 00:56:09 +0000691 onError = pParse->db->onError;
692 if( onError==OE_Default ) onError = OE_Abort;
drh0ca3e242002-01-29 23:07:02 +0000693 }
drh0d65dc02002-02-03 00:56:09 +0000694 if( onError!=OE_Replace ){
drh79b0c952002-05-21 12:56:43 +0000695 if( isUpdate ){
696 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
697 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
drhf5905aa2002-05-26 20:54:33 +0000698 jumpInst1 = sqliteVdbeAddOp(v, OP_Eq, 0, 0);
drh79b0c952002-05-21 12:56:43 +0000699 }
drh0d65dc02002-02-03 00:56:09 +0000700 sqliteVdbeAddOp(v, OP_Dup, nCol, 1);
drhf5905aa2002-05-26 20:54:33 +0000701 jumpInst2 = sqliteVdbeAddOp(v, OP_NotExists, base, 0);
drh0d65dc02002-02-03 00:56:09 +0000702 switch( onError ){
703 case OE_Rollback:
704 case OE_Abort:
705 case OE_Fail: {
706 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
707 break;
708 }
709 case OE_Ignore: {
710 sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0);
711 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
712 break;
713 }
714 default: assert(0);
drh0ca3e242002-01-29 23:07:02 +0000715 }
drh0d65dc02002-02-03 00:56:09 +0000716 contAddr = sqliteVdbeCurrentAddr(v);
drhf5905aa2002-05-26 20:54:33 +0000717 sqliteVdbeChangeP2(v, jumpInst2, contAddr);
drh0d65dc02002-02-03 00:56:09 +0000718 if( isUpdate ){
drhf5905aa2002-05-26 20:54:33 +0000719 sqliteVdbeChangeP2(v, jumpInst1, contAddr);
drh0d65dc02002-02-03 00:56:09 +0000720 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
721 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
drh0ca3e242002-01-29 23:07:02 +0000722 }
drh0ca3e242002-01-29 23:07:02 +0000723 }
724 }
drh0bd1f4e2002-06-06 18:54:39 +0000725
726 /* Test all UNIQUE constraints by creating entries for each UNIQUE
727 ** index and making sure that duplicate entries do not already exist.
728 ** Add the new records to the indices as we go.
729 */
drh9cfcf5d2002-01-29 18:41:24 +0000730 extra = 0;
731 for(extra=(-1), iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
drh9cfcf5d2002-01-29 18:41:24 +0000732 if( aIdxUsed && aIdxUsed[iCur]==0 ) continue;
733 extra++;
734 sqliteVdbeAddOp(v, OP_Dup, nCol+extra, 1);
735 for(i=0; i<pIdx->nColumn; i++){
736 int idx = pIdx->aiColumn[i];
737 if( idx==pTab->iPKey ){
drh0ca3e242002-01-29 23:07:02 +0000738 sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1);
drh9cfcf5d2002-01-29 18:41:24 +0000739 }else{
drh0ca3e242002-01-29 23:07:02 +0000740 sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1);
drh9cfcf5d2002-01-29 18:41:24 +0000741 }
742 }
drhf5905aa2002-05-26 20:54:33 +0000743 jumpInst1 = sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0);
drh491791a2002-07-18 00:34:09 +0000744 if( pParse->db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx);
drh9cfcf5d2002-01-29 18:41:24 +0000745 onError = pIdx->onError;
746 if( onError==OE_None ) continue;
747 if( overrideError!=OE_Default ){
748 onError = overrideError;
drh1c928532002-01-31 15:54:21 +0000749 }else if( onError==OE_Default ){
drh0d65dc02002-02-03 00:56:09 +0000750 onError = pParse->db->onError;
751 if( onError==OE_Default ) onError = OE_Abort;
drh9cfcf5d2002-01-29 18:41:24 +0000752 }
drhb419a922002-01-30 16:17:23 +0000753 sqliteVdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRecnos, 1);
drhf5905aa2002-05-26 20:54:33 +0000754 jumpInst2 = sqliteVdbeAddOp(v, OP_IsUnique, base+iCur+1, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000755 switch( onError ){
drh1c928532002-01-31 15:54:21 +0000756 case OE_Rollback:
757 case OE_Abort:
758 case OE_Fail: {
759 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
drh9cfcf5d2002-01-29 18:41:24 +0000760 break;
761 }
762 case OE_Ignore: {
drh0ca3e242002-01-29 23:07:02 +0000763 assert( seenReplace==0 );
drhfe1a1772002-04-09 03:15:06 +0000764 sqliteVdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRecnos, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000765 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
drh9cfcf5d2002-01-29 18:41:24 +0000766 break;
767 }
768 case OE_Replace: {
drh38640e12002-07-05 21:42:36 +0000769 sqliteGenerateRowDelete(pParse->db, v, pTab, base, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000770 if( isUpdate ){
drhb419a922002-01-30 16:17:23 +0000771 sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1);
drh0ca3e242002-01-29 23:07:02 +0000772 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000773 }
drh0ca3e242002-01-29 23:07:02 +0000774 seenReplace = 1;
drh9cfcf5d2002-01-29 18:41:24 +0000775 break;
776 }
drh0ca3e242002-01-29 23:07:02 +0000777 default: assert(0);
drh9cfcf5d2002-01-29 18:41:24 +0000778 }
779 contAddr = sqliteVdbeCurrentAddr(v);
drh0bd1f4e2002-06-06 18:54:39 +0000780#if NULL_DISTINCT_FOR_UNIQUE
drhf5905aa2002-05-26 20:54:33 +0000781 sqliteVdbeChangeP2(v, jumpInst1, contAddr);
drh0bd1f4e2002-06-06 18:54:39 +0000782#endif
drhf5905aa2002-05-26 20:54:33 +0000783 sqliteVdbeChangeP2(v, jumpInst2, contAddr);
drh9cfcf5d2002-01-29 18:41:24 +0000784 }
785}
drh0ca3e242002-01-29 23:07:02 +0000786
787/*
788** This routine generates code to finish the INSERT or UPDATE operation
789** that was started by a prior call to sqliteGenerateConstraintChecks.
790** The stack must contain keys for all active indices followed by data
791** and the recno for the new entry. This routine creates the new
792** entries in all indices and in the main table.
793**
drhb419a922002-01-30 16:17:23 +0000794** The arguments to this routine should be the same as the first six
drh0ca3e242002-01-29 23:07:02 +0000795** arguments to sqliteGenerateConstraintChecks.
796*/
797void sqliteCompleteInsertion(
798 Parse *pParse, /* The parser context */
799 Table *pTab, /* the table into which we are inserting */
800 int base, /* Index of a read/write cursor pointing at pTab */
801 char *aIdxUsed, /* Which indices are used. NULL means all are used */
drhb419a922002-01-30 16:17:23 +0000802 int recnoChng, /* True if the record number will change */
803 int isUpdate /* True for UPDATE, False for INSERT */
drh0ca3e242002-01-29 23:07:02 +0000804){
805 int i;
806 Vdbe *v;
807 int nIdx;
808 Index *pIdx;
809
810 v = sqliteGetVdbe(pParse);
811 assert( v!=0 );
drh417be792002-03-03 18:59:40 +0000812 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
drh0ca3e242002-01-29 23:07:02 +0000813 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
814 for(i=nIdx-1; i>=0; i--){
815 if( aIdxUsed && aIdxUsed[i]==0 ) continue;
816 sqliteVdbeAddOp(v, OP_IdxPut, base+i+1, 0);
817 }
818 sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
danielk1977c3f9bad2002-05-15 08:30:12 +0000819 sqliteVdbeAddOp(v, OP_PutIntKey, base, pParse->trigStack?0:1);
drhb419a922002-01-30 16:17:23 +0000820 if( isUpdate && recnoChng ){
drh0ca3e242002-01-29 23:07:02 +0000821 sqliteVdbeAddOp(v, OP_Pop, 1, 0);
822 }
823}