| blob | 31ab81b09bc99d844d3989a8970f6b7aba3990a2 |
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 SQLite parser
13 ** when syntax rules are reduced. The routines in this file handle the
14 ** following kinds of SQL syntax:
15 **
16 ** CREATE TABLE
17 ** DROP TABLE
18 ** CREATE INDEX
19 ** DROP INDEX
20 ** creating ID lists
21 ** BEGIN TRANSACTION
22 ** COMMIT
23 ** ROLLBACK
24 */
27 #ifndef SQLITE_OMIT_SHARED_CACHE
28 /*
29 ** The TableLock structure is only used by the sqlite3TableLock() and
30 ** codeTableLocks() functions.
31 */
37 };
39 /*
40 ** Record the fact that we want to lock a table at run-time.
41 **
42 ** The table to be locked has root page iTab and is found in database iDb.
43 ** A read or a write lock can be taken depending on isWritelock.
44 **
45 ** This routine just records the fact that the lock is desired. The
46 ** code to make the lock occur is generated by a later call to
47 ** codeTableLocks() which occurs during sqlite3FinishCoding().
48 */
55 ){
68 }
69 }
83 }
84 }
91 ){
95 }
97 /*
98 ** Code an OP_TableLock instruction for each table locked by the
99 ** statement (configured by calls to sqlite3TableLock()).
100 */
111 }
112 }
113 #else
114 #define codeTableLocks(x)
115 #endif
117 /*
118 ** Return TRUE if the given yDbMask object is empty - if it contains no
119 ** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero()
120 ** macros when SQLITE_MAX_ATTACHED is greater than 30.
121 */
122 #if SQLITE_MAX_ATTACHED>30
127 }
128 #endif
130 /*
131 ** This routine is called after a single SQL statement has been
132 ** parsed and a VDBE program to execute that statement has been
133 ** prepared. This routine puts the finishing touches on the
134 ** VDBE program and resets the pParse structure for the next
135 ** parse.
136 **
137 ** Note that if an error occurred, it might be the case that
138 ** no VDBE code was generated.
139 */
151 }
154 /* Begin by generating some termination code at the end of the
155 ** vdbe program
156 */
162 }
165 }
177 addrRewind =
183 }
188 }
189 }
192 #if SQLITE_USER_AUTHENTICATION
199 }
200 }
201 #endif
203 /* The cookie mask contains one bit for each database file open.
204 ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
205 ** set for each database that is used. Generate code to start a
206 ** transaction on each used database and to verify the schema cookie
207 ** on each used database.
208 */
211 ){
228 );
233 #ifndef SQLITE_OMIT_VIRTUALTABLE
237 }
239 #endif
241 /* Once all the cookies have been verified and transactions opened,
242 ** obtain the required table-locks. This is a no-op unless the
243 ** shared-cache feature is enabled.
244 */
247 /* Initialize any AUTOINCREMENT data structures required.
248 */
251 /* Code constant expressions that where factored out of inner loops.
252 **
253 ** The pConstExpr list might also contain expressions that we simply
254 ** want to keep around until the Parse object is deleted. Such
255 ** expressions have iConstExprReg==0. Do not generate code for
256 ** those expressions, of course.
257 */
265 }
266 }
267 }
273 }
274 }
276 /* Finally, jump back to the beginning of the executable code. */
278 }
279 }
281 /* Get the VDBE program ready for execution
282 */
286 /* A minimum of one cursor is required if autoincrement is used
287 * See ticket [a696379c1f08866] */
293 }
294 }
296 /*
297 ** Run the parser and code generator recursively in order to generate
298 ** code for the SQL statement given onto the end of the pParse context
299 ** currently under construction. Notes:
300 **
301 ** * The final OP_Halt is not appended and other initialization
302 ** and finalization steps are omitted because those are handling by the
303 ** outermost parser.
304 **
305 ** * Built-in SQL functions always take precedence over application-defined
306 ** SQL functions. In other words, it is not possible to override a
307 ** built-in function.
308 */
322 /* This can result either from an OOM or because the formatted string
323 ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set
324 ** an error */
328 }
338 }
340 #if SQLITE_USER_AUTHENTICATION
341 /*
342 ** Return TRUE if zTable is the name of the system table that stores the
343 ** list of users and their access credentials.
344 */
347 }
348 #endif
350 /*
351 ** Locate the in-memory structure that describes a particular database
352 ** table given the name of that table and (optionally) the name of the
353 ** database containing the table. Return NULL if not found.
354 **
355 ** If zDatabase is 0, all databases are searched for the table and the
356 ** first matching table is returned. (No checking for duplicate table
357 ** names is done.) The search order is TEMP first, then MAIN, then any
358 ** auxiliary databases added using the ATTACH command.
359 **
360 ** See also sqlite3LocateTable().
361 */
366 /* All mutexes are required for schema access. Make sure we hold them. */
368 #if SQLITE_USER_AUTHENTICATION
369 /* Only the admin user is allowed to know that the sqlite_user table
370 ** exists */
373 }
374 #endif
378 }
380 /* No match against the official names. But always match "main"
381 ** to schema 0 as a legacy fallback. */
386 }
387 }
394 ){
396 LEGACY_TEMP_SCHEMA_TABLE);
397 }
401 LEGACY_SCHEMA_TABLE);
402 }
403 }
404 }
406 /* Match against TEMP first */
409 /* The main database is second */
412 /* Attached databases are in order of attachment */
417 }
423 LEGACY_TEMP_SCHEMA_TABLE);
424 }
425 }
426 }
428 }
430 /*
431 ** Locate the in-memory structure that describes a particular database
432 ** table given the name of that table and (optionally) the name of the
433 ** database containing the table. Return NULL if not found. Also leave an
434 ** error message in pParse->zErrMsg.
435 **
436 ** The difference between this routine and sqlite3FindTable() is that this
437 ** routine leaves an error message in pParse->zErrMsg where
438 ** sqlite3FindTable() does not.
439 */
445 ){
449 /* Read the database schema. If an error occurs, leave an error message
450 ** and code in pParse and return NULL. */
453 ){
455 }
459 #ifndef SQLITE_OMIT_VIRTUALTABLE
460 /* If zName is the not the name of a table in the schema created using
461 ** CREATE, then check to see if it is the name of an virtual table that
462 ** can be an eponymous virtual table. */
467 }
471 }
472 }
473 #endif
478 }
486 }
489 }
492 }
494 /*
495 ** Locate the table identified by *p.
496 **
497 ** This is a wrapper around sqlite3LocateTable(). The difference between
498 ** sqlite3LocateTable() and this function is that this function restricts
499 ** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
500 ** non-NULL if it is part of a view or trigger program definition. See
501 ** sqlite3FixSrcList() for details.
502 */
505 u32 flags,
506 SrcItem *p
507 ){
515 }
517 }
519 /*
520 ** Return the preferred table name for system tables. Translate legacy
521 ** names into the new preferred names, as appropriate.
522 */
527 }
530 }
531 }
533 }
535 /*
536 ** Locate the in-memory structure that describes
537 ** a particular index given the name of that index
538 ** and the name of the database that contains the index.
539 ** Return NULL if not found.
540 **
541 ** If zDatabase is 0, all databases are searched for the
542 ** table and the first matching index is returned. (No checking
543 ** for duplicate index names is done.) The search order is
544 ** TEMP first, then MAIN, then any auxiliary databases added
545 ** using the ATTACH command.
546 */
550 /* All mutexes are required for schema access. Make sure we hold them. */
560 }
562 }
564 /*
565 ** Reclaim the memory used by an index
566 */
568 #ifndef SQLITE_OMIT_ANALYZE
570 #endif
575 #ifdef SQLITE_ENABLE_STAT4
577 #endif
579 }
581 /*
582 ** For the index called zIdxName which is found in the database iDb,
583 ** unlike that index from its Table then remove the index from
584 ** the index hash table and free all memory structures associated
585 ** with the index.
586 */
599 /* Justification of ALWAYS(); The index must be on the list of
600 ** indices. */
605 }
606 }
608 }
610 }
612 /*
613 ** Look through the list of open database files in db->aDb[] and if
614 ** any have been closed, remove them from the list. Reallocate the
615 ** db->aDb[] structure to a smaller size, if possible.
616 **
617 ** Entry 0 (the "main" database) and entry 1 (the "temp" database)
618 ** are never candidates for being collapsed.
619 */
628 }
631 }
632 j++;
633 }
639 }
640 }
642 /*
643 ** Reset the schema for the database at index iDb. Also reset the
644 ** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
645 ** Deferred resets may be run by calling with iDb<0.
646 */
656 }
662 }
663 }
664 }
665 }
667 /*
668 ** Erase all schema information from all attached databases (including
669 ** "main" and "temp") for a single database connection.
670 */
681 }
682 }
683 }
689 }
690 }
692 /*
693 ** This routine is called when a commit occurs.
694 */
697 }
699 /*
700 ** Set the expression associated with a column. This is usually
701 ** the DEFAULT value, but might also be the expression that computes
702 ** the value for a generated column.
703 */
709 ){
716 ){
722 }
723 }
725 /*
726 ** Return the expression associated with a column. The expression might be
727 ** the DEFAULT clause or the AS clause of a generated column.
728 ** Return NULL if the column has no associated expression.
729 */
736 }
738 /*
739 ** Set the collating sequence name for a column.
740 */
745 ){
746 i64 nColl;
747 i64 n;
753 }
760 }
761 }
763 /*
764 ** Return the collating squence name for a column
765 */
773 }
775 }
777 /*
778 ** Delete memory allocated for the column names of a table or view (the
779 ** Table.aCol[] array).
780 */
789 }
793 }
799 }
800 }
801 }
802 }
804 /*
805 ** Remove the memory data structures associated with the given
806 ** Table. No changes are made to disk by this routine.
807 **
808 ** This routine just deletes the data structure. It does not unlink
809 ** the table data structure from the hash table. But it does destroy
810 ** memory structures of the indices and foreign keys associated with
811 ** the table.
812 **
813 ** The db parameter is optional. It is needed if the Table object
814 ** contains lookaside memory. (Table objects in the schema do not use
815 ** lookaside memory, but some ephemeral Table objects do.) Or the
816 ** db parameter can be used with db->pnBytesFreed to measure the memory
817 ** used by the Table object.
818 */
822 #ifdef SQLITE_DEBUG
823 /* Record the number of outstanding lookaside allocations in schema Tables
824 ** prior to doing any free() operations. Since schema Tables do not use
825 ** lookaside, this number should not change.
826 **
827 ** If malloc has already failed, it may be that it failed while allocating
828 ** a Table object that was going to be marked ephemeral. So do not check
829 ** that no lookaside memory is used in this case either. */
833 }
834 #endif
836 /* Delete all indices associated with this table. */
845 );
848 }
850 }
854 }
855 #ifndef SQLITE_OMIT_VIRTUAL_TABLE
858 }
859 #endif
863 }
865 /* Delete the Table structure itself.
866 */
873 /* Verify that no lookaside memory was used by schema tables */
875 }
877 /* Do not delete the table until the reference count reaches zero. */
881 }
884 /*
885 ** Unlink the given table from the hash tables and the delete the
886 ** table structure with all its indices and foreign keys.
887 */
901 }
903 /*
904 ** Given a token, return a string that consists of the text of that
905 ** token. Space to hold the returned string
906 ** is obtained from sqliteMalloc() and must be freed by the calling
907 ** function.
908 **
909 ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
910 ** surround the body of the token are removed.
911 **
912 ** Tokens are often just pointers into the original SQL text and so
913 ** are not \000 terminated and are not persistent. The returned string
914 ** is \000 terminated and is persistent.
915 */
923 }
925 }
927 /*
928 ** Open the sqlite_schema table stored in database number iDb for
929 ** writing. The table is opened using cursor 0.
930 */
937 }
938 }
940 /*
941 ** Parameter zName points to a nul-terminated buffer containing the name
942 ** of a database ("main", "temp" or the name of an attached db). This
943 ** function returns the index of the named database in db->aDb[], or
944 ** -1 if the named db cannot be found.
945 */
952 /* "main" is always an acceptable alias for the primary database
953 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
955 }
956 }
958 }
960 /*
961 ** The token *pName contains the name of a database (either "main" or
962 ** "temp" or the name of an attached db). This routine returns the
963 ** index of the named database in db->aDb[], or -1 if the named db
964 ** does not exist.
965 */
973 }
975 /* The table or view or trigger name is passed to this routine via tokens
976 ** pName1 and pName2. If the table name was fully qualified, for example:
977 **
978 ** CREATE TABLE xxx.yyy (...);
979 **
980 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
981 ** the table name is not fully qualified, i.e.:
982 **
983 ** CREATE TABLE yyy(...);
984 **
985 ** Then pName1 is set to "yyy" and pName2 is "".
986 **
987 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
988 ** pName2) that stores the unqualified table name. The index of the
989 ** database "xxx" is returned.
990 */
996 ){
1005 }
1011 }
1017 }
1019 }
1021 /*
1022 ** True if PRAGMA writable_schema is ON
1023 */
1027 SQLITE_WriteSchema );
1029 SQLITE_Defensive );
1033 }
1035 /*
1036 ** This routine is used to check if the UTF-8 string zName is a legal
1037 ** unqualified name for a new schema object (table, index, view or
1038 ** trigger). All names are legal except those that begin with the string
1039 ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
1040 ** is reserved for internal use.
1041 **
1042 ** When parsing the sqlite_schema table, this routine also checks to
1043 ** make sure the "type", "name", and "tbl_name" columns are consistent
1044 ** with the SQL.
1045 */
1051 ){
1056 ){
1057 /* Skip these error checks for writable_schema=ON */
1059 }
1064 ){
1067 }
1071 ){
1073 zName);
1075 }
1077 }
1079 }
1081 /*
1082 ** Return the PRIMARY KEY index of a table
1083 */
1088 }
1090 /*
1091 ** Convert an table column number into a index column number. That is,
1092 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
1093 ** find the (first) offset of that column in index pIdx. Or return -1
1094 ** if column iCol is not used in index pIdx.
1095 */
1100 }
1102 }
1104 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1105 /* Convert a storage column number into a table column number.
1106 **
1107 ** The storage column number (0,1,2,....) is the index of the value
1108 ** as it appears in the record on disk. The true column number
1109 ** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
1110 **
1111 ** The storage column number is less than the table column number if
1112 ** and only there are VIRTUAL columns to the left.
1113 **
1114 ** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
1115 */
1121 }
1122 }
1124 }
1125 #endif
1127 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1128 /* Convert a table column number into a storage column number.
1129 **
1130 ** The storage column number (0,1,2,....) is the index of the value
1131 ** as it appears in the record on disk. Or, if the input column is
1132 ** the N-th virtual column (zero-based) then the storage number is
1133 ** the number of non-virtual columns in the table plus N.
1134 **
1135 ** The true column number is the index (0,1,2,...) of the column in
1136 ** the CREATE TABLE statement.
1137 **
1138 ** If the input column is a VIRTUAL column, then it should not appear
1139 ** in storage. But the value sometimes is cached in registers that
1140 ** follow the range of registers used to construct storage. This
1141 ** avoids computing the same VIRTUAL column multiple times, and provides
1142 ** values for use by OP_Param opcodes in triggers. Hence, if the
1143 ** input column is a VIRTUAL table, put it after all the other columns.
1144 **
1145 ** In the following, N means "normal column", S means STORED, and
1146 ** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
1147 **
1148 ** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
1149 ** -- 0 1 2 3 4 5 6 7 8
1150 **
1151 ** Then the mapping from this function is as follows:
1152 **
1153 ** INPUTS: 0 1 2 3 4 5 6 7 8
1154 ** OUTPUTS: 0 1 6 2 3 7 4 5 8
1155 **
1156 ** So, in other words, this routine shifts all the virtual columns to
1157 ** the end.
1158 **
1159 ** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and
1160 ** this routine is a no-op macro. If the pTab does not have any virtual
1161 ** columns, then this routine is no-op that always return iCol. If iCol
1162 ** is negative (indicating the ROWID column) then this routine return iCol.
1163 */
1166 i16 n;
1171 }
1173 /* iCol is a virtual column itself */
1176 /* iCol is a normal or stored column */
1178 }
1179 }
1180 #endif
1182 /*
1183 ** Insert a single OP_JournalMode query opcode in order to force the
1184 ** prepared statement to return false for sqlite3_stmt_readonly(). This
1185 ** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
1186 ** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
1187 ** will return false for sqlite3_stmt_readonly() even if that statement
1188 ** is a read-only no-op.
1189 */
1196 }
1197 }
1199 /*
1200 ** Begin constructing a new table representation in memory. This is
1201 ** the first of several action routines that get called in response
1202 ** to a CREATE TABLE statement. In particular, this routine is called
1203 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
1204 ** flag is true if the table should be stored in the auxiliary database
1205 ** file instead of in the main database file. This is normally the case
1206 ** when the "TEMP" or "TEMPORARY" keyword occurs in between
1207 ** CREATE and TABLE.
1208 **
1209 ** The new table record is initialized and put in pParse->pNewTable.
1210 ** As more of the CREATE TABLE statement is parsed, additional action
1211 ** routines will be called to add more information to this record.
1212 ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
1213 ** is called to complete the construction of the new table record.
1214 */
1223 ){
1232 /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */
1237 /* The common case */
1241 /* If creating a temp table, the name may not be qualified. Unless
1242 ** the database name is "temp" anyway. */
1245 }
1250 }
1251 }
1256 }
1258 #ifndef SQLITE_OMIT_AUTHORIZATION
1261 {
1263 SQLITE_CREATE_TABLE,
1264 SQLITE_CREATE_TEMP_TABLE,
1265 SQLITE_CREATE_VIEW,
1266 SQLITE_CREATE_TEMP_VIEW
1267 };
1271 }
1275 }
1276 }
1277 #endif
1279 /* Make sure the new table name does not collide with an existing
1280 ** index or table name in the same database. Issue an error message if
1281 ** it does. The exception is if the statement being parsed was passed
1282 ** to an sqlite3_declare_vtab() call. In that case only the column names
1283 ** and types will be used, so there is no need to test for namespace
1284 ** collisions.
1285 */
1290 }
1300 }
1302 }
1306 }
1307 }
1315 }
1320 #ifdef SQLITE_DEFAULT_ROWEST
1322 #else
1324 #endif
1328 /* Begin generating the code that will insert the table record into
1329 ** the schema table. Note in particular that we must go ahead
1330 ** and allocate the record number for the table entry now. Before any
1331 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
1332 ** indices to be created and the table record must come before the
1333 ** indices. Hence, the record number for the table must be allocated
1334 ** now.
1335 */
1340 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
1344 #ifndef SQLITE_OMIT_VIRTUALTABLE
1347 }
1348 #endif
1350 /* If the file format and encoding in the database have not been set,
1351 ** set them now.
1352 */
1365 /* This just creates a place-holder record in the sqlite_schema table.
1366 ** The record created does not contain anything yet. It will be replaced
1367 ** by the real entry in code generated at sqlite3EndTable().
1368 **
1369 ** The rowid for the new entry is left in register pParse->regRowid.
1370 ** The root page number of the new table is left in reg pParse->regRoot.
1371 ** The rowid and root page number values are needed by the code that
1372 ** sqlite3EndTable will generate.
1373 */
1374 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1378 #endif
1379 {
1383 }
1390 }
1392 /* Normal (non-error) return. */
1395 /* If an error occurs, we jump here */
1396 begin_table_error:
1400 }
1402 /* Set properties of a table column based on the (magical)
1403 ** name of the column.
1404 */
1405 #if SQLITE_ENABLE_HIDDEN_COLUMNS
1412 }
1413 }
1414 #endif
1416 /*
1417 ** Name of the special TEMP trigger used to implement RETURNING. The
1418 ** name begins with "sqlite_" so that it is guaranteed not to collide
1419 ** with any application-generated triggers.
1420 */
1423 /*
1424 ** Clean up the data structures associated with the RETURNING clause.
1425 */
1432 }
1434 /*
1435 ** Add the RETURNING clause to the parse currently underway.
1436 **
1437 ** This routine creates a special TEMP trigger that will fire for each row
1438 ** of the DML statement. That TEMP trigger contains a single SELECT
1439 ** statement with a result set that is the argument of the RETURNING clause.
1440 ** The trigger has the Trigger.bReturning flag and an opcode of
1441 ** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
1442 ** knows to handle it specially. The TEMP trigger is automatically
1443 ** removed at the end of the parse.
1444 **
1445 ** When this routine is called, we do not yet know if the RETURNING clause
1446 ** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
1447 ** RETURNING trigger instead. It will then be converted into the appropriate
1448 ** type on the first call to sqlite3TriggersExist().
1449 */
1458 }
1464 }
1487 }
1488 }
1490 /*
1491 ** Add a new column to the table currently being constructed.
1492 **
1493 ** The parser calls this routine once for each column declaration
1494 ** in a CREATE TABLE statement. sqlite3StartTable() gets called
1495 ** first to get things going. Then this routine is called for each
1496 ** column.
1497 */
1505 u8 hName;
1515 }
1518 /* Because keywords GENERATE ALWAYS can be converted into indentifiers
1519 ** by the parser, we can sometimes end up with a typename that ends
1520 ** with "generated always". Check for this case and omit the surplus
1521 ** text. */
1524 ){
1529 ){
1532 }
1533 }
1535 /* Check for standard typenames. For standard typenames we will
1536 ** set the Column.eType field rather than storing the typename after
1537 ** the column name, in order to save space. */
1543 ){
1549 }
1550 }
1551 }
1565 }
1566 }
1571 }
1580 /* If there is no type specified, columns have the default affinity
1581 ** 'BLOB' with a default size of 4 bytes. */
1585 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1589 }
1590 }
1591 #endif
1599 }
1603 }
1605 /*
1606 ** This routine is called by the parser while in the middle of
1607 ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1608 ** been seen on a column. This routine sets the notNull flag on
1609 ** the column currently under construction.
1610 */
1620 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
1621 ** on this column. */
1628 }
1629 }
1630 }
1631 }
1633 /*
1634 ** Scan the column type name zType (length nType) and return the
1635 ** associated affinity type.
1636 **
1637 ** This routine does a case-independent search of zType for the
1638 ** substrings in the following table. If one of the substrings is
1639 ** found, the corresponding affinity is returned. If zType contains
1640 ** more than one of the substrings, entries toward the top of
1641 ** the table take priority. For example, if zType is 'BLOBINT',
1642 ** SQLITE_AFF_INTEGER is returned.
1643 **
1644 ** Substring | Affinity
1645 ** --------------------------------
1646 ** 'INT' | SQLITE_AFF_INTEGER
1647 ** 'CHAR' | SQLITE_AFF_TEXT
1648 ** 'CLOB' | SQLITE_AFF_TEXT
1649 ** 'TEXT' | SQLITE_AFF_TEXT
1650 ** 'BLOB' | SQLITE_AFF_BLOB
1651 ** 'REAL' | SQLITE_AFF_REAL
1652 ** 'FLOA' | SQLITE_AFF_REAL
1653 ** 'DOUB' | SQLITE_AFF_REAL
1654 **
1655 ** If none of the substrings in the above table are found,
1656 ** SQLITE_AFF_NUMERIC is returned.
1657 */
1666 zIn++;
1678 #ifndef SQLITE_OMIT_FLOATING_POINT
1688 #endif
1692 }
1693 }
1695 /* If pCol is not NULL, store an estimate of the field size. The
1696 ** estimate is scaled so that the size of an integer is 1. */
1703 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
1706 }
1707 zChar++;
1708 }
1711 }
1712 }
1713 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1716 }
1717 #endif
1721 }
1723 }
1725 /*
1726 ** The expression is the default value for the most recently added column
1727 ** of the table currently under construction.
1728 **
1729 ** Default value expressions must be constant. Raise an exception if this
1730 ** is not the case.
1731 **
1732 ** This routine is called by the parser while in the middle of
1733 ** parsing a CREATE TABLE statement.
1734 */
1740 ){
1751 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1756 #endif
1758 /* A copy of pExpr is used instead of the original, as pExpr contains
1759 ** tokens that point to volatile memory.
1760 */
1770 }
1771 }
1774 }
1776 }
1778 /*
1779 ** Backwards Compatibility Hack:
1780 **
1781 ** Historical versions of SQLite accepted strings as column names in
1782 ** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1783 **
1784 ** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1785 ** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1786 **
1787 ** This is goofy. But to preserve backwards compatibility we continue to
1788 ** accept it. This routine does the necessary conversion. It converts
1789 ** the expression given in its argument from a TK_STRING into a TK_ID
1790 ** if the expression is just a TK_STRING with an optional COLLATE clause.
1791 ** If the expression is anything other than TK_STRING, the expression is
1792 ** unchanged.
1793 */
1799 }
1800 }
1802 /*
1803 ** Tag the given column as being part of the PRIMARY KEY
1804 */
1807 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1813 }
1814 #endif
1815 }
1817 /*
1818 ** Designate the PRIMARY KEY for the table. pList is a list of names
1819 ** of columns that form the primary key. If pList is NULL, then the
1820 ** most recently added column of the table is the primary key.
1821 **
1822 ** A table can have at most one primary key. If the table already has
1823 ** a primary key (and this is the second primary key) then create an
1824 ** error.
1825 **
1826 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
1827 ** then we will try to use that column as the rowid. Set the Table.iPKey
1828 ** field of the table under construction to be the index of the
1829 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1830 ** no INTEGER PRIMARY KEY.
1831 **
1832 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
1833 ** index for the key. No index is created for INTEGER PRIMARY KEYs.
1834 */
1841 ){
1851 }
1873 }
1874 }
1875 }
1876 }
1877 }
1879 && pCol
1882 ){
1886 }
1894 #ifndef SQLITE_OMIT_AUTOINCREMENT
1897 #endif
1902 }
1904 primary_key_exit:
1907 }
1909 /*
1910 ** Add a new CHECK constraint to the table currently under construction.
1911 */
1917 ){
1918 #ifndef SQLITE_OMIT_CHECK
1923 ){
1928 Token t;
1934 }
1936 #endif
1937 {
1939 }
1940 }
1942 /*
1943 ** Set the collation function of the most recently parsed table column
1944 ** to the CollSeq given.
1945 */
1962 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1963 ** then an index may have been created on this column before the
1964 ** collation type was added. Correct this if it is the case.
1965 */
1970 }
1971 }
1972 }
1974 }
1976 /* Change the most recently parsed column to be a GENERATED ALWAYS AS
1977 ** column.
1978 */
1980 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1985 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
1987 }
1992 }
1996 /* no-op */
2001 }
2002 }
2010 }
2015 generated_error:
2018 generated_done:
2020 #else
2021 /* Throw and error for the GENERATED ALWAYS AS clause if the
2022 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
2025 #endif
2026 }
2028 /*
2029 ** Generate code that will increment the schema cookie.
2030 **
2031 ** The schema cookie is used to determine when the schema for the
2032 ** database changes. After each schema change, the cookie value
2033 ** changes. When a process first reads the schema it records the
2034 ** cookie. Thereafter, whenever it goes to access the database,
2035 ** it checks the cookie to make sure the schema has not changed
2036 ** since it was last read.
2037 **
2038 ** This plan is not completely bullet-proof. It is possible for
2039 ** the schema to change multiple times and for the cookie to be
2040 ** set back to prior value. But schema changes are infrequent
2041 ** and the probability of hitting the same cookie value is only
2042 ** 1 chance in 2^32. So we're safe enough.
2043 **
2044 ** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
2045 ** the schema-version whenever the schema changes.
2046 */
2053 }
2055 /*
2056 ** Measure the number of characters needed to output the given
2057 ** identifier. The number returned includes any quotes used
2058 ** but does not include the null terminator.
2059 **
2060 ** The estimate is conservative. It might be larger that what is
2061 ** really needed.
2062 */
2067 }
2069 }
2071 /*
2072 ** The first parameter is a pointer to an output buffer. The second
2073 ** parameter is a pointer to an integer that contains the offset at
2074 ** which to write into the output buffer. This function copies the
2075 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
2076 ** to the specified offset in the buffer and updates *pIdx to refer
2077 ** to the first byte after the last byte written before returning.
2078 **
2079 ** If the string zSignedIdent consists entirely of alpha-numeric
2080 ** characters, does not begin with a digit and is not an SQL keyword,
2081 ** then it is copied to the output buffer exactly as it is. Otherwise,
2082 ** it is quoted using double-quotes.
2083 */
2091 }
2101 }
2105 }
2107 /*
2108 ** Generate a CREATE TABLE statement appropriate for the given
2109 ** table. Memory to hold the text of the statement is obtained
2110 ** from sqliteMalloc() and must be freed by the calling function.
2111 */
2120 }
2130 }
2136 }
2148 };
2171 }
2174 }
2176 /*
2177 ** Resize an Index object to hold N columns total. Return SQLITE_OK
2178 ** on success and SQLITE_NOMEM on an OOM error.
2179 */
2202 }
2204 /*
2205 ** Estimate the total row width for a table.
2206 */
2213 }
2216 }
2218 /*
2219 ** Estimate the average size of a row for an index.
2220 */
2229 }
2231 }
2233 /* Return true if column number x is any of the first nCol entries of aiCol[].
2234 ** This is used to determine if the column number x appears in any of the
2235 ** first nCol entries of an index.
2236 */
2241 }
2242 }
2244 }
2246 /*
2247 ** Return true if any of the first nKey entries of index pIdx exactly
2248 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
2249 ** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
2250 ** or may not be the same index as pPk.
2251 **
2252 ** The first nKey entries of pIdx are guaranteed to be ordinary columns,
2253 ** not a rowid or expression.
2254 **
2255 ** This routine differs from hasColumn() in that both the column and the
2256 ** collating sequence must match for this routine, but for hasColumn() only
2257 ** the column name must match.
2258 */
2273 ){
2275 }
2276 }
2278 }
2280 /* Recompute the colNotIdxed field of the Index.
2281 **
2282 ** colNotIdxed is a bitmask that has a 0 bit representing each indexed
2283 ** columns that are within the first 63 columns of the table. The
2284 ** high-order bit of colNotIdxed is always 1. All unindexed columns
2285 ** of the table have a 1.
2286 **
2287 ** 2019-10-24: For the purpose of this computation, virtual columns are
2288 ** not considered to be covered by the index, even if they are in the
2289 ** index, because we do not trust the logic in whereIndexExprTrans() to be
2290 ** able to find all instances of a reference to the indexed table column
2291 ** and convert them into references to the index. Hence we always want
2292 ** the actual table at hand in order to recompute the virtual column, if
2293 ** necessary.
2294 **
2295 ** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
2296 ** to determine if the index is covering index.
2297 */
2308 }
2309 }
2312 }
2314 /*
2315 ** This routine runs at the end of parsing a CREATE TABLE statement that
2316 ** has a WITHOUT ROWID clause. The job of this routine is to convert both
2317 ** internal schema data structures and the generated VDBE code so that they
2318 ** are appropriate for a WITHOUT ROWID table instead of a rowid table.
2319 ** Changes include:
2320 **
2321 ** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
2322 ** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
2323 ** into BTREE_BLOBKEY.
2324 ** (3) Bypass the creation of the sqlite_schema table entry
2325 ** for the PRIMARY KEY as the primary key index is now
2326 ** identified by the sqlite_schema table entry of the table itself.
2327 ** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
2328 ** schema to the rootpage from the main table.
2329 ** (5) Add all table columns to the PRIMARY KEY Index object
2330 ** so that the PRIMARY KEY is a covering index. The surplus
2331 ** columns are part of KeyInfo.nAllField and are not used for
2332 ** sorting or lookup or uniqueness checks.
2333 ** (6) Replace the rowid tail on all automatically generated UNIQUE
2334 ** indices with the PRIMARY KEY columns.
2335 **
2336 ** For virtual tables, only (1) is performed.
2337 */
2347 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
2348 */
2353 ){
2355 }
2356 }
2358 }
2360 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
2361 ** into BTREE_BLOBKEY.
2362 */
2367 }
2369 /* Locate the PRIMARY KEY index. Or, if this table was originally
2370 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
2371 */
2374 Token ipkToken;
2381 }
2384 }
2389 SQLITE_IDXTYPE_PRIMARYKEY);
2393 }
2401 /*
2402 ** Remove all redundant columns from the PRIMARY KEY. For example, change
2403 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
2404 ** code assumes the PRIMARY KEY contains no repeated columns.
2405 */
2414 }
2415 }
2417 }
2423 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema
2424 ** table entry. This is only required if currently generating VDBE
2425 ** code for a CREATE TABLE (not when parsing one as part of reading
2426 ** a database schema). */
2430 }
2432 /* The root page of the PRIMARY KEY is the table root page */
2435 /* Update the in-memory representation of all UNIQUE indices by converting
2436 ** the final rowid column into one or more columns of the PRIMARY KEY.
2437 */
2444 n++;
2445 }
2446 }
2448 /* This index is a superset of the primary key */
2451 }
2459 /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
2461 }
2462 j++;
2463 }
2464 }
2467 }
2469 /* Add all table columns to the PRIMARY KEY index
2470 */
2475 }
2480 ){
2484 j++;
2485 }
2486 }
2490 }
2493 #ifndef SQLITE_OMIT_VIRTUALTABLE
2494 /*
2495 ** Return true if pTab is a virtual table and zName is a shadow table name
2496 ** for that virtual table.
2497 */
2511 }
2514 #ifndef SQLITE_OMIT_VIRTUALTABLE
2515 /*
2516 ** Table pTab is a virtual table. If it the virtual table implementation
2517 ** exists and has an xShadowName method, then loop over all other ordinary
2518 ** tables within the same schema looking for shadow tables of pTab, and mark
2519 ** any shadow tables seen using the TF_Shadow flag.
2520 */
2542 ){
2544 }
2545 }
2546 }
2549 #ifndef SQLITE_OMIT_VIRTUALTABLE
2550 /*
2551 ** Return true if zName is a shadow table name in the current database
2552 ** connection.
2553 **
2554 ** zName is temporarily modified while this routine is running, but is
2555 ** restored to its original value prior to this routine returning.
2556 */
2568 }
2572 #ifdef SQLITE_DEBUG
2573 /*
2574 ** Mark all nodes of an expression as EP_Immutable, indicating that
2575 ** they should not be changed. Expressions attached to a table or
2576 ** index definition are tagged this way to help ensure that we do
2577 ** not pass them into code generator routines by mistake.
2578 */
2582 }
2585 Walker w;
2591 }
2592 }
2593 #else
2598 /*
2599 ** This routine is called to report the final ")" that terminates
2600 ** a CREATE TABLE statement.
2601 **
2602 ** The table structure that other action routines have been building
2603 ** is added to the internal hash tables, assuming no errors have
2604 ** occurred.
2605 **
2606 ** An entry for the table is made in the schema table on disk, unless
2607 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
2608 ** it means we are reading the sqlite_schema table because we just
2609 ** connected to the database or because the sqlite_schema table has
2610 ** recently changed, so the entry for this table already exists in
2611 ** the sqlite_schema table. We do not want to create it again.
2612 **
2613 ** If the pSelect argument is not NULL, it means that this routine
2614 ** was called to create a table generated from a
2615 ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
2616 ** the new table will match the result set of the SELECT.
2617 */
2624 ){
2632 }
2638 }
2640 /* If the db->init.busy is 1 it means we are reading the SQL off the
2641 ** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
2642 ** So do not write to the disk again. Extract the root page number
2643 ** for the table from the db->init.newTnum field. (The page number
2644 ** should have been put there by the sqliteOpenCb routine.)
2645 **
2646 ** If the root page number is 1, that means this is the sqlite_schema
2647 ** table itself. So mark it read-only.
2648 */
2653 }
2656 }
2658 /* Special processing for tables that include the STRICT keyword:
2659 **
2660 ** * Do not allow custom column datatypes. Every column must have
2661 ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
2662 **
2663 ** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY,
2664 ** then all columns of the PRIMARY KEY must have a NOT NULL
2665 ** constraint.
2666 */
2677 );
2681 }
2685 }
2689 ){
2692 }
2693 }
2694 }
2701 /* Special processing for WITHOUT ROWID Tables */
2707 }
2711 }
2714 }
2717 #ifndef SQLITE_OMIT_CHECK
2718 /* Resolve names in all CHECK constraint expressions.
2719 */
2723 /* If errors are seen, delete the CHECK constraints now, else they might
2724 ** actually be used if PRAGMA writable_schema=ON is set. */
2729 }
2730 }
2732 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
2744 /* If there are errors in resolving the expression, change the
2745 ** expression to a NULL. This prevents code generators that operate
2746 ** on the expression from inserting extra parts into the expression
2747 ** tree that have been allocated from lookaside memory, which is
2748 ** illegal in a schema and will lead to errors or heap corruption
2749 ** when the database connection closes. */
2752 }
2754 nNG++;
2755 }
2756 }
2760 }
2761 }
2762 #endif
2764 /* Estimate the average row size for the table and for all implied indices */
2768 }
2770 /* If not initializing, then create a record for the new table
2771 ** in the schema table of the database.
2772 **
2773 ** If this is a TEMPORARY table, write the entry into the auxiliary
2774 ** file instead of into the main database file.
2775 */
2788 /*
2789 ** Initialize zType for the new view or table.
2790 */
2792 /* A regular table */
2795 #ifndef SQLITE_OMIT_VIEW
2797 /* A view */
2800 #endif
2801 }
2803 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
2804 ** statement to populate the new table. The root-page number for the
2805 ** new table is in register pParse->regRoot.
2806 **
2807 ** Once the SELECT has been coded by sqlite3Select(), it is in a
2808 ** suitable state to query for the column names and types to be used
2809 ** by the new table.
2810 **
2811 ** A shared-cache write-lock is not required to write to the new table,
2812 ** as a schema-lock must have already been obtained to create it. Since
2813 ** a schema-lock excludes all other database users, the write-lock would
2814 ** be redundant.
2815 */
2829 }
2863 }
2865 /* Compute the complete text of the CREATE statement */
2874 );
2875 }
2877 /* A slot for the record has already been allocated in the
2878 ** schema table. We just need to update that slot with all
2879 ** the information we've collected.
2880 */
2882 "UPDATE %Q." LEGACY_SCHEMA_TABLE
2883 " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
2886 zType,
2890 zStmt,
2891 pParse->regRowid
2892 );
2896 #ifndef SQLITE_OMIT_AUTOINCREMENT
2897 /* Check to see if we need to create an sqlite_sequence table for
2898 ** keeping track of autoincrement keys.
2899 */
2906 pDb->zDbSName
2907 );
2908 }
2909 }
2910 #endif
2912 /* Reparse everything to update our internal data structures */
2915 }
2917 /* Add the table to the in-memory representation of the database.
2918 */
2929 }
2933 /* If this is the magic sqlite_sequence table used by autoincrement,
2934 ** then record a pointer to this table in the main database structure
2935 ** so that INSERT can find the table easily. */
2937 #ifndef SQLITE_OMIT_AUTOINCREMENT
2941 }
2942 #endif
2943 }
2945 #ifndef SQLITE_OMIT_ALTERTABLE
2950 }
2952 }
2953 #endif
2954 }
2956 #ifndef SQLITE_OMIT_VIEW
2957 /*
2958 ** The parser calls this routine in order to create a new VIEW
2959 */
2969 ){
2973 Token sEnd;
2974 DbFixer sFix;
2982 }
2987 /* Legacy versions of SQLite allowed the use of the magic "rowid" column
2988 ** on a view, even though views do not have rowids. The following flag
2989 ** setting fixes this problem. But the fix can be disabled by compiling
2990 ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
2991 ** depend upon the old buggy behavior. */
2992 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
2994 #endif
3001 /* Make a copy of the entire SELECT statement that defines the view.
3002 ** This will force all the Expr.token.z values to be dynamically
3003 ** allocated rather than point to the input string - which means that
3004 ** they will persist after the current sqlite3_exec() call returns.
3005 */
3012 }
3017 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
3018 ** the end.
3019 */
3024 }
3033 /* Use sqlite3EndTable() to add the view to the schema table */
3036 create_view_fail:
3040 }
3043 }
3046 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
3047 /*
3048 ** The Table structure pTable is really a VIEW. Fill in the names of
3049 ** the columns of the view in the pTable structure. Return the number
3050 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
3051 */
3057 #ifndef SQLITE_OMIT_VIRTUALTABLE
3059 #endif
3060 #ifndef SQLITE_OMIT_AUTHORIZATION
3062 #endif
3066 #ifndef SQLITE_OMIT_VIRTUALTABLE
3072 }
3073 #endif
3075 #ifndef SQLITE_OMIT_VIEW
3076 /* A positive nCol means the columns names for this view are
3077 ** already known.
3078 */
3081 /* A negative nCol is a special marker meaning that we are currently
3082 ** trying to compute the column names. If we enter this routine with
3083 ** a negative nCol, it means two or more views form a loop, like this:
3084 **
3085 ** CREATE VIEW one AS SELECT * FROM two;
3086 ** CREATE VIEW two AS SELECT * FROM one;
3087 **
3088 ** Actually, the error above is now caught prior to reaching this point.
3089 ** But the following test is still important as it does come up
3090 ** in the following:
3091 **
3092 ** CREATE TABLE main.ex1(a);
3093 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
3094 ** SELECT * FROM temp.ex1;
3095 */
3099 }
3102 /* If we get this far, it means we need to compute the table names.
3103 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
3104 ** "*" elements in the results set of the view and will assign cursors
3105 ** to the elements of the FROM clause. But we do not want these changes
3106 ** to be permanent. So the computation is done on a copy of the SELECT
3107 ** statement that defines the view.
3108 */
3118 DisableLookaside;
3119 #ifndef SQLITE_OMIT_AUTHORIZATION
3124 #else
3126 #endif
3131 nErr++;
3133 /* CREATE VIEW name(arglist) AS ...
3134 ** The names of the columns in the table are taken from
3135 ** arglist which is stored in pTable->pCheck. The pCheck field
3136 ** normally holds CHECK constraints on an ordinary table, but for
3137 ** a VIEW it holds the list of column names.
3138 */
3143 ){
3146 SQLITE_AFF_NONE);
3147 }
3149 /* CREATE VIEW name AS... without an argument list. Construct
3150 ** the column names from the SELECT statement that defines the view.
3151 */
3159 }
3163 EnableLookaside;
3166 nErr++;
3167 }
3171 }
3174 }
3177 #ifndef SQLITE_OMIT_VIEW
3178 /*
3179 ** Clear the column names from every VIEW in database idx.
3180 */
3189 }
3190 }
3192 }
3193 #else
3194 # define sqliteViewResetAll(A,B)
3197 /*
3198 ** This function is called by the VDBE to adjust the internal schema
3199 ** used by SQLite when the btree layer moves a table root page. The
3200 ** root-page of a table or index in database iDb has changed from iFrom
3201 ** to iTo.
3202 **
3203 ** Ticket #1728: The symbol table might still contain information
3204 ** on tables and/or indices that are the process of being deleted.
3205 ** If you are unlucky, one of those deleted indices or tables might
3206 ** have the same rootpage number as the real table or index that is
3207 ** being moved. So we cannot stop searching after the first match
3208 ** because the first match might be for one of the deleted indices
3209 ** or tables and not the table/index that is actually being moved.
3210 ** We must continue looping until all tables and indices with
3211 ** rootpage==iFrom have been converted to have a rootpage of iTo
3212 ** in order to be certain that we got the right one.
3213 */
3214 #ifndef SQLITE_OMIT_AUTOVACUUM
3227 }
3228 }
3234 }
3235 }
3236 }
3237 #endif
3239 /*
3240 ** Write code to erase the table with root-page iTable from database iDb.
3241 ** Also write code to modify the sqlite_schema table and internal schema
3242 ** if a root-page of another table is moved by the btree-layer whilst
3243 ** erasing iTable (this can happen with an auto-vacuum database).
3244 */
3251 #ifndef SQLITE_OMIT_AUTOVACUUM
3252 /* OP_Destroy stores an in integer r1. If this integer
3253 ** is non-zero, then it is the root page number of a table moved to
3254 ** location iTable. The following code modifies the sqlite_schema table to
3255 ** reflect this.
3256 **
3257 ** The "#NNN" in the SQL is a special constant that means whatever value
3258 ** is in register NNN. See grammar rules associated with the TK_REGISTER
3259 ** token for additional information.
3260 */
3262 "UPDATE %Q." LEGACY_SCHEMA_TABLE
3265 #endif
3267 }
3269 /*
3270 ** Write VDBE code to erase table pTab and all associated indices on disk.
3271 ** Code to update the sqlite_schema tables and internal schema definitions
3272 ** in case a root-page belonging to another table is moved by the btree layer
3273 ** is also added (this can happen with an auto-vacuum database).
3274 */
3276 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
3277 ** is not defined), then it is important to call OP_Destroy on the
3278 ** table and index root-pages in order, starting with the numerically
3279 ** largest root-page number. This guarantees that none of the root-pages
3280 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
3281 ** following were coded:
3282 **
3283 ** OP_Destroy 4 0
3284 ** ...
3285 ** OP_Destroy 5 0
3286 **
3287 ** and root page 5 happened to be the largest root-page number in the
3288 ** database, then root page 5 would be moved to page 4 by the
3289 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
3290 ** a free-list page.
3291 */
3301 }
3307 }
3308 }
3316 }
3317 }
3318 }
3320 /*
3321 ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
3322 ** after a DROP INDEX or DROP TABLE command.
3323 */
3329 ){
3339 );
3340 }
3341 }
3342 }
3344 /*
3345 ** Generate code to drop a table.
3346 */
3357 #ifndef SQLITE_OMIT_VIRTUALTABLE
3360 }
3361 #endif
3363 /* Drop all triggers associated with the table being dropped. Code
3364 ** is generated to remove entries from sqlite_schema and/or
3365 ** sqlite_temp_schema if required.
3366 */
3373 }
3375 #ifndef SQLITE_OMIT_AUTOINCREMENT
3376 /* Remove any entries of the sqlite_sequence table associated with
3377 ** the table being dropped. This is done before the table is dropped
3378 ** at the btree level, in case the sqlite_sequence table needs to
3379 ** move as a result of the drop (can happen in auto-vacuum mode).
3380 */
3385 );
3386 }
3387 #endif
3389 /* Drop all entries in the schema table that refer to the
3390 ** table. The program name loops through the schema table and deletes
3391 ** every row that refers to a table of the same name as the one being
3392 ** dropped. Triggers are handled separately because a trigger can be
3393 ** created in the temp database that refers to a table in another
3394 ** database.
3395 */
3397 "DELETE FROM %Q." LEGACY_SCHEMA_TABLE
3402 }
3404 /* Remove the table entry from SQLite's internal schema and modify
3405 ** the schema cookie.
3406 */
3410 }
3414 }
3416 /*
3417 ** Return TRUE if shadow tables should be read-only in the current
3418 ** context.
3419 */
3421 #ifndef SQLITE_OMIT_VIRTUALTABLE
3426 ){
3428 }
3429 #endif
3431 }
3433 /*
3434 ** Return true if it is not allowed to drop the given table
3435 */
3441 }
3444 }
3447 }
3449 }
3451 /*
3452 ** This routine is called to do the work of a DROP TABLE statement.
3453 ** pName is the name of the table to be dropped.
3454 */
3463 }
3476 }
3478 }
3482 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
3483 ** it is initialized.
3484 */
3487 }
3488 #ifndef SQLITE_OMIT_AUTHORIZATION
3489 {
3496 }
3502 }
3503 #ifndef SQLITE_OMIT_VIRTUALTABLE
3507 #endif
3513 }
3514 }
3517 }
3520 }
3521 }
3522 #endif
3526 }
3528 #ifndef SQLITE_OMIT_VIEW
3529 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
3530 ** on a table.
3531 */
3535 }
3539 }
3540 #endif
3542 /* Generate code to remove the table from the schema table
3543 ** on disk.
3544 */
3551 }
3553 }
3555 exit_drop_table:
3557 }
3559 /*
3560 ** This routine is called to create a new foreign key on the table
3561 ** currently under construction. pFromCol determines which columns
3562 ** in the current table point to the foreign key. If pFromCol==0 then
3563 ** connect the key to the last column inserted. pTo is the name of
3564 ** the table referred to (a.k.a the "parent" table). pToCol is a list
3565 ** of tables in the parent pTo table. flags contains all
3566 ** information about the conflict resolution algorithms specified
3567 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
3568 **
3569 ** An FKey structure is created and added to the table currently
3570 ** under construction in the pParse->pNewTable field.
3571 **
3572 ** The foreign key is set for IMMEDIATE processing. A subsequent call
3573 ** to sqlite3DeferForeignKey() might change this to DEFERRED.
3574 */
3581 ){
3583 #ifndef SQLITE_OMIT_FOREIGN_KEY
3587 i64 nByte;
3602 }
3606 "number of columns in foreign key does not match the number of "
3611 }
3616 }
3617 }
3621 }
3629 }
3644 }
3645 }
3651 }
3654 }
3655 }
3656 }
3663 }
3667 }
3668 }
3676 );
3680 }
3685 }
3687 /* Link the foreign key to the table as the last step.
3688 */
3693 fk_end:
3698 }
3700 /*
3701 ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
3702 ** clause is seen as part of a foreign key definition. The isDeferred
3703 ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
3704 ** The behavior of the most recently created foreign key is adjusted
3705 ** accordingly.
3706 */
3708 #ifndef SQLITE_OMIT_FOREIGN_KEY
3716 #endif
3717 }
3719 /*
3720 ** Generate code that will erase and refill index *pIdx. This is
3721 ** used to initialize a newly created index or to recompute the
3722 ** content of an index in response to a REINDEX command.
3723 **
3724 ** if memRootPage is not negative, it means that the index is newly
3725 ** created. The register specified by memRootPage contains the
3726 ** root page number of the index. If memRootPage is negative, then
3727 ** the index already exists and must be cleared before being refilled and
3728 ** the root page number of the index is taken from pIndex->tnum.
3729 */
3745 #ifndef SQLITE_OMIT_AUTHORIZATION
3749 }
3750 #endif
3752 /* Require a write-lock on the table to perform this operation */
3761 }
3765 /* Open the sorter cursor if we are to use one. */
3770 /* Open the table. Loop through all rows of the table, inserting index
3771 ** records into the sorter. */
3797 /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
3798 ** abort. The exception is if one of the indexed expressions contains a
3799 ** user function that throws an exception when it is evaluated. But the
3800 ** overhead of adding a statement journal to a CREATE INDEX statement is
3801 ** very small (since most of the pages written do not contain content that
3802 ** needs to be restored if the statement aborts), so we call
3803 ** sqlite3MayAbort() for all CREATE INDEX statements. */
3806 }
3809 /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
3810 ** faster by avoiding unnecessary seeks. But the optimization does
3811 ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
3812 ** with DESC primary keys, since those indexes have there keys in
3813 ** a different order from the main table.
3814 ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
3815 */
3817 }
3827 }
3829 /*
3830 ** Allocate heap space to hold an Index object with nCol columns.
3831 **
3832 ** Increase the allocation size to provide an extra nExtra bytes
3833 ** of 8-byte aligned space after the Index object and return a
3834 ** pointer to this extra space in *ppExtra.
3835 */
3841 ){
3860 }
3862 }
3864 /*
3865 ** If expression list pList contains an expression that was parsed with
3866 ** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
3867 ** pParse and return non-zero. Otherwise, return zero.
3868 */
3877 );
3879 }
3880 }
3881 }
3883 }
3885 /*
3886 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
3887 ** and pTblList is the name of the table that is to be indexed. Both will
3888 ** be NULL for a primary key or an index that is created to satisfy a
3889 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
3890 ** as the table to be indexed. pParse->pNewTable is a table that is
3891 ** currently being constructed by a CREATE TABLE statement.
3892 **
3893 ** pList is a list of columns to be indexed. pList will be NULL if this
3894 ** is a primary key or unique-constraint on the most recent column added
3895 ** to the table currently under construction.
3896 */
3908 u8 idxType /* The index type */
3909 ){
3930 }
3934 }
3937 }
3940 }
3942 /*
3943 ** Find the table that is to be indexed. Return early if not found.
3944 */
3947 /* Use the two-part index name to determine the database
3948 ** to search for the table. 'Fix' the table name to this db
3949 ** before looking up the table.
3950 */
3956 #ifndef SQLITE_OMIT_TEMPDB
3957 /* If the index name was unqualified, check if the table
3958 ** is a temp table. If so, set the database to 1. Do not do this
3959 ** if initialising a database schema.
3960 */
3965 }
3966 }
3967 #endif
3971 /* Because the parser constructs pTblName from a single identifier,
3972 ** sqlite3FixSrcList can never fail. */
3974 }
3983 }
3991 }
3998 #if SQLITE_USER_AUTHENTICATION
4000 #endif
4001 ){
4004 }
4005 #ifndef SQLITE_OMIT_VIEW
4009 }
4010 #endif
4011 #ifndef SQLITE_OMIT_VIRTUALTABLE
4015 }
4016 #endif
4018 /*
4019 ** Find the name of the index. Make sure there is not already another
4020 ** index or table with the same name.
4021 **
4022 ** Exception: If we are reading the names of permanent indices from the
4023 ** sqlite_schema table (because some other process changed the schema) and
4024 ** one of the index names collides with the name of a temporary table or
4025 ** index, then we will continue to process this index.
4026 **
4027 ** If pName==0 it means that we are
4028 ** dealing with a primary key or UNIQUE constraint. We have to invent our
4029 ** own name.
4030 */
4037 }
4043 }
4044 }
4052 }
4054 }
4055 }
4063 }
4065 /* Automatic index names generated from within sqlite3_declare_vtab()
4066 ** must have names that are distinct from normal automatic index names.
4067 ** The following statement converts "sqlite3_autoindex..." into
4068 ** "sqlite3_butoindex..." in order to make the names distinct.
4069 ** The "vtab_err.test" test demonstrates the need of this statement. */
4071 }
4073 /* Check for authorization to create an index.
4074 */
4075 #ifndef SQLITE_OMIT_AUTHORIZATION
4080 }
4085 }
4086 }
4087 #endif
4089 /* If pList==0, it means this routine was called to make a primary
4090 ** key out of the last column added to the table under construction.
4091 ** So create a fake list to simulate this.
4092 */
4094 Token prevCol;
4106 }
4108 /* Figure out how many bytes of space are required to store explicitly
4109 ** specified collation sequence names.
4110 */
4117 }
4118 }
4120 /*
4121 ** Allocate the index structure.
4122 */
4130 }
4146 }
4149 /* Check to see if we should honor DESC requests on index columns
4150 */
4155 }
4157 /* Analyze the list of expressions that form the terms of the index and
4158 ** report any errors. In the common case where the expression is exactly
4159 ** a table column, store that column in aiColumn[]. For general expressions,
4160 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
4161 **
4162 ** TODO: Issue a warning if two or more columns of the index are identical.
4163 ** TODO: Issue a warning if the table primary key is used as part of the
4164 ** index key.
4165 */
4170 }
4185 }
4189 }
4201 }
4204 }
4205 }
4207 }
4221 }
4225 }
4229 }
4231 /* Append the table key to the end of the index. For WITHOUT ROWID
4232 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
4233 ** normal tables (when pPk==0) this will be the rowid.
4234 */
4246 i++;
4247 }
4248 }
4253 }
4257 /* If this index contains every column of its table, then mark
4258 ** it as a covering index */
4269 }
4270 }
4273 /* This routine has been called to create an automatic index as a
4274 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
4275 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
4276 ** i.e. one of:
4277 **
4278 ** CREATE TABLE t(x PRIMARY KEY, y);
4279 ** CREATE TABLE t(x, y, UNIQUE(x, y));
4280 **
4281 ** Either way, check to see if the table already has such an index. If
4282 ** so, don't bother creating this one. This only applies to
4283 ** automatically created indices. Users can do as they wish with
4284 ** explicit indices.
4285 **
4286 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
4287 ** (and thus suppressing the second one) even if they have different
4288 ** sort orders.
4289 **
4290 ** If there are different collating sequences or if the columns of
4291 ** the constraint occur in different orders, then the constraints are
4292 ** considered distinct and both result in separate indices.
4293 */
4310 }
4313 /* This constraint creates the same index as a previous
4314 ** constraint specified somewhere in the CREATE TABLE statement.
4315 ** However the ON CONFLICT clauses are different. If both this
4316 ** constraint and the previous equivalent constraint have explicit
4317 ** ON CONFLICT clauses this is an error. Otherwise, use the
4318 ** explicitly specified behavior for the index.
4319 */
4323 }
4326 }
4327 }
4333 }
4335 }
4336 }
4337 }
4341 /* Link the new Index structure to its table and to the other
4342 ** in-memory database structures.
4343 */
4355 }
4356 }
4363 }
4365 }
4367 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
4368 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
4369 ** emit code to allocate the index rootpage on disk and make an entry for
4370 ** the index in the sqlite_schema table and populate the index with
4371 ** content. But, do not do this if we are simply reading the sqlite_schema
4372 ** table to parse the schema, or if this index is the PRIMARY KEY index
4373 ** of a WITHOUT ROWID table.
4374 **
4375 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
4376 ** or UNIQUE index in a CREATE TABLE statement. Since the table
4377 ** has just been created, it contains no data and the index initialization
4378 ** step can be skipped.
4379 */
4390 /* Create the rootpage for the index using CreateIndex. But before
4391 ** doing so, code a Noop instruction and store its address in
4392 ** Index.tnum. This is required in case this index is actually a
4393 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
4394 ** that case the convertToWithoutRowidTable() routine will replace
4395 ** the Noop with a Goto to jump over the VDBE code generated below. */
4399 /* Gather the complete text of the CREATE INDEX statement into
4400 ** the zStmt variable
4401 */
4406 /* A named index with an explicit CREATE INDEX statement */
4410 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
4411 /* zStmt = sqlite3MPrintf(""); */
4413 }
4415 /* Add an entry in sqlite_schema for this index
4416 */
4422 iMem,
4423 zStmt
4424 );
4427 /* Fill the index with data and reparse the schema. Code an OP_Expire
4428 ** to invalidate all pre-compiled statements.
4429 */
4436 }
4439 }
4440 }
4445 }
4450 }
4452 /* Clean up before exiting */
4453 exit_create_index:
4456 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
4457 ** The list was already ordered when this routine was entered, so at this
4458 ** point at most a single index (the newly added index) will be out of
4459 ** order. So we have to reorder at most one index. */
4470 }
4472 }
4473 #ifdef SQLITE_DEBUG
4474 /* Verify that all REPLACE indexes really are now at the end
4475 ** of the index list. In other words, no other index type ever
4476 ** comes after a REPLACE index on the list. */
4481 }
4482 #endif
4483 }
4488 }
4490 /*
4491 ** Fill the Index.aiRowEst[] array with default information - information
4492 ** to be used when we have not run the ANALYZE command.
4493 **
4494 ** aiRowEst[0] is supposed to contain the number of elements in the index.
4495 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
4496 ** number of rows in the table that match any particular value of the
4497 ** first column of the index. aiRowEst[2] is an estimate of the number
4498 ** of rows that match any particular combination of the first 2 columns
4499 ** of the index. And so forth. It must always be the case that
4500 *
4501 ** aiRowEst[N]<=aiRowEst[N-1]
4502 ** aiRowEst[N]>=1
4503 **
4504 ** Apart from that, we have little to go on besides intuition as to
4505 ** how aiRowEst[] should be initialized. The numbers generated here
4506 ** are based on typical values found in actual indices.
4507 */
4509 /* 10, 9, 8, 7, 6 */
4512 LogEst x;
4516 /* Indexes with default row estimates should not have stat1 data */
4519 /* Set the first entry (number of rows in the index) to the estimated
4520 ** number of rows in the table, or half the number of rows in the table
4521 ** for a partial index.
4522 **
4523 ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
4524 ** table but other parts we are having to guess at, then do not let the
4525 ** estimated number of rows in the table be less than 1000 (LogEst 99).
4526 ** Failure to do this can cause the indexes for which we do not have
4527 ** stat1 data to be ignored by the query planner.
4528 */
4533 }
4537 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
4538 ** 6 and each subsequent value (if any) is 5. */
4542 }
4546 }
4548 /*
4549 ** This routine will drop an existing named index. This routine
4550 ** implements the DROP INDEX statement.
4551 */
4560 }
4565 }
4573 }
4576 }
4581 }
4583 #ifndef SQLITE_OMIT_AUTHORIZATION
4584 {
4591 }
4595 }
4596 }
4597 #endif
4599 /* Generate code to remove the index and from the schema table */
4606 );
4611 }
4613 exit_drop_index:
4615 }
4617 /*
4618 ** pArray is a pointer to an array of objects. Each object in the
4619 ** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
4620 ** to extend the array so that there is space for a new object at the end.
4621 **
4622 ** When this function is called, *pnEntry contains the current size of
4623 ** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
4624 ** in total).
4625 **
4626 ** If the realloc() is successful (i.e. if no OOM condition occurs), the
4627 ** space allocated for the new object is zeroed, *pnEntry updated to
4628 ** reflect the new size of the array and a pointer to the new allocation
4629 ** returned. *pIdx is set to the index of the new array entry in this case.
4630 **
4631 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
4632 ** unchanged and a copy of pArray returned.
4633 */
4640 ){
4649 }
4651 }
4656 }
4658 /*
4659 ** Append a new element to the given IdList. Create a new IdList if
4660 ** need be.
4661 **
4662 ** A new IdList is returned, or NULL if malloc() fails.
4663 */
4677 }
4679 }
4684 }
4686 }
4688 /*
4689 ** Delete an IdList.
4690 */
4697 }
4699 }
4701 /*
4702 ** Return the index in pList of the identifier named zId. Return -1
4703 ** if not found.
4704 */
4710 }
4712 }
4714 /*
4715 ** Maximum size of a SrcList object.
4716 ** The SrcList object is used to represent the FROM clause of a
4717 ** SELECT statement, and the query planner cannot deal with more
4718 ** than 64 tables in a join. So any value larger than 64 here
4719 ** is sufficient for most uses. Smaller values, like say 10, are
4720 ** appropriate for small and memory-limited applications.
4721 */
4722 #ifndef SQLITE_MAX_SRCLIST
4723 # define SQLITE_MAX_SRCLIST 200
4724 #endif
4726 /*
4727 ** Expand the space allocated for the given SrcList object by
4728 ** creating nExtra new slots beginning at iStart. iStart is zero based.
4729 ** New slots are zeroed.
4730 **
4731 ** For example, suppose a SrcList initially contains two entries: A,B.
4732 ** To append 3 new entries onto the end, do this:
4733 **
4734 ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
4735 **
4736 ** After the call above it would contain: A, B, nil, nil, nil.
4737 ** If the iStart argument had been 1 instead of 2, then the result
4738 ** would have been: A, nil, nil, nil, B. To prepend the new slots,
4739 ** the iStart value would be 0. The result then would
4740 ** be: nil, nil, nil, A, B.
4741 **
4742 ** If a memory allocation fails or the SrcList becomes too large, leave
4743 ** the original SrcList unchanged, return NULL, and leave an error message
4744 ** in pParse.
4745 */
4751 ){
4754 /* Sanity checking on calling parameters */
4760 /* Allocate additional space if needed */
4768 SQLITE_MAX_SRCLIST);
4770 }
4777 }
4780 }
4782 /* Move existing slots that come after the newly inserted slots
4783 ** out of the way */
4786 }
4789 /* Zero the newly allocated slots */
4793 }
4795 /* Return a pointer to the enlarged SrcList */
4797 }
4800 /*
4801 ** Append a new table name to the given SrcList. Create a new SrcList if
4802 ** need be. A new entry is created in the SrcList even if pTable is NULL.
4803 **
4804 ** A SrcList is returned, or NULL if there is an OOM error or if the
4805 ** SrcList grows to large. The returned
4806 ** SrcList might be the same as the SrcList that was input or it might be
4807 ** a new one. If an OOM error does occurs, then the prior value of pList
4808 ** that is input to this routine is automatically freed.
4809 **
4810 ** If pDatabase is not null, it means that the table has an optional
4811 ** database name prefix. Like this: "database.table". The pDatabase
4812 ** points to the table name and the pTable points to the database name.
4813 ** The SrcList.a[].zName field is filled with the table name which might
4814 ** come from pTable (if pDatabase is NULL) or from pDatabase.
4815 ** SrcList.a[].zDatabase is filled with the database name from pTable,
4816 ** or with NULL if no database is specified.
4817 **
4818 ** In other words, if call like this:
4819 **
4820 ** sqlite3SrcListAppend(D,A,B,0);
4821 **
4822 ** Then B is a table name and the database name is unspecified. If called
4823 ** like this:
4824 **
4825 ** sqlite3SrcListAppend(D,A,B,C);
4826 **
4827 ** Then C is the table name and B is the database name. If C is defined
4828 ** then so is B. In other words, we never have a case where:
4829 **
4830 ** sqlite3SrcListAppend(D,A,0,C);
4831 **
4832 ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
4833 ** before being added to the SrcList.
4834 */
4840 ){
4861 }
4862 }
4866 }
4873 }
4875 }
4877 /*
4878 ** Assign VdbeCursor index numbers to all tables in a SrcList
4879 */
4890 }
4891 }
4892 }
4893 }
4895 /*
4896 ** Delete an entire SrcList including all its substructure.
4897 */
4914 }
4915 }
4917 }
4919 /*
4920 ** This routine is called by the parser to add a new term to the
4921 ** end of a growing FROM clause. The "p" parameter is the part of
4922 ** the FROM clause that has already been constructed. "p" is NULL
4923 ** if this is the first term of the FROM clause. pTable and pDatabase
4924 ** are the name of the table and database named in the FROM clause term.
4925 ** pDatabase is NULL if the database name qualifier is missing - the
4926 ** usual case. If the term has an alias, then pAlias points to the
4927 ** alias token. If the term is a subquery, then pSubquery is the
4928 ** SELECT statement that the subquery encodes. The pTable and
4929 ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
4930 ** parameters are the content of the ON and USING clauses.
4931 **
4932 ** Return a new SrcList which encodes is the FROM with the new
4933 ** term added.
4934 */
4943 ){
4949 );
4951 }
4955 }
4963 }
4967 }
4972 }
4973 }
4983 }
4986 append_from_error:
4991 }
4993 /*
4994 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
4995 ** element of the source-list passed as the second argument.
4996 */
5007 /* A "NOT INDEXED" clause was supplied. See parse.y
5008 ** construct "indexed_opt" for details. */
5014 }
5015 }
5016 }
5018 /*
5019 ** Append the contents of SrcList p2 to SrcList p1 and return the resulting
5020 ** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
5021 ** are deleted by this function.
5022 */
5034 }
5035 }
5037 }
5039 /*
5040 ** Add the list of function arguments to the SrcList entry for a
5041 ** table-valued-function.
5042 */
5053 }
5054 }
5056 /*
5057 ** When building up a FROM clause in the parser, the join operator
5058 ** is initially attached to the left operand. But the code generator
5059 ** expects the join operator to be on the right operand. This routine
5060 ** Shifts all join operators from left to right for an entire FROM
5061 ** clause.
5062 **
5063 ** Example: Suppose the join is like this:
5064 **
5065 ** A natural cross join B
5066 **
5067 ** The operator is "natural cross join". The A and B operands are stored
5068 ** in p->a[0] and p->a[1], respectively. The parser initially stores the
5069 ** operator with A. This routine shifts that operator over to B.
5070 **
5071 ** Additional changes:
5072 **
5073 ** * All tables to the left of the right-most RIGHT JOIN are tagged with
5074 ** JT_LTORJ (mnemonic: Left Table Of Right Join) so that the
5075 ** code generator can easily tell that the table is part of
5076 ** the left operand of at least one RIGHT JOIN.
5077 */
5088 /* All terms to the left of a RIGHT JOIN should be tagged with the
5089 ** JT_LTORJ flags */
5092 i--;
5097 }
5098 }
5099 }
5101 /*
5102 ** Generate VDBE code for a BEGIN statement.
5103 */
5114 }
5127 }
5130 }
5131 }
5133 }
5135 /*
5136 ** Generate VDBE code for a COMMIT or ROLLBACK statement.
5137 ** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
5138 ** code is generated for a COMMIT.
5139 */
5151 }
5155 }
5156 }
5158 /*
5159 ** This function is called by the parser when it parses a command to create,
5160 ** release or rollback an SQL savepoint.
5161 */
5166 #ifndef SQLITE_OMIT_AUTHORIZATION
5169 #endif
5173 }
5175 }
5176 }
5178 /*
5179 ** Make sure the TEMP database is open and available for use. Return
5180 ** the number of errors. Leave any error messages in the pParse structure.
5181 */
5188 SQLITE_OPEN_READWRITE |
5189 SQLITE_OPEN_CREATE |
5190 SQLITE_OPEN_EXCLUSIVE |
5191 SQLITE_OPEN_DELETEONCLOSE |
5192 SQLITE_OPEN_TEMP_DB;
5200 }
5206 }
5207 }
5209 }
5211 /*
5212 ** Record the fact that the schema cookie will need to be verified
5213 ** for database iDb. The code to actually verify the schema cookie
5214 ** will occur at the end of the top-level VDBE and will be generated
5215 ** later, by sqlite3FinishCoding().
5216 */
5226 }
5227 }
5228 }
5231 }
5234 /*
5235 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
5236 ** attached database. Otherwise, invoke it for the database named zDb only.
5237 */
5245 }
5246 }
5247 }
5249 /*
5250 ** Generate VDBE code that prepares for doing an operation that
5251 ** might change the database.
5252 **
5253 ** This routine starts a new transaction if we are not already within
5254 ** a transaction. If we are already within a transaction, then a checkpoint
5255 ** is set if the setStatement parameter is true. A checkpoint should
5256 ** be set for operations that might fail (due to a constraint) part of
5257 ** the way through and which will need to undo some writes without having to
5258 ** rollback the whole transaction. For operations where all constraints
5259 ** can be checked before any changes are made to the database, it is never
5260 ** necessary to undo a write and the checkpoint should not be set.
5261 */
5267 }
5269 /*
5270 ** Indicate that the statement currently under construction might write
5271 ** more than one entry (example: deleting one row then inserting another,
5272 ** inserting multiple rows in a table, or inserting a row and index entries.)
5273 ** If an abort occurs after some of these writes have completed, then it will
5274 ** be necessary to undo the completed writes.
5275 */
5279 }
5281 /*
5282 ** The code generator calls this routine if is discovers that it is
5283 ** possible to abort a statement prior to completion. In order to
5284 ** perform this abort without corrupting the database, we need to make
5285 ** sure that the statement is protected by a statement transaction.
5286 **
5287 ** Technically, we only need to set the mayAbort flag if the
5288 ** isMultiWrite flag was previously set. There is a time dependency
5289 ** such that the abort must occur after the multiwrite. This makes
5290 ** some statements involving the REPLACE conflict resolution algorithm
5291 ** go a little faster. But taking advantage of this time dependency
5292 ** makes it more difficult to prove that the code is correct (in
5293 ** particular, it prevents us from writing an effective
5294 ** implementation of sqlite3AssertMayAbort()) and so we have chosen
5295 ** to take the safe route and skip the optimization.
5296 */
5300 }
5302 /*
5303 ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
5304 ** error. The onError parameter determines which (if any) of the statement
5305 ** and/or current transaction is rolled back.
5306 */
5313 u8 p5Errmsg /* P5_ErrMsg type */
5314 ){
5321 }
5324 }
5326 /*
5327 ** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
5328 */
5333 ){
5336 StrAccum errMsg;
5352 }
5353 }
5359 }
5362 /*
5363 ** Code an OP_Halt due to non-unique rowid.
5364 */
5369 ){
5379 }
5381 P5_ConstraintUnique);
5382 }
5384 /*
5385 ** Check to see if pIndex uses the collating sequence pColl. Return
5386 ** true if it does and false if it does not.
5387 */
5388 #ifndef SQLITE_OMIT_REINDEX
5397 }
5398 }
5400 }
5401 #endif
5403 /*
5404 ** Recompute all indices of pTab that use the collating sequence pColl.
5405 ** If pColl==0 then recompute all indices of pTab.
5406 */
5407 #ifndef SQLITE_OMIT_REINDEX
5417 }
5418 }
5419 }
5420 }
5421 #endif
5423 /*
5424 ** Recompute all indices of all tables in all databases where the
5425 ** indices use the collating sequence pColl. If pColl==0 then recompute
5426 ** all indices everywhere.
5427 */
5428 #ifndef SQLITE_OMIT_REINDEX
5442 }
5443 }
5444 }
5445 #endif
5447 /*
5448 ** Generate code for the REINDEX command.
5449 **
5450 ** REINDEX -- 1
5451 ** REINDEX <collation> -- 2
5452 ** REINDEX ?<database>.?<tablename> -- 3
5453 ** REINDEX ?<database>.?<indexname> -- 4
5454 **
5455 ** Form 1 causes all indices in all attached databases to be rebuilt.
5456 ** Form 2 rebuilds all indices in all databases that use the named
5457 ** collating function. Forms 3 and 4 rebuild the named index or all
5458 ** indices associated with the named table.
5459 */
5460 #ifndef SQLITE_OMIT_REINDEX
5471 /* Read the database schema. If an error occurs, leave an error message
5472 ** and code in pParse and return NULL. */
5475 }
5490 }
5492 }
5503 }
5510 }
5512 }
5513 #endif
5515 /*
5516 ** Return a KeyInfo structure that is appropriate for the given Index.
5517 **
5518 ** The caller should invoke sqlite3KeyInfoUnref() on the returned object
5519 ** when it has finished using it.
5520 */
5531 }
5540 }
5544 /* Deactivate the index because it contains an unknown collating
5545 ** sequence. The only way to reactive the index is to reload the
5546 ** schema. Adding the missing collating sequence later does not
5547 ** reactive the index. The application had the chance to register
5548 ** the missing index using the collation-needed callback. For
5549 ** simplicity, SQLite will not give the application a second chance.
5550 */
5553 }
5556 }
5557 }
5559 }
5561 #ifndef SQLITE_OMIT_CTE
5562 /*
5563 ** Create a new CTE object
5564 */
5570 u8 eM10d /* The MATERIALIZED flag */
5571 ){
5586 }
5588 }
5590 /*
5591 ** Clear information from a Cte object, but do not deallocate storage
5592 ** for the object itself.
5593 */
5599 }
5601 /*
5602 ** Free the contents of the CTE object passed as the second argument.
5603 */
5608 }
5610 /*
5611 ** This routine is invoked once per CTE by the parser while parsing a
5612 ** WITH clause. The CTE described by teh third argument is added to
5613 ** the WITH clause of the second argument. If the second argument is
5614 ** NULL, then a new WITH argument is created.
5615 */
5620 ){
5627 }
5629 /* Check that the CTE name is unique within this WITH clause. If
5630 ** not, store an error in the Parse structure. */
5637 }
5638 }
5639 }
5646 }
5655 }
5658 }
5660 /*
5661 ** Free the contents of the With object passed as the second argument.
5662 */
5668 }
5670 }
5671 }