| blob | d53ff3b6709541866e831f7566b0aa1497aab1ef |
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 */
150 }
152 /* Begin by generating some termination code at the end of the
153 ** vdbe program
154 */
160 }
163 }
176 addrRewind =
182 }
187 }
188 }
191 #if SQLITE_USER_AUTHENTICATION
198 }
199 }
200 #endif
202 /* The cookie mask contains one bit for each database file open.
203 ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
204 ** set for each database that is used. Generate code to start a
205 ** transaction on each used database and to verify the schema cookie
206 ** on each used database.
207 */
210 ){
225 );
229 }
230 #ifndef SQLITE_OMIT_VIRTUALTABLE
234 }
236 #endif
238 /* Once all the cookies have been verified and transactions opened,
239 ** obtain the required table-locks. This is a no-op unless the
240 ** shared-cache feature is enabled.
241 */
244 /* Initialize any AUTOINCREMENT data structures required.
245 */
248 /* Code constant expressions that where factored out of inner loops.
249 **
250 ** The pConstExpr list might also contain expressions that we simply
251 ** want to keep around until the Parse object is deleted. Such
252 ** expressions have iConstExprReg==0. Do not generate code for
253 ** those expressions, of course.
254 */
262 }
263 }
264 }
272 }
273 }
275 /* Finally, jump back to the beginning of the executable code. */
277 }
278 }
280 /* Get the VDBE program ready for execution
281 */
283 /* A minimum of one cursor is required if autoincrement is used
284 * See ticket [a696379c1f08866] */
290 }
291 }
293 /*
294 ** Run the parser and code generator recursively in order to generate
295 ** code for the SQL statement given onto the end of the pParse context
296 ** currently under construction. Notes:
297 **
298 ** * The final OP_Halt is not appended and other initialization
299 ** and finalization steps are omitted because those are handling by the
300 ** outermost parser.
301 **
302 ** * Built-in SQL functions always take precedence over application-defined
303 ** SQL functions. In other words, it is not possible to override a
304 ** built-in function.
305 */
320 /* This can result either from an OOM or because the formatted string
321 ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set
322 ** an error */
326 }
337 }
339 #if SQLITE_USER_AUTHENTICATION
340 /*
341 ** Return TRUE if zTable is the name of the system table that stores the
342 ** list of users and their access credentials.
343 */
346 }
347 #endif
349 /*
350 ** Locate the in-memory structure that describes a particular database
351 ** table given the name of that table and (optionally) the name of the
352 ** database containing the table. Return NULL if not found.
353 **
354 ** If zDatabase is 0, all databases are searched for the table and the
355 ** first matching table is returned. (No checking for duplicate table
356 ** names is done.) The search order is TEMP first, then MAIN, then any
357 ** auxiliary databases added using the ATTACH command.
358 **
359 ** See also sqlite3LocateTable().
360 */
365 /* All mutexes are required for schema access. Make sure we hold them. */
367 #if SQLITE_USER_AUTHENTICATION
368 /* Only the admin user is allowed to know that the sqlite_user table
369 ** exists */
372 }
373 #endif
377 }
379 /* No match against the official names. But always match "main"
380 ** to schema 0 as a legacy fallback. */
385 }
386 }
393 ){
395 LEGACY_TEMP_SCHEMA_TABLE);
396 }
400 LEGACY_SCHEMA_TABLE);
401 }
402 }
403 }
405 /* Match against TEMP first */
408 /* The main database is second */
411 /* Attached databases are in order of attachment */
416 }
422 LEGACY_TEMP_SCHEMA_TABLE);
423 }
424 }
425 }
427 }
429 /*
430 ** Locate the in-memory structure that describes a particular database
431 ** table given the name of that table and (optionally) the name of the
432 ** database containing the table. Return NULL if not found. Also leave an
433 ** error message in pParse->zErrMsg.
434 **
435 ** The difference between this routine and sqlite3FindTable() is that this
436 ** routine leaves an error message in pParse->zErrMsg where
437 ** sqlite3FindTable() does not.
438 */
444 ){
448 /* Read the database schema. If an error occurs, leave an error message
449 ** and code in pParse and return NULL. */
452 ){
454 }
458 #ifndef SQLITE_OMIT_VIRTUALTABLE
459 /* If zName is the not the name of a table in the schema created using
460 ** CREATE, then check to see if it is the name of an virtual table that
461 ** can be an eponymous virtual table. */
466 }
470 }
471 }
472 #endif
477 }
485 }
488 }
491 }
493 /*
494 ** Locate the table identified by *p.
495 **
496 ** This is a wrapper around sqlite3LocateTable(). The difference between
497 ** sqlite3LocateTable() and this function is that this function restricts
498 ** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
499 ** non-NULL if it is part of a view or trigger program definition. See
500 ** sqlite3FixSrcList() for details.
501 */
504 u32 flags,
505 SrcItem *p
506 ){
514 }
516 }
518 /*
519 ** Return the preferred table name for system tables. Translate legacy
520 ** names into the new preferred names, as appropriate.
521 */
526 }
529 }
530 }
532 }
534 /*
535 ** Locate the in-memory structure that describes
536 ** a particular index given the name of that index
537 ** and the name of the database that contains the index.
538 ** Return NULL if not found.
539 **
540 ** If zDatabase is 0, all databases are searched for the
541 ** table and the first matching index is returned. (No checking
542 ** for duplicate index names is done.) The search order is
543 ** TEMP first, then MAIN, then any auxiliary databases added
544 ** using the ATTACH command.
545 */
549 /* All mutexes are required for schema access. Make sure we hold them. */
559 }
561 }
563 /*
564 ** Reclaim the memory used by an index
565 */
567 #ifndef SQLITE_OMIT_ANALYZE
569 #endif
574 #ifdef SQLITE_ENABLE_STAT4
576 #endif
578 }
580 /*
581 ** For the index called zIdxName which is found in the database iDb,
582 ** unlike that index from its Table then remove the index from
583 ** the index hash table and free all memory structures associated
584 ** with the index.
585 */
598 /* Justification of ALWAYS(); The index must be on the list of
599 ** indices. */
604 }
605 }
607 }
609 }
611 /*
612 ** Look through the list of open database files in db->aDb[] and if
613 ** any have been closed, remove them from the list. Reallocate the
614 ** db->aDb[] structure to a smaller size, if possible.
615 **
616 ** Entry 0 (the "main" database) and entry 1 (the "temp" database)
617 ** are never candidates for being collapsed.
618 */
627 }
630 }
631 j++;
632 }
638 }
639 }
641 /*
642 ** Reset the schema for the database at index iDb. Also reset the
643 ** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
644 ** Deferred resets may be run by calling with iDb<0.
645 */
655 }
661 }
662 }
663 }
664 }
666 /*
667 ** Erase all schema information from all attached databases (including
668 ** "main" and "temp") for a single database connection.
669 */
680 }
681 }
682 }
688 }
689 }
691 /*
692 ** This routine is called when a commit occurs.
693 */
696 }
698 /*
699 ** Set the expression associated with a column. This is usually
700 ** the DEFAULT value, but might also be the expression that computes
701 ** the value for a generated column.
702 */
708 ){
715 ){
721 }
722 }
724 /*
725 ** Return the expression associated with a column. The expression might be
726 ** the DEFAULT clause or the AS clause of a generated column.
727 ** Return NULL if the column has no associated expression.
728 */
735 }
737 /*
738 ** Set the collating sequence name for a column.
739 */
744 ){
745 i64 nColl;
746 i64 n;
752 }
759 }
760 }
762 /*
763 ** Return the collating squence name for a column
764 */
772 }
774 }
776 /*
777 ** Delete memory allocated for the column names of a table or view (the
778 ** Table.aCol[] array).
779 */
788 }
792 }
798 }
799 }
800 }
801 }
803 /*
804 ** Remove the memory data structures associated with the given
805 ** Table. No changes are made to disk by this routine.
806 **
807 ** This routine just deletes the data structure. It does not unlink
808 ** the table data structure from the hash table. But it does destroy
809 ** memory structures of the indices and foreign keys associated with
810 ** the table.
811 **
812 ** The db parameter is optional. It is needed if the Table object
813 ** contains lookaside memory. (Table objects in the schema do not use
814 ** lookaside memory, but some ephemeral Table objects do.) Or the
815 ** db parameter can be used with db->pnBytesFreed to measure the memory
816 ** used by the Table object.
817 */
821 #ifdef SQLITE_DEBUG
822 /* Record the number of outstanding lookaside allocations in schema Tables
823 ** prior to doing any free() operations. Since schema Tables do not use
824 ** lookaside, this number should not change.
825 **
826 ** If malloc has already failed, it may be that it failed while allocating
827 ** a Table object that was going to be marked ephemeral. So do not check
828 ** that no lookaside memory is used in this case either. */
832 }
833 #endif
835 /* Delete all indices associated with this table. */
844 );
847 }
849 }
853 }
854 #ifndef SQLITE_OMIT_VIRTUAL_TABLE
857 }
858 #endif
862 }
864 /* Delete the Table structure itself.
865 */
872 /* Verify that no lookaside memory was used by schema tables */
874 }
876 /* Do not delete the table until the reference count reaches zero. */
880 }
883 /*
884 ** Unlink the given table from the hash tables and the delete the
885 ** table structure with all its indices and foreign keys.
886 */
900 }
902 /*
903 ** Given a token, return a string that consists of the text of that
904 ** token. Space to hold the returned string
905 ** is obtained from sqliteMalloc() and must be freed by the calling
906 ** function.
907 **
908 ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
909 ** surround the body of the token are removed.
910 **
911 ** Tokens are often just pointers into the original SQL text and so
912 ** are not \000 terminated and are not persistent. The returned string
913 ** is \000 terminated and is persistent.
914 */
922 }
924 }
926 /*
927 ** Open the sqlite_schema table stored in database number iDb for
928 ** writing. The table is opened using cursor 0.
929 */
936 }
937 }
939 /*
940 ** Parameter zName points to a nul-terminated buffer containing the name
941 ** of a database ("main", "temp" or the name of an attached db). This
942 ** function returns the index of the named database in db->aDb[], or
943 ** -1 if the named db cannot be found.
944 */
951 /* "main" is always an acceptable alias for the primary database
952 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
954 }
955 }
957 }
959 /*
960 ** The token *pName contains the name of a database (either "main" or
961 ** "temp" or the name of an attached db). This routine returns the
962 ** index of the named database in db->aDb[], or -1 if the named db
963 ** does not exist.
964 */
972 }
974 /* The table or view or trigger name is passed to this routine via tokens
975 ** pName1 and pName2. If the table name was fully qualified, for example:
976 **
977 ** CREATE TABLE xxx.yyy (...);
978 **
979 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
980 ** the table name is not fully qualified, i.e.:
981 **
982 ** CREATE TABLE yyy(...);
983 **
984 ** Then pName1 is set to "yyy" and pName2 is "".
985 **
986 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
987 ** pName2) that stores the unqualified table name. The index of the
988 ** database "xxx" is returned.
989 */
995 ){
1004 }
1010 }
1016 }
1018 }
1020 /*
1021 ** True if PRAGMA writable_schema is ON
1022 */
1026 SQLITE_WriteSchema );
1028 SQLITE_Defensive );
1032 }
1034 /*
1035 ** This routine is used to check if the UTF-8 string zName is a legal
1036 ** unqualified name for a new schema object (table, index, view or
1037 ** trigger). All names are legal except those that begin with the string
1038 ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
1039 ** is reserved for internal use.
1040 **
1041 ** When parsing the sqlite_schema table, this routine also checks to
1042 ** make sure the "type", "name", and "tbl_name" columns are consistent
1043 ** with the SQL.
1044 */
1050 ){
1055 ){
1056 /* Skip these error checks for writable_schema=ON */
1058 }
1063 ){
1066 }
1070 ){
1072 zName);
1074 }
1076 }
1078 }
1080 /*
1081 ** Return the PRIMARY KEY index of a table
1082 */
1087 }
1089 /*
1090 ** Convert an table column number into a index column number. That is,
1091 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
1092 ** find the (first) offset of that column in index pIdx. Or return -1
1093 ** if column iCol is not used in index pIdx.
1094 */
1099 }
1101 }
1103 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1104 /* Convert a storage column number into a table column number.
1105 **
1106 ** The storage column number (0,1,2,....) is the index of the value
1107 ** as it appears in the record on disk. The true column number
1108 ** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
1109 **
1110 ** The storage column number is less than the table column number if
1111 ** and only there are VIRTUAL columns to the left.
1112 **
1113 ** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
1114 */
1120 }
1121 }
1123 }
1124 #endif
1126 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1127 /* Convert a table column number into a storage column number.
1128 **
1129 ** The storage column number (0,1,2,....) is the index of the value
1130 ** as it appears in the record on disk. Or, if the input column is
1131 ** the N-th virtual column (zero-based) then the storage number is
1132 ** the number of non-virtual columns in the table plus N.
1133 **
1134 ** The true column number is the index (0,1,2,...) of the column in
1135 ** the CREATE TABLE statement.
1136 **
1137 ** If the input column is a VIRTUAL column, then it should not appear
1138 ** in storage. But the value sometimes is cached in registers that
1139 ** follow the range of registers used to construct storage. This
1140 ** avoids computing the same VIRTUAL column multiple times, and provides
1141 ** values for use by OP_Param opcodes in triggers. Hence, if the
1142 ** input column is a VIRTUAL table, put it after all the other columns.
1143 **
1144 ** In the following, N means "normal column", S means STORED, and
1145 ** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
1146 **
1147 ** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
1148 ** -- 0 1 2 3 4 5 6 7 8
1149 **
1150 ** Then the mapping from this function is as follows:
1151 **
1152 ** INPUTS: 0 1 2 3 4 5 6 7 8
1153 ** OUTPUTS: 0 1 6 2 3 7 4 5 8
1154 **
1155 ** So, in other words, this routine shifts all the virtual columns to
1156 ** the end.
1157 **
1158 ** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and
1159 ** this routine is a no-op macro. If the pTab does not have any virtual
1160 ** columns, then this routine is no-op that always return iCol. If iCol
1161 ** is negative (indicating the ROWID column) then this routine return iCol.
1162 */
1165 i16 n;
1170 }
1172 /* iCol is a virtual column itself */
1175 /* iCol is a normal or stored column */
1177 }
1178 }
1179 #endif
1181 /*
1182 ** Insert a single OP_JournalMode query opcode in order to force the
1183 ** prepared statement to return false for sqlite3_stmt_readonly(). This
1184 ** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
1185 ** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
1186 ** will return false for sqlite3_stmt_readonly() even if that statement
1187 ** is a read-only no-op.
1188 */
1195 }
1196 }
1198 /*
1199 ** Begin constructing a new table representation in memory. This is
1200 ** the first of several action routines that get called in response
1201 ** to a CREATE TABLE statement. In particular, this routine is called
1202 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
1203 ** flag is true if the table should be stored in the auxiliary database
1204 ** file instead of in the main database file. This is normally the case
1205 ** when the "TEMP" or "TEMPORARY" keyword occurs in between
1206 ** CREATE and TABLE.
1207 **
1208 ** The new table record is initialized and put in pParse->pNewTable.
1209 ** As more of the CREATE TABLE statement is parsed, additional action
1210 ** routines will be called to add more information to this record.
1211 ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
1212 ** is called to complete the construction of the new table record.
1213 */
1222 ){
1231 /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */
1236 /* The common case */
1240 /* If creating a temp table, the name may not be qualified. Unless
1241 ** the database name is "temp" anyway. */
1244 }
1249 }
1250 }
1255 }
1257 #ifndef SQLITE_OMIT_AUTHORIZATION
1260 {
1262 SQLITE_CREATE_TABLE,
1263 SQLITE_CREATE_TEMP_TABLE,
1264 SQLITE_CREATE_VIEW,
1265 SQLITE_CREATE_TEMP_VIEW
1266 };
1270 }
1274 }
1275 }
1276 #endif
1278 /* Make sure the new table name does not collide with an existing
1279 ** index or table name in the same database. Issue an error message if
1280 ** it does. The exception is if the statement being parsed was passed
1281 ** to an sqlite3_declare_vtab() call. In that case only the column names
1282 ** and types will be used, so there is no need to test for namespace
1283 ** collisions.
1284 */
1289 }
1298 }
1300 }
1304 }
1305 }
1313 }
1318 #ifdef SQLITE_DEFAULT_ROWEST
1320 #else
1322 #endif
1326 /* Begin generating the code that will insert the table record into
1327 ** the schema table. Note in particular that we must go ahead
1328 ** and allocate the record number for the table entry now. Before any
1329 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
1330 ** indices to be created and the table record must come before the
1331 ** indices. Hence, the record number for the table must be allocated
1332 ** now.
1333 */
1338 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
1342 #ifndef SQLITE_OMIT_VIRTUALTABLE
1345 }
1346 #endif
1348 /* If the file format and encoding in the database have not been set,
1349 ** set them now.
1350 */
1363 /* This just creates a place-holder record in the sqlite_schema table.
1364 ** The record created does not contain anything yet. It will be replaced
1365 ** by the real entry in code generated at sqlite3EndTable().
1366 **
1367 ** The rowid for the new entry is left in register pParse->regRowid.
1368 ** The root page number of the new table is left in reg pParse->regRoot.
1369 ** The rowid and root page number values are needed by the code that
1370 ** sqlite3EndTable will generate.
1371 */
1372 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1376 #endif
1377 {
1381 }
1388 }
1390 /* Normal (non-error) return. */
1393 /* If an error occurs, we jump here */
1394 begin_table_error:
1398 }
1400 /* Set properties of a table column based on the (magical)
1401 ** name of the column.
1402 */
1403 #if SQLITE_ENABLE_HIDDEN_COLUMNS
1410 }
1411 }
1412 #endif
1414 /*
1415 ** Name of the special TEMP trigger used to implement RETURNING. The
1416 ** name begins with "sqlite_" so that it is guaranteed not to collide
1417 ** with any application-generated triggers.
1418 */
1421 /*
1422 ** Clean up the data structures associated with the RETURNING clause.
1423 */
1430 }
1432 /*
1433 ** Add the RETURNING clause to the parse currently underway.
1434 **
1435 ** This routine creates a special TEMP trigger that will fire for each row
1436 ** of the DML statement. That TEMP trigger contains a single SELECT
1437 ** statement with a result set that is the argument of the RETURNING clause.
1438 ** The trigger has the Trigger.bReturning flag and an opcode of
1439 ** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
1440 ** knows to handle it specially. The TEMP trigger is automatically
1441 ** removed at the end of the parse.
1442 **
1443 ** When this routine is called, we do not yet know if the RETURNING clause
1444 ** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
1445 ** RETURNING trigger instead. It will then be converted into the appropriate
1446 ** type on the first call to sqlite3TriggersExist().
1447 */
1456 }
1462 }
1485 }
1486 }
1488 /*
1489 ** Add a new column to the table currently being constructed.
1490 **
1491 ** The parser calls this routine once for each column declaration
1492 ** in a CREATE TABLE statement. sqlite3StartTable() gets called
1493 ** first to get things going. Then this routine is called for each
1494 ** column.
1495 */
1503 u8 hName;
1513 }
1516 /* Because keywords GENERATE ALWAYS can be converted into indentifiers
1517 ** by the parser, we can sometimes end up with a typename that ends
1518 ** with "generated always". Check for this case and omit the surplus
1519 ** text. */
1522 ){
1527 ){
1530 }
1531 }
1533 /* Check for standard typenames. For standard typenames we will
1534 ** set the Column.eType field rather than storing the typename after
1535 ** the column name, in order to save space. */
1541 ){
1547 }
1548 }
1549 }
1563 }
1564 }
1569 }
1578 /* If there is no type specified, columns have the default affinity
1579 ** 'BLOB' with a default size of 4 bytes. */
1583 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1587 }
1588 }
1589 #endif
1597 }
1601 }
1603 /*
1604 ** This routine is called by the parser while in the middle of
1605 ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1606 ** been seen on a column. This routine sets the notNull flag on
1607 ** the column currently under construction.
1608 */
1618 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
1619 ** on this column. */
1626 }
1627 }
1628 }
1629 }
1631 /*
1632 ** Scan the column type name zType (length nType) and return the
1633 ** associated affinity type.
1634 **
1635 ** This routine does a case-independent search of zType for the
1636 ** substrings in the following table. If one of the substrings is
1637 ** found, the corresponding affinity is returned. If zType contains
1638 ** more than one of the substrings, entries toward the top of
1639 ** the table take priority. For example, if zType is 'BLOBINT',
1640 ** SQLITE_AFF_INTEGER is returned.
1641 **
1642 ** Substring | Affinity
1643 ** --------------------------------
1644 ** 'INT' | SQLITE_AFF_INTEGER
1645 ** 'CHAR' | SQLITE_AFF_TEXT
1646 ** 'CLOB' | SQLITE_AFF_TEXT
1647 ** 'TEXT' | SQLITE_AFF_TEXT
1648 ** 'BLOB' | SQLITE_AFF_BLOB
1649 ** 'REAL' | SQLITE_AFF_REAL
1650 ** 'FLOA' | SQLITE_AFF_REAL
1651 ** 'DOUB' | SQLITE_AFF_REAL
1652 **
1653 ** If none of the substrings in the above table are found,
1654 ** SQLITE_AFF_NUMERIC is returned.
1655 */
1664 zIn++;
1676 #ifndef SQLITE_OMIT_FLOATING_POINT
1686 #endif
1690 }
1691 }
1693 /* If pCol is not NULL, store an estimate of the field size. The
1694 ** estimate is scaled so that the size of an integer is 1. */
1701 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
1704 }
1705 zChar++;
1706 }
1709 }
1710 }
1711 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
1714 }
1715 #endif
1719 }
1721 }
1723 /*
1724 ** The expression is the default value for the most recently added column
1725 ** of the table currently under construction.
1726 **
1727 ** Default value expressions must be constant. Raise an exception if this
1728 ** is not the case.
1729 **
1730 ** This routine is called by the parser while in the middle of
1731 ** parsing a CREATE TABLE statement.
1732 */
1738 ){
1749 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1754 #endif
1756 /* A copy of pExpr is used instead of the original, as pExpr contains
1757 ** tokens that point to volatile memory.
1758 */
1768 }
1769 }
1772 }
1774 }
1776 /*
1777 ** Backwards Compatibility Hack:
1778 **
1779 ** Historical versions of SQLite accepted strings as column names in
1780 ** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1781 **
1782 ** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1783 ** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1784 **
1785 ** This is goofy. But to preserve backwards compatibility we continue to
1786 ** accept it. This routine does the necessary conversion. It converts
1787 ** the expression given in its argument from a TK_STRING into a TK_ID
1788 ** if the expression is just a TK_STRING with an optional COLLATE clause.
1789 ** If the expression is anything other than TK_STRING, the expression is
1790 ** unchanged.
1791 */
1797 }
1798 }
1800 /*
1801 ** Tag the given column as being part of the PRIMARY KEY
1802 */
1805 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1811 }
1812 #endif
1813 }
1815 /*
1816 ** Designate the PRIMARY KEY for the table. pList is a list of names
1817 ** of columns that form the primary key. If pList is NULL, then the
1818 ** most recently added column of the table is the primary key.
1819 **
1820 ** A table can have at most one primary key. If the table already has
1821 ** a primary key (and this is the second primary key) then create an
1822 ** error.
1823 **
1824 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
1825 ** then we will try to use that column as the rowid. Set the Table.iPKey
1826 ** field of the table under construction to be the index of the
1827 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1828 ** no INTEGER PRIMARY KEY.
1829 **
1830 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
1831 ** index for the key. No index is created for INTEGER PRIMARY KEYs.
1832 */
1839 ){
1849 }
1871 }
1872 }
1873 }
1874 }
1875 }
1877 && pCol
1880 ){
1884 }
1892 #ifndef SQLITE_OMIT_AUTOINCREMENT
1895 #endif
1900 }
1902 primary_key_exit:
1905 }
1907 /*
1908 ** Add a new CHECK constraint to the table currently under construction.
1909 */
1915 ){
1916 #ifndef SQLITE_OMIT_CHECK
1921 ){
1926 Token t;
1932 }
1934 #endif
1935 {
1937 }
1938 }
1940 /*
1941 ** Set the collation function of the most recently parsed table column
1942 ** to the CollSeq given.
1943 */
1960 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1961 ** then an index may have been created on this column before the
1962 ** collation type was added. Correct this if it is the case.
1963 */
1968 }
1969 }
1970 }
1972 }
1974 /* Change the most recently parsed column to be a GENERATED ALWAYS AS
1975 ** column.
1976 */
1978 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
1983 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
1985 }
1990 }
1994 /* no-op */
1999 }
2000 }
2008 }
2013 generated_error:
2016 generated_done:
2018 #else
2019 /* Throw and error for the GENERATED ALWAYS AS clause if the
2020 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
2023 #endif
2024 }
2026 /*
2027 ** Generate code that will increment the schema cookie.
2028 **
2029 ** The schema cookie is used to determine when the schema for the
2030 ** database changes. After each schema change, the cookie value
2031 ** changes. When a process first reads the schema it records the
2032 ** cookie. Thereafter, whenever it goes to access the database,
2033 ** it checks the cookie to make sure the schema has not changed
2034 ** since it was last read.
2035 **
2036 ** This plan is not completely bullet-proof. It is possible for
2037 ** the schema to change multiple times and for the cookie to be
2038 ** set back to prior value. But schema changes are infrequent
2039 ** and the probability of hitting the same cookie value is only
2040 ** 1 chance in 2^32. So we're safe enough.
2041 **
2042 ** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
2043 ** the schema-version whenever the schema changes.
2044 */
2051 }
2053 /*
2054 ** Measure the number of characters needed to output the given
2055 ** identifier. The number returned includes any quotes used
2056 ** but does not include the null terminator.
2057 **
2058 ** The estimate is conservative. It might be larger that what is
2059 ** really needed.
2060 */
2065 }
2067 }
2069 /*
2070 ** The first parameter is a pointer to an output buffer. The second
2071 ** parameter is a pointer to an integer that contains the offset at
2072 ** which to write into the output buffer. This function copies the
2073 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
2074 ** to the specified offset in the buffer and updates *pIdx to refer
2075 ** to the first byte after the last byte written before returning.
2076 **
2077 ** If the string zSignedIdent consists entirely of alpha-numeric
2078 ** characters, does not begin with a digit and is not an SQL keyword,
2079 ** then it is copied to the output buffer exactly as it is. Otherwise,
2080 ** it is quoted using double-quotes.
2081 */
2089 }
2099 }
2103 }
2105 /*
2106 ** Generate a CREATE TABLE statement appropriate for the given
2107 ** table. Memory to hold the text of the statement is obtained
2108 ** from sqliteMalloc() and must be freed by the calling function.
2109 */
2118 }
2128 }
2134 }
2146 };
2169 }
2172 }
2174 /*
2175 ** Resize an Index object to hold N columns total. Return SQLITE_OK
2176 ** on success and SQLITE_NOMEM on an OOM error.
2177 */
2200 }
2202 /*
2203 ** Estimate the total row width for a table.
2204 */
2211 }
2214 }
2216 /*
2217 ** Estimate the average size of a row for an index.
2218 */
2227 }
2229 }
2231 /* Return true if column number x is any of the first nCol entries of aiCol[].
2232 ** This is used to determine if the column number x appears in any of the
2233 ** first nCol entries of an index.
2234 */
2239 }
2240 }
2242 }
2244 /*
2245 ** Return true if any of the first nKey entries of index pIdx exactly
2246 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
2247 ** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
2248 ** or may not be the same index as pPk.
2249 **
2250 ** The first nKey entries of pIdx are guaranteed to be ordinary columns,
2251 ** not a rowid or expression.
2252 **
2253 ** This routine differs from hasColumn() in that both the column and the
2254 ** collating sequence must match for this routine, but for hasColumn() only
2255 ** the column name must match.
2256 */
2271 ){
2273 }
2274 }
2276 }
2278 /* Recompute the colNotIdxed field of the Index.
2279 **
2280 ** colNotIdxed is a bitmask that has a 0 bit representing each indexed
2281 ** columns that are within the first 63 columns of the table. The
2282 ** high-order bit of colNotIdxed is always 1. All unindexed columns
2283 ** of the table have a 1.
2284 **
2285 ** 2019-10-24: For the purpose of this computation, virtual columns are
2286 ** not considered to be covered by the index, even if they are in the
2287 ** index, because we do not trust the logic in whereIndexExprTrans() to be
2288 ** able to find all instances of a reference to the indexed table column
2289 ** and convert them into references to the index. Hence we always want
2290 ** the actual table at hand in order to recompute the virtual column, if
2291 ** necessary.
2292 **
2293 ** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
2294 ** to determine if the index is covering index.
2295 */
2306 }
2307 }
2310 }
2312 /*
2313 ** This routine runs at the end of parsing a CREATE TABLE statement that
2314 ** has a WITHOUT ROWID clause. The job of this routine is to convert both
2315 ** internal schema data structures and the generated VDBE code so that they
2316 ** are appropriate for a WITHOUT ROWID table instead of a rowid table.
2317 ** Changes include:
2318 **
2319 ** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
2320 ** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
2321 ** into BTREE_BLOBKEY.
2322 ** (3) Bypass the creation of the sqlite_schema table entry
2323 ** for the PRIMARY KEY as the primary key index is now
2324 ** identified by the sqlite_schema table entry of the table itself.
2325 ** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
2326 ** schema to the rootpage from the main table.
2327 ** (5) Add all table columns to the PRIMARY KEY Index object
2328 ** so that the PRIMARY KEY is a covering index. The surplus
2329 ** columns are part of KeyInfo.nAllField and are not used for
2330 ** sorting or lookup or uniqueness checks.
2331 ** (6) Replace the rowid tail on all automatically generated UNIQUE
2332 ** indices with the PRIMARY KEY columns.
2333 **
2334 ** For virtual tables, only (1) is performed.
2335 */
2345 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
2346 */
2351 ){
2353 }
2354 }
2356 }
2358 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
2359 ** into BTREE_BLOBKEY.
2360 */
2365 }
2367 /* Locate the PRIMARY KEY index. Or, if this table was originally
2368 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
2369 */
2372 Token ipkToken;
2379 }
2382 }
2387 SQLITE_IDXTYPE_PRIMARYKEY);
2391 }
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 */
2855 }
2857 /* Compute the complete text of the CREATE statement */
2866 );
2867 }
2869 /* A slot for the record has already been allocated in the
2870 ** schema table. We just need to update that slot with all
2871 ** the information we've collected.
2872 */
2874 "UPDATE %Q." LEGACY_SCHEMA_TABLE
2875 " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
2878 zType,
2882 zStmt,
2883 pParse->regRowid
2884 );
2888 #ifndef SQLITE_OMIT_AUTOINCREMENT
2889 /* Check to see if we need to create an sqlite_sequence table for
2890 ** keeping track of autoincrement keys.
2891 */
2898 pDb->zDbSName
2899 );
2900 }
2901 }
2902 #endif
2904 /* Reparse everything to update our internal data structures */
2907 }
2909 /* Add the table to the in-memory representation of the database.
2910 */
2921 }
2925 /* If this is the magic sqlite_sequence table used by autoincrement,
2926 ** then record a pointer to this table in the main database structure
2927 ** so that INSERT can find the table easily. */
2929 #ifndef SQLITE_OMIT_AUTOINCREMENT
2933 }
2934 #endif
2935 }
2937 #ifndef SQLITE_OMIT_ALTERTABLE
2942 }
2944 }
2945 #endif
2946 }
2948 #ifndef SQLITE_OMIT_VIEW
2949 /*
2950 ** The parser calls this routine in order to create a new VIEW
2951 */
2961 ){
2965 Token sEnd;
2966 DbFixer sFix;
2974 }
2979 /* Legacy versions of SQLite allowed the use of the magic "rowid" column
2980 ** on a view, even though views do not have rowids. The following flag
2981 ** setting fixes this problem. But the fix can be disabled by compiling
2982 ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
2983 ** depend upon the old buggy behavior. */
2984 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
2986 #endif
2993 /* Make a copy of the entire SELECT statement that defines the view.
2994 ** This will force all the Expr.token.z values to be dynamically
2995 ** allocated rather than point to the input string - which means that
2996 ** they will persist after the current sqlite3_exec() call returns.
2997 */
3004 }
3009 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
3010 ** the end.
3011 */
3016 }
3025 /* Use sqlite3EndTable() to add the view to the schema table */
3028 create_view_fail:
3032 }
3035 }
3038 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
3039 /*
3040 ** The Table structure pTable is really a VIEW. Fill in the names of
3041 ** the columns of the view in the pTable structure. Return the number
3042 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
3043 */
3050 #ifndef SQLITE_OMIT_VIRTUALTABLE
3052 #endif
3053 #ifndef SQLITE_OMIT_AUTHORIZATION
3055 #endif
3059 #ifndef SQLITE_OMIT_VIRTUALTABLE
3065 }
3066 #endif
3068 #ifndef SQLITE_OMIT_VIEW
3069 /* A positive nCol means the columns names for this view are
3070 ** already known.
3071 */
3074 /* A negative nCol is a special marker meaning that we are currently
3075 ** trying to compute the column names. If we enter this routine with
3076 ** a negative nCol, it means two or more views form a loop, like this:
3077 **
3078 ** CREATE VIEW one AS SELECT * FROM two;
3079 ** CREATE VIEW two AS SELECT * FROM one;
3080 **
3081 ** Actually, the error above is now caught prior to reaching this point.
3082 ** But the following test is still important as it does come up
3083 ** in the following:
3084 **
3085 ** CREATE TABLE main.ex1(a);
3086 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
3087 ** SELECT * FROM temp.ex1;
3088 */
3092 }
3095 /* If we get this far, it means we need to compute the table names.
3096 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
3097 ** "*" elements in the results set of the view and will assign cursors
3098 ** to the elements of the FROM clause. But we do not want these changes
3099 ** to be permanent. So the computation is done on a copy of the SELECT
3100 ** statement that defines the view.
3101 */
3110 DisableLookaside;
3111 #ifndef SQLITE_OMIT_AUTHORIZATION
3116 #else
3118 #endif
3122 nErr++;
3124 /* CREATE VIEW name(arglist) AS ...
3125 ** The names of the columns in the table are taken from
3126 ** arglist which is stored in pTable->pCheck. The pCheck field
3127 ** normally holds CHECK constraints on an ordinary table, but for
3128 ** a VIEW it holds the list of column names.
3129 */
3135 ){
3137 SQLITE_AFF_NONE);
3138 }
3140 /* CREATE VIEW name AS... without an argument list. Construct
3141 ** the column names from the SELECT statement that defines the view.
3142 */
3150 }
3154 EnableLookaside;
3157 nErr++;
3158 }
3162 }
3165 }
3168 #ifndef SQLITE_OMIT_VIEW
3169 /*
3170 ** Clear the column names from every VIEW in database idx.
3171 */
3180 }
3181 }
3183 }
3184 #else
3185 # define sqliteViewResetAll(A,B)
3188 /*
3189 ** This function is called by the VDBE to adjust the internal schema
3190 ** used by SQLite when the btree layer moves a table root page. The
3191 ** root-page of a table or index in database iDb has changed from iFrom
3192 ** to iTo.
3193 **
3194 ** Ticket #1728: The symbol table might still contain information
3195 ** on tables and/or indices that are the process of being deleted.
3196 ** If you are unlucky, one of those deleted indices or tables might
3197 ** have the same rootpage number as the real table or index that is
3198 ** being moved. So we cannot stop searching after the first match
3199 ** because the first match might be for one of the deleted indices
3200 ** or tables and not the table/index that is actually being moved.
3201 ** We must continue looping until all tables and indices with
3202 ** rootpage==iFrom have been converted to have a rootpage of iTo
3203 ** in order to be certain that we got the right one.
3204 */
3205 #ifndef SQLITE_OMIT_AUTOVACUUM
3218 }
3219 }
3225 }
3226 }
3227 }
3228 #endif
3230 /*
3231 ** Write code to erase the table with root-page iTable from database iDb.
3232 ** Also write code to modify the sqlite_schema table and internal schema
3233 ** if a root-page of another table is moved by the btree-layer whilst
3234 ** erasing iTable (this can happen with an auto-vacuum database).
3235 */
3242 #ifndef SQLITE_OMIT_AUTOVACUUM
3243 /* OP_Destroy stores an in integer r1. If this integer
3244 ** is non-zero, then it is the root page number of a table moved to
3245 ** location iTable. The following code modifies the sqlite_schema table to
3246 ** reflect this.
3247 **
3248 ** The "#NNN" in the SQL is a special constant that means whatever value
3249 ** is in register NNN. See grammar rules associated with the TK_REGISTER
3250 ** token for additional information.
3251 */
3253 "UPDATE %Q." LEGACY_SCHEMA_TABLE
3256 #endif
3258 }
3260 /*
3261 ** Write VDBE code to erase table pTab and all associated indices on disk.
3262 ** Code to update the sqlite_schema tables and internal schema definitions
3263 ** in case a root-page belonging to another table is moved by the btree layer
3264 ** is also added (this can happen with an auto-vacuum database).
3265 */
3267 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
3268 ** is not defined), then it is important to call OP_Destroy on the
3269 ** table and index root-pages in order, starting with the numerically
3270 ** largest root-page number. This guarantees that none of the root-pages
3271 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
3272 ** following were coded:
3273 **
3274 ** OP_Destroy 4 0
3275 ** ...
3276 ** OP_Destroy 5 0
3277 **
3278 ** and root page 5 happened to be the largest root-page number in the
3279 ** database, then root page 5 would be moved to page 4 by the
3280 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
3281 ** a free-list page.
3282 */
3292 }
3298 }
3299 }
3307 }
3308 }
3309 }
3311 /*
3312 ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
3313 ** after a DROP INDEX or DROP TABLE command.
3314 */
3320 ){
3330 );
3331 }
3332 }
3333 }
3335 /*
3336 ** Generate code to drop a table.
3337 */
3348 #ifndef SQLITE_OMIT_VIRTUALTABLE
3351 }
3352 #endif
3354 /* Drop all triggers associated with the table being dropped. Code
3355 ** is generated to remove entries from sqlite_schema and/or
3356 ** sqlite_temp_schema if required.
3357 */
3364 }
3366 #ifndef SQLITE_OMIT_AUTOINCREMENT
3367 /* Remove any entries of the sqlite_sequence table associated with
3368 ** the table being dropped. This is done before the table is dropped
3369 ** at the btree level, in case the sqlite_sequence table needs to
3370 ** move as a result of the drop (can happen in auto-vacuum mode).
3371 */
3376 );
3377 }
3378 #endif
3380 /* Drop all entries in the schema table that refer to the
3381 ** table. The program name loops through the schema table and deletes
3382 ** every row that refers to a table of the same name as the one being
3383 ** dropped. Triggers are handled separately because a trigger can be
3384 ** created in the temp database that refers to a table in another
3385 ** database.
3386 */
3388 "DELETE FROM %Q." LEGACY_SCHEMA_TABLE
3393 }
3395 /* Remove the table entry from SQLite's internal schema and modify
3396 ** the schema cookie.
3397 */
3401 }
3405 }
3407 /*
3408 ** Return TRUE if shadow tables should be read-only in the current
3409 ** context.
3410 */
3412 #ifndef SQLITE_OMIT_VIRTUALTABLE
3417 ){
3419 }
3420 #endif
3422 }
3424 /*
3425 ** Return true if it is not allowed to drop the given table
3426 */
3432 }
3435 }
3438 }
3440 }
3442 /*
3443 ** This routine is called to do the work of a DROP TABLE statement.
3444 ** pName is the name of the table to be dropped.
3445 */
3454 }
3467 }
3469 }
3473 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
3474 ** it is initialized.
3475 */
3478 }
3479 #ifndef SQLITE_OMIT_AUTHORIZATION
3480 {
3487 }
3493 }
3494 #ifndef SQLITE_OMIT_VIRTUALTABLE
3498 #endif
3504 }
3505 }
3508 }
3511 }
3512 }
3513 #endif
3517 }
3519 #ifndef SQLITE_OMIT_VIEW
3520 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
3521 ** on a table.
3522 */
3526 }
3530 }
3531 #endif
3533 /* Generate code to remove the table from the schema table
3534 ** on disk.
3535 */
3542 }
3544 }
3546 exit_drop_table:
3548 }
3550 /*
3551 ** This routine is called to create a new foreign key on the table
3552 ** currently under construction. pFromCol determines which columns
3553 ** in the current table point to the foreign key. If pFromCol==0 then
3554 ** connect the key to the last column inserted. pTo is the name of
3555 ** the table referred to (a.k.a the "parent" table). pToCol is a list
3556 ** of tables in the parent pTo table. flags contains all
3557 ** information about the conflict resolution algorithms specified
3558 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
3559 **
3560 ** An FKey structure is created and added to the table currently
3561 ** under construction in the pParse->pNewTable field.
3562 **
3563 ** The foreign key is set for IMMEDIATE processing. A subsequent call
3564 ** to sqlite3DeferForeignKey() might change this to DEFERRED.
3565 */
3572 ){
3574 #ifndef SQLITE_OMIT_FOREIGN_KEY
3578 i64 nByte;
3593 }
3597 "number of columns in foreign key does not match the number of "
3602 }
3607 }
3608 }
3612 }
3620 }
3635 }
3636 }
3642 }
3645 }
3646 }
3647 }
3654 }
3658 }
3659 }
3667 );
3671 }
3676 }
3678 /* Link the foreign key to the table as the last step.
3679 */
3684 fk_end:
3689 }
3691 /*
3692 ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
3693 ** clause is seen as part of a foreign key definition. The isDeferred
3694 ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
3695 ** The behavior of the most recently created foreign key is adjusted
3696 ** accordingly.
3697 */
3699 #ifndef SQLITE_OMIT_FOREIGN_KEY
3707 #endif
3708 }
3710 /*
3711 ** Generate code that will erase and refill index *pIdx. This is
3712 ** used to initialize a newly created index or to recompute the
3713 ** content of an index in response to a REINDEX command.
3714 **
3715 ** if memRootPage is not negative, it means that the index is newly
3716 ** created. The register specified by memRootPage contains the
3717 ** root page number of the index. If memRootPage is negative, then
3718 ** the index already exists and must be cleared before being refilled and
3719 ** the root page number of the index is taken from pIndex->tnum.
3720 */
3736 #ifndef SQLITE_OMIT_AUTHORIZATION
3740 }
3741 #endif
3743 /* Require a write-lock on the table to perform this operation */
3752 }
3756 /* Open the sorter cursor if we are to use one. */
3761 /* Open the table. Loop through all rows of the table, inserting index
3762 ** records into the sorter. */
3788 /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
3789 ** abort. The exception is if one of the indexed expressions contains a
3790 ** user function that throws an exception when it is evaluated. But the
3791 ** overhead of adding a statement journal to a CREATE INDEX statement is
3792 ** very small (since most of the pages written do not contain content that
3793 ** needs to be restored if the statement aborts), so we call
3794 ** sqlite3MayAbort() for all CREATE INDEX statements. */
3797 }
3800 /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
3801 ** faster by avoiding unnecessary seeks. But the optimization does
3802 ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
3803 ** with DESC primary keys, since those indexes have there keys in
3804 ** a different order from the main table.
3805 ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
3806 */
3808 }
3818 }
3820 /*
3821 ** Allocate heap space to hold an Index object with nCol columns.
3822 **
3823 ** Increase the allocation size to provide an extra nExtra bytes
3824 ** of 8-byte aligned space after the Index object and return a
3825 ** pointer to this extra space in *ppExtra.
3826 */
3832 ){
3851 }
3853 }
3855 /*
3856 ** If expression list pList contains an expression that was parsed with
3857 ** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
3858 ** pParse and return non-zero. Otherwise, return zero.
3859 */
3868 );
3870 }
3871 }
3872 }
3874 }
3876 /*
3877 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
3878 ** and pTblList is the name of the table that is to be indexed. Both will
3879 ** be NULL for a primary key or an index that is created to satisfy a
3880 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
3881 ** as the table to be indexed. pParse->pNewTable is a table that is
3882 ** currently being constructed by a CREATE TABLE statement.
3883 **
3884 ** pList is a list of columns to be indexed. pList will be NULL if this
3885 ** is a primary key or unique-constraint on the most recent column added
3886 ** to the table currently under construction.
3887 */
3899 u8 idxType /* The index type */
3900 ){
3920 }
3923 }
3926 }
3929 }
3931 /*
3932 ** Find the table that is to be indexed. Return early if not found.
3933 */
3936 /* Use the two-part index name to determine the database
3937 ** to search for the table. 'Fix' the table name to this db
3938 ** before looking up the table.
3939 */
3945 #ifndef SQLITE_OMIT_TEMPDB
3946 /* If the index name was unqualified, check if the table
3947 ** is a temp table. If so, set the database to 1. Do not do this
3948 ** if initialising a database schema.
3949 */
3954 }
3955 }
3956 #endif
3960 /* Because the parser constructs pTblName from a single identifier,
3961 ** sqlite3FixSrcList can never fail. */
3963 }
3972 }
3980 }
3988 #if SQLITE_USER_AUTHENTICATION
3990 #endif
3991 ){
3994 }
3995 #ifndef SQLITE_OMIT_VIEW
3999 }
4000 #endif
4001 #ifndef SQLITE_OMIT_VIRTUALTABLE
4005 }
4006 #endif
4008 /*
4009 ** Find the name of the index. Make sure there is not already another
4010 ** index or table with the same name.
4011 **
4012 ** Exception: If we are reading the names of permanent indices from the
4013 ** sqlite_schema table (because some other process changed the schema) and
4014 ** one of the index names collides with the name of a temporary table or
4015 ** index, then we will continue to process this index.
4016 **
4017 ** If pName==0 it means that we are
4018 ** dealing with a primary key or UNIQUE constraint. We have to invent our
4019 ** own name.
4020 */
4027 }
4033 }
4034 }
4042 }
4044 }
4045 }
4053 }
4055 /* Automatic index names generated from within sqlite3_declare_vtab()
4056 ** must have names that are distinct from normal automatic index names.
4057 ** The following statement converts "sqlite3_autoindex..." into
4058 ** "sqlite3_butoindex..." in order to make the names distinct.
4059 ** The "vtab_err.test" test demonstrates the need of this statement. */
4061 }
4063 /* Check for authorization to create an index.
4064 */
4065 #ifndef SQLITE_OMIT_AUTHORIZATION
4070 }
4075 }
4076 }
4077 #endif
4079 /* If pList==0, it means this routine was called to make a primary
4080 ** key out of the last column added to the table under construction.
4081 ** So create a fake list to simulate this.
4082 */
4084 Token prevCol;
4096 }
4098 /* Figure out how many bytes of space are required to store explicitly
4099 ** specified collation sequence names.
4100 */
4107 }
4108 }
4110 /*
4111 ** Allocate the index structure.
4112 */
4120 }
4136 }
4139 /* Check to see if we should honor DESC requests on index columns
4140 */
4145 }
4147 /* Analyze the list of expressions that form the terms of the index and
4148 ** report any errors. In the common case where the expression is exactly
4149 ** a table column, store that column in aiColumn[]. For general expressions,
4150 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
4151 **
4152 ** TODO: Issue a warning if two or more columns of the index are identical.
4153 ** TODO: Issue a warning if the table primary key is used as part of the
4154 ** index key.
4155 */
4160 }
4175 }
4179 }
4191 }
4194 }
4195 }
4197 }
4211 }
4215 }
4219 }
4221 /* Append the table key to the end of the index. For WITHOUT ROWID
4222 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
4223 ** normal tables (when pPk==0) this will be the rowid.
4224 */
4236 i++;
4237 }
4238 }
4243 }
4247 /* If this index contains every column of its table, then mark
4248 ** it as a covering index */
4259 }
4260 }
4263 /* This routine has been called to create an automatic index as a
4264 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
4265 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
4266 ** i.e. one of:
4267 **
4268 ** CREATE TABLE t(x PRIMARY KEY, y);
4269 ** CREATE TABLE t(x, y, UNIQUE(x, y));
4270 **
4271 ** Either way, check to see if the table already has such an index. If
4272 ** so, don't bother creating this one. This only applies to
4273 ** automatically created indices. Users can do as they wish with
4274 ** explicit indices.
4275 **
4276 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
4277 ** (and thus suppressing the second one) even if they have different
4278 ** sort orders.
4279 **
4280 ** If there are different collating sequences or if the columns of
4281 ** the constraint occur in different orders, then the constraints are
4282 ** considered distinct and both result in separate indices.
4283 */
4300 }
4303 /* This constraint creates the same index as a previous
4304 ** constraint specified somewhere in the CREATE TABLE statement.
4305 ** However the ON CONFLICT clauses are different. If both this
4306 ** constraint and the previous equivalent constraint have explicit
4307 ** ON CONFLICT clauses this is an error. Otherwise, use the
4308 ** explicitly specified behavior for the index.
4309 */
4313 }
4316 }
4317 }
4323 }
4325 }
4326 }
4327 }
4331 /* Link the new Index structure to its table and to the other
4332 ** in-memory database structures.
4333 */
4345 }
4346 }
4353 }
4355 }
4357 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
4358 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
4359 ** emit code to allocate the index rootpage on disk and make an entry for
4360 ** the index in the sqlite_schema table and populate the index with
4361 ** content. But, do not do this if we are simply reading the sqlite_schema
4362 ** table to parse the schema, or if this index is the PRIMARY KEY index
4363 ** of a WITHOUT ROWID table.
4364 **
4365 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
4366 ** or UNIQUE index in a CREATE TABLE statement. Since the table
4367 ** has just been created, it contains no data and the index initialization
4368 ** step can be skipped.
4369 */
4380 /* Create the rootpage for the index using CreateIndex. But before
4381 ** doing so, code a Noop instruction and store its address in
4382 ** Index.tnum. This is required in case this index is actually a
4383 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
4384 ** that case the convertToWithoutRowidTable() routine will replace
4385 ** the Noop with a Goto to jump over the VDBE code generated below. */
4389 /* Gather the complete text of the CREATE INDEX statement into
4390 ** the zStmt variable
4391 */
4396 /* A named index with an explicit CREATE INDEX statement */
4400 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
4401 /* zStmt = sqlite3MPrintf(""); */
4403 }
4405 /* Add an entry in sqlite_schema for this index
4406 */
4412 iMem,
4413 zStmt
4414 );
4417 /* Fill the index with data and reparse the schema. Code an OP_Expire
4418 ** to invalidate all pre-compiled statements.
4419 */
4426 }
4429 }
4430 }
4435 }
4440 }
4442 /* Clean up before exiting */
4443 exit_create_index:
4446 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
4447 ** The list was already ordered when this routine was entered, so at this
4448 ** point at most a single index (the newly added index) will be out of
4449 ** order. So we have to reorder at most one index. */
4460 }
4462 }
4463 #ifdef SQLITE_DEBUG
4464 /* Verify that all REPLACE indexes really are now at the end
4465 ** of the index list. In other words, no other index type ever
4466 ** comes after a REPLACE index on the list. */
4471 }
4472 #endif
4473 }
4478 }
4480 /*
4481 ** Fill the Index.aiRowEst[] array with default information - information
4482 ** to be used when we have not run the ANALYZE command.
4483 **
4484 ** aiRowEst[0] is supposed to contain the number of elements in the index.
4485 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
4486 ** number of rows in the table that match any particular value of the
4487 ** first column of the index. aiRowEst[2] is an estimate of the number
4488 ** of rows that match any particular combination of the first 2 columns
4489 ** of the index. And so forth. It must always be the case that
4490 *
4491 ** aiRowEst[N]<=aiRowEst[N-1]
4492 ** aiRowEst[N]>=1
4493 **
4494 ** Apart from that, we have little to go on besides intuition as to
4495 ** how aiRowEst[] should be initialized. The numbers generated here
4496 ** are based on typical values found in actual indices.
4497 */
4499 /* 10, 9, 8, 7, 6 */
4502 LogEst x;
4506 /* Indexes with default row estimates should not have stat1 data */
4509 /* Set the first entry (number of rows in the index) to the estimated
4510 ** number of rows in the table, or half the number of rows in the table
4511 ** for a partial index.
4512 **
4513 ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
4514 ** table but other parts we are having to guess at, then do not let the
4515 ** estimated number of rows in the table be less than 1000 (LogEst 99).
4516 ** Failure to do this can cause the indexes for which we do not have
4517 ** stat1 data to be ignored by the query planner.
4518 */
4523 }
4527 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
4528 ** 6 and each subsequent value (if any) is 5. */
4532 }
4536 }
4538 /*
4539 ** This routine will drop an existing named index. This routine
4540 ** implements the DROP INDEX statement.
4541 */
4551 }
4555 }
4563 }
4566 }
4571 }
4573 #ifndef SQLITE_OMIT_AUTHORIZATION
4574 {
4581 }
4585 }
4586 }
4587 #endif
4589 /* Generate code to remove the index and from the schema table */
4596 );
4601 }
4603 exit_drop_index:
4605 }
4607 /*
4608 ** pArray is a pointer to an array of objects. Each object in the
4609 ** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
4610 ** to extend the array so that there is space for a new object at the end.
4611 **
4612 ** When this function is called, *pnEntry contains the current size of
4613 ** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
4614 ** in total).
4615 **
4616 ** If the realloc() is successful (i.e. if no OOM condition occurs), the
4617 ** space allocated for the new object is zeroed, *pnEntry updated to
4618 ** reflect the new size of the array and a pointer to the new allocation
4619 ** returned. *pIdx is set to the index of the new array entry in this case.
4620 **
4621 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
4622 ** unchanged and a copy of pArray returned.
4623 */
4630 ){
4639 }
4641 }
4646 }
4648 /*
4649 ** Append a new element to the given IdList. Create a new IdList if
4650 ** need be.
4651 **
4652 ** A new IdList is returned, or NULL if malloc() fails.
4653 */
4660 }
4662 db,
4666 &i
4667 );
4671 }
4675 }
4677 }
4679 /*
4680 ** Delete an IdList.
4681 */
4687 }
4690 }
4692 /*
4693 ** Return the index in pList of the identifier named zId. Return -1
4694 ** if not found.
4695 */
4701 }
4703 }
4705 /*
4706 ** Maximum size of a SrcList object.
4707 ** The SrcList object is used to represent the FROM clause of a
4708 ** SELECT statement, and the query planner cannot deal with more
4709 ** than 64 tables in a join. So any value larger than 64 here
4710 ** is sufficient for most uses. Smaller values, like say 10, are
4711 ** appropriate for small and memory-limited applications.
4712 */
4713 #ifndef SQLITE_MAX_SRCLIST
4714 # define SQLITE_MAX_SRCLIST 200
4715 #endif
4717 /*
4718 ** Expand the space allocated for the given SrcList object by
4719 ** creating nExtra new slots beginning at iStart. iStart is zero based.
4720 ** New slots are zeroed.
4721 **
4722 ** For example, suppose a SrcList initially contains two entries: A,B.
4723 ** To append 3 new entries onto the end, do this:
4724 **
4725 ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
4726 **
4727 ** After the call above it would contain: A, B, nil, nil, nil.
4728 ** If the iStart argument had been 1 instead of 2, then the result
4729 ** would have been: A, nil, nil, nil, B. To prepend the new slots,
4730 ** the iStart value would be 0. The result then would
4731 ** be: nil, nil, nil, A, B.
4732 **
4733 ** If a memory allocation fails or the SrcList becomes too large, leave
4734 ** the original SrcList unchanged, return NULL, and leave an error message
4735 ** in pParse.
4736 */
4742 ){
4745 /* Sanity checking on calling parameters */
4751 /* Allocate additional space if needed */
4759 SQLITE_MAX_SRCLIST);
4761 }
4768 }
4771 }
4773 /* Move existing slots that come after the newly inserted slots
4774 ** out of the way */
4777 }
4780 /* Zero the newly allocated slots */
4784 }
4786 /* Return a pointer to the enlarged SrcList */
4788 }
4791 /*
4792 ** Append a new table name to the given SrcList. Create a new SrcList if
4793 ** need be. A new entry is created in the SrcList even if pTable is NULL.
4794 **
4795 ** A SrcList is returned, or NULL if there is an OOM error or if the
4796 ** SrcList grows to large. The returned
4797 ** SrcList might be the same as the SrcList that was input or it might be
4798 ** a new one. If an OOM error does occurs, then the prior value of pList
4799 ** that is input to this routine is automatically freed.
4800 **
4801 ** If pDatabase is not null, it means that the table has an optional
4802 ** database name prefix. Like this: "database.table". The pDatabase
4803 ** points to the table name and the pTable points to the database name.
4804 ** The SrcList.a[].zName field is filled with the table name which might
4805 ** come from pTable (if pDatabase is NULL) or from pDatabase.
4806 ** SrcList.a[].zDatabase is filled with the database name from pTable,
4807 ** or with NULL if no database is specified.
4808 **
4809 ** In other words, if call like this:
4810 **
4811 ** sqlite3SrcListAppend(D,A,B,0);
4812 **
4813 ** Then B is a table name and the database name is unspecified. If called
4814 ** like this:
4815 **
4816 ** sqlite3SrcListAppend(D,A,B,C);
4817 **
4818 ** Then C is the table name and B is the database name. If C is defined
4819 ** then so is B. In other words, we never have a case where:
4820 **
4821 ** sqlite3SrcListAppend(D,A,0,C);
4822 **
4823 ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
4824 ** before being added to the SrcList.
4825 */
4831 ){
4852 }
4853 }
4857 }
4864 }
4866 }
4868 /*
4869 ** Assign VdbeCursor index numbers to all tables in a SrcList
4870 */
4881 }
4882 }
4883 }
4884 }
4886 /*
4887 ** Delete an entire SrcList including all its substructure.
4888 */
4903 }
4905 }
4907 /*
4908 ** This routine is called by the parser to add a new term to the
4909 ** end of a growing FROM clause. The "p" parameter is the part of
4910 ** the FROM clause that has already been constructed. "p" is NULL
4911 ** if this is the first term of the FROM clause. pTable and pDatabase
4912 ** are the name of the table and database named in the FROM clause term.
4913 ** pDatabase is NULL if the database name qualifier is missing - the
4914 ** usual case. If the term has an alias, then pAlias points to the
4915 ** alias token. If the term is a subquery, then pSubquery is the
4916 ** SELECT statement that the subquery encodes. The pTable and
4917 ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
4918 ** parameters are the content of the ON and USING clauses.
4919 **
4920 ** Return a new SrcList which encodes is the FROM with the new
4921 ** term added.
4922 */
4932 ){
4938 );
4940 }
4944 }
4952 }
4956 }
4962 append_from_error:
4968 }
4970 /*
4971 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
4972 ** element of the source-list passed as the second argument.
4973 */
4984 /* A "NOT INDEXED" clause was supplied. See parse.y
4985 ** construct "indexed_opt" for details. */
4991 }
4992 }
4993 }
4995 /*
4996 ** Append the contents of SrcList p2 to SrcList p1 and return the resulting
4997 ** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
4998 ** are deleted by this function.
4999 */
5010 }
5011 }
5013 }
5015 /*
5016 ** Add the list of function arguments to the SrcList entry for a
5017 ** table-valued-function.
5018 */
5029 }
5030 }
5032 /*
5033 ** When building up a FROM clause in the parser, the join operator
5034 ** is initially attached to the left operand. But the code generator
5035 ** expects the join operator to be on the right operand. This routine
5036 ** Shifts all join operators from left to right for an entire FROM
5037 ** clause.
5038 **
5039 ** Example: Suppose the join is like this:
5040 **
5041 ** A natural cross join B
5042 **
5043 ** The operator is "natural cross join". The A and B operands are stored
5044 ** in p->a[0] and p->a[1], respectively. The parser initially stores the
5045 ** operator with A. This routine shifts that operator over to B.
5046 */
5052 }
5054 }
5055 }
5057 /*
5058 ** Generate VDBE code for a BEGIN statement.
5059 */
5070 }
5083 }
5086 }
5087 }
5089 }
5091 /*
5092 ** Generate VDBE code for a COMMIT or ROLLBACK statement.
5093 ** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
5094 ** code is generated for a COMMIT.
5095 */
5107 }
5111 }
5112 }
5114 /*
5115 ** This function is called by the parser when it parses a command to create,
5116 ** release or rollback an SQL savepoint.
5117 */
5122 #ifndef SQLITE_OMIT_AUTHORIZATION
5125 #endif
5129 }
5131 }
5132 }
5134 /*
5135 ** Make sure the TEMP database is open and available for use. Return
5136 ** the number of errors. Leave any error messages in the pParse structure.
5137 */
5144 SQLITE_OPEN_READWRITE |
5145 SQLITE_OPEN_CREATE |
5146 SQLITE_OPEN_EXCLUSIVE |
5147 SQLITE_OPEN_DELETEONCLOSE |
5148 SQLITE_OPEN_TEMP_DB;
5156 }
5162 }
5163 }
5165 }
5167 /*
5168 ** Record the fact that the schema cookie will need to be verified
5169 ** for database iDb. The code to actually verify the schema cookie
5170 ** will occur at the end of the top-level VDBE and will be generated
5171 ** later, by sqlite3FinishCoding().
5172 */
5182 }
5183 }
5184 }
5187 }
5190 /*
5191 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
5192 ** attached database. Otherwise, invoke it for the database named zDb only.
5193 */
5201 }
5202 }
5203 }
5205 /*
5206 ** Generate VDBE code that prepares for doing an operation that
5207 ** might change the database.
5208 **
5209 ** This routine starts a new transaction if we are not already within
5210 ** a transaction. If we are already within a transaction, then a checkpoint
5211 ** is set if the setStatement parameter is true. A checkpoint should
5212 ** be set for operations that might fail (due to a constraint) part of
5213 ** the way through and which will need to undo some writes without having to
5214 ** rollback the whole transaction. For operations where all constraints
5215 ** can be checked before any changes are made to the database, it is never
5216 ** necessary to undo a write and the checkpoint should not be set.
5217 */
5223 }
5225 /*
5226 ** Indicate that the statement currently under construction might write
5227 ** more than one entry (example: deleting one row then inserting another,
5228 ** inserting multiple rows in a table, or inserting a row and index entries.)
5229 ** If an abort occurs after some of these writes have completed, then it will
5230 ** be necessary to undo the completed writes.
5231 */
5235 }
5237 /*
5238 ** The code generator calls this routine if is discovers that it is
5239 ** possible to abort a statement prior to completion. In order to
5240 ** perform this abort without corrupting the database, we need to make
5241 ** sure that the statement is protected by a statement transaction.
5242 **
5243 ** Technically, we only need to set the mayAbort flag if the
5244 ** isMultiWrite flag was previously set. There is a time dependency
5245 ** such that the abort must occur after the multiwrite. This makes
5246 ** some statements involving the REPLACE conflict resolution algorithm
5247 ** go a little faster. But taking advantage of this time dependency
5248 ** makes it more difficult to prove that the code is correct (in
5249 ** particular, it prevents us from writing an effective
5250 ** implementation of sqlite3AssertMayAbort()) and so we have chosen
5251 ** to take the safe route and skip the optimization.
5252 */
5256 }
5258 /*
5259 ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
5260 ** error. The onError parameter determines which (if any) of the statement
5261 ** and/or current transaction is rolled back.
5262 */
5269 u8 p5Errmsg /* P5_ErrMsg type */
5270 ){
5277 }
5280 }
5282 /*
5283 ** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
5284 */
5289 ){
5292 StrAccum errMsg;
5308 }
5309 }
5315 }
5318 /*
5319 ** Code an OP_Halt due to non-unique rowid.
5320 */
5325 ){
5335 }
5337 P5_ConstraintUnique);
5338 }
5340 /*
5341 ** Check to see if pIndex uses the collating sequence pColl. Return
5342 ** true if it does and false if it does not.
5343 */
5344 #ifndef SQLITE_OMIT_REINDEX
5353 }
5354 }
5356 }
5357 #endif
5359 /*
5360 ** Recompute all indices of pTab that use the collating sequence pColl.
5361 ** If pColl==0 then recompute all indices of pTab.
5362 */
5363 #ifndef SQLITE_OMIT_REINDEX
5373 }
5374 }
5375 }
5376 }
5377 #endif
5379 /*
5380 ** Recompute all indices of all tables in all databases where the
5381 ** indices use the collating sequence pColl. If pColl==0 then recompute
5382 ** all indices everywhere.
5383 */
5384 #ifndef SQLITE_OMIT_REINDEX
5398 }
5399 }
5400 }
5401 #endif
5403 /*
5404 ** Generate code for the REINDEX command.
5405 **
5406 ** REINDEX -- 1
5407 ** REINDEX <collation> -- 2
5408 ** REINDEX ?<database>.?<tablename> -- 3
5409 ** REINDEX ?<database>.?<indexname> -- 4
5410 **
5411 ** Form 1 causes all indices in all attached databases to be rebuilt.
5412 ** Form 2 rebuilds all indices in all databases that use the named
5413 ** collating function. Forms 3 and 4 rebuild the named index or all
5414 ** indices associated with the named table.
5415 */
5416 #ifndef SQLITE_OMIT_REINDEX
5427 /* Read the database schema. If an error occurs, leave an error message
5428 ** and code in pParse and return NULL. */
5431 }
5446 }
5448 }
5459 }
5466 }
5468 }
5469 #endif
5471 /*
5472 ** Return a KeyInfo structure that is appropriate for the given Index.
5473 **
5474 ** The caller should invoke sqlite3KeyInfoUnref() on the returned object
5475 ** when it has finished using it.
5476 */
5487 }
5496 }
5500 /* Deactivate the index because it contains an unknown collating
5501 ** sequence. The only way to reactive the index is to reload the
5502 ** schema. Adding the missing collating sequence later does not
5503 ** reactive the index. The application had the chance to register
5504 ** the missing index using the collation-needed callback. For
5505 ** simplicity, SQLite will not give the application a second chance.
5506 */
5509 }
5512 }
5513 }
5515 }
5517 #ifndef SQLITE_OMIT_CTE
5518 /*
5519 ** Create a new CTE object
5520 */
5526 u8 eM10d /* The MATERIALIZED flag */
5527 ){
5542 }
5544 }
5546 /*
5547 ** Clear information from a Cte object, but do not deallocate storage
5548 ** for the object itself.
5549 */
5555 }
5557 /*
5558 ** Free the contents of the CTE object passed as the second argument.
5559 */
5564 }
5566 /*
5567 ** This routine is invoked once per CTE by the parser while parsing a
5568 ** WITH clause. The CTE described by teh third argument is added to
5569 ** the WITH clause of the second argument. If the second argument is
5570 ** NULL, then a new WITH argument is created.
5571 */
5576 ){
5583 }
5585 /* Check that the CTE name is unique within this WITH clause. If
5586 ** not, store an error in the Parse structure. */
5593 }
5594 }
5595 }
5602 }
5611 }
5614 }
5616 /*
5617 ** Free the contents of the With object passed as the second argument.
5618 */
5624 }
5626 }
5627 }