blob: 0fe20326895a07f00f5d8bd73b18ac039de1fea5 [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 {
drhd698bc12006-03-23 23:33:26 +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 *zName; /* 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;
80 p->zName = 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,
102 p->zName, 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 ){
drhceea3322009-04-23 13:22:42 +0000228 assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
drh3492dd72009-09-14 23:47:24 +0000229 /* A minimum of one cursor is required if autoincrement is used
230 * See ticket [a696379c1f08866] */
231 if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
drh124c0b42011-06-01 18:15:55 +0000232 sqlite3VdbeMakeReady(v, pParse);
danielk1977441daf62005-02-01 03:46:43 +0000233 pParse->rc = SQLITE_DONE;
drhe294da02010-02-25 23:44:15 +0000234 }else{
drh483750b2003-01-29 18:46:51 +0000235 pParse->rc = SQLITE_ERROR;
drh75897232000-05-29 14:26:00 +0000236 }
237}
238
239/*
drh205f48e2004-11-05 00:43:11 +0000240** Run the parser and code generator recursively in order to generate
241** code for the SQL statement given onto the end of the pParse context
242** currently under construction. When the parser is run recursively
243** this way, the final OP_Halt is not appended and other initialization
244** and finalization steps are omitted because those are handling by the
245** outermost parser.
246**
247** Not everything is nestable. This facility is designed to permit
248** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use
drhf1974842004-11-05 03:56:00 +0000249** care if you decide to try to use this routine for some other purposes.
drh205f48e2004-11-05 00:43:11 +0000250*/
251void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
252 va_list ap;
253 char *zSql;
drhfb45d8c2008-07-08 00:06:49 +0000254 char *zErrMsg = 0;
drh633e6d52008-07-28 19:34:53 +0000255 sqlite3 *db = pParse->db;
drhcd9af602016-09-30 22:24:29 +0000256 char saveBuf[PARSE_TAIL_SZ];
drhf1974842004-11-05 03:56:00 +0000257
drh205f48e2004-11-05 00:43:11 +0000258 if( pParse->nErr ) return;
259 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
260 va_start(ap, zFormat);
drh633e6d52008-07-28 19:34:53 +0000261 zSql = sqlite3VMPrintf(db, zFormat, ap);
drh205f48e2004-11-05 00:43:11 +0000262 va_end(ap);
drh73c42a12004-11-20 18:13:10 +0000263 if( zSql==0 ){
264 return; /* A malloc must have failed */
265 }
drh205f48e2004-11-05 00:43:11 +0000266 pParse->nested++;
drhcd9af602016-09-30 22:24:29 +0000267 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
268 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
drhfb45d8c2008-07-08 00:06:49 +0000269 sqlite3RunParser(pParse, zSql, &zErrMsg);
drh633e6d52008-07-28 19:34:53 +0000270 sqlite3DbFree(db, zErrMsg);
271 sqlite3DbFree(db, zSql);
drhcd9af602016-09-30 22:24:29 +0000272 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
drh205f48e2004-11-05 00:43:11 +0000273 pParse->nested--;
274}
275
drhd4530972014-09-09 14:47:53 +0000276#if SQLITE_USER_AUTHENTICATION
277/*
278** Return TRUE if zTable is the name of the system table that stores the
279** list of users and their access credentials.
280*/
281int sqlite3UserAuthTable(const char *zTable){
282 return sqlite3_stricmp(zTable, "sqlite_user")==0;
283}
284#endif
285
drh205f48e2004-11-05 00:43:11 +0000286/*
danielk19778a414492004-06-29 08:59:35 +0000287** Locate the in-memory structure that describes a particular database
288** table given the name of that table and (optionally) the name of the
289** database containing the table. Return NULL if not found.
drha69d9162003-04-17 22:57:53 +0000290**
danielk19778a414492004-06-29 08:59:35 +0000291** If zDatabase is 0, all databases are searched for the table and the
292** first matching table is returned. (No checking for duplicate table
293** names is done.) The search order is TEMP first, then MAIN, then any
294** auxiliary databases added using the ATTACH command.
drhf26e09c2003-05-31 16:21:12 +0000295**
danielk19774adee202004-05-08 08:23:19 +0000296** See also sqlite3LocateTable().
drh75897232000-05-29 14:26:00 +0000297*/
drh9bb575f2004-09-06 17:24:11 +0000298Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
drhd24cc422003-03-27 12:51:24 +0000299 Table *p = 0;
300 int i;
drh9ca95732014-10-24 00:35:58 +0000301
drh21206082011-04-04 18:22:02 +0000302 /* All mutexes are required for schema access. Make sure we hold them. */
303 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
drhd4530972014-09-09 14:47:53 +0000304#if SQLITE_USER_AUTHENTICATION
305 /* Only the admin user is allowed to know that the sqlite_user table
306 ** exists */
drhe933b832014-09-10 17:34:28 +0000307 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
308 return 0;
309 }
drhd4530972014-09-09 14:47:53 +0000310#endif
danielk197753c0f742005-03-29 03:10:59 +0000311 for(i=OMIT_TEMPDB; i<db->nDb; i++){
drh812d7a22003-03-27 13:50:00 +0000312 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
drh69c33822016-08-18 14:33:11 +0000313 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 ) break;
317 }
drhd24cc422003-03-27 12:51:24 +0000318 }
drh74e24cd2002-01-09 03:19:59 +0000319 return p;
drh75897232000-05-29 14:26:00 +0000320}
321
322/*
danielk19778a414492004-06-29 08:59:35 +0000323** Locate the in-memory structure that describes a particular database
324** table given the name of that table and (optionally) the name of the
325** database containing the table. Return NULL if not found. Also leave an
326** error message in pParse->zErrMsg.
drha69d9162003-04-17 22:57:53 +0000327**
danielk19778a414492004-06-29 08:59:35 +0000328** The difference between this routine and sqlite3FindTable() is that this
329** routine leaves an error message in pParse->zErrMsg where
330** sqlite3FindTable() does not.
drha69d9162003-04-17 22:57:53 +0000331*/
drhca424112008-01-25 15:04:48 +0000332Table *sqlite3LocateTable(
333 Parse *pParse, /* context in which to report errors */
drh4d249e62016-06-10 22:49:01 +0000334 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
drhca424112008-01-25 15:04:48 +0000335 const char *zName, /* Name of the table we are looking for */
336 const char *zDbase /* Name of the database. Might be NULL */
337){
drha69d9162003-04-17 22:57:53 +0000338 Table *p;
drhf26e09c2003-05-31 16:21:12 +0000339
danielk19778a414492004-06-29 08:59:35 +0000340 /* Read the database schema. If an error occurs, leave an error message
341 ** and code in pParse and return NULL. */
342 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
343 return 0;
344 }
345
danielk19774adee202004-05-08 08:23:19 +0000346 p = sqlite3FindTable(pParse->db, zName, zDbase);
drha69d9162003-04-17 22:57:53 +0000347 if( p==0 ){
drh4d249e62016-06-10 22:49:01 +0000348 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
drhd2975922015-08-29 17:22:33 +0000349#ifndef SQLITE_OMIT_VIRTUALTABLE
drhb4d472f2015-09-08 20:26:09 +0000350 if( sqlite3FindDbName(pParse->db, zDbase)<1 ){
351 /* If zName is the not the name of a table in the schema created using
352 ** CREATE, then check to see if it is the name of an virtual table that
353 ** can be an eponymous virtual table. */
354 Module *pMod = (Module*)sqlite3HashFind(&pParse->db->aModule, zName);
355 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
356 return pMod->pEpoTab;
357 }
drh51be3872015-08-19 02:32:25 +0000358 }
359#endif
drh4d249e62016-06-10 22:49:01 +0000360 if( (flags & LOCATE_NOERR)==0 ){
361 if( zDbase ){
362 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
363 }else{
364 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
365 }
366 pParse->checkSchema = 1;
drha69d9162003-04-17 22:57:53 +0000367 }
368 }
danfab1d402015-11-26 15:51:55 +0000369
drha69d9162003-04-17 22:57:53 +0000370 return p;
371}
372
373/*
dan41fb5cd2012-10-04 19:33:00 +0000374** Locate the table identified by *p.
375**
376** This is a wrapper around sqlite3LocateTable(). The difference between
377** sqlite3LocateTable() and this function is that this function restricts
378** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
379** non-NULL if it is part of a view or trigger program definition. See
380** sqlite3FixSrcList() for details.
381*/
382Table *sqlite3LocateTableItem(
383 Parse *pParse,
drh4d249e62016-06-10 22:49:01 +0000384 u32 flags,
dan41fb5cd2012-10-04 19:33:00 +0000385 struct SrcList_item *p
386){
387 const char *zDb;
388 assert( p->pSchema==0 || p->zDatabase==0 );
389 if( p->pSchema ){
390 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
drh69c33822016-08-18 14:33:11 +0000391 zDb = pParse->db->aDb[iDb].zDbSName;
dan41fb5cd2012-10-04 19:33:00 +0000392 }else{
393 zDb = p->zDatabase;
394 }
drh4d249e62016-06-10 22:49:01 +0000395 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
dan41fb5cd2012-10-04 19:33:00 +0000396}
397
398/*
drha69d9162003-04-17 22:57:53 +0000399** Locate the in-memory structure that describes
400** a particular index given the name of that index
401** and the name of the database that contains the index.
drhf57b3392001-10-08 13:22:32 +0000402** Return NULL if not found.
drhf26e09c2003-05-31 16:21:12 +0000403**
404** If zDatabase is 0, all databases are searched for the
405** table and the first matching index is returned. (No checking
406** for duplicate index names is done.) The search order is
407** TEMP first, then MAIN, then any auxiliary databases added
408** using the ATTACH command.
drh75897232000-05-29 14:26:00 +0000409*/
drh9bb575f2004-09-06 17:24:11 +0000410Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
drhd24cc422003-03-27 12:51:24 +0000411 Index *p = 0;
412 int i;
drh21206082011-04-04 18:22:02 +0000413 /* All mutexes are required for schema access. Make sure we hold them. */
414 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
danielk197753c0f742005-03-29 03:10:59 +0000415 for(i=OMIT_TEMPDB; i<db->nDb; i++){
drh812d7a22003-03-27 13:50:00 +0000416 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
danielk1977e501b892006-01-09 06:29:47 +0000417 Schema *pSchema = db->aDb[j].pSchema;
drh04491712009-05-13 17:21:13 +0000418 assert( pSchema );
drh69c33822016-08-18 14:33:11 +0000419 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zDbSName) ) continue;
drh21206082011-04-04 18:22:02 +0000420 assert( sqlite3SchemaMutexHeld(db, j, 0) );
drhacbcb7e2014-08-21 20:26:37 +0000421 p = sqlite3HashFind(&pSchema->idxHash, zName);
drhd24cc422003-03-27 12:51:24 +0000422 if( p ) break;
423 }
drh74e24cd2002-01-09 03:19:59 +0000424 return p;
drh75897232000-05-29 14:26:00 +0000425}
426
427/*
drh956bc922004-07-24 17:38:29 +0000428** Reclaim the memory used by an index
429*/
dan1feeaed2010-07-23 15:41:47 +0000430static void freeIndex(sqlite3 *db, Index *p){
drh92aa5ea2009-09-11 14:05:06 +0000431#ifndef SQLITE_OMIT_ANALYZE
dand46def72010-07-24 11:28:28 +0000432 sqlite3DeleteIndexSamples(db, p);
drh92aa5ea2009-09-11 14:05:06 +0000433#endif
drh1fe05372013-07-31 18:12:26 +0000434 sqlite3ExprDelete(db, p->pPartIdxWhere);
drh1f9ca2c2015-08-25 16:57:52 +0000435 sqlite3ExprListDelete(db, p->aColExpr);
drh633e6d52008-07-28 19:34:53 +0000436 sqlite3DbFree(db, p->zColAff);
mistachkin5905f862015-12-31 19:04:42 +0000437 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
drh75b170b2014-10-04 00:07:44 +0000438#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
439 sqlite3_free(p->aiRowEst);
440#endif
drh633e6d52008-07-28 19:34:53 +0000441 sqlite3DbFree(db, p);
drh956bc922004-07-24 17:38:29 +0000442}
443
444/*
drhc96d8532005-05-03 12:30:33 +0000445** For the index called zIdxName which is found in the database iDb,
446** unlike that index from its Table then remove the index from
447** the index hash table and free all memory structures associated
448** with the index.
drh5e00f6c2001-09-13 13:46:56 +0000449*/
drh9bb575f2004-09-06 17:24:11 +0000450void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
drh956bc922004-07-24 17:38:29 +0000451 Index *pIndex;
drh21206082011-04-04 18:22:02 +0000452 Hash *pHash;
drh956bc922004-07-24 17:38:29 +0000453
drh21206082011-04-04 18:22:02 +0000454 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
455 pHash = &db->aDb[iDb].pSchema->idxHash;
drhacbcb7e2014-08-21 20:26:37 +0000456 pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
drh22645842011-03-24 01:34:03 +0000457 if( ALWAYS(pIndex) ){
drh956bc922004-07-24 17:38:29 +0000458 if( pIndex->pTable->pIndex==pIndex ){
459 pIndex->pTable->pIndex = pIndex->pNext;
460 }else{
461 Index *p;
drh04491712009-05-13 17:21:13 +0000462 /* Justification of ALWAYS(); The index must be on the list of
463 ** indices. */
464 p = pIndex->pTable->pIndex;
465 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
466 if( ALWAYS(p && p->pNext==pIndex) ){
drh956bc922004-07-24 17:38:29 +0000467 p->pNext = pIndex->pNext;
468 }
drh5e00f6c2001-09-13 13:46:56 +0000469 }
dan1feeaed2010-07-23 15:41:47 +0000470 freeIndex(db, pIndex);
drh5e00f6c2001-09-13 13:46:56 +0000471 }
drh956bc922004-07-24 17:38:29 +0000472 db->flags |= SQLITE_InternChanges;
drh5e00f6c2001-09-13 13:46:56 +0000473}
474
475/*
drh81028a42012-05-15 18:28:27 +0000476** Look through the list of open database files in db->aDb[] and if
477** any have been closed, remove them from the list. Reallocate the
478** db->aDb[] structure to a smaller size, if possible.
drh1c2d8412003-03-31 00:30:47 +0000479**
drh81028a42012-05-15 18:28:27 +0000480** Entry 0 (the "main" database) and entry 1 (the "temp" database)
481** are never candidates for being collapsed.
drh74e24cd2002-01-09 03:19:59 +0000482*/
drh81028a42012-05-15 18:28:27 +0000483void sqlite3CollapseDatabaseArray(sqlite3 *db){
drh1c2d8412003-03-31 00:30:47 +0000484 int i, j;
drh1c2d8412003-03-31 00:30:47 +0000485 for(i=j=2; i<db->nDb; i++){
drh4d189ca2004-02-12 18:46:38 +0000486 struct Db *pDb = &db->aDb[i];
487 if( pDb->pBt==0 ){
drh69c33822016-08-18 14:33:11 +0000488 sqlite3DbFree(db, pDb->zDbSName);
489 pDb->zDbSName = 0;
drh1c2d8412003-03-31 00:30:47 +0000490 continue;
491 }
492 if( j<i ){
drh8bf8dc92003-05-17 17:35:10 +0000493 db->aDb[j] = db->aDb[i];
drh1c2d8412003-03-31 00:30:47 +0000494 }
drh8bf8dc92003-05-17 17:35:10 +0000495 j++;
drh1c2d8412003-03-31 00:30:47 +0000496 }
drh1c2d8412003-03-31 00:30:47 +0000497 db->nDb = j;
498 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
499 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
drh633e6d52008-07-28 19:34:53 +0000500 sqlite3DbFree(db, db->aDb);
drh1c2d8412003-03-31 00:30:47 +0000501 db->aDb = db->aDbStatic;
502 }
drhe0bc4042002-06-25 01:09:11 +0000503}
504
505/*
drh81028a42012-05-15 18:28:27 +0000506** Reset the schema for the database at index iDb. Also reset the
507** TEMP schema.
508*/
509void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
drhbae591a2012-06-05 19:20:03 +0000510 Db *pDb;
drh81028a42012-05-15 18:28:27 +0000511 assert( iDb<db->nDb );
512
513 /* Case 1: Reset the single schema identified by iDb */
drhbae591a2012-06-05 19:20:03 +0000514 pDb = &db->aDb[iDb];
drh81028a42012-05-15 18:28:27 +0000515 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
516 assert( pDb->pSchema!=0 );
517 sqlite3SchemaClear(pDb->pSchema);
518
519 /* If any database other than TEMP is reset, then also reset TEMP
520 ** since TEMP might be holding triggers that reference tables in the
521 ** other database.
522 */
523 if( iDb!=1 ){
524 pDb = &db->aDb[1];
525 assert( pDb->pSchema!=0 );
526 sqlite3SchemaClear(pDb->pSchema);
527 }
528 return;
529}
530
531/*
532** Erase all schema information from all attached databases (including
533** "main" and "temp") for a single database connection.
534*/
535void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
536 int i;
537 sqlite3BtreeEnterAll(db);
538 for(i=0; i<db->nDb; i++){
539 Db *pDb = &db->aDb[i];
540 if( pDb->pSchema ){
541 sqlite3SchemaClear(pDb->pSchema);
542 }
543 }
544 db->flags &= ~SQLITE_InternChanges;
545 sqlite3VtabUnlockList(db);
546 sqlite3BtreeLeaveAll(db);
547 sqlite3CollapseDatabaseArray(db);
548}
549
550/*
drhe0bc4042002-06-25 01:09:11 +0000551** This routine is called when a commit occurs.
552*/
drh9bb575f2004-09-06 17:24:11 +0000553void sqlite3CommitInternalChanges(sqlite3 *db){
drhe0bc4042002-06-25 01:09:11 +0000554 db->flags &= ~SQLITE_InternChanges;
drh74e24cd2002-01-09 03:19:59 +0000555}
556
557/*
dand46def72010-07-24 11:28:28 +0000558** Delete memory allocated for the column names of a table or view (the
559** Table.aCol[] array).
drh956bc922004-07-24 17:38:29 +0000560*/
drh51be3872015-08-19 02:32:25 +0000561void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
drh956bc922004-07-24 17:38:29 +0000562 int i;
563 Column *pCol;
564 assert( pTable!=0 );
drhdd5b2fa2005-03-28 03:39:55 +0000565 if( (pCol = pTable->aCol)!=0 ){
566 for(i=0; i<pTable->nCol; i++, pCol++){
drh633e6d52008-07-28 19:34:53 +0000567 sqlite3DbFree(db, pCol->zName);
568 sqlite3ExprDelete(db, pCol->pDflt);
drh633e6d52008-07-28 19:34:53 +0000569 sqlite3DbFree(db, pCol->zColl);
drhdd5b2fa2005-03-28 03:39:55 +0000570 }
drh633e6d52008-07-28 19:34:53 +0000571 sqlite3DbFree(db, pTable->aCol);
drh956bc922004-07-24 17:38:29 +0000572 }
drh956bc922004-07-24 17:38:29 +0000573}
574
575/*
drh75897232000-05-29 14:26:00 +0000576** Remove the memory data structures associated with the given
drh967e8b72000-06-21 13:59:10 +0000577** Table. No changes are made to disk by this routine.
drh75897232000-05-29 14:26:00 +0000578**
579** This routine just deletes the data structure. It does not unlink
drhe61922a2009-05-02 13:29:37 +0000580** the table data structure from the hash table. But it does destroy
drhc2eef3b2002-08-31 18:53:06 +0000581** memory structures of the indices and foreign keys associated with
582** the table.
drh29ddd3a2012-05-15 12:49:32 +0000583**
584** The db parameter is optional. It is needed if the Table object
585** contains lookaside memory. (Table objects in the schema do not use
586** lookaside memory, but some ephemeral Table objects do.) Or the
587** db parameter can be used with db->pnBytesFreed to measure the memory
588** used by the Table object.
drh75897232000-05-29 14:26:00 +0000589*/
drhe8da01c2016-05-07 12:15:34 +0000590static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
drh75897232000-05-29 14:26:00 +0000591 Index *pIndex, *pNext;
drh29ddd3a2012-05-15 12:49:32 +0000592 TESTONLY( int nLookaside; ) /* Used to verify lookaside not used for schema */
drhc2eef3b2002-08-31 18:53:06 +0000593
drh29ddd3a2012-05-15 12:49:32 +0000594 /* Record the number of outstanding lookaside allocations in schema Tables
595 ** prior to doing any free() operations. Since schema Tables do not use
596 ** lookaside, this number should not change. */
597 TESTONLY( nLookaside = (db && (pTable->tabFlags & TF_Ephemeral)==0) ?
598 db->lookaside.nOut : 0 );
599
dand46def72010-07-24 11:28:28 +0000600 /* Delete all indices associated with this table. */
drhc2eef3b2002-08-31 18:53:06 +0000601 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
602 pNext = pIndex->pNext;
drh62340f82016-05-31 21:18:15 +0000603 assert( pIndex->pSchema==pTable->pSchema
604 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
drh273bfe92016-06-02 16:22:53 +0000605 if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){
dand46def72010-07-24 11:28:28 +0000606 char *zName = pIndex->zName;
607 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
drhacbcb7e2014-08-21 20:26:37 +0000608 &pIndex->pSchema->idxHash, zName, 0
dand46def72010-07-24 11:28:28 +0000609 );
drh21206082011-04-04 18:22:02 +0000610 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
dand46def72010-07-24 11:28:28 +0000611 assert( pOld==pIndex || pOld==0 );
612 }
613 freeIndex(db, pIndex);
drhc2eef3b2002-08-31 18:53:06 +0000614 }
615
dan1da40a32009-09-19 17:00:31 +0000616 /* Delete any foreign keys attached to this table. */
dan1feeaed2010-07-23 15:41:47 +0000617 sqlite3FkDelete(db, pTable);
drhc2eef3b2002-08-31 18:53:06 +0000618
619 /* Delete the Table structure itself.
620 */
drh51be3872015-08-19 02:32:25 +0000621 sqlite3DeleteColumnNames(db, pTable);
drh633e6d52008-07-28 19:34:53 +0000622 sqlite3DbFree(db, pTable->zName);
623 sqlite3DbFree(db, pTable->zColAff);
624 sqlite3SelectDelete(db, pTable->pSelect);
drh2938f922012-03-07 19:13:29 +0000625 sqlite3ExprListDelete(db, pTable->pCheck);
drh078e4082010-07-28 19:17:51 +0000626#ifndef SQLITE_OMIT_VIRTUALTABLE
dan1feeaed2010-07-23 15:41:47 +0000627 sqlite3VtabClear(db, pTable);
drh078e4082010-07-28 19:17:51 +0000628#endif
drh633e6d52008-07-28 19:34:53 +0000629 sqlite3DbFree(db, pTable);
drh29ddd3a2012-05-15 12:49:32 +0000630
631 /* Verify that no lookaside memory was used by schema tables */
632 assert( nLookaside==0 || nLookaside==db->lookaside.nOut );
drh75897232000-05-29 14:26:00 +0000633}
drhe8da01c2016-05-07 12:15:34 +0000634void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
635 /* Do not delete the table until the reference count reaches zero. */
636 if( !pTable ) return;
637 if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return;
638 deleteTable(db, pTable);
639}
640
drh75897232000-05-29 14:26:00 +0000641
642/*
drh5edc3122001-09-13 21:53:09 +0000643** Unlink the given table from the hash tables and the delete the
drhc2eef3b2002-08-31 18:53:06 +0000644** table structure with all its indices and foreign keys.
drh5edc3122001-09-13 21:53:09 +0000645*/
drh9bb575f2004-09-06 17:24:11 +0000646void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
drh956bc922004-07-24 17:38:29 +0000647 Table *p;
drh956bc922004-07-24 17:38:29 +0000648 Db *pDb;
649
drhd229ca92002-01-09 13:30:41 +0000650 assert( db!=0 );
drh956bc922004-07-24 17:38:29 +0000651 assert( iDb>=0 && iDb<db->nDb );
drh972a2312009-12-08 14:34:08 +0000652 assert( zTabName );
drh21206082011-04-04 18:22:02 +0000653 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh972a2312009-12-08 14:34:08 +0000654 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
drh956bc922004-07-24 17:38:29 +0000655 pDb = &db->aDb[iDb];
drhacbcb7e2014-08-21 20:26:37 +0000656 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
dan1feeaed2010-07-23 15:41:47 +0000657 sqlite3DeleteTable(db, p);
drh956bc922004-07-24 17:38:29 +0000658 db->flags |= SQLITE_InternChanges;
drh74e24cd2002-01-09 03:19:59 +0000659}
660
661/*
drha99db3b2004-06-19 14:49:12 +0000662** Given a token, return a string that consists of the text of that
drh24fb6272009-05-01 21:13:36 +0000663** token. Space to hold the returned string
drha99db3b2004-06-19 14:49:12 +0000664** is obtained from sqliteMalloc() and must be freed by the calling
665** function.
drh75897232000-05-29 14:26:00 +0000666**
drh24fb6272009-05-01 21:13:36 +0000667** Any quotation marks (ex: "name", 'name', [name], or `name`) that
668** surround the body of the token are removed.
669**
drhc96d8532005-05-03 12:30:33 +0000670** Tokens are often just pointers into the original SQL text and so
drha99db3b2004-06-19 14:49:12 +0000671** are not \000 terminated and are not persistent. The returned string
672** is \000 terminated and is persistent.
drh75897232000-05-29 14:26:00 +0000673*/
drh17435752007-08-16 04:30:38 +0000674char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
drha99db3b2004-06-19 14:49:12 +0000675 char *zName;
676 if( pName ){
drh17435752007-08-16 04:30:38 +0000677 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
drhb7916a72009-05-27 10:31:29 +0000678 sqlite3Dequote(zName);
drha99db3b2004-06-19 14:49:12 +0000679 }else{
680 zName = 0;
681 }
drh75897232000-05-29 14:26:00 +0000682 return zName;
683}
684
685/*
danielk1977cbb18d22004-05-28 11:37:27 +0000686** Open the sqlite_master table stored in database number iDb for
687** writing. The table is opened using cursor 0.
drhe0bc4042002-06-25 01:09:11 +0000688*/
danielk1977c00da102006-01-07 13:21:04 +0000689void sqlite3OpenMasterTable(Parse *p, int iDb){
690 Vdbe *v = sqlite3GetVdbe(p);
691 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
drh261c02d2013-10-25 14:46:15 +0000692 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
danielk19776ab3a2e2009-02-19 14:39:25 +0000693 if( p->nTab==0 ){
694 p->nTab = 1;
695 }
drhe0bc4042002-06-25 01:09:11 +0000696}
697
698/*
danielk197704103022009-02-03 16:51:24 +0000699** Parameter zName points to a nul-terminated buffer containing the name
700** of a database ("main", "temp" or the name of an attached db). This
701** function returns the index of the named database in db->aDb[], or
702** -1 if the named db cannot be found.
danielk1977cbb18d22004-05-28 11:37:27 +0000703*/
danielk197704103022009-02-03 16:51:24 +0000704int sqlite3FindDbName(sqlite3 *db, const char *zName){
705 int i = -1; /* Database number */
drh73c42a12004-11-20 18:13:10 +0000706 if( zName ){
danielk197704103022009-02-03 16:51:24 +0000707 Db *pDb;
danielk1977576ec6b2005-01-21 11:55:25 +0000708 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
drh69c33822016-08-18 14:33:11 +0000709 if( 0==sqlite3StrICmp(pDb->zDbSName, zName) ) break;
danielk1977cbb18d22004-05-28 11:37:27 +0000710 }
711 }
danielk1977576ec6b2005-01-21 11:55:25 +0000712 return i;
danielk1977cbb18d22004-05-28 11:37:27 +0000713}
714
danielk197704103022009-02-03 16:51:24 +0000715/*
716** The token *pName contains the name of a database (either "main" or
717** "temp" or the name of an attached db). This routine returns the
718** index of the named database in db->aDb[], or -1 if the named db
719** does not exist.
720*/
721int sqlite3FindDb(sqlite3 *db, Token *pName){
722 int i; /* Database number */
723 char *zName; /* Name we are searching for */
724 zName = sqlite3NameFromToken(db, pName);
725 i = sqlite3FindDbName(db, zName);
726 sqlite3DbFree(db, zName);
727 return i;
728}
729
drh0e3d7472004-06-19 17:33:07 +0000730/* The table or view or trigger name is passed to this routine via tokens
731** pName1 and pName2. If the table name was fully qualified, for example:
732**
733** CREATE TABLE xxx.yyy (...);
734**
735** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
736** the table name is not fully qualified, i.e.:
737**
738** CREATE TABLE yyy(...);
739**
740** Then pName1 is set to "yyy" and pName2 is "".
741**
742** This routine sets the *ppUnqual pointer to point at the token (pName1 or
743** pName2) that stores the unqualified table name. The index of the
744** database "xxx" is returned.
745*/
danielk1977ef2cb632004-05-29 02:37:19 +0000746int sqlite3TwoPartName(
drh0e3d7472004-06-19 17:33:07 +0000747 Parse *pParse, /* Parsing and code generating context */
drh90f5ecb2004-07-22 01:19:35 +0000748 Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
drh0e3d7472004-06-19 17:33:07 +0000749 Token *pName2, /* The "yyy" in the name "xxx.yyy" */
750 Token **pUnqual /* Write the unqualified object name here */
danielk1977cbb18d22004-05-28 11:37:27 +0000751){
drh0e3d7472004-06-19 17:33:07 +0000752 int iDb; /* Database holding the object */
danielk1977cbb18d22004-05-28 11:37:27 +0000753 sqlite3 *db = pParse->db;
754
drh055f2982016-01-15 15:06:41 +0000755 assert( pName2!=0 );
756 if( pName2->n>0 ){
shanedcc50b72008-11-13 18:29:50 +0000757 if( db->init.busy ) {
758 sqlite3ErrorMsg(pParse, "corrupt database");
shanedcc50b72008-11-13 18:29:50 +0000759 return -1;
760 }
danielk1977cbb18d22004-05-28 11:37:27 +0000761 *pUnqual = pName2;
drhff2d5ea2005-07-23 00:41:48 +0000762 iDb = sqlite3FindDb(db, pName1);
danielk1977cbb18d22004-05-28 11:37:27 +0000763 if( iDb<0 ){
764 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
danielk1977cbb18d22004-05-28 11:37:27 +0000765 return -1;
766 }
767 }else{
drh9ef5e772016-08-19 14:20:56 +0000768 assert( db->init.iDb==0 || db->init.busy || (db->flags & SQLITE_Vacuum)!=0);
danielk1977cbb18d22004-05-28 11:37:27 +0000769 iDb = db->init.iDb;
770 *pUnqual = pName1;
771 }
772 return iDb;
773}
774
775/*
danielk1977d8123362004-06-12 09:25:12 +0000776** This routine is used to check if the UTF-8 string zName is a legal
777** unqualified name for a new schema object (table, index, view or
778** trigger). All names are legal except those that begin with the string
779** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
780** is reserved for internal use.
781*/
782int sqlite3CheckObjectName(Parse *pParse, const char *zName){
drhf1974842004-11-05 03:56:00 +0000783 if( !pParse->db->init.busy && pParse->nested==0
danielk19773a3f38e2005-05-22 06:49:56 +0000784 && (pParse->db->flags & SQLITE_WriteSchema)==0
drhf1974842004-11-05 03:56:00 +0000785 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
danielk1977d8123362004-06-12 09:25:12 +0000786 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
787 return SQLITE_ERROR;
788 }
789 return SQLITE_OK;
790}
791
792/*
drh44156282013-10-23 22:23:03 +0000793** Return the PRIMARY KEY index of a table
794*/
795Index *sqlite3PrimaryKeyIndex(Table *pTab){
796 Index *p;
drh48dd1d82014-05-27 18:18:58 +0000797 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
drh44156282013-10-23 22:23:03 +0000798 return p;
799}
800
801/*
802** Return the column of index pIdx that corresponds to table
803** column iCol. Return -1 if not found.
804*/
805i16 sqlite3ColumnOfIndex(Index *pIdx, i16 iCol){
806 int i;
807 for(i=0; i<pIdx->nColumn; i++){
808 if( iCol==pIdx->aiColumn[i] ) return i;
809 }
810 return -1;
811}
812
813/*
drh75897232000-05-29 14:26:00 +0000814** Begin constructing a new table representation in memory. This is
815** the first of several action routines that get called in response
drhd9b02572001-04-15 00:37:09 +0000816** to a CREATE TABLE statement. In particular, this routine is called
drh74161702006-02-24 02:53:49 +0000817** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
drhe0bc4042002-06-25 01:09:11 +0000818** flag is true if the table should be stored in the auxiliary database
819** file instead of in the main database file. This is normally the case
820** when the "TEMP" or "TEMPORARY" keyword occurs in between
drhf57b3392001-10-08 13:22:32 +0000821** CREATE and TABLE.
drhd9b02572001-04-15 00:37:09 +0000822**
drhf57b3392001-10-08 13:22:32 +0000823** The new table record is initialized and put in pParse->pNewTable.
824** As more of the CREATE TABLE statement is parsed, additional action
825** routines will be called to add more information to this record.
danielk19774adee202004-05-08 08:23:19 +0000826** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
drhf57b3392001-10-08 13:22:32 +0000827** is called to complete the construction of the new table record.
drh75897232000-05-29 14:26:00 +0000828*/
danielk19774adee202004-05-08 08:23:19 +0000829void sqlite3StartTable(
drhe5f9c642003-01-13 23:27:31 +0000830 Parse *pParse, /* Parser context */
danielk1977cbb18d22004-05-28 11:37:27 +0000831 Token *pName1, /* First part of the name of the table or view */
832 Token *pName2, /* Second part of the name of the table or view */
drhe5f9c642003-01-13 23:27:31 +0000833 int isTemp, /* True if this is a TEMP table */
drhfaa59552005-12-29 23:33:54 +0000834 int isView, /* True if this is a VIEW */
danielk1977f1a381e2006-06-16 08:01:02 +0000835 int isVirtual, /* True if this is a VIRTUAL table */
drhfaa59552005-12-29 23:33:54 +0000836 int noErr /* Do nothing if table already exists */
drhe5f9c642003-01-13 23:27:31 +0000837){
drh75897232000-05-29 14:26:00 +0000838 Table *pTable;
drh23bf66d2004-12-14 03:34:34 +0000839 char *zName = 0; /* The name of the new table */
drh9bb575f2004-09-06 17:24:11 +0000840 sqlite3 *db = pParse->db;
drhadbca9c2001-09-27 15:11:53 +0000841 Vdbe *v;
danielk1977cbb18d22004-05-28 11:37:27 +0000842 int iDb; /* Database number to create the table in */
843 Token *pName; /* Unqualified name of the table to create */
drh75897232000-05-29 14:26:00 +0000844
drh055f2982016-01-15 15:06:41 +0000845 if( db->init.busy && db->init.newTnum==1 ){
846 /* Special case: Parsing the sqlite_master or sqlite_temp_master schema */
847 iDb = db->init.iDb;
848 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
849 pName = pName1;
850 }else{
851 /* The common case */
852 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
853 if( iDb<0 ) return;
854 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
855 /* If creating a temp table, the name may not be qualified. Unless
856 ** the database name is "temp" anyway. */
857 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
858 return;
859 }
860 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
861 zName = sqlite3NameFromToken(db, pName);
danielk1977cbb18d22004-05-28 11:37:27 +0000862 }
danielk1977cbb18d22004-05-28 11:37:27 +0000863 pParse->sNameToken = *pName;
danielk1977e0048402004-06-15 16:51:01 +0000864 if( zName==0 ) return;
danielk1977d8123362004-06-12 09:25:12 +0000865 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
drh23bf66d2004-12-14 03:34:34 +0000866 goto begin_table_error;
danielk1977d8123362004-06-12 09:25:12 +0000867 }
drh1d85d932004-02-14 23:05:52 +0000868 if( db->init.iDb==1 ) isTemp = 1;
drhe5f9c642003-01-13 23:27:31 +0000869#ifndef SQLITE_OMIT_AUTHORIZATION
drh055f2982016-01-15 15:06:41 +0000870 assert( isTemp==0 || isTemp==1 );
871 assert( isView==0 || isView==1 );
drhe5f9c642003-01-13 23:27:31 +0000872 {
drh055f2982016-01-15 15:06:41 +0000873 static const u8 aCode[] = {
874 SQLITE_CREATE_TABLE,
875 SQLITE_CREATE_TEMP_TABLE,
876 SQLITE_CREATE_VIEW,
877 SQLITE_CREATE_TEMP_VIEW
878 };
drh69c33822016-08-18 14:33:11 +0000879 char *zDb = db->aDb[iDb].zDbSName;
danielk19774adee202004-05-08 08:23:19 +0000880 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +0000881 goto begin_table_error;
drhe22a3342003-04-22 20:30:37 +0000882 }
drh055f2982016-01-15 15:06:41 +0000883 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
884 zName, 0, zDb) ){
drh23bf66d2004-12-14 03:34:34 +0000885 goto begin_table_error;
drhe5f9c642003-01-13 23:27:31 +0000886 }
887 }
888#endif
drhf57b3392001-10-08 13:22:32 +0000889
drhf57b3392001-10-08 13:22:32 +0000890 /* Make sure the new table name does not collide with an existing
danielk19773df6b252004-05-29 10:23:19 +0000891 ** index or table name in the same database. Issue an error message if
danielk19777e6ebfb2006-06-12 11:24:37 +0000892 ** it does. The exception is if the statement being parsed was passed
893 ** to an sqlite3_declare_vtab() call. In that case only the column names
894 ** and types will be used, so there is no need to test for namespace
895 ** collisions.
drhf57b3392001-10-08 13:22:32 +0000896 */
danielk19777e6ebfb2006-06-12 11:24:37 +0000897 if( !IN_DECLARE_VTAB ){
drh69c33822016-08-18 14:33:11 +0000898 char *zDb = db->aDb[iDb].zDbSName;
danielk19777e6ebfb2006-06-12 11:24:37 +0000899 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
900 goto begin_table_error;
drhfaa59552005-12-29 23:33:54 +0000901 }
dana16d1062010-09-28 17:37:28 +0000902 pTable = sqlite3FindTable(db, zName, zDb);
danielk19777e6ebfb2006-06-12 11:24:37 +0000903 if( pTable ){
904 if( !noErr ){
905 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
dan7687c832011-04-09 15:39:02 +0000906 }else{
drh33c59ec2015-04-19 20:39:17 +0000907 assert( !db->init.busy || CORRUPT_DB );
dan7687c832011-04-09 15:39:02 +0000908 sqlite3CodeVerifySchema(pParse, iDb);
danielk19777e6ebfb2006-06-12 11:24:37 +0000909 }
910 goto begin_table_error;
911 }
drh8a8a0d12010-09-28 20:26:44 +0000912 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
danielk19777e6ebfb2006-06-12 11:24:37 +0000913 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
914 goto begin_table_error;
915 }
drh75897232000-05-29 14:26:00 +0000916 }
danielk19777e6ebfb2006-06-12 11:24:37 +0000917
danielk197726783a52007-08-29 14:06:22 +0000918 pTable = sqlite3DbMallocZero(db, sizeof(Table));
drh6d4abfb2001-10-22 02:58:08 +0000919 if( pTable==0 ){
drh4df86af2016-02-04 11:48:00 +0000920 assert( db->mallocFailed );
mistachkinfad30392016-02-13 23:43:46 +0000921 pParse->rc = SQLITE_NOMEM_BKPT;
danielk1977e0048402004-06-15 16:51:01 +0000922 pParse->nErr++;
drh23bf66d2004-12-14 03:34:34 +0000923 goto begin_table_error;
drh6d4abfb2001-10-22 02:58:08 +0000924 }
drh75897232000-05-29 14:26:00 +0000925 pTable->zName = zName;
drh4a324312001-12-21 14:30:42 +0000926 pTable->iPKey = -1;
danielk1977da184232006-01-05 11:34:32 +0000927 pTable->pSchema = db->aDb[iDb].pSchema;
drhed8a3bb2005-06-06 21:19:56 +0000928 pTable->nRef = 1;
dancfc9df72014-04-25 15:01:01 +0000929 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
drhc4a64fa2009-05-11 20:53:28 +0000930 assert( pParse->pNewTable==0 );
drh75897232000-05-29 14:26:00 +0000931 pParse->pNewTable = pTable;
drh17f71932002-02-21 12:01:27 +0000932
drh4794f732004-11-05 17:17:50 +0000933 /* If this is the magic sqlite_sequence table used by autoincrement,
934 ** then record a pointer to this table in the main database structure
935 ** so that INSERT can find the table easily.
936 */
937#ifndef SQLITE_OMIT_AUTOINCREMENT
drh78776ec2005-06-14 02:12:46 +0000938 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
drh21206082011-04-04 18:22:02 +0000939 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danielk1977da184232006-01-05 11:34:32 +0000940 pTable->pSchema->pSeqTab = pTable;
drh4794f732004-11-05 17:17:50 +0000941 }
942#endif
943
drh17f71932002-02-21 12:01:27 +0000944 /* Begin generating the code that will insert the table record into
945 ** the SQLITE_MASTER table. Note in particular that we must go ahead
946 ** and allocate the record number for the table entry now. Before any
947 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
948 ** indices to be created and the table record must come before the
949 ** indices. Hence, the record number for the table must be allocated
950 ** now.
951 */
danielk19774adee202004-05-08 08:23:19 +0000952 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
drh728e0f92015-10-10 14:41:28 +0000953 int addr1;
drhe321c292006-01-12 01:56:43 +0000954 int fileFormat;
drhb7654112008-01-12 12:48:07 +0000955 int reg1, reg2, reg3;
drh3c03afd2015-09-09 13:28:06 +0000956 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
957 static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
drh0dd5cda2015-06-16 16:39:01 +0000958 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +0000959
danielk197720b1eaf2006-07-26 16:22:14 +0000960#ifndef SQLITE_OMIT_VIRTUALTABLE
961 if( isVirtual ){
drh66a51672008-01-03 00:01:23 +0000962 sqlite3VdbeAddOp0(v, OP_VBegin);
danielk197720b1eaf2006-07-26 16:22:14 +0000963 }
964#endif
965
danielk197736963fd2005-02-19 08:18:05 +0000966 /* If the file format and encoding in the database have not been set,
967 ** set them now.
danielk1977d008cfe2004-06-19 02:22:10 +0000968 */
drhb7654112008-01-12 12:48:07 +0000969 reg1 = pParse->regRowid = ++pParse->nMem;
970 reg2 = pParse->regRoot = ++pParse->nMem;
971 reg3 = ++pParse->nMem;
danielk19770d19f7a2009-06-03 11:25:07 +0000972 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
drhfb982642007-08-30 01:19:59 +0000973 sqlite3VdbeUsesBtree(v, iDb);
drh728e0f92015-10-10 14:41:28 +0000974 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
drhe321c292006-01-12 01:56:43 +0000975 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
drh76fe8032006-07-11 14:17:51 +0000976 1 : SQLITE_MAX_FILE_FORMAT;
drh1861afc2016-02-01 21:48:34 +0000977 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
978 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
drh728e0f92015-10-10 14:41:28 +0000979 sqlite3VdbeJumpHere(v, addr1);
danielk1977d008cfe2004-06-19 02:22:10 +0000980
drh4794f732004-11-05 17:17:50 +0000981 /* This just creates a place-holder record in the sqlite_master table.
982 ** The record created does not contain anything yet. It will be replaced
983 ** by the real entry in code generated at sqlite3EndTable().
drhb17131a2004-11-05 22:18:49 +0000984 **
drh0fa991b2009-03-21 16:19:26 +0000985 ** The rowid for the new entry is left in register pParse->regRowid.
986 ** The root page number of the new table is left in reg pParse->regRoot.
987 ** The rowid and root page number values are needed by the code that
988 ** sqlite3EndTable will generate.
drh4794f732004-11-05 17:17:50 +0000989 */
danielk1977f1a381e2006-06-16 08:01:02 +0000990#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
991 if( isView || isVirtual ){
drhb7654112008-01-12 12:48:07 +0000992 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
danielk1977a21c6b62005-01-24 10:25:59 +0000993 }else
994#endif
995 {
drh8a120f82013-11-01 17:59:53 +0000996 pParse->addrCrTab = sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
danielk1977a21c6b62005-01-24 10:25:59 +0000997 }
danielk1977c00da102006-01-07 13:21:04 +0000998 sqlite3OpenMasterTable(pParse, iDb);
drhb7654112008-01-12 12:48:07 +0000999 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
drh3c03afd2015-09-09 13:28:06 +00001000 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
drhb7654112008-01-12 12:48:07 +00001001 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
1002 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
drh66a51672008-01-03 00:01:23 +00001003 sqlite3VdbeAddOp0(v, OP_Close);
drh5e00f6c2001-09-13 13:46:56 +00001004 }
drh23bf66d2004-12-14 03:34:34 +00001005
1006 /* Normal (non-error) return. */
1007 return;
1008
1009 /* If an error occurs, we jump here */
1010begin_table_error:
drh633e6d52008-07-28 19:34:53 +00001011 sqlite3DbFree(db, zName);
drh23bf66d2004-12-14 03:34:34 +00001012 return;
drh75897232000-05-29 14:26:00 +00001013}
1014
drh03d69a62015-11-19 13:53:57 +00001015/* Set properties of a table column based on the (magical)
1016** name of the column.
1017*/
drh03d69a62015-11-19 13:53:57 +00001018#if SQLITE_ENABLE_HIDDEN_COLUMNS
drhe6110502015-12-31 15:34:03 +00001019void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
drh03d69a62015-11-19 13:53:57 +00001020 if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
1021 pCol->colFlags |= COLFLAG_HIDDEN;
danba68f8f2015-11-19 16:46:46 +00001022 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
1023 pTab->tabFlags |= TF_OOOHidden;
drh03d69a62015-11-19 13:53:57 +00001024 }
drh03d69a62015-11-19 13:53:57 +00001025}
drhe6110502015-12-31 15:34:03 +00001026#endif
drh03d69a62015-11-19 13:53:57 +00001027
1028
drh75897232000-05-29 14:26:00 +00001029/*
1030** Add a new column to the table currently being constructed.
drhd9b02572001-04-15 00:37:09 +00001031**
1032** The parser calls this routine once for each column declaration
danielk19774adee202004-05-08 08:23:19 +00001033** in a CREATE TABLE statement. sqlite3StartTable() gets called
drhd9b02572001-04-15 00:37:09 +00001034** first to get things going. Then this routine is called for each
1035** column.
drh75897232000-05-29 14:26:00 +00001036*/
drh2881ab62016-02-27 23:25:36 +00001037void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){
drh75897232000-05-29 14:26:00 +00001038 Table *p;
drh97fc3d02002-05-22 21:27:03 +00001039 int i;
drha99db3b2004-06-19 14:49:12 +00001040 char *z;
drh94eaafa2016-02-29 15:53:11 +00001041 char *zType;
drhc9b84a12002-06-20 11:36:48 +00001042 Column *pCol;
drhbb4957f2008-03-20 14:03:29 +00001043 sqlite3 *db = pParse->db;
drh75897232000-05-29 14:26:00 +00001044 if( (p = pParse->pNewTable)==0 ) return;
drhbb4957f2008-03-20 14:03:29 +00001045#if SQLITE_MAX_COLUMN
1046 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
drhe5c941b2007-05-08 13:58:26 +00001047 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
1048 return;
1049 }
drhbb4957f2008-03-20 14:03:29 +00001050#endif
drh94eaafa2016-02-29 15:53:11 +00001051 z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
drh97fc3d02002-05-22 21:27:03 +00001052 if( z==0 ) return;
drh94eaafa2016-02-29 15:53:11 +00001053 memcpy(z, pName->z, pName->n);
1054 z[pName->n] = 0;
1055 sqlite3Dequote(z);
drh97fc3d02002-05-22 21:27:03 +00001056 for(i=0; i<p->nCol; i++){
drha6f88ff2015-11-19 13:21:31 +00001057 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
danielk19774adee202004-05-08 08:23:19 +00001058 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
drh633e6d52008-07-28 19:34:53 +00001059 sqlite3DbFree(db, z);
drh97fc3d02002-05-22 21:27:03 +00001060 return;
1061 }
1062 }
drh75897232000-05-29 14:26:00 +00001063 if( (p->nCol & 0x7)==0 ){
drh6d4abfb2001-10-22 02:58:08 +00001064 Column *aNew;
danielk1977ae74e032008-12-23 11:11:51 +00001065 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
danielk1977d5d56522005-03-16 12:15:20 +00001066 if( aNew==0 ){
drh633e6d52008-07-28 19:34:53 +00001067 sqlite3DbFree(db, z);
danielk1977d5d56522005-03-16 12:15:20 +00001068 return;
1069 }
drh6d4abfb2001-10-22 02:58:08 +00001070 p->aCol = aNew;
drh75897232000-05-29 14:26:00 +00001071 }
drhc9b84a12002-06-20 11:36:48 +00001072 pCol = &p->aCol[p->nCol];
1073 memset(pCol, 0, sizeof(p->aCol[0]));
1074 pCol->zName = z;
danba68f8f2015-11-19 16:46:46 +00001075 sqlite3ColumnPropertiesFromName(p, pCol);
danielk1977a37cdde2004-05-16 11:15:36 +00001076
drh986dde72016-02-29 13:37:21 +00001077 if( pType->n==0 ){
drh2881ab62016-02-27 23:25:36 +00001078 /* If there is no type specified, columns have the default affinity
1079 ** 'BLOB'. */
1080 pCol->affinity = SQLITE_AFF_BLOB;
1081 pCol->szEst = 1;
1082 }else{
drhddb2b4a2016-03-25 12:10:32 +00001083 zType = z + sqlite3Strlen30(z) + 1;
1084 memcpy(zType, pType->z, pType->n);
1085 zType[pType->n] = 0;
drha6dddd92016-04-18 15:46:14 +00001086 sqlite3Dequote(zType);
drh94eaafa2016-02-29 15:53:11 +00001087 pCol->affinity = sqlite3AffinityType(zType, &pCol->szEst);
drhd7564862016-03-22 20:05:09 +00001088 pCol->colFlags |= COLFLAG_HASTYPE;
drh2881ab62016-02-27 23:25:36 +00001089 }
drhc9b84a12002-06-20 11:36:48 +00001090 p->nCol++;
drh986dde72016-02-29 13:37:21 +00001091 pParse->constraintName.n = 0;
drh75897232000-05-29 14:26:00 +00001092}
1093
1094/*
drh382c0242001-10-06 16:33:02 +00001095** This routine is called by the parser while in the middle of
1096** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1097** been seen on a column. This routine sets the notNull flag on
1098** the column currently under construction.
1099*/
danielk19774adee202004-05-08 08:23:19 +00001100void sqlite3AddNotNull(Parse *pParse, int onError){
drh382c0242001-10-06 16:33:02 +00001101 Table *p;
drhc4a64fa2009-05-11 20:53:28 +00001102 p = pParse->pNewTable;
1103 if( p==0 || NEVER(p->nCol<1) ) return;
1104 p->aCol[p->nCol-1].notNull = (u8)onError;
drh382c0242001-10-06 16:33:02 +00001105}
1106
1107/*
danielk197752a83fb2005-01-31 12:56:44 +00001108** Scan the column type name zType (length nType) and return the
1109** associated affinity type.
danielk1977b3dff962005-02-01 01:21:55 +00001110**
1111** This routine does a case-independent search of zType for the
1112** substrings in the following table. If one of the substrings is
1113** found, the corresponding affinity is returned. If zType contains
1114** more than one of the substrings, entries toward the top of
1115** the table take priority. For example, if zType is 'BLOBINT',
drh8a512562005-11-14 22:29:05 +00001116** SQLITE_AFF_INTEGER is returned.
danielk1977b3dff962005-02-01 01:21:55 +00001117**
1118** Substring | Affinity
1119** --------------------------------
1120** 'INT' | SQLITE_AFF_INTEGER
1121** 'CHAR' | SQLITE_AFF_TEXT
1122** 'CLOB' | SQLITE_AFF_TEXT
1123** 'TEXT' | SQLITE_AFF_TEXT
drh05883a32015-06-02 15:32:08 +00001124** 'BLOB' | SQLITE_AFF_BLOB
drh8a512562005-11-14 22:29:05 +00001125** 'REAL' | SQLITE_AFF_REAL
1126** 'FLOA' | SQLITE_AFF_REAL
1127** 'DOUB' | SQLITE_AFF_REAL
danielk1977b3dff962005-02-01 01:21:55 +00001128**
1129** If none of the substrings in the above table are found,
1130** SQLITE_AFF_NUMERIC is returned.
danielk197752a83fb2005-01-31 12:56:44 +00001131*/
drhfdaac672013-10-04 15:30:21 +00001132char sqlite3AffinityType(const char *zIn, u8 *pszEst){
danielk1977b3dff962005-02-01 01:21:55 +00001133 u32 h = 0;
1134 char aff = SQLITE_AFF_NUMERIC;
drhd3037a42013-10-04 18:29:25 +00001135 const char *zChar = 0;
danielk197752a83fb2005-01-31 12:56:44 +00001136
drh2f1e02e2016-03-09 02:12:44 +00001137 assert( zIn!=0 );
drhfdaac672013-10-04 15:30:21 +00001138 while( zIn[0] ){
drhb7916a72009-05-27 10:31:29 +00001139 h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
danielk1977b3dff962005-02-01 01:21:55 +00001140 zIn++;
danielk1977201f7162005-02-01 02:13:29 +00001141 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
drhfdaac672013-10-04 15:30:21 +00001142 aff = SQLITE_AFF_TEXT;
1143 zChar = zIn;
danielk1977201f7162005-02-01 02:13:29 +00001144 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
1145 aff = SQLITE_AFF_TEXT;
1146 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
1147 aff = SQLITE_AFF_TEXT;
1148 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
drh8a512562005-11-14 22:29:05 +00001149 && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
drh05883a32015-06-02 15:32:08 +00001150 aff = SQLITE_AFF_BLOB;
drhd3037a42013-10-04 18:29:25 +00001151 if( zIn[0]=='(' ) zChar = zIn;
drh8a512562005-11-14 22:29:05 +00001152#ifndef SQLITE_OMIT_FLOATING_POINT
1153 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
1154 && aff==SQLITE_AFF_NUMERIC ){
1155 aff = SQLITE_AFF_REAL;
1156 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
1157 && aff==SQLITE_AFF_NUMERIC ){
1158 aff = SQLITE_AFF_REAL;
1159 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
1160 && aff==SQLITE_AFF_NUMERIC ){
1161 aff = SQLITE_AFF_REAL;
1162#endif
danielk1977201f7162005-02-01 02:13:29 +00001163 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
drh8a512562005-11-14 22:29:05 +00001164 aff = SQLITE_AFF_INTEGER;
danielk1977b3dff962005-02-01 01:21:55 +00001165 break;
danielk197752a83fb2005-01-31 12:56:44 +00001166 }
1167 }
drhd3037a42013-10-04 18:29:25 +00001168
1169 /* If pszEst is not NULL, store an estimate of the field size. The
1170 ** estimate is scaled so that the size of an integer is 1. */
drhfdaac672013-10-04 15:30:21 +00001171 if( pszEst ){
drhd3037a42013-10-04 18:29:25 +00001172 *pszEst = 1; /* default size is approx 4 bytes */
drh7ea31cc2014-09-18 14:36:00 +00001173 if( aff<SQLITE_AFF_NUMERIC ){
drhd3037a42013-10-04 18:29:25 +00001174 if( zChar ){
1175 while( zChar[0] ){
1176 if( sqlite3Isdigit(zChar[0]) ){
drh4f991892013-10-11 15:05:05 +00001177 int v = 0;
drhd3037a42013-10-04 18:29:25 +00001178 sqlite3GetInt32(zChar, &v);
1179 v = v/4 + 1;
1180 if( v>255 ) v = 255;
1181 *pszEst = v; /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
1182 break;
1183 }
1184 zChar++;
drhfdaac672013-10-04 15:30:21 +00001185 }
drhd3037a42013-10-04 18:29:25 +00001186 }else{
1187 *pszEst = 5; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
drhfdaac672013-10-04 15:30:21 +00001188 }
drhfdaac672013-10-04 15:30:21 +00001189 }
1190 }
danielk1977b3dff962005-02-01 01:21:55 +00001191 return aff;
danielk197752a83fb2005-01-31 12:56:44 +00001192}
1193
1194/*
danielk19777977a172004-11-09 12:44:37 +00001195** The expression is the default value for the most recently added column
1196** of the table currently under construction.
1197**
1198** Default value expressions must be constant. Raise an exception if this
1199** is not the case.
drhd9b02572001-04-15 00:37:09 +00001200**
1201** This routine is called by the parser while in the middle of
1202** parsing a CREATE TABLE statement.
drh7020f652000-06-03 18:06:52 +00001203*/
drhb7916a72009-05-27 10:31:29 +00001204void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
drh7020f652000-06-03 18:06:52 +00001205 Table *p;
danielk19777977a172004-11-09 12:44:37 +00001206 Column *pCol;
drh633e6d52008-07-28 19:34:53 +00001207 sqlite3 *db = pParse->db;
drhc4a64fa2009-05-11 20:53:28 +00001208 p = pParse->pNewTable;
1209 if( p!=0 ){
drh42b9d7c2005-08-13 00:56:27 +00001210 pCol = &(p->aCol[p->nCol-1]);
drhfeada2d2014-09-24 13:20:22 +00001211 if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr, db->init.busy) ){
drh42b9d7c2005-08-13 00:56:27 +00001212 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
1213 pCol->zName);
1214 }else{
danielk19776ab3a2e2009-02-19 14:39:25 +00001215 /* A copy of pExpr is used instead of the original, as pExpr contains
1216 ** tokens that point to volatile memory. The 'span' of the expression
1217 ** is required by pragma table_info.
1218 */
drh94fa9c42016-02-27 21:16:04 +00001219 Expr x;
drh633e6d52008-07-28 19:34:53 +00001220 sqlite3ExprDelete(db, pCol->pDflt);
drh94fa9c42016-02-27 21:16:04 +00001221 memset(&x, 0, sizeof(x));
1222 x.op = TK_SPAN;
1223 x.u.zToken = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
1224 (int)(pSpan->zEnd - pSpan->zStart));
1225 x.pLeft = pSpan->pExpr;
1226 x.flags = EP_Skip;
1227 pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
1228 sqlite3DbFree(db, x.u.zToken);
drh42b9d7c2005-08-13 00:56:27 +00001229 }
danielk19777977a172004-11-09 12:44:37 +00001230 }
drhb7916a72009-05-27 10:31:29 +00001231 sqlite3ExprDelete(db, pSpan->pExpr);
drh7020f652000-06-03 18:06:52 +00001232}
1233
1234/*
drh153110a2015-11-01 21:19:13 +00001235** Backwards Compatibility Hack:
1236**
1237** Historical versions of SQLite accepted strings as column names in
1238** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1239**
1240** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1241** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1242**
1243** This is goofy. But to preserve backwards compatibility we continue to
1244** accept it. This routine does the necessary conversion. It converts
1245** the expression given in its argument from a TK_STRING into a TK_ID
1246** if the expression is just a TK_STRING with an optional COLLATE clause.
1247** If the epxression is anything other than TK_STRING, the expression is
1248** unchanged.
1249*/
1250static void sqlite3StringToId(Expr *p){
1251 if( p->op==TK_STRING ){
1252 p->op = TK_ID;
1253 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
1254 p->pLeft->op = TK_ID;
1255 }
1256}
1257
1258/*
drh4a324312001-12-21 14:30:42 +00001259** Designate the PRIMARY KEY for the table. pList is a list of names
1260** of columns that form the primary key. If pList is NULL, then the
1261** most recently added column of the table is the primary key.
1262**
1263** A table can have at most one primary key. If the table already has
1264** a primary key (and this is the second primary key) then create an
1265** error.
1266**
1267** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
drh23bf66d2004-12-14 03:34:34 +00001268** then we will try to use that column as the rowid. Set the Table.iPKey
drh4a324312001-12-21 14:30:42 +00001269** field of the table under construction to be the index of the
1270** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1271** no INTEGER PRIMARY KEY.
1272**
1273** If the key is not an INTEGER PRIMARY KEY, then create a unique
1274** index for the key. No index is created for INTEGER PRIMARY KEYs.
1275*/
drh205f48e2004-11-05 00:43:11 +00001276void sqlite3AddPrimaryKey(
1277 Parse *pParse, /* Parsing context */
1278 ExprList *pList, /* List of field names to be indexed */
1279 int onError, /* What to do with a uniqueness conflict */
drhfdd6e852005-12-16 01:06:16 +00001280 int autoInc, /* True if the AUTOINCREMENT keyword is present */
1281 int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
drh205f48e2004-11-05 00:43:11 +00001282){
drh4a324312001-12-21 14:30:42 +00001283 Table *pTab = pParse->pNewTable;
drhd7564862016-03-22 20:05:09 +00001284 Column *pCol = 0;
drh78100cc2003-08-23 22:40:53 +00001285 int iCol = -1, i;
drh8ea30bf2013-10-22 01:18:17 +00001286 int nTerm;
drh62340f82016-05-31 21:18:15 +00001287 if( pTab==0 ) goto primary_key_exit;
drh7d10d5a2008-08-20 16:35:10 +00001288 if( pTab->tabFlags & TF_HasPrimaryKey ){
danielk19774adee202004-05-08 08:23:19 +00001289 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00001290 "table \"%s\" has more than one primary key", pTab->zName);
drhe0194f22003-02-26 13:52:51 +00001291 goto primary_key_exit;
drh4a324312001-12-21 14:30:42 +00001292 }
drh7d10d5a2008-08-20 16:35:10 +00001293 pTab->tabFlags |= TF_HasPrimaryKey;
drh4a324312001-12-21 14:30:42 +00001294 if( pList==0 ){
1295 iCol = pTab->nCol - 1;
drhd7564862016-03-22 20:05:09 +00001296 pCol = &pTab->aCol[iCol];
1297 pCol->colFlags |= COLFLAG_PRIMKEY;
drh8ea30bf2013-10-22 01:18:17 +00001298 nTerm = 1;
drh78100cc2003-08-23 22:40:53 +00001299 }else{
drh8ea30bf2013-10-22 01:18:17 +00001300 nTerm = pList->nExpr;
1301 for(i=0; i<nTerm; i++){
drh108aa002015-08-24 20:21:20 +00001302 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
drh7d3d9da2015-09-01 00:42:52 +00001303 assert( pCExpr!=0 );
drh153110a2015-11-01 21:19:13 +00001304 sqlite3StringToId(pCExpr);
drh7d3d9da2015-09-01 00:42:52 +00001305 if( pCExpr->op==TK_ID ){
drh108aa002015-08-24 20:21:20 +00001306 const char *zCName = pCExpr->u.zToken;
1307 for(iCol=0; iCol<pTab->nCol; iCol++){
1308 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
drhd7564862016-03-22 20:05:09 +00001309 pCol = &pTab->aCol[iCol];
1310 pCol->colFlags |= COLFLAG_PRIMKEY;
drh108aa002015-08-24 20:21:20 +00001311 break;
1312 }
drhd3d39e92004-05-20 22:16:29 +00001313 }
drh78100cc2003-08-23 22:40:53 +00001314 }
drh4a324312001-12-21 14:30:42 +00001315 }
1316 }
drh8ea30bf2013-10-22 01:18:17 +00001317 if( nTerm==1
drhd7564862016-03-22 20:05:09 +00001318 && pCol
1319 && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
drhbc622bc2015-08-24 15:39:42 +00001320 && sortOrder!=SQLITE_SO_DESC
drh8ea30bf2013-10-22 01:18:17 +00001321 ){
drh4a324312001-12-21 14:30:42 +00001322 pTab->iPKey = iCol;
drh1bd10f82008-12-10 21:19:56 +00001323 pTab->keyConf = (u8)onError;
drh7d10d5a2008-08-20 16:35:10 +00001324 assert( autoInc==0 || autoInc==1 );
1325 pTab->tabFlags |= autoInc*TF_Autoincrement;
drh7f9c5db2013-10-23 00:32:58 +00001326 if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
drh205f48e2004-11-05 00:43:11 +00001327 }else if( autoInc ){
drh4794f732004-11-05 17:17:50 +00001328#ifndef SQLITE_OMIT_AUTOINCREMENT
drh205f48e2004-11-05 00:43:11 +00001329 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
1330 "INTEGER PRIMARY KEY");
drh4794f732004-11-05 17:17:50 +00001331#endif
drh4a324312001-12-21 14:30:42 +00001332 }else{
drh62340f82016-05-31 21:18:15 +00001333 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
1334 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
drhe0194f22003-02-26 13:52:51 +00001335 pList = 0;
drh4a324312001-12-21 14:30:42 +00001336 }
drhe0194f22003-02-26 13:52:51 +00001337
1338primary_key_exit:
drh633e6d52008-07-28 19:34:53 +00001339 sqlite3ExprListDelete(pParse->db, pList);
drhe0194f22003-02-26 13:52:51 +00001340 return;
drh4a324312001-12-21 14:30:42 +00001341}
1342
1343/*
drhffe07b22005-11-03 00:41:17 +00001344** Add a new CHECK constraint to the table currently under construction.
1345*/
1346void sqlite3AddCheckConstraint(
1347 Parse *pParse, /* Parsing context */
1348 Expr *pCheckExpr /* The check expression */
1349){
1350#ifndef SQLITE_OMIT_CHECK
1351 Table *pTab = pParse->pNewTable;
drhc9bbb012014-05-21 08:48:18 +00001352 sqlite3 *db = pParse->db;
1353 if( pTab && !IN_DECLARE_VTAB
1354 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
1355 ){
drh2938f922012-03-07 19:13:29 +00001356 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
1357 if( pParse->constraintName.n ){
1358 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
1359 }
drh33e619f2009-05-28 01:00:55 +00001360 }else
drhffe07b22005-11-03 00:41:17 +00001361#endif
drh33e619f2009-05-28 01:00:55 +00001362 {
drh2938f922012-03-07 19:13:29 +00001363 sqlite3ExprDelete(pParse->db, pCheckExpr);
drh33e619f2009-05-28 01:00:55 +00001364 }
drhffe07b22005-11-03 00:41:17 +00001365}
1366
1367/*
drhd3d39e92004-05-20 22:16:29 +00001368** Set the collation function of the most recently parsed table column
1369** to the CollSeq given.
drh8e2ca022002-06-17 17:07:19 +00001370*/
danielk197739002502007-11-12 09:50:26 +00001371void sqlite3AddCollateType(Parse *pParse, Token *pToken){
drh8e2ca022002-06-17 17:07:19 +00001372 Table *p;
danielk19770202b292004-06-09 09:55:16 +00001373 int i;
danielk197739002502007-11-12 09:50:26 +00001374 char *zColl; /* Dequoted name of collation sequence */
drh633e6d52008-07-28 19:34:53 +00001375 sqlite3 *db;
danielk1977a37cdde2004-05-16 11:15:36 +00001376
danielk1977b8cbb872006-06-19 05:33:45 +00001377 if( (p = pParse->pNewTable)==0 ) return;
danielk19770202b292004-06-09 09:55:16 +00001378 i = p->nCol-1;
drh633e6d52008-07-28 19:34:53 +00001379 db = pParse->db;
1380 zColl = sqlite3NameFromToken(db, pToken);
danielk197739002502007-11-12 09:50:26 +00001381 if( !zColl ) return;
1382
drhc4a64fa2009-05-11 20:53:28 +00001383 if( sqlite3LocateCollSeq(pParse, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00001384 Index *pIdx;
drhfe685c82013-06-08 19:58:27 +00001385 sqlite3DbFree(db, p->aCol[i].zColl);
danielk197739002502007-11-12 09:50:26 +00001386 p->aCol[i].zColl = zColl;
danielk1977b3bf5562006-01-10 17:58:23 +00001387
1388 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1389 ** then an index may have been created on this column before the
1390 ** collation type was added. Correct this if it is the case.
1391 */
1392 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhbbbdc832013-10-22 18:01:40 +00001393 assert( pIdx->nKeyCol==1 );
danielk1977b3bf5562006-01-10 17:58:23 +00001394 if( pIdx->aiColumn[0]==i ){
1395 pIdx->azColl[0] = p->aCol[i].zColl;
danielk19777cedc8d2004-06-10 10:50:08 +00001396 }
1397 }
danielk197739002502007-11-12 09:50:26 +00001398 }else{
drh633e6d52008-07-28 19:34:53 +00001399 sqlite3DbFree(db, zColl);
danielk19777cedc8d2004-06-10 10:50:08 +00001400 }
danielk19777cedc8d2004-06-10 10:50:08 +00001401}
1402
danielk1977466be562004-06-10 02:16:01 +00001403/*
1404** This function returns the collation sequence for database native text
1405** encoding identified by the string zName, length nName.
1406**
1407** If the requested collation sequence is not available, or not available
1408** in the database native encoding, the collation factory is invoked to
1409** request it. If the collation factory does not supply such a sequence,
1410** and the sequence is available in another text encoding, then that is
1411** returned instead.
1412**
1413** If no versions of the requested collations sequence are available, or
1414** another error occurs, NULL is returned and an error message written into
1415** pParse.
drha34001c2007-02-02 12:44:37 +00001416**
1417** This routine is a wrapper around sqlite3FindCollSeq(). This routine
1418** invokes the collation factory if the named collation cannot be found
1419** and generates an error message.
drhc4a64fa2009-05-11 20:53:28 +00001420**
1421** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq()
danielk1977466be562004-06-10 02:16:01 +00001422*/
drhc4a64fa2009-05-11 20:53:28 +00001423CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
danielk19774dade032005-05-25 10:45:10 +00001424 sqlite3 *db = pParse->db;
danielk197714db2662006-01-09 16:12:04 +00001425 u8 enc = ENC(db);
danielk19774dade032005-05-25 10:45:10 +00001426 u8 initbusy = db->init.busy;
danielk1977b3bf5562006-01-10 17:58:23 +00001427 CollSeq *pColl;
danielk19774dade032005-05-25 10:45:10 +00001428
drhc4a64fa2009-05-11 20:53:28 +00001429 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
danielk19777cedc8d2004-06-10 10:50:08 +00001430 if( !initbusy && (!pColl || !pColl->xCmp) ){
drh79e72a52012-10-05 14:43:40 +00001431 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
danielk1977466be562004-06-10 02:16:01 +00001432 }
1433
danielk19770202b292004-06-09 09:55:16 +00001434 return pColl;
1435}
1436
1437
drh8e2ca022002-06-17 17:07:19 +00001438/*
drh3f7d4e42004-07-24 14:35:58 +00001439** Generate code that will increment the schema cookie.
drh50e5dad2001-09-15 00:57:28 +00001440**
1441** The schema cookie is used to determine when the schema for the
1442** database changes. After each schema change, the cookie value
1443** changes. When a process first reads the schema it records the
1444** cookie. Thereafter, whenever it goes to access the database,
1445** it checks the cookie to make sure the schema has not changed
1446** since it was last read.
1447**
1448** This plan is not completely bullet-proof. It is possible for
1449** the schema to change multiple times and for the cookie to be
1450** set back to prior value. But schema changes are infrequent
1451** and the probability of hitting the same cookie value is only
1452** 1 chance in 2^32. So we're safe enough.
drh96fdcb42016-09-27 00:09:33 +00001453**
1454** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
1455** the schema-version whenever the schema changes.
drh50e5dad2001-09-15 00:57:28 +00001456*/
drh9cbf3422008-01-17 16:22:13 +00001457void sqlite3ChangeCookie(Parse *pParse, int iDb){
drh9cbf3422008-01-17 16:22:13 +00001458 sqlite3 *db = pParse->db;
1459 Vdbe *v = pParse->pVdbe;
drh21206082011-04-04 18:22:02 +00001460 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh1861afc2016-02-01 21:48:34 +00001461 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
1462 db->aDb[iDb].pSchema->schema_cookie+1);
drh50e5dad2001-09-15 00:57:28 +00001463}
1464
1465/*
drh969fa7c2002-02-18 18:30:32 +00001466** Measure the number of characters needed to output the given
1467** identifier. The number returned includes any quotes used
1468** but does not include the null terminator.
drh234c39d2004-07-24 03:30:47 +00001469**
1470** The estimate is conservative. It might be larger that what is
1471** really needed.
drh969fa7c2002-02-18 18:30:32 +00001472*/
1473static int identLength(const char *z){
1474 int n;
drh17f71932002-02-21 12:01:27 +00001475 for(n=0; *z; n++, z++){
drh234c39d2004-07-24 03:30:47 +00001476 if( *z=='"' ){ n++; }
drh969fa7c2002-02-18 18:30:32 +00001477 }
drh234c39d2004-07-24 03:30:47 +00001478 return n + 2;
drh969fa7c2002-02-18 18:30:32 +00001479}
1480
1481/*
danielk19771b870de2009-03-14 08:37:23 +00001482** The first parameter is a pointer to an output buffer. The second
1483** parameter is a pointer to an integer that contains the offset at
1484** which to write into the output buffer. This function copies the
1485** nul-terminated string pointed to by the third parameter, zSignedIdent,
1486** to the specified offset in the buffer and updates *pIdx to refer
1487** to the first byte after the last byte written before returning.
1488**
1489** If the string zSignedIdent consists entirely of alpha-numeric
1490** characters, does not begin with a digit and is not an SQL keyword,
1491** then it is copied to the output buffer exactly as it is. Otherwise,
1492** it is quoted using double-quotes.
1493*/
drhc4a64fa2009-05-11 20:53:28 +00001494static void identPut(char *z, int *pIdx, char *zSignedIdent){
drh4c755c02004-08-08 20:22:17 +00001495 unsigned char *zIdent = (unsigned char*)zSignedIdent;
drh17f71932002-02-21 12:01:27 +00001496 int i, j, needQuote;
drh969fa7c2002-02-18 18:30:32 +00001497 i = *pIdx;
danielk19771b870de2009-03-14 08:37:23 +00001498
drh17f71932002-02-21 12:01:27 +00001499 for(j=0; zIdent[j]; j++){
danielk197778ca0e72009-01-20 16:53:39 +00001500 if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
drh17f71932002-02-21 12:01:27 +00001501 }
drhc7407522014-01-10 20:38:12 +00001502 needQuote = sqlite3Isdigit(zIdent[0])
1503 || sqlite3KeywordCode(zIdent, j)!=TK_ID
1504 || zIdent[j]!=0
1505 || j==0;
danielk19771b870de2009-03-14 08:37:23 +00001506
drh234c39d2004-07-24 03:30:47 +00001507 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00001508 for(j=0; zIdent[j]; j++){
1509 z[i++] = zIdent[j];
drh234c39d2004-07-24 03:30:47 +00001510 if( zIdent[j]=='"' ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00001511 }
drh234c39d2004-07-24 03:30:47 +00001512 if( needQuote ) z[i++] = '"';
drh969fa7c2002-02-18 18:30:32 +00001513 z[i] = 0;
1514 *pIdx = i;
1515}
1516
1517/*
1518** Generate a CREATE TABLE statement appropriate for the given
1519** table. Memory to hold the text of the statement is obtained
1520** from sqliteMalloc() and must be freed by the calling function.
1521*/
drh1d34fde2009-02-03 15:50:33 +00001522static char *createTableStmt(sqlite3 *db, Table *p){
drh969fa7c2002-02-18 18:30:32 +00001523 int i, k, n;
1524 char *zStmt;
drhc4a64fa2009-05-11 20:53:28 +00001525 char *zSep, *zSep2, *zEnd;
drh234c39d2004-07-24 03:30:47 +00001526 Column *pCol;
drh969fa7c2002-02-18 18:30:32 +00001527 n = 0;
drh234c39d2004-07-24 03:30:47 +00001528 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
drhc4a64fa2009-05-11 20:53:28 +00001529 n += identLength(pCol->zName) + 5;
drh969fa7c2002-02-18 18:30:32 +00001530 }
1531 n += identLength(p->zName);
drhc4a64fa2009-05-11 20:53:28 +00001532 if( n<50 ){
drh969fa7c2002-02-18 18:30:32 +00001533 zSep = "";
1534 zSep2 = ",";
1535 zEnd = ")";
1536 }else{
1537 zSep = "\n ";
1538 zSep2 = ",\n ";
1539 zEnd = "\n)";
1540 }
drhe0bc4042002-06-25 01:09:11 +00001541 n += 35 + 6*p->nCol;
drhb9755982010-07-24 16:34:37 +00001542 zStmt = sqlite3DbMallocRaw(0, n);
drh820a9062008-01-31 13:35:48 +00001543 if( zStmt==0 ){
drh4a642b62016-02-05 01:55:27 +00001544 sqlite3OomFault(db);
drh820a9062008-01-31 13:35:48 +00001545 return 0;
1546 }
drhbdb339f2009-02-02 18:03:21 +00001547 sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
drhea678832008-12-10 19:26:22 +00001548 k = sqlite3Strlen30(zStmt);
drhc4a64fa2009-05-11 20:53:28 +00001549 identPut(zStmt, &k, p->zName);
drh969fa7c2002-02-18 18:30:32 +00001550 zStmt[k++] = '(';
drh234c39d2004-07-24 03:30:47 +00001551 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
drhc4a64fa2009-05-11 20:53:28 +00001552 static const char * const azType[] = {
drh05883a32015-06-02 15:32:08 +00001553 /* SQLITE_AFF_BLOB */ "",
drh7ea31cc2014-09-18 14:36:00 +00001554 /* SQLITE_AFF_TEXT */ " TEXT",
drhc4a64fa2009-05-11 20:53:28 +00001555 /* SQLITE_AFF_NUMERIC */ " NUM",
1556 /* SQLITE_AFF_INTEGER */ " INT",
1557 /* SQLITE_AFF_REAL */ " REAL"
1558 };
1559 int len;
1560 const char *zType;
1561
drh5bb3eb92007-05-04 13:15:55 +00001562 sqlite3_snprintf(n-k, &zStmt[k], zSep);
drhea678832008-12-10 19:26:22 +00001563 k += sqlite3Strlen30(&zStmt[k]);
drh969fa7c2002-02-18 18:30:32 +00001564 zSep = zSep2;
drhc4a64fa2009-05-11 20:53:28 +00001565 identPut(zStmt, &k, pCol->zName);
drh05883a32015-06-02 15:32:08 +00001566 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
1567 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
1568 testcase( pCol->affinity==SQLITE_AFF_BLOB );
drh7ea31cc2014-09-18 14:36:00 +00001569 testcase( pCol->affinity==SQLITE_AFF_TEXT );
drhc4a64fa2009-05-11 20:53:28 +00001570 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
1571 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
1572 testcase( pCol->affinity==SQLITE_AFF_REAL );
1573
drh05883a32015-06-02 15:32:08 +00001574 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
drhc4a64fa2009-05-11 20:53:28 +00001575 len = sqlite3Strlen30(zType);
drh05883a32015-06-02 15:32:08 +00001576 assert( pCol->affinity==SQLITE_AFF_BLOB
drhfdaac672013-10-04 15:30:21 +00001577 || pCol->affinity==sqlite3AffinityType(zType, 0) );
drhc4a64fa2009-05-11 20:53:28 +00001578 memcpy(&zStmt[k], zType, len);
1579 k += len;
1580 assert( k<=n );
drh969fa7c2002-02-18 18:30:32 +00001581 }
drh5bb3eb92007-05-04 13:15:55 +00001582 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
drh969fa7c2002-02-18 18:30:32 +00001583 return zStmt;
1584}
1585
1586/*
drh7f9c5db2013-10-23 00:32:58 +00001587** Resize an Index object to hold N columns total. Return SQLITE_OK
1588** on success and SQLITE_NOMEM on an OOM error.
1589*/
1590static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
1591 char *zExtra;
1592 int nByte;
1593 if( pIdx->nColumn>=N ) return SQLITE_OK;
1594 assert( pIdx->isResized==0 );
1595 nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
1596 zExtra = sqlite3DbMallocZero(db, nByte);
mistachkinfad30392016-02-13 23:43:46 +00001597 if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
drh7f9c5db2013-10-23 00:32:58 +00001598 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
drhf19aa5f2015-12-30 16:51:20 +00001599 pIdx->azColl = (const char**)zExtra;
drh7f9c5db2013-10-23 00:32:58 +00001600 zExtra += sizeof(char*)*N;
1601 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
1602 pIdx->aiColumn = (i16*)zExtra;
1603 zExtra += sizeof(i16)*N;
1604 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
1605 pIdx->aSortOrder = (u8*)zExtra;
1606 pIdx->nColumn = N;
1607 pIdx->isResized = 1;
1608 return SQLITE_OK;
1609}
1610
1611/*
drhfdaac672013-10-04 15:30:21 +00001612** Estimate the total row width for a table.
1613*/
drhe13e9f52013-10-05 19:18:00 +00001614static void estimateTableWidth(Table *pTab){
drhfdaac672013-10-04 15:30:21 +00001615 unsigned wTable = 0;
1616 const Column *pTabCol;
1617 int i;
1618 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
1619 wTable += pTabCol->szEst;
1620 }
1621 if( pTab->iPKey<0 ) wTable++;
drhe13e9f52013-10-05 19:18:00 +00001622 pTab->szTabRow = sqlite3LogEst(wTable*4);
drhfdaac672013-10-04 15:30:21 +00001623}
1624
1625/*
drhe13e9f52013-10-05 19:18:00 +00001626** Estimate the average size of a row for an index.
drhfdaac672013-10-04 15:30:21 +00001627*/
drhe13e9f52013-10-05 19:18:00 +00001628static void estimateIndexWidth(Index *pIdx){
drhbbbdc832013-10-22 18:01:40 +00001629 unsigned wIndex = 0;
drhfdaac672013-10-04 15:30:21 +00001630 int i;
1631 const Column *aCol = pIdx->pTable->aCol;
1632 for(i=0; i<pIdx->nColumn; i++){
drhbbbdc832013-10-22 18:01:40 +00001633 i16 x = pIdx->aiColumn[i];
1634 assert( x<pIdx->pTable->nCol );
1635 wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
drhfdaac672013-10-04 15:30:21 +00001636 }
drhe13e9f52013-10-05 19:18:00 +00001637 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
drhfdaac672013-10-04 15:30:21 +00001638}
1639
drh7f9c5db2013-10-23 00:32:58 +00001640/* Return true if value x is found any of the first nCol entries of aiCol[]
1641*/
1642static int hasColumn(const i16 *aiCol, int nCol, int x){
1643 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
1644 return 0;
1645}
1646
1647/*
drhc6bd4e42013-11-02 14:37:18 +00001648** This routine runs at the end of parsing a CREATE TABLE statement that
1649** has a WITHOUT ROWID clause. The job of this routine is to convert both
1650** internal schema data structures and the generated VDBE code so that they
1651** are appropriate for a WITHOUT ROWID table instead of a rowid table.
1652** Changes include:
drh7f9c5db2013-10-23 00:32:58 +00001653**
drh62340f82016-05-31 21:18:15 +00001654** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
1655** (2) Convert the OP_CreateTable into an OP_CreateIndex. There is
drhc6bd4e42013-11-02 14:37:18 +00001656** no rowid btree for a WITHOUT ROWID. Instead, the canonical
1657** data storage is a covering index btree.
drh62340f82016-05-31 21:18:15 +00001658** (3) Bypass the creation of the sqlite_master table entry
peter.d.reid60ec9142014-09-06 16:39:46 +00001659** for the PRIMARY KEY as the primary key index is now
drhc6bd4e42013-11-02 14:37:18 +00001660** identified by the sqlite_master table entry of the table itself.
drh62340f82016-05-31 21:18:15 +00001661** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
drhc6bd4e42013-11-02 14:37:18 +00001662** schema to the rootpage from the main table.
drhc6bd4e42013-11-02 14:37:18 +00001663** (5) Add all table columns to the PRIMARY KEY Index object
1664** so that the PRIMARY KEY is a covering index. The surplus
1665** columns are part of KeyInfo.nXField and are not used for
1666** sorting or lookup or uniqueness checks.
1667** (6) Replace the rowid tail on all automatically generated UNIQUE
1668** indices with the PRIMARY KEY columns.
drh62340f82016-05-31 21:18:15 +00001669**
1670** For virtual tables, only (1) is performed.
drh7f9c5db2013-10-23 00:32:58 +00001671*/
1672static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
1673 Index *pIdx;
1674 Index *pPk;
1675 int nPk;
1676 int i, j;
1677 sqlite3 *db = pParse->db;
drhc6bd4e42013-11-02 14:37:18 +00001678 Vdbe *v = pParse->pVdbe;
drh7f9c5db2013-10-23 00:32:58 +00001679
drh62340f82016-05-31 21:18:15 +00001680 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
1681 */
1682 if( !db->init.imposterTable ){
1683 for(i=0; i<pTab->nCol; i++){
1684 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){
1685 pTab->aCol[i].notNull = OE_Abort;
1686 }
1687 }
1688 }
1689
1690 /* The remaining transformations only apply to b-tree tables, not to
1691 ** virtual tables */
1692 if( IN_DECLARE_VTAB ) return;
1693
drh7f9c5db2013-10-23 00:32:58 +00001694 /* Convert the OP_CreateTable opcode that would normally create the
peter.d.reid60ec9142014-09-06 16:39:46 +00001695 ** root-page for the table into an OP_CreateIndex opcode. The index
drhc6bd4e42013-11-02 14:37:18 +00001696 ** created will become the PRIMARY KEY index.
drh7f9c5db2013-10-23 00:32:58 +00001697 */
1698 if( pParse->addrCrTab ){
drhc6bd4e42013-11-02 14:37:18 +00001699 assert( v );
drh0ff287f2015-09-02 18:40:33 +00001700 sqlite3VdbeChangeOpcode(v, pParse->addrCrTab, OP_CreateIndex);
drhc6bd4e42013-11-02 14:37:18 +00001701 }
1702
drh7f9c5db2013-10-23 00:32:58 +00001703 /* Locate the PRIMARY KEY index. Or, if this table was originally
1704 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
1705 */
1706 if( pTab->iPKey>=0 ){
1707 ExprList *pList;
drh108aa002015-08-24 20:21:20 +00001708 Token ipkToken;
drh40aced52016-01-22 17:48:09 +00001709 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
drh108aa002015-08-24 20:21:20 +00001710 pList = sqlite3ExprListAppend(pParse, 0,
1711 sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
drh7f9c5db2013-10-23 00:32:58 +00001712 if( pList==0 ) return;
drh7f9c5db2013-10-23 00:32:58 +00001713 pList->a[0].sortOrder = pParse->iPkSortOrder;
1714 assert( pParse->pNewTable==pTab );
drh62340f82016-05-31 21:18:15 +00001715 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
1716 SQLITE_IDXTYPE_PRIMARYKEY);
drh273bfe92016-06-02 16:22:53 +00001717 if( db->mallocFailed ) return;
drh62340f82016-05-31 21:18:15 +00001718 pPk = sqlite3PrimaryKeyIndex(pTab);
drh7f9c5db2013-10-23 00:32:58 +00001719 pTab->iPKey = -1;
drh44156282013-10-23 22:23:03 +00001720 }else{
1721 pPk = sqlite3PrimaryKeyIndex(pTab);
danc5b73582015-05-26 11:53:14 +00001722
1723 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_master
1724 ** table entry. This is only required if currently generating VDBE
1725 ** code for a CREATE TABLE (not when parsing one as part of reading
1726 ** a database schema). */
1727 if( v ){
1728 assert( db->init.busy==0 );
drh0ff287f2015-09-02 18:40:33 +00001729 sqlite3VdbeChangeOpcode(v, pPk->tnum, OP_Goto);
danc5b73582015-05-26 11:53:14 +00001730 }
1731
drhe385d882014-12-28 22:10:51 +00001732 /*
1733 ** Remove all redundant columns from the PRIMARY KEY. For example, change
1734 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
1735 ** code assumes the PRIMARY KEY contains no repeated columns.
1736 */
1737 for(i=j=1; i<pPk->nKeyCol; i++){
1738 if( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ){
1739 pPk->nColumn--;
1740 }else{
1741 pPk->aiColumn[j++] = pPk->aiColumn[i];
1742 }
1743 }
1744 pPk->nKeyCol = j;
drh7f9c5db2013-10-23 00:32:58 +00001745 }
drh7f9c5db2013-10-23 00:32:58 +00001746 assert( pPk!=0 );
drh62340f82016-05-31 21:18:15 +00001747 pPk->isCovering = 1;
1748 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
drh7f9c5db2013-10-23 00:32:58 +00001749 nPk = pPk->nKeyCol;
1750
drhc6bd4e42013-11-02 14:37:18 +00001751 /* The root page of the PRIMARY KEY is the table root page */
1752 pPk->tnum = pTab->tnum;
1753
drh7f9c5db2013-10-23 00:32:58 +00001754 /* Update the in-memory representation of all UNIQUE indices by converting
1755 ** the final rowid column into one or more columns of the PRIMARY KEY.
1756 */
1757 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1758 int n;
drh48dd1d82014-05-27 18:18:58 +00001759 if( IsPrimaryKeyIndex(pIdx) ) continue;
drh7f9c5db2013-10-23 00:32:58 +00001760 for(i=n=0; i<nPk; i++){
1761 if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ) n++;
1762 }
drh5a9a37b2013-11-05 17:30:04 +00001763 if( n==0 ){
1764 /* This index is a superset of the primary key */
1765 pIdx->nColumn = pIdx->nKeyCol;
1766 continue;
1767 }
drh7f9c5db2013-10-23 00:32:58 +00001768 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
1769 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
drh7913e412013-11-01 20:30:36 +00001770 if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ){
drh7f9c5db2013-10-23 00:32:58 +00001771 pIdx->aiColumn[j] = pPk->aiColumn[i];
1772 pIdx->azColl[j] = pPk->azColl[i];
1773 j++;
1774 }
1775 }
drh00012df2013-11-05 01:59:07 +00001776 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
1777 assert( pIdx->nColumn>=j );
drh7f9c5db2013-10-23 00:32:58 +00001778 }
1779
1780 /* Add all table columns to the PRIMARY KEY index
1781 */
1782 if( nPk<pTab->nCol ){
1783 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
1784 for(i=0, j=nPk; i<pTab->nCol; i++){
1785 if( !hasColumn(pPk->aiColumn, j, i) ){
1786 assert( j<pPk->nColumn );
1787 pPk->aiColumn[j] = i;
drhf19aa5f2015-12-30 16:51:20 +00001788 pPk->azColl[j] = sqlite3StrBINARY;
drh7f9c5db2013-10-23 00:32:58 +00001789 j++;
1790 }
1791 }
1792 assert( pPk->nColumn==j );
1793 assert( pTab->nCol==j );
drhc3e356f2013-11-04 18:34:46 +00001794 }else{
1795 pPk->nColumn = pTab->nCol;
drh7f9c5db2013-10-23 00:32:58 +00001796 }
1797}
1798
drhfdaac672013-10-04 15:30:21 +00001799/*
drh75897232000-05-29 14:26:00 +00001800** This routine is called to report the final ")" that terminates
1801** a CREATE TABLE statement.
1802**
drhf57b3392001-10-08 13:22:32 +00001803** The table structure that other action routines have been building
1804** is added to the internal hash tables, assuming no errors have
1805** occurred.
drh75897232000-05-29 14:26:00 +00001806**
drh1d85d932004-02-14 23:05:52 +00001807** An entry for the table is made in the master table on disk, unless
1808** this is a temporary table or db->init.busy==1. When db->init.busy==1
drhf57b3392001-10-08 13:22:32 +00001809** it means we are reading the sqlite_master table because we just
1810** connected to the database or because the sqlite_master table has
drhddba9e52005-03-19 01:41:21 +00001811** recently changed, so the entry for this table already exists in
drhf57b3392001-10-08 13:22:32 +00001812** the sqlite_master table. We do not want to create it again.
drh969fa7c2002-02-18 18:30:32 +00001813**
1814** If the pSelect argument is not NULL, it means that this routine
1815** was called to create a table generated from a
1816** "CREATE TABLE ... AS SELECT ..." statement. The column names of
1817** the new table will match the result set of the SELECT.
drh75897232000-05-29 14:26:00 +00001818*/
danielk197719a8e7e2005-03-17 05:03:38 +00001819void sqlite3EndTable(
1820 Parse *pParse, /* Parse context */
1821 Token *pCons, /* The ',' token after the last column defn. */
drh5969da42013-10-21 02:14:45 +00001822 Token *pEnd, /* The ')' before options in the CREATE TABLE */
1823 u8 tabOpts, /* Extra table options. Usually 0. */
danielk197719a8e7e2005-03-17 05:03:38 +00001824 Select *pSelect /* Select from a "CREATE ... AS SELECT" */
1825){
drhfdaac672013-10-04 15:30:21 +00001826 Table *p; /* The new table */
1827 sqlite3 *db = pParse->db; /* The database connection */
1828 int iDb; /* Database in which the table lives */
1829 Index *pIdx; /* An implied index of the table */
drh75897232000-05-29 14:26:00 +00001830
drh027616d2015-08-08 22:47:47 +00001831 if( pEnd==0 && pSelect==0 ){
drh5969da42013-10-21 02:14:45 +00001832 return;
danielk1977261919c2005-12-06 12:52:59 +00001833 }
drh834f9972015-08-08 23:23:33 +00001834 assert( !db->mallocFailed );
drh28037572000-08-02 13:47:41 +00001835 p = pParse->pNewTable;
drh5969da42013-10-21 02:14:45 +00001836 if( p==0 ) return;
drh75897232000-05-29 14:26:00 +00001837
danielk1977517eb642004-06-07 10:00:31 +00001838 assert( !db->init.busy || !pSelect );
1839
drhc6bd4e42013-11-02 14:37:18 +00001840 /* If the db->init.busy is 1 it means we are reading the SQL off the
1841 ** "sqlite_master" or "sqlite_temp_master" table on the disk.
1842 ** So do not write to the disk again. Extract the root page number
1843 ** for the table from the db->init.newTnum field. (The page number
1844 ** should have been put there by the sqliteOpenCb routine.)
drh055f2982016-01-15 15:06:41 +00001845 **
1846 ** If the root page number is 1, that means this is the sqlite_master
1847 ** table itself. So mark it read-only.
drhc6bd4e42013-11-02 14:37:18 +00001848 */
1849 if( db->init.busy ){
1850 p->tnum = db->init.newTnum;
drh055f2982016-01-15 15:06:41 +00001851 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
drhc6bd4e42013-11-02 14:37:18 +00001852 }
1853
1854 /* Special processing for WITHOUT ROWID Tables */
drh5969da42013-10-21 02:14:45 +00001855 if( tabOpts & TF_WithoutRowid ){
drhd2fe3352013-11-09 18:15:35 +00001856 if( (p->tabFlags & TF_Autoincrement) ){
1857 sqlite3ErrorMsg(pParse,
1858 "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
1859 return;
1860 }
drh5969da42013-10-21 02:14:45 +00001861 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
drhd2fe3352013-11-09 18:15:35 +00001862 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
drh7f9c5db2013-10-23 00:32:58 +00001863 }else{
drhfccda8a2015-05-27 13:06:55 +00001864 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
drh7f9c5db2013-10-23 00:32:58 +00001865 convertToWithoutRowidTable(pParse, p);
drh81eba732013-10-19 23:31:56 +00001866 }
1867 }
1868
drhb9bb7c12006-06-11 23:41:55 +00001869 iDb = sqlite3SchemaToIndex(db, p->pSchema);
danielk1977da184232006-01-05 11:34:32 +00001870
drhffe07b22005-11-03 00:41:17 +00001871#ifndef SQLITE_OMIT_CHECK
1872 /* Resolve names in all CHECK constraint expressions.
1873 */
1874 if( p->pCheck ){
drh3780be12013-07-31 19:05:22 +00001875 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
drhffe07b22005-11-03 00:41:17 +00001876 }
1877#endif /* !defined(SQLITE_OMIT_CHECK) */
1878
drhe13e9f52013-10-05 19:18:00 +00001879 /* Estimate the average row size for the table and for all implied indices */
1880 estimateTableWidth(p);
drhfdaac672013-10-04 15:30:21 +00001881 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
drhe13e9f52013-10-05 19:18:00 +00001882 estimateIndexWidth(pIdx);
drhfdaac672013-10-04 15:30:21 +00001883 }
1884
drhe3c41372001-09-17 20:25:58 +00001885 /* If not initializing, then create a record for the new table
drh0fa991b2009-03-21 16:19:26 +00001886 ** in the SQLITE_MASTER table of the database.
drhf57b3392001-10-08 13:22:32 +00001887 **
drhe0bc4042002-06-25 01:09:11 +00001888 ** If this is a TEMPORARY table, write the entry into the auxiliary
1889 ** file instead of into the main database file.
drh75897232000-05-29 14:26:00 +00001890 */
drh1d85d932004-02-14 23:05:52 +00001891 if( !db->init.busy ){
drh4ff6dfa2002-03-03 23:06:00 +00001892 int n;
drhd8bc7082000-06-07 23:51:50 +00001893 Vdbe *v;
drh4794f732004-11-05 17:17:50 +00001894 char *zType; /* "view" or "table" */
1895 char *zType2; /* "VIEW" or "TABLE" */
1896 char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
drh75897232000-05-29 14:26:00 +00001897
danielk19774adee202004-05-08 08:23:19 +00001898 v = sqlite3GetVdbe(pParse);
drh5969da42013-10-21 02:14:45 +00001899 if( NEVER(v==0) ) return;
danielk1977517eb642004-06-07 10:00:31 +00001900
drh66a51672008-01-03 00:01:23 +00001901 sqlite3VdbeAddOp1(v, OP_Close, 0);
danielk1977e6efa742004-11-10 11:55:10 +00001902
drh0fa991b2009-03-21 16:19:26 +00001903 /*
1904 ** Initialize zType for the new view or table.
drh4794f732004-11-05 17:17:50 +00001905 */
drh4ff6dfa2002-03-03 23:06:00 +00001906 if( p->pSelect==0 ){
1907 /* A regular table */
drh4794f732004-11-05 17:17:50 +00001908 zType = "table";
1909 zType2 = "TABLE";
danielk1977576ec6b2005-01-21 11:55:25 +00001910#ifndef SQLITE_OMIT_VIEW
drh4ff6dfa2002-03-03 23:06:00 +00001911 }else{
1912 /* A view */
drh4794f732004-11-05 17:17:50 +00001913 zType = "view";
1914 zType2 = "VIEW";
danielk1977576ec6b2005-01-21 11:55:25 +00001915#endif
drh4ff6dfa2002-03-03 23:06:00 +00001916 }
danielk1977517eb642004-06-07 10:00:31 +00001917
danielk1977517eb642004-06-07 10:00:31 +00001918 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
1919 ** statement to populate the new table. The root-page number for the
drh0fa991b2009-03-21 16:19:26 +00001920 ** new table is in register pParse->regRoot.
danielk1977517eb642004-06-07 10:00:31 +00001921 **
1922 ** Once the SELECT has been coded by sqlite3Select(), it is in a
1923 ** suitable state to query for the column names and types to be used
1924 ** by the new table.
danielk1977c00da102006-01-07 13:21:04 +00001925 **
1926 ** A shared-cache write-lock is not required to write to the new table,
1927 ** as a schema-lock must have already been obtained to create it. Since
1928 ** a schema-lock excludes all other database users, the write-lock would
1929 ** be redundant.
danielk1977517eb642004-06-07 10:00:31 +00001930 */
1931 if( pSelect ){
drh92632202015-05-20 17:18:29 +00001932 SelectDest dest; /* Where the SELECT should store results */
drh9df25c42015-05-20 15:51:09 +00001933 int regYield; /* Register holding co-routine entry-point */
1934 int addrTop; /* Top of the co-routine */
drh92632202015-05-20 17:18:29 +00001935 int regRec; /* A record to be insert into the new table */
1936 int regRowid; /* Rowid of the next row to insert */
1937 int addrInsLoop; /* Top of the loop for inserting rows */
1938 Table *pSelTab; /* A table that describes the SELECT results */
drh1013c932008-01-06 00:25:21 +00001939
drh9df25c42015-05-20 15:51:09 +00001940 regYield = ++pParse->nMem;
drh92632202015-05-20 17:18:29 +00001941 regRec = ++pParse->nMem;
1942 regRowid = ++pParse->nMem;
danielk19776ab3a2e2009-02-19 14:39:25 +00001943 assert(pParse->nTab==1);
drh0dd5cda2015-06-16 16:39:01 +00001944 sqlite3MayAbort(pParse);
drhb7654112008-01-12 12:48:07 +00001945 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
dan428c2182012-08-06 18:50:11 +00001946 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
danielk1977517eb642004-06-07 10:00:31 +00001947 pParse->nTab = 2;
drh9df25c42015-05-20 15:51:09 +00001948 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
1949 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
1950 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
drh7d10d5a2008-08-20 16:35:10 +00001951 sqlite3Select(pParse, pSelect, &dest);
drh2fade2f2016-02-09 02:12:20 +00001952 sqlite3VdbeEndCoroutine(v, regYield);
drh9df25c42015-05-20 15:51:09 +00001953 sqlite3VdbeJumpHere(v, addrTop - 1);
drh92632202015-05-20 17:18:29 +00001954 if( pParse->nErr ) return;
1955 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
1956 if( pSelTab==0 ) return;
1957 assert( p->aCol==0 );
1958 p->nCol = pSelTab->nCol;
1959 p->aCol = pSelTab->aCol;
1960 pSelTab->nCol = 0;
1961 pSelTab->aCol = 0;
1962 sqlite3DeleteTable(db, pSelTab);
1963 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
1964 VdbeCoverage(v);
1965 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
1966 sqlite3TableAffinity(v, p, 0);
1967 sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
1968 sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
drh076e85f2015-09-03 13:46:12 +00001969 sqlite3VdbeGoto(v, addrInsLoop);
drh92632202015-05-20 17:18:29 +00001970 sqlite3VdbeJumpHere(v, addrInsLoop);
1971 sqlite3VdbeAddOp1(v, OP_Close, 1);
danielk1977517eb642004-06-07 10:00:31 +00001972 }
drh4794f732004-11-05 17:17:50 +00001973
drh4794f732004-11-05 17:17:50 +00001974 /* Compute the complete text of the CREATE statement */
1975 if( pSelect ){
drh1d34fde2009-02-03 15:50:33 +00001976 zStmt = createTableStmt(db, p);
drh4794f732004-11-05 17:17:50 +00001977 }else{
drh8ea30bf2013-10-22 01:18:17 +00001978 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
1979 n = (int)(pEnd2->z - pParse->sNameToken.z);
1980 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
danielk19771e536952007-08-16 10:09:01 +00001981 zStmt = sqlite3MPrintf(db,
1982 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
1983 );
drh4794f732004-11-05 17:17:50 +00001984 }
1985
1986 /* A slot for the record has already been allocated in the
1987 ** SQLITE_MASTER table. We just need to update that slot with all
drh0fa991b2009-03-21 16:19:26 +00001988 ** the information we've collected.
drh4794f732004-11-05 17:17:50 +00001989 */
1990 sqlite3NestedParse(pParse,
1991 "UPDATE %Q.%s "
drhb7654112008-01-12 12:48:07 +00001992 "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
1993 "WHERE rowid=#%d",
drh69c33822016-08-18 14:33:11 +00001994 db->aDb[iDb].zDbSName, SCHEMA_TABLE(iDb),
drh4794f732004-11-05 17:17:50 +00001995 zType,
1996 p->zName,
1997 p->zName,
drhb7654112008-01-12 12:48:07 +00001998 pParse->regRoot,
1999 zStmt,
2000 pParse->regRowid
drh4794f732004-11-05 17:17:50 +00002001 );
drh633e6d52008-07-28 19:34:53 +00002002 sqlite3DbFree(db, zStmt);
drh9cbf3422008-01-17 16:22:13 +00002003 sqlite3ChangeCookie(pParse, iDb);
drh2958a4e2004-11-12 03:56:15 +00002004
2005#ifndef SQLITE_OMIT_AUTOINCREMENT
2006 /* Check to see if we need to create an sqlite_sequence table for
2007 ** keeping track of autoincrement keys.
2008 */
drh9ef5e772016-08-19 14:20:56 +00002009 if( (p->tabFlags & TF_Autoincrement)!=0 ){
danielk1977da184232006-01-05 11:34:32 +00002010 Db *pDb = &db->aDb[iDb];
drh21206082011-04-04 18:22:02 +00002011 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
danielk1977da184232006-01-05 11:34:32 +00002012 if( pDb->pSchema->pSeqTab==0 ){
drh2958a4e2004-11-12 03:56:15 +00002013 sqlite3NestedParse(pParse,
drhf3388142004-11-13 03:48:06 +00002014 "CREATE TABLE %Q.sqlite_sequence(name,seq)",
drh69c33822016-08-18 14:33:11 +00002015 pDb->zDbSName
drh2958a4e2004-11-12 03:56:15 +00002016 );
2017 }
2018 }
2019#endif
drh4794f732004-11-05 17:17:50 +00002020
2021 /* Reparse everything to update our internal data structures */
drh5d9c9da2011-06-03 20:11:17 +00002022 sqlite3VdbeAddParseSchemaOp(v, iDb,
dan197bc202013-10-19 15:07:49 +00002023 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
drh75897232000-05-29 14:26:00 +00002024 }
drh17e9e292003-02-01 13:53:28 +00002025
drh2958a4e2004-11-12 03:56:15 +00002026
drh17e9e292003-02-01 13:53:28 +00002027 /* Add the table to the in-memory representation of the database.
2028 */
drh8af73d42009-05-13 22:58:28 +00002029 if( db->init.busy ){
drh17e9e292003-02-01 13:53:28 +00002030 Table *pOld;
danielk1977e501b892006-01-09 06:29:47 +00002031 Schema *pSchema = p->pSchema;
drh21206082011-04-04 18:22:02 +00002032 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drhacbcb7e2014-08-21 20:26:37 +00002033 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
drh17e9e292003-02-01 13:53:28 +00002034 if( pOld ){
2035 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
drh4a642b62016-02-05 01:55:27 +00002036 sqlite3OomFault(db);
drh5969da42013-10-21 02:14:45 +00002037 return;
drh17e9e292003-02-01 13:53:28 +00002038 }
drh17e9e292003-02-01 13:53:28 +00002039 pParse->pNewTable = 0;
drh17e9e292003-02-01 13:53:28 +00002040 db->flags |= SQLITE_InternChanges;
danielk197719a8e7e2005-03-17 05:03:38 +00002041
2042#ifndef SQLITE_OMIT_ALTERTABLE
2043 if( !p->pSelect ){
danielk1977bab45c62006-01-16 15:14:27 +00002044 const char *zName = (const char *)pParse->sNameToken.z;
drh9a087a92007-05-15 14:34:32 +00002045 int nName;
drh5969da42013-10-21 02:14:45 +00002046 assert( !pSelect && pCons && pEnd );
danielk1977bab45c62006-01-16 15:14:27 +00002047 if( pCons->z==0 ){
drh5969da42013-10-21 02:14:45 +00002048 pCons = pEnd;
danielk1977bab45c62006-01-16 15:14:27 +00002049 }
drh1bd10f82008-12-10 21:19:56 +00002050 nName = (int)((const char *)pCons->z - zName);
drh9a087a92007-05-15 14:34:32 +00002051 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
danielk197719a8e7e2005-03-17 05:03:38 +00002052 }
2053#endif
drh17e9e292003-02-01 13:53:28 +00002054 }
drh75897232000-05-29 14:26:00 +00002055}
2056
drhb7f91642004-10-31 02:22:47 +00002057#ifndef SQLITE_OMIT_VIEW
drh75897232000-05-29 14:26:00 +00002058/*
drha76b5df2002-02-23 02:32:10 +00002059** The parser calls this routine in order to create a new VIEW
2060*/
danielk19774adee202004-05-08 08:23:19 +00002061void sqlite3CreateView(
drha76b5df2002-02-23 02:32:10 +00002062 Parse *pParse, /* The parsing context */
2063 Token *pBegin, /* The CREATE token that begins the statement */
danielk197748dec7e2004-05-28 12:33:30 +00002064 Token *pName1, /* The token that holds the name of the view */
2065 Token *pName2, /* The token that holds the name of the view */
drh8981b902015-08-24 17:42:49 +00002066 ExprList *pCNames, /* Optional list of view column names */
drh6276c1c2002-07-08 22:03:32 +00002067 Select *pSelect, /* A SELECT statement that will become the new view */
drhfdd48a72006-09-11 23:45:48 +00002068 int isTemp, /* TRUE for a TEMPORARY view */
2069 int noErr /* Suppress error messages if VIEW already exists */
drha76b5df2002-02-23 02:32:10 +00002070){
drha76b5df2002-02-23 02:32:10 +00002071 Table *p;
drh4b59ab52002-08-24 18:24:51 +00002072 int n;
drhb7916a72009-05-27 10:31:29 +00002073 const char *z;
drh4b59ab52002-08-24 18:24:51 +00002074 Token sEnd;
drhf26e09c2003-05-31 16:21:12 +00002075 DbFixer sFix;
drh88caeac2011-08-24 15:12:08 +00002076 Token *pName = 0;
danielk1977da184232006-01-05 11:34:32 +00002077 int iDb;
drh17435752007-08-16 04:30:38 +00002078 sqlite3 *db = pParse->db;
drha76b5df2002-02-23 02:32:10 +00002079
drh7c3d64f2005-06-06 15:32:08 +00002080 if( pParse->nVar>0 ){
2081 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
drh32498f12015-09-26 11:15:44 +00002082 goto create_view_fail;
drh7c3d64f2005-06-06 15:32:08 +00002083 }
drhfdd48a72006-09-11 23:45:48 +00002084 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
drha76b5df2002-02-23 02:32:10 +00002085 p = pParse->pNewTable;
drh8981b902015-08-24 17:42:49 +00002086 if( p==0 || pParse->nErr ) goto create_view_fail;
danielk1977ef2cb632004-05-29 02:37:19 +00002087 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
drh17435752007-08-16 04:30:38 +00002088 iDb = sqlite3SchemaToIndex(db, p->pSchema);
drhd100f692013-10-03 15:39:44 +00002089 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
drh8981b902015-08-24 17:42:49 +00002090 if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
drh174b6192002-12-03 02:22:52 +00002091
drh4b59ab52002-08-24 18:24:51 +00002092 /* Make a copy of the entire SELECT statement that defines the view.
2093 ** This will force all the Expr.token.z values to be dynamically
2094 ** allocated rather than point to the input string - which means that
danielk197724b03fd2004-05-10 10:34:34 +00002095 ** they will persist after the current sqlite3_exec() call returns.
drh4b59ab52002-08-24 18:24:51 +00002096 */
danielk19776ab3a2e2009-02-19 14:39:25 +00002097 p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
drh8981b902015-08-24 17:42:49 +00002098 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
2099 if( db->mallocFailed ) goto create_view_fail;
drh4b59ab52002-08-24 18:24:51 +00002100
2101 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
2102 ** the end.
2103 */
drha76b5df2002-02-23 02:32:10 +00002104 sEnd = pParse->sLastToken;
drh8981b902015-08-24 17:42:49 +00002105 assert( sEnd.z[0]!=0 );
2106 if( sEnd.z[0]!=';' ){
drha76b5df2002-02-23 02:32:10 +00002107 sEnd.z += sEnd.n;
2108 }
2109 sEnd.n = 0;
drh1bd10f82008-12-10 21:19:56 +00002110 n = (int)(sEnd.z - pBegin->z);
drh8981b902015-08-24 17:42:49 +00002111 assert( n>0 );
drhb7916a72009-05-27 10:31:29 +00002112 z = pBegin->z;
drh8981b902015-08-24 17:42:49 +00002113 while( sqlite3Isspace(z[n-1]) ){ n--; }
drh4ff6dfa2002-03-03 23:06:00 +00002114 sEnd.z = &z[n-1];
2115 sEnd.n = 1;
drh4b59ab52002-08-24 18:24:51 +00002116
danielk19774adee202004-05-08 08:23:19 +00002117 /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
drh5969da42013-10-21 02:14:45 +00002118 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
drh8981b902015-08-24 17:42:49 +00002119
2120create_view_fail:
2121 sqlite3SelectDelete(db, pSelect);
2122 sqlite3ExprListDelete(db, pCNames);
drha76b5df2002-02-23 02:32:10 +00002123 return;
drh417be792002-03-03 18:59:40 +00002124}
drhb7f91642004-10-31 02:22:47 +00002125#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00002126
danielk1977fe3fcbe22006-06-12 12:08:45 +00002127#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
drh417be792002-03-03 18:59:40 +00002128/*
2129** The Table structure pTable is really a VIEW. Fill in the names of
2130** the columns of the view in the pTable structure. Return the number
jplyoncfa56842004-01-19 04:55:56 +00002131** of errors. If an error is seen leave an error message in pParse->zErrMsg.
drh417be792002-03-03 18:59:40 +00002132*/
danielk19774adee202004-05-08 08:23:19 +00002133int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
drh9b3187e2005-01-18 14:45:47 +00002134 Table *pSelTab; /* A fake table from which we get the result set */
2135 Select *pSel; /* Copy of the SELECT that implements the view */
2136 int nErr = 0; /* Number of errors encountered */
2137 int n; /* Temporarily holds the number of cursors assigned */
drh17435752007-08-16 04:30:38 +00002138 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
drha0daa752016-09-16 11:53:10 +00002139#ifndef SQLITE_OMIT_AUTHORIZATION
drh32c6a482014-09-11 13:44:52 +00002140 sqlite3_xauth xAuth; /* Saved xAuth pointer */
drha0daa752016-09-16 11:53:10 +00002141#endif
drh417be792002-03-03 18:59:40 +00002142
2143 assert( pTable );
2144
danielk1977fe3fcbe22006-06-12 12:08:45 +00002145#ifndef SQLITE_OMIT_VIRTUALTABLE
2146 if( sqlite3VtabCallConnect(pParse, pTable) ){
2147 return SQLITE_ERROR;
2148 }
drh4cbdda92006-06-14 19:00:20 +00002149 if( IsVirtual(pTable) ) return 0;
danielk1977fe3fcbe22006-06-12 12:08:45 +00002150#endif
2151
2152#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00002153 /* A positive nCol means the columns names for this view are
2154 ** already known.
2155 */
2156 if( pTable->nCol>0 ) return 0;
2157
2158 /* A negative nCol is a special marker meaning that we are currently
2159 ** trying to compute the column names. If we enter this routine with
2160 ** a negative nCol, it means two or more views form a loop, like this:
2161 **
2162 ** CREATE VIEW one AS SELECT * FROM two;
2163 ** CREATE VIEW two AS SELECT * FROM one;
drh3b167c72002-06-28 12:18:47 +00002164 **
drh768578e2009-05-12 00:40:12 +00002165 ** Actually, the error above is now caught prior to reaching this point.
2166 ** But the following test is still important as it does come up
2167 ** in the following:
2168 **
2169 ** CREATE TABLE main.ex1(a);
2170 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
2171 ** SELECT * FROM temp.ex1;
drh417be792002-03-03 18:59:40 +00002172 */
2173 if( pTable->nCol<0 ){
danielk19774adee202004-05-08 08:23:19 +00002174 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
drh417be792002-03-03 18:59:40 +00002175 return 1;
2176 }
drh85c23c62005-08-20 03:03:04 +00002177 assert( pTable->nCol>=0 );
drh417be792002-03-03 18:59:40 +00002178
2179 /* If we get this far, it means we need to compute the table names.
drh9b3187e2005-01-18 14:45:47 +00002180 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
2181 ** "*" elements in the results set of the view and will assign cursors
2182 ** to the elements of the FROM clause. But we do not want these changes
2183 ** to be permanent. So the computation is done on a copy of the SELECT
2184 ** statement that defines the view.
drh417be792002-03-03 18:59:40 +00002185 */
drh9b3187e2005-01-18 14:45:47 +00002186 assert( pTable->pSelect );
drhed06a132016-04-05 20:59:12 +00002187 pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
2188 if( pSel ){
2189 n = pParse->nTab;
2190 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
2191 pTable->nCol = -1;
drh4a642b62016-02-05 01:55:27 +00002192 db->lookaside.bDisable++;
danielk1977db2d2862007-10-15 07:08:44 +00002193#ifndef SQLITE_OMIT_AUTHORIZATION
drhed06a132016-04-05 20:59:12 +00002194 xAuth = db->xAuth;
2195 db->xAuth = 0;
2196 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
2197 db->xAuth = xAuth;
danielk1977db2d2862007-10-15 07:08:44 +00002198#else
drhed06a132016-04-05 20:59:12 +00002199 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
danielk1977db2d2862007-10-15 07:08:44 +00002200#endif
drhed06a132016-04-05 20:59:12 +00002201 pParse->nTab = n;
2202 if( pTable->pCheck ){
2203 /* CREATE VIEW name(arglist) AS ...
2204 ** The names of the columns in the table are taken from
2205 ** arglist which is stored in pTable->pCheck. The pCheck field
2206 ** normally holds CHECK constraints on an ordinary table, but for
2207 ** a VIEW it holds the list of column names.
2208 */
2209 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
2210 &pTable->nCol, &pTable->aCol);
2211 if( db->mallocFailed==0
2212 && pParse->nErr==0
2213 && pTable->nCol==pSel->pEList->nExpr
2214 ){
2215 sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel);
drh8981b902015-08-24 17:42:49 +00002216 }
drhed06a132016-04-05 20:59:12 +00002217 }else if( pSelTab ){
2218 /* CREATE VIEW name AS... without an argument list. Construct
2219 ** the column names from the SELECT statement that defines the view.
2220 */
2221 assert( pTable->aCol==0 );
2222 pTable->nCol = pSelTab->nCol;
2223 pTable->aCol = pSelTab->aCol;
2224 pSelTab->nCol = 0;
2225 pSelTab->aCol = 0;
2226 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
2227 }else{
2228 pTable->nCol = 0;
danielk1977261919c2005-12-06 12:52:59 +00002229 nErr++;
2230 }
drhe8da01c2016-05-07 12:15:34 +00002231 sqlite3DeleteTable(db, pSelTab);
drhed06a132016-04-05 20:59:12 +00002232 sqlite3SelectDelete(db, pSel);
2233 db->lookaside.bDisable--;
2234 } else {
2235 nErr++;
drh417be792002-03-03 18:59:40 +00002236 }
drh8981b902015-08-24 17:42:49 +00002237 pTable->pSchema->schemaFlags |= DB_UnresetViews;
drhb7f91642004-10-31 02:22:47 +00002238#endif /* SQLITE_OMIT_VIEW */
danielk19774b2688a2006-06-20 11:01:07 +00002239 return nErr;
danielk1977fe3fcbe22006-06-12 12:08:45 +00002240}
2241#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
drh417be792002-03-03 18:59:40 +00002242
drhb7f91642004-10-31 02:22:47 +00002243#ifndef SQLITE_OMIT_VIEW
drh417be792002-03-03 18:59:40 +00002244/*
drh8bf8dc92003-05-17 17:35:10 +00002245** Clear the column names from every VIEW in database idx.
drh417be792002-03-03 18:59:40 +00002246*/
drh9bb575f2004-09-06 17:24:11 +00002247static void sqliteViewResetAll(sqlite3 *db, int idx){
drh417be792002-03-03 18:59:40 +00002248 HashElem *i;
drh21206082011-04-04 18:22:02 +00002249 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
drh8bf8dc92003-05-17 17:35:10 +00002250 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
danielk1977da184232006-01-05 11:34:32 +00002251 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
drh417be792002-03-03 18:59:40 +00002252 Table *pTab = sqliteHashData(i);
2253 if( pTab->pSelect ){
drh51be3872015-08-19 02:32:25 +00002254 sqlite3DeleteColumnNames(db, pTab);
dand46def72010-07-24 11:28:28 +00002255 pTab->aCol = 0;
2256 pTab->nCol = 0;
drh417be792002-03-03 18:59:40 +00002257 }
2258 }
drh8bf8dc92003-05-17 17:35:10 +00002259 DbClearProperty(db, idx, DB_UnresetViews);
drha76b5df2002-02-23 02:32:10 +00002260}
drhb7f91642004-10-31 02:22:47 +00002261#else
2262# define sqliteViewResetAll(A,B)
2263#endif /* SQLITE_OMIT_VIEW */
drha76b5df2002-02-23 02:32:10 +00002264
drh75897232000-05-29 14:26:00 +00002265/*
danielk1977a0bf2652004-11-04 14:30:04 +00002266** This function is called by the VDBE to adjust the internal schema
2267** used by SQLite when the btree layer moves a table root page. The
2268** root-page of a table or index in database iDb has changed from iFrom
2269** to iTo.
drh6205d4a2006-03-24 03:36:26 +00002270**
2271** Ticket #1728: The symbol table might still contain information
2272** on tables and/or indices that are the process of being deleted.
2273** If you are unlucky, one of those deleted indices or tables might
2274** have the same rootpage number as the real table or index that is
2275** being moved. So we cannot stop searching after the first match
2276** because the first match might be for one of the deleted indices
2277** or tables and not the table/index that is actually being moved.
2278** We must continue looping until all tables and indices with
2279** rootpage==iFrom have been converted to have a rootpage of iTo
2280** in order to be certain that we got the right one.
danielk1977a0bf2652004-11-04 14:30:04 +00002281*/
2282#ifndef SQLITE_OMIT_AUTOVACUUM
drhcdf011d2011-04-04 21:25:28 +00002283void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
danielk1977a0bf2652004-11-04 14:30:04 +00002284 HashElem *pElem;
danielk1977da184232006-01-05 11:34:32 +00002285 Hash *pHash;
drhcdf011d2011-04-04 21:25:28 +00002286 Db *pDb;
danielk1977da184232006-01-05 11:34:32 +00002287
drhcdf011d2011-04-04 21:25:28 +00002288 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2289 pDb = &db->aDb[iDb];
danielk1977da184232006-01-05 11:34:32 +00002290 pHash = &pDb->pSchema->tblHash;
2291 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00002292 Table *pTab = sqliteHashData(pElem);
2293 if( pTab->tnum==iFrom ){
2294 pTab->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00002295 }
2296 }
danielk1977da184232006-01-05 11:34:32 +00002297 pHash = &pDb->pSchema->idxHash;
2298 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
danielk1977a0bf2652004-11-04 14:30:04 +00002299 Index *pIdx = sqliteHashData(pElem);
2300 if( pIdx->tnum==iFrom ){
2301 pIdx->tnum = iTo;
danielk1977a0bf2652004-11-04 14:30:04 +00002302 }
2303 }
danielk1977a0bf2652004-11-04 14:30:04 +00002304}
2305#endif
2306
2307/*
2308** Write code to erase the table with root-page iTable from database iDb.
2309** Also write code to modify the sqlite_master table and internal schema
2310** if a root-page of another table is moved by the btree-layer whilst
2311** erasing iTable (this can happen with an auto-vacuum database).
2312*/
drh4e0cff62004-11-05 05:10:28 +00002313static void destroyRootPage(Parse *pParse, int iTable, int iDb){
2314 Vdbe *v = sqlite3GetVdbe(pParse);
drhb7654112008-01-12 12:48:07 +00002315 int r1 = sqlite3GetTempReg(pParse);
drh055f2982016-01-15 15:06:41 +00002316 assert( iTable>1 );
drhb7654112008-01-12 12:48:07 +00002317 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
dane0af83a2009-09-08 19:15:01 +00002318 sqlite3MayAbort(pParse);
drh40e016e2004-11-04 14:47:11 +00002319#ifndef SQLITE_OMIT_AUTOVACUUM
drhb7654112008-01-12 12:48:07 +00002320 /* OP_Destroy stores an in integer r1. If this integer
drh4e0cff62004-11-05 05:10:28 +00002321 ** is non-zero, then it is the root page number of a table moved to
drh81db88e2004-12-07 12:29:17 +00002322 ** location iTable. The following code modifies the sqlite_master table to
drh4e0cff62004-11-05 05:10:28 +00002323 ** reflect this.
2324 **
drh0fa991b2009-03-21 16:19:26 +00002325 ** The "#NNN" in the SQL is a special constant that means whatever value
drhb74b1012009-05-28 21:04:37 +00002326 ** is in register NNN. See grammar rules associated with the TK_REGISTER
2327 ** token for additional information.
drh4e0cff62004-11-05 05:10:28 +00002328 */
danielk197763e3e9f2004-11-05 09:19:27 +00002329 sqlite3NestedParse(pParse,
drhb7654112008-01-12 12:48:07 +00002330 "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
drh69c33822016-08-18 14:33:11 +00002331 pParse->db->aDb[iDb].zDbSName, SCHEMA_TABLE(iDb), iTable, r1, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00002332#endif
drhb7654112008-01-12 12:48:07 +00002333 sqlite3ReleaseTempReg(pParse, r1);
danielk1977a0bf2652004-11-04 14:30:04 +00002334}
2335
2336/*
2337** Write VDBE code to erase table pTab and all associated indices on disk.
2338** Code to update the sqlite_master tables and internal schema definitions
2339** in case a root-page belonging to another table is moved by the btree layer
2340** is also added (this can happen with an auto-vacuum database).
2341*/
drh4e0cff62004-11-05 05:10:28 +00002342static void destroyTable(Parse *pParse, Table *pTab){
danielk1977a0bf2652004-11-04 14:30:04 +00002343#ifdef SQLITE_OMIT_AUTOVACUUM
drheee46cf2004-11-06 00:02:48 +00002344 Index *pIdx;
drh29c636b2006-01-09 23:40:25 +00002345 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
2346 destroyRootPage(pParse, pTab->tnum, iDb);
danielk1977a0bf2652004-11-04 14:30:04 +00002347 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
drh29c636b2006-01-09 23:40:25 +00002348 destroyRootPage(pParse, pIdx->tnum, iDb);
danielk1977a0bf2652004-11-04 14:30:04 +00002349 }
2350#else
2351 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
2352 ** is not defined), then it is important to call OP_Destroy on the
2353 ** table and index root-pages in order, starting with the numerically
2354 ** largest root-page number. This guarantees that none of the root-pages
2355 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
2356 ** following were coded:
2357 **
2358 ** OP_Destroy 4 0
2359 ** ...
2360 ** OP_Destroy 5 0
2361 **
2362 ** and root page 5 happened to be the largest root-page number in the
2363 ** database, then root page 5 would be moved to page 4 by the
2364 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
2365 ** a free-list page.
2366 */
2367 int iTab = pTab->tnum;
2368 int iDestroyed = 0;
2369
2370 while( 1 ){
2371 Index *pIdx;
2372 int iLargest = 0;
2373
2374 if( iDestroyed==0 || iTab<iDestroyed ){
2375 iLargest = iTab;
2376 }
2377 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2378 int iIdx = pIdx->tnum;
danielk1977da184232006-01-05 11:34:32 +00002379 assert( pIdx->pSchema==pTab->pSchema );
danielk1977a0bf2652004-11-04 14:30:04 +00002380 if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
2381 iLargest = iIdx;
2382 }
2383 }
danielk1977da184232006-01-05 11:34:32 +00002384 if( iLargest==0 ){
2385 return;
2386 }else{
2387 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drh5a05be12012-10-09 18:51:44 +00002388 assert( iDb>=0 && iDb<pParse->db->nDb );
danielk1977da184232006-01-05 11:34:32 +00002389 destroyRootPage(pParse, iLargest, iDb);
2390 iDestroyed = iLargest;
2391 }
danielk1977a0bf2652004-11-04 14:30:04 +00002392 }
2393#endif
2394}
2395
2396/*
drh74e7c8f2011-10-21 19:06:32 +00002397** Remove entries from the sqlite_statN tables (for N in (1,2,3))
drha5ae4c32011-08-07 01:31:52 +00002398** after a DROP INDEX or DROP TABLE command.
2399*/
2400static void sqlite3ClearStatTables(
2401 Parse *pParse, /* The parsing context */
2402 int iDb, /* The database number */
2403 const char *zType, /* "idx" or "tbl" */
2404 const char *zName /* Name of index or table */
2405){
drha5ae4c32011-08-07 01:31:52 +00002406 int i;
drh69c33822016-08-18 14:33:11 +00002407 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
danf52bb8d2013-08-03 20:24:58 +00002408 for(i=1; i<=4; i++){
drh74e7c8f2011-10-21 19:06:32 +00002409 char zTab[24];
2410 sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
2411 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
drha5ae4c32011-08-07 01:31:52 +00002412 sqlite3NestedParse(pParse,
2413 "DELETE FROM %Q.%s WHERE %s=%Q",
drh74e7c8f2011-10-21 19:06:32 +00002414 zDbName, zTab, zType, zName
drha5ae4c32011-08-07 01:31:52 +00002415 );
2416 }
2417 }
2418}
2419
2420/*
drhfaacf172011-08-12 01:51:45 +00002421** Generate code to drop a table.
2422*/
2423void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
2424 Vdbe *v;
2425 sqlite3 *db = pParse->db;
2426 Trigger *pTrigger;
2427 Db *pDb = &db->aDb[iDb];
2428
2429 v = sqlite3GetVdbe(pParse);
2430 assert( v!=0 );
2431 sqlite3BeginWriteOperation(pParse, 1, iDb);
2432
2433#ifndef SQLITE_OMIT_VIRTUALTABLE
2434 if( IsVirtual(pTab) ){
2435 sqlite3VdbeAddOp0(v, OP_VBegin);
2436 }
2437#endif
2438
2439 /* Drop all triggers associated with the table being dropped. Code
2440 ** is generated to remove entries from sqlite_master and/or
2441 ** sqlite_temp_master if required.
2442 */
2443 pTrigger = sqlite3TriggerList(pParse, pTab);
2444 while( pTrigger ){
2445 assert( pTrigger->pSchema==pTab->pSchema ||
2446 pTrigger->pSchema==db->aDb[1].pSchema );
2447 sqlite3DropTriggerPtr(pParse, pTrigger);
2448 pTrigger = pTrigger->pNext;
2449 }
2450
2451#ifndef SQLITE_OMIT_AUTOINCREMENT
2452 /* Remove any entries of the sqlite_sequence table associated with
2453 ** the table being dropped. This is done before the table is dropped
2454 ** at the btree level, in case the sqlite_sequence table needs to
2455 ** move as a result of the drop (can happen in auto-vacuum mode).
2456 */
2457 if( pTab->tabFlags & TF_Autoincrement ){
2458 sqlite3NestedParse(pParse,
2459 "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
drh69c33822016-08-18 14:33:11 +00002460 pDb->zDbSName, pTab->zName
drhfaacf172011-08-12 01:51:45 +00002461 );
2462 }
2463#endif
2464
2465 /* Drop all SQLITE_MASTER table and index entries that refer to the
2466 ** table. The program name loops through the master table and deletes
2467 ** every row that refers to a table of the same name as the one being
mistachkin48864df2013-03-21 21:20:32 +00002468 ** dropped. Triggers are handled separately because a trigger can be
drhfaacf172011-08-12 01:51:45 +00002469 ** created in the temp database that refers to a table in another
2470 ** database.
2471 */
2472 sqlite3NestedParse(pParse,
2473 "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
drh69c33822016-08-18 14:33:11 +00002474 pDb->zDbSName, SCHEMA_TABLE(iDb), pTab->zName);
drhfaacf172011-08-12 01:51:45 +00002475 if( !isView && !IsVirtual(pTab) ){
2476 destroyTable(pParse, pTab);
2477 }
2478
2479 /* Remove the table entry from SQLite's internal schema and modify
2480 ** the schema cookie.
2481 */
2482 if( IsVirtual(pTab) ){
2483 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
2484 }
2485 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
2486 sqlite3ChangeCookie(pParse, iDb);
2487 sqliteViewResetAll(db, iDb);
drhfaacf172011-08-12 01:51:45 +00002488}
2489
2490/*
drh75897232000-05-29 14:26:00 +00002491** This routine is called to do the work of a DROP TABLE statement.
drhd9b02572001-04-15 00:37:09 +00002492** pName is the name of the table to be dropped.
drh75897232000-05-29 14:26:00 +00002493*/
drha0733842005-12-29 01:11:36 +00002494void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
danielk1977a8858102004-05-28 12:11:21 +00002495 Table *pTab;
drh75897232000-05-29 14:26:00 +00002496 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00002497 sqlite3 *db = pParse->db;
drhd24cc422003-03-27 12:51:24 +00002498 int iDb;
drh75897232000-05-29 14:26:00 +00002499
drh8af73d42009-05-13 22:58:28 +00002500 if( db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +00002501 goto exit_drop_table;
2502 }
drh8af73d42009-05-13 22:58:28 +00002503 assert( pParse->nErr==0 );
danielk1977a8858102004-05-28 12:11:21 +00002504 assert( pName->nSrc==1 );
drh75209962015-04-19 22:31:45 +00002505 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
drha7564662010-02-22 19:32:31 +00002506 if( noErr ) db->suppressErr++;
drh4d249e62016-06-10 22:49:01 +00002507 assert( isView==0 || isView==LOCATE_VIEW );
dan41fb5cd2012-10-04 19:33:00 +00002508 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
drha7564662010-02-22 19:32:31 +00002509 if( noErr ) db->suppressErr--;
danielk1977a8858102004-05-28 12:11:21 +00002510
drha0733842005-12-29 01:11:36 +00002511 if( pTab==0 ){
dan57966752011-04-09 17:32:58 +00002512 if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
drha0733842005-12-29 01:11:36 +00002513 goto exit_drop_table;
2514 }
danielk1977da184232006-01-05 11:34:32 +00002515 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drhe22a3342003-04-22 20:30:37 +00002516 assert( iDb>=0 && iDb<db->nDb );
danielk1977b5258c32007-10-04 18:11:15 +00002517
2518 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
2519 ** it is initialized.
2520 */
2521 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
2522 goto exit_drop_table;
2523 }
drhe5f9c642003-01-13 23:27:31 +00002524#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +00002525 {
2526 int code;
danielk1977da184232006-01-05 11:34:32 +00002527 const char *zTab = SCHEMA_TABLE(iDb);
drh69c33822016-08-18 14:33:11 +00002528 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977f1a381e2006-06-16 08:01:02 +00002529 const char *zArg2 = 0;
danielk19774adee202004-05-08 08:23:19 +00002530 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
danielk1977a8858102004-05-28 12:11:21 +00002531 goto exit_drop_table;
drhe22a3342003-04-22 20:30:37 +00002532 }
drhe5f9c642003-01-13 23:27:31 +00002533 if( isView ){
danielk197753c0f742005-03-29 03:10:59 +00002534 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00002535 code = SQLITE_DROP_TEMP_VIEW;
2536 }else{
2537 code = SQLITE_DROP_VIEW;
2538 }
danielk19774b2688a2006-06-20 11:01:07 +00002539#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977f1a381e2006-06-16 08:01:02 +00002540 }else if( IsVirtual(pTab) ){
2541 code = SQLITE_DROP_VTABLE;
danielk1977595a5232009-07-24 17:58:53 +00002542 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
danielk19774b2688a2006-06-20 11:01:07 +00002543#endif
drhe5f9c642003-01-13 23:27:31 +00002544 }else{
danielk197753c0f742005-03-29 03:10:59 +00002545 if( !OMIT_TEMPDB && iDb==1 ){
drhe5f9c642003-01-13 23:27:31 +00002546 code = SQLITE_DROP_TEMP_TABLE;
2547 }else{
2548 code = SQLITE_DROP_TABLE;
2549 }
2550 }
danielk1977f1a381e2006-06-16 08:01:02 +00002551 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
danielk1977a8858102004-05-28 12:11:21 +00002552 goto exit_drop_table;
drhe5f9c642003-01-13 23:27:31 +00002553 }
danielk1977a8858102004-05-28 12:11:21 +00002554 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
2555 goto exit_drop_table;
drh77ad4e42003-01-14 02:49:27 +00002556 }
drhe5f9c642003-01-13 23:27:31 +00002557 }
2558#endif
drh08ccfaa2011-10-07 23:52:25 +00002559 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
2560 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
danielk1977a8858102004-05-28 12:11:21 +00002561 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
danielk1977a8858102004-05-28 12:11:21 +00002562 goto exit_drop_table;
drh75897232000-05-29 14:26:00 +00002563 }
danielk1977576ec6b2005-01-21 11:55:25 +00002564
2565#ifndef SQLITE_OMIT_VIEW
2566 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
2567 ** on a table.
2568 */
danielk1977a8858102004-05-28 12:11:21 +00002569 if( isView && pTab->pSelect==0 ){
2570 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
2571 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00002572 }
danielk1977a8858102004-05-28 12:11:21 +00002573 if( !isView && pTab->pSelect ){
2574 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
2575 goto exit_drop_table;
drh4ff6dfa2002-03-03 23:06:00 +00002576 }
danielk1977576ec6b2005-01-21 11:55:25 +00002577#endif
drh75897232000-05-29 14:26:00 +00002578
drh1ccde152000-06-17 13:12:39 +00002579 /* Generate code to remove the table from the master table
2580 ** on disk.
2581 */
danielk19774adee202004-05-08 08:23:19 +00002582 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00002583 if( v ){
drh77658e22007-12-04 16:54:52 +00002584 sqlite3BeginWriteOperation(pParse, 1, iDb);
drha5ae4c32011-08-07 01:31:52 +00002585 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
drhe0bc4042002-06-25 01:09:11 +00002586 sqlite3FkDropTable(pParse, pName, pTab);
drhfaacf172011-08-12 01:51:45 +00002587 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
drh75897232000-05-29 14:26:00 +00002588 }
danielk1977a8858102004-05-28 12:11:21 +00002589
2590exit_drop_table:
drh633e6d52008-07-28 19:34:53 +00002591 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00002592}
2593
2594/*
drhc2eef3b2002-08-31 18:53:06 +00002595** This routine is called to create a new foreign key on the table
2596** currently under construction. pFromCol determines which columns
2597** in the current table point to the foreign key. If pFromCol==0 then
2598** connect the key to the last column inserted. pTo is the name of
drhbd50a922013-11-03 02:27:58 +00002599** the table referred to (a.k.a the "parent" table). pToCol is a list
2600** of tables in the parent pTo table. flags contains all
drhc2eef3b2002-08-31 18:53:06 +00002601** information about the conflict resolution algorithms specified
2602** in the ON DELETE, ON UPDATE and ON INSERT clauses.
2603**
2604** An FKey structure is created and added to the table currently
drhe61922a2009-05-02 13:29:37 +00002605** under construction in the pParse->pNewTable field.
drhc2eef3b2002-08-31 18:53:06 +00002606**
2607** The foreign key is set for IMMEDIATE processing. A subsequent call
danielk19774adee202004-05-08 08:23:19 +00002608** to sqlite3DeferForeignKey() might change this to DEFERRED.
drhc2eef3b2002-08-31 18:53:06 +00002609*/
danielk19774adee202004-05-08 08:23:19 +00002610void sqlite3CreateForeignKey(
drhc2eef3b2002-08-31 18:53:06 +00002611 Parse *pParse, /* Parsing context */
danielk19770202b292004-06-09 09:55:16 +00002612 ExprList *pFromCol, /* Columns in this table that point to other table */
drhc2eef3b2002-08-31 18:53:06 +00002613 Token *pTo, /* Name of the other table */
danielk19770202b292004-06-09 09:55:16 +00002614 ExprList *pToCol, /* Columns in the other table */
drhc2eef3b2002-08-31 18:53:06 +00002615 int flags /* Conflict resolution algorithms. */
2616){
danielk197718576932008-08-06 13:47:40 +00002617 sqlite3 *db = pParse->db;
drhb7f91642004-10-31 02:22:47 +00002618#ifndef SQLITE_OMIT_FOREIGN_KEY
drh40e016e2004-11-04 14:47:11 +00002619 FKey *pFKey = 0;
dan1da40a32009-09-19 17:00:31 +00002620 FKey *pNextTo;
drhc2eef3b2002-08-31 18:53:06 +00002621 Table *p = pParse->pNewTable;
2622 int nByte;
2623 int i;
2624 int nCol;
2625 char *z;
drhc2eef3b2002-08-31 18:53:06 +00002626
2627 assert( pTo!=0 );
drh8af73d42009-05-13 22:58:28 +00002628 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
drhc2eef3b2002-08-31 18:53:06 +00002629 if( pFromCol==0 ){
2630 int iCol = p->nCol-1;
drhd3001712009-05-12 17:46:53 +00002631 if( NEVER(iCol<0) ) goto fk_end;
danielk19770202b292004-06-09 09:55:16 +00002632 if( pToCol && pToCol->nExpr!=1 ){
danielk19774adee202004-05-08 08:23:19 +00002633 sqlite3ErrorMsg(pParse, "foreign key on %s"
drhf7a9e1a2004-02-22 18:40:56 +00002634 " should reference only one column of table %T",
2635 p->aCol[iCol].zName, pTo);
drhc2eef3b2002-08-31 18:53:06 +00002636 goto fk_end;
2637 }
2638 nCol = 1;
danielk19770202b292004-06-09 09:55:16 +00002639 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
danielk19774adee202004-05-08 08:23:19 +00002640 sqlite3ErrorMsg(pParse,
drhc2eef3b2002-08-31 18:53:06 +00002641 "number of columns in foreign key does not match the number of "
drhf7a9e1a2004-02-22 18:40:56 +00002642 "columns in the referenced table");
drhc2eef3b2002-08-31 18:53:06 +00002643 goto fk_end;
2644 }else{
danielk19770202b292004-06-09 09:55:16 +00002645 nCol = pFromCol->nExpr;
drhc2eef3b2002-08-31 18:53:06 +00002646 }
drhe61922a2009-05-02 13:29:37 +00002647 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
drhc2eef3b2002-08-31 18:53:06 +00002648 if( pToCol ){
danielk19770202b292004-06-09 09:55:16 +00002649 for(i=0; i<pToCol->nExpr; i++){
drhea678832008-12-10 19:26:22 +00002650 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
drhc2eef3b2002-08-31 18:53:06 +00002651 }
2652 }
drh633e6d52008-07-28 19:34:53 +00002653 pFKey = sqlite3DbMallocZero(db, nByte );
drh17435752007-08-16 04:30:38 +00002654 if( pFKey==0 ){
2655 goto fk_end;
2656 }
drhc2eef3b2002-08-31 18:53:06 +00002657 pFKey->pFrom = p;
2658 pFKey->pNextFrom = p->pFKey;
drhe61922a2009-05-02 13:29:37 +00002659 z = (char*)&pFKey->aCol[nCol];
drhdf68f6b2002-09-21 15:57:57 +00002660 pFKey->zTo = z;
drhc2eef3b2002-08-31 18:53:06 +00002661 memcpy(z, pTo->z, pTo->n);
2662 z[pTo->n] = 0;
danielk197770d9e9c2009-04-24 18:06:09 +00002663 sqlite3Dequote(z);
drhc2eef3b2002-08-31 18:53:06 +00002664 z += pTo->n+1;
drhc2eef3b2002-08-31 18:53:06 +00002665 pFKey->nCol = nCol;
drhc2eef3b2002-08-31 18:53:06 +00002666 if( pFromCol==0 ){
2667 pFKey->aCol[0].iFrom = p->nCol-1;
2668 }else{
2669 for(i=0; i<nCol; i++){
2670 int j;
2671 for(j=0; j<p->nCol; j++){
danielk19774adee202004-05-08 08:23:19 +00002672 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
drhc2eef3b2002-08-31 18:53:06 +00002673 pFKey->aCol[i].iFrom = j;
2674 break;
2675 }
2676 }
2677 if( j>=p->nCol ){
danielk19774adee202004-05-08 08:23:19 +00002678 sqlite3ErrorMsg(pParse,
drhf7a9e1a2004-02-22 18:40:56 +00002679 "unknown column \"%s\" in foreign key definition",
2680 pFromCol->a[i].zName);
drhc2eef3b2002-08-31 18:53:06 +00002681 goto fk_end;
2682 }
2683 }
2684 }
2685 if( pToCol ){
2686 for(i=0; i<nCol; i++){
drhea678832008-12-10 19:26:22 +00002687 int n = sqlite3Strlen30(pToCol->a[i].zName);
drhc2eef3b2002-08-31 18:53:06 +00002688 pFKey->aCol[i].zCol = z;
2689 memcpy(z, pToCol->a[i].zName, n);
2690 z[n] = 0;
2691 z += n+1;
2692 }
2693 }
2694 pFKey->isDeferred = 0;
dan8099ce62009-09-23 08:43:35 +00002695 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
2696 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
drhc2eef3b2002-08-31 18:53:06 +00002697
drh21206082011-04-04 18:22:02 +00002698 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
dan1da40a32009-09-19 17:00:31 +00002699 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
drhacbcb7e2014-08-21 20:26:37 +00002700 pFKey->zTo, (void *)pFKey
dan1da40a32009-09-19 17:00:31 +00002701 );
danf59c5ca2009-09-22 16:55:38 +00002702 if( pNextTo==pFKey ){
drh4a642b62016-02-05 01:55:27 +00002703 sqlite3OomFault(db);
danf59c5ca2009-09-22 16:55:38 +00002704 goto fk_end;
2705 }
dan1da40a32009-09-19 17:00:31 +00002706 if( pNextTo ){
2707 assert( pNextTo->pPrevTo==0 );
2708 pFKey->pNextTo = pNextTo;
2709 pNextTo->pPrevTo = pFKey;
2710 }
2711
drhc2eef3b2002-08-31 18:53:06 +00002712 /* Link the foreign key to the table as the last step.
2713 */
2714 p->pFKey = pFKey;
2715 pFKey = 0;
2716
2717fk_end:
drh633e6d52008-07-28 19:34:53 +00002718 sqlite3DbFree(db, pFKey);
drhb7f91642004-10-31 02:22:47 +00002719#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
drh633e6d52008-07-28 19:34:53 +00002720 sqlite3ExprListDelete(db, pFromCol);
2721 sqlite3ExprListDelete(db, pToCol);
drhc2eef3b2002-08-31 18:53:06 +00002722}
2723
2724/*
2725** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
2726** clause is seen as part of a foreign key definition. The isDeferred
2727** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
2728** The behavior of the most recently created foreign key is adjusted
2729** accordingly.
2730*/
danielk19774adee202004-05-08 08:23:19 +00002731void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
drhb7f91642004-10-31 02:22:47 +00002732#ifndef SQLITE_OMIT_FOREIGN_KEY
drhc2eef3b2002-08-31 18:53:06 +00002733 Table *pTab;
2734 FKey *pFKey;
2735 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
drh4c429832009-10-12 22:30:49 +00002736 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
drh1bd10f82008-12-10 21:19:56 +00002737 pFKey->isDeferred = (u8)isDeferred;
drhb7f91642004-10-31 02:22:47 +00002738#endif
drhc2eef3b2002-08-31 18:53:06 +00002739}
2740
2741/*
drh063336a2004-11-05 20:58:39 +00002742** Generate code that will erase and refill index *pIdx. This is
2743** used to initialize a newly created index or to recompute the
2744** content of an index in response to a REINDEX command.
2745**
2746** if memRootPage is not negative, it means that the index is newly
drh1db639c2008-01-17 02:36:28 +00002747** created. The register specified by memRootPage contains the
drh063336a2004-11-05 20:58:39 +00002748** root page number of the index. If memRootPage is negative, then
2749** the index already exists and must be cleared before being refilled and
2750** the root page number of the index is taken from pIndex->tnum.
2751*/
2752static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
2753 Table *pTab = pIndex->pTable; /* The table that is indexed */
danielk19776ab3a2e2009-02-19 14:39:25 +00002754 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
2755 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
drhb07028f2011-10-14 21:49:18 +00002756 int iSorter; /* Cursor opened by OpenSorter (if in use) */
drh063336a2004-11-05 20:58:39 +00002757 int addr1; /* Address of top of loop */
dan5134d132011-09-02 10:31:11 +00002758 int addr2; /* Address to jump to for next iteration */
drh063336a2004-11-05 20:58:39 +00002759 int tnum; /* Root page of index */
drhb2b9d3d2013-08-01 01:14:43 +00002760 int iPartIdxLabel; /* Jump to this label to skip a row */
drh063336a2004-11-05 20:58:39 +00002761 Vdbe *v; /* Generate code into this virtual machine */
danielk1977b3bf5562006-01-10 17:58:23 +00002762 KeyInfo *pKey; /* KeyInfo for index */
peter.d.reid60ec9142014-09-06 16:39:46 +00002763 int regRecord; /* Register holding assembled index record */
drh17435752007-08-16 04:30:38 +00002764 sqlite3 *db = pParse->db; /* The database connection */
2765 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drh063336a2004-11-05 20:58:39 +00002766
danielk19771d54df82004-11-23 15:41:16 +00002767#ifndef SQLITE_OMIT_AUTHORIZATION
2768 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
drh69c33822016-08-18 14:33:11 +00002769 db->aDb[iDb].zDbSName ) ){
danielk19771d54df82004-11-23 15:41:16 +00002770 return;
2771 }
2772#endif
2773
danielk1977c00da102006-01-07 13:21:04 +00002774 /* Require a write-lock on the table to perform this operation */
2775 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
2776
drh063336a2004-11-05 20:58:39 +00002777 v = sqlite3GetVdbe(pParse);
2778 if( v==0 ) return;
2779 if( memRootPage>=0 ){
drh1db639c2008-01-17 02:36:28 +00002780 tnum = memRootPage;
drh063336a2004-11-05 20:58:39 +00002781 }else{
2782 tnum = pIndex->tnum;
drh063336a2004-11-05 20:58:39 +00002783 }
drh2ec2fb22013-11-06 19:59:23 +00002784 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
drh60de73e2016-04-05 15:59:23 +00002785 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
dana20fde62011-07-12 14:28:05 +00002786
dan689ab892011-08-12 15:02:00 +00002787 /* Open the sorter cursor if we are to use one. */
drhca892a72011-09-03 00:17:51 +00002788 iSorter = pParse->nTab++;
danfad9f9a2014-04-01 18:41:51 +00002789 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
drh2ec2fb22013-11-06 19:59:23 +00002790 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
dana20fde62011-07-12 14:28:05 +00002791
2792 /* Open the table. Loop through all rows of the table, inserting index
2793 ** records into the sorter. */
drhdd9930e2013-10-23 23:37:02 +00002794 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
drh688852a2014-02-17 22:40:43 +00002795 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
drh2d401ab2008-01-10 23:50:11 +00002796 regRecord = sqlite3GetTempReg(pParse);
dana20fde62011-07-12 14:28:05 +00002797
drh1c2c0b72014-01-04 19:27:05 +00002798 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
drhca892a72011-09-03 00:17:51 +00002799 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
drh87744512014-04-13 19:15:49 +00002800 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
drh688852a2014-02-17 22:40:43 +00002801 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
drhca892a72011-09-03 00:17:51 +00002802 sqlite3VdbeJumpHere(v, addr1);
drh44156282013-10-23 22:23:03 +00002803 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
2804 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
drh2ec2fb22013-11-06 19:59:23 +00002805 (char *)pKey, P4_KEYINFO);
drh44156282013-10-23 22:23:03 +00002806 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
2807
drh688852a2014-02-17 22:40:43 +00002808 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
drh60de73e2016-04-05 15:59:23 +00002809 if( IsUniqueIndex(pIndex) ){
drhca892a72011-09-03 00:17:51 +00002810 int j2 = sqlite3VdbeCurrentAddr(v) + 3;
drh076e85f2015-09-03 13:46:12 +00002811 sqlite3VdbeGoto(v, j2);
drhca892a72011-09-03 00:17:51 +00002812 addr2 = sqlite3VdbeCurrentAddr(v);
drh1153c7b2013-11-01 22:02:56 +00002813 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
drhac502322014-07-30 13:56:48 +00002814 pIndex->nKeyCol); VdbeCoverage(v);
drhf9c8ce32013-11-05 13:33:55 +00002815 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
drhca892a72011-09-03 00:17:51 +00002816 }else{
2817 addr2 = sqlite3VdbeCurrentAddr(v);
dan689ab892011-08-12 15:02:00 +00002818 }
drh6cf4a7d2014-10-13 13:00:58 +00002819 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
danb18e60b2015-04-01 16:18:00 +00002820 sqlite3VdbeAddOp3(v, OP_Last, iIdx, 0, -1);
drh9b4eaeb2016-11-09 00:10:33 +00002821 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
drhca892a72011-09-03 00:17:51 +00002822 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
drh2d401ab2008-01-10 23:50:11 +00002823 sqlite3ReleaseTempReg(pParse, regRecord);
drh688852a2014-02-17 22:40:43 +00002824 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
drhd654be82005-09-20 17:42:23 +00002825 sqlite3VdbeJumpHere(v, addr1);
dana20fde62011-07-12 14:28:05 +00002826
drh66a51672008-01-03 00:01:23 +00002827 sqlite3VdbeAddOp1(v, OP_Close, iTab);
2828 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
dan689ab892011-08-12 15:02:00 +00002829 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
drh063336a2004-11-05 20:58:39 +00002830}
2831
2832/*
drh77e57df2013-10-22 14:28:02 +00002833** Allocate heap space to hold an Index object with nCol columns.
2834**
2835** Increase the allocation size to provide an extra nExtra bytes
2836** of 8-byte aligned space after the Index object and return a
2837** pointer to this extra space in *ppExtra.
2838*/
2839Index *sqlite3AllocateIndexObject(
2840 sqlite3 *db, /* Database connection */
drhbbbdc832013-10-22 18:01:40 +00002841 i16 nCol, /* Total number of columns in the index */
drh77e57df2013-10-22 14:28:02 +00002842 int nExtra, /* Number of bytes of extra space to alloc */
2843 char **ppExtra /* Pointer to the "extra" space */
2844){
2845 Index *p; /* Allocated index object */
2846 int nByte; /* Bytes of space for Index object + arrays */
2847
2848 nByte = ROUND8(sizeof(Index)) + /* Index structure */
2849 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
dancfc9df72014-04-25 15:01:01 +00002850 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
drhbbbdc832013-10-22 18:01:40 +00002851 sizeof(i16)*nCol + /* Index.aiColumn */
drh77e57df2013-10-22 14:28:02 +00002852 sizeof(u8)*nCol); /* Index.aSortOrder */
2853 p = sqlite3DbMallocZero(db, nByte + nExtra);
2854 if( p ){
2855 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
drhf19aa5f2015-12-30 16:51:20 +00002856 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
dancfc9df72014-04-25 15:01:01 +00002857 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
2858 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
drh77e57df2013-10-22 14:28:02 +00002859 p->aSortOrder = (u8*)pExtra;
2860 p->nColumn = nCol;
drhbbbdc832013-10-22 18:01:40 +00002861 p->nKeyCol = nCol - 1;
drh77e57df2013-10-22 14:28:02 +00002862 *ppExtra = ((char*)p) + nByte;
2863 }
2864 return p;
2865}
2866
2867/*
drh23bf66d2004-12-14 03:34:34 +00002868** Create a new index for an SQL table. pName1.pName2 is the name of the index
2869** and pTblList is the name of the table that is to be indexed. Both will
drhadbca9c2001-09-27 15:11:53 +00002870** be NULL for a primary key or an index that is created to satisfy a
2871** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
drh382c0242001-10-06 16:33:02 +00002872** as the table to be indexed. pParse->pNewTable is a table that is
2873** currently being constructed by a CREATE TABLE statement.
drh75897232000-05-29 14:26:00 +00002874**
drh382c0242001-10-06 16:33:02 +00002875** pList is a list of columns to be indexed. pList will be NULL if this
2876** is a primary key or unique-constraint on the most recent column added
2877** to the table currently under construction.
drh75897232000-05-29 14:26:00 +00002878*/
drh62340f82016-05-31 21:18:15 +00002879void sqlite3CreateIndex(
drh23bf66d2004-12-14 03:34:34 +00002880 Parse *pParse, /* All information about this parse */
2881 Token *pName1, /* First part of index name. May be NULL */
2882 Token *pName2, /* Second part of index name. May be NULL */
2883 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
danielk19770202b292004-06-09 09:55:16 +00002884 ExprList *pList, /* A list of columns to be indexed */
drh23bf66d2004-12-14 03:34:34 +00002885 int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
drh1c55ba02007-07-02 19:31:27 +00002886 Token *pStart, /* The CREATE token that begins this statement */
drh1fe05372013-07-31 18:12:26 +00002887 Expr *pPIWhere, /* WHERE clause for partial indices */
drh4d91a702006-01-04 15:54:36 +00002888 int sortOrder, /* Sort order of primary key when pList==NULL */
drh62340f82016-05-31 21:18:15 +00002889 int ifNotExist, /* Omit error if index already exists */
2890 u8 idxType /* The index type */
drh75897232000-05-29 14:26:00 +00002891){
drhfdd6e852005-12-16 01:06:16 +00002892 Table *pTab = 0; /* Table to be indexed */
2893 Index *pIndex = 0; /* The index to be created */
2894 char *zName = 0; /* Name of the index */
2895 int nName; /* Number of characters in zName */
drhbeae3192001-09-22 18:12:08 +00002896 int i, j;
drhfdd6e852005-12-16 01:06:16 +00002897 DbFixer sFix; /* For assigning database names to pTable */
2898 int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
drh9bb575f2004-09-06 17:24:11 +00002899 sqlite3 *db = pParse->db;
drhfdd6e852005-12-16 01:06:16 +00002900 Db *pDb; /* The specific table containing the indexed database */
2901 int iDb; /* Index of the database that is being written */
2902 Token *pName = 0; /* Unqualified name of the index to create */
2903 struct ExprList_item *pListItem; /* For looping over pList */
drhc28c4e52013-10-03 19:21:41 +00002904 int nExtra = 0; /* Space allocated for zExtra[] */
drh44156282013-10-23 22:23:03 +00002905 int nExtraCol; /* Number of extra columns needed */
drh47b927d2013-12-03 00:11:40 +00002906 char *zExtra = 0; /* Extra space after the Index object */
drh44156282013-10-23 22:23:03 +00002907 Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
danielk1977cbb18d22004-05-28 11:37:27 +00002908
drh62340f82016-05-31 21:18:15 +00002909 if( db->mallocFailed || pParse->nErr>0 ){
2910 goto exit_create_index;
2911 }
2912 if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
drhd3001712009-05-12 17:46:53 +00002913 goto exit_create_index;
2914 }
2915 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e501b892006-01-09 06:29:47 +00002916 goto exit_create_index;
2917 }
drhdaffd0e2001-04-11 14:28:42 +00002918
drh75897232000-05-29 14:26:00 +00002919 /*
2920 ** Find the table that is to be indexed. Return early if not found.
2921 */
danielk1977cbb18d22004-05-28 11:37:27 +00002922 if( pTblName!=0 ){
danielk1977cbb18d22004-05-28 11:37:27 +00002923
2924 /* Use the two-part index name to determine the database
danielk1977ef2cb632004-05-29 02:37:19 +00002925 ** to search for the table. 'Fix' the table name to this db
2926 ** before looking up the table.
danielk1977cbb18d22004-05-28 11:37:27 +00002927 */
2928 assert( pName1 && pName2 );
danielk1977ef2cb632004-05-29 02:37:19 +00002929 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
danielk1977cbb18d22004-05-28 11:37:27 +00002930 if( iDb<0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00002931 assert( pName && pName->z );
danielk1977cbb18d22004-05-28 11:37:27 +00002932
danielk197753c0f742005-03-29 03:10:59 +00002933#ifndef SQLITE_OMIT_TEMPDB
mistachkind5578432012-08-25 10:01:29 +00002934 /* If the index name was unqualified, check if the table
danielk1977fe910332007-12-02 11:46:34 +00002935 ** is a temp table. If so, set the database to 1. Do not do this
2936 ** if initialising a database schema.
danielk1977cbb18d22004-05-28 11:37:27 +00002937 */
danielk1977fe910332007-12-02 11:46:34 +00002938 if( !db->init.busy ){
2939 pTab = sqlite3SrcListLookup(pParse, pTblName);
drhd3001712009-05-12 17:46:53 +00002940 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
danielk1977fe910332007-12-02 11:46:34 +00002941 iDb = 1;
2942 }
danielk1977ef2cb632004-05-29 02:37:19 +00002943 }
danielk197753c0f742005-03-29 03:10:59 +00002944#endif
danielk1977ef2cb632004-05-29 02:37:19 +00002945
drhd100f692013-10-03 15:39:44 +00002946 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
2947 if( sqlite3FixSrcList(&sFix, pTblName) ){
drh85c23c62005-08-20 03:03:04 +00002948 /* Because the parser constructs pTblName from a single identifier,
2949 ** sqlite3FixSrcList can never fail. */
2950 assert(0);
danielk1977cbb18d22004-05-28 11:37:27 +00002951 }
dan41fb5cd2012-10-04 19:33:00 +00002952 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
drhc31c7c12012-10-08 23:25:07 +00002953 assert( db->mallocFailed==0 || pTab==0 );
2954 if( pTab==0 ) goto exit_create_index;
drh989b1162013-08-01 22:27:26 +00002955 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
2956 sqlite3ErrorMsg(pParse,
2957 "cannot create a TEMP index on non-TEMP table \"%s\"",
2958 pTab->zName);
2959 goto exit_create_index;
2960 }
drh44156282013-10-23 22:23:03 +00002961 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
drh75897232000-05-29 14:26:00 +00002962 }else{
drhe3c41372001-09-17 20:25:58 +00002963 assert( pName==0 );
drhb07028f2011-10-14 21:49:18 +00002964 assert( pStart==0 );
danielk1977da184232006-01-05 11:34:32 +00002965 pTab = pParse->pNewTable;
drha6370df2006-01-04 21:40:06 +00002966 if( !pTab ) goto exit_create_index;
danielk1977da184232006-01-05 11:34:32 +00002967 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh75897232000-05-29 14:26:00 +00002968 }
drhfdd6e852005-12-16 01:06:16 +00002969 pDb = &db->aDb[iDb];
danielk1977cbb18d22004-05-28 11:37:27 +00002970
drhd3001712009-05-12 17:46:53 +00002971 assert( pTab!=0 );
2972 assert( pParse->nErr==0 );
drh03881232009-02-13 03:43:31 +00002973 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
drh3a3a03f2014-09-11 16:36:43 +00002974 && db->init.busy==0
drhd4530972014-09-09 14:47:53 +00002975#if SQLITE_USER_AUTHENTICATION
2976 && sqlite3UserAuthTable(pTab->zName)==0
2977#endif
drh503a6862013-03-01 01:07:17 +00002978 && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 ){
danielk19774adee202004-05-08 08:23:19 +00002979 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
drh0be9df02003-03-30 00:19:49 +00002980 goto exit_create_index;
2981 }
danielk1977576ec6b2005-01-21 11:55:25 +00002982#ifndef SQLITE_OMIT_VIEW
drha76b5df2002-02-23 02:32:10 +00002983 if( pTab->pSelect ){
danielk19774adee202004-05-08 08:23:19 +00002984 sqlite3ErrorMsg(pParse, "views may not be indexed");
drha76b5df2002-02-23 02:32:10 +00002985 goto exit_create_index;
2986 }
danielk1977576ec6b2005-01-21 11:55:25 +00002987#endif
danielk19775ee9d692006-06-21 12:36:25 +00002988#ifndef SQLITE_OMIT_VIRTUALTABLE
2989 if( IsVirtual(pTab) ){
2990 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
2991 goto exit_create_index;
2992 }
2993#endif
drh75897232000-05-29 14:26:00 +00002994
2995 /*
2996 ** Find the name of the index. Make sure there is not already another
drhf57b3392001-10-08 13:22:32 +00002997 ** index or table with the same name.
2998 **
2999 ** Exception: If we are reading the names of permanent indices from the
3000 ** sqlite_master table (because some other process changed the schema) and
3001 ** one of the index names collides with the name of a temporary table or
drhd24cc422003-03-27 12:51:24 +00003002 ** index, then we will continue to process this index.
drhf57b3392001-10-08 13:22:32 +00003003 **
3004 ** If pName==0 it means that we are
drhadbca9c2001-09-27 15:11:53 +00003005 ** dealing with a primary key or UNIQUE constraint. We have to invent our
3006 ** own name.
drh75897232000-05-29 14:26:00 +00003007 */
danielk1977d8123362004-06-12 09:25:12 +00003008 if( pName ){
drh17435752007-08-16 04:30:38 +00003009 zName = sqlite3NameFromToken(db, pName);
drhe3c41372001-09-17 20:25:58 +00003010 if( zName==0 ) goto exit_create_index;
drhb07028f2011-10-14 21:49:18 +00003011 assert( pName->z!=0 );
danielk1977d8123362004-06-12 09:25:12 +00003012 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
drhd24cc422003-03-27 12:51:24 +00003013 goto exit_create_index;
drhe3c41372001-09-17 20:25:58 +00003014 }
danielk1977d8123362004-06-12 09:25:12 +00003015 if( !db->init.busy ){
danielk1977d45a0312007-03-13 16:32:25 +00003016 if( sqlite3FindTable(db, zName, 0)!=0 ){
3017 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
3018 goto exit_create_index;
3019 }
3020 }
drh69c33822016-08-18 14:33:11 +00003021 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
danielk197759a33f92007-03-17 10:26:59 +00003022 if( !ifNotExist ){
3023 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
dan7687c832011-04-09 15:39:02 +00003024 }else{
3025 assert( !db->init.busy );
3026 sqlite3CodeVerifySchema(pParse, iDb);
danielk1977d8123362004-06-12 09:25:12 +00003027 }
danielk197759a33f92007-03-17 10:26:59 +00003028 goto exit_create_index;
3029 }
danielk1977a21c6b62005-01-24 10:25:59 +00003030 }else{
drhadbca9c2001-09-27 15:11:53 +00003031 int n;
3032 Index *pLoop;
3033 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
drhf089aa42008-07-08 19:34:06 +00003034 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
danielk1977a1644fd2007-08-29 12:31:25 +00003035 if( zName==0 ){
danielk1977a1644fd2007-08-29 12:31:25 +00003036 goto exit_create_index;
3037 }
drh0aafa9c2016-08-05 14:35:47 +00003038
3039 /* Automatic index names generated from within sqlite3_declare_vtab()
3040 ** must have names that are distinct from normal automatic index names.
3041 ** The following statement converts "sqlite3_autoindex..." into
3042 ** "sqlite3_butoindex..." in order to make the names distinct.
3043 ** The "vtab_err.test" test demonstrates the need of this statement. */
3044 if( IN_DECLARE_VTAB ) zName[7]++;
drh75897232000-05-29 14:26:00 +00003045 }
3046
drhe5f9c642003-01-13 23:27:31 +00003047 /* Check for authorization to create an index.
3048 */
3049#ifndef SQLITE_OMIT_AUTHORIZATION
drhe22a3342003-04-22 20:30:37 +00003050 {
drh69c33822016-08-18 14:33:11 +00003051 const char *zDb = pDb->zDbSName;
danielk197753c0f742005-03-29 03:10:59 +00003052 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
drhe22a3342003-04-22 20:30:37 +00003053 goto exit_create_index;
3054 }
3055 i = SQLITE_CREATE_INDEX;
danielk197753c0f742005-03-29 03:10:59 +00003056 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00003057 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
drhe22a3342003-04-22 20:30:37 +00003058 goto exit_create_index;
3059 }
drhe5f9c642003-01-13 23:27:31 +00003060 }
3061#endif
3062
drh75897232000-05-29 14:26:00 +00003063 /* If pList==0, it means this routine was called to make a primary
drh1ccde152000-06-17 13:12:39 +00003064 ** key out of the last column added to the table under construction.
drh75897232000-05-29 14:26:00 +00003065 ** So create a fake list to simulate this.
3066 */
3067 if( pList==0 ){
drh108aa002015-08-24 20:21:20 +00003068 Token prevCol;
drh40aced52016-01-22 17:48:09 +00003069 sqlite3TokenInit(&prevCol, pTab->aCol[pTab->nCol-1].zName);
drh108aa002015-08-24 20:21:20 +00003070 pList = sqlite3ExprListAppend(pParse, 0,
3071 sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
drh75897232000-05-29 14:26:00 +00003072 if( pList==0 ) goto exit_create_index;
drhbc622bc2015-08-24 15:39:42 +00003073 assert( pList->nExpr==1 );
3074 sqlite3ExprListSetSortOrder(pList, sortOrder);
drh108aa002015-08-24 20:21:20 +00003075 }else{
3076 sqlite3ExprListCheckLength(pParse, pList, "index");
drh75897232000-05-29 14:26:00 +00003077 }
3078
danielk1977b3bf5562006-01-10 17:58:23 +00003079 /* Figure out how many bytes of space are required to store explicitly
3080 ** specified collation sequence names.
3081 */
3082 for(i=0; i<pList->nExpr; i++){
drhd3001712009-05-12 17:46:53 +00003083 Expr *pExpr = pList->a[i].pExpr;
drh7d3d9da2015-09-01 00:42:52 +00003084 assert( pExpr!=0 );
3085 if( pExpr->op==TK_COLLATE ){
dan911ce412013-05-15 15:16:50 +00003086 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
danielk1977b3bf5562006-01-10 17:58:23 +00003087 }
3088 }
3089
drh75897232000-05-29 14:26:00 +00003090 /*
3091 ** Allocate the index structure.
3092 */
drhea678832008-12-10 19:26:22 +00003093 nName = sqlite3Strlen30(zName);
drh44156282013-10-23 22:23:03 +00003094 nExtraCol = pPk ? pPk->nKeyCol : 1;
3095 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
drh77e57df2013-10-22 14:28:02 +00003096 nName + nExtra + 1, &zExtra);
drh17435752007-08-16 04:30:38 +00003097 if( db->mallocFailed ){
3098 goto exit_create_index;
3099 }
dancfc9df72014-04-25 15:01:01 +00003100 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
drhe09b84c2011-11-14 02:53:54 +00003101 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
drh77e57df2013-10-22 14:28:02 +00003102 pIndex->zName = zExtra;
3103 zExtra += nName + 1;
drh5bb3eb92007-05-04 13:15:55 +00003104 memcpy(pIndex->zName, zName, nName+1);
drh75897232000-05-29 14:26:00 +00003105 pIndex->pTable = pTab;
drh1bd10f82008-12-10 21:19:56 +00003106 pIndex->onError = (u8)onError;
drh9eade082013-10-24 14:16:10 +00003107 pIndex->uniqNotNull = onError!=OE_None;
drh62340f82016-05-31 21:18:15 +00003108 pIndex->idxType = idxType;
danielk1977da184232006-01-05 11:34:32 +00003109 pIndex->pSchema = db->aDb[iDb].pSchema;
drh72ffd092013-10-30 15:52:32 +00003110 pIndex->nKeyCol = pList->nExpr;
drh3780be12013-07-31 19:05:22 +00003111 if( pPIWhere ){
3112 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
3113 pIndex->pPartIdxWhere = pPIWhere;
3114 pPIWhere = 0;
3115 }
drh21206082011-04-04 18:22:02 +00003116 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
drh75897232000-05-29 14:26:00 +00003117
drhfdd6e852005-12-16 01:06:16 +00003118 /* Check to see if we should honor DESC requests on index columns
3119 */
danielk1977da184232006-01-05 11:34:32 +00003120 if( pDb->pSchema->file_format>=4 ){
drhfdd6e852005-12-16 01:06:16 +00003121 sortOrderMask = -1; /* Honor DESC */
drhfdd6e852005-12-16 01:06:16 +00003122 }else{
3123 sortOrderMask = 0; /* Ignore DESC */
3124 }
3125
drh1f9ca2c2015-08-25 16:57:52 +00003126 /* Analyze the list of expressions that form the terms of the index and
3127 ** report any errors. In the common case where the expression is exactly
3128 ** a table column, store that column in aiColumn[]. For general expressions,
drh4b92f982015-09-29 17:20:14 +00003129 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
drhd3001712009-05-12 17:46:53 +00003130 **
drh1f9ca2c2015-08-25 16:57:52 +00003131 ** TODO: Issue a warning if two or more columns of the index are identical.
3132 ** TODO: Issue a warning if the table primary key is used as part of the
3133 ** index key.
drh75897232000-05-29 14:26:00 +00003134 */
drhfdd6e852005-12-16 01:06:16 +00003135 for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
drh1f9ca2c2015-08-25 16:57:52 +00003136 Expr *pCExpr; /* The i-th index expression */
3137 int requestedSortOrder; /* ASC or DESC on the i-th expression */
drhf19aa5f2015-12-30 16:51:20 +00003138 const char *zColl; /* Collation sequence name */
danielk1977b3bf5562006-01-10 17:58:23 +00003139
drhedb04ed2015-09-04 12:54:01 +00003140 sqlite3StringToId(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00003141 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
3142 if( pParse->nErr ) goto exit_create_index;
drh108aa002015-08-24 20:21:20 +00003143 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
drha514b8e2015-08-25 00:27:06 +00003144 if( pCExpr->op!=TK_COLUMN ){
drh1f9ca2c2015-08-25 16:57:52 +00003145 if( pTab==pParse->pNewTable ){
3146 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
3147 "UNIQUE constraints");
3148 goto exit_create_index;
3149 }
3150 if( pIndex->aColExpr==0 ){
drh84926532015-08-31 19:38:42 +00003151 ExprList *pCopy = sqlite3ExprListDup(db, pList, 0);
3152 pIndex->aColExpr = pCopy;
3153 if( !db->mallocFailed ){
3154 assert( pCopy!=0 );
3155 pListItem = &pCopy->a[i];
3156 }
drh1f9ca2c2015-08-25 16:57:52 +00003157 }
drh4b92f982015-09-29 17:20:14 +00003158 j = XN_EXPR;
3159 pIndex->aiColumn[i] = XN_EXPR;
drh84926532015-08-31 19:38:42 +00003160 pIndex->uniqNotNull = 0;
drh1f9ca2c2015-08-25 16:57:52 +00003161 }else{
3162 j = pCExpr->iColumn;
3163 assert( j<=0x7fff );
3164 if( j<0 ){
3165 j = pTab->iPKey;
3166 }else if( pTab->aCol[j].notNull==0 ){
3167 pIndex->uniqNotNull = 0;
3168 }
3169 pIndex->aiColumn[i] = (i16)j;
drh108aa002015-08-24 20:21:20 +00003170 }
drha514b8e2015-08-25 00:27:06 +00003171 zColl = 0;
drh108aa002015-08-24 20:21:20 +00003172 if( pListItem->pExpr->op==TK_COLLATE ){
drhd3001712009-05-12 17:46:53 +00003173 int nColl;
dan911ce412013-05-15 15:16:50 +00003174 zColl = pListItem->pExpr->u.zToken;
drhd3001712009-05-12 17:46:53 +00003175 nColl = sqlite3Strlen30(zColl) + 1;
3176 assert( nExtra>=nColl );
3177 memcpy(zExtra, zColl, nColl);
danielk1977b3bf5562006-01-10 17:58:23 +00003178 zColl = zExtra;
drhd3001712009-05-12 17:46:53 +00003179 zExtra += nColl;
3180 nExtra -= nColl;
drha514b8e2015-08-25 00:27:06 +00003181 }else if( j>=0 ){
danielk1977b3bf5562006-01-10 17:58:23 +00003182 zColl = pTab->aCol[j].zColl;
danielk19770202b292004-06-09 09:55:16 +00003183 }
drhf19aa5f2015-12-30 16:51:20 +00003184 if( !zColl ) zColl = sqlite3StrBINARY;
drhb7f24de2009-05-13 17:35:23 +00003185 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
danielk19777cedc8d2004-06-10 10:50:08 +00003186 goto exit_create_index;
3187 }
danielk1977b3bf5562006-01-10 17:58:23 +00003188 pIndex->azColl[i] = zColl;
drhd946db02005-12-29 19:23:06 +00003189 requestedSortOrder = pListItem->sortOrder & sortOrderMask;
drh1bd10f82008-12-10 21:19:56 +00003190 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
drh75897232000-05-29 14:26:00 +00003191 }
drh1f9ca2c2015-08-25 16:57:52 +00003192
3193 /* Append the table key to the end of the index. For WITHOUT ROWID
3194 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
3195 ** normal tables (when pPk==0) this will be the rowid.
3196 */
drh44156282013-10-23 22:23:03 +00003197 if( pPk ){
drh7913e412013-11-01 20:30:36 +00003198 for(j=0; j<pPk->nKeyCol; j++){
3199 int x = pPk->aiColumn[j];
drh1f9ca2c2015-08-25 16:57:52 +00003200 assert( x>=0 );
drh7913e412013-11-01 20:30:36 +00003201 if( hasColumn(pIndex->aiColumn, pIndex->nKeyCol, x) ){
3202 pIndex->nColumn--;
3203 }else{
3204 pIndex->aiColumn[i] = x;
3205 pIndex->azColl[i] = pPk->azColl[j];
3206 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
3207 i++;
3208 }
drh44156282013-10-23 22:23:03 +00003209 }
drh7913e412013-11-01 20:30:36 +00003210 assert( i==pIndex->nColumn );
drh44156282013-10-23 22:23:03 +00003211 }else{
drh4b92f982015-09-29 17:20:14 +00003212 pIndex->aiColumn[i] = XN_ROWID;
drhf19aa5f2015-12-30 16:51:20 +00003213 pIndex->azColl[i] = sqlite3StrBINARY;
drh44156282013-10-23 22:23:03 +00003214 }
drh51147ba2005-07-23 22:59:55 +00003215 sqlite3DefaultRowEst(pIndex);
drhe13e9f52013-10-05 19:18:00 +00003216 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
drh75897232000-05-29 14:26:00 +00003217
danf769cd62016-02-24 20:16:28 +00003218 /* If this index contains every column of its table, then mark
3219 ** it as a covering index */
3220 assert( HasRowid(pTab)
3221 || pTab->iPKey<0 || sqlite3ColumnOfIndex(pIndex, pTab->iPKey)>=0 );
3222 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
3223 pIndex->isCovering = 1;
3224 for(j=0; j<pTab->nCol; j++){
3225 if( j==pTab->iPKey ) continue;
3226 if( sqlite3ColumnOfIndex(pIndex,j)>=0 ) continue;
3227 pIndex->isCovering = 0;
3228 break;
3229 }
3230 }
3231
danielk1977d8123362004-06-12 09:25:12 +00003232 if( pTab==pParse->pNewTable ){
3233 /* This routine has been called to create an automatic index as a
3234 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
3235 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
3236 ** i.e. one of:
3237 **
3238 ** CREATE TABLE t(x PRIMARY KEY, y);
3239 ** CREATE TABLE t(x, y, UNIQUE(x, y));
3240 **
3241 ** Either way, check to see if the table already has such an index. If
3242 ** so, don't bother creating this one. This only applies to
3243 ** automatically created indices. Users can do as they wish with
3244 ** explicit indices.
drhd3001712009-05-12 17:46:53 +00003245 **
3246 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
3247 ** (and thus suppressing the second one) even if they have different
3248 ** sort orders.
3249 **
3250 ** If there are different collating sequences or if the columns of
3251 ** the constraint occur in different orders, then the constraints are
3252 ** considered distinct and both result in separate indices.
danielk1977d8123362004-06-12 09:25:12 +00003253 */
3254 Index *pIdx;
3255 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
3256 int k;
drh5f1d1d92014-07-31 22:59:04 +00003257 assert( IsUniqueIndex(pIdx) );
drh48dd1d82014-05-27 18:18:58 +00003258 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
drh5f1d1d92014-07-31 22:59:04 +00003259 assert( IsUniqueIndex(pIndex) );
danielk1977d8123362004-06-12 09:25:12 +00003260
drhbbbdc832013-10-22 18:01:40 +00003261 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
3262 for(k=0; k<pIdx->nKeyCol; k++){
drhd3001712009-05-12 17:46:53 +00003263 const char *z1;
3264 const char *z2;
drh1f9ca2c2015-08-25 16:57:52 +00003265 assert( pIdx->aiColumn[k]>=0 );
danielk1977d8123362004-06-12 09:25:12 +00003266 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
drhd3001712009-05-12 17:46:53 +00003267 z1 = pIdx->azColl[k];
3268 z2 = pIndex->azColl[k];
drhc41c1322016-02-11 13:30:36 +00003269 if( sqlite3StrICmp(z1, z2) ) break;
danielk1977d8123362004-06-12 09:25:12 +00003270 }
drhbbbdc832013-10-22 18:01:40 +00003271 if( k==pIdx->nKeyCol ){
danielk1977f736b772004-06-17 06:13:34 +00003272 if( pIdx->onError!=pIndex->onError ){
3273 /* This constraint creates the same index as a previous
3274 ** constraint specified somewhere in the CREATE TABLE statement.
3275 ** However the ON CONFLICT clauses are different. If both this
3276 ** constraint and the previous equivalent constraint have explicit
3277 ** ON CONFLICT clauses this is an error. Otherwise, use the
mistachkin48864df2013-03-21 21:20:32 +00003278 ** explicitly specified behavior for the index.
danielk1977f736b772004-06-17 06:13:34 +00003279 */
3280 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
3281 sqlite3ErrorMsg(pParse,
3282 "conflicting ON CONFLICT clauses specified", 0);
3283 }
3284 if( pIdx->onError==OE_Default ){
3285 pIdx->onError = pIndex->onError;
3286 }
3287 }
drh273bfe92016-06-02 16:22:53 +00003288 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
danielk1977d8123362004-06-12 09:25:12 +00003289 goto exit_create_index;
3290 }
3291 }
3292 }
3293
drh75897232000-05-29 14:26:00 +00003294 /* Link the new Index structure to its table and to the other
drhadbca9c2001-09-27 15:11:53 +00003295 ** in-memory database structures.
drh75897232000-05-29 14:26:00 +00003296 */
drh7d3d9da2015-09-01 00:42:52 +00003297 assert( pParse->nErr==0 );
drhcc971732016-06-04 13:57:41 +00003298 if( db->init.busy ){
drh6d4abfb2001-10-22 02:58:08 +00003299 Index *p;
drhcc971732016-06-04 13:57:41 +00003300 assert( !IN_DECLARE_VTAB );
drh21206082011-04-04 18:22:02 +00003301 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
danielk1977da184232006-01-05 11:34:32 +00003302 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
drhacbcb7e2014-08-21 20:26:37 +00003303 pIndex->zName, pIndex);
drh6d4abfb2001-10-22 02:58:08 +00003304 if( p ){
3305 assert( p==pIndex ); /* Malloc must have failed */
drh4a642b62016-02-05 01:55:27 +00003306 sqlite3OomFault(db);
drh6d4abfb2001-10-22 02:58:08 +00003307 goto exit_create_index;
3308 }
drh5e00f6c2001-09-13 13:46:56 +00003309 db->flags |= SQLITE_InternChanges;
drh234c39d2004-07-24 03:30:47 +00003310 if( pTblName!=0 ){
3311 pIndex->tnum = db->init.newTnum;
3312 }
drhd78eeee2001-09-13 16:18:53 +00003313 }
3314
drh58383402013-11-04 17:00:50 +00003315 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
3316 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
3317 ** emit code to allocate the index rootpage on disk and make an entry for
3318 ** the index in the sqlite_master table and populate the index with
3319 ** content. But, do not do this if we are simply reading the sqlite_master
3320 ** table to parse the schema, or if this index is the PRIMARY KEY index
3321 ** of a WITHOUT ROWID table.
drh75897232000-05-29 14:26:00 +00003322 **
drh58383402013-11-04 17:00:50 +00003323 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
3324 ** or UNIQUE index in a CREATE TABLE statement. Since the table
drh382c0242001-10-06 16:33:02 +00003325 ** has just been created, it contains no data and the index initialization
3326 ** step can be skipped.
drh75897232000-05-29 14:26:00 +00003327 */
drh7d3d9da2015-09-01 00:42:52 +00003328 else if( HasRowid(pTab) || pTblName!=0 ){
drhadbca9c2001-09-27 15:11:53 +00003329 Vdbe *v;
drh063336a2004-11-05 20:58:39 +00003330 char *zStmt;
drh0a07c102008-01-03 18:03:08 +00003331 int iMem = ++pParse->nMem;
drh75897232000-05-29 14:26:00 +00003332
danielk19774adee202004-05-08 08:23:19 +00003333 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00003334 if( v==0 ) goto exit_create_index;
drh063336a2004-11-05 20:58:39 +00003335
drhaee128d2005-02-14 20:48:18 +00003336 sqlite3BeginWriteOperation(pParse, 1, iDb);
danc5b73582015-05-26 11:53:14 +00003337
3338 /* Create the rootpage for the index using CreateIndex. But before
3339 ** doing so, code a Noop instruction and store its address in
3340 ** Index.tnum. This is required in case this index is actually a
3341 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
3342 ** that case the convertToWithoutRowidTable() routine will replace
3343 ** the Noop with a Goto to jump over the VDBE code generated below. */
3344 pIndex->tnum = sqlite3VdbeAddOp0(v, OP_Noop);
drhb7654112008-01-12 12:48:07 +00003345 sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
drh063336a2004-11-05 20:58:39 +00003346
3347 /* Gather the complete text of the CREATE INDEX statement into
3348 ** the zStmt variable
3349 */
drhd3001712009-05-12 17:46:53 +00003350 if( pStart ){
drh77dfd5b2013-08-19 11:15:48 +00003351 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
drh8a9789b2013-08-01 03:36:59 +00003352 if( pName->z[n-1]==';' ) n--;
drh063336a2004-11-05 20:58:39 +00003353 /* A named index with an explicit CREATE INDEX statement */
danielk19771e536952007-08-16 10:09:01 +00003354 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
drh8a9789b2013-08-01 03:36:59 +00003355 onError==OE_None ? "" : " UNIQUE", n, pName->z);
drh063336a2004-11-05 20:58:39 +00003356 }else{
3357 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
drhe497f002004-11-07 13:01:49 +00003358 /* zStmt = sqlite3MPrintf(""); */
3359 zStmt = 0;
drh75897232000-05-29 14:26:00 +00003360 }
drh063336a2004-11-05 20:58:39 +00003361
3362 /* Add an entry in sqlite_master for this index
3363 */
3364 sqlite3NestedParse(pParse,
drhb7654112008-01-12 12:48:07 +00003365 "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
drh69c33822016-08-18 14:33:11 +00003366 db->aDb[iDb].zDbSName, SCHEMA_TABLE(iDb),
drh063336a2004-11-05 20:58:39 +00003367 pIndex->zName,
3368 pTab->zName,
drhb7654112008-01-12 12:48:07 +00003369 iMem,
drh063336a2004-11-05 20:58:39 +00003370 zStmt
3371 );
drh633e6d52008-07-28 19:34:53 +00003372 sqlite3DbFree(db, zStmt);
drh063336a2004-11-05 20:58:39 +00003373
danielk1977a21c6b62005-01-24 10:25:59 +00003374 /* Fill the index with data and reparse the schema. Code an OP_Expire
3375 ** to invalidate all pre-compiled statements.
drh063336a2004-11-05 20:58:39 +00003376 */
danielk1977cbb18d22004-05-28 11:37:27 +00003377 if( pTblName ){
drh063336a2004-11-05 20:58:39 +00003378 sqlite3RefillIndex(pParse, pIndex, iMem);
drh9cbf3422008-01-17 16:22:13 +00003379 sqlite3ChangeCookie(pParse, iDb);
drh5d9c9da2011-06-03 20:11:17 +00003380 sqlite3VdbeAddParseSchemaOp(v, iDb,
3381 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
drh01c736d2016-05-20 15:15:07 +00003382 sqlite3VdbeAddOp0(v, OP_Expire);
drh5e00f6c2001-09-13 13:46:56 +00003383 }
danc5b73582015-05-26 11:53:14 +00003384
3385 sqlite3VdbeJumpHere(v, pIndex->tnum);
drh75897232000-05-29 14:26:00 +00003386 }
3387
danielk1977d8123362004-06-12 09:25:12 +00003388 /* When adding an index to the list of indices for a table, make
3389 ** sure all indices labeled OE_Replace come after all those labeled
drhd3001712009-05-12 17:46:53 +00003390 ** OE_Ignore. This is necessary for the correct constraint check
3391 ** processing (in sqlite3GenerateConstraintChecks()) as part of
3392 ** UPDATE and INSERT statements.
danielk1977d8123362004-06-12 09:25:12 +00003393 */
drh234c39d2004-07-24 03:30:47 +00003394 if( db->init.busy || pTblName==0 ){
3395 if( onError!=OE_Replace || pTab->pIndex==0
3396 || pTab->pIndex->onError==OE_Replace){
3397 pIndex->pNext = pTab->pIndex;
3398 pTab->pIndex = pIndex;
3399 }else{
3400 Index *pOther = pTab->pIndex;
3401 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
3402 pOther = pOther->pNext;
3403 }
3404 pIndex->pNext = pOther->pNext;
3405 pOther->pNext = pIndex;
danielk1977d8123362004-06-12 09:25:12 +00003406 }
drh234c39d2004-07-24 03:30:47 +00003407 pIndex = 0;
danielk1977d8123362004-06-12 09:25:12 +00003408 }
danielk1977d8123362004-06-12 09:25:12 +00003409
drh75897232000-05-29 14:26:00 +00003410 /* Clean up before exiting */
3411exit_create_index:
drh1fe05372013-07-31 18:12:26 +00003412 if( pIndex ) freeIndex(db, pIndex);
3413 sqlite3ExprDelete(db, pPIWhere);
drh633e6d52008-07-28 19:34:53 +00003414 sqlite3ExprListDelete(db, pList);
3415 sqlite3SrcListDelete(db, pTblName);
3416 sqlite3DbFree(db, zName);
drh75897232000-05-29 14:26:00 +00003417}
3418
3419/*
drh51147ba2005-07-23 22:59:55 +00003420** Fill the Index.aiRowEst[] array with default information - information
drh91124b32005-08-18 18:15:05 +00003421** to be used when we have not run the ANALYZE command.
drh28c4cf42005-07-27 20:41:43 +00003422**
peter.d.reid60ec9142014-09-06 16:39:46 +00003423** aiRowEst[0] is supposed to contain the number of elements in the index.
drh28c4cf42005-07-27 20:41:43 +00003424** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
3425** number of rows in the table that match any particular value of the
3426** first column of the index. aiRowEst[2] is an estimate of the number
dancfc9df72014-04-25 15:01:01 +00003427** of rows that match any particular combination of the first 2 columns
drh28c4cf42005-07-27 20:41:43 +00003428** of the index. And so forth. It must always be the case that
3429*
3430** aiRowEst[N]<=aiRowEst[N-1]
3431** aiRowEst[N]>=1
3432**
3433** Apart from that, we have little to go on besides intuition as to
3434** how aiRowEst[] should be initialized. The numbers generated here
3435** are based on typical values found in actual indices.
drh51147ba2005-07-23 22:59:55 +00003436*/
3437void sqlite3DefaultRowEst(Index *pIdx){
dan264d2b92014-04-29 19:01:57 +00003438 /* 10, 9, 8, 7, 6 */
3439 LogEst aVal[] = { 33, 32, 30, 28, 26 };
dancfc9df72014-04-25 15:01:01 +00003440 LogEst *a = pIdx->aiRowLogEst;
3441 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
drh51147ba2005-07-23 22:59:55 +00003442 int i;
dancfc9df72014-04-25 15:01:01 +00003443
dan264d2b92014-04-29 19:01:57 +00003444 /* Set the first entry (number of rows in the index) to the estimated
drh8dc570b2016-06-08 18:07:21 +00003445 ** number of rows in the table, or half the number of rows in the table
3446 ** for a partial index. But do not let the estimate drop below 10. */
dancfc9df72014-04-25 15:01:01 +00003447 a[0] = pIdx->pTable->nRowLogEst;
drh8dc570b2016-06-08 18:07:21 +00003448 if( pIdx->pPartIdxWhere!=0 ) a[0] -= 10; assert( 10==sqlite3LogEst(2) );
3449 if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) );
dan264d2b92014-04-29 19:01:57 +00003450
3451 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
3452 ** 6 and each subsequent value (if any) is 5. */
dancfc9df72014-04-25 15:01:01 +00003453 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
dan264d2b92014-04-29 19:01:57 +00003454 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
3455 a[i] = 23; assert( 23==sqlite3LogEst(5) );
drh28c4cf42005-07-27 20:41:43 +00003456 }
dan264d2b92014-04-29 19:01:57 +00003457
3458 assert( 0==sqlite3LogEst(1) );
drh5f1d1d92014-07-31 22:59:04 +00003459 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
drh51147ba2005-07-23 22:59:55 +00003460}
3461
3462/*
drh74e24cd2002-01-09 03:19:59 +00003463** This routine will drop an existing named index. This routine
3464** implements the DROP INDEX statement.
drh75897232000-05-29 14:26:00 +00003465*/
drh4d91a702006-01-04 15:54:36 +00003466void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
drh75897232000-05-29 14:26:00 +00003467 Index *pIndex;
drh75897232000-05-29 14:26:00 +00003468 Vdbe *v;
drh9bb575f2004-09-06 17:24:11 +00003469 sqlite3 *db = pParse->db;
danielk1977da184232006-01-05 11:34:32 +00003470 int iDb;
drh75897232000-05-29 14:26:00 +00003471
drh8af73d42009-05-13 22:58:28 +00003472 assert( pParse->nErr==0 ); /* Never called with prior errors */
3473 if( db->mallocFailed ){
danielk1977d5d56522005-03-16 12:15:20 +00003474 goto exit_drop_index;
3475 }
drhd24cc422003-03-27 12:51:24 +00003476 assert( pName->nSrc==1 );
danielk1977d5d56522005-03-16 12:15:20 +00003477 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
3478 goto exit_drop_index;
3479 }
danielk19774adee202004-05-08 08:23:19 +00003480 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
drh75897232000-05-29 14:26:00 +00003481 if( pIndex==0 ){
drh4d91a702006-01-04 15:54:36 +00003482 if( !ifExists ){
3483 sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
dan57966752011-04-09 17:32:58 +00003484 }else{
3485 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
drh4d91a702006-01-04 15:54:36 +00003486 }
drha6ecd332004-06-10 00:29:09 +00003487 pParse->checkSchema = 1;
drhd24cc422003-03-27 12:51:24 +00003488 goto exit_drop_index;
drh75897232000-05-29 14:26:00 +00003489 }
drh48dd1d82014-05-27 18:18:58 +00003490 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
danielk19774adee202004-05-08 08:23:19 +00003491 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
drh485b39b2002-07-13 03:11:52 +00003492 "or PRIMARY KEY constraint cannot be dropped", 0);
drhd24cc422003-03-27 12:51:24 +00003493 goto exit_drop_index;
3494 }
danielk1977da184232006-01-05 11:34:32 +00003495 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
drhe5f9c642003-01-13 23:27:31 +00003496#ifndef SQLITE_OMIT_AUTHORIZATION
3497 {
3498 int code = SQLITE_DROP_INDEX;
3499 Table *pTab = pIndex->pTable;
drh69c33822016-08-18 14:33:11 +00003500 const char *zDb = db->aDb[iDb].zDbSName;
danielk1977da184232006-01-05 11:34:32 +00003501 const char *zTab = SCHEMA_TABLE(iDb);
danielk19774adee202004-05-08 08:23:19 +00003502 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
drhd24cc422003-03-27 12:51:24 +00003503 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00003504 }
danielk1977da184232006-01-05 11:34:32 +00003505 if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
danielk19774adee202004-05-08 08:23:19 +00003506 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
drhd24cc422003-03-27 12:51:24 +00003507 goto exit_drop_index;
drhe5f9c642003-01-13 23:27:31 +00003508 }
drhed6c8672003-01-12 18:02:16 +00003509 }
drhe5f9c642003-01-13 23:27:31 +00003510#endif
drh75897232000-05-29 14:26:00 +00003511
3512 /* Generate code to remove the index and from the master table */
danielk19774adee202004-05-08 08:23:19 +00003513 v = sqlite3GetVdbe(pParse);
drh75897232000-05-29 14:26:00 +00003514 if( v ){
drh77658e22007-12-04 16:54:52 +00003515 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhb17131a2004-11-05 22:18:49 +00003516 sqlite3NestedParse(pParse,
dan39f1bcb2010-09-29 07:16:46 +00003517 "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
drh69c33822016-08-18 14:33:11 +00003518 db->aDb[iDb].zDbSName, SCHEMA_TABLE(iDb), pIndex->zName
drhb17131a2004-11-05 22:18:49 +00003519 );
drha5ae4c32011-08-07 01:31:52 +00003520 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
drh9cbf3422008-01-17 16:22:13 +00003521 sqlite3ChangeCookie(pParse, iDb);
drhb17131a2004-11-05 22:18:49 +00003522 destroyRootPage(pParse, pIndex->tnum, iDb);
drh66a51672008-01-03 00:01:23 +00003523 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
drh75897232000-05-29 14:26:00 +00003524 }
3525
drhd24cc422003-03-27 12:51:24 +00003526exit_drop_index:
drh633e6d52008-07-28 19:34:53 +00003527 sqlite3SrcListDelete(db, pName);
drh75897232000-05-29 14:26:00 +00003528}
3529
3530/*
dan9ace1122012-03-29 07:51:45 +00003531** pArray is a pointer to an array of objects. Each object in the
3532** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
3533** to extend the array so that there is space for a new object at the end.
drh13449892005-09-07 21:22:45 +00003534**
dan9ace1122012-03-29 07:51:45 +00003535** When this function is called, *pnEntry contains the current size of
3536** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
3537** in total).
drh13449892005-09-07 21:22:45 +00003538**
dan9ace1122012-03-29 07:51:45 +00003539** If the realloc() is successful (i.e. if no OOM condition occurs), the
3540** space allocated for the new object is zeroed, *pnEntry updated to
3541** reflect the new size of the array and a pointer to the new allocation
3542** returned. *pIdx is set to the index of the new array entry in this case.
drh13449892005-09-07 21:22:45 +00003543**
dan9ace1122012-03-29 07:51:45 +00003544** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
3545** unchanged and a copy of pArray returned.
drh13449892005-09-07 21:22:45 +00003546*/
drhcf643722007-03-27 13:36:37 +00003547void *sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003548 sqlite3 *db, /* Connection to notify of malloc failures */
drhcf643722007-03-27 13:36:37 +00003549 void *pArray, /* Array of objects. Might be reallocated */
3550 int szEntry, /* Size of each object in the array */
drhcf643722007-03-27 13:36:37 +00003551 int *pnEntry, /* Number of objects currently in use */
drhcf643722007-03-27 13:36:37 +00003552 int *pIdx /* Write the index of a new slot here */
3553){
3554 char *z;
drh6c535152012-02-02 03:38:30 +00003555 int n = *pnEntry;
3556 if( (n & (n-1))==0 ){
3557 int sz = (n==0) ? 1 : 2*n;
3558 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
drh13449892005-09-07 21:22:45 +00003559 if( pNew==0 ){
drhcf643722007-03-27 13:36:37 +00003560 *pIdx = -1;
3561 return pArray;
drh13449892005-09-07 21:22:45 +00003562 }
drhcf643722007-03-27 13:36:37 +00003563 pArray = pNew;
drh13449892005-09-07 21:22:45 +00003564 }
drhcf643722007-03-27 13:36:37 +00003565 z = (char*)pArray;
drh6c535152012-02-02 03:38:30 +00003566 memset(&z[n * szEntry], 0, szEntry);
3567 *pIdx = n;
drhcf643722007-03-27 13:36:37 +00003568 ++*pnEntry;
3569 return pArray;
drh13449892005-09-07 21:22:45 +00003570}
3571
3572/*
drh75897232000-05-29 14:26:00 +00003573** Append a new element to the given IdList. Create a new IdList if
3574** need be.
drhdaffd0e2001-04-11 14:28:42 +00003575**
3576** A new IdList is returned, or NULL if malloc() fails.
drh75897232000-05-29 14:26:00 +00003577*/
drh17435752007-08-16 04:30:38 +00003578IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){
drh13449892005-09-07 21:22:45 +00003579 int i;
drh75897232000-05-29 14:26:00 +00003580 if( pList==0 ){
drh17435752007-08-16 04:30:38 +00003581 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
drh75897232000-05-29 14:26:00 +00003582 if( pList==0 ) return 0;
3583 }
drhcf643722007-03-27 13:36:37 +00003584 pList->a = sqlite3ArrayAllocate(
drh17435752007-08-16 04:30:38 +00003585 db,
drhcf643722007-03-27 13:36:37 +00003586 pList->a,
3587 sizeof(pList->a[0]),
drhcf643722007-03-27 13:36:37 +00003588 &pList->nId,
drhcf643722007-03-27 13:36:37 +00003589 &i
3590 );
drh13449892005-09-07 21:22:45 +00003591 if( i<0 ){
drh633e6d52008-07-28 19:34:53 +00003592 sqlite3IdListDelete(db, pList);
drh13449892005-09-07 21:22:45 +00003593 return 0;
drh75897232000-05-29 14:26:00 +00003594 }
drh17435752007-08-16 04:30:38 +00003595 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
drh75897232000-05-29 14:26:00 +00003596 return pList;
3597}
3598
3599/*
drhfe05af82005-07-21 03:14:59 +00003600** Delete an IdList.
3601*/
drh633e6d52008-07-28 19:34:53 +00003602void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
drhfe05af82005-07-21 03:14:59 +00003603 int i;
3604 if( pList==0 ) return;
3605 for(i=0; i<pList->nId; i++){
drh633e6d52008-07-28 19:34:53 +00003606 sqlite3DbFree(db, pList->a[i].zName);
drhfe05af82005-07-21 03:14:59 +00003607 }
drh633e6d52008-07-28 19:34:53 +00003608 sqlite3DbFree(db, pList->a);
3609 sqlite3DbFree(db, pList);
drhfe05af82005-07-21 03:14:59 +00003610}
3611
3612/*
3613** Return the index in pList of the identifier named zId. Return -1
3614** if not found.
3615*/
3616int sqlite3IdListIndex(IdList *pList, const char *zName){
3617 int i;
3618 if( pList==0 ) return -1;
3619 for(i=0; i<pList->nId; i++){
3620 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
3621 }
3622 return -1;
3623}
3624
3625/*
drha78c22c2008-11-11 18:28:58 +00003626** Expand the space allocated for the given SrcList object by
3627** creating nExtra new slots beginning at iStart. iStart is zero based.
3628** New slots are zeroed.
3629**
3630** For example, suppose a SrcList initially contains two entries: A,B.
3631** To append 3 new entries onto the end, do this:
3632**
3633** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
3634**
3635** After the call above it would contain: A, B, nil, nil, nil.
3636** If the iStart argument had been 1 instead of 2, then the result
3637** would have been: A, nil, nil, nil, B. To prepend the new slots,
3638** the iStart value would be 0. The result then would
3639** be: nil, nil, nil, A, B.
3640**
3641** If a memory allocation fails the SrcList is unchanged. The
3642** db->mallocFailed flag will be set to true.
3643*/
3644SrcList *sqlite3SrcListEnlarge(
3645 sqlite3 *db, /* Database connection to notify of OOM errors */
3646 SrcList *pSrc, /* The SrcList to be enlarged */
3647 int nExtra, /* Number of new slots to add to pSrc->a[] */
3648 int iStart /* Index in pSrc->a[] of first new slot */
3649){
3650 int i;
3651
3652 /* Sanity checking on calling parameters */
3653 assert( iStart>=0 );
3654 assert( nExtra>=1 );
drh8af73d42009-05-13 22:58:28 +00003655 assert( pSrc!=0 );
3656 assert( iStart<=pSrc->nSrc );
drha78c22c2008-11-11 18:28:58 +00003657
3658 /* Allocate additional space if needed */
drhfc5717c2014-03-05 19:04:46 +00003659 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
drha78c22c2008-11-11 18:28:58 +00003660 SrcList *pNew;
3661 int nAlloc = pSrc->nSrc+nExtra;
drh6a1e0712008-12-05 15:24:15 +00003662 int nGot;
drha78c22c2008-11-11 18:28:58 +00003663 pNew = sqlite3DbRealloc(db, pSrc,
3664 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
3665 if( pNew==0 ){
3666 assert( db->mallocFailed );
3667 return pSrc;
3668 }
3669 pSrc = pNew;
drh6a1e0712008-12-05 15:24:15 +00003670 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
drh6d1626e2014-03-05 15:52:43 +00003671 pSrc->nAlloc = nGot;
drha78c22c2008-11-11 18:28:58 +00003672 }
3673
3674 /* Move existing slots that come after the newly inserted slots
3675 ** out of the way */
3676 for(i=pSrc->nSrc-1; i>=iStart; i--){
3677 pSrc->a[i+nExtra] = pSrc->a[i];
3678 }
drh6d1626e2014-03-05 15:52:43 +00003679 pSrc->nSrc += nExtra;
drha78c22c2008-11-11 18:28:58 +00003680
3681 /* Zero the newly allocated slots */
3682 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
3683 for(i=iStart; i<iStart+nExtra; i++){
3684 pSrc->a[i].iCursor = -1;
3685 }
3686
3687 /* Return a pointer to the enlarged SrcList */
3688 return pSrc;
3689}
3690
3691
3692/*
drhad3cab52002-05-24 02:04:32 +00003693** Append a new table name to the given SrcList. Create a new SrcList if
drhb7916a72009-05-27 10:31:29 +00003694** need be. A new entry is created in the SrcList even if pTable is NULL.
drhad3cab52002-05-24 02:04:32 +00003695**
drha78c22c2008-11-11 18:28:58 +00003696** A SrcList is returned, or NULL if there is an OOM error. The returned
3697** SrcList might be the same as the SrcList that was input or it might be
3698** a new one. If an OOM error does occurs, then the prior value of pList
3699** that is input to this routine is automatically freed.
drh113088e2003-03-20 01:16:58 +00003700**
3701** If pDatabase is not null, it means that the table has an optional
3702** database name prefix. Like this: "database.table". The pDatabase
3703** points to the table name and the pTable points to the database name.
3704** The SrcList.a[].zName field is filled with the table name which might
3705** come from pTable (if pDatabase is NULL) or from pDatabase.
3706** SrcList.a[].zDatabase is filled with the database name from pTable,
3707** or with NULL if no database is specified.
3708**
3709** In other words, if call like this:
3710**
drh17435752007-08-16 04:30:38 +00003711** sqlite3SrcListAppend(D,A,B,0);
drh113088e2003-03-20 01:16:58 +00003712**
3713** Then B is a table name and the database name is unspecified. If called
3714** like this:
3715**
drh17435752007-08-16 04:30:38 +00003716** sqlite3SrcListAppend(D,A,B,C);
drh113088e2003-03-20 01:16:58 +00003717**
drhd3001712009-05-12 17:46:53 +00003718** Then C is the table name and B is the database name. If C is defined
3719** then so is B. In other words, we never have a case where:
3720**
3721** sqlite3SrcListAppend(D,A,0,C);
drhb7916a72009-05-27 10:31:29 +00003722**
3723** Both pTable and pDatabase are assumed to be quoted. They are dequoted
3724** before being added to the SrcList.
drhad3cab52002-05-24 02:04:32 +00003725*/
drh17435752007-08-16 04:30:38 +00003726SrcList *sqlite3SrcListAppend(
3727 sqlite3 *db, /* Connection to notify of malloc failures */
3728 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
3729 Token *pTable, /* Table to append */
3730 Token *pDatabase /* Database of the table */
3731){
drha99db3b2004-06-19 14:49:12 +00003732 struct SrcList_item *pItem;
drhd3001712009-05-12 17:46:53 +00003733 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
drh575fad62016-02-05 13:38:36 +00003734 assert( db!=0 );
drhad3cab52002-05-24 02:04:32 +00003735 if( pList==0 ){
drh575fad62016-02-05 13:38:36 +00003736 pList = sqlite3DbMallocRawNN(db, sizeof(SrcList) );
drhad3cab52002-05-24 02:04:32 +00003737 if( pList==0 ) return 0;
drh4305d102003-07-30 12:34:12 +00003738 pList->nAlloc = 1;
drhc263f7c2016-01-18 13:18:54 +00003739 pList->nSrc = 0;
drhad3cab52002-05-24 02:04:32 +00003740 }
drha78c22c2008-11-11 18:28:58 +00003741 pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
3742 if( db->mallocFailed ){
3743 sqlite3SrcListDelete(db, pList);
3744 return 0;
drhad3cab52002-05-24 02:04:32 +00003745 }
drha78c22c2008-11-11 18:28:58 +00003746 pItem = &pList->a[pList->nSrc-1];
drh113088e2003-03-20 01:16:58 +00003747 if( pDatabase && pDatabase->z==0 ){
3748 pDatabase = 0;
3749 }
drhd3001712009-05-12 17:46:53 +00003750 if( pDatabase ){
drh113088e2003-03-20 01:16:58 +00003751 Token *pTemp = pDatabase;
3752 pDatabase = pTable;
3753 pTable = pTemp;
3754 }
drh17435752007-08-16 04:30:38 +00003755 pItem->zName = sqlite3NameFromToken(db, pTable);
3756 pItem->zDatabase = sqlite3NameFromToken(db, pDatabase);
drhad3cab52002-05-24 02:04:32 +00003757 return pList;
3758}
3759
3760/*
drhdfe88ec2008-11-03 20:55:06 +00003761** Assign VdbeCursor index numbers to all tables in a SrcList
drh63eb5f22003-04-29 16:20:44 +00003762*/
danielk19774adee202004-05-08 08:23:19 +00003763void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
drh63eb5f22003-04-29 16:20:44 +00003764 int i;
drh9b3187e2005-01-18 14:45:47 +00003765 struct SrcList_item *pItem;
drh17435752007-08-16 04:30:38 +00003766 assert(pList || pParse->db->mallocFailed );
danielk1977261919c2005-12-06 12:52:59 +00003767 if( pList ){
3768 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
3769 if( pItem->iCursor>=0 ) break;
3770 pItem->iCursor = pParse->nTab++;
3771 if( pItem->pSelect ){
3772 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
3773 }
drh63eb5f22003-04-29 16:20:44 +00003774 }
3775 }
3776}
3777
3778/*
drhad3cab52002-05-24 02:04:32 +00003779** Delete an entire SrcList including all its substructure.
3780*/
drh633e6d52008-07-28 19:34:53 +00003781void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
drhad3cab52002-05-24 02:04:32 +00003782 int i;
drhbe5c89a2004-07-26 00:31:09 +00003783 struct SrcList_item *pItem;
drhad3cab52002-05-24 02:04:32 +00003784 if( pList==0 ) return;
drhbe5c89a2004-07-26 00:31:09 +00003785 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
drh633e6d52008-07-28 19:34:53 +00003786 sqlite3DbFree(db, pItem->zDatabase);
3787 sqlite3DbFree(db, pItem->zName);
3788 sqlite3DbFree(db, pItem->zAlias);
drh8a48b9c2015-08-19 15:20:00 +00003789 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
3790 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
dan1feeaed2010-07-23 15:41:47 +00003791 sqlite3DeleteTable(db, pItem->pTab);
drh633e6d52008-07-28 19:34:53 +00003792 sqlite3SelectDelete(db, pItem->pSelect);
3793 sqlite3ExprDelete(db, pItem->pOn);
3794 sqlite3IdListDelete(db, pItem->pUsing);
drh75897232000-05-29 14:26:00 +00003795 }
drh633e6d52008-07-28 19:34:53 +00003796 sqlite3DbFree(db, pList);
drh75897232000-05-29 14:26:00 +00003797}
3798
drh982cef72000-05-30 16:27:03 +00003799/*
drh61dfc312006-12-16 16:25:15 +00003800** This routine is called by the parser to add a new term to the
3801** end of a growing FROM clause. The "p" parameter is the part of
3802** the FROM clause that has already been constructed. "p" is NULL
3803** if this is the first term of the FROM clause. pTable and pDatabase
3804** are the name of the table and database named in the FROM clause term.
3805** pDatabase is NULL if the database name qualifier is missing - the
peter.d.reid60ec9142014-09-06 16:39:46 +00003806** usual case. If the term has an alias, then pAlias points to the
drh61dfc312006-12-16 16:25:15 +00003807** alias token. If the term is a subquery, then pSubquery is the
3808** SELECT statement that the subquery encodes. The pTable and
3809** pDatabase parameters are NULL for subqueries. The pOn and pUsing
3810** parameters are the content of the ON and USING clauses.
3811**
3812** Return a new SrcList which encodes is the FROM with the new
3813** term added.
3814*/
3815SrcList *sqlite3SrcListAppendFromTerm(
drh17435752007-08-16 04:30:38 +00003816 Parse *pParse, /* Parsing context */
drh61dfc312006-12-16 16:25:15 +00003817 SrcList *p, /* The left part of the FROM clause already seen */
3818 Token *pTable, /* Name of the table to add to the FROM clause */
3819 Token *pDatabase, /* Name of the database containing pTable */
3820 Token *pAlias, /* The right-hand side of the AS subexpression */
3821 Select *pSubquery, /* A subquery used in place of a table name */
3822 Expr *pOn, /* The ON clause of a join */
3823 IdList *pUsing /* The USING clause of a join */
3824){
3825 struct SrcList_item *pItem;
drh17435752007-08-16 04:30:38 +00003826 sqlite3 *db = pParse->db;
danielk1977bd1a0a42009-07-01 16:12:07 +00003827 if( !p && (pOn || pUsing) ){
3828 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
3829 (pOn ? "ON" : "USING")
3830 );
3831 goto append_from_error;
3832 }
drh17435752007-08-16 04:30:38 +00003833 p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
drh8af73d42009-05-13 22:58:28 +00003834 if( p==0 || NEVER(p->nSrc==0) ){
danielk1977bd1a0a42009-07-01 16:12:07 +00003835 goto append_from_error;
drh61dfc312006-12-16 16:25:15 +00003836 }
3837 pItem = &p->a[p->nSrc-1];
drh8af73d42009-05-13 22:58:28 +00003838 assert( pAlias!=0 );
3839 if( pAlias->n ){
drh17435752007-08-16 04:30:38 +00003840 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
drh61dfc312006-12-16 16:25:15 +00003841 }
3842 pItem->pSelect = pSubquery;
danielk1977bd1a0a42009-07-01 16:12:07 +00003843 pItem->pOn = pOn;
3844 pItem->pUsing = pUsing;
drh61dfc312006-12-16 16:25:15 +00003845 return p;
danielk1977bd1a0a42009-07-01 16:12:07 +00003846
3847 append_from_error:
3848 assert( p==0 );
3849 sqlite3ExprDelete(db, pOn);
3850 sqlite3IdListDelete(db, pUsing);
3851 sqlite3SelectDelete(db, pSubquery);
3852 return 0;
drh61dfc312006-12-16 16:25:15 +00003853}
3854
3855/*
danielk1977b1c685b2008-10-06 16:18:39 +00003856** Add an INDEXED BY or NOT INDEXED clause to the most recently added
3857** element of the source-list passed as the second argument.
3858*/
3859void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
drh8af73d42009-05-13 22:58:28 +00003860 assert( pIndexedBy!=0 );
3861 if( p && ALWAYS(p->nSrc>0) ){
danielk1977b1c685b2008-10-06 16:18:39 +00003862 struct SrcList_item *pItem = &p->a[p->nSrc-1];
drh8a48b9c2015-08-19 15:20:00 +00003863 assert( pItem->fg.notIndexed==0 );
3864 assert( pItem->fg.isIndexedBy==0 );
3865 assert( pItem->fg.isTabFunc==0 );
danielk1977b1c685b2008-10-06 16:18:39 +00003866 if( pIndexedBy->n==1 && !pIndexedBy->z ){
3867 /* A "NOT INDEXED" clause was supplied. See parse.y
3868 ** construct "indexed_opt" for details. */
drh8a48b9c2015-08-19 15:20:00 +00003869 pItem->fg.notIndexed = 1;
danielk1977b1c685b2008-10-06 16:18:39 +00003870 }else{
drh8a48b9c2015-08-19 15:20:00 +00003871 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
3872 pItem->fg.isIndexedBy = (pItem->u1.zIndexedBy!=0);
danielk1977b1c685b2008-10-06 16:18:39 +00003873 }
3874 }
3875}
3876
3877/*
drh01d230c2015-08-19 17:11:37 +00003878** Add the list of function arguments to the SrcList entry for a
3879** table-valued-function.
3880*/
3881void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
drh20292312015-11-21 13:24:46 +00003882 if( p ){
drh01d230c2015-08-19 17:11:37 +00003883 struct SrcList_item *pItem = &p->a[p->nSrc-1];
3884 assert( pItem->fg.notIndexed==0 );
3885 assert( pItem->fg.isIndexedBy==0 );
3886 assert( pItem->fg.isTabFunc==0 );
3887 pItem->u1.pFuncArg = pList;
3888 pItem->fg.isTabFunc = 1;
drhd8b1bfc2015-08-20 23:21:34 +00003889 }else{
3890 sqlite3ExprListDelete(pParse->db, pList);
drh01d230c2015-08-19 17:11:37 +00003891 }
3892}
3893
3894/*
drh61dfc312006-12-16 16:25:15 +00003895** When building up a FROM clause in the parser, the join operator
3896** is initially attached to the left operand. But the code generator
3897** expects the join operator to be on the right operand. This routine
3898** Shifts all join operators from left to right for an entire FROM
3899** clause.
3900**
3901** Example: Suppose the join is like this:
3902**
3903** A natural cross join B
3904**
3905** The operator is "natural cross join". The A and B operands are stored
3906** in p->a[0] and p->a[1], respectively. The parser initially stores the
3907** operator with A. This routine shifts that operator over to B.
3908*/
3909void sqlite3SrcListShiftJoinType(SrcList *p){
drhd017ab92011-08-23 00:01:58 +00003910 if( p ){
drh61dfc312006-12-16 16:25:15 +00003911 int i;
3912 for(i=p->nSrc-1; i>0; i--){
drh8a48b9c2015-08-19 15:20:00 +00003913 p->a[i].fg.jointype = p->a[i-1].fg.jointype;
drh61dfc312006-12-16 16:25:15 +00003914 }
drh8a48b9c2015-08-19 15:20:00 +00003915 p->a[0].fg.jointype = 0;
drh61dfc312006-12-16 16:25:15 +00003916 }
3917}
3918
3919/*
drhb0c88652016-02-01 13:21:13 +00003920** Generate VDBE code for a BEGIN statement.
drhc4a3c772001-04-04 11:48:57 +00003921*/
drh684917c2004-10-05 02:41:42 +00003922void sqlite3BeginTransaction(Parse *pParse, int type){
drh9bb575f2004-09-06 17:24:11 +00003923 sqlite3 *db;
danielk19771d850a72004-05-31 08:26:49 +00003924 Vdbe *v;
drh684917c2004-10-05 02:41:42 +00003925 int i;
drh5e00f6c2001-09-13 13:46:56 +00003926
drhd3001712009-05-12 17:46:53 +00003927 assert( pParse!=0 );
3928 db = pParse->db;
3929 assert( db!=0 );
drhd3001712009-05-12 17:46:53 +00003930 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
3931 return;
3932 }
danielk19771d850a72004-05-31 08:26:49 +00003933 v = sqlite3GetVdbe(pParse);
3934 if( !v ) return;
drh684917c2004-10-05 02:41:42 +00003935 if( type!=TK_DEFERRED ){
3936 for(i=0; i<db->nDb; i++){
drh66a51672008-01-03 00:01:23 +00003937 sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
drhfb982642007-08-30 01:19:59 +00003938 sqlite3VdbeUsesBtree(v, i);
drh684917c2004-10-05 02:41:42 +00003939 }
3940 }
drhb0c88652016-02-01 13:21:13 +00003941 sqlite3VdbeAddOp0(v, OP_AutoCommit);
drhc4a3c772001-04-04 11:48:57 +00003942}
3943
3944/*
drhb0c88652016-02-01 13:21:13 +00003945** Generate VDBE code for a COMMIT statement.
drhc4a3c772001-04-04 11:48:57 +00003946*/
danielk19774adee202004-05-08 08:23:19 +00003947void sqlite3CommitTransaction(Parse *pParse){
danielk19771d850a72004-05-31 08:26:49 +00003948 Vdbe *v;
drh5e00f6c2001-09-13 13:46:56 +00003949
drhd3001712009-05-12 17:46:53 +00003950 assert( pParse!=0 );
drhb07028f2011-10-14 21:49:18 +00003951 assert( pParse->db!=0 );
drhd3001712009-05-12 17:46:53 +00003952 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){
3953 return;
3954 }
danielk19771d850a72004-05-31 08:26:49 +00003955 v = sqlite3GetVdbe(pParse);
3956 if( v ){
drhb0c88652016-02-01 13:21:13 +00003957 sqlite3VdbeAddOp1(v, OP_AutoCommit, 1);
drh02f75f12004-02-24 01:04:11 +00003958 }
drhc4a3c772001-04-04 11:48:57 +00003959}
3960
3961/*
drhb0c88652016-02-01 13:21:13 +00003962** Generate VDBE code for a ROLLBACK statement.
drhc4a3c772001-04-04 11:48:57 +00003963*/
danielk19774adee202004-05-08 08:23:19 +00003964void sqlite3RollbackTransaction(Parse *pParse){
drh5e00f6c2001-09-13 13:46:56 +00003965 Vdbe *v;
3966
drhd3001712009-05-12 17:46:53 +00003967 assert( pParse!=0 );
drhb07028f2011-10-14 21:49:18 +00003968 assert( pParse->db!=0 );
drhd3001712009-05-12 17:46:53 +00003969 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){
3970 return;
3971 }
danielk19774adee202004-05-08 08:23:19 +00003972 v = sqlite3GetVdbe(pParse);
drh5e00f6c2001-09-13 13:46:56 +00003973 if( v ){
drh66a51672008-01-03 00:01:23 +00003974 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
drh02f75f12004-02-24 01:04:11 +00003975 }
drhc4a3c772001-04-04 11:48:57 +00003976}
drhf57b14a2001-09-14 18:54:08 +00003977
3978/*
danielk1977fd7f0452008-12-17 17:30:26 +00003979** This function is called by the parser when it parses a command to create,
3980** release or rollback an SQL savepoint.
3981*/
3982void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
danielk1977ab9b7032008-12-30 06:24:58 +00003983 char *zName = sqlite3NameFromToken(pParse->db, pName);
3984 if( zName ){
3985 Vdbe *v = sqlite3GetVdbe(pParse);
3986#ifndef SQLITE_OMIT_AUTHORIZATION
dan558814f2010-06-02 05:53:53 +00003987 static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
danielk1977ab9b7032008-12-30 06:24:58 +00003988 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
3989#endif
3990 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
3991 sqlite3DbFree(pParse->db, zName);
3992 return;
3993 }
3994 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
danielk1977fd7f0452008-12-17 17:30:26 +00003995 }
3996}
3997
3998/*
drhdc3ff9c2004-08-18 02:10:15 +00003999** Make sure the TEMP database is open and available for use. Return
4000** the number of errors. Leave any error messages in the pParse structure.
4001*/
danielk1977ddfb2f02006-02-17 12:25:14 +00004002int sqlite3OpenTempDatabase(Parse *pParse){
drhdc3ff9c2004-08-18 02:10:15 +00004003 sqlite3 *db = pParse->db;
4004 if( db->aDb[1].pBt==0 && !pParse->explain ){
drh33f4e022007-09-03 15:19:34 +00004005 int rc;
drh10a76c92010-01-26 01:25:26 +00004006 Btree *pBt;
drh33f4e022007-09-03 15:19:34 +00004007 static const int flags =
4008 SQLITE_OPEN_READWRITE |
4009 SQLITE_OPEN_CREATE |
4010 SQLITE_OPEN_EXCLUSIVE |
4011 SQLITE_OPEN_DELETEONCLOSE |
4012 SQLITE_OPEN_TEMP_DB;
4013
dan3a6d8ae2011-04-23 15:54:54 +00004014 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
drhdc3ff9c2004-08-18 02:10:15 +00004015 if( rc!=SQLITE_OK ){
4016 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
4017 "file for storing temporary tables");
4018 pParse->rc = rc;
4019 return 1;
4020 }
drh10a76c92010-01-26 01:25:26 +00004021 db->aDb[1].pBt = pBt;
danielk197714db2662006-01-09 16:12:04 +00004022 assert( db->aDb[1].pSchema );
drh10a76c92010-01-26 01:25:26 +00004023 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
drh4a642b62016-02-05 01:55:27 +00004024 sqlite3OomFault(db);
drh7c9c9862010-01-31 14:18:21 +00004025 return 1;
drh10a76c92010-01-26 01:25:26 +00004026 }
drhdc3ff9c2004-08-18 02:10:15 +00004027 }
4028 return 0;
4029}
4030
4031/*
drhaceb31b2014-02-08 01:40:27 +00004032** Record the fact that the schema cookie will need to be verified
4033** for database iDb. The code to actually verify the schema cookie
4034** will occur at the end of the top-level VDBE and will be generated
4035** later, by sqlite3FinishCoding().
drh001bbcb2003-03-19 03:14:00 +00004036*/
danielk19774adee202004-05-08 08:23:19 +00004037void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
dan65a7cd12009-09-01 12:16:01 +00004038 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh80242052004-06-09 00:48:12 +00004039
drh1d96cc62016-09-30 18:35:36 +00004040 assert( iDb>=0 && iDb<pParse->db->nDb );
4041 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
drhaceb31b2014-02-08 01:40:27 +00004042 assert( iDb<SQLITE_MAX_ATTACHED+2 );
drh1d96cc62016-09-30 18:35:36 +00004043 assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
drha7ab6d82014-07-21 15:44:39 +00004044 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
4045 DbMaskSet(pToplevel->cookieMask, iDb);
drhaceb31b2014-02-08 01:40:27 +00004046 if( !OMIT_TEMPDB && iDb==1 ){
4047 sqlite3OpenTempDatabase(pToplevel);
4048 }
drh001bbcb2003-03-19 03:14:00 +00004049 }
drh001bbcb2003-03-19 03:14:00 +00004050}
4051
4052/*
dan57966752011-04-09 17:32:58 +00004053** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
4054** attached database. Otherwise, invoke it for the database named zDb only.
4055*/
4056void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
4057 sqlite3 *db = pParse->db;
4058 int i;
4059 for(i=0; i<db->nDb; i++){
4060 Db *pDb = &db->aDb[i];
drh69c33822016-08-18 14:33:11 +00004061 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
dan57966752011-04-09 17:32:58 +00004062 sqlite3CodeVerifySchema(pParse, i);
4063 }
4064 }
4065}
4066
4067/*
drh1c928532002-01-31 15:54:21 +00004068** Generate VDBE code that prepares for doing an operation that
drhc977f7f2002-05-21 11:38:11 +00004069** might change the database.
4070**
4071** This routine starts a new transaction if we are not already within
4072** a transaction. If we are already within a transaction, then a checkpoint
drh7f0f12e2004-05-21 13:39:50 +00004073** is set if the setStatement parameter is true. A checkpoint should
drhc977f7f2002-05-21 11:38:11 +00004074** be set for operations that might fail (due to a constraint) part of
4075** the way through and which will need to undo some writes without having to
4076** rollback the whole transaction. For operations where all constraints
4077** can be checked before any changes are made to the database, it is never
4078** necessary to undo a write and the checkpoint should not be set.
drh1c928532002-01-31 15:54:21 +00004079*/
drh7f0f12e2004-05-21 13:39:50 +00004080void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
dan65a7cd12009-09-01 12:16:01 +00004081 Parse *pToplevel = sqlite3ParseToplevel(pParse);
drh80242052004-06-09 00:48:12 +00004082 sqlite3CodeVerifySchema(pParse, iDb);
drha7ab6d82014-07-21 15:44:39 +00004083 DbMaskSet(pToplevel->writeMask, iDb);
dane0af83a2009-09-08 19:15:01 +00004084 pToplevel->isMultiWrite |= setStatement;
4085}
4086
drhff738bc2009-09-24 00:09:58 +00004087/*
4088** Indicate that the statement currently under construction might write
4089** more than one entry (example: deleting one row then inserting another,
4090** inserting multiple rows in a table, or inserting a row and index entries.)
4091** If an abort occurs after some of these writes have completed, then it will
4092** be necessary to undo the completed writes.
4093*/
4094void sqlite3MultiWrite(Parse *pParse){
4095 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4096 pToplevel->isMultiWrite = 1;
4097}
4098
dane0af83a2009-09-08 19:15:01 +00004099/*
drhff738bc2009-09-24 00:09:58 +00004100** The code generator calls this routine if is discovers that it is
4101** possible to abort a statement prior to completion. In order to
4102** perform this abort without corrupting the database, we need to make
4103** sure that the statement is protected by a statement transaction.
4104**
4105** Technically, we only need to set the mayAbort flag if the
4106** isMultiWrite flag was previously set. There is a time dependency
4107** such that the abort must occur after the multiwrite. This makes
4108** some statements involving the REPLACE conflict resolution algorithm
4109** go a little faster. But taking advantage of this time dependency
4110** makes it more difficult to prove that the code is correct (in
4111** particular, it prevents us from writing an effective
4112** implementation of sqlite3AssertMayAbort()) and so we have chosen
4113** to take the safe route and skip the optimization.
dane0af83a2009-09-08 19:15:01 +00004114*/
4115void sqlite3MayAbort(Parse *pParse){
4116 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4117 pToplevel->mayAbort = 1;
4118}
4119
4120/*
4121** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
4122** error. The onError parameter determines which (if any) of the statement
4123** and/or current transaction is rolled back.
4124*/
drhd91c1a12013-02-09 13:58:25 +00004125void sqlite3HaltConstraint(
4126 Parse *pParse, /* Parsing context */
4127 int errCode, /* extended error code */
4128 int onError, /* Constraint type */
4129 char *p4, /* Error message */
drhf9c8ce32013-11-05 13:33:55 +00004130 i8 p4type, /* P4_STATIC or P4_TRANSIENT */
4131 u8 p5Errmsg /* P5_ErrMsg type */
drhd91c1a12013-02-09 13:58:25 +00004132){
dane0af83a2009-09-08 19:15:01 +00004133 Vdbe *v = sqlite3GetVdbe(pParse);
drhd91c1a12013-02-09 13:58:25 +00004134 assert( (errCode&0xff)==SQLITE_CONSTRAINT );
dane0af83a2009-09-08 19:15:01 +00004135 if( onError==OE_Abort ){
4136 sqlite3MayAbort(pParse);
danielk19771d850a72004-05-31 08:26:49 +00004137 }
drhd91c1a12013-02-09 13:58:25 +00004138 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
drh9b34abe2016-01-16 15:12:35 +00004139 sqlite3VdbeChangeP5(v, p5Errmsg);
drhf9c8ce32013-11-05 13:33:55 +00004140}
4141
4142/*
4143** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
4144*/
4145void sqlite3UniqueConstraint(
4146 Parse *pParse, /* Parsing context */
4147 int onError, /* Constraint type */
4148 Index *pIdx /* The index that triggers the constraint */
4149){
4150 char *zErr;
4151 int j;
4152 StrAccum errMsg;
4153 Table *pTab = pIdx->pTable;
4154
drhc0490572015-05-02 11:45:53 +00004155 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200);
drh8b576422015-08-31 23:09:42 +00004156 if( pIdx->aColExpr ){
drh5f4a6862016-01-30 12:50:25 +00004157 sqlite3XPrintf(&errMsg, "index '%q'", pIdx->zName);
drh8b576422015-08-31 23:09:42 +00004158 }else{
4159 for(j=0; j<pIdx->nKeyCol; j++){
4160 char *zCol;
4161 assert( pIdx->aiColumn[j]>=0 );
4162 zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
4163 if( j ) sqlite3StrAccumAppend(&errMsg, ", ", 2);
drh5f4a6862016-01-30 12:50:25 +00004164 sqlite3XPrintf(&errMsg, "%s.%s", pTab->zName, zCol);
drh8b576422015-08-31 23:09:42 +00004165 }
drhf9c8ce32013-11-05 13:33:55 +00004166 }
4167 zErr = sqlite3StrAccumFinish(&errMsg);
4168 sqlite3HaltConstraint(pParse,
drh48dd1d82014-05-27 18:18:58 +00004169 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
4170 : SQLITE_CONSTRAINT_UNIQUE,
dan93889d92013-11-06 16:28:59 +00004171 onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
drhf9c8ce32013-11-05 13:33:55 +00004172}
4173
4174
4175/*
4176** Code an OP_Halt due to non-unique rowid.
4177*/
4178void sqlite3RowidConstraint(
4179 Parse *pParse, /* Parsing context */
4180 int onError, /* Conflict resolution algorithm */
4181 Table *pTab /* The table with the non-unique rowid */
4182){
4183 char *zMsg;
4184 int rc;
4185 if( pTab->iPKey>=0 ){
4186 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
4187 pTab->aCol[pTab->iPKey].zName);
4188 rc = SQLITE_CONSTRAINT_PRIMARYKEY;
4189 }else{
4190 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
4191 rc = SQLITE_CONSTRAINT_ROWID;
4192 }
4193 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
4194 P5_ConstraintUnique);
drh663fc632002-02-02 18:49:19 +00004195}
4196
drh4343fea2004-11-05 23:46:15 +00004197/*
4198** Check to see if pIndex uses the collating sequence pColl. Return
4199** true if it does and false if it does not.
4200*/
4201#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00004202static int collationMatch(const char *zColl, Index *pIndex){
4203 int i;
drh04491712009-05-13 17:21:13 +00004204 assert( zColl!=0 );
danielk1977b3bf5562006-01-10 17:58:23 +00004205 for(i=0; i<pIndex->nColumn; i++){
4206 const char *z = pIndex->azColl[i];
drhbbbdc832013-10-22 18:01:40 +00004207 assert( z!=0 || pIndex->aiColumn[i]<0 );
4208 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
danielk1977b3bf5562006-01-10 17:58:23 +00004209 return 1;
4210 }
drh4343fea2004-11-05 23:46:15 +00004211 }
4212 return 0;
4213}
4214#endif
4215
4216/*
4217** Recompute all indices of pTab that use the collating sequence pColl.
4218** If pColl==0 then recompute all indices of pTab.
4219*/
4220#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00004221static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
drh4343fea2004-11-05 23:46:15 +00004222 Index *pIndex; /* An index associated with pTab */
4223
4224 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
danielk1977b3bf5562006-01-10 17:58:23 +00004225 if( zColl==0 || collationMatch(zColl, pIndex) ){
danielk1977da184232006-01-05 11:34:32 +00004226 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
4227 sqlite3BeginWriteOperation(pParse, 0, iDb);
drh4343fea2004-11-05 23:46:15 +00004228 sqlite3RefillIndex(pParse, pIndex, -1);
4229 }
4230 }
4231}
4232#endif
4233
4234/*
4235** Recompute all indices of all tables in all databases where the
4236** indices use the collating sequence pColl. If pColl==0 then recompute
4237** all indices everywhere.
4238*/
4239#ifndef SQLITE_OMIT_REINDEX
danielk1977b3bf5562006-01-10 17:58:23 +00004240static void reindexDatabases(Parse *pParse, char const *zColl){
drh4343fea2004-11-05 23:46:15 +00004241 Db *pDb; /* A single database */
4242 int iDb; /* The database index number */
4243 sqlite3 *db = pParse->db; /* The database connection */
4244 HashElem *k; /* For looping over tables in pDb */
4245 Table *pTab; /* A table in the database */
4246
drh21206082011-04-04 18:22:02 +00004247 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
drh4343fea2004-11-05 23:46:15 +00004248 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
drh43617e92006-03-06 20:55:46 +00004249 assert( pDb!=0 );
danielk1977da184232006-01-05 11:34:32 +00004250 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
drh4343fea2004-11-05 23:46:15 +00004251 pTab = (Table*)sqliteHashData(k);
danielk1977b3bf5562006-01-10 17:58:23 +00004252 reindexTable(pParse, pTab, zColl);
drh4343fea2004-11-05 23:46:15 +00004253 }
4254 }
4255}
4256#endif
4257
4258/*
drheee46cf2004-11-06 00:02:48 +00004259** Generate code for the REINDEX command.
4260**
4261** REINDEX -- 1
4262** REINDEX <collation> -- 2
4263** REINDEX ?<database>.?<tablename> -- 3
4264** REINDEX ?<database>.?<indexname> -- 4
4265**
4266** Form 1 causes all indices in all attached databases to be rebuilt.
4267** Form 2 rebuilds all indices in all databases that use the named
4268** collating function. Forms 3 and 4 rebuild the named index or all
4269** indices associated with the named table.
drh4343fea2004-11-05 23:46:15 +00004270*/
4271#ifndef SQLITE_OMIT_REINDEX
4272void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
4273 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
4274 char *z; /* Name of a table or index */
4275 const char *zDb; /* Name of the database */
4276 Table *pTab; /* A table in the database */
4277 Index *pIndex; /* An index associated with pTab */
4278 int iDb; /* The database index number */
4279 sqlite3 *db = pParse->db; /* The database connection */
4280 Token *pObjName; /* Name of the table or index to be reindexed */
4281
danielk197733a5edc2005-01-27 00:22:02 +00004282 /* Read the database schema. If an error occurs, leave an error message
4283 ** and code in pParse and return NULL. */
4284 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
danielk1977e63739a2005-01-27 00:33:37 +00004285 return;
danielk197733a5edc2005-01-27 00:22:02 +00004286 }
4287
drh8af73d42009-05-13 22:58:28 +00004288 if( pName1==0 ){
drh4343fea2004-11-05 23:46:15 +00004289 reindexDatabases(pParse, 0);
4290 return;
drhd3001712009-05-12 17:46:53 +00004291 }else if( NEVER(pName2==0) || pName2->z==0 ){
danielk197739002502007-11-12 09:50:26 +00004292 char *zColl;
danielk1977b3bf5562006-01-10 17:58:23 +00004293 assert( pName1->z );
danielk197739002502007-11-12 09:50:26 +00004294 zColl = sqlite3NameFromToken(pParse->db, pName1);
4295 if( !zColl ) return;
drhc4a64fa2009-05-11 20:53:28 +00004296 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
drh4343fea2004-11-05 23:46:15 +00004297 if( pColl ){
drhd3001712009-05-12 17:46:53 +00004298 reindexDatabases(pParse, zColl);
4299 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00004300 return;
4301 }
drh633e6d52008-07-28 19:34:53 +00004302 sqlite3DbFree(db, zColl);
drh4343fea2004-11-05 23:46:15 +00004303 }
4304 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
4305 if( iDb<0 ) return;
drh17435752007-08-16 04:30:38 +00004306 z = sqlite3NameFromToken(db, pObjName);
drh84f31122007-05-12 15:00:14 +00004307 if( z==0 ) return;
drh69c33822016-08-18 14:33:11 +00004308 zDb = db->aDb[iDb].zDbSName;
drh4343fea2004-11-05 23:46:15 +00004309 pTab = sqlite3FindTable(db, z, zDb);
4310 if( pTab ){
4311 reindexTable(pParse, pTab, 0);
drh633e6d52008-07-28 19:34:53 +00004312 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00004313 return;
4314 }
4315 pIndex = sqlite3FindIndex(db, z, zDb);
drh633e6d52008-07-28 19:34:53 +00004316 sqlite3DbFree(db, z);
drh4343fea2004-11-05 23:46:15 +00004317 if( pIndex ){
4318 sqlite3BeginWriteOperation(pParse, 0, iDb);
4319 sqlite3RefillIndex(pParse, pIndex, -1);
4320 return;
4321 }
4322 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
4323}
4324#endif
danielk1977b3bf5562006-01-10 17:58:23 +00004325
4326/*
drh2ec2fb22013-11-06 19:59:23 +00004327** Return a KeyInfo structure that is appropriate for the given Index.
danielk1977b3bf5562006-01-10 17:58:23 +00004328**
drh2ec2fb22013-11-06 19:59:23 +00004329** The caller should invoke sqlite3KeyInfoUnref() on the returned object
4330** when it has finished using it.
danielk1977b3bf5562006-01-10 17:58:23 +00004331*/
drh2ec2fb22013-11-06 19:59:23 +00004332KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
drh18b67f32014-12-12 00:20:37 +00004333 int i;
4334 int nCol = pIdx->nColumn;
4335 int nKey = pIdx->nKeyCol;
4336 KeyInfo *pKey;
drh2ec2fb22013-11-06 19:59:23 +00004337 if( pParse->nErr ) return 0;
drh18b67f32014-12-12 00:20:37 +00004338 if( pIdx->uniqNotNull ){
4339 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
4340 }else{
4341 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
drh41e13e12013-11-07 14:09:39 +00004342 }
drh18b67f32014-12-12 00:20:37 +00004343 if( pKey ){
4344 assert( sqlite3KeyInfoIsWriteable(pKey) );
4345 for(i=0; i<nCol; i++){
drhf19aa5f2015-12-30 16:51:20 +00004346 const char *zColl = pIdx->azColl[i];
4347 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
drh18b67f32014-12-12 00:20:37 +00004348 sqlite3LocateCollSeq(pParse, zColl);
4349 pKey->aSortOrder[i] = pIdx->aSortOrder[i];
drh2ec2fb22013-11-06 19:59:23 +00004350 }
drh18b67f32014-12-12 00:20:37 +00004351 if( pParse->nErr ){
4352 sqlite3KeyInfoUnref(pKey);
4353 pKey = 0;
danielk1977b3bf5562006-01-10 17:58:23 +00004354 }
danielk1977b3bf5562006-01-10 17:58:23 +00004355 }
drh18b67f32014-12-12 00:20:37 +00004356 return pKey;
danielk1977b3bf5562006-01-10 17:58:23 +00004357}
drh8b471862014-01-11 13:22:17 +00004358
4359#ifndef SQLITE_OMIT_CTE
dan7d562db2014-01-11 19:19:36 +00004360/*
4361** This routine is invoked once per CTE by the parser while parsing a
4362** WITH clause.
drh8b471862014-01-11 13:22:17 +00004363*/
dan7d562db2014-01-11 19:19:36 +00004364With *sqlite3WithAdd(
drh8b471862014-01-11 13:22:17 +00004365 Parse *pParse, /* Parsing context */
dan7d562db2014-01-11 19:19:36 +00004366 With *pWith, /* Existing WITH clause, or NULL */
drh8b471862014-01-11 13:22:17 +00004367 Token *pName, /* Name of the common-table */
dan4e9119d2014-01-13 15:12:23 +00004368 ExprList *pArglist, /* Optional column name list for the table */
drh8b471862014-01-11 13:22:17 +00004369 Select *pQuery /* Query used to initialize the table */
4370){
dan4e9119d2014-01-13 15:12:23 +00004371 sqlite3 *db = pParse->db;
4372 With *pNew;
4373 char *zName;
4374
4375 /* Check that the CTE name is unique within this WITH clause. If
4376 ** not, store an error in the Parse structure. */
4377 zName = sqlite3NameFromToken(pParse->db, pName);
4378 if( zName && pWith ){
4379 int i;
4380 for(i=0; i<pWith->nCte; i++){
4381 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
drh727a99f2014-01-16 21:59:51 +00004382 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
dan4e9119d2014-01-13 15:12:23 +00004383 }
4384 }
4385 }
4386
4387 if( pWith ){
4388 int nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
4389 pNew = sqlite3DbRealloc(db, pWith, nByte);
4390 }else{
4391 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
4392 }
drhb84e5742016-02-05 02:42:54 +00004393 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
dan4e9119d2014-01-13 15:12:23 +00004394
drhb84e5742016-02-05 02:42:54 +00004395 if( db->mallocFailed ){
dan4e9119d2014-01-13 15:12:23 +00004396 sqlite3ExprListDelete(db, pArglist);
4397 sqlite3SelectDelete(db, pQuery);
4398 sqlite3DbFree(db, zName);
dana9f5c132014-01-13 16:36:40 +00004399 pNew = pWith;
dan4e9119d2014-01-13 15:12:23 +00004400 }else{
4401 pNew->a[pNew->nCte].pSelect = pQuery;
4402 pNew->a[pNew->nCte].pCols = pArglist;
4403 pNew->a[pNew->nCte].zName = zName;
drh0576bc52015-08-26 11:40:11 +00004404 pNew->a[pNew->nCte].zCteErr = 0;
dan4e9119d2014-01-13 15:12:23 +00004405 pNew->nCte++;
4406 }
4407
4408 return pNew;
drh8b471862014-01-11 13:22:17 +00004409}
4410
dan7d562db2014-01-11 19:19:36 +00004411/*
4412** Free the contents of the With object passed as the second argument.
drh8b471862014-01-11 13:22:17 +00004413*/
dan7d562db2014-01-11 19:19:36 +00004414void sqlite3WithDelete(sqlite3 *db, With *pWith){
dan4e9119d2014-01-13 15:12:23 +00004415 if( pWith ){
4416 int i;
4417 for(i=0; i<pWith->nCte; i++){
4418 struct Cte *pCte = &pWith->a[i];
4419 sqlite3ExprListDelete(db, pCte->pCols);
4420 sqlite3SelectDelete(db, pCte->pSelect);
4421 sqlite3DbFree(db, pCte->zName);
4422 }
4423 sqlite3DbFree(db, pWith);
4424 }
drh8b471862014-01-11 13:22:17 +00004425}
4426#endif /* !defined(SQLITE_OMIT_CTE) */