blob: 746bf4ed5020c4508e88f7475441186f211762bb [file] [log] [blame]
drh75897232000-05-29 14:26:00 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drh75897232000-05-29 14:26:00 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh75897232000-05-29 14:26:00 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drh75897232000-05-29 14:26:00 +000010**
11*************************************************************************
drhb19a2bc2001-09-16 00:13:26 +000012** 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:
drh75897232000-05-29 14:26:00 +000015**
drhbed86902000-06-02 13:27:59 +000016** CREATE TABLE
17** DROP TABLE
18** CREATE INDEX
19** DROP INDEX
drh832508b2002-03-02 17:04:07 +000020** creating ID lists
drhb19a2bc2001-09-16 00:13:26 +000021** BEGIN TRANSACTION
22** COMMIT
23** ROLLBACK
drh75897232000-05-29 14:26:00 +000024*/
25#include "sqliteInt.h"
26
danielk1977c00da102006-01-07 13:21:04 +000027#ifndef SQLITE_OMIT_SHARED_CACHE
28/*
29** The TableLock structure is only used by the sqlite3TableLock() and
30** codeTableLocks() functions.
31*/
32struct TableLock {
drhe0a04a32016-12-16 01:00:21 +000033 int iDb; /* The database containing the table to be locked */
drhabc38152020-07-22 13:38:04 +000034 Pgno iTab; /* The root page of the table to be locked */
drhe0a04a32016-12-16 01:00:21 +000035 u8 isWriteLock; /* True for write lock. False for a read lock */
36 const char *zLockName; /* Name of the table */
danielk1977c00da102006-01-07 13:21:04 +000037};
38
39/*
drhd698bc12006-03-23 23:33:26 +000040** Record the fact that we want to lock a table at run-time.
danielk1977c00da102006-01-07 13:21:04 +000041**
drhd698bc12006-03-23 23:33:26 +000042** 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().
danielk1977c00da102006-01-07 13:21:04 +000048*/
drh94305062021-05-17 11:19:32 +000049static SQLITE_NOINLINE void lockTable(
drhd698bc12006-03-23 23:33:26 +000050 Parse *pParse, /* Parsing context */
51 int iDb, /* Index of the database containing the table to lock */
drhabc38152020-07-22 13:38:04 +000052 Pgno iTab, /* Root page number of the table to be locked */
drhd698bc12006-03-23 23:33:26 +000053 u8 isWriteLock, /* True for a write lock */
54 const char *zName /* Name of the table to be locked */
danielk1977c00da102006-01-07 13:21:04 +000055){
drh1d8f8922020-08-16 00:30:44 +000056 Parse *pToplevel;
danielk1977c00da102006-01-07 13:21:04 +000057 int i;
58 int nBytes;
59 TableLock *p;
drh8af73d42009-05-13 22:58:28 +000060 assert( iDb>=0 );
dan165921a2009-08-28 18:53:45 +000061
drh1d8f8922020-08-16 00:30:44 +000062 pToplevel = sqlite3ParseToplevel(pParse);
dan65a7cd12009-09-01 12:16:01 +000063 for(i=0; i<pToplevel->nTableLock; i++){
64 p = &pToplevel->aTableLock[i];
danielk1977c00da102006-01-07 13:21:04 +000065 if( p->iDb==iDb && p->iTab==iTab ){
66 p->isWriteLock = (p->isWriteLock || isWriteLock);
67 return;
68 }
69 }
70
dan65a7cd12009-09-01 12:16:01 +000071 nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
72 pToplevel->aTableLock =
73 sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
74 if( pToplevel->aTableLock ){
75 p = &pToplevel->aTableLock[pToplevel->nTableLock++];
danielk1977c00da102006-01-07 13:21:04 +000076 p->iDb = iDb;
77 p->iTab = iTab;
78 p->isWriteLock = isWriteLock;
drhe0a04a32016-12-16 01:00:21 +000079 p->zLockName = zName;
drhf3a65f72007-08-22 20:18:21 +000080 }else{
dan65a7cd12009-09-01 12:16:01 +000081 pToplevel->nTableLock = 0;
drh4a642b62016-02-05 01:55:27 +000082 sqlite3OomFault(pToplevel->db);
danielk1977c00da102006-01-07 13:21:04 +000083 }
84}
drh94305062021-05-17 11:19:32 +000085void sqlite3TableLock(
86 Parse *pParse, /* Parsing context */
87 int iDb, /* Index of the database containing the table to lock */
88 Pgno iTab, /* Root page number of the table to be locked */
89 u8 isWriteLock, /* True for a write lock */
90 const char *zName /* Name of the table to be locked */
91){
92 if( iDb==1 ) return;
93 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
94 lockTable(pParse, iDb, iTab, isWriteLock, zName);
95}
danielk1977c00da102006-01-07 13:21:04 +000096
97/*
98** Code an OP_TableLock instruction for each table locked by the
99** statement (configured by calls to sqlite3TableLock()).
100*/
101static void codeTableLocks(Parse *pParse){
102 int i;
drhf0b41742020-08-15 21:55:14 +0000103 Vdbe *pVdbe = pParse->pVdbe;
drh289a0c82020-08-15 22:23:00 +0000104 assert( pVdbe!=0 );
danielk1977c00da102006-01-07 13:21:04 +0000105
106 for(i=0; i<pParse->nTableLock; i++){
107 TableLock *p = &pParse->aTableLock[i];
108 int p1 = p->iDb;
drh6a9ad3d2008-04-02 16:29:30 +0000109 sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
drhe0a04a32016-12-16 01:00:21 +0000110 p->zLockName, P4_STATIC);
danielk1977c00da102006-01-07 13:21:04 +0000111 }
112}
113#else
114 #define codeTableLocks(x)
115#endif
116
drhe0bc4042002-06-25 01:09:11 +0000117/*
drha7ab6d82014-07-21 15:44:39 +0000118** 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
123int sqlite3DbMaskAllZero(yDbMask m){
124 int i;
125 for(i=0; i<sizeof(yDbMask); i++) if( m[i] ) return 0;
126 return 1;
127}
128#endif
129
130/*
drh75897232000-05-29 14:26:00 +0000131** This routine is called after a single SQL statement has been
drh80242052004-06-09 00:48:12 +0000132** 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.
drh75897232000-05-29 14:26:00 +0000136**
137** Note that if an error occurred, it might be the case that
138** no VDBE code was generated.
139*/
drh80242052004-06-09 00:48:12 +0000140void sqlite3FinishCoding(Parse *pParse){
drh9bb575f2004-09-06 17:24:11 +0000141 sqlite3 *db;
drh80242052004-06-09 00:48:12 +0000142 Vdbe *v;
drhb86ccfb2003-01-28 23:13:10 +0000143
danf78baaf2012-12-06 19:37:22 +0000144 assert( pParse->pToplevel==0 );
drh17435752007-08-16 04:30:38 +0000145 db = pParse->db;
drh205f48e2004-11-05 00:43:11 +0000146 if( pParse->nested ) return;
drhd99d2832015-04-17 15:58:33 +0000147 if( db->mallocFailed || pParse->nErr ){
148 if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;
149 return;
150 }
danielk197748d0d862005-02-01 03:09:52 +0000151
drh80242052004-06-09 00:48:12 +0000152 /* Begin by generating some termination code at the end of the
153 ** vdbe program
154 */
drh02c4aa32021-02-04 13:44:42 +0000155 v = pParse->pVdbe;
156 if( v==0 ){
157 if( db->init.busy ){
158 pParse->rc = SQLITE_DONE;
159 return;
160 }
161 v = sqlite3GetVdbe(pParse);
162 if( v==0 ) pParse->rc = SQLITE_ERROR;
drhc8af8792021-01-01 22:06:17 +0000163 }
danf3677212009-09-10 16:14:50 +0000164 assert( !pParse->isMultiWrite
165 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
drh80242052004-06-09 00:48:12 +0000166 if( v ){
drh381bdac2021-02-04 17:29:04 +0000167 if( pParse->bReturning ){
168 Returning *pReturning = pParse->u1.pReturning;
169 int addrRewind;
170 int i;
171 int reg;
172
drh7132f432021-10-20 12:52:12 +0000173 if( pReturning->nRetCol==0 ){
174 assert( CORRUPT_DB );
175 }else{
176 addrRewind =
177 sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
178 VdbeCoverage(v);
179 reg = pReturning->iRetReg;
180 for(i=0; i<pReturning->nRetCol; i++){
181 sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
182 }
183 sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);
184 sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
185 VdbeCoverage(v);
186 sqlite3VdbeJumpHere(v, addrRewind);
drh381bdac2021-02-04 17:29:04 +0000187 }
drh381bdac2021-02-04 17:29:04 +0000188 }
drh66a51672008-01-03 00:01:23 +0000189 sqlite3VdbeAddOp0(v, OP_Halt);
drh0e3d7472004-06-19 17:33:07 +0000190
drhb2445d52014-09-11 14:01:41 +0000191#if SQLITE_USER_AUTHENTICATION
192 if( pParse->nTableLock>0 && db->init.busy==0 ){
drh7883ecf2014-09-11 16:19:31 +0000193 sqlite3UserAuthInit(db);
drhb2445d52014-09-11 14:01:41 +0000194 if( db->auth.authLevel<UAUTH_User ){
drh7883ecf2014-09-11 16:19:31 +0000195 sqlite3ErrorMsg(pParse, "user not authenticated");
drh6ae3ab02016-08-23 14:42:15 +0000196 pParse->rc = SQLITE_AUTH_USER;
drh7883ecf2014-09-11 16:19:31 +0000197 return;
drhb2445d52014-09-11 14:01:41 +0000198 }
199 }
200#endif
201
drh0e3d7472004-06-19 17:33:07 +0000202 /* 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 */
drha7ab6d82014-07-21 15:44:39 +0000208 if( db->mallocFailed==0
209 && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)
210 ){
drhaceb31b2014-02-08 01:40:27 +0000211 int iDb, i;
212 assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
213 sqlite3VdbeJumpHere(v, 0);
drha7ab6d82014-07-21 15:44:39 +0000214 for(iDb=0; iDb<db->nDb; iDb++){
drh1d96cc62016-09-30 18:35:36 +0000215 Schema *pSchema;
drha7ab6d82014-07-21 15:44:39 +0000216 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
drhfb982642007-08-30 01:19:59 +0000217 sqlite3VdbeUsesBtree(v, iDb);
drh1d96cc62016-09-30 18:35:36 +0000218 pSchema = db->aDb[iDb].pSchema;
drhb22f7c82014-02-06 23:56:27 +0000219 sqlite3VdbeAddOp4Int(v,
220 OP_Transaction, /* Opcode */
221 iDb, /* P1 */
drha7ab6d82014-07-21 15:44:39 +0000222 DbMaskTest(pParse->writeMask,iDb), /* P2 */
drh1d96cc62016-09-30 18:35:36 +0000223 pSchema->schema_cookie, /* P3 */
224 pSchema->iGeneration /* P4 */
drhb22f7c82014-02-06 23:56:27 +0000225 );
226 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
dan076e0f92015-09-28 15:20:58 +0000227 VdbeComment((v,
228 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
drh80242052004-06-09 00:48:12 +0000229 }
danielk1977f9e7dda2006-06-16 16:08:53 +0000230#ifndef SQLITE_OMIT_VIRTUALTABLE
drhf30a9692013-11-15 01:10:18 +0000231 for(i=0; i<pParse->nVtabLock; i++){
232 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
233 sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
danielk1977f9e7dda2006-06-16 16:08:53 +0000234 }
drhf30a9692013-11-15 01:10:18 +0000235 pParse->nVtabLock = 0;
danielk1977f9e7dda2006-06-16 16:08:53 +0000236#endif
danielk1977c00da102006-01-07 13:21:04 +0000237
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 */
242 codeTableLocks(pParse);
drh0b9f50d2009-06-23 20:28:53 +0000243
244 /* Initialize any AUTOINCREMENT data structures required.
245 */
246 sqlite3AutoincrementBegin(pParse);
247
drh89636622020-06-07 17:33:18 +0000248 /* 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 */
drhf30a9692013-11-15 01:10:18 +0000255 if( pParse->pConstExpr ){
256 ExprList *pEL = pParse->pConstExpr;
drhaceb31b2014-02-08 01:40:27 +0000257 pParse->okConstFactor = 0;
drhf30a9692013-11-15 01:10:18 +0000258 for(i=0; i<pEL->nExpr; i++){
drh89636622020-06-07 17:33:18 +0000259 int iReg = pEL->a[i].u.iConstExprReg;
260 if( iReg>0 ){
261 sqlite3ExprCode(pParse, pEL->a[i].pExpr, iReg);
262 }
drhf30a9692013-11-15 01:10:18 +0000263 }
264 }
265
drh381bdac2021-02-04 17:29:04 +0000266 if( pParse->bReturning ){
267 Returning *pRet = pParse->u1.pReturning;
drh7132f432021-10-20 12:52:12 +0000268 if( pRet->nRetCol==0 ){
269 assert( CORRUPT_DB );
270 }else{
271 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);
272 }
drh381bdac2021-02-04 17:29:04 +0000273 }
274
drh0b9f50d2009-06-23 20:28:53 +0000275 /* Finally, jump back to the beginning of the executable code. */
drh076e85f2015-09-03 13:46:12 +0000276 sqlite3VdbeGoto(v, 1);
drh80242052004-06-09 00:48:12 +0000277 }
drh71c697e2004-08-08 23:39:19 +0000278 }
279
drh80242052004-06-09 00:48:12 +0000280 /* Get the VDBE program ready for execution
281 */
drh126a6e22015-04-15 04:10:50 +0000282 if( v && pParse->nErr==0 && !db->mallocFailed ){
drh3492dd72009-09-14 23:47:24 +0000283 /* A minimum of one cursor is required if autoincrement is used
284 * See ticket [a696379c1f08866] */
drh04ab5862018-12-01 21:13:41 +0000285 assert( pParse->pAinc==0 || pParse->nTab>0 );
drh124c0b42011-06-01 18:15:55 +0000286 sqlite3VdbeMakeReady(v, pParse);
danielk1977441daf62005-02-01 03:46:43 +0000287 pParse->rc = SQLITE_DONE;
drhe294da02010-02-25 23:44:15 +0000288 }else{
drh483750b2003-01-29 18:46:51 +0000289 pParse->rc = SQLITE_ERROR;
drh75897232000-05-29 14:26:00 +0000290 }
291}
292
293/*
drh205f48e2004-11-05 00:43:11 +0000294** 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
drh3edc9272021-08-04 13:42:12 +0000296** currently under construction. Notes:
drh205f48e2004-11-05 00:43:11 +0000297**
drh3edc9272021-08-04 13:42:12 +0000298** * 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.
drh205f48e2004-11-05 00:43:11 +0000305*/
306void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
307 va_list ap;
308 char *zSql;
drhfb45d8c2008-07-08 00:06:49 +0000309 char *zErrMsg = 0;
drh633e6d52008-07-28 19:34:53 +0000310 sqlite3 *db = pParse->db;
drh3edc9272021-08-04 13:42:12 +0000311 u32 savedDbFlags = db->mDbFlags;
drhcd9af602016-09-30 22:24:29 +0000312 char saveBuf[PARSE_TAIL_SZ];
drhf1974842004-11-05 03:56:00 +0000313
drh205f48e2004-11-05 00:43:11 +0000314 if( pParse->nErr ) return;
315 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
316 va_start(ap, zFormat);
drh633e6d52008-07-28 19:34:53 +0000317 zSql = sqlite3VMPrintf(db, zFormat, ap);
drh205f48e2004-11-05 00:43:11 +0000318 va_end(ap);
drh73c42a12004-11-20 18:13:10 +0000319 if( zSql==0 ){
drh480c5722019-02-22 16:18:12 +0000320 /* 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 */
323 if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
drha2b68062019-03-28 04:03:17 +0000324 pParse->nErr++;
drh480c5722019-02-22 16:18:12 +0000325 return;
drh73c42a12004-11-20 18:13:10 +0000326 }
drh205f48e2004-11-05 00:43:11 +0000327 pParse->nested++;
drhcd9af602016-09-30 22:24:29 +0000328 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
329 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
drh3edc9272021-08-04 13:42:12 +0000330 db->mDbFlags |= DBFLAG_PreferBuiltin;
drhfb45d8c2008-07-08 00:06:49 +0000331 sqlite3RunParser(pParse, zSql, &zErrMsg);
drh3edc9272021-08-04 13:42:12 +0000332 db->mDbFlags = savedDbFlags;
drh633e6d52008-07-28 19:34:53 +0000333 sqlite3DbFree(db, zErrMsg);
334 sqlite3DbFree(db, zSql);
drhcd9af602016-09-30 22:24:29 +0000335 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
drh205f48e2004-11-05 00:43:11 +0000336 pParse->nested--;
337}
338
drhd4530972014-09-09 14:47:53 +0000339#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*/
344int sqlite3UserAuthTable(const char *zTable){
345 return sqlite3_stricmp(zTable, "sqlite_user")==0;
346}
347#endif
348
drh205f48e2004-11-05 00:43:11 +0000349/*
danielk19778a414492004-06-29 08:59:35 +0000350** 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.
drha69d9162003-04-17 22:57:53 +0000353**
danielk19778a414492004-06-29 08:59:35 +0000354** 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.
drhf26e09c2003-05-31 16:21:12 +0000358**
danielk19774adee202004-05-08 08:23:19 +0000359** See also sqlite3LocateTable().
drh75897232000-05-29 14:26:00 +0000360*/
drh9bb575f2004-09-06 17:24:11 +0000361Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
drhd24cc422003-03-27 12:51:24 +0000362 Table *p = 0;
363 int i;
drh9ca95732014-10-24 00:35:58 +0000364
drh21206082011-04-04 18:22:02 +0000365 /* All mutexes are required for schema access. Make sure we hold them. */
366 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
drhd4530972014-09-09 14:47:53 +0000367#if SQLITE_USER_AUTHENTICATION
368 /* Only the admin user is allowed to know that the sqlite_user table
369 ** exists */
drhe933b832014-09-10 17:34:28 +0000370 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
371 return 0;
372 }
drhd4530972014-09-09 14:47:53 +0000373#endif
drhb2eb7e42020-05-16 21:01:00 +0000374 if( zDatabase ){
375 for(i=0; i<db->nDb; i++){
376 if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break;
377 }
378 if( i>=db->nDb ){
379 /* No match against the official names. But always match "main"
380 ** to schema 0 as a legacy fallback. */
381 if( sqlite3StrICmp(zDatabase,"main")==0 ){
382 i = 0;
383 }else{
384 return 0;
drhe0a04a32016-12-16 01:00:21 +0000385 }
drh69c33822016-08-18 14:33:11 +0000386 }
drhb2eb7e42020-05-16 21:01:00 +0000387 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
drh346a70c2020-06-15 20:27:35 +0000388 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
389 if( i==1 ){
drha7647092020-06-20 03:43:46 +0000390 if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0
391 || sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0
392 || sqlite3StrICmp(zName+7, &DFLT_SCHEMA_TABLE[7])==0
drh346a70c2020-06-15 20:27:35 +0000393 ){
394 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
395 DFLT_TEMP_SCHEMA_TABLE);
396 }
397 }else{
drha7647092020-06-20 03:43:46 +0000398 if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
drh346a70c2020-06-15 20:27:35 +0000399 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,
400 DFLT_SCHEMA_TABLE);
401 }
402 }
drhb2eb7e42020-05-16 21:01:00 +0000403 }
404 }else{
405 /* Match against TEMP first */
406 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
407 if( p ) return p;
408 /* The main database is second */
409 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
410 if( p ) return p;
411 /* Attached databases are in order of attachment */
412 for(i=2; i<db->nDb; i++){
413 assert( sqlite3SchemaMutexHeld(db, i, 0) );
414 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
415 if( p ) break;
416 }
drh346a70c2020-06-15 20:27:35 +0000417 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
drha7647092020-06-20 03:43:46 +0000418 if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
drh346a70c2020-06-15 20:27:35 +0000419 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, DFLT_SCHEMA_TABLE);
drha7647092020-06-20 03:43:46 +0000420 }else if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 ){
drh346a70c2020-06-15 20:27:35 +0000421 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
422 DFLT_TEMP_SCHEMA_TABLE);
423 }
424 }
drhd24cc422003-03-27 12:51:24 +0000425 }
drhb2eb7e42020-05-16 21:01:00 +0000426 return p;
drh75897232000-05-29 14:26:00 +0000427}
428
429/*
danielk19778a414492004-06-29 08:59:35 +0000430** 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.
drha69d9162003-04-17 22:57:53 +0000434**
danielk19778a414492004-06-29 08:59:35 +0000435** The difference between this routine and sqlite3FindTable() is that this
436** routine leaves an error message in pParse->zErrMsg where
437** sqlite3FindTable() does not.
drha69d9162003-04-17 22:57:53 +0000438*/
drhca424112008-01-25 15:04:48 +0000439Table *sqlite3LocateTable(
440 Parse *pParse, /* context in which to report errors */
drh4d249e62016-06-10 22:49:01 +0000441 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
drhca424112008-01-25 15:04:48 +0000442 const char *zName, /* Name of the table we are looking for */
443 const char *zDbase /* Name of the database. Might be NULL */
444){
drha69d9162003-04-17 22:57:53 +0000445 Table *p;
drhb2c85592018-04-25 12:01:45 +0000446 sqlite3 *db = pParse->db;
drhf26e09c2003-05-31 16:21:12 +0000447
danielk19778a414492004-06-29 08:59:35 +0000448 /* Read the database schema. If an error occurs, leave an error message
449 ** and code in pParse and return NULL. */
drhb2c85592018-04-25 12:01:45 +0000450 if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
451 && SQLITE_OK!=sqlite3ReadSchema(pParse)
452 ){
danielk19778a414492004-06-29 08:59:35 +0000453 return 0;
454 }
455
drhb2c85592018-04-25 12:01:45 +0000456 p = sqlite3FindTable(db, zName, zDbase);
drha69d9162003-04-17 22:57:53 +0000457 if( p==0 ){
drhd2975922015-08-29 17:22:33 +0000458#ifndef SQLITE_OMIT_VIRTUALTABLE
drh9196c812018-11-05 16:38:10 +0000459 /* 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. */
danbb0eec42021-04-26 14:09:48 +0000462 if( pParse->disableVtab==0 && db->init.busy==0 ){
dan1ea04432018-12-21 19:29:11 +0000463 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
464 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
465 pMod = sqlite3PragmaVtabRegister(db, zName);
466 }
467 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
danbd24e8f2021-07-08 18:29:25 +0000468 testcase( pMod->pEpoTab==0 );
dan1ea04432018-12-21 19:29:11 +0000469 return pMod->pEpoTab;
470 }
drh51be3872015-08-19 02:32:25 +0000471 }
472#endif
dan1ea04432018-12-21 19:29:11 +0000473 if( flags & LOCATE_NOERR ) return 0;
474 pParse->checkSchema = 1;
475 }else if( IsVirtual(p) && pParse->disableVtab ){
476 p = 0;
477 }
478
479 if( p==0 ){
480 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
481 if( zDbase ){
482 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
483 }else{
484 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
drha69d9162003-04-17 22:57:53 +0000485 }
drh1bb89e92021-04-19 18:03:52 +0000486 }else{
487 assert( HasRowid(p) || p->iPKey<0 );
drha69d9162003-04-17 22:57:53 +0000488 }
danfab1d402015-11-26 15:51:55 +0000489
drha69d9162003-04-17 22:57:53 +0000490 return p;
491}
492
493/*
dan41fb5cd2012-10-04 19:33:00 +0000494** 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*/
502Table *sqlite3LocateTableItem(
503 Parse *pParse,
drh4d249e62016-06-10 22:49:01 +0000504 u32 flags,
drh76012942021-02-21 21:04:54 +0000505 SrcItem *p
dan41fb5cd2012-10-04 19:33:00 +0000506){
507 const char *zDb;
drhcd1499f2021-05-20 00:44:04 +0000508 assert( p->pSchema==0 || p->zDatabase==0 );
dan41fb5cd2012-10-04 19:33:00 +0000509 if( p->pSchema ){
510 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
drh69c33822016-08-18 14:33:11 +0000511 zDb = pParse->db->aDb[iDb].zDbSName;
dan41fb5cd2012-10-04 19:33:00 +0000512 }else{
513 zDb = p->zDatabase;
514 }
drh4d249e62016-06-10 22:49:01 +0000515 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
dan41fb5cd2012-10-04 19:33:00 +0000516}
517
518/*
drha69d9162003-04-17 22:57:53 +0000519** Locate the in-memory structure that describes
520** a particular index given the name of that index
521** and the name of the database that contains the index.
drhf57b3392001-10-08 13:22:32 +0000522** Return NULL if not found.
drhf26e09c2003-05-31 16:21:12 +0000523**
524** If zDatabase is 0, all databases are searched for the
525** table and the first matching index is returned. (No checking
526** for duplicate index names is done.) The search order is
527** TEMP first, then MAIN, then any auxiliary databases added
528** using the ATTACH command.
drh75897232000-05-29 14:26:00 +0000529*/
drh9bb575f2004-09-06 17:24:11 +0000530Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
drhd24cc422003-03-27 12:51:24 +0000531 Index *p = 0;
532 int i;
drh21206082011-04-04 18:22:02 +0000533 /* All mutexes are required for schema access. Make sure we hold them. */
534 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
danielk197753c0f742005-03-29 03:10:59 +0000535 for(i=OMIT_TEMPDB; i<db->nDb; i++){
drh812d7a22003-03-27 13:50:00 +0000536 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
danielk1977e501b892006-01-09 06:29:47 +0000537 Schema *pSchema = db->aDb[j].pSchema;
drh04491712009-05-13 17:21:13 +0000538 assert( pSchema );
dan465c2b82020-03-21 15:10:40 +0000539 if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
drh21206082011-04-04 18:22:02 +0000540 assert( sqlite3SchemaMutexHeld(db, j, 0) );
drhacbcb7e2014-08-21 20:26:37 +0000541 p = sqlite3HashFind(&pSchema->idxHash, zName);
drhd24cc422003-03-27 12:51:24 +0000542 if( p ) break;
543 }
drh74e24cd2002-01-09 03:19:59 +0000544 return p;
drh75897232000-05-29 14:26:00 +0000545}
546
547/*
drh956bc922004-07-24 17:38:29 +0000548** Reclaim the memory used by an index
549*/
dancf8f2892018-08-09 20:47:01 +0000550void sqlite3FreeIndex(sqlite3 *db, Index *p){
drh92aa5ea2009-09-11 14:05:06 +0000551#ifndef SQLITE_OMIT_ANALYZE
dand46def72010-07-24 11:28:28 +0000552 sqlite3DeleteIndexSamples(db, p);
drh92aa5ea2009-09-11 14:05:06 +0000553#endif
drh1fe05372013-07-31 18:12:26 +0000554 sqlite3ExprDelete(db, p->pPartIdxWhere);
drh1f9ca2c2015-08-25 16:57:52 +0000555 sqlite3ExprListDelete(db, p->aColExpr);
drh633e6d52008-07-28 19:34:53 +0000556 sqlite3DbFree(db, p->zColAff);
mistachkin5905f862015-12-31 19:04:42 +0000557 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
drh175b8f02019-08-08 15:24:17 +0000558#ifdef SQLITE_ENABLE_STAT4
drh75b170b2014-10-04 00:07:44 +0000559 sqlite3_free(p->aiRowEst);
560#endif
drh633e6d52008-07-28 19:34:53 +0000561 sqlite3DbFree(db, p);
drh956bc922004-07-24 17:38:29 +0000562}
563
564/*
drhc96d8532005-05-03 12:30:33 +0000565** For the index called zIdxName which is found in the database iDb,
566** unlike that index from its Table then remove the index from
567** the index hash table and free all memory structures associated
568** with the index.
drh5e00f6c2001-09-13 13:46:56 +0000569*/
drh9bb575f2004-09-06 17:24:11 +0000570void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
drh956bc922004-07-24 17:38:29 +0000571 Index *pIndex;
drh21206082011-04-04 18:22:02 +0000572 Hash *pHash;
drh956bc922004-07-24 17:38:29 +0000573
drh21206082011-04-04 18:22:02 +0000574 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
575 pHash = &db->aDb[iDb].pSchema->idxHash;
drhacbcb7e2014-08-21 20:26:37 +0000576 pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
drh22645842011-03-24 01:34:03 +0000577 if( ALWAYS(pIndex) ){
drh956bc922004-07-24 17:38:29 +0000578 if( pIndex->pTable->pIndex==pIndex ){
579 pIndex->pTable->pIndex = pIndex->pNext;
580 }else{
581 Index *p;
drh04491712009-05-13 17:21:13 +0000582 /* Justification of ALWAYS(); The index must be on the list of
583 ** indices. */
584 p = pIndex->pTable->pIndex;
585 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
586 if( ALWAYS(p && p->pNext==pIndex) ){
drh956bc922004-07-24 17:38:29 +0000587 p->pNext = pIndex->pNext;
588 }
drh5e00f6c2001-09-13 13:46:56 +0000589 }
dancf8f2892018-08-09 20:47:01 +0000590 sqlite3FreeIndex(db, pIndex);
drh5e00f6c2001-09-13 13:46:56 +0000591 }
drh8257aa82017-07-26 19:59:13 +0000592 db->mDbFlags |= DBFLAG_SchemaChange;
drh5e00f6c2001-09-13 13:46:56 +0000593}
594
595/*
drh81028a42012-05-15 18:28:27 +0000596** Look through the list of open database files in db->aDb[] and if
597** any have been closed, remove them from the list. Reallocate the
598** db->aDb[] structure to a smaller size, if possible.
drh1c2d8412003-03-31 00:30:47 +0000599**
drh81028a42012-05-15 18:28:27 +0000600** Entry 0 (the "main" database) and entry 1 (the "temp" database)
601** are never candidates for being collapsed.
drh74e24cd2002-01-09 03:19:59 +0000602*/
drh81028a42012-05-15 18:28:27 +0000603void sqlite3CollapseDatabaseArray(sqlite3 *db){
drh1c2d8412003-03-31 00:30:47 +0000604 int i, j;
drh1c2d8412003-03-31 00:30:47 +0000605 for(i=j=2; i<db->nDb; i++){
drh4d189ca2004-02-12 18:46:38 +0000606 struct Db *pDb = &db->aDb[i];
607 if( pDb->pBt==0 ){
drh69c33822016-08-18 14:33:11 +0000608 sqlite3DbFree(db, pDb->zDbSName);
609 pDb->zDbSName = 0;
drh1c2d8412003-03-31 00:30:47 +0000610 continue;
611 }
612 if( j<i ){
drh8bf8dc92003-05-17 17:35:10 +0000613 db->aDb[j] = db->aDb[i];
drh1c2d8412003-03-31 00:30:47 +0000614 }
drh8bf8dc92003-05-17 17:35:10 +0000615 j++;
drh1c2d8412003-03-31 00:30:47 +0000616 }
drh1c2d8412003-03-31 00:30:47 +0000617 db->nDb = j;
618 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
619 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
drh633e6d52008-07-28 19:34:53 +0000620 sqlite3DbFree(db, db->aDb);
drh1c2d8412003-03-31 00:30:47 +0000621 db->aDb = db->aDbStatic;
622 }
drhe0bc4042002-06-25 01:09:11 +0000623}
624
625/*
drh81028a42012-05-15 18:28:27 +0000626** Reset the schema for the database at index iDb. Also reset the
drhdc6b41e2017-08-17 02:26:35 +0000627** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
628** Deferred resets may be run by calling with iDb<0.
drh81028a42012-05-15 18:28:27 +0000629*/
630void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
drhdc6b41e2017-08-17 02:26:35 +0000631 int i;
drh81028a42012-05-15 18:28:27 +0000632 assert( iDb<db->nDb );
633
drhdc6b41e2017-08-17 02:26:35 +0000634 if( iDb>=0 ){
635 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
636 DbSetProperty(db, iDb, DB_ResetWanted);
637 DbSetProperty(db, 1, DB_ResetWanted);
drhb2c85592018-04-25 12:01:45 +0000638 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
drh81028a42012-05-15 18:28:27 +0000639 }
drhdc6b41e2017-08-17 02:26:35 +0000640
641 if( db->nSchemaLock==0 ){
642 for(i=0; i<db->nDb; i++){
643 if( DbHasProperty(db, i, DB_ResetWanted) ){
644 sqlite3SchemaClear(db->aDb[i].pSchema);
645 }
646 }
647 }
drh81028a42012-05-15 18:28:27 +0000648}
649
650/*
651** Erase all schema information from all attached databases (including
652** "main" and "temp") for a single database connection.
653*/
654void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
655 int i;
656 sqlite3BtreeEnterAll(db);
657 for(i=0; i<db->nDb; i++){
658 Db *pDb = &db->aDb[i];
659 if( pDb->pSchema ){
dan63e50b92018-11-27 19:47:55 +0000660 if( db->nSchemaLock==0 ){
661 sqlite3SchemaClear(pDb->pSchema);
662 }else{
663 DbSetProperty(db, i, DB_ResetWanted);
664 }
drh81028a42012-05-15 18:28:27 +0000665 }
666 }
drhb2c85592018-04-25 12:01:45 +0000667 db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
drh81028a42012-05-15 18:28:27 +0000668 sqlite3VtabUnlockList(db);
669 sqlite3BtreeLeaveAll(db);
dan63e50b92018-11-27 19:47:55 +0000670 if( db->nSchemaLock==0 ){
671 sqlite3CollapseDatabaseArray(db);
672 }
drh81028a42012-05-15 18:28:27 +0000673}
674
675/*
drhe0bc4042002-06-25 01:09:11 +0000676** This routine is called when a commit occurs.
677*/
drh9bb575f2004-09-06 17:24:11 +0000678void sqlite3CommitInternalChanges(sqlite3 *db){
drh8257aa82017-07-26 19:59:13 +0000679 db->mDbFlags &= ~DBFLAG_SchemaChange;
drh74e24cd2002-01-09 03:19:59 +0000680}
681
682/*
drh79cf2b72021-07-31 20:30:41 +0000683** Set the expression associated with a column. This is usually
684** the DEFAULT value, but might also be the expression that computes
685** the value for a generated column.
686*/
687void sqlite3ColumnSetExpr(
688 Parse *pParse, /* Parsing context */
689 Table *pTab, /* The table containing the column */
690 Column *pCol, /* The column to receive the new DEFAULT expression */
691 Expr *pExpr /* The new default expression */
692){
drhf38524d2021-08-02 16:41:57 +0000693 ExprList *pList;
drh78b2fa82021-10-07 12:11:20 +0000694 assert( IsOrdinaryTable(pTab) );
drhf38524d2021-08-02 16:41:57 +0000695 pList = pTab->u.tab.pDfltList;
drh79cf2b72021-07-31 20:30:41 +0000696 if( pCol->iDflt==0
drh324f91a2021-08-04 14:50:23 +0000697 || NEVER(pList==0)
698 || NEVER(pList->nExpr<pCol->iDflt)
drh79cf2b72021-07-31 20:30:41 +0000699 ){
700 pCol->iDflt = pList==0 ? 1 : pList->nExpr+1;
drhf38524d2021-08-02 16:41:57 +0000701 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
drh79cf2b72021-07-31 20:30:41 +0000702 }else{
703 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
704 pList->a[pCol->iDflt-1].pExpr = pExpr;
705 }
706}
707
708/*
709** Return the expression associated with a column. The expression might be
710** the DEFAULT clause or the AS clause of a generated column.
711** Return NULL if the column has no associated expression.
712*/
713Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){
714 if( pCol->iDflt==0 ) return 0;
drh78b2fa82021-10-07 12:11:20 +0000715 if( NEVER(!IsOrdinaryTable(pTab)) ) return 0;
drh324f91a2021-08-04 14:50:23 +0000716 if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
717 if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;
drhf38524d2021-08-02 16:41:57 +0000718 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
drh79cf2b72021-07-31 20:30:41 +0000719}
720
721/*
drh65b40092021-08-05 15:27:19 +0000722** Set the collating sequence name for a column.
723*/
724void sqlite3ColumnSetColl(
725 sqlite3 *db,
726 Column *pCol,
727 const char *zColl
728){
729 int nColl;
730 int n;
731 char *zNew;
732 assert( zColl!=0 );
733 n = sqlite3Strlen30(pCol->zCnName) + 1;
734 if( pCol->colFlags & COLFLAG_HASTYPE ){
735 n += sqlite3Strlen30(pCol->zCnName+n) + 1;
736 }
737 nColl = sqlite3Strlen30(zColl) + 1;
738 zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n);
739 if( zNew ){
740 pCol->zCnName = zNew;
741 memcpy(pCol->zCnName + n, zColl, nColl);
742 pCol->colFlags |= COLFLAG_HASCOLL;
743 }
744}
745
746/*
747** Return the collating squence name for a column
748*/
749const char *sqlite3ColumnColl(Column *pCol){
750 const char *z;
751 if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0;
752 z = pCol->zCnName;
753 while( *z ){ z++; }
754 if( pCol->colFlags & COLFLAG_HASTYPE ){
755 do{ z++; }while( *z );
756 }
757 return z+1;
758}
759
760/*
dand46def72010-07-24 11:28:28 +0000761** Delete memory allocated for the column names of a table or view (the
762** Table.aCol[] array).
drh956bc922004-07-24 17:38:29 +0000763*/
drh51be3872015-08-19 02:32:25 +0000764void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
drh956bc922004-07-24 17:38:29 +0000765 int i;
766 Column *pCol;
767 assert( pTable!=0 );
drhdd5b2fa2005-03-28 03:39:55 +0000768 if( (pCol = pTable->aCol)!=0 ){
769 for(i=0; i<pTable->nCol; i++, pCol++){
drhcf9d36d2021-08-02 18:03:43 +0000770 assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) );
771 sqlite3DbFree(db, pCol->zCnName);
drhdd5b2fa2005-03-28 03:39:55 +0000772 }
drh633e6d52008-07-28 19:34:53 +0000773 sqlite3DbFree(db, pTable->aCol);
drh78b2fa82021-10-07 12:11:20 +0000774 if( IsOrdinaryTable(pTable) ){
drhf38524d2021-08-02 16:41:57 +0000775 sqlite3ExprListDelete(db, pTable->u.tab.pDfltList);
776 }
drh79cf2b72021-07-31 20:30:41 +0000777 if( db==0 || db->pnBytesFreed==0 ){
778 pTable->aCol = 0;
779 pTable->nCol = 0;
drh78b2fa82021-10-07 12:11:20 +0000780 if( IsOrdinaryTable(pTable) ){
drhf38524d2021-08-02 16:41:57 +0000781 pTable->u.tab.pDfltList = 0;
782 }
drh79cf2b72021-07-31 20:30:41 +0000783 }
drh956bc922004-07-24 17:38:29 +0000784 }
drh956bc922004-07-24 17:38:29 +0000785}
786
787/*
drh75897232000-05-29 14:26:00 +0000788** Remove the memory data structures associated with the given
drh967e8b72000-06-21 13:59:10 +0000789** Table. No changes are made to disk by this routine.
drh75897232000-05-29 14:26:00 +0000790**
791** This routine just deletes the data structure. It does not unlink
drhe61922a2009-05-02 13:29:37 +0000792** the table data structure from the hash table. But it does destroy
drhc2eef3b2002-08-31 18:53:06 +0000793** memory structures of the indices and foreign keys associated with
794** the table.
drh29ddd3a2012-05-15 12:49:32 +0000795**
796** The db parameter is optional. It is needed if the Table object
797** contains lookaside memory. (Table objects in the schema do not use
798** lookaside memory, but some ephemeral Table objects do.) Or the
799** db parameter can be used with db->pnBytesFreed to measure the memory
800** used by the Table object.
drh75897232000-05-29 14:26:00 +0000801*/
drhe8da01c2016-05-07 12:15:34 +0000802static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
drh75897232000-05-29 14:26:00 +0000803 Index *pIndex, *pNext;
drhc2eef3b2002-08-31 18:53:06 +0000804
drh52fb8e12017-08-29 20:21:12 +0000805#ifdef SQLITE_DEBUG
drh29ddd3a2012-05-15 12:49:32 +0000806 /* Record the number of outstanding lookaside allocations in schema Tables
danbedf84c2019-07-08 13:45:02 +0000807 ** prior to doing any free() operations. Since schema Tables do not use
808 ** lookaside, this number should not change.
809 **
810 ** If malloc has already failed, it may be that it failed while allocating
811 ** a Table object that was going to be marked ephemeral. So do not check
812 ** that no lookaside memory is used in this case either. */
drh52fb8e12017-08-29 20:21:12 +0000813 int nLookaside = 0;
danbedf84c2019-07-08 13:45:02 +0000814 if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){
drh52fb8e12017-08-29 20:21:12 +0000815 nLookaside = sqlite3LookasideUsed(db, 0);
816 }
817#endif
drh29ddd3a2012-05-15 12:49:32 +0000818
dand46def72010-07-24 11:28:28 +0000819 /* Delete all indices associated with this table. */
drhc2eef3b2002-08-31 18:53:06 +0000820 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
821 pNext = pIndex->pNext;
drh62340f82016-05-31 21:18:15 +0000822 assert( pIndex->pSchema==pTable->pSchema
823 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
drh273bfe92016-06-02 16:22:53 +0000824 if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){
dand46def72010-07-24 11:28:28 +0000825 char *zName = pIndex->zName;
826 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
drhacbcb7e2014-08-21 20:26:37 +0000827 &pIndex->pSchema->idxHash, zName, 0
dand46def72010-07-24 11:28:28 +0000828 );
drh21206082011-04-04 18:22:02 +0000829 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
dand46def72010-07-24 11:28:28 +0000830 assert( pOld==pIndex || pOld==0 );
831 }
dancf8f2892018-08-09 20:47:01 +0000832 sqlite3FreeIndex(db, pIndex);
drhc2eef3b2002-08-31 18:53:06 +0000833 }
834
drhf38524d2021-08-02 16:41:57 +0000835 if( IsOrdinaryTable(pTable) ){
836 sqlite3FkDelete(db, pTable);
837 }
838#ifndef SQLITE_OMIT_VIRTUAL_TABLE
839 else if( IsVirtual(pTable) ){
840 sqlite3VtabClear(db, pTable);
841 }
842#endif
843 else{
844 assert( IsView(pTable) );
845 sqlite3SelectDelete(db, pTable->u.view.pSelect);
846 }
drhc2eef3b2002-08-31 18:53:06 +0000847
848 /* Delete the Table structure itself.
849 */
drh51be3872015-08-19 02:32:25 +0000850 sqlite3DeleteColumnNames(db, pTable);
drh633e6d52008-07-28 19:34:53 +0000851 sqlite3DbFree(db, pTable->zName);
852 sqlite3DbFree(db, pTable->zColAff);
drh2938f922012-03-07 19:13:29 +0000853 sqlite3ExprListDelete(db, pTable->pCheck);
drh633e6d52008-07-28 19:34:53 +0000854 sqlite3DbFree(db, pTable);
drh29ddd3a2012-05-15 12:49:32 +0000855
856 /* Verify that no lookaside memory was used by schema tables */
drh52fb8e12017-08-29 20:21:12 +0000857 assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) );
drh75897232000-05-29 14:26:00 +0000858}
drhe8da01c2016-05-07 12:15:34 +0000859void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
860 /* Do not delete the table until the reference count reaches zero. */
861 if( !pTable ) return;
drh79df7782016-12-14 14:07:35 +0000862 if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return;
drhe8da01c2016-05-07 12:15:34 +0000863 deleteTable(db, pTable);
864}
865
drh75897232000-05-29 14:26:00 +0000866
867/*
drh5edc3122001-09-13 21:53:09 +0000868** Unlink the given table from the hash tables and the delete the
drhc2eef3b2002-08-31 18:53:06 +0000869** table structure with all its indices and foreign keys.
drh5edc3122001-09-13 21:53:09 +0000870*/
drh9bb575f2004-09-06 17:24:11 +0000871void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
drh956bc922004-07-24 17:38:29 +0000872 Table *p;
drh956bc922004-07-24 17:38:29 +0000873 Db *pDb;
874
drhd229ca92002-01-09 13:30:41 +0000875 assert( db!=0 );
drh956bc922004-07-24 17:38:29 +0000876 assert( iDb>=0 && iDb<db->nDb );
drh972a2312009-12-08 14:34:08 +0000877 assert( zTabName );
drh21206082011-04-04 18:22:02 +0000878 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh972a2312009-12-08 14:34:08 +0000879 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
drh956bc922004-07-24 17:38:29 +0000880 pDb = &db->aDb[iDb];
drhacbcb7e2014-08-21 20:26:37 +0000881 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
dan1feeaed2010-07-23 15:41:47 +0000882 sqlite3DeleteTable(db, p);
drh8257aa82017-07-26 19:59:13 +0000883 db->mDbFlags |= DBFLAG_SchemaChange;
drh74e24cd2002-01-09 03:19:59 +0000884}
885
886/*
drha99db3b2004-06-19 14:49:12 +0000887** Given a token, return a string that consists of the text of that
drh24fb6272009-05-01 21:13:36 +0000888** token. Space to hold the returned string
drha99db3b2004-06-19 14:49:12 +0000889** is obtained from sqliteMalloc() and must be freed by the calling
890** function.
drh75897232000-05-29 14:26:00 +0000891**
drh24fb6272009-05-01 21:13:36 +0000892** Any quotation marks (ex: "name", 'name', [name], or `name`) that
893** surround the body of the token are removed.
894**
drhc96d8532005-05-03 12:30:33 +0000895** Tokens are often just pointers into the original SQL text and so
drha99db3b2004-06-19 14:49:12 +0000896** are not \000 terminated and are not persistent. The returned string
897** is \000 terminated and is persistent.
drh75897232000-05-29 14:26:00 +0000898*/
drhb6dad522021-09-24 16:14:47 +0000899char *sqlite3NameFromToken(sqlite3 *db, const Token *pName){
drha99db3b2004-06-19 14:49:12 +0000900 char *zName;
901 if( pName ){
drhb6dad522021-09-24 16:14:47 +0000902 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
drhb7916a72009-05-27 10:31:29 +0000903 sqlite3Dequote(zName);
drha99db3b2004-06-19 14:49:12 +0000904 }else{
905 zName = 0;
906 }
drh75897232000-05-29 14:26:00 +0000907 return zName;
908}
909
910/*
drh1e32bed2020-06-19 13:33:53 +0000911** Open the sqlite_schema table stored in database number iDb for
danielk1977cbb18d22004-05-28 11:37:27 +0000912** writing. The table is opened using cursor 0.
drhe0bc4042002-06-25 01:09:11 +0000913*/
drh346a70c2020-06-15 20:27:35 +0000914void sqlite3OpenSchemaTable(Parse *p, int iDb){
danielk1977c00da102006-01-07 13:21:04 +0000915 Vdbe *v = sqlite3GetVdbe(p);
drh346a70c2020-06-15 20:27:35 +0000916 sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, DFLT_SCHEMA_TABLE);
917 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
danielk19776ab3a2e2009-02-19 14:39:25 +0000918 if( p->nTab==0 ){
919 p->nTab = 1;
920 }
drhe0bc4042002-06-25 01:09:11 +0000921}
922
923/*
danielk197704103022009-02-03 16:51:24 +0000924** Parameter zName points to a nul-terminated buffer containing the name
925** of a database ("main", "temp" or the name of an attached db). This
926** function returns the index of the named database in db->aDb[], or
927** -1 if the named db cannot be found.
danielk1977cbb18d22004-05-28 11:37:27 +0000928*/
danielk197704103022009-02-03 16:51:24 +0000929int sqlite3FindDbName(sqlite3 *db, const char *zName){
930 int i = -1; /* Database number */
drh73c42a12004-11-20 18:13:10 +0000931 if( zName ){
danielk197704103022009-02-03 16:51:24 +0000932 Db *pDb;
danielk1977576ec6b2005-01-21 11:55:25 +0000933 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
drh29518092016-12-24 19:37:16 +0000934 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
935 /* "main" is always an acceptable alias for the primary database
936 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
937 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
danielk1977cbb18d22004-05-28 11:37:27 +0000938 }
939 }
danielk1977576ec6b2005-01-21 11:55:25 +0000940 return i;
danielk1977cbb18d22004-05-28 11:37:27 +0000941}
942
danielk197704103022009-02-03 16:51:24 +0000943/*
944** The token *pName contains the name of a database (either "main" or
945** "temp" or the name of an attached db). This routine returns the
946** index of the named database in db->aDb[], or -1 if the named db
947** does not exist.
948*/
949int sqlite3FindDb(sqlite3 *db, Token *pName){
950 int i; /* Database number */
951 char *zName; /* Name we are searching for */
952 zName = sqlite3NameFromToken(db, pName);
953 i = sqlite3FindDbName(db, zName);
954 sqlite3DbFree(db, zName);
955 return i;
956}
957
drh0e3d7472004-06-19 17:33:07 +0000958/* The table or view or trigger name is passed to this routine via tokens
959** pName1 and pName2. If the table name was fully qualified, for example:
960**
961** CREATE TABLE xxx.yyy (...);
962**
963** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
964** the table name is not fully qualified, i.e.:
965**
966** CREATE TABLE yyy(...);
967**
968** Then pName1 is set to "yyy" and pName2 is "".
969**
970** This routine sets the *ppUnqual pointer to point at the token (pName1 or
971** pName2) that stores the unqualified table name. The index of the
972** database "xxx" is returned.
973*/
danielk1977ef2cb632004-05-29 02:37:19 +0000974int sqlite3TwoPartName(
drh0e3d7472004-06-19 17:33:07 +0000975 Parse *pParse, /* Parsing and code generating context */
drh90f5ecb2004-07-22 01:19:35 +0000976 Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
drh0e3d7472004-06-19 17:33:07 +0000977 Token *pName2, /* The "yyy" in the name "xxx.yyy" */
978 Token **pUnqual /* Write the unqualified object name here */
danielk1977cbb18d22004-05-28 11:37:27 +0000979){
drh0e3d7472004-06-19 17:33:07 +0000980 int iDb; /* Database holding the object */
danielk1977cbb18d22004-05-28 11:37:27 +0000981 sqlite3 *db = pParse->db;
982
drh055f2982016-01-15 15:06:41 +0000983 assert( pName2!=0 );
984 if( pName2->n>0 ){
shanedcc50b72008-11-13 18:29:50 +0000985 if( db->init.busy ) {
986 sqlite3ErrorMsg(pParse, "corrupt database");
shanedcc50b72008-11-13 18:29:50 +0000987 return -1;
988 }
danielk1977cbb18d22004-05-28 11:37:27 +0000989 *pUnqual = pName2;
drhff2d5ea2005-07-23 00:41:48 +0000990 iDb = sqlite3FindDb(db, pName1);
danielk1977cbb18d22004-05-28 11:37:27 +0000991 if( iDb<0 ){
992 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
danielk1977cbb18d22004-05-28 11:37:27 +0000993 return -1;
994 }
995 }else{
drhd36bcec2021-05-29 21:50:05 +0000996 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
drh8257aa82017-07-26 19:59:13 +0000997 || (db->mDbFlags & DBFLAG_Vacuum)!=0);
danielk1977cbb18d22004-05-28 11:37:27 +0000998 iDb = db->init.iDb;
999 *pUnqual = pName1;
1000 }
1001 return iDb;
1002}
1003
1004/*
drh0f1c2eb2018-11-03 17:31:48 +00001005** True if PRAGMA writable_schema is ON
1006*/
1007int sqlite3WritableSchema(sqlite3 *db){
1008 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
1009 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
1010 SQLITE_WriteSchema );
1011 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
1012 SQLITE_Defensive );
1013 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
1014 (SQLITE_WriteSchema|SQLITE_Defensive) );
1015 return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
1016}
1017
1018/*
danielk1977d8123362004-06-12 09:25:12 +00001019** This routine is used to check if the UTF-8 string zName is a legal
1020** unqualified name for a new schema object (table, index, view or
1021** trigger). All names are legal except those that begin with the string
1022** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
1023** is reserved for internal use.
drhc5a93d42019-08-12 00:08:07 +00001024**
drh1e32bed2020-06-19 13:33:53 +00001025** When parsing the sqlite_schema table, this routine also checks to
drhc5a93d42019-08-12 00:08:07 +00001026** make sure the "type", "name", and "tbl_name" columns are consistent
1027** with the SQL.
danielk1977d8123362004-06-12 09:25:12 +00001028*/
drhc5a93d42019-08-12 00:08:07 +00001029int sqlite3CheckObjectName(
1030 Parse *pParse, /* Parsing context */
1031 const char *zName, /* Name of the object to check */
1032 const char *zType, /* Type of this object */
1033 const char *zTblName /* Parent table name for triggers and indexes */
1034){
1035 sqlite3 *db = pParse->db;
drhca439a42020-07-22 21:05:23 +00001036 if( sqlite3WritableSchema(db)
1037 || db->init.imposterTable
1038 || !sqlite3Config.bExtraSchemaChecks
1039 ){
drhc5a93d42019-08-12 00:08:07 +00001040 /* Skip these error checks for writable_schema=ON */
1041 return SQLITE_OK;
1042 }
1043 if( db->init.busy ){
1044 if( sqlite3_stricmp(zType, db->init.azInit[0])
1045 || sqlite3_stricmp(zName, db->init.azInit[1])
1046 || sqlite3_stricmp(zTblName, db->init.azInit[2])
1047 ){
drhca439a42020-07-22 21:05:23 +00001048 sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
1049 return SQLITE_ERROR;
drhc5a93d42019-08-12 00:08:07 +00001050 }
1051 }else{
drh527cbd42019-11-16 14:15:19 +00001052 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
1053 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
drhc5a93d42019-08-12 00:08:07 +00001054 ){
1055 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
1056 zName);
1057 return SQLITE_ERROR;
1058 }
drh527cbd42019-11-16 14:15:19 +00001059
danielk1977d8123362004-06-12 09:25:12 +00001060 }
1061 return SQLITE_OK;
1062}
1063
1064/*
drh44156282013-10-23 22:23:03 +00001065** Return the PRIMARY KEY index of a table
1066*/
1067Index *sqlite3PrimaryKeyIndex(Table *pTab){
1068 Index *p;
drh48dd1d82014-05-27 18:18:58 +00001069 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
drh44156282013-10-23 22:23:03 +00001070 return p;
1071}
1072
1073/*
drhb9bcf7c2019-10-19 13:29:10 +00001074** Convert an table column number into a index column number. That is,
1075** for the column iCol in the table (as defined by the CREATE TABLE statement)
1076** find the (first) offset of that column in index pIdx. Or return -1
1077** if column iCol is not used in index pIdx.
drh44156282013-10-23 22:23:03 +00001078*/
drhb9bcf7c2019-10-19 13:29:10 +00001079i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
drh44156282013-10-23 22:23:03 +00001080 int i;
1081 for(i=0; i<pIdx->nColumn; i++){
1082 if( iCol==pIdx->aiColumn[i] ) return i;
1083 }
1084 return -1;
1085}
1086
drh81f7b372019-10-16 12:18:59 +00001087#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drhb9bcf7c2019-10-19 13:29:10 +00001088/* Convert a storage column number into a table column number.
drh81f7b372019-10-16 12:18:59 +00001089**
drh8e10d742019-10-18 17:42:47 +00001090** The storage column number (0,1,2,....) is the index of the value
1091** as it appears in the record on disk. The true column number
1092** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
1093**
drhb9bcf7c2019-10-19 13:29:10 +00001094** The storage column number is less than the table column number if
1095** and only there are VIRTUAL columns to the left.
drh8e10d742019-10-18 17:42:47 +00001096**
1097** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
drh8e10d742019-10-18 17:42:47 +00001098*/
drhb9bcf7c2019-10-19 13:29:10 +00001099i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
drh8e10d742019-10-18 17:42:47 +00001100 if( pTab->tabFlags & TF_HasVirtual ){
1101 int i;
1102 for(i=0; i<=iCol; i++){
1103 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
1104 }
1105 }
1106 return iCol;
1107}
1108#endif
1109
1110#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drhb9bcf7c2019-10-19 13:29:10 +00001111/* Convert a table column number into a storage column number.
drh8e10d742019-10-18 17:42:47 +00001112**
1113** The storage column number (0,1,2,....) is the index of the value
drhdd6cc9b2019-10-19 18:47:27 +00001114** as it appears in the record on disk. Or, if the input column is
1115** the N-th virtual column (zero-based) then the storage number is
1116** the number of non-virtual columns in the table plus N.
drh8e10d742019-10-18 17:42:47 +00001117**
drhdd6cc9b2019-10-19 18:47:27 +00001118** The true column number is the index (0,1,2,...) of the column in
1119** the CREATE TABLE statement.
drh8e10d742019-10-18 17:42:47 +00001120**
drhdd6cc9b2019-10-19 18:47:27 +00001121** If the input column is a VIRTUAL column, then it should not appear
1122** in storage. But the value sometimes is cached in registers that
1123** follow the range of registers used to construct storage. This
1124** avoids computing the same VIRTUAL column multiple times, and provides
1125** values for use by OP_Param opcodes in triggers. Hence, if the
1126** input column is a VIRTUAL table, put it after all the other columns.
1127**
1128** In the following, N means "normal column", S means STORED, and
1129** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
1130**
1131** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
1132** -- 0 1 2 3 4 5 6 7 8
1133**
1134** Then the mapping from this function is as follows:
1135**
1136** INPUTS: 0 1 2 3 4 5 6 7 8
1137** OUTPUTS: 0 1 6 2 3 7 4 5 8
1138**
1139** So, in other words, this routine shifts all the virtual columns to
1140** the end.
1141**
1142** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and
drh7fe2fc02019-12-07 00:22:18 +00001143** this routine is a no-op macro. If the pTab does not have any virtual
1144** columns, then this routine is no-op that always return iCol. If iCol
1145** is negative (indicating the ROWID column) then this routine return iCol.
drh81f7b372019-10-16 12:18:59 +00001146*/
drhb9bcf7c2019-10-19 13:29:10 +00001147i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
drh81f7b372019-10-16 12:18:59 +00001148 int i;
1149 i16 n;
1150 assert( iCol<pTab->nCol );
drh7fe2fc02019-12-07 00:22:18 +00001151 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
drh81f7b372019-10-16 12:18:59 +00001152 for(i=0, n=0; i<iCol; i++){
1153 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
1154 }
drhdd6cc9b2019-10-19 18:47:27 +00001155 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
1156 /* iCol is a virtual column itself */
1157 return pTab->nNVCol + i - n;
1158 }else{
1159 /* iCol is a normal or stored column */
1160 return n;
1161 }
drh81f7b372019-10-16 12:18:59 +00001162}
1163#endif
1164
drh44156282013-10-23 22:23:03 +00001165/*
drh31da7be2021-05-13 18:24:22 +00001166** Insert a single OP_JournalMode query opcode in order to force the
1167** prepared statement to return false for sqlite3_stmt_readonly(). This
1168** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
1169** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
1170** will return false for sqlite3_stmt_readonly() even if that statement
1171** is a read-only no-op.
1172*/
1173static void sqlite3ForceNotReadOnly(Parse *pParse){
1174 int iReg = ++pParse->nMem;
1175 Vdbe *v = sqlite3GetVdbe(pParse);
1176 if( v ){
1177 sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
dana8f249f2021-05-20 11:42:51 +00001178 sqlite3VdbeUsesBtree(v, 0);
drh31da7be2021-05-13 18:24:22 +00001179 }
1180}
1181
1182/*
drh75897232000-05-29 14:26:00 +00001183** Begin constructing a new table representation in memory. This is
1184** the first of several action routines that get called in response
drhd9b02572001-04-15 00:37:09 +00001185** to a CREATE TABLE statement. In particular, this routine is called
drh74161702006-02-24 02:53:49 +00001186** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
drhe0bc4042002-06-25 01:09:11 +00001187** flag is true if the table should be stored in the auxiliary database
1188** file instead of in the main database file. This is normally the case
1189** when the "TEMP" or "TEMPORARY" keyword occurs in between
drhf57b3392001-10-08 13:22:32 +00001190** CREATE and TABLE.
drhd9b02572001-04-15 00:37:09 +00001191**
drhf57b3392001-10-08 13:22:32 +00001192** The new table record is initialized and put in pParse->pNewTable.
1193** As more of the CREATE TABLE statement is parsed, additional action
1194** routines will be called to add more information to this record.
danielk19774adee202004-05-08 08:23:19 +00001195** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
drhf57b3392001-10-08 13:22:32 +00001196** is called to complete the construction of the new table record.
drh75897232000-05-29 14:26:00 +00001197*/
danielk19774adee202004-05-08 08:23:19 +00001198void sqlite3StartTable(
drhe5f9c642003-01-13 23:27:31 +00001199 Parse *pParse, /* Parser context */
danielk1977cbb18d22004-05-28 11:37:27 +00001200 Token *pName1, /* First part of the name of the table or view */
1201 Token *pName2, /* Second part of the name of the table or view */
drhe5f9c642003-01-13 23:27:31 +00001202 int isTemp, /* True if this is a TEMP table */
drhfaa59552005-12-29 23:33:54 +00001203 int isView, /* True if this is a VIEW */
danielk1977f1a381e2006-06-16 08:01:02 +00001204 int isVirtual, /* True if this is a VIRTUAL table */
drhfaa59552005-12-29 23:33:54 +00001205 int noErr /* Do nothing if table already exists */
drhe5f9c642003-01-13 23:27:31 +00001206){
drh75897232000-05-29 14:26:00 +00001207 Table *pTable;
drh23bf66d2004-12-14 03:34:34 +00001208 char *zName = 0; /* The name of the new table */
drh9bb575f2004-09-06 17:24:11 +00001209 sqlite3 *db = pParse->db;
drhadbca9c2001-09-27 15:11:53 +00001210 Vdbe *v;
danielk1977cbb18d22004-05-28 11:37:27 +00001211 int iDb; /* Database number to create the table in */
1212 Token *pName; /* Unqualified name of the table to create */
drh75897232000-05-29 14:26:00 +00001213
drh055f2982016-01-15 15:06:41 +00001214 if( db->init.busy && db->init.newTnum==1 ){
drh1e32bed2020-06-19 13:33:53 +00001215 /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */
drh055f2982016-01-15 15:06:41 +00001216 iDb = db->init.iDb;
1217 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
1218 pName = pName1;
1219 }else{
1220 /* The common case */
1221 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
1222 if( iDb<0 ) return;
1223 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
1224 /* If creating a temp table, the name may not be qualified. Unless
1225 ** the database name is "temp" anyway. */
1226 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
1227 return;
1228 }
1229 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
1230 zName = sqlite3NameFromToken(db, pName);
danc9461ec2018-08-29 21:00:16 +00001231 if( IN_RENAME_OBJECT ){
1232 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
1233 }
danielk1977cbb18d22004-05-28 11:37:27 +00001234 }
danielk1977cbb18d22004-05-28 11:37:27 +00001235 pParse->sNameToken = *pName;
danielk1977e0048402004-06-15 16:51:01 +00001236 if( zName==0 ) return;
drhc5a93d42019-08-12 00:08:07 +00001237 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
drh23bf66d2004-12-14 03:34:34 +00001238 goto begin_table_error;
danielk1977d8123362004-06-12 09:25:12 +00001239 }
drh1d85d932004-02-14 23:05:52 +00001240 if( db->init.iDb==1 ) isTemp = 1;
drhe5f9c642003-01-13 23:27:31 +00001241#ifndef SQLITE_OMIT_AUTHORIZATION
drh055f2982016-01-15 15:06:41 +00001242 assert( isTemp==0 || isTemp==1 );
1243 assert( isView==0 || isView==1 );
drhe5f9c642003-01-13 23:27:31 +00001244 {
drh055f2982016-01-15 15:06:41 +00001245 static const u8 aCode[] = {
1246 SQLITE_CREATE_TABLE,
1247 SQLITE_CREATE_TEMP_TABLE,
1248 SQLITE_CREATE_VIEW,
1249 SQLITE_CREATE_TEMP_VIEW
1250 };
drh69c33822016-08-18 14:33:11 +00001251 char *zDb = db->aDb[iDb].zDbSName;
danielk19774adee202004-05-08 08:23:19 +00001252 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +00001253 goto begin_table_error;
drhe22a3342003-04-22 20:30:37 +00001254 }
drh055f2982016-01-15 15:06:41 +00001255 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
1256 zName, 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +00001257 goto begin_table_error;
drhe5f9c642003-01-13 23:27:31 +00001258 }
1259 }
1260#endif
drhf57b3392001-10-08 13:22:32 +00001261
drhf57b3392001-10-08 13:22:32 +00001262 /* Make sure the new table name does not collide with an existing
danielk19773df6b252004-05-29 10:23:19 +00001263 ** index or table name in the same database. Issue an error message if
danielk19777e6ebfb2006-06-12 11:24:37 +00001264 ** it does. The exception is if the statement being parsed was passed
1265 ** to an sqlite3_declare_vtab() call. In that case only the column names
1266 ** and types will be used, so there is no need to test for namespace
1267 ** collisions.
drhf57b3392001-10-08 13:22:32 +00001268 */
dancf8f2892018-08-09 20:47:01 +00001269 if( !IN_SPECIAL_PARSE ){
drh69c33822016-08-18 14:33:11 +00001270 char *zDb = db->aDb[iDb].zDbSName;
danielk19777e6ebfb2006-06-12 11:24:37 +00001271 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
1272 goto begin_table_error;
drhfaa59552005-12-29 23:33:54 +00001273 }
dana16d1062010-09-28 17:37:28 +00001274 pTable = sqlite3FindTable(db, zName, zDb);
danielk19777e6ebfb2006-06-12 11:24:37 +00001275 if( pTable ){
1276 if( !noErr ){
1277 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
dan7687c832011-04-09 15:39:02 +00001278 }else{
drh33c59ec2015-04-19 20:39:17 +00001279 assert( !db->init.busy || CORRUPT_DB );
dan7687c832011-04-09 15:39:02 +00001280 sqlite3CodeVerifySchema(pParse, iDb);
drh31da7be2021-05-13 18:24:22 +00001281 sqlite3ForceNotReadOnly(pParse);
danielk19777e6ebfb2006-06-12 11:24:37 +00001282 }
1283 goto begin_table_error;
1284 }
drh8a8a0d12010-09-28 20:26:44 +00001285 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
danielk19777e6ebfb2006-06-12 11:24:37 +00001286 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
1287 goto begin_table_error;
1288 }
drh75897232000-05-29 14:26:00 +00001289 }
danielk19777e6ebfb2006-06-12 11:24:37 +00001290
danielk197726783a52007-08-29 14:06:22 +00001291 pTable = sqlite3DbMallocZero(db, sizeof(Table));
drh6d4abfb2001-10-22 02:58:08 +00001292 if( pTable==0 ){
drh4df86af2016-02-04 11:48:00 +00001293 assert( db->mallocFailed );
mistachkinfad30392016-02-13 23:43:46 +00001294 pParse->rc = SQLITE_NOMEM_BKPT;
danielk1977e0048402004-06-15 16:51:01 +00001295 pParse->nErr++;
drh23bf66d2004-12-14 03:34:34 +00001296 goto begin_table_error;
drh6d4abfb2001-10-22 02:58:08 +00001297 }
drh75897232000-05-29 14:26:00 +00001298 pTable->zName = zName;
drh4a324312001-12-21 14:30:42 +00001299 pTable->iPKey = -1;
danielk1977da184232006-01-05 11:34:32 +00001300 pTable->pSchema = db->aDb[iDb].pSchema;
drh79df7782016-12-14 14:07:35 +00001301 pTable->nTabRef = 1;
drhd1417ee2017-06-06 18:20:43 +00001302#ifdef SQLITE_DEFAULT_ROWEST
1303 pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
1304#else
dancfc9df72014-04-25 15:01:01 +00001305 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drhd1417ee2017-06-06 18:20:43 +00001306#endif
drhc4a64fa2009-05-11 20:53:28 +00001307 assert( pParse->pNewTable==0 );
drh75897232000-05-29 14:26:00 +00001308 pParse->pNewTable = pTable;
drh17f71932002-02-21 12:01:27 +00001309
1310 /* Begin generating the code that will insert the table record into
drh346a70c2020-06-15 20:27:35 +00001311 ** the schema table. Note in particular that we must go ahead
drh17f71932002-02-21 12:01:27 +00001312 ** and allocate the record number for the table entry now. Before any
1313 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
1314 ** indices to be created and the table record must come before the
1315 ** indices. Hence, the record number for the table must be allocated
1316 ** now.
1317 */
danielk19774adee202004-05-08 08:23:19 +00001318 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
drh728e0f92015-10-10 14:41:28 +00001319 int addr1;
drhe321c292006-01-12 01:56:43 +00001320 int fileFormat;
drhb7654112008-01-12 12:48:07 +00001321 int reg1, reg2, reg3;
drh3c03afd2015-09-09 13:28:06 +00001322 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
1323 static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
drh0dd5cda2015-06-16 16:39:01 +00001324 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00001325
danielk197720b1eaf2006-07-26 16:22:14 +00001326#ifndef SQLITE_OMIT_VIRTUALTABLE
1327 if( isVirtual ){
drh66a51672008-01-03 00:01:23 +00001328 sqlite3VdbeAddOp0(v, OP_VBegin);
danielk197720b1eaf2006-07-26 16:22:14 +00001329 }
1330#endif
1331
danielk197736963fd2005-02-19 08:18:05 +00001332 /* If the file format and encoding in the database have not been set,
1333 ** set them now.
danielk1977d008cfe2004-06-19 02:22:10 +00001334 */
drhb7654112008-01-12 12:48:07 +00001335 reg1 = pParse->regRowid = ++pParse->nMem;
1336 reg2 = pParse->regRoot = ++pParse->nMem;
1337 reg3 = ++pParse->nMem;
danielk19770d19f7a2009-06-03 11:25:07 +00001338 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
drhfb982642007-08-30 01:19:59 +00001339 sqlite3VdbeUsesBtree(v, iDb);
drh728e0f92015-10-10 14:41:28 +00001340 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
drhe321c292006-01-12 01:56:43 +00001341 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
drh76fe8032006-07-11 14:17:51 +00001342 1 : SQLITE_MAX_FILE_FORMAT;
drh1861afc2016-02-01 21:48:34 +00001343 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
1344 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
drh728e0f92015-10-10 14:41:28 +00001345 sqlite3VdbeJumpHere(v, addr1);
danielk1977d008cfe2004-06-19 02:22:10 +00001346
drh1e32bed2020-06-19 13:33:53 +00001347 /* This just creates a place-holder record in the sqlite_schema table.
drh4794f732004-11-05 17:17:50 +00001348 ** The record created does not contain anything yet. It will be replaced
1349 ** by the real entry in code generated at sqlite3EndTable().
drhb17131a2004-11-05 22:18:49 +00001350 **
drh0fa991b2009-03-21 16:19:26 +00001351 ** The rowid for the new entry is left in register pParse->regRowid.
1352 ** The root page number of the new table is left in reg pParse->regRoot.
1353 ** The rowid and root page number values are needed by the code that
1354 ** sqlite3EndTable will generate.
drh4794f732004-11-05 17:17:50 +00001355 */
danielk1977f1a381e2006-06-16 08:01:02 +00001356#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1357 if( isView || isVirtual ){
drhb7654112008-01-12 12:48:07 +00001358 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
danielk1977a21c6b62005-01-24 10:25:59 +00001359 }else
1360#endif
1361 {
drh381bdac2021-02-04 17:29:04 +00001362 assert( !pParse->bReturning );
1363 pParse->u1.addrCrTab =
drh0f3f7662017-08-18 14:34:28 +00001364 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
danielk1977a21c6b62005-01-24 10:25:59 +00001365 }
drh346a70c2020-06-15 20:27:35 +00001366 sqlite3OpenSchemaTable(pParse, iDb);
drhb7654112008-01-12 12:48:07 +00001367 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
drh3c03afd2015-09-09 13:28:06 +00001368 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
drhb7654112008-01-12 12:48:07 +00001369 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
1370 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drh66a51672008-01-03 00:01:23 +00001371 sqlite3VdbeAddOp0(v, OP_Close);
drh5e00f6c2001-09-13 13:46:56 +00001372 }
drh23bf66d2004-12-14 03:34:34 +00001373
1374 /* Normal (non-error) return. */
1375 return;
1376
1377 /* If an error occurs, we jump here */
1378begin_table_error:
drhc0495e82021-07-22 21:11:06 +00001379 pParse->checkSchema = 1;
drh633e6d52008-07-28 19:34:53 +00001380 sqlite3DbFree(db, zName);
drh23bf66d2004-12-14 03:34:34 +00001381 return;
drh75897232000-05-29 14:26:00 +00001382}
1383
drh03d69a62015-11-19 13:53:57 +00001384/* Set properties of a table column based on the (magical)
1385** name of the column.
1386*/
drh03d69a62015-11-19 13:53:57 +00001387#if SQLITE_ENABLE_HIDDEN_COLUMNS
drhe6110502015-12-31 15:34:03 +00001388void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
drhcf9d36d2021-08-02 18:03:43 +00001389 if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){
drh03d69a62015-11-19 13:53:57 +00001390 pCol->colFlags |= COLFLAG_HIDDEN;
drh6f6e60d2021-02-18 15:45:34 +00001391 if( pTab ) pTab->tabFlags |= TF_HasHidden;
danba68f8f2015-11-19 16:46:46 +00001392 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
1393 pTab->tabFlags |= TF_OOOHidden;
drh03d69a62015-11-19 13:53:57 +00001394 }
drh03d69a62015-11-19 13:53:57 +00001395}
drhe6110502015-12-31 15:34:03 +00001396#endif
drh03d69a62015-11-19 13:53:57 +00001397
drh2053f312021-01-12 20:16:31 +00001398/*
drh28828c52021-01-30 21:55:38 +00001399** Name of the special TEMP trigger used to implement RETURNING. The
1400** name begins with "sqlite_" so that it is guaranteed not to collide
1401** with any application-generated triggers.
drhb8352472021-01-29 19:32:17 +00001402*/
drh28828c52021-01-30 21:55:38 +00001403#define RETURNING_TRIGGER_NAME "sqlite_returning"
drhb8352472021-01-29 19:32:17 +00001404
1405/*
drh28828c52021-01-30 21:55:38 +00001406** Clean up the data structures associated with the RETURNING clause.
drhb8352472021-01-29 19:32:17 +00001407*/
1408static void sqlite3DeleteReturning(sqlite3 *db, Returning *pRet){
1409 Hash *pHash;
1410 pHash = &(db->aDb[1].pSchema->trigHash);
drh28828c52021-01-30 21:55:38 +00001411 sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, 0);
drhb8352472021-01-29 19:32:17 +00001412 sqlite3ExprListDelete(db, pRet->pReturnEL);
1413 sqlite3DbFree(db, pRet);
1414}
1415
1416/*
drh28828c52021-01-30 21:55:38 +00001417** Add the RETURNING clause to the parse currently underway.
1418**
1419** This routine creates a special TEMP trigger that will fire for each row
1420** of the DML statement. That TEMP trigger contains a single SELECT
1421** statement with a result set that is the argument of the RETURNING clause.
1422** The trigger has the Trigger.bReturning flag and an opcode of
1423** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
1424** knows to handle it specially. The TEMP trigger is automatically
1425** removed at the end of the parse.
1426**
1427** When this routine is called, we do not yet know if the RETURNING clause
1428** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
1429** RETURNING trigger instead. It will then be converted into the appropriate
1430** type on the first call to sqlite3TriggersExist().
drh2053f312021-01-12 20:16:31 +00001431*/
1432void sqlite3AddReturning(Parse *pParse, ExprList *pList){
drhb8352472021-01-29 19:32:17 +00001433 Returning *pRet;
1434 Hash *pHash;
1435 sqlite3 *db = pParse->db;
drhe1c9a4e2021-02-07 23:28:20 +00001436 if( pParse->pNewTrigger ){
1437 sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger");
1438 }else{
1439 assert( pParse->bReturning==0 );
1440 }
drhd086aa02021-01-29 21:31:59 +00001441 pParse->bReturning = 1;
drhb8352472021-01-29 19:32:17 +00001442 pRet = sqlite3DbMallocZero(db, sizeof(*pRet));
1443 if( pRet==0 ){
1444 sqlite3ExprListDelete(db, pList);
1445 return;
1446 }
drh381bdac2021-02-04 17:29:04 +00001447 pParse->u1.pReturning = pRet;
drhb8352472021-01-29 19:32:17 +00001448 pRet->pParse = pParse;
1449 pRet->pReturnEL = pList;
drh2053f312021-01-12 20:16:31 +00001450 sqlite3ParserAddCleanup(pParse,
drhb8352472021-01-29 19:32:17 +00001451 (void(*)(sqlite3*,void*))sqlite3DeleteReturning, pRet);
drh6d0053c2021-03-09 19:32:37 +00001452 testcase( pParse->earlyCleanup );
drhcf4108b2021-01-30 03:06:19 +00001453 if( db->mallocFailed ) return;
drh28828c52021-01-30 21:55:38 +00001454 pRet->retTrig.zName = RETURNING_TRIGGER_NAME;
drhb8352472021-01-29 19:32:17 +00001455 pRet->retTrig.op = TK_RETURNING;
1456 pRet->retTrig.tr_tm = TRIGGER_AFTER;
1457 pRet->retTrig.bReturning = 1;
1458 pRet->retTrig.pSchema = db->aDb[1].pSchema;
drha4767682021-04-27 13:04:18 +00001459 pRet->retTrig.pTabSchema = db->aDb[1].pSchema;
drhb8352472021-01-29 19:32:17 +00001460 pRet->retTrig.step_list = &pRet->retTStep;
drhdac9a5f2021-01-29 21:18:46 +00001461 pRet->retTStep.op = TK_RETURNING;
drhb8352472021-01-29 19:32:17 +00001462 pRet->retTStep.pTrig = &pRet->retTrig;
drh381bdac2021-02-04 17:29:04 +00001463 pRet->retTStep.pExprList = pList;
drhb8352472021-01-29 19:32:17 +00001464 pHash = &(db->aDb[1].pSchema->trigHash);
drhe1c9a4e2021-02-07 23:28:20 +00001465 assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 || pParse->nErr );
drh28828c52021-01-30 21:55:38 +00001466 if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig)
drh0166df02021-01-30 12:07:32 +00001467 ==&pRet->retTrig ){
1468 sqlite3OomFault(db);
1469 }
drh2053f312021-01-12 20:16:31 +00001470}
drh03d69a62015-11-19 13:53:57 +00001471
drh75897232000-05-29 14:26:00 +00001472/*
1473** Add a new column to the table currently being constructed.
drhd9b02572001-04-15 00:37:09 +00001474**
1475** The parser calls this routine once for each column declaration
danielk19774adee202004-05-08 08:23:19 +00001476** in a CREATE TABLE statement. sqlite3StartTable() gets called
drhd9b02572001-04-15 00:37:09 +00001477** first to get things going. Then this routine is called for each
1478** column.
drh75897232000-05-29 14:26:00 +00001479*/
drh77441fa2021-07-30 18:39:59 +00001480void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
drh75897232000-05-29 14:26:00 +00001481 Table *p;
drh97fc3d02002-05-22 21:27:03 +00001482 int i;
drha99db3b2004-06-19 14:49:12 +00001483 char *z;
drh94eaafa2016-02-29 15:53:11 +00001484 char *zType;
drhc9b84a12002-06-20 11:36:48 +00001485 Column *pCol;
drhbb4957f2008-03-20 14:03:29 +00001486 sqlite3 *db = pParse->db;
drh3e992d12021-01-01 19:17:01 +00001487 u8 hName;
drh7b3c5142021-07-30 12:47:35 +00001488 Column *aNew;
drhc2df4d62021-07-30 23:30:30 +00001489 u8 eType = COLTYPE_CUSTOM;
1490 u8 szEst = 1;
1491 char affinity = SQLITE_AFF_BLOB;
drh3e992d12021-01-01 19:17:01 +00001492
drh75897232000-05-29 14:26:00 +00001493 if( (p = pParse->pNewTable)==0 ) return;
drhbb4957f2008-03-20 14:03:29 +00001494 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drhe5c941b2007-05-08 13:58:26 +00001495 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
1496 return;
1497 }
drh77441fa2021-07-30 18:39:59 +00001498 if( !IN_RENAME_OBJECT ) sqlite3DequoteToken(&sName);
drhe48f2612021-07-30 20:09:08 +00001499
1500 /* Because keywords GENERATE ALWAYS can be converted into indentifiers
1501 ** by the parser, we can sometimes end up with a typename that ends
1502 ** with "generated always". Check for this case and omit the surplus
1503 ** text. */
1504 if( sType.n>=16
1505 && sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0
1506 ){
1507 sType.n -= 6;
1508 while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
1509 if( sType.n>=9
1510 && sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0
1511 ){
1512 sType.n -= 9;
1513 while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
1514 }
1515 }
1516
drhc2df4d62021-07-30 23:30:30 +00001517 /* Check for standard typenames. For standard typenames we will
1518 ** set the Column.eType field rather than storing the typename after
1519 ** the column name, in order to save space. */
1520 if( sType.n>=3 ){
1521 sqlite3DequoteToken(&sType);
1522 for(i=0; i<SQLITE_N_STDTYPE; i++){
1523 if( sType.n==sqlite3StdTypeLen[i]
1524 && sqlite3_strnicmp(sType.z, sqlite3StdType[i], sType.n)==0
1525 ){
1526 sType.n = 0;
1527 eType = i+1;
1528 affinity = sqlite3StdTypeAffinity[i];
1529 if( affinity<=SQLITE_AFF_TEXT ) szEst = 5;
1530 break;
1531 }
1532 }
1533 }
1534
1535 z = sqlite3DbMallocRaw(db, sName.n + 1 + sType.n + (sType.n>0) );
drh97fc3d02002-05-22 21:27:03 +00001536 if( z==0 ) return;
drh77441fa2021-07-30 18:39:59 +00001537 if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName);
1538 memcpy(z, sName.z, sName.n);
1539 z[sName.n] = 0;
drh94eaafa2016-02-29 15:53:11 +00001540 sqlite3Dequote(z);
drh3e992d12021-01-01 19:17:01 +00001541 hName = sqlite3StrIHash(z);
drh97fc3d02002-05-22 21:27:03 +00001542 for(i=0; i<p->nCol; i++){
drhcf9d36d2021-08-02 18:03:43 +00001543 if( p->aCol[i].hName==hName && sqlite3StrICmp(z, p->aCol[i].zCnName)==0 ){
danielk19774adee202004-05-08 08:23:19 +00001544 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
drh633e6d52008-07-28 19:34:53 +00001545 sqlite3DbFree(db, z);
drh97fc3d02002-05-22 21:27:03 +00001546 return;
1547 }
1548 }
drh7b3c5142021-07-30 12:47:35 +00001549 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+1)*sizeof(p->aCol[0]));
1550 if( aNew==0 ){
1551 sqlite3DbFree(db, z);
1552 return;
drh75897232000-05-29 14:26:00 +00001553 }
drh7b3c5142021-07-30 12:47:35 +00001554 p->aCol = aNew;
drhc9b84a12002-06-20 11:36:48 +00001555 pCol = &p->aCol[p->nCol];
1556 memset(pCol, 0, sizeof(p->aCol[0]));
drhcf9d36d2021-08-02 18:03:43 +00001557 pCol->zCnName = z;
drh3e992d12021-01-01 19:17:01 +00001558 pCol->hName = hName;
danba68f8f2015-11-19 16:46:46 +00001559 sqlite3ColumnPropertiesFromName(p, pCol);
danielk1977a37cdde2004-05-16 11:15:36 +00001560
drh77441fa2021-07-30 18:39:59 +00001561 if( sType.n==0 ){
drh2881ab62016-02-27 23:25:36 +00001562 /* If there is no type specified, columns have the default affinity
drhbbade8d2018-04-18 14:48:08 +00001563 ** 'BLOB' with a default size of 4 bytes. */
drhc2df4d62021-07-30 23:30:30 +00001564 pCol->affinity = affinity;
drhb70f2ea2021-08-18 12:05:22 +00001565 pCol->eCType = eType;
drhc2df4d62021-07-30 23:30:30 +00001566 pCol->szEst = szEst;
drhbbade8d2018-04-18 14:48:08 +00001567#ifdef SQLITE_ENABLE_SORTER_REFERENCES
drhc2df4d62021-07-30 23:30:30 +00001568 if( affinity==SQLITE_AFF_BLOB ){
1569 if( 4>=sqlite3GlobalConfig.szSorterRef ){
1570 pCol->colFlags |= COLFLAG_SORTERREF;
1571 }
dan2e3a5a82018-04-16 21:12:42 +00001572 }
drhbbade8d2018-04-18 14:48:08 +00001573#endif
drh2881ab62016-02-27 23:25:36 +00001574 }else{
drhddb2b4a2016-03-25 12:10:32 +00001575 zType = z + sqlite3Strlen30(z) + 1;
drh77441fa2021-07-30 18:39:59 +00001576 memcpy(zType, sType.z, sType.n);
1577 zType[sType.n] = 0;
drha6dddd92016-04-18 15:46:14 +00001578 sqlite3Dequote(zType);
dan2e3a5a82018-04-16 21:12:42 +00001579 pCol->affinity = sqlite3AffinityType(zType, pCol);
drhd7564862016-03-22 20:05:09 +00001580 pCol->colFlags |= COLFLAG_HASTYPE;
drh2881ab62016-02-27 23:25:36 +00001581 }
drhc9b84a12002-06-20 11:36:48 +00001582 p->nCol++;
drhf95909c2019-10-18 18:33:25 +00001583 p->nNVCol++;
drh986dde72016-02-29 13:37:21 +00001584 pParse->constraintName.n = 0;
drh75897232000-05-29 14:26:00 +00001585}
1586
1587/*
drh382c0242001-10-06 16:33:02 +00001588** This routine is called by the parser while in the middle of
1589** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1590** been seen on a column. This routine sets the notNull flag on
1591** the column currently under construction.
1592*/
danielk19774adee202004-05-08 08:23:19 +00001593void sqlite3AddNotNull(Parse *pParse, int onError){
drh382c0242001-10-06 16:33:02 +00001594 Table *p;
dan26e731c2018-01-29 16:22:39 +00001595 Column *pCol;
drhc4a64fa2009-05-11 20:53:28 +00001596 p = pParse->pNewTable;
1597 if( p==0 || NEVER(p->nCol<1) ) return;
dan26e731c2018-01-29 16:22:39 +00001598 pCol = &p->aCol[p->nCol-1];
1599 pCol->notNull = (u8)onError;
drh8b174f22017-02-22 15:11:36 +00001600 p->tabFlags |= TF_HasNotNull;
dan26e731c2018-01-29 16:22:39 +00001601
1602 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
1603 ** on this column. */
1604 if( pCol->colFlags & COLFLAG_UNIQUE ){
1605 Index *pIdx;
1606 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
1607 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
1608 if( pIdx->aiColumn[0]==p->nCol-1 ){
1609 pIdx->uniqNotNull = 1;
1610 }
1611 }
1612 }
drh382c0242001-10-06 16:33:02 +00001613}
1614
1615/*
danielk197752a83fb2005-01-31 12:56:44 +00001616** Scan the column type name zType (length nType) and return the
1617** associated affinity type.
danielk1977b3dff962005-02-01 01:21:55 +00001618**
1619** This routine does a case-independent search of zType for the
1620** substrings in the following table. If one of the substrings is
1621** found, the corresponding affinity is returned. If zType contains
1622** more than one of the substrings, entries toward the top of
1623** the table take priority. For example, if zType is 'BLOBINT',
drh8a512562005-11-14 22:29:05 +00001624** SQLITE_AFF_INTEGER is returned.
danielk1977b3dff962005-02-01 01:21:55 +00001625**
1626** Substring | Affinity
1627** --------------------------------
1628** 'INT' | SQLITE_AFF_INTEGER
1629** 'CHAR' | SQLITE_AFF_TEXT
1630** 'CLOB' | SQLITE_AFF_TEXT
1631** 'TEXT' | SQLITE_AFF_TEXT
drh05883a32015-06-02 15:32:08 +00001632** 'BLOB' | SQLITE_AFF_BLOB
drh8a512562005-11-14 22:29:05 +00001633** 'REAL' | SQLITE_AFF_REAL
1634** 'FLOA' | SQLITE_AFF_REAL
1635** 'DOUB' | SQLITE_AFF_REAL
danielk1977b3dff962005-02-01 01:21:55 +00001636**
1637** If none of the substrings in the above table are found,
1638** SQLITE_AFF_NUMERIC is returned.
danielk197752a83fb2005-01-31 12:56:44 +00001639*/
dan2e3a5a82018-04-16 21:12:42 +00001640char sqlite3AffinityType(const char *zIn, Column *pCol){
danielk1977b3dff962005-02-01 01:21:55 +00001641 u32 h = 0;
1642 char aff = SQLITE_AFF_NUMERIC;
drhd3037a42013-10-04 18:29:25 +00001643 const char *zChar = 0;
danielk197752a83fb2005-01-31 12:56:44 +00001644
drh2f1e02e2016-03-09 02:12:44 +00001645 assert( zIn!=0 );
drhfdaac672013-10-04 15:30:21 +00001646 while( zIn[0] ){
drhb7916a72009-05-27 10:31:29 +00001647 h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
danielk1977b3dff962005-02-01 01:21:55 +00001648 zIn++;
danielk1977201f7162005-02-01 02:13:29 +00001649 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
drhfdaac672013-10-04 15:30:21 +00001650 aff = SQLITE_AFF_TEXT;
1651 zChar = zIn;
danielk1977201f7162005-02-01 02:13:29 +00001652 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
1653 aff = SQLITE_AFF_TEXT;
1654 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
1655 aff = SQLITE_AFF_TEXT;
1656 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
drh8a512562005-11-14 22:29:05 +00001657 && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
drh05883a32015-06-02 15:32:08 +00001658 aff = SQLITE_AFF_BLOB;
drhd3037a42013-10-04 18:29:25 +00001659 if( zIn[0]=='(' ) zChar = zIn;
drh8a512562005-11-14 22:29:05 +00001660#ifndef SQLITE_OMIT_FLOATING_POINT
1661 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
1662 && aff==SQLITE_AFF_NUMERIC ){
1663 aff = SQLITE_AFF_REAL;
1664 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
1665 && aff==SQLITE_AFF_NUMERIC ){
1666 aff = SQLITE_AFF_REAL;
1667 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
1668 && aff==SQLITE_AFF_NUMERIC ){
1669 aff = SQLITE_AFF_REAL;
1670#endif
danielk1977201f7162005-02-01 02:13:29 +00001671 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
drh8a512562005-11-14 22:29:05 +00001672 aff = SQLITE_AFF_INTEGER;
danielk1977b3dff962005-02-01 01:21:55 +00001673 break;
danielk197752a83fb2005-01-31 12:56:44 +00001674 }
1675 }
drhd3037a42013-10-04 18:29:25 +00001676
dan2e3a5a82018-04-16 21:12:42 +00001677 /* If pCol is not NULL, store an estimate of the field size. The
drhd3037a42013-10-04 18:29:25 +00001678 ** estimate is scaled so that the size of an integer is 1. */
dan2e3a5a82018-04-16 21:12:42 +00001679 if( pCol ){
1680 int v = 0; /* default size is approx 4 bytes */
drh7ea31cc2014-09-18 14:36:00 +00001681 if( aff<SQLITE_AFF_NUMERIC ){
drhd3037a42013-10-04 18:29:25 +00001682 if( zChar ){
1683 while( zChar[0] ){
1684 if( sqlite3Isdigit(zChar[0]) ){
dan2e3a5a82018-04-16 21:12:42 +00001685 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
drhd3037a42013-10-04 18:29:25 +00001686 sqlite3GetInt32(zChar, &v);
drhd3037a42013-10-04 18:29:25 +00001687 break;
1688 }
1689 zChar++;
drhfdaac672013-10-04 15:30:21 +00001690 }
drhd3037a42013-10-04 18:29:25 +00001691 }else{
dan2e3a5a82018-04-16 21:12:42 +00001692 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
drhfdaac672013-10-04 15:30:21 +00001693 }
drhfdaac672013-10-04 15:30:21 +00001694 }
drhbbade8d2018-04-18 14:48:08 +00001695#ifdef SQLITE_ENABLE_SORTER_REFERENCES
dan2e3a5a82018-04-16 21:12:42 +00001696 if( v>=sqlite3GlobalConfig.szSorterRef ){
1697 pCol->colFlags |= COLFLAG_SORTERREF;
1698 }
drhbbade8d2018-04-18 14:48:08 +00001699#endif
dan2e3a5a82018-04-16 21:12:42 +00001700 v = v/4 + 1;
1701 if( v>255 ) v = 255;
1702 pCol->szEst = v;
drhfdaac672013-10-04 15:30:21 +00001703 }
danielk1977b3dff962005-02-01 01:21:55 +00001704 return aff;
danielk197752a83fb2005-01-31 12:56:44 +00001705}
1706
1707/*
danielk19777977a172004-11-09 12:44:37 +00001708** The expression is the default value for the most recently added column
1709** of the table currently under construction.
1710**
1711** Default value expressions must be constant. Raise an exception if this
1712** is not the case.
drhd9b02572001-04-15 00:37:09 +00001713**
1714** This routine is called by the parser while in the middle of
1715** parsing a CREATE TABLE statement.
drh7020f652000-06-03 18:06:52 +00001716*/
drh1be266b2017-12-24 00:18:47 +00001717void sqlite3AddDefaultValue(
1718 Parse *pParse, /* Parsing context */
1719 Expr *pExpr, /* The parsed expression of the default value */
1720 const char *zStart, /* Start of the default value text */
1721 const char *zEnd /* First character past end of defaut value text */
1722){
drh7020f652000-06-03 18:06:52 +00001723 Table *p;
danielk19777977a172004-11-09 12:44:37 +00001724 Column *pCol;
drh633e6d52008-07-28 19:34:53 +00001725 sqlite3 *db = pParse->db;
drhc4a64fa2009-05-11 20:53:28 +00001726 p = pParse->pNewTable;
1727 if( p!=0 ){
drh014fff22020-01-08 22:22:36 +00001728 int isInit = db->init.busy && db->init.iDb!=1;
drh42b9d7c2005-08-13 00:56:27 +00001729 pCol = &(p->aCol[p->nCol-1]);
drh014fff22020-01-08 22:22:36 +00001730 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
drh42b9d7c2005-08-13 00:56:27 +00001731 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
drhcf9d36d2021-08-02 18:03:43 +00001732 pCol->zCnName);
drh7e7fd732019-10-22 13:59:23 +00001733#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1734 }else if( pCol->colFlags & COLFLAG_GENERATED ){
drhab0992f2019-10-23 03:53:10 +00001735 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
1736 testcase( pCol->colFlags & COLFLAG_STORED );
drh7e7fd732019-10-22 13:59:23 +00001737 sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
1738#endif
drh42b9d7c2005-08-13 00:56:27 +00001739 }else{
danielk19776ab3a2e2009-02-19 14:39:25 +00001740 /* A copy of pExpr is used instead of the original, as pExpr contains
drh424981d2018-03-28 15:56:55 +00001741 ** tokens that point to volatile memory.
danielk19776ab3a2e2009-02-19 14:39:25 +00001742 */
drh79cf2b72021-07-31 20:30:41 +00001743 Expr x, *pDfltExpr;
drh94fa9c42016-02-27 21:16:04 +00001744 memset(&x, 0, sizeof(x));
1745 x.op = TK_SPAN;
drh9b2e0432017-12-27 19:43:22 +00001746 x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
drh1be266b2017-12-24 00:18:47 +00001747 x.pLeft = pExpr;
drh94fa9c42016-02-27 21:16:04 +00001748 x.flags = EP_Skip;
drh79cf2b72021-07-31 20:30:41 +00001749 pDfltExpr = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
drh94fa9c42016-02-27 21:16:04 +00001750 sqlite3DbFree(db, x.u.zToken);
drh79cf2b72021-07-31 20:30:41 +00001751 sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr);
drh42b9d7c2005-08-13 00:56:27 +00001752 }
danielk19777977a172004-11-09 12:44:37 +00001753 }
dan8900a482018-09-05 14:36:05 +00001754 if( IN_RENAME_OBJECT ){
1755 sqlite3RenameExprUnmap(pParse, pExpr);
1756 }
drh1be266b2017-12-24 00:18:47 +00001757 sqlite3ExprDelete(db, pExpr);
drh7020f652000-06-03 18:06:52 +00001758}
1759
1760/*
drh153110a2015-11-01 21:19:13 +00001761** Backwards Compatibility Hack:
1762**
1763** Historical versions of SQLite accepted strings as column names in
1764** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1765**
1766** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1767** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1768**
1769** This is goofy. But to preserve backwards compatibility we continue to
1770** accept it. This routine does the necessary conversion. It converts
1771** the expression given in its argument from a TK_STRING into a TK_ID
1772** if the expression is just a TK_STRING with an optional COLLATE clause.
drh6c591362019-04-27 20:16:42 +00001773** If the expression is anything other than TK_STRING, the expression is
drh153110a2015-11-01 21:19:13 +00001774** unchanged.
1775*/
1776static void sqlite3StringToId(Expr *p){
1777 if( p->op==TK_STRING ){
1778 p->op = TK_ID;
1779 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
1780 p->pLeft->op = TK_ID;
1781 }
1782}
1783
1784/*
drhf4b1d8d2019-10-22 15:45:03 +00001785** Tag the given column as being part of the PRIMARY KEY
1786*/
1787static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){
1788 pCol->colFlags |= COLFLAG_PRIMKEY;
1789#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1790 if( pCol->colFlags & COLFLAG_GENERATED ){
1791 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
1792 testcase( pCol->colFlags & COLFLAG_STORED );
1793 sqlite3ErrorMsg(pParse,
1794 "generated columns cannot be part of the PRIMARY KEY");
1795 }
1796#endif
1797}
1798
1799/*
drh4a324312001-12-21 14:30:42 +00001800** Designate the PRIMARY KEY for the table. pList is a list of names
1801** of columns that form the primary key. If pList is NULL, then the
1802** most recently added column of the table is the primary key.
1803**
1804** A table can have at most one primary key. If the table already has
1805** a primary key (and this is the second primary key) then create an
1806** error.
1807**
1808** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
drh23bf66d2004-12-14 03:34:34 +00001809** then we will try to use that column as the rowid. Set the Table.iPKey
drh4a324312001-12-21 14:30:42 +00001810** field of the table under construction to be the index of the
1811** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1812** no INTEGER PRIMARY KEY.
1813**
1814** If the key is not an INTEGER PRIMARY KEY, then create a unique
1815** index for the key. No index is created for INTEGER PRIMARY KEYs.
1816*/
drh205f48e2004-11-05 00:43:11 +00001817void sqlite3AddPrimaryKey(
1818 Parse *pParse, /* Parsing context */
1819 ExprList *pList, /* List of field names to be indexed */
1820 int onError, /* What to do with a uniqueness conflict */
drhfdd6e852005-12-16 01:06:16 +00001821 int autoInc, /* True if the AUTOINCREMENT keyword is present */
1822 int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
drh205f48e2004-11-05 00:43:11 +00001823){
drh4a324312001-12-21 14:30:42 +00001824 Table *pTab = pParse->pNewTable;
drhd7564862016-03-22 20:05:09 +00001825 Column *pCol = 0;
drh78100cc2003-08-23 22:40:53 +00001826 int iCol = -1, i;
drh8ea30bf2013-10-22 01:18:17 +00001827 int nTerm;
drh62340f82016-05-31 21:18:15 +00001828 if( pTab==0 ) goto primary_key_exit;
drh7d10d5a2008-08-20 16:35:10 +00001829 if( pTab->tabFlags & TF_HasPrimaryKey ){
danielk19774adee202004-05-08 08:23:19 +00001830 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00001831 "table \"%s\" has more than one primary key", pTab->zName);
drhe0194f22003-02-26 13:52:51 +00001832 goto primary_key_exit;
drh4a324312001-12-21 14:30:42 +00001833 }
drh7d10d5a2008-08-20 16:35:10 +00001834 pTab->tabFlags |= TF_HasPrimaryKey;
drh4a324312001-12-21 14:30:42 +00001835 if( pList==0 ){
1836 iCol = pTab->nCol - 1;
drhd7564862016-03-22 20:05:09 +00001837 pCol = &pTab->aCol[iCol];
drhf4b1d8d2019-10-22 15:45:03 +00001838 makeColumnPartOfPrimaryKey(pParse, pCol);
drh8ea30bf2013-10-22 01:18:17 +00001839 nTerm = 1;
drh78100cc2003-08-23 22:40:53 +00001840 }else{
drh8ea30bf2013-10-22 01:18:17 +00001841 nTerm = pList->nExpr;
1842 for(i=0; i<nTerm; i++){
drh108aa002015-08-24 20:21:20 +00001843 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
drh7d3d9da2015-09-01 00:42:52 +00001844 assert( pCExpr!=0 );
drh153110a2015-11-01 21:19:13 +00001845 sqlite3StringToId(pCExpr);
drh7d3d9da2015-09-01 00:42:52 +00001846 if( pCExpr->op==TK_ID ){
drhf9751072021-10-07 13:40:29 +00001847 const char *zCName;
1848 assert( !ExprHasProperty(pCExpr, EP_IntValue) );
1849 zCName = pCExpr->u.zToken;
drh108aa002015-08-24 20:21:20 +00001850 for(iCol=0; iCol<pTab->nCol; iCol++){
drhcf9d36d2021-08-02 18:03:43 +00001851 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
drhd7564862016-03-22 20:05:09 +00001852 pCol = &pTab->aCol[iCol];
drhf4b1d8d2019-10-22 15:45:03 +00001853 makeColumnPartOfPrimaryKey(pParse, pCol);
drh108aa002015-08-24 20:21:20 +00001854 break;
1855 }
drhd3d39e92004-05-20 22:16:29 +00001856 }
drh78100cc2003-08-23 22:40:53 +00001857 }
drh4a324312001-12-21 14:30:42 +00001858 }
1859 }
drh8ea30bf2013-10-22 01:18:17 +00001860 if( nTerm==1
drhd7564862016-03-22 20:05:09 +00001861 && pCol
drhb70f2ea2021-08-18 12:05:22 +00001862 && pCol->eCType==COLTYPE_INTEGER
drhbc622bc2015-08-24 15:39:42 +00001863 && sortOrder!=SQLITE_SO_DESC
drh8ea30bf2013-10-22 01:18:17 +00001864 ){
danc9461ec2018-08-29 21:00:16 +00001865 if( IN_RENAME_OBJECT && pList ){
dan2381f6d2019-03-20 16:58:21 +00001866 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
1867 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
dan987db762018-08-14 20:18:50 +00001868 }
drh4a324312001-12-21 14:30:42 +00001869 pTab->iPKey = iCol;
drh1bd10f82008-12-10 21:19:56 +00001870 pTab->keyConf = (u8)onError;
drh7d10d5a2008-08-20 16:35:10 +00001871 assert( autoInc==0 || autoInc==1 );
1872 pTab->tabFlags |= autoInc*TF_Autoincrement;
dan6e118922019-08-12 16:36:38 +00001873 if( pList ) pParse->iPkSortOrder = pList->a[0].sortFlags;
drh34ab9412019-12-19 17:42:27 +00001874 (void)sqlite3HasExplicitNulls(pParse, pList);
drh205f48e2004-11-05 00:43:11 +00001875 }else if( autoInc ){
drh4794f732004-11-05 17:17:50 +00001876#ifndef SQLITE_OMIT_AUTOINCREMENT
drh205f48e2004-11-05 00:43:11 +00001877 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
1878 "INTEGER PRIMARY KEY");
drh4794f732004-11-05 17:17:50 +00001879#endif
drh4a324312001-12-21 14:30:42 +00001880 }else{
drh62340f82016-05-31 21:18:15 +00001881 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
1882 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
drhe0194f22003-02-26 13:52:51 +00001883 pList = 0;
drh4a324312001-12-21 14:30:42 +00001884 }
drhe0194f22003-02-26 13:52:51 +00001885
1886primary_key_exit:
drh633e6d52008-07-28 19:34:53 +00001887 sqlite3ExprListDelete(pParse->db, pList);
drhe0194f22003-02-26 13:52:51 +00001888 return;
drh4a324312001-12-21 14:30:42 +00001889}
1890
1891/*
drhffe07b22005-11-03 00:41:17 +00001892** Add a new CHECK constraint to the table currently under construction.
1893*/
1894void sqlite3AddCheckConstraint(
drh92e21ef2020-08-27 18:36:30 +00001895 Parse *pParse, /* Parsing context */
1896 Expr *pCheckExpr, /* The check expression */
1897 const char *zStart, /* Opening "(" */
1898 const char *zEnd /* Closing ")" */
drhffe07b22005-11-03 00:41:17 +00001899){
1900#ifndef SQLITE_OMIT_CHECK
1901 Table *pTab = pParse->pNewTable;
drhc9bbb012014-05-21 08:48:18 +00001902 sqlite3 *db = pParse->db;
1903 if( pTab && !IN_DECLARE_VTAB
1904 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
1905 ){
drh2938f922012-03-07 19:13:29 +00001906 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
1907 if( pParse->constraintName.n ){
1908 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
drh92e21ef2020-08-27 18:36:30 +00001909 }else{
1910 Token t;
1911 for(zStart++; sqlite3Isspace(zStart[0]); zStart++){}
1912 while( sqlite3Isspace(zEnd[-1]) ){ zEnd--; }
1913 t.z = zStart;
1914 t.n = (int)(zEnd - t.z);
1915 sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
drh2938f922012-03-07 19:13:29 +00001916 }
drh33e619f2009-05-28 01:00:55 +00001917 }else
drhffe07b22005-11-03 00:41:17 +00001918#endif
drh33e619f2009-05-28 01:00:55 +00001919 {
drh2938f922012-03-07 19:13:29 +00001920 sqlite3ExprDelete(pParse->db, pCheckExpr);
drh33e619f2009-05-28 01:00:55 +00001921 }
drhffe07b22005-11-03 00:41:17 +00001922}
1923
1924/*
drhd3d39e92004-05-20 22:16:29 +00001925** Set the collation function of the most recently parsed table column
1926** to the CollSeq given.
drh8e2ca022002-06-17 17:07:19 +00001927*/
danielk197739002502007-11-12 09:50:26 +00001928void sqlite3AddCollateType(Parse *pParse, Token *pToken){
drh8e2ca022002-06-17 17:07:19 +00001929 Table *p;
danielk19770202b292004-06-09 09:55:16 +00001930 int i;
danielk197739002502007-11-12 09:50:26 +00001931 char *zColl; /* Dequoted name of collation sequence */
drh633e6d52008-07-28 19:34:53 +00001932 sqlite3 *db;
danielk1977a37cdde2004-05-16 11:15:36 +00001933
dan936a3052020-10-12 15:27:50 +00001934 if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return;
danielk19770202b292004-06-09 09:55:16 +00001935 i = p->nCol-1;
drh633e6d52008-07-28 19:34:53 +00001936 db = pParse->db;
1937 zColl = sqlite3NameFromToken(db, pToken);
danielk197739002502007-11-12 09:50:26 +00001938 if( !zColl ) return;
1939
drhc4a64fa2009-05-11 20:53:28 +00001940 if( sqlite3LocateCollSeq(pParse, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00001941 Index *pIdx;
drh65b40092021-08-05 15:27:19 +00001942 sqlite3ColumnSetColl(db, &p->aCol[i], zColl);
danielk1977b3bf5562006-01-10 17:58:23 +00001943
1944 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1945 ** then an index may have been created on this column before the
1946 ** collation type was added. Correct this if it is the case.
1947 */
1948 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhbbbdc832013-10-22 18:01:40 +00001949 assert( pIdx->nKeyCol==1 );
danielk1977b3bf5562006-01-10 17:58:23 +00001950 if( pIdx->aiColumn[0]==i ){
drh65b40092021-08-05 15:27:19 +00001951 pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]);
danielk19777cedc8d2004-06-10 10:50:08 +00001952 }
1953 }
1954 }
drh65b40092021-08-05 15:27:19 +00001955 sqlite3DbFree(db, zColl);
danielk19777cedc8d2004-06-10 10:50:08 +00001956}
1957
drh81f7b372019-10-16 12:18:59 +00001958/* Change the most recently parsed column to be a GENERATED ALWAYS AS
1959** column.
1960*/
1961void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
1962#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1963 u8 eType = COLFLAG_VIRTUAL;
1964 Table *pTab = pParse->pNewTable;
1965 Column *pCol;
drhf68bf5f2019-12-04 03:31:29 +00001966 if( pTab==0 ){
1967 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
1968 goto generated_done;
1969 }
drh81f7b372019-10-16 12:18:59 +00001970 pCol = &(pTab->aCol[pTab->nCol-1]);
drhb9bcf7c2019-10-19 13:29:10 +00001971 if( IN_DECLARE_VTAB ){
1972 sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
1973 goto generated_done;
1974 }
drh79cf2b72021-07-31 20:30:41 +00001975 if( pCol->iDflt>0 ) goto generated_error;
drh81f7b372019-10-16 12:18:59 +00001976 if( pType ){
1977 if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
1978 /* no-op */
1979 }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
1980 eType = COLFLAG_STORED;
1981 }else{
1982 goto generated_error;
1983 }
1984 }
drhf95909c2019-10-18 18:33:25 +00001985 if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
drh81f7b372019-10-16 12:18:59 +00001986 pCol->colFlags |= eType;
drhc1431142019-10-17 17:54:05 +00001987 assert( TF_HasVirtual==COLFLAG_VIRTUAL );
1988 assert( TF_HasStored==COLFLAG_STORED );
1989 pTab->tabFlags |= eType;
drha0e16a22019-10-27 22:22:24 +00001990 if( pCol->colFlags & COLFLAG_PRIMKEY ){
1991 makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
1992 }
drh79cf2b72021-07-31 20:30:41 +00001993 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
drhb9bcf7c2019-10-19 13:29:10 +00001994 pExpr = 0;
drh81f7b372019-10-16 12:18:59 +00001995 goto generated_done;
1996
1997generated_error:
drh7e7fd732019-10-22 13:59:23 +00001998 sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
drhcf9d36d2021-08-02 18:03:43 +00001999 pCol->zCnName);
drh81f7b372019-10-16 12:18:59 +00002000generated_done:
2001 sqlite3ExprDelete(pParse->db, pExpr);
2002#else
2003 /* Throw and error for the GENERATED ALWAYS AS clause if the
2004 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
drh7e7fd732019-10-22 13:59:23 +00002005 sqlite3ErrorMsg(pParse, "generated columns not supported");
drh81f7b372019-10-16 12:18:59 +00002006 sqlite3ExprDelete(pParse->db, pExpr);
2007#endif
2008}
2009
danielk1977466be562004-06-10 02:16:01 +00002010/*
drh3f7d4e42004-07-24 14:35:58 +00002011** Generate code that will increment the schema cookie.
drh50e5dad2001-09-15 00:57:28 +00002012**
2013** The schema cookie is used to determine when the schema for the
2014** database changes. After each schema change, the cookie value
2015** changes. When a process first reads the schema it records the
2016** cookie. Thereafter, whenever it goes to access the database,
2017** it checks the cookie to make sure the schema has not changed
2018** since it was last read.
2019**
2020** This plan is not completely bullet-proof. It is possible for
2021** the schema to change multiple times and for the cookie to be
2022** set back to prior value. But schema changes are infrequent
2023** and the probability of hitting the same cookie value is only
2024** 1 chance in 2^32. So we're safe enough.
drh96fdcb42016-09-27 00:09:33 +00002025**
2026** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
2027** the schema-version whenever the schema changes.
drh50e5dad2001-09-15 00:57:28 +00002028*/
drh9cbf3422008-01-17 16:22:13 +00002029void sqlite3ChangeCookie(Parse *pParse, int iDb){
drh9cbf3422008-01-17 16:22:13 +00002030 sqlite3 *db = pParse->db;
2031 Vdbe *v = pParse->pVdbe;
drh21206082011-04-04 18:22:02 +00002032 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh1861afc2016-02-01 21:48:34 +00002033 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
drh3517b312018-04-09 00:46:42 +00002034 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
drh50e5dad2001-09-15 00:57:28 +00002035}
2036
2037/*
drh969fa7c2002-02-18 18:30:32 +00002038** Measure the number of characters needed to output the given
2039** identifier. The number returned includes any quotes used
2040** but does not include the null terminator.
drh234c39d2004-07-24 03:30:47 +00002041**
2042** The estimate is conservative. It might be larger that what is
2043** really needed.
drh969fa7c2002-02-18 18:30:32 +00002044*/
2045static int identLength(const char *z){
2046 int n;
drh17f71932002-02-21 12:01:27 +00002047 for(n=0; *z; n++, z++){
drh234c39d2004-07-24 03:30:47 +00002048 if( *z=='"' ){ n++; }
drh969fa7c2002-02-18 18:30:32 +00002049 }
drh234c39d2004-07-24 03:30:47 +00002050 return n + 2;
drh969fa7c2002-02-18 18:30:32 +00002051}
2052
2053/*
danielk19771b870de2009-03-14 08:37:23 +00002054** The first parameter is a pointer to an output buffer. The second
2055** parameter is a pointer to an integer that contains the offset at
2056** which to write into the output buffer. This function copies the
2057** nul-terminated string pointed to by the third parameter, zSignedIdent,
2058** to the specified offset in the buffer and updates *pIdx to refer
2059** to the first byte after the last byte written before returning.
2060**
2061** If the string zSignedIdent consists entirely of alpha-numeric
2062** characters, does not begin with a digit and is not an SQL keyword,
2063** then it is copied to the output buffer exactly as it is. Otherwise,
2064** it is quoted using double-quotes.
2065*/
drhc4a64fa2009-05-11 20:53:28 +00002066static void identPut(char *z, int *pIdx, char *zSignedIdent){
drh4c755c02004-08-08 20:22:17 +00002067 unsigned char *zIdent = (unsigned char*)zSignedIdent;
drh17f71932002-02-21 12:01:27 +00002068 int i, j, needQuote;
drh969fa7c2002-02-18 18:30:32 +00002069 i = *pIdx;
danielk19771b870de2009-03-14 08:37:23 +00002070
drh17f71932002-02-21 12:01:27 +00002071 for(j=0; zIdent[j]; j++){
danielk197778ca0e72009-01-20 16:53:39 +00002072 if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
drh17f71932002-02-21 12:01:27 +00002073 }
drhc7407522014-01-10 20:38:12 +00002074 needQuote = sqlite3Isdigit(zIdent[0])
2075 || sqlite3KeywordCode(zIdent, j)!=TK_ID
2076 || zIdent[j]!=0
2077 || j==0;
danielk19771b870de2009-03-14 08:37:23 +00002078
drh234c39d2004-07-24 03:30:47 +00002079 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00002080 for(j=0; zIdent[j]; j++){
2081 z[i++] = zIdent[j];
drh234c39d2004-07-24 03:30:47 +00002082 if( zIdent[j]=='"' ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00002083 }
drh234c39d2004-07-24 03:30:47 +00002084 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00002085 z[i] = 0;
2086 *pIdx = i;
2087}
2088
2089/*
2090** Generate a CREATE TABLE statement appropriate for the given
2091** table. Memory to hold the text of the statement is obtained
2092** from sqliteMalloc() and must be freed by the calling function.
2093*/
drh1d34fde2009-02-03 15:50:33 +00002094static char *createTableStmt(sqlite3 *db, Table *p){
drh969fa7c2002-02-18 18:30:32 +00002095 int i, k, n;
2096 char *zStmt;
drhc4a64fa2009-05-11 20:53:28 +00002097 char *zSep, *zSep2, *zEnd;
drh234c39d2004-07-24 03:30:47 +00002098 Column *pCol;
drh969fa7c2002-02-18 18:30:32 +00002099 n = 0;
drh234c39d2004-07-24 03:30:47 +00002100 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
drhcf9d36d2021-08-02 18:03:43 +00002101 n += identLength(pCol->zCnName) + 5;
drh969fa7c2002-02-18 18:30:32 +00002102 }
2103 n += identLength(p->zName);
drhc4a64fa2009-05-11 20:53:28 +00002104 if( n<50 ){
drh969fa7c2002-02-18 18:30:32 +00002105 zSep = "";
2106 zSep2 = ",";
2107 zEnd = ")";
2108 }else{
2109 zSep = "\n ";
2110 zSep2 = ",\n ";
2111 zEnd = "\n)";
2112 }
drhe0bc4042002-06-25 01:09:11 +00002113 n += 35 + 6*p->nCol;
drhb9755982010-07-24 16:34:37 +00002114 zStmt = sqlite3DbMallocRaw(0, n);
drh820a9062008-01-31 13:35:48 +00002115 if( zStmt==0 ){
drh4a642b62016-02-05 01:55:27 +00002116 sqlite3OomFault(db);
drh820a9062008-01-31 13:35:48 +00002117 return 0;
2118 }
drhbdb339f2009-02-02 18:03:21 +00002119 sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
drhea678832008-12-10 19:26:22 +00002120 k = sqlite3Strlen30(zStmt);
drhc4a64fa2009-05-11 20:53:28 +00002121 identPut(zStmt, &k, p->zName);
drh969fa7c2002-02-18 18:30:32 +00002122 zStmt[k++] = '(';
drh234c39d2004-07-24 03:30:47 +00002123 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
drhc4a64fa2009-05-11 20:53:28 +00002124 static const char * const azType[] = {
drh05883a32015-06-02 15:32:08 +00002125 /* SQLITE_AFF_BLOB */ "",
drh7ea31cc2014-09-18 14:36:00 +00002126 /* SQLITE_AFF_TEXT */ " TEXT",
drhc4a64fa2009-05-11 20:53:28 +00002127 /* SQLITE_AFF_NUMERIC */ " NUM",
2128 /* SQLITE_AFF_INTEGER */ " INT",
2129 /* SQLITE_AFF_REAL */ " REAL"
2130 };
2131 int len;
2132 const char *zType;
2133
drh5bb3eb92007-05-04 13:15:55 +00002134 sqlite3_snprintf(n-k, &zStmt[k], zSep);
drhea678832008-12-10 19:26:22 +00002135 k += sqlite3Strlen30(&zStmt[k]);
drh969fa7c2002-02-18 18:30:32 +00002136 zSep = zSep2;
drhcf9d36d2021-08-02 18:03:43 +00002137 identPut(zStmt, &k, pCol->zCnName);
drh05883a32015-06-02 15:32:08 +00002138 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
2139 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
2140 testcase( pCol->affinity==SQLITE_AFF_BLOB );
drh7ea31cc2014-09-18 14:36:00 +00002141 testcase( pCol->affinity==SQLITE_AFF_TEXT );
drhc4a64fa2009-05-11 20:53:28 +00002142 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
2143 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
2144 testcase( pCol->affinity==SQLITE_AFF_REAL );
2145
drh05883a32015-06-02 15:32:08 +00002146 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
drhc4a64fa2009-05-11 20:53:28 +00002147 len = sqlite3Strlen30(zType);
drh05883a32015-06-02 15:32:08 +00002148 assert( pCol->affinity==SQLITE_AFF_BLOB
drhfdaac672013-10-04 15:30:21 +00002149 || pCol->affinity==sqlite3AffinityType(zType, 0) );
drhc4a64fa2009-05-11 20:53:28 +00002150 memcpy(&zStmt[k], zType, len);
2151 k += len;
2152 assert( k<=n );
drh969fa7c2002-02-18 18:30:32 +00002153 }
drh5bb3eb92007-05-04 13:15:55 +00002154 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
drh969fa7c2002-02-18 18:30:32 +00002155 return zStmt;
2156}
2157
2158/*
drh7f9c5db2013-10-23 00:32:58 +00002159** Resize an Index object to hold N columns total. Return SQLITE_OK
2160** on success and SQLITE_NOMEM on an OOM error.
2161*/
2162static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
2163 char *zExtra;
2164 int nByte;
2165 if( pIdx->nColumn>=N ) return SQLITE_OK;
2166 assert( pIdx->isResized==0 );
danb5a69232020-09-15 20:48:30 +00002167 nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*N;
drh7f9c5db2013-10-23 00:32:58 +00002168 zExtra = sqlite3DbMallocZero(db, nByte);
mistachkinfad30392016-02-13 23:43:46 +00002169 if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
drh7f9c5db2013-10-23 00:32:58 +00002170 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
drhf19aa5f2015-12-30 16:51:20 +00002171 pIdx->azColl = (const char**)zExtra;
drh7f9c5db2013-10-23 00:32:58 +00002172 zExtra += sizeof(char*)*N;
danb5a69232020-09-15 20:48:30 +00002173 memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
2174 pIdx->aiRowLogEst = (LogEst*)zExtra;
2175 zExtra += sizeof(LogEst)*N;
drh7f9c5db2013-10-23 00:32:58 +00002176 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
2177 pIdx->aiColumn = (i16*)zExtra;
2178 zExtra += sizeof(i16)*N;
2179 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
2180 pIdx->aSortOrder = (u8*)zExtra;
2181 pIdx->nColumn = N;
2182 pIdx->isResized = 1;
2183 return SQLITE_OK;
2184}
2185
2186/*
drhfdaac672013-10-04 15:30:21 +00002187** Estimate the total row width for a table.
2188*/
drhe13e9f52013-10-05 19:18:00 +00002189static void estimateTableWidth(Table *pTab){
drhfdaac672013-10-04 15:30:21 +00002190 unsigned wTable = 0;
2191 const Column *pTabCol;
2192 int i;
2193 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
2194 wTable += pTabCol->szEst;
2195 }
2196 if( pTab->iPKey<0 ) wTable++;
drhe13e9f52013-10-05 19:18:00 +00002197 pTab->szTabRow = sqlite3LogEst(wTable*4);
drhfdaac672013-10-04 15:30:21 +00002198}
2199
2200/*
drhe13e9f52013-10-05 19:18:00 +00002201** Estimate the average size of a row for an index.
drhfdaac672013-10-04 15:30:21 +00002202*/
drhe13e9f52013-10-05 19:18:00 +00002203static void estimateIndexWidth(Index *pIdx){
drhbbbdc832013-10-22 18:01:40 +00002204 unsigned wIndex = 0;
drhfdaac672013-10-04 15:30:21 +00002205 int i;
2206 const Column *aCol = pIdx->pTable->aCol;
2207 for(i=0; i<pIdx->nColumn; i++){
drhbbbdc832013-10-22 18:01:40 +00002208 i16 x = pIdx->aiColumn[i];
2209 assert( x<pIdx->pTable->nCol );
2210 wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
drhfdaac672013-10-04 15:30:21 +00002211 }
drhe13e9f52013-10-05 19:18:00 +00002212 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
drhfdaac672013-10-04 15:30:21 +00002213}
2214
drhf78d0f42019-04-28 19:27:02 +00002215/* Return true if column number x is any of the first nCol entries of aiCol[].
2216** This is used to determine if the column number x appears in any of the
2217** first nCol entries of an index.
drh7f9c5db2013-10-23 00:32:58 +00002218*/
2219static int hasColumn(const i16 *aiCol, int nCol, int x){
drhf78d0f42019-04-28 19:27:02 +00002220 while( nCol-- > 0 ){
drhf78d0f42019-04-28 19:27:02 +00002221 if( x==*(aiCol++) ){
2222 return 1;
2223 }
2224 }
2225 return 0;
2226}
2227
2228/*
drhc19b63c2019-04-29 13:30:16 +00002229** Return true if any of the first nKey entries of index pIdx exactly
2230** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
2231** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
2232** or may not be the same index as pPk.
drhf78d0f42019-04-28 19:27:02 +00002233**
drhc19b63c2019-04-29 13:30:16 +00002234** The first nKey entries of pIdx are guaranteed to be ordinary columns,
drhf78d0f42019-04-28 19:27:02 +00002235** not a rowid or expression.
2236**
2237** This routine differs from hasColumn() in that both the column and the
2238** collating sequence must match for this routine, but for hasColumn() only
2239** the column name must match.
2240*/
drhc19b63c2019-04-29 13:30:16 +00002241static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
drhf78d0f42019-04-28 19:27:02 +00002242 int i, j;
drhc19b63c2019-04-29 13:30:16 +00002243 assert( nKey<=pIdx->nColumn );
2244 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
2245 assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
2246 assert( pPk->pTable->tabFlags & TF_WithoutRowid );
2247 assert( pPk->pTable==pIdx->pTable );
2248 testcase( pPk==pIdx );
2249 j = pPk->aiColumn[iCol];
2250 assert( j!=XN_ROWID && j!=XN_EXPR );
drhf78d0f42019-04-28 19:27:02 +00002251 for(i=0; i<nKey; i++){
drhc19b63c2019-04-29 13:30:16 +00002252 assert( pIdx->aiColumn[i]>=0 || j>=0 );
2253 if( pIdx->aiColumn[i]==j
2254 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
drhf78d0f42019-04-28 19:27:02 +00002255 ){
2256 return 1;
2257 }
2258 }
drh7f9c5db2013-10-23 00:32:58 +00002259 return 0;
2260}
2261
drh1fe3ac72018-06-09 01:12:08 +00002262/* Recompute the colNotIdxed field of the Index.
2263**
2264** colNotIdxed is a bitmask that has a 0 bit representing each indexed
2265** columns that are within the first 63 columns of the table. The
2266** high-order bit of colNotIdxed is always 1. All unindexed columns
2267** of the table have a 1.
2268**
drhc7476732019-10-24 20:29:25 +00002269** 2019-10-24: For the purpose of this computation, virtual columns are
2270** not considered to be covered by the index, even if they are in the
2271** index, because we do not trust the logic in whereIndexExprTrans() to be
2272** able to find all instances of a reference to the indexed table column
2273** and convert them into references to the index. Hence we always want
2274** the actual table at hand in order to recompute the virtual column, if
2275** necessary.
2276**
drh1fe3ac72018-06-09 01:12:08 +00002277** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
2278** to determine if the index is covering index.
2279*/
2280static void recomputeColumnsNotIndexed(Index *pIdx){
2281 Bitmask m = 0;
2282 int j;
drhc7476732019-10-24 20:29:25 +00002283 Table *pTab = pIdx->pTable;
drh1fe3ac72018-06-09 01:12:08 +00002284 for(j=pIdx->nColumn-1; j>=0; j--){
2285 int x = pIdx->aiColumn[j];
drhc7476732019-10-24 20:29:25 +00002286 if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
drh1fe3ac72018-06-09 01:12:08 +00002287 testcase( x==BMS-1 );
2288 testcase( x==BMS-2 );
2289 if( x<BMS-1 ) m |= MASKBIT(x);
2290 }
2291 }
2292 pIdx->colNotIdxed = ~m;
2293 assert( (pIdx->colNotIdxed>>63)==1 );
2294}
2295
drh7f9c5db2013-10-23 00:32:58 +00002296/*
drhc6bd4e42013-11-02 14:37:18 +00002297** This routine runs at the end of parsing a CREATE TABLE statement that
2298** has a WITHOUT ROWID clause. The job of this routine is to convert both
2299** internal schema data structures and the generated VDBE code so that they
2300** are appropriate for a WITHOUT ROWID table instead of a rowid table.
2301** Changes include:
drh7f9c5db2013-10-23 00:32:58 +00002302**
drh62340f82016-05-31 21:18:15 +00002303** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
drh0f3f7662017-08-18 14:34:28 +00002304** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
2305** into BTREE_BLOBKEY.
drh1e32bed2020-06-19 13:33:53 +00002306** (3) Bypass the creation of the sqlite_schema table entry
peter.d.reid60ec9142014-09-06 16:39:46 +00002307** for the PRIMARY KEY as the primary key index is now
drh1e32bed2020-06-19 13:33:53 +00002308** identified by the sqlite_schema table entry of the table itself.
drh62340f82016-05-31 21:18:15 +00002309** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
drhc6bd4e42013-11-02 14:37:18 +00002310** schema to the rootpage from the main table.
drhc6bd4e42013-11-02 14:37:18 +00002311** (5) Add all table columns to the PRIMARY KEY Index object
2312** so that the PRIMARY KEY is a covering index. The surplus
drha485ad12017-08-02 22:43:14 +00002313** columns are part of KeyInfo.nAllField and are not used for
drhc6bd4e42013-11-02 14:37:18 +00002314** sorting or lookup or uniqueness checks.
2315** (6) Replace the rowid tail on all automatically generated UNIQUE
2316** indices with the PRIMARY KEY columns.
drh62340f82016-05-31 21:18:15 +00002317**
2318** For virtual tables, only (1) is performed.
drh7f9c5db2013-10-23 00:32:58 +00002319*/
2320static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
2321 Index *pIdx;
2322 Index *pPk;
2323 int nPk;
dan1ff94072019-07-17 09:18:06 +00002324 int nExtra;
drh7f9c5db2013-10-23 00:32:58 +00002325 int i, j;
2326 sqlite3 *db = pParse->db;
drhc6bd4e42013-11-02 14:37:18 +00002327 Vdbe *v = pParse->pVdbe;
drh7f9c5db2013-10-23 00:32:58 +00002328
drh62340f82016-05-31 21:18:15 +00002329 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
2330 */
2331 if( !db->init.imposterTable ){
2332 for(i=0; i<pTab->nCol; i++){
drhfd46ec62021-08-18 22:26:51 +00002333 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
2334 && (pTab->aCol[i].notNull==OE_None)
2335 ){
drh62340f82016-05-31 21:18:15 +00002336 pTab->aCol[i].notNull = OE_Abort;
2337 }
2338 }
drhcbda9c72019-10-26 17:08:06 +00002339 pTab->tabFlags |= TF_HasNotNull;
drh62340f82016-05-31 21:18:15 +00002340 }
2341
drh0f3f7662017-08-18 14:34:28 +00002342 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
2343 ** into BTREE_BLOBKEY.
drh7f9c5db2013-10-23 00:32:58 +00002344 */
drh381bdac2021-02-04 17:29:04 +00002345 assert( !pParse->bReturning );
2346 if( pParse->u1.addrCrTab ){
drhc6bd4e42013-11-02 14:37:18 +00002347 assert( v );
drh381bdac2021-02-04 17:29:04 +00002348 sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY);
drhc6bd4e42013-11-02 14:37:18 +00002349 }
2350
drh7f9c5db2013-10-23 00:32:58 +00002351 /* Locate the PRIMARY KEY index. Or, if this table was originally
2352 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
2353 */
2354 if( pTab->iPKey>=0 ){
2355 ExprList *pList;
drh108aa002015-08-24 20:21:20 +00002356 Token ipkToken;
drhcf9d36d2021-08-02 18:03:43 +00002357 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
drh108aa002015-08-24 20:21:20 +00002358 pList = sqlite3ExprListAppend(pParse, 0,
2359 sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
drh1bb89e92021-04-19 18:03:52 +00002360 if( pList==0 ){
2361 pTab->tabFlags &= ~TF_WithoutRowid;
2362 return;
2363 }
danf9b0c452019-05-06 16:15:28 +00002364 if( IN_RENAME_OBJECT ){
2365 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
2366 }
dan6e118922019-08-12 16:36:38 +00002367 pList->a[0].sortFlags = pParse->iPkSortOrder;
drh7f9c5db2013-10-23 00:32:58 +00002368 assert( pParse->pNewTable==pTab );
danf9b0c452019-05-06 16:15:28 +00002369 pTab->iPKey = -1;
drh62340f82016-05-31 21:18:15 +00002370 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
2371 SQLITE_IDXTYPE_PRIMARYKEY);
drh3bb9d752021-04-13 13:48:31 +00002372 if( db->mallocFailed || pParse->nErr ){
2373 pTab->tabFlags &= ~TF_WithoutRowid;
2374 return;
2375 }
drh62340f82016-05-31 21:18:15 +00002376 pPk = sqlite3PrimaryKeyIndex(pTab);
dan1ff94072019-07-17 09:18:06 +00002377 assert( pPk->nKeyCol==1 );
drh44156282013-10-23 22:23:03 +00002378 }else{
2379 pPk = sqlite3PrimaryKeyIndex(pTab);
drhf0c48b12019-02-11 01:58:34 +00002380 assert( pPk!=0 );
danc5b73582015-05-26 11:53:14 +00002381
drhe385d882014-12-28 22:10:51 +00002382 /*
2383 ** Remove all redundant columns from the PRIMARY KEY. For example, change
2384 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
2385 ** code assumes the PRIMARY KEY contains no repeated columns.
2386 */
2387 for(i=j=1; i<pPk->nKeyCol; i++){
drhf78d0f42019-04-28 19:27:02 +00002388 if( isDupColumn(pPk, j, pPk, i) ){
drhe385d882014-12-28 22:10:51 +00002389 pPk->nColumn--;
2390 }else{
drhf78d0f42019-04-28 19:27:02 +00002391 testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
dan1ff94072019-07-17 09:18:06 +00002392 pPk->azColl[j] = pPk->azColl[i];
2393 pPk->aSortOrder[j] = pPk->aSortOrder[i];
drhe385d882014-12-28 22:10:51 +00002394 pPk->aiColumn[j++] = pPk->aiColumn[i];
2395 }
2396 }
2397 pPk->nKeyCol = j;
drh7f9c5db2013-10-23 00:32:58 +00002398 }
drh7f9c5db2013-10-23 00:32:58 +00002399 assert( pPk!=0 );
drh62340f82016-05-31 21:18:15 +00002400 pPk->isCovering = 1;
2401 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
dan1ff94072019-07-17 09:18:06 +00002402 nPk = pPk->nColumn = pPk->nKeyCol;
drh7f9c5db2013-10-23 00:32:58 +00002403
drh1e32bed2020-06-19 13:33:53 +00002404 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema
drhdf949662017-07-30 18:40:52 +00002405 ** table entry. This is only required if currently generating VDBE
2406 ** code for a CREATE TABLE (not when parsing one as part of reading
2407 ** a database schema). */
2408 if( v && pPk->tnum>0 ){
2409 assert( db->init.busy==0 );
drhabc38152020-07-22 13:38:04 +00002410 sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
drhdf949662017-07-30 18:40:52 +00002411 }
2412
drhc6bd4e42013-11-02 14:37:18 +00002413 /* The root page of the PRIMARY KEY is the table root page */
2414 pPk->tnum = pTab->tnum;
2415
drh7f9c5db2013-10-23 00:32:58 +00002416 /* Update the in-memory representation of all UNIQUE indices by converting
2417 ** the final rowid column into one or more columns of the PRIMARY KEY.
2418 */
2419 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2420 int n;
drh48dd1d82014-05-27 18:18:58 +00002421 if( IsPrimaryKeyIndex(pIdx) ) continue;
drh7f9c5db2013-10-23 00:32:58 +00002422 for(i=n=0; i<nPk; i++){
drhf78d0f42019-04-28 19:27:02 +00002423 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
2424 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
2425 n++;
2426 }
drh7f9c5db2013-10-23 00:32:58 +00002427 }
drh5a9a37b2013-11-05 17:30:04 +00002428 if( n==0 ){
2429 /* This index is a superset of the primary key */
2430 pIdx->nColumn = pIdx->nKeyCol;
2431 continue;
2432 }
drh7f9c5db2013-10-23 00:32:58 +00002433 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
2434 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
drhf78d0f42019-04-28 19:27:02 +00002435 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
2436 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
drh7f9c5db2013-10-23 00:32:58 +00002437 pIdx->aiColumn[j] = pPk->aiColumn[i];
2438 pIdx->azColl[j] = pPk->azColl[i];
drhbf9ff252019-05-14 00:43:13 +00002439 if( pPk->aSortOrder[i] ){
2440 /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
2441 pIdx->bAscKeyBug = 1;
2442 }
drh7f9c5db2013-10-23 00:32:58 +00002443 j++;
2444 }
2445 }
drh00012df2013-11-05 01:59:07 +00002446 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
2447 assert( pIdx->nColumn>=j );
drh7f9c5db2013-10-23 00:32:58 +00002448 }
2449
2450 /* Add all table columns to the PRIMARY KEY index
2451 */
dan1ff94072019-07-17 09:18:06 +00002452 nExtra = 0;
2453 for(i=0; i<pTab->nCol; i++){
drh8e10d742019-10-18 17:42:47 +00002454 if( !hasColumn(pPk->aiColumn, nPk, i)
2455 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
drh7f9c5db2013-10-23 00:32:58 +00002456 }
dan1ff94072019-07-17 09:18:06 +00002457 if( resizeIndexObject(db, pPk, nPk+nExtra) ) return;
2458 for(i=0, j=nPk; i<pTab->nCol; i++){
drh8e10d742019-10-18 17:42:47 +00002459 if( !hasColumn(pPk->aiColumn, j, i)
2460 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
2461 ){
dan1ff94072019-07-17 09:18:06 +00002462 assert( j<pPk->nColumn );
2463 pPk->aiColumn[j] = i;
2464 pPk->azColl[j] = sqlite3StrBINARY;
2465 j++;
2466 }
2467 }
2468 assert( pPk->nColumn==j );
drh8e10d742019-10-18 17:42:47 +00002469 assert( pTab->nNVCol<=j );
drh1fe3ac72018-06-09 01:12:08 +00002470 recomputeColumnsNotIndexed(pPk);
drh7f9c5db2013-10-23 00:32:58 +00002471}
2472
drh3d863b52020-05-14 21:16:52 +00002473
2474#ifndef SQLITE_OMIT_VIRTUALTABLE
2475/*
2476** Return true if pTab is a virtual table and zName is a shadow table name
2477** for that virtual table.
2478*/
2479int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
2480 int nName; /* Length of zName */
2481 Module *pMod; /* Module for the virtual table */
2482
2483 if( !IsVirtual(pTab) ) return 0;
2484 nName = sqlite3Strlen30(pTab->zName);
2485 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
2486 if( zName[nName]!='_' ) return 0;
drhf38524d2021-08-02 16:41:57 +00002487 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
drh3d863b52020-05-14 21:16:52 +00002488 if( pMod==0 ) return 0;
2489 if( pMod->pModule->iVersion<3 ) return 0;
2490 if( pMod->pModule->xShadowName==0 ) return 0;
2491 return pMod->pModule->xShadowName(zName+nName+1);
2492}
2493#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
2494
danf6e015f2018-11-28 08:02:28 +00002495#ifndef SQLITE_OMIT_VIRTUALTABLE
drhfdaac672013-10-04 15:30:21 +00002496/*
drhddfec002021-11-04 00:51:53 +00002497** Table pTab is a virtual table. If it the virtual table implementation
2498** exists and has an xShadowName method, then loop over all other ordinary
2499** tables within the same schema looking for shadow tables of pTab, and mark
2500** any shadow tables seen using the TF_Shadow flag.
2501*/
2502void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
2503 int nName; /* Length of pTab->zName */
2504 Module *pMod; /* Module for the virtual table */
2505 HashElem *k; /* For looping through the symbol table */
2506
2507 assert( IsVirtual(pTab) );
2508 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
2509 if( pMod==0 ) return;
2510 if( NEVER(pMod->pModule==0) ) return;
2511 if( pMod->pModule->xShadowName==0 ) return;
2512 assert( pTab->zName!=0 );
2513 nName = sqlite3Strlen30(pTab->zName);
2514 for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
2515 Table *pOther = sqliteHashData(k);
2516 assert( pOther->zName!=0 );
2517 if( !IsOrdinaryTable(pOther) ) continue;
2518 if( pOther->tabFlags & TF_Shadow ) continue;
2519 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
2520 && pOther->zName[nName]=='_'
2521 && pMod->pModule->xShadowName(pOther->zName+nName+1)
2522 ){
2523 pOther->tabFlags |= TF_Shadow;
2524 }
2525 }
2526}
2527#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
2528
2529#ifndef SQLITE_OMIT_VIRTUALTABLE
2530/*
drh84c501b2018-11-05 23:01:45 +00002531** Return true if zName is a shadow table name in the current database
2532** connection.
2533**
2534** zName is temporarily modified while this routine is running, but is
2535** restored to its original value prior to this routine returning.
2536*/
drh527cbd42019-11-16 14:15:19 +00002537int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
drh84c501b2018-11-05 23:01:45 +00002538 char *zTail; /* Pointer to the last "_" in zName */
2539 Table *pTab; /* Table that zName is a shadow of */
drh84c501b2018-11-05 23:01:45 +00002540 zTail = strrchr(zName, '_');
2541 if( zTail==0 ) return 0;
2542 *zTail = 0;
2543 pTab = sqlite3FindTable(db, zName, 0);
2544 *zTail = '_';
2545 if( pTab==0 ) return 0;
2546 if( !IsVirtual(pTab) ) return 0;
drh3d863b52020-05-14 21:16:52 +00002547 return sqlite3IsShadowTableOf(db, pTab, zName);
drh84c501b2018-11-05 23:01:45 +00002548}
danf6e015f2018-11-28 08:02:28 +00002549#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
drh84c501b2018-11-05 23:01:45 +00002550
drh3d863b52020-05-14 21:16:52 +00002551
drhe7375bf2020-03-10 19:24:38 +00002552#ifdef SQLITE_DEBUG
2553/*
2554** Mark all nodes of an expression as EP_Immutable, indicating that
2555** they should not be changed. Expressions attached to a table or
2556** index definition are tagged this way to help ensure that we do
2557** not pass them into code generator routines by mistake.
2558*/
2559static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
2560 ExprSetVVAProperty(pExpr, EP_Immutable);
2561 return WRC_Continue;
2562}
2563static void markExprListImmutable(ExprList *pList){
2564 if( pList ){
2565 Walker w;
2566 memset(&w, 0, sizeof(w));
2567 w.xExprCallback = markImmutableExprStep;
2568 w.xSelectCallback = sqlite3SelectWalkNoop;
2569 w.xSelectCallback2 = 0;
2570 sqlite3WalkExprList(&w, pList);
2571 }
2572}
2573#else
2574#define markExprListImmutable(X) /* no-op */
2575#endif /* SQLITE_DEBUG */
2576
2577
drh84c501b2018-11-05 23:01:45 +00002578/*
drh75897232000-05-29 14:26:00 +00002579** This routine is called to report the final ")" that terminates
2580** a CREATE TABLE statement.
2581**
drhf57b3392001-10-08 13:22:32 +00002582** The table structure that other action routines have been building
2583** is added to the internal hash tables, assuming no errors have
2584** occurred.
drh75897232000-05-29 14:26:00 +00002585**
drh067b92b2020-06-19 15:24:12 +00002586** An entry for the table is made in the schema table on disk, unless
drh1d85d932004-02-14 23:05:52 +00002587** this is a temporary table or db->init.busy==1. When db->init.busy==1
drh1e32bed2020-06-19 13:33:53 +00002588** it means we are reading the sqlite_schema table because we just
2589** connected to the database or because the sqlite_schema table has
drhddba9e52005-03-19 01:41:21 +00002590** recently changed, so the entry for this table already exists in
drh1e32bed2020-06-19 13:33:53 +00002591** the sqlite_schema table. We do not want to create it again.
drh969fa7c2002-02-18 18:30:32 +00002592**
2593** If the pSelect argument is not NULL, it means that this routine
2594** was called to create a table generated from a
2595** "CREATE TABLE ... AS SELECT ..." statement. The column names of
2596** the new table will match the result set of the SELECT.
drh75897232000-05-29 14:26:00 +00002597*/
danielk197719a8e7e2005-03-17 05:03:38 +00002598void sqlite3EndTable(
2599 Parse *pParse, /* Parse context */
2600 Token *pCons, /* The ',' token after the last column defn. */
drh5969da42013-10-21 02:14:45 +00002601 Token *pEnd, /* The ')' before options in the CREATE TABLE */
drh44183f82021-08-18 13:13:58 +00002602 u32 tabOpts, /* Extra table options. Usually 0. */
danielk197719a8e7e2005-03-17 05:03:38 +00002603 Select *pSelect /* Select from a "CREATE ... AS SELECT" */
2604){
drhfdaac672013-10-04 15:30:21 +00002605 Table *p; /* The new table */
2606 sqlite3 *db = pParse->db; /* The database connection */
2607 int iDb; /* Database in which the table lives */
2608 Index *pIdx; /* An implied index of the table */
drh75897232000-05-29 14:26:00 +00002609
drh027616d2015-08-08 22:47:47 +00002610 if( pEnd==0 && pSelect==0 ){
drh5969da42013-10-21 02:14:45 +00002611 return;
danielk1977261919c2005-12-06 12:52:59 +00002612 }
drh28037572000-08-02 13:47:41 +00002613 p = pParse->pNewTable;
drh5969da42013-10-21 02:14:45 +00002614 if( p==0 ) return;
drh75897232000-05-29 14:26:00 +00002615
drh527cbd42019-11-16 14:15:19 +00002616 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
drh84c501b2018-11-05 23:01:45 +00002617 p->tabFlags |= TF_Shadow;
2618 }
2619
drhc6bd4e42013-11-02 14:37:18 +00002620 /* If the db->init.busy is 1 it means we are reading the SQL off the
drh1e32bed2020-06-19 13:33:53 +00002621 ** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
drhc6bd4e42013-11-02 14:37:18 +00002622 ** So do not write to the disk again. Extract the root page number
2623 ** for the table from the db->init.newTnum field. (The page number
2624 ** should have been put there by the sqliteOpenCb routine.)
drh055f2982016-01-15 15:06:41 +00002625 **
drh1e32bed2020-06-19 13:33:53 +00002626 ** If the root page number is 1, that means this is the sqlite_schema
drh055f2982016-01-15 15:06:41 +00002627 ** table itself. So mark it read-only.
drhc6bd4e42013-11-02 14:37:18 +00002628 */
2629 if( db->init.busy ){
drh54e3f942021-10-11 15:54:05 +00002630 if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){
drh1e9c47b2018-03-16 20:15:58 +00002631 sqlite3ErrorMsg(pParse, "");
2632 return;
2633 }
drhc6bd4e42013-11-02 14:37:18 +00002634 p->tnum = db->init.newTnum;
drh055f2982016-01-15 15:06:41 +00002635 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
drhc6bd4e42013-11-02 14:37:18 +00002636 }
2637
drh71c770f2021-08-19 16:29:33 +00002638 /* Special processing for tables that include the STRICT keyword:
2639 **
2640 ** * Do not allow custom column datatypes. Every column must have
2641 ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
2642 **
2643 ** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY,
2644 ** then all columns of the PRIMARY KEY must have a NOT NULL
2645 ** constraint.
2646 */
drh44183f82021-08-18 13:13:58 +00002647 if( tabOpts & TF_Strict ){
2648 int ii;
2649 p->tabFlags |= TF_Strict;
2650 for(ii=0; ii<p->nCol; ii++){
drhab165782021-08-19 00:24:43 +00002651 Column *pCol = &p->aCol[ii];
drhb9fd0102021-08-23 10:28:02 +00002652 if( pCol->eCType==COLTYPE_CUSTOM ){
2653 if( pCol->colFlags & COLFLAG_HASTYPE ){
2654 sqlite3ErrorMsg(pParse,
2655 "unknown datatype for %s.%s: \"%s\"",
2656 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
2657 );
2658 }else{
2659 sqlite3ErrorMsg(pParse, "missing datatype for %s.%s",
2660 p->zName, pCol->zCnName);
2661 }
drh44183f82021-08-18 13:13:58 +00002662 return;
drhb9fd0102021-08-23 10:28:02 +00002663 }else if( pCol->eCType==COLTYPE_ANY ){
2664 pCol->affinity = SQLITE_AFF_BLOB;
drh44183f82021-08-18 13:13:58 +00002665 }
drhab165782021-08-19 00:24:43 +00002666 if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0
2667 && p->iPKey!=ii
2668 && pCol->notNull == OE_None
2669 ){
drhab165782021-08-19 00:24:43 +00002670 pCol->notNull = OE_Abort;
2671 p->tabFlags |= TF_HasNotNull;
2672 }
drh44183f82021-08-18 13:13:58 +00002673 }
2674 }
2675
drh3cbd2b72019-02-19 13:51:58 +00002676 assert( (p->tabFlags & TF_HasPrimaryKey)==0
2677 || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
2678 assert( (p->tabFlags & TF_HasPrimaryKey)!=0
2679 || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
2680
drhc6bd4e42013-11-02 14:37:18 +00002681 /* Special processing for WITHOUT ROWID Tables */
drh5969da42013-10-21 02:14:45 +00002682 if( tabOpts & TF_WithoutRowid ){
drhd2fe3352013-11-09 18:15:35 +00002683 if( (p->tabFlags & TF_Autoincrement) ){
2684 sqlite3ErrorMsg(pParse,
2685 "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
2686 return;
2687 }
drh5969da42013-10-21 02:14:45 +00002688 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
drhd2fe3352013-11-09 18:15:35 +00002689 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
drh8e10d742019-10-18 17:42:47 +00002690 return;
drh81eba732013-10-19 23:31:56 +00002691 }
drh8e10d742019-10-18 17:42:47 +00002692 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
drhf95909c2019-10-18 18:33:25 +00002693 convertToWithoutRowidTable(pParse, p);
drh81eba732013-10-19 23:31:56 +00002694 }
drhb9bb7c12006-06-11 23:41:55 +00002695 iDb = sqlite3SchemaToIndex(db, p->pSchema);
danielk1977da184232006-01-05 11:34:32 +00002696
drhffe07b22005-11-03 00:41:17 +00002697#ifndef SQLITE_OMIT_CHECK
2698 /* Resolve names in all CHECK constraint expressions.
2699 */
2700 if( p->pCheck ){
drh3780be12013-07-31 19:05:22 +00002701 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
drh9524a7e2019-12-22 18:06:49 +00002702 if( pParse->nErr ){
2703 /* If errors are seen, delete the CHECK constraints now, else they might
2704 ** actually be used if PRAGMA writable_schema=ON is set. */
2705 sqlite3ExprListDelete(db, p->pCheck);
2706 p->pCheck = 0;
drhe7375bf2020-03-10 19:24:38 +00002707 }else{
2708 markExprListImmutable(p->pCheck);
drh9524a7e2019-12-22 18:06:49 +00002709 }
drhffe07b22005-11-03 00:41:17 +00002710 }
2711#endif /* !defined(SQLITE_OMIT_CHECK) */
drh81f7b372019-10-16 12:18:59 +00002712#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh427b96a2019-10-22 13:01:24 +00002713 if( p->tabFlags & TF_HasGenerated ){
drhf4658b62019-10-29 03:39:17 +00002714 int ii, nNG = 0;
drh427b96a2019-10-22 13:01:24 +00002715 testcase( p->tabFlags & TF_HasVirtual );
2716 testcase( p->tabFlags & TF_HasStored );
drh81f7b372019-10-16 12:18:59 +00002717 for(ii=0; ii<p->nCol; ii++){
drh0b0b3a92019-10-17 18:35:57 +00002718 u32 colFlags = p->aCol[ii].colFlags;
drh427b96a2019-10-22 13:01:24 +00002719 if( (colFlags & COLFLAG_GENERATED)!=0 ){
drh79cf2b72021-07-31 20:30:41 +00002720 Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]);
drh427b96a2019-10-22 13:01:24 +00002721 testcase( colFlags & COLFLAG_VIRTUAL );
2722 testcase( colFlags & COLFLAG_STORED );
drh7e3f1352019-12-14 19:55:31 +00002723 if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
2724 /* If there are errors in resolving the expression, change the
2725 ** expression to a NULL. This prevents code generators that operate
2726 ** on the expression from inserting extra parts into the expression
2727 ** tree that have been allocated from lookaside memory, which is
drh2d58b7f2020-01-17 23:27:41 +00002728 ** illegal in a schema and will lead to errors or heap corruption
2729 ** when the database connection closes. */
drh79cf2b72021-07-31 20:30:41 +00002730 sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii],
2731 sqlite3ExprAlloc(db, TK_NULL, 0, 0));
drh7e3f1352019-12-14 19:55:31 +00002732 }
drhf4658b62019-10-29 03:39:17 +00002733 }else{
2734 nNG++;
drh81f7b372019-10-16 12:18:59 +00002735 }
drh2c40a3e2019-10-29 01:26:24 +00002736 }
drhf4658b62019-10-29 03:39:17 +00002737 if( nNG==0 ){
2738 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
drh2c40a3e2019-10-29 01:26:24 +00002739 return;
drh81f7b372019-10-16 12:18:59 +00002740 }
2741 }
2742#endif
drhffe07b22005-11-03 00:41:17 +00002743
drhe13e9f52013-10-05 19:18:00 +00002744 /* Estimate the average row size for the table and for all implied indices */
2745 estimateTableWidth(p);
drhfdaac672013-10-04 15:30:21 +00002746 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhe13e9f52013-10-05 19:18:00 +00002747 estimateIndexWidth(pIdx);
drhfdaac672013-10-04 15:30:21 +00002748 }
2749
drhe3c41372001-09-17 20:25:58 +00002750 /* If not initializing, then create a record for the new table
drh346a70c2020-06-15 20:27:35 +00002751 ** in the schema table of the database.
drhf57b3392001-10-08 13:22:32 +00002752 **
drhe0bc4042002-06-25 01:09:11 +00002753 ** If this is a TEMPORARY table, write the entry into the auxiliary
2754 ** file instead of into the main database file.
drh75897232000-05-29 14:26:00 +00002755 */
drh1d85d932004-02-14 23:05:52 +00002756 if( !db->init.busy ){
drh4ff6dfa2002-03-03 23:06:00 +00002757 int n;
drhd8bc7082000-06-07 23:51:50 +00002758 Vdbe *v;
drh4794f732004-11-05 17:17:50 +00002759 char *zType; /* "view" or "table" */
2760 char *zType2; /* "VIEW" or "TABLE" */
2761 char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
drh75897232000-05-29 14:26:00 +00002762
danielk19774adee202004-05-08 08:23:19 +00002763 v = sqlite3GetVdbe(pParse);
drh5969da42013-10-21 02:14:45 +00002764 if( NEVER(v==0) ) return;
danielk1977517eb642004-06-07 10:00:31 +00002765
drh66a51672008-01-03 00:01:23 +00002766 sqlite3VdbeAddOp1(v, OP_Close, 0);
danielk1977e6efa742004-11-10 11:55:10 +00002767
drh0fa991b2009-03-21 16:19:26 +00002768 /*
2769 ** Initialize zType for the new view or table.
drh4794f732004-11-05 17:17:50 +00002770 */
drhf38524d2021-08-02 16:41:57 +00002771 if( IsOrdinaryTable(p) ){
drh4ff6dfa2002-03-03 23:06:00 +00002772 /* A regular table */
drh4794f732004-11-05 17:17:50 +00002773 zType = "table";
2774 zType2 = "TABLE";
danielk1977576ec6b2005-01-21 11:55:25 +00002775#ifndef SQLITE_OMIT_VIEW
drh4ff6dfa2002-03-03 23:06:00 +00002776 }else{
2777 /* A view */
drh4794f732004-11-05 17:17:50 +00002778 zType = "view";
2779 zType2 = "VIEW";
danielk1977576ec6b2005-01-21 11:55:25 +00002780#endif
drh4ff6dfa2002-03-03 23:06:00 +00002781 }
danielk1977517eb642004-06-07 10:00:31 +00002782
danielk1977517eb642004-06-07 10:00:31 +00002783 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
2784 ** statement to populate the new table. The root-page number for the
drh0fa991b2009-03-21 16:19:26 +00002785 ** new table is in register pParse->regRoot.
danielk1977517eb642004-06-07 10:00:31 +00002786 **
2787 ** Once the SELECT has been coded by sqlite3Select(), it is in a
2788 ** suitable state to query for the column names and types to be used
2789 ** by the new table.
danielk1977c00da102006-01-07 13:21:04 +00002790 **
2791 ** A shared-cache write-lock is not required to write to the new table,
2792 ** as a schema-lock must have already been obtained to create it. Since
2793 ** a schema-lock excludes all other database users, the write-lock would
2794 ** be redundant.
danielk1977517eb642004-06-07 10:00:31 +00002795 */
2796 if( pSelect ){
drh92632202015-05-20 17:18:29 +00002797 SelectDest dest; /* Where the SELECT should store results */
drh9df25c42015-05-20 15:51:09 +00002798 int regYield; /* Register holding co-routine entry-point */
2799 int addrTop; /* Top of the co-routine */
drh92632202015-05-20 17:18:29 +00002800 int regRec; /* A record to be insert into the new table */
2801 int regRowid; /* Rowid of the next row to insert */
2802 int addrInsLoop; /* Top of the loop for inserting rows */
2803 Table *pSelTab; /* A table that describes the SELECT results */
drh1013c932008-01-06 00:25:21 +00002804
drh9df25c42015-05-20 15:51:09 +00002805 regYield = ++pParse->nMem;
drh92632202015-05-20 17:18:29 +00002806 regRec = ++pParse->nMem;
2807 regRowid = ++pParse->nMem;
danielk19776ab3a2e2009-02-19 14:39:25 +00002808 assert(pParse->nTab==1);
drh0dd5cda2015-06-16 16:39:01 +00002809 sqlite3MayAbort(pParse);
drhb7654112008-01-12 12:48:07 +00002810 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
dan428c2182012-08-06 18:50:11 +00002811 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
danielk1977517eb642004-06-07 10:00:31 +00002812 pParse->nTab = 2;
drh9df25c42015-05-20 15:51:09 +00002813 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
2814 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
drh512795d2017-12-24 18:56:28 +00002815 if( pParse->nErr ) return;
drh81506b82019-08-05 19:32:06 +00002816 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB);
drh92632202015-05-20 17:18:29 +00002817 if( pSelTab==0 ) return;
2818 assert( p->aCol==0 );
drhf5f19152019-10-21 01:04:11 +00002819 p->nCol = p->nNVCol = pSelTab->nCol;
drh92632202015-05-20 17:18:29 +00002820 p->aCol = pSelTab->aCol;
2821 pSelTab->nCol = 0;
2822 pSelTab->aCol = 0;
2823 sqlite3DeleteTable(db, pSelTab);
drh755b0fd2017-12-23 12:33:40 +00002824 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
2825 sqlite3Select(pParse, pSelect, &dest);
drh5060a672017-12-25 13:43:54 +00002826 if( pParse->nErr ) return;
drh755b0fd2017-12-23 12:33:40 +00002827 sqlite3VdbeEndCoroutine(v, regYield);
2828 sqlite3VdbeJumpHere(v, addrTop - 1);
drh92632202015-05-20 17:18:29 +00002829 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
2830 VdbeCoverage(v);
2831 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
2832 sqlite3TableAffinity(v, p, 0);
2833 sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
2834 sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
drh076e85f2015-09-03 13:46:12 +00002835 sqlite3VdbeGoto(v, addrInsLoop);
drh92632202015-05-20 17:18:29 +00002836 sqlite3VdbeJumpHere(v, addrInsLoop);
2837 sqlite3VdbeAddOp1(v, OP_Close, 1);
danielk1977517eb642004-06-07 10:00:31 +00002838 }
drh4794f732004-11-05 17:17:50 +00002839
drh4794f732004-11-05 17:17:50 +00002840 /* Compute the complete text of the CREATE statement */
2841 if( pSelect ){
drh1d34fde2009-02-03 15:50:33 +00002842 zStmt = createTableStmt(db, p);
drh4794f732004-11-05 17:17:50 +00002843 }else{
drh8ea30bf2013-10-22 01:18:17 +00002844 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
2845 n = (int)(pEnd2->z - pParse->sNameToken.z);
2846 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
danielk19771e536952007-08-16 10:09:01 +00002847 zStmt = sqlite3MPrintf(db,
2848 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
2849 );
drh4794f732004-11-05 17:17:50 +00002850 }
2851
2852 /* A slot for the record has already been allocated in the
drh346a70c2020-06-15 20:27:35 +00002853 ** schema table. We just need to update that slot with all
drh0fa991b2009-03-21 16:19:26 +00002854 ** the information we've collected.
drh4794f732004-11-05 17:17:50 +00002855 */
2856 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +00002857 "UPDATE %Q." DFLT_SCHEMA_TABLE
2858 " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
2859 " WHERE rowid=#%d",
2860 db->aDb[iDb].zDbSName,
drh4794f732004-11-05 17:17:50 +00002861 zType,
2862 p->zName,
2863 p->zName,
drhb7654112008-01-12 12:48:07 +00002864 pParse->regRoot,
2865 zStmt,
2866 pParse->regRowid
drh4794f732004-11-05 17:17:50 +00002867 );
drh633e6d52008-07-28 19:34:53 +00002868 sqlite3DbFree(db, zStmt);
drh9cbf3422008-01-17 16:22:13 +00002869 sqlite3ChangeCookie(pParse, iDb);
drh2958a4e2004-11-12 03:56:15 +00002870
2871#ifndef SQLITE_OMIT_AUTOINCREMENT
2872 /* Check to see if we need to create an sqlite_sequence table for
2873 ** keeping track of autoincrement keys.
2874 */
dan755ed412021-04-07 12:02:30 +00002875 if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){
danielk1977da184232006-01-05 11:34:32 +00002876 Db *pDb = &db->aDb[iDb];
drh21206082011-04-04 18:22:02 +00002877 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danielk1977da184232006-01-05 11:34:32 +00002878 if( pDb->pSchema->pSeqTab==0 ){
drh2958a4e2004-11-12 03:56:15 +00002879 sqlite3NestedParse(pParse,
drhf3388142004-11-13 03:48:06 +00002880 "CREATE TABLE %Q.sqlite_sequence(name,seq)",
drh69c33822016-08-18 14:33:11 +00002881 pDb->zDbSName
drh2958a4e2004-11-12 03:56:15 +00002882 );
2883 }
2884 }
2885#endif
drh4794f732004-11-05 17:17:50 +00002886
2887 /* Reparse everything to update our internal data structures */
drh5d9c9da2011-06-03 20:11:17 +00002888 sqlite3VdbeAddParseSchemaOp(v, iDb,
dan6a5a13d2021-02-17 20:08:22 +00002889 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
drh75897232000-05-29 14:26:00 +00002890 }
drh17e9e292003-02-01 13:53:28 +00002891
2892 /* Add the table to the in-memory representation of the database.
2893 */
drh8af73d42009-05-13 22:58:28 +00002894 if( db->init.busy ){
drh17e9e292003-02-01 13:53:28 +00002895 Table *pOld;
danielk1977e501b892006-01-09 06:29:47 +00002896 Schema *pSchema = p->pSchema;
drh21206082011-04-04 18:22:02 +00002897 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh1bb89e92021-04-19 18:03:52 +00002898 assert( HasRowid(p) || p->iPKey<0 );
drhacbcb7e2014-08-21 20:26:37 +00002899 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
drh17e9e292003-02-01 13:53:28 +00002900 if( pOld ){
2901 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
drh4a642b62016-02-05 01:55:27 +00002902 sqlite3OomFault(db);
drh5969da42013-10-21 02:14:45 +00002903 return;
drh17e9e292003-02-01 13:53:28 +00002904 }
drh17e9e292003-02-01 13:53:28 +00002905 pParse->pNewTable = 0;
drh8257aa82017-07-26 19:59:13 +00002906 db->mDbFlags |= DBFLAG_SchemaChange;
dand4b64692021-04-06 16:16:15 +00002907
2908 /* If this is the magic sqlite_sequence table used by autoincrement,
2909 ** then record a pointer to this table in the main database structure
2910 ** so that INSERT can find the table easily. */
2911 assert( !pParse->nested );
2912#ifndef SQLITE_OMIT_AUTOINCREMENT
2913 if( strcmp(p->zName, "sqlite_sequence")==0 ){
2914 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2915 p->pSchema->pSeqTab = p;
2916 }
2917#endif
dan578277c2021-02-19 18:39:32 +00002918 }
danielk197719a8e7e2005-03-17 05:03:38 +00002919
2920#ifndef SQLITE_OMIT_ALTERTABLE
drhf38524d2021-08-02 16:41:57 +00002921 if( !pSelect && IsOrdinaryTable(p) ){
dan578277c2021-02-19 18:39:32 +00002922 assert( pCons && pEnd );
2923 if( pCons->z==0 ){
2924 pCons = pEnd;
danielk197719a8e7e2005-03-17 05:03:38 +00002925 }
drhf38524d2021-08-02 16:41:57 +00002926 p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z);
drh17e9e292003-02-01 13:53:28 +00002927 }
dan578277c2021-02-19 18:39:32 +00002928#endif
drh75897232000-05-29 14:26:00 +00002929}
2930
drhb7f91642004-10-31 02:22:47 +00002931#ifndef SQLITE_OMIT_VIEW
drh75897232000-05-29 14:26:00 +00002932/*
drha76b5df2002-02-23 02:32:10 +00002933** The parser calls this routine in order to create a new VIEW
2934*/
danielk19774adee202004-05-08 08:23:19 +00002935void sqlite3CreateView(
drha76b5df2002-02-23 02:32:10 +00002936 Parse *pParse, /* The parsing context */
2937 Token *pBegin, /* The CREATE token that begins the statement */
danielk197748dec7e2004-05-28 12:33:30 +00002938 Token *pName1, /* The token that holds the name of the view */
2939 Token *pName2, /* The token that holds the name of the view */
drh8981b902015-08-24 17:42:49 +00002940 ExprList *pCNames, /* Optional list of view column names */
drh6276c1c2002-07-08 22:03:32 +00002941 Select *pSelect, /* A SELECT statement that will become the new view */
drhfdd48a72006-09-11 23:45:48 +00002942 int isTemp, /* TRUE for a TEMPORARY view */
2943 int noErr /* Suppress error messages if VIEW already exists */
drha76b5df2002-02-23 02:32:10 +00002944){
drha76b5df2002-02-23 02:32:10 +00002945 Table *p;
drh4b59ab52002-08-24 18:24:51 +00002946 int n;
drhb7916a72009-05-27 10:31:29 +00002947 const char *z;
drh4b59ab52002-08-24 18:24:51 +00002948 Token sEnd;
drhf26e09c2003-05-31 16:21:12 +00002949 DbFixer sFix;
drh88caeac2011-08-24 15:12:08 +00002950 Token *pName = 0;
danielk1977da184232006-01-05 11:34:32 +00002951 int iDb;
drh17435752007-08-16 04:30:38 +00002952 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +00002953
drh7c3d64f2005-06-06 15:32:08 +00002954 if( pParse->nVar>0 ){
2955 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
drh32498f12015-09-26 11:15:44 +00002956 goto create_view_fail;
drh7c3d64f2005-06-06 15:32:08 +00002957 }
drhfdd48a72006-09-11 23:45:48 +00002958 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
drha76b5df2002-02-23 02:32:10 +00002959 p = pParse->pNewTable;
drh8981b902015-08-24 17:42:49 +00002960 if( p==0 || pParse->nErr ) goto create_view_fail;
drh6e5020e2021-04-07 15:45:01 +00002961
2962 /* Legacy versions of SQLite allowed the use of the magic "rowid" column
2963 ** on a view, even though views do not have rowids. The following flag
2964 ** setting fixes this problem. But the fix can be disabled by compiling
2965 ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
2966 ** depend upon the old buggy behavior. */
2967#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
drha6c54de2021-04-06 19:13:44 +00002968 p->tabFlags |= TF_NoVisibleRowid;
drh6e5020e2021-04-07 15:45:01 +00002969#endif
2970
danielk1977ef2cb632004-05-29 02:37:19 +00002971 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
drh17435752007-08-16 04:30:38 +00002972 iDb = sqlite3SchemaToIndex(db, p->pSchema);
drhd100f692013-10-03 15:39:44 +00002973 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
drh8981b902015-08-24 17:42:49 +00002974 if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
drh174b6192002-12-03 02:22:52 +00002975
drh4b59ab52002-08-24 18:24:51 +00002976 /* Make a copy of the entire SELECT statement that defines the view.
2977 ** This will force all the Expr.token.z values to be dynamically
2978 ** allocated rather than point to the input string - which means that
danielk197724b03fd2004-05-10 10:34:34 +00002979 ** they will persist after the current sqlite3_exec() call returns.
drh4b59ab52002-08-24 18:24:51 +00002980 */
dan38096962019-12-09 08:13:43 +00002981 pSelect->selFlags |= SF_View;
danc9461ec2018-08-29 21:00:16 +00002982 if( IN_RENAME_OBJECT ){
drhf38524d2021-08-02 16:41:57 +00002983 p->u.view.pSelect = pSelect;
dan987db762018-08-14 20:18:50 +00002984 pSelect = 0;
2985 }else{
drhf38524d2021-08-02 16:41:57 +00002986 p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
dan987db762018-08-14 20:18:50 +00002987 }
drh8981b902015-08-24 17:42:49 +00002988 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
drhf38524d2021-08-02 16:41:57 +00002989 p->eTabType = TABTYP_VIEW;
drh8981b902015-08-24 17:42:49 +00002990 if( db->mallocFailed ) goto create_view_fail;
drh4b59ab52002-08-24 18:24:51 +00002991
2992 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
2993 ** the end.
2994 */
drha76b5df2002-02-23 02:32:10 +00002995 sEnd = pParse->sLastToken;
drh6116ee42018-01-10 00:40:06 +00002996 assert( sEnd.z[0]!=0 || sEnd.n==0 );
drh8981b902015-08-24 17:42:49 +00002997 if( sEnd.z[0]!=';' ){
drha76b5df2002-02-23 02:32:10 +00002998 sEnd.z += sEnd.n;
2999 }
3000 sEnd.n = 0;
drh1bd10f82008-12-10 21:19:56 +00003001 n = (int)(sEnd.z - pBegin->z);
drh8981b902015-08-24 17:42:49 +00003002 assert( n>0 );
drhb7916a72009-05-27 10:31:29 +00003003 z = pBegin->z;
drh8981b902015-08-24 17:42:49 +00003004 while( sqlite3Isspace(z[n-1]) ){ n--; }
drh4ff6dfa2002-03-03 23:06:00 +00003005 sEnd.z = &z[n-1];
3006 sEnd.n = 1;
drh4b59ab52002-08-24 18:24:51 +00003007
drh346a70c2020-06-15 20:27:35 +00003008 /* Use sqlite3EndTable() to add the view to the schema table */
drh5969da42013-10-21 02:14:45 +00003009 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
drh8981b902015-08-24 17:42:49 +00003010
3011create_view_fail:
3012 sqlite3SelectDelete(db, pSelect);
dane8ab40d2018-09-12 08:51:48 +00003013 if( IN_RENAME_OBJECT ){
3014 sqlite3RenameExprlistUnmap(pParse, pCNames);
3015 }
drh8981b902015-08-24 17:42:49 +00003016 sqlite3ExprListDelete(db, pCNames);
drha76b5df2002-02-23 02:32:10 +00003017 return;
drh417be792002-03-03 18:59:40 +00003018}
drhb7f91642004-10-31 02:22:47 +00003019#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00003020
danielk1977fe3fcbe22006-06-12 12:08:45 +00003021#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
drh417be792002-03-03 18:59:40 +00003022/*
3023** The Table structure pTable is really a VIEW. Fill in the names of
3024** the columns of the view in the pTable structure. Return the number
jplyoncfa56842004-01-19 04:55:56 +00003025** of errors. If an error is seen leave an error message in pParse->zErrMsg.
drh417be792002-03-03 18:59:40 +00003026*/
danielk19774adee202004-05-08 08:23:19 +00003027int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
drh9b3187e2005-01-18 14:45:47 +00003028 Table *pSelTab; /* A fake table from which we get the result set */
3029 Select *pSel; /* Copy of the SELECT that implements the view */
3030 int nErr = 0; /* Number of errors encountered */
3031 int n; /* Temporarily holds the number of cursors assigned */
drh17435752007-08-16 04:30:38 +00003032 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
drh424981d2018-03-28 15:56:55 +00003033#ifndef SQLITE_OMIT_VIRTUALTABLE
drhdc6b41e2017-08-17 02:26:35 +00003034 int rc;
3035#endif
drha0daa752016-09-16 11:53:10 +00003036#ifndef SQLITE_OMIT_AUTHORIZATION
drh32c6a482014-09-11 13:44:52 +00003037 sqlite3_xauth xAuth; /* Saved xAuth pointer */
drha0daa752016-09-16 11:53:10 +00003038#endif
drh417be792002-03-03 18:59:40 +00003039
3040 assert( pTable );
3041
danielk1977fe3fcbe22006-06-12 12:08:45 +00003042#ifndef SQLITE_OMIT_VIRTUALTABLE
drhddfec002021-11-04 00:51:53 +00003043 if( IsVirtual(pTable) ){
3044 db->nSchemaLock++;
3045 rc = sqlite3VtabCallConnect(pParse, pTable);
3046 db->nSchemaLock--;
3047 return rc;
danielk1977fe3fcbe22006-06-12 12:08:45 +00003048 }
danielk1977fe3fcbe22006-06-12 12:08:45 +00003049#endif
3050
3051#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00003052 /* A positive nCol means the columns names for this view are
3053 ** already known.
3054 */
3055 if( pTable->nCol>0 ) return 0;
3056
3057 /* A negative nCol is a special marker meaning that we are currently
3058 ** trying to compute the column names. If we enter this routine with
3059 ** a negative nCol, it means two or more views form a loop, like this:
3060 **
3061 ** CREATE VIEW one AS SELECT * FROM two;
3062 ** CREATE VIEW two AS SELECT * FROM one;
drh3b167c72002-06-28 12:18:47 +00003063 **
drh768578e2009-05-12 00:40:12 +00003064 ** Actually, the error above is now caught prior to reaching this point.
3065 ** But the following test is still important as it does come up
3066 ** in the following:
3067 **
3068 ** CREATE TABLE main.ex1(a);
3069 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
3070 ** SELECT * FROM temp.ex1;
drh417be792002-03-03 18:59:40 +00003071 */
3072 if( pTable->nCol<0 ){
danielk19774adee202004-05-08 08:23:19 +00003073 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
drh417be792002-03-03 18:59:40 +00003074 return 1;
3075 }
drh85c23c62005-08-20 03:03:04 +00003076 assert( pTable->nCol>=0 );
drh417be792002-03-03 18:59:40 +00003077
3078 /* If we get this far, it means we need to compute the table names.
drh9b3187e2005-01-18 14:45:47 +00003079 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
3080 ** "*" elements in the results set of the view and will assign cursors
3081 ** to the elements of the FROM clause. But we do not want these changes
3082 ** to be permanent. So the computation is done on a copy of the SELECT
3083 ** statement that defines the view.
drh417be792002-03-03 18:59:40 +00003084 */
drhf38524d2021-08-02 16:41:57 +00003085 assert( IsView(pTable) );
3086 pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0);
drhed06a132016-04-05 20:59:12 +00003087 if( pSel ){
dan02083372018-09-17 08:27:23 +00003088 u8 eParseMode = pParse->eParseMode;
3089 pParse->eParseMode = PARSE_MODE_NORMAL;
drhed06a132016-04-05 20:59:12 +00003090 n = pParse->nTab;
3091 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
3092 pTable->nCol = -1;
drh31f69622019-10-05 14:39:36 +00003093 DisableLookaside;
danielk1977db2d2862007-10-15 07:08:44 +00003094#ifndef SQLITE_OMIT_AUTHORIZATION
drhed06a132016-04-05 20:59:12 +00003095 xAuth = db->xAuth;
3096 db->xAuth = 0;
drh96fb16e2019-08-06 14:37:24 +00003097 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
drhed06a132016-04-05 20:59:12 +00003098 db->xAuth = xAuth;
danielk1977db2d2862007-10-15 07:08:44 +00003099#else
drh96fb16e2019-08-06 14:37:24 +00003100 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
danielk1977db2d2862007-10-15 07:08:44 +00003101#endif
drhed06a132016-04-05 20:59:12 +00003102 pParse->nTab = n;
dan5d591022019-12-28 08:26:47 +00003103 if( pSelTab==0 ){
3104 pTable->nCol = 0;
3105 nErr++;
3106 }else if( pTable->pCheck ){
drhed06a132016-04-05 20:59:12 +00003107 /* CREATE VIEW name(arglist) AS ...
3108 ** The names of the columns in the table are taken from
3109 ** arglist which is stored in pTable->pCheck. The pCheck field
3110 ** normally holds CHECK constraints on an ordinary table, but for
3111 ** a VIEW it holds the list of column names.
3112 */
3113 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
3114 &pTable->nCol, &pTable->aCol);
3115 if( db->mallocFailed==0
drh4c983b22020-01-03 14:34:04 +00003116 && pParse->nErr==0
drhed06a132016-04-05 20:59:12 +00003117 && pTable->nCol==pSel->pEList->nExpr
3118 ){
drh96fb16e2019-08-06 14:37:24 +00003119 sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel,
3120 SQLITE_AFF_NONE);
drh8981b902015-08-24 17:42:49 +00003121 }
dan5d591022019-12-28 08:26:47 +00003122 }else{
drhed06a132016-04-05 20:59:12 +00003123 /* CREATE VIEW name AS... without an argument list. Construct
3124 ** the column names from the SELECT statement that defines the view.
3125 */
3126 assert( pTable->aCol==0 );
drh03836612019-11-02 17:59:10 +00003127 pTable->nCol = pSelTab->nCol;
drhed06a132016-04-05 20:59:12 +00003128 pTable->aCol = pSelTab->aCol;
dan3dc864b2021-02-25 16:55:47 +00003129 pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT);
drhed06a132016-04-05 20:59:12 +00003130 pSelTab->nCol = 0;
3131 pSelTab->aCol = 0;
3132 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
danielk1977261919c2005-12-06 12:52:59 +00003133 }
drh03836612019-11-02 17:59:10 +00003134 pTable->nNVCol = pTable->nCol;
drhe8da01c2016-05-07 12:15:34 +00003135 sqlite3DeleteTable(db, pSelTab);
drhed06a132016-04-05 20:59:12 +00003136 sqlite3SelectDelete(db, pSel);
drh31f69622019-10-05 14:39:36 +00003137 EnableLookaside;
dan02083372018-09-17 08:27:23 +00003138 pParse->eParseMode = eParseMode;
drhed06a132016-04-05 20:59:12 +00003139 } else {
3140 nErr++;
drh417be792002-03-03 18:59:40 +00003141 }
drh8981b902015-08-24 17:42:49 +00003142 pTable->pSchema->schemaFlags |= DB_UnresetViews;
dan77f3f402018-07-09 18:55:44 +00003143 if( db->mallocFailed ){
3144 sqlite3DeleteColumnNames(db, pTable);
dan77f3f402018-07-09 18:55:44 +00003145 }
drhb7f91642004-10-31 02:22:47 +00003146#endif /* SQLITE_OMIT_VIEW */
danielk19774b2688a2006-06-20 11:01:07 +00003147 return nErr;
danielk1977fe3fcbe22006-06-12 12:08:45 +00003148}
3149#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
drh417be792002-03-03 18:59:40 +00003150
drhb7f91642004-10-31 02:22:47 +00003151#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00003152/*
drh8bf8dc92003-05-17 17:35:10 +00003153** Clear the column names from every VIEW in database idx.
drh417be792002-03-03 18:59:40 +00003154*/
drh9bb575f2004-09-06 17:24:11 +00003155static void sqliteViewResetAll(sqlite3 *db, int idx){
drh417be792002-03-03 18:59:40 +00003156 HashElem *i;
drh21206082011-04-04 18:22:02 +00003157 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
drh8bf8dc92003-05-17 17:35:10 +00003158 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
danielk1977da184232006-01-05 11:34:32 +00003159 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
drh417be792002-03-03 18:59:40 +00003160 Table *pTab = sqliteHashData(i);
drhf38524d2021-08-02 16:41:57 +00003161 if( IsView(pTab) ){
drh51be3872015-08-19 02:32:25 +00003162 sqlite3DeleteColumnNames(db, pTab);
drh417be792002-03-03 18:59:40 +00003163 }
3164 }
drh8bf8dc92003-05-17 17:35:10 +00003165 DbClearProperty(db, idx, DB_UnresetViews);
drha76b5df2002-02-23 02:32:10 +00003166}
drhb7f91642004-10-31 02:22:47 +00003167#else
3168# define sqliteViewResetAll(A,B)
3169#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00003170
drh75897232000-05-29 14:26:00 +00003171/*
danielk1977a0bf2652004-11-04 14:30:04 +00003172** This function is called by the VDBE to adjust the internal schema
3173** used by SQLite when the btree layer moves a table root page. The
3174** root-page of a table or index in database iDb has changed from iFrom
3175** to iTo.
drh6205d4a2006-03-24 03:36:26 +00003176**
3177** Ticket #1728: The symbol table might still contain information
3178** on tables and/or indices that are the process of being deleted.
3179** If you are unlucky, one of those deleted indices or tables might
3180** have the same rootpage number as the real table or index that is
3181** being moved. So we cannot stop searching after the first match
3182** because the first match might be for one of the deleted indices
3183** or tables and not the table/index that is actually being moved.
3184** We must continue looping until all tables and indices with
3185** rootpage==iFrom have been converted to have a rootpage of iTo
3186** in order to be certain that we got the right one.
danielk1977a0bf2652004-11-04 14:30:04 +00003187*/
3188#ifndef SQLITE_OMIT_AUTOVACUUM
drhabc38152020-07-22 13:38:04 +00003189void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
danielk1977a0bf2652004-11-04 14:30:04 +00003190 HashElem *pElem;
danielk1977da184232006-01-05 11:34:32 +00003191 Hash *pHash;
drhcdf011d2011-04-04 21:25:28 +00003192 Db *pDb;
danielk1977da184232006-01-05 11:34:32 +00003193
drhcdf011d2011-04-04 21:25:28 +00003194 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
3195 pDb = &db->aDb[iDb];
danielk1977da184232006-01-05 11:34:32 +00003196 pHash = &pDb->pSchema->tblHash;
3197 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00003198 Table *pTab = sqliteHashData(pElem);
3199 if( pTab->tnum==iFrom ){
3200 pTab->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00003201 }
3202 }
danielk1977da184232006-01-05 11:34:32 +00003203 pHash = &pDb->pSchema->idxHash;
3204 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00003205 Index *pIdx = sqliteHashData(pElem);
3206 if( pIdx->tnum==iFrom ){
3207 pIdx->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00003208 }
3209 }
danielk1977a0bf2652004-11-04 14:30:04 +00003210}
3211#endif
3212
3213/*
3214** Write code to erase the table with root-page iTable from database iDb.
drh1e32bed2020-06-19 13:33:53 +00003215** Also write code to modify the sqlite_schema table and internal schema
danielk1977a0bf2652004-11-04 14:30:04 +00003216** if a root-page of another table is moved by the btree-layer whilst
3217** erasing iTable (this can happen with an auto-vacuum database).
3218*/
drh4e0cff62004-11-05 05:10:28 +00003219static void destroyRootPage(Parse *pParse, int iTable, int iDb){
3220 Vdbe *v = sqlite3GetVdbe(pParse);
drhb7654112008-01-12 12:48:07 +00003221 int r1 = sqlite3GetTempReg(pParse);
drh19918882020-07-30 23:47:00 +00003222 if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
drhb7654112008-01-12 12:48:07 +00003223 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
dane0af83a2009-09-08 19:15:01 +00003224 sqlite3MayAbort(pParse);
drh40e016e2004-11-04 14:47:11 +00003225#ifndef SQLITE_OMIT_AUTOVACUUM
drhb7654112008-01-12 12:48:07 +00003226 /* OP_Destroy stores an in integer r1. If this integer
drh4e0cff62004-11-05 05:10:28 +00003227 ** is non-zero, then it is the root page number of a table moved to
drh1e32bed2020-06-19 13:33:53 +00003228 ** location iTable. The following code modifies the sqlite_schema table to
drh4e0cff62004-11-05 05:10:28 +00003229 ** reflect this.
3230 **
drh0fa991b2009-03-21 16:19:26 +00003231 ** The "#NNN" in the SQL is a special constant that means whatever value
drhb74b1012009-05-28 21:04:37 +00003232 ** is in register NNN. See grammar rules associated with the TK_REGISTER
3233 ** token for additional information.
drh4e0cff62004-11-05 05:10:28 +00003234 */
danielk197763e3e9f2004-11-05 09:19:27 +00003235 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +00003236 "UPDATE %Q." DFLT_SCHEMA_TABLE
3237 " SET rootpage=%d WHERE #%d AND rootpage=#%d",
3238 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00003239#endif
drhb7654112008-01-12 12:48:07 +00003240 sqlite3ReleaseTempReg(pParse, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00003241}
3242
3243/*
3244** Write VDBE code to erase table pTab and all associated indices on disk.
drh1e32bed2020-06-19 13:33:53 +00003245** Code to update the sqlite_schema tables and internal schema definitions
danielk1977a0bf2652004-11-04 14:30:04 +00003246** in case a root-page belonging to another table is moved by the btree layer
3247** is also added (this can happen with an auto-vacuum database).
3248*/
drh4e0cff62004-11-05 05:10:28 +00003249static void destroyTable(Parse *pParse, Table *pTab){
danielk1977a0bf2652004-11-04 14:30:04 +00003250 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
3251 ** is not defined), then it is important to call OP_Destroy on the
3252 ** table and index root-pages in order, starting with the numerically
3253 ** largest root-page number. This guarantees that none of the root-pages
3254 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
3255 ** following were coded:
3256 **
3257 ** OP_Destroy 4 0
3258 ** ...
3259 ** OP_Destroy 5 0
3260 **
3261 ** and root page 5 happened to be the largest root-page number in the
3262 ** database, then root page 5 would be moved to page 4 by the
3263 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
3264 ** a free-list page.
3265 */
drhabc38152020-07-22 13:38:04 +00003266 Pgno iTab = pTab->tnum;
drh8deae5a2020-07-29 12:23:20 +00003267 Pgno iDestroyed = 0;
danielk1977a0bf2652004-11-04 14:30:04 +00003268
3269 while( 1 ){
3270 Index *pIdx;
drh8deae5a2020-07-29 12:23:20 +00003271 Pgno iLargest = 0;
danielk1977a0bf2652004-11-04 14:30:04 +00003272
3273 if( iDestroyed==0 || iTab<iDestroyed ){
3274 iLargest = iTab;
3275 }
3276 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
drhabc38152020-07-22 13:38:04 +00003277 Pgno iIdx = pIdx->tnum;
danielk1977da184232006-01-05 11:34:32 +00003278 assert( pIdx->pSchema==pTab->pSchema );
danielk1977a0bf2652004-11-04 14:30:04 +00003279 if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
3280 iLargest = iIdx;
3281 }
3282 }
danielk1977da184232006-01-05 11:34:32 +00003283 if( iLargest==0 ){
3284 return;
3285 }else{
3286 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drh5a05be12012-10-09 18:51:44 +00003287 assert( iDb>=0 && iDb<pParse->db->nDb );
danielk1977da184232006-01-05 11:34:32 +00003288 destroyRootPage(pParse, iLargest, iDb);
3289 iDestroyed = iLargest;
3290 }
danielk1977a0bf2652004-11-04 14:30:04 +00003291 }
danielk1977a0bf2652004-11-04 14:30:04 +00003292}
3293
3294/*
drh74e7c8f2011-10-21 19:06:32 +00003295** Remove entries from the sqlite_statN tables (for N in (1,2,3))
drha5ae4c32011-08-07 01:31:52 +00003296** after a DROP INDEX or DROP TABLE command.
3297*/
3298static void sqlite3ClearStatTables(
3299 Parse *pParse, /* The parsing context */
3300 int iDb, /* The database number */
3301 const char *zType, /* "idx" or "tbl" */
3302 const char *zName /* Name of index or table */
3303){
drha5ae4c32011-08-07 01:31:52 +00003304 int i;
drh69c33822016-08-18 14:33:11 +00003305 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
danf52bb8d2013-08-03 20:24:58 +00003306 for(i=1; i<=4; i++){
drh74e7c8f2011-10-21 19:06:32 +00003307 char zTab[24];
3308 sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
3309 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
drha5ae4c32011-08-07 01:31:52 +00003310 sqlite3NestedParse(pParse,
3311 "DELETE FROM %Q.%s WHERE %s=%Q",
drh74e7c8f2011-10-21 19:06:32 +00003312 zDbName, zTab, zType, zName
drha5ae4c32011-08-07 01:31:52 +00003313 );
3314 }
3315 }
3316}
3317
3318/*
drhfaacf172011-08-12 01:51:45 +00003319** Generate code to drop a table.
3320*/
3321void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
3322 Vdbe *v;
3323 sqlite3 *db = pParse->db;
3324 Trigger *pTrigger;
3325 Db *pDb = &db->aDb[iDb];
3326
3327 v = sqlite3GetVdbe(pParse);
3328 assert( v!=0 );
3329 sqlite3BeginWriteOperation(pParse, 1, iDb);
3330
3331#ifndef SQLITE_OMIT_VIRTUALTABLE
3332 if( IsVirtual(pTab) ){
3333 sqlite3VdbeAddOp0(v, OP_VBegin);
3334 }
3335#endif
3336
3337 /* Drop all triggers associated with the table being dropped. Code
drh1e32bed2020-06-19 13:33:53 +00003338 ** is generated to remove entries from sqlite_schema and/or
3339 ** sqlite_temp_schema if required.
drhfaacf172011-08-12 01:51:45 +00003340 */
3341 pTrigger = sqlite3TriggerList(pParse, pTab);
3342 while( pTrigger ){
3343 assert( pTrigger->pSchema==pTab->pSchema ||
3344 pTrigger->pSchema==db->aDb[1].pSchema );
3345 sqlite3DropTriggerPtr(pParse, pTrigger);
3346 pTrigger = pTrigger->pNext;
3347 }
3348
3349#ifndef SQLITE_OMIT_AUTOINCREMENT
3350 /* Remove any entries of the sqlite_sequence table associated with
3351 ** the table being dropped. This is done before the table is dropped
3352 ** at the btree level, in case the sqlite_sequence table needs to
3353 ** move as a result of the drop (can happen in auto-vacuum mode).
3354 */
3355 if( pTab->tabFlags & TF_Autoincrement ){
3356 sqlite3NestedParse(pParse,
3357 "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
drh69c33822016-08-18 14:33:11 +00003358 pDb->zDbSName, pTab->zName
drhfaacf172011-08-12 01:51:45 +00003359 );
3360 }
3361#endif
3362
drh346a70c2020-06-15 20:27:35 +00003363 /* Drop all entries in the schema table that refer to the
drh067b92b2020-06-19 15:24:12 +00003364 ** table. The program name loops through the schema table and deletes
drhfaacf172011-08-12 01:51:45 +00003365 ** every row that refers to a table of the same name as the one being
mistachkin48864df2013-03-21 21:20:32 +00003366 ** dropped. Triggers are handled separately because a trigger can be
drhfaacf172011-08-12 01:51:45 +00003367 ** created in the temp database that refers to a table in another
3368 ** database.
3369 */
3370 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +00003371 "DELETE FROM %Q." DFLT_SCHEMA_TABLE
3372 " WHERE tbl_name=%Q and type!='trigger'",
3373 pDb->zDbSName, pTab->zName);
drhfaacf172011-08-12 01:51:45 +00003374 if( !isView && !IsVirtual(pTab) ){
3375 destroyTable(pParse, pTab);
3376 }
3377
3378 /* Remove the table entry from SQLite's internal schema and modify
3379 ** the schema cookie.
3380 */
3381 if( IsVirtual(pTab) ){
3382 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
dan1d4b1642018-12-28 17:45:08 +00003383 sqlite3MayAbort(pParse);
drhfaacf172011-08-12 01:51:45 +00003384 }
3385 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
3386 sqlite3ChangeCookie(pParse, iDb);
3387 sqliteViewResetAll(db, iDb);
drhfaacf172011-08-12 01:51:45 +00003388}
3389
3390/*
drh070ae3b2019-11-16 13:51:31 +00003391** Return TRUE if shadow tables should be read-only in the current
3392** context.
3393*/
3394int sqlite3ReadOnlyShadowTables(sqlite3 *db){
3395#ifndef SQLITE_OMIT_VIRTUALTABLE
3396 if( (db->flags & SQLITE_Defensive)!=0
3397 && db->pVtabCtx==0
3398 && db->nVdbeExec==0
dan73983652021-07-19 14:00:29 +00003399 && !sqlite3VtabInSync(db)
drh070ae3b2019-11-16 13:51:31 +00003400 ){
3401 return 1;
3402 }
3403#endif
3404 return 0;
3405}
3406
3407/*
drhd0c51d12019-11-16 12:04:38 +00003408** Return true if it is not allowed to drop the given table
3409*/
drh070ae3b2019-11-16 13:51:31 +00003410static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
drhd0c51d12019-11-16 12:04:38 +00003411 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
3412 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
3413 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
3414 return 1;
3415 }
drh070ae3b2019-11-16 13:51:31 +00003416 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
3417 return 1;
drhd0c51d12019-11-16 12:04:38 +00003418 }
3419 return 0;
3420}
3421
3422/*
drh75897232000-05-29 14:26:00 +00003423** This routine is called to do the work of a DROP TABLE statement.
drhd9b02572001-04-15 00:37:09 +00003424** pName is the name of the table to be dropped.
drh75897232000-05-29 14:26:00 +00003425*/
drha0733842005-12-29 01:11:36 +00003426void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
danielk1977a8858102004-05-28 12:11:21 +00003427 Table *pTab;
drh75897232000-05-29 14:26:00 +00003428 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00003429 sqlite3 *db = pParse->db;
drhd24cc422003-03-27 12:51:24 +00003430 int iDb;
drh75897232000-05-29 14:26:00 +00003431
drh8af73d42009-05-13 22:58:28 +00003432 if( db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +00003433 goto exit_drop_table;
3434 }
drh8af73d42009-05-13 22:58:28 +00003435 assert( pParse->nErr==0 );
danielk1977a8858102004-05-28 12:11:21 +00003436 assert( pName->nSrc==1 );
drh75209962015-04-19 22:31:45 +00003437 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
drha7564662010-02-22 19:32:31 +00003438 if( noErr ) db->suppressErr++;
drh4d249e62016-06-10 22:49:01 +00003439 assert( isView==0 || isView==LOCATE_VIEW );
dan41fb5cd2012-10-04 19:33:00 +00003440 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
drha7564662010-02-22 19:32:31 +00003441 if( noErr ) db->suppressErr--;
danielk1977a8858102004-05-28 12:11:21 +00003442
drha0733842005-12-29 01:11:36 +00003443 if( pTab==0 ){
drh31da7be2021-05-13 18:24:22 +00003444 if( noErr ){
3445 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
3446 sqlite3ForceNotReadOnly(pParse);
3447 }
drha0733842005-12-29 01:11:36 +00003448 goto exit_drop_table;
3449 }
danielk1977da184232006-01-05 11:34:32 +00003450 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drhe22a3342003-04-22 20:30:37 +00003451 assert( iDb>=0 && iDb<db->nDb );
danielk1977b5258c32007-10-04 18:11:15 +00003452
3453 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
3454 ** it is initialized.
3455 */
3456 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
3457 goto exit_drop_table;
3458 }
drhe5f9c642003-01-13 23:27:31 +00003459#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +00003460 {
3461 int code;
danielk1977da184232006-01-05 11:34:32 +00003462 const char *zTab = SCHEMA_TABLE(iDb);
drh69c33822016-08-18 14:33:11 +00003463 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977f1a381e2006-06-16 08:01:02 +00003464 const char *zArg2 = 0;
danielk19774adee202004-05-08 08:23:19 +00003465 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
danielk1977a8858102004-05-28 12:11:21 +00003466 goto exit_drop_table;
drhe22a3342003-04-22 20:30:37 +00003467 }
drhe5f9c642003-01-13 23:27:31 +00003468 if( isView ){
danielk197753c0f742005-03-29 03:10:59 +00003469 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00003470 code = SQLITE_DROP_TEMP_VIEW;
3471 }else{
3472 code = SQLITE_DROP_VIEW;
3473 }
danielk19774b2688a2006-06-20 11:01:07 +00003474#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977f1a381e2006-06-16 08:01:02 +00003475 }else if( IsVirtual(pTab) ){
3476 code = SQLITE_DROP_VTABLE;
danielk1977595a5232009-07-24 17:58:53 +00003477 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
danielk19774b2688a2006-06-20 11:01:07 +00003478#endif
drhe5f9c642003-01-13 23:27:31 +00003479 }else{
danielk197753c0f742005-03-29 03:10:59 +00003480 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00003481 code = SQLITE_DROP_TEMP_TABLE;
3482 }else{
3483 code = SQLITE_DROP_TABLE;
3484 }
3485 }
danielk1977f1a381e2006-06-16 08:01:02 +00003486 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
danielk1977a8858102004-05-28 12:11:21 +00003487 goto exit_drop_table;
drhe5f9c642003-01-13 23:27:31 +00003488 }
danielk1977a8858102004-05-28 12:11:21 +00003489 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
3490 goto exit_drop_table;
drh77ad4e42003-01-14 02:49:27 +00003491 }
drhe5f9c642003-01-13 23:27:31 +00003492 }
3493#endif
drh070ae3b2019-11-16 13:51:31 +00003494 if( tableMayNotBeDropped(db, pTab) ){
danielk1977a8858102004-05-28 12:11:21 +00003495 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
danielk1977a8858102004-05-28 12:11:21 +00003496 goto exit_drop_table;
drh75897232000-05-29 14:26:00 +00003497 }
danielk1977576ec6b2005-01-21 11:55:25 +00003498
3499#ifndef SQLITE_OMIT_VIEW
3500 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
3501 ** on a table.
3502 */
drhf38524d2021-08-02 16:41:57 +00003503 if( isView && !IsView(pTab) ){
danielk1977a8858102004-05-28 12:11:21 +00003504 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
3505 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00003506 }
drhf38524d2021-08-02 16:41:57 +00003507 if( !isView && IsView(pTab) ){
danielk1977a8858102004-05-28 12:11:21 +00003508 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
3509 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00003510 }
danielk1977576ec6b2005-01-21 11:55:25 +00003511#endif
drh75897232000-05-29 14:26:00 +00003512
drh067b92b2020-06-19 15:24:12 +00003513 /* Generate code to remove the table from the schema table
drh1ccde152000-06-17 13:12:39 +00003514 ** on disk.
3515 */
danielk19774adee202004-05-08 08:23:19 +00003516 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00003517 if( v ){
drh77658e22007-12-04 16:54:52 +00003518 sqlite3BeginWriteOperation(pParse, 1, iDb);
mistachkin0fc2da32018-07-20 20:56:22 +00003519 if( !isView ){
3520 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
3521 sqlite3FkDropTable(pParse, pName, pTab);
3522 }
drhfaacf172011-08-12 01:51:45 +00003523 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
drh75897232000-05-29 14:26:00 +00003524 }
danielk1977a8858102004-05-28 12:11:21 +00003525
3526exit_drop_table:
drh633e6d52008-07-28 19:34:53 +00003527 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00003528}
3529
3530/*
drhc2eef3b2002-08-31 18:53:06 +00003531** This routine is called to create a new foreign key on the table
3532** currently under construction. pFromCol determines which columns
3533** in the current table point to the foreign key. If pFromCol==0 then
3534** connect the key to the last column inserted. pTo is the name of
drhbd50a922013-11-03 02:27:58 +00003535** the table referred to (a.k.a the "parent" table). pToCol is a list
3536** of tables in the parent pTo table. flags contains all
drhc2eef3b2002-08-31 18:53:06 +00003537** information about the conflict resolution algorithms specified
3538** in the ON DELETE, ON UPDATE and ON INSERT clauses.
3539**
3540** An FKey structure is created and added to the table currently
drhe61922a2009-05-02 13:29:37 +00003541** under construction in the pParse->pNewTable field.
drhc2eef3b2002-08-31 18:53:06 +00003542**
3543** The foreign key is set for IMMEDIATE processing. A subsequent call
danielk19774adee202004-05-08 08:23:19 +00003544** to sqlite3DeferForeignKey() might change this to DEFERRED.
drhc2eef3b2002-08-31 18:53:06 +00003545*/
danielk19774adee202004-05-08 08:23:19 +00003546void sqlite3CreateForeignKey(
drhc2eef3b2002-08-31 18:53:06 +00003547 Parse *pParse, /* Parsing context */
danielk19770202b292004-06-09 09:55:16 +00003548 ExprList *pFromCol, /* Columns in this table that point to other table */
drhc2eef3b2002-08-31 18:53:06 +00003549 Token *pTo, /* Name of the other table */
danielk19770202b292004-06-09 09:55:16 +00003550 ExprList *pToCol, /* Columns in the other table */
drhc2eef3b2002-08-31 18:53:06 +00003551 int flags /* Conflict resolution algorithms. */
3552){
danielk197718576932008-08-06 13:47:40 +00003553 sqlite3 *db = pParse->db;
drhb7f91642004-10-31 02:22:47 +00003554#ifndef SQLITE_OMIT_FOREIGN_KEY
drh40e016e2004-11-04 14:47:11 +00003555 FKey *pFKey = 0;
dan1da40a32009-09-19 17:00:31 +00003556 FKey *pNextTo;
drhc2eef3b2002-08-31 18:53:06 +00003557 Table *p = pParse->pNewTable;
3558 int nByte;
3559 int i;
3560 int nCol;
3561 char *z;
drhc2eef3b2002-08-31 18:53:06 +00003562
3563 assert( pTo!=0 );
drh8af73d42009-05-13 22:58:28 +00003564 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
drhc2eef3b2002-08-31 18:53:06 +00003565 if( pFromCol==0 ){
3566 int iCol = p->nCol-1;
drhd3001712009-05-12 17:46:53 +00003567 if( NEVER(iCol<0) ) goto fk_end;
danielk19770202b292004-06-09 09:55:16 +00003568 if( pToCol && pToCol->nExpr!=1 ){
danielk19774adee202004-05-08 08:23:19 +00003569 sqlite3ErrorMsg(pParse, "foreign key on %s"
drhf7a9e1a2004-02-22 18:40:56 +00003570 " should reference only one column of table %T",
drhcf9d36d2021-08-02 18:03:43 +00003571 p->aCol[iCol].zCnName, pTo);
drhc2eef3b2002-08-31 18:53:06 +00003572 goto fk_end;
3573 }
3574 nCol = 1;
danielk19770202b292004-06-09 09:55:16 +00003575 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
danielk19774adee202004-05-08 08:23:19 +00003576 sqlite3ErrorMsg(pParse,
drhc2eef3b2002-08-31 18:53:06 +00003577 "number of columns in foreign key does not match the number of "
drhf7a9e1a2004-02-22 18:40:56 +00003578 "columns in the referenced table");
drhc2eef3b2002-08-31 18:53:06 +00003579 goto fk_end;
3580 }else{
danielk19770202b292004-06-09 09:55:16 +00003581 nCol = pFromCol->nExpr;
drhc2eef3b2002-08-31 18:53:06 +00003582 }
drhe61922a2009-05-02 13:29:37 +00003583 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
drhc2eef3b2002-08-31 18:53:06 +00003584 if( pToCol ){
danielk19770202b292004-06-09 09:55:16 +00003585 for(i=0; i<pToCol->nExpr; i++){
drh41cee662019-12-12 20:22:34 +00003586 nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1;
drhc2eef3b2002-08-31 18:53:06 +00003587 }
3588 }
drh633e6d52008-07-28 19:34:53 +00003589 pFKey = sqlite3DbMallocZero(db, nByte );
drh17435752007-08-16 04:30:38 +00003590 if( pFKey==0 ){
3591 goto fk_end;
3592 }
drhc2eef3b2002-08-31 18:53:06 +00003593 pFKey->pFrom = p;
drh78b2fa82021-10-07 12:11:20 +00003594 assert( IsOrdinaryTable(p) );
drhf38524d2021-08-02 16:41:57 +00003595 pFKey->pNextFrom = p->u.tab.pFKey;
drhe61922a2009-05-02 13:29:37 +00003596 z = (char*)&pFKey->aCol[nCol];
drhdf68f6b2002-09-21 15:57:57 +00003597 pFKey->zTo = z;
danc9461ec2018-08-29 21:00:16 +00003598 if( IN_RENAME_OBJECT ){
3599 sqlite3RenameTokenMap(pParse, (void*)z, pTo);
3600 }
drhc2eef3b2002-08-31 18:53:06 +00003601 memcpy(z, pTo->z, pTo->n);
3602 z[pTo->n] = 0;
danielk197770d9e9c2009-04-24 18:06:09 +00003603 sqlite3Dequote(z);
drhc2eef3b2002-08-31 18:53:06 +00003604 z += pTo->n+1;
drhc2eef3b2002-08-31 18:53:06 +00003605 pFKey->nCol = nCol;
drhc2eef3b2002-08-31 18:53:06 +00003606 if( pFromCol==0 ){
3607 pFKey->aCol[0].iFrom = p->nCol-1;
3608 }else{
3609 for(i=0; i<nCol; i++){
3610 int j;
3611 for(j=0; j<p->nCol; j++){
drhcf9d36d2021-08-02 18:03:43 +00003612 if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){
drhc2eef3b2002-08-31 18:53:06 +00003613 pFKey->aCol[i].iFrom = j;
3614 break;
3615 }
3616 }
3617 if( j>=p->nCol ){
danielk19774adee202004-05-08 08:23:19 +00003618 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00003619 "unknown column \"%s\" in foreign key definition",
drh41cee662019-12-12 20:22:34 +00003620 pFromCol->a[i].zEName);
drhc2eef3b2002-08-31 18:53:06 +00003621 goto fk_end;
3622 }
danc9461ec2018-08-29 21:00:16 +00003623 if( IN_RENAME_OBJECT ){
drh41cee662019-12-12 20:22:34 +00003624 sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
dancf8f2892018-08-09 20:47:01 +00003625 }
drhc2eef3b2002-08-31 18:53:06 +00003626 }
3627 }
3628 if( pToCol ){
3629 for(i=0; i<nCol; i++){
drh41cee662019-12-12 20:22:34 +00003630 int n = sqlite3Strlen30(pToCol->a[i].zEName);
drhc2eef3b2002-08-31 18:53:06 +00003631 pFKey->aCol[i].zCol = z;
danc9461ec2018-08-29 21:00:16 +00003632 if( IN_RENAME_OBJECT ){
drh41cee662019-12-12 20:22:34 +00003633 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
dan6fe7f232018-08-10 19:19:33 +00003634 }
drh41cee662019-12-12 20:22:34 +00003635 memcpy(z, pToCol->a[i].zEName, n);
drhc2eef3b2002-08-31 18:53:06 +00003636 z[n] = 0;
3637 z += n+1;
3638 }
3639 }
3640 pFKey->isDeferred = 0;
dan8099ce62009-09-23 08:43:35 +00003641 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
3642 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
drhc2eef3b2002-08-31 18:53:06 +00003643
drh21206082011-04-04 18:22:02 +00003644 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
dan1da40a32009-09-19 17:00:31 +00003645 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
drhacbcb7e2014-08-21 20:26:37 +00003646 pFKey->zTo, (void *)pFKey
dan1da40a32009-09-19 17:00:31 +00003647 );
danf59c5ca2009-09-22 16:55:38 +00003648 if( pNextTo==pFKey ){
drh4a642b62016-02-05 01:55:27 +00003649 sqlite3OomFault(db);
danf59c5ca2009-09-22 16:55:38 +00003650 goto fk_end;
3651 }
dan1da40a32009-09-19 17:00:31 +00003652 if( pNextTo ){
3653 assert( pNextTo->pPrevTo==0 );
3654 pFKey->pNextTo = pNextTo;
3655 pNextTo->pPrevTo = pFKey;
3656 }
3657
drhc2eef3b2002-08-31 18:53:06 +00003658 /* Link the foreign key to the table as the last step.
3659 */
drh78b2fa82021-10-07 12:11:20 +00003660 assert( IsOrdinaryTable(p) );
drhf38524d2021-08-02 16:41:57 +00003661 p->u.tab.pFKey = pFKey;
drhc2eef3b2002-08-31 18:53:06 +00003662 pFKey = 0;
3663
3664fk_end:
drh633e6d52008-07-28 19:34:53 +00003665 sqlite3DbFree(db, pFKey);
drhb7f91642004-10-31 02:22:47 +00003666#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
drh633e6d52008-07-28 19:34:53 +00003667 sqlite3ExprListDelete(db, pFromCol);
3668 sqlite3ExprListDelete(db, pToCol);
drhc2eef3b2002-08-31 18:53:06 +00003669}
3670
3671/*
3672** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
3673** clause is seen as part of a foreign key definition. The isDeferred
3674** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
3675** The behavior of the most recently created foreign key is adjusted
3676** accordingly.
3677*/
danielk19774adee202004-05-08 08:23:19 +00003678void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
drhb7f91642004-10-31 02:22:47 +00003679#ifndef SQLITE_OMIT_FOREIGN_KEY
drhc2eef3b2002-08-31 18:53:06 +00003680 Table *pTab;
3681 FKey *pFKey;
drhf38524d2021-08-02 16:41:57 +00003682 if( (pTab = pParse->pNewTable)==0 ) return;
drh78b2fa82021-10-07 12:11:20 +00003683 if( NEVER(!IsOrdinaryTable(pTab)) ) return;
drhf38524d2021-08-02 16:41:57 +00003684 if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
drh4c429832009-10-12 22:30:49 +00003685 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
drh1bd10f82008-12-10 21:19:56 +00003686 pFKey->isDeferred = (u8)isDeferred;
drhb7f91642004-10-31 02:22:47 +00003687#endif
drhc2eef3b2002-08-31 18:53:06 +00003688}
3689
3690/*
drh063336a2004-11-05 20:58:39 +00003691** Generate code that will erase and refill index *pIdx. This is
3692** used to initialize a newly created index or to recompute the
3693** content of an index in response to a REINDEX command.
3694**
3695** if memRootPage is not negative, it means that the index is newly
drh1db639c2008-01-17 02:36:28 +00003696** created. The register specified by memRootPage contains the
drh063336a2004-11-05 20:58:39 +00003697** root page number of the index. If memRootPage is negative, then
3698** the index already exists and must be cleared before being refilled and
3699** the root page number of the index is taken from pIndex->tnum.
3700*/
3701static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
3702 Table *pTab = pIndex->pTable; /* The table that is indexed */
danielk19776ab3a2e2009-02-19 14:39:25 +00003703 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
3704 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
drhb07028f2011-10-14 21:49:18 +00003705 int iSorter; /* Cursor opened by OpenSorter (if in use) */
drh063336a2004-11-05 20:58:39 +00003706 int addr1; /* Address of top of loop */
dan5134d132011-09-02 10:31:11 +00003707 int addr2; /* Address to jump to for next iteration */
drhabc38152020-07-22 13:38:04 +00003708 Pgno tnum; /* Root page of index */
drhb2b9d3d2013-08-01 01:14:43 +00003709 int iPartIdxLabel; /* Jump to this label to skip a row */
drh063336a2004-11-05 20:58:39 +00003710 Vdbe *v; /* Generate code into this virtual machine */
danielk1977b3bf5562006-01-10 17:58:23 +00003711 KeyInfo *pKey; /* KeyInfo for index */
peter.d.reid60ec9142014-09-06 16:39:46 +00003712 int regRecord; /* Register holding assembled index record */
drh17435752007-08-16 04:30:38 +00003713 sqlite3 *db = pParse->db; /* The database connection */
3714 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drh063336a2004-11-05 20:58:39 +00003715
danielk19771d54df82004-11-23 15:41:16 +00003716#ifndef SQLITE_OMIT_AUTHORIZATION
3717 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
drh69c33822016-08-18 14:33:11 +00003718 db->aDb[iDb].zDbSName ) ){
danielk19771d54df82004-11-23 15:41:16 +00003719 return;
3720 }
3721#endif
3722
danielk1977c00da102006-01-07 13:21:04 +00003723 /* Require a write-lock on the table to perform this operation */
3724 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
3725
drh063336a2004-11-05 20:58:39 +00003726 v = sqlite3GetVdbe(pParse);
3727 if( v==0 ) return;
3728 if( memRootPage>=0 ){
drhabc38152020-07-22 13:38:04 +00003729 tnum = (Pgno)memRootPage;
drh063336a2004-11-05 20:58:39 +00003730 }else{
3731 tnum = pIndex->tnum;
drh063336a2004-11-05 20:58:39 +00003732 }
drh2ec2fb22013-11-06 19:59:23 +00003733 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
drh60de73e2016-04-05 15:59:23 +00003734 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
dana20fde62011-07-12 14:28:05 +00003735
dan689ab892011-08-12 15:02:00 +00003736 /* Open the sorter cursor if we are to use one. */
drhca892a72011-09-03 00:17:51 +00003737 iSorter = pParse->nTab++;
danfad9f9a2014-04-01 18:41:51 +00003738 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
drh2ec2fb22013-11-06 19:59:23 +00003739 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
dana20fde62011-07-12 14:28:05 +00003740
3741 /* Open the table. Loop through all rows of the table, inserting index
3742 ** records into the sorter. */
drhdd9930e2013-10-23 23:37:02 +00003743 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
drh688852a2014-02-17 22:40:43 +00003744 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
drh2d401ab2008-01-10 23:50:11 +00003745 regRecord = sqlite3GetTempReg(pParse);
drh4031baf2018-05-28 17:31:20 +00003746 sqlite3MultiWrite(pParse);
dana20fde62011-07-12 14:28:05 +00003747
drh1c2c0b72014-01-04 19:27:05 +00003748 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
drhca892a72011-09-03 00:17:51 +00003749 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
drh87744512014-04-13 19:15:49 +00003750 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
drh688852a2014-02-17 22:40:43 +00003751 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
drhca892a72011-09-03 00:17:51 +00003752 sqlite3VdbeJumpHere(v, addr1);
drh44156282013-10-23 22:23:03 +00003753 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
drhabc38152020-07-22 13:38:04 +00003754 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
drh2ec2fb22013-11-06 19:59:23 +00003755 (char *)pKey, P4_KEYINFO);
drh44156282013-10-23 22:23:03 +00003756 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
3757
drh688852a2014-02-17 22:40:43 +00003758 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
drh60de73e2016-04-05 15:59:23 +00003759 if( IsUniqueIndex(pIndex) ){
drh4031baf2018-05-28 17:31:20 +00003760 int j2 = sqlite3VdbeGoto(v, 1);
drhca892a72011-09-03 00:17:51 +00003761 addr2 = sqlite3VdbeCurrentAddr(v);
drh4031baf2018-05-28 17:31:20 +00003762 sqlite3VdbeVerifyAbortable(v, OE_Abort);
drh1153c7b2013-11-01 22:02:56 +00003763 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
drhac502322014-07-30 13:56:48 +00003764 pIndex->nKeyCol); VdbeCoverage(v);
drhf9c8ce32013-11-05 13:33:55 +00003765 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
drh4031baf2018-05-28 17:31:20 +00003766 sqlite3VdbeJumpHere(v, j2);
drhca892a72011-09-03 00:17:51 +00003767 }else{
dan7ed6c062019-05-21 16:32:41 +00003768 /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
3769 ** abort. The exception is if one of the indexed expressions contains a
3770 ** user function that throws an exception when it is evaluated. But the
3771 ** overhead of adding a statement journal to a CREATE INDEX statement is
3772 ** very small (since most of the pages written do not contain content that
3773 ** needs to be restored if the statement aborts), so we call
3774 ** sqlite3MayAbort() for all CREATE INDEX statements. */
danef14abb2019-05-21 14:42:24 +00003775 sqlite3MayAbort(pParse);
drhca892a72011-09-03 00:17:51 +00003776 addr2 = sqlite3VdbeCurrentAddr(v);
dan689ab892011-08-12 15:02:00 +00003777 }
drh6cf4a7d2014-10-13 13:00:58 +00003778 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
drhbf9ff252019-05-14 00:43:13 +00003779 if( !pIndex->bAscKeyBug ){
3780 /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
3781 ** faster by avoiding unnecessary seeks. But the optimization does
3782 ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
3783 ** with DESC primary keys, since those indexes have there keys in
3784 ** a different order from the main table.
3785 ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
3786 */
3787 sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
3788 }
drh9b4eaeb2016-11-09 00:10:33 +00003789 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
drhca892a72011-09-03 00:17:51 +00003790 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drh2d401ab2008-01-10 23:50:11 +00003791 sqlite3ReleaseTempReg(pParse, regRecord);
drh688852a2014-02-17 22:40:43 +00003792 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
drhd654be82005-09-20 17:42:23 +00003793 sqlite3VdbeJumpHere(v, addr1);
dana20fde62011-07-12 14:28:05 +00003794
drh66a51672008-01-03 00:01:23 +00003795 sqlite3VdbeAddOp1(v, OP_Close, iTab);
3796 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
dan689ab892011-08-12 15:02:00 +00003797 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
drh063336a2004-11-05 20:58:39 +00003798}
3799
3800/*
drh77e57df2013-10-22 14:28:02 +00003801** Allocate heap space to hold an Index object with nCol columns.
3802**
3803** Increase the allocation size to provide an extra nExtra bytes
3804** of 8-byte aligned space after the Index object and return a
3805** pointer to this extra space in *ppExtra.
3806*/
3807Index *sqlite3AllocateIndexObject(
3808 sqlite3 *db, /* Database connection */
drhbbbdc832013-10-22 18:01:40 +00003809 i16 nCol, /* Total number of columns in the index */
drh77e57df2013-10-22 14:28:02 +00003810 int nExtra, /* Number of bytes of extra space to alloc */
3811 char **ppExtra /* Pointer to the "extra" space */
3812){
3813 Index *p; /* Allocated index object */
3814 int nByte; /* Bytes of space for Index object + arrays */
3815
3816 nByte = ROUND8(sizeof(Index)) + /* Index structure */
3817 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
dancfc9df72014-04-25 15:01:01 +00003818 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
drhbbbdc832013-10-22 18:01:40 +00003819 sizeof(i16)*nCol + /* Index.aiColumn */
drh77e57df2013-10-22 14:28:02 +00003820 sizeof(u8)*nCol); /* Index.aSortOrder */
3821 p = sqlite3DbMallocZero(db, nByte + nExtra);
3822 if( p ){
3823 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
drhf19aa5f2015-12-30 16:51:20 +00003824 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
dancfc9df72014-04-25 15:01:01 +00003825 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
3826 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
drh77e57df2013-10-22 14:28:02 +00003827 p->aSortOrder = (u8*)pExtra;
3828 p->nColumn = nCol;
drhbbbdc832013-10-22 18:01:40 +00003829 p->nKeyCol = nCol - 1;
drh77e57df2013-10-22 14:28:02 +00003830 *ppExtra = ((char*)p) + nByte;
3831 }
3832 return p;
3833}
3834
3835/*
dan9105fd52019-08-19 17:26:32 +00003836** If expression list pList contains an expression that was parsed with
3837** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
3838** pParse and return non-zero. Otherwise, return zero.
3839*/
3840int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
3841 if( pList ){
3842 int i;
3843 for(i=0; i<pList->nExpr; i++){
3844 if( pList->a[i].bNulls ){
3845 u8 sf = pList->a[i].sortFlags;
3846 sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
3847 (sf==0 || sf==3) ? "FIRST" : "LAST"
3848 );
3849 return 1;
3850 }
3851 }
3852 }
3853 return 0;
3854}
3855
3856/*
drh23bf66d2004-12-14 03:34:34 +00003857** Create a new index for an SQL table. pName1.pName2 is the name of the index
3858** and pTblList is the name of the table that is to be indexed. Both will
drhadbca9c2001-09-27 15:11:53 +00003859** be NULL for a primary key or an index that is created to satisfy a
3860** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
drh382c0242001-10-06 16:33:02 +00003861** as the table to be indexed. pParse->pNewTable is a table that is
3862** currently being constructed by a CREATE TABLE statement.
drh75897232000-05-29 14:26:00 +00003863**
drh382c0242001-10-06 16:33:02 +00003864** pList is a list of columns to be indexed. pList will be NULL if this
3865** is a primary key or unique-constraint on the most recent column added
3866** to the table currently under construction.
drh75897232000-05-29 14:26:00 +00003867*/
drh62340f82016-05-31 21:18:15 +00003868void sqlite3CreateIndex(
drh23bf66d2004-12-14 03:34:34 +00003869 Parse *pParse, /* All information about this parse */
3870 Token *pName1, /* First part of index name. May be NULL */
3871 Token *pName2, /* Second part of index name. May be NULL */
3872 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
danielk19770202b292004-06-09 09:55:16 +00003873 ExprList *pList, /* A list of columns to be indexed */
drh23bf66d2004-12-14 03:34:34 +00003874 int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
drh1c55ba02007-07-02 19:31:27 +00003875 Token *pStart, /* The CREATE token that begins this statement */
drh1fe05372013-07-31 18:12:26 +00003876 Expr *pPIWhere, /* WHERE clause for partial indices */
drh4d91a702006-01-04 15:54:36 +00003877 int sortOrder, /* Sort order of primary key when pList==NULL */
drh62340f82016-05-31 21:18:15 +00003878 int ifNotExist, /* Omit error if index already exists */
3879 u8 idxType /* The index type */
drh75897232000-05-29 14:26:00 +00003880){
drhfdd6e852005-12-16 01:06:16 +00003881 Table *pTab = 0; /* Table to be indexed */
3882 Index *pIndex = 0; /* The index to be created */
3883 char *zName = 0; /* Name of the index */
3884 int nName; /* Number of characters in zName */
drhbeae3192001-09-22 18:12:08 +00003885 int i, j;
drhfdd6e852005-12-16 01:06:16 +00003886 DbFixer sFix; /* For assigning database names to pTable */
3887 int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
drh9bb575f2004-09-06 17:24:11 +00003888 sqlite3 *db = pParse->db;
drhfdd6e852005-12-16 01:06:16 +00003889 Db *pDb; /* The specific table containing the indexed database */
3890 int iDb; /* Index of the database that is being written */
3891 Token *pName = 0; /* Unqualified name of the index to create */
3892 struct ExprList_item *pListItem; /* For looping over pList */
drhc28c4e52013-10-03 19:21:41 +00003893 int nExtra = 0; /* Space allocated for zExtra[] */
drh44156282013-10-23 22:23:03 +00003894 int nExtraCol; /* Number of extra columns needed */
drh47b927d2013-12-03 00:11:40 +00003895 char *zExtra = 0; /* Extra space after the Index object */
drh44156282013-10-23 22:23:03 +00003896 Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
danielk1977cbb18d22004-05-28 11:37:27 +00003897
drh62340f82016-05-31 21:18:15 +00003898 if( db->mallocFailed || pParse->nErr>0 ){
3899 goto exit_create_index;
3900 }
3901 if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
drhd3001712009-05-12 17:46:53 +00003902 goto exit_create_index;
3903 }
3904 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e501b892006-01-09 06:29:47 +00003905 goto exit_create_index;
3906 }
dan9105fd52019-08-19 17:26:32 +00003907 if( sqlite3HasExplicitNulls(pParse, pList) ){
3908 goto exit_create_index;
3909 }
drhdaffd0e2001-04-11 14:28:42 +00003910
drh75897232000-05-29 14:26:00 +00003911 /*
3912 ** Find the table that is to be indexed. Return early if not found.
3913 */
danielk1977cbb18d22004-05-28 11:37:27 +00003914 if( pTblName!=0 ){
danielk1977cbb18d22004-05-28 11:37:27 +00003915
3916 /* Use the two-part index name to determine the database
danielk1977ef2cb632004-05-29 02:37:19 +00003917 ** to search for the table. 'Fix' the table name to this db
3918 ** before looking up the table.
danielk1977cbb18d22004-05-28 11:37:27 +00003919 */
3920 assert( pName1 && pName2 );
danielk1977ef2cb632004-05-29 02:37:19 +00003921 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
danielk1977cbb18d22004-05-28 11:37:27 +00003922 if( iDb<0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00003923 assert( pName && pName->z );
danielk1977cbb18d22004-05-28 11:37:27 +00003924
danielk197753c0f742005-03-29 03:10:59 +00003925#ifndef SQLITE_OMIT_TEMPDB
mistachkind5578432012-08-25 10:01:29 +00003926 /* If the index name was unqualified, check if the table
danielk1977fe910332007-12-02 11:46:34 +00003927 ** is a temp table. If so, set the database to 1. Do not do this
3928 ** if initialising a database schema.
danielk1977cbb18d22004-05-28 11:37:27 +00003929 */
danielk1977fe910332007-12-02 11:46:34 +00003930 if( !db->init.busy ){
3931 pTab = sqlite3SrcListLookup(pParse, pTblName);
drhd3001712009-05-12 17:46:53 +00003932 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
danielk1977fe910332007-12-02 11:46:34 +00003933 iDb = 1;
3934 }
danielk1977ef2cb632004-05-29 02:37:19 +00003935 }
danielk197753c0f742005-03-29 03:10:59 +00003936#endif
danielk1977ef2cb632004-05-29 02:37:19 +00003937
drhd100f692013-10-03 15:39:44 +00003938 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
3939 if( sqlite3FixSrcList(&sFix, pTblName) ){
drh85c23c62005-08-20 03:03:04 +00003940 /* Because the parser constructs pTblName from a single identifier,
3941 ** sqlite3FixSrcList can never fail. */
3942 assert(0);
danielk1977cbb18d22004-05-28 11:37:27 +00003943 }
dan41fb5cd2012-10-04 19:33:00 +00003944 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
drhc31c7c12012-10-08 23:25:07 +00003945 assert( db->mallocFailed==0 || pTab==0 );
3946 if( pTab==0 ) goto exit_create_index;
drh989b1162013-08-01 22:27:26 +00003947 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
3948 sqlite3ErrorMsg(pParse,
3949 "cannot create a TEMP index on non-TEMP table \"%s\"",
3950 pTab->zName);
3951 goto exit_create_index;
3952 }
drh44156282013-10-23 22:23:03 +00003953 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
drh75897232000-05-29 14:26:00 +00003954 }else{
drhe3c41372001-09-17 20:25:58 +00003955 assert( pName==0 );
drhb07028f2011-10-14 21:49:18 +00003956 assert( pStart==0 );
danielk1977da184232006-01-05 11:34:32 +00003957 pTab = pParse->pNewTable;
drha6370df2006-01-04 21:40:06 +00003958 if( !pTab ) goto exit_create_index;
danielk1977da184232006-01-05 11:34:32 +00003959 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh75897232000-05-29 14:26:00 +00003960 }
drhfdd6e852005-12-16 01:06:16 +00003961 pDb = &db->aDb[iDb];
danielk1977cbb18d22004-05-28 11:37:27 +00003962
drhd3001712009-05-12 17:46:53 +00003963 assert( pTab!=0 );
3964 assert( pParse->nErr==0 );
drh03881232009-02-13 03:43:31 +00003965 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
drh3a3a03f2014-09-11 16:36:43 +00003966 && db->init.busy==0
drh346f4e22019-03-25 21:35:41 +00003967 && pTblName!=0
drhd4530972014-09-09 14:47:53 +00003968#if SQLITE_USER_AUTHENTICATION
3969 && sqlite3UserAuthTable(pTab->zName)==0
3970#endif
drh067b92b2020-06-19 15:24:12 +00003971 ){
danielk19774adee202004-05-08 08:23:19 +00003972 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
drh0be9df02003-03-30 00:19:49 +00003973 goto exit_create_index;
3974 }
danielk1977576ec6b2005-01-21 11:55:25 +00003975#ifndef SQLITE_OMIT_VIEW
drhf38524d2021-08-02 16:41:57 +00003976 if( IsView(pTab) ){
danielk19774adee202004-05-08 08:23:19 +00003977 sqlite3ErrorMsg(pParse, "views may not be indexed");
drha76b5df2002-02-23 02:32:10 +00003978 goto exit_create_index;
3979 }
danielk1977576ec6b2005-01-21 11:55:25 +00003980#endif
danielk19775ee9d692006-06-21 12:36:25 +00003981#ifndef SQLITE_OMIT_VIRTUALTABLE
3982 if( IsVirtual(pTab) ){
3983 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
3984 goto exit_create_index;
3985 }
3986#endif
drh75897232000-05-29 14:26:00 +00003987
3988 /*
3989 ** Find the name of the index. Make sure there is not already another
drhf57b3392001-10-08 13:22:32 +00003990 ** index or table with the same name.
3991 **
3992 ** Exception: If we are reading the names of permanent indices from the
drh1e32bed2020-06-19 13:33:53 +00003993 ** sqlite_schema table (because some other process changed the schema) and
drhf57b3392001-10-08 13:22:32 +00003994 ** one of the index names collides with the name of a temporary table or
drhd24cc422003-03-27 12:51:24 +00003995 ** index, then we will continue to process this index.
drhf57b3392001-10-08 13:22:32 +00003996 **
3997 ** If pName==0 it means that we are
drhadbca9c2001-09-27 15:11:53 +00003998 ** dealing with a primary key or UNIQUE constraint. We have to invent our
3999 ** own name.
drh75897232000-05-29 14:26:00 +00004000 */
danielk1977d8123362004-06-12 09:25:12 +00004001 if( pName ){
drh17435752007-08-16 04:30:38 +00004002 zName = sqlite3NameFromToken(db, pName);
drhe3c41372001-09-17 20:25:58 +00004003 if( zName==0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00004004 assert( pName->z!=0 );
drhc5a93d42019-08-12 00:08:07 +00004005 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
drhd24cc422003-03-27 12:51:24 +00004006 goto exit_create_index;
drhe3c41372001-09-17 20:25:58 +00004007 }
danc9461ec2018-08-29 21:00:16 +00004008 if( !IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00004009 if( !db->init.busy ){
4010 if( sqlite3FindTable(db, zName, 0)!=0 ){
4011 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
4012 goto exit_create_index;
4013 }
4014 }
4015 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
4016 if( !ifNotExist ){
4017 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
4018 }else{
4019 assert( !db->init.busy );
4020 sqlite3CodeVerifySchema(pParse, iDb);
drh31da7be2021-05-13 18:24:22 +00004021 sqlite3ForceNotReadOnly(pParse);
dancf8f2892018-08-09 20:47:01 +00004022 }
danielk1977d45a0312007-03-13 16:32:25 +00004023 goto exit_create_index;
4024 }
4025 }
danielk1977a21c6b62005-01-24 10:25:59 +00004026 }else{
drhadbca9c2001-09-27 15:11:53 +00004027 int n;
4028 Index *pLoop;
4029 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
drhf089aa42008-07-08 19:34:06 +00004030 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
danielk1977a1644fd2007-08-29 12:31:25 +00004031 if( zName==0 ){
danielk1977a1644fd2007-08-29 12:31:25 +00004032 goto exit_create_index;
4033 }
drh0aafa9c2016-08-05 14:35:47 +00004034
4035 /* Automatic index names generated from within sqlite3_declare_vtab()
4036 ** must have names that are distinct from normal automatic index names.
4037 ** The following statement converts "sqlite3_autoindex..." into
4038 ** "sqlite3_butoindex..." in order to make the names distinct.
4039 ** The "vtab_err.test" test demonstrates the need of this statement. */
dancf8f2892018-08-09 20:47:01 +00004040 if( IN_SPECIAL_PARSE ) zName[7]++;
drh75897232000-05-29 14:26:00 +00004041 }
4042
drhe5f9c642003-01-13 23:27:31 +00004043 /* Check for authorization to create an index.
4044 */
4045#ifndef SQLITE_OMIT_AUTHORIZATION
danc9461ec2018-08-29 21:00:16 +00004046 if( !IN_RENAME_OBJECT ){
drh69c33822016-08-18 14:33:11 +00004047 const char *zDb = pDb->zDbSName;
danielk197753c0f742005-03-29 03:10:59 +00004048 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
drhe22a3342003-04-22 20:30:37 +00004049 goto exit_create_index;
4050 }
4051 i = SQLITE_CREATE_INDEX;
danielk197753c0f742005-03-29 03:10:59 +00004052 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00004053 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
drhe22a3342003-04-22 20:30:37 +00004054 goto exit_create_index;
4055 }
drhe5f9c642003-01-13 23:27:31 +00004056 }
4057#endif
4058
drh75897232000-05-29 14:26:00 +00004059 /* If pList==0, it means this routine was called to make a primary
drh1ccde152000-06-17 13:12:39 +00004060 ** key out of the last column added to the table under construction.
drh75897232000-05-29 14:26:00 +00004061 ** So create a fake list to simulate this.
4062 */
4063 if( pList==0 ){
drh108aa002015-08-24 20:21:20 +00004064 Token prevCol;
dan26e731c2018-01-29 16:22:39 +00004065 Column *pCol = &pTab->aCol[pTab->nCol-1];
4066 pCol->colFlags |= COLFLAG_UNIQUE;
drhcf9d36d2021-08-02 18:03:43 +00004067 sqlite3TokenInit(&prevCol, pCol->zCnName);
drh108aa002015-08-24 20:21:20 +00004068 pList = sqlite3ExprListAppend(pParse, 0,
4069 sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
drh75897232000-05-29 14:26:00 +00004070 if( pList==0 ) goto exit_create_index;
drhbc622bc2015-08-24 15:39:42 +00004071 assert( pList->nExpr==1 );
dan5b32bdf2019-08-17 15:47:32 +00004072 sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
drh108aa002015-08-24 20:21:20 +00004073 }else{
4074 sqlite3ExprListCheckLength(pParse, pList, "index");
drh8fe25c62019-03-31 21:09:33 +00004075 if( pParse->nErr ) goto exit_create_index;
drh75897232000-05-29 14:26:00 +00004076 }
4077
danielk1977b3bf5562006-01-10 17:58:23 +00004078 /* Figure out how many bytes of space are required to store explicitly
4079 ** specified collation sequence names.
4080 */
4081 for(i=0; i<pList->nExpr; i++){
drhd3001712009-05-12 17:46:53 +00004082 Expr *pExpr = pList->a[i].pExpr;
drh7d3d9da2015-09-01 00:42:52 +00004083 assert( pExpr!=0 );
4084 if( pExpr->op==TK_COLLATE ){
drhf9751072021-10-07 13:40:29 +00004085 assert( !ExprHasProperty(pExpr, EP_IntValue) );
dan911ce412013-05-15 15:16:50 +00004086 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
danielk1977b3bf5562006-01-10 17:58:23 +00004087 }
4088 }
4089
drh75897232000-05-29 14:26:00 +00004090 /*
4091 ** Allocate the index structure.
4092 */
drhea678832008-12-10 19:26:22 +00004093 nName = sqlite3Strlen30(zName);
drh44156282013-10-23 22:23:03 +00004094 nExtraCol = pPk ? pPk->nKeyCol : 1;
drh8fe25c62019-03-31 21:09:33 +00004095 assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
drh44156282013-10-23 22:23:03 +00004096 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
drh77e57df2013-10-22 14:28:02 +00004097 nName + nExtra + 1, &zExtra);
drh17435752007-08-16 04:30:38 +00004098 if( db->mallocFailed ){
4099 goto exit_create_index;
4100 }
dancfc9df72014-04-25 15:01:01 +00004101 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
drhe09b84c2011-11-14 02:53:54 +00004102 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
drh77e57df2013-10-22 14:28:02 +00004103 pIndex->zName = zExtra;
4104 zExtra += nName + 1;
drh5bb3eb92007-05-04 13:15:55 +00004105 memcpy(pIndex->zName, zName, nName+1);
drh75897232000-05-29 14:26:00 +00004106 pIndex->pTable = pTab;
drh1bd10f82008-12-10 21:19:56 +00004107 pIndex->onError = (u8)onError;
drh9eade082013-10-24 14:16:10 +00004108 pIndex->uniqNotNull = onError!=OE_None;
drh62340f82016-05-31 21:18:15 +00004109 pIndex->idxType = idxType;
danielk1977da184232006-01-05 11:34:32 +00004110 pIndex->pSchema = db->aDb[iDb].pSchema;
drh72ffd092013-10-30 15:52:32 +00004111 pIndex->nKeyCol = pList->nExpr;
drh3780be12013-07-31 19:05:22 +00004112 if( pPIWhere ){
4113 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
4114 pIndex->pPartIdxWhere = pPIWhere;
4115 pPIWhere = 0;
4116 }
drh21206082011-04-04 18:22:02 +00004117 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh75897232000-05-29 14:26:00 +00004118
drhfdd6e852005-12-16 01:06:16 +00004119 /* Check to see if we should honor DESC requests on index columns
4120 */
danielk1977da184232006-01-05 11:34:32 +00004121 if( pDb->pSchema->file_format>=4 ){
drhfdd6e852005-12-16 01:06:16 +00004122 sortOrderMask = -1; /* Honor DESC */
drhfdd6e852005-12-16 01:06:16 +00004123 }else{
4124 sortOrderMask = 0; /* Ignore DESC */
4125 }
4126
drh1f9ca2c2015-08-25 16:57:52 +00004127 /* Analyze the list of expressions that form the terms of the index and
4128 ** report any errors. In the common case where the expression is exactly
4129 ** a table column, store that column in aiColumn[]. For general expressions,
drh4b92f982015-09-29 17:20:14 +00004130 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
drhd3001712009-05-12 17:46:53 +00004131 **
drh1f9ca2c2015-08-25 16:57:52 +00004132 ** TODO: Issue a warning if two or more columns of the index are identical.
4133 ** TODO: Issue a warning if the table primary key is used as part of the
4134 ** index key.
drh75897232000-05-29 14:26:00 +00004135 */
dancf8f2892018-08-09 20:47:01 +00004136 pListItem = pList->a;
danc9461ec2018-08-29 21:00:16 +00004137 if( IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00004138 pIndex->aColExpr = pList;
4139 pList = 0;
4140 }
4141 for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
drh1f9ca2c2015-08-25 16:57:52 +00004142 Expr *pCExpr; /* The i-th index expression */
4143 int requestedSortOrder; /* ASC or DESC on the i-th expression */
drhf19aa5f2015-12-30 16:51:20 +00004144 const char *zColl; /* Collation sequence name */
danielk1977b3bf5562006-01-10 17:58:23 +00004145
drhedb04ed2015-09-04 12:54:01 +00004146 sqlite3StringToId(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00004147 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
4148 if( pParse->nErr ) goto exit_create_index;
drh108aa002015-08-24 20:21:20 +00004149 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00004150 if( pCExpr->op!=TK_COLUMN ){
drh1f9ca2c2015-08-25 16:57:52 +00004151 if( pTab==pParse->pNewTable ){
4152 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
4153 "UNIQUE constraints");
4154 goto exit_create_index;
4155 }
4156 if( pIndex->aColExpr==0 ){
dancf8f2892018-08-09 20:47:01 +00004157 pIndex->aColExpr = pList;
4158 pList = 0;
drh1f9ca2c2015-08-25 16:57:52 +00004159 }
drh4b92f982015-09-29 17:20:14 +00004160 j = XN_EXPR;
4161 pIndex->aiColumn[i] = XN_EXPR;
drh84926532015-08-31 19:38:42 +00004162 pIndex->uniqNotNull = 0;
drh1f9ca2c2015-08-25 16:57:52 +00004163 }else{
4164 j = pCExpr->iColumn;
4165 assert( j<=0x7fff );
4166 if( j<0 ){
4167 j = pTab->iPKey;
drhc7476732019-10-24 20:29:25 +00004168 }else{
4169 if( pTab->aCol[j].notNull==0 ){
4170 pIndex->uniqNotNull = 0;
4171 }
4172 if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
4173 pIndex->bHasVCol = 1;
4174 }
drh1f9ca2c2015-08-25 16:57:52 +00004175 }
4176 pIndex->aiColumn[i] = (i16)j;
drh108aa002015-08-24 20:21:20 +00004177 }
drha514b8e2015-08-25 00:27:06 +00004178 zColl = 0;
drh108aa002015-08-24 20:21:20 +00004179 if( pListItem->pExpr->op==TK_COLLATE ){
drhd3001712009-05-12 17:46:53 +00004180 int nColl;
drhf9751072021-10-07 13:40:29 +00004181 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
dan911ce412013-05-15 15:16:50 +00004182 zColl = pListItem->pExpr->u.zToken;
drhd3001712009-05-12 17:46:53 +00004183 nColl = sqlite3Strlen30(zColl) + 1;
4184 assert( nExtra>=nColl );
4185 memcpy(zExtra, zColl, nColl);
danielk1977b3bf5562006-01-10 17:58:23 +00004186 zColl = zExtra;
drhd3001712009-05-12 17:46:53 +00004187 zExtra += nColl;
4188 nExtra -= nColl;
drha514b8e2015-08-25 00:27:06 +00004189 }else if( j>=0 ){
drh65b40092021-08-05 15:27:19 +00004190 zColl = sqlite3ColumnColl(&pTab->aCol[j]);
danielk19770202b292004-06-09 09:55:16 +00004191 }
drhf19aa5f2015-12-30 16:51:20 +00004192 if( !zColl ) zColl = sqlite3StrBINARY;
drhb7f24de2009-05-13 17:35:23 +00004193 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
danielk19777cedc8d2004-06-10 10:50:08 +00004194 goto exit_create_index;
4195 }
danielk1977b3bf5562006-01-10 17:58:23 +00004196 pIndex->azColl[i] = zColl;
dan6e118922019-08-12 16:36:38 +00004197 requestedSortOrder = pListItem->sortFlags & sortOrderMask;
drh1bd10f82008-12-10 21:19:56 +00004198 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
drh75897232000-05-29 14:26:00 +00004199 }
drh1f9ca2c2015-08-25 16:57:52 +00004200
4201 /* Append the table key to the end of the index. For WITHOUT ROWID
4202 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
4203 ** normal tables (when pPk==0) this will be the rowid.
4204 */
drh44156282013-10-23 22:23:03 +00004205 if( pPk ){
drh7913e412013-11-01 20:30:36 +00004206 for(j=0; j<pPk->nKeyCol; j++){
4207 int x = pPk->aiColumn[j];
drh1f9ca2c2015-08-25 16:57:52 +00004208 assert( x>=0 );
drhf78d0f42019-04-28 19:27:02 +00004209 if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
drh7913e412013-11-01 20:30:36 +00004210 pIndex->nColumn--;
4211 }else{
drhf78d0f42019-04-28 19:27:02 +00004212 testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
drh7913e412013-11-01 20:30:36 +00004213 pIndex->aiColumn[i] = x;
4214 pIndex->azColl[i] = pPk->azColl[j];
4215 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
4216 i++;
4217 }
drh44156282013-10-23 22:23:03 +00004218 }
drh7913e412013-11-01 20:30:36 +00004219 assert( i==pIndex->nColumn );
drh44156282013-10-23 22:23:03 +00004220 }else{
drh4b92f982015-09-29 17:20:14 +00004221 pIndex->aiColumn[i] = XN_ROWID;
drhf19aa5f2015-12-30 16:51:20 +00004222 pIndex->azColl[i] = sqlite3StrBINARY;
drh44156282013-10-23 22:23:03 +00004223 }
drh51147ba2005-07-23 22:59:55 +00004224 sqlite3DefaultRowEst(pIndex);
drhe13e9f52013-10-05 19:18:00 +00004225 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
drh75897232000-05-29 14:26:00 +00004226
danf769cd62016-02-24 20:16:28 +00004227 /* If this index contains every column of its table, then mark
4228 ** it as a covering index */
4229 assert( HasRowid(pTab)
drhb9bcf7c2019-10-19 13:29:10 +00004230 || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
drh1fe3ac72018-06-09 01:12:08 +00004231 recomputeColumnsNotIndexed(pIndex);
danf769cd62016-02-24 20:16:28 +00004232 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
4233 pIndex->isCovering = 1;
4234 for(j=0; j<pTab->nCol; j++){
4235 if( j==pTab->iPKey ) continue;
drhb9bcf7c2019-10-19 13:29:10 +00004236 if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue;
danf769cd62016-02-24 20:16:28 +00004237 pIndex->isCovering = 0;
4238 break;
4239 }
4240 }
4241
danielk1977d8123362004-06-12 09:25:12 +00004242 if( pTab==pParse->pNewTable ){
4243 /* This routine has been called to create an automatic index as a
4244 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
4245 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
4246 ** i.e. one of:
4247 **
4248 ** CREATE TABLE t(x PRIMARY KEY, y);
4249 ** CREATE TABLE t(x, y, UNIQUE(x, y));
4250 **
4251 ** Either way, check to see if the table already has such an index. If
4252 ** so, don't bother creating this one. This only applies to
4253 ** automatically created indices. Users can do as they wish with
4254 ** explicit indices.
drhd3001712009-05-12 17:46:53 +00004255 **
4256 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
4257 ** (and thus suppressing the second one) even if they have different
4258 ** sort orders.
4259 **
4260 ** If there are different collating sequences or if the columns of
4261 ** the constraint occur in different orders, then the constraints are
4262 ** considered distinct and both result in separate indices.
danielk1977d8123362004-06-12 09:25:12 +00004263 */
4264 Index *pIdx;
4265 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
4266 int k;
drh5f1d1d92014-07-31 22:59:04 +00004267 assert( IsUniqueIndex(pIdx) );
drh48dd1d82014-05-27 18:18:58 +00004268 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
drh5f1d1d92014-07-31 22:59:04 +00004269 assert( IsUniqueIndex(pIndex) );
danielk1977d8123362004-06-12 09:25:12 +00004270
drhbbbdc832013-10-22 18:01:40 +00004271 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
4272 for(k=0; k<pIdx->nKeyCol; k++){
drhd3001712009-05-12 17:46:53 +00004273 const char *z1;
4274 const char *z2;
drh1f9ca2c2015-08-25 16:57:52 +00004275 assert( pIdx->aiColumn[k]>=0 );
danielk1977d8123362004-06-12 09:25:12 +00004276 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
drhd3001712009-05-12 17:46:53 +00004277 z1 = pIdx->azColl[k];
4278 z2 = pIndex->azColl[k];
drhc41c1322016-02-11 13:30:36 +00004279 if( sqlite3StrICmp(z1, z2) ) break;
danielk1977d8123362004-06-12 09:25:12 +00004280 }
drhbbbdc832013-10-22 18:01:40 +00004281 if( k==pIdx->nKeyCol ){
danielk1977f736b772004-06-17 06:13:34 +00004282 if( pIdx->onError!=pIndex->onError ){
4283 /* This constraint creates the same index as a previous
4284 ** constraint specified somewhere in the CREATE TABLE statement.
4285 ** However the ON CONFLICT clauses are different. If both this
4286 ** constraint and the previous equivalent constraint have explicit
4287 ** ON CONFLICT clauses this is an error. Otherwise, use the
mistachkin48864df2013-03-21 21:20:32 +00004288 ** explicitly specified behavior for the index.
danielk1977f736b772004-06-17 06:13:34 +00004289 */
4290 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
4291 sqlite3ErrorMsg(pParse,
4292 "conflicting ON CONFLICT clauses specified", 0);
4293 }
4294 if( pIdx->onError==OE_Default ){
4295 pIdx->onError = pIndex->onError;
4296 }
4297 }
drh273bfe92016-06-02 16:22:53 +00004298 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
drh885eeb62019-01-09 02:02:24 +00004299 if( IN_RENAME_OBJECT ){
4300 pIndex->pNext = pParse->pNewIndex;
4301 pParse->pNewIndex = pIndex;
4302 pIndex = 0;
4303 }
danielk1977d8123362004-06-12 09:25:12 +00004304 goto exit_create_index;
4305 }
4306 }
4307 }
4308
danc9461ec2018-08-29 21:00:16 +00004309 if( !IN_RENAME_OBJECT ){
drhd78eeee2001-09-13 16:18:53 +00004310
dancf8f2892018-08-09 20:47:01 +00004311 /* Link the new Index structure to its table and to the other
4312 ** in-memory database structures.
drh063336a2004-11-05 20:58:39 +00004313 */
dancf8f2892018-08-09 20:47:01 +00004314 assert( pParse->nErr==0 );
4315 if( db->init.busy ){
4316 Index *p;
4317 assert( !IN_SPECIAL_PARSE );
4318 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
dancf8f2892018-08-09 20:47:01 +00004319 if( pTblName!=0 ){
4320 pIndex->tnum = db->init.newTnum;
drh8d406732019-01-30 18:33:33 +00004321 if( sqlite3IndexHasDuplicateRootPage(pIndex) ){
drh8bf41262019-01-30 19:50:07 +00004322 sqlite3ErrorMsg(pParse, "invalid rootpage");
drh8d406732019-01-30 18:33:33 +00004323 pParse->rc = SQLITE_CORRUPT_BKPT;
4324 goto exit_create_index;
4325 }
dancf8f2892018-08-09 20:47:01 +00004326 }
danda7a4c02019-01-30 19:12:13 +00004327 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
4328 pIndex->zName, pIndex);
4329 if( p ){
4330 assert( p==pIndex ); /* Malloc must have failed */
4331 sqlite3OomFault(db);
4332 goto exit_create_index;
4333 }
4334 db->mDbFlags |= DBFLAG_SchemaChange;
drh75897232000-05-29 14:26:00 +00004335 }
drh063336a2004-11-05 20:58:39 +00004336
dancf8f2892018-08-09 20:47:01 +00004337 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
4338 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
4339 ** emit code to allocate the index rootpage on disk and make an entry for
drh1e32bed2020-06-19 13:33:53 +00004340 ** the index in the sqlite_schema table and populate the index with
4341 ** content. But, do not do this if we are simply reading the sqlite_schema
dancf8f2892018-08-09 20:47:01 +00004342 ** table to parse the schema, or if this index is the PRIMARY KEY index
4343 ** of a WITHOUT ROWID table.
4344 **
4345 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
4346 ** or UNIQUE index in a CREATE TABLE statement. Since the table
4347 ** has just been created, it contains no data and the index initialization
4348 ** step can be skipped.
drh063336a2004-11-05 20:58:39 +00004349 */
dancf8f2892018-08-09 20:47:01 +00004350 else if( HasRowid(pTab) || pTblName!=0 ){
4351 Vdbe *v;
4352 char *zStmt;
4353 int iMem = ++pParse->nMem;
drh063336a2004-11-05 20:58:39 +00004354
dancf8f2892018-08-09 20:47:01 +00004355 v = sqlite3GetVdbe(pParse);
4356 if( v==0 ) goto exit_create_index;
4357
4358 sqlite3BeginWriteOperation(pParse, 1, iDb);
4359
4360 /* Create the rootpage for the index using CreateIndex. But before
4361 ** doing so, code a Noop instruction and store its address in
4362 ** Index.tnum. This is required in case this index is actually a
4363 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
4364 ** that case the convertToWithoutRowidTable() routine will replace
4365 ** the Noop with a Goto to jump over the VDBE code generated below. */
drhabc38152020-07-22 13:38:04 +00004366 pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
dancf8f2892018-08-09 20:47:01 +00004367 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
4368
4369 /* Gather the complete text of the CREATE INDEX statement into
4370 ** the zStmt variable
4371 */
drh55f66b32019-07-16 19:44:32 +00004372 assert( pName!=0 || pStart==0 );
dancf8f2892018-08-09 20:47:01 +00004373 if( pStart ){
4374 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
4375 if( pName->z[n-1]==';' ) n--;
4376 /* A named index with an explicit CREATE INDEX statement */
4377 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
4378 onError==OE_None ? "" : " UNIQUE", n, pName->z);
4379 }else{
4380 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
4381 /* zStmt = sqlite3MPrintf(""); */
4382 zStmt = 0;
4383 }
4384
drh1e32bed2020-06-19 13:33:53 +00004385 /* Add an entry in sqlite_schema for this index
dancf8f2892018-08-09 20:47:01 +00004386 */
4387 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +00004388 "INSERT INTO %Q." DFLT_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
4389 db->aDb[iDb].zDbSName,
dancf8f2892018-08-09 20:47:01 +00004390 pIndex->zName,
4391 pTab->zName,
4392 iMem,
4393 zStmt
4394 );
4395 sqlite3DbFree(db, zStmt);
4396
4397 /* Fill the index with data and reparse the schema. Code an OP_Expire
4398 ** to invalidate all pre-compiled statements.
4399 */
4400 if( pTblName ){
4401 sqlite3RefillIndex(pParse, pIndex, iMem);
4402 sqlite3ChangeCookie(pParse, iDb);
4403 sqlite3VdbeAddParseSchemaOp(v, iDb,
dan6a5a13d2021-02-17 20:08:22 +00004404 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
dancf8f2892018-08-09 20:47:01 +00004405 sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
4406 }
4407
drhabc38152020-07-22 13:38:04 +00004408 sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
drh5e00f6c2001-09-13 13:46:56 +00004409 }
drh75897232000-05-29 14:26:00 +00004410 }
drh234c39d2004-07-24 03:30:47 +00004411 if( db->init.busy || pTblName==0 ){
drhd35bdd62019-12-15 02:49:32 +00004412 pIndex->pNext = pTab->pIndex;
4413 pTab->pIndex = pIndex;
drh234c39d2004-07-24 03:30:47 +00004414 pIndex = 0;
danielk1977d8123362004-06-12 09:25:12 +00004415 }
danc9461ec2018-08-29 21:00:16 +00004416 else if( IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00004417 assert( pParse->pNewIndex==0 );
4418 pParse->pNewIndex = pIndex;
4419 pIndex = 0;
4420 }
danielk1977d8123362004-06-12 09:25:12 +00004421
drh75897232000-05-29 14:26:00 +00004422 /* Clean up before exiting */
4423exit_create_index:
dancf8f2892018-08-09 20:47:01 +00004424 if( pIndex ) sqlite3FreeIndex(db, pIndex);
drh97060e52021-03-21 17:52:47 +00004425 if( pTab ){
4426 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
4427 ** The list was already ordered when this routine was entered, so at this
4428 ** point at most a single index (the newly added index) will be out of
4429 ** order. So we have to reorder at most one index. */
drhe85e1da2021-10-01 21:01:07 +00004430 Index **ppFrom;
drhd35bdd62019-12-15 02:49:32 +00004431 Index *pThis;
4432 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
4433 Index *pNext;
4434 if( pThis->onError!=OE_Replace ) continue;
4435 while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
4436 *ppFrom = pNext;
4437 pThis->pNext = pNext->pNext;
4438 pNext->pNext = pThis;
4439 ppFrom = &pNext->pNext;
4440 }
4441 break;
4442 }
drh97060e52021-03-21 17:52:47 +00004443#ifdef SQLITE_DEBUG
4444 /* Verify that all REPLACE indexes really are now at the end
4445 ** of the index list. In other words, no other index type ever
4446 ** comes after a REPLACE index on the list. */
4447 for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
4448 assert( pThis->onError!=OE_Replace
4449 || pThis->pNext==0
4450 || pThis->pNext->onError==OE_Replace );
4451 }
4452#endif
drhd35bdd62019-12-15 02:49:32 +00004453 }
drh1fe05372013-07-31 18:12:26 +00004454 sqlite3ExprDelete(db, pPIWhere);
drh633e6d52008-07-28 19:34:53 +00004455 sqlite3ExprListDelete(db, pList);
4456 sqlite3SrcListDelete(db, pTblName);
4457 sqlite3DbFree(db, zName);
drh75897232000-05-29 14:26:00 +00004458}
4459
4460/*
drh51147ba2005-07-23 22:59:55 +00004461** Fill the Index.aiRowEst[] array with default information - information
drh91124b32005-08-18 18:15:05 +00004462** to be used when we have not run the ANALYZE command.
drh28c4cf42005-07-27 20:41:43 +00004463**
peter.d.reid60ec9142014-09-06 16:39:46 +00004464** aiRowEst[0] is supposed to contain the number of elements in the index.
drh28c4cf42005-07-27 20:41:43 +00004465** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
4466** number of rows in the table that match any particular value of the
4467** first column of the index. aiRowEst[2] is an estimate of the number
dancfc9df72014-04-25 15:01:01 +00004468** of rows that match any particular combination of the first 2 columns
drh28c4cf42005-07-27 20:41:43 +00004469** of the index. And so forth. It must always be the case that
4470*
4471** aiRowEst[N]<=aiRowEst[N-1]
4472** aiRowEst[N]>=1
4473**
4474** Apart from that, we have little to go on besides intuition as to
4475** how aiRowEst[] should be initialized. The numbers generated here
4476** are based on typical values found in actual indices.
drh51147ba2005-07-23 22:59:55 +00004477*/
4478void sqlite3DefaultRowEst(Index *pIdx){
drh56c65c92020-05-28 00:45:16 +00004479 /* 10, 9, 8, 7, 6 */
4480 static const LogEst aVal[] = { 33, 32, 30, 28, 26 };
dancfc9df72014-04-25 15:01:01 +00004481 LogEst *a = pIdx->aiRowLogEst;
drh56c65c92020-05-28 00:45:16 +00004482 LogEst x;
dancfc9df72014-04-25 15:01:01 +00004483 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
drh51147ba2005-07-23 22:59:55 +00004484 int i;
dancfc9df72014-04-25 15:01:01 +00004485
drh33bec3f2017-02-17 13:38:15 +00004486 /* Indexes with default row estimates should not have stat1 data */
4487 assert( !pIdx->hasStat1 );
4488
dan264d2b92014-04-29 19:01:57 +00004489 /* Set the first entry (number of rows in the index) to the estimated
drh8dc570b2016-06-08 18:07:21 +00004490 ** number of rows in the table, or half the number of rows in the table
drh56c65c92020-05-28 00:45:16 +00004491 ** for a partial index.
4492 **
4493 ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
4494 ** table but other parts we are having to guess at, then do not let the
4495 ** estimated number of rows in the table be less than 1000 (LogEst 99).
4496 ** Failure to do this can cause the indexes for which we do not have
drh8c1fbe82020-08-11 17:20:02 +00004497 ** stat1 data to be ignored by the query planner.
drh56c65c92020-05-28 00:45:16 +00004498 */
4499 x = pIdx->pTable->nRowLogEst;
4500 assert( 99==sqlite3LogEst(1000) );
4501 if( x<99 ){
4502 pIdx->pTable->nRowLogEst = x = 99;
4503 }
drh5f086dd2021-04-29 13:37:36 +00004504 if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); }
drh56c65c92020-05-28 00:45:16 +00004505 a[0] = x;
dan264d2b92014-04-29 19:01:57 +00004506
4507 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
4508 ** 6 and each subsequent value (if any) is 5. */
dancfc9df72014-04-25 15:01:01 +00004509 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
dan264d2b92014-04-29 19:01:57 +00004510 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
4511 a[i] = 23; assert( 23==sqlite3LogEst(5) );
drh28c4cf42005-07-27 20:41:43 +00004512 }
dan264d2b92014-04-29 19:01:57 +00004513
4514 assert( 0==sqlite3LogEst(1) );
drh5f1d1d92014-07-31 22:59:04 +00004515 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
drh51147ba2005-07-23 22:59:55 +00004516}
4517
4518/*
drh74e24cd2002-01-09 03:19:59 +00004519** This routine will drop an existing named index. This routine
4520** implements the DROP INDEX statement.
drh75897232000-05-29 14:26:00 +00004521*/
drh4d91a702006-01-04 15:54:36 +00004522void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
drh75897232000-05-29 14:26:00 +00004523 Index *pIndex;
drh75897232000-05-29 14:26:00 +00004524 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00004525 sqlite3 *db = pParse->db;
danielk1977da184232006-01-05 11:34:32 +00004526 int iDb;
drh75897232000-05-29 14:26:00 +00004527
drh8af73d42009-05-13 22:58:28 +00004528 assert( pParse->nErr==0 ); /* Never called with prior errors */
4529 if( db->mallocFailed ){
danielk1977d5d56522005-03-16 12:15:20 +00004530 goto exit_drop_index;
4531 }
drhd24cc422003-03-27 12:51:24 +00004532 assert( pName->nSrc==1 );
danielk1977d5d56522005-03-16 12:15:20 +00004533 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
4534 goto exit_drop_index;
4535 }
danielk19774adee202004-05-08 08:23:19 +00004536 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
drh75897232000-05-29 14:26:00 +00004537 if( pIndex==0 ){
drh4d91a702006-01-04 15:54:36 +00004538 if( !ifExists ){
drha9799932021-03-19 13:00:28 +00004539 sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
dan57966752011-04-09 17:32:58 +00004540 }else{
4541 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
drh31da7be2021-05-13 18:24:22 +00004542 sqlite3ForceNotReadOnly(pParse);
drh4d91a702006-01-04 15:54:36 +00004543 }
drha6ecd332004-06-10 00:29:09 +00004544 pParse->checkSchema = 1;
drhd24cc422003-03-27 12:51:24 +00004545 goto exit_drop_index;
drh75897232000-05-29 14:26:00 +00004546 }
drh48dd1d82014-05-27 18:18:58 +00004547 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
danielk19774adee202004-05-08 08:23:19 +00004548 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
drh485b39b2002-07-13 03:11:52 +00004549 "or PRIMARY KEY constraint cannot be dropped", 0);
drhd24cc422003-03-27 12:51:24 +00004550 goto exit_drop_index;
4551 }
danielk1977da184232006-01-05 11:34:32 +00004552 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drhe5f9c642003-01-13 23:27:31 +00004553#ifndef SQLITE_OMIT_AUTHORIZATION
4554 {
4555 int code = SQLITE_DROP_INDEX;
4556 Table *pTab = pIndex->pTable;
drh69c33822016-08-18 14:33:11 +00004557 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977da184232006-01-05 11:34:32 +00004558 const char *zTab = SCHEMA_TABLE(iDb);
danielk19774adee202004-05-08 08:23:19 +00004559 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
drhd24cc422003-03-27 12:51:24 +00004560 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00004561 }
drh93fd5422021-06-14 20:41:20 +00004562 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00004563 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
drhd24cc422003-03-27 12:51:24 +00004564 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00004565 }
drhed6c8672003-01-12 18:02:16 +00004566 }
drhe5f9c642003-01-13 23:27:31 +00004567#endif
drh75897232000-05-29 14:26:00 +00004568
drh067b92b2020-06-19 15:24:12 +00004569 /* Generate code to remove the index and from the schema table */
danielk19774adee202004-05-08 08:23:19 +00004570 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00004571 if( v ){
drh77658e22007-12-04 16:54:52 +00004572 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00004573 sqlite3NestedParse(pParse,
drh346a70c2020-06-15 20:27:35 +00004574 "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='index'",
4575 db->aDb[iDb].zDbSName, pIndex->zName
drhb17131a2004-11-05 22:18:49 +00004576 );
drha5ae4c32011-08-07 01:31:52 +00004577 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
drh9cbf3422008-01-17 16:22:13 +00004578 sqlite3ChangeCookie(pParse, iDb);
drhb17131a2004-11-05 22:18:49 +00004579 destroyRootPage(pParse, pIndex->tnum, iDb);
drh66a51672008-01-03 00:01:23 +00004580 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
drh75897232000-05-29 14:26:00 +00004581 }
4582
drhd24cc422003-03-27 12:51:24 +00004583exit_drop_index:
drh633e6d52008-07-28 19:34:53 +00004584 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00004585}
4586
4587/*
dan9ace1122012-03-29 07:51:45 +00004588** pArray is a pointer to an array of objects. Each object in the
4589** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
4590** to extend the array so that there is space for a new object at the end.
drh13449892005-09-07 21:22:45 +00004591**
dan9ace1122012-03-29 07:51:45 +00004592** When this function is called, *pnEntry contains the current size of
4593** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
4594** in total).
drh13449892005-09-07 21:22:45 +00004595**
dan9ace1122012-03-29 07:51:45 +00004596** If the realloc() is successful (i.e. if no OOM condition occurs), the
4597** space allocated for the new object is zeroed, *pnEntry updated to
4598** reflect the new size of the array and a pointer to the new allocation
4599** returned. *pIdx is set to the index of the new array entry in this case.
drh13449892005-09-07 21:22:45 +00004600**
dan9ace1122012-03-29 07:51:45 +00004601** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
4602** unchanged and a copy of pArray returned.
drh13449892005-09-07 21:22:45 +00004603*/
drhcf643722007-03-27 13:36:37 +00004604void *sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00004605 sqlite3 *db, /* Connection to notify of malloc failures */
drhcf643722007-03-27 13:36:37 +00004606 void *pArray, /* Array of objects. Might be reallocated */
4607 int szEntry, /* Size of each object in the array */
drhcf643722007-03-27 13:36:37 +00004608 int *pnEntry, /* Number of objects currently in use */
drhcf643722007-03-27 13:36:37 +00004609 int *pIdx /* Write the index of a new slot here */
4610){
4611 char *z;
drhf6ad2012019-04-13 14:07:57 +00004612 sqlite3_int64 n = *pIdx = *pnEntry;
drh6c535152012-02-02 03:38:30 +00004613 if( (n & (n-1))==0 ){
drh0aa32312019-04-13 04:01:12 +00004614 sqlite3_int64 sz = (n==0) ? 1 : 2*n;
drh6c535152012-02-02 03:38:30 +00004615 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
drh13449892005-09-07 21:22:45 +00004616 if( pNew==0 ){
drhcf643722007-03-27 13:36:37 +00004617 *pIdx = -1;
4618 return pArray;
drh13449892005-09-07 21:22:45 +00004619 }
drhcf643722007-03-27 13:36:37 +00004620 pArray = pNew;
drh13449892005-09-07 21:22:45 +00004621 }
drhcf643722007-03-27 13:36:37 +00004622 z = (char*)pArray;
drh6c535152012-02-02 03:38:30 +00004623 memset(&z[n * szEntry], 0, szEntry);
drhcf643722007-03-27 13:36:37 +00004624 ++*pnEntry;
4625 return pArray;
drh13449892005-09-07 21:22:45 +00004626}
4627
4628/*
drh75897232000-05-29 14:26:00 +00004629** Append a new element to the given IdList. Create a new IdList if
4630** need be.
drhdaffd0e2001-04-11 14:28:42 +00004631**
4632** A new IdList is returned, or NULL if malloc() fails.
drh75897232000-05-29 14:26:00 +00004633*/
dan5496d6a2018-08-13 17:14:26 +00004634IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
4635 sqlite3 *db = pParse->db;
drh13449892005-09-07 21:22:45 +00004636 int i;
drh75897232000-05-29 14:26:00 +00004637 if( pList==0 ){
drh17435752007-08-16 04:30:38 +00004638 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
drh75897232000-05-29 14:26:00 +00004639 if( pList==0 ) return 0;
4640 }
drhcf643722007-03-27 13:36:37 +00004641 pList->a = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00004642 db,
drhcf643722007-03-27 13:36:37 +00004643 pList->a,
4644 sizeof(pList->a[0]),
drhcf643722007-03-27 13:36:37 +00004645 &pList->nId,
drhcf643722007-03-27 13:36:37 +00004646 &i
4647 );
drh13449892005-09-07 21:22:45 +00004648 if( i<0 ){
drh633e6d52008-07-28 19:34:53 +00004649 sqlite3IdListDelete(db, pList);
drh13449892005-09-07 21:22:45 +00004650 return 0;
drh75897232000-05-29 14:26:00 +00004651 }
drh17435752007-08-16 04:30:38 +00004652 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
danc9461ec2018-08-29 21:00:16 +00004653 if( IN_RENAME_OBJECT && pList->a[i].zName ){
dan07e95232018-08-21 16:32:53 +00004654 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
dan5496d6a2018-08-13 17:14:26 +00004655 }
drh75897232000-05-29 14:26:00 +00004656 return pList;
4657}
4658
4659/*
drhfe05af82005-07-21 03:14:59 +00004660** Delete an IdList.
4661*/
drh633e6d52008-07-28 19:34:53 +00004662void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
drhfe05af82005-07-21 03:14:59 +00004663 int i;
4664 if( pList==0 ) return;
4665 for(i=0; i<pList->nId; i++){
drh633e6d52008-07-28 19:34:53 +00004666 sqlite3DbFree(db, pList->a[i].zName);
drhfe05af82005-07-21 03:14:59 +00004667 }
drh633e6d52008-07-28 19:34:53 +00004668 sqlite3DbFree(db, pList->a);
drhdbd6a7d2017-04-05 12:39:49 +00004669 sqlite3DbFreeNN(db, pList);
drhfe05af82005-07-21 03:14:59 +00004670}
4671
4672/*
4673** Return the index in pList of the identifier named zId. Return -1
4674** if not found.
4675*/
4676int sqlite3IdListIndex(IdList *pList, const char *zName){
4677 int i;
4678 if( pList==0 ) return -1;
4679 for(i=0; i<pList->nId; i++){
4680 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
4681 }
4682 return -1;
4683}
4684
4685/*
drh0ad7aa82019-01-17 14:34:46 +00004686** Maximum size of a SrcList object.
4687** The SrcList object is used to represent the FROM clause of a
4688** SELECT statement, and the query planner cannot deal with more
4689** than 64 tables in a join. So any value larger than 64 here
4690** is sufficient for most uses. Smaller values, like say 10, are
4691** appropriate for small and memory-limited applications.
4692*/
4693#ifndef SQLITE_MAX_SRCLIST
4694# define SQLITE_MAX_SRCLIST 200
4695#endif
4696
4697/*
drha78c22c2008-11-11 18:28:58 +00004698** Expand the space allocated for the given SrcList object by
4699** creating nExtra new slots beginning at iStart. iStart is zero based.
4700** New slots are zeroed.
4701**
4702** For example, suppose a SrcList initially contains two entries: A,B.
4703** To append 3 new entries onto the end, do this:
4704**
4705** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
4706**
4707** After the call above it would contain: A, B, nil, nil, nil.
4708** If the iStart argument had been 1 instead of 2, then the result
4709** would have been: A, nil, nil, nil, B. To prepend the new slots,
4710** the iStart value would be 0. The result then would
4711** be: nil, nil, nil, A, B.
4712**
drh29c992c2019-01-17 15:40:41 +00004713** If a memory allocation fails or the SrcList becomes too large, leave
4714** the original SrcList unchanged, return NULL, and leave an error message
4715** in pParse.
drha78c22c2008-11-11 18:28:58 +00004716*/
4717SrcList *sqlite3SrcListEnlarge(
drh29c992c2019-01-17 15:40:41 +00004718 Parse *pParse, /* Parsing context into which errors are reported */
drha78c22c2008-11-11 18:28:58 +00004719 SrcList *pSrc, /* The SrcList to be enlarged */
4720 int nExtra, /* Number of new slots to add to pSrc->a[] */
4721 int iStart /* Index in pSrc->a[] of first new slot */
4722){
4723 int i;
4724
4725 /* Sanity checking on calling parameters */
4726 assert( iStart>=0 );
4727 assert( nExtra>=1 );
drh8af73d42009-05-13 22:58:28 +00004728 assert( pSrc!=0 );
4729 assert( iStart<=pSrc->nSrc );
drha78c22c2008-11-11 18:28:58 +00004730
4731 /* Allocate additional space if needed */
drhfc5717c2014-03-05 19:04:46 +00004732 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
drha78c22c2008-11-11 18:28:58 +00004733 SrcList *pNew;
drh0aa32312019-04-13 04:01:12 +00004734 sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
drh29c992c2019-01-17 15:40:41 +00004735 sqlite3 *db = pParse->db;
drh0ad7aa82019-01-17 14:34:46 +00004736
4737 if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
drh29c992c2019-01-17 15:40:41 +00004738 sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
4739 SQLITE_MAX_SRCLIST);
4740 return 0;
drh0ad7aa82019-01-17 14:34:46 +00004741 }
4742 if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST;
drha78c22c2008-11-11 18:28:58 +00004743 pNew = sqlite3DbRealloc(db, pSrc,
4744 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
4745 if( pNew==0 ){
4746 assert( db->mallocFailed );
drh29c992c2019-01-17 15:40:41 +00004747 return 0;
drha78c22c2008-11-11 18:28:58 +00004748 }
4749 pSrc = pNew;
drhd0ee3a12019-02-06 01:18:36 +00004750 pSrc->nAlloc = nAlloc;
drha78c22c2008-11-11 18:28:58 +00004751 }
4752
4753 /* Move existing slots that come after the newly inserted slots
4754 ** out of the way */
4755 for(i=pSrc->nSrc-1; i>=iStart; i--){
4756 pSrc->a[i+nExtra] = pSrc->a[i];
4757 }
drh6d1626e2014-03-05 15:52:43 +00004758 pSrc->nSrc += nExtra;
drha78c22c2008-11-11 18:28:58 +00004759
4760 /* Zero the newly allocated slots */
4761 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
4762 for(i=iStart; i<iStart+nExtra; i++){
4763 pSrc->a[i].iCursor = -1;
4764 }
4765
4766 /* Return a pointer to the enlarged SrcList */
4767 return pSrc;
4768}
4769
4770
4771/*
drhad3cab52002-05-24 02:04:32 +00004772** Append a new table name to the given SrcList. Create a new SrcList if
drhb7916a72009-05-27 10:31:29 +00004773** need be. A new entry is created in the SrcList even if pTable is NULL.
drhad3cab52002-05-24 02:04:32 +00004774**
drh29c992c2019-01-17 15:40:41 +00004775** A SrcList is returned, or NULL if there is an OOM error or if the
4776** SrcList grows to large. The returned
drha78c22c2008-11-11 18:28:58 +00004777** SrcList might be the same as the SrcList that was input or it might be
4778** a new one. If an OOM error does occurs, then the prior value of pList
4779** that is input to this routine is automatically freed.
drh113088e2003-03-20 01:16:58 +00004780**
4781** If pDatabase is not null, it means that the table has an optional
4782** database name prefix. Like this: "database.table". The pDatabase
4783** points to the table name and the pTable points to the database name.
4784** The SrcList.a[].zName field is filled with the table name which might
4785** come from pTable (if pDatabase is NULL) or from pDatabase.
4786** SrcList.a[].zDatabase is filled with the database name from pTable,
4787** or with NULL if no database is specified.
4788**
4789** In other words, if call like this:
4790**
drh17435752007-08-16 04:30:38 +00004791** sqlite3SrcListAppend(D,A,B,0);
drh113088e2003-03-20 01:16:58 +00004792**
4793** Then B is a table name and the database name is unspecified. If called
4794** like this:
4795**
drh17435752007-08-16 04:30:38 +00004796** sqlite3SrcListAppend(D,A,B,C);
drh113088e2003-03-20 01:16:58 +00004797**
drhd3001712009-05-12 17:46:53 +00004798** Then C is the table name and B is the database name. If C is defined
4799** then so is B. In other words, we never have a case where:
4800**
4801** sqlite3SrcListAppend(D,A,0,C);
drhb7916a72009-05-27 10:31:29 +00004802**
4803** Both pTable and pDatabase are assumed to be quoted. They are dequoted
4804** before being added to the SrcList.
drhad3cab52002-05-24 02:04:32 +00004805*/
drh17435752007-08-16 04:30:38 +00004806SrcList *sqlite3SrcListAppend(
drh29c992c2019-01-17 15:40:41 +00004807 Parse *pParse, /* Parsing context, in which errors are reported */
drh17435752007-08-16 04:30:38 +00004808 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
4809 Token *pTable, /* Table to append */
4810 Token *pDatabase /* Database of the table */
4811){
drh76012942021-02-21 21:04:54 +00004812 SrcItem *pItem;
drh29c992c2019-01-17 15:40:41 +00004813 sqlite3 *db;
drhd3001712009-05-12 17:46:53 +00004814 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
drh29c992c2019-01-17 15:40:41 +00004815 assert( pParse!=0 );
4816 assert( pParse->db!=0 );
4817 db = pParse->db;
drhad3cab52002-05-24 02:04:32 +00004818 if( pList==0 ){
drh29c992c2019-01-17 15:40:41 +00004819 pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
drhad3cab52002-05-24 02:04:32 +00004820 if( pList==0 ) return 0;
drh4305d102003-07-30 12:34:12 +00004821 pList->nAlloc = 1;
drhac178b32016-12-14 11:14:13 +00004822 pList->nSrc = 1;
4823 memset(&pList->a[0], 0, sizeof(pList->a[0]));
4824 pList->a[0].iCursor = -1;
4825 }else{
drh29c992c2019-01-17 15:40:41 +00004826 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
4827 if( pNew==0 ){
4828 sqlite3SrcListDelete(db, pList);
4829 return 0;
4830 }else{
4831 pList = pNew;
4832 }
drhad3cab52002-05-24 02:04:32 +00004833 }
drha78c22c2008-11-11 18:28:58 +00004834 pItem = &pList->a[pList->nSrc-1];
drh113088e2003-03-20 01:16:58 +00004835 if( pDatabase && pDatabase->z==0 ){
4836 pDatabase = 0;
4837 }
drhd3001712009-05-12 17:46:53 +00004838 if( pDatabase ){
drh169a6892017-07-06 01:02:09 +00004839 pItem->zName = sqlite3NameFromToken(db, pDatabase);
4840 pItem->zDatabase = sqlite3NameFromToken(db, pTable);
4841 }else{
4842 pItem->zName = sqlite3NameFromToken(db, pTable);
4843 pItem->zDatabase = 0;
drh113088e2003-03-20 01:16:58 +00004844 }
drhad3cab52002-05-24 02:04:32 +00004845 return pList;
4846}
4847
4848/*
drhdfe88ec2008-11-03 20:55:06 +00004849** Assign VdbeCursor index numbers to all tables in a SrcList
drh63eb5f22003-04-29 16:20:44 +00004850*/
danielk19774adee202004-05-08 08:23:19 +00004851void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
drh63eb5f22003-04-29 16:20:44 +00004852 int i;
drh76012942021-02-21 21:04:54 +00004853 SrcItem *pItem;
drh9da977f2021-04-20 12:14:12 +00004854 assert( pList || pParse->db->mallocFailed );
4855 if( ALWAYS(pList) ){
danielk1977261919c2005-12-06 12:52:59 +00004856 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
drh34055852020-10-19 01:23:48 +00004857 if( pItem->iCursor>=0 ) continue;
danielk1977261919c2005-12-06 12:52:59 +00004858 pItem->iCursor = pParse->nTab++;
4859 if( pItem->pSelect ){
4860 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
4861 }
drh63eb5f22003-04-29 16:20:44 +00004862 }
4863 }
4864}
4865
4866/*
drhad3cab52002-05-24 02:04:32 +00004867** Delete an entire SrcList including all its substructure.
4868*/
drh633e6d52008-07-28 19:34:53 +00004869void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
drhad3cab52002-05-24 02:04:32 +00004870 int i;
drh76012942021-02-21 21:04:54 +00004871 SrcItem *pItem;
drhad3cab52002-05-24 02:04:32 +00004872 if( pList==0 ) return;
drhbe5c89a2004-07-26 00:31:09 +00004873 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
drh45d827c2020-08-15 23:48:22 +00004874 if( pItem->zDatabase ) sqlite3DbFreeNN(db, pItem->zDatabase);
drh633e6d52008-07-28 19:34:53 +00004875 sqlite3DbFree(db, pItem->zName);
drh45d827c2020-08-15 23:48:22 +00004876 if( pItem->zAlias ) sqlite3DbFreeNN(db, pItem->zAlias);
drh8a48b9c2015-08-19 15:20:00 +00004877 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
4878 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
dan1feeaed2010-07-23 15:41:47 +00004879 sqlite3DeleteTable(db, pItem->pTab);
drh45d827c2020-08-15 23:48:22 +00004880 if( pItem->pSelect ) sqlite3SelectDelete(db, pItem->pSelect);
4881 if( pItem->pOn ) sqlite3ExprDelete(db, pItem->pOn);
4882 if( pItem->pUsing ) sqlite3IdListDelete(db, pItem->pUsing);
drh75897232000-05-29 14:26:00 +00004883 }
drhdbd6a7d2017-04-05 12:39:49 +00004884 sqlite3DbFreeNN(db, pList);
drh75897232000-05-29 14:26:00 +00004885}
4886
drh982cef72000-05-30 16:27:03 +00004887/*
drh61dfc312006-12-16 16:25:15 +00004888** This routine is called by the parser to add a new term to the
4889** end of a growing FROM clause. The "p" parameter is the part of
4890** the FROM clause that has already been constructed. "p" is NULL
4891** if this is the first term of the FROM clause. pTable and pDatabase
4892** are the name of the table and database named in the FROM clause term.
4893** pDatabase is NULL if the database name qualifier is missing - the
peter.d.reid60ec9142014-09-06 16:39:46 +00004894** usual case. If the term has an alias, then pAlias points to the
drh61dfc312006-12-16 16:25:15 +00004895** alias token. If the term is a subquery, then pSubquery is the
4896** SELECT statement that the subquery encodes. The pTable and
4897** pDatabase parameters are NULL for subqueries. The pOn and pUsing
4898** parameters are the content of the ON and USING clauses.
4899**
4900** Return a new SrcList which encodes is the FROM with the new
4901** term added.
4902*/
4903SrcList *sqlite3SrcListAppendFromTerm(
drh17435752007-08-16 04:30:38 +00004904 Parse *pParse, /* Parsing context */
drh61dfc312006-12-16 16:25:15 +00004905 SrcList *p, /* The left part of the FROM clause already seen */
4906 Token *pTable, /* Name of the table to add to the FROM clause */
4907 Token *pDatabase, /* Name of the database containing pTable */
4908 Token *pAlias, /* The right-hand side of the AS subexpression */
4909 Select *pSubquery, /* A subquery used in place of a table name */
4910 Expr *pOn, /* The ON clause of a join */
4911 IdList *pUsing /* The USING clause of a join */
4912){
drh76012942021-02-21 21:04:54 +00004913 SrcItem *pItem;
drh17435752007-08-16 04:30:38 +00004914 sqlite3 *db = pParse->db;
danielk1977bd1a0a42009-07-01 16:12:07 +00004915 if( !p && (pOn || pUsing) ){
4916 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
4917 (pOn ? "ON" : "USING")
4918 );
4919 goto append_from_error;
4920 }
drh29c992c2019-01-17 15:40:41 +00004921 p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
drh9d9c41e2017-10-31 03:40:15 +00004922 if( p==0 ){
danielk1977bd1a0a42009-07-01 16:12:07 +00004923 goto append_from_error;
drh61dfc312006-12-16 16:25:15 +00004924 }
drh9d9c41e2017-10-31 03:40:15 +00004925 assert( p->nSrc>0 );
drh61dfc312006-12-16 16:25:15 +00004926 pItem = &p->a[p->nSrc-1];
drha488ec92018-09-07 18:52:25 +00004927 assert( (pTable==0)==(pDatabase==0) );
4928 assert( pItem->zName==0 || pDatabase!=0 );
danc9461ec2018-08-29 21:00:16 +00004929 if( IN_RENAME_OBJECT && pItem->zName ){
drha488ec92018-09-07 18:52:25 +00004930 Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
danc9461ec2018-08-29 21:00:16 +00004931 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
4932 }
drh8af73d42009-05-13 22:58:28 +00004933 assert( pAlias!=0 );
4934 if( pAlias->n ){
drh17435752007-08-16 04:30:38 +00004935 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
drh61dfc312006-12-16 16:25:15 +00004936 }
4937 pItem->pSelect = pSubquery;
danielk1977bd1a0a42009-07-01 16:12:07 +00004938 pItem->pOn = pOn;
4939 pItem->pUsing = pUsing;
drh61dfc312006-12-16 16:25:15 +00004940 return p;
danielk1977bd1a0a42009-07-01 16:12:07 +00004941
4942 append_from_error:
4943 assert( p==0 );
4944 sqlite3ExprDelete(db, pOn);
4945 sqlite3IdListDelete(db, pUsing);
4946 sqlite3SelectDelete(db, pSubquery);
4947 return 0;
drh61dfc312006-12-16 16:25:15 +00004948}
4949
4950/*
danielk1977b1c685b2008-10-06 16:18:39 +00004951** Add an INDEXED BY or NOT INDEXED clause to the most recently added
4952** element of the source-list passed as the second argument.
4953*/
4954void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
drh8af73d42009-05-13 22:58:28 +00004955 assert( pIndexedBy!=0 );
drh8abc80b2017-08-12 01:09:06 +00004956 if( p && pIndexedBy->n>0 ){
drh76012942021-02-21 21:04:54 +00004957 SrcItem *pItem;
drh8abc80b2017-08-12 01:09:06 +00004958 assert( p->nSrc>0 );
4959 pItem = &p->a[p->nSrc-1];
drh8a48b9c2015-08-19 15:20:00 +00004960 assert( pItem->fg.notIndexed==0 );
4961 assert( pItem->fg.isIndexedBy==0 );
4962 assert( pItem->fg.isTabFunc==0 );
danielk1977b1c685b2008-10-06 16:18:39 +00004963 if( pIndexedBy->n==1 && !pIndexedBy->z ){
4964 /* A "NOT INDEXED" clause was supplied. See parse.y
4965 ** construct "indexed_opt" for details. */
drh8a48b9c2015-08-19 15:20:00 +00004966 pItem->fg.notIndexed = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00004967 }else{
drh8a48b9c2015-08-19 15:20:00 +00004968 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
drh8abc80b2017-08-12 01:09:06 +00004969 pItem->fg.isIndexedBy = 1;
drhdbfbb5a2021-10-07 23:04:50 +00004970 assert( pItem->fg.isCte==0 ); /* No collision on union u2 */
danielk1977b1c685b2008-10-06 16:18:39 +00004971 }
4972 }
4973}
4974
4975/*
dan69887c92020-04-27 20:55:33 +00004976** Append the contents of SrcList p2 to SrcList p1 and return the resulting
4977** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
4978** are deleted by this function.
4979*/
4980SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){
dan8b023cf2020-04-30 18:28:40 +00004981 assert( p1 && p1->nSrc==1 );
4982 if( p2 ){
4983 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
4984 if( pNew==0 ){
4985 sqlite3SrcListDelete(pParse->db, p2);
4986 }else{
4987 p1 = pNew;
drh76012942021-02-21 21:04:54 +00004988 memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
drh525326e2020-07-15 21:53:53 +00004989 sqlite3DbFree(pParse->db, p2);
dan69887c92020-04-27 20:55:33 +00004990 }
4991 }
4992 return p1;
4993}
4994
4995/*
drh01d230c2015-08-19 17:11:37 +00004996** Add the list of function arguments to the SrcList entry for a
4997** table-valued-function.
4998*/
4999void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
drh20292312015-11-21 13:24:46 +00005000 if( p ){
drh76012942021-02-21 21:04:54 +00005001 SrcItem *pItem = &p->a[p->nSrc-1];
drh01d230c2015-08-19 17:11:37 +00005002 assert( pItem->fg.notIndexed==0 );
5003 assert( pItem->fg.isIndexedBy==0 );
5004 assert( pItem->fg.isTabFunc==0 );
5005 pItem->u1.pFuncArg = pList;
5006 pItem->fg.isTabFunc = 1;
drhd8b1bfc2015-08-20 23:21:34 +00005007 }else{
5008 sqlite3ExprListDelete(pParse->db, pList);
drh01d230c2015-08-19 17:11:37 +00005009 }
5010}
5011
5012/*
drh61dfc312006-12-16 16:25:15 +00005013** When building up a FROM clause in the parser, the join operator
5014** is initially attached to the left operand. But the code generator
5015** expects the join operator to be on the right operand. This routine
5016** Shifts all join operators from left to right for an entire FROM
5017** clause.
5018**
5019** Example: Suppose the join is like this:
5020**
5021** A natural cross join B
5022**
5023** The operator is "natural cross join". The A and B operands are stored
5024** in p->a[0] and p->a[1], respectively. The parser initially stores the
5025** operator with A. This routine shifts that operator over to B.
5026*/
5027void sqlite3SrcListShiftJoinType(SrcList *p){
drhd017ab92011-08-23 00:01:58 +00005028 if( p ){
drh61dfc312006-12-16 16:25:15 +00005029 int i;
5030 for(i=p->nSrc-1; i>0; i--){
drh8a48b9c2015-08-19 15:20:00 +00005031 p->a[i].fg.jointype = p->a[i-1].fg.jointype;
drh61dfc312006-12-16 16:25:15 +00005032 }
drh8a48b9c2015-08-19 15:20:00 +00005033 p->a[0].fg.jointype = 0;
drh61dfc312006-12-16 16:25:15 +00005034 }
5035}
5036
5037/*
drhb0c88652016-02-01 13:21:13 +00005038** Generate VDBE code for a BEGIN statement.
drhc4a3c772001-04-04 11:48:57 +00005039*/
drh684917c2004-10-05 02:41:42 +00005040void sqlite3BeginTransaction(Parse *pParse, int type){
drh9bb575f2004-09-06 17:24:11 +00005041 sqlite3 *db;
danielk19771d850a72004-05-31 08:26:49 +00005042 Vdbe *v;
drh684917c2004-10-05 02:41:42 +00005043 int i;
drh5e00f6c2001-09-13 13:46:56 +00005044
drhd3001712009-05-12 17:46:53 +00005045 assert( pParse!=0 );
5046 db = pParse->db;
5047 assert( db!=0 );
drhd3001712009-05-12 17:46:53 +00005048 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
5049 return;
5050 }
danielk19771d850a72004-05-31 08:26:49 +00005051 v = sqlite3GetVdbe(pParse);
5052 if( !v ) return;
drh684917c2004-10-05 02:41:42 +00005053 if( type!=TK_DEFERRED ){
5054 for(i=0; i<db->nDb; i++){
drh1ca037f2020-10-12 13:24:00 +00005055 int eTxnType;
5056 Btree *pBt = db->aDb[i].pBt;
5057 if( pBt && sqlite3BtreeIsReadonly(pBt) ){
5058 eTxnType = 0; /* Read txn */
5059 }else if( type==TK_EXCLUSIVE ){
5060 eTxnType = 2; /* Exclusive txn */
5061 }else{
5062 eTxnType = 1; /* Write txn */
5063 }
5064 sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType);
drhfb982642007-08-30 01:19:59 +00005065 sqlite3VdbeUsesBtree(v, i);
drh684917c2004-10-05 02:41:42 +00005066 }
5067 }
drhb0c88652016-02-01 13:21:13 +00005068 sqlite3VdbeAddOp0(v, OP_AutoCommit);
drhc4a3c772001-04-04 11:48:57 +00005069}
5070
5071/*
drh07a3b112017-07-06 01:28:02 +00005072** Generate VDBE code for a COMMIT or ROLLBACK statement.
5073** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
5074** code is generated for a COMMIT.
drhc4a3c772001-04-04 11:48:57 +00005075*/
drh07a3b112017-07-06 01:28:02 +00005076void sqlite3EndTransaction(Parse *pParse, int eType){
danielk19771d850a72004-05-31 08:26:49 +00005077 Vdbe *v;
drh07a3b112017-07-06 01:28:02 +00005078 int isRollback;
drh5e00f6c2001-09-13 13:46:56 +00005079
drhd3001712009-05-12 17:46:53 +00005080 assert( pParse!=0 );
drhb07028f2011-10-14 21:49:18 +00005081 assert( pParse->db!=0 );
drh07a3b112017-07-06 01:28:02 +00005082 assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
5083 isRollback = eType==TK_ROLLBACK;
5084 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
5085 isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
drhd3001712009-05-12 17:46:53 +00005086 return;
5087 }
danielk19771d850a72004-05-31 08:26:49 +00005088 v = sqlite3GetVdbe(pParse);
5089 if( v ){
drh07a3b112017-07-06 01:28:02 +00005090 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
drh02f75f12004-02-24 01:04:11 +00005091 }
drhc4a3c772001-04-04 11:48:57 +00005092}
drhf57b14a2001-09-14 18:54:08 +00005093
5094/*
danielk1977fd7f0452008-12-17 17:30:26 +00005095** This function is called by the parser when it parses a command to create,
5096** release or rollback an SQL savepoint.
5097*/
5098void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
danielk1977ab9b7032008-12-30 06:24:58 +00005099 char *zName = sqlite3NameFromToken(pParse->db, pName);
5100 if( zName ){
5101 Vdbe *v = sqlite3GetVdbe(pParse);
5102#ifndef SQLITE_OMIT_AUTHORIZATION
dan558814f2010-06-02 05:53:53 +00005103 static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
danielk1977ab9b7032008-12-30 06:24:58 +00005104 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
5105#endif
5106 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
5107 sqlite3DbFree(pParse->db, zName);
5108 return;
5109 }
5110 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
danielk1977fd7f0452008-12-17 17:30:26 +00005111 }
5112}
5113
5114/*
drhdc3ff9c2004-08-18 02:10:15 +00005115** Make sure the TEMP database is open and available for use. Return
5116** the number of errors. Leave any error messages in the pParse structure.
5117*/
danielk1977ddfb2f02006-02-17 12:25:14 +00005118int sqlite3OpenTempDatabase(Parse *pParse){
drhdc3ff9c2004-08-18 02:10:15 +00005119 sqlite3 *db = pParse->db;
5120 if( db->aDb[1].pBt==0 && !pParse->explain ){
drh33f4e022007-09-03 15:19:34 +00005121 int rc;
drh10a76c92010-01-26 01:25:26 +00005122 Btree *pBt;
drh33f4e022007-09-03 15:19:34 +00005123 static const int flags =
5124 SQLITE_OPEN_READWRITE |
5125 SQLITE_OPEN_CREATE |
5126 SQLITE_OPEN_EXCLUSIVE |
5127 SQLITE_OPEN_DELETEONCLOSE |
5128 SQLITE_OPEN_TEMP_DB;
5129
dan3a6d8ae2011-04-23 15:54:54 +00005130 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
drhdc3ff9c2004-08-18 02:10:15 +00005131 if( rc!=SQLITE_OK ){
5132 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
5133 "file for storing temporary tables");
5134 pParse->rc = rc;
5135 return 1;
5136 }
drh10a76c92010-01-26 01:25:26 +00005137 db->aDb[1].pBt = pBt;
danielk197714db2662006-01-09 16:12:04 +00005138 assert( db->aDb[1].pSchema );
drhe937df82020-05-07 01:56:57 +00005139 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){
drh4a642b62016-02-05 01:55:27 +00005140 sqlite3OomFault(db);
drh7c9c9862010-01-31 14:18:21 +00005141 return 1;
drh10a76c92010-01-26 01:25:26 +00005142 }
drhdc3ff9c2004-08-18 02:10:15 +00005143 }
5144 return 0;
5145}
5146
5147/*
drhaceb31b2014-02-08 01:40:27 +00005148** Record the fact that the schema cookie will need to be verified
5149** for database iDb. The code to actually verify the schema cookie
5150** will occur at the end of the top-level VDBE and will be generated
5151** later, by sqlite3FinishCoding().
drh001bbcb2003-03-19 03:14:00 +00005152*/
drh1d8f8922020-08-16 00:30:44 +00005153static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
5154 assert( iDb>=0 && iDb<pToplevel->db->nDb );
5155 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
drh099b3852021-03-10 16:35:37 +00005156 assert( iDb<SQLITE_MAX_DB );
drh1d8f8922020-08-16 00:30:44 +00005157 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
drha7ab6d82014-07-21 15:44:39 +00005158 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
5159 DbMaskSet(pToplevel->cookieMask, iDb);
drhaceb31b2014-02-08 01:40:27 +00005160 if( !OMIT_TEMPDB && iDb==1 ){
5161 sqlite3OpenTempDatabase(pToplevel);
5162 }
drh001bbcb2003-03-19 03:14:00 +00005163 }
drh001bbcb2003-03-19 03:14:00 +00005164}
drh1d8f8922020-08-16 00:30:44 +00005165void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
5166 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
5167}
5168
drh001bbcb2003-03-19 03:14:00 +00005169
5170/*
dan57966752011-04-09 17:32:58 +00005171** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
5172** attached database. Otherwise, invoke it for the database named zDb only.
5173*/
5174void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
5175 sqlite3 *db = pParse->db;
5176 int i;
5177 for(i=0; i<db->nDb; i++){
5178 Db *pDb = &db->aDb[i];
drh69c33822016-08-18 14:33:11 +00005179 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
dan57966752011-04-09 17:32:58 +00005180 sqlite3CodeVerifySchema(pParse, i);
5181 }
5182 }
5183}
5184
5185/*
drh1c928532002-01-31 15:54:21 +00005186** Generate VDBE code that prepares for doing an operation that
drhc977f7f2002-05-21 11:38:11 +00005187** might change the database.
5188**
5189** This routine starts a new transaction if we are not already within
5190** a transaction. If we are already within a transaction, then a checkpoint
drh7f0f12e2004-05-21 13:39:50 +00005191** is set if the setStatement parameter is true. A checkpoint should
drhc977f7f2002-05-21 11:38:11 +00005192** be set for operations that might fail (due to a constraint) part of
5193** the way through and which will need to undo some writes without having to
5194** rollback the whole transaction. For operations where all constraints
5195** can be checked before any changes are made to the database, it is never
5196** necessary to undo a write and the checkpoint should not be set.
drh1c928532002-01-31 15:54:21 +00005197*/
drh7f0f12e2004-05-21 13:39:50 +00005198void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
dan65a7cd12009-09-01 12:16:01 +00005199 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh1d8f8922020-08-16 00:30:44 +00005200 sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
drha7ab6d82014-07-21 15:44:39 +00005201 DbMaskSet(pToplevel->writeMask, iDb);
dane0af83a2009-09-08 19:15:01 +00005202 pToplevel->isMultiWrite |= setStatement;
5203}
5204
drhff738bc2009-09-24 00:09:58 +00005205/*
5206** Indicate that the statement currently under construction might write
5207** more than one entry (example: deleting one row then inserting another,
5208** inserting multiple rows in a table, or inserting a row and index entries.)
5209** If an abort occurs after some of these writes have completed, then it will
5210** be necessary to undo the completed writes.
5211*/
5212void sqlite3MultiWrite(Parse *pParse){
5213 Parse *pToplevel = sqlite3ParseToplevel(pParse);
5214 pToplevel->isMultiWrite = 1;
5215}
5216
dane0af83a2009-09-08 19:15:01 +00005217/*
drhff738bc2009-09-24 00:09:58 +00005218** The code generator calls this routine if is discovers that it is
5219** possible to abort a statement prior to completion. In order to
5220** perform this abort without corrupting the database, we need to make
5221** sure that the statement is protected by a statement transaction.
5222**
5223** Technically, we only need to set the mayAbort flag if the
5224** isMultiWrite flag was previously set. There is a time dependency
5225** such that the abort must occur after the multiwrite. This makes
5226** some statements involving the REPLACE conflict resolution algorithm
5227** go a little faster. But taking advantage of this time dependency
5228** makes it more difficult to prove that the code is correct (in
5229** particular, it prevents us from writing an effective
5230** implementation of sqlite3AssertMayAbort()) and so we have chosen
5231** to take the safe route and skip the optimization.
dane0af83a2009-09-08 19:15:01 +00005232*/
5233void sqlite3MayAbort(Parse *pParse){
5234 Parse *pToplevel = sqlite3ParseToplevel(pParse);
5235 pToplevel->mayAbort = 1;
5236}
5237
5238/*
5239** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
5240** error. The onError parameter determines which (if any) of the statement
5241** and/or current transaction is rolled back.
5242*/
drhd91c1a12013-02-09 13:58:25 +00005243void sqlite3HaltConstraint(
5244 Parse *pParse, /* Parsing context */
5245 int errCode, /* extended error code */
5246 int onError, /* Constraint type */
5247 char *p4, /* Error message */
drhf9c8ce32013-11-05 13:33:55 +00005248 i8 p4type, /* P4_STATIC or P4_TRANSIENT */
5249 u8 p5Errmsg /* P5_ErrMsg type */
drhd91c1a12013-02-09 13:58:25 +00005250){
drh289a0c82020-08-15 22:23:00 +00005251 Vdbe *v;
5252 assert( pParse->pVdbe!=0 );
5253 v = sqlite3GetVdbe(pParse);
drh9e5fdc42020-05-08 19:02:21 +00005254 assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested );
dane0af83a2009-09-08 19:15:01 +00005255 if( onError==OE_Abort ){
5256 sqlite3MayAbort(pParse);
danielk19771d850a72004-05-31 08:26:49 +00005257 }
drhd91c1a12013-02-09 13:58:25 +00005258 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
drh9b34abe2016-01-16 15:12:35 +00005259 sqlite3VdbeChangeP5(v, p5Errmsg);
drhf9c8ce32013-11-05 13:33:55 +00005260}
5261
5262/*
5263** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
5264*/
5265void sqlite3UniqueConstraint(
5266 Parse *pParse, /* Parsing context */
5267 int onError, /* Constraint type */
5268 Index *pIdx /* The index that triggers the constraint */
5269){
5270 char *zErr;
5271 int j;
5272 StrAccum errMsg;
5273 Table *pTab = pIdx->pTable;
5274
drh86ec1ed2019-04-10 00:58:07 +00005275 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
5276 pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
drh8b576422015-08-31 23:09:42 +00005277 if( pIdx->aColExpr ){
drh0cdbe1a2018-05-09 13:46:26 +00005278 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
drh8b576422015-08-31 23:09:42 +00005279 }else{
5280 for(j=0; j<pIdx->nKeyCol; j++){
5281 char *zCol;
5282 assert( pIdx->aiColumn[j]>=0 );
drhcf9d36d2021-08-02 18:03:43 +00005283 zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
drh0cdbe1a2018-05-09 13:46:26 +00005284 if( j ) sqlite3_str_append(&errMsg, ", ", 2);
5285 sqlite3_str_appendall(&errMsg, pTab->zName);
5286 sqlite3_str_append(&errMsg, ".", 1);
5287 sqlite3_str_appendall(&errMsg, zCol);
drh8b576422015-08-31 23:09:42 +00005288 }
drhf9c8ce32013-11-05 13:33:55 +00005289 }
5290 zErr = sqlite3StrAccumFinish(&errMsg);
5291 sqlite3HaltConstraint(pParse,
drh48dd1d82014-05-27 18:18:58 +00005292 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
5293 : SQLITE_CONSTRAINT_UNIQUE,
dan93889d92013-11-06 16:28:59 +00005294 onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
drhf9c8ce32013-11-05 13:33:55 +00005295}
5296
5297
5298/*
5299** Code an OP_Halt due to non-unique rowid.
5300*/
5301void sqlite3RowidConstraint(
5302 Parse *pParse, /* Parsing context */
5303 int onError, /* Conflict resolution algorithm */
5304 Table *pTab /* The table with the non-unique rowid */
5305){
5306 char *zMsg;
5307 int rc;
5308 if( pTab->iPKey>=0 ){
5309 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
drhcf9d36d2021-08-02 18:03:43 +00005310 pTab->aCol[pTab->iPKey].zCnName);
drhf9c8ce32013-11-05 13:33:55 +00005311 rc = SQLITE_CONSTRAINT_PRIMARYKEY;
5312 }else{
5313 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
5314 rc = SQLITE_CONSTRAINT_ROWID;
5315 }
5316 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
5317 P5_ConstraintUnique);
drh663fc632002-02-02 18:49:19 +00005318}
5319
drh4343fea2004-11-05 23:46:15 +00005320/*
5321** Check to see if pIndex uses the collating sequence pColl. Return
5322** true if it does and false if it does not.
5323*/
5324#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00005325static int collationMatch(const char *zColl, Index *pIndex){
5326 int i;
drh04491712009-05-13 17:21:13 +00005327 assert( zColl!=0 );
danielk1977b3bf5562006-01-10 17:58:23 +00005328 for(i=0; i<pIndex->nColumn; i++){
5329 const char *z = pIndex->azColl[i];
drhbbbdc832013-10-22 18:01:40 +00005330 assert( z!=0 || pIndex->aiColumn[i]<0 );
5331 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00005332 return 1;
5333 }
drh4343fea2004-11-05 23:46:15 +00005334 }
5335 return 0;
5336}
5337#endif
5338
5339/*
5340** Recompute all indices of pTab that use the collating sequence pColl.
5341** If pColl==0 then recompute all indices of pTab.
5342*/
5343#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00005344static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
dane6370e92019-01-11 17:41:23 +00005345 if( !IsVirtual(pTab) ){
5346 Index *pIndex; /* An index associated with pTab */
drh4343fea2004-11-05 23:46:15 +00005347
dane6370e92019-01-11 17:41:23 +00005348 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
5349 if( zColl==0 || collationMatch(zColl, pIndex) ){
5350 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
5351 sqlite3BeginWriteOperation(pParse, 0, iDb);
5352 sqlite3RefillIndex(pParse, pIndex, -1);
5353 }
drh4343fea2004-11-05 23:46:15 +00005354 }
5355 }
5356}
5357#endif
5358
5359/*
5360** Recompute all indices of all tables in all databases where the
5361** indices use the collating sequence pColl. If pColl==0 then recompute
5362** all indices everywhere.
5363*/
5364#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00005365static void reindexDatabases(Parse *pParse, char const *zColl){
drh4343fea2004-11-05 23:46:15 +00005366 Db *pDb; /* A single database */
5367 int iDb; /* The database index number */
5368 sqlite3 *db = pParse->db; /* The database connection */
5369 HashElem *k; /* For looping over tables in pDb */
5370 Table *pTab; /* A table in the database */
5371
drh21206082011-04-04 18:22:02 +00005372 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
drh4343fea2004-11-05 23:46:15 +00005373 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
drh43617e92006-03-06 20:55:46 +00005374 assert( pDb!=0 );
danielk1977da184232006-01-05 11:34:32 +00005375 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
drh4343fea2004-11-05 23:46:15 +00005376 pTab = (Table*)sqliteHashData(k);
danielk1977b3bf5562006-01-10 17:58:23 +00005377 reindexTable(pParse, pTab, zColl);
drh4343fea2004-11-05 23:46:15 +00005378 }
5379 }
5380}
5381#endif
5382
5383/*
drheee46cf2004-11-06 00:02:48 +00005384** Generate code for the REINDEX command.
5385**
5386** REINDEX -- 1
5387** REINDEX <collation> -- 2
5388** REINDEX ?<database>.?<tablename> -- 3
5389** REINDEX ?<database>.?<indexname> -- 4
5390**
5391** Form 1 causes all indices in all attached databases to be rebuilt.
5392** Form 2 rebuilds all indices in all databases that use the named
5393** collating function. Forms 3 and 4 rebuild the named index or all
5394** indices associated with the named table.
drh4343fea2004-11-05 23:46:15 +00005395*/
5396#ifndef SQLITE_OMIT_REINDEX
5397void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
5398 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
5399 char *z; /* Name of a table or index */
5400 const char *zDb; /* Name of the database */
5401 Table *pTab; /* A table in the database */
5402 Index *pIndex; /* An index associated with pTab */
5403 int iDb; /* The database index number */
5404 sqlite3 *db = pParse->db; /* The database connection */
5405 Token *pObjName; /* Name of the table or index to be reindexed */
5406
danielk197733a5edc2005-01-27 00:22:02 +00005407 /* Read the database schema. If an error occurs, leave an error message
5408 ** and code in pParse and return NULL. */
5409 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e63739a2005-01-27 00:33:37 +00005410 return;
danielk197733a5edc2005-01-27 00:22:02 +00005411 }
5412
drh8af73d42009-05-13 22:58:28 +00005413 if( pName1==0 ){
drh4343fea2004-11-05 23:46:15 +00005414 reindexDatabases(pParse, 0);
5415 return;
drhd3001712009-05-12 17:46:53 +00005416 }else if( NEVER(pName2==0) || pName2->z==0 ){
danielk197739002502007-11-12 09:50:26 +00005417 char *zColl;
danielk1977b3bf5562006-01-10 17:58:23 +00005418 assert( pName1->z );
danielk197739002502007-11-12 09:50:26 +00005419 zColl = sqlite3NameFromToken(pParse->db, pName1);
5420 if( !zColl ) return;
drhc4a64fa2009-05-11 20:53:28 +00005421 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh4343fea2004-11-05 23:46:15 +00005422 if( pColl ){
drhd3001712009-05-12 17:46:53 +00005423 reindexDatabases(pParse, zColl);
5424 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00005425 return;
5426 }
drh633e6d52008-07-28 19:34:53 +00005427 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00005428 }
5429 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
5430 if( iDb<0 ) return;
drh17435752007-08-16 04:30:38 +00005431 z = sqlite3NameFromToken(db, pObjName);
drh84f31122007-05-12 15:00:14 +00005432 if( z==0 ) return;
drh69c33822016-08-18 14:33:11 +00005433 zDb = db->aDb[iDb].zDbSName;
drh4343fea2004-11-05 23:46:15 +00005434 pTab = sqlite3FindTable(db, z, zDb);
5435 if( pTab ){
5436 reindexTable(pParse, pTab, 0);
drh633e6d52008-07-28 19:34:53 +00005437 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00005438 return;
5439 }
5440 pIndex = sqlite3FindIndex(db, z, zDb);
drh633e6d52008-07-28 19:34:53 +00005441 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00005442 if( pIndex ){
5443 sqlite3BeginWriteOperation(pParse, 0, iDb);
5444 sqlite3RefillIndex(pParse, pIndex, -1);
5445 return;
5446 }
5447 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
5448}
5449#endif
danielk1977b3bf5562006-01-10 17:58:23 +00005450
5451/*
drh2ec2fb22013-11-06 19:59:23 +00005452** Return a KeyInfo structure that is appropriate for the given Index.
danielk1977b3bf5562006-01-10 17:58:23 +00005453**
drh2ec2fb22013-11-06 19:59:23 +00005454** The caller should invoke sqlite3KeyInfoUnref() on the returned object
5455** when it has finished using it.
danielk1977b3bf5562006-01-10 17:58:23 +00005456*/
drh2ec2fb22013-11-06 19:59:23 +00005457KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
drh18b67f32014-12-12 00:20:37 +00005458 int i;
5459 int nCol = pIdx->nColumn;
5460 int nKey = pIdx->nKeyCol;
5461 KeyInfo *pKey;
drh2ec2fb22013-11-06 19:59:23 +00005462 if( pParse->nErr ) return 0;
drh18b67f32014-12-12 00:20:37 +00005463 if( pIdx->uniqNotNull ){
5464 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
5465 }else{
5466 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
drh41e13e12013-11-07 14:09:39 +00005467 }
drh18b67f32014-12-12 00:20:37 +00005468 if( pKey ){
5469 assert( sqlite3KeyInfoIsWriteable(pKey) );
5470 for(i=0; i<nCol; i++){
drhf19aa5f2015-12-30 16:51:20 +00005471 const char *zColl = pIdx->azColl[i];
5472 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
drh18b67f32014-12-12 00:20:37 +00005473 sqlite3LocateCollSeq(pParse, zColl);
dan6e118922019-08-12 16:36:38 +00005474 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
5475 assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
drh2ec2fb22013-11-06 19:59:23 +00005476 }
drh18b67f32014-12-12 00:20:37 +00005477 if( pParse->nErr ){
drh7e8515d2017-12-08 19:37:04 +00005478 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
5479 if( pIdx->bNoQuery==0 ){
5480 /* Deactivate the index because it contains an unknown collating
5481 ** sequence. The only way to reactive the index is to reload the
5482 ** schema. Adding the missing collating sequence later does not
5483 ** reactive the index. The application had the chance to register
5484 ** the missing index using the collation-needed callback. For
5485 ** simplicity, SQLite will not give the application a second chance.
5486 */
5487 pIdx->bNoQuery = 1;
5488 pParse->rc = SQLITE_ERROR_RETRY;
5489 }
drh18b67f32014-12-12 00:20:37 +00005490 sqlite3KeyInfoUnref(pKey);
5491 pKey = 0;
danielk1977b3bf5562006-01-10 17:58:23 +00005492 }
danielk1977b3bf5562006-01-10 17:58:23 +00005493 }
drh18b67f32014-12-12 00:20:37 +00005494 return pKey;
danielk1977b3bf5562006-01-10 17:58:23 +00005495}
drh8b471862014-01-11 13:22:17 +00005496
5497#ifndef SQLITE_OMIT_CTE
drhf824b412021-02-20 14:57:16 +00005498/*
5499** Create a new CTE object
5500*/
5501Cte *sqlite3CteNew(
5502 Parse *pParse, /* Parsing context */
5503 Token *pName, /* Name of the common-table */
5504 ExprList *pArglist, /* Optional column name list for the table */
drh745912e2021-02-22 03:04:25 +00005505 Select *pQuery, /* Query used to initialize the table */
5506 u8 eM10d /* The MATERIALIZED flag */
drhf824b412021-02-20 14:57:16 +00005507){
5508 Cte *pNew;
5509 sqlite3 *db = pParse->db;
5510
5511 pNew = sqlite3DbMallocZero(db, sizeof(*pNew));
5512 assert( pNew!=0 || db->mallocFailed );
5513
5514 if( db->mallocFailed ){
5515 sqlite3ExprListDelete(db, pArglist);
5516 sqlite3SelectDelete(db, pQuery);
5517 }else{
5518 pNew->pSelect = pQuery;
5519 pNew->pCols = pArglist;
5520 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
drh745912e2021-02-22 03:04:25 +00005521 pNew->eM10d = eM10d;
drhf824b412021-02-20 14:57:16 +00005522 }
5523 return pNew;
5524}
5525
5526/*
5527** Clear information from a Cte object, but do not deallocate storage
5528** for the object itself.
5529*/
5530static void cteClear(sqlite3 *db, Cte *pCte){
5531 assert( pCte!=0 );
5532 sqlite3ExprListDelete(db, pCte->pCols);
5533 sqlite3SelectDelete(db, pCte->pSelect);
5534 sqlite3DbFree(db, pCte->zName);
5535}
5536
5537/*
5538** Free the contents of the CTE object passed as the second argument.
5539*/
5540void sqlite3CteDelete(sqlite3 *db, Cte *pCte){
5541 assert( pCte!=0 );
5542 cteClear(db, pCte);
5543 sqlite3DbFree(db, pCte);
5544}
5545
dan7d562db2014-01-11 19:19:36 +00005546/*
5547** This routine is invoked once per CTE by the parser while parsing a
drhf824b412021-02-20 14:57:16 +00005548** WITH clause. The CTE described by teh third argument is added to
5549** the WITH clause of the second argument. If the second argument is
5550** NULL, then a new WITH argument is created.
drh8b471862014-01-11 13:22:17 +00005551*/
dan7d562db2014-01-11 19:19:36 +00005552With *sqlite3WithAdd(
drh8b471862014-01-11 13:22:17 +00005553 Parse *pParse, /* Parsing context */
dan7d562db2014-01-11 19:19:36 +00005554 With *pWith, /* Existing WITH clause, or NULL */
drhf824b412021-02-20 14:57:16 +00005555 Cte *pCte /* CTE to add to the WITH clause */
drh8b471862014-01-11 13:22:17 +00005556){
dan4e9119d2014-01-13 15:12:23 +00005557 sqlite3 *db = pParse->db;
5558 With *pNew;
5559 char *zName;
5560
drhf824b412021-02-20 14:57:16 +00005561 if( pCte==0 ){
5562 return pWith;
5563 }
5564
dan4e9119d2014-01-13 15:12:23 +00005565 /* Check that the CTE name is unique within this WITH clause. If
5566 ** not, store an error in the Parse structure. */
drhf824b412021-02-20 14:57:16 +00005567 zName = pCte->zName;
dan4e9119d2014-01-13 15:12:23 +00005568 if( zName && pWith ){
5569 int i;
5570 for(i=0; i<pWith->nCte; i++){
5571 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
drh727a99f2014-01-16 21:59:51 +00005572 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
dan4e9119d2014-01-13 15:12:23 +00005573 }
5574 }
5575 }
5576
5577 if( pWith ){
drh0aa32312019-04-13 04:01:12 +00005578 sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
dan4e9119d2014-01-13 15:12:23 +00005579 pNew = sqlite3DbRealloc(db, pWith, nByte);
5580 }else{
5581 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
5582 }
drhb84e5742016-02-05 02:42:54 +00005583 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
dan4e9119d2014-01-13 15:12:23 +00005584
drhb84e5742016-02-05 02:42:54 +00005585 if( db->mallocFailed ){
drhf824b412021-02-20 14:57:16 +00005586 sqlite3CteDelete(db, pCte);
dana9f5c132014-01-13 16:36:40 +00005587 pNew = pWith;
dan4e9119d2014-01-13 15:12:23 +00005588 }else{
drhf824b412021-02-20 14:57:16 +00005589 pNew->a[pNew->nCte++] = *pCte;
5590 sqlite3DbFree(db, pCte);
dan4e9119d2014-01-13 15:12:23 +00005591 }
5592
5593 return pNew;
drh8b471862014-01-11 13:22:17 +00005594}
5595
dan7d562db2014-01-11 19:19:36 +00005596/*
5597** Free the contents of the With object passed as the second argument.
drh8b471862014-01-11 13:22:17 +00005598*/
dan7d562db2014-01-11 19:19:36 +00005599void sqlite3WithDelete(sqlite3 *db, With *pWith){
dan4e9119d2014-01-13 15:12:23 +00005600 if( pWith ){
5601 int i;
5602 for(i=0; i<pWith->nCte; i++){
drhf824b412021-02-20 14:57:16 +00005603 cteClear(db, &pWith->a[i]);
dan4e9119d2014-01-13 15:12:23 +00005604 }
5605 sqlite3DbFree(db, pWith);
5606 }
drh8b471862014-01-11 13:22:17 +00005607}
5608#endif /* !defined(SQLITE_OMIT_CTE) */