| blob | effaeb7332323688e617424b8b4b2bd35d0c2b5c |
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 */
152 }
155 /* Begin by generating some termination code at the end of the
156 ** vdbe program
157 */
163 }
166 }
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 */
224 );
229 #ifndef SQLITE_OMIT_VIRTUALTABLE
233 }
235 #endif
237 /* Once all the cookies have been verified and transactions opened,
238 ** obtain the required table-locks. This is a no-op unless the
239 ** shared-cache feature is enabled.
240 */
243 /* Initialize any AUTOINCREMENT data structures required.
244 */
247 /* Code constant expressions that where factored out of inner loops.
248 **
249 ** The pConstExpr list might also contain expressions that we simply
250 ** want to keep around until the Parse object is deleted. Such
251 ** expressions have iConstExprReg==0. Do not generate code for
252 ** those expressions, of course.
253 */
260 }
261 }
267 }
268 }
270 /* Finally, jump back to the beginning of the executable code. */
272 }
274 /* Get the VDBE program ready for execution
275 */
279 /* A minimum of one cursor is required if autoincrement is used
280 * See ticket [a696379c1f08866] */
286 }
287 }
289 /*
290 ** Run the parser and code generator recursively in order to generate
291 ** code for the SQL statement given onto the end of the pParse context
292 ** currently under construction. Notes:
293 **
294 ** * The final OP_Halt is not appended and other initialization
295 ** and finalization steps are omitted because those are handling by the
296 ** outermost parser.
297 **
298 ** * Built-in SQL functions always take precedence over application-defined
299 ** SQL functions. In other words, it is not possible to override a
300 ** built-in function.
301 */
315 /* This can result either from an OOM or because the formatted string
316 ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set
317 ** an error */
321 }
331 }
333 #if SQLITE_USER_AUTHENTICATION
334 /*
335 ** Return TRUE if zTable is the name of the system table that stores the
336 ** list of users and their access credentials.
337 */
340 }
341 #endif
343 /*
344 ** Locate the in-memory structure that describes a particular database
345 ** table given the name of that table and (optionally) the name of the
346 ** database containing the table. Return NULL if not found.
347 **
348 ** If zDatabase is 0, all databases are searched for the table and the
349 ** first matching table is returned. (No checking for duplicate table
350 ** names is done.) The search order is TEMP first, then MAIN, then any
351 ** auxiliary databases added using the ATTACH command.
352 **
353 ** See also sqlite3LocateTable().
354 */
359 /* All mutexes are required for schema access. Make sure we hold them. */
361 #if SQLITE_USER_AUTHENTICATION
362 /* Only the admin user is allowed to know that the sqlite_user table
363 ** exists */
366 }
367 #endif
371 }
373 /* No match against the official names. But always match "main"
374 ** to schema 0 as a legacy fallback. */
379 }
380 }
387 ){
389 LEGACY_TEMP_SCHEMA_TABLE);
390 }
394 LEGACY_SCHEMA_TABLE);
395 }
396 }
397 }
399 /* Match against TEMP first */
402 /* The main database is second */
405 /* Attached databases are in order of attachment */
410 }
416 LEGACY_TEMP_SCHEMA_TABLE);
417 }
418 }
419 }
421 }
423 /*
424 ** Locate the in-memory structure that describes a particular database
425 ** table given the name of that table and (optionally) the name of the
426 ** database containing the table. Return NULL if not found. Also leave an
427 ** error message in pParse->zErrMsg.
428 **
429 ** The difference between this routine and sqlite3FindTable() is that this
430 ** routine leaves an error message in pParse->zErrMsg where
431 ** sqlite3FindTable() does not.
432 */
438 ){
442 /* Read the database schema. If an error occurs, leave an error message
443 ** and code in pParse and return NULL. */
446 ){
448 }
452 #ifndef SQLITE_OMIT_VIRTUALTABLE
453 /* If zName is the not the name of a table in the schema created using
454 ** CREATE, then check to see if it is the name of an virtual table that
455 ** can be an eponymous virtual table. */
460 }
464 }
465 }
466 #endif
471 }
479 }
482 }
485 }
487 /*
488 ** Locate the table identified by *p.
489 **
490 ** This is a wrapper around sqlite3LocateTable(). The difference between
491 ** sqlite3LocateTable() and this function is that this function restricts
492 ** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
493 ** non-NULL if it is part of a view or trigger program definition. See
494 ** sqlite3FixSrcList() for details.
495 */
498 u32 flags,
499 SrcItem *p
500 ){
508 }
510 }
512 /*
513 ** Return the preferred table name for system tables. Translate legacy
514 ** names into the new preferred names, as appropriate.
515 */
520 }
523 }
524 }
526 }
528 /*
529 ** Locate the in-memory structure that describes
530 ** a particular index given the name of that index
531 ** and the name of the database that contains the index.
532 ** Return NULL if not found.
533 **
534 ** If zDatabase is 0, all databases are searched for the
535 ** table and the first matching index is returned. (No checking
536 ** for duplicate index names is done.) The search order is
537 ** TEMP first, then MAIN, then any auxiliary databases added
538 ** using the ATTACH command.
539 */
543 /* All mutexes are required for schema access. Make sure we hold them. */
553 }
555 }
557 /*
558 ** Reclaim the memory used by an index
559 */
561 #ifndef SQLITE_OMIT_ANALYZE
563 #endif
568 #ifdef SQLITE_ENABLE_STAT4
570 #endif
572 }
574 /*
575 ** For the index called zIdxName which is found in the database iDb,
576 ** unlike that index from its Table then remove the index from
577 ** the index hash table and free all memory structures associated
578 ** with the index.
579 */
592 /* Justification of ALWAYS(); The index must be on the list of
593 ** indices. */
598 }
599 }
601 }
603 }
605 /*
606 ** Look through the list of open database files in db->aDb[] and if
607 ** any have been closed, remove them from the list. Reallocate the
608 ** db->aDb[] structure to a smaller size, if possible.
609 **
610 ** Entry 0 (the "main" database) and entry 1 (the "temp" database)
611 ** are never candidates for being collapsed.
612 */
621 }
624 }
625 j++;
626 }
632 }
633 }
635 /*
636 ** Reset the schema for the database at index iDb. Also reset the
637 ** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
638 ** Deferred resets may be run by calling with iDb<0.
639 */
649 }
655 }
656 }
657 }
658 }
660 /*
661 ** Erase all schema information from all attached databases (including
662 ** "main" and "temp") for a single database connection.
663 */
674 }
675 }
676 }
682 }
683 }
685 /*
686 ** This routine is called when a commit occurs.
687 */
690 }
692 /*
693 ** Set the expression associated with a column. This is usually
694 ** the DEFAULT value, but might also be the expression that computes
695 ** the value for a generated column.
696 */
702 ){
709 ){
715 }
716 }
718 /*
719 ** Return the expression associated with a column. The expression might be
720 ** the DEFAULT clause or the AS clause of a generated column.
721 ** Return NULL if the column has no associated expression.
722 */
729 }
731 /*
732 ** Set the collating sequence name for a column.
733 */
738 ){
739 i64 nColl;
740 i64 n;
746 }
753 }
754 }
756 /*
757 ** Return the collating squence name for a column
758 */
766 }
768 }
770 /*
771 ** Delete memory allocated for the column names of a table or view (the
772 ** Table.aCol[] array).
773 */
783 }
787 }
793 }
794 }
795 }
796 }
798 /*
799 ** Remove the memory data structures associated with the given
800 ** Table. No changes are made to disk by this routine.
801 **
802 ** This routine just deletes the data structure. It does not unlink
803 ** the table data structure from the hash table. But it does destroy
804 ** memory structures of the indices and foreign keys associated with
805 ** the table.
806 **
807 ** The db parameter is optional. It is needed if the Table object
808 ** contains lookaside memory. (Table objects in the schema do not use
809 ** lookaside memory, but some ephemeral Table objects do.) Or the
810 ** db parameter can be used with db->pnBytesFreed to measure the memory
811 ** used by the Table object.
812 */
816 #ifdef SQLITE_DEBUG
817 /* Record the number of outstanding lookaside allocations in schema Tables
818 ** prior to doing any free() operations. Since schema Tables do not use
819 ** lookaside, this number should not change.
820 **
821 ** If malloc has already failed, it may be that it failed while allocating
822 ** a Table object that was going to be marked ephemeral. So do not check
823 ** that no lookaside memory is used in this case either. */
828 }
829 #endif
831 /* Delete all indices associated with this table. */
840 );
843 }
845 }
849 }
850 #ifndef SQLITE_OMIT_VIRTUAL_TABLE
853 }
854 #endif
858 }
860 /* Delete the Table structure itself.
861 */
868 /* Verify that no lookaside memory was used by schema tables */
870 }
872 /* Do not delete the table until the reference count reaches zero. */
877 }
880 /*
881 ** Unlink the given table from the hash tables and the delete the
882 ** table structure with all its indices and foreign keys.
883 */
897 }
899 /*
900 ** Given a token, return a string that consists of the text of that
901 ** token. Space to hold the returned string
902 ** is obtained from sqliteMalloc() and must be freed by the calling
903 ** function.
904 **
905 ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
906 ** surround the body of the token are removed.
907 **
908 ** Tokens are often just pointers into the original SQL text and so
909 ** are not \000 terminated and are not persistent. The returned string
910 ** is \000 terminated and is persistent.
911 */
919 }
921 }
923 /*
924 ** Open the sqlite_schema table stored in database number iDb for
925 ** writing. The table is opened using cursor 0.
926 */
933 }
934 }
936 /*
937 ** Parameter zName points to a nul-terminated buffer containing the name
938 ** of a database ("main", "temp" or the name of an attached db). This
939 ** function returns the index of the named database in db->aDb[], or
940 ** -1 if the named db cannot be found.
941 */
948 /* "main" is always an acceptable alias for the primary database
949 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
951 }
952 }
954 }
956 /*
957 ** The token *pName contains the name of a database (either "main" or
958 ** "temp" or the name of an attached db). This routine returns the
959 ** index of the named database in db->aDb[], or -1 if the named db
960 ** does not exist.
961 */
969 }
971 /* The table or view or trigger name is passed to this routine via tokens
972 ** pName1 and pName2. If the table name was fully qualified, for example:
973 **
974 ** CREATE TABLE xxx.yyy (...);
975 **
976 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
977 ** the table name is not fully qualified, i.e.:
978 **
979 ** CREATE TABLE yyy(...);
980 **
981 ** Then pName1 is set to "yyy" and pName2 is "".
982 **
983 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
984 ** pName2) that stores the unqualified table name. The index of the
985 ** database "xxx" is returned.
986 */
992 ){
1001 }
1007 }
1013 }
1015 }
1017 /*
1018 ** True if PRAGMA writable_schema is ON
1019 */
1023 SQLITE_WriteSchema );
1025 SQLITE_Defensive );
1029 }
1031 /*
1032 ** This routine is used to check if the UTF-8 string zName is a legal
1033 ** unqualified name for a new schema object (table, index, view or
1034 ** trigger). All names are legal except those that begin with the string
1035 ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
1036 ** is reserved for internal use.
1037 **
1038 ** When parsing the sqlite_schema table, this routine also checks to
1039 ** make sure the "type", "name", and "tbl_name" columns are consistent
1040 ** with the SQL.
1041 */
1047 ){
1052 ){
1053 /* Skip these error checks for writable_schema=ON */
1055 }
1060 ){
1063 }
1067 ){
1069 zName);
1071 }
1073 }
1075 }
1077 /*
1078 ** Return the PRIMARY KEY index of a table
1079 */
1084 }
1086 /*
1087 ** Convert an table column number into a index column number. That is,
1088 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
1089 ** find the (first) offset of that column in index pIdx. Or return -1
1090 ** if column iCol is not used in index pIdx.
1091 */
1096 }
1098 }
1100 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1101 /* Convert a storage column number into a table column number.
1102 **
1103 ** The storage column number (0,1,2,....) is the index of the value
1104 ** as it appears in the record on disk. The true column number
1105 ** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
1106 **
1107 ** The storage column number is less than the table column number if
1108 ** and only there are VIRTUAL columns to the left.
1109 **
1110 ** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
1111 */
1117 }
1118 }
1120 }
1121 #endif
1123 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1124 /* Convert a table column number into a storage column number.
1125 **
1126 ** The storage column number (0,1,2,....) is the index of the value
1127 ** as it appears in the record on disk. Or, if the input column is
1128 ** the N-th virtual column (zero-based) then the storage number is
1129 ** the number of non-virtual columns in the table plus N.
1130 **
1131 ** The true column number is the index (0,1,2,...) of the column in
1132 ** the CREATE TABLE statement.
1133 **
1134 ** If the input column is a VIRTUAL column, then it should not appear
1135 ** in storage. But the value sometimes is cached in registers that
1136 ** follow the range of registers used to construct storage. This
1137 ** avoids computing the same VIRTUAL column multiple times, and provides
1138 ** values for use by OP_Param opcodes in triggers. Hence, if the
1139 ** input column is a VIRTUAL table, put it after all the other columns.
1140 **
1141 ** In the following, N means "normal column", S means STORED, and
1142 ** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
1143 **
1144 ** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
1145 ** -- 0 1 2 3 4 5 6 7 8
1146 **
1147 ** Then the mapping from this function is as follows:
1148 **
1149 ** INPUTS: 0 1 2 3 4 5 6 7 8
1150 ** OUTPUTS: 0 1 6 2 3 7 4 5 8
1151 **
1152 ** So, in other words, this routine shifts all the virtual columns to
1153 ** the end.
1154 **
1155 ** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and
1156 ** this routine is a no-op macro. If the pTab does not have any virtual
1157 ** columns, then this routine is no-op that always return iCol. If iCol
1158 ** is negative (indicating the ROWID column) then this routine return iCol.
1159 */
1162 i16 n;
1167 }
1169 /* iCol is a virtual column itself */
1172 /* iCol is a normal or stored column */
1174 }
1175 }
1176 #endif
1178 /*
1179 ** Insert a single OP_JournalMode query opcode in order to force the
1180 ** prepared statement to return false for sqlite3_stmt_readonly(). This
1181 ** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
1182 ** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
1183 ** will return false for sqlite3_stmt_readonly() even if that statement
1184 ** is a read-only no-op.
1185 */
1192 }
1193 }
1195 /*
1196 ** Begin constructing a new table representation in memory. This is
1197 ** the first of several action routines that get called in response
1198 ** to a CREATE TABLE statement. In particular, this routine is called
1199 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
1200 ** flag is true if the table should be stored in the auxiliary database
1201 ** file instead of in the main database file. This is normally the case
1202 ** when the "TEMP" or "TEMPORARY" keyword occurs in between
1203 ** CREATE and TABLE.
1204 **
1205 ** The new table record is initialized and put in pParse->pNewTable.
1206 ** As more of the CREATE TABLE statement is parsed, additional action
1207 ** routines will be called to add more information to this record.
1208 ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
1209 ** is called to complete the construction of the new table record.
1210 */
1219 ){
1228 /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */
1233 /* The common case */
1237 /* If creating a temp table, the name may not be qualified. Unless
1238 ** the database name is "temp" anyway. */
1241 }
1246 }
1247 }
1252 }
1254 #ifndef SQLITE_OMIT_AUTHORIZATION
1257 {
1259 SQLITE_CREATE_TABLE,
1260 SQLITE_CREATE_TEMP_TABLE,
1261 SQLITE_CREATE_VIEW,
1262 SQLITE_CREATE_TEMP_VIEW
1263 };
1267 }
1271 }
1272 }
1273 #endif
1275 /* Make sure the new table name does not collide with an existing
1276 ** index or table name in the same database. Issue an error message if
1277 ** it does. The exception is if the statement being parsed was passed
1278 ** to an sqlite3_declare_vtab() call. In that case only the column names
1279 ** and types will be used, so there is no need to test for namespace
1280 ** collisions.
1281 */
1286 }
1296 }
1298 }
1302 }
1303 }
1311 }
1316 #ifdef SQLITE_DEFAULT_ROWEST
1318 #else
1320 #endif
1324 /* Begin generating the code that will insert the table record into
1325 ** the schema table. Note in particular that we must go ahead
1326 ** and allocate the record number for the table entry now. Before any
1327 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
1328 ** indices to be created and the table record must come before the
1329 ** indices. Hence, the record number for the table must be allocated
1330 ** now.
1331 */
1336 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
1340 #ifndef SQLITE_OMIT_VIRTUALTABLE
1343 }
1344 #endif
1346 /* If the file format and encoding in the database have not been set,
1347 ** set them now.
1348 */
1361 /* This just creates a place-holder record in the sqlite_schema table.
1362 ** The record created does not contain anything yet. It will be replaced
1363 ** by the real entry in code generated at sqlite3EndTable().
1364 **
1365 ** The rowid for the new entry is left in register pParse->regRowid.
1366 ** The root page number of the new table is left in reg pParse->regRoot.
1367 ** The rowid and root page number values are needed by the code that
1368 ** sqlite3EndTable will generate.
1369 */
1370 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1374 #endif
1375 {
1379 }
1386 }
1388 /* Normal (non-error) return. */
1391 /* If an error occurs, we jump here */
1392 begin_table_error:
1396 }
1398 /* Set properties of a table column based on the (magical)
1399 ** name of the column.
1400 */
1401 #if SQLITE_ENABLE_HIDDEN_COLUMNS
1408 }
1409 }
1410 #endif
1412 /*
1413 ** Name of the special TEMP trigger used to implement RETURNING. The
1414 ** name begins with "sqlite_" so that it is guaranteed not to collide
1415 ** with any application-generated triggers.
1416 */
1419 /*
1420 ** Clean up the data structures associated with the RETURNING clause.
1421 */
1428 }
1430 /*
1431 ** Add the RETURNING clause to the parse currently underway.
1432 **
1433 ** This routine creates a special TEMP trigger that will fire for each row
1434 ** of the DML statement. That TEMP trigger contains a single SELECT
1435 ** statement with a result set that is the argument of the RETURNING clause.
1436 ** The trigger has the Trigger.bReturning flag and an opcode of
1437 ** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
1438 ** knows to handle it specially. The TEMP trigger is automatically
1439 ** removed at the end of the parse.
1440 **
1441 ** When this routine is called, we do not yet know if the RETURNING clause
1442 ** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
1443 ** RETURNING trigger instead. It will then be converted into the appropriate
1444 ** type on the first call to sqlite3TriggersExist().
1445 */
1454 }
1460 }
1483 }
1484 }
1486 /*
1487 ** Add a new column to the table currently being constructed.
1488 **
1489 ** The parser calls this routine once for each column declaration
1490 ** in a CREATE TABLE statement. sqlite3StartTable() gets called
1491 ** first to get things going. Then this routine is called for each
1492 ** column.
1493 */
1501 u8 hName;
1511 }
1514 /* Because keywords GENERATE ALWAYS can be converted into indentifiers
1515 ** by the parser, we can sometimes end up with a typename that ends
1516 ** with "generated always". Check for this case and omit the surplus
1517 ** text. */
1520 ){
1525 ){
1528 }
1529 }
1531 /* Check for standard typenames. For standard typenames we will
1532 ** set the Column.eType field rather than storing the typename after
1533 ** the column name, in order to save space. */
1539 ){
1545 }
1546 }
1547 }
1561 }
1562 }
1567 }
1576 /* If there is no type specified, columns have the default affinity
1577 ** 'BLOB' with a default size of 4 bytes. */
1581 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1585 }
1586 }
1587 #endif
1595 }
1599 }
1601 /*
1602 ** This routine is called by the parser while in the middle of
1603 ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1604 ** been seen on a column. This routine sets the notNull flag on
1605 ** the column currently under construction.
1606 */
1616 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
1617 ** on this column. */
1624 }
1625 }
1626 }
1627 }
1629 /*
1630 ** Scan the column type name zType (length nType) and return the
1631 ** associated affinity type.
1632 **
1633 ** This routine does a case-independent search of zType for the
1634 ** substrings in the following table. If one of the substrings is
1635 ** found, the corresponding affinity is returned. If zType contains
1636 ** more than one of the substrings, entries toward the top of
1637 ** the table take priority. For example, if zType is 'BLOBINT',
1638 ** SQLITE_AFF_INTEGER is returned.
1639 **
1640 ** Substring | Affinity
1641 ** --------------------------------
1642 ** 'INT' | SQLITE_AFF_INTEGER
1643 ** 'CHAR' | SQLITE_AFF_TEXT
1644 ** 'CLOB' | SQLITE_AFF_TEXT
1645 ** 'TEXT' | SQLITE_AFF_TEXT
1646 ** 'BLOB' | SQLITE_AFF_BLOB
1647 ** 'REAL' | SQLITE_AFF_REAL
1648 ** 'FLOA' | SQLITE_AFF_REAL
1649 ** 'DOUB' | SQLITE_AFF_REAL
1650 **
1651 ** If none of the substrings in the above table are found,
1652 ** SQLITE_AFF_NUMERIC is returned.
1653 */
1662 zIn++;
1674 #ifndef SQLITE_OMIT_FLOATING_POINT
1684 #endif
1688 }
1689 }
1691 /* If pCol is not NULL, store an estimate of the field size. The
1692 ** estimate is scaled so that the size of an integer is 1. */
1699 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
1702 }
1703 zChar++;
1704 }
1707 }
1708 }
1709 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1712 }
1713 #endif
1717 }
1719 }
1721 /*
1722 ** The expression is the default value for the most recently added column
1723 ** of the table currently under construction.
1724 **
1725 ** Default value expressions must be constant. Raise an exception if this
1726 ** is not the case.
1727 **
1728 ** This routine is called by the parser while in the middle of
1729 ** parsing a CREATE TABLE statement.
1730 */
1736 ){
1747 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1752 #endif
1754 /* A copy of pExpr is used instead of the original, as pExpr contains
1755 ** tokens that point to volatile memory.
1756 */
1766 }
1767 }
1770 }
1772 }
1774 /*
1775 ** Backwards Compatibility Hack:
1776 **
1777 ** Historical versions of SQLite accepted strings as column names in
1778 ** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1779 **
1780 ** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1781 ** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1782 **
1783 ** This is goofy. But to preserve backwards compatibility we continue to
1784 ** accept it. This routine does the necessary conversion. It converts
1785 ** the expression given in its argument from a TK_STRING into a TK_ID
1786 ** if the expression is just a TK_STRING with an optional COLLATE clause.
1787 ** If the expression is anything other than TK_STRING, the expression is
1788 ** unchanged.
1789 */
1795 }
1796 }
1798 /*
1799 ** Tag the given column as being part of the PRIMARY KEY
1800 */
1803 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1809 }
1810 #endif
1811 }
1813 /*
1814 ** Designate the PRIMARY KEY for the table. pList is a list of names
1815 ** of columns that form the primary key. If pList is NULL, then the
1816 ** most recently added column of the table is the primary key.
1817 **
1818 ** A table can have at most one primary key. If the table already has
1819 ** a primary key (and this is the second primary key) then create an
1820 ** error.
1821 **
1822 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
1823 ** then we will try to use that column as the rowid. Set the Table.iPKey
1824 ** field of the table under construction to be the index of the
1825 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1826 ** no INTEGER PRIMARY KEY.
1827 **
1828 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
1829 ** index for the key. No index is created for INTEGER PRIMARY KEYs.
1830 */
1837 ){
1847 }
1869 }
1870 }
1871 }
1872 }
1873 }
1875 && pCol
1878 ){
1882 }
1890 #ifndef SQLITE_OMIT_AUTOINCREMENT
1893 #endif
1898 }
1900 primary_key_exit:
1903 }
1905 /*
1906 ** Add a new CHECK constraint to the table currently under construction.
1907 */
1913 ){
1914 #ifndef SQLITE_OMIT_CHECK
1919 ){
1924 Token t;
1930 }
1932 #endif
1933 {
1935 }
1936 }
1938 /*
1939 ** Set the collation function of the most recently parsed table column
1940 ** to the CollSeq given.
1941 */
1958 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1959 ** then an index may have been created on this column before the
1960 ** collation type was added. Correct this if it is the case.
1961 */
1966 }
1967 }
1968 }
1970 }
1972 /* Change the most recently parsed column to be a GENERATED ALWAYS AS
1973 ** column.
1974 */
1976 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1981 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
1983 }
1988 }
1992 /* no-op */
1997 }
1998 }
2006 }
2011 generated_error:
2014 generated_done:
2016 #else
2017 /* Throw and error for the GENERATED ALWAYS AS clause if the
2018 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
2021 #endif
2022 }
2024 /*
2025 ** Generate code that will increment the schema cookie.
2026 **
2027 ** The schema cookie is used to determine when the schema for the
2028 ** database changes. After each schema change, the cookie value
2029 ** changes. When a process first reads the schema it records the
2030 ** cookie. Thereafter, whenever it goes to access the database,
2031 ** it checks the cookie to make sure the schema has not changed
2032 ** since it was last read.
2033 **
2034 ** This plan is not completely bullet-proof. It is possible for
2035 ** the schema to change multiple times and for the cookie to be
2036 ** set back to prior value. But schema changes are infrequent
2037 ** and the probability of hitting the same cookie value is only
2038 ** 1 chance in 2^32. So we're safe enough.
2039 **
2040 ** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
2041 ** the schema-version whenever the schema changes.
2042 */
2049 }
2051 /*
2052 ** Measure the number of characters needed to output the given
2053 ** identifier. The number returned includes any quotes used
2054 ** but does not include the null terminator.
2055 **
2056 ** The estimate is conservative. It might be larger that what is
2057 ** really needed.
2058 */
2063 }
2065 }
2067 /*
2068 ** The first parameter is a pointer to an output buffer. The second
2069 ** parameter is a pointer to an integer that contains the offset at
2070 ** which to write into the output buffer. This function copies the
2071 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
2072 ** to the specified offset in the buffer and updates *pIdx to refer
2073 ** to the first byte after the last byte written before returning.
2074 **
2075 ** If the string zSignedIdent consists entirely of alpha-numeric
2076 ** characters, does not begin with a digit and is not an SQL keyword,
2077 ** then it is copied to the output buffer exactly as it is. Otherwise,
2078 ** it is quoted using double-quotes.
2079 */
2087 }
2097 }
2101 }
2103 /*
2104 ** Generate a CREATE TABLE statement appropriate for the given
2105 ** table. Memory to hold the text of the statement is obtained
2106 ** from sqliteMalloc() and must be freed by the calling function.
2107 */
2116 }
2126 }
2132 }
2144 };
2167 }
2170 }
2172 /*
2173 ** Resize an Index object to hold N columns total. Return SQLITE_OK
2174 ** on success and SQLITE_NOMEM on an OOM error.
2175 */
2198 }
2200 /*
2201 ** Estimate the total row width for a table.
2202 */
2209 }
2212 }
2214 /*
2215 ** Estimate the average size of a row for an index.
2216 */
2225 }
2227 }
2229 /* Return true if column number x is any of the first nCol entries of aiCol[].
2230 ** This is used to determine if the column number x appears in any of the
2231 ** first nCol entries of an index.
2232 */
2237 }
2238 }
2240 }
2242 /*
2243 ** Return true if any of the first nKey entries of index pIdx exactly
2244 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
2245 ** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
2246 ** or may not be the same index as pPk.
2247 **
2248 ** The first nKey entries of pIdx are guaranteed to be ordinary columns,
2249 ** not a rowid or expression.
2250 **
2251 ** This routine differs from hasColumn() in that both the column and the
2252 ** collating sequence must match for this routine, but for hasColumn() only
2253 ** the column name must match.
2254 */
2269 ){
2271 }
2272 }
2274 }
2276 /* Recompute the colNotIdxed field of the Index.
2277 **
2278 ** colNotIdxed is a bitmask that has a 0 bit representing each indexed
2279 ** columns that are within the first 63 columns of the table and a 1 for
2280 ** all other bits (all columns that are not in the index). The
2281 ** high-order bit of colNotIdxed is always 1. All unindexed columns
2282 ** of the table have a 1.
2283 **
2284 ** 2019-10-24: For the purpose of this computation, virtual columns are
2285 ** not considered to be covered by the index, even if they are in the
2286 ** index, because we do not trust the logic in whereIndexExprTrans() to be
2287 ** able to find all instances of a reference to the indexed table column
2288 ** and convert them into references to the index. Hence we always want
2289 ** the actual table at hand in order to recompute the virtual column, if
2290 ** necessary.
2291 **
2292 ** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
2293 ** to determine if the index is covering index.
2294 */
2305 }
2306 }
2309 }
2311 /*
2312 ** This routine runs at the end of parsing a CREATE TABLE statement that
2313 ** has a WITHOUT ROWID clause. The job of this routine is to convert both
2314 ** internal schema data structures and the generated VDBE code so that they
2315 ** are appropriate for a WITHOUT ROWID table instead of a rowid table.
2316 ** Changes include:
2317 **
2318 ** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
2319 ** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
2320 ** into BTREE_BLOBKEY.
2321 ** (3) Bypass the creation of the sqlite_schema table entry
2322 ** for the PRIMARY KEY as the primary key index is now
2323 ** identified by the sqlite_schema table entry of the table itself.
2324 ** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
2325 ** schema to the rootpage from the main table.
2326 ** (5) Add all table columns to the PRIMARY KEY Index object
2327 ** so that the PRIMARY KEY is a covering index. The surplus
2328 ** columns are part of KeyInfo.nAllField and are not used for
2329 ** sorting or lookup or uniqueness checks.
2330 ** (6) Replace the rowid tail on all automatically generated UNIQUE
2331 ** indices with the PRIMARY KEY columns.
2332 **
2333 ** For virtual tables, only (1) is performed.
2334 */
2344 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
2345 */
2350 ){
2352 }
2353 }
2355 }
2357 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
2358 ** into BTREE_BLOBKEY.
2359 */
2364 }
2366 /* Locate the PRIMARY KEY index. Or, if this table was originally
2367 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
2368 */
2371 Token ipkToken;
2378 }
2381 }
2386 SQLITE_IDXTYPE_PRIMARYKEY);
2390 }
2398 /*
2399 ** Remove all redundant columns from the PRIMARY KEY. For example, change
2400 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
2401 ** code assumes the PRIMARY KEY contains no repeated columns.
2402 */
2411 }
2412 }
2414 }
2420 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema
2421 ** table entry. This is only required if currently generating VDBE
2422 ** code for a CREATE TABLE (not when parsing one as part of reading
2423 ** a database schema). */
2427 }
2429 /* The root page of the PRIMARY KEY is the table root page */
2432 /* Update the in-memory representation of all UNIQUE indices by converting
2433 ** the final rowid column into one or more columns of the PRIMARY KEY.
2434 */
2441 n++;
2442 }
2443 }
2445 /* This index is a superset of the primary key */
2448 }
2456 /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
2458 }
2459 j++;
2460 }
2461 }
2464 }
2466 /* Add all table columns to the PRIMARY KEY index
2467 */
2472 }
2477 ){
2481 j++;
2482 }
2483 }
2487 }
2490 #ifndef SQLITE_OMIT_VIRTUALTABLE
2491 /*
2492 ** Return true if pTab is a virtual table and zName is a shadow table name
2493 ** for that virtual table.
2494 */
2508 }
2511 #ifndef SQLITE_OMIT_VIRTUALTABLE
2512 /*
2513 ** Table pTab is a virtual table. If it the virtual table implementation
2514 ** exists and has an xShadowName method, then loop over all other ordinary
2515 ** tables within the same schema looking for shadow tables of pTab, and mark
2516 ** any shadow tables seen using the TF_Shadow flag.
2517 */
2539 ){
2541 }
2542 }
2543 }
2546 #ifndef SQLITE_OMIT_VIRTUALTABLE
2547 /*
2548 ** Return true if zName is a shadow table name in the current database
2549 ** connection.
2550 **
2551 ** zName is temporarily modified while this routine is running, but is
2552 ** restored to its original value prior to this routine returning.
2553 */
2565 }
2569 #ifdef SQLITE_DEBUG
2570 /*
2571 ** Mark all nodes of an expression as EP_Immutable, indicating that
2572 ** they should not be changed. Expressions attached to a table or
2573 ** index definition are tagged this way to help ensure that we do
2574 ** not pass them into code generator routines by mistake.
2575 */
2579 }
2582 Walker w;
2588 }
2589 }
2590 #else
2595 /*
2596 ** This routine is called to report the final ")" that terminates
2597 ** a CREATE TABLE statement.
2598 **
2599 ** The table structure that other action routines have been building
2600 ** is added to the internal hash tables, assuming no errors have
2601 ** occurred.
2602 **
2603 ** An entry for the table is made in the schema table on disk, unless
2604 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
2605 ** it means we are reading the sqlite_schema table because we just
2606 ** connected to the database or because the sqlite_schema table has
2607 ** recently changed, so the entry for this table already exists in
2608 ** the sqlite_schema table. We do not want to create it again.
2609 **
2610 ** If the pSelect argument is not NULL, it means that this routine
2611 ** was called to create a table generated from a
2612 ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
2613 ** the new table will match the result set of the SELECT.
2614 */
2621 ){
2629 }
2635 }
2637 /* If the db->init.busy is 1 it means we are reading the SQL off the
2638 ** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
2639 ** So do not write to the disk again. Extract the root page number
2640 ** for the table from the db->init.newTnum field. (The page number
2641 ** should have been put there by the sqliteOpenCb routine.)
2642 **
2643 ** If the root page number is 1, that means this is the sqlite_schema
2644 ** table itself. So mark it read-only.
2645 */
2650 }
2653 }
2655 /* Special processing for tables that include the STRICT keyword:
2656 **
2657 ** * Do not allow custom column datatypes. Every column must have
2658 ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
2659 **
2660 ** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY,
2661 ** then all columns of the PRIMARY KEY must have a NOT NULL
2662 ** constraint.
2663 */
2674 );
2678 }
2682 }
2686 ){
2689 }
2690 }
2691 }
2698 /* Special processing for WITHOUT ROWID Tables */
2704 }
2708 }
2711 }
2714 #ifndef SQLITE_OMIT_CHECK
2715 /* Resolve names in all CHECK constraint expressions.
2716 */
2720 /* If errors are seen, delete the CHECK constraints now, else they might
2721 ** actually be used if PRAGMA writable_schema=ON is set. */
2726 }
2727 }
2729 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
2741 /* If there are errors in resolving the expression, change the
2742 ** expression to a NULL. This prevents code generators that operate
2743 ** on the expression from inserting extra parts into the expression
2744 ** tree that have been allocated from lookaside memory, which is
2745 ** illegal in a schema and will lead to errors or heap corruption
2746 ** when the database connection closes. */
2749 }
2751 nNG++;
2752 }
2753 }
2757 }
2758 }
2759 #endif
2761 /* Estimate the average row size for the table and for all implied indices */
2765 }
2767 /* If not initializing, then create a record for the new table
2768 ** in the schema table of the database.
2769 **
2770 ** If this is a TEMPORARY table, write the entry into the auxiliary
2771 ** file instead of into the main database file.
2772 */
2785 /*
2786 ** Initialize zType for the new view or table.
2787 */
2789 /* A regular table */
2792 #ifndef SQLITE_OMIT_VIEW
2794 /* A view */
2797 #endif
2798 }
2800 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
2801 ** statement to populate the new table. The root-page number for the
2802 ** new table is in register pParse->regRoot.
2803 **
2804 ** Once the SELECT has been coded by sqlite3Select(), it is in a
2805 ** suitable state to query for the column names and types to be used
2806 ** by the new table.
2807 **
2808 ** A shared-cache write-lock is not required to write to the new table,
2809 ** as a schema-lock must have already been obtained to create it. Since
2810 ** a schema-lock excludes all other database users, the write-lock would
2811 ** be redundant.
2812 */
2826 }
2860 }
2862 /* Compute the complete text of the CREATE statement */
2871 );
2872 }
2874 /* A slot for the record has already been allocated in the
2875 ** schema table. We just need to update that slot with all
2876 ** the information we've collected.
2877 */
2879 "UPDATE %Q." LEGACY_SCHEMA_TABLE
2880 " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
2883 zType,
2887 zStmt,
2888 pParse->regRowid
2889 );
2893 #ifndef SQLITE_OMIT_AUTOINCREMENT
2894 /* Check to see if we need to create an sqlite_sequence table for
2895 ** keeping track of autoincrement keys.
2896 */
2903 pDb->zDbSName
2904 );
2905 }
2906 }
2907 #endif
2909 /* Reparse everything to update our internal data structures */
2912 }
2914 /* Add the table to the in-memory representation of the database.
2915 */
2926 }
2930 /* If this is the magic sqlite_sequence table used by autoincrement,
2931 ** then record a pointer to this table in the main database structure
2932 ** so that INSERT can find the table easily. */
2934 #ifndef SQLITE_OMIT_AUTOINCREMENT
2938 }
2939 #endif
2940 }
2942 #ifndef SQLITE_OMIT_ALTERTABLE
2947 }
2949 }
2950 #endif
2951 }
2953 #ifndef SQLITE_OMIT_VIEW
2954 /*
2955 ** The parser calls this routine in order to create a new VIEW
2956 */
2966 ){
2970 Token sEnd;
2971 DbFixer sFix;
2979 }
2984 /* Legacy versions of SQLite allowed the use of the magic "rowid" column
2985 ** on a view, even though views do not have rowids. The following flag
2986 ** setting fixes this problem. But the fix can be disabled by compiling
2987 ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
2988 ** depend upon the old buggy behavior. */
2989 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
2991 #endif
2998 /* Make a copy of the entire SELECT statement that defines the view.
2999 ** This will force all the Expr.token.z values to be dynamically
3000 ** allocated rather than point to the input string - which means that
3001 ** they will persist after the current sqlite3_exec() call returns.
3002 */
3009 }
3014 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
3015 ** the end.
3016 */
3021 }
3030 /* Use sqlite3EndTable() to add the view to the schema table */
3033 create_view_fail:
3037 }
3040 }
3043 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
3044 /*
3045 ** The Table structure pTable is really a VIEW. Fill in the names of
3046 ** the columns of the view in the pTable structure. Return the number
3047 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
3048 */
3054 #ifndef SQLITE_OMIT_VIRTUALTABLE
3056 #endif
3057 #ifndef SQLITE_OMIT_AUTHORIZATION
3059 #endif
3063 #ifndef SQLITE_OMIT_VIRTUALTABLE
3069 }
3070 #endif
3072 #ifndef SQLITE_OMIT_VIEW
3073 /* A positive nCol means the columns names for this view are
3074 ** already known. This routine is not called unless either the
3075 ** table is virtual or nCol is zero.
3076 */
3079 /* A negative nCol is a special marker meaning that we are currently
3080 ** trying to compute the column names. If we enter this routine with
3081 ** a negative nCol, it means two or more views form a loop, like this:
3082 **
3083 ** CREATE VIEW one AS SELECT * FROM two;
3084 ** CREATE VIEW two AS SELECT * FROM one;
3085 **
3086 ** Actually, the error above is now caught prior to reaching this point.
3087 ** But the following test is still important as it does come up
3088 ** in the following:
3089 **
3090 ** CREATE TABLE main.ex1(a);
3091 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
3092 ** SELECT * FROM temp.ex1;
3093 */
3097 }
3100 /* If we get this far, it means we need to compute the table names.
3101 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
3102 ** "*" elements in the results set of the view and will assign cursors
3103 ** to the elements of the FROM clause. But we do not want these changes
3104 ** to be permanent. So the computation is done on a copy of the SELECT
3105 ** statement that defines the view.
3106 */
3116 DisableLookaside;
3117 #ifndef SQLITE_OMIT_AUTHORIZATION
3122 #else
3124 #endif
3129 nErr++;
3131 /* CREATE VIEW name(arglist) AS ...
3132 ** The names of the columns in the table are taken from
3133 ** arglist which is stored in pTable->pCheck. The pCheck field
3134 ** normally holds CHECK constraints on an ordinary table, but for
3135 ** a VIEW it holds the list of column names.
3136 */
3141 ){
3144 SQLITE_AFF_NONE);
3145 }
3147 /* CREATE VIEW name AS... without an argument list. Construct
3148 ** the column names from the SELECT statement that defines the view.
3149 */
3157 }
3161 EnableLookaside;
3164 nErr++;
3165 }
3169 }
3172 }
3177 }
3180 #ifndef SQLITE_OMIT_VIEW
3181 /*
3182 ** Clear the column names from every VIEW in database idx.
3183 */
3192 }
3193 }
3195 }
3196 #else
3197 # define sqliteViewResetAll(A,B)
3200 /*
3201 ** This function is called by the VDBE to adjust the internal schema
3202 ** used by SQLite when the btree layer moves a table root page. The
3203 ** root-page of a table or index in database iDb has changed from iFrom
3204 ** to iTo.
3205 **
3206 ** Ticket #1728: The symbol table might still contain information
3207 ** on tables and/or indices that are the process of being deleted.
3208 ** If you are unlucky, one of those deleted indices or tables might
3209 ** have the same rootpage number as the real table or index that is
3210 ** being moved. So we cannot stop searching after the first match
3211 ** because the first match might be for one of the deleted indices
3212 ** or tables and not the table/index that is actually being moved.
3213 ** We must continue looping until all tables and indices with
3214 ** rootpage==iFrom have been converted to have a rootpage of iTo
3215 ** in order to be certain that we got the right one.
3216 */
3217 #ifndef SQLITE_OMIT_AUTOVACUUM
3230 }
3231 }
3237 }
3238 }
3239 }
3240 #endif
3242 /*
3243 ** Write code to erase the table with root-page iTable from database iDb.
3244 ** Also write code to modify the sqlite_schema table and internal schema
3245 ** if a root-page of another table is moved by the btree-layer whilst
3246 ** erasing iTable (this can happen with an auto-vacuum database).
3247 */
3254 #ifndef SQLITE_OMIT_AUTOVACUUM
3255 /* OP_Destroy stores an in integer r1. If this integer
3256 ** is non-zero, then it is the root page number of a table moved to
3257 ** location iTable. The following code modifies the sqlite_schema table to
3258 ** reflect this.
3259 **
3260 ** The "#NNN" in the SQL is a special constant that means whatever value
3261 ** is in register NNN. See grammar rules associated with the TK_REGISTER
3262 ** token for additional information.
3263 */
3265 "UPDATE %Q." LEGACY_SCHEMA_TABLE
3268 #endif
3270 }
3272 /*
3273 ** Write VDBE code to erase table pTab and all associated indices on disk.
3274 ** Code to update the sqlite_schema tables and internal schema definitions
3275 ** in case a root-page belonging to another table is moved by the btree layer
3276 ** is also added (this can happen with an auto-vacuum database).
3277 */
3279 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
3280 ** is not defined), then it is important to call OP_Destroy on the
3281 ** table and index root-pages in order, starting with the numerically
3282 ** largest root-page number. This guarantees that none of the root-pages
3283 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
3284 ** following were coded:
3285 **
3286 ** OP_Destroy 4 0
3287 ** ...
3288 ** OP_Destroy 5 0
3289 **
3290 ** and root page 5 happened to be the largest root-page number in the
3291 ** database, then root page 5 would be moved to page 4 by the
3292 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
3293 ** a free-list page.
3294 */
3304 }
3310 }
3311 }
3319 }
3320 }
3321 }
3323 /*
3324 ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
3325 ** after a DROP INDEX or DROP TABLE command.
3326 */
3332 ){
3342 );
3343 }
3344 }
3345 }
3347 /*
3348 ** Generate code to drop a table.
3349 */
3360 #ifndef SQLITE_OMIT_VIRTUALTABLE
3363 }
3364 #endif
3366 /* Drop all triggers associated with the table being dropped. Code
3367 ** is generated to remove entries from sqlite_schema and/or
3368 ** sqlite_temp_schema if required.
3369 */
3376 }
3378 #ifndef SQLITE_OMIT_AUTOINCREMENT
3379 /* Remove any entries of the sqlite_sequence table associated with
3380 ** the table being dropped. This is done before the table is dropped
3381 ** at the btree level, in case the sqlite_sequence table needs to
3382 ** move as a result of the drop (can happen in auto-vacuum mode).
3383 */
3388 );
3389 }
3390 #endif
3392 /* Drop all entries in the schema table that refer to the
3393 ** table. The program name loops through the schema table and deletes
3394 ** every row that refers to a table of the same name as the one being
3395 ** dropped. Triggers are handled separately because a trigger can be
3396 ** created in the temp database that refers to a table in another
3397 ** database.
3398 */
3400 "DELETE FROM %Q." LEGACY_SCHEMA_TABLE
3405 }
3407 /* Remove the table entry from SQLite's internal schema and modify
3408 ** the schema cookie.
3409 */
3413 }
3417 }
3419 /*
3420 ** Return TRUE if shadow tables should be read-only in the current
3421 ** context.
3422 */
3424 #ifndef SQLITE_OMIT_VIRTUALTABLE
3429 ){
3431 }
3432 #endif
3434 }
3436 /*
3437 ** Return true if it is not allowed to drop the given table
3438 */
3444 }
3447 }
3450 }
3452 }
3454 /*
3455 ** This routine is called to do the work of a DROP TABLE statement.
3456 ** pName is the name of the table to be dropped.
3457 */
3466 }
3479 }
3481 }
3485 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
3486 ** it is initialized.
3487 */
3490 }
3491 #ifndef SQLITE_OMIT_AUTHORIZATION
3492 {
3499 }
3505 }
3506 #ifndef SQLITE_OMIT_VIRTUALTABLE
3510 #endif
3516 }
3517 }
3520 }
3523 }
3524 }
3525 #endif
3529 }
3531 #ifndef SQLITE_OMIT_VIEW
3532 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
3533 ** on a table.
3534 */
3538 }
3542 }
3543 #endif
3545 /* Generate code to remove the table from the schema table
3546 ** on disk.
3547 */
3554 }
3556 }
3558 exit_drop_table:
3560 }
3562 /*
3563 ** This routine is called to create a new foreign key on the table
3564 ** currently under construction. pFromCol determines which columns
3565 ** in the current table point to the foreign key. If pFromCol==0 then
3566 ** connect the key to the last column inserted. pTo is the name of
3567 ** the table referred to (a.k.a the "parent" table). pToCol is a list
3568 ** of tables in the parent pTo table. flags contains all
3569 ** information about the conflict resolution algorithms specified
3570 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
3571 **
3572 ** An FKey structure is created and added to the table currently
3573 ** under construction in the pParse->pNewTable field.
3574 **
3575 ** The foreign key is set for IMMEDIATE processing. A subsequent call
3576 ** to sqlite3DeferForeignKey() might change this to DEFERRED.
3577 */
3584 ){
3586 #ifndef SQLITE_OMIT_FOREIGN_KEY
3590 i64 nByte;
3605 }
3609 "number of columns in foreign key does not match the number of "
3614 }
3619 }
3620 }
3624 }
3632 }
3647 }
3648 }
3654 }
3657 }
3658 }
3659 }
3666 }
3670 }
3671 }
3679 );
3683 }
3688 }
3690 /* Link the foreign key to the table as the last step.
3691 */
3696 fk_end:
3701 }
3703 /*
3704 ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
3705 ** clause is seen as part of a foreign key definition. The isDeferred
3706 ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
3707 ** The behavior of the most recently created foreign key is adjusted
3708 ** accordingly.
3709 */
3711 #ifndef SQLITE_OMIT_FOREIGN_KEY
3719 #endif
3720 }
3722 /*
3723 ** Generate code that will erase and refill index *pIdx. This is
3724 ** used to initialize a newly created index or to recompute the
3725 ** content of an index in response to a REINDEX command.
3726 **
3727 ** if memRootPage is not negative, it means that the index is newly
3728 ** created. The register specified by memRootPage contains the
3729 ** root page number of the index. If memRootPage is negative, then
3730 ** the index already exists and must be cleared before being refilled and
3731 ** the root page number of the index is taken from pIndex->tnum.
3732 */
3748 #ifndef SQLITE_OMIT_AUTHORIZATION
3752 }
3753 #endif
3755 /* Require a write-lock on the table to perform this operation */
3764 }
3768 /* Open the sorter cursor if we are to use one. */
3773 /* Open the table. Loop through all rows of the table, inserting index
3774 ** records into the sorter. */
3800 /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
3801 ** abort. The exception is if one of the indexed expressions contains a
3802 ** user function that throws an exception when it is evaluated. But the
3803 ** overhead of adding a statement journal to a CREATE INDEX statement is
3804 ** very small (since most of the pages written do not contain content that
3805 ** needs to be restored if the statement aborts), so we call
3806 ** sqlite3MayAbort() for all CREATE INDEX statements. */
3809 }
3812 /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
3813 ** faster by avoiding unnecessary seeks. But the optimization does
3814 ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
3815 ** with DESC primary keys, since those indexes have there keys in
3816 ** a different order from the main table.
3817 ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
3818 */
3820 }
3830 }
3832 /*
3833 ** Allocate heap space to hold an Index object with nCol columns.
3834 **
3835 ** Increase the allocation size to provide an extra nExtra bytes
3836 ** of 8-byte aligned space after the Index object and return a
3837 ** pointer to this extra space in *ppExtra.
3838 */
3844 ){
3863 }
3865 }
3867 /*
3868 ** If expression list pList contains an expression that was parsed with
3869 ** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
3870 ** pParse and return non-zero. Otherwise, return zero.
3871 */
3880 );
3882 }
3883 }
3884 }
3886 }
3888 /*
3889 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
3890 ** and pTblList is the name of the table that is to be indexed. Both will
3891 ** be NULL for a primary key or an index that is created to satisfy a
3892 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
3893 ** as the table to be indexed. pParse->pNewTable is a table that is
3894 ** currently being constructed by a CREATE TABLE statement.
3895 **
3896 ** pList is a list of columns to be indexed. pList will be NULL if this
3897 ** is a primary key or unique-constraint on the most recent column added
3898 ** to the table currently under construction.
3899 */
3911 u8 idxType /* The index type */
3912 ){
3933 }
3937 }
3940 }
3943 }
3945 /*
3946 ** Find the table that is to be indexed. Return early if not found.
3947 */
3950 /* Use the two-part index name to determine the database
3951 ** to search for the table. 'Fix' the table name to this db
3952 ** before looking up the table.
3953 */
3959 #ifndef SQLITE_OMIT_TEMPDB
3960 /* If the index name was unqualified, check if the table
3961 ** is a temp table. If so, set the database to 1. Do not do this
3962 ** if initialising a database schema.
3963 */
3968 }
3969 }
3970 #endif
3974 /* Because the parser constructs pTblName from a single identifier,
3975 ** sqlite3FixSrcList can never fail. */
3977 }
3986 }
3994 }
4001 #if SQLITE_USER_AUTHENTICATION
4003 #endif
4004 ){
4007 }
4008 #ifndef SQLITE_OMIT_VIEW
4012 }
4013 #endif
4014 #ifndef SQLITE_OMIT_VIRTUALTABLE
4018 }
4019 #endif
4021 /*
4022 ** Find the name of the index. Make sure there is not already another
4023 ** index or table with the same name.
4024 **
4025 ** Exception: If we are reading the names of permanent indices from the
4026 ** sqlite_schema table (because some other process changed the schema) and
4027 ** one of the index names collides with the name of a temporary table or
4028 ** index, then we will continue to process this index.
4029 **
4030 ** If pName==0 it means that we are
4031 ** dealing with a primary key or UNIQUE constraint. We have to invent our
4032 ** own name.
4033 */
4040 }
4046 }
4047 }
4055 }
4057 }
4058 }
4066 }
4068 /* Automatic index names generated from within sqlite3_declare_vtab()
4069 ** must have names that are distinct from normal automatic index names.
4070 ** The following statement converts "sqlite3_autoindex..." into
4071 ** "sqlite3_butoindex..." in order to make the names distinct.
4072 ** The "vtab_err.test" test demonstrates the need of this statement. */
4074 }
4076 /* Check for authorization to create an index.
4077 */
4078 #ifndef SQLITE_OMIT_AUTHORIZATION
4083 }
4088 }
4089 }
4090 #endif
4092 /* If pList==0, it means this routine was called to make a primary
4093 ** key out of the last column added to the table under construction.
4094 ** So create a fake list to simulate this.
4095 */
4097 Token prevCol;
4109 }
4111 /* Figure out how many bytes of space are required to store explicitly
4112 ** specified collation sequence names.
4113 */
4120 }
4121 }
4123 /*
4124 ** Allocate the index structure.
4125 */
4133 }
4149 }
4152 /* Check to see if we should honor DESC requests on index columns
4153 */
4158 }
4160 /* Analyze the list of expressions that form the terms of the index and
4161 ** report any errors. In the common case where the expression is exactly
4162 ** a table column, store that column in aiColumn[]. For general expressions,
4163 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
4164 **
4165 ** TODO: Issue a warning if two or more columns of the index are identical.
4166 ** TODO: Issue a warning if the table primary key is used as part of the
4167 ** index key.
4168 */
4173 }
4188 }
4192 }
4205 }
4209 }
4210 }
4212 }
4226 }
4230 }
4234 }
4236 /* Append the table key to the end of the index. For WITHOUT ROWID
4237 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
4238 ** normal tables (when pPk==0) this will be the rowid.
4239 */
4251 i++;
4252 }
4253 }
4258 }
4262 /* If this index contains every column of its table, then mark
4263 ** it as a covering index */
4274 }
4275 }
4278 /* This routine has been called to create an automatic index as a
4279 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
4280 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
4281 ** i.e. one of:
4282 **
4283 ** CREATE TABLE t(x PRIMARY KEY, y);
4284 ** CREATE TABLE t(x, y, UNIQUE(x, y));
4285 **
4286 ** Either way, check to see if the table already has such an index. If
4287 ** so, don't bother creating this one. This only applies to
4288 ** automatically created indices. Users can do as they wish with
4289 ** explicit indices.
4290 **
4291 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
4292 ** (and thus suppressing the second one) even if they have different
4293 ** sort orders.
4294 **
4295 ** If there are different collating sequences or if the columns of
4296 ** the constraint occur in different orders, then the constraints are
4297 ** considered distinct and both result in separate indices.
4298 */
4315 }
4318 /* This constraint creates the same index as a previous
4319 ** constraint specified somewhere in the CREATE TABLE statement.
4320 ** However the ON CONFLICT clauses are different. If both this
4321 ** constraint and the previous equivalent constraint have explicit
4322 ** ON CONFLICT clauses this is an error. Otherwise, use the
4323 ** explicitly specified behavior for the index.
4324 */
4328 }
4331 }
4332 }
4338 }
4340 }
4341 }
4342 }
4346 /* Link the new Index structure to its table and to the other
4347 ** in-memory database structures.
4348 */
4360 }
4361 }
4368 }
4370 }
4372 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
4373 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
4374 ** emit code to allocate the index rootpage on disk and make an entry for
4375 ** the index in the sqlite_schema table and populate the index with
4376 ** content. But, do not do this if we are simply reading the sqlite_schema
4377 ** table to parse the schema, or if this index is the PRIMARY KEY index
4378 ** of a WITHOUT ROWID table.
4379 **
4380 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
4381 ** or UNIQUE index in a CREATE TABLE statement. Since the table
4382 ** has just been created, it contains no data and the index initialization
4383 ** step can be skipped.
4384 */
4395 /* Create the rootpage for the index using CreateIndex. But before
4396 ** doing so, code a Noop instruction and store its address in
4397 ** Index.tnum. This is required in case this index is actually a
4398 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
4399 ** that case the convertToWithoutRowidTable() routine will replace
4400 ** the Noop with a Goto to jump over the VDBE code generated below. */
4404 /* Gather the complete text of the CREATE INDEX statement into
4405 ** the zStmt variable
4406 */
4411 /* A named index with an explicit CREATE INDEX statement */
4415 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
4416 /* zStmt = sqlite3MPrintf(""); */
4418 }
4420 /* Add an entry in sqlite_schema for this index
4421 */
4427 iMem,
4428 zStmt
4429 );
4432 /* Fill the index with data and reparse the schema. Code an OP_Expire
4433 ** to invalidate all pre-compiled statements.
4434 */
4441 }
4444 }
4445 }
4450 }
4455 }
4457 /* Clean up before exiting */
4458 exit_create_index:
4461 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
4462 ** The list was already ordered when this routine was entered, so at this
4463 ** point at most a single index (the newly added index) will be out of
4464 ** order. So we have to reorder at most one index. */
4475 }
4477 }
4478 #ifdef SQLITE_DEBUG
4479 /* Verify that all REPLACE indexes really are now at the end
4480 ** of the index list. In other words, no other index type ever
4481 ** comes after a REPLACE index on the list. */
4486 }
4487 #endif
4488 }
4493 }
4495 /*
4496 ** Fill the Index.aiRowEst[] array with default information - information
4497 ** to be used when we have not run the ANALYZE command.
4498 **
4499 ** aiRowEst[0] is supposed to contain the number of elements in the index.
4500 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
4501 ** number of rows in the table that match any particular value of the
4502 ** first column of the index. aiRowEst[2] is an estimate of the number
4503 ** of rows that match any particular combination of the first 2 columns
4504 ** of the index. And so forth. It must always be the case that
4505 *
4506 ** aiRowEst[N]<=aiRowEst[N-1]
4507 ** aiRowEst[N]>=1
4508 **
4509 ** Apart from that, we have little to go on besides intuition as to
4510 ** how aiRowEst[] should be initialized. The numbers generated here
4511 ** are based on typical values found in actual indices.
4512 */
4514 /* 10, 9, 8, 7, 6 */
4517 LogEst x;
4521 /* Indexes with default row estimates should not have stat1 data */
4524 /* Set the first entry (number of rows in the index) to the estimated
4525 ** number of rows in the table, or half the number of rows in the table
4526 ** for a partial index.
4527 **
4528 ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
4529 ** table but other parts we are having to guess at, then do not let the
4530 ** estimated number of rows in the table be less than 1000 (LogEst 99).
4531 ** Failure to do this can cause the indexes for which we do not have
4532 ** stat1 data to be ignored by the query planner.
4533 */
4538 }
4542 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
4543 ** 6 and each subsequent value (if any) is 5. */
4547 }
4551 }
4553 /*
4554 ** This routine will drop an existing named index. This routine
4555 ** implements the DROP INDEX statement.
4556 */
4565 }
4570 }
4578 }
4581 }
4586 }
4588 #ifndef SQLITE_OMIT_AUTHORIZATION
4589 {
4596 }
4600 }
4601 }
4602 #endif
4604 /* Generate code to remove the index and from the schema table */
4611 );
4616 }
4618 exit_drop_index:
4620 }
4622 /*
4623 ** pArray is a pointer to an array of objects. Each object in the
4624 ** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
4625 ** to extend the array so that there is space for a new object at the end.
4626 **
4627 ** When this function is called, *pnEntry contains the current size of
4628 ** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
4629 ** in total).
4630 **
4631 ** If the realloc() is successful (i.e. if no OOM condition occurs), the
4632 ** space allocated for the new object is zeroed, *pnEntry updated to
4633 ** reflect the new size of the array and a pointer to the new allocation
4634 ** returned. *pIdx is set to the index of the new array entry in this case.
4635 **
4636 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
4637 ** unchanged and a copy of pArray returned.
4638 */
4645 ){
4654 }
4656 }
4661 }
4663 /*
4664 ** Append a new element to the given IdList. Create a new IdList if
4665 ** need be.
4666 **
4667 ** A new IdList is returned, or NULL if malloc() fails.
4668 */
4682 }
4684 }
4689 }
4691 }
4693 /*
4694 ** Delete an IdList.
4695 */
4703 }
4705 }
4707 /*
4708 ** Return the index in pList of the identifier named zId. Return -1
4709 ** if not found.
4710 */
4716 }
4718 }
4720 /*
4721 ** Maximum size of a SrcList object.
4722 ** The SrcList object is used to represent the FROM clause of a
4723 ** SELECT statement, and the query planner cannot deal with more
4724 ** than 64 tables in a join. So any value larger than 64 here
4725 ** is sufficient for most uses. Smaller values, like say 10, are
4726 ** appropriate for small and memory-limited applications.
4727 */
4728 #ifndef SQLITE_MAX_SRCLIST
4729 # define SQLITE_MAX_SRCLIST 200
4730 #endif
4732 /*
4733 ** Expand the space allocated for the given SrcList object by
4734 ** creating nExtra new slots beginning at iStart. iStart is zero based.
4735 ** New slots are zeroed.
4736 **
4737 ** For example, suppose a SrcList initially contains two entries: A,B.
4738 ** To append 3 new entries onto the end, do this:
4739 **
4740 ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
4741 **
4742 ** After the call above it would contain: A, B, nil, nil, nil.
4743 ** If the iStart argument had been 1 instead of 2, then the result
4744 ** would have been: A, nil, nil, nil, B. To prepend the new slots,
4745 ** the iStart value would be 0. The result then would
4746 ** be: nil, nil, nil, A, B.
4747 **
4748 ** If a memory allocation fails or the SrcList becomes too large, leave
4749 ** the original SrcList unchanged, return NULL, and leave an error message
4750 ** in pParse.
4751 */
4757 ){
4760 /* Sanity checking on calling parameters */
4766 /* Allocate additional space if needed */
4774 SQLITE_MAX_SRCLIST);
4776 }
4783 }
4786 }
4788 /* Move existing slots that come after the newly inserted slots
4789 ** out of the way */
4792 }
4795 /* Zero the newly allocated slots */
4799 }
4801 /* Return a pointer to the enlarged SrcList */
4803 }
4806 /*
4807 ** Append a new table name to the given SrcList. Create a new SrcList if
4808 ** need be. A new entry is created in the SrcList even if pTable is NULL.
4809 **
4810 ** A SrcList is returned, or NULL if there is an OOM error or if the
4811 ** SrcList grows to large. The returned
4812 ** SrcList might be the same as the SrcList that was input or it might be
4813 ** a new one. If an OOM error does occurs, then the prior value of pList
4814 ** that is input to this routine is automatically freed.
4815 **
4816 ** If pDatabase is not null, it means that the table has an optional
4817 ** database name prefix. Like this: "database.table". The pDatabase
4818 ** points to the table name and the pTable points to the database name.
4819 ** The SrcList.a[].zName field is filled with the table name which might
4820 ** come from pTable (if pDatabase is NULL) or from pDatabase.
4821 ** SrcList.a[].zDatabase is filled with the database name from pTable,
4822 ** or with NULL if no database is specified.
4823 **
4824 ** In other words, if call like this:
4825 **
4826 ** sqlite3SrcListAppend(D,A,B,0);
4827 **
4828 ** Then B is a table name and the database name is unspecified. If called
4829 ** like this:
4830 **
4831 ** sqlite3SrcListAppend(D,A,B,C);
4832 **
4833 ** Then C is the table name and B is the database name. If C is defined
4834 ** then so is B. In other words, we never have a case where:
4835 **
4836 ** sqlite3SrcListAppend(D,A,0,C);
4837 **
4838 ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
4839 ** before being added to the SrcList.
4840 */
4846 ){
4867 }
4868 }
4872 }
4879 }
4881 }
4883 /*
4884 ** Assign VdbeCursor index numbers to all tables in a SrcList
4885 */
4896 }
4897 }
4898 }
4899 }
4901 /*
4902 ** Delete an entire SrcList including all its substructure.
4903 */
4921 }
4922 }
4924 }
4926 /*
4927 ** This routine is called by the parser to add a new term to the
4928 ** end of a growing FROM clause. The "p" parameter is the part of
4929 ** the FROM clause that has already been constructed. "p" is NULL
4930 ** if this is the first term of the FROM clause. pTable and pDatabase
4931 ** are the name of the table and database named in the FROM clause term.
4932 ** pDatabase is NULL if the database name qualifier is missing - the
4933 ** usual case. If the term has an alias, then pAlias points to the
4934 ** alias token. If the term is a subquery, then pSubquery is the
4935 ** SELECT statement that the subquery encodes. The pTable and
4936 ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
4937 ** parameters are the content of the ON and USING clauses.
4938 **
4939 ** Return a new SrcList which encodes is the FROM with the new
4940 ** term added.
4941 */
4950 ){
4956 );
4958 }
4962 }
4970 }
4974 }
4979 }
4980 }
4990 }
4993 append_from_error:
4998 }
5000 /*
5001 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
5002 ** element of the source-list passed as the second argument.
5003 */
5014 /* A "NOT INDEXED" clause was supplied. See parse.y
5015 ** construct "indexed_opt" for details. */
5021 }
5022 }
5023 }
5025 /*
5026 ** Append the contents of SrcList p2 to SrcList p1 and return the resulting
5027 ** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
5028 ** are deleted by this function.
5029 */
5041 }
5042 }
5044 }
5046 /*
5047 ** Add the list of function arguments to the SrcList entry for a
5048 ** table-valued-function.
5049 */
5060 }
5061 }
5063 /*
5064 ** When building up a FROM clause in the parser, the join operator
5065 ** is initially attached to the left operand. But the code generator
5066 ** expects the join operator to be on the right operand. This routine
5067 ** Shifts all join operators from left to right for an entire FROM
5068 ** clause.
5069 **
5070 ** Example: Suppose the join is like this:
5071 **
5072 ** A natural cross join B
5073 **
5074 ** The operator is "natural cross join". The A and B operands are stored
5075 ** in p->a[0] and p->a[1], respectively. The parser initially stores the
5076 ** operator with A. This routine shifts that operator over to B.
5077 **
5078 ** Additional changes:
5079 **
5080 ** * All tables to the left of the right-most RIGHT JOIN are tagged with
5081 ** JT_LTORJ (mnemonic: Left Table Of Right Join) so that the
5082 ** code generator can easily tell that the table is part of
5083 ** the left operand of at least one RIGHT JOIN.
5084 */
5095 /* All terms to the left of a RIGHT JOIN should be tagged with the
5096 ** JT_LTORJ flags */
5099 i--;
5104 }
5105 }
5106 }
5108 /*
5109 ** Generate VDBE code for a BEGIN statement.
5110 */
5121 }
5134 }
5137 }
5138 }
5140 }
5142 /*
5143 ** Generate VDBE code for a COMMIT or ROLLBACK statement.
5144 ** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
5145 ** code is generated for a COMMIT.
5146 */
5158 }
5162 }
5163 }
5165 /*
5166 ** This function is called by the parser when it parses a command to create,
5167 ** release or rollback an SQL savepoint.
5168 */
5173 #ifndef SQLITE_OMIT_AUTHORIZATION
5176 #endif
5180 }
5182 }
5183 }
5185 /*
5186 ** Make sure the TEMP database is open and available for use. Return
5187 ** the number of errors. Leave any error messages in the pParse structure.
5188 */
5195 SQLITE_OPEN_READWRITE |
5196 SQLITE_OPEN_CREATE |
5197 SQLITE_OPEN_EXCLUSIVE |
5198 SQLITE_OPEN_DELETEONCLOSE |
5199 SQLITE_OPEN_TEMP_DB;
5207 }
5213 }
5214 }
5216 }
5218 /*
5219 ** Record the fact that the schema cookie will need to be verified
5220 ** for database iDb. The code to actually verify the schema cookie
5221 ** will occur at the end of the top-level VDBE and will be generated
5222 ** later, by sqlite3FinishCoding().
5223 */
5233 }
5234 }
5235 }
5238 }
5241 /*
5242 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
5243 ** attached database. Otherwise, invoke it for the database named zDb only.
5244 */
5252 }
5253 }
5254 }
5256 /*
5257 ** Generate VDBE code that prepares for doing an operation that
5258 ** might change the database.
5259 **
5260 ** This routine starts a new transaction if we are not already within
5261 ** a transaction. If we are already within a transaction, then a checkpoint
5262 ** is set if the setStatement parameter is true. A checkpoint should
5263 ** be set for operations that might fail (due to a constraint) part of
5264 ** the way through and which will need to undo some writes without having to
5265 ** rollback the whole transaction. For operations where all constraints
5266 ** can be checked before any changes are made to the database, it is never
5267 ** necessary to undo a write and the checkpoint should not be set.
5268 */
5274 }
5276 /*
5277 ** Indicate that the statement currently under construction might write
5278 ** more than one entry (example: deleting one row then inserting another,
5279 ** inserting multiple rows in a table, or inserting a row and index entries.)
5280 ** If an abort occurs after some of these writes have completed, then it will
5281 ** be necessary to undo the completed writes.
5282 */
5286 }
5288 /*
5289 ** The code generator calls this routine if is discovers that it is
5290 ** possible to abort a statement prior to completion. In order to
5291 ** perform this abort without corrupting the database, we need to make
5292 ** sure that the statement is protected by a statement transaction.
5293 **
5294 ** Technically, we only need to set the mayAbort flag if the
5295 ** isMultiWrite flag was previously set. There is a time dependency
5296 ** such that the abort must occur after the multiwrite. This makes
5297 ** some statements involving the REPLACE conflict resolution algorithm
5298 ** go a little faster. But taking advantage of this time dependency
5299 ** makes it more difficult to prove that the code is correct (in
5300 ** particular, it prevents us from writing an effective
5301 ** implementation of sqlite3AssertMayAbort()) and so we have chosen
5302 ** to take the safe route and skip the optimization.
5303 */
5307 }
5309 /*
5310 ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
5311 ** error. The onError parameter determines which (if any) of the statement
5312 ** and/or current transaction is rolled back.
5313 */
5320 u8 p5Errmsg /* P5_ErrMsg type */
5321 ){
5328 }
5331 }
5333 /*
5334 ** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
5335 */
5340 ){
5343 StrAccum errMsg;
5359 }
5360 }
5366 }
5369 /*
5370 ** Code an OP_Halt due to non-unique rowid.
5371 */
5376 ){
5386 }
5388 P5_ConstraintUnique);
5389 }
5391 /*
5392 ** Check to see if pIndex uses the collating sequence pColl. Return
5393 ** true if it does and false if it does not.
5394 */
5395 #ifndef SQLITE_OMIT_REINDEX
5404 }
5405 }
5407 }
5408 #endif
5410 /*
5411 ** Recompute all indices of pTab that use the collating sequence pColl.
5412 ** If pColl==0 then recompute all indices of pTab.
5413 */
5414 #ifndef SQLITE_OMIT_REINDEX
5424 }
5425 }
5426 }
5427 }
5428 #endif
5430 /*
5431 ** Recompute all indices of all tables in all databases where the
5432 ** indices use the collating sequence pColl. If pColl==0 then recompute
5433 ** all indices everywhere.
5434 */
5435 #ifndef SQLITE_OMIT_REINDEX
5449 }
5450 }
5451 }
5452 #endif
5454 /*
5455 ** Generate code for the REINDEX command.
5456 **
5457 ** REINDEX -- 1
5458 ** REINDEX <collation> -- 2
5459 ** REINDEX ?<database>.?<tablename> -- 3
5460 ** REINDEX ?<database>.?<indexname> -- 4
5461 **
5462 ** Form 1 causes all indices in all attached databases to be rebuilt.
5463 ** Form 2 rebuilds all indices in all databases that use the named
5464 ** collating function. Forms 3 and 4 rebuild the named index or all
5465 ** indices associated with the named table.
5466 */
5467 #ifndef SQLITE_OMIT_REINDEX
5478 /* Read the database schema. If an error occurs, leave an error message
5479 ** and code in pParse and return NULL. */
5482 }
5497 }
5499 }
5510 }
5517 }
5519 }
5520 #endif
5522 /*
5523 ** Return a KeyInfo structure that is appropriate for the given Index.
5524 **
5525 ** The caller should invoke sqlite3KeyInfoUnref() on the returned object
5526 ** when it has finished using it.
5527 */
5538 }
5547 }
5551 /* Deactivate the index because it contains an unknown collating
5552 ** sequence. The only way to reactive the index is to reload the
5553 ** schema. Adding the missing collating sequence later does not
5554 ** reactive the index. The application had the chance to register
5555 ** the missing index using the collation-needed callback. For
5556 ** simplicity, SQLite will not give the application a second chance.
5557 */
5560 }
5563 }
5564 }
5566 }
5568 #ifndef SQLITE_OMIT_CTE
5569 /*
5570 ** Create a new CTE object
5571 */
5577 u8 eM10d /* The MATERIALIZED flag */
5578 ){
5593 }
5595 }
5597 /*
5598 ** Clear information from a Cte object, but do not deallocate storage
5599 ** for the object itself.
5600 */
5606 }
5608 /*
5609 ** Free the contents of the CTE object passed as the second argument.
5610 */
5615 }
5617 /*
5618 ** This routine is invoked once per CTE by the parser while parsing a
5619 ** WITH clause. The CTE described by teh third argument is added to
5620 ** the WITH clause of the second argument. If the second argument is
5621 ** NULL, then a new WITH argument is created.
5622 */
5627 ){
5634 }
5636 /* Check that the CTE name is unique within this WITH clause. If
5637 ** not, store an error in the Parse structure. */
5644 }
5645 }
5646 }
5653 }
5662 }
5665 }
5667 /*
5668 ** Free the contents of the With object passed as the second argument.
5669 */
5675 }
5677 }
5678 }