monotone

monotone Mtn Source Tree

Root/sqlite/insert.c

1/*
2** 2001 September 15
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** This file contains C code routines that are called by the parser
13** to handle INSERT statements in SQLite.
14**
15** $Id: insert.c,v 1.1 2003/08/05 23:03:07 graydon Exp $
16*/
17#include "sqliteInt.h"
18
19/*
20** This routine is call to handle SQL of the following forms:
21**
22** insert into TABLE (IDLIST) values(EXPRLIST)
23** insert into TABLE (IDLIST) select
24**
25** 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
27** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted.
28**
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.
33**
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
85*/
86void sqliteInsert(
87 Parse *pParse, /* Parser context */
88 SrcList *pTabList, /* Name of table into which we are inserting */
89 ExprList *pList, /* List of values to be inserted */
90 Select *pSelect, /* A SELECT statement to use as the data source */
91 IdList *pColumn, /* Column names corresponding to IDLIST. */
92 int onError /* How to handle constraint errors */
93){
94 Table *pTab; /* The table to insert into */
95 char *zTab; /* Name of the table into which we are inserting */
96 const char *zDb; /* Name of the database holding this table */
97 int i, j, idx; /* Loop counters */
98 Vdbe *v; /* Generate code into this virtual machine */
99 Index *pIdx; /* For looping over indices of the table */
100 int nColumn; /* Number of columns in the data */
101 int base; /* VDBE Cursor number for pTab */
102 int iCont, iBreak; /* Beginning and end of the loop over srcTab */
103 sqlite *db; /* The main database structure */
104 int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
105 int endOfLoop; /* Label for the end of the insertion loop */
106 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 */
112 int isView; /* True if attempting to insert into a view */
113
114 int row_triggers_exist = 0; /* True if there are FOR EACH ROW triggers */
115 int before_triggers; /* True if there are BEFORE triggers */
116 int after_triggers; /* True if there are AFTER triggers */
117 int newIdx = -1; /* Cursor for the NEW table */
118
119 if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
120 db = pParse->db;
121
122 /* Locate the table into which we will be inserting new information.
123 */
124 assert( pTabList->nSrc==1 );
125 zTab = pTabList->a[0].zName;
126 if( zTab==0 ) goto insert_cleanup;
127 pTab = sqliteSrcListLookup(pParse, pTabList);
128 if( pTab==0 ){
129 goto insert_cleanup;
130 }
131 assert( pTab->iDb<db->nDb );
132 zDb = db->aDb[pTab->iDb].zName;
133 if( sqliteAuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
134 goto insert_cleanup;
135 }
136
137 /* Ensure that:
138 * (a) the table is not read-only,
139 * (b) that if it is a view then ON INSERT triggers exist
140 */
141 before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT,
142 TK_BEFORE, TK_ROW, 0);
143 after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT,
144 TK_AFTER, TK_ROW, 0);
145 row_triggers_exist = before_triggers || after_triggers;
146 isView = pTab->pSelect!=0;
147 if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){
148 goto insert_cleanup;
149 }
150 if( pTab==0 ) goto insert_cleanup;
151
152 /* If pTab is really a view, make sure it has been initialized.
153 */
154 if( isView && sqliteViewGetColumnNames(pParse, pTab) ){
155 goto insert_cleanup;
156 }
157
158 /* Allocate a VDBE
159 */
160 v = sqliteGetVdbe(pParse);
161 if( v==0 ) goto insert_cleanup;
162 sqliteBeginWriteOperation(pParse, pSelect || row_triggers_exist, pTab->iDb);
163
164 /* if there are row triggers, allocate a temp table for new.* references. */
165 if( row_triggers_exist ){
166 newIdx = pParse->nTab++;
167 }
168
169 /* Figure out how many columns of data are supplied. If the data
170 ** is coming from a SELECT statement, then this step also generates
171 ** all the code to implement the SELECT statement and invoke a subroutine
172 ** to process each row of the result. (Template 2.) If the SELECT
173 ** statement uses the the table that is being inserted into, then the
174 ** subroutine is also coded here. That subroutine stores the SELECT
175 ** results in a temporary table. (Template 3.)
176 */
177 if( pSelect ){
178 /* Data is coming from a SELECT. Generate code to implement that SELECT
179 */
180 int rc, iInitCode;
181 iInitCode = sqliteVdbeAddOp(v, OP_Goto, 0, 0);
182 iSelectLoop = sqliteVdbeCurrentAddr(v);
183 iInsertBlock = sqliteVdbeMakeLabel(v);
184 rc = sqliteSelect(pParse, pSelect, SRT_Subroutine, iInsertBlock, 0,0,0);
185 if( rc || pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
186 iCleanup = sqliteVdbeMakeLabel(v);
187 sqliteVdbeAddOp(v, OP_Goto, 0, iCleanup);
188 assert( pSelect->pEList );
189 nColumn = pSelect->pEList->nExpr;
190
191 /* Set useTempTable to TRUE if the result of the SELECT statement
192 ** should be written into a temporary table. Set to FALSE if each
193 ** row of the SELECT can be written directly into the result table.
194 **
195 ** A temp table must be used if the table being updated is also one
196 ** of the tables being read by the SELECT statement. Also use a
197 ** temp table in the case of row triggers.
198 */
199 if( row_triggers_exist ){
200 useTempTable = 1;
201 }else{
202 int addr = sqliteVdbeFindOp(v, OP_OpenRead, pTab->tnum);
203 useTempTable = 0;
204 if( addr>0 ){
205 VdbeOp *pOp = sqliteVdbeGetOp(v, addr-2);
206 if( pOp->opcode==OP_Integer && pOp->p1==pTab->iDb ){
207 useTempTable = 1;
208 }
209 }
210 }
211
212 if( useTempTable ){
213 /* Generate the subroutine that SELECT calls to process each row of
214 ** the result. Store the result in a temporary table
215 */
216 srcTab = pParse->nTab++;
217 sqliteVdbeResolveLabel(v, iInsertBlock);
218 sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0);
219 sqliteVdbeAddOp(v, OP_NewRecno, srcTab, 0);
220 sqliteVdbeAddOp(v, OP_Pull, 1, 0);
221 sqliteVdbeAddOp(v, OP_PutIntKey, srcTab, 0);
222 sqliteVdbeAddOp(v, OP_Return, 0, 0);
223
224 /* The following code runs first because the GOTO at the very top
225 ** of the program jumps to it. Create the temporary table, then jump
226 ** back up and execute the SELECT code above.
227 */
228 sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v));
229 sqliteVdbeAddOp(v, OP_OpenTemp, srcTab, 0);
230 sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop);
231 sqliteVdbeResolveLabel(v, iCleanup);
232 }else{
233 sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v));
234 }
235 }else{
236 /* This is the case if the data for the INSERT is coming from a VALUES
237 ** clause
238 */
239 SrcList dummy;
240 assert( pList!=0 );
241 srcTab = -1;
242 useTempTable = 0;
243 assert( pList );
244 nColumn = pList->nExpr;
245 dummy.nSrc = 0;
246 for(i=0; i<nColumn; i++){
247 if( sqliteExprResolveIds(pParse, &dummy, 0, pList->a[i].pExpr) ){
248 goto insert_cleanup;
249 }
250 if( sqliteExprCheck(pParse, pList->a[i].pExpr, 0, 0) ){
251 goto insert_cleanup;
252 }
253 }
254 }
255
256 /* Make sure the number of columns in the source data matches the number
257 ** of columns to be inserted into the table.
258 */
259 if( pColumn==0 && nColumn!=pTab->nCol ){
260 sqliteErrorMsg(pParse,
261 "table %S has %d columns but %d values were supplied",
262 pTabList, 0, pTab->nCol, nColumn);
263 goto insert_cleanup;
264 }
265 if( pColumn!=0 && nColumn!=pColumn->nId ){
266 sqliteErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
267 goto insert_cleanup;
268 }
269
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.
273 **
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.)
280 */
281 if( pColumn ){
282 for(i=0; i<pColumn->nId; i++){
283 pColumn->a[i].idx = -1;
284 }
285 for(i=0; i<pColumn->nId; i++){
286 for(j=0; j<pTab->nCol; j++){
287 if( sqliteStrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
288 pColumn->a[i].idx = j;
289 if( j==pTab->iPKey ){
290 keyColumn = i;
291 }
292 break;
293 }
294 }
295 if( j>=pTab->nCol ){
296 if( sqliteIsRowid(pColumn->a[i].zName) ){
297 keyColumn = i;
298 }else{
299 sqliteErrorMsg(pParse, "table %S has no column named %s",
300 pTabList, 0, pColumn->a[i].zName);
301 pParse->nErr++;
302 goto insert_cleanup;
303 }
304 }
305 }
306 }
307
308 /* If there is no IDLIST term but the table has an integer primary
309 ** key, the set the keyColumn variable to the primary key column index
310 ** in the original table definition.
311 */
312 if( pColumn==0 ){
313 keyColumn = pTab->iPKey;
314 }
315
316 /* Open the temp table for FOR EACH ROW triggers
317 */
318 if( row_triggers_exist ){
319 sqliteVdbeAddOp(v, OP_OpenPseudo, newIdx, 0);
320 }
321
322 /* Initialize the count of rows to be inserted
323 */
324 if( db->flags & SQLITE_CountRows ){
325 iCntMem = pParse->nMem++;
326 sqliteVdbeAddOp(v, OP_Integer, 0, 0);
327 sqliteVdbeAddOp(v, OP_MemStore, iCntMem, 1);
328 }
329
330 /* Open tables and indices if there are no row triggers */
331 if( !row_triggers_exist ){
332 base = pParse->nTab;
333 sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0);
334 sqliteVdbeAddOp(v, OP_OpenWrite, base, pTab->tnum);
335 sqliteVdbeChangeP3(v, -1, pTab->zName, P3_STATIC);
336 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
337 sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0);
338 sqliteVdbeAddOp(v, OP_OpenWrite, idx+base, pIdx->tnum);
339 sqliteVdbeChangeP3(v, -1, pIdx->zName, P3_STATIC);
340 }
341 pParse->nTab += idx;
342 }
343
344 /* If the data source is a temporary table, then we have to create
345 ** a loop because there might be multiple rows of data. If the data
346 ** source is a subroutine call from the SELECT statement, then we need
347 ** to launch the SELECT statement processing.
348 */
349 if( useTempTable ){
350 iBreak = sqliteVdbeMakeLabel(v);
351 sqliteVdbeAddOp(v, OP_Rewind, srcTab, iBreak);
352 iCont = sqliteVdbeCurrentAddr(v);
353 }else if( pSelect ){
354 sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop);
355 sqliteVdbeResolveLabel(v, iInsertBlock);
356 }
357
358 /* Run the BEFORE and INSTEAD OF triggers, if there are any
359 */
360 endOfLoop = sqliteVdbeMakeLabel(v);
361 if( before_triggers ){
362
363 /* build the NEW.* reference row. Note that if there is an INTEGER
364 ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
365 ** translated into a unique ID for the row. But on a BEFORE trigger,
366 ** we do not know what the unique ID will be (because the insert has
367 ** not happened yet) so we substitute a rowid of -1
368 */
369 if( keyColumn<0 ){
370 sqliteVdbeAddOp(v, OP_Integer, -1, 0);
371 }else if( useTempTable ){
372 sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn);
373 }else if( pSelect ){
374 sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1);
375 }else{
376 sqliteExprCode(pParse, pList->a[keyColumn].pExpr);
377 sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3);
378 sqliteVdbeAddOp(v, OP_Pop, 1, 0);
379 sqliteVdbeAddOp(v, OP_Integer, -1, 0);
380 sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0);
381 }
382
383 /* Create the new column data
384 */
385 for(i=0; i<pTab->nCol; i++){
386 if( pColumn==0 ){
387 j = i;
388 }else{
389 for(j=0; j<pColumn->nId; j++){
390 if( pColumn->a[j].idx==i ) break;
391 }
392 }
393 if( pColumn && j>=pColumn->nId ){
394 sqliteVdbeAddOp(v, OP_String, 0, 0);
395 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
396 }else if( useTempTable ){
397 sqliteVdbeAddOp(v, OP_Column, srcTab, j);
398 }else if( pSelect ){
399 sqliteVdbeAddOp(v, OP_Dup, nColumn-j-1, 1);
400 }else{
401 sqliteExprCode(pParse, pList->a[j].pExpr);
402 }
403 }
404 sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
405 sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0);
406
407 /* Fire BEFORE or INSTEAD OF triggers */
408 if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_BEFORE, pTab,
409 newIdx, -1, onError, endOfLoop) ){
410 goto insert_cleanup;
411 }
412 }
413
414 /* If any triggers exists, the opening of tables and indices is deferred
415 ** until now.
416 */
417 if( row_triggers_exist && !isView ){
418 base = pParse->nTab;
419 sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0);
420 sqliteVdbeAddOp(v, OP_OpenWrite, base, pTab->tnum);
421 sqliteVdbeChangeP3(v, -1, pTab->zName, P3_STATIC);
422 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
423 sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0);
424 sqliteVdbeAddOp(v, OP_OpenWrite, idx+base, pIdx->tnum);
425 sqliteVdbeChangeP3(v, -1, pIdx->zName, P3_STATIC);
426 }
427 pParse->nTab += idx;
428 }
429
430 /* Push the record number for the new entry onto the stack. The
431 ** record number is a randomly generate integer created by NewRecno
432 ** except when the table has an INTEGER PRIMARY KEY column, in which
433 ** case the record number is the same as that column.
434 */
435 if( !isView ){
436 if( keyColumn>=0 ){
437 if( useTempTable ){
438 sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn);
439 }else if( pSelect ){
440 sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1);
441 }else{
442 sqliteExprCode(pParse, pList->a[keyColumn].pExpr);
443 }
444 /* If the PRIMARY KEY expression is NULL, then use OP_NewRecno
445 ** to generate a unique primary key value.
446 */
447 sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3);
448 sqliteVdbeAddOp(v, OP_Pop, 1, 0);
449 sqliteVdbeAddOp(v, OP_NewRecno, base, 0);
450 sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0);
451 }else{
452 sqliteVdbeAddOp(v, OP_NewRecno, base, 0);
453 }
454
455 /* Push onto the stack, data for all columns of the new entry, beginning
456 ** with the first column.
457 */
458 for(i=0; i<pTab->nCol; i++){
459 if( i==pTab->iPKey ){
460 /* The value of the INTEGER PRIMARY KEY column is always a NULL.
461 ** Whenever this column is read, the record number will be substituted
462 ** in its place. So will fill this column with a NULL to avoid
463 ** taking up data space with information that will never be used. */
464 sqliteVdbeAddOp(v, OP_String, 0, 0);
465 continue;
466 }
467 if( pColumn==0 ){
468 j = i;
469 }else{
470 for(j=0; j<pColumn->nId; j++){
471 if( pColumn->a[j].idx==i ) break;
472 }
473 }
474 if( pColumn && j>=pColumn->nId ){
475 sqliteVdbeAddOp(v, OP_String, 0, 0);
476 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
477 }else if( useTempTable ){
478 sqliteVdbeAddOp(v, OP_Column, srcTab, j);
479 }else if( pSelect ){
480 sqliteVdbeAddOp(v, OP_Dup, i+nColumn-j, 1);
481 }else{
482 sqliteExprCode(pParse, pList->a[j].pExpr);
483 }
484 }
485
486 /* Generate code to check constraints and generate index keys and
487 ** do the insertion.
488 */
489 sqliteGenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0,
490 0, onError, endOfLoop);
491 sqliteCompleteInsertion(pParse, pTab, base, 0,0,0,
492 after_triggers ? newIdx : -1);
493 }
494
495 /* Update the count of rows that are inserted
496 */
497 if( (db->flags & SQLITE_CountRows)!=0 ){
498 sqliteVdbeAddOp(v, OP_MemIncr, iCntMem, 0);
499 }
500
501 if( row_triggers_exist ){
502 /* Close all tables opened */
503 if( !isView ){
504 sqliteVdbeAddOp(v, OP_Close, base, 0);
505 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
506 sqliteVdbeAddOp(v, OP_Close, idx+base, 0);
507 }
508 }
509
510 /* Code AFTER triggers */
511 if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_AFTER, pTab, newIdx, -1,
512 onError, endOfLoop) ){
513 goto insert_cleanup;
514 }
515 }
516
517 /* The bottom of the loop, if the data source is a SELECT statement
518 */
519 sqliteVdbeResolveLabel(v, endOfLoop);
520 if( useTempTable ){
521 sqliteVdbeAddOp(v, OP_Next, srcTab, iCont);
522 sqliteVdbeResolveLabel(v, iBreak);
523 sqliteVdbeAddOp(v, OP_Close, srcTab, 0);
524 }else if( pSelect ){
525 sqliteVdbeAddOp(v, OP_Pop, nColumn, 0);
526 sqliteVdbeAddOp(v, OP_Return, 0, 0);
527 sqliteVdbeResolveLabel(v, iCleanup);
528 }
529
530 if( !row_triggers_exist ){
531 /* Close all tables opened */
532 sqliteVdbeAddOp(v, OP_Close, base, 0);
533 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
534 sqliteVdbeAddOp(v, OP_Close, idx+base, 0);
535 }
536 }
537
538 sqliteEndWriteOperation(pParse);
539
540 /*
541 ** Return the number of rows inserted.
542 */
543 if( db->flags & SQLITE_CountRows ){
544 sqliteVdbeAddOp(v, OP_ColumnName, 0, 0);
545 sqliteVdbeChangeP3(v, -1, "rows inserted", P3_STATIC);
546 sqliteVdbeAddOp(v, OP_MemLoad, iCntMem, 0);
547 sqliteVdbeAddOp(v, OP_Callback, 1, 0);
548 }
549
550insert_cleanup:
551 sqliteSrcListDelete(pTabList);
552 if( pList ) sqliteExprListDelete(pList);
553 if( pSelect ) sqliteSelectDelete(pSelect);
554 sqliteIdListDelete(pColumn);
555}
556
557/*
558** Generate code to do a constraint check prior to an INSERT or an UPDATE.
559**
560** When this routine is called, the stack contains (from bottom to top)
561** the following values:
562**
563** 1. The recno of the row to be updated before the update. This
564** value is omitted unless we are doing an UPDATE that involves a
565** change to the record number.
566**
567** 2. The recno of the row after the update.
568**
569** 3. The data in the first column of the entry after the update.
570**
571** i. Data from middle columns...
572**
573** N. The data in the last column of the entry after the update.
574**
575** The old recno shown as entry (1) above is omitted unless both isUpdate
576** and recnoChng are 1. isUpdate is true for UPDATEs and false for
577** INSERTs and recnoChng is true if the record number is being changed.
578**
579** The code generated by this routine pushes additional entries onto
580** the stack which are the keys for new index entries for the new record.
581** The order of index keys is the same as the order of the indices on
582** the pTable->pIndex list. A key is only created for index i if
583** aIdxUsed!=0 and aIdxUsed[i]!=0.
584**
585** This routine also generates code to check constraints. NOT NULL,
586** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
587** then the appropriate action is performed. There are five possible
588** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
589**
590** Constraint type Action What Happens
591** --------------- ---------- ----------------------------------------
592** any ROLLBACK The current transaction is rolled back and
593** sqlite_exec() returns immediately with a
594** return code of SQLITE_CONSTRAINT.
595**
596** any ABORT Back out changes from the current command
597** only (do not do a complete rollback) then
598** cause sqlite_exec() to return immediately
599** with SQLITE_CONSTRAINT.
600**
601** any FAIL Sqlite_exec() returns immediately with a
602** return code of SQLITE_CONSTRAINT. The
603** transaction is not rolled back and any
604** prior changes are retained.
605**
606** any IGNORE The record number and data is popped from
607** the stack and there is an immediate jump
608** to label ignoreDest.
609**
610** NOT NULL REPLACE The NULL value is replace by the default
611** value for that column. If the default value
612** is NULL, the action is the same as ABORT.
613**
614** UNIQUE REPLACE The other row that conflicts with the row
615** being inserted is removed.
616**
617** CHECK REPLACE Illegal. The results in an exception.
618**
619** Which action to take is determined by the overrideError parameter.
620** Or if overrideError==OE_Default, then the pParse->onError parameter
621** is used. Or if pParse->onError==OE_Default then the onError value
622** for the constraint is used.
623**
624** The calling routine must open a read/write cursor for pTab with
625** cursor number "base". All indices of pTab must also have open
626** read/write cursors with cursor number base+i for the i-th cursor.
627** Except, if there is no possibility of a REPLACE action then
628** cursors do not need to be open for indices where aIdxUsed[i]==0.
629**
630** If the isUpdate flag is true, it means that the "base" cursor is
631** initially pointing to an entry that is being updated. The isUpdate
632** flag causes extra code to be generated so that the "base" cursor
633** is still pointing at the same entry after the routine returns.
634** Without the isUpdate flag, the "base" cursor might be moved.
635*/
636void sqliteGenerateConstraintChecks(
637 Parse *pParse, /* The parser context */
638 Table *pTab, /* the table into which we are inserting */
639 int base, /* Index of a read/write cursor pointing at pTab */
640 char *aIdxUsed, /* Which indices are used. NULL means all are used */
641 int recnoChng, /* True if the record number will change */
642 int isUpdate, /* True for UPDATE, False for INSERT */
643 int overrideError, /* Override onError to this if not OE_Default */
644 int ignoreDest /* Jump to this label on an OE_Ignore resolution */
645){
646 int i;
647 Vdbe *v;
648 int nCol;
649 int onError;
650 int addr;
651 int extra;
652 int iCur;
653 Index *pIdx;
654 int seenReplace = 0;
655 int jumpInst1, jumpInst2;
656 int contAddr;
657 int hasTwoRecnos = (isUpdate && recnoChng);
658
659 v = sqliteGetVdbe(pParse);
660 assert( v!=0 );
661 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
662 nCol = pTab->nCol;
663
664 /* Test all NOT NULL constraints.
665 */
666 for(i=0; i<nCol; i++){
667 if( i==pTab->iPKey ){
668 continue;
669 }
670 onError = pTab->aCol[i].notNull;
671 if( onError==OE_None ) continue;
672 if( overrideError!=OE_Default ){
673 onError = overrideError;
674 }else if( pParse->db->onError!=OE_Default ){
675 onError = pParse->db->onError;
676 }else if( onError==OE_Default ){
677 onError = OE_Abort;
678 }
679 if( onError==OE_Replace && pTab->aCol[i].zDflt==0 ){
680 onError = OE_Abort;
681 }
682 sqliteVdbeAddOp(v, OP_Dup, nCol-1-i, 1);
683 addr = sqliteVdbeAddOp(v, OP_NotNull, 1, 0);
684 switch( onError ){
685 case OE_Rollback:
686 case OE_Abort:
687 case OE_Fail: {
688 char *zMsg = 0;
689 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
690 sqliteSetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName,
691 " may not be NULL", 0);
692 sqliteVdbeChangeP3(v, -1, zMsg, P3_DYNAMIC);
693 break;
694 }
695 case OE_Ignore: {
696 sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0);
697 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
698 break;
699 }
700 case OE_Replace: {
701 sqliteVdbeAddOp(v, OP_String, 0, 0);
702 sqliteVdbeChangeP3(v, -1, pTab->aCol[i].zDflt, P3_STATIC);
703 sqliteVdbeAddOp(v, OP_Push, nCol-i, 0);
704 break;
705 }
706 default: assert(0);
707 }
708 sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v));
709 }
710
711 /* Test all CHECK constraints
712 */
713 /**** TBD ****/
714
715 /* If we have an INTEGER PRIMARY KEY, make sure the primary key
716 ** of the new record does not previously exist. Except, if this
717 ** is an UPDATE and the primary key is not changing, that is OK.
718 */
719 if( recnoChng ){
720 onError = pTab->keyConf;
721 if( overrideError!=OE_Default ){
722 onError = overrideError;
723 }else if( pParse->db->onError!=OE_Default ){
724 onError = pParse->db->onError;
725 }else if( onError==OE_Default ){
726 onError = OE_Abort;
727 }
728
729 if( isUpdate ){
730 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
731 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
732 jumpInst1 = sqliteVdbeAddOp(v, OP_Eq, 0, 0);
733 }
734 sqliteVdbeAddOp(v, OP_Dup, nCol, 1);
735 jumpInst2 = sqliteVdbeAddOp(v, OP_NotExists, base, 0);
736 switch( onError ){
737 default: {
738 onError = OE_Abort;
739 /* Fall thru into the next case */
740 }
741 case OE_Rollback:
742 case OE_Abort:
743 case OE_Fail: {
744 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
745 sqliteVdbeChangeP3(v, -1, "PRIMARY KEY must be unique", P3_STATIC);
746 break;
747 }
748 case OE_Replace: {
749 sqliteGenerateRowIndexDelete(pParse->db, v, pTab, base, 0);
750 if( isUpdate ){
751 sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1);
752 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
753 }
754 seenReplace = 1;
755 break;
756 }
757 case OE_Ignore: {
758 assert( seenReplace==0 );
759 sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0);
760 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
761 break;
762 }
763 }
764 contAddr = sqliteVdbeCurrentAddr(v);
765 sqliteVdbeChangeP2(v, jumpInst2, contAddr);
766 if( isUpdate ){
767 sqliteVdbeChangeP2(v, jumpInst1, contAddr);
768 sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1);
769 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
770 }
771 }
772
773 /* Test all UNIQUE constraints by creating entries for each UNIQUE
774 ** index and making sure that duplicate entries do not already exist.
775 ** Add the new records to the indices as we go.
776 */
777 extra = -1;
778 for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
779 if( aIdxUsed && aIdxUsed[iCur]==0 ) continue; /* Skip unused indices */
780 extra++;
781
782 /* Create a key for accessing the index entry */
783 sqliteVdbeAddOp(v, OP_Dup, nCol+extra, 1);
784 for(i=0; i<pIdx->nColumn; i++){
785 int idx = pIdx->aiColumn[i];
786 if( idx==pTab->iPKey ){
787 sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1);
788 }else{
789 sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1);
790 }
791 }
792 jumpInst1 = sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0);
793 if( pParse->db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx);
794
795 /* Find out what action to take in case there is an indexing conflict */
796 onError = pIdx->onError;
797 if( onError==OE_None ) continue; /* pIdx is not a UNIQUE index */
798 if( overrideError!=OE_Default ){
799 onError = overrideError;
800 }else if( pParse->db->onError!=OE_Default ){
801 onError = pParse->db->onError;
802 }else if( onError==OE_Default ){
803 onError = OE_Abort;
804 }
805 if( seenReplace ){
806 if( onError==OE_Ignore ) onError = OE_Replace;
807 else if( onError==OE_Fail ) onError = OE_Abort;
808 }
809
810
811 /* Check to see if the new index entry will be unique */
812 sqliteVdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRecnos, 1);
813 jumpInst2 = sqliteVdbeAddOp(v, OP_IsUnique, base+iCur+1, 0);
814
815 /* Generate code that executes if the new index entry is not unique */
816 switch( onError ){
817 case OE_Rollback:
818 case OE_Abort:
819 case OE_Fail: {
820 sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError);
821 sqliteVdbeChangeP3(v, -1, "uniqueness constraint failed", P3_STATIC);
822 break;
823 }
824 case OE_Ignore: {
825 assert( seenReplace==0 );
826 sqliteVdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRecnos, 0);
827 sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest);
828 break;
829 }
830 case OE_Replace: {
831 sqliteGenerateRowDelete(pParse->db, v, pTab, base, 0);
832 if( isUpdate ){
833 sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1);
834 sqliteVdbeAddOp(v, OP_MoveTo, base, 0);
835 }
836 seenReplace = 1;
837 break;
838 }
839 default: assert(0);
840 }
841 contAddr = sqliteVdbeCurrentAddr(v);
842#if NULL_DISTINCT_FOR_UNIQUE
843 sqliteVdbeChangeP2(v, jumpInst1, contAddr);
844#endif
845 sqliteVdbeChangeP2(v, jumpInst2, contAddr);
846 }
847}
848
849/*
850** This routine generates code to finish the INSERT or UPDATE operation
851** that was started by a prior call to sqliteGenerateConstraintChecks.
852** The stack must contain keys for all active indices followed by data
853** and the recno for the new entry. This routine creates the new
854** entries in all indices and in the main table.
855**
856** The arguments to this routine should be the same as the first six
857** arguments to sqliteGenerateConstraintChecks.
858*/
859void sqliteCompleteInsertion(
860 Parse *pParse, /* The parser context */
861 Table *pTab, /* the table into which we are inserting */
862 int base, /* Index of a read/write cursor pointing at pTab */
863 char *aIdxUsed, /* Which indices are used. NULL means all are used */
864 int recnoChng, /* True if the record number will change */
865 int isUpdate, /* True for UPDATE, False for INSERT */
866 int newIdx /* Index of NEW table for triggers. -1 if none */
867){
868 int i;
869 Vdbe *v;
870 int nIdx;
871 Index *pIdx;
872
873 v = sqliteGetVdbe(pParse);
874 assert( v!=0 );
875 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
876 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
877 for(i=nIdx-1; i>=0; i--){
878 if( aIdxUsed && aIdxUsed[i]==0 ) continue;
879 sqliteVdbeAddOp(v, OP_IdxPut, base+i+1, 0);
880 }
881 sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);
882 if( newIdx>=0 ){
883 sqliteVdbeAddOp(v, OP_Dup, 1, 0);
884 sqliteVdbeAddOp(v, OP_Dup, 1, 0);
885 sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0);
886 }
887 sqliteVdbeAddOp(v, OP_PutIntKey, base, pParse->trigStack?0:1);
888 if( isUpdate && recnoChng ){
889 sqliteVdbeAddOp(v, OP_Pop, 1, 0);
890 }
891}

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status