| blob | 9b97b99a3578abf9d2f52bf95fa002b8bf9e4663 |
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 */
17 /*
18 ** Generate code that will
19 **
20 ** (1) acquire a lock for table pTab then
21 ** (2) open pTab as cursor iCur.
22 **
23 ** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
24 ** for that table that is actually opened.
25 */
32 ){
50 }
51 }
53 /*
54 ** Return a pointer to the column affinity string associated with index
55 ** pIdx. A column affinity string has one character for each column in
56 ** the table, according to the affinity of the column:
57 **
58 ** Character Column affinity
59 ** ------------------------------
60 ** 'A' BLOB
61 ** 'B' TEXT
62 ** 'C' NUMERIC
63 ** 'D' INTEGER
64 ** 'F' REAL
65 **
66 ** An extra 'D' is appended to the end of the string to cover the
67 ** rowid that appears as the last column in every index.
68 **
69 ** Memory for the buffer containing the column index affinity string
70 ** is managed along with the rest of the Index structure. It will be
71 ** released when sqlite3DeleteIndex() is called.
72 */
75 /* The first time a column affinity string for a particular index is
76 ** required, it is allocated and populated here. It is then stored as
77 ** a member of the Index structure for subsequent use.
78 **
79 ** The column affinity string will eventually be deleted by
80 ** sqliteDeleteIndex() when the Index structure itself is cleaned
81 ** up.
82 */
89 }
101 }
105 }
107 }
110 }
112 /*
113 ** Make changes to the evolving bytecode to do affinity transformations
114 ** of values that are about to be gathered into a row for table pTab.
115 **
116 ** For ordinary (legacy, non-strict) tables:
117 ** -----------------------------------------
118 **
119 ** Compute the affinity string for table pTab, if it has not already been
120 ** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities.
121 **
122 ** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries
123 ** which were then optimized out) then this routine becomes a no-op.
124 **
125 ** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the
126 ** affinities for register iReg and following. Or if iReg==0,
127 ** then just set the P4 operand of the previous opcode (which should be
128 ** an OP_MakeRecord) to the affinity string.
129 **
130 ** A column affinity string has one character per column:
131 **
132 ** Character Column affinity
133 ** --------- ---------------
134 ** 'A' BLOB
135 ** 'B' TEXT
136 ** 'C' NUMERIC
137 ** 'D' INTEGER
138 ** 'E' REAL
139 **
140 ** For STRICT tables:
141 ** ------------------
142 **
143 ** Generate an appropropriate OP_TypeCheck opcode that will verify the
144 ** datatypes against the column definitions in pTab. If iReg==0, that
145 ** means an OP_MakeRecord opcode has already been generated and should be
146 ** the last opcode generated. The new OP_TypeCheck needs to be inserted
147 ** before the OP_MakeRecord. The new OP_TypeCheck should use the same
148 ** register set as the OP_MakeRecord. If iReg>0 then register iReg is
149 ** the first of a series of registers that will form the new record.
150 ** Apply the type checking to that array of registers.
151 */
157 /* Move the previous opcode (which should be OP_MakeRecord) forward
158 ** by one slot and insert a new OP_TypeCheck where the current
159 ** OP_MakeRecord is found */
168 /* Insert an isolated OP_Typecheck */
171 }
173 }
181 }
187 }
188 }
193 }
203 }
204 }
205 }
207 /*
208 ** Return non-zero if the table pTab in database iDb or any of its indices
209 ** have been opened at any point in the VDBE program. This is used to see if
210 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
211 ** run without using a temporary table for the results of the SELECT.
212 */
217 #ifndef SQLITE_OMIT_VIRTUALTABLE
219 #endif
229 }
233 }
234 }
235 }
236 #ifndef SQLITE_OMIT_VIRTUALTABLE
241 }
242 #endif
243 }
245 }
247 /* This walker callback will compute the union of colFlags flags for all
248 ** referenced columns in a CHECK constraint or generated column expression.
249 */
254 }
256 }
258 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
259 /*
260 ** All regular columns for table pTab have been puts into registers
261 ** starting with iRegStore. The registers that correspond to STORED
262 ** or VIRTUAL columns have not yet been initialized. This routine goes
263 ** back and computes the values for those columns based on the previously
264 ** computed normal columns.
265 */
270 ){
272 Walker w;
281 /* Before computing generated columns, first go through and make sure
282 ** that appropriate affinity has been applied to the regular columns
283 */
288 /* Change the OP_Affinity argument to '@' (NONE) for all stored
289 ** columns. '@' is the no-op affinity and those columns have not
290 ** yet been computed. */
298 }
301 }
302 jj++;
303 }
305 /* If an OP_TypeCheck was generated because the table is STRICT,
306 ** then set the P3 operand to indicate that generated columns should
307 ** not be checked */
309 }
310 }
312 /* Because there can be multiple generated columns that refer to one another,
313 ** this is a two-pass algorithm. On the first pass, mark all generated
314 ** columns as "not available".
315 */
321 }
322 }
329 /* On the second pass, compute the value of each NOT-AVAILABLE column.
330 ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will
331 ** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as
332 ** they are needed.
333 */
349 }
355 }
356 }
360 }
362 }
366 #ifndef SQLITE_OMIT_AUTOINCREMENT
367 /*
368 ** Locate or create an AutoincInfo structure associated with table pTab
369 ** which is in database iDb. Return the register number for the register
370 ** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT
371 ** table. (Also return zero when doing a VACUUM since we do not want to
372 ** update the AUTOINCREMENT counters during a VACUUM.)
373 **
374 ** There is at most one AutoincInfo structure per table even if the
375 ** same table is autoincremented multiple times due to inserts within
376 ** triggers. A new AutoincInfo structure is created if this is the
377 ** first use of table pTab. On 2nd and subsequent uses, the original
378 ** AutoincInfo structure is used.
379 **
380 ** Four consecutive registers are allocated:
381 **
382 ** (1) The name of the pTab table.
383 ** (2) The maximum ROWID of pTab.
384 ** (3) The rowid in sqlite_sequence of pTab
385 ** (4) The original value of the max ROWID in pTab, or NULL if none
386 **
387 ** The 2nd register is the one that is returned. That is all the
388 ** insert routine needs to know about.
389 */
394 ){
399 ){
404 /* Verify that the sqlite_sequence table exists and is an ordinary
405 ** rowid table with exactly two columns.
406 ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
411 ){
415 }
431 }
433 }
435 }
437 /*
438 ** This routine generates code that will initialize all of the
439 ** register used by the autoincrement tracker.
440 */
448 /* This routine is never called during trigger-generation. It is
449 ** only called from the top-level */
469 };
491 }
492 }
494 /*
495 ** Update the maximum rowid for an autoincrement calculation.
496 **
497 ** This routine should be called when the regRowid register holds a
498 ** new rowid that is about to be inserted. If that new rowid is
499 ** larger than the maximum rowid in the memId memory cell, then the
500 ** memory cell is updated.
501 */
505 }
506 }
508 /*
509 ** This routine generates the code needed to write autoincrement
510 ** maximum rowid values back into the sqlite_sequence register.
511 ** Every statement that might do an INSERT into an autoincrement
512 ** table (either directly or through triggers) needs to call this
513 ** routine just before the "exit" code.
514 */
529 };
550 }
551 }
554 }
555 #else
556 /*
557 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
558 ** above are all no-ops
559 */
560 # define autoIncBegin(A,B,C) (0)
561 # define autoIncStep(A,B,C)
565 /* Forward declaration */
572 );
574 /*
575 ** This routine is called to handle SQL of the following forms:
576 **
577 ** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),...
578 ** insert into TABLE (IDLIST) select
579 ** insert into TABLE (IDLIST) default values
580 **
581 ** The IDLIST following the table name is always optional. If omitted,
582 ** then a list of all (non-hidden) columns for the table is substituted.
583 ** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST
584 ** is omitted.
585 **
586 ** For the pSelect parameter holds the values to be inserted for the
587 ** first two forms shown above. A VALUES clause is really just short-hand
588 ** for a SELECT statement that omits the FROM clause and everything else
589 ** that follows. If the pSelect parameter is NULL, that means that the
590 ** DEFAULT VALUES form of the INSERT statement is intended.
591 **
592 ** The code generated follows one of four templates. For a simple
593 ** insert with data coming from a single-row VALUES clause, the code executes
594 ** once straight down through. Pseudo-code follows (we call this
595 ** the "1st template"):
596 **
597 ** open write cursor to <table> and its indices
598 ** put VALUES clause expressions into registers
599 ** write the resulting record into <table>
600 ** cleanup
601 **
602 ** The three remaining templates assume the statement is of the form
603 **
604 ** INSERT INTO <table> SELECT ...
605 **
606 ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
607 ** in other words if the SELECT pulls all columns from a single table
608 ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
609 ** if <table2> and <table1> are distinct tables but have identical
610 ** schemas, including all the same indices, then a special optimization
611 ** is invoked that copies raw records from <table2> over to <table1>.
612 ** See the xferOptimization() function for the implementation of this
613 ** template. This is the 2nd template.
614 **
615 ** open a write cursor to <table>
616 ** open read cursor on <table2>
617 ** transfer all records in <table2> over to <table>
618 ** close cursors
619 ** foreach index on <table>
620 ** open a write cursor on the <table> index
621 ** open a read cursor on the corresponding <table2> index
622 ** transfer all records from the read to the write cursors
623 ** close cursors
624 ** end foreach
625 **
626 ** The 3rd template is for when the second template does not apply
627 ** and the SELECT clause does not read from <table> at any time.
628 ** The generated code follows this template:
629 **
630 ** X <- A
631 ** goto B
632 ** A: setup for the SELECT
633 ** loop over the rows in the SELECT
634 ** load values into registers R..R+n
635 ** yield X
636 ** end loop
637 ** cleanup after the SELECT
638 ** end-coroutine X
639 ** B: open write cursor to <table> and its indices
640 ** C: yield X, at EOF goto D
641 ** insert the select result into <table> from R..R+n
642 ** goto C
643 ** D: cleanup
644 **
645 ** The 4th template is used if the insert statement takes its
646 ** values from a SELECT but the data is being inserted into a table
647 ** that is also read as part of the SELECT. In the third form,
648 ** we have to use an intermediate table to store the results of
649 ** the select. The template is like this:
650 **
651 ** X <- A
652 ** goto B
653 ** A: setup for the SELECT
654 ** loop over the tables in the SELECT
655 ** load value into register R..R+n
656 ** yield X
657 ** end loop
658 ** cleanup after the SELECT
659 ** end co-routine R
660 ** B: open temp table
661 ** L: yield X, at EOF goto M
662 ** insert row from R..R+n into temp table
663 ** goto L
664 ** M: open write cursor to <table> and its indices
665 ** rewind temp table
666 ** C: loop over rows of intermediate table
667 ** transfer values form intermediate table into <table>
668 ** end loop
669 ** D: cleanup
670 */
678 ){
702 /* Register allocations */
711 #ifndef SQLITE_OMIT_TRIGGER
715 #endif
721 }
725 /* If the Select object is really just a simple VALUES() list with a
726 ** single row (the common case) then keep that one row of values
727 ** and discard the other (unused) parts of the pSelect object
728 */
734 }
736 /* Locate the table into which we will be inserting new information.
737 */
742 }
748 }
751 /* Figure out if we have any triggers and if the table being
752 ** inserted into is a view
753 */
754 #ifndef SQLITE_OMIT_TRIGGER
757 #else
758 # define pTrigger 0
759 # define tmask 0
760 # define isView 0
761 #endif
762 #ifdef SQLITE_OMIT_VIEW
763 # undef isView
764 # define isView 0
765 #endif
768 #if TREETRACE_ENABLED
773 }
774 #endif
776 /* If pTab is really a view, make sure it has been initialized.
777 ** ViewGetColumnNames() is a no-op if pTab is not a view.
778 */
781 }
783 /* Cannot insert into a read-only table.
784 */
787 }
789 /* Allocate a VDBE
790 */
796 #ifndef SQLITE_OMIT_XFER_OPT
797 /* If the statement is of the form
798 **
799 ** INSERT INTO <table1> SELECT * FROM <table2>;
800 **
801 ** Then special optimizations can be applied that make the transfer
802 ** very fast and which reduce fragmentation of indices.
803 **
804 ** This is the 2nd template.
805 */
810 ){
814 }
817 /* If this is an AUTOINCREMENT table, look up the sequence number in the
818 ** sqlite_sequence table and store it in memory cell regAutoinc.
819 */
822 /* Allocate a block registers to hold the rowid and the values
823 ** for all columns of the new row.
824 */
828 regRowid++;
830 }
833 /* If the INSERT statement included an IDLIST term, then make sure
834 ** all elements of the IDLIST really are columns of the table and
835 ** remember the column indices.
836 **
837 ** If the table has an INTEGER PRIMARY KEY column and that column
838 ** is named in the IDLIST, then record in the ipkColumn variable
839 ** the index into IDLIST of the primary key column. ipkColumn is
840 ** the index of the primary key as it appears in IDLIST, not as
841 ** is appears in the original table. (The index of the INTEGER
842 ** PRIMARY KEY in the original table is pTab->iPKey.) After this
843 ** loop, if ipkColumn==(-1), that means that integer primary key
844 ** is unspecified, and hence the table is either WITHOUT ROWID or
845 ** it will automatically generated an integer primary key.
846 **
847 ** bIdListInOrder is true if the columns in IDLIST are in storage
848 ** order. This enables an optimization that avoids shuffling the
849 ** columns into storage order. False negatives are harmless,
850 ** but false positives will cause database corruption.
851 */
858 }
866 }
867 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
873 }
874 #endif
876 }
877 }
887 }
888 }
889 }
890 }
892 /* Figure out how many columns of data are supplied. If the data
893 ** is coming from a SELECT statement, then generate a co-routine that
894 ** produces a single row of the SELECT on each invocation. The
895 ** co-routine is the common header to the 3rd and 4th templates.
896 */
898 /* Data is coming from a SELECT or from a multi-row VALUES clause.
899 ** Generate a co-routine to run the SELECT. */
920 /* Set useTempTable to TRUE if the result of the SELECT statement
921 ** should be written into a temporary table (template 4). Set to
922 ** FALSE if each output row of the SELECT can be written directly into
923 ** the destination table (template 3).
924 **
925 ** A temp table must be used if the table being updated is also one
926 ** of the tables being read by the SELECT statement. Also use a
927 ** temp table in the case of row triggers.
928 */
931 }
934 /* Invoke the coroutine to extract information from the SELECT
935 ** and add it to a transient table srcTab. The code generated
936 ** here is from the 4th template:
937 **
938 ** B: open temp table
939 ** L: yield X, goto M at EOF
940 ** insert row from R..R+n into temp table
941 ** goto L
942 ** M: ...
943 */
960 }
962 /* This is the case if the data for the INSERT is coming from a
963 ** single-row VALUES clause
964 */
965 NameContext sNC;
974 }
977 }
978 }
980 /* If there is no IDLIST term but the table has an integer primary
981 ** key, the set the ipkColumn variable to the integer primary key
982 ** column index in the original table definition.
983 */
986 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
994 ipkColumn--;
995 }
996 }
997 }
998 #endif
1000 /* Make sure the number of columns in the source data matches the number
1001 ** of columns to be inserted into the table.
1002 */
1009 }
1010 }
1016 }
1017 }
1021 }
1023 /* Initialize the count of rows to be inserted
1024 */
1029 ){
1032 }
1034 /* If this is not a view, open the table and and all indices */
1042 }
1047 }
1049 }
1050 #ifndef SQLITE_OMIT_UPSERT
1057 }
1061 }
1064 }
1075 }
1076 }
1079 }
1080 #endif
1083 /* This is the top of the main insertion loop */
1085 /* This block codes the top of loop only. The complete loop is the
1086 ** following pseudocode (template 4):
1087 **
1088 ** rewind temp table, if empty goto D
1089 ** C: loop over rows of intermediate table
1090 ** transfer values form intermediate table into <table>
1091 ** end loop
1092 ** D: ...
1093 */
1097 /* This block codes the top of loop only. The complete loop is the
1098 ** following pseudocode (template 3):
1099 **
1100 ** C: yield X, at EOF goto D
1101 ** insert the select result into <table> from R..R+n
1102 ** goto C
1103 ** D: ...
1104 */
1109 /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
1110 ** SELECT, go ahead and copy the value into the rowid slot now, so that
1111 ** the value does not get overwritten by a NULL at tag-20191021-002. */
1113 }
1114 }
1116 /* Compute data for ordinary columns of the new entry. Values
1117 ** are written in storage order into registers starting with regData.
1118 ** Only ordinary columns are computed in this loop. The rowid
1119 ** (if there is one) is computed later and generated columns are
1120 ** computed after the rowid since they might depend on the value
1121 ** of the rowid.
1122 */
1127 u32 colFlags;
1130 /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
1131 ** using the rowid. So put a NULL in the IPK slot of the record to avoid
1132 ** using excess space. The file format definition requires this extra
1133 ** NULL - we cannot optimize further by skipping the column completely */
1136 }
1138 nHidden++;
1140 /* Virtual columns do not participate in OP_MakeRecord. So back up
1141 ** iRegStore by one slot to compensate for the iRegStore++ in the
1142 ** outer for() loop */
1143 iRegStore--;
1146 /* Stored columns are computed later. But if there are BEFORE
1147 ** triggers, the slots used for stored columns will be OP_Copy-ed
1148 ** to a second block of registers, so the register needs to be
1149 ** initialized to NULL to avoid an uninitialized register read */
1152 }
1155 /* Hidden columns that are not explicitly named in the INSERT
1156 ** get there default value */
1159 iRegStore);
1161 }
1162 }
1167 /* A column not named in the insert column list gets its
1168 ** default value */
1171 iRegStore);
1173 }
1176 /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */
1179 iRegStore);
1183 }
1190 }
1193 }
1194 }
1197 /* Run the BEFORE and INSTEAD OF triggers, if there are any
1198 */
1203 /* build the NEW.* reference row. Note that if there is an INTEGER
1204 ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
1205 ** translated into a unique ID for the row. But on a BEFORE trigger,
1206 ** we do not know what the unique ID will be (because the insert has
1207 ** not happened yet) so we substitute a rowid of -1
1208 */
1219 }
1224 }
1226 /* Copy the new data already generated. */
1230 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1231 /* Compute the new value for generated columns after all other
1232 ** columns have already been computed. This must be done after
1233 ** computing the ROWID in case one of the generated columns
1234 ** refers to the ROWID. */
1239 }
1240 #endif
1242 /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
1243 ** do not attempt any conversions before assembling the record.
1244 ** If this is a real table, attempt conversions as required by the
1245 ** table column affinities.
1246 */
1249 }
1251 /* Fire BEFORE or INSTEAD OF triggers */
1256 }
1260 /* The row that the VUpdate opcode will delete: none */
1262 }
1264 /* Compute the new rowid */
1268 /* Rowid already initialized at tag-20191021-001 */
1276 }
1277 }
1278 /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
1279 ** to generate a unique primary key value.
1280 */
1290 }
1292 }
1298 }
1301 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1302 /* Compute the new value for generated columns after all other
1303 ** columns have already been computed. This must be done after
1304 ** computing the ROWID in case one of the generated columns
1305 ** is derived from the INTEGER PRIMARY KEY. */
1308 }
1309 #endif
1311 /* Generate code to check constraints and generate index keys and
1312 ** do the insertion.
1313 */
1314 #ifndef SQLITE_OMIT_VIRTUALTABLE
1322 #endif
1323 {
1328 );
1331 /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
1332 ** constraints or (b) there are no triggers and this table is not a
1333 ** parent table in a foreign key constraint. It is safe to set the
1334 ** flag in the second case as if any REPLACE constraint is hit, an
1335 ** OP_Delete or OP_IdxDelete instruction will be executed on each
1336 ** cursor that is disturbed. And these instructions both clear the
1337 ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
1338 ** functionality. */
1342 );
1343 }
1344 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
1346 /* If there is a RETURNING clause, populate the rowid register with
1347 ** constant value -1, in case one or more of the returned expressions
1348 ** refer to the "rowid" of the view. */
1350 #endif
1351 }
1353 /* Update the count of rows that are inserted
1354 */
1357 }
1360 /* Code AFTER triggers */
1363 }
1365 /* The bottom of the main insertion loop, if the data source
1366 ** is a SELECT statement.
1367 */
1375 #ifdef SQLITE_DEBUG
1376 /* If we are jumping back to an OP_Yield that is preceded by an
1377 ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
1378 ** OP_ReleaseReg will be included in the loop. */
1382 }
1383 #endif
1385 }
1387 #ifndef SQLITE_OMIT_XFER_OPT
1388 insert_end:
1390 /* Update the sqlite_sequence table by storing the content of the
1391 ** maximum rowid counter values recorded while inserting into
1392 ** autoincrement tables.
1393 */
1396 }
1398 /*
1399 ** Return the number of rows inserted. If this routine is
1400 ** generating code because of a call to sqlite3NestedParse(), do not
1401 ** invoke the callback function.
1402 */
1405 }
1407 insert_cleanup:
1414 }
1416 /* Make sure "isView" and other macros defined above are undefined. Otherwise
1417 ** they may interfere with compilation of other functions in this file
1418 ** (or in another file, if this file becomes part of the amalgamation). */
1419 #ifdef isView
1420 #undef isView
1421 #endif
1422 #ifdef pTrigger
1423 #undef pTrigger
1424 #endif
1425 #ifdef tmask
1426 #undef tmask
1427 #endif
1429 /*
1430 ** Meanings of bits in of pWalker->eCode for
1431 ** sqlite3ExprReferencesUpdatedColumn()
1432 */
1436 /* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn().
1437 * Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this
1438 ** expression node references any of the
1439 ** columns that are being modifed by an UPDATE statement.
1440 */
1447 }
1450 }
1451 }
1453 }
1455 /*
1456 ** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
1457 ** only columns that are modified by the UPDATE are those for which
1458 ** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
1459 **
1460 ** Return true if CHECK constraint pExpr uses any of the
1461 ** changing columns (or the rowid if it is changing). In other words,
1462 ** return true if this CHECK constraint must be validated for
1463 ** the new row in the UPDATE statement.
1464 **
1465 ** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
1466 ** The operation of this routine is the same - return true if an only if
1467 ** the expression uses one or more of columns identified by the second and
1468 ** third arguments.
1469 */
1474 ){
1475 Walker w;
1484 }
1490 }
1492 /*
1493 ** The sqlite3GenerateConstraintChecks() routine usually wants to visit
1494 ** the indexes of a table in the order provided in the Table->pIndex list.
1495 ** However, sometimes (rarely - when there is an upsert) it wants to visit
1496 ** the indexes in a different order. The following data structures accomplish
1497 ** this.
1498 **
1499 ** The IndexIterator object is used to walk through all of the indexes
1500 ** of a table in either Index.pNext order, or in some other order established
1501 ** by an array of IndexListTerm objects.
1502 */
1517 };
1519 /* When IndexIterator.eType==1, then each index is an array of instances
1520 ** of the following object
1521 */
1525 };
1527 /* Return the first index on the list */
1536 }
1537 }
1539 /* Return the next index from the list. Return NULL when out of indexes */
1546 }
1553 }
1554 }
1556 /*
1557 ** Generate code to do constraint checks prior to an INSERT or an UPDATE
1558 ** on table pTab.
1559 **
1560 ** The regNewData parameter is the first register in a range that contains
1561 ** the data to be inserted or the data after the update. There will be
1562 ** pTab->nCol+1 registers in this range. The first register (the one
1563 ** that regNewData points to) will contain the new rowid, or NULL in the
1564 ** case of a WITHOUT ROWID table. The second register in the range will
1565 ** contain the content of the first table column. The third register will
1566 ** contain the content of the second table column. And so forth.
1567 **
1568 ** The regOldData parameter is similar to regNewData except that it contains
1569 ** the data prior to an UPDATE rather than afterwards. regOldData is zero
1570 ** for an INSERT. This routine can distinguish between UPDATE and INSERT by
1571 ** checking regOldData for zero.
1572 **
1573 ** For an UPDATE, the pkChng boolean is true if the true primary key (the
1574 ** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
1575 ** might be modified by the UPDATE. If pkChng is false, then the key of
1576 ** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
1577 **
1578 ** For an INSERT, the pkChng boolean indicates whether or not the rowid
1579 ** was explicitly specified as part of the INSERT statement. If pkChng
1580 ** is zero, it means that the either rowid is computed automatically or
1581 ** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT,
1582 ** pkChng will only be true if the INSERT statement provides an integer
1583 ** value for either the rowid column or its INTEGER PRIMARY KEY alias.
1584 **
1585 ** The code generated by this routine will store new index entries into
1586 ** registers identified by aRegIdx[]. No index entry is created for
1587 ** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
1588 ** the same as the order of indices on the linked list of indices
1589 ** at pTab->pIndex.
1590 **
1591 ** (2019-05-07) The generated code also creates a new record for the
1592 ** main table, if pTab is a rowid table, and stores that record in the
1593 ** register identified by aRegIdx[nIdx] - in other words in the first
1594 ** entry of aRegIdx[] past the last index. It is important that the
1595 ** record be generated during constraint checks to avoid affinity changes
1596 ** to the register content that occur after constraint checks but before
1597 ** the new record is inserted.
1598 **
1599 ** The caller must have already opened writeable cursors on the main
1600 ** table and all applicable indices (that is to say, all indices for which
1601 ** aRegIdx[] is not zero). iDataCur is the cursor for the main table when
1602 ** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
1603 ** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor
1604 ** for the first index in the pTab->pIndex list. Cursors for other indices
1605 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
1606 **
1607 ** This routine also generates code to check constraints. NOT NULL,
1608 ** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
1609 ** then the appropriate action is performed. There are five possible
1610 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
1611 **
1612 ** Constraint type Action What Happens
1613 ** --------------- ---------- ----------------------------------------
1614 ** any ROLLBACK The current transaction is rolled back and
1615 ** sqlite3_step() returns immediately with a
1616 ** return code of SQLITE_CONSTRAINT.
1617 **
1618 ** any ABORT Back out changes from the current command
1619 ** only (do not do a complete rollback) then
1620 ** cause sqlite3_step() to return immediately
1621 ** with SQLITE_CONSTRAINT.
1622 **
1623 ** any FAIL Sqlite3_step() returns immediately with a
1624 ** return code of SQLITE_CONSTRAINT. The
1625 ** transaction is not rolled back and any
1626 ** changes to prior rows are retained.
1627 **
1628 ** any IGNORE The attempt in insert or update the current
1629 ** row is skipped, without throwing an error.
1630 ** Processing continues with the next row.
1631 ** (There is an immediate jump to ignoreDest.)
1632 **
1633 ** NOT NULL REPLACE The NULL value is replace by the default
1634 ** value for that column. If the default value
1635 ** is NULL, the action is the same as ABORT.
1636 **
1637 ** UNIQUE REPLACE The other row that conflicts with the row
1638 ** being inserted is removed.
1639 **
1640 ** CHECK REPLACE Illegal. The results in an exception.
1641 **
1642 ** Which action to take is determined by the overrideError parameter.
1643 ** Or if overrideError==OE_Default, then the pParse->onError parameter
1644 ** is used. Or if pParse->onError==OE_Default then the onError value
1645 ** for the constraint is used.
1646 */
1661 ){
1679 /* Variables associated with retesting uniqueness constraints after
1680 ** replace triggers fire have run */
1695 /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
1696 ** normal rowid tables. nPkField is the number of key fields in the
1697 ** pPk index or 1 for a rowid table. In other words, nPkField is the
1698 ** number of fields in the true primary key of the table. */
1705 }
1707 /* Record that this module has started */
1711 /* Test all NOT NULL constraints.
1712 */
1726 }
1729 nGenerated++;
1731 }
1733 /* Do not check NOT NULL on columns that do not change */
1735 }
1740 }
1744 ){
1751 }
1754 }
1764 nSeenReplace++;
1769 }
1772 /* no break */ deliberate_fall_through
1783 }
1789 }
1793 /* If there are no generated columns with NOT NULL constraints
1794 ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
1795 ** pass is sufficient */
1797 }
1800 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1802 /* If any NOT NULL ON CONFLICT REPLACE constraints fired on the
1803 ** first pass, recomputed values for all generated columns, as
1804 ** those values might depend on columns affected by the REPLACE.
1805 */
1807 }
1808 #endif
1812 /* Test all CHECK constraints
1813 */
1814 #ifndef SQLITE_OMIT_CHECK
1825 ){
1826 /* The check constraints do not reference any of the columns being
1827 ** updated so there is no point it verifying the check constraint */
1829 }
1833 }
1839 }
1849 P5_ConstraintCheck);
1850 }
1852 }
1854 }
1857 /* UNIQUE and PRIMARY KEY constraints should be handled in the following
1858 ** order:
1859 **
1860 ** (1) OE_Update
1861 ** (2) OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
1862 ** (3) OE_Replace
1863 **
1864 ** OE_Fail and OE_Ignore must happen before any changes are made.
1865 ** OE_Update guarantees that only a single row will change, so it
1866 ** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback
1867 ** could happen in any order, but they are grouped up front for
1868 ** convenience.
1869 **
1870 ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
1871 ** The order of constraints used to have OE_Update as (2) and OE_Abort
1872 ** and so forth as (1). But apparently PostgreSQL checks the OE_Update
1873 ** constraint before any others, so it had to be moved.
1874 **
1875 ** Constraint checking code is generated in this order:
1876 ** (A) The rowid constraint
1877 ** (B) Unique index constraints that do not have OE_Replace as their
1878 ** default conflict resolution strategy
1879 ** (C) Unique index that do use OE_Replace by default.
1880 **
1881 ** The ordering of (2) and (3) is accomplished by making sure the linked
1882 ** list of indexes attached to a table puts all OE_Replace indexes last
1883 ** in the list. See sqlite3CreateIndex() for where that happens.
1884 */
1891 /* There is just on ON CONFLICT clause and it has no constraint-target */
1894 /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
1895 ** Make all unique constraint resolution be OE_Ignore */
1899 /* A single ON CONFLICT DO UPDATE. Make all resolutions OE_Update */
1901 }
1903 /* Otherwise, we'll need to run the IndexListTerm array version of the
1904 ** iterator to ensure that all of the ON CONFLICT conditions are
1905 ** checked first and in order. */
1907 u64 nByte;
1912 }
1927 jj++;
1928 }
1933 i++;
1934 }
1939 i++;
1940 }
1942 }
1943 }
1945 /* Determine if it is possible that triggers (either explicitly coded
1946 ** triggers or FK resolution actions) might run as a result of deletes
1947 ** that happen when OE_Replace conflict resolution occurs. (Call these
1948 ** "replace triggers".) If any replace triggers run, we will need to
1949 ** recheck all of the uniqueness constraints after they have all run.
1950 ** But on the recheck, the resolution is OE_Abort instead of OE_Replace.
1951 **
1952 ** If replace triggers are a possibility, then
1953 **
1954 ** (1) Allocate register regTrigCnt and initialize it to zero.
1955 ** That register will count the number of replace triggers that
1956 ** fire. Constraint recheck only occurs if the number is positive.
1957 ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
1958 ** (3) Initialize addrRecheck and lblRecheckOk
1959 **
1960 ** The uniqueness rechecking code will create a series of tests to run
1961 ** in a second pass. The addrRecheck and lblRecheckOk variables are
1962 ** used to link together these tests which are separated from each other
1963 ** in the generate bytecode.
1964 */
1966 /* There are not DELETE triggers nor FK constraints. No constraint
1967 ** rechecks are needed. */
1977 }
1979 /* Replace triggers might exist. Allocate the counter and
1980 ** initialize it to zero. */
1986 }
1987 }
1989 /* If rowid is changing, make sure the new rowid does not previously
1990 ** exist in the table.
1991 */
1995 /* Figure out what action to take in case of a rowid collision */
2001 }
2003 /* figure out whether or not upsert applies in this case */
2011 }
2012 }
2014 /* The first ON CONFLICT clause has a conflict target other than
2015 ** the IPK. We have to jump ahead to that first ON CONFLICT clause
2016 ** and then come back here and deal with the IPK afterwards */
2018 }
2019 }
2021 /* If the response to a rowid conflict is REPLACE but the response
2022 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
2023 ** to defer the running of the rowid conflict checking until after
2024 ** the UNIQUE constraints have run.
2025 */
2030 ){
2033 }
2036 /* pkChng!=0 does not mean that the rowid has changed, only that
2037 ** it might have changed. Skip the conflict logic below if the rowid
2038 ** is unchanged. */
2042 }
2044 /* Check to see if the new rowid already exists in the table. Skip
2045 ** the following conflict logic if it does not. */
2054 /* no break */ deliberate_fall_through
2055 }
2064 }
2066 /* If there are DELETE triggers on this table and the
2067 ** recursive-triggers flag is set, call GenerateRowDelete() to
2068 ** remove the conflicting row from the table. This will fire
2069 ** the triggers and remove both the table and index b-tree entries.
2070 **
2071 ** Otherwise, if there are no triggers or the recursive-triggers
2072 ** flag is not set, but the table has one or more indexes, call
2073 ** GenerateRowIndexDelete(). This removes the index b-tree entries
2074 ** only. The table b-tree entry will be replaced by the new entry
2075 ** when it is inserted.
2076 **
2077 ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
2078 ** also invoke MultiWrite() to indicate that this VDBE may require
2079 ** statement rollback (if the statement is aborted after the delete
2080 ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
2081 ** but being more selective here allows statements like:
2082 **
2083 ** REPLACE INTO t(rowid) VALUES($newrowid)
2084 **
2085 ** to run without a statement journal if there are no indexes on the
2086 ** table.
2087 */
2093 nReplaceTrig++;
2095 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2097 /* This OP_Delete opcode fires the pre-update-hook only. It does
2098 ** not modify the b-tree. It is more efficient to let the coming
2099 ** OP_Insert replace the existing entry than it is to delete the
2100 ** existing entry and then insert a new one. */
2107 }
2108 }
2111 }
2112 #ifndef SQLITE_OMIT_UPSERT
2115 /* no break */ deliberate_fall_through
2116 }
2117 #endif
2122 }
2123 }
2130 }
2131 }
2133 /* Test all UNIQUE constraints by creating entries for each UNIQUE
2134 ** index and making sure that duplicate entries do not already exist.
2135 ** Compute the revised record entries for indices as we go.
2136 **
2137 ** This loop also handles the case of the PRIMARY KEY index for a
2138 ** WITHOUT ROWID table.
2139 */
2141 pIdx;
2143 ){
2155 }
2156 }
2161 }
2166 /* Skip partial indices for which the WHERE clause is not true */
2171 SQLITE_JUMPIFNULL);
2173 }
2175 /* Create a record for this index entry as it should appear after
2176 ** the insert or update. Store that record in the aRegIdx[ix] register
2177 */
2196 }
2197 }
2200 #ifdef SQLITE_ENABLE_NULL_TRIM
2203 }
2204 #endif
2207 /* In an UPDATE operation, if this index is the PRIMARY KEY index
2208 ** of a WITHOUT ROWID table and there has been no change the
2209 ** primary key, then no collision is possible. The collision detection
2210 ** logic below can all be skipped. */
2214 }
2216 /* Find out what action to take in case there is a uniqueness conflict */
2221 }
2226 }
2228 /* Figure out if the upsert clause applies to this index */
2234 }
2235 }
2237 /* Collision detection may be omitted if all of the following are true:
2238 ** (1) The conflict resolution algorithm is REPLACE
2239 ** (2) The table is a WITHOUT ROWID table
2240 ** (3) There are no secondary indexes on the table
2241 ** (4) No delete triggers need to be fired if there is a conflict
2242 ** (5) No FK constraint counters need to be updated if a conflict occurs.
2243 **
2244 ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
2245 ** must be explicitly deleted in order to ensure any pre-update hook
2246 ** is invoked. */
2248 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
2256 ){
2259 }
2262 /* Check to see if the new index entry will be unique */
2264 addrConflictCk =
2268 /* Generate code to handle collisions */
2273 /* Conflict only if the rowid of the existing index entry
2274 ** is different from old-rowid */
2279 }
2282 /* Extract the PRIMARY KEY from the end of the index entry and
2283 ** store it in registers regR..regR+nPk-1 */
2291 }
2292 }
2294 /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
2295 ** table, only conflict if the new PRIMARY KEY values are actually
2296 ** different from the old. See TH3 withoutrowid04.test.
2297 **
2298 ** For a UNIQUE index, only conflict if the PRIMARY KEY values
2299 ** of the matched index row are different from the original PRIMARY
2300 ** KEY values of this row before the update. */
2312 }
2316 );
2320 }
2321 }
2322 }
2323 }
2325 /* Generate code that executes if the new index entry is not unique */
2337 }
2338 #ifndef SQLITE_OMIT_UPSERT
2341 /* no break */ deliberate_fall_through
2342 }
2343 #endif
2348 }
2359 nReplaceTrig++;
2360 }
2363 }
2369 }
2377 /* Here we insert code that will be invoked after all constraint
2378 ** checks have run, if and only if one or more replace triggers
2379 ** fired. */
2383 /* Bypass the recheck if this partial index is not defined
2384 ** for the current row */
2387 }
2388 /* Copy the constraint check code from above, except change
2389 ** the constraint-ok jump destination to be the address of
2390 ** the next retest block */
2393 /* The sqlite3VdbeAddOp4() call might reallocate the opcode array.
2394 ** Hence, make a complete copy of the opcode, rather than using
2395 ** a pointer to the opcode. */
2404 }
2409 }
2410 nConflictCk--;
2411 addrConflictCk++;
2412 }
2413 /* If the retest fails, issue an abort */
2417 }
2420 }
2421 }
2425 && upsertIpkReturn
2427 ){
2431 }
2432 }
2434 /* If the IPK constraint is a REPLACE, run it last */
2440 }
2442 /* Recheck all uniqueness constraints after replace triggers have run */
2452 }
2458 }
2460 }
2462 /* Generate the table record */
2469 }
2470 }
2474 }
2476 #ifdef SQLITE_ENABLE_NULL_TRIM
2477 /*
2478 ** Change the P5 operand on the last opcode (which should be an OP_MakeRecord)
2479 ** to be the number of columns in table pTab that must not be NULL-trimmed.
2480 **
2481 ** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
2482 */
2484 u16 i;
2486 /* Records with omitted columns are only allowed for schema format
2487 ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
2493 }
2495 }
2496 #endif
2498 /*
2499 ** Table pTab is a WITHOUT ROWID table that is being written to. The cursor
2500 ** number is iCur, and register regData contains the new record for the
2501 ** PK index. This function adds code to invoke the pre-update hook,
2502 ** if one is registered.
2503 */
2504 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2510 ){
2519 }
2520 #else
2521 # define codeWithoutRowidPreupdate(a,b,c,d)
2522 #endif
2524 /*
2525 ** This routine generates code to finish the INSERT or UPDATE operation
2526 ** that was started by a prior call to sqlite3GenerateConstraintChecks.
2527 ** A consecutive range of registers starting at regNewData contains the
2528 ** rowid and the content to be inserted.
2529 **
2530 ** The arguments to this routine should be the same as the first six
2531 ** arguments to sqlite3GenerateConstraintChecks.
2532 */
2543 ){
2552 );
2558 /* All REPLACE indexes are at the end of the list */
2566 }
2573 }
2574 }
2579 }
2586 }
2589 }
2592 }
2596 }
2598 }
2600 /*
2601 ** Allocate cursors for the pTab table and all its indices and generate
2602 ** code to open and initialized those cursors.
2603 **
2604 ** The cursor for the object that contains the complete data (normally
2605 ** the table itself, but the PRIMARY KEY index in the case of a WITHOUT
2606 ** ROWID table) is returned in *piDataCur. The first index cursor is
2607 ** returned in *piIdxCur. The number of indices is returned.
2608 **
2609 ** Use iBase as the first cursor (either the *piDataCur for rowid tables
2610 ** or the first index for WITHOUT ROWID tables) if it is non-negative.
2611 ** If iBase is negative, then allocate the next available cursor.
2612 **
2613 ** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
2614 ** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
2615 ** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the
2616 ** pTab->pIndex list.
2617 **
2618 ** If pTab is a virtual table, then this routine is a no-op and the
2619 ** *piDataCur and *piIdxCur values are left uninitialized.
2620 */
2630 ){
2640 /* This routine is a no-op for virtual tables. Leave the output
2641 ** variables *piDataCur and *piIdxCur set to illegal cursor numbers
2642 ** for improved error detection. */
2645 }
2656 }
2664 }
2670 }
2671 }
2674 }
2677 #ifdef SQLITE_TEST
2678 /*
2679 ** The following global variable is incremented whenever the
2680 ** transfer optimization is used. This is used for testing
2681 ** purposes only - to make sure the transfer optimization really
2682 ** is happening when it is supposed to.
2683 */
2688 #ifndef SQLITE_OMIT_XFER_OPT
2689 /*
2690 ** Check to see if index pSrc is compatible as a source of data
2691 ** for index pDest in an insert transfer optimization. The rules
2692 ** for a compatible index:
2693 **
2694 ** * The index is over the same set of columns
2695 ** * The same DESC and ASC markings occurs on all columns
2696 ** * The same onError processing (OE_Abort, OE_Ignore, etc)
2697 ** * The same collating sequence on each column
2698 ** * The index has the exact same WHERE clause
2699 */
2706 }
2709 }
2713 }
2719 }
2720 }
2723 }
2726 }
2727 }
2730 }
2732 /* If no test above fails then the indices must be compatible */
2734 }
2736 /*
2737 ** Attempt the transfer optimization on INSERTs of the form
2738 **
2739 ** INSERT INTO tab1 SELECT * FROM tab2;
2740 **
2741 ** The xfer optimization transfers raw records from tab2 over to tab1.
2742 ** Columns are not decoded and reassembled, which greatly improves
2743 ** performance. Raw index records are transferred in the same way.
2744 **
2745 ** The xfer optimization is only attempted if tab1 and tab2 are compatible.
2746 ** There are lots of rules for determining compatibility - see comments
2747 ** embedded in the code for details.
2748 **
2749 ** This routine returns TRUE if the optimization is guaranteed to be used.
2750 ** Sometimes the xfer optimization will only work if the destination table
2751 ** is empty - a factor that can only be determined at run-time. In that
2752 ** case, this routine generates code for the xfer optimization but also
2753 ** does a test to see if the destination table is empty and jumps over the
2754 ** xfer optimization code if the test fails. In that case, this routine
2755 ** returns FALSE so that the caller will know to go ahead and generate
2756 ** an unoptimized transfer. This routine also returns FALSE if there
2757 ** is no chance that the xfer optimization can be applied.
2758 **
2759 ** This optimization is particularly useful at making VACUUM run faster.
2760 */
2767 ){
2786 /* Do not attempt to process this query if there are an WITH clauses
2787 ** attached to it. Proceeding may generate a false "no such table: xxx"
2788 ** error if pSelect reads from a CTE named "xxx". */
2790 }
2791 #ifndef SQLITE_OMIT_VIRTUALTABLE
2794 }
2795 #endif
2799 }
2803 }
2806 }
2809 }
2812 }
2813 /* Do not need to test for a HAVING clause. If HAVING is present but
2814 ** there is no ORDER BY, we will get an error. */
2817 }
2820 }
2823 }
2826 }
2831 }
2835 }
2837 /* At this point we have established that the statement is of the
2838 ** correct syntactic form to participate in this optimization. Now
2839 ** we have to check the semantics.
2840 */
2845 }
2849 }
2852 }
2855 }
2858 }
2861 }
2864 }
2868 #ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
2871 ){
2873 }
2874 #endif
2875 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
2876 /* Even if tables t1 and t2 have identical schemas, if they contain
2877 ** generated columns, then this statement is semantically incorrect:
2878 **
2879 ** INSERT INTO t2 SELECT * FROM t1;
2880 **
2881 ** The reason is that generated column values are returned by the
2882 ** the SELECT statement on the right but the INSERT statement on the
2883 ** left wants them to be omitted.
2884 **
2885 ** Nevertheless, this is a useful notational shorthand to tell SQLite
2886 ** to do a bulk transfer all of the content from t1 over to t2.
2887 **
2888 ** We could, in theory, disable this (except for internal use by the
2889 ** VACUUM command where it is actually needed). But why do that? It
2890 ** seems harmless enough, and provides a useful service.
2891 */
2895 }
2896 /* But the transfer is only allowed if both the source and destination
2897 ** tables have the exact same expressions for generated columns.
2898 ** This requirement could be relaxed for VIRTUAL columns, I suppose.
2899 */
2907 }
2908 }
2909 #endif
2912 }
2916 }
2919 }
2920 /* Default values for second and subsequent columns need to match. */
2931 ){
2933 }
2934 }
2935 }
2939 }
2942 }
2945 }
2948 /* The sqlite3FaultSim() call allows this corruption test to be
2949 ** bypassed during testing, in order to exercise other corruption tests
2950 ** further downstream. */
2952 }
2953 }
2954 #ifndef SQLITE_OMIT_CHECK
2957 }
2958 #endif
2959 #ifndef SQLITE_OMIT_FOREIGN_KEY
2960 /* Disallow the transfer optimization if the destination table constains
2961 ** any foreign key constraints. This is more restrictive than necessary.
2962 ** But the main beneficiary of the transfer optimization is the VACUUM
2963 ** command, and the VACUUM command disables foreign key constraints. So
2964 ** the extra complication to make this rule less restrictive is probably
2965 ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
2966 */
2970 }
2971 #endif
2974 }
2976 /* If we get this far, it means that the xfer optimization is at
2977 ** least a possibility, though it might only work if the destination
2978 ** table (tab1) is initially empty.
2979 */
2980 #ifdef SQLITE_TEST
2981 sqlite3_xferopt_count++;
2982 #endif
2998 )){
2999 /* In some circumstances, we are able to run the xfer optimization
3000 ** only if the destination table is initially empty. Unless the
3001 ** DBFLAG_Vacuum flag is set, this block generates code to make
3002 ** that determination. If DBFLAG_Vacuum is set, then the destination
3003 ** table is always empty.
3004 **
3005 ** Conditions under which the destination must be empty:
3006 **
3007 ** (1) There is no INTEGER PRIMARY KEY but there are indices.
3008 ** (If the destination is not initially empty, the rowid fields
3009 ** of index entries might need to change.)
3010 **
3011 ** (2) The destination has a unique index. (The xfer optimization
3012 ** is unable to test uniqueness.)
3013 **
3014 ** (3) onError is something other than OE_Abort and OE_Rollback.
3015 */
3019 }
3021 u8 insFlags;
3032 }
3039 }
3046 }
3047 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
3052 #endif
3053 {
3055 }
3059 }
3068 }
3073 }
3084 /* This INSERT command is part of a VACUUM operation, which guarantees
3085 ** that the destination table is empty. If all indexed columns use
3086 ** collation sequence BINARY, then it can also be assumed that the
3087 ** index will be populated by inserting keys in strictly sorted
3088 ** order. In this case, instead of seeking within the b-tree as part
3089 ** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the
3090 ** OP_IdxInsert to seek to the point within the b-tree where each key
3091 ** should be inserted. This is faster.
3092 **
3093 ** If any of the indexed columns use a collation sequence other than
3094 ** BINARY, this optimization is disabled. This is because the user
3095 ** might change the definition of a collation sequence and then run
3096 ** a VACUUM command. In that case keys may not be written in strictly
3097 ** sorted order. */
3101 }
3106 }
3109 }
3115 ){
3117 }
3118 }
3125 }
3137 }
3138 }