blob: 29a798e6c7de5cd13cd0d7db3b8dcf6f4e3a4b04 [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;
drh7bace9e2022-07-23 12:51:48 +0000143 int iDb, i;
drhb86ccfb2003-01-28 23:13:10 +0000144
danf78baaf2012-12-06 19:37:22 +0000145 assert( pParse->pToplevel==0 );
drh17435752007-08-16 04:30:38 +0000146 db = pParse->db;
drh0c7d3d32022-01-24 16:47:12 +0000147 assert( db->pParse==pParse );
drh205f48e2004-11-05 00:43:11 +0000148 if( pParse->nested ) return;
drh0c7d3d32022-01-24 16:47:12 +0000149 if( pParse->nErr ){
drha5c9a702022-01-25 00:03:25 +0000150 if( db->mallocFailed ) pParse->rc = SQLITE_NOMEM;
drhd99d2832015-04-17 15:58:33 +0000151 return;
152 }
drh0c7d3d32022-01-24 16:47:12 +0000153 assert( db->mallocFailed==0 );
danielk197748d0d862005-02-01 03:09:52 +0000154
drh80242052004-06-09 00:48:12 +0000155 /* Begin by generating some termination code at the end of the
156 ** vdbe program
157 */
drh02c4aa32021-02-04 13:44:42 +0000158 v = pParse->pVdbe;
159 if( v==0 ){
160 if( db->init.busy ){
161 pParse->rc = SQLITE_DONE;
162 return;
163 }
164 v = sqlite3GetVdbe(pParse);
165 if( v==0 ) pParse->rc = SQLITE_ERROR;
drhc8af8792021-01-01 22:06:17 +0000166 }
danf3677212009-09-10 16:14:50 +0000167 assert( !pParse->isMultiWrite
168 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
drh80242052004-06-09 00:48:12 +0000169 if( v ){
drh381bdac2021-02-04 17:29:04 +0000170 if( pParse->bReturning ){
171 Returning *pReturning = pParse->u1.pReturning;
172 int addrRewind;
drh381bdac2021-02-04 17:29:04 +0000173 int reg;
174
drh1a6bac02022-04-25 10:43:19 +0000175 if( pReturning->nRetCol ){
drh3b26b2b2021-12-01 19:17:14 +0000176 sqlite3VdbeAddOp0(v, OP_FkCheck);
drh7132f432021-10-20 12:52:12 +0000177 addrRewind =
178 sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
179 VdbeCoverage(v);
180 reg = pReturning->iRetReg;
181 for(i=0; i<pReturning->nRetCol; i++){
182 sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
183 }
184 sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);
185 sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
186 VdbeCoverage(v);
187 sqlite3VdbeJumpHere(v, addrRewind);
drh381bdac2021-02-04 17:29:04 +0000188 }
drh381bdac2021-02-04 17:29:04 +0000189 }
drh66a51672008-01-03 00:01:23 +0000190 sqlite3VdbeAddOp0(v, OP_Halt);
drh0e3d7472004-06-19 17:33:07 +0000191
drhb2445d52014-09-11 14:01:41 +0000192#if SQLITE_USER_AUTHENTICATION
193 if( pParse->nTableLock>0 && db->init.busy==0 ){
drh7883ecf2014-09-11 16:19:31 +0000194 sqlite3UserAuthInit(db);
drhb2445d52014-09-11 14:01:41 +0000195 if( db->auth.authLevel<UAUTH_User ){
drh7883ecf2014-09-11 16:19:31 +0000196 sqlite3ErrorMsg(pParse, "user not authenticated");
drh6ae3ab02016-08-23 14:42:15 +0000197 pParse->rc = SQLITE_AUTH_USER;
drh7883ecf2014-09-11 16:19:31 +0000198 return;
drhb2445d52014-09-11 14:01:41 +0000199 }
200 }
201#endif
202
drh0e3d7472004-06-19 17:33:07 +0000203 /* The cookie mask contains one bit for each database file open.
204 ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
205 ** set for each database that is used. Generate code to start a
206 ** transaction on each used database and to verify the schema cookie
207 ** on each used database.
208 */
drh7bace9e2022-07-23 12:51:48 +0000209 assert( pParse->nErr>0 || sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
210 sqlite3VdbeJumpHere(v, 0);
211 assert( db->nDb>0 );
212 iDb = 0;
213 do{
214 Schema *pSchema;
215 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
216 sqlite3VdbeUsesBtree(v, iDb);
217 pSchema = db->aDb[iDb].pSchema;
218 sqlite3VdbeAddOp4Int(v,
219 OP_Transaction, /* Opcode */
220 iDb, /* P1 */
221 DbMaskTest(pParse->writeMask,iDb), /* P2 */
222 pSchema->schema_cookie, /* P3 */
223 pSchema->iGeneration /* P4 */
224 );
225 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
226 VdbeComment((v,
227 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
228 }while( ++iDb<db->nDb );
danielk1977f9e7dda2006-06-16 16:08:53 +0000229#ifndef SQLITE_OMIT_VIRTUALTABLE
drh7bace9e2022-07-23 12:51:48 +0000230 for(i=0; i<pParse->nVtabLock; i++){
231 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
232 sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
233 }
234 pParse->nVtabLock = 0;
danielk1977f9e7dda2006-06-16 16:08:53 +0000235#endif
danielk1977c00da102006-01-07 13:21:04 +0000236
drh7bace9e2022-07-23 12:51:48 +0000237 /* Once all the cookies have been verified and transactions opened,
238 ** obtain the required table-locks. This is a no-op unless the
239 ** shared-cache feature is enabled.
240 */
241 codeTableLocks(pParse);
drh0b9f50d2009-06-23 20:28:53 +0000242
drh7bace9e2022-07-23 12:51:48 +0000243 /* Initialize any AUTOINCREMENT data structures required.
244 */
245 sqlite3AutoincrementBegin(pParse);
drh0b9f50d2009-06-23 20:28:53 +0000246
drh7bace9e2022-07-23 12:51:48 +0000247 /* Code constant expressions that where factored out of inner loops.
248 **
249 ** The pConstExpr list might also contain expressions that we simply
250 ** want to keep around until the Parse object is deleted. Such
251 ** expressions have iConstExprReg==0. Do not generate code for
252 ** those expressions, of course.
253 */
254 if( pParse->pConstExpr ){
255 ExprList *pEL = pParse->pConstExpr;
256 pParse->okConstFactor = 0;
257 for(i=0; i<pEL->nExpr; i++){
258 int iReg = pEL->a[i].u.iConstExprReg;
259 sqlite3ExprCode(pParse, pEL->a[i].pExpr, iReg);
drhf30a9692013-11-15 01:10:18 +0000260 }
drh80242052004-06-09 00:48:12 +0000261 }
drh7bace9e2022-07-23 12:51:48 +0000262
263 if( pParse->bReturning ){
264 Returning *pRet = pParse->u1.pReturning;
265 if( pRet->nRetCol ){
266 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);
267 }
268 }
269
270 /* Finally, jump back to the beginning of the executable code. */
271 sqlite3VdbeGoto(v, 1);
drh71c697e2004-08-08 23:39:19 +0000272 }
273
drh80242052004-06-09 00:48:12 +0000274 /* Get the VDBE program ready for execution
275 */
drh1da88b52022-01-24 19:38:56 +0000276 assert( v!=0 || pParse->nErr );
277 assert( db->mallocFailed==0 || pParse->nErr );
278 if( pParse->nErr==0 ){
drh3492dd72009-09-14 23:47:24 +0000279 /* A minimum of one cursor is required if autoincrement is used
280 * See ticket [a696379c1f08866] */
drh04ab5862018-12-01 21:13:41 +0000281 assert( pParse->pAinc==0 || pParse->nTab>0 );
drh124c0b42011-06-01 18:15:55 +0000282 sqlite3VdbeMakeReady(v, pParse);
danielk1977441daf62005-02-01 03:46:43 +0000283 pParse->rc = SQLITE_DONE;
drhe294da02010-02-25 23:44:15 +0000284 }else{
drh483750b2003-01-29 18:46:51 +0000285 pParse->rc = SQLITE_ERROR;
drh75897232000-05-29 14:26:00 +0000286 }
287}
288
289/*
drh205f48e2004-11-05 00:43:11 +0000290** Run the parser and code generator recursively in order to generate
291** code for the SQL statement given onto the end of the pParse context
drh3edc9272021-08-04 13:42:12 +0000292** currently under construction. Notes:
drh205f48e2004-11-05 00:43:11 +0000293**
drh3edc9272021-08-04 13:42:12 +0000294** * The final OP_Halt is not appended and other initialization
295** and finalization steps are omitted because those are handling by the
296** outermost parser.
297**
298** * Built-in SQL functions always take precedence over application-defined
299** SQL functions. In other words, it is not possible to override a
300** built-in function.
drh205f48e2004-11-05 00:43:11 +0000301*/
302void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
303 va_list ap;
304 char *zSql;
drh633e6d52008-07-28 19:34:53 +0000305 sqlite3 *db = pParse->db;
drh3edc9272021-08-04 13:42:12 +0000306 u32 savedDbFlags = db->mDbFlags;
drhcd9af602016-09-30 22:24:29 +0000307 char saveBuf[PARSE_TAIL_SZ];
drhf1974842004-11-05 03:56:00 +0000308
drh205f48e2004-11-05 00:43:11 +0000309 if( pParse->nErr ) return;
310 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
311 va_start(ap, zFormat);
drh633e6d52008-07-28 19:34:53 +0000312 zSql = sqlite3VMPrintf(db, zFormat, ap);
drh205f48e2004-11-05 00:43:11 +0000313 va_end(ap);
drh73c42a12004-11-20 18:13:10 +0000314 if( zSql==0 ){
drh480c5722019-02-22 16:18:12 +0000315 /* This can result either from an OOM or because the formatted string
316 ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set
317 ** an error */
318 if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
drha2b68062019-03-28 04:03:17 +0000319 pParse->nErr++;
drh480c5722019-02-22 16:18:12 +0000320 return;
drh73c42a12004-11-20 18:13:10 +0000321 }
drh205f48e2004-11-05 00:43:11 +0000322 pParse->nested++;
drhcd9af602016-09-30 22:24:29 +0000323 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
324 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
drh3edc9272021-08-04 13:42:12 +0000325 db->mDbFlags |= DBFLAG_PreferBuiltin;
drh54bc6382021-12-31 19:20:42 +0000326 sqlite3RunParser(pParse, zSql);
drh3edc9272021-08-04 13:42:12 +0000327 db->mDbFlags = savedDbFlags;
drh633e6d52008-07-28 19:34:53 +0000328 sqlite3DbFree(db, zSql);
drhcd9af602016-09-30 22:24:29 +0000329 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
drh205f48e2004-11-05 00:43:11 +0000330 pParse->nested--;
331}
332
drhd4530972014-09-09 14:47:53 +0000333#if SQLITE_USER_AUTHENTICATION
334/*
335** Return TRUE if zTable is the name of the system table that stores the
336** list of users and their access credentials.
337*/
338int sqlite3UserAuthTable(const char *zTable){
339 return sqlite3_stricmp(zTable, "sqlite_user")==0;
340}
341#endif
342
drh205f48e2004-11-05 00:43:11 +0000343/*
danielk19778a414492004-06-29 08:59:35 +0000344** Locate the in-memory structure that describes a particular database
345** table given the name of that table and (optionally) the name of the
346** database containing the table. Return NULL if not found.
drha69d9162003-04-17 22:57:53 +0000347**
danielk19778a414492004-06-29 08:59:35 +0000348** If zDatabase is 0, all databases are searched for the table and the
349** first matching table is returned. (No checking for duplicate table
350** names is done.) The search order is TEMP first, then MAIN, then any
351** auxiliary databases added using the ATTACH command.
drhf26e09c2003-05-31 16:21:12 +0000352**
danielk19774adee202004-05-08 08:23:19 +0000353** See also sqlite3LocateTable().
drh75897232000-05-29 14:26:00 +0000354*/
drh9bb575f2004-09-06 17:24:11 +0000355Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
drhd24cc422003-03-27 12:51:24 +0000356 Table *p = 0;
357 int i;
drh9ca95732014-10-24 00:35:58 +0000358
drh21206082011-04-04 18:22:02 +0000359 /* All mutexes are required for schema access. Make sure we hold them. */
360 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
drhd4530972014-09-09 14:47:53 +0000361#if SQLITE_USER_AUTHENTICATION
362 /* Only the admin user is allowed to know that the sqlite_user table
363 ** exists */
drhe933b832014-09-10 17:34:28 +0000364 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
365 return 0;
366 }
drhd4530972014-09-09 14:47:53 +0000367#endif
drhb2eb7e42020-05-16 21:01:00 +0000368 if( zDatabase ){
369 for(i=0; i<db->nDb; i++){
370 if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break;
371 }
372 if( i>=db->nDb ){
373 /* No match against the official names. But always match "main"
374 ** to schema 0 as a legacy fallback. */
375 if( sqlite3StrICmp(zDatabase,"main")==0 ){
376 i = 0;
377 }else{
378 return 0;
drhe0a04a32016-12-16 01:00:21 +0000379 }
drh69c33822016-08-18 14:33:11 +0000380 }
drhb2eb7e42020-05-16 21:01:00 +0000381 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
drh346a70c2020-06-15 20:27:35 +0000382 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
383 if( i==1 ){
drha4a871c2021-11-04 14:04:20 +0000384 if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0
385 || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0
386 || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0
drh346a70c2020-06-15 20:27:35 +0000387 ){
388 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
drha4a871c2021-11-04 14:04:20 +0000389 LEGACY_TEMP_SCHEMA_TABLE);
drh346a70c2020-06-15 20:27:35 +0000390 }
391 }else{
drha4a871c2021-11-04 14:04:20 +0000392 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
drh346a70c2020-06-15 20:27:35 +0000393 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,
drha4a871c2021-11-04 14:04:20 +0000394 LEGACY_SCHEMA_TABLE);
drh346a70c2020-06-15 20:27:35 +0000395 }
396 }
drhb2eb7e42020-05-16 21:01:00 +0000397 }
398 }else{
399 /* Match against TEMP first */
400 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
401 if( p ) return p;
402 /* The main database is second */
403 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
404 if( p ) return p;
405 /* Attached databases are in order of attachment */
406 for(i=2; i<db->nDb; i++){
407 assert( sqlite3SchemaMutexHeld(db, i, 0) );
408 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
409 if( p ) break;
410 }
drh346a70c2020-06-15 20:27:35 +0000411 if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
drha4a871c2021-11-04 14:04:20 +0000412 if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
413 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, LEGACY_SCHEMA_TABLE);
414 }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
drh346a70c2020-06-15 20:27:35 +0000415 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
drha4a871c2021-11-04 14:04:20 +0000416 LEGACY_TEMP_SCHEMA_TABLE);
drh346a70c2020-06-15 20:27:35 +0000417 }
418 }
drhd24cc422003-03-27 12:51:24 +0000419 }
drhb2eb7e42020-05-16 21:01:00 +0000420 return p;
drh75897232000-05-29 14:26:00 +0000421}
422
423/*
danielk19778a414492004-06-29 08:59:35 +0000424** Locate the in-memory structure that describes a particular database
425** table given the name of that table and (optionally) the name of the
426** database containing the table. Return NULL if not found. Also leave an
427** error message in pParse->zErrMsg.
drha69d9162003-04-17 22:57:53 +0000428**
danielk19778a414492004-06-29 08:59:35 +0000429** The difference between this routine and sqlite3FindTable() is that this
430** routine leaves an error message in pParse->zErrMsg where
431** sqlite3FindTable() does not.
drha69d9162003-04-17 22:57:53 +0000432*/
drhca424112008-01-25 15:04:48 +0000433Table *sqlite3LocateTable(
434 Parse *pParse, /* context in which to report errors */
drh4d249e62016-06-10 22:49:01 +0000435 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
drhca424112008-01-25 15:04:48 +0000436 const char *zName, /* Name of the table we are looking for */
437 const char *zDbase /* Name of the database. Might be NULL */
438){
drha69d9162003-04-17 22:57:53 +0000439 Table *p;
drhb2c85592018-04-25 12:01:45 +0000440 sqlite3 *db = pParse->db;
drhf26e09c2003-05-31 16:21:12 +0000441
danielk19778a414492004-06-29 08:59:35 +0000442 /* Read the database schema. If an error occurs, leave an error message
443 ** and code in pParse and return NULL. */
drhb2c85592018-04-25 12:01:45 +0000444 if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
445 && SQLITE_OK!=sqlite3ReadSchema(pParse)
446 ){
danielk19778a414492004-06-29 08:59:35 +0000447 return 0;
448 }
449
drhb2c85592018-04-25 12:01:45 +0000450 p = sqlite3FindTable(db, zName, zDbase);
drha69d9162003-04-17 22:57:53 +0000451 if( p==0 ){
drhd2975922015-08-29 17:22:33 +0000452#ifndef SQLITE_OMIT_VIRTUALTABLE
drh9196c812018-11-05 16:38:10 +0000453 /* If zName is the not the name of a table in the schema created using
454 ** CREATE, then check to see if it is the name of an virtual table that
455 ** can be an eponymous virtual table. */
drh7424aef2022-10-01 13:17:53 +0000456 if( (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)==0 && db->init.busy==0 ){
dan1ea04432018-12-21 19:29:11 +0000457 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
458 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
459 pMod = sqlite3PragmaVtabRegister(db, zName);
460 }
461 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
danbd24e8f2021-07-08 18:29:25 +0000462 testcase( pMod->pEpoTab==0 );
dan1ea04432018-12-21 19:29:11 +0000463 return pMod->pEpoTab;
464 }
drh51be3872015-08-19 02:32:25 +0000465 }
466#endif
dan1ea04432018-12-21 19:29:11 +0000467 if( flags & LOCATE_NOERR ) return 0;
468 pParse->checkSchema = 1;
drh7424aef2022-10-01 13:17:53 +0000469 }else if( IsVirtual(p) && (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)!=0 ){
dan1ea04432018-12-21 19:29:11 +0000470 p = 0;
471 }
472
473 if( p==0 ){
474 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
475 if( zDbase ){
476 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
477 }else{
478 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
drha69d9162003-04-17 22:57:53 +0000479 }
drh1bb89e92021-04-19 18:03:52 +0000480 }else{
481 assert( HasRowid(p) || p->iPKey<0 );
drha69d9162003-04-17 22:57:53 +0000482 }
danfab1d402015-11-26 15:51:55 +0000483
drha69d9162003-04-17 22:57:53 +0000484 return p;
485}
486
487/*
dan41fb5cd2012-10-04 19:33:00 +0000488** Locate the table identified by *p.
489**
490** This is a wrapper around sqlite3LocateTable(). The difference between
491** sqlite3LocateTable() and this function is that this function restricts
492** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
493** non-NULL if it is part of a view or trigger program definition. See
494** sqlite3FixSrcList() for details.
495*/
496Table *sqlite3LocateTableItem(
497 Parse *pParse,
drh4d249e62016-06-10 22:49:01 +0000498 u32 flags,
drh76012942021-02-21 21:04:54 +0000499 SrcItem *p
dan41fb5cd2012-10-04 19:33:00 +0000500){
501 const char *zDb;
drhcd1499f2021-05-20 00:44:04 +0000502 assert( p->pSchema==0 || p->zDatabase==0 );
dan41fb5cd2012-10-04 19:33:00 +0000503 if( p->pSchema ){
504 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
drh69c33822016-08-18 14:33:11 +0000505 zDb = pParse->db->aDb[iDb].zDbSName;
dan41fb5cd2012-10-04 19:33:00 +0000506 }else{
507 zDb = p->zDatabase;
508 }
drh4d249e62016-06-10 22:49:01 +0000509 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
dan41fb5cd2012-10-04 19:33:00 +0000510}
511
512/*
drha4a871c2021-11-04 14:04:20 +0000513** Return the preferred table name for system tables. Translate legacy
514** names into the new preferred names, as appropriate.
515*/
516const char *sqlite3PreferredTableName(const char *zName){
517 if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
518 if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){
519 return PREFERRED_SCHEMA_TABLE;
520 }
521 if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
522 return PREFERRED_TEMP_SCHEMA_TABLE;
523 }
524 }
525 return zName;
526}
527
528/*
drha69d9162003-04-17 22:57:53 +0000529** Locate the in-memory structure that describes
530** a particular index given the name of that index
531** and the name of the database that contains the index.
drhf57b3392001-10-08 13:22:32 +0000532** Return NULL if not found.
drhf26e09c2003-05-31 16:21:12 +0000533**
534** If zDatabase is 0, all databases are searched for the
535** table and the first matching index is returned. (No checking
536** for duplicate index names is done.) The search order is
537** TEMP first, then MAIN, then any auxiliary databases added
538** using the ATTACH command.
drh75897232000-05-29 14:26:00 +0000539*/
drh9bb575f2004-09-06 17:24:11 +0000540Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
drhd24cc422003-03-27 12:51:24 +0000541 Index *p = 0;
542 int i;
drh21206082011-04-04 18:22:02 +0000543 /* All mutexes are required for schema access. Make sure we hold them. */
544 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
danielk197753c0f742005-03-29 03:10:59 +0000545 for(i=OMIT_TEMPDB; i<db->nDb; i++){
drh812d7a22003-03-27 13:50:00 +0000546 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
danielk1977e501b892006-01-09 06:29:47 +0000547 Schema *pSchema = db->aDb[j].pSchema;
drh04491712009-05-13 17:21:13 +0000548 assert( pSchema );
dan465c2b82020-03-21 15:10:40 +0000549 if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
drh21206082011-04-04 18:22:02 +0000550 assert( sqlite3SchemaMutexHeld(db, j, 0) );
drhacbcb7e2014-08-21 20:26:37 +0000551 p = sqlite3HashFind(&pSchema->idxHash, zName);
drhd24cc422003-03-27 12:51:24 +0000552 if( p ) break;
553 }
drh74e24cd2002-01-09 03:19:59 +0000554 return p;
drh75897232000-05-29 14:26:00 +0000555}
556
557/*
drh956bc922004-07-24 17:38:29 +0000558** Reclaim the memory used by an index
559*/
dancf8f2892018-08-09 20:47:01 +0000560void sqlite3FreeIndex(sqlite3 *db, Index *p){
drh92aa5ea2009-09-11 14:05:06 +0000561#ifndef SQLITE_OMIT_ANALYZE
dand46def72010-07-24 11:28:28 +0000562 sqlite3DeleteIndexSamples(db, p);
drh92aa5ea2009-09-11 14:05:06 +0000563#endif
drh1fe05372013-07-31 18:12:26 +0000564 sqlite3ExprDelete(db, p->pPartIdxWhere);
drh1f9ca2c2015-08-25 16:57:52 +0000565 sqlite3ExprListDelete(db, p->aColExpr);
drh633e6d52008-07-28 19:34:53 +0000566 sqlite3DbFree(db, p->zColAff);
mistachkin5905f862015-12-31 19:04:42 +0000567 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
drh175b8f02019-08-08 15:24:17 +0000568#ifdef SQLITE_ENABLE_STAT4
drh75b170b2014-10-04 00:07:44 +0000569 sqlite3_free(p->aiRowEst);
570#endif
drh633e6d52008-07-28 19:34:53 +0000571 sqlite3DbFree(db, p);
drh956bc922004-07-24 17:38:29 +0000572}
573
574/*
drhc96d8532005-05-03 12:30:33 +0000575** For the index called zIdxName which is found in the database iDb,
576** unlike that index from its Table then remove the index from
577** the index hash table and free all memory structures associated
578** with the index.
drh5e00f6c2001-09-13 13:46:56 +0000579*/
drh9bb575f2004-09-06 17:24:11 +0000580void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
drh956bc922004-07-24 17:38:29 +0000581 Index *pIndex;
drh21206082011-04-04 18:22:02 +0000582 Hash *pHash;
drh956bc922004-07-24 17:38:29 +0000583
drh21206082011-04-04 18:22:02 +0000584 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
585 pHash = &db->aDb[iDb].pSchema->idxHash;
drhacbcb7e2014-08-21 20:26:37 +0000586 pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
drh22645842011-03-24 01:34:03 +0000587 if( ALWAYS(pIndex) ){
drh956bc922004-07-24 17:38:29 +0000588 if( pIndex->pTable->pIndex==pIndex ){
589 pIndex->pTable->pIndex = pIndex->pNext;
590 }else{
591 Index *p;
drh04491712009-05-13 17:21:13 +0000592 /* Justification of ALWAYS(); The index must be on the list of
593 ** indices. */
594 p = pIndex->pTable->pIndex;
595 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
596 if( ALWAYS(p && p->pNext==pIndex) ){
drh956bc922004-07-24 17:38:29 +0000597 p->pNext = pIndex->pNext;
598 }
drh5e00f6c2001-09-13 13:46:56 +0000599 }
dancf8f2892018-08-09 20:47:01 +0000600 sqlite3FreeIndex(db, pIndex);
drh5e00f6c2001-09-13 13:46:56 +0000601 }
drh8257aa82017-07-26 19:59:13 +0000602 db->mDbFlags |= DBFLAG_SchemaChange;
drh5e00f6c2001-09-13 13:46:56 +0000603}
604
605/*
drh81028a42012-05-15 18:28:27 +0000606** Look through the list of open database files in db->aDb[] and if
607** any have been closed, remove them from the list. Reallocate the
608** db->aDb[] structure to a smaller size, if possible.
drh1c2d8412003-03-31 00:30:47 +0000609**
drh81028a42012-05-15 18:28:27 +0000610** Entry 0 (the "main" database) and entry 1 (the "temp" database)
611** are never candidates for being collapsed.
drh74e24cd2002-01-09 03:19:59 +0000612*/
drh81028a42012-05-15 18:28:27 +0000613void sqlite3CollapseDatabaseArray(sqlite3 *db){
drh1c2d8412003-03-31 00:30:47 +0000614 int i, j;
drh1c2d8412003-03-31 00:30:47 +0000615 for(i=j=2; i<db->nDb; i++){
drh4d189ca2004-02-12 18:46:38 +0000616 struct Db *pDb = &db->aDb[i];
617 if( pDb->pBt==0 ){
drh69c33822016-08-18 14:33:11 +0000618 sqlite3DbFree(db, pDb->zDbSName);
619 pDb->zDbSName = 0;
drh1c2d8412003-03-31 00:30:47 +0000620 continue;
621 }
622 if( j<i ){
drh8bf8dc92003-05-17 17:35:10 +0000623 db->aDb[j] = db->aDb[i];
drh1c2d8412003-03-31 00:30:47 +0000624 }
drh8bf8dc92003-05-17 17:35:10 +0000625 j++;
drh1c2d8412003-03-31 00:30:47 +0000626 }
drh1c2d8412003-03-31 00:30:47 +0000627 db->nDb = j;
628 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
629 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
drh633e6d52008-07-28 19:34:53 +0000630 sqlite3DbFree(db, db->aDb);
drh1c2d8412003-03-31 00:30:47 +0000631 db->aDb = db->aDbStatic;
632 }
drhe0bc4042002-06-25 01:09:11 +0000633}
634
635/*
drh81028a42012-05-15 18:28:27 +0000636** Reset the schema for the database at index iDb. Also reset the
drhdc6b41e2017-08-17 02:26:35 +0000637** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
638** Deferred resets may be run by calling with iDb<0.
drh81028a42012-05-15 18:28:27 +0000639*/
640void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
drhdc6b41e2017-08-17 02:26:35 +0000641 int i;
drh81028a42012-05-15 18:28:27 +0000642 assert( iDb<db->nDb );
643
drhdc6b41e2017-08-17 02:26:35 +0000644 if( iDb>=0 ){
645 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
646 DbSetProperty(db, iDb, DB_ResetWanted);
647 DbSetProperty(db, 1, DB_ResetWanted);
drhb2c85592018-04-25 12:01:45 +0000648 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
drh81028a42012-05-15 18:28:27 +0000649 }
drhdc6b41e2017-08-17 02:26:35 +0000650
651 if( db->nSchemaLock==0 ){
652 for(i=0; i<db->nDb; i++){
653 if( DbHasProperty(db, i, DB_ResetWanted) ){
654 sqlite3SchemaClear(db->aDb[i].pSchema);
655 }
656 }
657 }
drh81028a42012-05-15 18:28:27 +0000658}
659
660/*
661** Erase all schema information from all attached databases (including
662** "main" and "temp") for a single database connection.
663*/
664void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
665 int i;
666 sqlite3BtreeEnterAll(db);
667 for(i=0; i<db->nDb; i++){
668 Db *pDb = &db->aDb[i];
669 if( pDb->pSchema ){
dan63e50b92018-11-27 19:47:55 +0000670 if( db->nSchemaLock==0 ){
671 sqlite3SchemaClear(pDb->pSchema);
672 }else{
673 DbSetProperty(db, i, DB_ResetWanted);
674 }
drh81028a42012-05-15 18:28:27 +0000675 }
676 }
drhb2c85592018-04-25 12:01:45 +0000677 db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
drh81028a42012-05-15 18:28:27 +0000678 sqlite3VtabUnlockList(db);
679 sqlite3BtreeLeaveAll(db);
dan63e50b92018-11-27 19:47:55 +0000680 if( db->nSchemaLock==0 ){
681 sqlite3CollapseDatabaseArray(db);
682 }
drh81028a42012-05-15 18:28:27 +0000683}
684
685/*
drhe0bc4042002-06-25 01:09:11 +0000686** This routine is called when a commit occurs.
687*/
drh9bb575f2004-09-06 17:24:11 +0000688void sqlite3CommitInternalChanges(sqlite3 *db){
drh8257aa82017-07-26 19:59:13 +0000689 db->mDbFlags &= ~DBFLAG_SchemaChange;
drh74e24cd2002-01-09 03:19:59 +0000690}
691
692/*
drh79cf2b72021-07-31 20:30:41 +0000693** Set the expression associated with a column. This is usually
694** the DEFAULT value, but might also be the expression that computes
695** the value for a generated column.
696*/
697void sqlite3ColumnSetExpr(
698 Parse *pParse, /* Parsing context */
699 Table *pTab, /* The table containing the column */
700 Column *pCol, /* The column to receive the new DEFAULT expression */
701 Expr *pExpr /* The new default expression */
702){
drhf38524d2021-08-02 16:41:57 +0000703 ExprList *pList;
drh78b2fa82021-10-07 12:11:20 +0000704 assert( IsOrdinaryTable(pTab) );
drhf38524d2021-08-02 16:41:57 +0000705 pList = pTab->u.tab.pDfltList;
drh79cf2b72021-07-31 20:30:41 +0000706 if( pCol->iDflt==0
drh324f91a2021-08-04 14:50:23 +0000707 || NEVER(pList==0)
708 || NEVER(pList->nExpr<pCol->iDflt)
drh79cf2b72021-07-31 20:30:41 +0000709 ){
710 pCol->iDflt = pList==0 ? 1 : pList->nExpr+1;
drhf38524d2021-08-02 16:41:57 +0000711 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
drh79cf2b72021-07-31 20:30:41 +0000712 }else{
713 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
714 pList->a[pCol->iDflt-1].pExpr = pExpr;
715 }
716}
717
718/*
719** Return the expression associated with a column. The expression might be
720** the DEFAULT clause or the AS clause of a generated column.
721** Return NULL if the column has no associated expression.
722*/
723Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){
724 if( pCol->iDflt==0 ) return 0;
drh78b2fa82021-10-07 12:11:20 +0000725 if( NEVER(!IsOrdinaryTable(pTab)) ) return 0;
drh324f91a2021-08-04 14:50:23 +0000726 if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
727 if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;
drhf38524d2021-08-02 16:41:57 +0000728 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
drh79cf2b72021-07-31 20:30:41 +0000729}
730
731/*
drh65b40092021-08-05 15:27:19 +0000732** Set the collating sequence name for a column.
733*/
734void sqlite3ColumnSetColl(
735 sqlite3 *db,
736 Column *pCol,
737 const char *zColl
738){
drh913306a2021-11-26 17:10:18 +0000739 i64 nColl;
740 i64 n;
drh65b40092021-08-05 15:27:19 +0000741 char *zNew;
742 assert( zColl!=0 );
743 n = sqlite3Strlen30(pCol->zCnName) + 1;
744 if( pCol->colFlags & COLFLAG_HASTYPE ){
745 n += sqlite3Strlen30(pCol->zCnName+n) + 1;
746 }
747 nColl = sqlite3Strlen30(zColl) + 1;
748 zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n);
749 if( zNew ){
750 pCol->zCnName = zNew;
751 memcpy(pCol->zCnName + n, zColl, nColl);
752 pCol->colFlags |= COLFLAG_HASCOLL;
753 }
754}
755
756/*
757** Return the collating squence name for a column
758*/
759const char *sqlite3ColumnColl(Column *pCol){
760 const char *z;
761 if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0;
762 z = pCol->zCnName;
763 while( *z ){ z++; }
764 if( pCol->colFlags & COLFLAG_HASTYPE ){
765 do{ z++; }while( *z );
766 }
767 return z+1;
768}
769
770/*
dand46def72010-07-24 11:28:28 +0000771** Delete memory allocated for the column names of a table or view (the
772** Table.aCol[] array).
drh956bc922004-07-24 17:38:29 +0000773*/
drh51be3872015-08-19 02:32:25 +0000774void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
drh956bc922004-07-24 17:38:29 +0000775 int i;
776 Column *pCol;
777 assert( pTable!=0 );
drh41ce47c2022-08-22 02:00:26 +0000778 assert( db!=0 );
drhdd5b2fa2005-03-28 03:39:55 +0000779 if( (pCol = pTable->aCol)!=0 ){
780 for(i=0; i<pTable->nCol; i++, pCol++){
drhcf9d36d2021-08-02 18:03:43 +0000781 assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) );
782 sqlite3DbFree(db, pCol->zCnName);
drhdd5b2fa2005-03-28 03:39:55 +0000783 }
drh41ce47c2022-08-22 02:00:26 +0000784 sqlite3DbNNFreeNN(db, pTable->aCol);
drh78b2fa82021-10-07 12:11:20 +0000785 if( IsOrdinaryTable(pTable) ){
drhf38524d2021-08-02 16:41:57 +0000786 sqlite3ExprListDelete(db, pTable->u.tab.pDfltList);
787 }
drh41ce47c2022-08-22 02:00:26 +0000788 if( db->pnBytesFreed==0 ){
drh79cf2b72021-07-31 20:30:41 +0000789 pTable->aCol = 0;
790 pTable->nCol = 0;
drh78b2fa82021-10-07 12:11:20 +0000791 if( IsOrdinaryTable(pTable) ){
drhf38524d2021-08-02 16:41:57 +0000792 pTable->u.tab.pDfltList = 0;
793 }
drh79cf2b72021-07-31 20:30:41 +0000794 }
drh956bc922004-07-24 17:38:29 +0000795 }
drh956bc922004-07-24 17:38:29 +0000796}
797
798/*
drh75897232000-05-29 14:26:00 +0000799** Remove the memory data structures associated with the given
drh967e8b72000-06-21 13:59:10 +0000800** Table. No changes are made to disk by this routine.
drh75897232000-05-29 14:26:00 +0000801**
802** This routine just deletes the data structure. It does not unlink
drhe61922a2009-05-02 13:29:37 +0000803** the table data structure from the hash table. But it does destroy
drhc2eef3b2002-08-31 18:53:06 +0000804** memory structures of the indices and foreign keys associated with
805** the table.
drh29ddd3a2012-05-15 12:49:32 +0000806**
807** The db parameter is optional. It is needed if the Table object
808** contains lookaside memory. (Table objects in the schema do not use
809** lookaside memory, but some ephemeral Table objects do.) Or the
810** db parameter can be used with db->pnBytesFreed to measure the memory
811** used by the Table object.
drh75897232000-05-29 14:26:00 +0000812*/
drhe8da01c2016-05-07 12:15:34 +0000813static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
drh75897232000-05-29 14:26:00 +0000814 Index *pIndex, *pNext;
drhc2eef3b2002-08-31 18:53:06 +0000815
drh52fb8e12017-08-29 20:21:12 +0000816#ifdef SQLITE_DEBUG
drh29ddd3a2012-05-15 12:49:32 +0000817 /* Record the number of outstanding lookaside allocations in schema Tables
danbedf84c2019-07-08 13:45:02 +0000818 ** prior to doing any free() operations. Since schema Tables do not use
819 ** lookaside, this number should not change.
820 **
821 ** If malloc has already failed, it may be that it failed while allocating
822 ** a Table object that was going to be marked ephemeral. So do not check
823 ** that no lookaside memory is used in this case either. */
drh52fb8e12017-08-29 20:21:12 +0000824 int nLookaside = 0;
drh41ce47c2022-08-22 02:00:26 +0000825 assert( db!=0 );
826 if( !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){
drh52fb8e12017-08-29 20:21:12 +0000827 nLookaside = sqlite3LookasideUsed(db, 0);
828 }
829#endif
drh29ddd3a2012-05-15 12:49:32 +0000830
dand46def72010-07-24 11:28:28 +0000831 /* Delete all indices associated with this table. */
drhc2eef3b2002-08-31 18:53:06 +0000832 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
833 pNext = pIndex->pNext;
drh62340f82016-05-31 21:18:15 +0000834 assert( pIndex->pSchema==pTable->pSchema
835 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
drh41ce47c2022-08-22 02:00:26 +0000836 if( db->pnBytesFreed==0 && !IsVirtual(pTable) ){
dand46def72010-07-24 11:28:28 +0000837 char *zName = pIndex->zName;
838 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
drhacbcb7e2014-08-21 20:26:37 +0000839 &pIndex->pSchema->idxHash, zName, 0
dand46def72010-07-24 11:28:28 +0000840 );
drh21206082011-04-04 18:22:02 +0000841 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
dand46def72010-07-24 11:28:28 +0000842 assert( pOld==pIndex || pOld==0 );
843 }
dancf8f2892018-08-09 20:47:01 +0000844 sqlite3FreeIndex(db, pIndex);
drhc2eef3b2002-08-31 18:53:06 +0000845 }
846
drhf38524d2021-08-02 16:41:57 +0000847 if( IsOrdinaryTable(pTable) ){
848 sqlite3FkDelete(db, pTable);
849 }
850#ifndef SQLITE_OMIT_VIRTUAL_TABLE
851 else if( IsVirtual(pTable) ){
852 sqlite3VtabClear(db, pTable);
853 }
854#endif
855 else{
856 assert( IsView(pTable) );
857 sqlite3SelectDelete(db, pTable->u.view.pSelect);
858 }
drhc2eef3b2002-08-31 18:53:06 +0000859
860 /* Delete the Table structure itself.
861 */
drh51be3872015-08-19 02:32:25 +0000862 sqlite3DeleteColumnNames(db, pTable);
drh633e6d52008-07-28 19:34:53 +0000863 sqlite3DbFree(db, pTable->zName);
864 sqlite3DbFree(db, pTable->zColAff);
drh2938f922012-03-07 19:13:29 +0000865 sqlite3ExprListDelete(db, pTable->pCheck);
drh633e6d52008-07-28 19:34:53 +0000866 sqlite3DbFree(db, pTable);
drh29ddd3a2012-05-15 12:49:32 +0000867
868 /* Verify that no lookaside memory was used by schema tables */
drh52fb8e12017-08-29 20:21:12 +0000869 assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) );
drh75897232000-05-29 14:26:00 +0000870}
drhe8da01c2016-05-07 12:15:34 +0000871void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
872 /* Do not delete the table until the reference count reaches zero. */
drh41ce47c2022-08-22 02:00:26 +0000873 assert( db!=0 );
drhe8da01c2016-05-07 12:15:34 +0000874 if( !pTable ) return;
drh41ce47c2022-08-22 02:00:26 +0000875 if( db->pnBytesFreed==0 && (--pTable->nTabRef)>0 ) return;
drhe8da01c2016-05-07 12:15:34 +0000876 deleteTable(db, pTable);
877}
878
drh75897232000-05-29 14:26:00 +0000879
880/*
drh5edc3122001-09-13 21:53:09 +0000881** Unlink the given table from the hash tables and the delete the
drhc2eef3b2002-08-31 18:53:06 +0000882** table structure with all its indices and foreign keys.
drh5edc3122001-09-13 21:53:09 +0000883*/
drh9bb575f2004-09-06 17:24:11 +0000884void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
drh956bc922004-07-24 17:38:29 +0000885 Table *p;
drh956bc922004-07-24 17:38:29 +0000886 Db *pDb;
887
drhd229ca92002-01-09 13:30:41 +0000888 assert( db!=0 );
drh956bc922004-07-24 17:38:29 +0000889 assert( iDb>=0 && iDb<db->nDb );
drh972a2312009-12-08 14:34:08 +0000890 assert( zTabName );
drh21206082011-04-04 18:22:02 +0000891 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh972a2312009-12-08 14:34:08 +0000892 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
drh956bc922004-07-24 17:38:29 +0000893 pDb = &db->aDb[iDb];
drhacbcb7e2014-08-21 20:26:37 +0000894 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
dan1feeaed2010-07-23 15:41:47 +0000895 sqlite3DeleteTable(db, p);
drh8257aa82017-07-26 19:59:13 +0000896 db->mDbFlags |= DBFLAG_SchemaChange;
drh74e24cd2002-01-09 03:19:59 +0000897}
898
899/*
drha99db3b2004-06-19 14:49:12 +0000900** Given a token, return a string that consists of the text of that
drh24fb6272009-05-01 21:13:36 +0000901** token. Space to hold the returned string
drha99db3b2004-06-19 14:49:12 +0000902** is obtained from sqliteMalloc() and must be freed by the calling
903** function.
drh75897232000-05-29 14:26:00 +0000904**
drh24fb6272009-05-01 21:13:36 +0000905** Any quotation marks (ex: "name", 'name', [name], or `name`) that
906** surround the body of the token are removed.
907**
drhc96d8532005-05-03 12:30:33 +0000908** Tokens are often just pointers into the original SQL text and so
drha99db3b2004-06-19 14:49:12 +0000909** are not \000 terminated and are not persistent. The returned string
910** is \000 terminated and is persistent.
drh75897232000-05-29 14:26:00 +0000911*/
drhb6dad522021-09-24 16:14:47 +0000912char *sqlite3NameFromToken(sqlite3 *db, const Token *pName){
drha99db3b2004-06-19 14:49:12 +0000913 char *zName;
914 if( pName ){
drhb6dad522021-09-24 16:14:47 +0000915 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
drhb7916a72009-05-27 10:31:29 +0000916 sqlite3Dequote(zName);
drha99db3b2004-06-19 14:49:12 +0000917 }else{
918 zName = 0;
919 }
drh75897232000-05-29 14:26:00 +0000920 return zName;
921}
922
923/*
drh1e32bed2020-06-19 13:33:53 +0000924** Open the sqlite_schema table stored in database number iDb for
danielk1977cbb18d22004-05-28 11:37:27 +0000925** writing. The table is opened using cursor 0.
drhe0bc4042002-06-25 01:09:11 +0000926*/
drh346a70c2020-06-15 20:27:35 +0000927void sqlite3OpenSchemaTable(Parse *p, int iDb){
danielk1977c00da102006-01-07 13:21:04 +0000928 Vdbe *v = sqlite3GetVdbe(p);
drha4a871c2021-11-04 14:04:20 +0000929 sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);
drh346a70c2020-06-15 20:27:35 +0000930 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
danielk19776ab3a2e2009-02-19 14:39:25 +0000931 if( p->nTab==0 ){
932 p->nTab = 1;
933 }
drhe0bc4042002-06-25 01:09:11 +0000934}
935
936/*
danielk197704103022009-02-03 16:51:24 +0000937** Parameter zName points to a nul-terminated buffer containing the name
938** of a database ("main", "temp" or the name of an attached db). This
939** function returns the index of the named database in db->aDb[], or
940** -1 if the named db cannot be found.
danielk1977cbb18d22004-05-28 11:37:27 +0000941*/
danielk197704103022009-02-03 16:51:24 +0000942int sqlite3FindDbName(sqlite3 *db, const char *zName){
943 int i = -1; /* Database number */
drh73c42a12004-11-20 18:13:10 +0000944 if( zName ){
danielk197704103022009-02-03 16:51:24 +0000945 Db *pDb;
danielk1977576ec6b2005-01-21 11:55:25 +0000946 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
drh29518092016-12-24 19:37:16 +0000947 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
948 /* "main" is always an acceptable alias for the primary database
949 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
950 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
danielk1977cbb18d22004-05-28 11:37:27 +0000951 }
952 }
danielk1977576ec6b2005-01-21 11:55:25 +0000953 return i;
danielk1977cbb18d22004-05-28 11:37:27 +0000954}
955
danielk197704103022009-02-03 16:51:24 +0000956/*
957** The token *pName contains the name of a database (either "main" or
958** "temp" or the name of an attached db). This routine returns the
959** index of the named database in db->aDb[], or -1 if the named db
960** does not exist.
961*/
962int sqlite3FindDb(sqlite3 *db, Token *pName){
963 int i; /* Database number */
964 char *zName; /* Name we are searching for */
965 zName = sqlite3NameFromToken(db, pName);
966 i = sqlite3FindDbName(db, zName);
967 sqlite3DbFree(db, zName);
968 return i;
969}
970
drh0e3d7472004-06-19 17:33:07 +0000971/* The table or view or trigger name is passed to this routine via tokens
972** pName1 and pName2. If the table name was fully qualified, for example:
973**
974** CREATE TABLE xxx.yyy (...);
975**
976** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
977** the table name is not fully qualified, i.e.:
978**
979** CREATE TABLE yyy(...);
980**
981** Then pName1 is set to "yyy" and pName2 is "".
982**
983** This routine sets the *ppUnqual pointer to point at the token (pName1 or
984** pName2) that stores the unqualified table name. The index of the
985** database "xxx" is returned.
986*/
danielk1977ef2cb632004-05-29 02:37:19 +0000987int sqlite3TwoPartName(
drh0e3d7472004-06-19 17:33:07 +0000988 Parse *pParse, /* Parsing and code generating context */
drh90f5ecb2004-07-22 01:19:35 +0000989 Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
drh0e3d7472004-06-19 17:33:07 +0000990 Token *pName2, /* The "yyy" in the name "xxx.yyy" */
991 Token **pUnqual /* Write the unqualified object name here */
danielk1977cbb18d22004-05-28 11:37:27 +0000992){
drh0e3d7472004-06-19 17:33:07 +0000993 int iDb; /* Database holding the object */
danielk1977cbb18d22004-05-28 11:37:27 +0000994 sqlite3 *db = pParse->db;
995
drh055f2982016-01-15 15:06:41 +0000996 assert( pName2!=0 );
997 if( pName2->n>0 ){
shanedcc50b72008-11-13 18:29:50 +0000998 if( db->init.busy ) {
999 sqlite3ErrorMsg(pParse, "corrupt database");
shanedcc50b72008-11-13 18:29:50 +00001000 return -1;
1001 }
danielk1977cbb18d22004-05-28 11:37:27 +00001002 *pUnqual = pName2;
drhff2d5ea2005-07-23 00:41:48 +00001003 iDb = sqlite3FindDb(db, pName1);
danielk1977cbb18d22004-05-28 11:37:27 +00001004 if( iDb<0 ){
1005 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
danielk1977cbb18d22004-05-28 11:37:27 +00001006 return -1;
1007 }
1008 }else{
drhd36bcec2021-05-29 21:50:05 +00001009 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
drh8257aa82017-07-26 19:59:13 +00001010 || (db->mDbFlags & DBFLAG_Vacuum)!=0);
danielk1977cbb18d22004-05-28 11:37:27 +00001011 iDb = db->init.iDb;
1012 *pUnqual = pName1;
1013 }
1014 return iDb;
1015}
1016
1017/*
drh0f1c2eb2018-11-03 17:31:48 +00001018** True if PRAGMA writable_schema is ON
1019*/
1020int sqlite3WritableSchema(sqlite3 *db){
1021 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
1022 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
1023 SQLITE_WriteSchema );
1024 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
1025 SQLITE_Defensive );
1026 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
1027 (SQLITE_WriteSchema|SQLITE_Defensive) );
1028 return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
1029}
1030
1031/*
danielk1977d8123362004-06-12 09:25:12 +00001032** This routine is used to check if the UTF-8 string zName is a legal
1033** unqualified name for a new schema object (table, index, view or
1034** trigger). All names are legal except those that begin with the string
1035** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
1036** is reserved for internal use.
drhc5a93d42019-08-12 00:08:07 +00001037**
drh1e32bed2020-06-19 13:33:53 +00001038** When parsing the sqlite_schema table, this routine also checks to
drhc5a93d42019-08-12 00:08:07 +00001039** make sure the "type", "name", and "tbl_name" columns are consistent
1040** with the SQL.
danielk1977d8123362004-06-12 09:25:12 +00001041*/
drhc5a93d42019-08-12 00:08:07 +00001042int sqlite3CheckObjectName(
1043 Parse *pParse, /* Parsing context */
1044 const char *zName, /* Name of the object to check */
1045 const char *zType, /* Type of this object */
1046 const char *zTblName /* Parent table name for triggers and indexes */
1047){
1048 sqlite3 *db = pParse->db;
drhca439a42020-07-22 21:05:23 +00001049 if( sqlite3WritableSchema(db)
1050 || db->init.imposterTable
1051 || !sqlite3Config.bExtraSchemaChecks
1052 ){
drhc5a93d42019-08-12 00:08:07 +00001053 /* Skip these error checks for writable_schema=ON */
1054 return SQLITE_OK;
1055 }
1056 if( db->init.busy ){
1057 if( sqlite3_stricmp(zType, db->init.azInit[0])
1058 || sqlite3_stricmp(zName, db->init.azInit[1])
1059 || sqlite3_stricmp(zTblName, db->init.azInit[2])
1060 ){
drhca439a42020-07-22 21:05:23 +00001061 sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
1062 return SQLITE_ERROR;
drhc5a93d42019-08-12 00:08:07 +00001063 }
1064 }else{
drh527cbd42019-11-16 14:15:19 +00001065 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
1066 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
drhc5a93d42019-08-12 00:08:07 +00001067 ){
1068 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
1069 zName);
1070 return SQLITE_ERROR;
1071 }
drh527cbd42019-11-16 14:15:19 +00001072
danielk1977d8123362004-06-12 09:25:12 +00001073 }
1074 return SQLITE_OK;
1075}
1076
1077/*
drh44156282013-10-23 22:23:03 +00001078** Return the PRIMARY KEY index of a table
1079*/
1080Index *sqlite3PrimaryKeyIndex(Table *pTab){
1081 Index *p;
drh48dd1d82014-05-27 18:18:58 +00001082 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
drh44156282013-10-23 22:23:03 +00001083 return p;
1084}
1085
1086/*
drhb9bcf7c2019-10-19 13:29:10 +00001087** Convert an table column number into a index column number. That is,
1088** for the column iCol in the table (as defined by the CREATE TABLE statement)
1089** find the (first) offset of that column in index pIdx. Or return -1
1090** if column iCol is not used in index pIdx.
drh44156282013-10-23 22:23:03 +00001091*/
drhb9bcf7c2019-10-19 13:29:10 +00001092i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
drh44156282013-10-23 22:23:03 +00001093 int i;
1094 for(i=0; i<pIdx->nColumn; i++){
1095 if( iCol==pIdx->aiColumn[i] ) return i;
1096 }
1097 return -1;
1098}
1099
drh81f7b372019-10-16 12:18:59 +00001100#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drhb9bcf7c2019-10-19 13:29:10 +00001101/* Convert a storage column number into a table column number.
drh81f7b372019-10-16 12:18:59 +00001102**
drh8e10d742019-10-18 17:42:47 +00001103** The storage column number (0,1,2,....) is the index of the value
1104** as it appears in the record on disk. The true column number
1105** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
1106**
drhb9bcf7c2019-10-19 13:29:10 +00001107** The storage column number is less than the table column number if
1108** and only there are VIRTUAL columns to the left.
drh8e10d742019-10-18 17:42:47 +00001109**
1110** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
drh8e10d742019-10-18 17:42:47 +00001111*/
drhb9bcf7c2019-10-19 13:29:10 +00001112i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
drh8e10d742019-10-18 17:42:47 +00001113 if( pTab->tabFlags & TF_HasVirtual ){
1114 int i;
1115 for(i=0; i<=iCol; i++){
1116 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
1117 }
1118 }
1119 return iCol;
1120}
1121#endif
1122
1123#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drhb9bcf7c2019-10-19 13:29:10 +00001124/* Convert a table column number into a storage column number.
drh8e10d742019-10-18 17:42:47 +00001125**
1126** The storage column number (0,1,2,....) is the index of the value
drhdd6cc9b2019-10-19 18:47:27 +00001127** as it appears in the record on disk. Or, if the input column is
1128** the N-th virtual column (zero-based) then the storage number is
1129** the number of non-virtual columns in the table plus N.
drh8e10d742019-10-18 17:42:47 +00001130**
drhdd6cc9b2019-10-19 18:47:27 +00001131** The true column number is the index (0,1,2,...) of the column in
1132** the CREATE TABLE statement.
drh8e10d742019-10-18 17:42:47 +00001133**
drhdd6cc9b2019-10-19 18:47:27 +00001134** If the input column is a VIRTUAL column, then it should not appear
1135** in storage. But the value sometimes is cached in registers that
1136** follow the range of registers used to construct storage. This
1137** avoids computing the same VIRTUAL column multiple times, and provides
1138** values for use by OP_Param opcodes in triggers. Hence, if the
1139** input column is a VIRTUAL table, put it after all the other columns.
1140**
1141** In the following, N means "normal column", S means STORED, and
1142** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
1143**
1144** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
1145** -- 0 1 2 3 4 5 6 7 8
1146**
1147** Then the mapping from this function is as follows:
1148**
1149** INPUTS: 0 1 2 3 4 5 6 7 8
1150** OUTPUTS: 0 1 6 2 3 7 4 5 8
1151**
1152** So, in other words, this routine shifts all the virtual columns to
1153** the end.
1154**
1155** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and
drh7fe2fc02019-12-07 00:22:18 +00001156** this routine is a no-op macro. If the pTab does not have any virtual
1157** columns, then this routine is no-op that always return iCol. If iCol
1158** is negative (indicating the ROWID column) then this routine return iCol.
drh81f7b372019-10-16 12:18:59 +00001159*/
drhb9bcf7c2019-10-19 13:29:10 +00001160i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
drh81f7b372019-10-16 12:18:59 +00001161 int i;
1162 i16 n;
1163 assert( iCol<pTab->nCol );
drh7fe2fc02019-12-07 00:22:18 +00001164 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
drh81f7b372019-10-16 12:18:59 +00001165 for(i=0, n=0; i<iCol; i++){
1166 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
1167 }
drhdd6cc9b2019-10-19 18:47:27 +00001168 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
1169 /* iCol is a virtual column itself */
1170 return pTab->nNVCol + i - n;
1171 }else{
1172 /* iCol is a normal or stored column */
1173 return n;
1174 }
drh81f7b372019-10-16 12:18:59 +00001175}
1176#endif
1177
drh44156282013-10-23 22:23:03 +00001178/*
drh31da7be2021-05-13 18:24:22 +00001179** Insert a single OP_JournalMode query opcode in order to force the
1180** prepared statement to return false for sqlite3_stmt_readonly(). This
1181** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
1182** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
1183** will return false for sqlite3_stmt_readonly() even if that statement
1184** is a read-only no-op.
1185*/
1186static void sqlite3ForceNotReadOnly(Parse *pParse){
1187 int iReg = ++pParse->nMem;
1188 Vdbe *v = sqlite3GetVdbe(pParse);
1189 if( v ){
1190 sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
dana8f249f2021-05-20 11:42:51 +00001191 sqlite3VdbeUsesBtree(v, 0);
drh31da7be2021-05-13 18:24:22 +00001192 }
1193}
1194
1195/*
drh75897232000-05-29 14:26:00 +00001196** Begin constructing a new table representation in memory. This is
1197** the first of several action routines that get called in response
drhd9b02572001-04-15 00:37:09 +00001198** to a CREATE TABLE statement. In particular, this routine is called
drh74161702006-02-24 02:53:49 +00001199** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
drhe0bc4042002-06-25 01:09:11 +00001200** flag is true if the table should be stored in the auxiliary database
1201** file instead of in the main database file. This is normally the case
1202** when the "TEMP" or "TEMPORARY" keyword occurs in between
drhf57b3392001-10-08 13:22:32 +00001203** CREATE and TABLE.
drhd9b02572001-04-15 00:37:09 +00001204**
drhf57b3392001-10-08 13:22:32 +00001205** The new table record is initialized and put in pParse->pNewTable.
1206** As more of the CREATE TABLE statement is parsed, additional action
1207** routines will be called to add more information to this record.
danielk19774adee202004-05-08 08:23:19 +00001208** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
drhf57b3392001-10-08 13:22:32 +00001209** is called to complete the construction of the new table record.
drh75897232000-05-29 14:26:00 +00001210*/
danielk19774adee202004-05-08 08:23:19 +00001211void sqlite3StartTable(
drhe5f9c642003-01-13 23:27:31 +00001212 Parse *pParse, /* Parser context */
danielk1977cbb18d22004-05-28 11:37:27 +00001213 Token *pName1, /* First part of the name of the table or view */
1214 Token *pName2, /* Second part of the name of the table or view */
drhe5f9c642003-01-13 23:27:31 +00001215 int isTemp, /* True if this is a TEMP table */
drhfaa59552005-12-29 23:33:54 +00001216 int isView, /* True if this is a VIEW */
danielk1977f1a381e2006-06-16 08:01:02 +00001217 int isVirtual, /* True if this is a VIRTUAL table */
drhfaa59552005-12-29 23:33:54 +00001218 int noErr /* Do nothing if table already exists */
drhe5f9c642003-01-13 23:27:31 +00001219){
drh75897232000-05-29 14:26:00 +00001220 Table *pTable;
drh23bf66d2004-12-14 03:34:34 +00001221 char *zName = 0; /* The name of the new table */
drh9bb575f2004-09-06 17:24:11 +00001222 sqlite3 *db = pParse->db;
drhadbca9c2001-09-27 15:11:53 +00001223 Vdbe *v;
danielk1977cbb18d22004-05-28 11:37:27 +00001224 int iDb; /* Database number to create the table in */
1225 Token *pName; /* Unqualified name of the table to create */
drh75897232000-05-29 14:26:00 +00001226
drh055f2982016-01-15 15:06:41 +00001227 if( db->init.busy && db->init.newTnum==1 ){
drh1e32bed2020-06-19 13:33:53 +00001228 /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */
drh055f2982016-01-15 15:06:41 +00001229 iDb = db->init.iDb;
1230 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
1231 pName = pName1;
1232 }else{
1233 /* The common case */
1234 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
1235 if( iDb<0 ) return;
1236 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
1237 /* If creating a temp table, the name may not be qualified. Unless
1238 ** the database name is "temp" anyway. */
1239 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
1240 return;
1241 }
1242 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
1243 zName = sqlite3NameFromToken(db, pName);
danc9461ec2018-08-29 21:00:16 +00001244 if( IN_RENAME_OBJECT ){
1245 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
1246 }
danielk1977cbb18d22004-05-28 11:37:27 +00001247 }
danielk1977cbb18d22004-05-28 11:37:27 +00001248 pParse->sNameToken = *pName;
danielk1977e0048402004-06-15 16:51:01 +00001249 if( zName==0 ) return;
drhc5a93d42019-08-12 00:08:07 +00001250 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
drh23bf66d2004-12-14 03:34:34 +00001251 goto begin_table_error;
danielk1977d8123362004-06-12 09:25:12 +00001252 }
drh1d85d932004-02-14 23:05:52 +00001253 if( db->init.iDb==1 ) isTemp = 1;
drhe5f9c642003-01-13 23:27:31 +00001254#ifndef SQLITE_OMIT_AUTHORIZATION
drh055f2982016-01-15 15:06:41 +00001255 assert( isTemp==0 || isTemp==1 );
1256 assert( isView==0 || isView==1 );
drhe5f9c642003-01-13 23:27:31 +00001257 {
drh055f2982016-01-15 15:06:41 +00001258 static const u8 aCode[] = {
1259 SQLITE_CREATE_TABLE,
1260 SQLITE_CREATE_TEMP_TABLE,
1261 SQLITE_CREATE_VIEW,
1262 SQLITE_CREATE_TEMP_VIEW
1263 };
drh69c33822016-08-18 14:33:11 +00001264 char *zDb = db->aDb[iDb].zDbSName;
danielk19774adee202004-05-08 08:23:19 +00001265 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +00001266 goto begin_table_error;
drhe22a3342003-04-22 20:30:37 +00001267 }
drh055f2982016-01-15 15:06:41 +00001268 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
1269 zName, 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +00001270 goto begin_table_error;
drhe5f9c642003-01-13 23:27:31 +00001271 }
1272 }
1273#endif
drhf57b3392001-10-08 13:22:32 +00001274
drhf57b3392001-10-08 13:22:32 +00001275 /* Make sure the new table name does not collide with an existing
danielk19773df6b252004-05-29 10:23:19 +00001276 ** index or table name in the same database. Issue an error message if
danielk19777e6ebfb2006-06-12 11:24:37 +00001277 ** it does. The exception is if the statement being parsed was passed
1278 ** to an sqlite3_declare_vtab() call. In that case only the column names
1279 ** and types will be used, so there is no need to test for namespace
1280 ** collisions.
drhf57b3392001-10-08 13:22:32 +00001281 */
dancf8f2892018-08-09 20:47:01 +00001282 if( !IN_SPECIAL_PARSE ){
drh69c33822016-08-18 14:33:11 +00001283 char *zDb = db->aDb[iDb].zDbSName;
danielk19777e6ebfb2006-06-12 11:24:37 +00001284 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
1285 goto begin_table_error;
drhfaa59552005-12-29 23:33:54 +00001286 }
dana16d1062010-09-28 17:37:28 +00001287 pTable = sqlite3FindTable(db, zName, zDb);
danielk19777e6ebfb2006-06-12 11:24:37 +00001288 if( pTable ){
1289 if( !noErr ){
larrybr6e85b272022-02-07 01:09:49 +00001290 sqlite3ErrorMsg(pParse, "%s %T already exists",
1291 (IsView(pTable)? "view" : "table"), pName);
dan7687c832011-04-09 15:39:02 +00001292 }else{
drh33c59ec2015-04-19 20:39:17 +00001293 assert( !db->init.busy || CORRUPT_DB );
dan7687c832011-04-09 15:39:02 +00001294 sqlite3CodeVerifySchema(pParse, iDb);
drh31da7be2021-05-13 18:24:22 +00001295 sqlite3ForceNotReadOnly(pParse);
danielk19777e6ebfb2006-06-12 11:24:37 +00001296 }
1297 goto begin_table_error;
1298 }
drh8a8a0d12010-09-28 20:26:44 +00001299 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
danielk19777e6ebfb2006-06-12 11:24:37 +00001300 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
1301 goto begin_table_error;
1302 }
drh75897232000-05-29 14:26:00 +00001303 }
danielk19777e6ebfb2006-06-12 11:24:37 +00001304
danielk197726783a52007-08-29 14:06:22 +00001305 pTable = sqlite3DbMallocZero(db, sizeof(Table));
drh6d4abfb2001-10-22 02:58:08 +00001306 if( pTable==0 ){
drh4df86af2016-02-04 11:48:00 +00001307 assert( db->mallocFailed );
mistachkinfad30392016-02-13 23:43:46 +00001308 pParse->rc = SQLITE_NOMEM_BKPT;
danielk1977e0048402004-06-15 16:51:01 +00001309 pParse->nErr++;
drh23bf66d2004-12-14 03:34:34 +00001310 goto begin_table_error;
drh6d4abfb2001-10-22 02:58:08 +00001311 }
drh75897232000-05-29 14:26:00 +00001312 pTable->zName = zName;
drh4a324312001-12-21 14:30:42 +00001313 pTable->iPKey = -1;
danielk1977da184232006-01-05 11:34:32 +00001314 pTable->pSchema = db->aDb[iDb].pSchema;
drh79df7782016-12-14 14:07:35 +00001315 pTable->nTabRef = 1;
drhd1417ee2017-06-06 18:20:43 +00001316#ifdef SQLITE_DEFAULT_ROWEST
1317 pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
1318#else
dancfc9df72014-04-25 15:01:01 +00001319 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drhd1417ee2017-06-06 18:20:43 +00001320#endif
drhc4a64fa2009-05-11 20:53:28 +00001321 assert( pParse->pNewTable==0 );
drh75897232000-05-29 14:26:00 +00001322 pParse->pNewTable = pTable;
drh17f71932002-02-21 12:01:27 +00001323
1324 /* Begin generating the code that will insert the table record into
drh346a70c2020-06-15 20:27:35 +00001325 ** the schema table. Note in particular that we must go ahead
drh17f71932002-02-21 12:01:27 +00001326 ** and allocate the record number for the table entry now. Before any
1327 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
1328 ** indices to be created and the table record must come before the
1329 ** indices. Hence, the record number for the table must be allocated
1330 ** now.
1331 */
danielk19774adee202004-05-08 08:23:19 +00001332 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
drh728e0f92015-10-10 14:41:28 +00001333 int addr1;
drhe321c292006-01-12 01:56:43 +00001334 int fileFormat;
drhb7654112008-01-12 12:48:07 +00001335 int reg1, reg2, reg3;
drh3c03afd2015-09-09 13:28:06 +00001336 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
1337 static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
drh0dd5cda2015-06-16 16:39:01 +00001338 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00001339
danielk197720b1eaf2006-07-26 16:22:14 +00001340#ifndef SQLITE_OMIT_VIRTUALTABLE
1341 if( isVirtual ){
drh66a51672008-01-03 00:01:23 +00001342 sqlite3VdbeAddOp0(v, OP_VBegin);
danielk197720b1eaf2006-07-26 16:22:14 +00001343 }
1344#endif
1345
danielk197736963fd2005-02-19 08:18:05 +00001346 /* If the file format and encoding in the database have not been set,
1347 ** set them now.
danielk1977d008cfe2004-06-19 02:22:10 +00001348 */
drhb7654112008-01-12 12:48:07 +00001349 reg1 = pParse->regRowid = ++pParse->nMem;
1350 reg2 = pParse->regRoot = ++pParse->nMem;
1351 reg3 = ++pParse->nMem;
danielk19770d19f7a2009-06-03 11:25:07 +00001352 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
drhfb982642007-08-30 01:19:59 +00001353 sqlite3VdbeUsesBtree(v, iDb);
drh728e0f92015-10-10 14:41:28 +00001354 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
drhe321c292006-01-12 01:56:43 +00001355 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
drh76fe8032006-07-11 14:17:51 +00001356 1 : SQLITE_MAX_FILE_FORMAT;
drh1861afc2016-02-01 21:48:34 +00001357 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
1358 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
drh728e0f92015-10-10 14:41:28 +00001359 sqlite3VdbeJumpHere(v, addr1);
danielk1977d008cfe2004-06-19 02:22:10 +00001360
drh1e32bed2020-06-19 13:33:53 +00001361 /* This just creates a place-holder record in the sqlite_schema table.
drh4794f732004-11-05 17:17:50 +00001362 ** The record created does not contain anything yet. It will be replaced
1363 ** by the real entry in code generated at sqlite3EndTable().
drhb17131a2004-11-05 22:18:49 +00001364 **
drh0fa991b2009-03-21 16:19:26 +00001365 ** The rowid for the new entry is left in register pParse->regRowid.
1366 ** The root page number of the new table is left in reg pParse->regRoot.
1367 ** The rowid and root page number values are needed by the code that
1368 ** sqlite3EndTable will generate.
drh4794f732004-11-05 17:17:50 +00001369 */
danielk1977f1a381e2006-06-16 08:01:02 +00001370#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1371 if( isView || isVirtual ){
drhb7654112008-01-12 12:48:07 +00001372 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
danielk1977a21c6b62005-01-24 10:25:59 +00001373 }else
1374#endif
1375 {
drh381bdac2021-02-04 17:29:04 +00001376 assert( !pParse->bReturning );
1377 pParse->u1.addrCrTab =
drh0f3f7662017-08-18 14:34:28 +00001378 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
danielk1977a21c6b62005-01-24 10:25:59 +00001379 }
drh346a70c2020-06-15 20:27:35 +00001380 sqlite3OpenSchemaTable(pParse, iDb);
drhb7654112008-01-12 12:48:07 +00001381 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
drh3c03afd2015-09-09 13:28:06 +00001382 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
drhb7654112008-01-12 12:48:07 +00001383 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
1384 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drh66a51672008-01-03 00:01:23 +00001385 sqlite3VdbeAddOp0(v, OP_Close);
drh5e00f6c2001-09-13 13:46:56 +00001386 }
drh23bf66d2004-12-14 03:34:34 +00001387
1388 /* Normal (non-error) return. */
1389 return;
1390
1391 /* If an error occurs, we jump here */
1392begin_table_error:
drhc0495e82021-07-22 21:11:06 +00001393 pParse->checkSchema = 1;
drh633e6d52008-07-28 19:34:53 +00001394 sqlite3DbFree(db, zName);
drh23bf66d2004-12-14 03:34:34 +00001395 return;
drh75897232000-05-29 14:26:00 +00001396}
1397
drh03d69a62015-11-19 13:53:57 +00001398/* Set properties of a table column based on the (magical)
1399** name of the column.
1400*/
drh03d69a62015-11-19 13:53:57 +00001401#if SQLITE_ENABLE_HIDDEN_COLUMNS
drhe6110502015-12-31 15:34:03 +00001402void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
drhcf9d36d2021-08-02 18:03:43 +00001403 if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){
drh03d69a62015-11-19 13:53:57 +00001404 pCol->colFlags |= COLFLAG_HIDDEN;
drh6f6e60d2021-02-18 15:45:34 +00001405 if( pTab ) pTab->tabFlags |= TF_HasHidden;
danba68f8f2015-11-19 16:46:46 +00001406 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
1407 pTab->tabFlags |= TF_OOOHidden;
drh03d69a62015-11-19 13:53:57 +00001408 }
drh03d69a62015-11-19 13:53:57 +00001409}
drhe6110502015-12-31 15:34:03 +00001410#endif
drh03d69a62015-11-19 13:53:57 +00001411
drh2053f312021-01-12 20:16:31 +00001412/*
drh28828c52021-01-30 21:55:38 +00001413** Name of the special TEMP trigger used to implement RETURNING. The
1414** name begins with "sqlite_" so that it is guaranteed not to collide
1415** with any application-generated triggers.
drhb8352472021-01-29 19:32:17 +00001416*/
drh28828c52021-01-30 21:55:38 +00001417#define RETURNING_TRIGGER_NAME "sqlite_returning"
drhb8352472021-01-29 19:32:17 +00001418
1419/*
drh28828c52021-01-30 21:55:38 +00001420** Clean up the data structures associated with the RETURNING clause.
drhb8352472021-01-29 19:32:17 +00001421*/
1422static void sqlite3DeleteReturning(sqlite3 *db, Returning *pRet){
1423 Hash *pHash;
1424 pHash = &(db->aDb[1].pSchema->trigHash);
drh28828c52021-01-30 21:55:38 +00001425 sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, 0);
drhb8352472021-01-29 19:32:17 +00001426 sqlite3ExprListDelete(db, pRet->pReturnEL);
1427 sqlite3DbFree(db, pRet);
1428}
1429
1430/*
drh28828c52021-01-30 21:55:38 +00001431** Add the RETURNING clause to the parse currently underway.
1432**
1433** This routine creates a special TEMP trigger that will fire for each row
1434** of the DML statement. That TEMP trigger contains a single SELECT
1435** statement with a result set that is the argument of the RETURNING clause.
1436** The trigger has the Trigger.bReturning flag and an opcode of
1437** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
1438** knows to handle it specially. The TEMP trigger is automatically
1439** removed at the end of the parse.
1440**
1441** When this routine is called, we do not yet know if the RETURNING clause
1442** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
1443** RETURNING trigger instead. It will then be converted into the appropriate
1444** type on the first call to sqlite3TriggersExist().
drh2053f312021-01-12 20:16:31 +00001445*/
1446void sqlite3AddReturning(Parse *pParse, ExprList *pList){
drhb8352472021-01-29 19:32:17 +00001447 Returning *pRet;
1448 Hash *pHash;
1449 sqlite3 *db = pParse->db;
drhe1c9a4e2021-02-07 23:28:20 +00001450 if( pParse->pNewTrigger ){
1451 sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger");
1452 }else{
1453 assert( pParse->bReturning==0 );
1454 }
drhd086aa02021-01-29 21:31:59 +00001455 pParse->bReturning = 1;
drhb8352472021-01-29 19:32:17 +00001456 pRet = sqlite3DbMallocZero(db, sizeof(*pRet));
1457 if( pRet==0 ){
1458 sqlite3ExprListDelete(db, pList);
1459 return;
1460 }
drh381bdac2021-02-04 17:29:04 +00001461 pParse->u1.pReturning = pRet;
drhb8352472021-01-29 19:32:17 +00001462 pRet->pParse = pParse;
1463 pRet->pReturnEL = pList;
drh2053f312021-01-12 20:16:31 +00001464 sqlite3ParserAddCleanup(pParse,
drhb8352472021-01-29 19:32:17 +00001465 (void(*)(sqlite3*,void*))sqlite3DeleteReturning, pRet);
drh6d0053c2021-03-09 19:32:37 +00001466 testcase( pParse->earlyCleanup );
drhcf4108b2021-01-30 03:06:19 +00001467 if( db->mallocFailed ) return;
drh28828c52021-01-30 21:55:38 +00001468 pRet->retTrig.zName = RETURNING_TRIGGER_NAME;
drhb8352472021-01-29 19:32:17 +00001469 pRet->retTrig.op = TK_RETURNING;
1470 pRet->retTrig.tr_tm = TRIGGER_AFTER;
1471 pRet->retTrig.bReturning = 1;
1472 pRet->retTrig.pSchema = db->aDb[1].pSchema;
drha4767682021-04-27 13:04:18 +00001473 pRet->retTrig.pTabSchema = db->aDb[1].pSchema;
drhb8352472021-01-29 19:32:17 +00001474 pRet->retTrig.step_list = &pRet->retTStep;
drhdac9a5f2021-01-29 21:18:46 +00001475 pRet->retTStep.op = TK_RETURNING;
drhb8352472021-01-29 19:32:17 +00001476 pRet->retTStep.pTrig = &pRet->retTrig;
drh381bdac2021-02-04 17:29:04 +00001477 pRet->retTStep.pExprList = pList;
drhb8352472021-01-29 19:32:17 +00001478 pHash = &(db->aDb[1].pSchema->trigHash);
drhe1c9a4e2021-02-07 23:28:20 +00001479 assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 || pParse->nErr );
drh28828c52021-01-30 21:55:38 +00001480 if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig)
drh0166df02021-01-30 12:07:32 +00001481 ==&pRet->retTrig ){
1482 sqlite3OomFault(db);
1483 }
drh2053f312021-01-12 20:16:31 +00001484}
drh03d69a62015-11-19 13:53:57 +00001485
drh75897232000-05-29 14:26:00 +00001486/*
1487** Add a new column to the table currently being constructed.
drhd9b02572001-04-15 00:37:09 +00001488**
1489** The parser calls this routine once for each column declaration
danielk19774adee202004-05-08 08:23:19 +00001490** in a CREATE TABLE statement. sqlite3StartTable() gets called
drhd9b02572001-04-15 00:37:09 +00001491** first to get things going. Then this routine is called for each
1492** column.
drh75897232000-05-29 14:26:00 +00001493*/
drh77441fa2021-07-30 18:39:59 +00001494void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
drh75897232000-05-29 14:26:00 +00001495 Table *p;
drh97fc3d02002-05-22 21:27:03 +00001496 int i;
drha99db3b2004-06-19 14:49:12 +00001497 char *z;
drh94eaafa2016-02-29 15:53:11 +00001498 char *zType;
drhc9b84a12002-06-20 11:36:48 +00001499 Column *pCol;
drhbb4957f2008-03-20 14:03:29 +00001500 sqlite3 *db = pParse->db;
drh3e992d12021-01-01 19:17:01 +00001501 u8 hName;
drh7b3c5142021-07-30 12:47:35 +00001502 Column *aNew;
drhc2df4d62021-07-30 23:30:30 +00001503 u8 eType = COLTYPE_CUSTOM;
1504 u8 szEst = 1;
1505 char affinity = SQLITE_AFF_BLOB;
drh3e992d12021-01-01 19:17:01 +00001506
drh75897232000-05-29 14:26:00 +00001507 if( (p = pParse->pNewTable)==0 ) return;
drhbb4957f2008-03-20 14:03:29 +00001508 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drhe5c941b2007-05-08 13:58:26 +00001509 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
1510 return;
1511 }
drh77441fa2021-07-30 18:39:59 +00001512 if( !IN_RENAME_OBJECT ) sqlite3DequoteToken(&sName);
drhe48f2612021-07-30 20:09:08 +00001513
1514 /* Because keywords GENERATE ALWAYS can be converted into indentifiers
1515 ** by the parser, we can sometimes end up with a typename that ends
1516 ** with "generated always". Check for this case and omit the surplus
1517 ** text. */
1518 if( sType.n>=16
1519 && sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0
1520 ){
1521 sType.n -= 6;
1522 while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
1523 if( sType.n>=9
1524 && sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0
1525 ){
1526 sType.n -= 9;
1527 while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
1528 }
1529 }
1530
drhc2df4d62021-07-30 23:30:30 +00001531 /* Check for standard typenames. For standard typenames we will
1532 ** set the Column.eType field rather than storing the typename after
1533 ** the column name, in order to save space. */
1534 if( sType.n>=3 ){
1535 sqlite3DequoteToken(&sType);
1536 for(i=0; i<SQLITE_N_STDTYPE; i++){
1537 if( sType.n==sqlite3StdTypeLen[i]
1538 && sqlite3_strnicmp(sType.z, sqlite3StdType[i], sType.n)==0
1539 ){
1540 sType.n = 0;
1541 eType = i+1;
1542 affinity = sqlite3StdTypeAffinity[i];
1543 if( affinity<=SQLITE_AFF_TEXT ) szEst = 5;
1544 break;
1545 }
1546 }
1547 }
1548
drh913306a2021-11-26 17:10:18 +00001549 z = sqlite3DbMallocRaw(db, (i64)sName.n + 1 + (i64)sType.n + (sType.n>0) );
drh97fc3d02002-05-22 21:27:03 +00001550 if( z==0 ) return;
drh77441fa2021-07-30 18:39:59 +00001551 if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName);
1552 memcpy(z, sName.z, sName.n);
1553 z[sName.n] = 0;
drh94eaafa2016-02-29 15:53:11 +00001554 sqlite3Dequote(z);
drh3e992d12021-01-01 19:17:01 +00001555 hName = sqlite3StrIHash(z);
drh97fc3d02002-05-22 21:27:03 +00001556 for(i=0; i<p->nCol; i++){
drhcf9d36d2021-08-02 18:03:43 +00001557 if( p->aCol[i].hName==hName && sqlite3StrICmp(z, p->aCol[i].zCnName)==0 ){
danielk19774adee202004-05-08 08:23:19 +00001558 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
drh633e6d52008-07-28 19:34:53 +00001559 sqlite3DbFree(db, z);
drh97fc3d02002-05-22 21:27:03 +00001560 return;
1561 }
1562 }
drh913306a2021-11-26 17:10:18 +00001563 aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
drh7b3c5142021-07-30 12:47:35 +00001564 if( aNew==0 ){
1565 sqlite3DbFree(db, z);
1566 return;
drh75897232000-05-29 14:26:00 +00001567 }
drh7b3c5142021-07-30 12:47:35 +00001568 p->aCol = aNew;
drhc9b84a12002-06-20 11:36:48 +00001569 pCol = &p->aCol[p->nCol];
1570 memset(pCol, 0, sizeof(p->aCol[0]));
drhcf9d36d2021-08-02 18:03:43 +00001571 pCol->zCnName = z;
drh3e992d12021-01-01 19:17:01 +00001572 pCol->hName = hName;
danba68f8f2015-11-19 16:46:46 +00001573 sqlite3ColumnPropertiesFromName(p, pCol);
danielk1977a37cdde2004-05-16 11:15:36 +00001574
drh77441fa2021-07-30 18:39:59 +00001575 if( sType.n==0 ){
drh2881ab62016-02-27 23:25:36 +00001576 /* If there is no type specified, columns have the default affinity
drhbbade8d2018-04-18 14:48:08 +00001577 ** 'BLOB' with a default size of 4 bytes. */
drhc2df4d62021-07-30 23:30:30 +00001578 pCol->affinity = affinity;
drhb70f2ea2021-08-18 12:05:22 +00001579 pCol->eCType = eType;
drhc2df4d62021-07-30 23:30:30 +00001580 pCol->szEst = szEst;
drhbbade8d2018-04-18 14:48:08 +00001581#ifdef SQLITE_ENABLE_SORTER_REFERENCES
drhc2df4d62021-07-30 23:30:30 +00001582 if( affinity==SQLITE_AFF_BLOB ){
1583 if( 4>=sqlite3GlobalConfig.szSorterRef ){
1584 pCol->colFlags |= COLFLAG_SORTERREF;
1585 }
dan2e3a5a82018-04-16 21:12:42 +00001586 }
drhbbade8d2018-04-18 14:48:08 +00001587#endif
drh2881ab62016-02-27 23:25:36 +00001588 }else{
drhddb2b4a2016-03-25 12:10:32 +00001589 zType = z + sqlite3Strlen30(z) + 1;
drh77441fa2021-07-30 18:39:59 +00001590 memcpy(zType, sType.z, sType.n);
1591 zType[sType.n] = 0;
drha6dddd92016-04-18 15:46:14 +00001592 sqlite3Dequote(zType);
dan2e3a5a82018-04-16 21:12:42 +00001593 pCol->affinity = sqlite3AffinityType(zType, pCol);
drhd7564862016-03-22 20:05:09 +00001594 pCol->colFlags |= COLFLAG_HASTYPE;
drh2881ab62016-02-27 23:25:36 +00001595 }
drhc9b84a12002-06-20 11:36:48 +00001596 p->nCol++;
drhf95909c2019-10-18 18:33:25 +00001597 p->nNVCol++;
drh986dde72016-02-29 13:37:21 +00001598 pParse->constraintName.n = 0;
drh75897232000-05-29 14:26:00 +00001599}
1600
1601/*
drh382c0242001-10-06 16:33:02 +00001602** This routine is called by the parser while in the middle of
1603** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1604** been seen on a column. This routine sets the notNull flag on
1605** the column currently under construction.
1606*/
danielk19774adee202004-05-08 08:23:19 +00001607void sqlite3AddNotNull(Parse *pParse, int onError){
drh382c0242001-10-06 16:33:02 +00001608 Table *p;
dan26e731c2018-01-29 16:22:39 +00001609 Column *pCol;
drhc4a64fa2009-05-11 20:53:28 +00001610 p = pParse->pNewTable;
1611 if( p==0 || NEVER(p->nCol<1) ) return;
dan26e731c2018-01-29 16:22:39 +00001612 pCol = &p->aCol[p->nCol-1];
1613 pCol->notNull = (u8)onError;
drh8b174f22017-02-22 15:11:36 +00001614 p->tabFlags |= TF_HasNotNull;
dan26e731c2018-01-29 16:22:39 +00001615
1616 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
1617 ** on this column. */
1618 if( pCol->colFlags & COLFLAG_UNIQUE ){
1619 Index *pIdx;
1620 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
1621 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
1622 if( pIdx->aiColumn[0]==p->nCol-1 ){
1623 pIdx->uniqNotNull = 1;
1624 }
1625 }
1626 }
drh382c0242001-10-06 16:33:02 +00001627}
1628
1629/*
danielk197752a83fb2005-01-31 12:56:44 +00001630** Scan the column type name zType (length nType) and return the
1631** associated affinity type.
danielk1977b3dff962005-02-01 01:21:55 +00001632**
1633** This routine does a case-independent search of zType for the
1634** substrings in the following table. If one of the substrings is
1635** found, the corresponding affinity is returned. If zType contains
1636** more than one of the substrings, entries toward the top of
1637** the table take priority. For example, if zType is 'BLOBINT',
drh8a512562005-11-14 22:29:05 +00001638** SQLITE_AFF_INTEGER is returned.
danielk1977b3dff962005-02-01 01:21:55 +00001639**
1640** Substring | Affinity
1641** --------------------------------
1642** 'INT' | SQLITE_AFF_INTEGER
1643** 'CHAR' | SQLITE_AFF_TEXT
1644** 'CLOB' | SQLITE_AFF_TEXT
1645** 'TEXT' | SQLITE_AFF_TEXT
drh05883a32015-06-02 15:32:08 +00001646** 'BLOB' | SQLITE_AFF_BLOB
drh8a512562005-11-14 22:29:05 +00001647** 'REAL' | SQLITE_AFF_REAL
1648** 'FLOA' | SQLITE_AFF_REAL
1649** 'DOUB' | SQLITE_AFF_REAL
danielk1977b3dff962005-02-01 01:21:55 +00001650**
1651** If none of the substrings in the above table are found,
1652** SQLITE_AFF_NUMERIC is returned.
danielk197752a83fb2005-01-31 12:56:44 +00001653*/
dan2e3a5a82018-04-16 21:12:42 +00001654char sqlite3AffinityType(const char *zIn, Column *pCol){
danielk1977b3dff962005-02-01 01:21:55 +00001655 u32 h = 0;
1656 char aff = SQLITE_AFF_NUMERIC;
drhd3037a42013-10-04 18:29:25 +00001657 const char *zChar = 0;
danielk197752a83fb2005-01-31 12:56:44 +00001658
drh2f1e02e2016-03-09 02:12:44 +00001659 assert( zIn!=0 );
drhfdaac672013-10-04 15:30:21 +00001660 while( zIn[0] ){
drhb7916a72009-05-27 10:31:29 +00001661 h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
danielk1977b3dff962005-02-01 01:21:55 +00001662 zIn++;
danielk1977201f7162005-02-01 02:13:29 +00001663 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
drhfdaac672013-10-04 15:30:21 +00001664 aff = SQLITE_AFF_TEXT;
1665 zChar = zIn;
danielk1977201f7162005-02-01 02:13:29 +00001666 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
1667 aff = SQLITE_AFF_TEXT;
1668 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
1669 aff = SQLITE_AFF_TEXT;
1670 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
drh8a512562005-11-14 22:29:05 +00001671 && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
drh05883a32015-06-02 15:32:08 +00001672 aff = SQLITE_AFF_BLOB;
drhd3037a42013-10-04 18:29:25 +00001673 if( zIn[0]=='(' ) zChar = zIn;
drh8a512562005-11-14 22:29:05 +00001674#ifndef SQLITE_OMIT_FLOATING_POINT
1675 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
1676 && aff==SQLITE_AFF_NUMERIC ){
1677 aff = SQLITE_AFF_REAL;
1678 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
1679 && aff==SQLITE_AFF_NUMERIC ){
1680 aff = SQLITE_AFF_REAL;
1681 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
1682 && aff==SQLITE_AFF_NUMERIC ){
1683 aff = SQLITE_AFF_REAL;
1684#endif
danielk1977201f7162005-02-01 02:13:29 +00001685 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
drh8a512562005-11-14 22:29:05 +00001686 aff = SQLITE_AFF_INTEGER;
danielk1977b3dff962005-02-01 01:21:55 +00001687 break;
danielk197752a83fb2005-01-31 12:56:44 +00001688 }
1689 }
drhd3037a42013-10-04 18:29:25 +00001690
dan2e3a5a82018-04-16 21:12:42 +00001691 /* If pCol is not NULL, store an estimate of the field size. The
drhd3037a42013-10-04 18:29:25 +00001692 ** estimate is scaled so that the size of an integer is 1. */
dan2e3a5a82018-04-16 21:12:42 +00001693 if( pCol ){
1694 int v = 0; /* default size is approx 4 bytes */
drh7ea31cc2014-09-18 14:36:00 +00001695 if( aff<SQLITE_AFF_NUMERIC ){
drhd3037a42013-10-04 18:29:25 +00001696 if( zChar ){
1697 while( zChar[0] ){
1698 if( sqlite3Isdigit(zChar[0]) ){
dan2e3a5a82018-04-16 21:12:42 +00001699 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
drhd3037a42013-10-04 18:29:25 +00001700 sqlite3GetInt32(zChar, &v);
drhd3037a42013-10-04 18:29:25 +00001701 break;
1702 }
1703 zChar++;
drhfdaac672013-10-04 15:30:21 +00001704 }
drhd3037a42013-10-04 18:29:25 +00001705 }else{
dan2e3a5a82018-04-16 21:12:42 +00001706 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
drhfdaac672013-10-04 15:30:21 +00001707 }
drhfdaac672013-10-04 15:30:21 +00001708 }
drhbbade8d2018-04-18 14:48:08 +00001709#ifdef SQLITE_ENABLE_SORTER_REFERENCES
dan2e3a5a82018-04-16 21:12:42 +00001710 if( v>=sqlite3GlobalConfig.szSorterRef ){
1711 pCol->colFlags |= COLFLAG_SORTERREF;
1712 }
drhbbade8d2018-04-18 14:48:08 +00001713#endif
dan2e3a5a82018-04-16 21:12:42 +00001714 v = v/4 + 1;
1715 if( v>255 ) v = 255;
1716 pCol->szEst = v;
drhfdaac672013-10-04 15:30:21 +00001717 }
danielk1977b3dff962005-02-01 01:21:55 +00001718 return aff;
danielk197752a83fb2005-01-31 12:56:44 +00001719}
1720
1721/*
danielk19777977a172004-11-09 12:44:37 +00001722** The expression is the default value for the most recently added column
1723** of the table currently under construction.
1724**
1725** Default value expressions must be constant. Raise an exception if this
1726** is not the case.
drhd9b02572001-04-15 00:37:09 +00001727**
1728** This routine is called by the parser while in the middle of
1729** parsing a CREATE TABLE statement.
drh7020f652000-06-03 18:06:52 +00001730*/
drh1be266b2017-12-24 00:18:47 +00001731void sqlite3AddDefaultValue(
1732 Parse *pParse, /* Parsing context */
1733 Expr *pExpr, /* The parsed expression of the default value */
1734 const char *zStart, /* Start of the default value text */
1735 const char *zEnd /* First character past end of defaut value text */
1736){
drh7020f652000-06-03 18:06:52 +00001737 Table *p;
danielk19777977a172004-11-09 12:44:37 +00001738 Column *pCol;
drh633e6d52008-07-28 19:34:53 +00001739 sqlite3 *db = pParse->db;
drhc4a64fa2009-05-11 20:53:28 +00001740 p = pParse->pNewTable;
1741 if( p!=0 ){
drh014fff22020-01-08 22:22:36 +00001742 int isInit = db->init.busy && db->init.iDb!=1;
drh42b9d7c2005-08-13 00:56:27 +00001743 pCol = &(p->aCol[p->nCol-1]);
drh014fff22020-01-08 22:22:36 +00001744 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
drh42b9d7c2005-08-13 00:56:27 +00001745 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
drhcf9d36d2021-08-02 18:03:43 +00001746 pCol->zCnName);
drh7e7fd732019-10-22 13:59:23 +00001747#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1748 }else if( pCol->colFlags & COLFLAG_GENERATED ){
drhab0992f2019-10-23 03:53:10 +00001749 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
1750 testcase( pCol->colFlags & COLFLAG_STORED );
drh7e7fd732019-10-22 13:59:23 +00001751 sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
1752#endif
drh42b9d7c2005-08-13 00:56:27 +00001753 }else{
danielk19776ab3a2e2009-02-19 14:39:25 +00001754 /* A copy of pExpr is used instead of the original, as pExpr contains
drh424981d2018-03-28 15:56:55 +00001755 ** tokens that point to volatile memory.
danielk19776ab3a2e2009-02-19 14:39:25 +00001756 */
drh79cf2b72021-07-31 20:30:41 +00001757 Expr x, *pDfltExpr;
drh94fa9c42016-02-27 21:16:04 +00001758 memset(&x, 0, sizeof(x));
1759 x.op = TK_SPAN;
drh9b2e0432017-12-27 19:43:22 +00001760 x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
drh1be266b2017-12-24 00:18:47 +00001761 x.pLeft = pExpr;
drh94fa9c42016-02-27 21:16:04 +00001762 x.flags = EP_Skip;
drh79cf2b72021-07-31 20:30:41 +00001763 pDfltExpr = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
drh94fa9c42016-02-27 21:16:04 +00001764 sqlite3DbFree(db, x.u.zToken);
drh79cf2b72021-07-31 20:30:41 +00001765 sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr);
drh42b9d7c2005-08-13 00:56:27 +00001766 }
danielk19777977a172004-11-09 12:44:37 +00001767 }
dan8900a482018-09-05 14:36:05 +00001768 if( IN_RENAME_OBJECT ){
1769 sqlite3RenameExprUnmap(pParse, pExpr);
1770 }
drh1be266b2017-12-24 00:18:47 +00001771 sqlite3ExprDelete(db, pExpr);
drh7020f652000-06-03 18:06:52 +00001772}
1773
1774/*
drh153110a2015-11-01 21:19:13 +00001775** Backwards Compatibility Hack:
1776**
1777** Historical versions of SQLite accepted strings as column names in
1778** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1779**
1780** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1781** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1782**
1783** This is goofy. But to preserve backwards compatibility we continue to
1784** accept it. This routine does the necessary conversion. It converts
1785** the expression given in its argument from a TK_STRING into a TK_ID
1786** if the expression is just a TK_STRING with an optional COLLATE clause.
drh6c591362019-04-27 20:16:42 +00001787** If the expression is anything other than TK_STRING, the expression is
drh153110a2015-11-01 21:19:13 +00001788** unchanged.
1789*/
1790static void sqlite3StringToId(Expr *p){
1791 if( p->op==TK_STRING ){
1792 p->op = TK_ID;
1793 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
1794 p->pLeft->op = TK_ID;
1795 }
1796}
1797
1798/*
drhf4b1d8d2019-10-22 15:45:03 +00001799** Tag the given column as being part of the PRIMARY KEY
1800*/
1801static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){
1802 pCol->colFlags |= COLFLAG_PRIMKEY;
1803#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1804 if( pCol->colFlags & COLFLAG_GENERATED ){
1805 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
1806 testcase( pCol->colFlags & COLFLAG_STORED );
1807 sqlite3ErrorMsg(pParse,
1808 "generated columns cannot be part of the PRIMARY KEY");
1809 }
1810#endif
1811}
1812
1813/*
drh4a324312001-12-21 14:30:42 +00001814** Designate the PRIMARY KEY for the table. pList is a list of names
1815** of columns that form the primary key. If pList is NULL, then the
1816** most recently added column of the table is the primary key.
1817**
1818** A table can have at most one primary key. If the table already has
1819** a primary key (and this is the second primary key) then create an
1820** error.
1821**
1822** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
drh23bf66d2004-12-14 03:34:34 +00001823** then we will try to use that column as the rowid. Set the Table.iPKey
drh4a324312001-12-21 14:30:42 +00001824** field of the table under construction to be the index of the
1825** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1826** no INTEGER PRIMARY KEY.
1827**
1828** If the key is not an INTEGER PRIMARY KEY, then create a unique
1829** index for the key. No index is created for INTEGER PRIMARY KEYs.
1830*/
drh205f48e2004-11-05 00:43:11 +00001831void sqlite3AddPrimaryKey(
1832 Parse *pParse, /* Parsing context */
1833 ExprList *pList, /* List of field names to be indexed */
1834 int onError, /* What to do with a uniqueness conflict */
drhfdd6e852005-12-16 01:06:16 +00001835 int autoInc, /* True if the AUTOINCREMENT keyword is present */
1836 int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
drh205f48e2004-11-05 00:43:11 +00001837){
drh4a324312001-12-21 14:30:42 +00001838 Table *pTab = pParse->pNewTable;
drhd7564862016-03-22 20:05:09 +00001839 Column *pCol = 0;
drh78100cc2003-08-23 22:40:53 +00001840 int iCol = -1, i;
drh8ea30bf2013-10-22 01:18:17 +00001841 int nTerm;
drh62340f82016-05-31 21:18:15 +00001842 if( pTab==0 ) goto primary_key_exit;
drh7d10d5a2008-08-20 16:35:10 +00001843 if( pTab->tabFlags & TF_HasPrimaryKey ){
danielk19774adee202004-05-08 08:23:19 +00001844 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00001845 "table \"%s\" has more than one primary key", pTab->zName);
drhe0194f22003-02-26 13:52:51 +00001846 goto primary_key_exit;
drh4a324312001-12-21 14:30:42 +00001847 }
drh7d10d5a2008-08-20 16:35:10 +00001848 pTab->tabFlags |= TF_HasPrimaryKey;
drh4a324312001-12-21 14:30:42 +00001849 if( pList==0 ){
1850 iCol = pTab->nCol - 1;
drhd7564862016-03-22 20:05:09 +00001851 pCol = &pTab->aCol[iCol];
drhf4b1d8d2019-10-22 15:45:03 +00001852 makeColumnPartOfPrimaryKey(pParse, pCol);
drh8ea30bf2013-10-22 01:18:17 +00001853 nTerm = 1;
drh78100cc2003-08-23 22:40:53 +00001854 }else{
drh8ea30bf2013-10-22 01:18:17 +00001855 nTerm = pList->nExpr;
1856 for(i=0; i<nTerm; i++){
drh108aa002015-08-24 20:21:20 +00001857 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
drh7d3d9da2015-09-01 00:42:52 +00001858 assert( pCExpr!=0 );
drh153110a2015-11-01 21:19:13 +00001859 sqlite3StringToId(pCExpr);
drh7d3d9da2015-09-01 00:42:52 +00001860 if( pCExpr->op==TK_ID ){
drhf9751072021-10-07 13:40:29 +00001861 const char *zCName;
1862 assert( !ExprHasProperty(pCExpr, EP_IntValue) );
1863 zCName = pCExpr->u.zToken;
drh108aa002015-08-24 20:21:20 +00001864 for(iCol=0; iCol<pTab->nCol; iCol++){
drhcf9d36d2021-08-02 18:03:43 +00001865 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
drhd7564862016-03-22 20:05:09 +00001866 pCol = &pTab->aCol[iCol];
drhf4b1d8d2019-10-22 15:45:03 +00001867 makeColumnPartOfPrimaryKey(pParse, pCol);
drh108aa002015-08-24 20:21:20 +00001868 break;
1869 }
drhd3d39e92004-05-20 22:16:29 +00001870 }
drh78100cc2003-08-23 22:40:53 +00001871 }
drh4a324312001-12-21 14:30:42 +00001872 }
1873 }
drh8ea30bf2013-10-22 01:18:17 +00001874 if( nTerm==1
drhd7564862016-03-22 20:05:09 +00001875 && pCol
drhb70f2ea2021-08-18 12:05:22 +00001876 && pCol->eCType==COLTYPE_INTEGER
drhbc622bc2015-08-24 15:39:42 +00001877 && sortOrder!=SQLITE_SO_DESC
drh8ea30bf2013-10-22 01:18:17 +00001878 ){
danc9461ec2018-08-29 21:00:16 +00001879 if( IN_RENAME_OBJECT && pList ){
dan2381f6d2019-03-20 16:58:21 +00001880 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
1881 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
dan987db762018-08-14 20:18:50 +00001882 }
drh4a324312001-12-21 14:30:42 +00001883 pTab->iPKey = iCol;
drh1bd10f82008-12-10 21:19:56 +00001884 pTab->keyConf = (u8)onError;
drh7d10d5a2008-08-20 16:35:10 +00001885 assert( autoInc==0 || autoInc==1 );
1886 pTab->tabFlags |= autoInc*TF_Autoincrement;
drhd88fd532022-05-02 20:49:30 +00001887 if( pList ) pParse->iPkSortOrder = pList->a[0].fg.sortFlags;
drh34ab9412019-12-19 17:42:27 +00001888 (void)sqlite3HasExplicitNulls(pParse, pList);
drh205f48e2004-11-05 00:43:11 +00001889 }else if( autoInc ){
drh4794f732004-11-05 17:17:50 +00001890#ifndef SQLITE_OMIT_AUTOINCREMENT
drh205f48e2004-11-05 00:43:11 +00001891 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
1892 "INTEGER PRIMARY KEY");
drh4794f732004-11-05 17:17:50 +00001893#endif
drh4a324312001-12-21 14:30:42 +00001894 }else{
drh62340f82016-05-31 21:18:15 +00001895 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
1896 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
drhe0194f22003-02-26 13:52:51 +00001897 pList = 0;
drh4a324312001-12-21 14:30:42 +00001898 }
drhe0194f22003-02-26 13:52:51 +00001899
1900primary_key_exit:
drh633e6d52008-07-28 19:34:53 +00001901 sqlite3ExprListDelete(pParse->db, pList);
drhe0194f22003-02-26 13:52:51 +00001902 return;
drh4a324312001-12-21 14:30:42 +00001903}
1904
1905/*
drhffe07b22005-11-03 00:41:17 +00001906** Add a new CHECK constraint to the table currently under construction.
1907*/
1908void sqlite3AddCheckConstraint(
drh92e21ef2020-08-27 18:36:30 +00001909 Parse *pParse, /* Parsing context */
1910 Expr *pCheckExpr, /* The check expression */
1911 const char *zStart, /* Opening "(" */
1912 const char *zEnd /* Closing ")" */
drhffe07b22005-11-03 00:41:17 +00001913){
1914#ifndef SQLITE_OMIT_CHECK
1915 Table *pTab = pParse->pNewTable;
drhc9bbb012014-05-21 08:48:18 +00001916 sqlite3 *db = pParse->db;
1917 if( pTab && !IN_DECLARE_VTAB
1918 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
1919 ){
drh2938f922012-03-07 19:13:29 +00001920 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
1921 if( pParse->constraintName.n ){
1922 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
drh92e21ef2020-08-27 18:36:30 +00001923 }else{
1924 Token t;
1925 for(zStart++; sqlite3Isspace(zStart[0]); zStart++){}
1926 while( sqlite3Isspace(zEnd[-1]) ){ zEnd--; }
1927 t.z = zStart;
1928 t.n = (int)(zEnd - t.z);
1929 sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
drh2938f922012-03-07 19:13:29 +00001930 }
drh33e619f2009-05-28 01:00:55 +00001931 }else
drhffe07b22005-11-03 00:41:17 +00001932#endif
drh33e619f2009-05-28 01:00:55 +00001933 {
drh2938f922012-03-07 19:13:29 +00001934 sqlite3ExprDelete(pParse->db, pCheckExpr);
drh33e619f2009-05-28 01:00:55 +00001935 }
drhffe07b22005-11-03 00:41:17 +00001936}
1937
1938/*
drhd3d39e92004-05-20 22:16:29 +00001939** Set the collation function of the most recently parsed table column
1940** to the CollSeq given.
drh8e2ca022002-06-17 17:07:19 +00001941*/
danielk197739002502007-11-12 09:50:26 +00001942void sqlite3AddCollateType(Parse *pParse, Token *pToken){
drh8e2ca022002-06-17 17:07:19 +00001943 Table *p;
danielk19770202b292004-06-09 09:55:16 +00001944 int i;
danielk197739002502007-11-12 09:50:26 +00001945 char *zColl; /* Dequoted name of collation sequence */
drh633e6d52008-07-28 19:34:53 +00001946 sqlite3 *db;
danielk1977a37cdde2004-05-16 11:15:36 +00001947
dan936a3052020-10-12 15:27:50 +00001948 if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return;
danielk19770202b292004-06-09 09:55:16 +00001949 i = p->nCol-1;
drh633e6d52008-07-28 19:34:53 +00001950 db = pParse->db;
1951 zColl = sqlite3NameFromToken(db, pToken);
danielk197739002502007-11-12 09:50:26 +00001952 if( !zColl ) return;
1953
drhc4a64fa2009-05-11 20:53:28 +00001954 if( sqlite3LocateCollSeq(pParse, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00001955 Index *pIdx;
drh65b40092021-08-05 15:27:19 +00001956 sqlite3ColumnSetColl(db, &p->aCol[i], zColl);
danielk1977b3bf5562006-01-10 17:58:23 +00001957
1958 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1959 ** then an index may have been created on this column before the
1960 ** collation type was added. Correct this if it is the case.
1961 */
1962 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhbbbdc832013-10-22 18:01:40 +00001963 assert( pIdx->nKeyCol==1 );
danielk1977b3bf5562006-01-10 17:58:23 +00001964 if( pIdx->aiColumn[0]==i ){
drh65b40092021-08-05 15:27:19 +00001965 pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]);
danielk19777cedc8d2004-06-10 10:50:08 +00001966 }
1967 }
1968 }
drh65b40092021-08-05 15:27:19 +00001969 sqlite3DbFree(db, zColl);
danielk19777cedc8d2004-06-10 10:50:08 +00001970}
1971
drh81f7b372019-10-16 12:18:59 +00001972/* Change the most recently parsed column to be a GENERATED ALWAYS AS
1973** column.
1974*/
1975void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
1976#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1977 u8 eType = COLFLAG_VIRTUAL;
1978 Table *pTab = pParse->pNewTable;
1979 Column *pCol;
drhf68bf5f2019-12-04 03:31:29 +00001980 if( pTab==0 ){
1981 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
1982 goto generated_done;
1983 }
drh81f7b372019-10-16 12:18:59 +00001984 pCol = &(pTab->aCol[pTab->nCol-1]);
drhb9bcf7c2019-10-19 13:29:10 +00001985 if( IN_DECLARE_VTAB ){
1986 sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
1987 goto generated_done;
1988 }
drh79cf2b72021-07-31 20:30:41 +00001989 if( pCol->iDflt>0 ) goto generated_error;
drh81f7b372019-10-16 12:18:59 +00001990 if( pType ){
1991 if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
1992 /* no-op */
1993 }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
1994 eType = COLFLAG_STORED;
1995 }else{
1996 goto generated_error;
1997 }
1998 }
drhf95909c2019-10-18 18:33:25 +00001999 if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
drh81f7b372019-10-16 12:18:59 +00002000 pCol->colFlags |= eType;
drhc1431142019-10-17 17:54:05 +00002001 assert( TF_HasVirtual==COLFLAG_VIRTUAL );
2002 assert( TF_HasStored==COLFLAG_STORED );
2003 pTab->tabFlags |= eType;
drha0e16a22019-10-27 22:22:24 +00002004 if( pCol->colFlags & COLFLAG_PRIMKEY ){
2005 makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
2006 }
drh79cf2b72021-07-31 20:30:41 +00002007 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
drhb9bcf7c2019-10-19 13:29:10 +00002008 pExpr = 0;
drh81f7b372019-10-16 12:18:59 +00002009 goto generated_done;
2010
2011generated_error:
drh7e7fd732019-10-22 13:59:23 +00002012 sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
drhcf9d36d2021-08-02 18:03:43 +00002013 pCol->zCnName);
drh81f7b372019-10-16 12:18:59 +00002014generated_done:
2015 sqlite3ExprDelete(pParse->db, pExpr);
2016#else
2017 /* Throw and error for the GENERATED ALWAYS AS clause if the
2018 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
drh7e7fd732019-10-22 13:59:23 +00002019 sqlite3ErrorMsg(pParse, "generated columns not supported");
drh81f7b372019-10-16 12:18:59 +00002020 sqlite3ExprDelete(pParse->db, pExpr);
2021#endif
2022}
2023
danielk1977466be562004-06-10 02:16:01 +00002024/*
drh3f7d4e42004-07-24 14:35:58 +00002025** Generate code that will increment the schema cookie.
drh50e5dad2001-09-15 00:57:28 +00002026**
2027** The schema cookie is used to determine when the schema for the
2028** database changes. After each schema change, the cookie value
2029** changes. When a process first reads the schema it records the
2030** cookie. Thereafter, whenever it goes to access the database,
2031** it checks the cookie to make sure the schema has not changed
2032** since it was last read.
2033**
2034** This plan is not completely bullet-proof. It is possible for
2035** the schema to change multiple times and for the cookie to be
2036** set back to prior value. But schema changes are infrequent
2037** and the probability of hitting the same cookie value is only
2038** 1 chance in 2^32. So we're safe enough.
drh96fdcb42016-09-27 00:09:33 +00002039**
2040** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
2041** the schema-version whenever the schema changes.
drh50e5dad2001-09-15 00:57:28 +00002042*/
drh9cbf3422008-01-17 16:22:13 +00002043void sqlite3ChangeCookie(Parse *pParse, int iDb){
drh9cbf3422008-01-17 16:22:13 +00002044 sqlite3 *db = pParse->db;
2045 Vdbe *v = pParse->pVdbe;
drh21206082011-04-04 18:22:02 +00002046 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh1861afc2016-02-01 21:48:34 +00002047 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
drh3517b312018-04-09 00:46:42 +00002048 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
drh50e5dad2001-09-15 00:57:28 +00002049}
2050
2051/*
drh969fa7c2002-02-18 18:30:32 +00002052** Measure the number of characters needed to output the given
2053** identifier. The number returned includes any quotes used
2054** but does not include the null terminator.
drh234c39d2004-07-24 03:30:47 +00002055**
2056** The estimate is conservative. It might be larger that what is
2057** really needed.
drh969fa7c2002-02-18 18:30:32 +00002058*/
2059static int identLength(const char *z){
2060 int n;
drh17f71932002-02-21 12:01:27 +00002061 for(n=0; *z; n++, z++){
drh234c39d2004-07-24 03:30:47 +00002062 if( *z=='"' ){ n++; }
drh969fa7c2002-02-18 18:30:32 +00002063 }
drh234c39d2004-07-24 03:30:47 +00002064 return n + 2;
drh969fa7c2002-02-18 18:30:32 +00002065}
2066
2067/*
danielk19771b870de2009-03-14 08:37:23 +00002068** The first parameter is a pointer to an output buffer. The second
2069** parameter is a pointer to an integer that contains the offset at
2070** which to write into the output buffer. This function copies the
2071** nul-terminated string pointed to by the third parameter, zSignedIdent,
2072** to the specified offset in the buffer and updates *pIdx to refer
2073** to the first byte after the last byte written before returning.
2074**
2075** If the string zSignedIdent consists entirely of alpha-numeric
2076** characters, does not begin with a digit and is not an SQL keyword,
2077** then it is copied to the output buffer exactly as it is. Otherwise,
2078** it is quoted using double-quotes.
2079*/
drhc4a64fa2009-05-11 20:53:28 +00002080static void identPut(char *z, int *pIdx, char *zSignedIdent){
drh4c755c02004-08-08 20:22:17 +00002081 unsigned char *zIdent = (unsigned char*)zSignedIdent;
drh17f71932002-02-21 12:01:27 +00002082 int i, j, needQuote;
drh969fa7c2002-02-18 18:30:32 +00002083 i = *pIdx;
danielk19771b870de2009-03-14 08:37:23 +00002084
drh17f71932002-02-21 12:01:27 +00002085 for(j=0; zIdent[j]; j++){
danielk197778ca0e72009-01-20 16:53:39 +00002086 if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
drh17f71932002-02-21 12:01:27 +00002087 }
drhc7407522014-01-10 20:38:12 +00002088 needQuote = sqlite3Isdigit(zIdent[0])
2089 || sqlite3KeywordCode(zIdent, j)!=TK_ID
2090 || zIdent[j]!=0
2091 || j==0;
danielk19771b870de2009-03-14 08:37:23 +00002092
drh234c39d2004-07-24 03:30:47 +00002093 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00002094 for(j=0; zIdent[j]; j++){
2095 z[i++] = zIdent[j];
drh234c39d2004-07-24 03:30:47 +00002096 if( zIdent[j]=='"' ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00002097 }
drh234c39d2004-07-24 03:30:47 +00002098 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00002099 z[i] = 0;
2100 *pIdx = i;
2101}
2102
2103/*
2104** Generate a CREATE TABLE statement appropriate for the given
2105** table. Memory to hold the text of the statement is obtained
2106** from sqliteMalloc() and must be freed by the calling function.
2107*/
drh1d34fde2009-02-03 15:50:33 +00002108static char *createTableStmt(sqlite3 *db, Table *p){
drh969fa7c2002-02-18 18:30:32 +00002109 int i, k, n;
2110 char *zStmt;
drhc4a64fa2009-05-11 20:53:28 +00002111 char *zSep, *zSep2, *zEnd;
drh234c39d2004-07-24 03:30:47 +00002112 Column *pCol;
drh969fa7c2002-02-18 18:30:32 +00002113 n = 0;
drh234c39d2004-07-24 03:30:47 +00002114 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
drhcf9d36d2021-08-02 18:03:43 +00002115 n += identLength(pCol->zCnName) + 5;
drh969fa7c2002-02-18 18:30:32 +00002116 }
2117 n += identLength(p->zName);
drhc4a64fa2009-05-11 20:53:28 +00002118 if( n<50 ){
drh969fa7c2002-02-18 18:30:32 +00002119 zSep = "";
2120 zSep2 = ",";
2121 zEnd = ")";
2122 }else{
2123 zSep = "\n ";
2124 zSep2 = ",\n ";
2125 zEnd = "\n)";
2126 }
drhe0bc4042002-06-25 01:09:11 +00002127 n += 35 + 6*p->nCol;
drhb9755982010-07-24 16:34:37 +00002128 zStmt = sqlite3DbMallocRaw(0, n);
drh820a9062008-01-31 13:35:48 +00002129 if( zStmt==0 ){
drh4a642b62016-02-05 01:55:27 +00002130 sqlite3OomFault(db);
drh820a9062008-01-31 13:35:48 +00002131 return 0;
2132 }
drhbdb339f2009-02-02 18:03:21 +00002133 sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
drhea678832008-12-10 19:26:22 +00002134 k = sqlite3Strlen30(zStmt);
drhc4a64fa2009-05-11 20:53:28 +00002135 identPut(zStmt, &k, p->zName);
drh969fa7c2002-02-18 18:30:32 +00002136 zStmt[k++] = '(';
drh234c39d2004-07-24 03:30:47 +00002137 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
drhc4a64fa2009-05-11 20:53:28 +00002138 static const char * const azType[] = {
drh05883a32015-06-02 15:32:08 +00002139 /* SQLITE_AFF_BLOB */ "",
drh7ea31cc2014-09-18 14:36:00 +00002140 /* SQLITE_AFF_TEXT */ " TEXT",
drhc4a64fa2009-05-11 20:53:28 +00002141 /* SQLITE_AFF_NUMERIC */ " NUM",
2142 /* SQLITE_AFF_INTEGER */ " INT",
drh00d6b272022-12-15 20:03:08 +00002143 /* SQLITE_AFF_REAL */ " REAL",
2144 /* SQLITE_AFF_FLEXNUM */ " NUM",
drhc4a64fa2009-05-11 20:53:28 +00002145 };
2146 int len;
2147 const char *zType;
2148
drh5bb3eb92007-05-04 13:15:55 +00002149 sqlite3_snprintf(n-k, &zStmt[k], zSep);
drhea678832008-12-10 19:26:22 +00002150 k += sqlite3Strlen30(&zStmt[k]);
drh969fa7c2002-02-18 18:30:32 +00002151 zSep = zSep2;
drhcf9d36d2021-08-02 18:03:43 +00002152 identPut(zStmt, &k, pCol->zCnName);
drh05883a32015-06-02 15:32:08 +00002153 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
2154 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
2155 testcase( pCol->affinity==SQLITE_AFF_BLOB );
drh7ea31cc2014-09-18 14:36:00 +00002156 testcase( pCol->affinity==SQLITE_AFF_TEXT );
drhc4a64fa2009-05-11 20:53:28 +00002157 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
2158 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
2159 testcase( pCol->affinity==SQLITE_AFF_REAL );
drh00d6b272022-12-15 20:03:08 +00002160 testcase( pCol->affinity==SQLITE_AFF_FLEXNUM );
drhc4a64fa2009-05-11 20:53:28 +00002161
drh05883a32015-06-02 15:32:08 +00002162 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
drhc4a64fa2009-05-11 20:53:28 +00002163 len = sqlite3Strlen30(zType);
drh00d6b272022-12-15 20:03:08 +00002164 assert( pCol->affinity==SQLITE_AFF_BLOB
2165 || pCol->affinity==SQLITE_AFF_FLEXNUM
drhfdaac672013-10-04 15:30:21 +00002166 || pCol->affinity==sqlite3AffinityType(zType, 0) );
drhc4a64fa2009-05-11 20:53:28 +00002167 memcpy(&zStmt[k], zType, len);
2168 k += len;
2169 assert( k<=n );
drh969fa7c2002-02-18 18:30:32 +00002170 }
drh5bb3eb92007-05-04 13:15:55 +00002171 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
drh969fa7c2002-02-18 18:30:32 +00002172 return zStmt;
2173}
2174
2175/*
drh7f9c5db2013-10-23 00:32:58 +00002176** Resize an Index object to hold N columns total. Return SQLITE_OK
2177** on success and SQLITE_NOMEM on an OOM error.
2178*/
2179static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
2180 char *zExtra;
2181 int nByte;
2182 if( pIdx->nColumn>=N ) return SQLITE_OK;
2183 assert( pIdx->isResized==0 );
danb5a69232020-09-15 20:48:30 +00002184 nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*N;
drh7f9c5db2013-10-23 00:32:58 +00002185 zExtra = sqlite3DbMallocZero(db, nByte);
mistachkinfad30392016-02-13 23:43:46 +00002186 if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
drh7f9c5db2013-10-23 00:32:58 +00002187 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
drhf19aa5f2015-12-30 16:51:20 +00002188 pIdx->azColl = (const char**)zExtra;
drh7f9c5db2013-10-23 00:32:58 +00002189 zExtra += sizeof(char*)*N;
danb5a69232020-09-15 20:48:30 +00002190 memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
2191 pIdx->aiRowLogEst = (LogEst*)zExtra;
2192 zExtra += sizeof(LogEst)*N;
drh7f9c5db2013-10-23 00:32:58 +00002193 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
2194 pIdx->aiColumn = (i16*)zExtra;
2195 zExtra += sizeof(i16)*N;
2196 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
2197 pIdx->aSortOrder = (u8*)zExtra;
2198 pIdx->nColumn = N;
2199 pIdx->isResized = 1;
2200 return SQLITE_OK;
2201}
2202
2203/*
drhfdaac672013-10-04 15:30:21 +00002204** Estimate the total row width for a table.
2205*/
drhe13e9f52013-10-05 19:18:00 +00002206static void estimateTableWidth(Table *pTab){
drhfdaac672013-10-04 15:30:21 +00002207 unsigned wTable = 0;
2208 const Column *pTabCol;
2209 int i;
2210 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
2211 wTable += pTabCol->szEst;
2212 }
2213 if( pTab->iPKey<0 ) wTable++;
drhe13e9f52013-10-05 19:18:00 +00002214 pTab->szTabRow = sqlite3LogEst(wTable*4);
drhfdaac672013-10-04 15:30:21 +00002215}
2216
2217/*
drhe13e9f52013-10-05 19:18:00 +00002218** Estimate the average size of a row for an index.
drhfdaac672013-10-04 15:30:21 +00002219*/
drhe13e9f52013-10-05 19:18:00 +00002220static void estimateIndexWidth(Index *pIdx){
drhbbbdc832013-10-22 18:01:40 +00002221 unsigned wIndex = 0;
drhfdaac672013-10-04 15:30:21 +00002222 int i;
2223 const Column *aCol = pIdx->pTable->aCol;
2224 for(i=0; i<pIdx->nColumn; i++){
drhbbbdc832013-10-22 18:01:40 +00002225 i16 x = pIdx->aiColumn[i];
2226 assert( x<pIdx->pTable->nCol );
2227 wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
drhfdaac672013-10-04 15:30:21 +00002228 }
drhe13e9f52013-10-05 19:18:00 +00002229 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
drhfdaac672013-10-04 15:30:21 +00002230}
2231
drhf78d0f42019-04-28 19:27:02 +00002232/* Return true if column number x is any of the first nCol entries of aiCol[].
2233** This is used to determine if the column number x appears in any of the
2234** first nCol entries of an index.
drh7f9c5db2013-10-23 00:32:58 +00002235*/
2236static int hasColumn(const i16 *aiCol, int nCol, int x){
drhf78d0f42019-04-28 19:27:02 +00002237 while( nCol-- > 0 ){
drhf78d0f42019-04-28 19:27:02 +00002238 if( x==*(aiCol++) ){
2239 return 1;
2240 }
2241 }
2242 return 0;
2243}
2244
2245/*
drhc19b63c2019-04-29 13:30:16 +00002246** Return true if any of the first nKey entries of index pIdx exactly
2247** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
2248** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
2249** or may not be the same index as pPk.
drhf78d0f42019-04-28 19:27:02 +00002250**
drhc19b63c2019-04-29 13:30:16 +00002251** The first nKey entries of pIdx are guaranteed to be ordinary columns,
drhf78d0f42019-04-28 19:27:02 +00002252** not a rowid or expression.
2253**
2254** This routine differs from hasColumn() in that both the column and the
2255** collating sequence must match for this routine, but for hasColumn() only
2256** the column name must match.
2257*/
drhc19b63c2019-04-29 13:30:16 +00002258static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
drhf78d0f42019-04-28 19:27:02 +00002259 int i, j;
drhc19b63c2019-04-29 13:30:16 +00002260 assert( nKey<=pIdx->nColumn );
2261 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
2262 assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
2263 assert( pPk->pTable->tabFlags & TF_WithoutRowid );
2264 assert( pPk->pTable==pIdx->pTable );
2265 testcase( pPk==pIdx );
2266 j = pPk->aiColumn[iCol];
2267 assert( j!=XN_ROWID && j!=XN_EXPR );
drhf78d0f42019-04-28 19:27:02 +00002268 for(i=0; i<nKey; i++){
drhc19b63c2019-04-29 13:30:16 +00002269 assert( pIdx->aiColumn[i]>=0 || j>=0 );
2270 if( pIdx->aiColumn[i]==j
2271 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
drhf78d0f42019-04-28 19:27:02 +00002272 ){
2273 return 1;
2274 }
2275 }
drh7f9c5db2013-10-23 00:32:58 +00002276 return 0;
2277}
2278
drh1fe3ac72018-06-09 01:12:08 +00002279/* Recompute the colNotIdxed field of the Index.
2280**
2281** colNotIdxed is a bitmask that has a 0 bit representing each indexed
drh5723c652022-10-22 13:49:35 +00002282** columns that are within the first 63 columns of the table and a 1 for
2283** all other bits (all columns that are not in the index). The
drh1fe3ac72018-06-09 01:12:08 +00002284** high-order bit of colNotIdxed is always 1. All unindexed columns
2285** of the table have a 1.
2286**
drhc7476732019-10-24 20:29:25 +00002287** 2019-10-24: For the purpose of this computation, virtual columns are
2288** not considered to be covered by the index, even if they are in the
2289** index, because we do not trust the logic in whereIndexExprTrans() to be
2290** able to find all instances of a reference to the indexed table column
2291** and convert them into references to the index. Hence we always want
2292** the actual table at hand in order to recompute the virtual column, if
2293** necessary.
2294**
drh1fe3ac72018-06-09 01:12:08 +00002295** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
2296** to determine if the index is covering index.
2297*/
2298static void recomputeColumnsNotIndexed(Index *pIdx){
2299 Bitmask m = 0;
2300 int j;
drhc7476732019-10-24 20:29:25 +00002301 Table *pTab = pIdx->pTable;
drh1fe3ac72018-06-09 01:12:08 +00002302 for(j=pIdx->nColumn-1; j>=0; j--){
2303 int x = pIdx->aiColumn[j];
drhc7476732019-10-24 20:29:25 +00002304 if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
drh1fe3ac72018-06-09 01:12:08 +00002305 testcase( x==BMS-1 );
2306 testcase( x==BMS-2 );
2307 if( x<BMS-1 ) m |= MASKBIT(x);
2308 }
2309 }
2310 pIdx->colNotIdxed = ~m;
drh5723c652022-10-22 13:49:35 +00002311 assert( (pIdx->colNotIdxed>>63)==1 ); /* See note-20221022-a */
drh1fe3ac72018-06-09 01:12:08 +00002312}
2313
drh7f9c5db2013-10-23 00:32:58 +00002314/*
drhc6bd4e42013-11-02 14:37:18 +00002315** This routine runs at the end of parsing a CREATE TABLE statement that
2316** has a WITHOUT ROWID clause. The job of this routine is to convert both
2317** internal schema data structures and the generated VDBE code so that they
2318** are appropriate for a WITHOUT ROWID table instead of a rowid table.
2319** Changes include:
drh7f9c5db2013-10-23 00:32:58 +00002320**
drh62340f82016-05-31 21:18:15 +00002321** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
drh0f3f7662017-08-18 14:34:28 +00002322** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
2323** into BTREE_BLOBKEY.
drh1e32bed2020-06-19 13:33:53 +00002324** (3) Bypass the creation of the sqlite_schema table entry
peter.d.reid60ec9142014-09-06 16:39:46 +00002325** for the PRIMARY KEY as the primary key index is now
drh1e32bed2020-06-19 13:33:53 +00002326** identified by the sqlite_schema table entry of the table itself.
drh62340f82016-05-31 21:18:15 +00002327** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
drhc6bd4e42013-11-02 14:37:18 +00002328** schema to the rootpage from the main table.
drhc6bd4e42013-11-02 14:37:18 +00002329** (5) Add all table columns to the PRIMARY KEY Index object
2330** so that the PRIMARY KEY is a covering index. The surplus
drha485ad12017-08-02 22:43:14 +00002331** columns are part of KeyInfo.nAllField and are not used for
drhc6bd4e42013-11-02 14:37:18 +00002332** sorting or lookup or uniqueness checks.
2333** (6) Replace the rowid tail on all automatically generated UNIQUE
2334** indices with the PRIMARY KEY columns.
drh62340f82016-05-31 21:18:15 +00002335**
2336** For virtual tables, only (1) is performed.
drh7f9c5db2013-10-23 00:32:58 +00002337*/
2338static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
2339 Index *pIdx;
2340 Index *pPk;
2341 int nPk;
dan1ff94072019-07-17 09:18:06 +00002342 int nExtra;
drh7f9c5db2013-10-23 00:32:58 +00002343 int i, j;
2344 sqlite3 *db = pParse->db;
drhc6bd4e42013-11-02 14:37:18 +00002345 Vdbe *v = pParse->pVdbe;
drh7f9c5db2013-10-23 00:32:58 +00002346
drh62340f82016-05-31 21:18:15 +00002347 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
2348 */
2349 if( !db->init.imposterTable ){
2350 for(i=0; i<pTab->nCol; i++){
drhfd46ec62021-08-18 22:26:51 +00002351 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
2352 && (pTab->aCol[i].notNull==OE_None)
2353 ){
drh62340f82016-05-31 21:18:15 +00002354 pTab->aCol[i].notNull = OE_Abort;
2355 }
2356 }
drhcbda9c72019-10-26 17:08:06 +00002357 pTab->tabFlags |= TF_HasNotNull;
drh62340f82016-05-31 21:18:15 +00002358 }
2359
drh0f3f7662017-08-18 14:34:28 +00002360 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
2361 ** into BTREE_BLOBKEY.
drh7f9c5db2013-10-23 00:32:58 +00002362 */
drh381bdac2021-02-04 17:29:04 +00002363 assert( !pParse->bReturning );
2364 if( pParse->u1.addrCrTab ){
drhc6bd4e42013-11-02 14:37:18 +00002365 assert( v );
drh381bdac2021-02-04 17:29:04 +00002366 sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY);
drhc6bd4e42013-11-02 14:37:18 +00002367 }
2368
drh7f9c5db2013-10-23 00:32:58 +00002369 /* Locate the PRIMARY KEY index. Or, if this table was originally
2370 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
2371 */
2372 if( pTab->iPKey>=0 ){
2373 ExprList *pList;
drh108aa002015-08-24 20:21:20 +00002374 Token ipkToken;
drhcf9d36d2021-08-02 18:03:43 +00002375 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
drh108aa002015-08-24 20:21:20 +00002376 pList = sqlite3ExprListAppend(pParse, 0,
2377 sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
drh1bb89e92021-04-19 18:03:52 +00002378 if( pList==0 ){
2379 pTab->tabFlags &= ~TF_WithoutRowid;
2380 return;
2381 }
danf9b0c452019-05-06 16:15:28 +00002382 if( IN_RENAME_OBJECT ){
2383 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
2384 }
drhd88fd532022-05-02 20:49:30 +00002385 pList->a[0].fg.sortFlags = pParse->iPkSortOrder;
drh7f9c5db2013-10-23 00:32:58 +00002386 assert( pParse->pNewTable==pTab );
danf9b0c452019-05-06 16:15:28 +00002387 pTab->iPKey = -1;
drh62340f82016-05-31 21:18:15 +00002388 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
2389 SQLITE_IDXTYPE_PRIMARYKEY);
drh0c7d3d32022-01-24 16:47:12 +00002390 if( pParse->nErr ){
drh3bb9d752021-04-13 13:48:31 +00002391 pTab->tabFlags &= ~TF_WithoutRowid;
2392 return;
2393 }
drh0c7d3d32022-01-24 16:47:12 +00002394 assert( db->mallocFailed==0 );
drh62340f82016-05-31 21:18:15 +00002395 pPk = sqlite3PrimaryKeyIndex(pTab);
dan1ff94072019-07-17 09:18:06 +00002396 assert( pPk->nKeyCol==1 );
drh44156282013-10-23 22:23:03 +00002397 }else{
2398 pPk = sqlite3PrimaryKeyIndex(pTab);
drhf0c48b12019-02-11 01:58:34 +00002399 assert( pPk!=0 );
danc5b73582015-05-26 11:53:14 +00002400
drhe385d882014-12-28 22:10:51 +00002401 /*
2402 ** Remove all redundant columns from the PRIMARY KEY. For example, change
2403 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
2404 ** code assumes the PRIMARY KEY contains no repeated columns.
2405 */
2406 for(i=j=1; i<pPk->nKeyCol; i++){
drhf78d0f42019-04-28 19:27:02 +00002407 if( isDupColumn(pPk, j, pPk, i) ){
drhe385d882014-12-28 22:10:51 +00002408 pPk->nColumn--;
2409 }else{
drhf78d0f42019-04-28 19:27:02 +00002410 testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
dan1ff94072019-07-17 09:18:06 +00002411 pPk->azColl[j] = pPk->azColl[i];
2412 pPk->aSortOrder[j] = pPk->aSortOrder[i];
drhe385d882014-12-28 22:10:51 +00002413 pPk->aiColumn[j++] = pPk->aiColumn[i];
2414 }
2415 }
2416 pPk->nKeyCol = j;
drh7f9c5db2013-10-23 00:32:58 +00002417 }
drh7f9c5db2013-10-23 00:32:58 +00002418 assert( pPk!=0 );
drh62340f82016-05-31 21:18:15 +00002419 pPk->isCovering = 1;
2420 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
dan1ff94072019-07-17 09:18:06 +00002421 nPk = pPk->nColumn = pPk->nKeyCol;
drh7f9c5db2013-10-23 00:32:58 +00002422
drh1e32bed2020-06-19 13:33:53 +00002423 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema
drhdf949662017-07-30 18:40:52 +00002424 ** table entry. This is only required if currently generating VDBE
2425 ** code for a CREATE TABLE (not when parsing one as part of reading
2426 ** a database schema). */
2427 if( v && pPk->tnum>0 ){
2428 assert( db->init.busy==0 );
drhabc38152020-07-22 13:38:04 +00002429 sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
drhdf949662017-07-30 18:40:52 +00002430 }
2431
drhc6bd4e42013-11-02 14:37:18 +00002432 /* The root page of the PRIMARY KEY is the table root page */
2433 pPk->tnum = pTab->tnum;
2434
drh7f9c5db2013-10-23 00:32:58 +00002435 /* Update the in-memory representation of all UNIQUE indices by converting
2436 ** the final rowid column into one or more columns of the PRIMARY KEY.
2437 */
2438 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2439 int n;
drh48dd1d82014-05-27 18:18:58 +00002440 if( IsPrimaryKeyIndex(pIdx) ) continue;
drh7f9c5db2013-10-23 00:32:58 +00002441 for(i=n=0; i<nPk; i++){
drhf78d0f42019-04-28 19:27:02 +00002442 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
2443 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
2444 n++;
2445 }
drh7f9c5db2013-10-23 00:32:58 +00002446 }
drh5a9a37b2013-11-05 17:30:04 +00002447 if( n==0 ){
2448 /* This index is a superset of the primary key */
2449 pIdx->nColumn = pIdx->nKeyCol;
2450 continue;
2451 }
drh7f9c5db2013-10-23 00:32:58 +00002452 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
2453 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
drhf78d0f42019-04-28 19:27:02 +00002454 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
2455 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
drh7f9c5db2013-10-23 00:32:58 +00002456 pIdx->aiColumn[j] = pPk->aiColumn[i];
2457 pIdx->azColl[j] = pPk->azColl[i];
drhbf9ff252019-05-14 00:43:13 +00002458 if( pPk->aSortOrder[i] ){
2459 /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
2460 pIdx->bAscKeyBug = 1;
2461 }
drh7f9c5db2013-10-23 00:32:58 +00002462 j++;
2463 }
2464 }
drh00012df2013-11-05 01:59:07 +00002465 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
2466 assert( pIdx->nColumn>=j );
drh7f9c5db2013-10-23 00:32:58 +00002467 }
2468
2469 /* Add all table columns to the PRIMARY KEY index
2470 */
dan1ff94072019-07-17 09:18:06 +00002471 nExtra = 0;
2472 for(i=0; i<pTab->nCol; i++){
drh8e10d742019-10-18 17:42:47 +00002473 if( !hasColumn(pPk->aiColumn, nPk, i)
2474 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
drh7f9c5db2013-10-23 00:32:58 +00002475 }
dan1ff94072019-07-17 09:18:06 +00002476 if( resizeIndexObject(db, pPk, nPk+nExtra) ) return;
2477 for(i=0, j=nPk; i<pTab->nCol; i++){
drh8e10d742019-10-18 17:42:47 +00002478 if( !hasColumn(pPk->aiColumn, j, i)
2479 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
2480 ){
dan1ff94072019-07-17 09:18:06 +00002481 assert( j<pPk->nColumn );
2482 pPk->aiColumn[j] = i;
2483 pPk->azColl[j] = sqlite3StrBINARY;
2484 j++;
2485 }
2486 }
2487 assert( pPk->nColumn==j );
drh8e10d742019-10-18 17:42:47 +00002488 assert( pTab->nNVCol<=j );
drh1fe3ac72018-06-09 01:12:08 +00002489 recomputeColumnsNotIndexed(pPk);
drh7f9c5db2013-10-23 00:32:58 +00002490}
2491
drh3d863b52020-05-14 21:16:52 +00002492
2493#ifndef SQLITE_OMIT_VIRTUALTABLE
2494/*
2495** Return true if pTab is a virtual table and zName is a shadow table name
2496** for that virtual table.
2497*/
2498int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
2499 int nName; /* Length of zName */
2500 Module *pMod; /* Module for the virtual table */
2501
2502 if( !IsVirtual(pTab) ) return 0;
2503 nName = sqlite3Strlen30(pTab->zName);
2504 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
2505 if( zName[nName]!='_' ) return 0;
drhf38524d2021-08-02 16:41:57 +00002506 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
drh3d863b52020-05-14 21:16:52 +00002507 if( pMod==0 ) return 0;
2508 if( pMod->pModule->iVersion<3 ) return 0;
2509 if( pMod->pModule->xShadowName==0 ) return 0;
2510 return pMod->pModule->xShadowName(zName+nName+1);
2511}
2512#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
2513
danf6e015f2018-11-28 08:02:28 +00002514#ifndef SQLITE_OMIT_VIRTUALTABLE
drhfdaac672013-10-04 15:30:21 +00002515/*
drhddfec002021-11-04 00:51:53 +00002516** Table pTab is a virtual table. If it the virtual table implementation
2517** exists and has an xShadowName method, then loop over all other ordinary
2518** tables within the same schema looking for shadow tables of pTab, and mark
2519** any shadow tables seen using the TF_Shadow flag.
2520*/
2521void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
2522 int nName; /* Length of pTab->zName */
2523 Module *pMod; /* Module for the virtual table */
2524 HashElem *k; /* For looping through the symbol table */
2525
2526 assert( IsVirtual(pTab) );
2527 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
2528 if( pMod==0 ) return;
2529 if( NEVER(pMod->pModule==0) ) return;
drh62561b82021-11-06 10:59:27 +00002530 if( pMod->pModule->iVersion<3 ) return;
drhddfec002021-11-04 00:51:53 +00002531 if( pMod->pModule->xShadowName==0 ) return;
2532 assert( pTab->zName!=0 );
2533 nName = sqlite3Strlen30(pTab->zName);
2534 for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
2535 Table *pOther = sqliteHashData(k);
2536 assert( pOther->zName!=0 );
2537 if( !IsOrdinaryTable(pOther) ) continue;
2538 if( pOther->tabFlags & TF_Shadow ) continue;
2539 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
2540 && pOther->zName[nName]=='_'
2541 && pMod->pModule->xShadowName(pOther->zName+nName+1)
2542 ){
2543 pOther->tabFlags |= TF_Shadow;
2544 }
2545 }
2546}
2547#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
2548
2549#ifndef SQLITE_OMIT_VIRTUALTABLE
2550/*
drh84c501b2018-11-05 23:01:45 +00002551** Return true if zName is a shadow table name in the current database
2552** connection.
2553**
2554** zName is temporarily modified while this routine is running, but is
2555** restored to its original value prior to this routine returning.
2556*/
drh527cbd42019-11-16 14:15:19 +00002557int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
drh84c501b2018-11-05 23:01:45 +00002558 char *zTail; /* Pointer to the last "_" in zName */
2559 Table *pTab; /* Table that zName is a shadow of */
drh84c501b2018-11-05 23:01:45 +00002560 zTail = strrchr(zName, '_');
2561 if( zTail==0 ) return 0;
2562 *zTail = 0;
2563 pTab = sqlite3FindTable(db, zName, 0);
2564 *zTail = '_';
2565 if( pTab==0 ) return 0;
2566 if( !IsVirtual(pTab) ) return 0;
drh3d863b52020-05-14 21:16:52 +00002567 return sqlite3IsShadowTableOf(db, pTab, zName);
drh84c501b2018-11-05 23:01:45 +00002568}
danf6e015f2018-11-28 08:02:28 +00002569#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
drh84c501b2018-11-05 23:01:45 +00002570
drh3d863b52020-05-14 21:16:52 +00002571
drhe7375bf2020-03-10 19:24:38 +00002572#ifdef SQLITE_DEBUG
2573/*
2574** Mark all nodes of an expression as EP_Immutable, indicating that
2575** they should not be changed. Expressions attached to a table or
2576** index definition are tagged this way to help ensure that we do
2577** not pass them into code generator routines by mistake.
2578*/
2579static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
2580 ExprSetVVAProperty(pExpr, EP_Immutable);
2581 return WRC_Continue;
2582}
2583static void markExprListImmutable(ExprList *pList){
2584 if( pList ){
2585 Walker w;
2586 memset(&w, 0, sizeof(w));
2587 w.xExprCallback = markImmutableExprStep;
2588 w.xSelectCallback = sqlite3SelectWalkNoop;
2589 w.xSelectCallback2 = 0;
2590 sqlite3WalkExprList(&w, pList);
2591 }
2592}
2593#else
2594#define markExprListImmutable(X) /* no-op */
2595#endif /* SQLITE_DEBUG */
2596
2597
drh84c501b2018-11-05 23:01:45 +00002598/*
drh75897232000-05-29 14:26:00 +00002599** This routine is called to report the final ")" that terminates
2600** a CREATE TABLE statement.
2601**
drhf57b3392001-10-08 13:22:32 +00002602** The table structure that other action routines have been building
2603** is added to the internal hash tables, assuming no errors have
2604** occurred.
drh75897232000-05-29 14:26:00 +00002605**
drh067b92b2020-06-19 15:24:12 +00002606** An entry for the table is made in the schema table on disk, unless
drh1d85d932004-02-14 23:05:52 +00002607** this is a temporary table or db->init.busy==1. When db->init.busy==1
drh1e32bed2020-06-19 13:33:53 +00002608** it means we are reading the sqlite_schema table because we just
2609** connected to the database or because the sqlite_schema table has
drhddba9e52005-03-19 01:41:21 +00002610** recently changed, so the entry for this table already exists in
drh1e32bed2020-06-19 13:33:53 +00002611** the sqlite_schema table. We do not want to create it again.
drh969fa7c2002-02-18 18:30:32 +00002612**
2613** If the pSelect argument is not NULL, it means that this routine
2614** was called to create a table generated from a
2615** "CREATE TABLE ... AS SELECT ..." statement. The column names of
2616** the new table will match the result set of the SELECT.
drh75897232000-05-29 14:26:00 +00002617*/
danielk197719a8e7e2005-03-17 05:03:38 +00002618void sqlite3EndTable(
2619 Parse *pParse, /* Parse context */
2620 Token *pCons, /* The ',' token after the last column defn. */
drh5969da42013-10-21 02:14:45 +00002621 Token *pEnd, /* The ')' before options in the CREATE TABLE */
drh44183f82021-08-18 13:13:58 +00002622 u32 tabOpts, /* Extra table options. Usually 0. */
danielk197719a8e7e2005-03-17 05:03:38 +00002623 Select *pSelect /* Select from a "CREATE ... AS SELECT" */
2624){
drhfdaac672013-10-04 15:30:21 +00002625 Table *p; /* The new table */
2626 sqlite3 *db = pParse->db; /* The database connection */
2627 int iDb; /* Database in which the table lives */
2628 Index *pIdx; /* An implied index of the table */
drh75897232000-05-29 14:26:00 +00002629
drh027616d2015-08-08 22:47:47 +00002630 if( pEnd==0 && pSelect==0 ){
drh5969da42013-10-21 02:14:45 +00002631 return;
danielk1977261919c2005-12-06 12:52:59 +00002632 }
drh28037572000-08-02 13:47:41 +00002633 p = pParse->pNewTable;
drh5969da42013-10-21 02:14:45 +00002634 if( p==0 ) return;
drh75897232000-05-29 14:26:00 +00002635
drh527cbd42019-11-16 14:15:19 +00002636 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
drh84c501b2018-11-05 23:01:45 +00002637 p->tabFlags |= TF_Shadow;
2638 }
2639
drhc6bd4e42013-11-02 14:37:18 +00002640 /* If the db->init.busy is 1 it means we are reading the SQL off the
drh1e32bed2020-06-19 13:33:53 +00002641 ** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
drhc6bd4e42013-11-02 14:37:18 +00002642 ** So do not write to the disk again. Extract the root page number
2643 ** for the table from the db->init.newTnum field. (The page number
2644 ** should have been put there by the sqliteOpenCb routine.)
drh055f2982016-01-15 15:06:41 +00002645 **
drh1e32bed2020-06-19 13:33:53 +00002646 ** If the root page number is 1, that means this is the sqlite_schema
drh055f2982016-01-15 15:06:41 +00002647 ** table itself. So mark it read-only.
drhc6bd4e42013-11-02 14:37:18 +00002648 */
2649 if( db->init.busy ){
drh54e3f942021-10-11 15:54:05 +00002650 if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){
drh1e9c47b2018-03-16 20:15:58 +00002651 sqlite3ErrorMsg(pParse, "");
2652 return;
2653 }
drhc6bd4e42013-11-02 14:37:18 +00002654 p->tnum = db->init.newTnum;
drh055f2982016-01-15 15:06:41 +00002655 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
drhc6bd4e42013-11-02 14:37:18 +00002656 }
2657
drh71c770f2021-08-19 16:29:33 +00002658 /* Special processing for tables that include the STRICT keyword:
2659 **
2660 ** * Do not allow custom column datatypes. Every column must have
2661 ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
2662 **
2663 ** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY,
2664 ** then all columns of the PRIMARY KEY must have a NOT NULL
2665 ** constraint.
2666 */
drh44183f82021-08-18 13:13:58 +00002667 if( tabOpts & TF_Strict ){
2668 int ii;
2669 p->tabFlags |= TF_Strict;
2670 for(ii=0; ii<p->nCol; ii++){
drhab165782021-08-19 00:24:43 +00002671 Column *pCol = &p->aCol[ii];
drhb9fd0102021-08-23 10:28:02 +00002672 if( pCol->eCType==COLTYPE_CUSTOM ){
2673 if( pCol->colFlags & COLFLAG_HASTYPE ){
2674 sqlite3ErrorMsg(pParse,
2675 "unknown datatype for %s.%s: \"%s\"",
2676 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
2677 );
2678 }else{
2679 sqlite3ErrorMsg(pParse, "missing datatype for %s.%s",
2680 p->zName, pCol->zCnName);
2681 }
drh44183f82021-08-18 13:13:58 +00002682 return;
drhb9fd0102021-08-23 10:28:02 +00002683 }else if( pCol->eCType==COLTYPE_ANY ){
2684 pCol->affinity = SQLITE_AFF_BLOB;
drh44183f82021-08-18 13:13:58 +00002685 }
drhab165782021-08-19 00:24:43 +00002686 if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0
2687 && p->iPKey!=ii
2688 && pCol->notNull == OE_None
2689 ){
drhab165782021-08-19 00:24:43 +00002690 pCol->notNull = OE_Abort;
2691 p->tabFlags |= TF_HasNotNull;
2692 }
drh44183f82021-08-18 13:13:58 +00002693 }
2694 }
2695
drh3cbd2b72019-02-19 13:51:58 +00002696 assert( (p->tabFlags & TF_HasPrimaryKey)==0
2697 || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
2698 assert( (p->tabFlags & TF_HasPrimaryKey)!=0
2699 || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
2700
drhc6bd4e42013-11-02 14:37:18 +00002701 /* Special processing for WITHOUT ROWID Tables */
drh5969da42013-10-21 02:14:45 +00002702 if( tabOpts & TF_WithoutRowid ){
drhd2fe3352013-11-09 18:15:35 +00002703 if( (p->tabFlags & TF_Autoincrement) ){
2704 sqlite3ErrorMsg(pParse,
2705 "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
2706 return;
2707 }
drh5969da42013-10-21 02:14:45 +00002708 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
drhd2fe3352013-11-09 18:15:35 +00002709 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
drh8e10d742019-10-18 17:42:47 +00002710 return;
drh81eba732013-10-19 23:31:56 +00002711 }
drh8e10d742019-10-18 17:42:47 +00002712 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
drhf95909c2019-10-18 18:33:25 +00002713 convertToWithoutRowidTable(pParse, p);
drh81eba732013-10-19 23:31:56 +00002714 }
drhb9bb7c12006-06-11 23:41:55 +00002715 iDb = sqlite3SchemaToIndex(db, p->pSchema);
danielk1977da184232006-01-05 11:34:32 +00002716
drhffe07b22005-11-03 00:41:17 +00002717#ifndef SQLITE_OMIT_CHECK
2718 /* Resolve names in all CHECK constraint expressions.
2719 */
2720 if( p->pCheck ){
drh3780be12013-07-31 19:05:22 +00002721 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
drh9524a7e2019-12-22 18:06:49 +00002722 if( pParse->nErr ){
2723 /* If errors are seen, delete the CHECK constraints now, else they might
2724 ** actually be used if PRAGMA writable_schema=ON is set. */
2725 sqlite3ExprListDelete(db, p->pCheck);
2726 p->pCheck = 0;
drhe7375bf2020-03-10 19:24:38 +00002727 }else{
2728 markExprListImmutable(p->pCheck);
drh9524a7e2019-12-22 18:06:49 +00002729 }
drhffe07b22005-11-03 00:41:17 +00002730 }
2731#endif /* !defined(SQLITE_OMIT_CHECK) */
drh81f7b372019-10-16 12:18:59 +00002732#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh427b96a2019-10-22 13:01:24 +00002733 if( p->tabFlags & TF_HasGenerated ){
drhf4658b62019-10-29 03:39:17 +00002734 int ii, nNG = 0;
drh427b96a2019-10-22 13:01:24 +00002735 testcase( p->tabFlags & TF_HasVirtual );
2736 testcase( p->tabFlags & TF_HasStored );
drh81f7b372019-10-16 12:18:59 +00002737 for(ii=0; ii<p->nCol; ii++){
drh0b0b3a92019-10-17 18:35:57 +00002738 u32 colFlags = p->aCol[ii].colFlags;
drh427b96a2019-10-22 13:01:24 +00002739 if( (colFlags & COLFLAG_GENERATED)!=0 ){
drh79cf2b72021-07-31 20:30:41 +00002740 Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]);
drh427b96a2019-10-22 13:01:24 +00002741 testcase( colFlags & COLFLAG_VIRTUAL );
2742 testcase( colFlags & COLFLAG_STORED );
drh7e3f1352019-12-14 19:55:31 +00002743 if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
2744 /* If there are errors in resolving the expression, change the
2745 ** expression to a NULL. This prevents code generators that operate
2746 ** on the expression from inserting extra parts into the expression
2747 ** tree that have been allocated from lookaside memory, which is
drh2d58b7f2020-01-17 23:27:41 +00002748 ** illegal in a schema and will lead to errors or heap corruption
2749 ** when the database connection closes. */
drh79cf2b72021-07-31 20:30:41 +00002750 sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii],
2751 sqlite3ExprAlloc(db, TK_NULL, 0, 0));
drh7e3f1352019-12-14 19:55:31 +00002752 }
drhf4658b62019-10-29 03:39:17 +00002753 }else{
2754 nNG++;
drh81f7b372019-10-16 12:18:59 +00002755 }
drh2c40a3e2019-10-29 01:26:24 +00002756 }
drhf4658b62019-10-29 03:39:17 +00002757 if( nNG==0 ){
2758 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
drh2c40a3e2019-10-29 01:26:24 +00002759 return;
drh81f7b372019-10-16 12:18:59 +00002760 }
2761 }
2762#endif
drhffe07b22005-11-03 00:41:17 +00002763
drhe13e9f52013-10-05 19:18:00 +00002764 /* Estimate the average row size for the table and for all implied indices */
2765 estimateTableWidth(p);
drhfdaac672013-10-04 15:30:21 +00002766 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhe13e9f52013-10-05 19:18:00 +00002767 estimateIndexWidth(pIdx);
drhfdaac672013-10-04 15:30:21 +00002768 }
2769
drhe3c41372001-09-17 20:25:58 +00002770 /* If not initializing, then create a record for the new table
drh346a70c2020-06-15 20:27:35 +00002771 ** in the schema table of the database.
drhf57b3392001-10-08 13:22:32 +00002772 **
drhe0bc4042002-06-25 01:09:11 +00002773 ** If this is a TEMPORARY table, write the entry into the auxiliary
2774 ** file instead of into the main database file.
drh75897232000-05-29 14:26:00 +00002775 */
drh1d85d932004-02-14 23:05:52 +00002776 if( !db->init.busy ){
drh4ff6dfa2002-03-03 23:06:00 +00002777 int n;
drhd8bc7082000-06-07 23:51:50 +00002778 Vdbe *v;
drh4794f732004-11-05 17:17:50 +00002779 char *zType; /* "view" or "table" */
2780 char *zType2; /* "VIEW" or "TABLE" */
2781 char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
drh75897232000-05-29 14:26:00 +00002782
danielk19774adee202004-05-08 08:23:19 +00002783 v = sqlite3GetVdbe(pParse);
drh5969da42013-10-21 02:14:45 +00002784 if( NEVER(v==0) ) return;
danielk1977517eb642004-06-07 10:00:31 +00002785
drh66a51672008-01-03 00:01:23 +00002786 sqlite3VdbeAddOp1(v, OP_Close, 0);
danielk1977e6efa742004-11-10 11:55:10 +00002787
drh0fa991b2009-03-21 16:19:26 +00002788 /*
2789 ** Initialize zType for the new view or table.
drh4794f732004-11-05 17:17:50 +00002790 */
drhf38524d2021-08-02 16:41:57 +00002791 if( IsOrdinaryTable(p) ){
drh4ff6dfa2002-03-03 23:06:00 +00002792 /* A regular table */
drh4794f732004-11-05 17:17:50 +00002793 zType = "table";
2794 zType2 = "TABLE";
danielk1977576ec6b2005-01-21 11:55:25 +00002795#ifndef SQLITE_OMIT_VIEW
drh4ff6dfa2002-03-03 23:06:00 +00002796 }else{
2797 /* A view */
drh4794f732004-11-05 17:17:50 +00002798 zType = "view";
2799 zType2 = "VIEW";
danielk1977576ec6b2005-01-21 11:55:25 +00002800#endif
drh4ff6dfa2002-03-03 23:06:00 +00002801 }
danielk1977517eb642004-06-07 10:00:31 +00002802
danielk1977517eb642004-06-07 10:00:31 +00002803 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
2804 ** statement to populate the new table. The root-page number for the
drh0fa991b2009-03-21 16:19:26 +00002805 ** new table is in register pParse->regRoot.
danielk1977517eb642004-06-07 10:00:31 +00002806 **
2807 ** Once the SELECT has been coded by sqlite3Select(), it is in a
2808 ** suitable state to query for the column names and types to be used
2809 ** by the new table.
danielk1977c00da102006-01-07 13:21:04 +00002810 **
2811 ** A shared-cache write-lock is not required to write to the new table,
2812 ** as a schema-lock must have already been obtained to create it. Since
2813 ** a schema-lock excludes all other database users, the write-lock would
2814 ** be redundant.
danielk1977517eb642004-06-07 10:00:31 +00002815 */
2816 if( pSelect ){
drh92632202015-05-20 17:18:29 +00002817 SelectDest dest; /* Where the SELECT should store results */
drh9df25c42015-05-20 15:51:09 +00002818 int regYield; /* Register holding co-routine entry-point */
2819 int addrTop; /* Top of the co-routine */
drh92632202015-05-20 17:18:29 +00002820 int regRec; /* A record to be insert into the new table */
2821 int regRowid; /* Rowid of the next row to insert */
2822 int addrInsLoop; /* Top of the loop for inserting rows */
2823 Table *pSelTab; /* A table that describes the SELECT results */
drh1013c932008-01-06 00:25:21 +00002824
drhfde30432022-03-10 21:04:49 +00002825 if( IN_SPECIAL_PARSE ){
2826 pParse->rc = SQLITE_ERROR;
2827 pParse->nErr++;
2828 return;
2829 }
drh9df25c42015-05-20 15:51:09 +00002830 regYield = ++pParse->nMem;
drh92632202015-05-20 17:18:29 +00002831 regRec = ++pParse->nMem;
2832 regRowid = ++pParse->nMem;
danielk19776ab3a2e2009-02-19 14:39:25 +00002833 assert(pParse->nTab==1);
drh0dd5cda2015-06-16 16:39:01 +00002834 sqlite3MayAbort(pParse);
drhb7654112008-01-12 12:48:07 +00002835 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
dan428c2182012-08-06 18:50:11 +00002836 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
danielk1977517eb642004-06-07 10:00:31 +00002837 pParse->nTab = 2;
drh9df25c42015-05-20 15:51:09 +00002838 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
2839 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
drh512795d2017-12-24 18:56:28 +00002840 if( pParse->nErr ) return;
drh81506b82019-08-05 19:32:06 +00002841 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB);
drh92632202015-05-20 17:18:29 +00002842 if( pSelTab==0 ) return;
2843 assert( p->aCol==0 );
drhf5f19152019-10-21 01:04:11 +00002844 p->nCol = p->nNVCol = pSelTab->nCol;
drh92632202015-05-20 17:18:29 +00002845 p->aCol = pSelTab->aCol;
2846 pSelTab->nCol = 0;
2847 pSelTab->aCol = 0;
2848 sqlite3DeleteTable(db, pSelTab);
drh755b0fd2017-12-23 12:33:40 +00002849 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
2850 sqlite3Select(pParse, pSelect, &dest);
drh5060a672017-12-25 13:43:54 +00002851 if( pParse->nErr ) return;
drh755b0fd2017-12-23 12:33:40 +00002852 sqlite3VdbeEndCoroutine(v, regYield);
2853 sqlite3VdbeJumpHere(v, addrTop - 1);
drh92632202015-05-20 17:18:29 +00002854 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
2855 VdbeCoverage(v);
2856 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
2857 sqlite3TableAffinity(v, p, 0);
2858 sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
2859 sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
drh076e85f2015-09-03 13:46:12 +00002860 sqlite3VdbeGoto(v, addrInsLoop);
drh92632202015-05-20 17:18:29 +00002861 sqlite3VdbeJumpHere(v, addrInsLoop);
2862 sqlite3VdbeAddOp1(v, OP_Close, 1);
danielk1977517eb642004-06-07 10:00:31 +00002863 }
drh4794f732004-11-05 17:17:50 +00002864
drh4794f732004-11-05 17:17:50 +00002865 /* Compute the complete text of the CREATE statement */
2866 if( pSelect ){
drh1d34fde2009-02-03 15:50:33 +00002867 zStmt = createTableStmt(db, p);
drh4794f732004-11-05 17:17:50 +00002868 }else{
drh8ea30bf2013-10-22 01:18:17 +00002869 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
2870 n = (int)(pEnd2->z - pParse->sNameToken.z);
2871 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
danielk19771e536952007-08-16 10:09:01 +00002872 zStmt = sqlite3MPrintf(db,
2873 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
2874 );
drh4794f732004-11-05 17:17:50 +00002875 }
2876
2877 /* A slot for the record has already been allocated in the
drh346a70c2020-06-15 20:27:35 +00002878 ** schema table. We just need to update that slot with all
drh0fa991b2009-03-21 16:19:26 +00002879 ** the information we've collected.
drh4794f732004-11-05 17:17:50 +00002880 */
2881 sqlite3NestedParse(pParse,
drha4a871c2021-11-04 14:04:20 +00002882 "UPDATE %Q." LEGACY_SCHEMA_TABLE
drh346a70c2020-06-15 20:27:35 +00002883 " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
2884 " WHERE rowid=#%d",
2885 db->aDb[iDb].zDbSName,
drh4794f732004-11-05 17:17:50 +00002886 zType,
2887 p->zName,
2888 p->zName,
drhb7654112008-01-12 12:48:07 +00002889 pParse->regRoot,
2890 zStmt,
2891 pParse->regRowid
drh4794f732004-11-05 17:17:50 +00002892 );
drh633e6d52008-07-28 19:34:53 +00002893 sqlite3DbFree(db, zStmt);
drh9cbf3422008-01-17 16:22:13 +00002894 sqlite3ChangeCookie(pParse, iDb);
drh2958a4e2004-11-12 03:56:15 +00002895
2896#ifndef SQLITE_OMIT_AUTOINCREMENT
2897 /* Check to see if we need to create an sqlite_sequence table for
2898 ** keeping track of autoincrement keys.
2899 */
dan755ed412021-04-07 12:02:30 +00002900 if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){
danielk1977da184232006-01-05 11:34:32 +00002901 Db *pDb = &db->aDb[iDb];
drh21206082011-04-04 18:22:02 +00002902 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danielk1977da184232006-01-05 11:34:32 +00002903 if( pDb->pSchema->pSeqTab==0 ){
drh2958a4e2004-11-12 03:56:15 +00002904 sqlite3NestedParse(pParse,
drhf3388142004-11-13 03:48:06 +00002905 "CREATE TABLE %Q.sqlite_sequence(name,seq)",
drh69c33822016-08-18 14:33:11 +00002906 pDb->zDbSName
drh2958a4e2004-11-12 03:56:15 +00002907 );
2908 }
2909 }
2910#endif
drh4794f732004-11-05 17:17:50 +00002911
2912 /* Reparse everything to update our internal data structures */
drh5d9c9da2011-06-03 20:11:17 +00002913 sqlite3VdbeAddParseSchemaOp(v, iDb,
dan6a5a13d2021-02-17 20:08:22 +00002914 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
drh75897232000-05-29 14:26:00 +00002915 }
drh17e9e292003-02-01 13:53:28 +00002916
2917 /* Add the table to the in-memory representation of the database.
2918 */
drh8af73d42009-05-13 22:58:28 +00002919 if( db->init.busy ){
drh17e9e292003-02-01 13:53:28 +00002920 Table *pOld;
danielk1977e501b892006-01-09 06:29:47 +00002921 Schema *pSchema = p->pSchema;
drh21206082011-04-04 18:22:02 +00002922 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh1bb89e92021-04-19 18:03:52 +00002923 assert( HasRowid(p) || p->iPKey<0 );
drhacbcb7e2014-08-21 20:26:37 +00002924 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
drh17e9e292003-02-01 13:53:28 +00002925 if( pOld ){
2926 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
drh4a642b62016-02-05 01:55:27 +00002927 sqlite3OomFault(db);
drh5969da42013-10-21 02:14:45 +00002928 return;
drh17e9e292003-02-01 13:53:28 +00002929 }
drh17e9e292003-02-01 13:53:28 +00002930 pParse->pNewTable = 0;
drh8257aa82017-07-26 19:59:13 +00002931 db->mDbFlags |= DBFLAG_SchemaChange;
dand4b64692021-04-06 16:16:15 +00002932
2933 /* If this is the magic sqlite_sequence table used by autoincrement,
2934 ** then record a pointer to this table in the main database structure
2935 ** so that INSERT can find the table easily. */
2936 assert( !pParse->nested );
2937#ifndef SQLITE_OMIT_AUTOINCREMENT
2938 if( strcmp(p->zName, "sqlite_sequence")==0 ){
2939 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2940 p->pSchema->pSeqTab = p;
2941 }
2942#endif
dan578277c2021-02-19 18:39:32 +00002943 }
danielk197719a8e7e2005-03-17 05:03:38 +00002944
2945#ifndef SQLITE_OMIT_ALTERTABLE
drhf38524d2021-08-02 16:41:57 +00002946 if( !pSelect && IsOrdinaryTable(p) ){
dan578277c2021-02-19 18:39:32 +00002947 assert( pCons && pEnd );
2948 if( pCons->z==0 ){
2949 pCons = pEnd;
danielk197719a8e7e2005-03-17 05:03:38 +00002950 }
drhf38524d2021-08-02 16:41:57 +00002951 p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z);
drh17e9e292003-02-01 13:53:28 +00002952 }
dan578277c2021-02-19 18:39:32 +00002953#endif
drh75897232000-05-29 14:26:00 +00002954}
2955
drhb7f91642004-10-31 02:22:47 +00002956#ifndef SQLITE_OMIT_VIEW
drh75897232000-05-29 14:26:00 +00002957/*
drha76b5df2002-02-23 02:32:10 +00002958** The parser calls this routine in order to create a new VIEW
2959*/
danielk19774adee202004-05-08 08:23:19 +00002960void sqlite3CreateView(
drha76b5df2002-02-23 02:32:10 +00002961 Parse *pParse, /* The parsing context */
2962 Token *pBegin, /* The CREATE token that begins the statement */
danielk197748dec7e2004-05-28 12:33:30 +00002963 Token *pName1, /* The token that holds the name of the view */
2964 Token *pName2, /* The token that holds the name of the view */
drh8981b902015-08-24 17:42:49 +00002965 ExprList *pCNames, /* Optional list of view column names */
drh6276c1c2002-07-08 22:03:32 +00002966 Select *pSelect, /* A SELECT statement that will become the new view */
drhfdd48a72006-09-11 23:45:48 +00002967 int isTemp, /* TRUE for a TEMPORARY view */
2968 int noErr /* Suppress error messages if VIEW already exists */
drha76b5df2002-02-23 02:32:10 +00002969){
drha76b5df2002-02-23 02:32:10 +00002970 Table *p;
drh4b59ab52002-08-24 18:24:51 +00002971 int n;
drhb7916a72009-05-27 10:31:29 +00002972 const char *z;
drh4b59ab52002-08-24 18:24:51 +00002973 Token sEnd;
drhf26e09c2003-05-31 16:21:12 +00002974 DbFixer sFix;
drh88caeac2011-08-24 15:12:08 +00002975 Token *pName = 0;
danielk1977da184232006-01-05 11:34:32 +00002976 int iDb;
drh17435752007-08-16 04:30:38 +00002977 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +00002978
drh7c3d64f2005-06-06 15:32:08 +00002979 if( pParse->nVar>0 ){
2980 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
drh32498f12015-09-26 11:15:44 +00002981 goto create_view_fail;
drh7c3d64f2005-06-06 15:32:08 +00002982 }
drhfdd48a72006-09-11 23:45:48 +00002983 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
drha76b5df2002-02-23 02:32:10 +00002984 p = pParse->pNewTable;
drh8981b902015-08-24 17:42:49 +00002985 if( p==0 || pParse->nErr ) goto create_view_fail;
drh6e5020e2021-04-07 15:45:01 +00002986
2987 /* Legacy versions of SQLite allowed the use of the magic "rowid" column
2988 ** on a view, even though views do not have rowids. The following flag
2989 ** setting fixes this problem. But the fix can be disabled by compiling
2990 ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
2991 ** depend upon the old buggy behavior. */
2992#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
drha6c54de2021-04-06 19:13:44 +00002993 p->tabFlags |= TF_NoVisibleRowid;
drh6e5020e2021-04-07 15:45:01 +00002994#endif
2995
danielk1977ef2cb632004-05-29 02:37:19 +00002996 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
drh17435752007-08-16 04:30:38 +00002997 iDb = sqlite3SchemaToIndex(db, p->pSchema);
drhd100f692013-10-03 15:39:44 +00002998 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
drh8981b902015-08-24 17:42:49 +00002999 if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
drh174b6192002-12-03 02:22:52 +00003000
drh4b59ab52002-08-24 18:24:51 +00003001 /* Make a copy of the entire SELECT statement that defines the view.
3002 ** This will force all the Expr.token.z values to be dynamically
3003 ** allocated rather than point to the input string - which means that
danielk197724b03fd2004-05-10 10:34:34 +00003004 ** they will persist after the current sqlite3_exec() call returns.
drh4b59ab52002-08-24 18:24:51 +00003005 */
dan38096962019-12-09 08:13:43 +00003006 pSelect->selFlags |= SF_View;
danc9461ec2018-08-29 21:00:16 +00003007 if( IN_RENAME_OBJECT ){
drhf38524d2021-08-02 16:41:57 +00003008 p->u.view.pSelect = pSelect;
dan987db762018-08-14 20:18:50 +00003009 pSelect = 0;
3010 }else{
drhf38524d2021-08-02 16:41:57 +00003011 p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
dan987db762018-08-14 20:18:50 +00003012 }
drh8981b902015-08-24 17:42:49 +00003013 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
drhf38524d2021-08-02 16:41:57 +00003014 p->eTabType = TABTYP_VIEW;
drh8981b902015-08-24 17:42:49 +00003015 if( db->mallocFailed ) goto create_view_fail;
drh4b59ab52002-08-24 18:24:51 +00003016
3017 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
3018 ** the end.
3019 */
drha76b5df2002-02-23 02:32:10 +00003020 sEnd = pParse->sLastToken;
drh6116ee42018-01-10 00:40:06 +00003021 assert( sEnd.z[0]!=0 || sEnd.n==0 );
drh8981b902015-08-24 17:42:49 +00003022 if( sEnd.z[0]!=';' ){
drha76b5df2002-02-23 02:32:10 +00003023 sEnd.z += sEnd.n;
3024 }
3025 sEnd.n = 0;
drh1bd10f82008-12-10 21:19:56 +00003026 n = (int)(sEnd.z - pBegin->z);
drh8981b902015-08-24 17:42:49 +00003027 assert( n>0 );
drhb7916a72009-05-27 10:31:29 +00003028 z = pBegin->z;
drh8981b902015-08-24 17:42:49 +00003029 while( sqlite3Isspace(z[n-1]) ){ n--; }
drh4ff6dfa2002-03-03 23:06:00 +00003030 sEnd.z = &z[n-1];
3031 sEnd.n = 1;
drh4b59ab52002-08-24 18:24:51 +00003032
drh346a70c2020-06-15 20:27:35 +00003033 /* Use sqlite3EndTable() to add the view to the schema table */
drh5969da42013-10-21 02:14:45 +00003034 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
drh8981b902015-08-24 17:42:49 +00003035
3036create_view_fail:
3037 sqlite3SelectDelete(db, pSelect);
dane8ab40d2018-09-12 08:51:48 +00003038 if( IN_RENAME_OBJECT ){
3039 sqlite3RenameExprlistUnmap(pParse, pCNames);
3040 }
drh8981b902015-08-24 17:42:49 +00003041 sqlite3ExprListDelete(db, pCNames);
drha76b5df2002-02-23 02:32:10 +00003042 return;
drh417be792002-03-03 18:59:40 +00003043}
drhb7f91642004-10-31 02:22:47 +00003044#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00003045
danielk1977fe3fcbe22006-06-12 12:08:45 +00003046#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
drh417be792002-03-03 18:59:40 +00003047/*
3048** The Table structure pTable is really a VIEW. Fill in the names of
3049** the columns of the view in the pTable structure. Return the number
jplyoncfa56842004-01-19 04:55:56 +00003050** of errors. If an error is seen leave an error message in pParse->zErrMsg.
drh417be792002-03-03 18:59:40 +00003051*/
drhef69d2b2022-07-25 22:31:04 +00003052static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){
drh9b3187e2005-01-18 14:45:47 +00003053 Table *pSelTab; /* A fake table from which we get the result set */
3054 Select *pSel; /* Copy of the SELECT that implements the view */
3055 int nErr = 0; /* Number of errors encountered */
drh17435752007-08-16 04:30:38 +00003056 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
drh424981d2018-03-28 15:56:55 +00003057#ifndef SQLITE_OMIT_VIRTUALTABLE
drhdc6b41e2017-08-17 02:26:35 +00003058 int rc;
3059#endif
drha0daa752016-09-16 11:53:10 +00003060#ifndef SQLITE_OMIT_AUTHORIZATION
drh32c6a482014-09-11 13:44:52 +00003061 sqlite3_xauth xAuth; /* Saved xAuth pointer */
drha0daa752016-09-16 11:53:10 +00003062#endif
drh417be792002-03-03 18:59:40 +00003063
3064 assert( pTable );
3065
danielk1977fe3fcbe22006-06-12 12:08:45 +00003066#ifndef SQLITE_OMIT_VIRTUALTABLE
drhddfec002021-11-04 00:51:53 +00003067 if( IsVirtual(pTable) ){
3068 db->nSchemaLock++;
3069 rc = sqlite3VtabCallConnect(pParse, pTable);
3070 db->nSchemaLock--;
3071 return rc;
danielk1977fe3fcbe22006-06-12 12:08:45 +00003072 }
danielk1977fe3fcbe22006-06-12 12:08:45 +00003073#endif
3074
3075#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00003076 /* A positive nCol means the columns names for this view are
drh509a6302022-07-25 23:01:41 +00003077 ** already known. This routine is not called unless either the
3078 ** table is virtual or nCol is zero.
drh417be792002-03-03 18:59:40 +00003079 */
drh509a6302022-07-25 23:01:41 +00003080 assert( pTable->nCol<=0 );
drh417be792002-03-03 18:59:40 +00003081
3082 /* A negative nCol is a special marker meaning that we are currently
3083 ** trying to compute the column names. If we enter this routine with
3084 ** a negative nCol, it means two or more views form a loop, like this:
3085 **
3086 ** CREATE VIEW one AS SELECT * FROM two;
3087 ** CREATE VIEW two AS SELECT * FROM one;
drh3b167c72002-06-28 12:18:47 +00003088 **
drh768578e2009-05-12 00:40:12 +00003089 ** Actually, the error above is now caught prior to reaching this point.
3090 ** But the following test is still important as it does come up
3091 ** in the following:
3092 **
3093 ** CREATE TABLE main.ex1(a);
3094 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
3095 ** SELECT * FROM temp.ex1;
drh417be792002-03-03 18:59:40 +00003096 */
3097 if( pTable->nCol<0 ){
danielk19774adee202004-05-08 08:23:19 +00003098 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
drh417be792002-03-03 18:59:40 +00003099 return 1;
3100 }
drh85c23c62005-08-20 03:03:04 +00003101 assert( pTable->nCol>=0 );
drh417be792002-03-03 18:59:40 +00003102
3103 /* If we get this far, it means we need to compute the table names.
drh9b3187e2005-01-18 14:45:47 +00003104 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
3105 ** "*" elements in the results set of the view and will assign cursors
3106 ** to the elements of the FROM clause. But we do not want these changes
3107 ** to be permanent. So the computation is done on a copy of the SELECT
3108 ** statement that defines the view.
drh417be792002-03-03 18:59:40 +00003109 */
drhf38524d2021-08-02 16:41:57 +00003110 assert( IsView(pTable) );
3111 pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0);
drhed06a132016-04-05 20:59:12 +00003112 if( pSel ){
dan02083372018-09-17 08:27:23 +00003113 u8 eParseMode = pParse->eParseMode;
drh7f417562022-04-25 14:49:48 +00003114 int nTab = pParse->nTab;
3115 int nSelect = pParse->nSelect;
dan02083372018-09-17 08:27:23 +00003116 pParse->eParseMode = PARSE_MODE_NORMAL;
drhed06a132016-04-05 20:59:12 +00003117 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
3118 pTable->nCol = -1;
drh31f69622019-10-05 14:39:36 +00003119 DisableLookaside;
danielk1977db2d2862007-10-15 07:08:44 +00003120#ifndef SQLITE_OMIT_AUTHORIZATION
drhed06a132016-04-05 20:59:12 +00003121 xAuth = db->xAuth;
3122 db->xAuth = 0;
drh96fb16e2019-08-06 14:37:24 +00003123 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
drhed06a132016-04-05 20:59:12 +00003124 db->xAuth = xAuth;
danielk1977db2d2862007-10-15 07:08:44 +00003125#else
drh96fb16e2019-08-06 14:37:24 +00003126 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
danielk1977db2d2862007-10-15 07:08:44 +00003127#endif
drh7f417562022-04-25 14:49:48 +00003128 pParse->nTab = nTab;
3129 pParse->nSelect = nSelect;
dan5d591022019-12-28 08:26:47 +00003130 if( pSelTab==0 ){
3131 pTable->nCol = 0;
3132 nErr++;
3133 }else if( pTable->pCheck ){
drhed06a132016-04-05 20:59:12 +00003134 /* CREATE VIEW name(arglist) AS ...
3135 ** The names of the columns in the table are taken from
3136 ** arglist which is stored in pTable->pCheck. The pCheck field
3137 ** normally holds CHECK constraints on an ordinary table, but for
3138 ** a VIEW it holds the list of column names.
3139 */
3140 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
3141 &pTable->nCol, &pTable->aCol);
drh0c7d3d32022-01-24 16:47:12 +00003142 if( pParse->nErr==0
drhed06a132016-04-05 20:59:12 +00003143 && pTable->nCol==pSel->pEList->nExpr
3144 ){
drh0c7d3d32022-01-24 16:47:12 +00003145 assert( db->mallocFailed==0 );
drh9e660872022-12-13 15:54:43 +00003146 sqlite3SubqueryColumnTypes(pParse, pTable, pSel, SQLITE_AFF_NONE);
drh8981b902015-08-24 17:42:49 +00003147 }
dan5d591022019-12-28 08:26:47 +00003148 }else{
drhed06a132016-04-05 20:59:12 +00003149 /* CREATE VIEW name AS... without an argument list. Construct
3150 ** the column names from the SELECT statement that defines the view.
3151 */
3152 assert( pTable->aCol==0 );
drh03836612019-11-02 17:59:10 +00003153 pTable->nCol = pSelTab->nCol;
drhed06a132016-04-05 20:59:12 +00003154 pTable->aCol = pSelTab->aCol;
dan3dc864b2021-02-25 16:55:47 +00003155 pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT);
drhed06a132016-04-05 20:59:12 +00003156 pSelTab->nCol = 0;
3157 pSelTab->aCol = 0;
3158 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
danielk1977261919c2005-12-06 12:52:59 +00003159 }
drh03836612019-11-02 17:59:10 +00003160 pTable->nNVCol = pTable->nCol;
drhe8da01c2016-05-07 12:15:34 +00003161 sqlite3DeleteTable(db, pSelTab);
drhed06a132016-04-05 20:59:12 +00003162 sqlite3SelectDelete(db, pSel);
drh31f69622019-10-05 14:39:36 +00003163 EnableLookaside;
dan02083372018-09-17 08:27:23 +00003164 pParse->eParseMode = eParseMode;
drhed06a132016-04-05 20:59:12 +00003165 } else {
3166 nErr++;
drh417be792002-03-03 18:59:40 +00003167 }
drh8981b902015-08-24 17:42:49 +00003168 pTable->pSchema->schemaFlags |= DB_UnresetViews;
dan77f3f402018-07-09 18:55:44 +00003169 if( db->mallocFailed ){
3170 sqlite3DeleteColumnNames(db, pTable);
dan77f3f402018-07-09 18:55:44 +00003171 }
drhb7f91642004-10-31 02:22:47 +00003172#endif /* SQLITE_OMIT_VIEW */
danielk19774b2688a2006-06-20 11:01:07 +00003173 return nErr;
danielk1977fe3fcbe22006-06-12 12:08:45 +00003174}
drhef69d2b2022-07-25 22:31:04 +00003175int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
3176 assert( pTable!=0 );
3177 if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0;
3178 return viewGetColumnNames(pParse, pTable);
3179}
danielk1977fe3fcbe22006-06-12 12:08:45 +00003180#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
drh417be792002-03-03 18:59:40 +00003181
drhb7f91642004-10-31 02:22:47 +00003182#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00003183/*
drh8bf8dc92003-05-17 17:35:10 +00003184** Clear the column names from every VIEW in database idx.
drh417be792002-03-03 18:59:40 +00003185*/
drh9bb575f2004-09-06 17:24:11 +00003186static void sqliteViewResetAll(sqlite3 *db, int idx){
drh417be792002-03-03 18:59:40 +00003187 HashElem *i;
drh21206082011-04-04 18:22:02 +00003188 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
drh8bf8dc92003-05-17 17:35:10 +00003189 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
danielk1977da184232006-01-05 11:34:32 +00003190 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
drh417be792002-03-03 18:59:40 +00003191 Table *pTab = sqliteHashData(i);
drhf38524d2021-08-02 16:41:57 +00003192 if( IsView(pTab) ){
drh51be3872015-08-19 02:32:25 +00003193 sqlite3DeleteColumnNames(db, pTab);
drh417be792002-03-03 18:59:40 +00003194 }
3195 }
drh8bf8dc92003-05-17 17:35:10 +00003196 DbClearProperty(db, idx, DB_UnresetViews);
drha76b5df2002-02-23 02:32:10 +00003197}
drhb7f91642004-10-31 02:22:47 +00003198#else
3199# define sqliteViewResetAll(A,B)
3200#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00003201
drh75897232000-05-29 14:26:00 +00003202/*
danielk1977a0bf2652004-11-04 14:30:04 +00003203** This function is called by the VDBE to adjust the internal schema
3204** used by SQLite when the btree layer moves a table root page. The
3205** root-page of a table or index in database iDb has changed from iFrom
3206** to iTo.
drh6205d4a2006-03-24 03:36:26 +00003207**
3208** Ticket #1728: The symbol table might still contain information
3209** on tables and/or indices that are the process of being deleted.
3210** If you are unlucky, one of those deleted indices or tables might
3211** have the same rootpage number as the real table or index that is
3212** being moved. So we cannot stop searching after the first match
3213** because the first match might be for one of the deleted indices
3214** or tables and not the table/index that is actually being moved.
3215** We must continue looping until all tables and indices with
3216** rootpage==iFrom have been converted to have a rootpage of iTo
3217** in order to be certain that we got the right one.
danielk1977a0bf2652004-11-04 14:30:04 +00003218*/
3219#ifndef SQLITE_OMIT_AUTOVACUUM
drhabc38152020-07-22 13:38:04 +00003220void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
danielk1977a0bf2652004-11-04 14:30:04 +00003221 HashElem *pElem;
danielk1977da184232006-01-05 11:34:32 +00003222 Hash *pHash;
drhcdf011d2011-04-04 21:25:28 +00003223 Db *pDb;
danielk1977da184232006-01-05 11:34:32 +00003224
drhcdf011d2011-04-04 21:25:28 +00003225 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
3226 pDb = &db->aDb[iDb];
danielk1977da184232006-01-05 11:34:32 +00003227 pHash = &pDb->pSchema->tblHash;
3228 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00003229 Table *pTab = sqliteHashData(pElem);
3230 if( pTab->tnum==iFrom ){
3231 pTab->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00003232 }
3233 }
danielk1977da184232006-01-05 11:34:32 +00003234 pHash = &pDb->pSchema->idxHash;
3235 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00003236 Index *pIdx = sqliteHashData(pElem);
3237 if( pIdx->tnum==iFrom ){
3238 pIdx->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00003239 }
3240 }
danielk1977a0bf2652004-11-04 14:30:04 +00003241}
3242#endif
3243
3244/*
3245** Write code to erase the table with root-page iTable from database iDb.
drh1e32bed2020-06-19 13:33:53 +00003246** Also write code to modify the sqlite_schema table and internal schema
danielk1977a0bf2652004-11-04 14:30:04 +00003247** if a root-page of another table is moved by the btree-layer whilst
3248** erasing iTable (this can happen with an auto-vacuum database).
3249*/
drh4e0cff62004-11-05 05:10:28 +00003250static void destroyRootPage(Parse *pParse, int iTable, int iDb){
3251 Vdbe *v = sqlite3GetVdbe(pParse);
drhb7654112008-01-12 12:48:07 +00003252 int r1 = sqlite3GetTempReg(pParse);
drh19918882020-07-30 23:47:00 +00003253 if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
drhb7654112008-01-12 12:48:07 +00003254 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
dane0af83a2009-09-08 19:15:01 +00003255 sqlite3MayAbort(pParse);
drh40e016e2004-11-04 14:47:11 +00003256#ifndef SQLITE_OMIT_AUTOVACUUM
drhb7654112008-01-12 12:48:07 +00003257 /* OP_Destroy stores an in integer r1. If this integer
drh4e0cff62004-11-05 05:10:28 +00003258 ** is non-zero, then it is the root page number of a table moved to
drh1e32bed2020-06-19 13:33:53 +00003259 ** location iTable. The following code modifies the sqlite_schema table to
drh4e0cff62004-11-05 05:10:28 +00003260 ** reflect this.
3261 **
drh0fa991b2009-03-21 16:19:26 +00003262 ** The "#NNN" in the SQL is a special constant that means whatever value
drhb74b1012009-05-28 21:04:37 +00003263 ** is in register NNN. See grammar rules associated with the TK_REGISTER
3264 ** token for additional information.
drh4e0cff62004-11-05 05:10:28 +00003265 */
danielk197763e3e9f2004-11-05 09:19:27 +00003266 sqlite3NestedParse(pParse,
drha4a871c2021-11-04 14:04:20 +00003267 "UPDATE %Q." LEGACY_SCHEMA_TABLE
drh346a70c2020-06-15 20:27:35 +00003268 " SET rootpage=%d WHERE #%d AND rootpage=#%d",
3269 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00003270#endif
drhb7654112008-01-12 12:48:07 +00003271 sqlite3ReleaseTempReg(pParse, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00003272}
3273
3274/*
3275** Write VDBE code to erase table pTab and all associated indices on disk.
drh1e32bed2020-06-19 13:33:53 +00003276** Code to update the sqlite_schema tables and internal schema definitions
danielk1977a0bf2652004-11-04 14:30:04 +00003277** in case a root-page belonging to another table is moved by the btree layer
3278** is also added (this can happen with an auto-vacuum database).
3279*/
drh4e0cff62004-11-05 05:10:28 +00003280static void destroyTable(Parse *pParse, Table *pTab){
danielk1977a0bf2652004-11-04 14:30:04 +00003281 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
3282 ** is not defined), then it is important to call OP_Destroy on the
3283 ** table and index root-pages in order, starting with the numerically
3284 ** largest root-page number. This guarantees that none of the root-pages
3285 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
3286 ** following were coded:
3287 **
3288 ** OP_Destroy 4 0
3289 ** ...
3290 ** OP_Destroy 5 0
3291 **
3292 ** and root page 5 happened to be the largest root-page number in the
3293 ** database, then root page 5 would be moved to page 4 by the
3294 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
3295 ** a free-list page.
3296 */
drhabc38152020-07-22 13:38:04 +00003297 Pgno iTab = pTab->tnum;
drh8deae5a2020-07-29 12:23:20 +00003298 Pgno iDestroyed = 0;
danielk1977a0bf2652004-11-04 14:30:04 +00003299
3300 while( 1 ){
3301 Index *pIdx;
drh8deae5a2020-07-29 12:23:20 +00003302 Pgno iLargest = 0;
danielk1977a0bf2652004-11-04 14:30:04 +00003303
3304 if( iDestroyed==0 || iTab<iDestroyed ){
3305 iLargest = iTab;
3306 }
3307 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
drhabc38152020-07-22 13:38:04 +00003308 Pgno iIdx = pIdx->tnum;
danielk1977da184232006-01-05 11:34:32 +00003309 assert( pIdx->pSchema==pTab->pSchema );
danielk1977a0bf2652004-11-04 14:30:04 +00003310 if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
3311 iLargest = iIdx;
3312 }
3313 }
danielk1977da184232006-01-05 11:34:32 +00003314 if( iLargest==0 ){
3315 return;
3316 }else{
3317 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drh5a05be12012-10-09 18:51:44 +00003318 assert( iDb>=0 && iDb<pParse->db->nDb );
danielk1977da184232006-01-05 11:34:32 +00003319 destroyRootPage(pParse, iLargest, iDb);
3320 iDestroyed = iLargest;
3321 }
danielk1977a0bf2652004-11-04 14:30:04 +00003322 }
danielk1977a0bf2652004-11-04 14:30:04 +00003323}
3324
3325/*
drh74e7c8f2011-10-21 19:06:32 +00003326** Remove entries from the sqlite_statN tables (for N in (1,2,3))
drha5ae4c32011-08-07 01:31:52 +00003327** after a DROP INDEX or DROP TABLE command.
3328*/
3329static void sqlite3ClearStatTables(
3330 Parse *pParse, /* The parsing context */
3331 int iDb, /* The database number */
3332 const char *zType, /* "idx" or "tbl" */
3333 const char *zName /* Name of index or table */
3334){
drha5ae4c32011-08-07 01:31:52 +00003335 int i;
drh69c33822016-08-18 14:33:11 +00003336 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
danf52bb8d2013-08-03 20:24:58 +00003337 for(i=1; i<=4; i++){
drh74e7c8f2011-10-21 19:06:32 +00003338 char zTab[24];
3339 sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
3340 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
drha5ae4c32011-08-07 01:31:52 +00003341 sqlite3NestedParse(pParse,
3342 "DELETE FROM %Q.%s WHERE %s=%Q",
drh74e7c8f2011-10-21 19:06:32 +00003343 zDbName, zTab, zType, zName
drha5ae4c32011-08-07 01:31:52 +00003344 );
3345 }
3346 }
3347}
3348
3349/*
drhfaacf172011-08-12 01:51:45 +00003350** Generate code to drop a table.
3351*/
3352void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
3353 Vdbe *v;
3354 sqlite3 *db = pParse->db;
3355 Trigger *pTrigger;
3356 Db *pDb = &db->aDb[iDb];
3357
3358 v = sqlite3GetVdbe(pParse);
3359 assert( v!=0 );
3360 sqlite3BeginWriteOperation(pParse, 1, iDb);
3361
3362#ifndef SQLITE_OMIT_VIRTUALTABLE
3363 if( IsVirtual(pTab) ){
3364 sqlite3VdbeAddOp0(v, OP_VBegin);
3365 }
3366#endif
3367
3368 /* Drop all triggers associated with the table being dropped. Code
drh1e32bed2020-06-19 13:33:53 +00003369 ** is generated to remove entries from sqlite_schema and/or
3370 ** sqlite_temp_schema if required.
drhfaacf172011-08-12 01:51:45 +00003371 */
3372 pTrigger = sqlite3TriggerList(pParse, pTab);
3373 while( pTrigger ){
3374 assert( pTrigger->pSchema==pTab->pSchema ||
3375 pTrigger->pSchema==db->aDb[1].pSchema );
3376 sqlite3DropTriggerPtr(pParse, pTrigger);
3377 pTrigger = pTrigger->pNext;
3378 }
3379
3380#ifndef SQLITE_OMIT_AUTOINCREMENT
3381 /* Remove any entries of the sqlite_sequence table associated with
3382 ** the table being dropped. This is done before the table is dropped
3383 ** at the btree level, in case the sqlite_sequence table needs to
3384 ** move as a result of the drop (can happen in auto-vacuum mode).
3385 */
3386 if( pTab->tabFlags & TF_Autoincrement ){
3387 sqlite3NestedParse(pParse,
3388 "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
drh69c33822016-08-18 14:33:11 +00003389 pDb->zDbSName, pTab->zName
drhfaacf172011-08-12 01:51:45 +00003390 );
3391 }
3392#endif
3393
drh346a70c2020-06-15 20:27:35 +00003394 /* Drop all entries in the schema table that refer to the
drh067b92b2020-06-19 15:24:12 +00003395 ** table. The program name loops through the schema table and deletes
drhfaacf172011-08-12 01:51:45 +00003396 ** every row that refers to a table of the same name as the one being
mistachkin48864df2013-03-21 21:20:32 +00003397 ** dropped. Triggers are handled separately because a trigger can be
drhfaacf172011-08-12 01:51:45 +00003398 ** created in the temp database that refers to a table in another
3399 ** database.
3400 */
3401 sqlite3NestedParse(pParse,
drha4a871c2021-11-04 14:04:20 +00003402 "DELETE FROM %Q." LEGACY_SCHEMA_TABLE
drh346a70c2020-06-15 20:27:35 +00003403 " WHERE tbl_name=%Q and type!='trigger'",
3404 pDb->zDbSName, pTab->zName);
drhfaacf172011-08-12 01:51:45 +00003405 if( !isView && !IsVirtual(pTab) ){
3406 destroyTable(pParse, pTab);
3407 }
3408
3409 /* Remove the table entry from SQLite's internal schema and modify
3410 ** the schema cookie.
3411 */
3412 if( IsVirtual(pTab) ){
3413 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
dan1d4b1642018-12-28 17:45:08 +00003414 sqlite3MayAbort(pParse);
drhfaacf172011-08-12 01:51:45 +00003415 }
3416 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
3417 sqlite3ChangeCookie(pParse, iDb);
3418 sqliteViewResetAll(db, iDb);
drhfaacf172011-08-12 01:51:45 +00003419}
3420
3421/*
drh070ae3b2019-11-16 13:51:31 +00003422** Return TRUE if shadow tables should be read-only in the current
3423** context.
3424*/
3425int sqlite3ReadOnlyShadowTables(sqlite3 *db){
3426#ifndef SQLITE_OMIT_VIRTUALTABLE
3427 if( (db->flags & SQLITE_Defensive)!=0
3428 && db->pVtabCtx==0
3429 && db->nVdbeExec==0
dan73983652021-07-19 14:00:29 +00003430 && !sqlite3VtabInSync(db)
drh070ae3b2019-11-16 13:51:31 +00003431 ){
3432 return 1;
3433 }
3434#endif
3435 return 0;
3436}
3437
3438/*
drhd0c51d12019-11-16 12:04:38 +00003439** Return true if it is not allowed to drop the given table
3440*/
drh070ae3b2019-11-16 13:51:31 +00003441static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
drhd0c51d12019-11-16 12:04:38 +00003442 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
3443 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
3444 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
3445 return 1;
3446 }
drh070ae3b2019-11-16 13:51:31 +00003447 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
3448 return 1;
drhd0c51d12019-11-16 12:04:38 +00003449 }
dan35c73122021-11-06 18:22:50 +00003450 if( pTab->tabFlags & TF_Eponymous ){
3451 return 1;
3452 }
drhd0c51d12019-11-16 12:04:38 +00003453 return 0;
3454}
3455
3456/*
drh75897232000-05-29 14:26:00 +00003457** This routine is called to do the work of a DROP TABLE statement.
drhd9b02572001-04-15 00:37:09 +00003458** pName is the name of the table to be dropped.
drh75897232000-05-29 14:26:00 +00003459*/
drha0733842005-12-29 01:11:36 +00003460void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
danielk1977a8858102004-05-28 12:11:21 +00003461 Table *pTab;
drh75897232000-05-29 14:26:00 +00003462 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00003463 sqlite3 *db = pParse->db;
drhd24cc422003-03-27 12:51:24 +00003464 int iDb;
drh75897232000-05-29 14:26:00 +00003465
drh8af73d42009-05-13 22:58:28 +00003466 if( db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +00003467 goto exit_drop_table;
3468 }
drh8af73d42009-05-13 22:58:28 +00003469 assert( pParse->nErr==0 );
danielk1977a8858102004-05-28 12:11:21 +00003470 assert( pName->nSrc==1 );
drh75209962015-04-19 22:31:45 +00003471 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
drha7564662010-02-22 19:32:31 +00003472 if( noErr ) db->suppressErr++;
drh4d249e62016-06-10 22:49:01 +00003473 assert( isView==0 || isView==LOCATE_VIEW );
dan41fb5cd2012-10-04 19:33:00 +00003474 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
drha7564662010-02-22 19:32:31 +00003475 if( noErr ) db->suppressErr--;
danielk1977a8858102004-05-28 12:11:21 +00003476
drha0733842005-12-29 01:11:36 +00003477 if( pTab==0 ){
drh31da7be2021-05-13 18:24:22 +00003478 if( noErr ){
3479 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
3480 sqlite3ForceNotReadOnly(pParse);
3481 }
drha0733842005-12-29 01:11:36 +00003482 goto exit_drop_table;
3483 }
danielk1977da184232006-01-05 11:34:32 +00003484 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drhe22a3342003-04-22 20:30:37 +00003485 assert( iDb>=0 && iDb<db->nDb );
danielk1977b5258c32007-10-04 18:11:15 +00003486
3487 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
3488 ** it is initialized.
3489 */
3490 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
3491 goto exit_drop_table;
3492 }
drhe5f9c642003-01-13 23:27:31 +00003493#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +00003494 {
3495 int code;
danielk1977da184232006-01-05 11:34:32 +00003496 const char *zTab = SCHEMA_TABLE(iDb);
drh69c33822016-08-18 14:33:11 +00003497 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977f1a381e2006-06-16 08:01:02 +00003498 const char *zArg2 = 0;
danielk19774adee202004-05-08 08:23:19 +00003499 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
danielk1977a8858102004-05-28 12:11:21 +00003500 goto exit_drop_table;
drhe22a3342003-04-22 20:30:37 +00003501 }
drhe5f9c642003-01-13 23:27:31 +00003502 if( isView ){
danielk197753c0f742005-03-29 03:10:59 +00003503 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00003504 code = SQLITE_DROP_TEMP_VIEW;
3505 }else{
3506 code = SQLITE_DROP_VIEW;
3507 }
danielk19774b2688a2006-06-20 11:01:07 +00003508#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977f1a381e2006-06-16 08:01:02 +00003509 }else if( IsVirtual(pTab) ){
3510 code = SQLITE_DROP_VTABLE;
danielk1977595a5232009-07-24 17:58:53 +00003511 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
danielk19774b2688a2006-06-20 11:01:07 +00003512#endif
drhe5f9c642003-01-13 23:27:31 +00003513 }else{
danielk197753c0f742005-03-29 03:10:59 +00003514 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00003515 code = SQLITE_DROP_TEMP_TABLE;
3516 }else{
3517 code = SQLITE_DROP_TABLE;
3518 }
3519 }
danielk1977f1a381e2006-06-16 08:01:02 +00003520 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
danielk1977a8858102004-05-28 12:11:21 +00003521 goto exit_drop_table;
drhe5f9c642003-01-13 23:27:31 +00003522 }
danielk1977a8858102004-05-28 12:11:21 +00003523 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
3524 goto exit_drop_table;
drh77ad4e42003-01-14 02:49:27 +00003525 }
drhe5f9c642003-01-13 23:27:31 +00003526 }
3527#endif
drh070ae3b2019-11-16 13:51:31 +00003528 if( tableMayNotBeDropped(db, pTab) ){
danielk1977a8858102004-05-28 12:11:21 +00003529 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
danielk1977a8858102004-05-28 12:11:21 +00003530 goto exit_drop_table;
drh75897232000-05-29 14:26:00 +00003531 }
danielk1977576ec6b2005-01-21 11:55:25 +00003532
3533#ifndef SQLITE_OMIT_VIEW
3534 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
3535 ** on a table.
3536 */
drhf38524d2021-08-02 16:41:57 +00003537 if( isView && !IsView(pTab) ){
danielk1977a8858102004-05-28 12:11:21 +00003538 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
3539 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00003540 }
drhf38524d2021-08-02 16:41:57 +00003541 if( !isView && IsView(pTab) ){
danielk1977a8858102004-05-28 12:11:21 +00003542 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
3543 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00003544 }
danielk1977576ec6b2005-01-21 11:55:25 +00003545#endif
drh75897232000-05-29 14:26:00 +00003546
drh067b92b2020-06-19 15:24:12 +00003547 /* Generate code to remove the table from the schema table
drh1ccde152000-06-17 13:12:39 +00003548 ** on disk.
3549 */
danielk19774adee202004-05-08 08:23:19 +00003550 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00003551 if( v ){
drh77658e22007-12-04 16:54:52 +00003552 sqlite3BeginWriteOperation(pParse, 1, iDb);
mistachkin0fc2da32018-07-20 20:56:22 +00003553 if( !isView ){
3554 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
3555 sqlite3FkDropTable(pParse, pName, pTab);
3556 }
drhfaacf172011-08-12 01:51:45 +00003557 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
drh75897232000-05-29 14:26:00 +00003558 }
danielk1977a8858102004-05-28 12:11:21 +00003559
3560exit_drop_table:
drh633e6d52008-07-28 19:34:53 +00003561 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00003562}
3563
3564/*
drhc2eef3b2002-08-31 18:53:06 +00003565** This routine is called to create a new foreign key on the table
3566** currently under construction. pFromCol determines which columns
3567** in the current table point to the foreign key. If pFromCol==0 then
3568** connect the key to the last column inserted. pTo is the name of
drhbd50a922013-11-03 02:27:58 +00003569** the table referred to (a.k.a the "parent" table). pToCol is a list
3570** of tables in the parent pTo table. flags contains all
drhc2eef3b2002-08-31 18:53:06 +00003571** information about the conflict resolution algorithms specified
3572** in the ON DELETE, ON UPDATE and ON INSERT clauses.
3573**
3574** An FKey structure is created and added to the table currently
drhe61922a2009-05-02 13:29:37 +00003575** under construction in the pParse->pNewTable field.
drhc2eef3b2002-08-31 18:53:06 +00003576**
3577** The foreign key is set for IMMEDIATE processing. A subsequent call
danielk19774adee202004-05-08 08:23:19 +00003578** to sqlite3DeferForeignKey() might change this to DEFERRED.
drhc2eef3b2002-08-31 18:53:06 +00003579*/
danielk19774adee202004-05-08 08:23:19 +00003580void sqlite3CreateForeignKey(
drhc2eef3b2002-08-31 18:53:06 +00003581 Parse *pParse, /* Parsing context */
danielk19770202b292004-06-09 09:55:16 +00003582 ExprList *pFromCol, /* Columns in this table that point to other table */
drhc2eef3b2002-08-31 18:53:06 +00003583 Token *pTo, /* Name of the other table */
danielk19770202b292004-06-09 09:55:16 +00003584 ExprList *pToCol, /* Columns in the other table */
drhc2eef3b2002-08-31 18:53:06 +00003585 int flags /* Conflict resolution algorithms. */
3586){
danielk197718576932008-08-06 13:47:40 +00003587 sqlite3 *db = pParse->db;
drhb7f91642004-10-31 02:22:47 +00003588#ifndef SQLITE_OMIT_FOREIGN_KEY
drh40e016e2004-11-04 14:47:11 +00003589 FKey *pFKey = 0;
dan1da40a32009-09-19 17:00:31 +00003590 FKey *pNextTo;
drhc2eef3b2002-08-31 18:53:06 +00003591 Table *p = pParse->pNewTable;
drh913306a2021-11-26 17:10:18 +00003592 i64 nByte;
drhc2eef3b2002-08-31 18:53:06 +00003593 int i;
3594 int nCol;
3595 char *z;
drhc2eef3b2002-08-31 18:53:06 +00003596
3597 assert( pTo!=0 );
drh8af73d42009-05-13 22:58:28 +00003598 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
drhc2eef3b2002-08-31 18:53:06 +00003599 if( pFromCol==0 ){
3600 int iCol = p->nCol-1;
drhd3001712009-05-12 17:46:53 +00003601 if( NEVER(iCol<0) ) goto fk_end;
danielk19770202b292004-06-09 09:55:16 +00003602 if( pToCol && pToCol->nExpr!=1 ){
danielk19774adee202004-05-08 08:23:19 +00003603 sqlite3ErrorMsg(pParse, "foreign key on %s"
drhf7a9e1a2004-02-22 18:40:56 +00003604 " should reference only one column of table %T",
drhcf9d36d2021-08-02 18:03:43 +00003605 p->aCol[iCol].zCnName, pTo);
drhc2eef3b2002-08-31 18:53:06 +00003606 goto fk_end;
3607 }
3608 nCol = 1;
danielk19770202b292004-06-09 09:55:16 +00003609 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
danielk19774adee202004-05-08 08:23:19 +00003610 sqlite3ErrorMsg(pParse,
drhc2eef3b2002-08-31 18:53:06 +00003611 "number of columns in foreign key does not match the number of "
drhf7a9e1a2004-02-22 18:40:56 +00003612 "columns in the referenced table");
drhc2eef3b2002-08-31 18:53:06 +00003613 goto fk_end;
3614 }else{
danielk19770202b292004-06-09 09:55:16 +00003615 nCol = pFromCol->nExpr;
drhc2eef3b2002-08-31 18:53:06 +00003616 }
drhe61922a2009-05-02 13:29:37 +00003617 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
drhc2eef3b2002-08-31 18:53:06 +00003618 if( pToCol ){
danielk19770202b292004-06-09 09:55:16 +00003619 for(i=0; i<pToCol->nExpr; i++){
drh41cee662019-12-12 20:22:34 +00003620 nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1;
drhc2eef3b2002-08-31 18:53:06 +00003621 }
3622 }
drh633e6d52008-07-28 19:34:53 +00003623 pFKey = sqlite3DbMallocZero(db, nByte );
drh17435752007-08-16 04:30:38 +00003624 if( pFKey==0 ){
3625 goto fk_end;
3626 }
drhc2eef3b2002-08-31 18:53:06 +00003627 pFKey->pFrom = p;
drh78b2fa82021-10-07 12:11:20 +00003628 assert( IsOrdinaryTable(p) );
drhf38524d2021-08-02 16:41:57 +00003629 pFKey->pNextFrom = p->u.tab.pFKey;
drhe61922a2009-05-02 13:29:37 +00003630 z = (char*)&pFKey->aCol[nCol];
drhdf68f6b2002-09-21 15:57:57 +00003631 pFKey->zTo = z;
danc9461ec2018-08-29 21:00:16 +00003632 if( IN_RENAME_OBJECT ){
3633 sqlite3RenameTokenMap(pParse, (void*)z, pTo);
3634 }
drhc2eef3b2002-08-31 18:53:06 +00003635 memcpy(z, pTo->z, pTo->n);
3636 z[pTo->n] = 0;
danielk197770d9e9c2009-04-24 18:06:09 +00003637 sqlite3Dequote(z);
drhc2eef3b2002-08-31 18:53:06 +00003638 z += pTo->n+1;
drhc2eef3b2002-08-31 18:53:06 +00003639 pFKey->nCol = nCol;
drhc2eef3b2002-08-31 18:53:06 +00003640 if( pFromCol==0 ){
3641 pFKey->aCol[0].iFrom = p->nCol-1;
3642 }else{
3643 for(i=0; i<nCol; i++){
3644 int j;
3645 for(j=0; j<p->nCol; j++){
drhcf9d36d2021-08-02 18:03:43 +00003646 if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){
drhc2eef3b2002-08-31 18:53:06 +00003647 pFKey->aCol[i].iFrom = j;
3648 break;
3649 }
3650 }
3651 if( j>=p->nCol ){
danielk19774adee202004-05-08 08:23:19 +00003652 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00003653 "unknown column \"%s\" in foreign key definition",
drh41cee662019-12-12 20:22:34 +00003654 pFromCol->a[i].zEName);
drhc2eef3b2002-08-31 18:53:06 +00003655 goto fk_end;
3656 }
danc9461ec2018-08-29 21:00:16 +00003657 if( IN_RENAME_OBJECT ){
drh41cee662019-12-12 20:22:34 +00003658 sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
dancf8f2892018-08-09 20:47:01 +00003659 }
drhc2eef3b2002-08-31 18:53:06 +00003660 }
3661 }
3662 if( pToCol ){
3663 for(i=0; i<nCol; i++){
drh41cee662019-12-12 20:22:34 +00003664 int n = sqlite3Strlen30(pToCol->a[i].zEName);
drhc2eef3b2002-08-31 18:53:06 +00003665 pFKey->aCol[i].zCol = z;
danc9461ec2018-08-29 21:00:16 +00003666 if( IN_RENAME_OBJECT ){
drh41cee662019-12-12 20:22:34 +00003667 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
dan6fe7f232018-08-10 19:19:33 +00003668 }
drh41cee662019-12-12 20:22:34 +00003669 memcpy(z, pToCol->a[i].zEName, n);
drhc2eef3b2002-08-31 18:53:06 +00003670 z[n] = 0;
3671 z += n+1;
3672 }
3673 }
3674 pFKey->isDeferred = 0;
dan8099ce62009-09-23 08:43:35 +00003675 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
3676 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
drhc2eef3b2002-08-31 18:53:06 +00003677
drh21206082011-04-04 18:22:02 +00003678 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
dan1da40a32009-09-19 17:00:31 +00003679 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
drhacbcb7e2014-08-21 20:26:37 +00003680 pFKey->zTo, (void *)pFKey
dan1da40a32009-09-19 17:00:31 +00003681 );
danf59c5ca2009-09-22 16:55:38 +00003682 if( pNextTo==pFKey ){
drh4a642b62016-02-05 01:55:27 +00003683 sqlite3OomFault(db);
danf59c5ca2009-09-22 16:55:38 +00003684 goto fk_end;
3685 }
dan1da40a32009-09-19 17:00:31 +00003686 if( pNextTo ){
3687 assert( pNextTo->pPrevTo==0 );
3688 pFKey->pNextTo = pNextTo;
3689 pNextTo->pPrevTo = pFKey;
3690 }
3691
drhc2eef3b2002-08-31 18:53:06 +00003692 /* Link the foreign key to the table as the last step.
3693 */
drh78b2fa82021-10-07 12:11:20 +00003694 assert( IsOrdinaryTable(p) );
drhf38524d2021-08-02 16:41:57 +00003695 p->u.tab.pFKey = pFKey;
drhc2eef3b2002-08-31 18:53:06 +00003696 pFKey = 0;
3697
3698fk_end:
drh633e6d52008-07-28 19:34:53 +00003699 sqlite3DbFree(db, pFKey);
drhb7f91642004-10-31 02:22:47 +00003700#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
drh633e6d52008-07-28 19:34:53 +00003701 sqlite3ExprListDelete(db, pFromCol);
3702 sqlite3ExprListDelete(db, pToCol);
drhc2eef3b2002-08-31 18:53:06 +00003703}
3704
3705/*
3706** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
3707** clause is seen as part of a foreign key definition. The isDeferred
3708** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
3709** The behavior of the most recently created foreign key is adjusted
3710** accordingly.
3711*/
danielk19774adee202004-05-08 08:23:19 +00003712void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
drhb7f91642004-10-31 02:22:47 +00003713#ifndef SQLITE_OMIT_FOREIGN_KEY
drhc2eef3b2002-08-31 18:53:06 +00003714 Table *pTab;
3715 FKey *pFKey;
drhf38524d2021-08-02 16:41:57 +00003716 if( (pTab = pParse->pNewTable)==0 ) return;
drh78b2fa82021-10-07 12:11:20 +00003717 if( NEVER(!IsOrdinaryTable(pTab)) ) return;
drhf38524d2021-08-02 16:41:57 +00003718 if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
drh4c429832009-10-12 22:30:49 +00003719 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
drh1bd10f82008-12-10 21:19:56 +00003720 pFKey->isDeferred = (u8)isDeferred;
drhb7f91642004-10-31 02:22:47 +00003721#endif
drhc2eef3b2002-08-31 18:53:06 +00003722}
3723
3724/*
drh063336a2004-11-05 20:58:39 +00003725** Generate code that will erase and refill index *pIdx. This is
3726** used to initialize a newly created index or to recompute the
3727** content of an index in response to a REINDEX command.
3728**
3729** if memRootPage is not negative, it means that the index is newly
drh1db639c2008-01-17 02:36:28 +00003730** created. The register specified by memRootPage contains the
drh063336a2004-11-05 20:58:39 +00003731** root page number of the index. If memRootPage is negative, then
3732** the index already exists and must be cleared before being refilled and
3733** the root page number of the index is taken from pIndex->tnum.
3734*/
3735static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
3736 Table *pTab = pIndex->pTable; /* The table that is indexed */
danielk19776ab3a2e2009-02-19 14:39:25 +00003737 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
3738 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
drhb07028f2011-10-14 21:49:18 +00003739 int iSorter; /* Cursor opened by OpenSorter (if in use) */
drh063336a2004-11-05 20:58:39 +00003740 int addr1; /* Address of top of loop */
dan5134d132011-09-02 10:31:11 +00003741 int addr2; /* Address to jump to for next iteration */
drhabc38152020-07-22 13:38:04 +00003742 Pgno tnum; /* Root page of index */
drhb2b9d3d2013-08-01 01:14:43 +00003743 int iPartIdxLabel; /* Jump to this label to skip a row */
drh063336a2004-11-05 20:58:39 +00003744 Vdbe *v; /* Generate code into this virtual machine */
danielk1977b3bf5562006-01-10 17:58:23 +00003745 KeyInfo *pKey; /* KeyInfo for index */
peter.d.reid60ec9142014-09-06 16:39:46 +00003746 int regRecord; /* Register holding assembled index record */
drh17435752007-08-16 04:30:38 +00003747 sqlite3 *db = pParse->db; /* The database connection */
3748 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drh063336a2004-11-05 20:58:39 +00003749
danielk19771d54df82004-11-23 15:41:16 +00003750#ifndef SQLITE_OMIT_AUTHORIZATION
3751 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
drh69c33822016-08-18 14:33:11 +00003752 db->aDb[iDb].zDbSName ) ){
danielk19771d54df82004-11-23 15:41:16 +00003753 return;
3754 }
3755#endif
3756
danielk1977c00da102006-01-07 13:21:04 +00003757 /* Require a write-lock on the table to perform this operation */
3758 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
3759
drh063336a2004-11-05 20:58:39 +00003760 v = sqlite3GetVdbe(pParse);
3761 if( v==0 ) return;
3762 if( memRootPage>=0 ){
drhabc38152020-07-22 13:38:04 +00003763 tnum = (Pgno)memRootPage;
drh063336a2004-11-05 20:58:39 +00003764 }else{
3765 tnum = pIndex->tnum;
drh063336a2004-11-05 20:58:39 +00003766 }
drh2ec2fb22013-11-06 19:59:23 +00003767 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
drh0c7d3d32022-01-24 16:47:12 +00003768 assert( pKey!=0 || pParse->nErr );
dana20fde62011-07-12 14:28:05 +00003769
dan689ab892011-08-12 15:02:00 +00003770 /* Open the sorter cursor if we are to use one. */
drhca892a72011-09-03 00:17:51 +00003771 iSorter = pParse->nTab++;
danfad9f9a2014-04-01 18:41:51 +00003772 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
drh2ec2fb22013-11-06 19:59:23 +00003773 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
dana20fde62011-07-12 14:28:05 +00003774
3775 /* Open the table. Loop through all rows of the table, inserting index
3776 ** records into the sorter. */
drhdd9930e2013-10-23 23:37:02 +00003777 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
drh688852a2014-02-17 22:40:43 +00003778 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
drh2d401ab2008-01-10 23:50:11 +00003779 regRecord = sqlite3GetTempReg(pParse);
drh4031baf2018-05-28 17:31:20 +00003780 sqlite3MultiWrite(pParse);
dana20fde62011-07-12 14:28:05 +00003781
drh1c2c0b72014-01-04 19:27:05 +00003782 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
drhca892a72011-09-03 00:17:51 +00003783 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
drh87744512014-04-13 19:15:49 +00003784 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
drh688852a2014-02-17 22:40:43 +00003785 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
drhca892a72011-09-03 00:17:51 +00003786 sqlite3VdbeJumpHere(v, addr1);
drh44156282013-10-23 22:23:03 +00003787 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
drhabc38152020-07-22 13:38:04 +00003788 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
drh2ec2fb22013-11-06 19:59:23 +00003789 (char *)pKey, P4_KEYINFO);
drh44156282013-10-23 22:23:03 +00003790 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
3791
drh688852a2014-02-17 22:40:43 +00003792 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
drh60de73e2016-04-05 15:59:23 +00003793 if( IsUniqueIndex(pIndex) ){
drh4031baf2018-05-28 17:31:20 +00003794 int j2 = sqlite3VdbeGoto(v, 1);
drhca892a72011-09-03 00:17:51 +00003795 addr2 = sqlite3VdbeCurrentAddr(v);
drh4031baf2018-05-28 17:31:20 +00003796 sqlite3VdbeVerifyAbortable(v, OE_Abort);
drh1153c7b2013-11-01 22:02:56 +00003797 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
drhac502322014-07-30 13:56:48 +00003798 pIndex->nKeyCol); VdbeCoverage(v);
drhf9c8ce32013-11-05 13:33:55 +00003799 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
drh4031baf2018-05-28 17:31:20 +00003800 sqlite3VdbeJumpHere(v, j2);
drhca892a72011-09-03 00:17:51 +00003801 }else{
dan7ed6c062019-05-21 16:32:41 +00003802 /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
3803 ** abort. The exception is if one of the indexed expressions contains a
3804 ** user function that throws an exception when it is evaluated. But the
3805 ** overhead of adding a statement journal to a CREATE INDEX statement is
3806 ** very small (since most of the pages written do not contain content that
3807 ** needs to be restored if the statement aborts), so we call
3808 ** sqlite3MayAbort() for all CREATE INDEX statements. */
danef14abb2019-05-21 14:42:24 +00003809 sqlite3MayAbort(pParse);
drhca892a72011-09-03 00:17:51 +00003810 addr2 = sqlite3VdbeCurrentAddr(v);
dan689ab892011-08-12 15:02:00 +00003811 }
drh6cf4a7d2014-10-13 13:00:58 +00003812 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
drhbf9ff252019-05-14 00:43:13 +00003813 if( !pIndex->bAscKeyBug ){
3814 /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
3815 ** faster by avoiding unnecessary seeks. But the optimization does
3816 ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
3817 ** with DESC primary keys, since those indexes have there keys in
3818 ** a different order from the main table.
3819 ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
3820 */
3821 sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
3822 }
drh9b4eaeb2016-11-09 00:10:33 +00003823 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
drhca892a72011-09-03 00:17:51 +00003824 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drh2d401ab2008-01-10 23:50:11 +00003825 sqlite3ReleaseTempReg(pParse, regRecord);
drh688852a2014-02-17 22:40:43 +00003826 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
drhd654be82005-09-20 17:42:23 +00003827 sqlite3VdbeJumpHere(v, addr1);
dana20fde62011-07-12 14:28:05 +00003828
drh66a51672008-01-03 00:01:23 +00003829 sqlite3VdbeAddOp1(v, OP_Close, iTab);
3830 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
dan689ab892011-08-12 15:02:00 +00003831 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
drh063336a2004-11-05 20:58:39 +00003832}
3833
3834/*
drh77e57df2013-10-22 14:28:02 +00003835** Allocate heap space to hold an Index object with nCol columns.
3836**
3837** Increase the allocation size to provide an extra nExtra bytes
3838** of 8-byte aligned space after the Index object and return a
3839** pointer to this extra space in *ppExtra.
3840*/
3841Index *sqlite3AllocateIndexObject(
3842 sqlite3 *db, /* Database connection */
drhbbbdc832013-10-22 18:01:40 +00003843 i16 nCol, /* Total number of columns in the index */
drh77e57df2013-10-22 14:28:02 +00003844 int nExtra, /* Number of bytes of extra space to alloc */
3845 char **ppExtra /* Pointer to the "extra" space */
3846){
3847 Index *p; /* Allocated index object */
3848 int nByte; /* Bytes of space for Index object + arrays */
3849
3850 nByte = ROUND8(sizeof(Index)) + /* Index structure */
3851 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
dancfc9df72014-04-25 15:01:01 +00003852 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
drhbbbdc832013-10-22 18:01:40 +00003853 sizeof(i16)*nCol + /* Index.aiColumn */
drh77e57df2013-10-22 14:28:02 +00003854 sizeof(u8)*nCol); /* Index.aSortOrder */
3855 p = sqlite3DbMallocZero(db, nByte + nExtra);
3856 if( p ){
3857 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
drhf19aa5f2015-12-30 16:51:20 +00003858 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
dancfc9df72014-04-25 15:01:01 +00003859 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
3860 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
drh77e57df2013-10-22 14:28:02 +00003861 p->aSortOrder = (u8*)pExtra;
3862 p->nColumn = nCol;
drhbbbdc832013-10-22 18:01:40 +00003863 p->nKeyCol = nCol - 1;
drh77e57df2013-10-22 14:28:02 +00003864 *ppExtra = ((char*)p) + nByte;
3865 }
3866 return p;
3867}
3868
3869/*
dan9105fd52019-08-19 17:26:32 +00003870** If expression list pList contains an expression that was parsed with
3871** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
3872** pParse and return non-zero. Otherwise, return zero.
3873*/
3874int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
3875 if( pList ){
3876 int i;
3877 for(i=0; i<pList->nExpr; i++){
drhd88fd532022-05-02 20:49:30 +00003878 if( pList->a[i].fg.bNulls ){
3879 u8 sf = pList->a[i].fg.sortFlags;
dan9105fd52019-08-19 17:26:32 +00003880 sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
3881 (sf==0 || sf==3) ? "FIRST" : "LAST"
3882 );
3883 return 1;
3884 }
3885 }
3886 }
3887 return 0;
3888}
3889
3890/*
drh23bf66d2004-12-14 03:34:34 +00003891** Create a new index for an SQL table. pName1.pName2 is the name of the index
3892** and pTblList is the name of the table that is to be indexed. Both will
drhadbca9c2001-09-27 15:11:53 +00003893** be NULL for a primary key or an index that is created to satisfy a
3894** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
drh382c0242001-10-06 16:33:02 +00003895** as the table to be indexed. pParse->pNewTable is a table that is
3896** currently being constructed by a CREATE TABLE statement.
drh75897232000-05-29 14:26:00 +00003897**
drh382c0242001-10-06 16:33:02 +00003898** pList is a list of columns to be indexed. pList will be NULL if this
3899** is a primary key or unique-constraint on the most recent column added
3900** to the table currently under construction.
drh75897232000-05-29 14:26:00 +00003901*/
drh62340f82016-05-31 21:18:15 +00003902void sqlite3CreateIndex(
drh23bf66d2004-12-14 03:34:34 +00003903 Parse *pParse, /* All information about this parse */
3904 Token *pName1, /* First part of index name. May be NULL */
3905 Token *pName2, /* Second part of index name. May be NULL */
3906 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
danielk19770202b292004-06-09 09:55:16 +00003907 ExprList *pList, /* A list of columns to be indexed */
drh23bf66d2004-12-14 03:34:34 +00003908 int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
drh1c55ba02007-07-02 19:31:27 +00003909 Token *pStart, /* The CREATE token that begins this statement */
drh1fe05372013-07-31 18:12:26 +00003910 Expr *pPIWhere, /* WHERE clause for partial indices */
drh4d91a702006-01-04 15:54:36 +00003911 int sortOrder, /* Sort order of primary key when pList==NULL */
drh62340f82016-05-31 21:18:15 +00003912 int ifNotExist, /* Omit error if index already exists */
3913 u8 idxType /* The index type */
drh75897232000-05-29 14:26:00 +00003914){
drhfdd6e852005-12-16 01:06:16 +00003915 Table *pTab = 0; /* Table to be indexed */
3916 Index *pIndex = 0; /* The index to be created */
3917 char *zName = 0; /* Name of the index */
3918 int nName; /* Number of characters in zName */
drhbeae3192001-09-22 18:12:08 +00003919 int i, j;
drhfdd6e852005-12-16 01:06:16 +00003920 DbFixer sFix; /* For assigning database names to pTable */
3921 int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
drh9bb575f2004-09-06 17:24:11 +00003922 sqlite3 *db = pParse->db;
drhfdd6e852005-12-16 01:06:16 +00003923 Db *pDb; /* The specific table containing the indexed database */
3924 int iDb; /* Index of the database that is being written */
3925 Token *pName = 0; /* Unqualified name of the index to create */
3926 struct ExprList_item *pListItem; /* For looping over pList */
drhc28c4e52013-10-03 19:21:41 +00003927 int nExtra = 0; /* Space allocated for zExtra[] */
drh44156282013-10-23 22:23:03 +00003928 int nExtraCol; /* Number of extra columns needed */
drh47b927d2013-12-03 00:11:40 +00003929 char *zExtra = 0; /* Extra space after the Index object */
drh44156282013-10-23 22:23:03 +00003930 Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
danielk1977cbb18d22004-05-28 11:37:27 +00003931
drh0c7d3d32022-01-24 16:47:12 +00003932 assert( db->pParse==pParse );
3933 if( pParse->nErr ){
drh62340f82016-05-31 21:18:15 +00003934 goto exit_create_index;
3935 }
drh0c7d3d32022-01-24 16:47:12 +00003936 assert( db->mallocFailed==0 );
drh62340f82016-05-31 21:18:15 +00003937 if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
drhd3001712009-05-12 17:46:53 +00003938 goto exit_create_index;
3939 }
3940 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e501b892006-01-09 06:29:47 +00003941 goto exit_create_index;
3942 }
dan9105fd52019-08-19 17:26:32 +00003943 if( sqlite3HasExplicitNulls(pParse, pList) ){
3944 goto exit_create_index;
3945 }
drhdaffd0e2001-04-11 14:28:42 +00003946
drh75897232000-05-29 14:26:00 +00003947 /*
3948 ** Find the table that is to be indexed. Return early if not found.
3949 */
danielk1977cbb18d22004-05-28 11:37:27 +00003950 if( pTblName!=0 ){
danielk1977cbb18d22004-05-28 11:37:27 +00003951
3952 /* Use the two-part index name to determine the database
danielk1977ef2cb632004-05-29 02:37:19 +00003953 ** to search for the table. 'Fix' the table name to this db
3954 ** before looking up the table.
danielk1977cbb18d22004-05-28 11:37:27 +00003955 */
3956 assert( pName1 && pName2 );
danielk1977ef2cb632004-05-29 02:37:19 +00003957 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
danielk1977cbb18d22004-05-28 11:37:27 +00003958 if( iDb<0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00003959 assert( pName && pName->z );
danielk1977cbb18d22004-05-28 11:37:27 +00003960
danielk197753c0f742005-03-29 03:10:59 +00003961#ifndef SQLITE_OMIT_TEMPDB
mistachkind5578432012-08-25 10:01:29 +00003962 /* If the index name was unqualified, check if the table
danielk1977fe910332007-12-02 11:46:34 +00003963 ** is a temp table. If so, set the database to 1. Do not do this
3964 ** if initialising a database schema.
danielk1977cbb18d22004-05-28 11:37:27 +00003965 */
danielk1977fe910332007-12-02 11:46:34 +00003966 if( !db->init.busy ){
3967 pTab = sqlite3SrcListLookup(pParse, pTblName);
drhd3001712009-05-12 17:46:53 +00003968 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
danielk1977fe910332007-12-02 11:46:34 +00003969 iDb = 1;
3970 }
danielk1977ef2cb632004-05-29 02:37:19 +00003971 }
danielk197753c0f742005-03-29 03:10:59 +00003972#endif
danielk1977ef2cb632004-05-29 02:37:19 +00003973
drhd100f692013-10-03 15:39:44 +00003974 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
3975 if( sqlite3FixSrcList(&sFix, pTblName) ){
drh85c23c62005-08-20 03:03:04 +00003976 /* Because the parser constructs pTblName from a single identifier,
3977 ** sqlite3FixSrcList can never fail. */
3978 assert(0);
danielk1977cbb18d22004-05-28 11:37:27 +00003979 }
dan41fb5cd2012-10-04 19:33:00 +00003980 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
drhc31c7c12012-10-08 23:25:07 +00003981 assert( db->mallocFailed==0 || pTab==0 );
3982 if( pTab==0 ) goto exit_create_index;
drh989b1162013-08-01 22:27:26 +00003983 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
3984 sqlite3ErrorMsg(pParse,
3985 "cannot create a TEMP index on non-TEMP table \"%s\"",
3986 pTab->zName);
3987 goto exit_create_index;
3988 }
drh44156282013-10-23 22:23:03 +00003989 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
drh75897232000-05-29 14:26:00 +00003990 }else{
drhe3c41372001-09-17 20:25:58 +00003991 assert( pName==0 );
drhb07028f2011-10-14 21:49:18 +00003992 assert( pStart==0 );
danielk1977da184232006-01-05 11:34:32 +00003993 pTab = pParse->pNewTable;
drha6370df2006-01-04 21:40:06 +00003994 if( !pTab ) goto exit_create_index;
danielk1977da184232006-01-05 11:34:32 +00003995 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh75897232000-05-29 14:26:00 +00003996 }
drhfdd6e852005-12-16 01:06:16 +00003997 pDb = &db->aDb[iDb];
danielk1977cbb18d22004-05-28 11:37:27 +00003998
drhd3001712009-05-12 17:46:53 +00003999 assert( pTab!=0 );
drh03881232009-02-13 03:43:31 +00004000 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
drh3a3a03f2014-09-11 16:36:43 +00004001 && db->init.busy==0
drh346f4e22019-03-25 21:35:41 +00004002 && pTblName!=0
drhd4530972014-09-09 14:47:53 +00004003#if SQLITE_USER_AUTHENTICATION
4004 && sqlite3UserAuthTable(pTab->zName)==0
4005#endif
drh067b92b2020-06-19 15:24:12 +00004006 ){
danielk19774adee202004-05-08 08:23:19 +00004007 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
drh0be9df02003-03-30 00:19:49 +00004008 goto exit_create_index;
4009 }
danielk1977576ec6b2005-01-21 11:55:25 +00004010#ifndef SQLITE_OMIT_VIEW
drhf38524d2021-08-02 16:41:57 +00004011 if( IsView(pTab) ){
danielk19774adee202004-05-08 08:23:19 +00004012 sqlite3ErrorMsg(pParse, "views may not be indexed");
drha76b5df2002-02-23 02:32:10 +00004013 goto exit_create_index;
4014 }
danielk1977576ec6b2005-01-21 11:55:25 +00004015#endif
danielk19775ee9d692006-06-21 12:36:25 +00004016#ifndef SQLITE_OMIT_VIRTUALTABLE
4017 if( IsVirtual(pTab) ){
4018 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
4019 goto exit_create_index;
4020 }
4021#endif
drh75897232000-05-29 14:26:00 +00004022
4023 /*
4024 ** Find the name of the index. Make sure there is not already another
drhf57b3392001-10-08 13:22:32 +00004025 ** index or table with the same name.
4026 **
4027 ** Exception: If we are reading the names of permanent indices from the
drh1e32bed2020-06-19 13:33:53 +00004028 ** sqlite_schema table (because some other process changed the schema) and
drhf57b3392001-10-08 13:22:32 +00004029 ** one of the index names collides with the name of a temporary table or
drhd24cc422003-03-27 12:51:24 +00004030 ** index, then we will continue to process this index.
drhf57b3392001-10-08 13:22:32 +00004031 **
4032 ** If pName==0 it means that we are
drhadbca9c2001-09-27 15:11:53 +00004033 ** dealing with a primary key or UNIQUE constraint. We have to invent our
4034 ** own name.
drh75897232000-05-29 14:26:00 +00004035 */
danielk1977d8123362004-06-12 09:25:12 +00004036 if( pName ){
drh17435752007-08-16 04:30:38 +00004037 zName = sqlite3NameFromToken(db, pName);
drhe3c41372001-09-17 20:25:58 +00004038 if( zName==0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00004039 assert( pName->z!=0 );
drhc5a93d42019-08-12 00:08:07 +00004040 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
drhd24cc422003-03-27 12:51:24 +00004041 goto exit_create_index;
drhe3c41372001-09-17 20:25:58 +00004042 }
danc9461ec2018-08-29 21:00:16 +00004043 if( !IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00004044 if( !db->init.busy ){
drh626bcc82022-08-09 16:13:21 +00004045 if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){
dancf8f2892018-08-09 20:47:01 +00004046 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
4047 goto exit_create_index;
4048 }
4049 }
4050 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
4051 if( !ifNotExist ){
4052 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
4053 }else{
4054 assert( !db->init.busy );
4055 sqlite3CodeVerifySchema(pParse, iDb);
drh31da7be2021-05-13 18:24:22 +00004056 sqlite3ForceNotReadOnly(pParse);
dancf8f2892018-08-09 20:47:01 +00004057 }
danielk1977d45a0312007-03-13 16:32:25 +00004058 goto exit_create_index;
4059 }
4060 }
danielk1977a21c6b62005-01-24 10:25:59 +00004061 }else{
drhadbca9c2001-09-27 15:11:53 +00004062 int n;
4063 Index *pLoop;
4064 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
drhf089aa42008-07-08 19:34:06 +00004065 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
danielk1977a1644fd2007-08-29 12:31:25 +00004066 if( zName==0 ){
danielk1977a1644fd2007-08-29 12:31:25 +00004067 goto exit_create_index;
4068 }
drh0aafa9c2016-08-05 14:35:47 +00004069
4070 /* Automatic index names generated from within sqlite3_declare_vtab()
4071 ** must have names that are distinct from normal automatic index names.
4072 ** The following statement converts "sqlite3_autoindex..." into
4073 ** "sqlite3_butoindex..." in order to make the names distinct.
4074 ** The "vtab_err.test" test demonstrates the need of this statement. */
dancf8f2892018-08-09 20:47:01 +00004075 if( IN_SPECIAL_PARSE ) zName[7]++;
drh75897232000-05-29 14:26:00 +00004076 }
4077
drhe5f9c642003-01-13 23:27:31 +00004078 /* Check for authorization to create an index.
4079 */
4080#ifndef SQLITE_OMIT_AUTHORIZATION
danc9461ec2018-08-29 21:00:16 +00004081 if( !IN_RENAME_OBJECT ){
drh69c33822016-08-18 14:33:11 +00004082 const char *zDb = pDb->zDbSName;
danielk197753c0f742005-03-29 03:10:59 +00004083 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
drhe22a3342003-04-22 20:30:37 +00004084 goto exit_create_index;
4085 }
4086 i = SQLITE_CREATE_INDEX;
danielk197753c0f742005-03-29 03:10:59 +00004087 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00004088 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
drhe22a3342003-04-22 20:30:37 +00004089 goto exit_create_index;
4090 }
drhe5f9c642003-01-13 23:27:31 +00004091 }
4092#endif
4093
drh75897232000-05-29 14:26:00 +00004094 /* If pList==0, it means this routine was called to make a primary
drh1ccde152000-06-17 13:12:39 +00004095 ** key out of the last column added to the table under construction.
drh75897232000-05-29 14:26:00 +00004096 ** So create a fake list to simulate this.
4097 */
4098 if( pList==0 ){
drh108aa002015-08-24 20:21:20 +00004099 Token prevCol;
dan26e731c2018-01-29 16:22:39 +00004100 Column *pCol = &pTab->aCol[pTab->nCol-1];
4101 pCol->colFlags |= COLFLAG_UNIQUE;
drhcf9d36d2021-08-02 18:03:43 +00004102 sqlite3TokenInit(&prevCol, pCol->zCnName);
drh108aa002015-08-24 20:21:20 +00004103 pList = sqlite3ExprListAppend(pParse, 0,
4104 sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
drh75897232000-05-29 14:26:00 +00004105 if( pList==0 ) goto exit_create_index;
drhbc622bc2015-08-24 15:39:42 +00004106 assert( pList->nExpr==1 );
dan5b32bdf2019-08-17 15:47:32 +00004107 sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
drh108aa002015-08-24 20:21:20 +00004108 }else{
4109 sqlite3ExprListCheckLength(pParse, pList, "index");
drh8fe25c62019-03-31 21:09:33 +00004110 if( pParse->nErr ) goto exit_create_index;
drh75897232000-05-29 14:26:00 +00004111 }
4112
danielk1977b3bf5562006-01-10 17:58:23 +00004113 /* Figure out how many bytes of space are required to store explicitly
4114 ** specified collation sequence names.
4115 */
4116 for(i=0; i<pList->nExpr; i++){
drhd3001712009-05-12 17:46:53 +00004117 Expr *pExpr = pList->a[i].pExpr;
drh7d3d9da2015-09-01 00:42:52 +00004118 assert( pExpr!=0 );
4119 if( pExpr->op==TK_COLLATE ){
drhf9751072021-10-07 13:40:29 +00004120 assert( !ExprHasProperty(pExpr, EP_IntValue) );
dan911ce412013-05-15 15:16:50 +00004121 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
danielk1977b3bf5562006-01-10 17:58:23 +00004122 }
4123 }
4124
drh75897232000-05-29 14:26:00 +00004125 /*
4126 ** Allocate the index structure.
4127 */
drhea678832008-12-10 19:26:22 +00004128 nName = sqlite3Strlen30(zName);
drh44156282013-10-23 22:23:03 +00004129 nExtraCol = pPk ? pPk->nKeyCol : 1;
drh8fe25c62019-03-31 21:09:33 +00004130 assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
drh44156282013-10-23 22:23:03 +00004131 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
drh77e57df2013-10-22 14:28:02 +00004132 nName + nExtra + 1, &zExtra);
drh17435752007-08-16 04:30:38 +00004133 if( db->mallocFailed ){
4134 goto exit_create_index;
4135 }
dancfc9df72014-04-25 15:01:01 +00004136 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
drhe09b84c2011-11-14 02:53:54 +00004137 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
drh77e57df2013-10-22 14:28:02 +00004138 pIndex->zName = zExtra;
4139 zExtra += nName + 1;
drh5bb3eb92007-05-04 13:15:55 +00004140 memcpy(pIndex->zName, zName, nName+1);
drh75897232000-05-29 14:26:00 +00004141 pIndex->pTable = pTab;
drh1bd10f82008-12-10 21:19:56 +00004142 pIndex->onError = (u8)onError;
drh9eade082013-10-24 14:16:10 +00004143 pIndex->uniqNotNull = onError!=OE_None;
drh62340f82016-05-31 21:18:15 +00004144 pIndex->idxType = idxType;
danielk1977da184232006-01-05 11:34:32 +00004145 pIndex->pSchema = db->aDb[iDb].pSchema;
drh72ffd092013-10-30 15:52:32 +00004146 pIndex->nKeyCol = pList->nExpr;
drh3780be12013-07-31 19:05:22 +00004147 if( pPIWhere ){
4148 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
4149 pIndex->pPartIdxWhere = pPIWhere;
4150 pPIWhere = 0;
4151 }
drh21206082011-04-04 18:22:02 +00004152 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh75897232000-05-29 14:26:00 +00004153
drhfdd6e852005-12-16 01:06:16 +00004154 /* Check to see if we should honor DESC requests on index columns
4155 */
danielk1977da184232006-01-05 11:34:32 +00004156 if( pDb->pSchema->file_format>=4 ){
drhfdd6e852005-12-16 01:06:16 +00004157 sortOrderMask = -1; /* Honor DESC */
drhfdd6e852005-12-16 01:06:16 +00004158 }else{
4159 sortOrderMask = 0; /* Ignore DESC */
4160 }
4161
drh1f9ca2c2015-08-25 16:57:52 +00004162 /* Analyze the list of expressions that form the terms of the index and
4163 ** report any errors. In the common case where the expression is exactly
4164 ** a table column, store that column in aiColumn[]. For general expressions,
drh4b92f982015-09-29 17:20:14 +00004165 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
drhd3001712009-05-12 17:46:53 +00004166 **
drh1f9ca2c2015-08-25 16:57:52 +00004167 ** TODO: Issue a warning if two or more columns of the index are identical.
4168 ** TODO: Issue a warning if the table primary key is used as part of the
4169 ** index key.
drh75897232000-05-29 14:26:00 +00004170 */
dancf8f2892018-08-09 20:47:01 +00004171 pListItem = pList->a;
danc9461ec2018-08-29 21:00:16 +00004172 if( IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00004173 pIndex->aColExpr = pList;
4174 pList = 0;
4175 }
4176 for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
drh1f9ca2c2015-08-25 16:57:52 +00004177 Expr *pCExpr; /* The i-th index expression */
4178 int requestedSortOrder; /* ASC or DESC on the i-th expression */
drhf19aa5f2015-12-30 16:51:20 +00004179 const char *zColl; /* Collation sequence name */
danielk1977b3bf5562006-01-10 17:58:23 +00004180
drhedb04ed2015-09-04 12:54:01 +00004181 sqlite3StringToId(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00004182 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
4183 if( pParse->nErr ) goto exit_create_index;
drh108aa002015-08-24 20:21:20 +00004184 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00004185 if( pCExpr->op!=TK_COLUMN ){
drh1f9ca2c2015-08-25 16:57:52 +00004186 if( pTab==pParse->pNewTable ){
4187 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
4188 "UNIQUE constraints");
4189 goto exit_create_index;
4190 }
4191 if( pIndex->aColExpr==0 ){
dancf8f2892018-08-09 20:47:01 +00004192 pIndex->aColExpr = pList;
4193 pList = 0;
drh1f9ca2c2015-08-25 16:57:52 +00004194 }
drh4b92f982015-09-29 17:20:14 +00004195 j = XN_EXPR;
4196 pIndex->aiColumn[i] = XN_EXPR;
drh84926532015-08-31 19:38:42 +00004197 pIndex->uniqNotNull = 0;
drh4bc1cc12022-10-13 21:08:34 +00004198 pIndex->bHasExpr = 1;
drh1f9ca2c2015-08-25 16:57:52 +00004199 }else{
4200 j = pCExpr->iColumn;
4201 assert( j<=0x7fff );
4202 if( j<0 ){
4203 j = pTab->iPKey;
drhc7476732019-10-24 20:29:25 +00004204 }else{
4205 if( pTab->aCol[j].notNull==0 ){
4206 pIndex->uniqNotNull = 0;
4207 }
4208 if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
4209 pIndex->bHasVCol = 1;
drh08535842022-10-17 14:30:01 +00004210 pIndex->bHasExpr = 1;
drhc7476732019-10-24 20:29:25 +00004211 }
drh1f9ca2c2015-08-25 16:57:52 +00004212 }
4213 pIndex->aiColumn[i] = (i16)j;
drh108aa002015-08-24 20:21:20 +00004214 }
drha514b8e2015-08-25 00:27:06 +00004215 zColl = 0;
drh108aa002015-08-24 20:21:20 +00004216 if( pListItem->pExpr->op==TK_COLLATE ){
drhd3001712009-05-12 17:46:53 +00004217 int nColl;
drhf9751072021-10-07 13:40:29 +00004218 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
dan911ce412013-05-15 15:16:50 +00004219 zColl = pListItem->pExpr->u.zToken;
drhd3001712009-05-12 17:46:53 +00004220 nColl = sqlite3Strlen30(zColl) + 1;
4221 assert( nExtra>=nColl );
4222 memcpy(zExtra, zColl, nColl);
danielk1977b3bf5562006-01-10 17:58:23 +00004223 zColl = zExtra;
drhd3001712009-05-12 17:46:53 +00004224 zExtra += nColl;
4225 nExtra -= nColl;
drha514b8e2015-08-25 00:27:06 +00004226 }else if( j>=0 ){
drh65b40092021-08-05 15:27:19 +00004227 zColl = sqlite3ColumnColl(&pTab->aCol[j]);
danielk19770202b292004-06-09 09:55:16 +00004228 }
drhf19aa5f2015-12-30 16:51:20 +00004229 if( !zColl ) zColl = sqlite3StrBINARY;
drhb7f24de2009-05-13 17:35:23 +00004230 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
danielk19777cedc8d2004-06-10 10:50:08 +00004231 goto exit_create_index;
4232 }
danielk1977b3bf5562006-01-10 17:58:23 +00004233 pIndex->azColl[i] = zColl;
drhd88fd532022-05-02 20:49:30 +00004234 requestedSortOrder = pListItem->fg.sortFlags & sortOrderMask;
drh1bd10f82008-12-10 21:19:56 +00004235 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
drh75897232000-05-29 14:26:00 +00004236 }
drh1f9ca2c2015-08-25 16:57:52 +00004237
4238 /* Append the table key to the end of the index. For WITHOUT ROWID
4239 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
4240 ** normal tables (when pPk==0) this will be the rowid.
4241 */
drh44156282013-10-23 22:23:03 +00004242 if( pPk ){
drh7913e412013-11-01 20:30:36 +00004243 for(j=0; j<pPk->nKeyCol; j++){
4244 int x = pPk->aiColumn[j];
drh1f9ca2c2015-08-25 16:57:52 +00004245 assert( x>=0 );
drhf78d0f42019-04-28 19:27:02 +00004246 if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
drh7913e412013-11-01 20:30:36 +00004247 pIndex->nColumn--;
4248 }else{
drhf78d0f42019-04-28 19:27:02 +00004249 testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
drh7913e412013-11-01 20:30:36 +00004250 pIndex->aiColumn[i] = x;
4251 pIndex->azColl[i] = pPk->azColl[j];
4252 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
4253 i++;
4254 }
drh44156282013-10-23 22:23:03 +00004255 }
drh7913e412013-11-01 20:30:36 +00004256 assert( i==pIndex->nColumn );
drh44156282013-10-23 22:23:03 +00004257 }else{
drh4b92f982015-09-29 17:20:14 +00004258 pIndex->aiColumn[i] = XN_ROWID;
drhf19aa5f2015-12-30 16:51:20 +00004259 pIndex->azColl[i] = sqlite3StrBINARY;
drh44156282013-10-23 22:23:03 +00004260 }
drh51147ba2005-07-23 22:59:55 +00004261 sqlite3DefaultRowEst(pIndex);
drhe13e9f52013-10-05 19:18:00 +00004262 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
drh75897232000-05-29 14:26:00 +00004263
danf769cd62016-02-24 20:16:28 +00004264 /* If this index contains every column of its table, then mark
4265 ** it as a covering index */
4266 assert( HasRowid(pTab)
drhb9bcf7c2019-10-19 13:29:10 +00004267 || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
drh1fe3ac72018-06-09 01:12:08 +00004268 recomputeColumnsNotIndexed(pIndex);
danf769cd62016-02-24 20:16:28 +00004269 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
4270 pIndex->isCovering = 1;
4271 for(j=0; j<pTab->nCol; j++){
4272 if( j==pTab->iPKey ) continue;
drhb9bcf7c2019-10-19 13:29:10 +00004273 if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue;
danf769cd62016-02-24 20:16:28 +00004274 pIndex->isCovering = 0;
4275 break;
4276 }
4277 }
4278
danielk1977d8123362004-06-12 09:25:12 +00004279 if( pTab==pParse->pNewTable ){
4280 /* This routine has been called to create an automatic index as a
4281 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
4282 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
4283 ** i.e. one of:
4284 **
4285 ** CREATE TABLE t(x PRIMARY KEY, y);
4286 ** CREATE TABLE t(x, y, UNIQUE(x, y));
4287 **
4288 ** Either way, check to see if the table already has such an index. If
4289 ** so, don't bother creating this one. This only applies to
4290 ** automatically created indices. Users can do as they wish with
4291 ** explicit indices.
drhd3001712009-05-12 17:46:53 +00004292 **
4293 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
4294 ** (and thus suppressing the second one) even if they have different
4295 ** sort orders.
4296 **
4297 ** If there are different collating sequences or if the columns of
4298 ** the constraint occur in different orders, then the constraints are
4299 ** considered distinct and both result in separate indices.
danielk1977d8123362004-06-12 09:25:12 +00004300 */
4301 Index *pIdx;
4302 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
4303 int k;
drh5f1d1d92014-07-31 22:59:04 +00004304 assert( IsUniqueIndex(pIdx) );
drh48dd1d82014-05-27 18:18:58 +00004305 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
drh5f1d1d92014-07-31 22:59:04 +00004306 assert( IsUniqueIndex(pIndex) );
danielk1977d8123362004-06-12 09:25:12 +00004307
drhbbbdc832013-10-22 18:01:40 +00004308 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
4309 for(k=0; k<pIdx->nKeyCol; k++){
drhd3001712009-05-12 17:46:53 +00004310 const char *z1;
4311 const char *z2;
drh1f9ca2c2015-08-25 16:57:52 +00004312 assert( pIdx->aiColumn[k]>=0 );
danielk1977d8123362004-06-12 09:25:12 +00004313 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
drhd3001712009-05-12 17:46:53 +00004314 z1 = pIdx->azColl[k];
4315 z2 = pIndex->azColl[k];
drhc41c1322016-02-11 13:30:36 +00004316 if( sqlite3StrICmp(z1, z2) ) break;
danielk1977d8123362004-06-12 09:25:12 +00004317 }
drhbbbdc832013-10-22 18:01:40 +00004318 if( k==pIdx->nKeyCol ){
danielk1977f736b772004-06-17 06:13:34 +00004319 if( pIdx->onError!=pIndex->onError ){
4320 /* This constraint creates the same index as a previous
4321 ** constraint specified somewhere in the CREATE TABLE statement.
4322 ** However the ON CONFLICT clauses are different. If both this
4323 ** constraint and the previous equivalent constraint have explicit
4324 ** ON CONFLICT clauses this is an error. Otherwise, use the
mistachkin48864df2013-03-21 21:20:32 +00004325 ** explicitly specified behavior for the index.
danielk1977f736b772004-06-17 06:13:34 +00004326 */
4327 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
4328 sqlite3ErrorMsg(pParse,
4329 "conflicting ON CONFLICT clauses specified", 0);
4330 }
4331 if( pIdx->onError==OE_Default ){
4332 pIdx->onError = pIndex->onError;
4333 }
4334 }
drh273bfe92016-06-02 16:22:53 +00004335 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
drh885eeb62019-01-09 02:02:24 +00004336 if( IN_RENAME_OBJECT ){
4337 pIndex->pNext = pParse->pNewIndex;
4338 pParse->pNewIndex = pIndex;
4339 pIndex = 0;
4340 }
danielk1977d8123362004-06-12 09:25:12 +00004341 goto exit_create_index;
4342 }
4343 }
4344 }
4345
danc9461ec2018-08-29 21:00:16 +00004346 if( !IN_RENAME_OBJECT ){
drhd78eeee2001-09-13 16:18:53 +00004347
dancf8f2892018-08-09 20:47:01 +00004348 /* Link the new Index structure to its table and to the other
4349 ** in-memory database structures.
drh063336a2004-11-05 20:58:39 +00004350 */
dancf8f2892018-08-09 20:47:01 +00004351 assert( pParse->nErr==0 );
4352 if( db->init.busy ){
4353 Index *p;
4354 assert( !IN_SPECIAL_PARSE );
4355 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
dancf8f2892018-08-09 20:47:01 +00004356 if( pTblName!=0 ){
4357 pIndex->tnum = db->init.newTnum;
drh8d406732019-01-30 18:33:33 +00004358 if( sqlite3IndexHasDuplicateRootPage(pIndex) ){
drh8bf41262019-01-30 19:50:07 +00004359 sqlite3ErrorMsg(pParse, "invalid rootpage");
drh8d406732019-01-30 18:33:33 +00004360 pParse->rc = SQLITE_CORRUPT_BKPT;
4361 goto exit_create_index;
4362 }
dancf8f2892018-08-09 20:47:01 +00004363 }
danda7a4c02019-01-30 19:12:13 +00004364 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
4365 pIndex->zName, pIndex);
4366 if( p ){
4367 assert( p==pIndex ); /* Malloc must have failed */
4368 sqlite3OomFault(db);
4369 goto exit_create_index;
4370 }
4371 db->mDbFlags |= DBFLAG_SchemaChange;
drh75897232000-05-29 14:26:00 +00004372 }
drh063336a2004-11-05 20:58:39 +00004373
dancf8f2892018-08-09 20:47:01 +00004374 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
4375 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
4376 ** emit code to allocate the index rootpage on disk and make an entry for
drh1e32bed2020-06-19 13:33:53 +00004377 ** the index in the sqlite_schema table and populate the index with
4378 ** content. But, do not do this if we are simply reading the sqlite_schema
dancf8f2892018-08-09 20:47:01 +00004379 ** table to parse the schema, or if this index is the PRIMARY KEY index
4380 ** of a WITHOUT ROWID table.
4381 **
4382 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
4383 ** or UNIQUE index in a CREATE TABLE statement. Since the table
4384 ** has just been created, it contains no data and the index initialization
4385 ** step can be skipped.
drh063336a2004-11-05 20:58:39 +00004386 */
dancf8f2892018-08-09 20:47:01 +00004387 else if( HasRowid(pTab) || pTblName!=0 ){
4388 Vdbe *v;
4389 char *zStmt;
4390 int iMem = ++pParse->nMem;
drh063336a2004-11-05 20:58:39 +00004391
dancf8f2892018-08-09 20:47:01 +00004392 v = sqlite3GetVdbe(pParse);
4393 if( v==0 ) goto exit_create_index;
4394
4395 sqlite3BeginWriteOperation(pParse, 1, iDb);
4396
4397 /* Create the rootpage for the index using CreateIndex. But before
4398 ** doing so, code a Noop instruction and store its address in
4399 ** Index.tnum. This is required in case this index is actually a
4400 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
4401 ** that case the convertToWithoutRowidTable() routine will replace
4402 ** the Noop with a Goto to jump over the VDBE code generated below. */
drhabc38152020-07-22 13:38:04 +00004403 pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
dancf8f2892018-08-09 20:47:01 +00004404 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
4405
4406 /* Gather the complete text of the CREATE INDEX statement into
4407 ** the zStmt variable
4408 */
drh55f66b32019-07-16 19:44:32 +00004409 assert( pName!=0 || pStart==0 );
dancf8f2892018-08-09 20:47:01 +00004410 if( pStart ){
4411 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
4412 if( pName->z[n-1]==';' ) n--;
4413 /* A named index with an explicit CREATE INDEX statement */
4414 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
4415 onError==OE_None ? "" : " UNIQUE", n, pName->z);
4416 }else{
4417 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
4418 /* zStmt = sqlite3MPrintf(""); */
4419 zStmt = 0;
4420 }
4421
drh1e32bed2020-06-19 13:33:53 +00004422 /* Add an entry in sqlite_schema for this index
dancf8f2892018-08-09 20:47:01 +00004423 */
4424 sqlite3NestedParse(pParse,
drhfd4bf772021-12-03 14:43:49 +00004425 "INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
4426 db->aDb[iDb].zDbSName,
4427 pIndex->zName,
4428 pTab->zName,
4429 iMem,
4430 zStmt
4431 );
dancf8f2892018-08-09 20:47:01 +00004432 sqlite3DbFree(db, zStmt);
4433
4434 /* Fill the index with data and reparse the schema. Code an OP_Expire
4435 ** to invalidate all pre-compiled statements.
4436 */
4437 if( pTblName ){
4438 sqlite3RefillIndex(pParse, pIndex, iMem);
4439 sqlite3ChangeCookie(pParse, iDb);
4440 sqlite3VdbeAddParseSchemaOp(v, iDb,
dan6a5a13d2021-02-17 20:08:22 +00004441 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
dancf8f2892018-08-09 20:47:01 +00004442 sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
4443 }
4444
drhabc38152020-07-22 13:38:04 +00004445 sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
drh5e00f6c2001-09-13 13:46:56 +00004446 }
drh75897232000-05-29 14:26:00 +00004447 }
drh234c39d2004-07-24 03:30:47 +00004448 if( db->init.busy || pTblName==0 ){
drhd35bdd62019-12-15 02:49:32 +00004449 pIndex->pNext = pTab->pIndex;
4450 pTab->pIndex = pIndex;
drh234c39d2004-07-24 03:30:47 +00004451 pIndex = 0;
danielk1977d8123362004-06-12 09:25:12 +00004452 }
danc9461ec2018-08-29 21:00:16 +00004453 else if( IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00004454 assert( pParse->pNewIndex==0 );
4455 pParse->pNewIndex = pIndex;
4456 pIndex = 0;
4457 }
danielk1977d8123362004-06-12 09:25:12 +00004458
drh75897232000-05-29 14:26:00 +00004459 /* Clean up before exiting */
4460exit_create_index:
dancf8f2892018-08-09 20:47:01 +00004461 if( pIndex ) sqlite3FreeIndex(db, pIndex);
drh97060e52021-03-21 17:52:47 +00004462 if( pTab ){
4463 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
4464 ** The list was already ordered when this routine was entered, so at this
4465 ** point at most a single index (the newly added index) will be out of
4466 ** order. So we have to reorder at most one index. */
drhe85e1da2021-10-01 21:01:07 +00004467 Index **ppFrom;
drhd35bdd62019-12-15 02:49:32 +00004468 Index *pThis;
4469 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
4470 Index *pNext;
4471 if( pThis->onError!=OE_Replace ) continue;
4472 while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
4473 *ppFrom = pNext;
4474 pThis->pNext = pNext->pNext;
4475 pNext->pNext = pThis;
4476 ppFrom = &pNext->pNext;
4477 }
4478 break;
4479 }
drh97060e52021-03-21 17:52:47 +00004480#ifdef SQLITE_DEBUG
4481 /* Verify that all REPLACE indexes really are now at the end
4482 ** of the index list. In other words, no other index type ever
4483 ** comes after a REPLACE index on the list. */
4484 for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
4485 assert( pThis->onError!=OE_Replace
4486 || pThis->pNext==0
4487 || pThis->pNext->onError==OE_Replace );
4488 }
4489#endif
drhd35bdd62019-12-15 02:49:32 +00004490 }
drh1fe05372013-07-31 18:12:26 +00004491 sqlite3ExprDelete(db, pPIWhere);
drh633e6d52008-07-28 19:34:53 +00004492 sqlite3ExprListDelete(db, pList);
4493 sqlite3SrcListDelete(db, pTblName);
4494 sqlite3DbFree(db, zName);
drh75897232000-05-29 14:26:00 +00004495}
4496
4497/*
drh51147ba2005-07-23 22:59:55 +00004498** Fill the Index.aiRowEst[] array with default information - information
drh91124b32005-08-18 18:15:05 +00004499** to be used when we have not run the ANALYZE command.
drh28c4cf42005-07-27 20:41:43 +00004500**
peter.d.reid60ec9142014-09-06 16:39:46 +00004501** aiRowEst[0] is supposed to contain the number of elements in the index.
drh28c4cf42005-07-27 20:41:43 +00004502** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
4503** number of rows in the table that match any particular value of the
4504** first column of the index. aiRowEst[2] is an estimate of the number
dancfc9df72014-04-25 15:01:01 +00004505** of rows that match any particular combination of the first 2 columns
drh28c4cf42005-07-27 20:41:43 +00004506** of the index. And so forth. It must always be the case that
4507*
4508** aiRowEst[N]<=aiRowEst[N-1]
4509** aiRowEst[N]>=1
4510**
4511** Apart from that, we have little to go on besides intuition as to
4512** how aiRowEst[] should be initialized. The numbers generated here
4513** are based on typical values found in actual indices.
drh51147ba2005-07-23 22:59:55 +00004514*/
4515void sqlite3DefaultRowEst(Index *pIdx){
drh56c65c92020-05-28 00:45:16 +00004516 /* 10, 9, 8, 7, 6 */
4517 static const LogEst aVal[] = { 33, 32, 30, 28, 26 };
dancfc9df72014-04-25 15:01:01 +00004518 LogEst *a = pIdx->aiRowLogEst;
drh56c65c92020-05-28 00:45:16 +00004519 LogEst x;
dancfc9df72014-04-25 15:01:01 +00004520 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
drh51147ba2005-07-23 22:59:55 +00004521 int i;
dancfc9df72014-04-25 15:01:01 +00004522
drh33bec3f2017-02-17 13:38:15 +00004523 /* Indexes with default row estimates should not have stat1 data */
4524 assert( !pIdx->hasStat1 );
4525
dan264d2b92014-04-29 19:01:57 +00004526 /* Set the first entry (number of rows in the index) to the estimated
drh8dc570b2016-06-08 18:07:21 +00004527 ** number of rows in the table, or half the number of rows in the table
drh56c65c92020-05-28 00:45:16 +00004528 ** for a partial index.
4529 **
4530 ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
4531 ** table but other parts we are having to guess at, then do not let the
4532 ** estimated number of rows in the table be less than 1000 (LogEst 99).
4533 ** Failure to do this can cause the indexes for which we do not have
drh8c1fbe82020-08-11 17:20:02 +00004534 ** stat1 data to be ignored by the query planner.
drh56c65c92020-05-28 00:45:16 +00004535 */
4536 x = pIdx->pTable->nRowLogEst;
4537 assert( 99==sqlite3LogEst(1000) );
4538 if( x<99 ){
4539 pIdx->pTable->nRowLogEst = x = 99;
4540 }
drh5f086dd2021-04-29 13:37:36 +00004541 if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); }
drh56c65c92020-05-28 00:45:16 +00004542 a[0] = x;
dan264d2b92014-04-29 19:01:57 +00004543
4544 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
4545 ** 6 and each subsequent value (if any) is 5. */
dancfc9df72014-04-25 15:01:01 +00004546 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
dan264d2b92014-04-29 19:01:57 +00004547 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
4548 a[i] = 23; assert( 23==sqlite3LogEst(5) );
drh28c4cf42005-07-27 20:41:43 +00004549 }
dan264d2b92014-04-29 19:01:57 +00004550
4551 assert( 0==sqlite3LogEst(1) );
drh5f1d1d92014-07-31 22:59:04 +00004552 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
drh51147ba2005-07-23 22:59:55 +00004553}
4554
4555/*
drh74e24cd2002-01-09 03:19:59 +00004556** This routine will drop an existing named index. This routine
4557** implements the DROP INDEX statement.
drh75897232000-05-29 14:26:00 +00004558*/
drh4d91a702006-01-04 15:54:36 +00004559void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
drh75897232000-05-29 14:26:00 +00004560 Index *pIndex;
drh75897232000-05-29 14:26:00 +00004561 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00004562 sqlite3 *db = pParse->db;
danielk1977da184232006-01-05 11:34:32 +00004563 int iDb;
drh75897232000-05-29 14:26:00 +00004564
drh8af73d42009-05-13 22:58:28 +00004565 if( db->mallocFailed ){
danielk1977d5d56522005-03-16 12:15:20 +00004566 goto exit_drop_index;
4567 }
drh3cdb1392022-01-24 12:48:54 +00004568 assert( pParse->nErr==0 ); /* Never called with prior non-OOM errors */
drhd24cc422003-03-27 12:51:24 +00004569 assert( pName->nSrc==1 );
danielk1977d5d56522005-03-16 12:15:20 +00004570 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
4571 goto exit_drop_index;
4572 }
danielk19774adee202004-05-08 08:23:19 +00004573 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
drh75897232000-05-29 14:26:00 +00004574 if( pIndex==0 ){
drh4d91a702006-01-04 15:54:36 +00004575 if( !ifExists ){
drha9799932021-03-19 13:00:28 +00004576 sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
dan57966752011-04-09 17:32:58 +00004577 }else{
4578 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
drh31da7be2021-05-13 18:24:22 +00004579 sqlite3ForceNotReadOnly(pParse);
drh4d91a702006-01-04 15:54:36 +00004580 }
drha6ecd332004-06-10 00:29:09 +00004581 pParse->checkSchema = 1;
drhd24cc422003-03-27 12:51:24 +00004582 goto exit_drop_index;
drh75897232000-05-29 14:26:00 +00004583 }
drh48dd1d82014-05-27 18:18:58 +00004584 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
danielk19774adee202004-05-08 08:23:19 +00004585 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
drh485b39b2002-07-13 03:11:52 +00004586 "or PRIMARY KEY constraint cannot be dropped", 0);
drhd24cc422003-03-27 12:51:24 +00004587 goto exit_drop_index;
4588 }
danielk1977da184232006-01-05 11:34:32 +00004589 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drhe5f9c642003-01-13 23:27:31 +00004590#ifndef SQLITE_OMIT_AUTHORIZATION
4591 {
4592 int code = SQLITE_DROP_INDEX;
4593 Table *pTab = pIndex->pTable;
drh69c33822016-08-18 14:33:11 +00004594 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977da184232006-01-05 11:34:32 +00004595 const char *zTab = SCHEMA_TABLE(iDb);
danielk19774adee202004-05-08 08:23:19 +00004596 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
drhd24cc422003-03-27 12:51:24 +00004597 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00004598 }
drh93fd5422021-06-14 20:41:20 +00004599 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00004600 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
drhd24cc422003-03-27 12:51:24 +00004601 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00004602 }
drhed6c8672003-01-12 18:02:16 +00004603 }
drhe5f9c642003-01-13 23:27:31 +00004604#endif
drh75897232000-05-29 14:26:00 +00004605
drh067b92b2020-06-19 15:24:12 +00004606 /* Generate code to remove the index and from the schema table */
danielk19774adee202004-05-08 08:23:19 +00004607 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00004608 if( v ){
drh77658e22007-12-04 16:54:52 +00004609 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00004610 sqlite3NestedParse(pParse,
drha4a871c2021-11-04 14:04:20 +00004611 "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='index'",
drh346a70c2020-06-15 20:27:35 +00004612 db->aDb[iDb].zDbSName, pIndex->zName
drhb17131a2004-11-05 22:18:49 +00004613 );
drha5ae4c32011-08-07 01:31:52 +00004614 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
drh9cbf3422008-01-17 16:22:13 +00004615 sqlite3ChangeCookie(pParse, iDb);
drhb17131a2004-11-05 22:18:49 +00004616 destroyRootPage(pParse, pIndex->tnum, iDb);
drh66a51672008-01-03 00:01:23 +00004617 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
drh75897232000-05-29 14:26:00 +00004618 }
4619
drhd24cc422003-03-27 12:51:24 +00004620exit_drop_index:
drh633e6d52008-07-28 19:34:53 +00004621 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00004622}
4623
4624/*
dan9ace1122012-03-29 07:51:45 +00004625** pArray is a pointer to an array of objects. Each object in the
4626** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
4627** to extend the array so that there is space for a new object at the end.
drh13449892005-09-07 21:22:45 +00004628**
dan9ace1122012-03-29 07:51:45 +00004629** When this function is called, *pnEntry contains the current size of
4630** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
4631** in total).
drh13449892005-09-07 21:22:45 +00004632**
dan9ace1122012-03-29 07:51:45 +00004633** If the realloc() is successful (i.e. if no OOM condition occurs), the
4634** space allocated for the new object is zeroed, *pnEntry updated to
4635** reflect the new size of the array and a pointer to the new allocation
4636** returned. *pIdx is set to the index of the new array entry in this case.
drh13449892005-09-07 21:22:45 +00004637**
dan9ace1122012-03-29 07:51:45 +00004638** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
4639** unchanged and a copy of pArray returned.
drh13449892005-09-07 21:22:45 +00004640*/
drhcf643722007-03-27 13:36:37 +00004641void *sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00004642 sqlite3 *db, /* Connection to notify of malloc failures */
drhcf643722007-03-27 13:36:37 +00004643 void *pArray, /* Array of objects. Might be reallocated */
4644 int szEntry, /* Size of each object in the array */
drhcf643722007-03-27 13:36:37 +00004645 int *pnEntry, /* Number of objects currently in use */
drhcf643722007-03-27 13:36:37 +00004646 int *pIdx /* Write the index of a new slot here */
4647){
4648 char *z;
drhf6ad2012019-04-13 14:07:57 +00004649 sqlite3_int64 n = *pIdx = *pnEntry;
drh6c535152012-02-02 03:38:30 +00004650 if( (n & (n-1))==0 ){
drh0aa32312019-04-13 04:01:12 +00004651 sqlite3_int64 sz = (n==0) ? 1 : 2*n;
drh6c535152012-02-02 03:38:30 +00004652 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
drh13449892005-09-07 21:22:45 +00004653 if( pNew==0 ){
drhcf643722007-03-27 13:36:37 +00004654 *pIdx = -1;
4655 return pArray;
drh13449892005-09-07 21:22:45 +00004656 }
drhcf643722007-03-27 13:36:37 +00004657 pArray = pNew;
drh13449892005-09-07 21:22:45 +00004658 }
drhcf643722007-03-27 13:36:37 +00004659 z = (char*)pArray;
drh6c535152012-02-02 03:38:30 +00004660 memset(&z[n * szEntry], 0, szEntry);
drhcf643722007-03-27 13:36:37 +00004661 ++*pnEntry;
4662 return pArray;
drh13449892005-09-07 21:22:45 +00004663}
4664
4665/*
drh75897232000-05-29 14:26:00 +00004666** Append a new element to the given IdList. Create a new IdList if
4667** need be.
drhdaffd0e2001-04-11 14:28:42 +00004668**
4669** A new IdList is returned, or NULL if malloc() fails.
drh75897232000-05-29 14:26:00 +00004670*/
dan5496d6a2018-08-13 17:14:26 +00004671IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
4672 sqlite3 *db = pParse->db;
drh13449892005-09-07 21:22:45 +00004673 int i;
drh75897232000-05-29 14:26:00 +00004674 if( pList==0 ){
drh17435752007-08-16 04:30:38 +00004675 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
drh75897232000-05-29 14:26:00 +00004676 if( pList==0 ) return 0;
drha99e3252022-04-15 15:47:14 +00004677 }else{
4678 IdList *pNew;
4679 pNew = sqlite3DbRealloc(db, pList,
4680 sizeof(IdList) + pList->nId*sizeof(pList->a));
4681 if( pNew==0 ){
4682 sqlite3IdListDelete(db, pList);
4683 return 0;
4684 }
4685 pList = pNew;
drh75897232000-05-29 14:26:00 +00004686 }
drha99e3252022-04-15 15:47:14 +00004687 i = pList->nId++;
drh17435752007-08-16 04:30:38 +00004688 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
danc9461ec2018-08-29 21:00:16 +00004689 if( IN_RENAME_OBJECT && pList->a[i].zName ){
dan07e95232018-08-21 16:32:53 +00004690 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
dan5496d6a2018-08-13 17:14:26 +00004691 }
drh75897232000-05-29 14:26:00 +00004692 return pList;
4693}
4694
4695/*
drhfe05af82005-07-21 03:14:59 +00004696** Delete an IdList.
4697*/
drh633e6d52008-07-28 19:34:53 +00004698void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
drhfe05af82005-07-21 03:14:59 +00004699 int i;
drh41ce47c2022-08-22 02:00:26 +00004700 assert( db!=0 );
drhfe05af82005-07-21 03:14:59 +00004701 if( pList==0 ) return;
drhf80bb192022-04-18 19:48:31 +00004702 assert( pList->eU4!=EU4_EXPR ); /* EU4_EXPR mode is not currently used */
drhfe05af82005-07-21 03:14:59 +00004703 for(i=0; i<pList->nId; i++){
drh633e6d52008-07-28 19:34:53 +00004704 sqlite3DbFree(db, pList->a[i].zName);
drhfe05af82005-07-21 03:14:59 +00004705 }
drh41ce47c2022-08-22 02:00:26 +00004706 sqlite3DbNNFreeNN(db, pList);
drhfe05af82005-07-21 03:14:59 +00004707}
4708
4709/*
4710** Return the index in pList of the identifier named zId. Return -1
4711** if not found.
4712*/
4713int sqlite3IdListIndex(IdList *pList, const char *zName){
4714 int i;
drhd44f8b22022-04-07 01:11:13 +00004715 assert( pList!=0 );
drhfe05af82005-07-21 03:14:59 +00004716 for(i=0; i<pList->nId; i++){
4717 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
4718 }
4719 return -1;
4720}
4721
4722/*
drh0ad7aa82019-01-17 14:34:46 +00004723** Maximum size of a SrcList object.
4724** The SrcList object is used to represent the FROM clause of a
4725** SELECT statement, and the query planner cannot deal with more
4726** than 64 tables in a join. So any value larger than 64 here
4727** is sufficient for most uses. Smaller values, like say 10, are
4728** appropriate for small and memory-limited applications.
4729*/
4730#ifndef SQLITE_MAX_SRCLIST
4731# define SQLITE_MAX_SRCLIST 200
4732#endif
4733
4734/*
drha78c22c2008-11-11 18:28:58 +00004735** Expand the space allocated for the given SrcList object by
4736** creating nExtra new slots beginning at iStart. iStart is zero based.
4737** New slots are zeroed.
4738**
4739** For example, suppose a SrcList initially contains two entries: A,B.
4740** To append 3 new entries onto the end, do this:
4741**
4742** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
4743**
4744** After the call above it would contain: A, B, nil, nil, nil.
4745** If the iStart argument had been 1 instead of 2, then the result
4746** would have been: A, nil, nil, nil, B. To prepend the new slots,
4747** the iStart value would be 0. The result then would
4748** be: nil, nil, nil, A, B.
4749**
drh29c992c2019-01-17 15:40:41 +00004750** If a memory allocation fails or the SrcList becomes too large, leave
4751** the original SrcList unchanged, return NULL, and leave an error message
4752** in pParse.
drha78c22c2008-11-11 18:28:58 +00004753*/
4754SrcList *sqlite3SrcListEnlarge(
drh29c992c2019-01-17 15:40:41 +00004755 Parse *pParse, /* Parsing context into which errors are reported */
drha78c22c2008-11-11 18:28:58 +00004756 SrcList *pSrc, /* The SrcList to be enlarged */
4757 int nExtra, /* Number of new slots to add to pSrc->a[] */
4758 int iStart /* Index in pSrc->a[] of first new slot */
4759){
4760 int i;
4761
4762 /* Sanity checking on calling parameters */
4763 assert( iStart>=0 );
4764 assert( nExtra>=1 );
drh8af73d42009-05-13 22:58:28 +00004765 assert( pSrc!=0 );
4766 assert( iStart<=pSrc->nSrc );
drha78c22c2008-11-11 18:28:58 +00004767
4768 /* Allocate additional space if needed */
drhfc5717c2014-03-05 19:04:46 +00004769 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
drha78c22c2008-11-11 18:28:58 +00004770 SrcList *pNew;
drh0aa32312019-04-13 04:01:12 +00004771 sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
drh29c992c2019-01-17 15:40:41 +00004772 sqlite3 *db = pParse->db;
drh0ad7aa82019-01-17 14:34:46 +00004773
4774 if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
drh29c992c2019-01-17 15:40:41 +00004775 sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
4776 SQLITE_MAX_SRCLIST);
4777 return 0;
drh0ad7aa82019-01-17 14:34:46 +00004778 }
4779 if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST;
drha78c22c2008-11-11 18:28:58 +00004780 pNew = sqlite3DbRealloc(db, pSrc,
4781 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
4782 if( pNew==0 ){
4783 assert( db->mallocFailed );
drh29c992c2019-01-17 15:40:41 +00004784 return 0;
drha78c22c2008-11-11 18:28:58 +00004785 }
4786 pSrc = pNew;
drhd0ee3a12019-02-06 01:18:36 +00004787 pSrc->nAlloc = nAlloc;
drha78c22c2008-11-11 18:28:58 +00004788 }
4789
4790 /* Move existing slots that come after the newly inserted slots
4791 ** out of the way */
4792 for(i=pSrc->nSrc-1; i>=iStart; i--){
4793 pSrc->a[i+nExtra] = pSrc->a[i];
4794 }
drh6d1626e2014-03-05 15:52:43 +00004795 pSrc->nSrc += nExtra;
drha78c22c2008-11-11 18:28:58 +00004796
4797 /* Zero the newly allocated slots */
4798 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
4799 for(i=iStart; i<iStart+nExtra; i++){
4800 pSrc->a[i].iCursor = -1;
4801 }
4802
4803 /* Return a pointer to the enlarged SrcList */
4804 return pSrc;
4805}
4806
4807
4808/*
drhad3cab52002-05-24 02:04:32 +00004809** Append a new table name to the given SrcList. Create a new SrcList if
drhb7916a72009-05-27 10:31:29 +00004810** need be. A new entry is created in the SrcList even if pTable is NULL.
drhad3cab52002-05-24 02:04:32 +00004811**
drh29c992c2019-01-17 15:40:41 +00004812** A SrcList is returned, or NULL if there is an OOM error or if the
4813** SrcList grows to large. The returned
drha78c22c2008-11-11 18:28:58 +00004814** SrcList might be the same as the SrcList that was input or it might be
4815** a new one. If an OOM error does occurs, then the prior value of pList
4816** that is input to this routine is automatically freed.
drh113088e2003-03-20 01:16:58 +00004817**
4818** If pDatabase is not null, it means that the table has an optional
4819** database name prefix. Like this: "database.table". The pDatabase
4820** points to the table name and the pTable points to the database name.
4821** The SrcList.a[].zName field is filled with the table name which might
4822** come from pTable (if pDatabase is NULL) or from pDatabase.
4823** SrcList.a[].zDatabase is filled with the database name from pTable,
4824** or with NULL if no database is specified.
4825**
4826** In other words, if call like this:
4827**
drh17435752007-08-16 04:30:38 +00004828** sqlite3SrcListAppend(D,A,B,0);
drh113088e2003-03-20 01:16:58 +00004829**
4830** Then B is a table name and the database name is unspecified. If called
4831** like this:
4832**
drh17435752007-08-16 04:30:38 +00004833** sqlite3SrcListAppend(D,A,B,C);
drh113088e2003-03-20 01:16:58 +00004834**
drhd3001712009-05-12 17:46:53 +00004835** Then C is the table name and B is the database name. If C is defined
4836** then so is B. In other words, we never have a case where:
4837**
4838** sqlite3SrcListAppend(D,A,0,C);
drhb7916a72009-05-27 10:31:29 +00004839**
4840** Both pTable and pDatabase are assumed to be quoted. They are dequoted
4841** before being added to the SrcList.
drhad3cab52002-05-24 02:04:32 +00004842*/
drh17435752007-08-16 04:30:38 +00004843SrcList *sqlite3SrcListAppend(
drh29c992c2019-01-17 15:40:41 +00004844 Parse *pParse, /* Parsing context, in which errors are reported */
drh17435752007-08-16 04:30:38 +00004845 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
4846 Token *pTable, /* Table to append */
4847 Token *pDatabase /* Database of the table */
4848){
drh76012942021-02-21 21:04:54 +00004849 SrcItem *pItem;
drh29c992c2019-01-17 15:40:41 +00004850 sqlite3 *db;
drhd3001712009-05-12 17:46:53 +00004851 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
drh29c992c2019-01-17 15:40:41 +00004852 assert( pParse!=0 );
4853 assert( pParse->db!=0 );
4854 db = pParse->db;
drhad3cab52002-05-24 02:04:32 +00004855 if( pList==0 ){
drh29c992c2019-01-17 15:40:41 +00004856 pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
drhad3cab52002-05-24 02:04:32 +00004857 if( pList==0 ) return 0;
drh4305d102003-07-30 12:34:12 +00004858 pList->nAlloc = 1;
drhac178b32016-12-14 11:14:13 +00004859 pList->nSrc = 1;
4860 memset(&pList->a[0], 0, sizeof(pList->a[0]));
4861 pList->a[0].iCursor = -1;
4862 }else{
drh29c992c2019-01-17 15:40:41 +00004863 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
4864 if( pNew==0 ){
4865 sqlite3SrcListDelete(db, pList);
4866 return 0;
4867 }else{
4868 pList = pNew;
4869 }
drhad3cab52002-05-24 02:04:32 +00004870 }
drha78c22c2008-11-11 18:28:58 +00004871 pItem = &pList->a[pList->nSrc-1];
drh113088e2003-03-20 01:16:58 +00004872 if( pDatabase && pDatabase->z==0 ){
4873 pDatabase = 0;
4874 }
drhd3001712009-05-12 17:46:53 +00004875 if( pDatabase ){
drh169a6892017-07-06 01:02:09 +00004876 pItem->zName = sqlite3NameFromToken(db, pDatabase);
4877 pItem->zDatabase = sqlite3NameFromToken(db, pTable);
4878 }else{
4879 pItem->zName = sqlite3NameFromToken(db, pTable);
4880 pItem->zDatabase = 0;
drh113088e2003-03-20 01:16:58 +00004881 }
drhad3cab52002-05-24 02:04:32 +00004882 return pList;
4883}
4884
4885/*
drhdfe88ec2008-11-03 20:55:06 +00004886** Assign VdbeCursor index numbers to all tables in a SrcList
drh63eb5f22003-04-29 16:20:44 +00004887*/
danielk19774adee202004-05-08 08:23:19 +00004888void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
drh63eb5f22003-04-29 16:20:44 +00004889 int i;
drh76012942021-02-21 21:04:54 +00004890 SrcItem *pItem;
drh9da977f2021-04-20 12:14:12 +00004891 assert( pList || pParse->db->mallocFailed );
4892 if( ALWAYS(pList) ){
danielk1977261919c2005-12-06 12:52:59 +00004893 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
drh34055852020-10-19 01:23:48 +00004894 if( pItem->iCursor>=0 ) continue;
danielk1977261919c2005-12-06 12:52:59 +00004895 pItem->iCursor = pParse->nTab++;
4896 if( pItem->pSelect ){
4897 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
4898 }
drh63eb5f22003-04-29 16:20:44 +00004899 }
4900 }
4901}
4902
4903/*
drhad3cab52002-05-24 02:04:32 +00004904** Delete an entire SrcList including all its substructure.
4905*/
drh633e6d52008-07-28 19:34:53 +00004906void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
drhad3cab52002-05-24 02:04:32 +00004907 int i;
drh76012942021-02-21 21:04:54 +00004908 SrcItem *pItem;
drh41ce47c2022-08-22 02:00:26 +00004909 assert( db!=0 );
drhad3cab52002-05-24 02:04:32 +00004910 if( pList==0 ) return;
drhbe5c89a2004-07-26 00:31:09 +00004911 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
drh41ce47c2022-08-22 02:00:26 +00004912 if( pItem->zDatabase ) sqlite3DbNNFreeNN(db, pItem->zDatabase);
4913 if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
4914 if( pItem->zAlias ) sqlite3DbNNFreeNN(db, pItem->zAlias);
drh8a48b9c2015-08-19 15:20:00 +00004915 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
4916 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
dan1feeaed2010-07-23 15:41:47 +00004917 sqlite3DeleteTable(db, pItem->pTab);
drh45d827c2020-08-15 23:48:22 +00004918 if( pItem->pSelect ) sqlite3SelectDelete(db, pItem->pSelect);
drhd44f8b22022-04-07 01:11:13 +00004919 if( pItem->fg.isUsing ){
4920 sqlite3IdListDelete(db, pItem->u3.pUsing);
4921 }else if( pItem->u3.pOn ){
4922 sqlite3ExprDelete(db, pItem->u3.pOn);
4923 }
drh75897232000-05-29 14:26:00 +00004924 }
drh41ce47c2022-08-22 02:00:26 +00004925 sqlite3DbNNFreeNN(db, pList);
drh75897232000-05-29 14:26:00 +00004926}
4927
drh982cef72000-05-30 16:27:03 +00004928/*
drh61dfc312006-12-16 16:25:15 +00004929** This routine is called by the parser to add a new term to the
4930** end of a growing FROM clause. The "p" parameter is the part of
4931** the FROM clause that has already been constructed. "p" is NULL
4932** if this is the first term of the FROM clause. pTable and pDatabase
4933** are the name of the table and database named in the FROM clause term.
4934** pDatabase is NULL if the database name qualifier is missing - the
peter.d.reid60ec9142014-09-06 16:39:46 +00004935** usual case. If the term has an alias, then pAlias points to the
drh61dfc312006-12-16 16:25:15 +00004936** alias token. If the term is a subquery, then pSubquery is the
4937** SELECT statement that the subquery encodes. The pTable and
4938** pDatabase parameters are NULL for subqueries. The pOn and pUsing
4939** parameters are the content of the ON and USING clauses.
4940**
4941** Return a new SrcList which encodes is the FROM with the new
4942** term added.
4943*/
4944SrcList *sqlite3SrcListAppendFromTerm(
drh17435752007-08-16 04:30:38 +00004945 Parse *pParse, /* Parsing context */
drh61dfc312006-12-16 16:25:15 +00004946 SrcList *p, /* The left part of the FROM clause already seen */
4947 Token *pTable, /* Name of the table to add to the FROM clause */
4948 Token *pDatabase, /* Name of the database containing pTable */
4949 Token *pAlias, /* The right-hand side of the AS subexpression */
4950 Select *pSubquery, /* A subquery used in place of a table name */
drhd44f8b22022-04-07 01:11:13 +00004951 OnOrUsing *pOnUsing /* Either the ON clause or the USING clause */
drh61dfc312006-12-16 16:25:15 +00004952){
drh76012942021-02-21 21:04:54 +00004953 SrcItem *pItem;
drh17435752007-08-16 04:30:38 +00004954 sqlite3 *db = pParse->db;
drhd44f8b22022-04-07 01:11:13 +00004955 if( !p && pOnUsing!=0 && (pOnUsing->pOn || pOnUsing->pUsing) ){
danielk1977bd1a0a42009-07-01 16:12:07 +00004956 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
drhd44f8b22022-04-07 01:11:13 +00004957 (pOnUsing->pOn ? "ON" : "USING")
danielk1977bd1a0a42009-07-01 16:12:07 +00004958 );
4959 goto append_from_error;
4960 }
drh29c992c2019-01-17 15:40:41 +00004961 p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
drh9d9c41e2017-10-31 03:40:15 +00004962 if( p==0 ){
danielk1977bd1a0a42009-07-01 16:12:07 +00004963 goto append_from_error;
drh61dfc312006-12-16 16:25:15 +00004964 }
drh9d9c41e2017-10-31 03:40:15 +00004965 assert( p->nSrc>0 );
drh61dfc312006-12-16 16:25:15 +00004966 pItem = &p->a[p->nSrc-1];
drha488ec92018-09-07 18:52:25 +00004967 assert( (pTable==0)==(pDatabase==0) );
4968 assert( pItem->zName==0 || pDatabase!=0 );
danc9461ec2018-08-29 21:00:16 +00004969 if( IN_RENAME_OBJECT && pItem->zName ){
drha488ec92018-09-07 18:52:25 +00004970 Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
danc9461ec2018-08-29 21:00:16 +00004971 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
4972 }
drh8af73d42009-05-13 22:58:28 +00004973 assert( pAlias!=0 );
4974 if( pAlias->n ){
drh17435752007-08-16 04:30:38 +00004975 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
drh61dfc312006-12-16 16:25:15 +00004976 }
drh815b7822022-04-20 15:07:39 +00004977 if( pSubquery ){
4978 pItem->pSelect = pSubquery;
4979 if( pSubquery->selFlags & SF_NestedFrom ){
4980 pItem->fg.isNestedFrom = 1;
4981 }
4982 }
drhd44f8b22022-04-07 01:11:13 +00004983 assert( pOnUsing==0 || pOnUsing->pOn==0 || pOnUsing->pUsing==0 );
4984 assert( pItem->fg.isUsing==0 );
4985 if( pOnUsing==0 ){
4986 pItem->u3.pOn = 0;
4987 }else if( pOnUsing->pUsing ){
4988 pItem->fg.isUsing = 1;
4989 pItem->u3.pUsing = pOnUsing->pUsing;
4990 }else{
4991 pItem->u3.pOn = pOnUsing->pOn;
4992 }
drh61dfc312006-12-16 16:25:15 +00004993 return p;
danielk1977bd1a0a42009-07-01 16:12:07 +00004994
drh46658d72021-12-08 18:50:30 +00004995append_from_error:
danielk1977bd1a0a42009-07-01 16:12:07 +00004996 assert( p==0 );
drhd44f8b22022-04-07 01:11:13 +00004997 sqlite3ClearOnOrUsing(db, pOnUsing);
danielk1977bd1a0a42009-07-01 16:12:07 +00004998 sqlite3SelectDelete(db, pSubquery);
4999 return 0;
drh61dfc312006-12-16 16:25:15 +00005000}
5001
5002/*
danielk1977b1c685b2008-10-06 16:18:39 +00005003** Add an INDEXED BY or NOT INDEXED clause to the most recently added
5004** element of the source-list passed as the second argument.
5005*/
5006void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
drh8af73d42009-05-13 22:58:28 +00005007 assert( pIndexedBy!=0 );
drh8abc80b2017-08-12 01:09:06 +00005008 if( p && pIndexedBy->n>0 ){
drh76012942021-02-21 21:04:54 +00005009 SrcItem *pItem;
drh8abc80b2017-08-12 01:09:06 +00005010 assert( p->nSrc>0 );
5011 pItem = &p->a[p->nSrc-1];
drh8a48b9c2015-08-19 15:20:00 +00005012 assert( pItem->fg.notIndexed==0 );
5013 assert( pItem->fg.isIndexedBy==0 );
5014 assert( pItem->fg.isTabFunc==0 );
danielk1977b1c685b2008-10-06 16:18:39 +00005015 if( pIndexedBy->n==1 && !pIndexedBy->z ){
5016 /* A "NOT INDEXED" clause was supplied. See parse.y
5017 ** construct "indexed_opt" for details. */
drh8a48b9c2015-08-19 15:20:00 +00005018 pItem->fg.notIndexed = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00005019 }else{
drh8a48b9c2015-08-19 15:20:00 +00005020 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
drh8abc80b2017-08-12 01:09:06 +00005021 pItem->fg.isIndexedBy = 1;
drhdbfbb5a2021-10-07 23:04:50 +00005022 assert( pItem->fg.isCte==0 ); /* No collision on union u2 */
danielk1977b1c685b2008-10-06 16:18:39 +00005023 }
5024 }
5025}
5026
5027/*
dan69887c92020-04-27 20:55:33 +00005028** Append the contents of SrcList p2 to SrcList p1 and return the resulting
5029** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
5030** are deleted by this function.
5031*/
5032SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){
dan8b023cf2020-04-30 18:28:40 +00005033 assert( p1 && p1->nSrc==1 );
5034 if( p2 ){
5035 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
5036 if( pNew==0 ){
5037 sqlite3SrcListDelete(pParse->db, p2);
5038 }else{
5039 p1 = pNew;
drh76012942021-02-21 21:04:54 +00005040 memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
drh525326e2020-07-15 21:53:53 +00005041 sqlite3DbFree(pParse->db, p2);
drhd9732682022-04-18 10:09:29 +00005042 p1->a[0].fg.jointype |= (JT_LTORJ & p1->a[1].fg.jointype);
dan69887c92020-04-27 20:55:33 +00005043 }
5044 }
5045 return p1;
5046}
5047
5048/*
drh01d230c2015-08-19 17:11:37 +00005049** Add the list of function arguments to the SrcList entry for a
5050** table-valued-function.
5051*/
5052void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
drh20292312015-11-21 13:24:46 +00005053 if( p ){
drh76012942021-02-21 21:04:54 +00005054 SrcItem *pItem = &p->a[p->nSrc-1];
drh01d230c2015-08-19 17:11:37 +00005055 assert( pItem->fg.notIndexed==0 );
5056 assert( pItem->fg.isIndexedBy==0 );
5057 assert( pItem->fg.isTabFunc==0 );
5058 pItem->u1.pFuncArg = pList;
5059 pItem->fg.isTabFunc = 1;
drhd8b1bfc2015-08-20 23:21:34 +00005060 }else{
5061 sqlite3ExprListDelete(pParse->db, pList);
drh01d230c2015-08-19 17:11:37 +00005062 }
5063}
5064
5065/*
drh61dfc312006-12-16 16:25:15 +00005066** When building up a FROM clause in the parser, the join operator
5067** is initially attached to the left operand. But the code generator
5068** expects the join operator to be on the right operand. This routine
5069** Shifts all join operators from left to right for an entire FROM
5070** clause.
5071**
5072** Example: Suppose the join is like this:
5073**
5074** A natural cross join B
5075**
5076** The operator is "natural cross join". The A and B operands are stored
5077** in p->a[0] and p->a[1], respectively. The parser initially stores the
5078** operator with A. This routine shifts that operator over to B.
drh62ed36b2022-04-10 20:28:41 +00005079**
5080** Additional changes:
5081**
5082** * All tables to the left of the right-most RIGHT JOIN are tagged with
5083** JT_LTORJ (mnemonic: Left Table Of Right Join) so that the
5084** code generator can easily tell that the table is part of
5085** the left operand of at least one RIGHT JOIN.
drh61dfc312006-12-16 16:25:15 +00005086*/
drhfdc621a2022-04-16 19:13:16 +00005087void sqlite3SrcListShiftJoinType(Parse *pParse, SrcList *p){
drh6dab33b2022-04-21 19:25:51 +00005088 (void)pParse;
drh62ed36b2022-04-10 20:28:41 +00005089 if( p && p->nSrc>1 ){
5090 int i = p->nSrc-1;
drha76ac882022-04-08 19:20:12 +00005091 u8 allFlags = 0;
drh62ed36b2022-04-10 20:28:41 +00005092 do{
drha76ac882022-04-08 19:20:12 +00005093 allFlags |= p->a[i].fg.jointype = p->a[i-1].fg.jointype;
drh62ed36b2022-04-10 20:28:41 +00005094 }while( (--i)>0 );
drh8a48b9c2015-08-19 15:20:00 +00005095 p->a[0].fg.jointype = 0;
drha76ac882022-04-08 19:20:12 +00005096
5097 /* All terms to the left of a RIGHT JOIN should be tagged with the
5098 ** JT_LTORJ flags */
5099 if( allFlags & JT_RIGHT ){
5100 for(i=p->nSrc-1; ALWAYS(i>0) && (p->a[i].fg.jointype&JT_RIGHT)==0; i--){}
5101 i--;
5102 assert( i>=0 );
5103 do{
drhfdc621a2022-04-16 19:13:16 +00005104 p->a[i].fg.jointype |= JT_LTORJ;
5105 }while( (--i)>=0 );
drha76ac882022-04-08 19:20:12 +00005106 }
drh61dfc312006-12-16 16:25:15 +00005107 }
5108}
5109
5110/*
drhb0c88652016-02-01 13:21:13 +00005111** Generate VDBE code for a BEGIN statement.
drhc4a3c772001-04-04 11:48:57 +00005112*/
drh684917c2004-10-05 02:41:42 +00005113void sqlite3BeginTransaction(Parse *pParse, int type){
drh9bb575f2004-09-06 17:24:11 +00005114 sqlite3 *db;
danielk19771d850a72004-05-31 08:26:49 +00005115 Vdbe *v;
drh684917c2004-10-05 02:41:42 +00005116 int i;
drh5e00f6c2001-09-13 13:46:56 +00005117
drhd3001712009-05-12 17:46:53 +00005118 assert( pParse!=0 );
5119 db = pParse->db;
5120 assert( db!=0 );
drhd3001712009-05-12 17:46:53 +00005121 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
5122 return;
5123 }
danielk19771d850a72004-05-31 08:26:49 +00005124 v = sqlite3GetVdbe(pParse);
5125 if( !v ) return;
drh684917c2004-10-05 02:41:42 +00005126 if( type!=TK_DEFERRED ){
5127 for(i=0; i<db->nDb; i++){
drh1ca037f2020-10-12 13:24:00 +00005128 int eTxnType;
5129 Btree *pBt = db->aDb[i].pBt;
5130 if( pBt && sqlite3BtreeIsReadonly(pBt) ){
5131 eTxnType = 0; /* Read txn */
5132 }else if( type==TK_EXCLUSIVE ){
5133 eTxnType = 2; /* Exclusive txn */
5134 }else{
5135 eTxnType = 1; /* Write txn */
5136 }
5137 sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType);
drhfb982642007-08-30 01:19:59 +00005138 sqlite3VdbeUsesBtree(v, i);
drh684917c2004-10-05 02:41:42 +00005139 }
5140 }
drhb0c88652016-02-01 13:21:13 +00005141 sqlite3VdbeAddOp0(v, OP_AutoCommit);
drhc4a3c772001-04-04 11:48:57 +00005142}
5143
5144/*
drh07a3b112017-07-06 01:28:02 +00005145** Generate VDBE code for a COMMIT or ROLLBACK statement.
5146** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
5147** code is generated for a COMMIT.
drhc4a3c772001-04-04 11:48:57 +00005148*/
drh07a3b112017-07-06 01:28:02 +00005149void sqlite3EndTransaction(Parse *pParse, int eType){
danielk19771d850a72004-05-31 08:26:49 +00005150 Vdbe *v;
drh07a3b112017-07-06 01:28:02 +00005151 int isRollback;
drh5e00f6c2001-09-13 13:46:56 +00005152
drhd3001712009-05-12 17:46:53 +00005153 assert( pParse!=0 );
drhb07028f2011-10-14 21:49:18 +00005154 assert( pParse->db!=0 );
drh07a3b112017-07-06 01:28:02 +00005155 assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
5156 isRollback = eType==TK_ROLLBACK;
5157 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
5158 isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
drhd3001712009-05-12 17:46:53 +00005159 return;
5160 }
danielk19771d850a72004-05-31 08:26:49 +00005161 v = sqlite3GetVdbe(pParse);
5162 if( v ){
drh07a3b112017-07-06 01:28:02 +00005163 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
drh02f75f12004-02-24 01:04:11 +00005164 }
drhc4a3c772001-04-04 11:48:57 +00005165}
drhf57b14a2001-09-14 18:54:08 +00005166
5167/*
danielk1977fd7f0452008-12-17 17:30:26 +00005168** This function is called by the parser when it parses a command to create,
5169** release or rollback an SQL savepoint.
5170*/
5171void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
danielk1977ab9b7032008-12-30 06:24:58 +00005172 char *zName = sqlite3NameFromToken(pParse->db, pName);
5173 if( zName ){
5174 Vdbe *v = sqlite3GetVdbe(pParse);
5175#ifndef SQLITE_OMIT_AUTHORIZATION
dan558814f2010-06-02 05:53:53 +00005176 static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
danielk1977ab9b7032008-12-30 06:24:58 +00005177 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
5178#endif
5179 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
5180 sqlite3DbFree(pParse->db, zName);
5181 return;
5182 }
5183 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
danielk1977fd7f0452008-12-17 17:30:26 +00005184 }
5185}
5186
5187/*
drhdc3ff9c2004-08-18 02:10:15 +00005188** Make sure the TEMP database is open and available for use. Return
5189** the number of errors. Leave any error messages in the pParse structure.
5190*/
danielk1977ddfb2f02006-02-17 12:25:14 +00005191int sqlite3OpenTempDatabase(Parse *pParse){
drhdc3ff9c2004-08-18 02:10:15 +00005192 sqlite3 *db = pParse->db;
5193 if( db->aDb[1].pBt==0 && !pParse->explain ){
drh33f4e022007-09-03 15:19:34 +00005194 int rc;
drh10a76c92010-01-26 01:25:26 +00005195 Btree *pBt;
drh33f4e022007-09-03 15:19:34 +00005196 static const int flags =
5197 SQLITE_OPEN_READWRITE |
5198 SQLITE_OPEN_CREATE |
5199 SQLITE_OPEN_EXCLUSIVE |
5200 SQLITE_OPEN_DELETEONCLOSE |
5201 SQLITE_OPEN_TEMP_DB;
5202
dan3a6d8ae2011-04-23 15:54:54 +00005203 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
drhdc3ff9c2004-08-18 02:10:15 +00005204 if( rc!=SQLITE_OK ){
5205 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
5206 "file for storing temporary tables");
5207 pParse->rc = rc;
5208 return 1;
5209 }
drh10a76c92010-01-26 01:25:26 +00005210 db->aDb[1].pBt = pBt;
danielk197714db2662006-01-09 16:12:04 +00005211 assert( db->aDb[1].pSchema );
drhe937df82020-05-07 01:56:57 +00005212 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){
drh4a642b62016-02-05 01:55:27 +00005213 sqlite3OomFault(db);
drh7c9c9862010-01-31 14:18:21 +00005214 return 1;
drh10a76c92010-01-26 01:25:26 +00005215 }
drhdc3ff9c2004-08-18 02:10:15 +00005216 }
5217 return 0;
5218}
5219
5220/*
drhaceb31b2014-02-08 01:40:27 +00005221** Record the fact that the schema cookie will need to be verified
5222** for database iDb. The code to actually verify the schema cookie
5223** will occur at the end of the top-level VDBE and will be generated
5224** later, by sqlite3FinishCoding().
drh001bbcb2003-03-19 03:14:00 +00005225*/
drh1d8f8922020-08-16 00:30:44 +00005226static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
5227 assert( iDb>=0 && iDb<pToplevel->db->nDb );
5228 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
drh099b3852021-03-10 16:35:37 +00005229 assert( iDb<SQLITE_MAX_DB );
drh1d8f8922020-08-16 00:30:44 +00005230 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
drha7ab6d82014-07-21 15:44:39 +00005231 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
5232 DbMaskSet(pToplevel->cookieMask, iDb);
drhaceb31b2014-02-08 01:40:27 +00005233 if( !OMIT_TEMPDB && iDb==1 ){
5234 sqlite3OpenTempDatabase(pToplevel);
5235 }
drh001bbcb2003-03-19 03:14:00 +00005236 }
drh001bbcb2003-03-19 03:14:00 +00005237}
drh1d8f8922020-08-16 00:30:44 +00005238void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
5239 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
5240}
5241
drh001bbcb2003-03-19 03:14:00 +00005242
5243/*
dan57966752011-04-09 17:32:58 +00005244** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
5245** attached database. Otherwise, invoke it for the database named zDb only.
5246*/
5247void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
5248 sqlite3 *db = pParse->db;
5249 int i;
5250 for(i=0; i<db->nDb; i++){
5251 Db *pDb = &db->aDb[i];
drh69c33822016-08-18 14:33:11 +00005252 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
dan57966752011-04-09 17:32:58 +00005253 sqlite3CodeVerifySchema(pParse, i);
5254 }
5255 }
5256}
5257
5258/*
drh1c928532002-01-31 15:54:21 +00005259** Generate VDBE code that prepares for doing an operation that
drhc977f7f2002-05-21 11:38:11 +00005260** might change the database.
5261**
5262** This routine starts a new transaction if we are not already within
5263** a transaction. If we are already within a transaction, then a checkpoint
drh7f0f12e2004-05-21 13:39:50 +00005264** is set if the setStatement parameter is true. A checkpoint should
drhc977f7f2002-05-21 11:38:11 +00005265** be set for operations that might fail (due to a constraint) part of
5266** the way through and which will need to undo some writes without having to
5267** rollback the whole transaction. For operations where all constraints
5268** can be checked before any changes are made to the database, it is never
5269** necessary to undo a write and the checkpoint should not be set.
drh1c928532002-01-31 15:54:21 +00005270*/
drh7f0f12e2004-05-21 13:39:50 +00005271void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
dan65a7cd12009-09-01 12:16:01 +00005272 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh1d8f8922020-08-16 00:30:44 +00005273 sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
drha7ab6d82014-07-21 15:44:39 +00005274 DbMaskSet(pToplevel->writeMask, iDb);
dane0af83a2009-09-08 19:15:01 +00005275 pToplevel->isMultiWrite |= setStatement;
5276}
5277
drhff738bc2009-09-24 00:09:58 +00005278/*
5279** Indicate that the statement currently under construction might write
5280** more than one entry (example: deleting one row then inserting another,
5281** inserting multiple rows in a table, or inserting a row and index entries.)
5282** If an abort occurs after some of these writes have completed, then it will
5283** be necessary to undo the completed writes.
5284*/
5285void sqlite3MultiWrite(Parse *pParse){
5286 Parse *pToplevel = sqlite3ParseToplevel(pParse);
5287 pToplevel->isMultiWrite = 1;
5288}
5289
dane0af83a2009-09-08 19:15:01 +00005290/*
drhff738bc2009-09-24 00:09:58 +00005291** The code generator calls this routine if is discovers that it is
5292** possible to abort a statement prior to completion. In order to
5293** perform this abort without corrupting the database, we need to make
5294** sure that the statement is protected by a statement transaction.
5295**
5296** Technically, we only need to set the mayAbort flag if the
5297** isMultiWrite flag was previously set. There is a time dependency
5298** such that the abort must occur after the multiwrite. This makes
5299** some statements involving the REPLACE conflict resolution algorithm
5300** go a little faster. But taking advantage of this time dependency
5301** makes it more difficult to prove that the code is correct (in
5302** particular, it prevents us from writing an effective
5303** implementation of sqlite3AssertMayAbort()) and so we have chosen
5304** to take the safe route and skip the optimization.
dane0af83a2009-09-08 19:15:01 +00005305*/
5306void sqlite3MayAbort(Parse *pParse){
5307 Parse *pToplevel = sqlite3ParseToplevel(pParse);
5308 pToplevel->mayAbort = 1;
5309}
5310
5311/*
5312** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
5313** error. The onError parameter determines which (if any) of the statement
5314** and/or current transaction is rolled back.
5315*/
drhd91c1a12013-02-09 13:58:25 +00005316void sqlite3HaltConstraint(
5317 Parse *pParse, /* Parsing context */
5318 int errCode, /* extended error code */
5319 int onError, /* Constraint type */
5320 char *p4, /* Error message */
drhf9c8ce32013-11-05 13:33:55 +00005321 i8 p4type, /* P4_STATIC or P4_TRANSIENT */
5322 u8 p5Errmsg /* P5_ErrMsg type */
drhd91c1a12013-02-09 13:58:25 +00005323){
drh289a0c82020-08-15 22:23:00 +00005324 Vdbe *v;
5325 assert( pParse->pVdbe!=0 );
5326 v = sqlite3GetVdbe(pParse);
drh9e5fdc42020-05-08 19:02:21 +00005327 assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested );
dane0af83a2009-09-08 19:15:01 +00005328 if( onError==OE_Abort ){
5329 sqlite3MayAbort(pParse);
danielk19771d850a72004-05-31 08:26:49 +00005330 }
drhd91c1a12013-02-09 13:58:25 +00005331 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
drh9b34abe2016-01-16 15:12:35 +00005332 sqlite3VdbeChangeP5(v, p5Errmsg);
drhf9c8ce32013-11-05 13:33:55 +00005333}
5334
5335/*
5336** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
5337*/
5338void sqlite3UniqueConstraint(
5339 Parse *pParse, /* Parsing context */
5340 int onError, /* Constraint type */
5341 Index *pIdx /* The index that triggers the constraint */
5342){
5343 char *zErr;
5344 int j;
5345 StrAccum errMsg;
5346 Table *pTab = pIdx->pTable;
5347
drh86ec1ed2019-04-10 00:58:07 +00005348 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
5349 pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
drh8b576422015-08-31 23:09:42 +00005350 if( pIdx->aColExpr ){
drh0cdbe1a2018-05-09 13:46:26 +00005351 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
drh8b576422015-08-31 23:09:42 +00005352 }else{
5353 for(j=0; j<pIdx->nKeyCol; j++){
5354 char *zCol;
5355 assert( pIdx->aiColumn[j]>=0 );
drhcf9d36d2021-08-02 18:03:43 +00005356 zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
drh0cdbe1a2018-05-09 13:46:26 +00005357 if( j ) sqlite3_str_append(&errMsg, ", ", 2);
5358 sqlite3_str_appendall(&errMsg, pTab->zName);
5359 sqlite3_str_append(&errMsg, ".", 1);
5360 sqlite3_str_appendall(&errMsg, zCol);
drh8b576422015-08-31 23:09:42 +00005361 }
drhf9c8ce32013-11-05 13:33:55 +00005362 }
5363 zErr = sqlite3StrAccumFinish(&errMsg);
5364 sqlite3HaltConstraint(pParse,
drh48dd1d82014-05-27 18:18:58 +00005365 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
5366 : SQLITE_CONSTRAINT_UNIQUE,
dan93889d92013-11-06 16:28:59 +00005367 onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
drhf9c8ce32013-11-05 13:33:55 +00005368}
5369
5370
5371/*
5372** Code an OP_Halt due to non-unique rowid.
5373*/
5374void sqlite3RowidConstraint(
5375 Parse *pParse, /* Parsing context */
5376 int onError, /* Conflict resolution algorithm */
5377 Table *pTab /* The table with the non-unique rowid */
5378){
5379 char *zMsg;
5380 int rc;
5381 if( pTab->iPKey>=0 ){
5382 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
drhcf9d36d2021-08-02 18:03:43 +00005383 pTab->aCol[pTab->iPKey].zCnName);
drhf9c8ce32013-11-05 13:33:55 +00005384 rc = SQLITE_CONSTRAINT_PRIMARYKEY;
5385 }else{
5386 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
5387 rc = SQLITE_CONSTRAINT_ROWID;
5388 }
5389 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
5390 P5_ConstraintUnique);
drh663fc632002-02-02 18:49:19 +00005391}
5392
drh4343fea2004-11-05 23:46:15 +00005393/*
5394** Check to see if pIndex uses the collating sequence pColl. Return
5395** true if it does and false if it does not.
5396*/
5397#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00005398static int collationMatch(const char *zColl, Index *pIndex){
5399 int i;
drh04491712009-05-13 17:21:13 +00005400 assert( zColl!=0 );
danielk1977b3bf5562006-01-10 17:58:23 +00005401 for(i=0; i<pIndex->nColumn; i++){
5402 const char *z = pIndex->azColl[i];
drhbbbdc832013-10-22 18:01:40 +00005403 assert( z!=0 || pIndex->aiColumn[i]<0 );
5404 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00005405 return 1;
5406 }
drh4343fea2004-11-05 23:46:15 +00005407 }
5408 return 0;
5409}
5410#endif
5411
5412/*
5413** Recompute all indices of pTab that use the collating sequence pColl.
5414** If pColl==0 then recompute all indices of pTab.
5415*/
5416#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00005417static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
dane6370e92019-01-11 17:41:23 +00005418 if( !IsVirtual(pTab) ){
5419 Index *pIndex; /* An index associated with pTab */
drh4343fea2004-11-05 23:46:15 +00005420
dane6370e92019-01-11 17:41:23 +00005421 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
5422 if( zColl==0 || collationMatch(zColl, pIndex) ){
5423 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
5424 sqlite3BeginWriteOperation(pParse, 0, iDb);
5425 sqlite3RefillIndex(pParse, pIndex, -1);
5426 }
drh4343fea2004-11-05 23:46:15 +00005427 }
5428 }
5429}
5430#endif
5431
5432/*
5433** Recompute all indices of all tables in all databases where the
5434** indices use the collating sequence pColl. If pColl==0 then recompute
5435** all indices everywhere.
5436*/
5437#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00005438static void reindexDatabases(Parse *pParse, char const *zColl){
drh4343fea2004-11-05 23:46:15 +00005439 Db *pDb; /* A single database */
5440 int iDb; /* The database index number */
5441 sqlite3 *db = pParse->db; /* The database connection */
5442 HashElem *k; /* For looping over tables in pDb */
5443 Table *pTab; /* A table in the database */
5444
drh21206082011-04-04 18:22:02 +00005445 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
drh4343fea2004-11-05 23:46:15 +00005446 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
drh43617e92006-03-06 20:55:46 +00005447 assert( pDb!=0 );
danielk1977da184232006-01-05 11:34:32 +00005448 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
drh4343fea2004-11-05 23:46:15 +00005449 pTab = (Table*)sqliteHashData(k);
danielk1977b3bf5562006-01-10 17:58:23 +00005450 reindexTable(pParse, pTab, zColl);
drh4343fea2004-11-05 23:46:15 +00005451 }
5452 }
5453}
5454#endif
5455
5456/*
drheee46cf2004-11-06 00:02:48 +00005457** Generate code for the REINDEX command.
5458**
5459** REINDEX -- 1
5460** REINDEX <collation> -- 2
5461** REINDEX ?<database>.?<tablename> -- 3
5462** REINDEX ?<database>.?<indexname> -- 4
5463**
5464** Form 1 causes all indices in all attached databases to be rebuilt.
5465** Form 2 rebuilds all indices in all databases that use the named
5466** collating function. Forms 3 and 4 rebuild the named index or all
5467** indices associated with the named table.
drh4343fea2004-11-05 23:46:15 +00005468*/
5469#ifndef SQLITE_OMIT_REINDEX
5470void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
5471 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
5472 char *z; /* Name of a table or index */
5473 const char *zDb; /* Name of the database */
5474 Table *pTab; /* A table in the database */
5475 Index *pIndex; /* An index associated with pTab */
5476 int iDb; /* The database index number */
5477 sqlite3 *db = pParse->db; /* The database connection */
5478 Token *pObjName; /* Name of the table or index to be reindexed */
5479
danielk197733a5edc2005-01-27 00:22:02 +00005480 /* Read the database schema. If an error occurs, leave an error message
5481 ** and code in pParse and return NULL. */
5482 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e63739a2005-01-27 00:33:37 +00005483 return;
danielk197733a5edc2005-01-27 00:22:02 +00005484 }
5485
drh8af73d42009-05-13 22:58:28 +00005486 if( pName1==0 ){
drh4343fea2004-11-05 23:46:15 +00005487 reindexDatabases(pParse, 0);
5488 return;
drhd3001712009-05-12 17:46:53 +00005489 }else if( NEVER(pName2==0) || pName2->z==0 ){
danielk197739002502007-11-12 09:50:26 +00005490 char *zColl;
danielk1977b3bf5562006-01-10 17:58:23 +00005491 assert( pName1->z );
danielk197739002502007-11-12 09:50:26 +00005492 zColl = sqlite3NameFromToken(pParse->db, pName1);
5493 if( !zColl ) return;
drhc4a64fa2009-05-11 20:53:28 +00005494 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh4343fea2004-11-05 23:46:15 +00005495 if( pColl ){
drhd3001712009-05-12 17:46:53 +00005496 reindexDatabases(pParse, zColl);
5497 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00005498 return;
5499 }
drh633e6d52008-07-28 19:34:53 +00005500 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00005501 }
5502 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
5503 if( iDb<0 ) return;
drh17435752007-08-16 04:30:38 +00005504 z = sqlite3NameFromToken(db, pObjName);
drh84f31122007-05-12 15:00:14 +00005505 if( z==0 ) return;
drh69c33822016-08-18 14:33:11 +00005506 zDb = db->aDb[iDb].zDbSName;
drh4343fea2004-11-05 23:46:15 +00005507 pTab = sqlite3FindTable(db, z, zDb);
5508 if( pTab ){
5509 reindexTable(pParse, pTab, 0);
drh633e6d52008-07-28 19:34:53 +00005510 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00005511 return;
5512 }
5513 pIndex = sqlite3FindIndex(db, z, zDb);
drh633e6d52008-07-28 19:34:53 +00005514 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00005515 if( pIndex ){
5516 sqlite3BeginWriteOperation(pParse, 0, iDb);
5517 sqlite3RefillIndex(pParse, pIndex, -1);
5518 return;
5519 }
5520 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
5521}
5522#endif
danielk1977b3bf5562006-01-10 17:58:23 +00005523
5524/*
drh2ec2fb22013-11-06 19:59:23 +00005525** Return a KeyInfo structure that is appropriate for the given Index.
danielk1977b3bf5562006-01-10 17:58:23 +00005526**
drh2ec2fb22013-11-06 19:59:23 +00005527** The caller should invoke sqlite3KeyInfoUnref() on the returned object
5528** when it has finished using it.
danielk1977b3bf5562006-01-10 17:58:23 +00005529*/
drh2ec2fb22013-11-06 19:59:23 +00005530KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
drh18b67f32014-12-12 00:20:37 +00005531 int i;
5532 int nCol = pIdx->nColumn;
5533 int nKey = pIdx->nKeyCol;
5534 KeyInfo *pKey;
drh2ec2fb22013-11-06 19:59:23 +00005535 if( pParse->nErr ) return 0;
drh18b67f32014-12-12 00:20:37 +00005536 if( pIdx->uniqNotNull ){
5537 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
5538 }else{
5539 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
drh41e13e12013-11-07 14:09:39 +00005540 }
drh18b67f32014-12-12 00:20:37 +00005541 if( pKey ){
5542 assert( sqlite3KeyInfoIsWriteable(pKey) );
5543 for(i=0; i<nCol; i++){
drhf19aa5f2015-12-30 16:51:20 +00005544 const char *zColl = pIdx->azColl[i];
5545 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
drh18b67f32014-12-12 00:20:37 +00005546 sqlite3LocateCollSeq(pParse, zColl);
dan6e118922019-08-12 16:36:38 +00005547 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
5548 assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
drh2ec2fb22013-11-06 19:59:23 +00005549 }
drh18b67f32014-12-12 00:20:37 +00005550 if( pParse->nErr ){
drh7e8515d2017-12-08 19:37:04 +00005551 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
5552 if( pIdx->bNoQuery==0 ){
5553 /* Deactivate the index because it contains an unknown collating
5554 ** sequence. The only way to reactive the index is to reload the
5555 ** schema. Adding the missing collating sequence later does not
5556 ** reactive the index. The application had the chance to register
5557 ** the missing index using the collation-needed callback. For
5558 ** simplicity, SQLite will not give the application a second chance.
5559 */
5560 pIdx->bNoQuery = 1;
5561 pParse->rc = SQLITE_ERROR_RETRY;
5562 }
drh18b67f32014-12-12 00:20:37 +00005563 sqlite3KeyInfoUnref(pKey);
5564 pKey = 0;
danielk1977b3bf5562006-01-10 17:58:23 +00005565 }
danielk1977b3bf5562006-01-10 17:58:23 +00005566 }
drh18b67f32014-12-12 00:20:37 +00005567 return pKey;
danielk1977b3bf5562006-01-10 17:58:23 +00005568}
drh8b471862014-01-11 13:22:17 +00005569
5570#ifndef SQLITE_OMIT_CTE
drhf824b412021-02-20 14:57:16 +00005571/*
5572** Create a new CTE object
5573*/
5574Cte *sqlite3CteNew(
5575 Parse *pParse, /* Parsing context */
5576 Token *pName, /* Name of the common-table */
5577 ExprList *pArglist, /* Optional column name list for the table */
drh745912e2021-02-22 03:04:25 +00005578 Select *pQuery, /* Query used to initialize the table */
5579 u8 eM10d /* The MATERIALIZED flag */
drhf824b412021-02-20 14:57:16 +00005580){
5581 Cte *pNew;
5582 sqlite3 *db = pParse->db;
5583
5584 pNew = sqlite3DbMallocZero(db, sizeof(*pNew));
5585 assert( pNew!=0 || db->mallocFailed );
5586
5587 if( db->mallocFailed ){
5588 sqlite3ExprListDelete(db, pArglist);
5589 sqlite3SelectDelete(db, pQuery);
5590 }else{
5591 pNew->pSelect = pQuery;
5592 pNew->pCols = pArglist;
5593 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
drh745912e2021-02-22 03:04:25 +00005594 pNew->eM10d = eM10d;
drhf824b412021-02-20 14:57:16 +00005595 }
5596 return pNew;
5597}
5598
5599/*
5600** Clear information from a Cte object, but do not deallocate storage
5601** for the object itself.
5602*/
5603static void cteClear(sqlite3 *db, Cte *pCte){
5604 assert( pCte!=0 );
5605 sqlite3ExprListDelete(db, pCte->pCols);
5606 sqlite3SelectDelete(db, pCte->pSelect);
5607 sqlite3DbFree(db, pCte->zName);
5608}
5609
5610/*
5611** Free the contents of the CTE object passed as the second argument.
5612*/
5613void sqlite3CteDelete(sqlite3 *db, Cte *pCte){
5614 assert( pCte!=0 );
5615 cteClear(db, pCte);
5616 sqlite3DbFree(db, pCte);
5617}
5618
dan7d562db2014-01-11 19:19:36 +00005619/*
5620** This routine is invoked once per CTE by the parser while parsing a
drhf824b412021-02-20 14:57:16 +00005621** WITH clause. The CTE described by teh third argument is added to
5622** the WITH clause of the second argument. If the second argument is
5623** NULL, then a new WITH argument is created.
drh8b471862014-01-11 13:22:17 +00005624*/
dan7d562db2014-01-11 19:19:36 +00005625With *sqlite3WithAdd(
drh8b471862014-01-11 13:22:17 +00005626 Parse *pParse, /* Parsing context */
dan7d562db2014-01-11 19:19:36 +00005627 With *pWith, /* Existing WITH clause, or NULL */
drhf824b412021-02-20 14:57:16 +00005628 Cte *pCte /* CTE to add to the WITH clause */
drh8b471862014-01-11 13:22:17 +00005629){
dan4e9119d2014-01-13 15:12:23 +00005630 sqlite3 *db = pParse->db;
5631 With *pNew;
5632 char *zName;
5633
drhf824b412021-02-20 14:57:16 +00005634 if( pCte==0 ){
5635 return pWith;
5636 }
5637
dan4e9119d2014-01-13 15:12:23 +00005638 /* Check that the CTE name is unique within this WITH clause. If
5639 ** not, store an error in the Parse structure. */
drhf824b412021-02-20 14:57:16 +00005640 zName = pCte->zName;
dan4e9119d2014-01-13 15:12:23 +00005641 if( zName && pWith ){
5642 int i;
5643 for(i=0; i<pWith->nCte; i++){
5644 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
drh727a99f2014-01-16 21:59:51 +00005645 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
dan4e9119d2014-01-13 15:12:23 +00005646 }
5647 }
5648 }
5649
5650 if( pWith ){
drh0aa32312019-04-13 04:01:12 +00005651 sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
dan4e9119d2014-01-13 15:12:23 +00005652 pNew = sqlite3DbRealloc(db, pWith, nByte);
5653 }else{
5654 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
5655 }
drhb84e5742016-02-05 02:42:54 +00005656 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
dan4e9119d2014-01-13 15:12:23 +00005657
drhb84e5742016-02-05 02:42:54 +00005658 if( db->mallocFailed ){
drhf824b412021-02-20 14:57:16 +00005659 sqlite3CteDelete(db, pCte);
dana9f5c132014-01-13 16:36:40 +00005660 pNew = pWith;
dan4e9119d2014-01-13 15:12:23 +00005661 }else{
drhf824b412021-02-20 14:57:16 +00005662 pNew->a[pNew->nCte++] = *pCte;
5663 sqlite3DbFree(db, pCte);
dan4e9119d2014-01-13 15:12:23 +00005664 }
5665
5666 return pNew;
drh8b471862014-01-11 13:22:17 +00005667}
5668
dan7d562db2014-01-11 19:19:36 +00005669/*
5670** Free the contents of the With object passed as the second argument.
drh8b471862014-01-11 13:22:17 +00005671*/
dan7d562db2014-01-11 19:19:36 +00005672void sqlite3WithDelete(sqlite3 *db, With *pWith){
dan4e9119d2014-01-13 15:12:23 +00005673 if( pWith ){
5674 int i;
5675 for(i=0; i<pWith->nCte; i++){
drhf824b412021-02-20 14:57:16 +00005676 cteClear(db, &pWith->a[i]);
dan4e9119d2014-01-13 15:12:23 +00005677 }
5678 sqlite3DbFree(db, pWith);
5679 }
drh8b471862014-01-11 13:22:17 +00005680}
5681#endif /* !defined(SQLITE_OMIT_CTE) */