blob: aa49c40828f4a6b323f28351a63dc8e176cc434a [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**
drhe64e7b22002-02-18 13:56:36 +000015** $Id: insert.c,v 1.43 2002/02/18 13:56:37 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.
drhcce7d172000-05-31 15:34:51 +000033*/
34void sqliteInsert(
35 Parse *pParse, /* Parser context */
36 Token *pTableName, /* Name of table into which we are inserting */
37 ExprList *pList, /* List of values to be inserted */
drh5974a302000-06-07 14:42:26 +000038 Select *pSelect, /* A SELECT statement to use as the data source */
drh9cfcf5d2002-01-29 18:41:24 +000039 IdList *pColumn, /* Column names corresponding to IDLIST. */
40 int onError /* How to handle constraint errors */
drhcce7d172000-05-31 15:34:51 +000041){
drh5974a302000-06-07 14:42:26 +000042 Table *pTab; /* The table to insert into */
43 char *zTab; /* Name of the table into which we are inserting */
44 int i, j, idx; /* Loop counters */
45 Vdbe *v; /* Generate code into this virtual machine */
46 Index *pIdx; /* For looping over indices of the table */
47 int srcTab; /* Date comes from this temporary cursor if >=0 */
drh967e8b72000-06-21 13:59:10 +000048 int nColumn; /* Number of columns in the data */
drh5974a302000-06-07 14:42:26 +000049 int base; /* First available cursor */
50 int iCont, iBreak; /* Beginning and end of the loop over srcTab */
drhecdc7532001-09-23 02:35:53 +000051 sqlite *db; /* The main database structure */
drhf57b3392001-10-08 13:22:32 +000052 int openOp; /* Opcode used to open cursors */
drh4a324312001-12-21 14:30:42 +000053 int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
drh0ca3e242002-01-29 23:07:02 +000054 int endOfLoop; /* Label for the end of the insertion loop */
drhcce7d172000-05-31 15:34:51 +000055
drhdaffd0e2001-04-11 14:28:42 +000056 if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
drhecdc7532001-09-23 02:35:53 +000057 db = pParse->db;
drhdaffd0e2001-04-11 14:28:42 +000058
drh1ccde152000-06-17 13:12:39 +000059 /* Locate the table into which we will be inserting new information.
60 */
drhcce7d172000-05-31 15:34:51 +000061 zTab = sqliteTableNameFromToken(pTableName);
drhdaffd0e2001-04-11 14:28:42 +000062 if( zTab==0 ) goto insert_cleanup;
drhecdc7532001-09-23 02:35:53 +000063 pTab = sqliteFindTable(db, zTab);
drhcce7d172000-05-31 15:34:51 +000064 sqliteFree(zTab);
65 if( pTab==0 ){
66 sqliteSetNString(&pParse->zErrMsg, "no such table: ", 0,
67 pTableName->z, pTableName->n, 0);
68 pParse->nErr++;
69 goto insert_cleanup;
70 }
71 if( pTab->readOnly ){
72 sqliteSetString(&pParse->zErrMsg, "table ", pTab->zName,
73 " may not be modified", 0);
74 pParse->nErr++;
75 goto insert_cleanup;
76 }
drh1ccde152000-06-17 13:12:39 +000077
78 /* Allocate a VDBE
79 */
drhd8bc7082000-06-07 23:51:50 +000080 v = sqliteGetVdbe(pParse);
drh5974a302000-06-07 14:42:26 +000081 if( v==0 ) goto insert_cleanup;
drh663fc632002-02-02 18:49:19 +000082 if( pSelect ){
83 sqliteBeginMultiWriteOperation(pParse);
84 }else{
85 sqliteBeginWriteOperation(pParse);
86 }
drh1ccde152000-06-17 13:12:39 +000087
88 /* Figure out how many columns of data are supplied. If the data
drhc6b52df2002-01-04 03:09:29 +000089 ** is coming from a SELECT statement, then this step has to generate
drh1ccde152000-06-17 13:12:39 +000090 ** all the code to implement the SELECT statement and leave the data
91 ** in a temporary table. If data is coming from an expression list,
92 ** then we just have to count the number of expressions.
93 */
drh5974a302000-06-07 14:42:26 +000094 if( pSelect ){
95 int rc;
96 srcTab = pParse->nTab++;
drh99fcd712001-10-13 01:06:47 +000097 sqliteVdbeAddOp(v, OP_OpenTemp, srcTab, 0);
drh5974a302000-06-07 14:42:26 +000098 rc = sqliteSelect(pParse, pSelect, SRT_Table, srcTab);
drhdaffd0e2001-04-11 14:28:42 +000099 if( rc || pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
drh5974a302000-06-07 14:42:26 +0000100 assert( pSelect->pEList );
drh967e8b72000-06-21 13:59:10 +0000101 nColumn = pSelect->pEList->nExpr;
drh5974a302000-06-07 14:42:26 +0000102 }else{
drhe64e7b22002-02-18 13:56:36 +0000103 IdList dummy;
drhdaffd0e2001-04-11 14:28:42 +0000104 assert( pList!=0 );
drh5974a302000-06-07 14:42:26 +0000105 srcTab = -1;
106 assert( pList );
drh967e8b72000-06-21 13:59:10 +0000107 nColumn = pList->nExpr;
drhe64e7b22002-02-18 13:56:36 +0000108 for(i=0; i<nColumn; i++){
109 sqliteExprResolveInSelect(pParse, pList->a[i].pExpr);
110 }
111 dummy.nId = 0;
112 for(i=0; i<nColumn; i++){
113 if( sqliteExprResolveIds(pParse, &dummy, 0, pList->a[i].pExpr) ){
114 goto insert_cleanup;
115 }
116 }
drh5974a302000-06-07 14:42:26 +0000117 }
drh1ccde152000-06-17 13:12:39 +0000118
119 /* Make sure the number of columns in the source data matches the number
120 ** of columns to be inserted into the table.
121 */
drh967e8b72000-06-21 13:59:10 +0000122 if( pColumn==0 && nColumn!=pTab->nCol ){
drhcce7d172000-05-31 15:34:51 +0000123 char zNum1[30];
124 char zNum2[30];
drh967e8b72000-06-21 13:59:10 +0000125 sprintf(zNum1,"%d", nColumn);
drhcce7d172000-05-31 15:34:51 +0000126 sprintf(zNum2,"%d", pTab->nCol);
127 sqliteSetString(&pParse->zErrMsg, "table ", pTab->zName,
128 " has ", zNum2, " columns but ",
129 zNum1, " values were supplied", 0);
130 pParse->nErr++;
131 goto insert_cleanup;
132 }
drh967e8b72000-06-21 13:59:10 +0000133 if( pColumn!=0 && nColumn!=pColumn->nId ){
drhcce7d172000-05-31 15:34:51 +0000134 char zNum1[30];
135 char zNum2[30];
drh967e8b72000-06-21 13:59:10 +0000136 sprintf(zNum1,"%d", nColumn);
137 sprintf(zNum2,"%d", pColumn->nId);
drhcce7d172000-05-31 15:34:51 +0000138 sqliteSetString(&pParse->zErrMsg, zNum1, " values for ",
139 zNum2, " columns", 0);
140 pParse->nErr++;
141 goto insert_cleanup;
142 }
drh1ccde152000-06-17 13:12:39 +0000143
144 /* If the INSERT statement included an IDLIST term, then make sure
145 ** all elements of the IDLIST really are columns of the table and
146 ** remember the column indices.
drhc8392582001-12-31 02:48:51 +0000147 **
148 ** If the table has an INTEGER PRIMARY KEY column and that column
149 ** is named in the IDLIST, then record in the keyColumn variable
150 ** the index into IDLIST of the primary key column. keyColumn is
151 ** the index of the primary key as it appears in IDLIST, not as
152 ** is appears in the original table. (The index of the primary
153 ** key in the original table is pTab->iPKey.)
drh1ccde152000-06-17 13:12:39 +0000154 */
drh967e8b72000-06-21 13:59:10 +0000155 if( pColumn ){
156 for(i=0; i<pColumn->nId; i++){
157 pColumn->a[i].idx = -1;
drhcce7d172000-05-31 15:34:51 +0000158 }
drh967e8b72000-06-21 13:59:10 +0000159 for(i=0; i<pColumn->nId; i++){
drhcce7d172000-05-31 15:34:51 +0000160 for(j=0; j<pTab->nCol; j++){
drh967e8b72000-06-21 13:59:10 +0000161 if( sqliteStrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
162 pColumn->a[i].idx = j;
drh4a324312001-12-21 14:30:42 +0000163 if( j==pTab->iPKey ){
drh9aa028d2001-12-22 21:48:29 +0000164 keyColumn = i;
drh4a324312001-12-21 14:30:42 +0000165 }
drhcce7d172000-05-31 15:34:51 +0000166 break;
167 }
168 }
169 if( j>=pTab->nCol ){
170 sqliteSetString(&pParse->zErrMsg, "table ", pTab->zName,
drh967e8b72000-06-21 13:59:10 +0000171 " has no column named ", pColumn->a[i].zName, 0);
drhcce7d172000-05-31 15:34:51 +0000172 pParse->nErr++;
173 goto insert_cleanup;
174 }
175 }
176 }
drh1ccde152000-06-17 13:12:39 +0000177
drhaacc5432002-01-06 17:07:40 +0000178 /* If there is no IDLIST term but the table has an integer primary
drhc8392582001-12-31 02:48:51 +0000179 ** key, the set the keyColumn variable to the primary key column index
180 ** in the original table definition.
drh4a324312001-12-21 14:30:42 +0000181 */
182 if( pColumn==0 ){
183 keyColumn = pTab->iPKey;
184 }
185
drh1ccde152000-06-17 13:12:39 +0000186 /* Open cursors into the table that is received the new data and
187 ** all indices of that table.
188 */
drh5974a302000-06-07 14:42:26 +0000189 base = pParse->nTab;
drhf57b3392001-10-08 13:22:32 +0000190 openOp = pTab->isTemp ? OP_OpenWrAux : OP_OpenWrite;
drh99fcd712001-10-13 01:06:47 +0000191 sqliteVdbeAddOp(v, openOp, base, pTab->tnum);
192 sqliteVdbeChangeP3(v, -1, pTab->zName, P3_STATIC);
drh5974a302000-06-07 14:42:26 +0000193 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
drh99fcd712001-10-13 01:06:47 +0000194 sqliteVdbeAddOp(v, openOp, idx+base, pIdx->tnum);
195 sqliteVdbeChangeP3(v, -1, pIdx->zName, P3_STATIC);
drh19a775c2000-06-05 18:54:46 +0000196 }
drh1ccde152000-06-17 13:12:39 +0000197
198 /* If the data source is a SELECT statement, then we have to create
199 ** a loop because there might be multiple rows of data. If the data
200 ** source is an expression list, then exactly one row will be inserted
201 ** and the loop is not used.
202 */
drh5974a302000-06-07 14:42:26 +0000203 if( srcTab>=0 ){
drh1bee3d72001-10-15 00:44:35 +0000204 if( db->flags & SQLITE_CountRows ){
205 sqliteVdbeAddOp(v, OP_Integer, 0, 0); /* Initialize the row count */
206 }
drh5974a302000-06-07 14:42:26 +0000207 iBreak = sqliteVdbeMakeLabel(v);
drh6b563442001-11-07 16:48:26 +0000208 sqliteVdbeAddOp(v, OP_Rewind, srcTab, iBreak);
209 iCont = sqliteVdbeCurrentAddr(v);
drh5974a302000-06-07 14:42:26 +0000210 }
drh1ccde152000-06-17 13:12:39 +0000211
drh4a324312001-12-21 14:30:42 +0000212 /* Push the record number for the new entry onto the stack. The
213 ** record number is a randomly generate integer created by NewRecno
214 ** except when the table has an INTEGER PRIMARY KEY column, in which
drhb419a922002-01-30 16:17:23 +0000215 ** case the record number is the same as that column.
drh1ccde152000-06-17 13:12:39 +0000216 */
drh4a324312001-12-21 14:30:42 +0000217 if( keyColumn>=0 ){
218 if( srcTab>=0 ){
219 sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn);
220 }else{
221 sqliteExprCode(pParse, pList->a[keyColumn].pExpr);
222 }
drh8aff1012001-12-22 14:49:24 +0000223 sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0);
drh4a324312001-12-21 14:30:42 +0000224 }else{
225 sqliteVdbeAddOp(v, OP_NewRecno, base, 0);
226 }
drh4a324312001-12-21 14:30:42 +0000227
drhaacc5432002-01-06 17:07:40 +0000228 /* Push onto the stack, data for all columns of the new entry, beginning
drh4a324312001-12-21 14:30:42 +0000229 ** with the first column.
230 */
drh5974a302000-06-07 14:42:26 +0000231 for(i=0; i<pTab->nCol; i++){
drh4a324312001-12-21 14:30:42 +0000232 if( i==pTab->iPKey ){
233 /* The value of the INTEGER PRIMARY KEY column is always a NULL.
drhaacc5432002-01-06 17:07:40 +0000234 ** Whenever this column is read, the record number will be substituted
235 ** in its place. So will fill this column with a NULL to avoid
236 ** taking up data space with information that will never be used. */
drh4a324312001-12-21 14:30:42 +0000237 sqliteVdbeAddOp(v, OP_String, 0, 0);
238 continue;
239 }
drh967e8b72000-06-21 13:59:10 +0000240 if( pColumn==0 ){
drh5974a302000-06-07 14:42:26 +0000241 j = i;
242 }else{
drh967e8b72000-06-21 13:59:10 +0000243 for(j=0; j<pColumn->nId; j++){
244 if( pColumn->a[j].idx==i ) break;
drh5974a302000-06-07 14:42:26 +0000245 }
drhbed86902000-06-02 13:27:59 +0000246 }
drh967e8b72000-06-21 13:59:10 +0000247 if( pColumn && j>=pColumn->nId ){
drh99fcd712001-10-13 01:06:47 +0000248 sqliteVdbeAddOp(v, OP_String, 0, 0);
249 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
drh5974a302000-06-07 14:42:26 +0000250 }else if( srcTab>=0 ){
drh24e97df2002-02-03 19:06:02 +0000251 sqliteVdbeAddOp(v, OP_Column, srcTab, j);
drh5974a302000-06-07 14:42:26 +0000252 }else{
253 sqliteExprCode(pParse, pList->a[j].pExpr);
254 }
255 }
drh1ccde152000-06-17 13:12:39 +0000256
drh0ca3e242002-01-29 23:07:02 +0000257 /* Generate code to check constraints and generate index keys and
258 ** do the insertion.
drh4a324312001-12-21 14:30:42 +0000259 */
drh0ca3e242002-01-29 23:07:02 +0000260 endOfLoop = sqliteVdbeMakeLabel(v);
drhb419a922002-01-30 16:17:23 +0000261 sqliteGenerateConstraintChecks(pParse, pTab, base, 0,0,0, onError, endOfLoop);
262 sqliteCompleteInsertion(pParse, pTab, base, 0,0,0);
drh1bee3d72001-10-15 00:44:35 +0000263
264 /* If inserting from a SELECT, keep a count of the number of
265 ** rows inserted.
266 */
267 if( srcTab>=0 && (db->flags & SQLITE_CountRows)!=0 ){
268 sqliteVdbeAddOp(v, OP_AddImm, 1, 0);
269 }
270
drh1ccde152000-06-17 13:12:39 +0000271 /* The bottom of the loop, if the data source is a SELECT statement
272 */
drh0ca3e242002-01-29 23:07:02 +0000273 sqliteVdbeResolveLabel(v, endOfLoop);
drh5974a302000-06-07 14:42:26 +0000274 if( srcTab>=0 ){
drh6b563442001-11-07 16:48:26 +0000275 sqliteVdbeAddOp(v, OP_Next, srcTab, iCont);
drh99fcd712001-10-13 01:06:47 +0000276 sqliteVdbeResolveLabel(v, iBreak);
drh6b563442001-11-07 16:48:26 +0000277 sqliteVdbeAddOp(v, OP_Close, srcTab, 0);
278 }
279 sqliteVdbeAddOp(v, OP_Close, base, 0);
280 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
281 sqliteVdbeAddOp(v, OP_Close, idx+base, 0);
drhcce7d172000-05-31 15:34:51 +0000282 }
drh1c928532002-01-31 15:54:21 +0000283 sqliteEndWriteOperation(pParse);
drh5e00f6c2001-09-13 13:46:56 +0000284
drh1bee3d72001-10-15 00:44:35 +0000285 /*
286 ** Return the number of rows inserted.
287 */
288 if( db->flags & SQLITE_CountRows ){
289 sqliteVdbeAddOp(v, OP_ColumnCount, 1, 0);
290 sqliteVdbeAddOp(v, OP_ColumnName, 0, 0);
291 sqliteVdbeChangeP3(v, -1, "rows inserted", P3_STATIC);
292 if( srcTab<0 ){
293 sqliteVdbeAddOp(v, OP_Integer, 1, 0);
294 }
295 sqliteVdbeAddOp(v, OP_Callback, 1, 0);
296 }
drhcce7d172000-05-31 15:34:51 +0000297
298insert_cleanup:
drh5974a302000-06-07 14:42:26 +0000299 if( pList ) sqliteExprListDelete(pList);
300 if( pSelect ) sqliteSelectDelete(pSelect);
drh967e8b72000-06-21 13:59:10 +0000301 sqliteIdListDelete(pColumn);
drhcce7d172000-05-31 15:34:51 +0000302}
drh9cfcf5d2002-01-29 18:41:24 +0000303
drh9cfcf5d2002-01-29 18:41:24 +0000304/*
305** Generate code to do a constraint check prior to an INSERT or an UPDATE.
306**
307** When this routine is called, the stack contains (from bottom to top)
drh0ca3e242002-01-29 23:07:02 +0000308** the following values:
309**
drhb419a922002-01-30 16:17:23 +0000310** 1. The recno of the row to be updated before it is updated. This
311** value is omitted unless we are doing an UPDATE that involves a
312** change to the record number.
drh0ca3e242002-01-29 23:07:02 +0000313**
drhb419a922002-01-30 16:17:23 +0000314** 2. The recno of the row after the update.
drh0ca3e242002-01-29 23:07:02 +0000315**
316** 3. The data in the first column of the entry after the update.
317**
318** i. Data from middle columns...
319**
320** N. The data in the last column of the entry after the update.
321**
drhb419a922002-01-30 16:17:23 +0000322** The old recno shown as entry (1) above is omitted unless both isUpdate
drh1c928532002-01-31 15:54:21 +0000323** and recnoChng are 1. isUpdate is true for UPDATEs and false for
324** INSERTs and recnoChng is true if the record number is being changed.
drh0ca3e242002-01-29 23:07:02 +0000325**
326** The code generated by this routine pushes additional entries onto
327** the stack which are the keys for new index entries for the new record.
328** The order of index keys is the same as the order of the indices on
329** the pTable->pIndex list. A key is only created for index i if
330** aIdxUsed!=0 and aIdxUsed[i]!=0.
drh9cfcf5d2002-01-29 18:41:24 +0000331**
332** This routine also generates code to check constraints. NOT NULL,
333** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
drh1c928532002-01-31 15:54:21 +0000334** then the appropriate action is performed. There are five possible
335** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
drh9cfcf5d2002-01-29 18:41:24 +0000336**
337** Constraint type Action What Happens
338** --------------- ---------- ----------------------------------------
drh1c928532002-01-31 15:54:21 +0000339** any ROLLBACK The current transaction is rolled back and
drh9cfcf5d2002-01-29 18:41:24 +0000340** sqlite_exec() returns immediately with a
341** return code of SQLITE_CONSTRAINT.
342**
drh1c928532002-01-31 15:54:21 +0000343** any ABORT Back out changes from the current command
344** only (do not do a complete rollback) then
345** cause sqlite_exec() to return immediately
346** with SQLITE_CONSTRAINT.
347**
348** any FAIL Sqlite_exec() returns immediately with a
349** return code of SQLITE_CONSTRAINT. The
350** transaction is not rolled back and any
351** prior changes are retained.
352**
drh9cfcf5d2002-01-29 18:41:24 +0000353** any IGNORE The record number and data is popped from
354** the stack and there is an immediate jump
355** to label ignoreDest.
356**
357** NOT NULL REPLACE The NULL value is replace by the default
358** value for that column. If the default value
359** is NULL, the action is the same as ABORT.
360**
361** UNIQUE REPLACE The other row that conflicts with the row
362** being inserted is removed.
363**
364** CHECK REPLACE Illegal. The results in an exception.
365**
drh1c928532002-01-31 15:54:21 +0000366** Which action to take is determined by the overrideError parameter.
367** Or if overrideError==OE_Default, then the pParse->onError parameter
368** is used. Or if pParse->onError==OE_Default then the onError value
369** for the constraint is used.
drh9cfcf5d2002-01-29 18:41:24 +0000370**
371** The calling routine must an open read/write cursor for pTab with
372** cursor number "base". All indices of pTab must also have open
373** read/write cursors with cursor number base+i for the i-th cursor.
374** Except, if there is no possibility of a REPLACE action then
375** cursors do not need to be open for indices where aIdxUsed[i]==0.
376**
377** If the isUpdate flag is true, it means that the "base" cursor is
378** initially pointing to an entry that is being updated. The isUpdate
379** flag causes extra code to be generated so that the "base" cursor
380** is still pointing at the same entry after the routine returns.
381** Without the isUpdate flag, the "base" cursor might be moved.
382*/
383void sqliteGenerateConstraintChecks(
384 Parse *pParse, /* The parser context */
385 Table *pTab, /* the table into which we are inserting */
386 int base, /* Index of a read/write cursor pointing at pTab */
387 char *aIdxUsed, /* Which indices are used. NULL means all are used */
drh0ca3e242002-01-29 23:07:02 +0000388 int recnoChng, /* True if the record number will change */
drhb419a922002-01-30 16:17:23 +0000389 int isUpdate, /* True for UPDATE, False for INSERT */
drh9cfcf5d2002-01-29 18:41:24 +0000390 int overrideError, /* Override onError to this if not OE_Default */
drhb419a922002-01-30 16:17:23 +0000391 int ignoreDest /* Jump to this label on an OE_Ignore resolution */
drh9cfcf5d2002-01-29 18:41:24 +0000392){
393 int i;
394 Vdbe *v;
395 int nCol;
396 int onError;
397 int addr;
398 int extra;
drh0ca3e242002-01-29 23:07:02 +0000399 int iCur;
400 Index *pIdx;
401 int seenReplace = 0;
402 int jumpInst;
403 int contAddr;
drhb419a922002-01-30 16:17:23 +0000404 int hasTwoRecnos = (isUpdate && recnoChng);
drh9cfcf5d2002-01-29 18:41:24 +0000405
406 v = sqliteGetVdbe(pParse);
407 assert( v!=0 );
408 nCol = pTab->nCol;
409
410 /* Test all NOT NULL constraints.
411 */
412 for(i=0; i<nCol; i++){
drh0ca3e242002-01-29 23:07:02 +0000413 if( i==pTab->iPKey ){
414 /* Fix me: Make sure the INTEGER PRIMARY KEY is not NULL. */
415 continue;
416 }
drh9cfcf5d2002-01-29 18:41:24 +0000417 onError = pTab->aCol[i].notNull;
drh0ca3e242002-01-29 23:07:02 +0000418 if( onError==OE_None ) continue;
drh9cfcf5d2002-01-29 18:41:24 +0000419 if( overrideError!=OE_Default ){
420 onError = overrideError;
drh1c928532002-01-31 15:54:21 +0000421 }else if( onError==OE_Default ){
drh0d65dc02002-02-03 00:56:09 +0000422 onError = pParse->db->onError;
423 if( onError==OE_Default ) onError = OE_Abort;
drh9cfcf5d2002-01-29 18:41:24 +0000424 }
425 if( onError==OE_Replace && pTab->aCol[i].zDflt==0 ){
426 onError = OE_Abort;
427 }
drhef6764a2002-01-30 04:32:00 +0000428 sqliteVdbeAddOp(v, OP_Dup, nCol-1-i, 1);
429 addr = sqliteVdbeAddOp(v, OP_NotNull, 0, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000430 switch( onError ){
drh1c928532002-01-31 15:54:21 +0000431 case OE_Rollback:
432 case OE_Abort:
433 case OE_Fail: {
434 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
drh9cfcf5d2002-01-29 18:41:24 +0000435 break;
436 }
437 case OE_Ignore: {
drhb419a922002-01-30 16:17:23 +0000438 sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0);
drh0ca3e242002-01-29 23:07:02 +0000439 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
drh9cfcf5d2002-01-29 18:41:24 +0000440 break;
441 }
442 case OE_Replace: {
443 sqliteVdbeAddOp(v, OP_String, 0, 0);
444 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
445 sqliteVdbeAddOp(v, OP_Push, nCol-i, 0);
446 break;
447 }
drh0ca3e242002-01-29 23:07:02 +0000448 default: assert(0);
drh9cfcf5d2002-01-29 18:41:24 +0000449 }
drhef6764a2002-01-30 04:32:00 +0000450 sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v));
drh9cfcf5d2002-01-29 18:41:24 +0000451 }
452
453 /* Test all CHECK constraints
454 */
455
456 /* Test all UNIQUE constraints. Add index records as we go.
457 */
drh0d65dc02002-02-03 00:56:09 +0000458 if( (recnoChng || !isUpdate) && pTab->iPKey>=0 ){
drh0ca3e242002-01-29 23:07:02 +0000459 onError = pTab->keyConf;
460 if( overrideError!=OE_Default ){
461 onError = overrideError;
drh1c928532002-01-31 15:54:21 +0000462 }else if( onError==OE_Default ){
drh0d65dc02002-02-03 00:56:09 +0000463 onError = pParse->db->onError;
464 if( onError==OE_Default ) onError = OE_Abort;
drh0ca3e242002-01-29 23:07:02 +0000465 }
drh0d65dc02002-02-03 00:56:09 +0000466 if( onError!=OE_Replace ){
467 sqliteVdbeAddOp(v, OP_Dup, nCol, 1);
468 jumpInst = sqliteVdbeAddOp(v, OP_NotExists, base, 0);
469 switch( onError ){
470 case OE_Rollback:
471 case OE_Abort:
472 case OE_Fail: {
473 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
474 break;
475 }
476 case OE_Ignore: {
477 sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0);
478 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
479 break;
480 }
481 default: assert(0);
drh0ca3e242002-01-29 23:07:02 +0000482 }
drh0d65dc02002-02-03 00:56:09 +0000483 contAddr = sqliteVdbeCurrentAddr(v);
484 sqliteVdbeChangeP2(v, jumpInst, contAddr);
485 if( isUpdate ){
486 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
487 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
drh0ca3e242002-01-29 23:07:02 +0000488 }
drh0ca3e242002-01-29 23:07:02 +0000489 }
490 }
drh9cfcf5d2002-01-29 18:41:24 +0000491 extra = 0;
492 for(extra=(-1), iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
drh9cfcf5d2002-01-29 18:41:24 +0000493 if( aIdxUsed && aIdxUsed[iCur]==0 ) continue;
494 extra++;
495 sqliteVdbeAddOp(v, OP_Dup, nCol+extra, 1);
496 for(i=0; i<pIdx->nColumn; i++){
497 int idx = pIdx->aiColumn[i];
498 if( idx==pTab->iPKey ){
drh0ca3e242002-01-29 23:07:02 +0000499 sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1);
drh9cfcf5d2002-01-29 18:41:24 +0000500 }else{
drh0ca3e242002-01-29 23:07:02 +0000501 sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1);
drh9cfcf5d2002-01-29 18:41:24 +0000502 }
503 }
504 sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0);
505 onError = pIdx->onError;
506 if( onError==OE_None ) continue;
507 if( overrideError!=OE_Default ){
508 onError = overrideError;
drh1c928532002-01-31 15:54:21 +0000509 }else if( onError==OE_Default ){
drh0d65dc02002-02-03 00:56:09 +0000510 onError = pParse->db->onError;
511 if( onError==OE_Default ) onError = OE_Abort;
drh9cfcf5d2002-01-29 18:41:24 +0000512 }
drhb419a922002-01-30 16:17:23 +0000513 sqliteVdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRecnos, 1);
drh0ca3e242002-01-29 23:07:02 +0000514 jumpInst = sqliteVdbeAddOp(v, OP_IsUnique, base+iCur+1, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000515 switch( onError ){
drh1c928532002-01-31 15:54:21 +0000516 case OE_Rollback:
517 case OE_Abort:
518 case OE_Fail: {
519 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
drh9cfcf5d2002-01-29 18:41:24 +0000520 break;
521 }
522 case OE_Ignore: {
drh0ca3e242002-01-29 23:07:02 +0000523 assert( seenReplace==0 );
drhb419a922002-01-30 16:17:23 +0000524 sqliteVdbeAddOp(v, OP_Pop, nCol+extra+2+hasTwoRecnos, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000525 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
drh9cfcf5d2002-01-29 18:41:24 +0000526 break;
527 }
528 case OE_Replace: {
drh9cfcf5d2002-01-29 18:41:24 +0000529 sqliteGenerateRowDelete(v, pTab, base);
530 if( isUpdate ){
drhb419a922002-01-30 16:17:23 +0000531 sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1);
drh0ca3e242002-01-29 23:07:02 +0000532 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
drh9cfcf5d2002-01-29 18:41:24 +0000533 }
drh0ca3e242002-01-29 23:07:02 +0000534 seenReplace = 1;
drh9cfcf5d2002-01-29 18:41:24 +0000535 break;
536 }
drh0ca3e242002-01-29 23:07:02 +0000537 default: assert(0);
drh9cfcf5d2002-01-29 18:41:24 +0000538 }
539 contAddr = sqliteVdbeCurrentAddr(v);
540 sqliteVdbeChangeP2(v, jumpInst, contAddr);
541 }
542}
drh0ca3e242002-01-29 23:07:02 +0000543
544/*
545** This routine generates code to finish the INSERT or UPDATE operation
546** that was started by a prior call to sqliteGenerateConstraintChecks.
547** The stack must contain keys for all active indices followed by data
548** and the recno for the new entry. This routine creates the new
549** entries in all indices and in the main table.
550**
drhb419a922002-01-30 16:17:23 +0000551** The arguments to this routine should be the same as the first six
drh0ca3e242002-01-29 23:07:02 +0000552** arguments to sqliteGenerateConstraintChecks.
553*/
554void sqliteCompleteInsertion(
555 Parse *pParse, /* The parser context */
556 Table *pTab, /* the table into which we are inserting */
557 int base, /* Index of a read/write cursor pointing at pTab */
558 char *aIdxUsed, /* Which indices are used. NULL means all are used */
drhb419a922002-01-30 16:17:23 +0000559 int recnoChng, /* True if the record number will change */
560 int isUpdate /* True for UPDATE, False for INSERT */
drh0ca3e242002-01-29 23:07:02 +0000561){
562 int i;
563 Vdbe *v;
564 int nIdx;
565 Index *pIdx;
566
567 v = sqliteGetVdbe(pParse);
568 assert( v!=0 );
569 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
570 for(i=nIdx-1; i>=0; i--){
571 if( aIdxUsed && aIdxUsed[i]==0 ) continue;
572 sqliteVdbeAddOp(v, OP_IdxPut, base+i+1, 0);
573 }
574 sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
575 sqliteVdbeAddOp(v, OP_PutIntKey, base, 0);
drhb419a922002-01-30 16:17:23 +0000576 if( isUpdate && recnoChng ){
drh0ca3e242002-01-29 23:07:02 +0000577 sqliteVdbeAddOp(v, OP_Pop, 1, 0);
578 }
579}