| blob | 1f6cdffcc3828a49bf80352f99320c2f1adf9224 |
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 }
102 }
106 }
108 }
111 }
113 /*
114 ** Compute an affinity string for a table. Space is obtained
115 ** from sqlite3DbMalloc(). The caller is responsible for freeing
116 ** the space when done.
117 */
126 }
127 }
131 }
133 }
135 /*
136 ** Make changes to the evolving bytecode to do affinity transformations
137 ** of values that are about to be gathered into a row for table pTab.
138 **
139 ** For ordinary (legacy, non-strict) tables:
140 ** -----------------------------------------
141 **
142 ** Compute the affinity string for table pTab, if it has not already been
143 ** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities.
144 **
145 ** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries
146 ** which were then optimized out) then this routine becomes a no-op.
147 **
148 ** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the
149 ** affinities for register iReg and following. Or if iReg==0,
150 ** then just set the P4 operand of the previous opcode (which should be
151 ** an OP_MakeRecord) to the affinity string.
152 **
153 ** A column affinity string has one character per column:
154 **
155 ** Character Column affinity
156 ** --------- ---------------
157 ** 'A' BLOB
158 ** 'B' TEXT
159 ** 'C' NUMERIC
160 ** 'D' INTEGER
161 ** 'E' REAL
162 **
163 ** For STRICT tables:
164 ** ------------------
165 **
166 ** Generate an appropropriate OP_TypeCheck opcode that will verify the
167 ** datatypes against the column definitions in pTab. If iReg==0, that
168 ** means an OP_MakeRecord opcode has already been generated and should be
169 ** the last opcode generated. The new OP_TypeCheck needs to be inserted
170 ** before the OP_MakeRecord. The new OP_TypeCheck should use the same
171 ** register set as the OP_MakeRecord. If iReg>0 then register iReg is
172 ** the first of a series of registers that will form the new record.
173 ** Apply the type checking to that array of registers.
174 */
180 /* Move the previous opcode (which should be OP_MakeRecord) forward
181 ** by one slot and insert a new OP_TypeCheck where the current
182 ** OP_MakeRecord is found */
191 /* Insert an isolated OP_Typecheck */
194 }
196 }
203 }
205 }
215 }
216 }
217 }
219 /*
220 ** Return non-zero if the table pTab in database iDb or any of its indices
221 ** have been opened at any point in the VDBE program. This is used to see if
222 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
223 ** run without using a temporary table for the results of the SELECT.
224 */
229 #ifndef SQLITE_OMIT_VIRTUALTABLE
231 #endif
241 }
245 }
246 }
247 }
248 #ifndef SQLITE_OMIT_VIRTUALTABLE
253 }
254 #endif
255 }
257 }
259 /* This walker callback will compute the union of colFlags flags for all
260 ** referenced columns in a CHECK constraint or generated column expression.
261 */
266 }
268 }
270 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
271 /*
272 ** All regular columns for table pTab have been puts into registers
273 ** starting with iRegStore. The registers that correspond to STORED
274 ** or VIRTUAL columns have not yet been initialized. This routine goes
275 ** back and computes the values for those columns based on the previously
276 ** computed normal columns.
277 */
282 ){
284 Walker w;
293 /* Before computing generated columns, first go through and make sure
294 ** that appropriate affinity has been applied to the regular columns
295 */
300 /* Change the OP_Affinity argument to '@' (NONE) for all stored
301 ** columns. '@' is the no-op affinity and those columns have not
302 ** yet been computed. */
310 }
313 }
314 jj++;
315 }
317 /* If an OP_TypeCheck was generated because the table is STRICT,
318 ** then set the P3 operand to indicate that generated columns should
319 ** not be checked */
321 }
322 }
324 /* Because there can be multiple generated columns that refer to one another,
325 ** this is a two-pass algorithm. On the first pass, mark all generated
326 ** columns as "not available".
327 */
333 }
334 }
341 /* On the second pass, compute the value of each NOT-AVAILABLE column.
342 ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will
343 ** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as
344 ** they are needed.
345 */
361 }
367 }
368 }
372 }
374 }
378 #ifndef SQLITE_OMIT_AUTOINCREMENT
379 /*
380 ** Locate or create an AutoincInfo structure associated with table pTab
381 ** which is in database iDb. Return the register number for the register
382 ** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT
383 ** table. (Also return zero when doing a VACUUM since we do not want to
384 ** update the AUTOINCREMENT counters during a VACUUM.)
385 **
386 ** There is at most one AutoincInfo structure per table even if the
387 ** same table is autoincremented multiple times due to inserts within
388 ** triggers. A new AutoincInfo structure is created if this is the
389 ** first use of table pTab. On 2nd and subsequent uses, the original
390 ** AutoincInfo structure is used.
391 **
392 ** Four consecutive registers are allocated:
393 **
394 ** (1) The name of the pTab table.
395 ** (2) The maximum ROWID of pTab.
396 ** (3) The rowid in sqlite_sequence of pTab
397 ** (4) The original value of the max ROWID in pTab, or NULL if none
398 **
399 ** The 2nd register is the one that is returned. That is all the
400 ** insert routine needs to know about.
401 */
406 ){
411 ){
416 /* Verify that the sqlite_sequence table exists and is an ordinary
417 ** rowid table with exactly two columns.
418 ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
423 ){
427 }
443 }
445 }
447 }
449 /*
450 ** This routine generates code that will initialize all of the
451 ** register used by the autoincrement tracker.
452 */
460 /* This routine is never called during trigger-generation. It is
461 ** only called from the top-level */
481 };
503 }
504 }
506 /*
507 ** Update the maximum rowid for an autoincrement calculation.
508 **
509 ** This routine should be called when the regRowid register holds a
510 ** new rowid that is about to be inserted. If that new rowid is
511 ** larger than the maximum rowid in the memId memory cell, then the
512 ** memory cell is updated.
513 */
517 }
518 }
520 /*
521 ** This routine generates the code needed to write autoincrement
522 ** maximum rowid values back into the sqlite_sequence register.
523 ** Every statement that might do an INSERT into an autoincrement
524 ** table (either directly or through triggers) needs to call this
525 ** routine just before the "exit" code.
526 */
541 };
562 }
563 }
566 }
567 #else
568 /*
569 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
570 ** above are all no-ops
571 */
572 # define autoIncBegin(A,B,C) (0)
573 # define autoIncStep(A,B,C)
577 /* Forward declaration */
584 );
586 /*
587 ** This routine is called to handle SQL of the following forms:
588 **
589 ** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),...
590 ** insert into TABLE (IDLIST) select
591 ** insert into TABLE (IDLIST) default values
592 **
593 ** The IDLIST following the table name is always optional. If omitted,
594 ** then a list of all (non-hidden) columns for the table is substituted.
595 ** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST
596 ** is omitted.
597 **
598 ** For the pSelect parameter holds the values to be inserted for the
599 ** first two forms shown above. A VALUES clause is really just short-hand
600 ** for a SELECT statement that omits the FROM clause and everything else
601 ** that follows. If the pSelect parameter is NULL, that means that the
602 ** DEFAULT VALUES form of the INSERT statement is intended.
603 **
604 ** The code generated follows one of four templates. For a simple
605 ** insert with data coming from a single-row VALUES clause, the code executes
606 ** once straight down through. Pseudo-code follows (we call this
607 ** the "1st template"):
608 **
609 ** open write cursor to <table> and its indices
610 ** put VALUES clause expressions into registers
611 ** write the resulting record into <table>
612 ** cleanup
613 **
614 ** The three remaining templates assume the statement is of the form
615 **
616 ** INSERT INTO <table> SELECT ...
617 **
618 ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
619 ** in other words if the SELECT pulls all columns from a single table
620 ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
621 ** if <table2> and <table1> are distinct tables but have identical
622 ** schemas, including all the same indices, then a special optimization
623 ** is invoked that copies raw records from <table2> over to <table1>.
624 ** See the xferOptimization() function for the implementation of this
625 ** template. This is the 2nd template.
626 **
627 ** open a write cursor to <table>
628 ** open read cursor on <table2>
629 ** transfer all records in <table2> over to <table>
630 ** close cursors
631 ** foreach index on <table>
632 ** open a write cursor on the <table> index
633 ** open a read cursor on the corresponding <table2> index
634 ** transfer all records from the read to the write cursors
635 ** close cursors
636 ** end foreach
637 **
638 ** The 3rd template is for when the second template does not apply
639 ** and the SELECT clause does not read from <table> at any time.
640 ** The generated code follows this template:
641 **
642 ** X <- A
643 ** goto B
644 ** A: setup for the SELECT
645 ** loop over the rows in the SELECT
646 ** load values into registers R..R+n
647 ** yield X
648 ** end loop
649 ** cleanup after the SELECT
650 ** end-coroutine X
651 ** B: open write cursor to <table> and its indices
652 ** C: yield X, at EOF goto D
653 ** insert the select result into <table> from R..R+n
654 ** goto C
655 ** D: cleanup
656 **
657 ** The 4th template is used if the insert statement takes its
658 ** values from a SELECT but the data is being inserted into a table
659 ** that is also read as part of the SELECT. In the third form,
660 ** we have to use an intermediate table to store the results of
661 ** the select. The template is like this:
662 **
663 ** X <- A
664 ** goto B
665 ** A: setup for the SELECT
666 ** loop over the tables in the SELECT
667 ** load value into register R..R+n
668 ** yield X
669 ** end loop
670 ** cleanup after the SELECT
671 ** end co-routine R
672 ** B: open temp table
673 ** L: yield X, at EOF goto M
674 ** insert row from R..R+n into temp table
675 ** goto L
676 ** M: open write cursor to <table> and its indices
677 ** rewind temp table
678 ** C: loop over rows of intermediate table
679 ** transfer values form intermediate table into <table>
680 ** end loop
681 ** D: cleanup
682 */
690 ){
714 /* Register allocations */
723 #ifndef SQLITE_OMIT_TRIGGER
727 #endif
733 }
737 /* If the Select object is really just a simple VALUES() list with a
738 ** single row (the common case) then keep that one row of values
739 ** and discard the other (unused) parts of the pSelect object
740 */
746 }
748 /* Locate the table into which we will be inserting new information.
749 */
754 }
760 }
763 /* Figure out if we have any triggers and if the table being
764 ** inserted into is a view
765 */
766 #ifndef SQLITE_OMIT_TRIGGER
769 #else
770 # define pTrigger 0
771 # define tmask 0
772 # define isView 0
773 #endif
774 #ifdef SQLITE_OMIT_VIEW
775 # undef isView
776 # define isView 0
777 #endif
780 #if TREETRACE_ENABLED
785 }
786 #endif
788 /* If pTab is really a view, make sure it has been initialized.
789 ** ViewGetColumnNames() is a no-op if pTab is not a view.
790 */
793 }
795 /* Cannot insert into a read-only table.
796 */
799 }
801 /* Allocate a VDBE
802 */
808 #ifndef SQLITE_OMIT_XFER_OPT
809 /* If the statement is of the form
810 **
811 ** INSERT INTO <table1> SELECT * FROM <table2>;
812 **
813 ** Then special optimizations can be applied that make the transfer
814 ** very fast and which reduce fragmentation of indices.
815 **
816 ** This is the 2nd template.
817 */
822 ){
826 }
829 /* If this is an AUTOINCREMENT table, look up the sequence number in the
830 ** sqlite_sequence table and store it in memory cell regAutoinc.
831 */
834 /* Allocate a block registers to hold the rowid and the values
835 ** for all columns of the new row.
836 */
840 regRowid++;
842 }
845 /* If the INSERT statement included an IDLIST term, then make sure
846 ** all elements of the IDLIST really are columns of the table and
847 ** remember the column indices.
848 **
849 ** If the table has an INTEGER PRIMARY KEY column and that column
850 ** is named in the IDLIST, then record in the ipkColumn variable
851 ** the index into IDLIST of the primary key column. ipkColumn is
852 ** the index of the primary key as it appears in IDLIST, not as
853 ** is appears in the original table. (The index of the INTEGER
854 ** PRIMARY KEY in the original table is pTab->iPKey.) After this
855 ** loop, if ipkColumn==(-1), that means that integer primary key
856 ** is unspecified, and hence the table is either WITHOUT ROWID or
857 ** it will automatically generated an integer primary key.
858 **
859 ** bIdListInOrder is true if the columns in IDLIST are in storage
860 ** order. This enables an optimization that avoids shuffling the
861 ** columns into storage order. False negatives are harmless,
862 ** but false positives will cause database corruption.
863 */
870 }
878 }
879 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
885 }
886 #endif
888 }
889 }
899 }
900 }
901 }
902 }
904 /* Figure out how many columns of data are supplied. If the data
905 ** is coming from a SELECT statement, then generate a co-routine that
906 ** produces a single row of the SELECT on each invocation. The
907 ** co-routine is the common header to the 3rd and 4th templates.
908 */
910 /* Data is coming from a SELECT or from a multi-row VALUES clause.
911 ** Generate a co-routine to run the SELECT. */
932 /* Set useTempTable to TRUE if the result of the SELECT statement
933 ** should be written into a temporary table (template 4). Set to
934 ** FALSE if each output row of the SELECT can be written directly into
935 ** the destination table (template 3).
936 **
937 ** A temp table must be used if the table being updated is also one
938 ** of the tables being read by the SELECT statement. Also use a
939 ** temp table in the case of row triggers.
940 */
943 }
946 /* Invoke the coroutine to extract information from the SELECT
947 ** and add it to a transient table srcTab. The code generated
948 ** here is from the 4th template:
949 **
950 ** B: open temp table
951 ** L: yield X, goto M at EOF
952 ** insert row from R..R+n into temp table
953 ** goto L
954 ** M: ...
955 */
972 }
974 /* This is the case if the data for the INSERT is coming from a
975 ** single-row VALUES clause
976 */
977 NameContext sNC;
986 }
989 }
990 }
992 /* If there is no IDLIST term but the table has an integer primary
993 ** key, the set the ipkColumn variable to the integer primary key
994 ** column index in the original table definition.
995 */
998 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1006 ipkColumn--;
1007 }
1008 }
1009 }
1010 #endif
1012 /* Make sure the number of columns in the source data matches the number
1013 ** of columns to be inserted into the table.
1014 */
1021 }
1022 }
1028 }
1029 }
1033 }
1035 /* Initialize the count of rows to be inserted
1036 */
1041 ){
1044 }
1046 /* If this is not a view, open the table and and all indices */
1054 }
1059 }
1061 }
1062 #ifndef SQLITE_OMIT_UPSERT
1069 }
1073 }
1076 }
1087 }
1088 }
1091 }
1092 #endif
1095 /* This is the top of the main insertion loop */
1097 /* This block codes the top of loop only. The complete loop is the
1098 ** following pseudocode (template 4):
1099 **
1100 ** rewind temp table, if empty goto D
1101 ** C: loop over rows of intermediate table
1102 ** transfer values form intermediate table into <table>
1103 ** end loop
1104 ** D: ...
1105 */
1109 /* This block codes the top of loop only. The complete loop is the
1110 ** following pseudocode (template 3):
1111 **
1112 ** C: yield X, at EOF goto D
1113 ** insert the select result into <table> from R..R+n
1114 ** goto C
1115 ** D: ...
1116 */
1121 /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
1122 ** SELECT, go ahead and copy the value into the rowid slot now, so that
1123 ** the value does not get overwritten by a NULL at tag-20191021-002. */
1125 }
1126 }
1128 /* Compute data for ordinary columns of the new entry. Values
1129 ** are written in storage order into registers starting with regData.
1130 ** Only ordinary columns are computed in this loop. The rowid
1131 ** (if there is one) is computed later and generated columns are
1132 ** computed after the rowid since they might depend on the value
1133 ** of the rowid.
1134 */
1139 u32 colFlags;
1142 /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
1143 ** using the rowid. So put a NULL in the IPK slot of the record to avoid
1144 ** using excess space. The file format definition requires this extra
1145 ** NULL - we cannot optimize further by skipping the column completely */
1148 }
1150 nHidden++;
1152 /* Virtual columns do not participate in OP_MakeRecord. So back up
1153 ** iRegStore by one slot to compensate for the iRegStore++ in the
1154 ** outer for() loop */
1155 iRegStore--;
1158 /* Stored columns are computed later. But if there are BEFORE
1159 ** triggers, the slots used for stored columns will be OP_Copy-ed
1160 ** to a second block of registers, so the register needs to be
1161 ** initialized to NULL to avoid an uninitialized register read */
1164 }
1167 /* Hidden columns that are not explicitly named in the INSERT
1168 ** get there default value */
1171 iRegStore);
1173 }
1174 }
1179 /* A column not named in the insert column list gets its
1180 ** default value */
1183 iRegStore);
1185 }
1188 /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */
1191 iRegStore);
1195 }
1202 }
1209 }
1210 }
1211 }
1214 /* Run the BEFORE and INSTEAD OF triggers, if there are any
1215 */
1220 /* build the NEW.* reference row. Note that if there is an INTEGER
1221 ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
1222 ** translated into a unique ID for the row. But on a BEFORE trigger,
1223 ** we do not know what the unique ID will be (because the insert has
1224 ** not happened yet) so we substitute a rowid of -1
1225 */
1236 }
1241 }
1243 /* Copy the new data already generated. */
1247 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1248 /* Compute the new value for generated columns after all other
1249 ** columns have already been computed. This must be done after
1250 ** computing the ROWID in case one of the generated columns
1251 ** refers to the ROWID. */
1256 }
1257 #endif
1259 /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
1260 ** do not attempt any conversions before assembling the record.
1261 ** If this is a real table, attempt conversions as required by the
1262 ** table column affinities.
1263 */
1266 }
1268 /* Fire BEFORE or INSTEAD OF triggers */
1273 }
1277 /* The row that the VUpdate opcode will delete: none */
1279 }
1281 /* Compute the new rowid */
1285 /* Rowid already initialized at tag-20191021-001 */
1293 }
1294 }
1295 /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
1296 ** to generate a unique primary key value.
1297 */
1307 }
1309 }
1315 }
1318 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1319 /* Compute the new value for generated columns after all other
1320 ** columns have already been computed. This must be done after
1321 ** computing the ROWID in case one of the generated columns
1322 ** is derived from the INTEGER PRIMARY KEY. */
1325 }
1326 #endif
1328 /* Generate code to check constraints and generate index keys and
1329 ** do the insertion.
1330 */
1331 #ifndef SQLITE_OMIT_VIRTUALTABLE
1339 #endif
1340 {
1345 );
1348 }
1350 /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
1351 ** constraints or (b) there are no triggers and this table is not a
1352 ** parent table in a foreign key constraint. It is safe to set the
1353 ** flag in the second case as if any REPLACE constraint is hit, an
1354 ** OP_Delete or OP_IdxDelete instruction will be executed on each
1355 ** cursor that is disturbed. And these instructions both clear the
1356 ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
1357 ** functionality. */
1361 );
1362 }
1363 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
1365 /* If there is a RETURNING clause, populate the rowid register with
1366 ** constant value -1, in case one or more of the returned expressions
1367 ** refer to the "rowid" of the view. */
1369 #endif
1370 }
1372 /* Update the count of rows that are inserted
1373 */
1376 }
1379 /* Code AFTER triggers */
1382 }
1384 /* The bottom of the main insertion loop, if the data source
1385 ** is a SELECT statement.
1386 */
1394 #ifdef SQLITE_DEBUG
1395 /* If we are jumping back to an OP_Yield that is preceded by an
1396 ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
1397 ** OP_ReleaseReg will be included in the loop. */
1401 }
1402 #endif
1404 }
1406 #ifndef SQLITE_OMIT_XFER_OPT
1407 insert_end:
1409 /* Update the sqlite_sequence table by storing the content of the
1410 ** maximum rowid counter values recorded while inserting into
1411 ** autoincrement tables.
1412 */
1415 }
1417 /*
1418 ** Return the number of rows inserted. If this routine is
1419 ** generating code because of a call to sqlite3NestedParse(), do not
1420 ** invoke the callback function.
1421 */
1424 }
1426 insert_cleanup:
1433 }
1435 /* Make sure "isView" and other macros defined above are undefined. Otherwise
1436 ** they may interfere with compilation of other functions in this file
1437 ** (or in another file, if this file becomes part of the amalgamation). */
1438 #ifdef isView
1439 #undef isView
1440 #endif
1441 #ifdef pTrigger
1442 #undef pTrigger
1443 #endif
1444 #ifdef tmask
1445 #undef tmask
1446 #endif
1448 /*
1449 ** Meanings of bits in of pWalker->eCode for
1450 ** sqlite3ExprReferencesUpdatedColumn()
1451 */
1455 /* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn().
1456 * Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this
1457 ** expression node references any of the
1458 ** columns that are being modifed by an UPDATE statement.
1459 */
1466 }
1469 }
1470 }
1472 }
1474 /*
1475 ** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
1476 ** only columns that are modified by the UPDATE are those for which
1477 ** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
1478 **
1479 ** Return true if CHECK constraint pExpr uses any of the
1480 ** changing columns (or the rowid if it is changing). In other words,
1481 ** return true if this CHECK constraint must be validated for
1482 ** the new row in the UPDATE statement.
1483 **
1484 ** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
1485 ** The operation of this routine is the same - return true if an only if
1486 ** the expression uses one or more of columns identified by the second and
1487 ** third arguments.
1488 */
1493 ){
1494 Walker w;
1503 }
1509 }
1511 /*
1512 ** The sqlite3GenerateConstraintChecks() routine usually wants to visit
1513 ** the indexes of a table in the order provided in the Table->pIndex list.
1514 ** However, sometimes (rarely - when there is an upsert) it wants to visit
1515 ** the indexes in a different order. The following data structures accomplish
1516 ** this.
1517 **
1518 ** The IndexIterator object is used to walk through all of the indexes
1519 ** of a table in either Index.pNext order, or in some other order established
1520 ** by an array of IndexListTerm objects.
1521 */
1536 };
1538 /* When IndexIterator.eType==1, then each index is an array of instances
1539 ** of the following object
1540 */
1544 };
1546 /* Return the first index on the list */
1555 }
1556 }
1558 /* Return the next index from the list. Return NULL when out of indexes */
1565 }
1572 }
1573 }
1575 /*
1576 ** Generate code to do constraint checks prior to an INSERT or an UPDATE
1577 ** on table pTab.
1578 **
1579 ** The regNewData parameter is the first register in a range that contains
1580 ** the data to be inserted or the data after the update. There will be
1581 ** pTab->nCol+1 registers in this range. The first register (the one
1582 ** that regNewData points to) will contain the new rowid, or NULL in the
1583 ** case of a WITHOUT ROWID table. The second register in the range will
1584 ** contain the content of the first table column. The third register will
1585 ** contain the content of the second table column. And so forth.
1586 **
1587 ** The regOldData parameter is similar to regNewData except that it contains
1588 ** the data prior to an UPDATE rather than afterwards. regOldData is zero
1589 ** for an INSERT. This routine can distinguish between UPDATE and INSERT by
1590 ** checking regOldData for zero.
1591 **
1592 ** For an UPDATE, the pkChng boolean is true if the true primary key (the
1593 ** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
1594 ** might be modified by the UPDATE. If pkChng is false, then the key of
1595 ** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
1596 **
1597 ** For an INSERT, the pkChng boolean indicates whether or not the rowid
1598 ** was explicitly specified as part of the INSERT statement. If pkChng
1599 ** is zero, it means that the either rowid is computed automatically or
1600 ** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT,
1601 ** pkChng will only be true if the INSERT statement provides an integer
1602 ** value for either the rowid column or its INTEGER PRIMARY KEY alias.
1603 **
1604 ** The code generated by this routine will store new index entries into
1605 ** registers identified by aRegIdx[]. No index entry is created for
1606 ** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
1607 ** the same as the order of indices on the linked list of indices
1608 ** at pTab->pIndex.
1609 **
1610 ** (2019-05-07) The generated code also creates a new record for the
1611 ** main table, if pTab is a rowid table, and stores that record in the
1612 ** register identified by aRegIdx[nIdx] - in other words in the first
1613 ** entry of aRegIdx[] past the last index. It is important that the
1614 ** record be generated during constraint checks to avoid affinity changes
1615 ** to the register content that occur after constraint checks but before
1616 ** the new record is inserted.
1617 **
1618 ** The caller must have already opened writeable cursors on the main
1619 ** table and all applicable indices (that is to say, all indices for which
1620 ** aRegIdx[] is not zero). iDataCur is the cursor for the main table when
1621 ** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
1622 ** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor
1623 ** for the first index in the pTab->pIndex list. Cursors for other indices
1624 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
1625 **
1626 ** This routine also generates code to check constraints. NOT NULL,
1627 ** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
1628 ** then the appropriate action is performed. There are five possible
1629 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
1630 **
1631 ** Constraint type Action What Happens
1632 ** --------------- ---------- ----------------------------------------
1633 ** any ROLLBACK The current transaction is rolled back and
1634 ** sqlite3_step() returns immediately with a
1635 ** return code of SQLITE_CONSTRAINT.
1636 **
1637 ** any ABORT Back out changes from the current command
1638 ** only (do not do a complete rollback) then
1639 ** cause sqlite3_step() to return immediately
1640 ** with SQLITE_CONSTRAINT.
1641 **
1642 ** any FAIL Sqlite3_step() returns immediately with a
1643 ** return code of SQLITE_CONSTRAINT. The
1644 ** transaction is not rolled back and any
1645 ** changes to prior rows are retained.
1646 **
1647 ** any IGNORE The attempt in insert or update the current
1648 ** row is skipped, without throwing an error.
1649 ** Processing continues with the next row.
1650 ** (There is an immediate jump to ignoreDest.)
1651 **
1652 ** NOT NULL REPLACE The NULL value is replace by the default
1653 ** value for that column. If the default value
1654 ** is NULL, the action is the same as ABORT.
1655 **
1656 ** UNIQUE REPLACE The other row that conflicts with the row
1657 ** being inserted is removed.
1658 **
1659 ** CHECK REPLACE Illegal. The results in an exception.
1660 **
1661 ** Which action to take is determined by the overrideError parameter.
1662 ** Or if overrideError==OE_Default, then the pParse->onError parameter
1663 ** is used. Or if pParse->onError==OE_Default then the onError value
1664 ** for the constraint is used.
1665 */
1680 ){
1698 /* Variables associated with retesting uniqueness constraints after
1699 ** replace triggers fire have run */
1714 /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
1715 ** normal rowid tables. nPkField is the number of key fields in the
1716 ** pPk index or 1 for a rowid table. In other words, nPkField is the
1717 ** number of fields in the true primary key of the table. */
1724 }
1726 /* Record that this module has started */
1730 /* Test all NOT NULL constraints.
1731 */
1745 }
1748 nGenerated++;
1750 }
1752 /* Do not check NOT NULL on columns that do not change */
1754 }
1759 }
1763 ){
1770 }
1773 }
1783 nSeenReplace++;
1788 }
1791 /* no break */ deliberate_fall_through
1802 }
1808 }
1812 /* If there are no generated columns with NOT NULL constraints
1813 ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
1814 ** pass is sufficient */
1816 }
1819 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1821 /* If any NOT NULL ON CONFLICT REPLACE constraints fired on the
1822 ** first pass, recomputed values for all generated columns, as
1823 ** those values might depend on columns affected by the REPLACE.
1824 */
1826 }
1827 #endif
1831 /* Test all CHECK constraints
1832 */
1833 #ifndef SQLITE_OMIT_CHECK
1844 ){
1845 /* The check constraints do not reference any of the columns being
1846 ** updated so there is no point it verifying the check constraint */
1848 }
1852 }
1858 }
1868 P5_ConstraintCheck);
1869 }
1871 }
1873 }
1876 /* UNIQUE and PRIMARY KEY constraints should be handled in the following
1877 ** order:
1878 **
1879 ** (1) OE_Update
1880 ** (2) OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
1881 ** (3) OE_Replace
1882 **
1883 ** OE_Fail and OE_Ignore must happen before any changes are made.
1884 ** OE_Update guarantees that only a single row will change, so it
1885 ** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback
1886 ** could happen in any order, but they are grouped up front for
1887 ** convenience.
1888 **
1889 ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
1890 ** The order of constraints used to have OE_Update as (2) and OE_Abort
1891 ** and so forth as (1). But apparently PostgreSQL checks the OE_Update
1892 ** constraint before any others, so it had to be moved.
1893 **
1894 ** Constraint checking code is generated in this order:
1895 ** (A) The rowid constraint
1896 ** (B) Unique index constraints that do not have OE_Replace as their
1897 ** default conflict resolution strategy
1898 ** (C) Unique index that do use OE_Replace by default.
1899 **
1900 ** The ordering of (2) and (3) is accomplished by making sure the linked
1901 ** list of indexes attached to a table puts all OE_Replace indexes last
1902 ** in the list. See sqlite3CreateIndex() for where that happens.
1903 */
1910 /* There is just on ON CONFLICT clause and it has no constraint-target */
1913 /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
1914 ** Make all unique constraint resolution be OE_Ignore */
1918 /* A single ON CONFLICT DO UPDATE. Make all resolutions OE_Update */
1920 }
1922 /* Otherwise, we'll need to run the IndexListTerm array version of the
1923 ** iterator to ensure that all of the ON CONFLICT conditions are
1924 ** checked first and in order. */
1926 u64 nByte;
1931 }
1946 jj++;
1947 }
1952 i++;
1953 }
1958 i++;
1959 }
1961 }
1962 }
1964 /* Determine if it is possible that triggers (either explicitly coded
1965 ** triggers or FK resolution actions) might run as a result of deletes
1966 ** that happen when OE_Replace conflict resolution occurs. (Call these
1967 ** "replace triggers".) If any replace triggers run, we will need to
1968 ** recheck all of the uniqueness constraints after they have all run.
1969 ** But on the recheck, the resolution is OE_Abort instead of OE_Replace.
1970 **
1971 ** If replace triggers are a possibility, then
1972 **
1973 ** (1) Allocate register regTrigCnt and initialize it to zero.
1974 ** That register will count the number of replace triggers that
1975 ** fire. Constraint recheck only occurs if the number is positive.
1976 ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
1977 ** (3) Initialize addrRecheck and lblRecheckOk
1978 **
1979 ** The uniqueness rechecking code will create a series of tests to run
1980 ** in a second pass. The addrRecheck and lblRecheckOk variables are
1981 ** used to link together these tests which are separated from each other
1982 ** in the generate bytecode.
1983 */
1985 /* There are not DELETE triggers nor FK constraints. No constraint
1986 ** rechecks are needed. */
1996 }
1998 /* Replace triggers might exist. Allocate the counter and
1999 ** initialize it to zero. */
2005 }
2006 }
2008 /* If rowid is changing, make sure the new rowid does not previously
2009 ** exist in the table.
2010 */
2014 /* Figure out what action to take in case of a rowid collision */
2020 }
2022 /* figure out whether or not upsert applies in this case */
2030 }
2031 }
2033 /* The first ON CONFLICT clause has a conflict target other than
2034 ** the IPK. We have to jump ahead to that first ON CONFLICT clause
2035 ** and then come back here and deal with the IPK afterwards */
2037 }
2038 }
2040 /* If the response to a rowid conflict is REPLACE but the response
2041 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
2042 ** to defer the running of the rowid conflict checking until after
2043 ** the UNIQUE constraints have run.
2044 */
2049 ){
2052 }
2055 /* pkChng!=0 does not mean that the rowid has changed, only that
2056 ** it might have changed. Skip the conflict logic below if the rowid
2057 ** is unchanged. */
2061 }
2063 /* Check to see if the new rowid already exists in the table. Skip
2064 ** the following conflict logic if it does not. */
2073 /* no break */ deliberate_fall_through
2074 }
2083 }
2085 /* If there are DELETE triggers on this table and the
2086 ** recursive-triggers flag is set, call GenerateRowDelete() to
2087 ** remove the conflicting row from the table. This will fire
2088 ** the triggers and remove both the table and index b-tree entries.
2089 **
2090 ** Otherwise, if there are no triggers or the recursive-triggers
2091 ** flag is not set, but the table has one or more indexes, call
2092 ** GenerateRowIndexDelete(). This removes the index b-tree entries
2093 ** only. The table b-tree entry will be replaced by the new entry
2094 ** when it is inserted.
2095 **
2096 ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
2097 ** also invoke MultiWrite() to indicate that this VDBE may require
2098 ** statement rollback (if the statement is aborted after the delete
2099 ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
2100 ** but being more selective here allows statements like:
2101 **
2102 ** REPLACE INTO t(rowid) VALUES($newrowid)
2103 **
2104 ** to run without a statement journal if there are no indexes on the
2105 ** table.
2106 */
2112 nReplaceTrig++;
2114 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2116 /* This OP_Delete opcode fires the pre-update-hook only. It does
2117 ** not modify the b-tree. It is more efficient to let the coming
2118 ** OP_Insert replace the existing entry than it is to delete the
2119 ** existing entry and then insert a new one. */
2126 }
2127 }
2130 }
2131 #ifndef SQLITE_OMIT_UPSERT
2134 /* no break */ deliberate_fall_through
2135 }
2136 #endif
2141 }
2142 }
2149 }
2150 }
2152 /* Test all UNIQUE constraints by creating entries for each UNIQUE
2153 ** index and making sure that duplicate entries do not already exist.
2154 ** Compute the revised record entries for indices as we go.
2155 **
2156 ** This loop also handles the case of the PRIMARY KEY index for a
2157 ** WITHOUT ROWID table.
2158 */
2160 pIdx;
2162 ){
2174 }
2175 }
2180 }
2185 /* Skip partial indices for which the WHERE clause is not true */
2190 SQLITE_JUMPIFNULL);
2192 }
2194 /* Create a record for this index entry as it should appear after
2195 ** the insert or update. Store that record in the aRegIdx[ix] register
2196 */
2215 }
2216 }
2219 #ifdef SQLITE_ENABLE_NULL_TRIM
2222 }
2223 #endif
2226 /* In an UPDATE operation, if this index is the PRIMARY KEY index
2227 ** of a WITHOUT ROWID table and there has been no change the
2228 ** primary key, then no collision is possible. The collision detection
2229 ** logic below can all be skipped. */
2233 }
2235 /* Find out what action to take in case there is a uniqueness conflict */
2240 }
2245 }
2247 /* Figure out if the upsert clause applies to this index */
2253 }
2254 }
2256 /* Collision detection may be omitted if all of the following are true:
2257 ** (1) The conflict resolution algorithm is REPLACE
2258 ** (2) The table is a WITHOUT ROWID table
2259 ** (3) There are no secondary indexes on the table
2260 ** (4) No delete triggers need to be fired if there is a conflict
2261 ** (5) No FK constraint counters need to be updated if a conflict occurs.
2262 **
2263 ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
2264 ** must be explicitly deleted in order to ensure any pre-update hook
2265 ** is invoked. */
2267 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
2275 ){
2278 }
2281 /* Check to see if the new index entry will be unique */
2283 addrConflictCk =
2287 /* Generate code to handle collisions */
2292 /* Conflict only if the rowid of the existing index entry
2293 ** is different from old-rowid */
2298 }
2301 /* Extract the PRIMARY KEY from the end of the index entry and
2302 ** store it in registers regR..regR+nPk-1 */
2310 }
2311 }
2313 /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
2314 ** table, only conflict if the new PRIMARY KEY values are actually
2315 ** different from the old. See TH3 withoutrowid04.test.
2316 **
2317 ** For a UNIQUE index, only conflict if the PRIMARY KEY values
2318 ** of the matched index row are different from the original PRIMARY
2319 ** KEY values of this row before the update. */
2331 }
2335 );
2339 }
2340 }
2341 }
2342 }
2344 /* Generate code that executes if the new index entry is not unique */
2356 }
2357 #ifndef SQLITE_OMIT_UPSERT
2360 /* no break */ deliberate_fall_through
2361 }
2362 #endif
2367 }
2378 nReplaceTrig++;
2379 }
2382 }
2388 }
2396 /* Here we insert code that will be invoked after all constraint
2397 ** checks have run, if and only if one or more replace triggers
2398 ** fired. */
2402 /* Bypass the recheck if this partial index is not defined
2403 ** for the current row */
2406 }
2407 /* Copy the constraint check code from above, except change
2408 ** the constraint-ok jump destination to be the address of
2409 ** the next retest block */
2412 /* The sqlite3VdbeAddOp4() call might reallocate the opcode array.
2413 ** Hence, make a complete copy of the opcode, rather than using
2414 ** a pointer to the opcode. */
2423 }
2428 }
2429 nConflictCk--;
2430 addrConflictCk++;
2431 }
2432 /* If the retest fails, issue an abort */
2436 }
2439 }
2440 }
2444 && upsertIpkReturn
2446 ){
2450 }
2451 }
2453 /* If the IPK constraint is a REPLACE, run it last */
2459 }
2461 /* Recheck all uniqueness constraints after replace triggers have run */
2471 }
2477 }
2479 }
2481 /* Generate the table record */
2488 }
2489 }
2493 }
2495 #ifdef SQLITE_ENABLE_NULL_TRIM
2496 /*
2497 ** Change the P5 operand on the last opcode (which should be an OP_MakeRecord)
2498 ** to be the number of columns in table pTab that must not be NULL-trimmed.
2499 **
2500 ** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
2501 */
2503 u16 i;
2505 /* Records with omitted columns are only allowed for schema format
2506 ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
2512 }
2514 }
2515 #endif
2517 /*
2518 ** Table pTab is a WITHOUT ROWID table that is being written to. The cursor
2519 ** number is iCur, and register regData contains the new record for the
2520 ** PK index. This function adds code to invoke the pre-update hook,
2521 ** if one is registered.
2522 */
2523 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2529 ){
2538 }
2539 #else
2540 # define codeWithoutRowidPreupdate(a,b,c,d)
2541 #endif
2543 /*
2544 ** This routine generates code to finish the INSERT or UPDATE operation
2545 ** that was started by a prior call to sqlite3GenerateConstraintChecks.
2546 ** A consecutive range of registers starting at regNewData contains the
2547 ** rowid and the content to be inserted.
2548 **
2549 ** The arguments to this routine should be the same as the first six
2550 ** arguments to sqlite3GenerateConstraintChecks.
2551 */
2562 ){
2571 );
2577 /* All REPLACE indexes are at the end of the list */
2585 }
2592 }
2593 }
2598 }
2605 }
2608 }
2611 }
2615 }
2617 }
2619 /*
2620 ** Allocate cursors for the pTab table and all its indices and generate
2621 ** code to open and initialized those cursors.
2622 **
2623 ** The cursor for the object that contains the complete data (normally
2624 ** the table itself, but the PRIMARY KEY index in the case of a WITHOUT
2625 ** ROWID table) is returned in *piDataCur. The first index cursor is
2626 ** returned in *piIdxCur. The number of indices is returned.
2627 **
2628 ** Use iBase as the first cursor (either the *piDataCur for rowid tables
2629 ** or the first index for WITHOUT ROWID tables) if it is non-negative.
2630 ** If iBase is negative, then allocate the next available cursor.
2631 **
2632 ** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
2633 ** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
2634 ** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the
2635 ** pTab->pIndex list.
2636 **
2637 ** If pTab is a virtual table, then this routine is a no-op and the
2638 ** *piDataCur and *piIdxCur values are left uninitialized.
2639 */
2649 ){
2659 /* This routine is a no-op for virtual tables. Leave the output
2660 ** variables *piDataCur and *piIdxCur set to illegal cursor numbers
2661 ** for improved error detection. */
2664 }
2675 }
2683 }
2689 }
2690 }
2693 }
2696 #ifdef SQLITE_TEST
2697 /*
2698 ** The following global variable is incremented whenever the
2699 ** transfer optimization is used. This is used for testing
2700 ** purposes only - to make sure the transfer optimization really
2701 ** is happening when it is supposed to.
2702 */
2707 #ifndef SQLITE_OMIT_XFER_OPT
2708 /*
2709 ** Check to see if index pSrc is compatible as a source of data
2710 ** for index pDest in an insert transfer optimization. The rules
2711 ** for a compatible index:
2712 **
2713 ** * The index is over the same set of columns
2714 ** * The same DESC and ASC markings occurs on all columns
2715 ** * The same onError processing (OE_Abort, OE_Ignore, etc)
2716 ** * The same collating sequence on each column
2717 ** * The index has the exact same WHERE clause
2718 */
2725 }
2728 }
2732 }
2738 }
2739 }
2742 }
2745 }
2746 }
2749 }
2751 /* If no test above fails then the indices must be compatible */
2753 }
2755 /*
2756 ** Attempt the transfer optimization on INSERTs of the form
2757 **
2758 ** INSERT INTO tab1 SELECT * FROM tab2;
2759 **
2760 ** The xfer optimization transfers raw records from tab2 over to tab1.
2761 ** Columns are not decoded and reassembled, which greatly improves
2762 ** performance. Raw index records are transferred in the same way.
2763 **
2764 ** The xfer optimization is only attempted if tab1 and tab2 are compatible.
2765 ** There are lots of rules for determining compatibility - see comments
2766 ** embedded in the code for details.
2767 **
2768 ** This routine returns TRUE if the optimization is guaranteed to be used.
2769 ** Sometimes the xfer optimization will only work if the destination table
2770 ** is empty - a factor that can only be determined at run-time. In that
2771 ** case, this routine generates code for the xfer optimization but also
2772 ** does a test to see if the destination table is empty and jumps over the
2773 ** xfer optimization code if the test fails. In that case, this routine
2774 ** returns FALSE so that the caller will know to go ahead and generate
2775 ** an unoptimized transfer. This routine also returns FALSE if there
2776 ** is no chance that the xfer optimization can be applied.
2777 **
2778 ** This optimization is particularly useful at making VACUUM run faster.
2779 */
2786 ){
2805 /* Do not attempt to process this query if there are an WITH clauses
2806 ** attached to it. Proceeding may generate a false "no such table: xxx"
2807 ** error if pSelect reads from a CTE named "xxx". */
2809 }
2810 #ifndef SQLITE_OMIT_VIRTUALTABLE
2813 }
2814 #endif
2818 }
2822 }
2825 }
2828 }
2831 }
2832 /* Do not need to test for a HAVING clause. If HAVING is present but
2833 ** there is no ORDER BY, we will get an error. */
2836 }
2839 }
2842 }
2845 }
2850 }
2854 }
2856 /* At this point we have established that the statement is of the
2857 ** correct syntactic form to participate in this optimization. Now
2858 ** we have to check the semantics.
2859 */
2864 }
2868 }
2871 }
2874 }
2877 }
2880 }
2883 }
2887 #ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
2890 ){
2892 }
2893 #endif
2894 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
2895 /* Even if tables t1 and t2 have identical schemas, if they contain
2896 ** generated columns, then this statement is semantically incorrect:
2897 **
2898 ** INSERT INTO t2 SELECT * FROM t1;
2899 **
2900 ** The reason is that generated column values are returned by the
2901 ** the SELECT statement on the right but the INSERT statement on the
2902 ** left wants them to be omitted.
2903 **
2904 ** Nevertheless, this is a useful notational shorthand to tell SQLite
2905 ** to do a bulk transfer all of the content from t1 over to t2.
2906 **
2907 ** We could, in theory, disable this (except for internal use by the
2908 ** VACUUM command where it is actually needed). But why do that? It
2909 ** seems harmless enough, and provides a useful service.
2910 */
2914 }
2915 /* But the transfer is only allowed if both the source and destination
2916 ** tables have the exact same expressions for generated columns.
2917 ** This requirement could be relaxed for VIRTUAL columns, I suppose.
2918 */
2926 }
2927 }
2928 #endif
2931 }
2935 }
2938 }
2939 /* Default values for second and subsequent columns need to match. */
2950 ){
2952 }
2953 }
2954 }
2958 }
2961 }
2964 }
2967 /* The sqlite3FaultSim() call allows this corruption test to be
2968 ** bypassed during testing, in order to exercise other corruption tests
2969 ** further downstream. */
2971 }
2972 }
2973 #ifndef SQLITE_OMIT_CHECK
2976 }
2977 #endif
2978 #ifndef SQLITE_OMIT_FOREIGN_KEY
2979 /* Disallow the transfer optimization if the destination table constains
2980 ** any foreign key constraints. This is more restrictive than necessary.
2981 ** But the main beneficiary of the transfer optimization is the VACUUM
2982 ** command, and the VACUUM command disables foreign key constraints. So
2983 ** the extra complication to make this rule less restrictive is probably
2984 ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
2985 */
2989 }
2990 #endif
2993 }
2995 /* If we get this far, it means that the xfer optimization is at
2996 ** least a possibility, though it might only work if the destination
2997 ** table (tab1) is initially empty.
2998 */
2999 #ifdef SQLITE_TEST
3000 sqlite3_xferopt_count++;
3001 #endif
3017 )){
3018 /* In some circumstances, we are able to run the xfer optimization
3019 ** only if the destination table is initially empty. Unless the
3020 ** DBFLAG_Vacuum flag is set, this block generates code to make
3021 ** that determination. If DBFLAG_Vacuum is set, then the destination
3022 ** table is always empty.
3023 **
3024 ** Conditions under which the destination must be empty:
3025 **
3026 ** (1) There is no INTEGER PRIMARY KEY but there are indices.
3027 ** (If the destination is not initially empty, the rowid fields
3028 ** of index entries might need to change.)
3029 **
3030 ** (2) The destination has a unique index. (The xfer optimization
3031 ** is unable to test uniqueness.)
3032 **
3033 ** (3) onError is something other than OE_Abort and OE_Rollback.
3034 */
3038 }
3040 u8 insFlags;
3051 }
3058 }
3065 }
3066 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
3071 #endif
3072 {
3074 }
3078 }
3087 }
3092 }
3103 /* This INSERT command is part of a VACUUM operation, which guarantees
3104 ** that the destination table is empty. If all indexed columns use
3105 ** collation sequence BINARY, then it can also be assumed that the
3106 ** index will be populated by inserting keys in strictly sorted
3107 ** order. In this case, instead of seeking within the b-tree as part
3108 ** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the
3109 ** OP_IdxInsert to seek to the point within the b-tree where each key
3110 ** should be inserted. This is faster.
3111 **
3112 ** If any of the indexed columns use a collation sequence other than
3113 ** BINARY, this optimization is disabled. This is because the user
3114 ** might change the definition of a collation sequence and then run
3115 ** a VACUUM command. In that case keys may not be written in strictly
3116 ** sorted order. */
3120 }
3125 }
3128 }
3134 ){
3136 }
3137 }
3144 }
3156 }
3157 }