blob: 806a93ed714e9a7708bb0cfbaf37deadbddaff10 [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 */
34 int iTab; /* The root page of the table to be locked */
35 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*/
49void sqlite3TableLock(
drhd698bc12006-03-23 23:33:26 +000050 Parse *pParse, /* Parsing context */
51 int iDb, /* Index of the database containing the table to lock */
52 int iTab, /* Root page number of the table to be locked */
53 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){
dan65a7cd12009-09-01 12:16:01 +000056 Parse *pToplevel = sqlite3ParseToplevel(pParse);
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
drh9d06ff22016-11-08 17:19:22 +000062 if( iDb==1 ) return;
63 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
dan65a7cd12009-09-01 12:16:01 +000064 for(i=0; i<pToplevel->nTableLock; i++){
65 p = &pToplevel->aTableLock[i];
danielk1977c00da102006-01-07 13:21:04 +000066 if( p->iDb==iDb && p->iTab==iTab ){
67 p->isWriteLock = (p->isWriteLock || isWriteLock);
68 return;
69 }
70 }
71
dan65a7cd12009-09-01 12:16:01 +000072 nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
73 pToplevel->aTableLock =
74 sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
75 if( pToplevel->aTableLock ){
76 p = &pToplevel->aTableLock[pToplevel->nTableLock++];
danielk1977c00da102006-01-07 13:21:04 +000077 p->iDb = iDb;
78 p->iTab = iTab;
79 p->isWriteLock = isWriteLock;
drhe0a04a32016-12-16 01:00:21 +000080 p->zLockName = zName;
drhf3a65f72007-08-22 20:18:21 +000081 }else{
dan65a7cd12009-09-01 12:16:01 +000082 pToplevel->nTableLock = 0;
drh4a642b62016-02-05 01:55:27 +000083 sqlite3OomFault(pToplevel->db);
danielk1977c00da102006-01-07 13:21:04 +000084 }
85}
86
87/*
88** Code an OP_TableLock instruction for each table locked by the
89** statement (configured by calls to sqlite3TableLock()).
90*/
91static void codeTableLocks(Parse *pParse){
92 int i;
93 Vdbe *pVdbe;
danielk1977c00da102006-01-07 13:21:04 +000094
drh04491712009-05-13 17:21:13 +000095 pVdbe = sqlite3GetVdbe(pParse);
96 assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
danielk1977c00da102006-01-07 13:21:04 +000097
98 for(i=0; i<pParse->nTableLock; i++){
99 TableLock *p = &pParse->aTableLock[i];
100 int p1 = p->iDb;
drh6a9ad3d2008-04-02 16:29:30 +0000101 sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
drhe0a04a32016-12-16 01:00:21 +0000102 p->zLockName, P4_STATIC);
danielk1977c00da102006-01-07 13:21:04 +0000103 }
104}
105#else
106 #define codeTableLocks(x)
107#endif
108
drhe0bc4042002-06-25 01:09:11 +0000109/*
drha7ab6d82014-07-21 15:44:39 +0000110** Return TRUE if the given yDbMask object is empty - if it contains no
111** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero()
112** macros when SQLITE_MAX_ATTACHED is greater than 30.
113*/
114#if SQLITE_MAX_ATTACHED>30
115int sqlite3DbMaskAllZero(yDbMask m){
116 int i;
117 for(i=0; i<sizeof(yDbMask); i++) if( m[i] ) return 0;
118 return 1;
119}
120#endif
121
122/*
drh75897232000-05-29 14:26:00 +0000123** This routine is called after a single SQL statement has been
drh80242052004-06-09 00:48:12 +0000124** parsed and a VDBE program to execute that statement has been
125** prepared. This routine puts the finishing touches on the
126** VDBE program and resets the pParse structure for the next
127** parse.
drh75897232000-05-29 14:26:00 +0000128**
129** Note that if an error occurred, it might be the case that
130** no VDBE code was generated.
131*/
drh80242052004-06-09 00:48:12 +0000132void sqlite3FinishCoding(Parse *pParse){
drh9bb575f2004-09-06 17:24:11 +0000133 sqlite3 *db;
drh80242052004-06-09 00:48:12 +0000134 Vdbe *v;
drhb86ccfb2003-01-28 23:13:10 +0000135
danf78baaf2012-12-06 19:37:22 +0000136 assert( pParse->pToplevel==0 );
drh17435752007-08-16 04:30:38 +0000137 db = pParse->db;
drh205f48e2004-11-05 00:43:11 +0000138 if( pParse->nested ) return;
drhd99d2832015-04-17 15:58:33 +0000139 if( db->mallocFailed || pParse->nErr ){
140 if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;
141 return;
142 }
danielk197748d0d862005-02-01 03:09:52 +0000143
drh80242052004-06-09 00:48:12 +0000144 /* Begin by generating some termination code at the end of the
145 ** vdbe program
146 */
drh80242052004-06-09 00:48:12 +0000147 v = sqlite3GetVdbe(pParse);
danf3677212009-09-10 16:14:50 +0000148 assert( !pParse->isMultiWrite
149 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
drh80242052004-06-09 00:48:12 +0000150 if( v ){
drh66a51672008-01-03 00:01:23 +0000151 sqlite3VdbeAddOp0(v, OP_Halt);
drh0e3d7472004-06-19 17:33:07 +0000152
drhb2445d52014-09-11 14:01:41 +0000153#if SQLITE_USER_AUTHENTICATION
154 if( pParse->nTableLock>0 && db->init.busy==0 ){
drh7883ecf2014-09-11 16:19:31 +0000155 sqlite3UserAuthInit(db);
drhb2445d52014-09-11 14:01:41 +0000156 if( db->auth.authLevel<UAUTH_User ){
drh7883ecf2014-09-11 16:19:31 +0000157 sqlite3ErrorMsg(pParse, "user not authenticated");
drh6ae3ab02016-08-23 14:42:15 +0000158 pParse->rc = SQLITE_AUTH_USER;
drh7883ecf2014-09-11 16:19:31 +0000159 return;
drhb2445d52014-09-11 14:01:41 +0000160 }
161 }
162#endif
163
drh0e3d7472004-06-19 17:33:07 +0000164 /* The cookie mask contains one bit for each database file open.
165 ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
166 ** set for each database that is used. Generate code to start a
167 ** transaction on each used database and to verify the schema cookie
168 ** on each used database.
169 */
drha7ab6d82014-07-21 15:44:39 +0000170 if( db->mallocFailed==0
171 && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)
172 ){
drhaceb31b2014-02-08 01:40:27 +0000173 int iDb, i;
174 assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
175 sqlite3VdbeJumpHere(v, 0);
drha7ab6d82014-07-21 15:44:39 +0000176 for(iDb=0; iDb<db->nDb; iDb++){
drh1d96cc62016-09-30 18:35:36 +0000177 Schema *pSchema;
drha7ab6d82014-07-21 15:44:39 +0000178 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
drhfb982642007-08-30 01:19:59 +0000179 sqlite3VdbeUsesBtree(v, iDb);
drh1d96cc62016-09-30 18:35:36 +0000180 pSchema = db->aDb[iDb].pSchema;
drhb22f7c82014-02-06 23:56:27 +0000181 sqlite3VdbeAddOp4Int(v,
182 OP_Transaction, /* Opcode */
183 iDb, /* P1 */
drha7ab6d82014-07-21 15:44:39 +0000184 DbMaskTest(pParse->writeMask,iDb), /* P2 */
drh1d96cc62016-09-30 18:35:36 +0000185 pSchema->schema_cookie, /* P3 */
186 pSchema->iGeneration /* P4 */
drhb22f7c82014-02-06 23:56:27 +0000187 );
188 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
dan076e0f92015-09-28 15:20:58 +0000189 VdbeComment((v,
190 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
drh80242052004-06-09 00:48:12 +0000191 }
danielk1977f9e7dda2006-06-16 16:08:53 +0000192#ifndef SQLITE_OMIT_VIRTUALTABLE
drhf30a9692013-11-15 01:10:18 +0000193 for(i=0; i<pParse->nVtabLock; i++){
194 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
195 sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
danielk1977f9e7dda2006-06-16 16:08:53 +0000196 }
drhf30a9692013-11-15 01:10:18 +0000197 pParse->nVtabLock = 0;
danielk1977f9e7dda2006-06-16 16:08:53 +0000198#endif
danielk1977c00da102006-01-07 13:21:04 +0000199
200 /* Once all the cookies have been verified and transactions opened,
201 ** obtain the required table-locks. This is a no-op unless the
202 ** shared-cache feature is enabled.
203 */
204 codeTableLocks(pParse);
drh0b9f50d2009-06-23 20:28:53 +0000205
206 /* Initialize any AUTOINCREMENT data structures required.
207 */
208 sqlite3AutoincrementBegin(pParse);
209
drhf30a9692013-11-15 01:10:18 +0000210 /* Code constant expressions that where factored out of inner loops */
drhf30a9692013-11-15 01:10:18 +0000211 if( pParse->pConstExpr ){
212 ExprList *pEL = pParse->pConstExpr;
drhaceb31b2014-02-08 01:40:27 +0000213 pParse->okConstFactor = 0;
drhf30a9692013-11-15 01:10:18 +0000214 for(i=0; i<pEL->nExpr; i++){
drhc2acc4e2013-11-15 18:15:19 +0000215 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
drhf30a9692013-11-15 01:10:18 +0000216 }
217 }
218
drh0b9f50d2009-06-23 20:28:53 +0000219 /* Finally, jump back to the beginning of the executable code. */
drh076e85f2015-09-03 13:46:12 +0000220 sqlite3VdbeGoto(v, 1);
drh80242052004-06-09 00:48:12 +0000221 }
drh71c697e2004-08-08 23:39:19 +0000222 }
223
drh3f7d4e42004-07-24 14:35:58 +0000224
drh80242052004-06-09 00:48:12 +0000225 /* Get the VDBE program ready for execution
226 */
drh126a6e22015-04-15 04:10:50 +0000227 if( v && pParse->nErr==0 && !db->mallocFailed ){
drh3492dd72009-09-14 23:47:24 +0000228 /* A minimum of one cursor is required if autoincrement is used
229 * See ticket [a696379c1f08866] */
drh04ab5862018-12-01 21:13:41 +0000230 assert( pParse->pAinc==0 || pParse->nTab>0 );
drh124c0b42011-06-01 18:15:55 +0000231 sqlite3VdbeMakeReady(v, pParse);
danielk1977441daf62005-02-01 03:46:43 +0000232 pParse->rc = SQLITE_DONE;
drhe294da02010-02-25 23:44:15 +0000233 }else{
drh483750b2003-01-29 18:46:51 +0000234 pParse->rc = SQLITE_ERROR;
drh75897232000-05-29 14:26:00 +0000235 }
236}
237
238/*
drh205f48e2004-11-05 00:43:11 +0000239** Run the parser and code generator recursively in order to generate
240** code for the SQL statement given onto the end of the pParse context
241** currently under construction. When the parser is run recursively
242** this way, the final OP_Halt is not appended and other initialization
243** and finalization steps are omitted because those are handling by the
244** outermost parser.
245**
246** Not everything is nestable. This facility is designed to permit
247** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use
drhf1974842004-11-05 03:56:00 +0000248** care if you decide to try to use this routine for some other purposes.
drh205f48e2004-11-05 00:43:11 +0000249*/
250void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
251 va_list ap;
252 char *zSql;
drhfb45d8c2008-07-08 00:06:49 +0000253 char *zErrMsg = 0;
drh633e6d52008-07-28 19:34:53 +0000254 sqlite3 *db = pParse->db;
drhcd9af602016-09-30 22:24:29 +0000255 char saveBuf[PARSE_TAIL_SZ];
drhf1974842004-11-05 03:56:00 +0000256
drh205f48e2004-11-05 00:43:11 +0000257 if( pParse->nErr ) return;
258 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
259 va_start(ap, zFormat);
drh633e6d52008-07-28 19:34:53 +0000260 zSql = sqlite3VMPrintf(db, zFormat, ap);
drh205f48e2004-11-05 00:43:11 +0000261 va_end(ap);
drh73c42a12004-11-20 18:13:10 +0000262 if( zSql==0 ){
263 return; /* A malloc must have failed */
264 }
drh205f48e2004-11-05 00:43:11 +0000265 pParse->nested++;
drhcd9af602016-09-30 22:24:29 +0000266 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
267 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
drhfb45d8c2008-07-08 00:06:49 +0000268 sqlite3RunParser(pParse, zSql, &zErrMsg);
drh633e6d52008-07-28 19:34:53 +0000269 sqlite3DbFree(db, zErrMsg);
270 sqlite3DbFree(db, zSql);
drhcd9af602016-09-30 22:24:29 +0000271 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
drh205f48e2004-11-05 00:43:11 +0000272 pParse->nested--;
273}
274
drhd4530972014-09-09 14:47:53 +0000275#if SQLITE_USER_AUTHENTICATION
276/*
277** Return TRUE if zTable is the name of the system table that stores the
278** list of users and their access credentials.
279*/
280int sqlite3UserAuthTable(const char *zTable){
281 return sqlite3_stricmp(zTable, "sqlite_user")==0;
282}
283#endif
284
drh205f48e2004-11-05 00:43:11 +0000285/*
danielk19778a414492004-06-29 08:59:35 +0000286** Locate the in-memory structure that describes a particular database
287** table given the name of that table and (optionally) the name of the
288** database containing the table. Return NULL if not found.
drha69d9162003-04-17 22:57:53 +0000289**
danielk19778a414492004-06-29 08:59:35 +0000290** If zDatabase is 0, all databases are searched for the table and the
291** first matching table is returned. (No checking for duplicate table
292** names is done.) The search order is TEMP first, then MAIN, then any
293** auxiliary databases added using the ATTACH command.
drhf26e09c2003-05-31 16:21:12 +0000294**
danielk19774adee202004-05-08 08:23:19 +0000295** See also sqlite3LocateTable().
drh75897232000-05-29 14:26:00 +0000296*/
drh9bb575f2004-09-06 17:24:11 +0000297Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
drhd24cc422003-03-27 12:51:24 +0000298 Table *p = 0;
299 int i;
drh9ca95732014-10-24 00:35:58 +0000300
drh21206082011-04-04 18:22:02 +0000301 /* All mutexes are required for schema access. Make sure we hold them. */
302 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
drhd4530972014-09-09 14:47:53 +0000303#if SQLITE_USER_AUTHENTICATION
304 /* Only the admin user is allowed to know that the sqlite_user table
305 ** exists */
drhe933b832014-09-10 17:34:28 +0000306 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
307 return 0;
308 }
drhd4530972014-09-09 14:47:53 +0000309#endif
drhe0a04a32016-12-16 01:00:21 +0000310 while(1){
311 for(i=OMIT_TEMPDB; i<db->nDb; i++){
312 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
313 if( zDatabase==0 || sqlite3StrICmp(zDatabase, db->aDb[j].zDbSName)==0 ){
314 assert( sqlite3SchemaMutexHeld(db, j, 0) );
315 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
316 if( p ) return p;
317 }
drh69c33822016-08-18 14:33:11 +0000318 }
drhe0a04a32016-12-16 01:00:21 +0000319 /* Not found. If the name we were looking for was temp.sqlite_master
320 ** then change the name to sqlite_temp_master and try again. */
321 if( sqlite3StrICmp(zName, MASTER_NAME)!=0 ) break;
drh30776ac2016-12-16 02:31:50 +0000322 if( sqlite3_stricmp(zDatabase, db->aDb[1].zDbSName)!=0 ) break;
drhe0a04a32016-12-16 01:00:21 +0000323 zName = TEMP_MASTER_NAME;
drhd24cc422003-03-27 12:51:24 +0000324 }
drhe0a04a32016-12-16 01:00:21 +0000325 return 0;
drh75897232000-05-29 14:26:00 +0000326}
327
328/*
danielk19778a414492004-06-29 08:59:35 +0000329** Locate the in-memory structure that describes a particular database
330** table given the name of that table and (optionally) the name of the
331** database containing the table. Return NULL if not found. Also leave an
332** error message in pParse->zErrMsg.
drha69d9162003-04-17 22:57:53 +0000333**
danielk19778a414492004-06-29 08:59:35 +0000334** The difference between this routine and sqlite3FindTable() is that this
335** routine leaves an error message in pParse->zErrMsg where
336** sqlite3FindTable() does not.
drha69d9162003-04-17 22:57:53 +0000337*/
drhca424112008-01-25 15:04:48 +0000338Table *sqlite3LocateTable(
339 Parse *pParse, /* context in which to report errors */
drh4d249e62016-06-10 22:49:01 +0000340 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
drhca424112008-01-25 15:04:48 +0000341 const char *zName, /* Name of the table we are looking for */
342 const char *zDbase /* Name of the database. Might be NULL */
343){
drha69d9162003-04-17 22:57:53 +0000344 Table *p;
drhb2c85592018-04-25 12:01:45 +0000345 sqlite3 *db = pParse->db;
drhf26e09c2003-05-31 16:21:12 +0000346
danielk19778a414492004-06-29 08:59:35 +0000347 /* Read the database schema. If an error occurs, leave an error message
348 ** and code in pParse and return NULL. */
drhb2c85592018-04-25 12:01:45 +0000349 if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
350 && SQLITE_OK!=sqlite3ReadSchema(pParse)
351 ){
danielk19778a414492004-06-29 08:59:35 +0000352 return 0;
353 }
354
drhb2c85592018-04-25 12:01:45 +0000355 p = sqlite3FindTable(db, zName, zDbase);
drha69d9162003-04-17 22:57:53 +0000356 if( p==0 ){
drh4d249e62016-06-10 22:49:01 +0000357 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
drhd2975922015-08-29 17:22:33 +0000358#ifndef SQLITE_OMIT_VIRTUALTABLE
drh9196c812018-11-05 16:38:10 +0000359 /* If zName is the not the name of a table in the schema created using
360 ** CREATE, then check to see if it is the name of an virtual table that
361 ** can be an eponymous virtual table. */
362 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
363 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
364 pMod = sqlite3PragmaVtabRegister(db, zName);
365 }
366 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
367 return pMod->pEpoTab;
drh51be3872015-08-19 02:32:25 +0000368 }
369#endif
drh4d249e62016-06-10 22:49:01 +0000370 if( (flags & LOCATE_NOERR)==0 ){
371 if( zDbase ){
372 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
373 }else{
374 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
375 }
376 pParse->checkSchema = 1;
drha69d9162003-04-17 22:57:53 +0000377 }
378 }
danfab1d402015-11-26 15:51:55 +0000379
drha69d9162003-04-17 22:57:53 +0000380 return p;
381}
382
383/*
dan41fb5cd2012-10-04 19:33:00 +0000384** Locate the table identified by *p.
385**
386** This is a wrapper around sqlite3LocateTable(). The difference between
387** sqlite3LocateTable() and this function is that this function restricts
388** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
389** non-NULL if it is part of a view or trigger program definition. See
390** sqlite3FixSrcList() for details.
391*/
392Table *sqlite3LocateTableItem(
393 Parse *pParse,
drh4d249e62016-06-10 22:49:01 +0000394 u32 flags,
dan41fb5cd2012-10-04 19:33:00 +0000395 struct SrcList_item *p
396){
397 const char *zDb;
398 assert( p->pSchema==0 || p->zDatabase==0 );
399 if( p->pSchema ){
400 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
drh69c33822016-08-18 14:33:11 +0000401 zDb = pParse->db->aDb[iDb].zDbSName;
dan41fb5cd2012-10-04 19:33:00 +0000402 }else{
403 zDb = p->zDatabase;
404 }
drh4d249e62016-06-10 22:49:01 +0000405 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
dan41fb5cd2012-10-04 19:33:00 +0000406}
407
408/*
drha69d9162003-04-17 22:57:53 +0000409** Locate the in-memory structure that describes
410** a particular index given the name of that index
411** and the name of the database that contains the index.
drhf57b3392001-10-08 13:22:32 +0000412** Return NULL if not found.
drhf26e09c2003-05-31 16:21:12 +0000413**
414** If zDatabase is 0, all databases are searched for the
415** table and the first matching index is returned. (No checking
416** for duplicate index names is done.) The search order is
417** TEMP first, then MAIN, then any auxiliary databases added
418** using the ATTACH command.
drh75897232000-05-29 14:26:00 +0000419*/
drh9bb575f2004-09-06 17:24:11 +0000420Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
drhd24cc422003-03-27 12:51:24 +0000421 Index *p = 0;
422 int i;
drh21206082011-04-04 18:22:02 +0000423 /* All mutexes are required for schema access. Make sure we hold them. */
424 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
danielk197753c0f742005-03-29 03:10:59 +0000425 for(i=OMIT_TEMPDB; i<db->nDb; i++){
drh812d7a22003-03-27 13:50:00 +0000426 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
danielk1977e501b892006-01-09 06:29:47 +0000427 Schema *pSchema = db->aDb[j].pSchema;
drh04491712009-05-13 17:21:13 +0000428 assert( pSchema );
drh69c33822016-08-18 14:33:11 +0000429 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zDbSName) ) continue;
drh21206082011-04-04 18:22:02 +0000430 assert( sqlite3SchemaMutexHeld(db, j, 0) );
drhacbcb7e2014-08-21 20:26:37 +0000431 p = sqlite3HashFind(&pSchema->idxHash, zName);
drhd24cc422003-03-27 12:51:24 +0000432 if( p ) break;
433 }
drh74e24cd2002-01-09 03:19:59 +0000434 return p;
drh75897232000-05-29 14:26:00 +0000435}
436
437/*
drh956bc922004-07-24 17:38:29 +0000438** Reclaim the memory used by an index
439*/
dancf8f2892018-08-09 20:47:01 +0000440void sqlite3FreeIndex(sqlite3 *db, Index *p){
drh92aa5ea2009-09-11 14:05:06 +0000441#ifndef SQLITE_OMIT_ANALYZE
dand46def72010-07-24 11:28:28 +0000442 sqlite3DeleteIndexSamples(db, p);
drh92aa5ea2009-09-11 14:05:06 +0000443#endif
drh1fe05372013-07-31 18:12:26 +0000444 sqlite3ExprDelete(db, p->pPartIdxWhere);
drh1f9ca2c2015-08-25 16:57:52 +0000445 sqlite3ExprListDelete(db, p->aColExpr);
drh633e6d52008-07-28 19:34:53 +0000446 sqlite3DbFree(db, p->zColAff);
mistachkin5905f862015-12-31 19:04:42 +0000447 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
drh75b170b2014-10-04 00:07:44 +0000448#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
449 sqlite3_free(p->aiRowEst);
450#endif
drh633e6d52008-07-28 19:34:53 +0000451 sqlite3DbFree(db, p);
drh956bc922004-07-24 17:38:29 +0000452}
453
454/*
drhc96d8532005-05-03 12:30:33 +0000455** For the index called zIdxName which is found in the database iDb,
456** unlike that index from its Table then remove the index from
457** the index hash table and free all memory structures associated
458** with the index.
drh5e00f6c2001-09-13 13:46:56 +0000459*/
drh9bb575f2004-09-06 17:24:11 +0000460void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
drh956bc922004-07-24 17:38:29 +0000461 Index *pIndex;
drh21206082011-04-04 18:22:02 +0000462 Hash *pHash;
drh956bc922004-07-24 17:38:29 +0000463
drh21206082011-04-04 18:22:02 +0000464 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
465 pHash = &db->aDb[iDb].pSchema->idxHash;
drhacbcb7e2014-08-21 20:26:37 +0000466 pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
drh22645842011-03-24 01:34:03 +0000467 if( ALWAYS(pIndex) ){
drh956bc922004-07-24 17:38:29 +0000468 if( pIndex->pTable->pIndex==pIndex ){
469 pIndex->pTable->pIndex = pIndex->pNext;
470 }else{
471 Index *p;
drh04491712009-05-13 17:21:13 +0000472 /* Justification of ALWAYS(); The index must be on the list of
473 ** indices. */
474 p = pIndex->pTable->pIndex;
475 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
476 if( ALWAYS(p && p->pNext==pIndex) ){
drh956bc922004-07-24 17:38:29 +0000477 p->pNext = pIndex->pNext;
478 }
drh5e00f6c2001-09-13 13:46:56 +0000479 }
dancf8f2892018-08-09 20:47:01 +0000480 sqlite3FreeIndex(db, pIndex);
drh5e00f6c2001-09-13 13:46:56 +0000481 }
drh8257aa82017-07-26 19:59:13 +0000482 db->mDbFlags |= DBFLAG_SchemaChange;
drh5e00f6c2001-09-13 13:46:56 +0000483}
484
485/*
drh81028a42012-05-15 18:28:27 +0000486** Look through the list of open database files in db->aDb[] and if
487** any have been closed, remove them from the list. Reallocate the
488** db->aDb[] structure to a smaller size, if possible.
drh1c2d8412003-03-31 00:30:47 +0000489**
drh81028a42012-05-15 18:28:27 +0000490** Entry 0 (the "main" database) and entry 1 (the "temp" database)
491** are never candidates for being collapsed.
drh74e24cd2002-01-09 03:19:59 +0000492*/
drh81028a42012-05-15 18:28:27 +0000493void sqlite3CollapseDatabaseArray(sqlite3 *db){
drh1c2d8412003-03-31 00:30:47 +0000494 int i, j;
drh1c2d8412003-03-31 00:30:47 +0000495 for(i=j=2; i<db->nDb; i++){
drh4d189ca2004-02-12 18:46:38 +0000496 struct Db *pDb = &db->aDb[i];
497 if( pDb->pBt==0 ){
drh69c33822016-08-18 14:33:11 +0000498 sqlite3DbFree(db, pDb->zDbSName);
499 pDb->zDbSName = 0;
drh1c2d8412003-03-31 00:30:47 +0000500 continue;
501 }
502 if( j<i ){
drh8bf8dc92003-05-17 17:35:10 +0000503 db->aDb[j] = db->aDb[i];
drh1c2d8412003-03-31 00:30:47 +0000504 }
drh8bf8dc92003-05-17 17:35:10 +0000505 j++;
drh1c2d8412003-03-31 00:30:47 +0000506 }
drh1c2d8412003-03-31 00:30:47 +0000507 db->nDb = j;
508 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
509 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
drh633e6d52008-07-28 19:34:53 +0000510 sqlite3DbFree(db, db->aDb);
drh1c2d8412003-03-31 00:30:47 +0000511 db->aDb = db->aDbStatic;
512 }
drhe0bc4042002-06-25 01:09:11 +0000513}
514
515/*
drh81028a42012-05-15 18:28:27 +0000516** Reset the schema for the database at index iDb. Also reset the
drhdc6b41e2017-08-17 02:26:35 +0000517** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
518** Deferred resets may be run by calling with iDb<0.
drh81028a42012-05-15 18:28:27 +0000519*/
520void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
drhdc6b41e2017-08-17 02:26:35 +0000521 int i;
drh81028a42012-05-15 18:28:27 +0000522 assert( iDb<db->nDb );
523
drhdc6b41e2017-08-17 02:26:35 +0000524 if( iDb>=0 ){
525 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
526 DbSetProperty(db, iDb, DB_ResetWanted);
527 DbSetProperty(db, 1, DB_ResetWanted);
drhb2c85592018-04-25 12:01:45 +0000528 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
drh81028a42012-05-15 18:28:27 +0000529 }
drhdc6b41e2017-08-17 02:26:35 +0000530
531 if( db->nSchemaLock==0 ){
532 for(i=0; i<db->nDb; i++){
533 if( DbHasProperty(db, i, DB_ResetWanted) ){
534 sqlite3SchemaClear(db->aDb[i].pSchema);
535 }
536 }
537 }
drh81028a42012-05-15 18:28:27 +0000538}
539
540/*
541** Erase all schema information from all attached databases (including
542** "main" and "temp") for a single database connection.
543*/
544void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
545 int i;
546 sqlite3BtreeEnterAll(db);
547 for(i=0; i<db->nDb; i++){
548 Db *pDb = &db->aDb[i];
549 if( pDb->pSchema ){
dan63e50b92018-11-27 19:47:55 +0000550 if( db->nSchemaLock==0 ){
551 sqlite3SchemaClear(pDb->pSchema);
552 }else{
553 DbSetProperty(db, i, DB_ResetWanted);
554 }
drh81028a42012-05-15 18:28:27 +0000555 }
556 }
drhb2c85592018-04-25 12:01:45 +0000557 db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
drh81028a42012-05-15 18:28:27 +0000558 sqlite3VtabUnlockList(db);
559 sqlite3BtreeLeaveAll(db);
dan63e50b92018-11-27 19:47:55 +0000560 if( db->nSchemaLock==0 ){
561 sqlite3CollapseDatabaseArray(db);
562 }
drh81028a42012-05-15 18:28:27 +0000563}
564
565/*
drhe0bc4042002-06-25 01:09:11 +0000566** This routine is called when a commit occurs.
567*/
drh9bb575f2004-09-06 17:24:11 +0000568void sqlite3CommitInternalChanges(sqlite3 *db){
drh8257aa82017-07-26 19:59:13 +0000569 db->mDbFlags &= ~DBFLAG_SchemaChange;
drh74e24cd2002-01-09 03:19:59 +0000570}
571
572/*
dand46def72010-07-24 11:28:28 +0000573** Delete memory allocated for the column names of a table or view (the
574** Table.aCol[] array).
drh956bc922004-07-24 17:38:29 +0000575*/
drh51be3872015-08-19 02:32:25 +0000576void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
drh956bc922004-07-24 17:38:29 +0000577 int i;
578 Column *pCol;
579 assert( pTable!=0 );
drhdd5b2fa2005-03-28 03:39:55 +0000580 if( (pCol = pTable->aCol)!=0 ){
581 for(i=0; i<pTable->nCol; i++, pCol++){
drh633e6d52008-07-28 19:34:53 +0000582 sqlite3DbFree(db, pCol->zName);
583 sqlite3ExprDelete(db, pCol->pDflt);
drh633e6d52008-07-28 19:34:53 +0000584 sqlite3DbFree(db, pCol->zColl);
drhdd5b2fa2005-03-28 03:39:55 +0000585 }
drh633e6d52008-07-28 19:34:53 +0000586 sqlite3DbFree(db, pTable->aCol);
drh956bc922004-07-24 17:38:29 +0000587 }
drh956bc922004-07-24 17:38:29 +0000588}
589
590/*
drh75897232000-05-29 14:26:00 +0000591** Remove the memory data structures associated with the given
drh967e8b72000-06-21 13:59:10 +0000592** Table. No changes are made to disk by this routine.
drh75897232000-05-29 14:26:00 +0000593**
594** This routine just deletes the data structure. It does not unlink
drhe61922a2009-05-02 13:29:37 +0000595** the table data structure from the hash table. But it does destroy
drhc2eef3b2002-08-31 18:53:06 +0000596** memory structures of the indices and foreign keys associated with
597** the table.
drh29ddd3a2012-05-15 12:49:32 +0000598**
599** The db parameter is optional. It is needed if the Table object
600** contains lookaside memory. (Table objects in the schema do not use
601** lookaside memory, but some ephemeral Table objects do.) Or the
602** db parameter can be used with db->pnBytesFreed to measure the memory
603** used by the Table object.
drh75897232000-05-29 14:26:00 +0000604*/
drhe8da01c2016-05-07 12:15:34 +0000605static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
drh75897232000-05-29 14:26:00 +0000606 Index *pIndex, *pNext;
drhc2eef3b2002-08-31 18:53:06 +0000607
drh52fb8e12017-08-29 20:21:12 +0000608#ifdef SQLITE_DEBUG
drh29ddd3a2012-05-15 12:49:32 +0000609 /* Record the number of outstanding lookaside allocations in schema Tables
610 ** prior to doing any free() operations. Since schema Tables do not use
611 ** lookaside, this number should not change. */
drh52fb8e12017-08-29 20:21:12 +0000612 int nLookaside = 0;
613 if( db && (pTable->tabFlags & TF_Ephemeral)==0 ){
614 nLookaside = sqlite3LookasideUsed(db, 0);
615 }
616#endif
drh29ddd3a2012-05-15 12:49:32 +0000617
dand46def72010-07-24 11:28:28 +0000618 /* Delete all indices associated with this table. */
drhc2eef3b2002-08-31 18:53:06 +0000619 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
620 pNext = pIndex->pNext;
drh62340f82016-05-31 21:18:15 +0000621 assert( pIndex->pSchema==pTable->pSchema
622 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
drh273bfe92016-06-02 16:22:53 +0000623 if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){
dand46def72010-07-24 11:28:28 +0000624 char *zName = pIndex->zName;
625 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
drhacbcb7e2014-08-21 20:26:37 +0000626 &pIndex->pSchema->idxHash, zName, 0
dand46def72010-07-24 11:28:28 +0000627 );
drh21206082011-04-04 18:22:02 +0000628 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
dand46def72010-07-24 11:28:28 +0000629 assert( pOld==pIndex || pOld==0 );
630 }
dancf8f2892018-08-09 20:47:01 +0000631 sqlite3FreeIndex(db, pIndex);
drhc2eef3b2002-08-31 18:53:06 +0000632 }
633
dan1da40a32009-09-19 17:00:31 +0000634 /* Delete any foreign keys attached to this table. */
dan1feeaed2010-07-23 15:41:47 +0000635 sqlite3FkDelete(db, pTable);
drhc2eef3b2002-08-31 18:53:06 +0000636
637 /* Delete the Table structure itself.
638 */
mistachkin8bee11a2018-10-29 17:53:23 +0000639#ifdef SQLITE_ENABLE_NORMALIZE
640 if( pTable->pColHash ){
641 sqlite3HashClear(pTable->pColHash);
642 sqlite3_free(pTable->pColHash);
643 }
644#endif
drh51be3872015-08-19 02:32:25 +0000645 sqlite3DeleteColumnNames(db, pTable);
drh633e6d52008-07-28 19:34:53 +0000646 sqlite3DbFree(db, pTable->zName);
647 sqlite3DbFree(db, pTable->zColAff);
648 sqlite3SelectDelete(db, pTable->pSelect);
drh2938f922012-03-07 19:13:29 +0000649 sqlite3ExprListDelete(db, pTable->pCheck);
drh078e4082010-07-28 19:17:51 +0000650#ifndef SQLITE_OMIT_VIRTUALTABLE
dan1feeaed2010-07-23 15:41:47 +0000651 sqlite3VtabClear(db, pTable);
drh078e4082010-07-28 19:17:51 +0000652#endif
drh633e6d52008-07-28 19:34:53 +0000653 sqlite3DbFree(db, pTable);
drh29ddd3a2012-05-15 12:49:32 +0000654
655 /* Verify that no lookaside memory was used by schema tables */
drh52fb8e12017-08-29 20:21:12 +0000656 assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) );
drh75897232000-05-29 14:26:00 +0000657}
drhe8da01c2016-05-07 12:15:34 +0000658void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
659 /* Do not delete the table until the reference count reaches zero. */
660 if( !pTable ) return;
drh79df7782016-12-14 14:07:35 +0000661 if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return;
drhe8da01c2016-05-07 12:15:34 +0000662 deleteTable(db, pTable);
663}
664
drh75897232000-05-29 14:26:00 +0000665
666/*
drh5edc3122001-09-13 21:53:09 +0000667** Unlink the given table from the hash tables and the delete the
drhc2eef3b2002-08-31 18:53:06 +0000668** table structure with all its indices and foreign keys.
drh5edc3122001-09-13 21:53:09 +0000669*/
drh9bb575f2004-09-06 17:24:11 +0000670void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
drh956bc922004-07-24 17:38:29 +0000671 Table *p;
drh956bc922004-07-24 17:38:29 +0000672 Db *pDb;
673
drhd229ca92002-01-09 13:30:41 +0000674 assert( db!=0 );
drh956bc922004-07-24 17:38:29 +0000675 assert( iDb>=0 && iDb<db->nDb );
drh972a2312009-12-08 14:34:08 +0000676 assert( zTabName );
drh21206082011-04-04 18:22:02 +0000677 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh972a2312009-12-08 14:34:08 +0000678 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
drh956bc922004-07-24 17:38:29 +0000679 pDb = &db->aDb[iDb];
drhacbcb7e2014-08-21 20:26:37 +0000680 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
dan1feeaed2010-07-23 15:41:47 +0000681 sqlite3DeleteTable(db, p);
drh8257aa82017-07-26 19:59:13 +0000682 db->mDbFlags |= DBFLAG_SchemaChange;
drh74e24cd2002-01-09 03:19:59 +0000683}
684
685/*
drha99db3b2004-06-19 14:49:12 +0000686** Given a token, return a string that consists of the text of that
drh24fb6272009-05-01 21:13:36 +0000687** token. Space to hold the returned string
drha99db3b2004-06-19 14:49:12 +0000688** is obtained from sqliteMalloc() and must be freed by the calling
689** function.
drh75897232000-05-29 14:26:00 +0000690**
drh24fb6272009-05-01 21:13:36 +0000691** Any quotation marks (ex: "name", 'name', [name], or `name`) that
692** surround the body of the token are removed.
693**
drhc96d8532005-05-03 12:30:33 +0000694** Tokens are often just pointers into the original SQL text and so
drha99db3b2004-06-19 14:49:12 +0000695** are not \000 terminated and are not persistent. The returned string
696** is \000 terminated and is persistent.
drh75897232000-05-29 14:26:00 +0000697*/
drh17435752007-08-16 04:30:38 +0000698char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
drha99db3b2004-06-19 14:49:12 +0000699 char *zName;
700 if( pName ){
drh17435752007-08-16 04:30:38 +0000701 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
drhb7916a72009-05-27 10:31:29 +0000702 sqlite3Dequote(zName);
drha99db3b2004-06-19 14:49:12 +0000703 }else{
704 zName = 0;
705 }
drh75897232000-05-29 14:26:00 +0000706 return zName;
707}
708
709/*
danielk1977cbb18d22004-05-28 11:37:27 +0000710** Open the sqlite_master table stored in database number iDb for
711** writing. The table is opened using cursor 0.
drhe0bc4042002-06-25 01:09:11 +0000712*/
danielk1977c00da102006-01-07 13:21:04 +0000713void sqlite3OpenMasterTable(Parse *p, int iDb){
714 Vdbe *v = sqlite3GetVdbe(p);
drhe0a04a32016-12-16 01:00:21 +0000715 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, MASTER_NAME);
drh261c02d2013-10-25 14:46:15 +0000716 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
danielk19776ab3a2e2009-02-19 14:39:25 +0000717 if( p->nTab==0 ){
718 p->nTab = 1;
719 }
drhe0bc4042002-06-25 01:09:11 +0000720}
721
722/*
danielk197704103022009-02-03 16:51:24 +0000723** Parameter zName points to a nul-terminated buffer containing the name
724** of a database ("main", "temp" or the name of an attached db). This
725** function returns the index of the named database in db->aDb[], or
726** -1 if the named db cannot be found.
danielk1977cbb18d22004-05-28 11:37:27 +0000727*/
danielk197704103022009-02-03 16:51:24 +0000728int sqlite3FindDbName(sqlite3 *db, const char *zName){
729 int i = -1; /* Database number */
drh73c42a12004-11-20 18:13:10 +0000730 if( zName ){
danielk197704103022009-02-03 16:51:24 +0000731 Db *pDb;
danielk1977576ec6b2005-01-21 11:55:25 +0000732 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
drh29518092016-12-24 19:37:16 +0000733 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
734 /* "main" is always an acceptable alias for the primary database
735 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
736 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
danielk1977cbb18d22004-05-28 11:37:27 +0000737 }
738 }
danielk1977576ec6b2005-01-21 11:55:25 +0000739 return i;
danielk1977cbb18d22004-05-28 11:37:27 +0000740}
741
danielk197704103022009-02-03 16:51:24 +0000742/*
743** The token *pName contains the name of a database (either "main" or
744** "temp" or the name of an attached db). This routine returns the
745** index of the named database in db->aDb[], or -1 if the named db
746** does not exist.
747*/
748int sqlite3FindDb(sqlite3 *db, Token *pName){
749 int i; /* Database number */
750 char *zName; /* Name we are searching for */
751 zName = sqlite3NameFromToken(db, pName);
752 i = sqlite3FindDbName(db, zName);
753 sqlite3DbFree(db, zName);
754 return i;
755}
756
drh0e3d7472004-06-19 17:33:07 +0000757/* The table or view or trigger name is passed to this routine via tokens
758** pName1 and pName2. If the table name was fully qualified, for example:
759**
760** CREATE TABLE xxx.yyy (...);
761**
762** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
763** the table name is not fully qualified, i.e.:
764**
765** CREATE TABLE yyy(...);
766**
767** Then pName1 is set to "yyy" and pName2 is "".
768**
769** This routine sets the *ppUnqual pointer to point at the token (pName1 or
770** pName2) that stores the unqualified table name. The index of the
771** database "xxx" is returned.
772*/
danielk1977ef2cb632004-05-29 02:37:19 +0000773int sqlite3TwoPartName(
drh0e3d7472004-06-19 17:33:07 +0000774 Parse *pParse, /* Parsing and code generating context */
drh90f5ecb2004-07-22 01:19:35 +0000775 Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
drh0e3d7472004-06-19 17:33:07 +0000776 Token *pName2, /* The "yyy" in the name "xxx.yyy" */
777 Token **pUnqual /* Write the unqualified object name here */
danielk1977cbb18d22004-05-28 11:37:27 +0000778){
drh0e3d7472004-06-19 17:33:07 +0000779 int iDb; /* Database holding the object */
danielk1977cbb18d22004-05-28 11:37:27 +0000780 sqlite3 *db = pParse->db;
781
drh055f2982016-01-15 15:06:41 +0000782 assert( pName2!=0 );
783 if( pName2->n>0 ){
shanedcc50b72008-11-13 18:29:50 +0000784 if( db->init.busy ) {
785 sqlite3ErrorMsg(pParse, "corrupt database");
shanedcc50b72008-11-13 18:29:50 +0000786 return -1;
787 }
danielk1977cbb18d22004-05-28 11:37:27 +0000788 *pUnqual = pName2;
drhff2d5ea2005-07-23 00:41:48 +0000789 iDb = sqlite3FindDb(db, pName1);
danielk1977cbb18d22004-05-28 11:37:27 +0000790 if( iDb<0 ){
791 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
danielk1977cbb18d22004-05-28 11:37:27 +0000792 return -1;
793 }
794 }else{
danc9461ec2018-08-29 21:00:16 +0000795 assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT
drh8257aa82017-07-26 19:59:13 +0000796 || (db->mDbFlags & DBFLAG_Vacuum)!=0);
danielk1977cbb18d22004-05-28 11:37:27 +0000797 iDb = db->init.iDb;
798 *pUnqual = pName1;
799 }
800 return iDb;
801}
802
803/*
drh0f1c2eb2018-11-03 17:31:48 +0000804** True if PRAGMA writable_schema is ON
805*/
806int sqlite3WritableSchema(sqlite3 *db){
807 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
808 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
809 SQLITE_WriteSchema );
810 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
811 SQLITE_Defensive );
812 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
813 (SQLITE_WriteSchema|SQLITE_Defensive) );
814 return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
815}
816
817/*
danielk1977d8123362004-06-12 09:25:12 +0000818** This routine is used to check if the UTF-8 string zName is a legal
819** unqualified name for a new schema object (table, index, view or
820** trigger). All names are legal except those that begin with the string
821** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
822** is reserved for internal use.
823*/
824int sqlite3CheckObjectName(Parse *pParse, const char *zName){
drhf1974842004-11-05 03:56:00 +0000825 if( !pParse->db->init.busy && pParse->nested==0
drh0f1c2eb2018-11-03 17:31:48 +0000826 && sqlite3WritableSchema(pParse->db)==0
drhf1974842004-11-05 03:56:00 +0000827 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
danielk1977d8123362004-06-12 09:25:12 +0000828 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
829 return SQLITE_ERROR;
830 }
831 return SQLITE_OK;
832}
833
834/*
drh44156282013-10-23 22:23:03 +0000835** Return the PRIMARY KEY index of a table
836*/
837Index *sqlite3PrimaryKeyIndex(Table *pTab){
838 Index *p;
drh48dd1d82014-05-27 18:18:58 +0000839 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
drh44156282013-10-23 22:23:03 +0000840 return p;
841}
842
843/*
844** Return the column of index pIdx that corresponds to table
845** column iCol. Return -1 if not found.
846*/
847i16 sqlite3ColumnOfIndex(Index *pIdx, i16 iCol){
848 int i;
849 for(i=0; i<pIdx->nColumn; i++){
850 if( iCol==pIdx->aiColumn[i] ) return i;
851 }
852 return -1;
853}
854
855/*
drh75897232000-05-29 14:26:00 +0000856** Begin constructing a new table representation in memory. This is
857** the first of several action routines that get called in response
drhd9b02572001-04-15 00:37:09 +0000858** to a CREATE TABLE statement. In particular, this routine is called
drh74161702006-02-24 02:53:49 +0000859** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
drhe0bc4042002-06-25 01:09:11 +0000860** flag is true if the table should be stored in the auxiliary database
861** file instead of in the main database file. This is normally the case
862** when the "TEMP" or "TEMPORARY" keyword occurs in between
drhf57b3392001-10-08 13:22:32 +0000863** CREATE and TABLE.
drhd9b02572001-04-15 00:37:09 +0000864**
drhf57b3392001-10-08 13:22:32 +0000865** The new table record is initialized and put in pParse->pNewTable.
866** As more of the CREATE TABLE statement is parsed, additional action
867** routines will be called to add more information to this record.
danielk19774adee202004-05-08 08:23:19 +0000868** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
drhf57b3392001-10-08 13:22:32 +0000869** is called to complete the construction of the new table record.
drh75897232000-05-29 14:26:00 +0000870*/
danielk19774adee202004-05-08 08:23:19 +0000871void sqlite3StartTable(
drhe5f9c642003-01-13 23:27:31 +0000872 Parse *pParse, /* Parser context */
danielk1977cbb18d22004-05-28 11:37:27 +0000873 Token *pName1, /* First part of the name of the table or view */
874 Token *pName2, /* Second part of the name of the table or view */
drhe5f9c642003-01-13 23:27:31 +0000875 int isTemp, /* True if this is a TEMP table */
drhfaa59552005-12-29 23:33:54 +0000876 int isView, /* True if this is a VIEW */
danielk1977f1a381e2006-06-16 08:01:02 +0000877 int isVirtual, /* True if this is a VIRTUAL table */
drhfaa59552005-12-29 23:33:54 +0000878 int noErr /* Do nothing if table already exists */
drhe5f9c642003-01-13 23:27:31 +0000879){
drh75897232000-05-29 14:26:00 +0000880 Table *pTable;
drh23bf66d2004-12-14 03:34:34 +0000881 char *zName = 0; /* The name of the new table */
drh9bb575f2004-09-06 17:24:11 +0000882 sqlite3 *db = pParse->db;
drhadbca9c2001-09-27 15:11:53 +0000883 Vdbe *v;
danielk1977cbb18d22004-05-28 11:37:27 +0000884 int iDb; /* Database number to create the table in */
885 Token *pName; /* Unqualified name of the table to create */
drh75897232000-05-29 14:26:00 +0000886
drh055f2982016-01-15 15:06:41 +0000887 if( db->init.busy && db->init.newTnum==1 ){
888 /* Special case: Parsing the sqlite_master or sqlite_temp_master schema */
889 iDb = db->init.iDb;
890 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
891 pName = pName1;
892 }else{
893 /* The common case */
894 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
895 if( iDb<0 ) return;
896 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
897 /* If creating a temp table, the name may not be qualified. Unless
898 ** the database name is "temp" anyway. */
899 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
900 return;
901 }
902 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
903 zName = sqlite3NameFromToken(db, pName);
danc9461ec2018-08-29 21:00:16 +0000904 if( IN_RENAME_OBJECT ){
905 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
906 }
danielk1977cbb18d22004-05-28 11:37:27 +0000907 }
danielk1977cbb18d22004-05-28 11:37:27 +0000908 pParse->sNameToken = *pName;
danielk1977e0048402004-06-15 16:51:01 +0000909 if( zName==0 ) return;
danielk1977d8123362004-06-12 09:25:12 +0000910 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
drh23bf66d2004-12-14 03:34:34 +0000911 goto begin_table_error;
danielk1977d8123362004-06-12 09:25:12 +0000912 }
drh1d85d932004-02-14 23:05:52 +0000913 if( db->init.iDb==1 ) isTemp = 1;
drhe5f9c642003-01-13 23:27:31 +0000914#ifndef SQLITE_OMIT_AUTHORIZATION
drh055f2982016-01-15 15:06:41 +0000915 assert( isTemp==0 || isTemp==1 );
916 assert( isView==0 || isView==1 );
drhe5f9c642003-01-13 23:27:31 +0000917 {
drh055f2982016-01-15 15:06:41 +0000918 static const u8 aCode[] = {
919 SQLITE_CREATE_TABLE,
920 SQLITE_CREATE_TEMP_TABLE,
921 SQLITE_CREATE_VIEW,
922 SQLITE_CREATE_TEMP_VIEW
923 };
drh69c33822016-08-18 14:33:11 +0000924 char *zDb = db->aDb[iDb].zDbSName;
danielk19774adee202004-05-08 08:23:19 +0000925 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +0000926 goto begin_table_error;
drhe22a3342003-04-22 20:30:37 +0000927 }
drh055f2982016-01-15 15:06:41 +0000928 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
929 zName, 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +0000930 goto begin_table_error;
drhe5f9c642003-01-13 23:27:31 +0000931 }
932 }
933#endif
drhf57b3392001-10-08 13:22:32 +0000934
drhf57b3392001-10-08 13:22:32 +0000935 /* Make sure the new table name does not collide with an existing
danielk19773df6b252004-05-29 10:23:19 +0000936 ** index or table name in the same database. Issue an error message if
danielk19777e6ebfb2006-06-12 11:24:37 +0000937 ** it does. The exception is if the statement being parsed was passed
938 ** to an sqlite3_declare_vtab() call. In that case only the column names
939 ** and types will be used, so there is no need to test for namespace
940 ** collisions.
drhf57b3392001-10-08 13:22:32 +0000941 */
dancf8f2892018-08-09 20:47:01 +0000942 if( !IN_SPECIAL_PARSE ){
drh69c33822016-08-18 14:33:11 +0000943 char *zDb = db->aDb[iDb].zDbSName;
danielk19777e6ebfb2006-06-12 11:24:37 +0000944 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
945 goto begin_table_error;
drhfaa59552005-12-29 23:33:54 +0000946 }
dana16d1062010-09-28 17:37:28 +0000947 pTable = sqlite3FindTable(db, zName, zDb);
danielk19777e6ebfb2006-06-12 11:24:37 +0000948 if( pTable ){
949 if( !noErr ){
950 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
dan7687c832011-04-09 15:39:02 +0000951 }else{
drh33c59ec2015-04-19 20:39:17 +0000952 assert( !db->init.busy || CORRUPT_DB );
dan7687c832011-04-09 15:39:02 +0000953 sqlite3CodeVerifySchema(pParse, iDb);
danielk19777e6ebfb2006-06-12 11:24:37 +0000954 }
955 goto begin_table_error;
956 }
drh8a8a0d12010-09-28 20:26:44 +0000957 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
danielk19777e6ebfb2006-06-12 11:24:37 +0000958 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
959 goto begin_table_error;
960 }
drh75897232000-05-29 14:26:00 +0000961 }
danielk19777e6ebfb2006-06-12 11:24:37 +0000962
danielk197726783a52007-08-29 14:06:22 +0000963 pTable = sqlite3DbMallocZero(db, sizeof(Table));
drh6d4abfb2001-10-22 02:58:08 +0000964 if( pTable==0 ){
drh4df86af2016-02-04 11:48:00 +0000965 assert( db->mallocFailed );
mistachkinfad30392016-02-13 23:43:46 +0000966 pParse->rc = SQLITE_NOMEM_BKPT;
danielk1977e0048402004-06-15 16:51:01 +0000967 pParse->nErr++;
drh23bf66d2004-12-14 03:34:34 +0000968 goto begin_table_error;
drh6d4abfb2001-10-22 02:58:08 +0000969 }
drh75897232000-05-29 14:26:00 +0000970 pTable->zName = zName;
drh4a324312001-12-21 14:30:42 +0000971 pTable->iPKey = -1;
danielk1977da184232006-01-05 11:34:32 +0000972 pTable->pSchema = db->aDb[iDb].pSchema;
drh79df7782016-12-14 14:07:35 +0000973 pTable->nTabRef = 1;
drhd1417ee2017-06-06 18:20:43 +0000974#ifdef SQLITE_DEFAULT_ROWEST
975 pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
976#else
dancfc9df72014-04-25 15:01:01 +0000977 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drhd1417ee2017-06-06 18:20:43 +0000978#endif
drhc4a64fa2009-05-11 20:53:28 +0000979 assert( pParse->pNewTable==0 );
drh75897232000-05-29 14:26:00 +0000980 pParse->pNewTable = pTable;
drh17f71932002-02-21 12:01:27 +0000981
drh4794f732004-11-05 17:17:50 +0000982 /* If this is the magic sqlite_sequence table used by autoincrement,
983 ** then record a pointer to this table in the main database structure
984 ** so that INSERT can find the table easily.
985 */
986#ifndef SQLITE_OMIT_AUTOINCREMENT
drh78776ec2005-06-14 02:12:46 +0000987 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
drh21206082011-04-04 18:22:02 +0000988 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danielk1977da184232006-01-05 11:34:32 +0000989 pTable->pSchema->pSeqTab = pTable;
drh4794f732004-11-05 17:17:50 +0000990 }
991#endif
992
drh17f71932002-02-21 12:01:27 +0000993 /* Begin generating the code that will insert the table record into
994 ** the SQLITE_MASTER table. Note in particular that we must go ahead
995 ** and allocate the record number for the table entry now. Before any
996 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
997 ** indices to be created and the table record must come before the
998 ** indices. Hence, the record number for the table must be allocated
999 ** now.
1000 */
danielk19774adee202004-05-08 08:23:19 +00001001 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
drh728e0f92015-10-10 14:41:28 +00001002 int addr1;
drhe321c292006-01-12 01:56:43 +00001003 int fileFormat;
drhb7654112008-01-12 12:48:07 +00001004 int reg1, reg2, reg3;
drh3c03afd2015-09-09 13:28:06 +00001005 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
1006 static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
drh0dd5cda2015-06-16 16:39:01 +00001007 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00001008
danielk197720b1eaf2006-07-26 16:22:14 +00001009#ifndef SQLITE_OMIT_VIRTUALTABLE
1010 if( isVirtual ){
drh66a51672008-01-03 00:01:23 +00001011 sqlite3VdbeAddOp0(v, OP_VBegin);
danielk197720b1eaf2006-07-26 16:22:14 +00001012 }
1013#endif
1014
danielk197736963fd2005-02-19 08:18:05 +00001015 /* If the file format and encoding in the database have not been set,
1016 ** set them now.
danielk1977d008cfe2004-06-19 02:22:10 +00001017 */
drhb7654112008-01-12 12:48:07 +00001018 reg1 = pParse->regRowid = ++pParse->nMem;
1019 reg2 = pParse->regRoot = ++pParse->nMem;
1020 reg3 = ++pParse->nMem;
danielk19770d19f7a2009-06-03 11:25:07 +00001021 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
drhfb982642007-08-30 01:19:59 +00001022 sqlite3VdbeUsesBtree(v, iDb);
drh728e0f92015-10-10 14:41:28 +00001023 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
drhe321c292006-01-12 01:56:43 +00001024 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
drh76fe8032006-07-11 14:17:51 +00001025 1 : SQLITE_MAX_FILE_FORMAT;
drh1861afc2016-02-01 21:48:34 +00001026 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
1027 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
drh728e0f92015-10-10 14:41:28 +00001028 sqlite3VdbeJumpHere(v, addr1);
danielk1977d008cfe2004-06-19 02:22:10 +00001029
drh4794f732004-11-05 17:17:50 +00001030 /* This just creates a place-holder record in the sqlite_master table.
1031 ** The record created does not contain anything yet. It will be replaced
1032 ** by the real entry in code generated at sqlite3EndTable().
drhb17131a2004-11-05 22:18:49 +00001033 **
drh0fa991b2009-03-21 16:19:26 +00001034 ** The rowid for the new entry is left in register pParse->regRowid.
1035 ** The root page number of the new table is left in reg pParse->regRoot.
1036 ** The rowid and root page number values are needed by the code that
1037 ** sqlite3EndTable will generate.
drh4794f732004-11-05 17:17:50 +00001038 */
danielk1977f1a381e2006-06-16 08:01:02 +00001039#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1040 if( isView || isVirtual ){
drhb7654112008-01-12 12:48:07 +00001041 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
danielk1977a21c6b62005-01-24 10:25:59 +00001042 }else
1043#endif
1044 {
drh0f3f7662017-08-18 14:34:28 +00001045 pParse->addrCrTab =
1046 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
danielk1977a21c6b62005-01-24 10:25:59 +00001047 }
danielk1977c00da102006-01-07 13:21:04 +00001048 sqlite3OpenMasterTable(pParse, iDb);
drhb7654112008-01-12 12:48:07 +00001049 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
drh3c03afd2015-09-09 13:28:06 +00001050 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
drhb7654112008-01-12 12:48:07 +00001051 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
1052 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drh66a51672008-01-03 00:01:23 +00001053 sqlite3VdbeAddOp0(v, OP_Close);
drh5e00f6c2001-09-13 13:46:56 +00001054 }
drh23bf66d2004-12-14 03:34:34 +00001055
1056 /* Normal (non-error) return. */
1057 return;
1058
1059 /* If an error occurs, we jump here */
1060begin_table_error:
drh633e6d52008-07-28 19:34:53 +00001061 sqlite3DbFree(db, zName);
drh23bf66d2004-12-14 03:34:34 +00001062 return;
drh75897232000-05-29 14:26:00 +00001063}
1064
drh03d69a62015-11-19 13:53:57 +00001065/* Set properties of a table column based on the (magical)
1066** name of the column.
1067*/
drh03d69a62015-11-19 13:53:57 +00001068#if SQLITE_ENABLE_HIDDEN_COLUMNS
drhe6110502015-12-31 15:34:03 +00001069void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
drh03d69a62015-11-19 13:53:57 +00001070 if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
1071 pCol->colFlags |= COLFLAG_HIDDEN;
danba68f8f2015-11-19 16:46:46 +00001072 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
1073 pTab->tabFlags |= TF_OOOHidden;
drh03d69a62015-11-19 13:53:57 +00001074 }
drh03d69a62015-11-19 13:53:57 +00001075}
drhe6110502015-12-31 15:34:03 +00001076#endif
drh03d69a62015-11-19 13:53:57 +00001077
1078
drh75897232000-05-29 14:26:00 +00001079/*
1080** Add a new column to the table currently being constructed.
drhd9b02572001-04-15 00:37:09 +00001081**
1082** The parser calls this routine once for each column declaration
danielk19774adee202004-05-08 08:23:19 +00001083** in a CREATE TABLE statement. sqlite3StartTable() gets called
drhd9b02572001-04-15 00:37:09 +00001084** first to get things going. Then this routine is called for each
1085** column.
drh75897232000-05-29 14:26:00 +00001086*/
drh2881ab62016-02-27 23:25:36 +00001087void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){
drh75897232000-05-29 14:26:00 +00001088 Table *p;
drh97fc3d02002-05-22 21:27:03 +00001089 int i;
drha99db3b2004-06-19 14:49:12 +00001090 char *z;
drh94eaafa2016-02-29 15:53:11 +00001091 char *zType;
drhc9b84a12002-06-20 11:36:48 +00001092 Column *pCol;
drhbb4957f2008-03-20 14:03:29 +00001093 sqlite3 *db = pParse->db;
drh75897232000-05-29 14:26:00 +00001094 if( (p = pParse->pNewTable)==0 ) return;
drhbb4957f2008-03-20 14:03:29 +00001095 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drhe5c941b2007-05-08 13:58:26 +00001096 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
1097 return;
1098 }
drh94eaafa2016-02-29 15:53:11 +00001099 z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
drh97fc3d02002-05-22 21:27:03 +00001100 if( z==0 ) return;
danc9461ec2018-08-29 21:00:16 +00001101 if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName);
drh94eaafa2016-02-29 15:53:11 +00001102 memcpy(z, pName->z, pName->n);
1103 z[pName->n] = 0;
1104 sqlite3Dequote(z);
drh97fc3d02002-05-22 21:27:03 +00001105 for(i=0; i<p->nCol; i++){
drha6f88ff2015-11-19 13:21:31 +00001106 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
danielk19774adee202004-05-08 08:23:19 +00001107 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
drh633e6d52008-07-28 19:34:53 +00001108 sqlite3DbFree(db, z);
drh97fc3d02002-05-22 21:27:03 +00001109 return;
1110 }
1111 }
drh75897232000-05-29 14:26:00 +00001112 if( (p->nCol & 0x7)==0 ){
drh6d4abfb2001-10-22 02:58:08 +00001113 Column *aNew;
danielk1977ae74e032008-12-23 11:11:51 +00001114 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
danielk1977d5d56522005-03-16 12:15:20 +00001115 if( aNew==0 ){
drh633e6d52008-07-28 19:34:53 +00001116 sqlite3DbFree(db, z);
danielk1977d5d56522005-03-16 12:15:20 +00001117 return;
1118 }
drh6d4abfb2001-10-22 02:58:08 +00001119 p->aCol = aNew;
drh75897232000-05-29 14:26:00 +00001120 }
drhc9b84a12002-06-20 11:36:48 +00001121 pCol = &p->aCol[p->nCol];
1122 memset(pCol, 0, sizeof(p->aCol[0]));
1123 pCol->zName = z;
danba68f8f2015-11-19 16:46:46 +00001124 sqlite3ColumnPropertiesFromName(p, pCol);
danielk1977a37cdde2004-05-16 11:15:36 +00001125
drh986dde72016-02-29 13:37:21 +00001126 if( pType->n==0 ){
drh2881ab62016-02-27 23:25:36 +00001127 /* If there is no type specified, columns have the default affinity
drhbbade8d2018-04-18 14:48:08 +00001128 ** 'BLOB' with a default size of 4 bytes. */
drh2881ab62016-02-27 23:25:36 +00001129 pCol->affinity = SQLITE_AFF_BLOB;
1130 pCol->szEst = 1;
drhbbade8d2018-04-18 14:48:08 +00001131#ifdef SQLITE_ENABLE_SORTER_REFERENCES
dan2e3a5a82018-04-16 21:12:42 +00001132 if( 4>=sqlite3GlobalConfig.szSorterRef ){
1133 pCol->colFlags |= COLFLAG_SORTERREF;
1134 }
drhbbade8d2018-04-18 14:48:08 +00001135#endif
drh2881ab62016-02-27 23:25:36 +00001136 }else{
drhddb2b4a2016-03-25 12:10:32 +00001137 zType = z + sqlite3Strlen30(z) + 1;
1138 memcpy(zType, pType->z, pType->n);
1139 zType[pType->n] = 0;
drha6dddd92016-04-18 15:46:14 +00001140 sqlite3Dequote(zType);
dan2e3a5a82018-04-16 21:12:42 +00001141 pCol->affinity = sqlite3AffinityType(zType, pCol);
drhd7564862016-03-22 20:05:09 +00001142 pCol->colFlags |= COLFLAG_HASTYPE;
drh2881ab62016-02-27 23:25:36 +00001143 }
drhc9b84a12002-06-20 11:36:48 +00001144 p->nCol++;
drh986dde72016-02-29 13:37:21 +00001145 pParse->constraintName.n = 0;
drh75897232000-05-29 14:26:00 +00001146}
1147
1148/*
drh382c0242001-10-06 16:33:02 +00001149** This routine is called by the parser while in the middle of
1150** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1151** been seen on a column. This routine sets the notNull flag on
1152** the column currently under construction.
1153*/
danielk19774adee202004-05-08 08:23:19 +00001154void sqlite3AddNotNull(Parse *pParse, int onError){
drh382c0242001-10-06 16:33:02 +00001155 Table *p;
dan26e731c2018-01-29 16:22:39 +00001156 Column *pCol;
drhc4a64fa2009-05-11 20:53:28 +00001157 p = pParse->pNewTable;
1158 if( p==0 || NEVER(p->nCol<1) ) return;
dan26e731c2018-01-29 16:22:39 +00001159 pCol = &p->aCol[p->nCol-1];
1160 pCol->notNull = (u8)onError;
drh8b174f22017-02-22 15:11:36 +00001161 p->tabFlags |= TF_HasNotNull;
dan26e731c2018-01-29 16:22:39 +00001162
1163 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
1164 ** on this column. */
1165 if( pCol->colFlags & COLFLAG_UNIQUE ){
1166 Index *pIdx;
1167 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
1168 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
1169 if( pIdx->aiColumn[0]==p->nCol-1 ){
1170 pIdx->uniqNotNull = 1;
1171 }
1172 }
1173 }
drh382c0242001-10-06 16:33:02 +00001174}
1175
1176/*
danielk197752a83fb2005-01-31 12:56:44 +00001177** Scan the column type name zType (length nType) and return the
1178** associated affinity type.
danielk1977b3dff962005-02-01 01:21:55 +00001179**
1180** This routine does a case-independent search of zType for the
1181** substrings in the following table. If one of the substrings is
1182** found, the corresponding affinity is returned. If zType contains
1183** more than one of the substrings, entries toward the top of
1184** the table take priority. For example, if zType is 'BLOBINT',
drh8a512562005-11-14 22:29:05 +00001185** SQLITE_AFF_INTEGER is returned.
danielk1977b3dff962005-02-01 01:21:55 +00001186**
1187** Substring | Affinity
1188** --------------------------------
1189** 'INT' | SQLITE_AFF_INTEGER
1190** 'CHAR' | SQLITE_AFF_TEXT
1191** 'CLOB' | SQLITE_AFF_TEXT
1192** 'TEXT' | SQLITE_AFF_TEXT
drh05883a32015-06-02 15:32:08 +00001193** 'BLOB' | SQLITE_AFF_BLOB
drh8a512562005-11-14 22:29:05 +00001194** 'REAL' | SQLITE_AFF_REAL
1195** 'FLOA' | SQLITE_AFF_REAL
1196** 'DOUB' | SQLITE_AFF_REAL
danielk1977b3dff962005-02-01 01:21:55 +00001197**
1198** If none of the substrings in the above table are found,
1199** SQLITE_AFF_NUMERIC is returned.
danielk197752a83fb2005-01-31 12:56:44 +00001200*/
dan2e3a5a82018-04-16 21:12:42 +00001201char sqlite3AffinityType(const char *zIn, Column *pCol){
danielk1977b3dff962005-02-01 01:21:55 +00001202 u32 h = 0;
1203 char aff = SQLITE_AFF_NUMERIC;
drhd3037a42013-10-04 18:29:25 +00001204 const char *zChar = 0;
danielk197752a83fb2005-01-31 12:56:44 +00001205
drh2f1e02e2016-03-09 02:12:44 +00001206 assert( zIn!=0 );
drhfdaac672013-10-04 15:30:21 +00001207 while( zIn[0] ){
drhb7916a72009-05-27 10:31:29 +00001208 h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
danielk1977b3dff962005-02-01 01:21:55 +00001209 zIn++;
danielk1977201f7162005-02-01 02:13:29 +00001210 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
drhfdaac672013-10-04 15:30:21 +00001211 aff = SQLITE_AFF_TEXT;
1212 zChar = zIn;
danielk1977201f7162005-02-01 02:13:29 +00001213 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
1214 aff = SQLITE_AFF_TEXT;
1215 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
1216 aff = SQLITE_AFF_TEXT;
1217 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
drh8a512562005-11-14 22:29:05 +00001218 && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
drh05883a32015-06-02 15:32:08 +00001219 aff = SQLITE_AFF_BLOB;
drhd3037a42013-10-04 18:29:25 +00001220 if( zIn[0]=='(' ) zChar = zIn;
drh8a512562005-11-14 22:29:05 +00001221#ifndef SQLITE_OMIT_FLOATING_POINT
1222 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
1223 && aff==SQLITE_AFF_NUMERIC ){
1224 aff = SQLITE_AFF_REAL;
1225 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
1226 && aff==SQLITE_AFF_NUMERIC ){
1227 aff = SQLITE_AFF_REAL;
1228 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
1229 && aff==SQLITE_AFF_NUMERIC ){
1230 aff = SQLITE_AFF_REAL;
1231#endif
danielk1977201f7162005-02-01 02:13:29 +00001232 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
drh8a512562005-11-14 22:29:05 +00001233 aff = SQLITE_AFF_INTEGER;
danielk1977b3dff962005-02-01 01:21:55 +00001234 break;
danielk197752a83fb2005-01-31 12:56:44 +00001235 }
1236 }
drhd3037a42013-10-04 18:29:25 +00001237
dan2e3a5a82018-04-16 21:12:42 +00001238 /* If pCol is not NULL, store an estimate of the field size. The
drhd3037a42013-10-04 18:29:25 +00001239 ** estimate is scaled so that the size of an integer is 1. */
dan2e3a5a82018-04-16 21:12:42 +00001240 if( pCol ){
1241 int v = 0; /* default size is approx 4 bytes */
drh7ea31cc2014-09-18 14:36:00 +00001242 if( aff<SQLITE_AFF_NUMERIC ){
drhd3037a42013-10-04 18:29:25 +00001243 if( zChar ){
1244 while( zChar[0] ){
1245 if( sqlite3Isdigit(zChar[0]) ){
dan2e3a5a82018-04-16 21:12:42 +00001246 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
drhd3037a42013-10-04 18:29:25 +00001247 sqlite3GetInt32(zChar, &v);
drhd3037a42013-10-04 18:29:25 +00001248 break;
1249 }
1250 zChar++;
drhfdaac672013-10-04 15:30:21 +00001251 }
drhd3037a42013-10-04 18:29:25 +00001252 }else{
dan2e3a5a82018-04-16 21:12:42 +00001253 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
drhfdaac672013-10-04 15:30:21 +00001254 }
drhfdaac672013-10-04 15:30:21 +00001255 }
drhbbade8d2018-04-18 14:48:08 +00001256#ifdef SQLITE_ENABLE_SORTER_REFERENCES
dan2e3a5a82018-04-16 21:12:42 +00001257 if( v>=sqlite3GlobalConfig.szSorterRef ){
1258 pCol->colFlags |= COLFLAG_SORTERREF;
1259 }
drhbbade8d2018-04-18 14:48:08 +00001260#endif
dan2e3a5a82018-04-16 21:12:42 +00001261 v = v/4 + 1;
1262 if( v>255 ) v = 255;
1263 pCol->szEst = v;
drhfdaac672013-10-04 15:30:21 +00001264 }
danielk1977b3dff962005-02-01 01:21:55 +00001265 return aff;
danielk197752a83fb2005-01-31 12:56:44 +00001266}
1267
1268/*
danielk19777977a172004-11-09 12:44:37 +00001269** The expression is the default value for the most recently added column
1270** of the table currently under construction.
1271**
1272** Default value expressions must be constant. Raise an exception if this
1273** is not the case.
drhd9b02572001-04-15 00:37:09 +00001274**
1275** This routine is called by the parser while in the middle of
1276** parsing a CREATE TABLE statement.
drh7020f652000-06-03 18:06:52 +00001277*/
drh1be266b2017-12-24 00:18:47 +00001278void sqlite3AddDefaultValue(
1279 Parse *pParse, /* Parsing context */
1280 Expr *pExpr, /* The parsed expression of the default value */
1281 const char *zStart, /* Start of the default value text */
1282 const char *zEnd /* First character past end of defaut value text */
1283){
drh7020f652000-06-03 18:06:52 +00001284 Table *p;
danielk19777977a172004-11-09 12:44:37 +00001285 Column *pCol;
drh633e6d52008-07-28 19:34:53 +00001286 sqlite3 *db = pParse->db;
drhc4a64fa2009-05-11 20:53:28 +00001287 p = pParse->pNewTable;
1288 if( p!=0 ){
drh42b9d7c2005-08-13 00:56:27 +00001289 pCol = &(p->aCol[p->nCol-1]);
drh1be266b2017-12-24 00:18:47 +00001290 if( !sqlite3ExprIsConstantOrFunction(pExpr, db->init.busy) ){
drh42b9d7c2005-08-13 00:56:27 +00001291 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
1292 pCol->zName);
1293 }else{
danielk19776ab3a2e2009-02-19 14:39:25 +00001294 /* A copy of pExpr is used instead of the original, as pExpr contains
drh424981d2018-03-28 15:56:55 +00001295 ** tokens that point to volatile memory.
danielk19776ab3a2e2009-02-19 14:39:25 +00001296 */
drh94fa9c42016-02-27 21:16:04 +00001297 Expr x;
drh633e6d52008-07-28 19:34:53 +00001298 sqlite3ExprDelete(db, pCol->pDflt);
drh94fa9c42016-02-27 21:16:04 +00001299 memset(&x, 0, sizeof(x));
1300 x.op = TK_SPAN;
drh9b2e0432017-12-27 19:43:22 +00001301 x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
drh1be266b2017-12-24 00:18:47 +00001302 x.pLeft = pExpr;
drh94fa9c42016-02-27 21:16:04 +00001303 x.flags = EP_Skip;
1304 pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
1305 sqlite3DbFree(db, x.u.zToken);
drh42b9d7c2005-08-13 00:56:27 +00001306 }
danielk19777977a172004-11-09 12:44:37 +00001307 }
dan8900a482018-09-05 14:36:05 +00001308 if( IN_RENAME_OBJECT ){
1309 sqlite3RenameExprUnmap(pParse, pExpr);
1310 }
drh1be266b2017-12-24 00:18:47 +00001311 sqlite3ExprDelete(db, pExpr);
drh7020f652000-06-03 18:06:52 +00001312}
1313
1314/*
drh153110a2015-11-01 21:19:13 +00001315** Backwards Compatibility Hack:
1316**
1317** Historical versions of SQLite accepted strings as column names in
1318** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1319**
1320** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1321** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1322**
1323** This is goofy. But to preserve backwards compatibility we continue to
1324** accept it. This routine does the necessary conversion. It converts
1325** the expression given in its argument from a TK_STRING into a TK_ID
1326** if the expression is just a TK_STRING with an optional COLLATE clause.
1327** If the epxression is anything other than TK_STRING, the expression is
1328** unchanged.
1329*/
1330static void sqlite3StringToId(Expr *p){
1331 if( p->op==TK_STRING ){
1332 p->op = TK_ID;
1333 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
1334 p->pLeft->op = TK_ID;
1335 }
1336}
1337
1338/*
drh4a324312001-12-21 14:30:42 +00001339** Designate the PRIMARY KEY for the table. pList is a list of names
1340** of columns that form the primary key. If pList is NULL, then the
1341** most recently added column of the table is the primary key.
1342**
1343** A table can have at most one primary key. If the table already has
1344** a primary key (and this is the second primary key) then create an
1345** error.
1346**
1347** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
drh23bf66d2004-12-14 03:34:34 +00001348** then we will try to use that column as the rowid. Set the Table.iPKey
drh4a324312001-12-21 14:30:42 +00001349** field of the table under construction to be the index of the
1350** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1351** no INTEGER PRIMARY KEY.
1352**
1353** If the key is not an INTEGER PRIMARY KEY, then create a unique
1354** index for the key. No index is created for INTEGER PRIMARY KEYs.
1355*/
drh205f48e2004-11-05 00:43:11 +00001356void sqlite3AddPrimaryKey(
1357 Parse *pParse, /* Parsing context */
1358 ExprList *pList, /* List of field names to be indexed */
1359 int onError, /* What to do with a uniqueness conflict */
drhfdd6e852005-12-16 01:06:16 +00001360 int autoInc, /* True if the AUTOINCREMENT keyword is present */
1361 int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
drh205f48e2004-11-05 00:43:11 +00001362){
drh4a324312001-12-21 14:30:42 +00001363 Table *pTab = pParse->pNewTable;
drhd7564862016-03-22 20:05:09 +00001364 Column *pCol = 0;
drh78100cc2003-08-23 22:40:53 +00001365 int iCol = -1, i;
drh8ea30bf2013-10-22 01:18:17 +00001366 int nTerm;
drh62340f82016-05-31 21:18:15 +00001367 if( pTab==0 ) goto primary_key_exit;
drh7d10d5a2008-08-20 16:35:10 +00001368 if( pTab->tabFlags & TF_HasPrimaryKey ){
danielk19774adee202004-05-08 08:23:19 +00001369 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00001370 "table \"%s\" has more than one primary key", pTab->zName);
drhe0194f22003-02-26 13:52:51 +00001371 goto primary_key_exit;
drh4a324312001-12-21 14:30:42 +00001372 }
drh7d10d5a2008-08-20 16:35:10 +00001373 pTab->tabFlags |= TF_HasPrimaryKey;
drh4a324312001-12-21 14:30:42 +00001374 if( pList==0 ){
1375 iCol = pTab->nCol - 1;
drhd7564862016-03-22 20:05:09 +00001376 pCol = &pTab->aCol[iCol];
1377 pCol->colFlags |= COLFLAG_PRIMKEY;
drh8ea30bf2013-10-22 01:18:17 +00001378 nTerm = 1;
drh78100cc2003-08-23 22:40:53 +00001379 }else{
drh8ea30bf2013-10-22 01:18:17 +00001380 nTerm = pList->nExpr;
1381 for(i=0; i<nTerm; i++){
drh108aa002015-08-24 20:21:20 +00001382 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
drh7d3d9da2015-09-01 00:42:52 +00001383 assert( pCExpr!=0 );
drh153110a2015-11-01 21:19:13 +00001384 sqlite3StringToId(pCExpr);
drh7d3d9da2015-09-01 00:42:52 +00001385 if( pCExpr->op==TK_ID ){
drh108aa002015-08-24 20:21:20 +00001386 const char *zCName = pCExpr->u.zToken;
1387 for(iCol=0; iCol<pTab->nCol; iCol++){
1388 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
drhd7564862016-03-22 20:05:09 +00001389 pCol = &pTab->aCol[iCol];
1390 pCol->colFlags |= COLFLAG_PRIMKEY;
drh108aa002015-08-24 20:21:20 +00001391 break;
1392 }
drhd3d39e92004-05-20 22:16:29 +00001393 }
drh78100cc2003-08-23 22:40:53 +00001394 }
drh4a324312001-12-21 14:30:42 +00001395 }
1396 }
drh8ea30bf2013-10-22 01:18:17 +00001397 if( nTerm==1
drhd7564862016-03-22 20:05:09 +00001398 && pCol
1399 && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
drhbc622bc2015-08-24 15:39:42 +00001400 && sortOrder!=SQLITE_SO_DESC
drh8ea30bf2013-10-22 01:18:17 +00001401 ){
danc9461ec2018-08-29 21:00:16 +00001402 if( IN_RENAME_OBJECT && pList ){
dan07e95232018-08-21 16:32:53 +00001403 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pList->a[0].pExpr);
dan987db762018-08-14 20:18:50 +00001404 }
drh4a324312001-12-21 14:30:42 +00001405 pTab->iPKey = iCol;
drh1bd10f82008-12-10 21:19:56 +00001406 pTab->keyConf = (u8)onError;
drh7d10d5a2008-08-20 16:35:10 +00001407 assert( autoInc==0 || autoInc==1 );
1408 pTab->tabFlags |= autoInc*TF_Autoincrement;
drh7f9c5db2013-10-23 00:32:58 +00001409 if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
drh205f48e2004-11-05 00:43:11 +00001410 }else if( autoInc ){
drh4794f732004-11-05 17:17:50 +00001411#ifndef SQLITE_OMIT_AUTOINCREMENT
drh205f48e2004-11-05 00:43:11 +00001412 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
1413 "INTEGER PRIMARY KEY");
drh4794f732004-11-05 17:17:50 +00001414#endif
drh4a324312001-12-21 14:30:42 +00001415 }else{
drh62340f82016-05-31 21:18:15 +00001416 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
1417 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
drhe0194f22003-02-26 13:52:51 +00001418 pList = 0;
drh4a324312001-12-21 14:30:42 +00001419 }
drhe0194f22003-02-26 13:52:51 +00001420
1421primary_key_exit:
drh633e6d52008-07-28 19:34:53 +00001422 sqlite3ExprListDelete(pParse->db, pList);
drhe0194f22003-02-26 13:52:51 +00001423 return;
drh4a324312001-12-21 14:30:42 +00001424}
1425
1426/*
drhffe07b22005-11-03 00:41:17 +00001427** Add a new CHECK constraint to the table currently under construction.
1428*/
1429void sqlite3AddCheckConstraint(
1430 Parse *pParse, /* Parsing context */
1431 Expr *pCheckExpr /* The check expression */
1432){
1433#ifndef SQLITE_OMIT_CHECK
1434 Table *pTab = pParse->pNewTable;
drhc9bbb012014-05-21 08:48:18 +00001435 sqlite3 *db = pParse->db;
1436 if( pTab && !IN_DECLARE_VTAB
1437 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
1438 ){
drh2938f922012-03-07 19:13:29 +00001439 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
1440 if( pParse->constraintName.n ){
1441 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
1442 }
drh33e619f2009-05-28 01:00:55 +00001443 }else
drhffe07b22005-11-03 00:41:17 +00001444#endif
drh33e619f2009-05-28 01:00:55 +00001445 {
drh2938f922012-03-07 19:13:29 +00001446 sqlite3ExprDelete(pParse->db, pCheckExpr);
drh33e619f2009-05-28 01:00:55 +00001447 }
drhffe07b22005-11-03 00:41:17 +00001448}
1449
1450/*
drhd3d39e92004-05-20 22:16:29 +00001451** Set the collation function of the most recently parsed table column
1452** to the CollSeq given.
drh8e2ca022002-06-17 17:07:19 +00001453*/
danielk197739002502007-11-12 09:50:26 +00001454void sqlite3AddCollateType(Parse *pParse, Token *pToken){
drh8e2ca022002-06-17 17:07:19 +00001455 Table *p;
danielk19770202b292004-06-09 09:55:16 +00001456 int i;
danielk197739002502007-11-12 09:50:26 +00001457 char *zColl; /* Dequoted name of collation sequence */
drh633e6d52008-07-28 19:34:53 +00001458 sqlite3 *db;
danielk1977a37cdde2004-05-16 11:15:36 +00001459
danielk1977b8cbb872006-06-19 05:33:45 +00001460 if( (p = pParse->pNewTable)==0 ) return;
danielk19770202b292004-06-09 09:55:16 +00001461 i = p->nCol-1;
drh633e6d52008-07-28 19:34:53 +00001462 db = pParse->db;
1463 zColl = sqlite3NameFromToken(db, pToken);
danielk197739002502007-11-12 09:50:26 +00001464 if( !zColl ) return;
1465
drhc4a64fa2009-05-11 20:53:28 +00001466 if( sqlite3LocateCollSeq(pParse, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00001467 Index *pIdx;
drhfe685c82013-06-08 19:58:27 +00001468 sqlite3DbFree(db, p->aCol[i].zColl);
danielk197739002502007-11-12 09:50:26 +00001469 p->aCol[i].zColl = zColl;
danielk1977b3bf5562006-01-10 17:58:23 +00001470
1471 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1472 ** then an index may have been created on this column before the
1473 ** collation type was added. Correct this if it is the case.
1474 */
1475 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhbbbdc832013-10-22 18:01:40 +00001476 assert( pIdx->nKeyCol==1 );
danielk1977b3bf5562006-01-10 17:58:23 +00001477 if( pIdx->aiColumn[0]==i ){
1478 pIdx->azColl[0] = p->aCol[i].zColl;
danielk19777cedc8d2004-06-10 10:50:08 +00001479 }
1480 }
danielk197739002502007-11-12 09:50:26 +00001481 }else{
drh633e6d52008-07-28 19:34:53 +00001482 sqlite3DbFree(db, zColl);
danielk19777cedc8d2004-06-10 10:50:08 +00001483 }
danielk19777cedc8d2004-06-10 10:50:08 +00001484}
1485
danielk1977466be562004-06-10 02:16:01 +00001486/*
1487** This function returns the collation sequence for database native text
1488** encoding identified by the string zName, length nName.
1489**
1490** If the requested collation sequence is not available, or not available
1491** in the database native encoding, the collation factory is invoked to
1492** request it. If the collation factory does not supply such a sequence,
1493** and the sequence is available in another text encoding, then that is
1494** returned instead.
1495**
1496** If no versions of the requested collations sequence are available, or
1497** another error occurs, NULL is returned and an error message written into
1498** pParse.
drha34001c2007-02-02 12:44:37 +00001499**
1500** This routine is a wrapper around sqlite3FindCollSeq(). This routine
1501** invokes the collation factory if the named collation cannot be found
1502** and generates an error message.
drhc4a64fa2009-05-11 20:53:28 +00001503**
1504** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq()
danielk1977466be562004-06-10 02:16:01 +00001505*/
drhc4a64fa2009-05-11 20:53:28 +00001506CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
danielk19774dade032005-05-25 10:45:10 +00001507 sqlite3 *db = pParse->db;
danielk197714db2662006-01-09 16:12:04 +00001508 u8 enc = ENC(db);
danielk19774dade032005-05-25 10:45:10 +00001509 u8 initbusy = db->init.busy;
danielk1977b3bf5562006-01-10 17:58:23 +00001510 CollSeq *pColl;
danielk19774dade032005-05-25 10:45:10 +00001511
drhc4a64fa2009-05-11 20:53:28 +00001512 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
danielk19777cedc8d2004-06-10 10:50:08 +00001513 if( !initbusy && (!pColl || !pColl->xCmp) ){
drh79e72a52012-10-05 14:43:40 +00001514 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
danielk1977466be562004-06-10 02:16:01 +00001515 }
1516
danielk19770202b292004-06-09 09:55:16 +00001517 return pColl;
1518}
1519
1520
drh8e2ca022002-06-17 17:07:19 +00001521/*
drh3f7d4e42004-07-24 14:35:58 +00001522** Generate code that will increment the schema cookie.
drh50e5dad2001-09-15 00:57:28 +00001523**
1524** The schema cookie is used to determine when the schema for the
1525** database changes. After each schema change, the cookie value
1526** changes. When a process first reads the schema it records the
1527** cookie. Thereafter, whenever it goes to access the database,
1528** it checks the cookie to make sure the schema has not changed
1529** since it was last read.
1530**
1531** This plan is not completely bullet-proof. It is possible for
1532** the schema to change multiple times and for the cookie to be
1533** set back to prior value. But schema changes are infrequent
1534** and the probability of hitting the same cookie value is only
1535** 1 chance in 2^32. So we're safe enough.
drh96fdcb42016-09-27 00:09:33 +00001536**
1537** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
1538** the schema-version whenever the schema changes.
drh50e5dad2001-09-15 00:57:28 +00001539*/
drh9cbf3422008-01-17 16:22:13 +00001540void sqlite3ChangeCookie(Parse *pParse, int iDb){
drh9cbf3422008-01-17 16:22:13 +00001541 sqlite3 *db = pParse->db;
1542 Vdbe *v = pParse->pVdbe;
drh21206082011-04-04 18:22:02 +00001543 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh1861afc2016-02-01 21:48:34 +00001544 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
drh3517b312018-04-09 00:46:42 +00001545 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
drh50e5dad2001-09-15 00:57:28 +00001546}
1547
1548/*
drh969fa7c2002-02-18 18:30:32 +00001549** Measure the number of characters needed to output the given
1550** identifier. The number returned includes any quotes used
1551** but does not include the null terminator.
drh234c39d2004-07-24 03:30:47 +00001552**
1553** The estimate is conservative. It might be larger that what is
1554** really needed.
drh969fa7c2002-02-18 18:30:32 +00001555*/
1556static int identLength(const char *z){
1557 int n;
drh17f71932002-02-21 12:01:27 +00001558 for(n=0; *z; n++, z++){
drh234c39d2004-07-24 03:30:47 +00001559 if( *z=='"' ){ n++; }
drh969fa7c2002-02-18 18:30:32 +00001560 }
drh234c39d2004-07-24 03:30:47 +00001561 return n + 2;
drh969fa7c2002-02-18 18:30:32 +00001562}
1563
1564/*
danielk19771b870de2009-03-14 08:37:23 +00001565** The first parameter is a pointer to an output buffer. The second
1566** parameter is a pointer to an integer that contains the offset at
1567** which to write into the output buffer. This function copies the
1568** nul-terminated string pointed to by the third parameter, zSignedIdent,
1569** to the specified offset in the buffer and updates *pIdx to refer
1570** to the first byte after the last byte written before returning.
1571**
1572** If the string zSignedIdent consists entirely of alpha-numeric
1573** characters, does not begin with a digit and is not an SQL keyword,
1574** then it is copied to the output buffer exactly as it is. Otherwise,
1575** it is quoted using double-quotes.
1576*/
drhc4a64fa2009-05-11 20:53:28 +00001577static void identPut(char *z, int *pIdx, char *zSignedIdent){
drh4c755c02004-08-08 20:22:17 +00001578 unsigned char *zIdent = (unsigned char*)zSignedIdent;
drh17f71932002-02-21 12:01:27 +00001579 int i, j, needQuote;
drh969fa7c2002-02-18 18:30:32 +00001580 i = *pIdx;
danielk19771b870de2009-03-14 08:37:23 +00001581
drh17f71932002-02-21 12:01:27 +00001582 for(j=0; zIdent[j]; j++){
danielk197778ca0e72009-01-20 16:53:39 +00001583 if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
drh17f71932002-02-21 12:01:27 +00001584 }
drhc7407522014-01-10 20:38:12 +00001585 needQuote = sqlite3Isdigit(zIdent[0])
1586 || sqlite3KeywordCode(zIdent, j)!=TK_ID
1587 || zIdent[j]!=0
1588 || j==0;
danielk19771b870de2009-03-14 08:37:23 +00001589
drh234c39d2004-07-24 03:30:47 +00001590 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00001591 for(j=0; zIdent[j]; j++){
1592 z[i++] = zIdent[j];
drh234c39d2004-07-24 03:30:47 +00001593 if( zIdent[j]=='"' ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00001594 }
drh234c39d2004-07-24 03:30:47 +00001595 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00001596 z[i] = 0;
1597 *pIdx = i;
1598}
1599
1600/*
1601** Generate a CREATE TABLE statement appropriate for the given
1602** table. Memory to hold the text of the statement is obtained
1603** from sqliteMalloc() and must be freed by the calling function.
1604*/
drh1d34fde2009-02-03 15:50:33 +00001605static char *createTableStmt(sqlite3 *db, Table *p){
drh969fa7c2002-02-18 18:30:32 +00001606 int i, k, n;
1607 char *zStmt;
drhc4a64fa2009-05-11 20:53:28 +00001608 char *zSep, *zSep2, *zEnd;
drh234c39d2004-07-24 03:30:47 +00001609 Column *pCol;
drh969fa7c2002-02-18 18:30:32 +00001610 n = 0;
drh234c39d2004-07-24 03:30:47 +00001611 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
drhc4a64fa2009-05-11 20:53:28 +00001612 n += identLength(pCol->zName) + 5;
drh969fa7c2002-02-18 18:30:32 +00001613 }
1614 n += identLength(p->zName);
drhc4a64fa2009-05-11 20:53:28 +00001615 if( n<50 ){
drh969fa7c2002-02-18 18:30:32 +00001616 zSep = "";
1617 zSep2 = ",";
1618 zEnd = ")";
1619 }else{
1620 zSep = "\n ";
1621 zSep2 = ",\n ";
1622 zEnd = "\n)";
1623 }
drhe0bc4042002-06-25 01:09:11 +00001624 n += 35 + 6*p->nCol;
drhb9755982010-07-24 16:34:37 +00001625 zStmt = sqlite3DbMallocRaw(0, n);
drh820a9062008-01-31 13:35:48 +00001626 if( zStmt==0 ){
drh4a642b62016-02-05 01:55:27 +00001627 sqlite3OomFault(db);
drh820a9062008-01-31 13:35:48 +00001628 return 0;
1629 }
drhbdb339f2009-02-02 18:03:21 +00001630 sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
drhea678832008-12-10 19:26:22 +00001631 k = sqlite3Strlen30(zStmt);
drhc4a64fa2009-05-11 20:53:28 +00001632 identPut(zStmt, &k, p->zName);
drh969fa7c2002-02-18 18:30:32 +00001633 zStmt[k++] = '(';
drh234c39d2004-07-24 03:30:47 +00001634 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
drhc4a64fa2009-05-11 20:53:28 +00001635 static const char * const azType[] = {
drh05883a32015-06-02 15:32:08 +00001636 /* SQLITE_AFF_BLOB */ "",
drh7ea31cc2014-09-18 14:36:00 +00001637 /* SQLITE_AFF_TEXT */ " TEXT",
drhc4a64fa2009-05-11 20:53:28 +00001638 /* SQLITE_AFF_NUMERIC */ " NUM",
1639 /* SQLITE_AFF_INTEGER */ " INT",
1640 /* SQLITE_AFF_REAL */ " REAL"
1641 };
1642 int len;
1643 const char *zType;
1644
drh5bb3eb92007-05-04 13:15:55 +00001645 sqlite3_snprintf(n-k, &zStmt[k], zSep);
drhea678832008-12-10 19:26:22 +00001646 k += sqlite3Strlen30(&zStmt[k]);
drh969fa7c2002-02-18 18:30:32 +00001647 zSep = zSep2;
drhc4a64fa2009-05-11 20:53:28 +00001648 identPut(zStmt, &k, pCol->zName);
drh05883a32015-06-02 15:32:08 +00001649 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
1650 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
1651 testcase( pCol->affinity==SQLITE_AFF_BLOB );
drh7ea31cc2014-09-18 14:36:00 +00001652 testcase( pCol->affinity==SQLITE_AFF_TEXT );
drhc4a64fa2009-05-11 20:53:28 +00001653 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
1654 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
1655 testcase( pCol->affinity==SQLITE_AFF_REAL );
1656
drh05883a32015-06-02 15:32:08 +00001657 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
drhc4a64fa2009-05-11 20:53:28 +00001658 len = sqlite3Strlen30(zType);
drh05883a32015-06-02 15:32:08 +00001659 assert( pCol->affinity==SQLITE_AFF_BLOB
drhfdaac672013-10-04 15:30:21 +00001660 || pCol->affinity==sqlite3AffinityType(zType, 0) );
drhc4a64fa2009-05-11 20:53:28 +00001661 memcpy(&zStmt[k], zType, len);
1662 k += len;
1663 assert( k<=n );
drh969fa7c2002-02-18 18:30:32 +00001664 }
drh5bb3eb92007-05-04 13:15:55 +00001665 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
drh969fa7c2002-02-18 18:30:32 +00001666 return zStmt;
1667}
1668
1669/*
drh7f9c5db2013-10-23 00:32:58 +00001670** Resize an Index object to hold N columns total. Return SQLITE_OK
1671** on success and SQLITE_NOMEM on an OOM error.
1672*/
1673static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
1674 char *zExtra;
1675 int nByte;
1676 if( pIdx->nColumn>=N ) return SQLITE_OK;
1677 assert( pIdx->isResized==0 );
1678 nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
1679 zExtra = sqlite3DbMallocZero(db, nByte);
mistachkinfad30392016-02-13 23:43:46 +00001680 if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
drh7f9c5db2013-10-23 00:32:58 +00001681 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
drhf19aa5f2015-12-30 16:51:20 +00001682 pIdx->azColl = (const char**)zExtra;
drh7f9c5db2013-10-23 00:32:58 +00001683 zExtra += sizeof(char*)*N;
1684 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
1685 pIdx->aiColumn = (i16*)zExtra;
1686 zExtra += sizeof(i16)*N;
1687 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
1688 pIdx->aSortOrder = (u8*)zExtra;
1689 pIdx->nColumn = N;
1690 pIdx->isResized = 1;
1691 return SQLITE_OK;
1692}
1693
1694/*
drhfdaac672013-10-04 15:30:21 +00001695** Estimate the total row width for a table.
1696*/
drhe13e9f52013-10-05 19:18:00 +00001697static void estimateTableWidth(Table *pTab){
drhfdaac672013-10-04 15:30:21 +00001698 unsigned wTable = 0;
1699 const Column *pTabCol;
1700 int i;
1701 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
1702 wTable += pTabCol->szEst;
1703 }
1704 if( pTab->iPKey<0 ) wTable++;
drhe13e9f52013-10-05 19:18:00 +00001705 pTab->szTabRow = sqlite3LogEst(wTable*4);
drhfdaac672013-10-04 15:30:21 +00001706}
1707
1708/*
drhe13e9f52013-10-05 19:18:00 +00001709** Estimate the average size of a row for an index.
drhfdaac672013-10-04 15:30:21 +00001710*/
drhe13e9f52013-10-05 19:18:00 +00001711static void estimateIndexWidth(Index *pIdx){
drhbbbdc832013-10-22 18:01:40 +00001712 unsigned wIndex = 0;
drhfdaac672013-10-04 15:30:21 +00001713 int i;
1714 const Column *aCol = pIdx->pTable->aCol;
1715 for(i=0; i<pIdx->nColumn; i++){
drhbbbdc832013-10-22 18:01:40 +00001716 i16 x = pIdx->aiColumn[i];
1717 assert( x<pIdx->pTable->nCol );
1718 wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
drhfdaac672013-10-04 15:30:21 +00001719 }
drhe13e9f52013-10-05 19:18:00 +00001720 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
drhfdaac672013-10-04 15:30:21 +00001721}
1722
drh7f9c5db2013-10-23 00:32:58 +00001723/* Return true if value x is found any of the first nCol entries of aiCol[]
1724*/
1725static int hasColumn(const i16 *aiCol, int nCol, int x){
1726 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
1727 return 0;
1728}
1729
drh1fe3ac72018-06-09 01:12:08 +00001730/* Recompute the colNotIdxed field of the Index.
1731**
1732** colNotIdxed is a bitmask that has a 0 bit representing each indexed
1733** columns that are within the first 63 columns of the table. The
1734** high-order bit of colNotIdxed is always 1. All unindexed columns
1735** of the table have a 1.
1736**
1737** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
1738** to determine if the index is covering index.
1739*/
1740static void recomputeColumnsNotIndexed(Index *pIdx){
1741 Bitmask m = 0;
1742 int j;
1743 for(j=pIdx->nColumn-1; j>=0; j--){
1744 int x = pIdx->aiColumn[j];
1745 if( x>=0 ){
1746 testcase( x==BMS-1 );
1747 testcase( x==BMS-2 );
1748 if( x<BMS-1 ) m |= MASKBIT(x);
1749 }
1750 }
1751 pIdx->colNotIdxed = ~m;
1752 assert( (pIdx->colNotIdxed>>63)==1 );
1753}
1754
drh7f9c5db2013-10-23 00:32:58 +00001755/*
drhc6bd4e42013-11-02 14:37:18 +00001756** This routine runs at the end of parsing a CREATE TABLE statement that
1757** has a WITHOUT ROWID clause. The job of this routine is to convert both
1758** internal schema data structures and the generated VDBE code so that they
1759** are appropriate for a WITHOUT ROWID table instead of a rowid table.
1760** Changes include:
drh7f9c5db2013-10-23 00:32:58 +00001761**
drh62340f82016-05-31 21:18:15 +00001762** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
drh0f3f7662017-08-18 14:34:28 +00001763** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
1764** into BTREE_BLOBKEY.
drh62340f82016-05-31 21:18:15 +00001765** (3) Bypass the creation of the sqlite_master table entry
peter.d.reid60ec9142014-09-06 16:39:46 +00001766** for the PRIMARY KEY as the primary key index is now
drhc6bd4e42013-11-02 14:37:18 +00001767** identified by the sqlite_master table entry of the table itself.
drh62340f82016-05-31 21:18:15 +00001768** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
drhc6bd4e42013-11-02 14:37:18 +00001769** schema to the rootpage from the main table.
drhc6bd4e42013-11-02 14:37:18 +00001770** (5) Add all table columns to the PRIMARY KEY Index object
1771** so that the PRIMARY KEY is a covering index. The surplus
drha485ad12017-08-02 22:43:14 +00001772** columns are part of KeyInfo.nAllField and are not used for
drhc6bd4e42013-11-02 14:37:18 +00001773** sorting or lookup or uniqueness checks.
1774** (6) Replace the rowid tail on all automatically generated UNIQUE
1775** indices with the PRIMARY KEY columns.
drh62340f82016-05-31 21:18:15 +00001776**
1777** For virtual tables, only (1) is performed.
drh7f9c5db2013-10-23 00:32:58 +00001778*/
1779static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
1780 Index *pIdx;
1781 Index *pPk;
1782 int nPk;
1783 int i, j;
1784 sqlite3 *db = pParse->db;
drhc6bd4e42013-11-02 14:37:18 +00001785 Vdbe *v = pParse->pVdbe;
drh7f9c5db2013-10-23 00:32:58 +00001786
drh62340f82016-05-31 21:18:15 +00001787 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
1788 */
1789 if( !db->init.imposterTable ){
1790 for(i=0; i<pTab->nCol; i++){
1791 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){
1792 pTab->aCol[i].notNull = OE_Abort;
1793 }
1794 }
1795 }
1796
drh0f3f7662017-08-18 14:34:28 +00001797 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
1798 ** into BTREE_BLOBKEY.
drh7f9c5db2013-10-23 00:32:58 +00001799 */
1800 if( pParse->addrCrTab ){
drhc6bd4e42013-11-02 14:37:18 +00001801 assert( v );
drh0f3f7662017-08-18 14:34:28 +00001802 sqlite3VdbeChangeP3(v, pParse->addrCrTab, BTREE_BLOBKEY);
drhc6bd4e42013-11-02 14:37:18 +00001803 }
1804
drh7f9c5db2013-10-23 00:32:58 +00001805 /* Locate the PRIMARY KEY index. Or, if this table was originally
1806 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
1807 */
1808 if( pTab->iPKey>=0 ){
1809 ExprList *pList;
drh108aa002015-08-24 20:21:20 +00001810 Token ipkToken;
drh40aced52016-01-22 17:48:09 +00001811 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
drh108aa002015-08-24 20:21:20 +00001812 pList = sqlite3ExprListAppend(pParse, 0,
1813 sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
drh7f9c5db2013-10-23 00:32:58 +00001814 if( pList==0 ) return;
drh7f9c5db2013-10-23 00:32:58 +00001815 pList->a[0].sortOrder = pParse->iPkSortOrder;
1816 assert( pParse->pNewTable==pTab );
drh62340f82016-05-31 21:18:15 +00001817 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
1818 SQLITE_IDXTYPE_PRIMARYKEY);
drh8ff21f42018-07-09 02:02:09 +00001819 if( db->mallocFailed || pParse->nErr ) return;
drh62340f82016-05-31 21:18:15 +00001820 pPk = sqlite3PrimaryKeyIndex(pTab);
drh7f9c5db2013-10-23 00:32:58 +00001821 pTab->iPKey = -1;
drh44156282013-10-23 22:23:03 +00001822 }else{
1823 pPk = sqlite3PrimaryKeyIndex(pTab);
danc5b73582015-05-26 11:53:14 +00001824
drhe385d882014-12-28 22:10:51 +00001825 /*
1826 ** Remove all redundant columns from the PRIMARY KEY. For example, change
1827 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
1828 ** code assumes the PRIMARY KEY contains no repeated columns.
1829 */
1830 for(i=j=1; i<pPk->nKeyCol; i++){
1831 if( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ){
1832 pPk->nColumn--;
1833 }else{
1834 pPk->aiColumn[j++] = pPk->aiColumn[i];
1835 }
1836 }
1837 pPk->nKeyCol = j;
drh7f9c5db2013-10-23 00:32:58 +00001838 }
drh7f9c5db2013-10-23 00:32:58 +00001839 assert( pPk!=0 );
drh62340f82016-05-31 21:18:15 +00001840 pPk->isCovering = 1;
1841 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
drh7f9c5db2013-10-23 00:32:58 +00001842 nPk = pPk->nKeyCol;
1843
drhdf949662017-07-30 18:40:52 +00001844 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_master
1845 ** table entry. This is only required if currently generating VDBE
1846 ** code for a CREATE TABLE (not when parsing one as part of reading
1847 ** a database schema). */
1848 if( v && pPk->tnum>0 ){
1849 assert( db->init.busy==0 );
1850 sqlite3VdbeChangeOpcode(v, pPk->tnum, OP_Goto);
1851 }
1852
drhc6bd4e42013-11-02 14:37:18 +00001853 /* The root page of the PRIMARY KEY is the table root page */
1854 pPk->tnum = pTab->tnum;
1855
drh7f9c5db2013-10-23 00:32:58 +00001856 /* Update the in-memory representation of all UNIQUE indices by converting
1857 ** the final rowid column into one or more columns of the PRIMARY KEY.
1858 */
1859 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1860 int n;
drh48dd1d82014-05-27 18:18:58 +00001861 if( IsPrimaryKeyIndex(pIdx) ) continue;
drh7f9c5db2013-10-23 00:32:58 +00001862 for(i=n=0; i<nPk; i++){
1863 if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ) n++;
1864 }
drh5a9a37b2013-11-05 17:30:04 +00001865 if( n==0 ){
1866 /* This index is a superset of the primary key */
1867 pIdx->nColumn = pIdx->nKeyCol;
1868 continue;
1869 }
drh7f9c5db2013-10-23 00:32:58 +00001870 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
1871 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
drh7913e412013-11-01 20:30:36 +00001872 if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ){
drh7f9c5db2013-10-23 00:32:58 +00001873 pIdx->aiColumn[j] = pPk->aiColumn[i];
1874 pIdx->azColl[j] = pPk->azColl[i];
1875 j++;
1876 }
1877 }
drh00012df2013-11-05 01:59:07 +00001878 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
1879 assert( pIdx->nColumn>=j );
drh7f9c5db2013-10-23 00:32:58 +00001880 }
1881
1882 /* Add all table columns to the PRIMARY KEY index
1883 */
1884 if( nPk<pTab->nCol ){
1885 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
1886 for(i=0, j=nPk; i<pTab->nCol; i++){
1887 if( !hasColumn(pPk->aiColumn, j, i) ){
1888 assert( j<pPk->nColumn );
1889 pPk->aiColumn[j] = i;
drhf19aa5f2015-12-30 16:51:20 +00001890 pPk->azColl[j] = sqlite3StrBINARY;
drh7f9c5db2013-10-23 00:32:58 +00001891 j++;
1892 }
1893 }
1894 assert( pPk->nColumn==j );
1895 assert( pTab->nCol==j );
drhc3e356f2013-11-04 18:34:46 +00001896 }else{
1897 pPk->nColumn = pTab->nCol;
drh7f9c5db2013-10-23 00:32:58 +00001898 }
drh1fe3ac72018-06-09 01:12:08 +00001899 recomputeColumnsNotIndexed(pPk);
drh7f9c5db2013-10-23 00:32:58 +00001900}
1901
danf6e015f2018-11-28 08:02:28 +00001902#ifndef SQLITE_OMIT_VIRTUALTABLE
drhfdaac672013-10-04 15:30:21 +00001903/*
drh84c501b2018-11-05 23:01:45 +00001904** Return true if zName is a shadow table name in the current database
1905** connection.
1906**
1907** zName is temporarily modified while this routine is running, but is
1908** restored to its original value prior to this routine returning.
1909*/
1910static int isShadowTableName(sqlite3 *db, char *zName){
1911 char *zTail; /* Pointer to the last "_" in zName */
1912 Table *pTab; /* Table that zName is a shadow of */
drh5a654702018-11-06 13:37:20 +00001913 Module *pMod; /* Module for the virtual table */
1914
drh84c501b2018-11-05 23:01:45 +00001915 zTail = strrchr(zName, '_');
1916 if( zTail==0 ) return 0;
1917 *zTail = 0;
1918 pTab = sqlite3FindTable(db, zName, 0);
1919 *zTail = '_';
1920 if( pTab==0 ) return 0;
1921 if( !IsVirtual(pTab) ) return 0;
drh5a654702018-11-06 13:37:20 +00001922 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
drhab0659f2018-11-10 04:14:51 +00001923 if( pMod==0 ) return 0;
drh5a654702018-11-06 13:37:20 +00001924 if( pMod->pModule->iVersion<3 ) return 0;
1925 if( pMod->pModule->xShadowName==0 ) return 0;
1926 return pMod->pModule->xShadowName(zTail+1);
drh84c501b2018-11-05 23:01:45 +00001927}
danf6e015f2018-11-28 08:02:28 +00001928#else
1929# define isShadowTableName(x,y) 0
1930#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
drh84c501b2018-11-05 23:01:45 +00001931
1932/*
drh75897232000-05-29 14:26:00 +00001933** This routine is called to report the final ")" that terminates
1934** a CREATE TABLE statement.
1935**
drhf57b3392001-10-08 13:22:32 +00001936** The table structure that other action routines have been building
1937** is added to the internal hash tables, assuming no errors have
1938** occurred.
drh75897232000-05-29 14:26:00 +00001939**
drh1d85d932004-02-14 23:05:52 +00001940** An entry for the table is made in the master table on disk, unless
1941** this is a temporary table or db->init.busy==1. When db->init.busy==1
drhf57b3392001-10-08 13:22:32 +00001942** it means we are reading the sqlite_master table because we just
1943** connected to the database or because the sqlite_master table has
drhddba9e52005-03-19 01:41:21 +00001944** recently changed, so the entry for this table already exists in
drhf57b3392001-10-08 13:22:32 +00001945** the sqlite_master table. We do not want to create it again.
drh969fa7c2002-02-18 18:30:32 +00001946**
1947** If the pSelect argument is not NULL, it means that this routine
1948** was called to create a table generated from a
1949** "CREATE TABLE ... AS SELECT ..." statement. The column names of
1950** the new table will match the result set of the SELECT.
drh75897232000-05-29 14:26:00 +00001951*/
danielk197719a8e7e2005-03-17 05:03:38 +00001952void sqlite3EndTable(
1953 Parse *pParse, /* Parse context */
1954 Token *pCons, /* The ',' token after the last column defn. */
drh5969da42013-10-21 02:14:45 +00001955 Token *pEnd, /* The ')' before options in the CREATE TABLE */
1956 u8 tabOpts, /* Extra table options. Usually 0. */
danielk197719a8e7e2005-03-17 05:03:38 +00001957 Select *pSelect /* Select from a "CREATE ... AS SELECT" */
1958){
drhfdaac672013-10-04 15:30:21 +00001959 Table *p; /* The new table */
1960 sqlite3 *db = pParse->db; /* The database connection */
1961 int iDb; /* Database in which the table lives */
1962 Index *pIdx; /* An implied index of the table */
drh75897232000-05-29 14:26:00 +00001963
drh027616d2015-08-08 22:47:47 +00001964 if( pEnd==0 && pSelect==0 ){
drh5969da42013-10-21 02:14:45 +00001965 return;
danielk1977261919c2005-12-06 12:52:59 +00001966 }
drh834f9972015-08-08 23:23:33 +00001967 assert( !db->mallocFailed );
drh28037572000-08-02 13:47:41 +00001968 p = pParse->pNewTable;
drh5969da42013-10-21 02:14:45 +00001969 if( p==0 ) return;
drh75897232000-05-29 14:26:00 +00001970
drh84c501b2018-11-05 23:01:45 +00001971 if( pSelect==0 && isShadowTableName(db, p->zName) ){
1972 p->tabFlags |= TF_Shadow;
1973 }
1974
drhc6bd4e42013-11-02 14:37:18 +00001975 /* If the db->init.busy is 1 it means we are reading the SQL off the
1976 ** "sqlite_master" or "sqlite_temp_master" table on the disk.
1977 ** So do not write to the disk again. Extract the root page number
1978 ** for the table from the db->init.newTnum field. (The page number
1979 ** should have been put there by the sqliteOpenCb routine.)
drh055f2982016-01-15 15:06:41 +00001980 **
1981 ** If the root page number is 1, that means this is the sqlite_master
1982 ** table itself. So mark it read-only.
drhc6bd4e42013-11-02 14:37:18 +00001983 */
1984 if( db->init.busy ){
drh1e9c47b2018-03-16 20:15:58 +00001985 if( pSelect ){
1986 sqlite3ErrorMsg(pParse, "");
1987 return;
1988 }
drhc6bd4e42013-11-02 14:37:18 +00001989 p->tnum = db->init.newTnum;
drh055f2982016-01-15 15:06:41 +00001990 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
drhc6bd4e42013-11-02 14:37:18 +00001991 }
1992
1993 /* Special processing for WITHOUT ROWID Tables */
drh5969da42013-10-21 02:14:45 +00001994 if( tabOpts & TF_WithoutRowid ){
drhd2fe3352013-11-09 18:15:35 +00001995 if( (p->tabFlags & TF_Autoincrement) ){
1996 sqlite3ErrorMsg(pParse,
1997 "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
1998 return;
1999 }
drh5969da42013-10-21 02:14:45 +00002000 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
drhd2fe3352013-11-09 18:15:35 +00002001 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
drh7f9c5db2013-10-23 00:32:58 +00002002 }else{
drhfccda8a2015-05-27 13:06:55 +00002003 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
drh7f9c5db2013-10-23 00:32:58 +00002004 convertToWithoutRowidTable(pParse, p);
drh81eba732013-10-19 23:31:56 +00002005 }
2006 }
2007
drhb9bb7c12006-06-11 23:41:55 +00002008 iDb = sqlite3SchemaToIndex(db, p->pSchema);
danielk1977da184232006-01-05 11:34:32 +00002009
drhffe07b22005-11-03 00:41:17 +00002010#ifndef SQLITE_OMIT_CHECK
2011 /* Resolve names in all CHECK constraint expressions.
2012 */
2013 if( p->pCheck ){
drh3780be12013-07-31 19:05:22 +00002014 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
drhffe07b22005-11-03 00:41:17 +00002015 }
2016#endif /* !defined(SQLITE_OMIT_CHECK) */
2017
drhe13e9f52013-10-05 19:18:00 +00002018 /* Estimate the average row size for the table and for all implied indices */
2019 estimateTableWidth(p);
drhfdaac672013-10-04 15:30:21 +00002020 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhe13e9f52013-10-05 19:18:00 +00002021 estimateIndexWidth(pIdx);
drhfdaac672013-10-04 15:30:21 +00002022 }
2023
drhe3c41372001-09-17 20:25:58 +00002024 /* If not initializing, then create a record for the new table
drh0fa991b2009-03-21 16:19:26 +00002025 ** in the SQLITE_MASTER table of the database.
drhf57b3392001-10-08 13:22:32 +00002026 **
drhe0bc4042002-06-25 01:09:11 +00002027 ** If this is a TEMPORARY table, write the entry into the auxiliary
2028 ** file instead of into the main database file.
drh75897232000-05-29 14:26:00 +00002029 */
drh1d85d932004-02-14 23:05:52 +00002030 if( !db->init.busy ){
drh4ff6dfa2002-03-03 23:06:00 +00002031 int n;
drhd8bc7082000-06-07 23:51:50 +00002032 Vdbe *v;
drh4794f732004-11-05 17:17:50 +00002033 char *zType; /* "view" or "table" */
2034 char *zType2; /* "VIEW" or "TABLE" */
2035 char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
drh75897232000-05-29 14:26:00 +00002036
danielk19774adee202004-05-08 08:23:19 +00002037 v = sqlite3GetVdbe(pParse);
drh5969da42013-10-21 02:14:45 +00002038 if( NEVER(v==0) ) return;
danielk1977517eb642004-06-07 10:00:31 +00002039
drh66a51672008-01-03 00:01:23 +00002040 sqlite3VdbeAddOp1(v, OP_Close, 0);
danielk1977e6efa742004-11-10 11:55:10 +00002041
drh0fa991b2009-03-21 16:19:26 +00002042 /*
2043 ** Initialize zType for the new view or table.
drh4794f732004-11-05 17:17:50 +00002044 */
drh4ff6dfa2002-03-03 23:06:00 +00002045 if( p->pSelect==0 ){
2046 /* A regular table */
drh4794f732004-11-05 17:17:50 +00002047 zType = "table";
2048 zType2 = "TABLE";
danielk1977576ec6b2005-01-21 11:55:25 +00002049#ifndef SQLITE_OMIT_VIEW
drh4ff6dfa2002-03-03 23:06:00 +00002050 }else{
2051 /* A view */
drh4794f732004-11-05 17:17:50 +00002052 zType = "view";
2053 zType2 = "VIEW";
danielk1977576ec6b2005-01-21 11:55:25 +00002054#endif
drh4ff6dfa2002-03-03 23:06:00 +00002055 }
danielk1977517eb642004-06-07 10:00:31 +00002056
danielk1977517eb642004-06-07 10:00:31 +00002057 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
2058 ** statement to populate the new table. The root-page number for the
drh0fa991b2009-03-21 16:19:26 +00002059 ** new table is in register pParse->regRoot.
danielk1977517eb642004-06-07 10:00:31 +00002060 **
2061 ** Once the SELECT has been coded by sqlite3Select(), it is in a
2062 ** suitable state to query for the column names and types to be used
2063 ** by the new table.
danielk1977c00da102006-01-07 13:21:04 +00002064 **
2065 ** A shared-cache write-lock is not required to write to the new table,
2066 ** as a schema-lock must have already been obtained to create it. Since
2067 ** a schema-lock excludes all other database users, the write-lock would
2068 ** be redundant.
danielk1977517eb642004-06-07 10:00:31 +00002069 */
2070 if( pSelect ){
drh92632202015-05-20 17:18:29 +00002071 SelectDest dest; /* Where the SELECT should store results */
drh9df25c42015-05-20 15:51:09 +00002072 int regYield; /* Register holding co-routine entry-point */
2073 int addrTop; /* Top of the co-routine */
drh92632202015-05-20 17:18:29 +00002074 int regRec; /* A record to be insert into the new table */
2075 int regRowid; /* Rowid of the next row to insert */
2076 int addrInsLoop; /* Top of the loop for inserting rows */
2077 Table *pSelTab; /* A table that describes the SELECT results */
drh1013c932008-01-06 00:25:21 +00002078
drh9df25c42015-05-20 15:51:09 +00002079 regYield = ++pParse->nMem;
drh92632202015-05-20 17:18:29 +00002080 regRec = ++pParse->nMem;
2081 regRowid = ++pParse->nMem;
danielk19776ab3a2e2009-02-19 14:39:25 +00002082 assert(pParse->nTab==1);
drh0dd5cda2015-06-16 16:39:01 +00002083 sqlite3MayAbort(pParse);
drhb7654112008-01-12 12:48:07 +00002084 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
dan428c2182012-08-06 18:50:11 +00002085 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
danielk1977517eb642004-06-07 10:00:31 +00002086 pParse->nTab = 2;
drh9df25c42015-05-20 15:51:09 +00002087 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
2088 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
drh512795d2017-12-24 18:56:28 +00002089 if( pParse->nErr ) return;
drh92632202015-05-20 17:18:29 +00002090 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
2091 if( pSelTab==0 ) return;
2092 assert( p->aCol==0 );
2093 p->nCol = pSelTab->nCol;
2094 p->aCol = pSelTab->aCol;
2095 pSelTab->nCol = 0;
2096 pSelTab->aCol = 0;
2097 sqlite3DeleteTable(db, pSelTab);
drh755b0fd2017-12-23 12:33:40 +00002098 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
2099 sqlite3Select(pParse, pSelect, &dest);
drh5060a672017-12-25 13:43:54 +00002100 if( pParse->nErr ) return;
drh755b0fd2017-12-23 12:33:40 +00002101 sqlite3VdbeEndCoroutine(v, regYield);
2102 sqlite3VdbeJumpHere(v, addrTop - 1);
drh92632202015-05-20 17:18:29 +00002103 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
2104 VdbeCoverage(v);
2105 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
2106 sqlite3TableAffinity(v, p, 0);
2107 sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
2108 sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
drh076e85f2015-09-03 13:46:12 +00002109 sqlite3VdbeGoto(v, addrInsLoop);
drh92632202015-05-20 17:18:29 +00002110 sqlite3VdbeJumpHere(v, addrInsLoop);
2111 sqlite3VdbeAddOp1(v, OP_Close, 1);
danielk1977517eb642004-06-07 10:00:31 +00002112 }
drh4794f732004-11-05 17:17:50 +00002113
drh4794f732004-11-05 17:17:50 +00002114 /* Compute the complete text of the CREATE statement */
2115 if( pSelect ){
drh1d34fde2009-02-03 15:50:33 +00002116 zStmt = createTableStmt(db, p);
drh4794f732004-11-05 17:17:50 +00002117 }else{
drh8ea30bf2013-10-22 01:18:17 +00002118 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
2119 n = (int)(pEnd2->z - pParse->sNameToken.z);
2120 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
danielk19771e536952007-08-16 10:09:01 +00002121 zStmt = sqlite3MPrintf(db,
2122 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
2123 );
drh4794f732004-11-05 17:17:50 +00002124 }
2125
2126 /* A slot for the record has already been allocated in the
2127 ** SQLITE_MASTER table. We just need to update that slot with all
drh0fa991b2009-03-21 16:19:26 +00002128 ** the information we've collected.
drh4794f732004-11-05 17:17:50 +00002129 */
2130 sqlite3NestedParse(pParse,
2131 "UPDATE %Q.%s "
drhb7654112008-01-12 12:48:07 +00002132 "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
2133 "WHERE rowid=#%d",
drhe0a04a32016-12-16 01:00:21 +00002134 db->aDb[iDb].zDbSName, MASTER_NAME,
drh4794f732004-11-05 17:17:50 +00002135 zType,
2136 p->zName,
2137 p->zName,
drhb7654112008-01-12 12:48:07 +00002138 pParse->regRoot,
2139 zStmt,
2140 pParse->regRowid
drh4794f732004-11-05 17:17:50 +00002141 );
drh633e6d52008-07-28 19:34:53 +00002142 sqlite3DbFree(db, zStmt);
drh9cbf3422008-01-17 16:22:13 +00002143 sqlite3ChangeCookie(pParse, iDb);
drh2958a4e2004-11-12 03:56:15 +00002144
2145#ifndef SQLITE_OMIT_AUTOINCREMENT
2146 /* Check to see if we need to create an sqlite_sequence table for
2147 ** keeping track of autoincrement keys.
2148 */
drh9ef5e772016-08-19 14:20:56 +00002149 if( (p->tabFlags & TF_Autoincrement)!=0 ){
danielk1977da184232006-01-05 11:34:32 +00002150 Db *pDb = &db->aDb[iDb];
drh21206082011-04-04 18:22:02 +00002151 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danielk1977da184232006-01-05 11:34:32 +00002152 if( pDb->pSchema->pSeqTab==0 ){
drh2958a4e2004-11-12 03:56:15 +00002153 sqlite3NestedParse(pParse,
drhf3388142004-11-13 03:48:06 +00002154 "CREATE TABLE %Q.sqlite_sequence(name,seq)",
drh69c33822016-08-18 14:33:11 +00002155 pDb->zDbSName
drh2958a4e2004-11-12 03:56:15 +00002156 );
2157 }
2158 }
2159#endif
drh4794f732004-11-05 17:17:50 +00002160
2161 /* Reparse everything to update our internal data structures */
drh5d9c9da2011-06-03 20:11:17 +00002162 sqlite3VdbeAddParseSchemaOp(v, iDb,
dan197bc202013-10-19 15:07:49 +00002163 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
drh75897232000-05-29 14:26:00 +00002164 }
drh17e9e292003-02-01 13:53:28 +00002165
drh2958a4e2004-11-12 03:56:15 +00002166
drh17e9e292003-02-01 13:53:28 +00002167 /* Add the table to the in-memory representation of the database.
2168 */
drh8af73d42009-05-13 22:58:28 +00002169 if( db->init.busy ){
drh17e9e292003-02-01 13:53:28 +00002170 Table *pOld;
danielk1977e501b892006-01-09 06:29:47 +00002171 Schema *pSchema = p->pSchema;
drh21206082011-04-04 18:22:02 +00002172 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drhacbcb7e2014-08-21 20:26:37 +00002173 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
drh17e9e292003-02-01 13:53:28 +00002174 if( pOld ){
2175 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
drh4a642b62016-02-05 01:55:27 +00002176 sqlite3OomFault(db);
drh5969da42013-10-21 02:14:45 +00002177 return;
drh17e9e292003-02-01 13:53:28 +00002178 }
drh17e9e292003-02-01 13:53:28 +00002179 pParse->pNewTable = 0;
drh8257aa82017-07-26 19:59:13 +00002180 db->mDbFlags |= DBFLAG_SchemaChange;
danielk197719a8e7e2005-03-17 05:03:38 +00002181
2182#ifndef SQLITE_OMIT_ALTERTABLE
2183 if( !p->pSelect ){
danielk1977bab45c62006-01-16 15:14:27 +00002184 const char *zName = (const char *)pParse->sNameToken.z;
drh9a087a92007-05-15 14:34:32 +00002185 int nName;
drh5969da42013-10-21 02:14:45 +00002186 assert( !pSelect && pCons && pEnd );
danielk1977bab45c62006-01-16 15:14:27 +00002187 if( pCons->z==0 ){
drh5969da42013-10-21 02:14:45 +00002188 pCons = pEnd;
danielk1977bab45c62006-01-16 15:14:27 +00002189 }
drh1bd10f82008-12-10 21:19:56 +00002190 nName = (int)((const char *)pCons->z - zName);
drh9a087a92007-05-15 14:34:32 +00002191 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
danielk197719a8e7e2005-03-17 05:03:38 +00002192 }
2193#endif
drh17e9e292003-02-01 13:53:28 +00002194 }
drh75897232000-05-29 14:26:00 +00002195}
2196
drhb7f91642004-10-31 02:22:47 +00002197#ifndef SQLITE_OMIT_VIEW
drh75897232000-05-29 14:26:00 +00002198/*
drha76b5df2002-02-23 02:32:10 +00002199** The parser calls this routine in order to create a new VIEW
2200*/
danielk19774adee202004-05-08 08:23:19 +00002201void sqlite3CreateView(
drha76b5df2002-02-23 02:32:10 +00002202 Parse *pParse, /* The parsing context */
2203 Token *pBegin, /* The CREATE token that begins the statement */
danielk197748dec7e2004-05-28 12:33:30 +00002204 Token *pName1, /* The token that holds the name of the view */
2205 Token *pName2, /* The token that holds the name of the view */
drh8981b902015-08-24 17:42:49 +00002206 ExprList *pCNames, /* Optional list of view column names */
drh6276c1c2002-07-08 22:03:32 +00002207 Select *pSelect, /* A SELECT statement that will become the new view */
drhfdd48a72006-09-11 23:45:48 +00002208 int isTemp, /* TRUE for a TEMPORARY view */
2209 int noErr /* Suppress error messages if VIEW already exists */
drha76b5df2002-02-23 02:32:10 +00002210){
drha76b5df2002-02-23 02:32:10 +00002211 Table *p;
drh4b59ab52002-08-24 18:24:51 +00002212 int n;
drhb7916a72009-05-27 10:31:29 +00002213 const char *z;
drh4b59ab52002-08-24 18:24:51 +00002214 Token sEnd;
drhf26e09c2003-05-31 16:21:12 +00002215 DbFixer sFix;
drh88caeac2011-08-24 15:12:08 +00002216 Token *pName = 0;
danielk1977da184232006-01-05 11:34:32 +00002217 int iDb;
drh17435752007-08-16 04:30:38 +00002218 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +00002219
drh7c3d64f2005-06-06 15:32:08 +00002220 if( pParse->nVar>0 ){
2221 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
drh32498f12015-09-26 11:15:44 +00002222 goto create_view_fail;
drh7c3d64f2005-06-06 15:32:08 +00002223 }
drhfdd48a72006-09-11 23:45:48 +00002224 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
drha76b5df2002-02-23 02:32:10 +00002225 p = pParse->pNewTable;
drh8981b902015-08-24 17:42:49 +00002226 if( p==0 || pParse->nErr ) goto create_view_fail;
danielk1977ef2cb632004-05-29 02:37:19 +00002227 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
drh17435752007-08-16 04:30:38 +00002228 iDb = sqlite3SchemaToIndex(db, p->pSchema);
drhd100f692013-10-03 15:39:44 +00002229 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
drh8981b902015-08-24 17:42:49 +00002230 if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
drh174b6192002-12-03 02:22:52 +00002231
drh4b59ab52002-08-24 18:24:51 +00002232 /* Make a copy of the entire SELECT statement that defines the view.
2233 ** This will force all the Expr.token.z values to be dynamically
2234 ** allocated rather than point to the input string - which means that
danielk197724b03fd2004-05-10 10:34:34 +00002235 ** they will persist after the current sqlite3_exec() call returns.
drh4b59ab52002-08-24 18:24:51 +00002236 */
danc9461ec2018-08-29 21:00:16 +00002237 if( IN_RENAME_OBJECT ){
dan987db762018-08-14 20:18:50 +00002238 p->pSelect = pSelect;
2239 pSelect = 0;
2240 }else{
2241 p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
2242 }
drh8981b902015-08-24 17:42:49 +00002243 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
2244 if( db->mallocFailed ) goto create_view_fail;
drh4b59ab52002-08-24 18:24:51 +00002245
2246 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
2247 ** the end.
2248 */
drha76b5df2002-02-23 02:32:10 +00002249 sEnd = pParse->sLastToken;
drh6116ee42018-01-10 00:40:06 +00002250 assert( sEnd.z[0]!=0 || sEnd.n==0 );
drh8981b902015-08-24 17:42:49 +00002251 if( sEnd.z[0]!=';' ){
drha76b5df2002-02-23 02:32:10 +00002252 sEnd.z += sEnd.n;
2253 }
2254 sEnd.n = 0;
drh1bd10f82008-12-10 21:19:56 +00002255 n = (int)(sEnd.z - pBegin->z);
drh8981b902015-08-24 17:42:49 +00002256 assert( n>0 );
drhb7916a72009-05-27 10:31:29 +00002257 z = pBegin->z;
drh8981b902015-08-24 17:42:49 +00002258 while( sqlite3Isspace(z[n-1]) ){ n--; }
drh4ff6dfa2002-03-03 23:06:00 +00002259 sEnd.z = &z[n-1];
2260 sEnd.n = 1;
drh4b59ab52002-08-24 18:24:51 +00002261
danielk19774adee202004-05-08 08:23:19 +00002262 /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
drh5969da42013-10-21 02:14:45 +00002263 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
drh8981b902015-08-24 17:42:49 +00002264
2265create_view_fail:
2266 sqlite3SelectDelete(db, pSelect);
dane8ab40d2018-09-12 08:51:48 +00002267 if( IN_RENAME_OBJECT ){
2268 sqlite3RenameExprlistUnmap(pParse, pCNames);
2269 }
drh8981b902015-08-24 17:42:49 +00002270 sqlite3ExprListDelete(db, pCNames);
drha76b5df2002-02-23 02:32:10 +00002271 return;
drh417be792002-03-03 18:59:40 +00002272}
drhb7f91642004-10-31 02:22:47 +00002273#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00002274
danielk1977fe3fcbe22006-06-12 12:08:45 +00002275#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
drh417be792002-03-03 18:59:40 +00002276/*
2277** The Table structure pTable is really a VIEW. Fill in the names of
2278** the columns of the view in the pTable structure. Return the number
jplyoncfa56842004-01-19 04:55:56 +00002279** of errors. If an error is seen leave an error message in pParse->zErrMsg.
drh417be792002-03-03 18:59:40 +00002280*/
danielk19774adee202004-05-08 08:23:19 +00002281int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
drh9b3187e2005-01-18 14:45:47 +00002282 Table *pSelTab; /* A fake table from which we get the result set */
2283 Select *pSel; /* Copy of the SELECT that implements the view */
2284 int nErr = 0; /* Number of errors encountered */
2285 int n; /* Temporarily holds the number of cursors assigned */
drh17435752007-08-16 04:30:38 +00002286 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
drh424981d2018-03-28 15:56:55 +00002287#ifndef SQLITE_OMIT_VIRTUALTABLE
drhdc6b41e2017-08-17 02:26:35 +00002288 int rc;
2289#endif
drha0daa752016-09-16 11:53:10 +00002290#ifndef SQLITE_OMIT_AUTHORIZATION
drh32c6a482014-09-11 13:44:52 +00002291 sqlite3_xauth xAuth; /* Saved xAuth pointer */
drha0daa752016-09-16 11:53:10 +00002292#endif
drh417be792002-03-03 18:59:40 +00002293
2294 assert( pTable );
2295
danielk1977fe3fcbe22006-06-12 12:08:45 +00002296#ifndef SQLITE_OMIT_VIRTUALTABLE
drhdc6b41e2017-08-17 02:26:35 +00002297 db->nSchemaLock++;
2298 rc = sqlite3VtabCallConnect(pParse, pTable);
2299 db->nSchemaLock--;
2300 if( rc ){
drhefaffb62017-08-17 18:23:46 +00002301 return 1;
danielk1977fe3fcbe22006-06-12 12:08:45 +00002302 }
drh4cbdda92006-06-14 19:00:20 +00002303 if( IsVirtual(pTable) ) return 0;
danielk1977fe3fcbe22006-06-12 12:08:45 +00002304#endif
2305
2306#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00002307 /* A positive nCol means the columns names for this view are
2308 ** already known.
2309 */
2310 if( pTable->nCol>0 ) return 0;
2311
2312 /* A negative nCol is a special marker meaning that we are currently
2313 ** trying to compute the column names. If we enter this routine with
2314 ** a negative nCol, it means two or more views form a loop, like this:
2315 **
2316 ** CREATE VIEW one AS SELECT * FROM two;
2317 ** CREATE VIEW two AS SELECT * FROM one;
drh3b167c72002-06-28 12:18:47 +00002318 **
drh768578e2009-05-12 00:40:12 +00002319 ** Actually, the error above is now caught prior to reaching this point.
2320 ** But the following test is still important as it does come up
2321 ** in the following:
2322 **
2323 ** CREATE TABLE main.ex1(a);
2324 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
2325 ** SELECT * FROM temp.ex1;
drh417be792002-03-03 18:59:40 +00002326 */
2327 if( pTable->nCol<0 ){
danielk19774adee202004-05-08 08:23:19 +00002328 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
drh417be792002-03-03 18:59:40 +00002329 return 1;
2330 }
drh85c23c62005-08-20 03:03:04 +00002331 assert( pTable->nCol>=0 );
drh417be792002-03-03 18:59:40 +00002332
2333 /* If we get this far, it means we need to compute the table names.
drh9b3187e2005-01-18 14:45:47 +00002334 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
2335 ** "*" elements in the results set of the view and will assign cursors
2336 ** to the elements of the FROM clause. But we do not want these changes
2337 ** to be permanent. So the computation is done on a copy of the SELECT
2338 ** statement that defines the view.
drh417be792002-03-03 18:59:40 +00002339 */
drh9b3187e2005-01-18 14:45:47 +00002340 assert( pTable->pSelect );
drhed06a132016-04-05 20:59:12 +00002341 pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
2342 if( pSel ){
dan02083372018-09-17 08:27:23 +00002343#ifndef SQLITE_OMIT_ALTERTABLE
2344 u8 eParseMode = pParse->eParseMode;
2345 pParse->eParseMode = PARSE_MODE_NORMAL;
2346#endif
drhed06a132016-04-05 20:59:12 +00002347 n = pParse->nTab;
2348 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
2349 pTable->nCol = -1;
drh4a642b62016-02-05 01:55:27 +00002350 db->lookaside.bDisable++;
danielk1977db2d2862007-10-15 07:08:44 +00002351#ifndef SQLITE_OMIT_AUTHORIZATION
drhed06a132016-04-05 20:59:12 +00002352 xAuth = db->xAuth;
2353 db->xAuth = 0;
2354 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
2355 db->xAuth = xAuth;
danielk1977db2d2862007-10-15 07:08:44 +00002356#else
drhed06a132016-04-05 20:59:12 +00002357 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
danielk1977db2d2862007-10-15 07:08:44 +00002358#endif
drhed06a132016-04-05 20:59:12 +00002359 pParse->nTab = n;
2360 if( pTable->pCheck ){
2361 /* CREATE VIEW name(arglist) AS ...
2362 ** The names of the columns in the table are taken from
2363 ** arglist which is stored in pTable->pCheck. The pCheck field
2364 ** normally holds CHECK constraints on an ordinary table, but for
2365 ** a VIEW it holds the list of column names.
2366 */
2367 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
2368 &pTable->nCol, &pTable->aCol);
2369 if( db->mallocFailed==0
2370 && pParse->nErr==0
2371 && pTable->nCol==pSel->pEList->nExpr
2372 ){
2373 sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel);
drh8981b902015-08-24 17:42:49 +00002374 }
drhed06a132016-04-05 20:59:12 +00002375 }else if( pSelTab ){
2376 /* CREATE VIEW name AS... without an argument list. Construct
2377 ** the column names from the SELECT statement that defines the view.
2378 */
2379 assert( pTable->aCol==0 );
2380 pTable->nCol = pSelTab->nCol;
2381 pTable->aCol = pSelTab->aCol;
2382 pSelTab->nCol = 0;
2383 pSelTab->aCol = 0;
2384 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
2385 }else{
2386 pTable->nCol = 0;
danielk1977261919c2005-12-06 12:52:59 +00002387 nErr++;
2388 }
drhe8da01c2016-05-07 12:15:34 +00002389 sqlite3DeleteTable(db, pSelTab);
drhed06a132016-04-05 20:59:12 +00002390 sqlite3SelectDelete(db, pSel);
2391 db->lookaside.bDisable--;
dan02083372018-09-17 08:27:23 +00002392#ifndef SQLITE_OMIT_ALTERTABLE
2393 pParse->eParseMode = eParseMode;
2394#endif
drhed06a132016-04-05 20:59:12 +00002395 } else {
2396 nErr++;
drh417be792002-03-03 18:59:40 +00002397 }
drh8981b902015-08-24 17:42:49 +00002398 pTable->pSchema->schemaFlags |= DB_UnresetViews;
dan77f3f402018-07-09 18:55:44 +00002399 if( db->mallocFailed ){
2400 sqlite3DeleteColumnNames(db, pTable);
2401 pTable->aCol = 0;
2402 pTable->nCol = 0;
2403 }
drhb7f91642004-10-31 02:22:47 +00002404#endif /* SQLITE_OMIT_VIEW */
danielk19774b2688a2006-06-20 11:01:07 +00002405 return nErr;
danielk1977fe3fcbe22006-06-12 12:08:45 +00002406}
2407#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
drh417be792002-03-03 18:59:40 +00002408
drhb7f91642004-10-31 02:22:47 +00002409#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00002410/*
drh8bf8dc92003-05-17 17:35:10 +00002411** Clear the column names from every VIEW in database idx.
drh417be792002-03-03 18:59:40 +00002412*/
drh9bb575f2004-09-06 17:24:11 +00002413static void sqliteViewResetAll(sqlite3 *db, int idx){
drh417be792002-03-03 18:59:40 +00002414 HashElem *i;
drh21206082011-04-04 18:22:02 +00002415 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
drh8bf8dc92003-05-17 17:35:10 +00002416 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
danielk1977da184232006-01-05 11:34:32 +00002417 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
drh417be792002-03-03 18:59:40 +00002418 Table *pTab = sqliteHashData(i);
2419 if( pTab->pSelect ){
drh51be3872015-08-19 02:32:25 +00002420 sqlite3DeleteColumnNames(db, pTab);
dand46def72010-07-24 11:28:28 +00002421 pTab->aCol = 0;
2422 pTab->nCol = 0;
drh417be792002-03-03 18:59:40 +00002423 }
2424 }
drh8bf8dc92003-05-17 17:35:10 +00002425 DbClearProperty(db, idx, DB_UnresetViews);
drha76b5df2002-02-23 02:32:10 +00002426}
drhb7f91642004-10-31 02:22:47 +00002427#else
2428# define sqliteViewResetAll(A,B)
2429#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00002430
drh75897232000-05-29 14:26:00 +00002431/*
danielk1977a0bf2652004-11-04 14:30:04 +00002432** This function is called by the VDBE to adjust the internal schema
2433** used by SQLite when the btree layer moves a table root page. The
2434** root-page of a table or index in database iDb has changed from iFrom
2435** to iTo.
drh6205d4a2006-03-24 03:36:26 +00002436**
2437** Ticket #1728: The symbol table might still contain information
2438** on tables and/or indices that are the process of being deleted.
2439** If you are unlucky, one of those deleted indices or tables might
2440** have the same rootpage number as the real table or index that is
2441** being moved. So we cannot stop searching after the first match
2442** because the first match might be for one of the deleted indices
2443** or tables and not the table/index that is actually being moved.
2444** We must continue looping until all tables and indices with
2445** rootpage==iFrom have been converted to have a rootpage of iTo
2446** in order to be certain that we got the right one.
danielk1977a0bf2652004-11-04 14:30:04 +00002447*/
2448#ifndef SQLITE_OMIT_AUTOVACUUM
drhcdf011d2011-04-04 21:25:28 +00002449void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
danielk1977a0bf2652004-11-04 14:30:04 +00002450 HashElem *pElem;
danielk1977da184232006-01-05 11:34:32 +00002451 Hash *pHash;
drhcdf011d2011-04-04 21:25:28 +00002452 Db *pDb;
danielk1977da184232006-01-05 11:34:32 +00002453
drhcdf011d2011-04-04 21:25:28 +00002454 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2455 pDb = &db->aDb[iDb];
danielk1977da184232006-01-05 11:34:32 +00002456 pHash = &pDb->pSchema->tblHash;
2457 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00002458 Table *pTab = sqliteHashData(pElem);
2459 if( pTab->tnum==iFrom ){
2460 pTab->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00002461 }
2462 }
danielk1977da184232006-01-05 11:34:32 +00002463 pHash = &pDb->pSchema->idxHash;
2464 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00002465 Index *pIdx = sqliteHashData(pElem);
2466 if( pIdx->tnum==iFrom ){
2467 pIdx->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00002468 }
2469 }
danielk1977a0bf2652004-11-04 14:30:04 +00002470}
2471#endif
2472
2473/*
2474** Write code to erase the table with root-page iTable from database iDb.
2475** Also write code to modify the sqlite_master table and internal schema
2476** if a root-page of another table is moved by the btree-layer whilst
2477** erasing iTable (this can happen with an auto-vacuum database).
2478*/
drh4e0cff62004-11-05 05:10:28 +00002479static void destroyRootPage(Parse *pParse, int iTable, int iDb){
2480 Vdbe *v = sqlite3GetVdbe(pParse);
drhb7654112008-01-12 12:48:07 +00002481 int r1 = sqlite3GetTempReg(pParse);
drhf4452cf2018-10-29 21:01:28 +00002482 if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
drhb7654112008-01-12 12:48:07 +00002483 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
dane0af83a2009-09-08 19:15:01 +00002484 sqlite3MayAbort(pParse);
drh40e016e2004-11-04 14:47:11 +00002485#ifndef SQLITE_OMIT_AUTOVACUUM
drhb7654112008-01-12 12:48:07 +00002486 /* OP_Destroy stores an in integer r1. If this integer
drh4e0cff62004-11-05 05:10:28 +00002487 ** is non-zero, then it is the root page number of a table moved to
drh81db88e2004-12-07 12:29:17 +00002488 ** location iTable. The following code modifies the sqlite_master table to
drh4e0cff62004-11-05 05:10:28 +00002489 ** reflect this.
2490 **
drh0fa991b2009-03-21 16:19:26 +00002491 ** The "#NNN" in the SQL is a special constant that means whatever value
drhb74b1012009-05-28 21:04:37 +00002492 ** is in register NNN. See grammar rules associated with the TK_REGISTER
2493 ** token for additional information.
drh4e0cff62004-11-05 05:10:28 +00002494 */
danielk197763e3e9f2004-11-05 09:19:27 +00002495 sqlite3NestedParse(pParse,
drhb7654112008-01-12 12:48:07 +00002496 "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
drhe0a04a32016-12-16 01:00:21 +00002497 pParse->db->aDb[iDb].zDbSName, MASTER_NAME, iTable, r1, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00002498#endif
drhb7654112008-01-12 12:48:07 +00002499 sqlite3ReleaseTempReg(pParse, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00002500}
2501
2502/*
2503** Write VDBE code to erase table pTab and all associated indices on disk.
2504** Code to update the sqlite_master tables and internal schema definitions
2505** in case a root-page belonging to another table is moved by the btree layer
2506** is also added (this can happen with an auto-vacuum database).
2507*/
drh4e0cff62004-11-05 05:10:28 +00002508static void destroyTable(Parse *pParse, Table *pTab){
danielk1977a0bf2652004-11-04 14:30:04 +00002509 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
2510 ** is not defined), then it is important to call OP_Destroy on the
2511 ** table and index root-pages in order, starting with the numerically
2512 ** largest root-page number. This guarantees that none of the root-pages
2513 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
2514 ** following were coded:
2515 **
2516 ** OP_Destroy 4 0
2517 ** ...
2518 ** OP_Destroy 5 0
2519 **
2520 ** and root page 5 happened to be the largest root-page number in the
2521 ** database, then root page 5 would be moved to page 4 by the
2522 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
2523 ** a free-list page.
2524 */
2525 int iTab = pTab->tnum;
2526 int iDestroyed = 0;
2527
2528 while( 1 ){
2529 Index *pIdx;
2530 int iLargest = 0;
2531
2532 if( iDestroyed==0 || iTab<iDestroyed ){
2533 iLargest = iTab;
2534 }
2535 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2536 int iIdx = pIdx->tnum;
danielk1977da184232006-01-05 11:34:32 +00002537 assert( pIdx->pSchema==pTab->pSchema );
danielk1977a0bf2652004-11-04 14:30:04 +00002538 if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
2539 iLargest = iIdx;
2540 }
2541 }
danielk1977da184232006-01-05 11:34:32 +00002542 if( iLargest==0 ){
2543 return;
2544 }else{
2545 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drh5a05be12012-10-09 18:51:44 +00002546 assert( iDb>=0 && iDb<pParse->db->nDb );
danielk1977da184232006-01-05 11:34:32 +00002547 destroyRootPage(pParse, iLargest, iDb);
2548 iDestroyed = iLargest;
2549 }
danielk1977a0bf2652004-11-04 14:30:04 +00002550 }
danielk1977a0bf2652004-11-04 14:30:04 +00002551}
2552
2553/*
drh74e7c8f2011-10-21 19:06:32 +00002554** Remove entries from the sqlite_statN tables (for N in (1,2,3))
drha5ae4c32011-08-07 01:31:52 +00002555** after a DROP INDEX or DROP TABLE command.
2556*/
2557static void sqlite3ClearStatTables(
2558 Parse *pParse, /* The parsing context */
2559 int iDb, /* The database number */
2560 const char *zType, /* "idx" or "tbl" */
2561 const char *zName /* Name of index or table */
2562){
drha5ae4c32011-08-07 01:31:52 +00002563 int i;
drh69c33822016-08-18 14:33:11 +00002564 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
danf52bb8d2013-08-03 20:24:58 +00002565 for(i=1; i<=4; i++){
drh74e7c8f2011-10-21 19:06:32 +00002566 char zTab[24];
2567 sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
2568 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
drha5ae4c32011-08-07 01:31:52 +00002569 sqlite3NestedParse(pParse,
2570 "DELETE FROM %Q.%s WHERE %s=%Q",
drh74e7c8f2011-10-21 19:06:32 +00002571 zDbName, zTab, zType, zName
drha5ae4c32011-08-07 01:31:52 +00002572 );
2573 }
2574 }
2575}
2576
2577/*
drhfaacf172011-08-12 01:51:45 +00002578** Generate code to drop a table.
2579*/
2580void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
2581 Vdbe *v;
2582 sqlite3 *db = pParse->db;
2583 Trigger *pTrigger;
2584 Db *pDb = &db->aDb[iDb];
2585
2586 v = sqlite3GetVdbe(pParse);
2587 assert( v!=0 );
2588 sqlite3BeginWriteOperation(pParse, 1, iDb);
2589
2590#ifndef SQLITE_OMIT_VIRTUALTABLE
2591 if( IsVirtual(pTab) ){
2592 sqlite3VdbeAddOp0(v, OP_VBegin);
2593 }
2594#endif
2595
2596 /* Drop all triggers associated with the table being dropped. Code
2597 ** is generated to remove entries from sqlite_master and/or
2598 ** sqlite_temp_master if required.
2599 */
2600 pTrigger = sqlite3TriggerList(pParse, pTab);
2601 while( pTrigger ){
2602 assert( pTrigger->pSchema==pTab->pSchema ||
2603 pTrigger->pSchema==db->aDb[1].pSchema );
2604 sqlite3DropTriggerPtr(pParse, pTrigger);
2605 pTrigger = pTrigger->pNext;
2606 }
2607
2608#ifndef SQLITE_OMIT_AUTOINCREMENT
2609 /* Remove any entries of the sqlite_sequence table associated with
2610 ** the table being dropped. This is done before the table is dropped
2611 ** at the btree level, in case the sqlite_sequence table needs to
2612 ** move as a result of the drop (can happen in auto-vacuum mode).
2613 */
2614 if( pTab->tabFlags & TF_Autoincrement ){
2615 sqlite3NestedParse(pParse,
2616 "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
drh69c33822016-08-18 14:33:11 +00002617 pDb->zDbSName, pTab->zName
drhfaacf172011-08-12 01:51:45 +00002618 );
2619 }
2620#endif
2621
2622 /* Drop all SQLITE_MASTER table and index entries that refer to the
2623 ** table. The program name loops through the master table and deletes
2624 ** every row that refers to a table of the same name as the one being
mistachkin48864df2013-03-21 21:20:32 +00002625 ** dropped. Triggers are handled separately because a trigger can be
drhfaacf172011-08-12 01:51:45 +00002626 ** created in the temp database that refers to a table in another
2627 ** database.
2628 */
2629 sqlite3NestedParse(pParse,
2630 "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
drhe0a04a32016-12-16 01:00:21 +00002631 pDb->zDbSName, MASTER_NAME, pTab->zName);
drhfaacf172011-08-12 01:51:45 +00002632 if( !isView && !IsVirtual(pTab) ){
2633 destroyTable(pParse, pTab);
2634 }
2635
2636 /* Remove the table entry from SQLite's internal schema and modify
2637 ** the schema cookie.
2638 */
2639 if( IsVirtual(pTab) ){
2640 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
2641 }
2642 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
2643 sqlite3ChangeCookie(pParse, iDb);
2644 sqliteViewResetAll(db, iDb);
drhfaacf172011-08-12 01:51:45 +00002645}
2646
2647/*
drh75897232000-05-29 14:26:00 +00002648** This routine is called to do the work of a DROP TABLE statement.
drhd9b02572001-04-15 00:37:09 +00002649** pName is the name of the table to be dropped.
drh75897232000-05-29 14:26:00 +00002650*/
drha0733842005-12-29 01:11:36 +00002651void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
danielk1977a8858102004-05-28 12:11:21 +00002652 Table *pTab;
drh75897232000-05-29 14:26:00 +00002653 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00002654 sqlite3 *db = pParse->db;
drhd24cc422003-03-27 12:51:24 +00002655 int iDb;
drh75897232000-05-29 14:26:00 +00002656
drh8af73d42009-05-13 22:58:28 +00002657 if( db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +00002658 goto exit_drop_table;
2659 }
drh8af73d42009-05-13 22:58:28 +00002660 assert( pParse->nErr==0 );
danielk1977a8858102004-05-28 12:11:21 +00002661 assert( pName->nSrc==1 );
drh75209962015-04-19 22:31:45 +00002662 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
drha7564662010-02-22 19:32:31 +00002663 if( noErr ) db->suppressErr++;
drh4d249e62016-06-10 22:49:01 +00002664 assert( isView==0 || isView==LOCATE_VIEW );
dan41fb5cd2012-10-04 19:33:00 +00002665 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
drha7564662010-02-22 19:32:31 +00002666 if( noErr ) db->suppressErr--;
danielk1977a8858102004-05-28 12:11:21 +00002667
drha0733842005-12-29 01:11:36 +00002668 if( pTab==0 ){
dan57966752011-04-09 17:32:58 +00002669 if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
drha0733842005-12-29 01:11:36 +00002670 goto exit_drop_table;
2671 }
danielk1977da184232006-01-05 11:34:32 +00002672 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drhe22a3342003-04-22 20:30:37 +00002673 assert( iDb>=0 && iDb<db->nDb );
danielk1977b5258c32007-10-04 18:11:15 +00002674
2675 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
2676 ** it is initialized.
2677 */
2678 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
2679 goto exit_drop_table;
2680 }
drhe5f9c642003-01-13 23:27:31 +00002681#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +00002682 {
2683 int code;
danielk1977da184232006-01-05 11:34:32 +00002684 const char *zTab = SCHEMA_TABLE(iDb);
drh69c33822016-08-18 14:33:11 +00002685 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977f1a381e2006-06-16 08:01:02 +00002686 const char *zArg2 = 0;
danielk19774adee202004-05-08 08:23:19 +00002687 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
danielk1977a8858102004-05-28 12:11:21 +00002688 goto exit_drop_table;
drhe22a3342003-04-22 20:30:37 +00002689 }
drhe5f9c642003-01-13 23:27:31 +00002690 if( isView ){
danielk197753c0f742005-03-29 03:10:59 +00002691 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00002692 code = SQLITE_DROP_TEMP_VIEW;
2693 }else{
2694 code = SQLITE_DROP_VIEW;
2695 }
danielk19774b2688a2006-06-20 11:01:07 +00002696#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977f1a381e2006-06-16 08:01:02 +00002697 }else if( IsVirtual(pTab) ){
2698 code = SQLITE_DROP_VTABLE;
danielk1977595a5232009-07-24 17:58:53 +00002699 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
danielk19774b2688a2006-06-20 11:01:07 +00002700#endif
drhe5f9c642003-01-13 23:27:31 +00002701 }else{
danielk197753c0f742005-03-29 03:10:59 +00002702 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00002703 code = SQLITE_DROP_TEMP_TABLE;
2704 }else{
2705 code = SQLITE_DROP_TABLE;
2706 }
2707 }
danielk1977f1a381e2006-06-16 08:01:02 +00002708 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
danielk1977a8858102004-05-28 12:11:21 +00002709 goto exit_drop_table;
drhe5f9c642003-01-13 23:27:31 +00002710 }
danielk1977a8858102004-05-28 12:11:21 +00002711 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
2712 goto exit_drop_table;
drh77ad4e42003-01-14 02:49:27 +00002713 }
drhe5f9c642003-01-13 23:27:31 +00002714 }
2715#endif
drh08ccfaa2011-10-07 23:52:25 +00002716 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
2717 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
danielk1977a8858102004-05-28 12:11:21 +00002718 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
danielk1977a8858102004-05-28 12:11:21 +00002719 goto exit_drop_table;
drh75897232000-05-29 14:26:00 +00002720 }
danielk1977576ec6b2005-01-21 11:55:25 +00002721
2722#ifndef SQLITE_OMIT_VIEW
2723 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
2724 ** on a table.
2725 */
danielk1977a8858102004-05-28 12:11:21 +00002726 if( isView && pTab->pSelect==0 ){
2727 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
2728 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00002729 }
danielk1977a8858102004-05-28 12:11:21 +00002730 if( !isView && pTab->pSelect ){
2731 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
2732 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00002733 }
danielk1977576ec6b2005-01-21 11:55:25 +00002734#endif
drh75897232000-05-29 14:26:00 +00002735
drh1ccde152000-06-17 13:12:39 +00002736 /* Generate code to remove the table from the master table
2737 ** on disk.
2738 */
danielk19774adee202004-05-08 08:23:19 +00002739 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00002740 if( v ){
drh77658e22007-12-04 16:54:52 +00002741 sqlite3BeginWriteOperation(pParse, 1, iDb);
mistachkin0fc2da32018-07-20 20:56:22 +00002742 if( !isView ){
2743 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
2744 sqlite3FkDropTable(pParse, pName, pTab);
2745 }
drhfaacf172011-08-12 01:51:45 +00002746 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
drh75897232000-05-29 14:26:00 +00002747 }
danielk1977a8858102004-05-28 12:11:21 +00002748
2749exit_drop_table:
drh633e6d52008-07-28 19:34:53 +00002750 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00002751}
2752
2753/*
drhc2eef3b2002-08-31 18:53:06 +00002754** This routine is called to create a new foreign key on the table
2755** currently under construction. pFromCol determines which columns
2756** in the current table point to the foreign key. If pFromCol==0 then
2757** connect the key to the last column inserted. pTo is the name of
drhbd50a922013-11-03 02:27:58 +00002758** the table referred to (a.k.a the "parent" table). pToCol is a list
2759** of tables in the parent pTo table. flags contains all
drhc2eef3b2002-08-31 18:53:06 +00002760** information about the conflict resolution algorithms specified
2761** in the ON DELETE, ON UPDATE and ON INSERT clauses.
2762**
2763** An FKey structure is created and added to the table currently
drhe61922a2009-05-02 13:29:37 +00002764** under construction in the pParse->pNewTable field.
drhc2eef3b2002-08-31 18:53:06 +00002765**
2766** The foreign key is set for IMMEDIATE processing. A subsequent call
danielk19774adee202004-05-08 08:23:19 +00002767** to sqlite3DeferForeignKey() might change this to DEFERRED.
drhc2eef3b2002-08-31 18:53:06 +00002768*/
danielk19774adee202004-05-08 08:23:19 +00002769void sqlite3CreateForeignKey(
drhc2eef3b2002-08-31 18:53:06 +00002770 Parse *pParse, /* Parsing context */
danielk19770202b292004-06-09 09:55:16 +00002771 ExprList *pFromCol, /* Columns in this table that point to other table */
drhc2eef3b2002-08-31 18:53:06 +00002772 Token *pTo, /* Name of the other table */
danielk19770202b292004-06-09 09:55:16 +00002773 ExprList *pToCol, /* Columns in the other table */
drhc2eef3b2002-08-31 18:53:06 +00002774 int flags /* Conflict resolution algorithms. */
2775){
danielk197718576932008-08-06 13:47:40 +00002776 sqlite3 *db = pParse->db;
drhb7f91642004-10-31 02:22:47 +00002777#ifndef SQLITE_OMIT_FOREIGN_KEY
drh40e016e2004-11-04 14:47:11 +00002778 FKey *pFKey = 0;
dan1da40a32009-09-19 17:00:31 +00002779 FKey *pNextTo;
drhc2eef3b2002-08-31 18:53:06 +00002780 Table *p = pParse->pNewTable;
2781 int nByte;
2782 int i;
2783 int nCol;
2784 char *z;
drhc2eef3b2002-08-31 18:53:06 +00002785
2786 assert( pTo!=0 );
drh8af73d42009-05-13 22:58:28 +00002787 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
drhc2eef3b2002-08-31 18:53:06 +00002788 if( pFromCol==0 ){
2789 int iCol = p->nCol-1;
drhd3001712009-05-12 17:46:53 +00002790 if( NEVER(iCol<0) ) goto fk_end;
danielk19770202b292004-06-09 09:55:16 +00002791 if( pToCol && pToCol->nExpr!=1 ){
danielk19774adee202004-05-08 08:23:19 +00002792 sqlite3ErrorMsg(pParse, "foreign key on %s"
drhf7a9e1a2004-02-22 18:40:56 +00002793 " should reference only one column of table %T",
2794 p->aCol[iCol].zName, pTo);
drhc2eef3b2002-08-31 18:53:06 +00002795 goto fk_end;
2796 }
2797 nCol = 1;
danielk19770202b292004-06-09 09:55:16 +00002798 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
danielk19774adee202004-05-08 08:23:19 +00002799 sqlite3ErrorMsg(pParse,
drhc2eef3b2002-08-31 18:53:06 +00002800 "number of columns in foreign key does not match the number of "
drhf7a9e1a2004-02-22 18:40:56 +00002801 "columns in the referenced table");
drhc2eef3b2002-08-31 18:53:06 +00002802 goto fk_end;
2803 }else{
danielk19770202b292004-06-09 09:55:16 +00002804 nCol = pFromCol->nExpr;
drhc2eef3b2002-08-31 18:53:06 +00002805 }
drhe61922a2009-05-02 13:29:37 +00002806 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
drhc2eef3b2002-08-31 18:53:06 +00002807 if( pToCol ){
danielk19770202b292004-06-09 09:55:16 +00002808 for(i=0; i<pToCol->nExpr; i++){
drhea678832008-12-10 19:26:22 +00002809 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
drhc2eef3b2002-08-31 18:53:06 +00002810 }
2811 }
drh633e6d52008-07-28 19:34:53 +00002812 pFKey = sqlite3DbMallocZero(db, nByte );
drh17435752007-08-16 04:30:38 +00002813 if( pFKey==0 ){
2814 goto fk_end;
2815 }
drhc2eef3b2002-08-31 18:53:06 +00002816 pFKey->pFrom = p;
2817 pFKey->pNextFrom = p->pFKey;
drhe61922a2009-05-02 13:29:37 +00002818 z = (char*)&pFKey->aCol[nCol];
drhdf68f6b2002-09-21 15:57:57 +00002819 pFKey->zTo = z;
danc9461ec2018-08-29 21:00:16 +00002820 if( IN_RENAME_OBJECT ){
2821 sqlite3RenameTokenMap(pParse, (void*)z, pTo);
2822 }
drhc2eef3b2002-08-31 18:53:06 +00002823 memcpy(z, pTo->z, pTo->n);
2824 z[pTo->n] = 0;
danielk197770d9e9c2009-04-24 18:06:09 +00002825 sqlite3Dequote(z);
drhc2eef3b2002-08-31 18:53:06 +00002826 z += pTo->n+1;
drhc2eef3b2002-08-31 18:53:06 +00002827 pFKey->nCol = nCol;
drhc2eef3b2002-08-31 18:53:06 +00002828 if( pFromCol==0 ){
2829 pFKey->aCol[0].iFrom = p->nCol-1;
2830 }else{
2831 for(i=0; i<nCol; i++){
2832 int j;
2833 for(j=0; j<p->nCol; j++){
danielk19774adee202004-05-08 08:23:19 +00002834 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
drhc2eef3b2002-08-31 18:53:06 +00002835 pFKey->aCol[i].iFrom = j;
2836 break;
2837 }
2838 }
2839 if( j>=p->nCol ){
danielk19774adee202004-05-08 08:23:19 +00002840 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00002841 "unknown column \"%s\" in foreign key definition",
2842 pFromCol->a[i].zName);
drhc2eef3b2002-08-31 18:53:06 +00002843 goto fk_end;
2844 }
danc9461ec2018-08-29 21:00:16 +00002845 if( IN_RENAME_OBJECT ){
dan07e95232018-08-21 16:32:53 +00002846 sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zName);
dancf8f2892018-08-09 20:47:01 +00002847 }
drhc2eef3b2002-08-31 18:53:06 +00002848 }
2849 }
2850 if( pToCol ){
2851 for(i=0; i<nCol; i++){
drhea678832008-12-10 19:26:22 +00002852 int n = sqlite3Strlen30(pToCol->a[i].zName);
drhc2eef3b2002-08-31 18:53:06 +00002853 pFKey->aCol[i].zCol = z;
danc9461ec2018-08-29 21:00:16 +00002854 if( IN_RENAME_OBJECT ){
dan07e95232018-08-21 16:32:53 +00002855 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zName);
dan6fe7f232018-08-10 19:19:33 +00002856 }
drhc2eef3b2002-08-31 18:53:06 +00002857 memcpy(z, pToCol->a[i].zName, n);
2858 z[n] = 0;
2859 z += n+1;
2860 }
2861 }
2862 pFKey->isDeferred = 0;
dan8099ce62009-09-23 08:43:35 +00002863 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
2864 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
drhc2eef3b2002-08-31 18:53:06 +00002865
drh21206082011-04-04 18:22:02 +00002866 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
dan1da40a32009-09-19 17:00:31 +00002867 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
drhacbcb7e2014-08-21 20:26:37 +00002868 pFKey->zTo, (void *)pFKey
dan1da40a32009-09-19 17:00:31 +00002869 );
danf59c5ca2009-09-22 16:55:38 +00002870 if( pNextTo==pFKey ){
drh4a642b62016-02-05 01:55:27 +00002871 sqlite3OomFault(db);
danf59c5ca2009-09-22 16:55:38 +00002872 goto fk_end;
2873 }
dan1da40a32009-09-19 17:00:31 +00002874 if( pNextTo ){
2875 assert( pNextTo->pPrevTo==0 );
2876 pFKey->pNextTo = pNextTo;
2877 pNextTo->pPrevTo = pFKey;
2878 }
2879
drhc2eef3b2002-08-31 18:53:06 +00002880 /* Link the foreign key to the table as the last step.
2881 */
2882 p->pFKey = pFKey;
2883 pFKey = 0;
2884
2885fk_end:
drh633e6d52008-07-28 19:34:53 +00002886 sqlite3DbFree(db, pFKey);
drhb7f91642004-10-31 02:22:47 +00002887#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
drh633e6d52008-07-28 19:34:53 +00002888 sqlite3ExprListDelete(db, pFromCol);
2889 sqlite3ExprListDelete(db, pToCol);
drhc2eef3b2002-08-31 18:53:06 +00002890}
2891
2892/*
2893** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
2894** clause is seen as part of a foreign key definition. The isDeferred
2895** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
2896** The behavior of the most recently created foreign key is adjusted
2897** accordingly.
2898*/
danielk19774adee202004-05-08 08:23:19 +00002899void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
drhb7f91642004-10-31 02:22:47 +00002900#ifndef SQLITE_OMIT_FOREIGN_KEY
drhc2eef3b2002-08-31 18:53:06 +00002901 Table *pTab;
2902 FKey *pFKey;
2903 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
drh4c429832009-10-12 22:30:49 +00002904 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
drh1bd10f82008-12-10 21:19:56 +00002905 pFKey->isDeferred = (u8)isDeferred;
drhb7f91642004-10-31 02:22:47 +00002906#endif
drhc2eef3b2002-08-31 18:53:06 +00002907}
2908
2909/*
drh063336a2004-11-05 20:58:39 +00002910** Generate code that will erase and refill index *pIdx. This is
2911** used to initialize a newly created index or to recompute the
2912** content of an index in response to a REINDEX command.
2913**
2914** if memRootPage is not negative, it means that the index is newly
drh1db639c2008-01-17 02:36:28 +00002915** created. The register specified by memRootPage contains the
drh063336a2004-11-05 20:58:39 +00002916** root page number of the index. If memRootPage is negative, then
2917** the index already exists and must be cleared before being refilled and
2918** the root page number of the index is taken from pIndex->tnum.
2919*/
2920static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
2921 Table *pTab = pIndex->pTable; /* The table that is indexed */
danielk19776ab3a2e2009-02-19 14:39:25 +00002922 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
2923 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
drhb07028f2011-10-14 21:49:18 +00002924 int iSorter; /* Cursor opened by OpenSorter (if in use) */
drh063336a2004-11-05 20:58:39 +00002925 int addr1; /* Address of top of loop */
dan5134d132011-09-02 10:31:11 +00002926 int addr2; /* Address to jump to for next iteration */
drh063336a2004-11-05 20:58:39 +00002927 int tnum; /* Root page of index */
drhb2b9d3d2013-08-01 01:14:43 +00002928 int iPartIdxLabel; /* Jump to this label to skip a row */
drh063336a2004-11-05 20:58:39 +00002929 Vdbe *v; /* Generate code into this virtual machine */
danielk1977b3bf5562006-01-10 17:58:23 +00002930 KeyInfo *pKey; /* KeyInfo for index */
peter.d.reid60ec9142014-09-06 16:39:46 +00002931 int regRecord; /* Register holding assembled index record */
drh17435752007-08-16 04:30:38 +00002932 sqlite3 *db = pParse->db; /* The database connection */
2933 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drh063336a2004-11-05 20:58:39 +00002934
danielk19771d54df82004-11-23 15:41:16 +00002935#ifndef SQLITE_OMIT_AUTHORIZATION
2936 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
drh69c33822016-08-18 14:33:11 +00002937 db->aDb[iDb].zDbSName ) ){
danielk19771d54df82004-11-23 15:41:16 +00002938 return;
2939 }
2940#endif
2941
danielk1977c00da102006-01-07 13:21:04 +00002942 /* Require a write-lock on the table to perform this operation */
2943 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
2944
drh063336a2004-11-05 20:58:39 +00002945 v = sqlite3GetVdbe(pParse);
2946 if( v==0 ) return;
2947 if( memRootPage>=0 ){
drh1db639c2008-01-17 02:36:28 +00002948 tnum = memRootPage;
drh063336a2004-11-05 20:58:39 +00002949 }else{
2950 tnum = pIndex->tnum;
drh063336a2004-11-05 20:58:39 +00002951 }
drh2ec2fb22013-11-06 19:59:23 +00002952 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
drh60de73e2016-04-05 15:59:23 +00002953 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
dana20fde62011-07-12 14:28:05 +00002954
dan689ab892011-08-12 15:02:00 +00002955 /* Open the sorter cursor if we are to use one. */
drhca892a72011-09-03 00:17:51 +00002956 iSorter = pParse->nTab++;
danfad9f9a2014-04-01 18:41:51 +00002957 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
drh2ec2fb22013-11-06 19:59:23 +00002958 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
dana20fde62011-07-12 14:28:05 +00002959
2960 /* Open the table. Loop through all rows of the table, inserting index
2961 ** records into the sorter. */
drhdd9930e2013-10-23 23:37:02 +00002962 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
drh688852a2014-02-17 22:40:43 +00002963 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
drh2d401ab2008-01-10 23:50:11 +00002964 regRecord = sqlite3GetTempReg(pParse);
drh4031baf2018-05-28 17:31:20 +00002965 sqlite3MultiWrite(pParse);
dana20fde62011-07-12 14:28:05 +00002966
drh1c2c0b72014-01-04 19:27:05 +00002967 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
drhca892a72011-09-03 00:17:51 +00002968 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
drh87744512014-04-13 19:15:49 +00002969 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
drh688852a2014-02-17 22:40:43 +00002970 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
drhca892a72011-09-03 00:17:51 +00002971 sqlite3VdbeJumpHere(v, addr1);
drh44156282013-10-23 22:23:03 +00002972 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
2973 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
drh2ec2fb22013-11-06 19:59:23 +00002974 (char *)pKey, P4_KEYINFO);
drh44156282013-10-23 22:23:03 +00002975 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
2976
drh688852a2014-02-17 22:40:43 +00002977 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
drh60de73e2016-04-05 15:59:23 +00002978 if( IsUniqueIndex(pIndex) ){
drh4031baf2018-05-28 17:31:20 +00002979 int j2 = sqlite3VdbeGoto(v, 1);
drhca892a72011-09-03 00:17:51 +00002980 addr2 = sqlite3VdbeCurrentAddr(v);
drh4031baf2018-05-28 17:31:20 +00002981 sqlite3VdbeVerifyAbortable(v, OE_Abort);
drh1153c7b2013-11-01 22:02:56 +00002982 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
drhac502322014-07-30 13:56:48 +00002983 pIndex->nKeyCol); VdbeCoverage(v);
drhf9c8ce32013-11-05 13:33:55 +00002984 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
drh4031baf2018-05-28 17:31:20 +00002985 sqlite3VdbeJumpHere(v, j2);
drhca892a72011-09-03 00:17:51 +00002986 }else{
2987 addr2 = sqlite3VdbeCurrentAddr(v);
dan689ab892011-08-12 15:02:00 +00002988 }
drh6cf4a7d2014-10-13 13:00:58 +00002989 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
drh86b40df2017-08-01 19:53:43 +00002990 sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
drh9b4eaeb2016-11-09 00:10:33 +00002991 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
drhca892a72011-09-03 00:17:51 +00002992 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drh2d401ab2008-01-10 23:50:11 +00002993 sqlite3ReleaseTempReg(pParse, regRecord);
drh688852a2014-02-17 22:40:43 +00002994 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
drhd654be82005-09-20 17:42:23 +00002995 sqlite3VdbeJumpHere(v, addr1);
dana20fde62011-07-12 14:28:05 +00002996
drh66a51672008-01-03 00:01:23 +00002997 sqlite3VdbeAddOp1(v, OP_Close, iTab);
2998 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
dan689ab892011-08-12 15:02:00 +00002999 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
drh063336a2004-11-05 20:58:39 +00003000}
3001
3002/*
drh77e57df2013-10-22 14:28:02 +00003003** Allocate heap space to hold an Index object with nCol columns.
3004**
3005** Increase the allocation size to provide an extra nExtra bytes
3006** of 8-byte aligned space after the Index object and return a
3007** pointer to this extra space in *ppExtra.
3008*/
3009Index *sqlite3AllocateIndexObject(
3010 sqlite3 *db, /* Database connection */
drhbbbdc832013-10-22 18:01:40 +00003011 i16 nCol, /* Total number of columns in the index */
drh77e57df2013-10-22 14:28:02 +00003012 int nExtra, /* Number of bytes of extra space to alloc */
3013 char **ppExtra /* Pointer to the "extra" space */
3014){
3015 Index *p; /* Allocated index object */
3016 int nByte; /* Bytes of space for Index object + arrays */
3017
3018 nByte = ROUND8(sizeof(Index)) + /* Index structure */
3019 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
dancfc9df72014-04-25 15:01:01 +00003020 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
drhbbbdc832013-10-22 18:01:40 +00003021 sizeof(i16)*nCol + /* Index.aiColumn */
drh77e57df2013-10-22 14:28:02 +00003022 sizeof(u8)*nCol); /* Index.aSortOrder */
3023 p = sqlite3DbMallocZero(db, nByte + nExtra);
3024 if( p ){
3025 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
drhf19aa5f2015-12-30 16:51:20 +00003026 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
dancfc9df72014-04-25 15:01:01 +00003027 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
3028 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
drh77e57df2013-10-22 14:28:02 +00003029 p->aSortOrder = (u8*)pExtra;
3030 p->nColumn = nCol;
drhbbbdc832013-10-22 18:01:40 +00003031 p->nKeyCol = nCol - 1;
drh77e57df2013-10-22 14:28:02 +00003032 *ppExtra = ((char*)p) + nByte;
3033 }
3034 return p;
3035}
3036
3037/*
drh23bf66d2004-12-14 03:34:34 +00003038** Create a new index for an SQL table. pName1.pName2 is the name of the index
3039** and pTblList is the name of the table that is to be indexed. Both will
drhadbca9c2001-09-27 15:11:53 +00003040** be NULL for a primary key or an index that is created to satisfy a
3041** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
drh382c0242001-10-06 16:33:02 +00003042** as the table to be indexed. pParse->pNewTable is a table that is
3043** currently being constructed by a CREATE TABLE statement.
drh75897232000-05-29 14:26:00 +00003044**
drh382c0242001-10-06 16:33:02 +00003045** pList is a list of columns to be indexed. pList will be NULL if this
3046** is a primary key or unique-constraint on the most recent column added
3047** to the table currently under construction.
drh75897232000-05-29 14:26:00 +00003048*/
drh62340f82016-05-31 21:18:15 +00003049void sqlite3CreateIndex(
drh23bf66d2004-12-14 03:34:34 +00003050 Parse *pParse, /* All information about this parse */
3051 Token *pName1, /* First part of index name. May be NULL */
3052 Token *pName2, /* Second part of index name. May be NULL */
3053 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
danielk19770202b292004-06-09 09:55:16 +00003054 ExprList *pList, /* A list of columns to be indexed */
drh23bf66d2004-12-14 03:34:34 +00003055 int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
drh1c55ba02007-07-02 19:31:27 +00003056 Token *pStart, /* The CREATE token that begins this statement */
drh1fe05372013-07-31 18:12:26 +00003057 Expr *pPIWhere, /* WHERE clause for partial indices */
drh4d91a702006-01-04 15:54:36 +00003058 int sortOrder, /* Sort order of primary key when pList==NULL */
drh62340f82016-05-31 21:18:15 +00003059 int ifNotExist, /* Omit error if index already exists */
3060 u8 idxType /* The index type */
drh75897232000-05-29 14:26:00 +00003061){
drhfdd6e852005-12-16 01:06:16 +00003062 Table *pTab = 0; /* Table to be indexed */
3063 Index *pIndex = 0; /* The index to be created */
3064 char *zName = 0; /* Name of the index */
3065 int nName; /* Number of characters in zName */
drhbeae3192001-09-22 18:12:08 +00003066 int i, j;
drhfdd6e852005-12-16 01:06:16 +00003067 DbFixer sFix; /* For assigning database names to pTable */
3068 int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
drh9bb575f2004-09-06 17:24:11 +00003069 sqlite3 *db = pParse->db;
drhfdd6e852005-12-16 01:06:16 +00003070 Db *pDb; /* The specific table containing the indexed database */
3071 int iDb; /* Index of the database that is being written */
3072 Token *pName = 0; /* Unqualified name of the index to create */
3073 struct ExprList_item *pListItem; /* For looping over pList */
drhc28c4e52013-10-03 19:21:41 +00003074 int nExtra = 0; /* Space allocated for zExtra[] */
drh44156282013-10-23 22:23:03 +00003075 int nExtraCol; /* Number of extra columns needed */
drh47b927d2013-12-03 00:11:40 +00003076 char *zExtra = 0; /* Extra space after the Index object */
drh44156282013-10-23 22:23:03 +00003077 Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
danielk1977cbb18d22004-05-28 11:37:27 +00003078
drh62340f82016-05-31 21:18:15 +00003079 if( db->mallocFailed || pParse->nErr>0 ){
3080 goto exit_create_index;
3081 }
3082 if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
drhd3001712009-05-12 17:46:53 +00003083 goto exit_create_index;
3084 }
3085 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e501b892006-01-09 06:29:47 +00003086 goto exit_create_index;
3087 }
drhdaffd0e2001-04-11 14:28:42 +00003088
drh75897232000-05-29 14:26:00 +00003089 /*
3090 ** Find the table that is to be indexed. Return early if not found.
3091 */
danielk1977cbb18d22004-05-28 11:37:27 +00003092 if( pTblName!=0 ){
danielk1977cbb18d22004-05-28 11:37:27 +00003093
3094 /* Use the two-part index name to determine the database
danielk1977ef2cb632004-05-29 02:37:19 +00003095 ** to search for the table. 'Fix' the table name to this db
3096 ** before looking up the table.
danielk1977cbb18d22004-05-28 11:37:27 +00003097 */
3098 assert( pName1 && pName2 );
danielk1977ef2cb632004-05-29 02:37:19 +00003099 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
danielk1977cbb18d22004-05-28 11:37:27 +00003100 if( iDb<0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00003101 assert( pName && pName->z );
danielk1977cbb18d22004-05-28 11:37:27 +00003102
danielk197753c0f742005-03-29 03:10:59 +00003103#ifndef SQLITE_OMIT_TEMPDB
mistachkind5578432012-08-25 10:01:29 +00003104 /* If the index name was unqualified, check if the table
danielk1977fe910332007-12-02 11:46:34 +00003105 ** is a temp table. If so, set the database to 1. Do not do this
3106 ** if initialising a database schema.
danielk1977cbb18d22004-05-28 11:37:27 +00003107 */
danielk1977fe910332007-12-02 11:46:34 +00003108 if( !db->init.busy ){
3109 pTab = sqlite3SrcListLookup(pParse, pTblName);
drhd3001712009-05-12 17:46:53 +00003110 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
danielk1977fe910332007-12-02 11:46:34 +00003111 iDb = 1;
3112 }
danielk1977ef2cb632004-05-29 02:37:19 +00003113 }
danielk197753c0f742005-03-29 03:10:59 +00003114#endif
danielk1977ef2cb632004-05-29 02:37:19 +00003115
drhd100f692013-10-03 15:39:44 +00003116 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
3117 if( sqlite3FixSrcList(&sFix, pTblName) ){
drh85c23c62005-08-20 03:03:04 +00003118 /* Because the parser constructs pTblName from a single identifier,
3119 ** sqlite3FixSrcList can never fail. */
3120 assert(0);
danielk1977cbb18d22004-05-28 11:37:27 +00003121 }
dan41fb5cd2012-10-04 19:33:00 +00003122 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
drhc31c7c12012-10-08 23:25:07 +00003123 assert( db->mallocFailed==0 || pTab==0 );
3124 if( pTab==0 ) goto exit_create_index;
drh989b1162013-08-01 22:27:26 +00003125 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
3126 sqlite3ErrorMsg(pParse,
3127 "cannot create a TEMP index on non-TEMP table \"%s\"",
3128 pTab->zName);
3129 goto exit_create_index;
3130 }
drh44156282013-10-23 22:23:03 +00003131 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
drh75897232000-05-29 14:26:00 +00003132 }else{
drhe3c41372001-09-17 20:25:58 +00003133 assert( pName==0 );
drhb07028f2011-10-14 21:49:18 +00003134 assert( pStart==0 );
danielk1977da184232006-01-05 11:34:32 +00003135 pTab = pParse->pNewTable;
drha6370df2006-01-04 21:40:06 +00003136 if( !pTab ) goto exit_create_index;
danielk1977da184232006-01-05 11:34:32 +00003137 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh75897232000-05-29 14:26:00 +00003138 }
drhfdd6e852005-12-16 01:06:16 +00003139 pDb = &db->aDb[iDb];
danielk1977cbb18d22004-05-28 11:37:27 +00003140
drhd3001712009-05-12 17:46:53 +00003141 assert( pTab!=0 );
3142 assert( pParse->nErr==0 );
drh03881232009-02-13 03:43:31 +00003143 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
drh3a3a03f2014-09-11 16:36:43 +00003144 && db->init.busy==0
drhd4530972014-09-09 14:47:53 +00003145#if SQLITE_USER_AUTHENTICATION
3146 && sqlite3UserAuthTable(pTab->zName)==0
3147#endif
drh8c2e6c52018-05-01 18:39:31 +00003148#ifdef SQLITE_ALLOW_SQLITE_MASTER_INDEX
3149 && sqlite3StrICmp(&pTab->zName[7],"master")!=0
3150#endif
3151 && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0
3152 ){
danielk19774adee202004-05-08 08:23:19 +00003153 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
drh0be9df02003-03-30 00:19:49 +00003154 goto exit_create_index;
3155 }
danielk1977576ec6b2005-01-21 11:55:25 +00003156#ifndef SQLITE_OMIT_VIEW
drha76b5df2002-02-23 02:32:10 +00003157 if( pTab->pSelect ){
danielk19774adee202004-05-08 08:23:19 +00003158 sqlite3ErrorMsg(pParse, "views may not be indexed");
drha76b5df2002-02-23 02:32:10 +00003159 goto exit_create_index;
3160 }
danielk1977576ec6b2005-01-21 11:55:25 +00003161#endif
danielk19775ee9d692006-06-21 12:36:25 +00003162#ifndef SQLITE_OMIT_VIRTUALTABLE
3163 if( IsVirtual(pTab) ){
3164 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
3165 goto exit_create_index;
3166 }
3167#endif
drh75897232000-05-29 14:26:00 +00003168
3169 /*
3170 ** Find the name of the index. Make sure there is not already another
drhf57b3392001-10-08 13:22:32 +00003171 ** index or table with the same name.
3172 **
3173 ** Exception: If we are reading the names of permanent indices from the
3174 ** sqlite_master table (because some other process changed the schema) and
3175 ** one of the index names collides with the name of a temporary table or
drhd24cc422003-03-27 12:51:24 +00003176 ** index, then we will continue to process this index.
drhf57b3392001-10-08 13:22:32 +00003177 **
3178 ** If pName==0 it means that we are
drhadbca9c2001-09-27 15:11:53 +00003179 ** dealing with a primary key or UNIQUE constraint. We have to invent our
3180 ** own name.
drh75897232000-05-29 14:26:00 +00003181 */
danielk1977d8123362004-06-12 09:25:12 +00003182 if( pName ){
drh17435752007-08-16 04:30:38 +00003183 zName = sqlite3NameFromToken(db, pName);
drhe3c41372001-09-17 20:25:58 +00003184 if( zName==0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00003185 assert( pName->z!=0 );
danielk1977d8123362004-06-12 09:25:12 +00003186 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
drhd24cc422003-03-27 12:51:24 +00003187 goto exit_create_index;
drhe3c41372001-09-17 20:25:58 +00003188 }
danc9461ec2018-08-29 21:00:16 +00003189 if( !IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00003190 if( !db->init.busy ){
3191 if( sqlite3FindTable(db, zName, 0)!=0 ){
3192 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
3193 goto exit_create_index;
3194 }
3195 }
3196 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
3197 if( !ifNotExist ){
3198 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
3199 }else{
3200 assert( !db->init.busy );
3201 sqlite3CodeVerifySchema(pParse, iDb);
3202 }
danielk1977d45a0312007-03-13 16:32:25 +00003203 goto exit_create_index;
3204 }
3205 }
danielk1977a21c6b62005-01-24 10:25:59 +00003206 }else{
drhadbca9c2001-09-27 15:11:53 +00003207 int n;
3208 Index *pLoop;
3209 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
drhf089aa42008-07-08 19:34:06 +00003210 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
danielk1977a1644fd2007-08-29 12:31:25 +00003211 if( zName==0 ){
danielk1977a1644fd2007-08-29 12:31:25 +00003212 goto exit_create_index;
3213 }
drh0aafa9c2016-08-05 14:35:47 +00003214
3215 /* Automatic index names generated from within sqlite3_declare_vtab()
3216 ** must have names that are distinct from normal automatic index names.
3217 ** The following statement converts "sqlite3_autoindex..." into
3218 ** "sqlite3_butoindex..." in order to make the names distinct.
3219 ** The "vtab_err.test" test demonstrates the need of this statement. */
dancf8f2892018-08-09 20:47:01 +00003220 if( IN_SPECIAL_PARSE ) zName[7]++;
drh75897232000-05-29 14:26:00 +00003221 }
3222
drhe5f9c642003-01-13 23:27:31 +00003223 /* Check for authorization to create an index.
3224 */
3225#ifndef SQLITE_OMIT_AUTHORIZATION
danc9461ec2018-08-29 21:00:16 +00003226 if( !IN_RENAME_OBJECT ){
drh69c33822016-08-18 14:33:11 +00003227 const char *zDb = pDb->zDbSName;
danielk197753c0f742005-03-29 03:10:59 +00003228 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
drhe22a3342003-04-22 20:30:37 +00003229 goto exit_create_index;
3230 }
3231 i = SQLITE_CREATE_INDEX;
danielk197753c0f742005-03-29 03:10:59 +00003232 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00003233 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
drhe22a3342003-04-22 20:30:37 +00003234 goto exit_create_index;
3235 }
drhe5f9c642003-01-13 23:27:31 +00003236 }
3237#endif
3238
drh75897232000-05-29 14:26:00 +00003239 /* If pList==0, it means this routine was called to make a primary
drh1ccde152000-06-17 13:12:39 +00003240 ** key out of the last column added to the table under construction.
drh75897232000-05-29 14:26:00 +00003241 ** So create a fake list to simulate this.
3242 */
3243 if( pList==0 ){
drh108aa002015-08-24 20:21:20 +00003244 Token prevCol;
dan26e731c2018-01-29 16:22:39 +00003245 Column *pCol = &pTab->aCol[pTab->nCol-1];
3246 pCol->colFlags |= COLFLAG_UNIQUE;
3247 sqlite3TokenInit(&prevCol, pCol->zName);
drh108aa002015-08-24 20:21:20 +00003248 pList = sqlite3ExprListAppend(pParse, 0,
3249 sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
drh75897232000-05-29 14:26:00 +00003250 if( pList==0 ) goto exit_create_index;
drhbc622bc2015-08-24 15:39:42 +00003251 assert( pList->nExpr==1 );
3252 sqlite3ExprListSetSortOrder(pList, sortOrder);
drh108aa002015-08-24 20:21:20 +00003253 }else{
3254 sqlite3ExprListCheckLength(pParse, pList, "index");
drh75897232000-05-29 14:26:00 +00003255 }
3256
danielk1977b3bf5562006-01-10 17:58:23 +00003257 /* Figure out how many bytes of space are required to store explicitly
3258 ** specified collation sequence names.
3259 */
3260 for(i=0; i<pList->nExpr; i++){
drhd3001712009-05-12 17:46:53 +00003261 Expr *pExpr = pList->a[i].pExpr;
drh7d3d9da2015-09-01 00:42:52 +00003262 assert( pExpr!=0 );
3263 if( pExpr->op==TK_COLLATE ){
dan911ce412013-05-15 15:16:50 +00003264 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
danielk1977b3bf5562006-01-10 17:58:23 +00003265 }
3266 }
3267
drh75897232000-05-29 14:26:00 +00003268 /*
3269 ** Allocate the index structure.
3270 */
drhea678832008-12-10 19:26:22 +00003271 nName = sqlite3Strlen30(zName);
drh44156282013-10-23 22:23:03 +00003272 nExtraCol = pPk ? pPk->nKeyCol : 1;
3273 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
drh77e57df2013-10-22 14:28:02 +00003274 nName + nExtra + 1, &zExtra);
drh17435752007-08-16 04:30:38 +00003275 if( db->mallocFailed ){
3276 goto exit_create_index;
3277 }
dancfc9df72014-04-25 15:01:01 +00003278 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
drhe09b84c2011-11-14 02:53:54 +00003279 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
drh77e57df2013-10-22 14:28:02 +00003280 pIndex->zName = zExtra;
3281 zExtra += nName + 1;
drh5bb3eb92007-05-04 13:15:55 +00003282 memcpy(pIndex->zName, zName, nName+1);
drh75897232000-05-29 14:26:00 +00003283 pIndex->pTable = pTab;
drh1bd10f82008-12-10 21:19:56 +00003284 pIndex->onError = (u8)onError;
drh9eade082013-10-24 14:16:10 +00003285 pIndex->uniqNotNull = onError!=OE_None;
drh62340f82016-05-31 21:18:15 +00003286 pIndex->idxType = idxType;
danielk1977da184232006-01-05 11:34:32 +00003287 pIndex->pSchema = db->aDb[iDb].pSchema;
drh72ffd092013-10-30 15:52:32 +00003288 pIndex->nKeyCol = pList->nExpr;
drh3780be12013-07-31 19:05:22 +00003289 if( pPIWhere ){
3290 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
3291 pIndex->pPartIdxWhere = pPIWhere;
3292 pPIWhere = 0;
3293 }
drh21206082011-04-04 18:22:02 +00003294 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh75897232000-05-29 14:26:00 +00003295
drhfdd6e852005-12-16 01:06:16 +00003296 /* Check to see if we should honor DESC requests on index columns
3297 */
danielk1977da184232006-01-05 11:34:32 +00003298 if( pDb->pSchema->file_format>=4 ){
drhfdd6e852005-12-16 01:06:16 +00003299 sortOrderMask = -1; /* Honor DESC */
drhfdd6e852005-12-16 01:06:16 +00003300 }else{
3301 sortOrderMask = 0; /* Ignore DESC */
3302 }
3303
drh1f9ca2c2015-08-25 16:57:52 +00003304 /* Analyze the list of expressions that form the terms of the index and
3305 ** report any errors. In the common case where the expression is exactly
3306 ** a table column, store that column in aiColumn[]. For general expressions,
drh4b92f982015-09-29 17:20:14 +00003307 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
drhd3001712009-05-12 17:46:53 +00003308 **
drh1f9ca2c2015-08-25 16:57:52 +00003309 ** TODO: Issue a warning if two or more columns of the index are identical.
3310 ** TODO: Issue a warning if the table primary key is used as part of the
3311 ** index key.
drh75897232000-05-29 14:26:00 +00003312 */
dancf8f2892018-08-09 20:47:01 +00003313 pListItem = pList->a;
danc9461ec2018-08-29 21:00:16 +00003314 if( IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00003315 pIndex->aColExpr = pList;
3316 pList = 0;
3317 }
3318 for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
drh1f9ca2c2015-08-25 16:57:52 +00003319 Expr *pCExpr; /* The i-th index expression */
3320 int requestedSortOrder; /* ASC or DESC on the i-th expression */
drhf19aa5f2015-12-30 16:51:20 +00003321 const char *zColl; /* Collation sequence name */
danielk1977b3bf5562006-01-10 17:58:23 +00003322
drhedb04ed2015-09-04 12:54:01 +00003323 sqlite3StringToId(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00003324 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
3325 if( pParse->nErr ) goto exit_create_index;
drh108aa002015-08-24 20:21:20 +00003326 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00003327 if( pCExpr->op!=TK_COLUMN ){
drh1f9ca2c2015-08-25 16:57:52 +00003328 if( pTab==pParse->pNewTable ){
3329 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
3330 "UNIQUE constraints");
3331 goto exit_create_index;
3332 }
3333 if( pIndex->aColExpr==0 ){
dancf8f2892018-08-09 20:47:01 +00003334 pIndex->aColExpr = pList;
3335 pList = 0;
drh1f9ca2c2015-08-25 16:57:52 +00003336 }
drh4b92f982015-09-29 17:20:14 +00003337 j = XN_EXPR;
3338 pIndex->aiColumn[i] = XN_EXPR;
drh84926532015-08-31 19:38:42 +00003339 pIndex->uniqNotNull = 0;
drh1f9ca2c2015-08-25 16:57:52 +00003340 }else{
3341 j = pCExpr->iColumn;
3342 assert( j<=0x7fff );
3343 if( j<0 ){
3344 j = pTab->iPKey;
3345 }else if( pTab->aCol[j].notNull==0 ){
3346 pIndex->uniqNotNull = 0;
3347 }
3348 pIndex->aiColumn[i] = (i16)j;
drh108aa002015-08-24 20:21:20 +00003349 }
drha514b8e2015-08-25 00:27:06 +00003350 zColl = 0;
drh108aa002015-08-24 20:21:20 +00003351 if( pListItem->pExpr->op==TK_COLLATE ){
drhd3001712009-05-12 17:46:53 +00003352 int nColl;
dan911ce412013-05-15 15:16:50 +00003353 zColl = pListItem->pExpr->u.zToken;
drhd3001712009-05-12 17:46:53 +00003354 nColl = sqlite3Strlen30(zColl) + 1;
3355 assert( nExtra>=nColl );
3356 memcpy(zExtra, zColl, nColl);
danielk1977b3bf5562006-01-10 17:58:23 +00003357 zColl = zExtra;
drhd3001712009-05-12 17:46:53 +00003358 zExtra += nColl;
3359 nExtra -= nColl;
drha514b8e2015-08-25 00:27:06 +00003360 }else if( j>=0 ){
danielk1977b3bf5562006-01-10 17:58:23 +00003361 zColl = pTab->aCol[j].zColl;
danielk19770202b292004-06-09 09:55:16 +00003362 }
drhf19aa5f2015-12-30 16:51:20 +00003363 if( !zColl ) zColl = sqlite3StrBINARY;
drhb7f24de2009-05-13 17:35:23 +00003364 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
danielk19777cedc8d2004-06-10 10:50:08 +00003365 goto exit_create_index;
3366 }
danielk1977b3bf5562006-01-10 17:58:23 +00003367 pIndex->azColl[i] = zColl;
drhd946db02005-12-29 19:23:06 +00003368 requestedSortOrder = pListItem->sortOrder & sortOrderMask;
drh1bd10f82008-12-10 21:19:56 +00003369 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
drh75897232000-05-29 14:26:00 +00003370 }
drh1f9ca2c2015-08-25 16:57:52 +00003371
3372 /* Append the table key to the end of the index. For WITHOUT ROWID
3373 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
3374 ** normal tables (when pPk==0) this will be the rowid.
3375 */
drh44156282013-10-23 22:23:03 +00003376 if( pPk ){
drh7913e412013-11-01 20:30:36 +00003377 for(j=0; j<pPk->nKeyCol; j++){
3378 int x = pPk->aiColumn[j];
drh1f9ca2c2015-08-25 16:57:52 +00003379 assert( x>=0 );
drh7913e412013-11-01 20:30:36 +00003380 if( hasColumn(pIndex->aiColumn, pIndex->nKeyCol, x) ){
3381 pIndex->nColumn--;
3382 }else{
3383 pIndex->aiColumn[i] = x;
3384 pIndex->azColl[i] = pPk->azColl[j];
3385 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
3386 i++;
3387 }
drh44156282013-10-23 22:23:03 +00003388 }
drh7913e412013-11-01 20:30:36 +00003389 assert( i==pIndex->nColumn );
drh44156282013-10-23 22:23:03 +00003390 }else{
drh4b92f982015-09-29 17:20:14 +00003391 pIndex->aiColumn[i] = XN_ROWID;
drhf19aa5f2015-12-30 16:51:20 +00003392 pIndex->azColl[i] = sqlite3StrBINARY;
drh44156282013-10-23 22:23:03 +00003393 }
drh51147ba2005-07-23 22:59:55 +00003394 sqlite3DefaultRowEst(pIndex);
drhe13e9f52013-10-05 19:18:00 +00003395 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
drh75897232000-05-29 14:26:00 +00003396
danf769cd62016-02-24 20:16:28 +00003397 /* If this index contains every column of its table, then mark
3398 ** it as a covering index */
3399 assert( HasRowid(pTab)
3400 || pTab->iPKey<0 || sqlite3ColumnOfIndex(pIndex, pTab->iPKey)>=0 );
drh1fe3ac72018-06-09 01:12:08 +00003401 recomputeColumnsNotIndexed(pIndex);
danf769cd62016-02-24 20:16:28 +00003402 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
3403 pIndex->isCovering = 1;
3404 for(j=0; j<pTab->nCol; j++){
3405 if( j==pTab->iPKey ) continue;
3406 if( sqlite3ColumnOfIndex(pIndex,j)>=0 ) continue;
3407 pIndex->isCovering = 0;
3408 break;
3409 }
3410 }
3411
danielk1977d8123362004-06-12 09:25:12 +00003412 if( pTab==pParse->pNewTable ){
3413 /* This routine has been called to create an automatic index as a
3414 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
3415 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
3416 ** i.e. one of:
3417 **
3418 ** CREATE TABLE t(x PRIMARY KEY, y);
3419 ** CREATE TABLE t(x, y, UNIQUE(x, y));
3420 **
3421 ** Either way, check to see if the table already has such an index. If
3422 ** so, don't bother creating this one. This only applies to
3423 ** automatically created indices. Users can do as they wish with
3424 ** explicit indices.
drhd3001712009-05-12 17:46:53 +00003425 **
3426 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
3427 ** (and thus suppressing the second one) even if they have different
3428 ** sort orders.
3429 **
3430 ** If there are different collating sequences or if the columns of
3431 ** the constraint occur in different orders, then the constraints are
3432 ** considered distinct and both result in separate indices.
danielk1977d8123362004-06-12 09:25:12 +00003433 */
3434 Index *pIdx;
3435 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
3436 int k;
drh5f1d1d92014-07-31 22:59:04 +00003437 assert( IsUniqueIndex(pIdx) );
drh48dd1d82014-05-27 18:18:58 +00003438 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
drh5f1d1d92014-07-31 22:59:04 +00003439 assert( IsUniqueIndex(pIndex) );
danielk1977d8123362004-06-12 09:25:12 +00003440
drhbbbdc832013-10-22 18:01:40 +00003441 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
3442 for(k=0; k<pIdx->nKeyCol; k++){
drhd3001712009-05-12 17:46:53 +00003443 const char *z1;
3444 const char *z2;
drh1f9ca2c2015-08-25 16:57:52 +00003445 assert( pIdx->aiColumn[k]>=0 );
danielk1977d8123362004-06-12 09:25:12 +00003446 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
drhd3001712009-05-12 17:46:53 +00003447 z1 = pIdx->azColl[k];
3448 z2 = pIndex->azColl[k];
drhc41c1322016-02-11 13:30:36 +00003449 if( sqlite3StrICmp(z1, z2) ) break;
danielk1977d8123362004-06-12 09:25:12 +00003450 }
drhbbbdc832013-10-22 18:01:40 +00003451 if( k==pIdx->nKeyCol ){
danielk1977f736b772004-06-17 06:13:34 +00003452 if( pIdx->onError!=pIndex->onError ){
3453 /* This constraint creates the same index as a previous
3454 ** constraint specified somewhere in the CREATE TABLE statement.
3455 ** However the ON CONFLICT clauses are different. If both this
3456 ** constraint and the previous equivalent constraint have explicit
3457 ** ON CONFLICT clauses this is an error. Otherwise, use the
mistachkin48864df2013-03-21 21:20:32 +00003458 ** explicitly specified behavior for the index.
danielk1977f736b772004-06-17 06:13:34 +00003459 */
3460 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
3461 sqlite3ErrorMsg(pParse,
3462 "conflicting ON CONFLICT clauses specified", 0);
3463 }
3464 if( pIdx->onError==OE_Default ){
3465 pIdx->onError = pIndex->onError;
3466 }
3467 }
drh273bfe92016-06-02 16:22:53 +00003468 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
danielk1977d8123362004-06-12 09:25:12 +00003469 goto exit_create_index;
3470 }
3471 }
3472 }
3473
danc9461ec2018-08-29 21:00:16 +00003474 if( !IN_RENAME_OBJECT ){
drhd78eeee2001-09-13 16:18:53 +00003475
dancf8f2892018-08-09 20:47:01 +00003476 /* Link the new Index structure to its table and to the other
3477 ** in-memory database structures.
drh063336a2004-11-05 20:58:39 +00003478 */
dancf8f2892018-08-09 20:47:01 +00003479 assert( pParse->nErr==0 );
3480 if( db->init.busy ){
3481 Index *p;
3482 assert( !IN_SPECIAL_PARSE );
3483 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
3484 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
3485 pIndex->zName, pIndex);
3486 if( p ){
3487 assert( p==pIndex ); /* Malloc must have failed */
3488 sqlite3OomFault(db);
3489 goto exit_create_index;
3490 }
3491 db->mDbFlags |= DBFLAG_SchemaChange;
3492 if( pTblName!=0 ){
3493 pIndex->tnum = db->init.newTnum;
3494 }
drh75897232000-05-29 14:26:00 +00003495 }
drh063336a2004-11-05 20:58:39 +00003496
dancf8f2892018-08-09 20:47:01 +00003497 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
3498 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
3499 ** emit code to allocate the index rootpage on disk and make an entry for
3500 ** the index in the sqlite_master table and populate the index with
3501 ** content. But, do not do this if we are simply reading the sqlite_master
3502 ** table to parse the schema, or if this index is the PRIMARY KEY index
3503 ** of a WITHOUT ROWID table.
3504 **
3505 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
3506 ** or UNIQUE index in a CREATE TABLE statement. Since the table
3507 ** has just been created, it contains no data and the index initialization
3508 ** step can be skipped.
drh063336a2004-11-05 20:58:39 +00003509 */
dancf8f2892018-08-09 20:47:01 +00003510 else if( HasRowid(pTab) || pTblName!=0 ){
3511 Vdbe *v;
3512 char *zStmt;
3513 int iMem = ++pParse->nMem;
drh063336a2004-11-05 20:58:39 +00003514
dancf8f2892018-08-09 20:47:01 +00003515 v = sqlite3GetVdbe(pParse);
3516 if( v==0 ) goto exit_create_index;
3517
3518 sqlite3BeginWriteOperation(pParse, 1, iDb);
3519
3520 /* Create the rootpage for the index using CreateIndex. But before
3521 ** doing so, code a Noop instruction and store its address in
3522 ** Index.tnum. This is required in case this index is actually a
3523 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
3524 ** that case the convertToWithoutRowidTable() routine will replace
3525 ** the Noop with a Goto to jump over the VDBE code generated below. */
3526 pIndex->tnum = sqlite3VdbeAddOp0(v, OP_Noop);
3527 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
3528
3529 /* Gather the complete text of the CREATE INDEX statement into
3530 ** the zStmt variable
3531 */
3532 if( pStart ){
3533 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
3534 if( pName->z[n-1]==';' ) n--;
3535 /* A named index with an explicit CREATE INDEX statement */
3536 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
3537 onError==OE_None ? "" : " UNIQUE", n, pName->z);
3538 }else{
3539 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
3540 /* zStmt = sqlite3MPrintf(""); */
3541 zStmt = 0;
3542 }
3543
3544 /* Add an entry in sqlite_master for this index
3545 */
3546 sqlite3NestedParse(pParse,
3547 "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
3548 db->aDb[iDb].zDbSName, MASTER_NAME,
3549 pIndex->zName,
3550 pTab->zName,
3551 iMem,
3552 zStmt
3553 );
3554 sqlite3DbFree(db, zStmt);
3555
3556 /* Fill the index with data and reparse the schema. Code an OP_Expire
3557 ** to invalidate all pre-compiled statements.
3558 */
3559 if( pTblName ){
3560 sqlite3RefillIndex(pParse, pIndex, iMem);
3561 sqlite3ChangeCookie(pParse, iDb);
3562 sqlite3VdbeAddParseSchemaOp(v, iDb,
3563 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
3564 sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
3565 }
3566
3567 sqlite3VdbeJumpHere(v, pIndex->tnum);
drh5e00f6c2001-09-13 13:46:56 +00003568 }
drh75897232000-05-29 14:26:00 +00003569 }
3570
danielk1977d8123362004-06-12 09:25:12 +00003571 /* When adding an index to the list of indices for a table, make
3572 ** sure all indices labeled OE_Replace come after all those labeled
drhd3001712009-05-12 17:46:53 +00003573 ** OE_Ignore. This is necessary for the correct constraint check
3574 ** processing (in sqlite3GenerateConstraintChecks()) as part of
3575 ** UPDATE and INSERT statements.
danielk1977d8123362004-06-12 09:25:12 +00003576 */
drh234c39d2004-07-24 03:30:47 +00003577 if( db->init.busy || pTblName==0 ){
3578 if( onError!=OE_Replace || pTab->pIndex==0
3579 || pTab->pIndex->onError==OE_Replace){
3580 pIndex->pNext = pTab->pIndex;
3581 pTab->pIndex = pIndex;
3582 }else{
3583 Index *pOther = pTab->pIndex;
3584 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
3585 pOther = pOther->pNext;
3586 }
3587 pIndex->pNext = pOther->pNext;
3588 pOther->pNext = pIndex;
danielk1977d8123362004-06-12 09:25:12 +00003589 }
drh234c39d2004-07-24 03:30:47 +00003590 pIndex = 0;
danielk1977d8123362004-06-12 09:25:12 +00003591 }
danc9461ec2018-08-29 21:00:16 +00003592 else if( IN_RENAME_OBJECT ){
dancf8f2892018-08-09 20:47:01 +00003593 assert( pParse->pNewIndex==0 );
3594 pParse->pNewIndex = pIndex;
3595 pIndex = 0;
3596 }
danielk1977d8123362004-06-12 09:25:12 +00003597
drh75897232000-05-29 14:26:00 +00003598 /* Clean up before exiting */
3599exit_create_index:
dancf8f2892018-08-09 20:47:01 +00003600 if( pIndex ) sqlite3FreeIndex(db, pIndex);
drh1fe05372013-07-31 18:12:26 +00003601 sqlite3ExprDelete(db, pPIWhere);
drh633e6d52008-07-28 19:34:53 +00003602 sqlite3ExprListDelete(db, pList);
3603 sqlite3SrcListDelete(db, pTblName);
3604 sqlite3DbFree(db, zName);
drh75897232000-05-29 14:26:00 +00003605}
3606
3607/*
drh51147ba2005-07-23 22:59:55 +00003608** Fill the Index.aiRowEst[] array with default information - information
drh91124b32005-08-18 18:15:05 +00003609** to be used when we have not run the ANALYZE command.
drh28c4cf42005-07-27 20:41:43 +00003610**
peter.d.reid60ec9142014-09-06 16:39:46 +00003611** aiRowEst[0] is supposed to contain the number of elements in the index.
drh28c4cf42005-07-27 20:41:43 +00003612** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
3613** number of rows in the table that match any particular value of the
3614** first column of the index. aiRowEst[2] is an estimate of the number
dancfc9df72014-04-25 15:01:01 +00003615** of rows that match any particular combination of the first 2 columns
drh28c4cf42005-07-27 20:41:43 +00003616** of the index. And so forth. It must always be the case that
3617*
3618** aiRowEst[N]<=aiRowEst[N-1]
3619** aiRowEst[N]>=1
3620**
3621** Apart from that, we have little to go on besides intuition as to
3622** how aiRowEst[] should be initialized. The numbers generated here
3623** are based on typical values found in actual indices.
drh51147ba2005-07-23 22:59:55 +00003624*/
3625void sqlite3DefaultRowEst(Index *pIdx){
dan264d2b92014-04-29 19:01:57 +00003626 /* 10, 9, 8, 7, 6 */
3627 LogEst aVal[] = { 33, 32, 30, 28, 26 };
dancfc9df72014-04-25 15:01:01 +00003628 LogEst *a = pIdx->aiRowLogEst;
3629 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
drh51147ba2005-07-23 22:59:55 +00003630 int i;
dancfc9df72014-04-25 15:01:01 +00003631
drh33bec3f2017-02-17 13:38:15 +00003632 /* Indexes with default row estimates should not have stat1 data */
3633 assert( !pIdx->hasStat1 );
3634
dan264d2b92014-04-29 19:01:57 +00003635 /* Set the first entry (number of rows in the index) to the estimated
drh8dc570b2016-06-08 18:07:21 +00003636 ** number of rows in the table, or half the number of rows in the table
3637 ** for a partial index. But do not let the estimate drop below 10. */
dancfc9df72014-04-25 15:01:01 +00003638 a[0] = pIdx->pTable->nRowLogEst;
drh8dc570b2016-06-08 18:07:21 +00003639 if( pIdx->pPartIdxWhere!=0 ) a[0] -= 10; assert( 10==sqlite3LogEst(2) );
3640 if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) );
dan264d2b92014-04-29 19:01:57 +00003641
3642 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
3643 ** 6 and each subsequent value (if any) is 5. */
dancfc9df72014-04-25 15:01:01 +00003644 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
dan264d2b92014-04-29 19:01:57 +00003645 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
3646 a[i] = 23; assert( 23==sqlite3LogEst(5) );
drh28c4cf42005-07-27 20:41:43 +00003647 }
dan264d2b92014-04-29 19:01:57 +00003648
3649 assert( 0==sqlite3LogEst(1) );
drh5f1d1d92014-07-31 22:59:04 +00003650 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
drh51147ba2005-07-23 22:59:55 +00003651}
3652
3653/*
drh74e24cd2002-01-09 03:19:59 +00003654** This routine will drop an existing named index. This routine
3655** implements the DROP INDEX statement.
drh75897232000-05-29 14:26:00 +00003656*/
drh4d91a702006-01-04 15:54:36 +00003657void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
drh75897232000-05-29 14:26:00 +00003658 Index *pIndex;
drh75897232000-05-29 14:26:00 +00003659 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00003660 sqlite3 *db = pParse->db;
danielk1977da184232006-01-05 11:34:32 +00003661 int iDb;
drh75897232000-05-29 14:26:00 +00003662
drh8af73d42009-05-13 22:58:28 +00003663 assert( pParse->nErr==0 ); /* Never called with prior errors */
3664 if( db->mallocFailed ){
danielk1977d5d56522005-03-16 12:15:20 +00003665 goto exit_drop_index;
3666 }
drhd24cc422003-03-27 12:51:24 +00003667 assert( pName->nSrc==1 );
danielk1977d5d56522005-03-16 12:15:20 +00003668 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
3669 goto exit_drop_index;
3670 }
danielk19774adee202004-05-08 08:23:19 +00003671 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
drh75897232000-05-29 14:26:00 +00003672 if( pIndex==0 ){
drh4d91a702006-01-04 15:54:36 +00003673 if( !ifExists ){
3674 sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
dan57966752011-04-09 17:32:58 +00003675 }else{
3676 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
drh4d91a702006-01-04 15:54:36 +00003677 }
drha6ecd332004-06-10 00:29:09 +00003678 pParse->checkSchema = 1;
drhd24cc422003-03-27 12:51:24 +00003679 goto exit_drop_index;
drh75897232000-05-29 14:26:00 +00003680 }
drh48dd1d82014-05-27 18:18:58 +00003681 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
danielk19774adee202004-05-08 08:23:19 +00003682 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
drh485b39b2002-07-13 03:11:52 +00003683 "or PRIMARY KEY constraint cannot be dropped", 0);
drhd24cc422003-03-27 12:51:24 +00003684 goto exit_drop_index;
3685 }
danielk1977da184232006-01-05 11:34:32 +00003686 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drhe5f9c642003-01-13 23:27:31 +00003687#ifndef SQLITE_OMIT_AUTHORIZATION
3688 {
3689 int code = SQLITE_DROP_INDEX;
3690 Table *pTab = pIndex->pTable;
drh69c33822016-08-18 14:33:11 +00003691 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977da184232006-01-05 11:34:32 +00003692 const char *zTab = SCHEMA_TABLE(iDb);
danielk19774adee202004-05-08 08:23:19 +00003693 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
drhd24cc422003-03-27 12:51:24 +00003694 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00003695 }
danielk1977da184232006-01-05 11:34:32 +00003696 if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00003697 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
drhd24cc422003-03-27 12:51:24 +00003698 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00003699 }
drhed6c8672003-01-12 18:02:16 +00003700 }
drhe5f9c642003-01-13 23:27:31 +00003701#endif
drh75897232000-05-29 14:26:00 +00003702
3703 /* Generate code to remove the index and from the master table */
danielk19774adee202004-05-08 08:23:19 +00003704 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00003705 if( v ){
drh77658e22007-12-04 16:54:52 +00003706 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00003707 sqlite3NestedParse(pParse,
dan39f1bcb2010-09-29 07:16:46 +00003708 "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
drhe0a04a32016-12-16 01:00:21 +00003709 db->aDb[iDb].zDbSName, MASTER_NAME, pIndex->zName
drhb17131a2004-11-05 22:18:49 +00003710 );
drha5ae4c32011-08-07 01:31:52 +00003711 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
drh9cbf3422008-01-17 16:22:13 +00003712 sqlite3ChangeCookie(pParse, iDb);
drhb17131a2004-11-05 22:18:49 +00003713 destroyRootPage(pParse, pIndex->tnum, iDb);
drh66a51672008-01-03 00:01:23 +00003714 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
drh75897232000-05-29 14:26:00 +00003715 }
3716
drhd24cc422003-03-27 12:51:24 +00003717exit_drop_index:
drh633e6d52008-07-28 19:34:53 +00003718 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00003719}
3720
3721/*
dan9ace1122012-03-29 07:51:45 +00003722** pArray is a pointer to an array of objects. Each object in the
3723** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
3724** to extend the array so that there is space for a new object at the end.
drh13449892005-09-07 21:22:45 +00003725**
dan9ace1122012-03-29 07:51:45 +00003726** When this function is called, *pnEntry contains the current size of
3727** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
3728** in total).
drh13449892005-09-07 21:22:45 +00003729**
dan9ace1122012-03-29 07:51:45 +00003730** If the realloc() is successful (i.e. if no OOM condition occurs), the
3731** space allocated for the new object is zeroed, *pnEntry updated to
3732** reflect the new size of the array and a pointer to the new allocation
3733** returned. *pIdx is set to the index of the new array entry in this case.
drh13449892005-09-07 21:22:45 +00003734**
dan9ace1122012-03-29 07:51:45 +00003735** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
3736** unchanged and a copy of pArray returned.
drh13449892005-09-07 21:22:45 +00003737*/
drhcf643722007-03-27 13:36:37 +00003738void *sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003739 sqlite3 *db, /* Connection to notify of malloc failures */
drhcf643722007-03-27 13:36:37 +00003740 void *pArray, /* Array of objects. Might be reallocated */
3741 int szEntry, /* Size of each object in the array */
drhcf643722007-03-27 13:36:37 +00003742 int *pnEntry, /* Number of objects currently in use */
drhcf643722007-03-27 13:36:37 +00003743 int *pIdx /* Write the index of a new slot here */
3744){
3745 char *z;
drh6c535152012-02-02 03:38:30 +00003746 int n = *pnEntry;
3747 if( (n & (n-1))==0 ){
3748 int sz = (n==0) ? 1 : 2*n;
3749 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
drh13449892005-09-07 21:22:45 +00003750 if( pNew==0 ){
drhcf643722007-03-27 13:36:37 +00003751 *pIdx = -1;
3752 return pArray;
drh13449892005-09-07 21:22:45 +00003753 }
drhcf643722007-03-27 13:36:37 +00003754 pArray = pNew;
drh13449892005-09-07 21:22:45 +00003755 }
drhcf643722007-03-27 13:36:37 +00003756 z = (char*)pArray;
drh6c535152012-02-02 03:38:30 +00003757 memset(&z[n * szEntry], 0, szEntry);
3758 *pIdx = n;
drhcf643722007-03-27 13:36:37 +00003759 ++*pnEntry;
3760 return pArray;
drh13449892005-09-07 21:22:45 +00003761}
3762
3763/*
drh75897232000-05-29 14:26:00 +00003764** Append a new element to the given IdList. Create a new IdList if
3765** need be.
drhdaffd0e2001-04-11 14:28:42 +00003766**
3767** A new IdList is returned, or NULL if malloc() fails.
drh75897232000-05-29 14:26:00 +00003768*/
dan5496d6a2018-08-13 17:14:26 +00003769IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
3770 sqlite3 *db = pParse->db;
drh13449892005-09-07 21:22:45 +00003771 int i;
drh75897232000-05-29 14:26:00 +00003772 if( pList==0 ){
drh17435752007-08-16 04:30:38 +00003773 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
drh75897232000-05-29 14:26:00 +00003774 if( pList==0 ) return 0;
3775 }
drhcf643722007-03-27 13:36:37 +00003776 pList->a = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003777 db,
drhcf643722007-03-27 13:36:37 +00003778 pList->a,
3779 sizeof(pList->a[0]),
drhcf643722007-03-27 13:36:37 +00003780 &pList->nId,
drhcf643722007-03-27 13:36:37 +00003781 &i
3782 );
drh13449892005-09-07 21:22:45 +00003783 if( i<0 ){
drh633e6d52008-07-28 19:34:53 +00003784 sqlite3IdListDelete(db, pList);
drh13449892005-09-07 21:22:45 +00003785 return 0;
drh75897232000-05-29 14:26:00 +00003786 }
drh17435752007-08-16 04:30:38 +00003787 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
danc9461ec2018-08-29 21:00:16 +00003788 if( IN_RENAME_OBJECT && pList->a[i].zName ){
dan07e95232018-08-21 16:32:53 +00003789 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
dan5496d6a2018-08-13 17:14:26 +00003790 }
drh75897232000-05-29 14:26:00 +00003791 return pList;
3792}
3793
3794/*
drhfe05af82005-07-21 03:14:59 +00003795** Delete an IdList.
3796*/
drh633e6d52008-07-28 19:34:53 +00003797void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
drhfe05af82005-07-21 03:14:59 +00003798 int i;
3799 if( pList==0 ) return;
3800 for(i=0; i<pList->nId; i++){
drh633e6d52008-07-28 19:34:53 +00003801 sqlite3DbFree(db, pList->a[i].zName);
drhfe05af82005-07-21 03:14:59 +00003802 }
drh633e6d52008-07-28 19:34:53 +00003803 sqlite3DbFree(db, pList->a);
drhdbd6a7d2017-04-05 12:39:49 +00003804 sqlite3DbFreeNN(db, pList);
drhfe05af82005-07-21 03:14:59 +00003805}
3806
3807/*
3808** Return the index in pList of the identifier named zId. Return -1
3809** if not found.
3810*/
3811int sqlite3IdListIndex(IdList *pList, const char *zName){
3812 int i;
3813 if( pList==0 ) return -1;
3814 for(i=0; i<pList->nId; i++){
3815 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
3816 }
3817 return -1;
3818}
3819
3820/*
drha78c22c2008-11-11 18:28:58 +00003821** Expand the space allocated for the given SrcList object by
3822** creating nExtra new slots beginning at iStart. iStart is zero based.
3823** New slots are zeroed.
3824**
3825** For example, suppose a SrcList initially contains two entries: A,B.
3826** To append 3 new entries onto the end, do this:
3827**
3828** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
3829**
3830** After the call above it would contain: A, B, nil, nil, nil.
3831** If the iStart argument had been 1 instead of 2, then the result
3832** would have been: A, nil, nil, nil, B. To prepend the new slots,
3833** the iStart value would be 0. The result then would
3834** be: nil, nil, nil, A, B.
3835**
3836** If a memory allocation fails the SrcList is unchanged. The
3837** db->mallocFailed flag will be set to true.
3838*/
3839SrcList *sqlite3SrcListEnlarge(
3840 sqlite3 *db, /* Database connection to notify of OOM errors */
3841 SrcList *pSrc, /* The SrcList to be enlarged */
3842 int nExtra, /* Number of new slots to add to pSrc->a[] */
3843 int iStart /* Index in pSrc->a[] of first new slot */
3844){
3845 int i;
3846
3847 /* Sanity checking on calling parameters */
3848 assert( iStart>=0 );
3849 assert( nExtra>=1 );
drh8af73d42009-05-13 22:58:28 +00003850 assert( pSrc!=0 );
3851 assert( iStart<=pSrc->nSrc );
drha78c22c2008-11-11 18:28:58 +00003852
3853 /* Allocate additional space if needed */
drhfc5717c2014-03-05 19:04:46 +00003854 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
drha78c22c2008-11-11 18:28:58 +00003855 SrcList *pNew;
drh35a18952016-12-15 18:59:14 +00003856 int nAlloc = pSrc->nSrc*2+nExtra;
drh6a1e0712008-12-05 15:24:15 +00003857 int nGot;
drha78c22c2008-11-11 18:28:58 +00003858 pNew = sqlite3DbRealloc(db, pSrc,
3859 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
3860 if( pNew==0 ){
3861 assert( db->mallocFailed );
3862 return pSrc;
3863 }
3864 pSrc = pNew;
drh6a1e0712008-12-05 15:24:15 +00003865 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
drh6d1626e2014-03-05 15:52:43 +00003866 pSrc->nAlloc = nGot;
drha78c22c2008-11-11 18:28:58 +00003867 }
3868
3869 /* Move existing slots that come after the newly inserted slots
3870 ** out of the way */
3871 for(i=pSrc->nSrc-1; i>=iStart; i--){
3872 pSrc->a[i+nExtra] = pSrc->a[i];
3873 }
drh6d1626e2014-03-05 15:52:43 +00003874 pSrc->nSrc += nExtra;
drha78c22c2008-11-11 18:28:58 +00003875
3876 /* Zero the newly allocated slots */
3877 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
3878 for(i=iStart; i<iStart+nExtra; i++){
3879 pSrc->a[i].iCursor = -1;
3880 }
3881
3882 /* Return a pointer to the enlarged SrcList */
3883 return pSrc;
3884}
3885
3886
3887/*
drhad3cab52002-05-24 02:04:32 +00003888** Append a new table name to the given SrcList. Create a new SrcList if
drhb7916a72009-05-27 10:31:29 +00003889** need be. A new entry is created in the SrcList even if pTable is NULL.
drhad3cab52002-05-24 02:04:32 +00003890**
drha78c22c2008-11-11 18:28:58 +00003891** A SrcList is returned, or NULL if there is an OOM error. The returned
3892** SrcList might be the same as the SrcList that was input or it might be
3893** a new one. If an OOM error does occurs, then the prior value of pList
3894** that is input to this routine is automatically freed.
drh113088e2003-03-20 01:16:58 +00003895**
3896** If pDatabase is not null, it means that the table has an optional
3897** database name prefix. Like this: "database.table". The pDatabase
3898** points to the table name and the pTable points to the database name.
3899** The SrcList.a[].zName field is filled with the table name which might
3900** come from pTable (if pDatabase is NULL) or from pDatabase.
3901** SrcList.a[].zDatabase is filled with the database name from pTable,
3902** or with NULL if no database is specified.
3903**
3904** In other words, if call like this:
3905**
drh17435752007-08-16 04:30:38 +00003906** sqlite3SrcListAppend(D,A,B,0);
drh113088e2003-03-20 01:16:58 +00003907**
3908** Then B is a table name and the database name is unspecified. If called
3909** like this:
3910**
drh17435752007-08-16 04:30:38 +00003911** sqlite3SrcListAppend(D,A,B,C);
drh113088e2003-03-20 01:16:58 +00003912**
drhd3001712009-05-12 17:46:53 +00003913** Then C is the table name and B is the database name. If C is defined
3914** then so is B. In other words, we never have a case where:
3915**
3916** sqlite3SrcListAppend(D,A,0,C);
drhb7916a72009-05-27 10:31:29 +00003917**
3918** Both pTable and pDatabase are assumed to be quoted. They are dequoted
3919** before being added to the SrcList.
drhad3cab52002-05-24 02:04:32 +00003920*/
drh17435752007-08-16 04:30:38 +00003921SrcList *sqlite3SrcListAppend(
3922 sqlite3 *db, /* Connection to notify of malloc failures */
3923 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
3924 Token *pTable, /* Table to append */
3925 Token *pDatabase /* Database of the table */
3926){
drha99db3b2004-06-19 14:49:12 +00003927 struct SrcList_item *pItem;
drhd3001712009-05-12 17:46:53 +00003928 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
drh575fad62016-02-05 13:38:36 +00003929 assert( db!=0 );
drhad3cab52002-05-24 02:04:32 +00003930 if( pList==0 ){
drh575fad62016-02-05 13:38:36 +00003931 pList = sqlite3DbMallocRawNN(db, sizeof(SrcList) );
drhad3cab52002-05-24 02:04:32 +00003932 if( pList==0 ) return 0;
drh4305d102003-07-30 12:34:12 +00003933 pList->nAlloc = 1;
drhac178b32016-12-14 11:14:13 +00003934 pList->nSrc = 1;
3935 memset(&pList->a[0], 0, sizeof(pList->a[0]));
3936 pList->a[0].iCursor = -1;
3937 }else{
3938 pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
drhad3cab52002-05-24 02:04:32 +00003939 }
drha78c22c2008-11-11 18:28:58 +00003940 if( db->mallocFailed ){
3941 sqlite3SrcListDelete(db, pList);
3942 return 0;
drhad3cab52002-05-24 02:04:32 +00003943 }
drha78c22c2008-11-11 18:28:58 +00003944 pItem = &pList->a[pList->nSrc-1];
drh113088e2003-03-20 01:16:58 +00003945 if( pDatabase && pDatabase->z==0 ){
3946 pDatabase = 0;
3947 }
drhd3001712009-05-12 17:46:53 +00003948 if( pDatabase ){
drh169a6892017-07-06 01:02:09 +00003949 pItem->zName = sqlite3NameFromToken(db, pDatabase);
3950 pItem->zDatabase = sqlite3NameFromToken(db, pTable);
3951 }else{
3952 pItem->zName = sqlite3NameFromToken(db, pTable);
3953 pItem->zDatabase = 0;
drh113088e2003-03-20 01:16:58 +00003954 }
drhad3cab52002-05-24 02:04:32 +00003955 return pList;
3956}
3957
3958/*
drhdfe88ec2008-11-03 20:55:06 +00003959** Assign VdbeCursor index numbers to all tables in a SrcList
drh63eb5f22003-04-29 16:20:44 +00003960*/
danielk19774adee202004-05-08 08:23:19 +00003961void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
drh63eb5f22003-04-29 16:20:44 +00003962 int i;
drh9b3187e2005-01-18 14:45:47 +00003963 struct SrcList_item *pItem;
drh17435752007-08-16 04:30:38 +00003964 assert(pList || pParse->db->mallocFailed );
danielk1977261919c2005-12-06 12:52:59 +00003965 if( pList ){
3966 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
3967 if( pItem->iCursor>=0 ) break;
3968 pItem->iCursor = pParse->nTab++;
3969 if( pItem->pSelect ){
3970 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
3971 }
drh63eb5f22003-04-29 16:20:44 +00003972 }
3973 }
3974}
3975
3976/*
drhad3cab52002-05-24 02:04:32 +00003977** Delete an entire SrcList including all its substructure.
3978*/
drh633e6d52008-07-28 19:34:53 +00003979void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
drhad3cab52002-05-24 02:04:32 +00003980 int i;
drhbe5c89a2004-07-26 00:31:09 +00003981 struct SrcList_item *pItem;
drhad3cab52002-05-24 02:04:32 +00003982 if( pList==0 ) return;
drhbe5c89a2004-07-26 00:31:09 +00003983 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
drh633e6d52008-07-28 19:34:53 +00003984 sqlite3DbFree(db, pItem->zDatabase);
3985 sqlite3DbFree(db, pItem->zName);
3986 sqlite3DbFree(db, pItem->zAlias);
drh8a48b9c2015-08-19 15:20:00 +00003987 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
3988 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
dan1feeaed2010-07-23 15:41:47 +00003989 sqlite3DeleteTable(db, pItem->pTab);
drh633e6d52008-07-28 19:34:53 +00003990 sqlite3SelectDelete(db, pItem->pSelect);
3991 sqlite3ExprDelete(db, pItem->pOn);
3992 sqlite3IdListDelete(db, pItem->pUsing);
drh75897232000-05-29 14:26:00 +00003993 }
drhdbd6a7d2017-04-05 12:39:49 +00003994 sqlite3DbFreeNN(db, pList);
drh75897232000-05-29 14:26:00 +00003995}
3996
drh982cef72000-05-30 16:27:03 +00003997/*
drh61dfc312006-12-16 16:25:15 +00003998** This routine is called by the parser to add a new term to the
3999** end of a growing FROM clause. The "p" parameter is the part of
4000** the FROM clause that has already been constructed. "p" is NULL
4001** if this is the first term of the FROM clause. pTable and pDatabase
4002** are the name of the table and database named in the FROM clause term.
4003** pDatabase is NULL if the database name qualifier is missing - the
peter.d.reid60ec9142014-09-06 16:39:46 +00004004** usual case. If the term has an alias, then pAlias points to the
drh61dfc312006-12-16 16:25:15 +00004005** alias token. If the term is a subquery, then pSubquery is the
4006** SELECT statement that the subquery encodes. The pTable and
4007** pDatabase parameters are NULL for subqueries. The pOn and pUsing
4008** parameters are the content of the ON and USING clauses.
4009**
4010** Return a new SrcList which encodes is the FROM with the new
4011** term added.
4012*/
4013SrcList *sqlite3SrcListAppendFromTerm(
drh17435752007-08-16 04:30:38 +00004014 Parse *pParse, /* Parsing context */
drh61dfc312006-12-16 16:25:15 +00004015 SrcList *p, /* The left part of the FROM clause already seen */
4016 Token *pTable, /* Name of the table to add to the FROM clause */
4017 Token *pDatabase, /* Name of the database containing pTable */
4018 Token *pAlias, /* The right-hand side of the AS subexpression */
4019 Select *pSubquery, /* A subquery used in place of a table name */
drh39a7c342018-12-04 01:18:36 +00004020 const OnUsing *pOnUsing /* The ON or USING clause */
drh61dfc312006-12-16 16:25:15 +00004021){
4022 struct SrcList_item *pItem;
drh17435752007-08-16 04:30:38 +00004023 sqlite3 *db = pParse->db;
drh39a7c342018-12-04 01:18:36 +00004024 assert( pOnUsing!=0 );
4025 if( !p && (pOnUsing->pOn || pOnUsing->pUsing) ){
danielk1977bd1a0a42009-07-01 16:12:07 +00004026 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
drh39a7c342018-12-04 01:18:36 +00004027 (pOnUsing->pOn ? "ON" : "USING")
danielk1977bd1a0a42009-07-01 16:12:07 +00004028 );
4029 goto append_from_error;
4030 }
drh17435752007-08-16 04:30:38 +00004031 p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
drh9d9c41e2017-10-31 03:40:15 +00004032 if( p==0 ){
danielk1977bd1a0a42009-07-01 16:12:07 +00004033 goto append_from_error;
drh61dfc312006-12-16 16:25:15 +00004034 }
drh9d9c41e2017-10-31 03:40:15 +00004035 assert( p->nSrc>0 );
drh61dfc312006-12-16 16:25:15 +00004036 pItem = &p->a[p->nSrc-1];
drha488ec92018-09-07 18:52:25 +00004037 assert( (pTable==0)==(pDatabase==0) );
4038 assert( pItem->zName==0 || pDatabase!=0 );
danc9461ec2018-08-29 21:00:16 +00004039 if( IN_RENAME_OBJECT && pItem->zName ){
drha488ec92018-09-07 18:52:25 +00004040 Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
danc9461ec2018-08-29 21:00:16 +00004041 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
4042 }
drh8af73d42009-05-13 22:58:28 +00004043 assert( pAlias!=0 );
4044 if( pAlias->n ){
drh17435752007-08-16 04:30:38 +00004045 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
drh61dfc312006-12-16 16:25:15 +00004046 }
4047 pItem->pSelect = pSubquery;
drh39a7c342018-12-04 01:18:36 +00004048 pItem->pOn = pOnUsing->pOn;
4049 pItem->pUsing = pOnUsing->pUsing;
drh61dfc312006-12-16 16:25:15 +00004050 return p;
danielk1977bd1a0a42009-07-01 16:12:07 +00004051
4052 append_from_error:
4053 assert( p==0 );
drh39a7c342018-12-04 01:18:36 +00004054 sqlite3ExprDelete(db, pOnUsing->pOn);
4055 sqlite3IdListDelete(db, pOnUsing->pUsing);
danielk1977bd1a0a42009-07-01 16:12:07 +00004056 sqlite3SelectDelete(db, pSubquery);
4057 return 0;
drh61dfc312006-12-16 16:25:15 +00004058}
4059
4060/*
danielk1977b1c685b2008-10-06 16:18:39 +00004061** Add an INDEXED BY or NOT INDEXED clause to the most recently added
4062** element of the source-list passed as the second argument.
4063*/
4064void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
drh8af73d42009-05-13 22:58:28 +00004065 assert( pIndexedBy!=0 );
drh8abc80b2017-08-12 01:09:06 +00004066 if( p && pIndexedBy->n>0 ){
4067 struct SrcList_item *pItem;
4068 assert( p->nSrc>0 );
4069 pItem = &p->a[p->nSrc-1];
drh8a48b9c2015-08-19 15:20:00 +00004070 assert( pItem->fg.notIndexed==0 );
4071 assert( pItem->fg.isIndexedBy==0 );
4072 assert( pItem->fg.isTabFunc==0 );
danielk1977b1c685b2008-10-06 16:18:39 +00004073 if( pIndexedBy->n==1 && !pIndexedBy->z ){
4074 /* A "NOT INDEXED" clause was supplied. See parse.y
4075 ** construct "indexed_opt" for details. */
drh8a48b9c2015-08-19 15:20:00 +00004076 pItem->fg.notIndexed = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00004077 }else{
drh8a48b9c2015-08-19 15:20:00 +00004078 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
drh8abc80b2017-08-12 01:09:06 +00004079 pItem->fg.isIndexedBy = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00004080 }
4081 }
4082}
4083
4084/*
drh01d230c2015-08-19 17:11:37 +00004085** Add the list of function arguments to the SrcList entry for a
4086** table-valued-function.
4087*/
4088void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
drh20292312015-11-21 13:24:46 +00004089 if( p ){
drh01d230c2015-08-19 17:11:37 +00004090 struct SrcList_item *pItem = &p->a[p->nSrc-1];
4091 assert( pItem->fg.notIndexed==0 );
4092 assert( pItem->fg.isIndexedBy==0 );
4093 assert( pItem->fg.isTabFunc==0 );
4094 pItem->u1.pFuncArg = pList;
4095 pItem->fg.isTabFunc = 1;
drhd8b1bfc2015-08-20 23:21:34 +00004096 }else{
4097 sqlite3ExprListDelete(pParse->db, pList);
drh01d230c2015-08-19 17:11:37 +00004098 }
4099}
4100
4101/*
drh61dfc312006-12-16 16:25:15 +00004102** When building up a FROM clause in the parser, the join operator
4103** is initially attached to the left operand. But the code generator
4104** expects the join operator to be on the right operand. This routine
4105** Shifts all join operators from left to right for an entire FROM
4106** clause.
4107**
4108** Example: Suppose the join is like this:
4109**
4110** A natural cross join B
4111**
4112** The operator is "natural cross join". The A and B operands are stored
4113** in p->a[0] and p->a[1], respectively. The parser initially stores the
4114** operator with A. This routine shifts that operator over to B.
4115*/
4116void sqlite3SrcListShiftJoinType(SrcList *p){
drhd017ab92011-08-23 00:01:58 +00004117 if( p ){
drh61dfc312006-12-16 16:25:15 +00004118 int i;
4119 for(i=p->nSrc-1; i>0; i--){
drh8a48b9c2015-08-19 15:20:00 +00004120 p->a[i].fg.jointype = p->a[i-1].fg.jointype;
drh61dfc312006-12-16 16:25:15 +00004121 }
drh8a48b9c2015-08-19 15:20:00 +00004122 p->a[0].fg.jointype = 0;
drh61dfc312006-12-16 16:25:15 +00004123 }
4124}
4125
4126/*
drhb0c88652016-02-01 13:21:13 +00004127** Generate VDBE code for a BEGIN statement.
drhc4a3c772001-04-04 11:48:57 +00004128*/
drh684917c2004-10-05 02:41:42 +00004129void sqlite3BeginTransaction(Parse *pParse, int type){
drh9bb575f2004-09-06 17:24:11 +00004130 sqlite3 *db;
danielk19771d850a72004-05-31 08:26:49 +00004131 Vdbe *v;
drh684917c2004-10-05 02:41:42 +00004132 int i;
drh5e00f6c2001-09-13 13:46:56 +00004133
drhd3001712009-05-12 17:46:53 +00004134 assert( pParse!=0 );
4135 db = pParse->db;
4136 assert( db!=0 );
drhd3001712009-05-12 17:46:53 +00004137 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
4138 return;
4139 }
danielk19771d850a72004-05-31 08:26:49 +00004140 v = sqlite3GetVdbe(pParse);
4141 if( !v ) return;
drh684917c2004-10-05 02:41:42 +00004142 if( type!=TK_DEFERRED ){
4143 for(i=0; i<db->nDb; i++){
drh66a51672008-01-03 00:01:23 +00004144 sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
drhfb982642007-08-30 01:19:59 +00004145 sqlite3VdbeUsesBtree(v, i);
drh684917c2004-10-05 02:41:42 +00004146 }
4147 }
drhb0c88652016-02-01 13:21:13 +00004148 sqlite3VdbeAddOp0(v, OP_AutoCommit);
drhc4a3c772001-04-04 11:48:57 +00004149}
4150
4151/*
drh07a3b112017-07-06 01:28:02 +00004152** Generate VDBE code for a COMMIT or ROLLBACK statement.
4153** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
4154** code is generated for a COMMIT.
drhc4a3c772001-04-04 11:48:57 +00004155*/
drh07a3b112017-07-06 01:28:02 +00004156void sqlite3EndTransaction(Parse *pParse, int eType){
danielk19771d850a72004-05-31 08:26:49 +00004157 Vdbe *v;
drh07a3b112017-07-06 01:28:02 +00004158 int isRollback;
drh5e00f6c2001-09-13 13:46:56 +00004159
drhd3001712009-05-12 17:46:53 +00004160 assert( pParse!=0 );
drhb07028f2011-10-14 21:49:18 +00004161 assert( pParse->db!=0 );
drh07a3b112017-07-06 01:28:02 +00004162 assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
4163 isRollback = eType==TK_ROLLBACK;
4164 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
4165 isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
drhd3001712009-05-12 17:46:53 +00004166 return;
4167 }
danielk19771d850a72004-05-31 08:26:49 +00004168 v = sqlite3GetVdbe(pParse);
4169 if( v ){
drh07a3b112017-07-06 01:28:02 +00004170 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
drh02f75f12004-02-24 01:04:11 +00004171 }
drhc4a3c772001-04-04 11:48:57 +00004172}
drhf57b14a2001-09-14 18:54:08 +00004173
4174/*
danielk1977fd7f0452008-12-17 17:30:26 +00004175** This function is called by the parser when it parses a command to create,
4176** release or rollback an SQL savepoint.
4177*/
4178void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
danielk1977ab9b7032008-12-30 06:24:58 +00004179 char *zName = sqlite3NameFromToken(pParse->db, pName);
4180 if( zName ){
4181 Vdbe *v = sqlite3GetVdbe(pParse);
4182#ifndef SQLITE_OMIT_AUTHORIZATION
dan558814f2010-06-02 05:53:53 +00004183 static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
danielk1977ab9b7032008-12-30 06:24:58 +00004184 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
4185#endif
4186 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
4187 sqlite3DbFree(pParse->db, zName);
4188 return;
4189 }
4190 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
danielk1977fd7f0452008-12-17 17:30:26 +00004191 }
4192}
4193
4194/*
drhdc3ff9c2004-08-18 02:10:15 +00004195** Make sure the TEMP database is open and available for use. Return
4196** the number of errors. Leave any error messages in the pParse structure.
4197*/
danielk1977ddfb2f02006-02-17 12:25:14 +00004198int sqlite3OpenTempDatabase(Parse *pParse){
drhdc3ff9c2004-08-18 02:10:15 +00004199 sqlite3 *db = pParse->db;
4200 if( db->aDb[1].pBt==0 && !pParse->explain ){
drh33f4e022007-09-03 15:19:34 +00004201 int rc;
drh10a76c92010-01-26 01:25:26 +00004202 Btree *pBt;
drh33f4e022007-09-03 15:19:34 +00004203 static const int flags =
4204 SQLITE_OPEN_READWRITE |
4205 SQLITE_OPEN_CREATE |
4206 SQLITE_OPEN_EXCLUSIVE |
4207 SQLITE_OPEN_DELETEONCLOSE |
4208 SQLITE_OPEN_TEMP_DB;
4209
dan3a6d8ae2011-04-23 15:54:54 +00004210 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
drhdc3ff9c2004-08-18 02:10:15 +00004211 if( rc!=SQLITE_OK ){
4212 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
4213 "file for storing temporary tables");
4214 pParse->rc = rc;
4215 return 1;
4216 }
drh10a76c92010-01-26 01:25:26 +00004217 db->aDb[1].pBt = pBt;
danielk197714db2662006-01-09 16:12:04 +00004218 assert( db->aDb[1].pSchema );
drh10a76c92010-01-26 01:25:26 +00004219 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
drh4a642b62016-02-05 01:55:27 +00004220 sqlite3OomFault(db);
drh7c9c9862010-01-31 14:18:21 +00004221 return 1;
drh10a76c92010-01-26 01:25:26 +00004222 }
drhdc3ff9c2004-08-18 02:10:15 +00004223 }
4224 return 0;
4225}
4226
4227/*
drhaceb31b2014-02-08 01:40:27 +00004228** Record the fact that the schema cookie will need to be verified
4229** for database iDb. The code to actually verify the schema cookie
4230** will occur at the end of the top-level VDBE and will be generated
4231** later, by sqlite3FinishCoding().
drh001bbcb2003-03-19 03:14:00 +00004232*/
danielk19774adee202004-05-08 08:23:19 +00004233void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
dan65a7cd12009-09-01 12:16:01 +00004234 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh80242052004-06-09 00:48:12 +00004235
drh1d96cc62016-09-30 18:35:36 +00004236 assert( iDb>=0 && iDb<pParse->db->nDb );
4237 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
drhaceb31b2014-02-08 01:40:27 +00004238 assert( iDb<SQLITE_MAX_ATTACHED+2 );
drh1d96cc62016-09-30 18:35:36 +00004239 assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
drha7ab6d82014-07-21 15:44:39 +00004240 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
4241 DbMaskSet(pToplevel->cookieMask, iDb);
drhaceb31b2014-02-08 01:40:27 +00004242 if( !OMIT_TEMPDB && iDb==1 ){
4243 sqlite3OpenTempDatabase(pToplevel);
4244 }
drh001bbcb2003-03-19 03:14:00 +00004245 }
drh001bbcb2003-03-19 03:14:00 +00004246}
4247
4248/*
dan57966752011-04-09 17:32:58 +00004249** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
4250** attached database. Otherwise, invoke it for the database named zDb only.
4251*/
4252void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
4253 sqlite3 *db = pParse->db;
4254 int i;
4255 for(i=0; i<db->nDb; i++){
4256 Db *pDb = &db->aDb[i];
drh69c33822016-08-18 14:33:11 +00004257 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
dan57966752011-04-09 17:32:58 +00004258 sqlite3CodeVerifySchema(pParse, i);
4259 }
4260 }
4261}
4262
4263/*
drh1c928532002-01-31 15:54:21 +00004264** Generate VDBE code that prepares for doing an operation that
drhc977f7f2002-05-21 11:38:11 +00004265** might change the database.
4266**
4267** This routine starts a new transaction if we are not already within
4268** a transaction. If we are already within a transaction, then a checkpoint
drh7f0f12e2004-05-21 13:39:50 +00004269** is set if the setStatement parameter is true. A checkpoint should
drhc977f7f2002-05-21 11:38:11 +00004270** be set for operations that might fail (due to a constraint) part of
4271** the way through and which will need to undo some writes without having to
4272** rollback the whole transaction. For operations where all constraints
4273** can be checked before any changes are made to the database, it is never
4274** necessary to undo a write and the checkpoint should not be set.
drh1c928532002-01-31 15:54:21 +00004275*/
drh7f0f12e2004-05-21 13:39:50 +00004276void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
dan65a7cd12009-09-01 12:16:01 +00004277 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh80242052004-06-09 00:48:12 +00004278 sqlite3CodeVerifySchema(pParse, iDb);
drha7ab6d82014-07-21 15:44:39 +00004279 DbMaskSet(pToplevel->writeMask, iDb);
dane0af83a2009-09-08 19:15:01 +00004280 pToplevel->isMultiWrite |= setStatement;
4281}
4282
drhff738bc2009-09-24 00:09:58 +00004283/*
4284** Indicate that the statement currently under construction might write
4285** more than one entry (example: deleting one row then inserting another,
4286** inserting multiple rows in a table, or inserting a row and index entries.)
4287** If an abort occurs after some of these writes have completed, then it will
4288** be necessary to undo the completed writes.
4289*/
4290void sqlite3MultiWrite(Parse *pParse){
4291 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4292 pToplevel->isMultiWrite = 1;
4293}
4294
dane0af83a2009-09-08 19:15:01 +00004295/*
drhff738bc2009-09-24 00:09:58 +00004296** The code generator calls this routine if is discovers that it is
4297** possible to abort a statement prior to completion. In order to
4298** perform this abort without corrupting the database, we need to make
4299** sure that the statement is protected by a statement transaction.
4300**
4301** Technically, we only need to set the mayAbort flag if the
4302** isMultiWrite flag was previously set. There is a time dependency
4303** such that the abort must occur after the multiwrite. This makes
4304** some statements involving the REPLACE conflict resolution algorithm
4305** go a little faster. But taking advantage of this time dependency
4306** makes it more difficult to prove that the code is correct (in
4307** particular, it prevents us from writing an effective
4308** implementation of sqlite3AssertMayAbort()) and so we have chosen
4309** to take the safe route and skip the optimization.
dane0af83a2009-09-08 19:15:01 +00004310*/
4311void sqlite3MayAbort(Parse *pParse){
4312 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4313 pToplevel->mayAbort = 1;
4314}
4315
4316/*
4317** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
4318** error. The onError parameter determines which (if any) of the statement
4319** and/or current transaction is rolled back.
4320*/
drhd91c1a12013-02-09 13:58:25 +00004321void sqlite3HaltConstraint(
4322 Parse *pParse, /* Parsing context */
4323 int errCode, /* extended error code */
4324 int onError, /* Constraint type */
4325 char *p4, /* Error message */
drhf9c8ce32013-11-05 13:33:55 +00004326 i8 p4type, /* P4_STATIC or P4_TRANSIENT */
4327 u8 p5Errmsg /* P5_ErrMsg type */
drhd91c1a12013-02-09 13:58:25 +00004328){
dane0af83a2009-09-08 19:15:01 +00004329 Vdbe *v = sqlite3GetVdbe(pParse);
drhd91c1a12013-02-09 13:58:25 +00004330 assert( (errCode&0xff)==SQLITE_CONSTRAINT );
dane0af83a2009-09-08 19:15:01 +00004331 if( onError==OE_Abort ){
4332 sqlite3MayAbort(pParse);
danielk19771d850a72004-05-31 08:26:49 +00004333 }
drhd91c1a12013-02-09 13:58:25 +00004334 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
drh9b34abe2016-01-16 15:12:35 +00004335 sqlite3VdbeChangeP5(v, p5Errmsg);
drhf9c8ce32013-11-05 13:33:55 +00004336}
4337
4338/*
4339** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
4340*/
4341void sqlite3UniqueConstraint(
4342 Parse *pParse, /* Parsing context */
4343 int onError, /* Constraint type */
4344 Index *pIdx /* The index that triggers the constraint */
4345){
4346 char *zErr;
4347 int j;
4348 StrAccum errMsg;
4349 Table *pTab = pIdx->pTable;
4350
drhc0490572015-05-02 11:45:53 +00004351 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200);
drh8b576422015-08-31 23:09:42 +00004352 if( pIdx->aColExpr ){
drh0cdbe1a2018-05-09 13:46:26 +00004353 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
drh8b576422015-08-31 23:09:42 +00004354 }else{
4355 for(j=0; j<pIdx->nKeyCol; j++){
4356 char *zCol;
4357 assert( pIdx->aiColumn[j]>=0 );
4358 zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
drh0cdbe1a2018-05-09 13:46:26 +00004359 if( j ) sqlite3_str_append(&errMsg, ", ", 2);
4360 sqlite3_str_appendall(&errMsg, pTab->zName);
4361 sqlite3_str_append(&errMsg, ".", 1);
4362 sqlite3_str_appendall(&errMsg, zCol);
drh8b576422015-08-31 23:09:42 +00004363 }
drhf9c8ce32013-11-05 13:33:55 +00004364 }
4365 zErr = sqlite3StrAccumFinish(&errMsg);
4366 sqlite3HaltConstraint(pParse,
drh48dd1d82014-05-27 18:18:58 +00004367 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
4368 : SQLITE_CONSTRAINT_UNIQUE,
dan93889d92013-11-06 16:28:59 +00004369 onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
drhf9c8ce32013-11-05 13:33:55 +00004370}
4371
4372
4373/*
4374** Code an OP_Halt due to non-unique rowid.
4375*/
4376void sqlite3RowidConstraint(
4377 Parse *pParse, /* Parsing context */
4378 int onError, /* Conflict resolution algorithm */
4379 Table *pTab /* The table with the non-unique rowid */
4380){
4381 char *zMsg;
4382 int rc;
4383 if( pTab->iPKey>=0 ){
4384 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
4385 pTab->aCol[pTab->iPKey].zName);
4386 rc = SQLITE_CONSTRAINT_PRIMARYKEY;
4387 }else{
4388 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
4389 rc = SQLITE_CONSTRAINT_ROWID;
4390 }
4391 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
4392 P5_ConstraintUnique);
drh663fc632002-02-02 18:49:19 +00004393}
4394
drh4343fea2004-11-05 23:46:15 +00004395/*
4396** Check to see if pIndex uses the collating sequence pColl. Return
4397** true if it does and false if it does not.
4398*/
4399#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00004400static int collationMatch(const char *zColl, Index *pIndex){
4401 int i;
drh04491712009-05-13 17:21:13 +00004402 assert( zColl!=0 );
danielk1977b3bf5562006-01-10 17:58:23 +00004403 for(i=0; i<pIndex->nColumn; i++){
4404 const char *z = pIndex->azColl[i];
drhbbbdc832013-10-22 18:01:40 +00004405 assert( z!=0 || pIndex->aiColumn[i]<0 );
4406 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00004407 return 1;
4408 }
drh4343fea2004-11-05 23:46:15 +00004409 }
4410 return 0;
4411}
4412#endif
4413
4414/*
4415** Recompute all indices of pTab that use the collating sequence pColl.
4416** If pColl==0 then recompute all indices of pTab.
4417*/
4418#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00004419static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
drh4343fea2004-11-05 23:46:15 +00004420 Index *pIndex; /* An index associated with pTab */
4421
4422 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
danielk1977b3bf5562006-01-10 17:58:23 +00004423 if( zColl==0 || collationMatch(zColl, pIndex) ){
danielk1977da184232006-01-05 11:34:32 +00004424 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
4425 sqlite3BeginWriteOperation(pParse, 0, iDb);
drh4343fea2004-11-05 23:46:15 +00004426 sqlite3RefillIndex(pParse, pIndex, -1);
4427 }
4428 }
4429}
4430#endif
4431
4432/*
4433** Recompute all indices of all tables in all databases where the
4434** indices use the collating sequence pColl. If pColl==0 then recompute
4435** all indices everywhere.
4436*/
4437#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00004438static void reindexDatabases(Parse *pParse, char const *zColl){
drh4343fea2004-11-05 23:46:15 +00004439 Db *pDb; /* A single database */
4440 int iDb; /* The database index number */
4441 sqlite3 *db = pParse->db; /* The database connection */
4442 HashElem *k; /* For looping over tables in pDb */
4443 Table *pTab; /* A table in the database */
4444
drh21206082011-04-04 18:22:02 +00004445 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
drh4343fea2004-11-05 23:46:15 +00004446 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
drh43617e92006-03-06 20:55:46 +00004447 assert( pDb!=0 );
danielk1977da184232006-01-05 11:34:32 +00004448 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
drh4343fea2004-11-05 23:46:15 +00004449 pTab = (Table*)sqliteHashData(k);
danielk1977b3bf5562006-01-10 17:58:23 +00004450 reindexTable(pParse, pTab, zColl);
drh4343fea2004-11-05 23:46:15 +00004451 }
4452 }
4453}
4454#endif
4455
4456/*
drheee46cf2004-11-06 00:02:48 +00004457** Generate code for the REINDEX command.
4458**
4459** REINDEX -- 1
4460** REINDEX <collation> -- 2
4461** REINDEX ?<database>.?<tablename> -- 3
4462** REINDEX ?<database>.?<indexname> -- 4
4463**
4464** Form 1 causes all indices in all attached databases to be rebuilt.
4465** Form 2 rebuilds all indices in all databases that use the named
4466** collating function. Forms 3 and 4 rebuild the named index or all
4467** indices associated with the named table.
drh4343fea2004-11-05 23:46:15 +00004468*/
4469#ifndef SQLITE_OMIT_REINDEX
4470void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
4471 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
4472 char *z; /* Name of a table or index */
4473 const char *zDb; /* Name of the database */
4474 Table *pTab; /* A table in the database */
4475 Index *pIndex; /* An index associated with pTab */
4476 int iDb; /* The database index number */
4477 sqlite3 *db = pParse->db; /* The database connection */
4478 Token *pObjName; /* Name of the table or index to be reindexed */
4479
danielk197733a5edc2005-01-27 00:22:02 +00004480 /* Read the database schema. If an error occurs, leave an error message
4481 ** and code in pParse and return NULL. */
4482 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e63739a2005-01-27 00:33:37 +00004483 return;
danielk197733a5edc2005-01-27 00:22:02 +00004484 }
4485
drh8af73d42009-05-13 22:58:28 +00004486 if( pName1==0 ){
drh4343fea2004-11-05 23:46:15 +00004487 reindexDatabases(pParse, 0);
4488 return;
drhd3001712009-05-12 17:46:53 +00004489 }else if( NEVER(pName2==0) || pName2->z==0 ){
danielk197739002502007-11-12 09:50:26 +00004490 char *zColl;
danielk1977b3bf5562006-01-10 17:58:23 +00004491 assert( pName1->z );
danielk197739002502007-11-12 09:50:26 +00004492 zColl = sqlite3NameFromToken(pParse->db, pName1);
4493 if( !zColl ) return;
drhc4a64fa2009-05-11 20:53:28 +00004494 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh4343fea2004-11-05 23:46:15 +00004495 if( pColl ){
drhd3001712009-05-12 17:46:53 +00004496 reindexDatabases(pParse, zColl);
4497 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00004498 return;
4499 }
drh633e6d52008-07-28 19:34:53 +00004500 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00004501 }
4502 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
4503 if( iDb<0 ) return;
drh17435752007-08-16 04:30:38 +00004504 z = sqlite3NameFromToken(db, pObjName);
drh84f31122007-05-12 15:00:14 +00004505 if( z==0 ) return;
drh69c33822016-08-18 14:33:11 +00004506 zDb = db->aDb[iDb].zDbSName;
drh4343fea2004-11-05 23:46:15 +00004507 pTab = sqlite3FindTable(db, z, zDb);
4508 if( pTab ){
4509 reindexTable(pParse, pTab, 0);
drh633e6d52008-07-28 19:34:53 +00004510 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00004511 return;
4512 }
4513 pIndex = sqlite3FindIndex(db, z, zDb);
drh633e6d52008-07-28 19:34:53 +00004514 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00004515 if( pIndex ){
4516 sqlite3BeginWriteOperation(pParse, 0, iDb);
4517 sqlite3RefillIndex(pParse, pIndex, -1);
4518 return;
4519 }
4520 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
4521}
4522#endif
danielk1977b3bf5562006-01-10 17:58:23 +00004523
4524/*
drh2ec2fb22013-11-06 19:59:23 +00004525** Return a KeyInfo structure that is appropriate for the given Index.
danielk1977b3bf5562006-01-10 17:58:23 +00004526**
drh2ec2fb22013-11-06 19:59:23 +00004527** The caller should invoke sqlite3KeyInfoUnref() on the returned object
4528** when it has finished using it.
danielk1977b3bf5562006-01-10 17:58:23 +00004529*/
drh2ec2fb22013-11-06 19:59:23 +00004530KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
drh18b67f32014-12-12 00:20:37 +00004531 int i;
4532 int nCol = pIdx->nColumn;
4533 int nKey = pIdx->nKeyCol;
4534 KeyInfo *pKey;
drh2ec2fb22013-11-06 19:59:23 +00004535 if( pParse->nErr ) return 0;
drh18b67f32014-12-12 00:20:37 +00004536 if( pIdx->uniqNotNull ){
4537 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
4538 }else{
4539 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
drh41e13e12013-11-07 14:09:39 +00004540 }
drh18b67f32014-12-12 00:20:37 +00004541 if( pKey ){
4542 assert( sqlite3KeyInfoIsWriteable(pKey) );
4543 for(i=0; i<nCol; i++){
drhf19aa5f2015-12-30 16:51:20 +00004544 const char *zColl = pIdx->azColl[i];
4545 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
drh18b67f32014-12-12 00:20:37 +00004546 sqlite3LocateCollSeq(pParse, zColl);
4547 pKey->aSortOrder[i] = pIdx->aSortOrder[i];
drh2ec2fb22013-11-06 19:59:23 +00004548 }
drh18b67f32014-12-12 00:20:37 +00004549 if( pParse->nErr ){
drh7e8515d2017-12-08 19:37:04 +00004550 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
4551 if( pIdx->bNoQuery==0 ){
4552 /* Deactivate the index because it contains an unknown collating
4553 ** sequence. The only way to reactive the index is to reload the
4554 ** schema. Adding the missing collating sequence later does not
4555 ** reactive the index. The application had the chance to register
4556 ** the missing index using the collation-needed callback. For
4557 ** simplicity, SQLite will not give the application a second chance.
4558 */
4559 pIdx->bNoQuery = 1;
4560 pParse->rc = SQLITE_ERROR_RETRY;
4561 }
drh18b67f32014-12-12 00:20:37 +00004562 sqlite3KeyInfoUnref(pKey);
4563 pKey = 0;
danielk1977b3bf5562006-01-10 17:58:23 +00004564 }
danielk1977b3bf5562006-01-10 17:58:23 +00004565 }
drh18b67f32014-12-12 00:20:37 +00004566 return pKey;
danielk1977b3bf5562006-01-10 17:58:23 +00004567}
drh8b471862014-01-11 13:22:17 +00004568
4569#ifndef SQLITE_OMIT_CTE
dan7d562db2014-01-11 19:19:36 +00004570/*
4571** This routine is invoked once per CTE by the parser while parsing a
4572** WITH clause.
drh8b471862014-01-11 13:22:17 +00004573*/
dan7d562db2014-01-11 19:19:36 +00004574With *sqlite3WithAdd(
drh8b471862014-01-11 13:22:17 +00004575 Parse *pParse, /* Parsing context */
dan7d562db2014-01-11 19:19:36 +00004576 With *pWith, /* Existing WITH clause, or NULL */
drh8b471862014-01-11 13:22:17 +00004577 Token *pName, /* Name of the common-table */
dan4e9119d2014-01-13 15:12:23 +00004578 ExprList *pArglist, /* Optional column name list for the table */
drh8b471862014-01-11 13:22:17 +00004579 Select *pQuery /* Query used to initialize the table */
4580){
dan4e9119d2014-01-13 15:12:23 +00004581 sqlite3 *db = pParse->db;
4582 With *pNew;
4583 char *zName;
4584
4585 /* Check that the CTE name is unique within this WITH clause. If
4586 ** not, store an error in the Parse structure. */
4587 zName = sqlite3NameFromToken(pParse->db, pName);
4588 if( zName && pWith ){
4589 int i;
4590 for(i=0; i<pWith->nCte; i++){
4591 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
drh727a99f2014-01-16 21:59:51 +00004592 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
dan4e9119d2014-01-13 15:12:23 +00004593 }
4594 }
4595 }
4596
4597 if( pWith ){
4598 int nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
4599 pNew = sqlite3DbRealloc(db, pWith, nByte);
4600 }else{
4601 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
4602 }
drhb84e5742016-02-05 02:42:54 +00004603 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
dan4e9119d2014-01-13 15:12:23 +00004604
drhb84e5742016-02-05 02:42:54 +00004605 if( db->mallocFailed ){
dan4e9119d2014-01-13 15:12:23 +00004606 sqlite3ExprListDelete(db, pArglist);
4607 sqlite3SelectDelete(db, pQuery);
4608 sqlite3DbFree(db, zName);
dana9f5c132014-01-13 16:36:40 +00004609 pNew = pWith;
dan4e9119d2014-01-13 15:12:23 +00004610 }else{
4611 pNew->a[pNew->nCte].pSelect = pQuery;
4612 pNew->a[pNew->nCte].pCols = pArglist;
4613 pNew->a[pNew->nCte].zName = zName;
drh0576bc52015-08-26 11:40:11 +00004614 pNew->a[pNew->nCte].zCteErr = 0;
dan4e9119d2014-01-13 15:12:23 +00004615 pNew->nCte++;
4616 }
4617
4618 return pNew;
drh8b471862014-01-11 13:22:17 +00004619}
4620
dan7d562db2014-01-11 19:19:36 +00004621/*
4622** Free the contents of the With object passed as the second argument.
drh8b471862014-01-11 13:22:17 +00004623*/
dan7d562db2014-01-11 19:19:36 +00004624void sqlite3WithDelete(sqlite3 *db, With *pWith){
dan4e9119d2014-01-13 15:12:23 +00004625 if( pWith ){
4626 int i;
4627 for(i=0; i<pWith->nCte; i++){
4628 struct Cte *pCte = &pWith->a[i];
4629 sqlite3ExprListDelete(db, pCte->pCols);
4630 sqlite3SelectDelete(db, pCte->pSelect);
4631 sqlite3DbFree(db, pCte->zName);
4632 }
4633 sqlite3DbFree(db, pWith);
4634 }
drh8b471862014-01-11 13:22:17 +00004635}
4636#endif /* !defined(SQLITE_OMIT_CTE) */