1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains C code routines that are called by the SQLite parser
13 ** when syntax rules are reduced. The routines in this file handle the
14 ** following kinds of SQL syntax:
15 **
16 ** CREATE TABLE
17 ** DROP TABLE
18 ** CREATE INDEX
19 ** DROP INDEX
20 ** creating ID lists
21 ** BEGIN TRANSACTION
22 ** COMMIT
23 ** ROLLBACK
24 */
25 #include "sqliteInt.h"
26
27 #ifndef SQLITE_OMIT_SHARED_CACHE
28 /*
29 ** The TableLock structure is only used by the sqlite3TableLock() and
30 ** codeTableLocks() functions.
31 */
32 struct TableLock {
33 int iDb; /* The database containing the table to be locked */
34 int iTab; /* The root page of the table to be locked */
35 u8 isWriteLock; /* True for write lock. False for a read lock */
36 const char *zLockName; /* Name of the table */
37 };
38
39 /*
40 ** Record the fact that we want to lock a table at run-time.
41 **
42 ** The table to be locked has root page iTab and is found in database iDb.
43 ** A read or a write lock can be taken depending on isWritelock.
44 **
45 ** This routine just records the fact that the lock is desired. The
46 ** code to make the lock occur is generated by a later call to
47 ** codeTableLocks() which occurs during sqlite3FinishCoding().
48 */
sqlite3TableLock(Parse * pParse,int iDb,int iTab,u8 isWriteLock,const char * zName)49 void sqlite3TableLock(
50 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 */
55 ){
56 Parse *pToplevel = sqlite3ParseToplevel(pParse);
57 int i;
58 int nBytes;
59 TableLock *p;
60 assert( iDb>=0 );
61
62 if( iDb==1 ) return;
63 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
64 for(i=0; i<pToplevel->nTableLock; i++){
65 p = &pToplevel->aTableLock[i];
66 if( p->iDb==iDb && p->iTab==iTab ){
67 p->isWriteLock = (p->isWriteLock || isWriteLock);
68 return;
69 }
70 }
71
72 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++];
77 p->iDb = iDb;
78 p->iTab = iTab;
79 p->isWriteLock = isWriteLock;
80 p->zLockName = zName;
81 }else{
82 pToplevel->nTableLock = 0;
83 sqlite3OomFault(pToplevel->db);
84 }
85 }
86
87 /*
88 ** Code an OP_TableLock instruction for each table locked by the
89 ** statement (configured by calls to sqlite3TableLock()).
90 */
codeTableLocks(Parse * pParse)91 static void codeTableLocks(Parse *pParse){
92 int i;
93 Vdbe *pVdbe;
94
95 pVdbe = sqlite3GetVdbe(pParse);
96 assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
97
98 for(i=0; i<pParse->nTableLock; i++){
99 TableLock *p = &pParse->aTableLock[i];
100 int p1 = p->iDb;
101 sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
102 p->zLockName, P4_STATIC);
103 }
104 }
105 #else
106 #define codeTableLocks(x)
107 #endif
108
109 /*
110 ** 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
sqlite3DbMaskAllZero(yDbMask m)115 int 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 /*
123 ** This routine is called after a single SQL statement has been
124 ** 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.
128 **
129 ** Note that if an error occurred, it might be the case that
130 ** no VDBE code was generated.
131 */
sqlite3FinishCoding(Parse * pParse)132 void sqlite3FinishCoding(Parse *pParse){
133 sqlite3 *db;
134 Vdbe *v;
135
136 assert( pParse->pToplevel==0 );
137 db = pParse->db;
138 if( pParse->nested ) return;
139 if( db->mallocFailed || pParse->nErr ){
140 if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;
141 return;
142 }
143
144 /* Begin by generating some termination code at the end of the
145 ** vdbe program
146 */
147 v = sqlite3GetVdbe(pParse);
148 assert( !pParse->isMultiWrite
149 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
150 if( v ){
151 sqlite3VdbeAddOp0(v, OP_Halt);
152
153 #if SQLITE_USER_AUTHENTICATION
154 if( pParse->nTableLock>0 && db->init.busy==0 ){
155 sqlite3UserAuthInit(db);
156 if( db->auth.authLevel<UAUTH_User ){
157 sqlite3ErrorMsg(pParse, "user not authenticated");
158 pParse->rc = SQLITE_AUTH_USER;
159 return;
160 }
161 }
162 #endif
163
164 /* 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 */
170 if( db->mallocFailed==0
171 && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)
172 ){
173 int iDb, i;
174 assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
175 sqlite3VdbeJumpHere(v, 0);
176 for(iDb=0; iDb<db->nDb; iDb++){
177 Schema *pSchema;
178 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
179 sqlite3VdbeUsesBtree(v, iDb);
180 pSchema = db->aDb[iDb].pSchema;
181 sqlite3VdbeAddOp4Int(v,
182 OP_Transaction, /* Opcode */
183 iDb, /* P1 */
184 DbMaskTest(pParse->writeMask,iDb), /* P2 */
185 pSchema->schema_cookie, /* P3 */
186 pSchema->iGeneration /* P4 */
187 );
188 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
189 VdbeComment((v,
190 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
191 }
192 #ifndef SQLITE_OMIT_VIRTUALTABLE
193 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);
196 }
197 pParse->nVtabLock = 0;
198 #endif
199
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);
205
206 /* Initialize any AUTOINCREMENT data structures required.
207 */
208 sqlite3AutoincrementBegin(pParse);
209
210 /* Code constant expressions that where factored out of inner loops */
211 if( pParse->pConstExpr ){
212 ExprList *pEL = pParse->pConstExpr;
213 pParse->okConstFactor = 0;
214 for(i=0; i<pEL->nExpr; i++){
215 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
216 }
217 }
218
219 /* Finally, jump back to the beginning of the executable code. */
220 sqlite3VdbeGoto(v, 1);
221 }
222 }
223
224
225 /* Get the VDBE program ready for execution
226 */
227 if( v && pParse->nErr==0 && !db->mallocFailed ){
228 assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
229 /* 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;
232 sqlite3VdbeMakeReady(v, pParse);
233 pParse->rc = SQLITE_DONE;
234 }else{
235 pParse->rc = SQLITE_ERROR;
236 }
237 }
238
239 /*
240 ** 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
249 ** care if you decide to try to use this routine for some other purposes.
250 */
sqlite3NestedParse(Parse * pParse,const char * zFormat,...)251 void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
252 va_list ap;
253 char *zSql;
254 char *zErrMsg = 0;
255 sqlite3 *db = pParse->db;
256 char saveBuf[PARSE_TAIL_SZ];
257
258 if( pParse->nErr ) return;
259 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
260 va_start(ap, zFormat);
261 zSql = sqlite3VMPrintf(db, zFormat, ap);
262 va_end(ap);
263 if( zSql==0 ){
264 return; /* A malloc must have failed */
265 }
266 pParse->nested++;
267 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
268 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
269 sqlite3RunParser(pParse, zSql, &zErrMsg);
270 sqlite3DbFree(db, zErrMsg);
271 sqlite3DbFree(db, zSql);
272 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
273 pParse->nested--;
274 }
275
276 #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 */
sqlite3UserAuthTable(const char * zTable)281 int sqlite3UserAuthTable(const char *zTable){
282 return sqlite3_stricmp(zTable, "sqlite_user")==0;
283 }
284 #endif
285
286 /*
287 ** 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.
290 **
291 ** 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.
295 **
296 ** See also sqlite3LocateTable().
297 */
sqlite3FindTable(sqlite3 * db,const char * zName,const char * zDatabase)298 Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
299 Table *p = 0;
300 int i;
301
302 /* All mutexes are required for schema access. Make sure we hold them. */
303 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
304 #if SQLITE_USER_AUTHENTICATION
305 /* Only the admin user is allowed to know that the sqlite_user table
306 ** exists */
307 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
308 return 0;
309 }
310 #endif
311 while(1){
312 for(i=OMIT_TEMPDB; i<db->nDb; i++){
313 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
314 if( zDatabase==0 || sqlite3StrICmp(zDatabase, db->aDb[j].zDbSName)==0 ){
315 assert( sqlite3SchemaMutexHeld(db, j, 0) );
316 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
317 if( p ) return p;
318 }
319 }
320 /* Not found. If the name we were looking for was temp.sqlite_master
321 ** then change the name to sqlite_temp_master and try again. */
322 if( sqlite3StrICmp(zName, MASTER_NAME)!=0 ) break;
323 if( sqlite3_stricmp(zDatabase, db->aDb[1].zDbSName)!=0 ) break;
324 zName = TEMP_MASTER_NAME;
325 }
326 return 0;
327 }
328
329 /*
330 ** Locate the in-memory structure that describes a particular database
331 ** table given the name of that table and (optionally) the name of the
332 ** database containing the table. Return NULL if not found. Also leave an
333 ** error message in pParse->zErrMsg.
334 **
335 ** The difference between this routine and sqlite3FindTable() is that this
336 ** routine leaves an error message in pParse->zErrMsg where
337 ** sqlite3FindTable() does not.
338 */
sqlite3LocateTable(Parse * pParse,u32 flags,const char * zName,const char * zDbase)339 Table *sqlite3LocateTable(
340 Parse *pParse, /* context in which to report errors */
341 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
342 const char *zName, /* Name of the table we are looking for */
343 const char *zDbase /* Name of the database. Might be NULL */
344 ){
345 Table *p;
346
347 /* Read the database schema. If an error occurs, leave an error message
348 ** and code in pParse and return NULL. */
349 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
350 return 0;
351 }
352
353 p = sqlite3FindTable(pParse->db, zName, zDbase);
354 if( p==0 ){
355 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
356 #ifndef SQLITE_OMIT_VIRTUALTABLE
357 if( sqlite3FindDbName(pParse->db, zDbase)<1 ){
358 /* If zName is the not the name of a table in the schema created using
359 ** CREATE, then check to see if it is the name of an virtual table that
360 ** can be an eponymous virtual table. */
361 Module *pMod = (Module*)sqlite3HashFind(&pParse->db->aModule, zName);
362 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
363 pMod = sqlite3PragmaVtabRegister(pParse->db, zName);
364 }
365 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
366 return pMod->pEpoTab;
367 }
368 }
369 #endif
370 if( (flags & LOCATE_NOERR)==0 ){
371 if( zDbase ){
372 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
373 }else{
374 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
375 }
376 pParse->checkSchema = 1;
377 }
378 }
379
380 return p;
381 }
382
383 /*
384 ** Locate the table identified by *p.
385 **
386 ** This is a wrapper around sqlite3LocateTable(). The difference between
387 ** sqlite3LocateTable() and this function is that this function restricts
388 ** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
389 ** non-NULL if it is part of a view or trigger program definition. See
390 ** sqlite3FixSrcList() for details.
391 */
sqlite3LocateTableItem(Parse * pParse,u32 flags,struct SrcList_item * p)392 Table *sqlite3LocateTableItem(
393 Parse *pParse,
394 u32 flags,
395 struct SrcList_item *p
396 ){
397 const char *zDb;
398 assert( p->pSchema==0 || p->zDatabase==0 );
399 if( p->pSchema ){
400 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
401 zDb = pParse->db->aDb[iDb].zDbSName;
402 }else{
403 zDb = p->zDatabase;
404 }
405 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
406 }
407
408 /*
409 ** Locate the in-memory structure that describes
410 ** a particular index given the name of that index
411 ** and the name of the database that contains the index.
412 ** Return NULL if not found.
413 **
414 ** If zDatabase is 0, all databases are searched for the
415 ** table and the first matching index is returned. (No checking
416 ** for duplicate index names is done.) The search order is
417 ** TEMP first, then MAIN, then any auxiliary databases added
418 ** using the ATTACH command.
419 */
sqlite3FindIndex(sqlite3 * db,const char * zName,const char * zDb)420 Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
421 Index *p = 0;
422 int i;
423 /* All mutexes are required for schema access. Make sure we hold them. */
424 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
425 for(i=OMIT_TEMPDB; i<db->nDb; i++){
426 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
427 Schema *pSchema = db->aDb[j].pSchema;
428 assert( pSchema );
429 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zDbSName) ) continue;
430 assert( sqlite3SchemaMutexHeld(db, j, 0) );
431 p = sqlite3HashFind(&pSchema->idxHash, zName);
432 if( p ) break;
433 }
434 return p;
435 }
436
437 /*
438 ** Reclaim the memory used by an index
439 */
freeIndex(sqlite3 * db,Index * p)440 static void freeIndex(sqlite3 *db, Index *p){
441 #ifndef SQLITE_OMIT_ANALYZE
442 sqlite3DeleteIndexSamples(db, p);
443 #endif
444 sqlite3ExprDelete(db, p->pPartIdxWhere);
445 sqlite3ExprListDelete(db, p->aColExpr);
446 sqlite3DbFree(db, p->zColAff);
447 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
448 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
449 sqlite3_free(p->aiRowEst);
450 #endif
451 sqlite3DbFree(db, p);
452 }
453
454 /*
455 ** For the index called zIdxName which is found in the database iDb,
456 ** unlike that index from its Table then remove the index from
457 ** the index hash table and free all memory structures associated
458 ** with the index.
459 */
sqlite3UnlinkAndDeleteIndex(sqlite3 * db,int iDb,const char * zIdxName)460 void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
461 Index *pIndex;
462 Hash *pHash;
463
464 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
465 pHash = &db->aDb[iDb].pSchema->idxHash;
466 pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
467 if( ALWAYS(pIndex) ){
468 if( pIndex->pTable->pIndex==pIndex ){
469 pIndex->pTable->pIndex = pIndex->pNext;
470 }else{
471 Index *p;
472 /* Justification of ALWAYS(); The index must be on the list of
473 ** indices. */
474 p = pIndex->pTable->pIndex;
475 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
476 if( ALWAYS(p && p->pNext==pIndex) ){
477 p->pNext = pIndex->pNext;
478 }
479 }
480 freeIndex(db, pIndex);
481 }
482 db->flags |= SQLITE_InternChanges;
483 }
484
485 /*
486 ** Look through the list of open database files in db->aDb[] and if
487 ** any have been closed, remove them from the list. Reallocate the
488 ** db->aDb[] structure to a smaller size, if possible.
489 **
490 ** Entry 0 (the "main" database) and entry 1 (the "temp" database)
491 ** are never candidates for being collapsed.
492 */
sqlite3CollapseDatabaseArray(sqlite3 * db)493 void sqlite3CollapseDatabaseArray(sqlite3 *db){
494 int i, j;
495 for(i=j=2; i<db->nDb; i++){
496 struct Db *pDb = &db->aDb[i];
497 if( pDb->pBt==0 ){
498 sqlite3DbFree(db, pDb->zDbSName);
499 pDb->zDbSName = 0;
500 continue;
501 }
502 if( j<i ){
503 db->aDb[j] = db->aDb[i];
504 }
505 j++;
506 }
507 db->nDb = j;
508 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
509 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
510 sqlite3DbFree(db, db->aDb);
511 db->aDb = db->aDbStatic;
512 }
513 }
514
515 /*
516 ** Reset the schema for the database at index iDb. Also reset the
517 ** TEMP schema.
518 */
sqlite3ResetOneSchema(sqlite3 * db,int iDb)519 void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
520 Db *pDb;
521 assert( iDb<db->nDb );
522
523 /* Case 1: Reset the single schema identified by iDb */
524 pDb = &db->aDb[iDb];
525 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
526 assert( pDb->pSchema!=0 );
527 sqlite3SchemaClear(pDb->pSchema);
528
529 /* If any database other than TEMP is reset, then also reset TEMP
530 ** since TEMP might be holding triggers that reference tables in the
531 ** other database.
532 */
533 if( iDb!=1 ){
534 pDb = &db->aDb[1];
535 assert( pDb->pSchema!=0 );
536 sqlite3SchemaClear(pDb->pSchema);
537 }
538 return;
539 }
540
541 /*
542 ** Erase all schema information from all attached databases (including
543 ** "main" and "temp") for a single database connection.
544 */
sqlite3ResetAllSchemasOfConnection(sqlite3 * db)545 void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
546 int i;
547 sqlite3BtreeEnterAll(db);
548 for(i=0; i<db->nDb; i++){
549 Db *pDb = &db->aDb[i];
550 if( pDb->pSchema ){
551 sqlite3SchemaClear(pDb->pSchema);
552 }
553 }
554 db->flags &= ~SQLITE_InternChanges;
555 sqlite3VtabUnlockList(db);
556 sqlite3BtreeLeaveAll(db);
557 sqlite3CollapseDatabaseArray(db);
558 }
559
560 /*
561 ** This routine is called when a commit occurs.
562 */
sqlite3CommitInternalChanges(sqlite3 * db)563 void sqlite3CommitInternalChanges(sqlite3 *db){
564 db->flags &= ~SQLITE_InternChanges;
565 }
566
567 /*
568 ** Delete memory allocated for the column names of a table or view (the
569 ** Table.aCol[] array).
570 */
sqlite3DeleteColumnNames(sqlite3 * db,Table * pTable)571 void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
572 int i;
573 Column *pCol;
574 assert( pTable!=0 );
575 if( (pCol = pTable->aCol)!=0 ){
576 for(i=0; i<pTable->nCol; i++, pCol++){
577 sqlite3DbFree(db, pCol->zName);
578 sqlite3ExprDelete(db, pCol->pDflt);
579 sqlite3DbFree(db, pCol->zColl);
580 }
581 sqlite3DbFree(db, pTable->aCol);
582 }
583 }
584
585 /*
586 ** Remove the memory data structures associated with the given
587 ** Table. No changes are made to disk by this routine.
588 **
589 ** This routine just deletes the data structure. It does not unlink
590 ** the table data structure from the hash table. But it does destroy
591 ** memory structures of the indices and foreign keys associated with
592 ** the table.
593 **
594 ** The db parameter is optional. It is needed if the Table object
595 ** contains lookaside memory. (Table objects in the schema do not use
596 ** lookaside memory, but some ephemeral Table objects do.) Or the
597 ** db parameter can be used with db->pnBytesFreed to measure the memory
598 ** used by the Table object.
599 */
deleteTable(sqlite3 * db,Table * pTable)600 static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
601 Index *pIndex, *pNext;
602 TESTONLY( int nLookaside; ) /* Used to verify lookaside not used for schema */
603
604 /* Record the number of outstanding lookaside allocations in schema Tables
605 ** prior to doing any free() operations. Since schema Tables do not use
606 ** lookaside, this number should not change. */
607 TESTONLY( nLookaside = (db && (pTable->tabFlags & TF_Ephemeral)==0) ?
608 db->lookaside.nOut : 0 );
609
610 /* Delete all indices associated with this table. */
611 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
612 pNext = pIndex->pNext;
613 assert( pIndex->pSchema==pTable->pSchema
614 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
615 if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){
616 char *zName = pIndex->zName;
617 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
618 &pIndex->pSchema->idxHash, zName, 0
619 );
620 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
621 assert( pOld==pIndex || pOld==0 );
622 }
623 freeIndex(db, pIndex);
624 }
625
626 /* Delete any foreign keys attached to this table. */
627 sqlite3FkDelete(db, pTable);
628
629 /* Delete the Table structure itself.
630 */
631 sqlite3DeleteColumnNames(db, pTable);
632 sqlite3DbFree(db, pTable->zName);
633 sqlite3DbFree(db, pTable->zColAff);
634 sqlite3SelectDelete(db, pTable->pSelect);
635 sqlite3ExprListDelete(db, pTable->pCheck);
636 #ifndef SQLITE_OMIT_VIRTUALTABLE
637 sqlite3VtabClear(db, pTable);
638 #endif
639 sqlite3DbFree(db, pTable);
640
641 /* Verify that no lookaside memory was used by schema tables */
642 assert( nLookaside==0 || nLookaside==db->lookaside.nOut );
643 }
sqlite3DeleteTable(sqlite3 * db,Table * pTable)644 void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
645 /* Do not delete the table until the reference count reaches zero. */
646 if( !pTable ) return;
647 if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return;
648 deleteTable(db, pTable);
649 }
650
651
652 /*
653 ** Unlink the given table from the hash tables and the delete the
654 ** table structure with all its indices and foreign keys.
655 */
sqlite3UnlinkAndDeleteTable(sqlite3 * db,int iDb,const char * zTabName)656 void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
657 Table *p;
658 Db *pDb;
659
660 assert( db!=0 );
661 assert( iDb>=0 && iDb<db->nDb );
662 assert( zTabName );
663 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
664 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
665 pDb = &db->aDb[iDb];
666 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
667 sqlite3DeleteTable(db, p);
668 db->flags |= SQLITE_InternChanges;
669 }
670
671 /*
672 ** Given a token, return a string that consists of the text of that
673 ** token. Space to hold the returned string
674 ** is obtained from sqliteMalloc() and must be freed by the calling
675 ** function.
676 **
677 ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
678 ** surround the body of the token are removed.
679 **
680 ** Tokens are often just pointers into the original SQL text and so
681 ** are not \000 terminated and are not persistent. The returned string
682 ** is \000 terminated and is persistent.
683 */
sqlite3NameFromToken(sqlite3 * db,Token * pName)684 char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
685 char *zName;
686 if( pName ){
687 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
688 sqlite3Dequote(zName);
689 }else{
690 zName = 0;
691 }
692 return zName;
693 }
694
695 /*
696 ** Open the sqlite_master table stored in database number iDb for
697 ** writing. The table is opened using cursor 0.
698 */
sqlite3OpenMasterTable(Parse * p,int iDb)699 void sqlite3OpenMasterTable(Parse *p, int iDb){
700 Vdbe *v = sqlite3GetVdbe(p);
701 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, MASTER_NAME);
702 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
703 if( p->nTab==0 ){
704 p->nTab = 1;
705 }
706 }
707
708 /*
709 ** Parameter zName points to a nul-terminated buffer containing the name
710 ** of a database ("main", "temp" or the name of an attached db). This
711 ** function returns the index of the named database in db->aDb[], or
712 ** -1 if the named db cannot be found.
713 */
sqlite3FindDbName(sqlite3 * db,const char * zName)714 int sqlite3FindDbName(sqlite3 *db, const char *zName){
715 int i = -1; /* Database number */
716 if( zName ){
717 Db *pDb;
718 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
719 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
720 /* "main" is always an acceptable alias for the primary database
721 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
722 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
723 }
724 }
725 return i;
726 }
727
728 /*
729 ** The token *pName contains the name of a database (either "main" or
730 ** "temp" or the name of an attached db). This routine returns the
731 ** index of the named database in db->aDb[], or -1 if the named db
732 ** does not exist.
733 */
sqlite3FindDb(sqlite3 * db,Token * pName)734 int sqlite3FindDb(sqlite3 *db, Token *pName){
735 int i; /* Database number */
736 char *zName; /* Name we are searching for */
737 zName = sqlite3NameFromToken(db, pName);
738 i = sqlite3FindDbName(db, zName);
739 sqlite3DbFree(db, zName);
740 return i;
741 }
742
743 /* The table or view or trigger name is passed to this routine via tokens
744 ** pName1 and pName2. If the table name was fully qualified, for example:
745 **
746 ** CREATE TABLE xxx.yyy (...);
747 **
748 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
749 ** the table name is not fully qualified, i.e.:
750 **
751 ** CREATE TABLE yyy(...);
752 **
753 ** Then pName1 is set to "yyy" and pName2 is "".
754 **
755 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
756 ** pName2) that stores the unqualified table name. The index of the
757 ** database "xxx" is returned.
758 */
sqlite3TwoPartName(Parse * pParse,Token * pName1,Token * pName2,Token ** pUnqual)759 int sqlite3TwoPartName(
760 Parse *pParse, /* Parsing and code generating context */
761 Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
762 Token *pName2, /* The "yyy" in the name "xxx.yyy" */
763 Token **pUnqual /* Write the unqualified object name here */
764 ){
765 int iDb; /* Database holding the object */
766 sqlite3 *db = pParse->db;
767
768 assert( pName2!=0 );
769 if( pName2->n>0 ){
770 if( db->init.busy ) {
771 sqlite3ErrorMsg(pParse, "corrupt database");
772 return -1;
773 }
774 *pUnqual = pName2;
775 iDb = sqlite3FindDb(db, pName1);
776 if( iDb<0 ){
777 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
778 return -1;
779 }
780 }else{
781 assert( db->init.iDb==0 || db->init.busy || (db->flags & SQLITE_Vacuum)!=0);
782 iDb = db->init.iDb;
783 *pUnqual = pName1;
784 }
785 return iDb;
786 }
787
788 /*
789 ** This routine is used to check if the UTF-8 string zName is a legal
790 ** unqualified name for a new schema object (table, index, view or
791 ** trigger). All names are legal except those that begin with the string
792 ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
793 ** is reserved for internal use.
794 */
sqlite3CheckObjectName(Parse * pParse,const char * zName)795 int sqlite3CheckObjectName(Parse *pParse, const char *zName){
796 if( !pParse->db->init.busy && pParse->nested==0
797 && (pParse->db->flags & SQLITE_WriteSchema)==0
798 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
799 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
800 return SQLITE_ERROR;
801 }
802 return SQLITE_OK;
803 }
804
805 /*
806 ** Return the PRIMARY KEY index of a table
807 */
sqlite3PrimaryKeyIndex(Table * pTab)808 Index *sqlite3PrimaryKeyIndex(Table *pTab){
809 Index *p;
810 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
811 return p;
812 }
813
814 /*
815 ** Return the column of index pIdx that corresponds to table
816 ** column iCol. Return -1 if not found.
817 */
sqlite3ColumnOfIndex(Index * pIdx,i16 iCol)818 i16 sqlite3ColumnOfIndex(Index *pIdx, i16 iCol){
819 int i;
820 for(i=0; i<pIdx->nColumn; i++){
821 if( iCol==pIdx->aiColumn[i] ) return i;
822 }
823 return -1;
824 }
825
826 /*
827 ** Begin constructing a new table representation in memory. This is
828 ** the first of several action routines that get called in response
829 ** to a CREATE TABLE statement. In particular, this routine is called
830 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
831 ** flag is true if the table should be stored in the auxiliary database
832 ** file instead of in the main database file. This is normally the case
833 ** when the "TEMP" or "TEMPORARY" keyword occurs in between
834 ** CREATE and TABLE.
835 **
836 ** The new table record is initialized and put in pParse->pNewTable.
837 ** As more of the CREATE TABLE statement is parsed, additional action
838 ** routines will be called to add more information to this record.
839 ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
840 ** is called to complete the construction of the new table record.
841 */
sqlite3StartTable(Parse * pParse,Token * pName1,Token * pName2,int isTemp,int isView,int isVirtual,int noErr)842 void sqlite3StartTable(
843 Parse *pParse, /* Parser context */
844 Token *pName1, /* First part of the name of the table or view */
845 Token *pName2, /* Second part of the name of the table or view */
846 int isTemp, /* True if this is a TEMP table */
847 int isView, /* True if this is a VIEW */
848 int isVirtual, /* True if this is a VIRTUAL table */
849 int noErr /* Do nothing if table already exists */
850 ){
851 Table *pTable;
852 char *zName = 0; /* The name of the new table */
853 sqlite3 *db = pParse->db;
854 Vdbe *v;
855 int iDb; /* Database number to create the table in */
856 Token *pName; /* Unqualified name of the table to create */
857
858 if( db->init.busy && db->init.newTnum==1 ){
859 /* Special case: Parsing the sqlite_master or sqlite_temp_master schema */
860 iDb = db->init.iDb;
861 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
862 pName = pName1;
863 }else{
864 /* The common case */
865 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
866 if( iDb<0 ) return;
867 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
868 /* If creating a temp table, the name may not be qualified. Unless
869 ** the database name is "temp" anyway. */
870 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
871 return;
872 }
873 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
874 zName = sqlite3NameFromToken(db, pName);
875 }
876 pParse->sNameToken = *pName;
877 if( zName==0 ) return;
878 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
879 goto begin_table_error;
880 }
881 if( db->init.iDb==1 ) isTemp = 1;
882 #ifndef SQLITE_OMIT_AUTHORIZATION
883 assert( isTemp==0 || isTemp==1 );
884 assert( isView==0 || isView==1 );
885 {
886 static const u8 aCode[] = {
887 SQLITE_CREATE_TABLE,
888 SQLITE_CREATE_TEMP_TABLE,
889 SQLITE_CREATE_VIEW,
890 SQLITE_CREATE_TEMP_VIEW
891 };
892 char *zDb = db->aDb[iDb].zDbSName;
893 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
894 goto begin_table_error;
895 }
896 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
897 zName, 0, zDb) ){
898 goto begin_table_error;
899 }
900 }
901 #endif
902
903 /* Make sure the new table name does not collide with an existing
904 ** index or table name in the same database. Issue an error message if
905 ** it does. The exception is if the statement being parsed was passed
906 ** to an sqlite3_declare_vtab() call. In that case only the column names
907 ** and types will be used, so there is no need to test for namespace
908 ** collisions.
909 */
910 if( !IN_DECLARE_VTAB ){
911 char *zDb = db->aDb[iDb].zDbSName;
912 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
913 goto begin_table_error;
914 }
915 pTable = sqlite3FindTable(db, zName, zDb);
916 if( pTable ){
917 if( !noErr ){
918 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
919 }else{
920 assert( !db->init.busy || CORRUPT_DB );
921 sqlite3CodeVerifySchema(pParse, iDb);
922 }
923 goto begin_table_error;
924 }
925 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
926 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
927 goto begin_table_error;
928 }
929 }
930
931 pTable = sqlite3DbMallocZero(db, sizeof(Table));
932 if( pTable==0 ){
933 assert( db->mallocFailed );
934 pParse->rc = SQLITE_NOMEM_BKPT;
935 pParse->nErr++;
936 goto begin_table_error;
937 }
938 pTable->zName = zName;
939 pTable->iPKey = -1;
940 pTable->pSchema = db->aDb[iDb].pSchema;
941 pTable->nTabRef = 1;
942 #ifdef SQLITE_DEFAULT_ROWEST
943 pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
944 #else
945 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
946 #endif
947 assert( pParse->pNewTable==0 );
948 pParse->pNewTable = pTable;
949
950 /* If this is the magic sqlite_sequence table used by autoincrement,
951 ** then record a pointer to this table in the main database structure
952 ** so that INSERT can find the table easily.
953 */
954 #ifndef SQLITE_OMIT_AUTOINCREMENT
955 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
956 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
957 pTable->pSchema->pSeqTab = pTable;
958 }
959 #endif
960
961 /* Begin generating the code that will insert the table record into
962 ** the SQLITE_MASTER table. Note in particular that we must go ahead
963 ** and allocate the record number for the table entry now. Before any
964 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
965 ** indices to be created and the table record must come before the
966 ** indices. Hence, the record number for the table must be allocated
967 ** now.
968 */
969 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
970 int addr1;
971 int fileFormat;
972 int reg1, reg2, reg3;
973 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
974 static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
975 sqlite3BeginWriteOperation(pParse, 1, iDb);
976
977 #ifndef SQLITE_OMIT_VIRTUALTABLE
978 if( isVirtual ){
979 sqlite3VdbeAddOp0(v, OP_VBegin);
980 }
981 #endif
982
983 /* If the file format and encoding in the database have not been set,
984 ** set them now.
985 */
986 reg1 = pParse->regRowid = ++pParse->nMem;
987 reg2 = pParse->regRoot = ++pParse->nMem;
988 reg3 = ++pParse->nMem;
989 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
990 sqlite3VdbeUsesBtree(v, iDb);
991 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
992 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
993 1 : SQLITE_MAX_FILE_FORMAT;
994 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
995 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
996 sqlite3VdbeJumpHere(v, addr1);
997
998 /* This just creates a place-holder record in the sqlite_master table.
999 ** The record created does not contain anything yet. It will be replaced
1000 ** by the real entry in code generated at sqlite3EndTable().
1001 **
1002 ** The rowid for the new entry is left in register pParse->regRowid.
1003 ** The root page number of the new table is left in reg pParse->regRoot.
1004 ** The rowid and root page number values are needed by the code that
1005 ** sqlite3EndTable will generate.
1006 */
1007 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
1008 if( isView || isVirtual ){
1009 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
1010 }else
1011 #endif
1012 {
1013 pParse->addrCrTab = sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
1014 }
1015 sqlite3OpenMasterTable(pParse, iDb);
1016 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
1017 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
1018 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
1019 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
1020 sqlite3VdbeAddOp0(v, OP_Close);
1021 }
1022
1023 /* Normal (non-error) return. */
1024 return;
1025
1026 /* If an error occurs, we jump here */
1027 begin_table_error:
1028 sqlite3DbFree(db, zName);
1029 return;
1030 }
1031
1032 /* Set properties of a table column based on the (magical)
1033 ** name of the column.
1034 */
1035 #if SQLITE_ENABLE_HIDDEN_COLUMNS
sqlite3ColumnPropertiesFromName(Table * pTab,Column * pCol)1036 void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
1037 if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
1038 pCol->colFlags |= COLFLAG_HIDDEN;
1039 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
1040 pTab->tabFlags |= TF_OOOHidden;
1041 }
1042 }
1043 #endif
1044
1045
1046 /*
1047 ** Add a new column to the table currently being constructed.
1048 **
1049 ** The parser calls this routine once for each column declaration
1050 ** in a CREATE TABLE statement. sqlite3StartTable() gets called
1051 ** first to get things going. Then this routine is called for each
1052 ** column.
1053 */
sqlite3AddColumn(Parse * pParse,Token * pName,Token * pType)1054 void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){
1055 Table *p;
1056 int i;
1057 char *z;
1058 char *zType;
1059 Column *pCol;
1060 sqlite3 *db = pParse->db;
1061 if( (p = pParse->pNewTable)==0 ) return;
1062 #if SQLITE_MAX_COLUMN
1063 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
1064 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
1065 return;
1066 }
1067 #endif
1068 z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
1069 if( z==0 ) return;
1070 memcpy(z, pName->z, pName->n);
1071 z[pName->n] = 0;
1072 sqlite3Dequote(z);
1073 for(i=0; i<p->nCol; i++){
1074 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
1075 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
1076 sqlite3DbFree(db, z);
1077 return;
1078 }
1079 }
1080 if( (p->nCol & 0x7)==0 ){
1081 Column *aNew;
1082 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
1083 if( aNew==0 ){
1084 sqlite3DbFree(db, z);
1085 return;
1086 }
1087 p->aCol = aNew;
1088 }
1089 pCol = &p->aCol[p->nCol];
1090 memset(pCol, 0, sizeof(p->aCol[0]));
1091 pCol->zName = z;
1092 sqlite3ColumnPropertiesFromName(p, pCol);
1093
1094 if( pType->n==0 ){
1095 /* If there is no type specified, columns have the default affinity
1096 ** 'BLOB'. */
1097 pCol->affinity = SQLITE_AFF_BLOB;
1098 pCol->szEst = 1;
1099 }else{
1100 zType = z + sqlite3Strlen30(z) + 1;
1101 memcpy(zType, pType->z, pType->n);
1102 zType[pType->n] = 0;
1103 sqlite3Dequote(zType);
1104 pCol->affinity = sqlite3AffinityType(zType, &pCol->szEst);
1105 pCol->colFlags |= COLFLAG_HASTYPE;
1106 }
1107 p->nCol++;
1108 pParse->constraintName.n = 0;
1109 }
1110
1111 /*
1112 ** This routine is called by the parser while in the middle of
1113 ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
1114 ** been seen on a column. This routine sets the notNull flag on
1115 ** the column currently under construction.
1116 */
sqlite3AddNotNull(Parse * pParse,int onError)1117 void sqlite3AddNotNull(Parse *pParse, int onError){
1118 Table *p;
1119 p = pParse->pNewTable;
1120 if( p==0 || NEVER(p->nCol<1) ) return;
1121 p->aCol[p->nCol-1].notNull = (u8)onError;
1122 p->tabFlags |= TF_HasNotNull;
1123 }
1124
1125 /*
1126 ** Scan the column type name zType (length nType) and return the
1127 ** associated affinity type.
1128 **
1129 ** This routine does a case-independent search of zType for the
1130 ** substrings in the following table. If one of the substrings is
1131 ** found, the corresponding affinity is returned. If zType contains
1132 ** more than one of the substrings, entries toward the top of
1133 ** the table take priority. For example, if zType is 'BLOBINT',
1134 ** SQLITE_AFF_INTEGER is returned.
1135 **
1136 ** Substring | Affinity
1137 ** --------------------------------
1138 ** 'INT' | SQLITE_AFF_INTEGER
1139 ** 'CHAR' | SQLITE_AFF_TEXT
1140 ** 'CLOB' | SQLITE_AFF_TEXT
1141 ** 'TEXT' | SQLITE_AFF_TEXT
1142 ** 'BLOB' | SQLITE_AFF_BLOB
1143 ** 'REAL' | SQLITE_AFF_REAL
1144 ** 'FLOA' | SQLITE_AFF_REAL
1145 ** 'DOUB' | SQLITE_AFF_REAL
1146 **
1147 ** If none of the substrings in the above table are found,
1148 ** SQLITE_AFF_NUMERIC is returned.
1149 */
sqlite3AffinityType(const char * zIn,u8 * pszEst)1150 char sqlite3AffinityType(const char *zIn, u8 *pszEst){
1151 u32 h = 0;
1152 char aff = SQLITE_AFF_NUMERIC;
1153 const char *zChar = 0;
1154
1155 assert( zIn!=0 );
1156 while( zIn[0] ){
1157 h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
1158 zIn++;
1159 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
1160 aff = SQLITE_AFF_TEXT;
1161 zChar = zIn;
1162 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
1163 aff = SQLITE_AFF_TEXT;
1164 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
1165 aff = SQLITE_AFF_TEXT;
1166 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
1167 && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
1168 aff = SQLITE_AFF_BLOB;
1169 if( zIn[0]=='(' ) zChar = zIn;
1170 #ifndef SQLITE_OMIT_FLOATING_POINT
1171 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
1172 && aff==SQLITE_AFF_NUMERIC ){
1173 aff = SQLITE_AFF_REAL;
1174 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
1175 && aff==SQLITE_AFF_NUMERIC ){
1176 aff = SQLITE_AFF_REAL;
1177 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
1178 && aff==SQLITE_AFF_NUMERIC ){
1179 aff = SQLITE_AFF_REAL;
1180 #endif
1181 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
1182 aff = SQLITE_AFF_INTEGER;
1183 break;
1184 }
1185 }
1186
1187 /* If pszEst is not NULL, store an estimate of the field size. The
1188 ** estimate is scaled so that the size of an integer is 1. */
1189 if( pszEst ){
1190 *pszEst = 1; /* default size is approx 4 bytes */
1191 if( aff<SQLITE_AFF_NUMERIC ){
1192 if( zChar ){
1193 while( zChar[0] ){
1194 if( sqlite3Isdigit(zChar[0]) ){
1195 int v = 0;
1196 sqlite3GetInt32(zChar, &v);
1197 v = v/4 + 1;
1198 if( v>255 ) v = 255;
1199 *pszEst = v; /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
1200 break;
1201 }
1202 zChar++;
1203 }
1204 }else{
1205 *pszEst = 5; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
1206 }
1207 }
1208 }
1209 return aff;
1210 }
1211
1212 /*
1213 ** The expression is the default value for the most recently added column
1214 ** of the table currently under construction.
1215 **
1216 ** Default value expressions must be constant. Raise an exception if this
1217 ** is not the case.
1218 **
1219 ** This routine is called by the parser while in the middle of
1220 ** parsing a CREATE TABLE statement.
1221 */
sqlite3AddDefaultValue(Parse * pParse,ExprSpan * pSpan)1222 void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
1223 Table *p;
1224 Column *pCol;
1225 sqlite3 *db = pParse->db;
1226 p = pParse->pNewTable;
1227 if( p!=0 ){
1228 pCol = &(p->aCol[p->nCol-1]);
1229 if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr, db->init.busy) ){
1230 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
1231 pCol->zName);
1232 }else{
1233 /* A copy of pExpr is used instead of the original, as pExpr contains
1234 ** tokens that point to volatile memory. The 'span' of the expression
1235 ** is required by pragma table_info.
1236 */
1237 Expr x;
1238 sqlite3ExprDelete(db, pCol->pDflt);
1239 memset(&x, 0, sizeof(x));
1240 x.op = TK_SPAN;
1241 x.u.zToken = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
1242 (int)(pSpan->zEnd - pSpan->zStart));
1243 x.pLeft = pSpan->pExpr;
1244 x.flags = EP_Skip;
1245 pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
1246 sqlite3DbFree(db, x.u.zToken);
1247 }
1248 }
1249 sqlite3ExprDelete(db, pSpan->pExpr);
1250 }
1251
1252 /*
1253 ** Backwards Compatibility Hack:
1254 **
1255 ** Historical versions of SQLite accepted strings as column names in
1256 ** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
1257 **
1258 ** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
1259 ** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
1260 **
1261 ** This is goofy. But to preserve backwards compatibility we continue to
1262 ** accept it. This routine does the necessary conversion. It converts
1263 ** the expression given in its argument from a TK_STRING into a TK_ID
1264 ** if the expression is just a TK_STRING with an optional COLLATE clause.
1265 ** If the epxression is anything other than TK_STRING, the expression is
1266 ** unchanged.
1267 */
sqlite3StringToId(Expr * p)1268 static void sqlite3StringToId(Expr *p){
1269 if( p->op==TK_STRING ){
1270 p->op = TK_ID;
1271 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
1272 p->pLeft->op = TK_ID;
1273 }
1274 }
1275
1276 /*
1277 ** Designate the PRIMARY KEY for the table. pList is a list of names
1278 ** of columns that form the primary key. If pList is NULL, then the
1279 ** most recently added column of the table is the primary key.
1280 **
1281 ** A table can have at most one primary key. If the table already has
1282 ** a primary key (and this is the second primary key) then create an
1283 ** error.
1284 **
1285 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
1286 ** then we will try to use that column as the rowid. Set the Table.iPKey
1287 ** field of the table under construction to be the index of the
1288 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
1289 ** no INTEGER PRIMARY KEY.
1290 **
1291 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
1292 ** index for the key. No index is created for INTEGER PRIMARY KEYs.
1293 */
sqlite3AddPrimaryKey(Parse * pParse,ExprList * pList,int onError,int autoInc,int sortOrder)1294 void sqlite3AddPrimaryKey(
1295 Parse *pParse, /* Parsing context */
1296 ExprList *pList, /* List of field names to be indexed */
1297 int onError, /* What to do with a uniqueness conflict */
1298 int autoInc, /* True if the AUTOINCREMENT keyword is present */
1299 int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
1300 ){
1301 Table *pTab = pParse->pNewTable;
1302 Column *pCol = 0;
1303 int iCol = -1, i;
1304 int nTerm;
1305 if( pTab==0 ) goto primary_key_exit;
1306 if( pTab->tabFlags & TF_HasPrimaryKey ){
1307 sqlite3ErrorMsg(pParse,
1308 "table \"%s\" has more than one primary key", pTab->zName);
1309 goto primary_key_exit;
1310 }
1311 pTab->tabFlags |= TF_HasPrimaryKey;
1312 if( pList==0 ){
1313 iCol = pTab->nCol - 1;
1314 pCol = &pTab->aCol[iCol];
1315 pCol->colFlags |= COLFLAG_PRIMKEY;
1316 nTerm = 1;
1317 }else{
1318 nTerm = pList->nExpr;
1319 for(i=0; i<nTerm; i++){
1320 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
1321 assert( pCExpr!=0 );
1322 sqlite3StringToId(pCExpr);
1323 if( pCExpr->op==TK_ID ){
1324 const char *zCName = pCExpr->u.zToken;
1325 for(iCol=0; iCol<pTab->nCol; iCol++){
1326 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
1327 pCol = &pTab->aCol[iCol];
1328 pCol->colFlags |= COLFLAG_PRIMKEY;
1329 break;
1330 }
1331 }
1332 }
1333 }
1334 }
1335 if( nTerm==1
1336 && pCol
1337 && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
1338 && sortOrder!=SQLITE_SO_DESC
1339 ){
1340 pTab->iPKey = iCol;
1341 pTab->keyConf = (u8)onError;
1342 assert( autoInc==0 || autoInc==1 );
1343 pTab->tabFlags |= autoInc*TF_Autoincrement;
1344 if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
1345 }else if( autoInc ){
1346 #ifndef SQLITE_OMIT_AUTOINCREMENT
1347 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
1348 "INTEGER PRIMARY KEY");
1349 #endif
1350 }else{
1351 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
1352 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
1353 pList = 0;
1354 }
1355
1356 primary_key_exit:
1357 sqlite3ExprListDelete(pParse->db, pList);
1358 return;
1359 }
1360
1361 /*
1362 ** Add a new CHECK constraint to the table currently under construction.
1363 */
sqlite3AddCheckConstraint(Parse * pParse,Expr * pCheckExpr)1364 void sqlite3AddCheckConstraint(
1365 Parse *pParse, /* Parsing context */
1366 Expr *pCheckExpr /* The check expression */
1367 ){
1368 #ifndef SQLITE_OMIT_CHECK
1369 Table *pTab = pParse->pNewTable;
1370 sqlite3 *db = pParse->db;
1371 if( pTab && !IN_DECLARE_VTAB
1372 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
1373 ){
1374 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
1375 if( pParse->constraintName.n ){
1376 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
1377 }
1378 }else
1379 #endif
1380 {
1381 sqlite3ExprDelete(pParse->db, pCheckExpr);
1382 }
1383 }
1384
1385 /*
1386 ** Set the collation function of the most recently parsed table column
1387 ** to the CollSeq given.
1388 */
sqlite3AddCollateType(Parse * pParse,Token * pToken)1389 void sqlite3AddCollateType(Parse *pParse, Token *pToken){
1390 Table *p;
1391 int i;
1392 char *zColl; /* Dequoted name of collation sequence */
1393 sqlite3 *db;
1394
1395 if( (p = pParse->pNewTable)==0 ) return;
1396 i = p->nCol-1;
1397 db = pParse->db;
1398 zColl = sqlite3NameFromToken(db, pToken);
1399 if( !zColl ) return;
1400
1401 if( sqlite3LocateCollSeq(pParse, zColl) ){
1402 Index *pIdx;
1403 sqlite3DbFree(db, p->aCol[i].zColl);
1404 p->aCol[i].zColl = zColl;
1405
1406 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
1407 ** then an index may have been created on this column before the
1408 ** collation type was added. Correct this if it is the case.
1409 */
1410 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
1411 assert( pIdx->nKeyCol==1 );
1412 if( pIdx->aiColumn[0]==i ){
1413 pIdx->azColl[0] = p->aCol[i].zColl;
1414 }
1415 }
1416 }else{
1417 sqlite3DbFree(db, zColl);
1418 }
1419 }
1420
1421 /*
1422 ** This function returns the collation sequence for database native text
1423 ** encoding identified by the string zName, length nName.
1424 **
1425 ** If the requested collation sequence is not available, or not available
1426 ** in the database native encoding, the collation factory is invoked to
1427 ** request it. If the collation factory does not supply such a sequence,
1428 ** and the sequence is available in another text encoding, then that is
1429 ** returned instead.
1430 **
1431 ** If no versions of the requested collations sequence are available, or
1432 ** another error occurs, NULL is returned and an error message written into
1433 ** pParse.
1434 **
1435 ** This routine is a wrapper around sqlite3FindCollSeq(). This routine
1436 ** invokes the collation factory if the named collation cannot be found
1437 ** and generates an error message.
1438 **
1439 ** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq()
1440 */
sqlite3LocateCollSeq(Parse * pParse,const char * zName)1441 CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
1442 sqlite3 *db = pParse->db;
1443 u8 enc = ENC(db);
1444 u8 initbusy = db->init.busy;
1445 CollSeq *pColl;
1446
1447 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
1448 if( !initbusy && (!pColl || !pColl->xCmp) ){
1449 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
1450 }
1451
1452 return pColl;
1453 }
1454
1455
1456 /*
1457 ** Generate code that will increment the schema cookie.
1458 **
1459 ** The schema cookie is used to determine when the schema for the
1460 ** database changes. After each schema change, the cookie value
1461 ** changes. When a process first reads the schema it records the
1462 ** cookie. Thereafter, whenever it goes to access the database,
1463 ** it checks the cookie to make sure the schema has not changed
1464 ** since it was last read.
1465 **
1466 ** This plan is not completely bullet-proof. It is possible for
1467 ** the schema to change multiple times and for the cookie to be
1468 ** set back to prior value. But schema changes are infrequent
1469 ** and the probability of hitting the same cookie value is only
1470 ** 1 chance in 2^32. So we're safe enough.
1471 **
1472 ** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
1473 ** the schema-version whenever the schema changes.
1474 */
sqlite3ChangeCookie(Parse * pParse,int iDb)1475 void sqlite3ChangeCookie(Parse *pParse, int iDb){
1476 sqlite3 *db = pParse->db;
1477 Vdbe *v = pParse->pVdbe;
1478 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1479 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
1480 db->aDb[iDb].pSchema->schema_cookie+1);
1481 }
1482
1483 /*
1484 ** Measure the number of characters needed to output the given
1485 ** identifier. The number returned includes any quotes used
1486 ** but does not include the null terminator.
1487 **
1488 ** The estimate is conservative. It might be larger that what is
1489 ** really needed.
1490 */
identLength(const char * z)1491 static int identLength(const char *z){
1492 int n;
1493 for(n=0; *z; n++, z++){
1494 if( *z=='"' ){ n++; }
1495 }
1496 return n + 2;
1497 }
1498
1499 /*
1500 ** The first parameter is a pointer to an output buffer. The second
1501 ** parameter is a pointer to an integer that contains the offset at
1502 ** which to write into the output buffer. This function copies the
1503 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
1504 ** to the specified offset in the buffer and updates *pIdx to refer
1505 ** to the first byte after the last byte written before returning.
1506 **
1507 ** If the string zSignedIdent consists entirely of alpha-numeric
1508 ** characters, does not begin with a digit and is not an SQL keyword,
1509 ** then it is copied to the output buffer exactly as it is. Otherwise,
1510 ** it is quoted using double-quotes.
1511 */
identPut(char * z,int * pIdx,char * zSignedIdent)1512 static void identPut(char *z, int *pIdx, char *zSignedIdent){
1513 unsigned char *zIdent = (unsigned char*)zSignedIdent;
1514 int i, j, needQuote;
1515 i = *pIdx;
1516
1517 for(j=0; zIdent[j]; j++){
1518 if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
1519 }
1520 needQuote = sqlite3Isdigit(zIdent[0])
1521 || sqlite3KeywordCode(zIdent, j)!=TK_ID
1522 || zIdent[j]!=0
1523 || j==0;
1524
1525 if( needQuote ) z[i++] = '"';
1526 for(j=0; zIdent[j]; j++){
1527 z[i++] = zIdent[j];
1528 if( zIdent[j]=='"' ) z[i++] = '"';
1529 }
1530 if( needQuote ) z[i++] = '"';
1531 z[i] = 0;
1532 *pIdx = i;
1533 }
1534
1535 /*
1536 ** Generate a CREATE TABLE statement appropriate for the given
1537 ** table. Memory to hold the text of the statement is obtained
1538 ** from sqliteMalloc() and must be freed by the calling function.
1539 */
createTableStmt(sqlite3 * db,Table * p)1540 static char *createTableStmt(sqlite3 *db, Table *p){
1541 int i, k, n;
1542 char *zStmt;
1543 char *zSep, *zSep2, *zEnd;
1544 Column *pCol;
1545 n = 0;
1546 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
1547 n += identLength(pCol->zName) + 5;
1548 }
1549 n += identLength(p->zName);
1550 if( n<50 ){
1551 zSep = "";
1552 zSep2 = ",";
1553 zEnd = ")";
1554 }else{
1555 zSep = "\n ";
1556 zSep2 = ",\n ";
1557 zEnd = "\n)";
1558 }
1559 n += 35 + 6*p->nCol;
1560 zStmt = sqlite3DbMallocRaw(0, n);
1561 if( zStmt==0 ){
1562 sqlite3OomFault(db);
1563 return 0;
1564 }
1565 sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
1566 k = sqlite3Strlen30(zStmt);
1567 identPut(zStmt, &k, p->zName);
1568 zStmt[k++] = '(';
1569 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
1570 static const char * const azType[] = {
1571 /* SQLITE_AFF_BLOB */ "",
1572 /* SQLITE_AFF_TEXT */ " TEXT",
1573 /* SQLITE_AFF_NUMERIC */ " NUM",
1574 /* SQLITE_AFF_INTEGER */ " INT",
1575 /* SQLITE_AFF_REAL */ " REAL"
1576 };
1577 int len;
1578 const char *zType;
1579
1580 sqlite3_snprintf(n-k, &zStmt[k], zSep);
1581 k += sqlite3Strlen30(&zStmt[k]);
1582 zSep = zSep2;
1583 identPut(zStmt, &k, pCol->zName);
1584 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
1585 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
1586 testcase( pCol->affinity==SQLITE_AFF_BLOB );
1587 testcase( pCol->affinity==SQLITE_AFF_TEXT );
1588 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
1589 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
1590 testcase( pCol->affinity==SQLITE_AFF_REAL );
1591
1592 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
1593 len = sqlite3Strlen30(zType);
1594 assert( pCol->affinity==SQLITE_AFF_BLOB
1595 || pCol->affinity==sqlite3AffinityType(zType, 0) );
1596 memcpy(&zStmt[k], zType, len);
1597 k += len;
1598 assert( k<=n );
1599 }
1600 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
1601 return zStmt;
1602 }
1603
1604 /*
1605 ** Resize an Index object to hold N columns total. Return SQLITE_OK
1606 ** on success and SQLITE_NOMEM on an OOM error.
1607 */
resizeIndexObject(sqlite3 * db,Index * pIdx,int N)1608 static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
1609 char *zExtra;
1610 int nByte;
1611 if( pIdx->nColumn>=N ) return SQLITE_OK;
1612 assert( pIdx->isResized==0 );
1613 nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
1614 zExtra = sqlite3DbMallocZero(db, nByte);
1615 if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
1616 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
1617 pIdx->azColl = (const char**)zExtra;
1618 zExtra += sizeof(char*)*N;
1619 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
1620 pIdx->aiColumn = (i16*)zExtra;
1621 zExtra += sizeof(i16)*N;
1622 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
1623 pIdx->aSortOrder = (u8*)zExtra;
1624 pIdx->nColumn = N;
1625 pIdx->isResized = 1;
1626 return SQLITE_OK;
1627 }
1628
1629 /*
1630 ** Estimate the total row width for a table.
1631 */
estimateTableWidth(Table * pTab)1632 static void estimateTableWidth(Table *pTab){
1633 unsigned wTable = 0;
1634 const Column *pTabCol;
1635 int i;
1636 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
1637 wTable += pTabCol->szEst;
1638 }
1639 if( pTab->iPKey<0 ) wTable++;
1640 pTab->szTabRow = sqlite3LogEst(wTable*4);
1641 }
1642
1643 /*
1644 ** Estimate the average size of a row for an index.
1645 */
estimateIndexWidth(Index * pIdx)1646 static void estimateIndexWidth(Index *pIdx){
1647 unsigned wIndex = 0;
1648 int i;
1649 const Column *aCol = pIdx->pTable->aCol;
1650 for(i=0; i<pIdx->nColumn; i++){
1651 i16 x = pIdx->aiColumn[i];
1652 assert( x<pIdx->pTable->nCol );
1653 wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
1654 }
1655 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
1656 }
1657
1658 /* Return true if value x is found any of the first nCol entries of aiCol[]
1659 */
hasColumn(const i16 * aiCol,int nCol,int x)1660 static int hasColumn(const i16 *aiCol, int nCol, int x){
1661 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
1662 return 0;
1663 }
1664
1665 /*
1666 ** This routine runs at the end of parsing a CREATE TABLE statement that
1667 ** has a WITHOUT ROWID clause. The job of this routine is to convert both
1668 ** internal schema data structures and the generated VDBE code so that they
1669 ** are appropriate for a WITHOUT ROWID table instead of a rowid table.
1670 ** Changes include:
1671 **
1672 ** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
1673 ** (2) Convert the OP_CreateTable into an OP_CreateIndex. There is
1674 ** no rowid btree for a WITHOUT ROWID. Instead, the canonical
1675 ** data storage is a covering index btree.
1676 ** (3) Bypass the creation of the sqlite_master table entry
1677 ** for the PRIMARY KEY as the primary key index is now
1678 ** identified by the sqlite_master table entry of the table itself.
1679 ** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
1680 ** schema to the rootpage from the main table.
1681 ** (5) Add all table columns to the PRIMARY KEY Index object
1682 ** so that the PRIMARY KEY is a covering index. The surplus
1683 ** columns are part of KeyInfo.nXField and are not used for
1684 ** sorting or lookup or uniqueness checks.
1685 ** (6) Replace the rowid tail on all automatically generated UNIQUE
1686 ** indices with the PRIMARY KEY columns.
1687 **
1688 ** For virtual tables, only (1) is performed.
1689 */
convertToWithoutRowidTable(Parse * pParse,Table * pTab)1690 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
1691 Index *pIdx;
1692 Index *pPk;
1693 int nPk;
1694 int i, j;
1695 sqlite3 *db = pParse->db;
1696 Vdbe *v = pParse->pVdbe;
1697
1698 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
1699 */
1700 if( !db->init.imposterTable ){
1701 for(i=0; i<pTab->nCol; i++){
1702 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){
1703 pTab->aCol[i].notNull = OE_Abort;
1704 }
1705 }
1706 }
1707
1708 /* The remaining transformations only apply to b-tree tables, not to
1709 ** virtual tables */
1710 if( IN_DECLARE_VTAB ) return;
1711
1712 /* Convert the OP_CreateTable opcode that would normally create the
1713 ** root-page for the table into an OP_CreateIndex opcode. The index
1714 ** created will become the PRIMARY KEY index.
1715 */
1716 if( pParse->addrCrTab ){
1717 assert( v );
1718 sqlite3VdbeChangeOpcode(v, pParse->addrCrTab, OP_CreateIndex);
1719 }
1720
1721 /* Locate the PRIMARY KEY index. Or, if this table was originally
1722 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
1723 */
1724 if( pTab->iPKey>=0 ){
1725 ExprList *pList;
1726 Token ipkToken;
1727 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
1728 pList = sqlite3ExprListAppend(pParse, 0,
1729 sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
1730 if( pList==0 ) return;
1731 pList->a[0].sortOrder = pParse->iPkSortOrder;
1732 assert( pParse->pNewTable==pTab );
1733 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
1734 SQLITE_IDXTYPE_PRIMARYKEY);
1735 if( db->mallocFailed ) return;
1736 pPk = sqlite3PrimaryKeyIndex(pTab);
1737 pTab->iPKey = -1;
1738 }else{
1739 pPk = sqlite3PrimaryKeyIndex(pTab);
1740
1741 /*
1742 ** Remove all redundant columns from the PRIMARY KEY. For example, change
1743 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
1744 ** code assumes the PRIMARY KEY contains no repeated columns.
1745 */
1746 for(i=j=1; i<pPk->nKeyCol; i++){
1747 if( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ){
1748 pPk->nColumn--;
1749 }else{
1750 pPk->aiColumn[j++] = pPk->aiColumn[i];
1751 }
1752 }
1753 pPk->nKeyCol = j;
1754 }
1755 assert( pPk!=0 );
1756 pPk->isCovering = 1;
1757 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
1758 nPk = pPk->nKeyCol;
1759
1760 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_master
1761 ** table entry. This is only required if currently generating VDBE
1762 ** code for a CREATE TABLE (not when parsing one as part of reading
1763 ** a database schema). */
1764 if( v && pPk->tnum>0 ){
1765 assert( db->init.busy==0 );
1766 sqlite3VdbeChangeOpcode(v, pPk->tnum, OP_Goto);
1767 }
1768
1769 /* The root page of the PRIMARY KEY is the table root page */
1770 pPk->tnum = pTab->tnum;
1771
1772 /* Update the in-memory representation of all UNIQUE indices by converting
1773 ** the final rowid column into one or more columns of the PRIMARY KEY.
1774 */
1775 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1776 int n;
1777 if( IsPrimaryKeyIndex(pIdx) ) continue;
1778 for(i=n=0; i<nPk; i++){
1779 if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ) n++;
1780 }
1781 if( n==0 ){
1782 /* This index is a superset of the primary key */
1783 pIdx->nColumn = pIdx->nKeyCol;
1784 continue;
1785 }
1786 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
1787 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
1788 if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ){
1789 pIdx->aiColumn[j] = pPk->aiColumn[i];
1790 pIdx->azColl[j] = pPk->azColl[i];
1791 j++;
1792 }
1793 }
1794 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
1795 assert( pIdx->nColumn>=j );
1796 }
1797
1798 /* Add all table columns to the PRIMARY KEY index
1799 */
1800 if( nPk<pTab->nCol ){
1801 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
1802 for(i=0, j=nPk; i<pTab->nCol; i++){
1803 if( !hasColumn(pPk->aiColumn, j, i) ){
1804 assert( j<pPk->nColumn );
1805 pPk->aiColumn[j] = i;
1806 pPk->azColl[j] = sqlite3StrBINARY;
1807 j++;
1808 }
1809 }
1810 assert( pPk->nColumn==j );
1811 assert( pTab->nCol==j );
1812 }else{
1813 pPk->nColumn = pTab->nCol;
1814 }
1815 }
1816
1817 /*
1818 ** This routine is called to report the final ")" that terminates
1819 ** a CREATE TABLE statement.
1820 **
1821 ** The table structure that other action routines have been building
1822 ** is added to the internal hash tables, assuming no errors have
1823 ** occurred.
1824 **
1825 ** An entry for the table is made in the master table on disk, unless
1826 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
1827 ** it means we are reading the sqlite_master table because we just
1828 ** connected to the database or because the sqlite_master table has
1829 ** recently changed, so the entry for this table already exists in
1830 ** the sqlite_master table. We do not want to create it again.
1831 **
1832 ** If the pSelect argument is not NULL, it means that this routine
1833 ** was called to create a table generated from a
1834 ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
1835 ** the new table will match the result set of the SELECT.
1836 */
sqlite3EndTable(Parse * pParse,Token * pCons,Token * pEnd,u8 tabOpts,Select * pSelect)1837 void sqlite3EndTable(
1838 Parse *pParse, /* Parse context */
1839 Token *pCons, /* The ',' token after the last column defn. */
1840 Token *pEnd, /* The ')' before options in the CREATE TABLE */
1841 u8 tabOpts, /* Extra table options. Usually 0. */
1842 Select *pSelect /* Select from a "CREATE ... AS SELECT" */
1843 ){
1844 Table *p; /* The new table */
1845 sqlite3 *db = pParse->db; /* The database connection */
1846 int iDb; /* Database in which the table lives */
1847 Index *pIdx; /* An implied index of the table */
1848
1849 if( pEnd==0 && pSelect==0 ){
1850 return;
1851 }
1852 assert( !db->mallocFailed );
1853 p = pParse->pNewTable;
1854 if( p==0 ) return;
1855
1856 assert( !db->init.busy || !pSelect );
1857
1858 /* If the db->init.busy is 1 it means we are reading the SQL off the
1859 ** "sqlite_master" or "sqlite_temp_master" table on the disk.
1860 ** So do not write to the disk again. Extract the root page number
1861 ** for the table from the db->init.newTnum field. (The page number
1862 ** should have been put there by the sqliteOpenCb routine.)
1863 **
1864 ** If the root page number is 1, that means this is the sqlite_master
1865 ** table itself. So mark it read-only.
1866 */
1867 if( db->init.busy ){
1868 p->tnum = db->init.newTnum;
1869 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
1870 }
1871
1872 /* Special processing for WITHOUT ROWID Tables */
1873 if( tabOpts & TF_WithoutRowid ){
1874 if( (p->tabFlags & TF_Autoincrement) ){
1875 sqlite3ErrorMsg(pParse,
1876 "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
1877 return;
1878 }
1879 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
1880 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
1881 }else{
1882 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
1883 convertToWithoutRowidTable(pParse, p);
1884 }
1885 }
1886
1887 iDb = sqlite3SchemaToIndex(db, p->pSchema);
1888
1889 #ifndef SQLITE_OMIT_CHECK
1890 /* Resolve names in all CHECK constraint expressions.
1891 */
1892 if( p->pCheck ){
1893 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
1894 }
1895 #endif /* !defined(SQLITE_OMIT_CHECK) */
1896
1897 /* Estimate the average row size for the table and for all implied indices */
1898 estimateTableWidth(p);
1899 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
1900 estimateIndexWidth(pIdx);
1901 }
1902
1903 /* If not initializing, then create a record for the new table
1904 ** in the SQLITE_MASTER table of the database.
1905 **
1906 ** If this is a TEMPORARY table, write the entry into the auxiliary
1907 ** file instead of into the main database file.
1908 */
1909 if( !db->init.busy ){
1910 int n;
1911 Vdbe *v;
1912 char *zType; /* "view" or "table" */
1913 char *zType2; /* "VIEW" or "TABLE" */
1914 char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
1915
1916 v = sqlite3GetVdbe(pParse);
1917 if( NEVER(v==0) ) return;
1918
1919 sqlite3VdbeAddOp1(v, OP_Close, 0);
1920
1921 /*
1922 ** Initialize zType for the new view or table.
1923 */
1924 if( p->pSelect==0 ){
1925 /* A regular table */
1926 zType = "table";
1927 zType2 = "TABLE";
1928 #ifndef SQLITE_OMIT_VIEW
1929 }else{
1930 /* A view */
1931 zType = "view";
1932 zType2 = "VIEW";
1933 #endif
1934 }
1935
1936 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
1937 ** statement to populate the new table. The root-page number for the
1938 ** new table is in register pParse->regRoot.
1939 **
1940 ** Once the SELECT has been coded by sqlite3Select(), it is in a
1941 ** suitable state to query for the column names and types to be used
1942 ** by the new table.
1943 **
1944 ** A shared-cache write-lock is not required to write to the new table,
1945 ** as a schema-lock must have already been obtained to create it. Since
1946 ** a schema-lock excludes all other database users, the write-lock would
1947 ** be redundant.
1948 */
1949 if( pSelect ){
1950 SelectDest dest; /* Where the SELECT should store results */
1951 int regYield; /* Register holding co-routine entry-point */
1952 int addrTop; /* Top of the co-routine */
1953 int regRec; /* A record to be insert into the new table */
1954 int regRowid; /* Rowid of the next row to insert */
1955 int addrInsLoop; /* Top of the loop for inserting rows */
1956 Table *pSelTab; /* A table that describes the SELECT results */
1957
1958 regYield = ++pParse->nMem;
1959 regRec = ++pParse->nMem;
1960 regRowid = ++pParse->nMem;
1961 assert(pParse->nTab==1);
1962 sqlite3MayAbort(pParse);
1963 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
1964 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
1965 pParse->nTab = 2;
1966 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
1967 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
1968 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
1969 sqlite3Select(pParse, pSelect, &dest);
1970 sqlite3VdbeEndCoroutine(v, regYield);
1971 sqlite3VdbeJumpHere(v, addrTop - 1);
1972 if( pParse->nErr ) return;
1973 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
1974 if( pSelTab==0 ) return;
1975 assert( p->aCol==0 );
1976 p->nCol = pSelTab->nCol;
1977 p->aCol = pSelTab->aCol;
1978 pSelTab->nCol = 0;
1979 pSelTab->aCol = 0;
1980 sqlite3DeleteTable(db, pSelTab);
1981 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
1982 VdbeCoverage(v);
1983 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
1984 sqlite3TableAffinity(v, p, 0);
1985 sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
1986 sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
1987 sqlite3VdbeGoto(v, addrInsLoop);
1988 sqlite3VdbeJumpHere(v, addrInsLoop);
1989 sqlite3VdbeAddOp1(v, OP_Close, 1);
1990 }
1991
1992 /* Compute the complete text of the CREATE statement */
1993 if( pSelect ){
1994 zStmt = createTableStmt(db, p);
1995 }else{
1996 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
1997 n = (int)(pEnd2->z - pParse->sNameToken.z);
1998 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
1999 zStmt = sqlite3MPrintf(db,
2000 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
2001 );
2002 }
2003
2004 /* A slot for the record has already been allocated in the
2005 ** SQLITE_MASTER table. We just need to update that slot with all
2006 ** the information we've collected.
2007 */
2008 sqlite3NestedParse(pParse,
2009 "UPDATE %Q.%s "
2010 "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
2011 "WHERE rowid=#%d",
2012 db->aDb[iDb].zDbSName, MASTER_NAME,
2013 zType,
2014 p->zName,
2015 p->zName,
2016 pParse->regRoot,
2017 zStmt,
2018 pParse->regRowid
2019 );
2020 sqlite3DbFree(db, zStmt);
2021 sqlite3ChangeCookie(pParse, iDb);
2022
2023 #ifndef SQLITE_OMIT_AUTOINCREMENT
2024 /* Check to see if we need to create an sqlite_sequence table for
2025 ** keeping track of autoincrement keys.
2026 */
2027 if( (p->tabFlags & TF_Autoincrement)!=0 ){
2028 Db *pDb = &db->aDb[iDb];
2029 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2030 if( pDb->pSchema->pSeqTab==0 ){
2031 sqlite3NestedParse(pParse,
2032 "CREATE TABLE %Q.sqlite_sequence(name,seq)",
2033 pDb->zDbSName
2034 );
2035 }
2036 }
2037 #endif
2038
2039 /* Reparse everything to update our internal data structures */
2040 sqlite3VdbeAddParseSchemaOp(v, iDb,
2041 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
2042 }
2043
2044
2045 /* Add the table to the in-memory representation of the database.
2046 */
2047 if( db->init.busy ){
2048 Table *pOld;
2049 Schema *pSchema = p->pSchema;
2050 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2051 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
2052 if( pOld ){
2053 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
2054 sqlite3OomFault(db);
2055 return;
2056 }
2057 pParse->pNewTable = 0;
2058 db->flags |= SQLITE_InternChanges;
2059
2060 #ifndef SQLITE_OMIT_ALTERTABLE
2061 if( !p->pSelect ){
2062 const char *zName = (const char *)pParse->sNameToken.z;
2063 int nName;
2064 assert( !pSelect && pCons && pEnd );
2065 if( pCons->z==0 ){
2066 pCons = pEnd;
2067 }
2068 nName = (int)((const char *)pCons->z - zName);
2069 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
2070 }
2071 #endif
2072 }
2073 }
2074
2075 #ifndef SQLITE_OMIT_VIEW
2076 /*
2077 ** The parser calls this routine in order to create a new VIEW
2078 */
sqlite3CreateView(Parse * pParse,Token * pBegin,Token * pName1,Token * pName2,ExprList * pCNames,Select * pSelect,int isTemp,int noErr)2079 void sqlite3CreateView(
2080 Parse *pParse, /* The parsing context */
2081 Token *pBegin, /* The CREATE token that begins the statement */
2082 Token *pName1, /* The token that holds the name of the view */
2083 Token *pName2, /* The token that holds the name of the view */
2084 ExprList *pCNames, /* Optional list of view column names */
2085 Select *pSelect, /* A SELECT statement that will become the new view */
2086 int isTemp, /* TRUE for a TEMPORARY view */
2087 int noErr /* Suppress error messages if VIEW already exists */
2088 ){
2089 Table *p;
2090 int n;
2091 const char *z;
2092 Token sEnd;
2093 DbFixer sFix;
2094 Token *pName = 0;
2095 int iDb;
2096 sqlite3 *db = pParse->db;
2097
2098 if( pParse->nVar>0 ){
2099 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
2100 goto create_view_fail;
2101 }
2102 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
2103 p = pParse->pNewTable;
2104 if( p==0 || pParse->nErr ) goto create_view_fail;
2105 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
2106 iDb = sqlite3SchemaToIndex(db, p->pSchema);
2107 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
2108 if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
2109
2110 /* Make a copy of the entire SELECT statement that defines the view.
2111 ** This will force all the Expr.token.z values to be dynamically
2112 ** allocated rather than point to the input string - which means that
2113 ** they will persist after the current sqlite3_exec() call returns.
2114 */
2115 p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
2116 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
2117 if( db->mallocFailed ) goto create_view_fail;
2118
2119 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
2120 ** the end.
2121 */
2122 sEnd = pParse->sLastToken;
2123 assert( sEnd.z[0]!=0 );
2124 if( sEnd.z[0]!=';' ){
2125 sEnd.z += sEnd.n;
2126 }
2127 sEnd.n = 0;
2128 n = (int)(sEnd.z - pBegin->z);
2129 assert( n>0 );
2130 z = pBegin->z;
2131 while( sqlite3Isspace(z[n-1]) ){ n--; }
2132 sEnd.z = &z[n-1];
2133 sEnd.n = 1;
2134
2135 /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
2136 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
2137
2138 create_view_fail:
2139 sqlite3SelectDelete(db, pSelect);
2140 sqlite3ExprListDelete(db, pCNames);
2141 return;
2142 }
2143 #endif /* SQLITE_OMIT_VIEW */
2144
2145 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
2146 /*
2147 ** The Table structure pTable is really a VIEW. Fill in the names of
2148 ** the columns of the view in the pTable structure. Return the number
2149 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
2150 */
sqlite3ViewGetColumnNames(Parse * pParse,Table * pTable)2151 int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
2152 Table *pSelTab; /* A fake table from which we get the result set */
2153 Select *pSel; /* Copy of the SELECT that implements the view */
2154 int nErr = 0; /* Number of errors encountered */
2155 int n; /* Temporarily holds the number of cursors assigned */
2156 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
2157 #ifndef SQLITE_OMIT_AUTHORIZATION
2158 sqlite3_xauth xAuth; /* Saved xAuth pointer */
2159 #endif
2160
2161 assert( pTable );
2162
2163 #ifndef SQLITE_OMIT_VIRTUALTABLE
2164 if( sqlite3VtabCallConnect(pParse, pTable) ){
2165 return SQLITE_ERROR;
2166 }
2167 if( IsVirtual(pTable) ) return 0;
2168 #endif
2169
2170 #ifndef SQLITE_OMIT_VIEW
2171 /* A positive nCol means the columns names for this view are
2172 ** already known.
2173 */
2174 if( pTable->nCol>0 ) return 0;
2175
2176 /* A negative nCol is a special marker meaning that we are currently
2177 ** trying to compute the column names. If we enter this routine with
2178 ** a negative nCol, it means two or more views form a loop, like this:
2179 **
2180 ** CREATE VIEW one AS SELECT * FROM two;
2181 ** CREATE VIEW two AS SELECT * FROM one;
2182 **
2183 ** Actually, the error above is now caught prior to reaching this point.
2184 ** But the following test is still important as it does come up
2185 ** in the following:
2186 **
2187 ** CREATE TABLE main.ex1(a);
2188 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
2189 ** SELECT * FROM temp.ex1;
2190 */
2191 if( pTable->nCol<0 ){
2192 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
2193 return 1;
2194 }
2195 assert( pTable->nCol>=0 );
2196
2197 /* If we get this far, it means we need to compute the table names.
2198 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
2199 ** "*" elements in the results set of the view and will assign cursors
2200 ** to the elements of the FROM clause. But we do not want these changes
2201 ** to be permanent. So the computation is done on a copy of the SELECT
2202 ** statement that defines the view.
2203 */
2204 assert( pTable->pSelect );
2205 pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
2206 if( pSel ){
2207 n = pParse->nTab;
2208 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
2209 pTable->nCol = -1;
2210 db->lookaside.bDisable++;
2211 #ifndef SQLITE_OMIT_AUTHORIZATION
2212 xAuth = db->xAuth;
2213 db->xAuth = 0;
2214 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
2215 db->xAuth = xAuth;
2216 #else
2217 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
2218 #endif
2219 pParse->nTab = n;
2220 if( pTable->pCheck ){
2221 /* CREATE VIEW name(arglist) AS ...
2222 ** The names of the columns in the table are taken from
2223 ** arglist which is stored in pTable->pCheck. The pCheck field
2224 ** normally holds CHECK constraints on an ordinary table, but for
2225 ** a VIEW it holds the list of column names.
2226 */
2227 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
2228 &pTable->nCol, &pTable->aCol);
2229 if( db->mallocFailed==0
2230 && pParse->nErr==0
2231 && pTable->nCol==pSel->pEList->nExpr
2232 ){
2233 sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel);
2234 }
2235 }else if( pSelTab ){
2236 /* CREATE VIEW name AS... without an argument list. Construct
2237 ** the column names from the SELECT statement that defines the view.
2238 */
2239 assert( pTable->aCol==0 );
2240 pTable->nCol = pSelTab->nCol;
2241 pTable->aCol = pSelTab->aCol;
2242 pSelTab->nCol = 0;
2243 pSelTab->aCol = 0;
2244 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
2245 }else{
2246 pTable->nCol = 0;
2247 nErr++;
2248 }
2249 sqlite3DeleteTable(db, pSelTab);
2250 sqlite3SelectDelete(db, pSel);
2251 db->lookaside.bDisable--;
2252 } else {
2253 nErr++;
2254 }
2255 pTable->pSchema->schemaFlags |= DB_UnresetViews;
2256 #endif /* SQLITE_OMIT_VIEW */
2257 return nErr;
2258 }
2259 #endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
2260
2261 #ifndef SQLITE_OMIT_VIEW
2262 /*
2263 ** Clear the column names from every VIEW in database idx.
2264 */
sqliteViewResetAll(sqlite3 * db,int idx)2265 static void sqliteViewResetAll(sqlite3 *db, int idx){
2266 HashElem *i;
2267 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
2268 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
2269 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
2270 Table *pTab = sqliteHashData(i);
2271 if( pTab->pSelect ){
2272 sqlite3DeleteColumnNames(db, pTab);
2273 pTab->aCol = 0;
2274 pTab->nCol = 0;
2275 }
2276 }
2277 DbClearProperty(db, idx, DB_UnresetViews);
2278 }
2279 #else
2280 # define sqliteViewResetAll(A,B)
2281 #endif /* SQLITE_OMIT_VIEW */
2282
2283 /*
2284 ** This function is called by the VDBE to adjust the internal schema
2285 ** used by SQLite when the btree layer moves a table root page. The
2286 ** root-page of a table or index in database iDb has changed from iFrom
2287 ** to iTo.
2288 **
2289 ** Ticket #1728: The symbol table might still contain information
2290 ** on tables and/or indices that are the process of being deleted.
2291 ** If you are unlucky, one of those deleted indices or tables might
2292 ** have the same rootpage number as the real table or index that is
2293 ** being moved. So we cannot stop searching after the first match
2294 ** because the first match might be for one of the deleted indices
2295 ** or tables and not the table/index that is actually being moved.
2296 ** We must continue looping until all tables and indices with
2297 ** rootpage==iFrom have been converted to have a rootpage of iTo
2298 ** in order to be certain that we got the right one.
2299 */
2300 #ifndef SQLITE_OMIT_AUTOVACUUM
sqlite3RootPageMoved(sqlite3 * db,int iDb,int iFrom,int iTo)2301 void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
2302 HashElem *pElem;
2303 Hash *pHash;
2304 Db *pDb;
2305
2306 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
2307 pDb = &db->aDb[iDb];
2308 pHash = &pDb->pSchema->tblHash;
2309 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
2310 Table *pTab = sqliteHashData(pElem);
2311 if( pTab->tnum==iFrom ){
2312 pTab->tnum = iTo;
2313 }
2314 }
2315 pHash = &pDb->pSchema->idxHash;
2316 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
2317 Index *pIdx = sqliteHashData(pElem);
2318 if( pIdx->tnum==iFrom ){
2319 pIdx->tnum = iTo;
2320 }
2321 }
2322 }
2323 #endif
2324
2325 /*
2326 ** Write code to erase the table with root-page iTable from database iDb.
2327 ** Also write code to modify the sqlite_master table and internal schema
2328 ** if a root-page of another table is moved by the btree-layer whilst
2329 ** erasing iTable (this can happen with an auto-vacuum database).
2330 */
destroyRootPage(Parse * pParse,int iTable,int iDb)2331 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
2332 Vdbe *v = sqlite3GetVdbe(pParse);
2333 int r1 = sqlite3GetTempReg(pParse);
2334 assert( iTable>1 );
2335 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
2336 sqlite3MayAbort(pParse);
2337 #ifndef SQLITE_OMIT_AUTOVACUUM
2338 /* OP_Destroy stores an in integer r1. If this integer
2339 ** is non-zero, then it is the root page number of a table moved to
2340 ** location iTable. The following code modifies the sqlite_master table to
2341 ** reflect this.
2342 **
2343 ** The "#NNN" in the SQL is a special constant that means whatever value
2344 ** is in register NNN. See grammar rules associated with the TK_REGISTER
2345 ** token for additional information.
2346 */
2347 sqlite3NestedParse(pParse,
2348 "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
2349 pParse->db->aDb[iDb].zDbSName, MASTER_NAME, iTable, r1, r1);
2350 #endif
2351 sqlite3ReleaseTempReg(pParse, r1);
2352 }
2353
2354 /*
2355 ** Write VDBE code to erase table pTab and all associated indices on disk.
2356 ** Code to update the sqlite_master tables and internal schema definitions
2357 ** in case a root-page belonging to another table is moved by the btree layer
2358 ** is also added (this can happen with an auto-vacuum database).
2359 */
destroyTable(Parse * pParse,Table * pTab)2360 static void destroyTable(Parse *pParse, Table *pTab){
2361 #ifdef SQLITE_OMIT_AUTOVACUUM
2362 Index *pIdx;
2363 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
2364 destroyRootPage(pParse, pTab->tnum, iDb);
2365 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2366 destroyRootPage(pParse, pIdx->tnum, iDb);
2367 }
2368 #else
2369 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
2370 ** is not defined), then it is important to call OP_Destroy on the
2371 ** table and index root-pages in order, starting with the numerically
2372 ** largest root-page number. This guarantees that none of the root-pages
2373 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
2374 ** following were coded:
2375 **
2376 ** OP_Destroy 4 0
2377 ** ...
2378 ** OP_Destroy 5 0
2379 **
2380 ** and root page 5 happened to be the largest root-page number in the
2381 ** database, then root page 5 would be moved to page 4 by the
2382 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
2383 ** a free-list page.
2384 */
2385 int iTab = pTab->tnum;
2386 int iDestroyed = 0;
2387
2388 while( 1 ){
2389 Index *pIdx;
2390 int iLargest = 0;
2391
2392 if( iDestroyed==0 || iTab<iDestroyed ){
2393 iLargest = iTab;
2394 }
2395 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
2396 int iIdx = pIdx->tnum;
2397 assert( pIdx->pSchema==pTab->pSchema );
2398 if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
2399 iLargest = iIdx;
2400 }
2401 }
2402 if( iLargest==0 ){
2403 return;
2404 }else{
2405 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
2406 assert( iDb>=0 && iDb<pParse->db->nDb );
2407 destroyRootPage(pParse, iLargest, iDb);
2408 iDestroyed = iLargest;
2409 }
2410 }
2411 #endif
2412 }
2413
2414 /*
2415 ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
2416 ** after a DROP INDEX or DROP TABLE command.
2417 */
sqlite3ClearStatTables(Parse * pParse,int iDb,const char * zType,const char * zName)2418 static void sqlite3ClearStatTables(
2419 Parse *pParse, /* The parsing context */
2420 int iDb, /* The database number */
2421 const char *zType, /* "idx" or "tbl" */
2422 const char *zName /* Name of index or table */
2423 ){
2424 int i;
2425 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
2426 for(i=1; i<=4; i++){
2427 char zTab[24];
2428 sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
2429 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
2430 sqlite3NestedParse(pParse,
2431 "DELETE FROM %Q.%s WHERE %s=%Q",
2432 zDbName, zTab, zType, zName
2433 );
2434 }
2435 }
2436 }
2437
2438 /*
2439 ** Generate code to drop a table.
2440 */
sqlite3CodeDropTable(Parse * pParse,Table * pTab,int iDb,int isView)2441 void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
2442 Vdbe *v;
2443 sqlite3 *db = pParse->db;
2444 Trigger *pTrigger;
2445 Db *pDb = &db->aDb[iDb];
2446
2447 v = sqlite3GetVdbe(pParse);
2448 assert( v!=0 );
2449 sqlite3BeginWriteOperation(pParse, 1, iDb);
2450
2451 #ifndef SQLITE_OMIT_VIRTUALTABLE
2452 if( IsVirtual(pTab) ){
2453 sqlite3VdbeAddOp0(v, OP_VBegin);
2454 }
2455 #endif
2456
2457 /* Drop all triggers associated with the table being dropped. Code
2458 ** is generated to remove entries from sqlite_master and/or
2459 ** sqlite_temp_master if required.
2460 */
2461 pTrigger = sqlite3TriggerList(pParse, pTab);
2462 while( pTrigger ){
2463 assert( pTrigger->pSchema==pTab->pSchema ||
2464 pTrigger->pSchema==db->aDb[1].pSchema );
2465 sqlite3DropTriggerPtr(pParse, pTrigger);
2466 pTrigger = pTrigger->pNext;
2467 }
2468
2469 #ifndef SQLITE_OMIT_AUTOINCREMENT
2470 /* Remove any entries of the sqlite_sequence table associated with
2471 ** the table being dropped. This is done before the table is dropped
2472 ** at the btree level, in case the sqlite_sequence table needs to
2473 ** move as a result of the drop (can happen in auto-vacuum mode).
2474 */
2475 if( pTab->tabFlags & TF_Autoincrement ){
2476 sqlite3NestedParse(pParse,
2477 "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
2478 pDb->zDbSName, pTab->zName
2479 );
2480 }
2481 #endif
2482
2483 /* Drop all SQLITE_MASTER table and index entries that refer to the
2484 ** table. The program name loops through the master table and deletes
2485 ** every row that refers to a table of the same name as the one being
2486 ** dropped. Triggers are handled separately because a trigger can be
2487 ** created in the temp database that refers to a table in another
2488 ** database.
2489 */
2490 sqlite3NestedParse(pParse,
2491 "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
2492 pDb->zDbSName, MASTER_NAME, pTab->zName);
2493 if( !isView && !IsVirtual(pTab) ){
2494 destroyTable(pParse, pTab);
2495 }
2496
2497 /* Remove the table entry from SQLite's internal schema and modify
2498 ** the schema cookie.
2499 */
2500 if( IsVirtual(pTab) ){
2501 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
2502 }
2503 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
2504 sqlite3ChangeCookie(pParse, iDb);
2505 sqliteViewResetAll(db, iDb);
2506 }
2507
2508 /*
2509 ** This routine is called to do the work of a DROP TABLE statement.
2510 ** pName is the name of the table to be dropped.
2511 */
sqlite3DropTable(Parse * pParse,SrcList * pName,int isView,int noErr)2512 void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
2513 Table *pTab;
2514 Vdbe *v;
2515 sqlite3 *db = pParse->db;
2516 int iDb;
2517
2518 if( db->mallocFailed ){
2519 goto exit_drop_table;
2520 }
2521 assert( pParse->nErr==0 );
2522 assert( pName->nSrc==1 );
2523 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
2524 if( noErr ) db->suppressErr++;
2525 assert( isView==0 || isView==LOCATE_VIEW );
2526 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
2527 if( noErr ) db->suppressErr--;
2528
2529 if( pTab==0 ){
2530 if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
2531 goto exit_drop_table;
2532 }
2533 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
2534 assert( iDb>=0 && iDb<db->nDb );
2535
2536 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
2537 ** it is initialized.
2538 */
2539 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
2540 goto exit_drop_table;
2541 }
2542 #ifndef SQLITE_OMIT_AUTHORIZATION
2543 {
2544 int code;
2545 const char *zTab = SCHEMA_TABLE(iDb);
2546 const char *zDb = db->aDb[iDb].zDbSName;
2547 const char *zArg2 = 0;
2548 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
2549 goto exit_drop_table;
2550 }
2551 if( isView ){
2552 if( !OMIT_TEMPDB && iDb==1 ){
2553 code = SQLITE_DROP_TEMP_VIEW;
2554 }else{
2555 code = SQLITE_DROP_VIEW;
2556 }
2557 #ifndef SQLITE_OMIT_VIRTUALTABLE
2558 }else if( IsVirtual(pTab) ){
2559 code = SQLITE_DROP_VTABLE;
2560 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
2561 #endif
2562 }else{
2563 if( !OMIT_TEMPDB && iDb==1 ){
2564 code = SQLITE_DROP_TEMP_TABLE;
2565 }else{
2566 code = SQLITE_DROP_TABLE;
2567 }
2568 }
2569 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
2570 goto exit_drop_table;
2571 }
2572 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
2573 goto exit_drop_table;
2574 }
2575 }
2576 #endif
2577 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
2578 && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
2579 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
2580 goto exit_drop_table;
2581 }
2582
2583 #ifndef SQLITE_OMIT_VIEW
2584 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
2585 ** on a table.
2586 */
2587 if( isView && pTab->pSelect==0 ){
2588 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
2589 goto exit_drop_table;
2590 }
2591 if( !isView && pTab->pSelect ){
2592 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
2593 goto exit_drop_table;
2594 }
2595 #endif
2596
2597 /* Generate code to remove the table from the master table
2598 ** on disk.
2599 */
2600 v = sqlite3GetVdbe(pParse);
2601 if( v ){
2602 sqlite3BeginWriteOperation(pParse, 1, iDb);
2603 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
2604 sqlite3FkDropTable(pParse, pName, pTab);
2605 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
2606 }
2607
2608 exit_drop_table:
2609 sqlite3SrcListDelete(db, pName);
2610 }
2611
2612 /*
2613 ** This routine is called to create a new foreign key on the table
2614 ** currently under construction. pFromCol determines which columns
2615 ** in the current table point to the foreign key. If pFromCol==0 then
2616 ** connect the key to the last column inserted. pTo is the name of
2617 ** the table referred to (a.k.a the "parent" table). pToCol is a list
2618 ** of tables in the parent pTo table. flags contains all
2619 ** information about the conflict resolution algorithms specified
2620 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
2621 **
2622 ** An FKey structure is created and added to the table currently
2623 ** under construction in the pParse->pNewTable field.
2624 **
2625 ** The foreign key is set for IMMEDIATE processing. A subsequent call
2626 ** to sqlite3DeferForeignKey() might change this to DEFERRED.
2627 */
sqlite3CreateForeignKey(Parse * pParse,ExprList * pFromCol,Token * pTo,ExprList * pToCol,int flags)2628 void sqlite3CreateForeignKey(
2629 Parse *pParse, /* Parsing context */
2630 ExprList *pFromCol, /* Columns in this table that point to other table */
2631 Token *pTo, /* Name of the other table */
2632 ExprList *pToCol, /* Columns in the other table */
2633 int flags /* Conflict resolution algorithms. */
2634 ){
2635 sqlite3 *db = pParse->db;
2636 #ifndef SQLITE_OMIT_FOREIGN_KEY
2637 FKey *pFKey = 0;
2638 FKey *pNextTo;
2639 Table *p = pParse->pNewTable;
2640 int nByte;
2641 int i;
2642 int nCol;
2643 char *z;
2644
2645 assert( pTo!=0 );
2646 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
2647 if( pFromCol==0 ){
2648 int iCol = p->nCol-1;
2649 if( NEVER(iCol<0) ) goto fk_end;
2650 if( pToCol && pToCol->nExpr!=1 ){
2651 sqlite3ErrorMsg(pParse, "foreign key on %s"
2652 " should reference only one column of table %T",
2653 p->aCol[iCol].zName, pTo);
2654 goto fk_end;
2655 }
2656 nCol = 1;
2657 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
2658 sqlite3ErrorMsg(pParse,
2659 "number of columns in foreign key does not match the number of "
2660 "columns in the referenced table");
2661 goto fk_end;
2662 }else{
2663 nCol = pFromCol->nExpr;
2664 }
2665 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
2666 if( pToCol ){
2667 for(i=0; i<pToCol->nExpr; i++){
2668 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
2669 }
2670 }
2671 pFKey = sqlite3DbMallocZero(db, nByte );
2672 if( pFKey==0 ){
2673 goto fk_end;
2674 }
2675 pFKey->pFrom = p;
2676 pFKey->pNextFrom = p->pFKey;
2677 z = (char*)&pFKey->aCol[nCol];
2678 pFKey->zTo = z;
2679 memcpy(z, pTo->z, pTo->n);
2680 z[pTo->n] = 0;
2681 sqlite3Dequote(z);
2682 z += pTo->n+1;
2683 pFKey->nCol = nCol;
2684 if( pFromCol==0 ){
2685 pFKey->aCol[0].iFrom = p->nCol-1;
2686 }else{
2687 for(i=0; i<nCol; i++){
2688 int j;
2689 for(j=0; j<p->nCol; j++){
2690 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
2691 pFKey->aCol[i].iFrom = j;
2692 break;
2693 }
2694 }
2695 if( j>=p->nCol ){
2696 sqlite3ErrorMsg(pParse,
2697 "unknown column \"%s\" in foreign key definition",
2698 pFromCol->a[i].zName);
2699 goto fk_end;
2700 }
2701 }
2702 }
2703 if( pToCol ){
2704 for(i=0; i<nCol; i++){
2705 int n = sqlite3Strlen30(pToCol->a[i].zName);
2706 pFKey->aCol[i].zCol = z;
2707 memcpy(z, pToCol->a[i].zName, n);
2708 z[n] = 0;
2709 z += n+1;
2710 }
2711 }
2712 pFKey->isDeferred = 0;
2713 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
2714 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
2715
2716 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
2717 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
2718 pFKey->zTo, (void *)pFKey
2719 );
2720 if( pNextTo==pFKey ){
2721 sqlite3OomFault(db);
2722 goto fk_end;
2723 }
2724 if( pNextTo ){
2725 assert( pNextTo->pPrevTo==0 );
2726 pFKey->pNextTo = pNextTo;
2727 pNextTo->pPrevTo = pFKey;
2728 }
2729
2730 /* Link the foreign key to the table as the last step.
2731 */
2732 p->pFKey = pFKey;
2733 pFKey = 0;
2734
2735 fk_end:
2736 sqlite3DbFree(db, pFKey);
2737 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
2738 sqlite3ExprListDelete(db, pFromCol);
2739 sqlite3ExprListDelete(db, pToCol);
2740 }
2741
2742 /*
2743 ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
2744 ** clause is seen as part of a foreign key definition. The isDeferred
2745 ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
2746 ** The behavior of the most recently created foreign key is adjusted
2747 ** accordingly.
2748 */
sqlite3DeferForeignKey(Parse * pParse,int isDeferred)2749 void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
2750 #ifndef SQLITE_OMIT_FOREIGN_KEY
2751 Table *pTab;
2752 FKey *pFKey;
2753 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
2754 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
2755 pFKey->isDeferred = (u8)isDeferred;
2756 #endif
2757 }
2758
2759 /*
2760 ** Generate code that will erase and refill index *pIdx. This is
2761 ** used to initialize a newly created index or to recompute the
2762 ** content of an index in response to a REINDEX command.
2763 **
2764 ** if memRootPage is not negative, it means that the index is newly
2765 ** created. The register specified by memRootPage contains the
2766 ** root page number of the index. If memRootPage is negative, then
2767 ** the index already exists and must be cleared before being refilled and
2768 ** the root page number of the index is taken from pIndex->tnum.
2769 */
sqlite3RefillIndex(Parse * pParse,Index * pIndex,int memRootPage)2770 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
2771 Table *pTab = pIndex->pTable; /* The table that is indexed */
2772 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
2773 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
2774 int iSorter; /* Cursor opened by OpenSorter (if in use) */
2775 int addr1; /* Address of top of loop */
2776 int addr2; /* Address to jump to for next iteration */
2777 int tnum; /* Root page of index */
2778 int iPartIdxLabel; /* Jump to this label to skip a row */
2779 Vdbe *v; /* Generate code into this virtual machine */
2780 KeyInfo *pKey; /* KeyInfo for index */
2781 int regRecord; /* Register holding assembled index record */
2782 sqlite3 *db = pParse->db; /* The database connection */
2783 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
2784
2785 #ifndef SQLITE_OMIT_AUTHORIZATION
2786 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
2787 db->aDb[iDb].zDbSName ) ){
2788 return;
2789 }
2790 #endif
2791
2792 /* Require a write-lock on the table to perform this operation */
2793 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
2794
2795 v = sqlite3GetVdbe(pParse);
2796 if( v==0 ) return;
2797 if( memRootPage>=0 ){
2798 tnum = memRootPage;
2799 }else{
2800 tnum = pIndex->tnum;
2801 }
2802 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
2803 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
2804
2805 /* Open the sorter cursor if we are to use one. */
2806 iSorter = pParse->nTab++;
2807 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
2808 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
2809
2810 /* Open the table. Loop through all rows of the table, inserting index
2811 ** records into the sorter. */
2812 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
2813 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
2814 regRecord = sqlite3GetTempReg(pParse);
2815
2816 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
2817 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
2818 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
2819 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
2820 sqlite3VdbeJumpHere(v, addr1);
2821 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
2822 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
2823 (char *)pKey, P4_KEYINFO);
2824 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
2825
2826 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
2827 if( IsUniqueIndex(pIndex) ){
2828 int j2 = sqlite3VdbeCurrentAddr(v) + 3;
2829 sqlite3VdbeGoto(v, j2);
2830 addr2 = sqlite3VdbeCurrentAddr(v);
2831 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
2832 pIndex->nKeyCol); VdbeCoverage(v);
2833 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
2834 }else{
2835 addr2 = sqlite3VdbeCurrentAddr(v);
2836 }
2837 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
2838 sqlite3VdbeAddOp3(v, OP_Last, iIdx, 0, -1);
2839 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
2840 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
2841 sqlite3ReleaseTempReg(pParse, regRecord);
2842 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
2843 sqlite3VdbeJumpHere(v, addr1);
2844
2845 sqlite3VdbeAddOp1(v, OP_Close, iTab);
2846 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
2847 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
2848 }
2849
2850 /*
2851 ** Allocate heap space to hold an Index object with nCol columns.
2852 **
2853 ** Increase the allocation size to provide an extra nExtra bytes
2854 ** of 8-byte aligned space after the Index object and return a
2855 ** pointer to this extra space in *ppExtra.
2856 */
sqlite3AllocateIndexObject(sqlite3 * db,i16 nCol,int nExtra,char ** ppExtra)2857 Index *sqlite3AllocateIndexObject(
2858 sqlite3 *db, /* Database connection */
2859 i16 nCol, /* Total number of columns in the index */
2860 int nExtra, /* Number of bytes of extra space to alloc */
2861 char **ppExtra /* Pointer to the "extra" space */
2862 ){
2863 Index *p; /* Allocated index object */
2864 int nByte; /* Bytes of space for Index object + arrays */
2865
2866 nByte = ROUND8(sizeof(Index)) + /* Index structure */
2867 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
2868 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
2869 sizeof(i16)*nCol + /* Index.aiColumn */
2870 sizeof(u8)*nCol); /* Index.aSortOrder */
2871 p = sqlite3DbMallocZero(db, nByte + nExtra);
2872 if( p ){
2873 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
2874 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
2875 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
2876 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
2877 p->aSortOrder = (u8*)pExtra;
2878 p->nColumn = nCol;
2879 p->nKeyCol = nCol - 1;
2880 *ppExtra = ((char*)p) + nByte;
2881 }
2882 return p;
2883 }
2884
2885 /*
2886 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
2887 ** and pTblList is the name of the table that is to be indexed. Both will
2888 ** be NULL for a primary key or an index that is created to satisfy a
2889 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
2890 ** as the table to be indexed. pParse->pNewTable is a table that is
2891 ** currently being constructed by a CREATE TABLE statement.
2892 **
2893 ** pList is a list of columns to be indexed. pList will be NULL if this
2894 ** is a primary key or unique-constraint on the most recent column added
2895 ** to the table currently under construction.
2896 */
sqlite3CreateIndex(Parse * pParse,Token * pName1,Token * pName2,SrcList * pTblName,ExprList * pList,int onError,Token * pStart,Expr * pPIWhere,int sortOrder,int ifNotExist,u8 idxType)2897 void sqlite3CreateIndex(
2898 Parse *pParse, /* All information about this parse */
2899 Token *pName1, /* First part of index name. May be NULL */
2900 Token *pName2, /* Second part of index name. May be NULL */
2901 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
2902 ExprList *pList, /* A list of columns to be indexed */
2903 int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
2904 Token *pStart, /* The CREATE token that begins this statement */
2905 Expr *pPIWhere, /* WHERE clause for partial indices */
2906 int sortOrder, /* Sort order of primary key when pList==NULL */
2907 int ifNotExist, /* Omit error if index already exists */
2908 u8 idxType /* The index type */
2909 ){
2910 Table *pTab = 0; /* Table to be indexed */
2911 Index *pIndex = 0; /* The index to be created */
2912 char *zName = 0; /* Name of the index */
2913 int nName; /* Number of characters in zName */
2914 int i, j;
2915 DbFixer sFix; /* For assigning database names to pTable */
2916 int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
2917 sqlite3 *db = pParse->db;
2918 Db *pDb; /* The specific table containing the indexed database */
2919 int iDb; /* Index of the database that is being written */
2920 Token *pName = 0; /* Unqualified name of the index to create */
2921 struct ExprList_item *pListItem; /* For looping over pList */
2922 int nExtra = 0; /* Space allocated for zExtra[] */
2923 int nExtraCol; /* Number of extra columns needed */
2924 char *zExtra = 0; /* Extra space after the Index object */
2925 Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
2926
2927 if( db->mallocFailed || pParse->nErr>0 ){
2928 goto exit_create_index;
2929 }
2930 if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
2931 goto exit_create_index;
2932 }
2933 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
2934 goto exit_create_index;
2935 }
2936
2937 /*
2938 ** Find the table that is to be indexed. Return early if not found.
2939 */
2940 if( pTblName!=0 ){
2941
2942 /* Use the two-part index name to determine the database
2943 ** to search for the table. 'Fix' the table name to this db
2944 ** before looking up the table.
2945 */
2946 assert( pName1 && pName2 );
2947 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
2948 if( iDb<0 ) goto exit_create_index;
2949 assert( pName && pName->z );
2950
2951 #ifndef SQLITE_OMIT_TEMPDB
2952 /* If the index name was unqualified, check if the table
2953 ** is a temp table. If so, set the database to 1. Do not do this
2954 ** if initialising a database schema.
2955 */
2956 if( !db->init.busy ){
2957 pTab = sqlite3SrcListLookup(pParse, pTblName);
2958 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
2959 iDb = 1;
2960 }
2961 }
2962 #endif
2963
2964 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
2965 if( sqlite3FixSrcList(&sFix, pTblName) ){
2966 /* Because the parser constructs pTblName from a single identifier,
2967 ** sqlite3FixSrcList can never fail. */
2968 assert(0);
2969 }
2970 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
2971 assert( db->mallocFailed==0 || pTab==0 );
2972 if( pTab==0 ) goto exit_create_index;
2973 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
2974 sqlite3ErrorMsg(pParse,
2975 "cannot create a TEMP index on non-TEMP table \"%s\"",
2976 pTab->zName);
2977 goto exit_create_index;
2978 }
2979 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
2980 }else{
2981 assert( pName==0 );
2982 assert( pStart==0 );
2983 pTab = pParse->pNewTable;
2984 if( !pTab ) goto exit_create_index;
2985 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
2986 }
2987 pDb = &db->aDb[iDb];
2988
2989 assert( pTab!=0 );
2990 assert( pParse->nErr==0 );
2991 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
2992 && db->init.busy==0
2993 #if SQLITE_USER_AUTHENTICATION
2994 && sqlite3UserAuthTable(pTab->zName)==0
2995 #endif
2996 && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 ){
2997 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
2998 goto exit_create_index;
2999 }
3000 #ifndef SQLITE_OMIT_VIEW
3001 if( pTab->pSelect ){
3002 sqlite3ErrorMsg(pParse, "views may not be indexed");
3003 goto exit_create_index;
3004 }
3005 #endif
3006 #ifndef SQLITE_OMIT_VIRTUALTABLE
3007 if( IsVirtual(pTab) ){
3008 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
3009 goto exit_create_index;
3010 }
3011 #endif
3012
3013 /*
3014 ** Find the name of the index. Make sure there is not already another
3015 ** index or table with the same name.
3016 **
3017 ** Exception: If we are reading the names of permanent indices from the
3018 ** sqlite_master table (because some other process changed the schema) and
3019 ** one of the index names collides with the name of a temporary table or
3020 ** index, then we will continue to process this index.
3021 **
3022 ** If pName==0 it means that we are
3023 ** dealing with a primary key or UNIQUE constraint. We have to invent our
3024 ** own name.
3025 */
3026 if( pName ){
3027 zName = sqlite3NameFromToken(db, pName);
3028 if( zName==0 ) goto exit_create_index;
3029 assert( pName->z!=0 );
3030 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
3031 goto exit_create_index;
3032 }
3033 if( !db->init.busy ){
3034 if( sqlite3FindTable(db, zName, 0)!=0 ){
3035 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
3036 goto exit_create_index;
3037 }
3038 }
3039 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
3040 if( !ifNotExist ){
3041 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
3042 }else{
3043 assert( !db->init.busy );
3044 sqlite3CodeVerifySchema(pParse, iDb);
3045 }
3046 goto exit_create_index;
3047 }
3048 }else{
3049 int n;
3050 Index *pLoop;
3051 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
3052 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
3053 if( zName==0 ){
3054 goto exit_create_index;
3055 }
3056
3057 /* Automatic index names generated from within sqlite3_declare_vtab()
3058 ** must have names that are distinct from normal automatic index names.
3059 ** The following statement converts "sqlite3_autoindex..." into
3060 ** "sqlite3_butoindex..." in order to make the names distinct.
3061 ** The "vtab_err.test" test demonstrates the need of this statement. */
3062 if( IN_DECLARE_VTAB ) zName[7]++;
3063 }
3064
3065 /* Check for authorization to create an index.
3066 */
3067 #ifndef SQLITE_OMIT_AUTHORIZATION
3068 {
3069 const char *zDb = pDb->zDbSName;
3070 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
3071 goto exit_create_index;
3072 }
3073 i = SQLITE_CREATE_INDEX;
3074 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
3075 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
3076 goto exit_create_index;
3077 }
3078 }
3079 #endif
3080
3081 /* If pList==0, it means this routine was called to make a primary
3082 ** key out of the last column added to the table under construction.
3083 ** So create a fake list to simulate this.
3084 */
3085 if( pList==0 ){
3086 Token prevCol;
3087 sqlite3TokenInit(&prevCol, pTab->aCol[pTab->nCol-1].zName);
3088 pList = sqlite3ExprListAppend(pParse, 0,
3089 sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
3090 if( pList==0 ) goto exit_create_index;
3091 assert( pList->nExpr==1 );
3092 sqlite3ExprListSetSortOrder(pList, sortOrder);
3093 }else{
3094 sqlite3ExprListCheckLength(pParse, pList, "index");
3095 }
3096
3097 /* Figure out how many bytes of space are required to store explicitly
3098 ** specified collation sequence names.
3099 */
3100 for(i=0; i<pList->nExpr; i++){
3101 Expr *pExpr = pList->a[i].pExpr;
3102 assert( pExpr!=0 );
3103 if( pExpr->op==TK_COLLATE ){
3104 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
3105 }
3106 }
3107
3108 /*
3109 ** Allocate the index structure.
3110 */
3111 nName = sqlite3Strlen30(zName);
3112 nExtraCol = pPk ? pPk->nKeyCol : 1;
3113 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
3114 nName + nExtra + 1, &zExtra);
3115 if( db->mallocFailed ){
3116 goto exit_create_index;
3117 }
3118 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
3119 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
3120 pIndex->zName = zExtra;
3121 zExtra += nName + 1;
3122 memcpy(pIndex->zName, zName, nName+1);
3123 pIndex->pTable = pTab;
3124 pIndex->onError = (u8)onError;
3125 pIndex->uniqNotNull = onError!=OE_None;
3126 pIndex->idxType = idxType;
3127 pIndex->pSchema = db->aDb[iDb].pSchema;
3128 pIndex->nKeyCol = pList->nExpr;
3129 if( pPIWhere ){
3130 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
3131 pIndex->pPartIdxWhere = pPIWhere;
3132 pPIWhere = 0;
3133 }
3134 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
3135
3136 /* Check to see if we should honor DESC requests on index columns
3137 */
3138 if( pDb->pSchema->file_format>=4 ){
3139 sortOrderMask = -1; /* Honor DESC */
3140 }else{
3141 sortOrderMask = 0; /* Ignore DESC */
3142 }
3143
3144 /* Analyze the list of expressions that form the terms of the index and
3145 ** report any errors. In the common case where the expression is exactly
3146 ** a table column, store that column in aiColumn[]. For general expressions,
3147 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
3148 **
3149 ** TODO: Issue a warning if two or more columns of the index are identical.
3150 ** TODO: Issue a warning if the table primary key is used as part of the
3151 ** index key.
3152 */
3153 for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
3154 Expr *pCExpr; /* The i-th index expression */
3155 int requestedSortOrder; /* ASC or DESC on the i-th expression */
3156 const char *zColl; /* Collation sequence name */
3157
3158 sqlite3StringToId(pListItem->pExpr);
3159 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
3160 if( pParse->nErr ) goto exit_create_index;
3161 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
3162 if( pCExpr->op!=TK_COLUMN ){
3163 if( pTab==pParse->pNewTable ){
3164 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
3165 "UNIQUE constraints");
3166 goto exit_create_index;
3167 }
3168 if( pIndex->aColExpr==0 ){
3169 ExprList *pCopy = sqlite3ExprListDup(db, pList, 0);
3170 pIndex->aColExpr = pCopy;
3171 if( !db->mallocFailed ){
3172 assert( pCopy!=0 );
3173 pListItem = &pCopy->a[i];
3174 }
3175 }
3176 j = XN_EXPR;
3177 pIndex->aiColumn[i] = XN_EXPR;
3178 pIndex->uniqNotNull = 0;
3179 }else{
3180 j = pCExpr->iColumn;
3181 assert( j<=0x7fff );
3182 if( j<0 ){
3183 j = pTab->iPKey;
3184 }else if( pTab->aCol[j].notNull==0 ){
3185 pIndex->uniqNotNull = 0;
3186 }
3187 pIndex->aiColumn[i] = (i16)j;
3188 }
3189 zColl = 0;
3190 if( pListItem->pExpr->op==TK_COLLATE ){
3191 int nColl;
3192 zColl = pListItem->pExpr->u.zToken;
3193 nColl = sqlite3Strlen30(zColl) + 1;
3194 assert( nExtra>=nColl );
3195 memcpy(zExtra, zColl, nColl);
3196 zColl = zExtra;
3197 zExtra += nColl;
3198 nExtra -= nColl;
3199 }else if( j>=0 ){
3200 zColl = pTab->aCol[j].zColl;
3201 }
3202 if( !zColl ) zColl = sqlite3StrBINARY;
3203 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
3204 goto exit_create_index;
3205 }
3206 pIndex->azColl[i] = zColl;
3207 requestedSortOrder = pListItem->sortOrder & sortOrderMask;
3208 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
3209 }
3210
3211 /* Append the table key to the end of the index. For WITHOUT ROWID
3212 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
3213 ** normal tables (when pPk==0) this will be the rowid.
3214 */
3215 if( pPk ){
3216 for(j=0; j<pPk->nKeyCol; j++){
3217 int x = pPk->aiColumn[j];
3218 assert( x>=0 );
3219 if( hasColumn(pIndex->aiColumn, pIndex->nKeyCol, x) ){
3220 pIndex->nColumn--;
3221 }else{
3222 pIndex->aiColumn[i] = x;
3223 pIndex->azColl[i] = pPk->azColl[j];
3224 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
3225 i++;
3226 }
3227 }
3228 assert( i==pIndex->nColumn );
3229 }else{
3230 pIndex->aiColumn[i] = XN_ROWID;
3231 pIndex->azColl[i] = sqlite3StrBINARY;
3232 }
3233 sqlite3DefaultRowEst(pIndex);
3234 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
3235
3236 /* If this index contains every column of its table, then mark
3237 ** it as a covering index */
3238 assert( HasRowid(pTab)
3239 || pTab->iPKey<0 || sqlite3ColumnOfIndex(pIndex, pTab->iPKey)>=0 );
3240 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
3241 pIndex->isCovering = 1;
3242 for(j=0; j<pTab->nCol; j++){
3243 if( j==pTab->iPKey ) continue;
3244 if( sqlite3ColumnOfIndex(pIndex,j)>=0 ) continue;
3245 pIndex->isCovering = 0;
3246 break;
3247 }
3248 }
3249
3250 if( pTab==pParse->pNewTable ){
3251 /* This routine has been called to create an automatic index as a
3252 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
3253 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
3254 ** i.e. one of:
3255 **
3256 ** CREATE TABLE t(x PRIMARY KEY, y);
3257 ** CREATE TABLE t(x, y, UNIQUE(x, y));
3258 **
3259 ** Either way, check to see if the table already has such an index. If
3260 ** so, don't bother creating this one. This only applies to
3261 ** automatically created indices. Users can do as they wish with
3262 ** explicit indices.
3263 **
3264 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
3265 ** (and thus suppressing the second one) even if they have different
3266 ** sort orders.
3267 **
3268 ** If there are different collating sequences or if the columns of
3269 ** the constraint occur in different orders, then the constraints are
3270 ** considered distinct and both result in separate indices.
3271 */
3272 Index *pIdx;
3273 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
3274 int k;
3275 assert( IsUniqueIndex(pIdx) );
3276 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
3277 assert( IsUniqueIndex(pIndex) );
3278
3279 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
3280 for(k=0; k<pIdx->nKeyCol; k++){
3281 const char *z1;
3282 const char *z2;
3283 assert( pIdx->aiColumn[k]>=0 );
3284 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
3285 z1 = pIdx->azColl[k];
3286 z2 = pIndex->azColl[k];
3287 if( sqlite3StrICmp(z1, z2) ) break;
3288 }
3289 if( k==pIdx->nKeyCol ){
3290 if( pIdx->onError!=pIndex->onError ){
3291 /* This constraint creates the same index as a previous
3292 ** constraint specified somewhere in the CREATE TABLE statement.
3293 ** However the ON CONFLICT clauses are different. If both this
3294 ** constraint and the previous equivalent constraint have explicit
3295 ** ON CONFLICT clauses this is an error. Otherwise, use the
3296 ** explicitly specified behavior for the index.
3297 */
3298 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
3299 sqlite3ErrorMsg(pParse,
3300 "conflicting ON CONFLICT clauses specified", 0);
3301 }
3302 if( pIdx->onError==OE_Default ){
3303 pIdx->onError = pIndex->onError;
3304 }
3305 }
3306 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
3307 goto exit_create_index;
3308 }
3309 }
3310 }
3311
3312 /* Link the new Index structure to its table and to the other
3313 ** in-memory database structures.
3314 */
3315 assert( pParse->nErr==0 );
3316 if( db->init.busy ){
3317 Index *p;
3318 assert( !IN_DECLARE_VTAB );
3319 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
3320 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
3321 pIndex->zName, pIndex);
3322 if( p ){
3323 assert( p==pIndex ); /* Malloc must have failed */
3324 sqlite3OomFault(db);
3325 goto exit_create_index;
3326 }
3327 db->flags |= SQLITE_InternChanges;
3328 if( pTblName!=0 ){
3329 pIndex->tnum = db->init.newTnum;
3330 }
3331 }
3332
3333 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
3334 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
3335 ** emit code to allocate the index rootpage on disk and make an entry for
3336 ** the index in the sqlite_master table and populate the index with
3337 ** content. But, do not do this if we are simply reading the sqlite_master
3338 ** table to parse the schema, or if this index is the PRIMARY KEY index
3339 ** of a WITHOUT ROWID table.
3340 **
3341 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
3342 ** or UNIQUE index in a CREATE TABLE statement. Since the table
3343 ** has just been created, it contains no data and the index initialization
3344 ** step can be skipped.
3345 */
3346 else if( HasRowid(pTab) || pTblName!=0 ){
3347 Vdbe *v;
3348 char *zStmt;
3349 int iMem = ++pParse->nMem;
3350
3351 v = sqlite3GetVdbe(pParse);
3352 if( v==0 ) goto exit_create_index;
3353
3354 sqlite3BeginWriteOperation(pParse, 1, iDb);
3355
3356 /* Create the rootpage for the index using CreateIndex. But before
3357 ** doing so, code a Noop instruction and store its address in
3358 ** Index.tnum. This is required in case this index is actually a
3359 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
3360 ** that case the convertToWithoutRowidTable() routine will replace
3361 ** the Noop with a Goto to jump over the VDBE code generated below. */
3362 pIndex->tnum = sqlite3VdbeAddOp0(v, OP_Noop);
3363 sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
3364
3365 /* Gather the complete text of the CREATE INDEX statement into
3366 ** the zStmt variable
3367 */
3368 if( pStart ){
3369 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
3370 if( pName->z[n-1]==';' ) n--;
3371 /* A named index with an explicit CREATE INDEX statement */
3372 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
3373 onError==OE_None ? "" : " UNIQUE", n, pName->z);
3374 }else{
3375 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
3376 /* zStmt = sqlite3MPrintf(""); */
3377 zStmt = 0;
3378 }
3379
3380 /* Add an entry in sqlite_master for this index
3381 */
3382 sqlite3NestedParse(pParse,
3383 "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
3384 db->aDb[iDb].zDbSName, MASTER_NAME,
3385 pIndex->zName,
3386 pTab->zName,
3387 iMem,
3388 zStmt
3389 );
3390 sqlite3DbFree(db, zStmt);
3391
3392 /* Fill the index with data and reparse the schema. Code an OP_Expire
3393 ** to invalidate all pre-compiled statements.
3394 */
3395 if( pTblName ){
3396 sqlite3RefillIndex(pParse, pIndex, iMem);
3397 sqlite3ChangeCookie(pParse, iDb);
3398 sqlite3VdbeAddParseSchemaOp(v, iDb,
3399 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
3400 sqlite3VdbeAddOp0(v, OP_Expire);
3401 }
3402
3403 sqlite3VdbeJumpHere(v, pIndex->tnum);
3404 }
3405
3406 /* When adding an index to the list of indices for a table, make
3407 ** sure all indices labeled OE_Replace come after all those labeled
3408 ** OE_Ignore. This is necessary for the correct constraint check
3409 ** processing (in sqlite3GenerateConstraintChecks()) as part of
3410 ** UPDATE and INSERT statements.
3411 */
3412 if( db->init.busy || pTblName==0 ){
3413 if( onError!=OE_Replace || pTab->pIndex==0
3414 || pTab->pIndex->onError==OE_Replace){
3415 pIndex->pNext = pTab->pIndex;
3416 pTab->pIndex = pIndex;
3417 }else{
3418 Index *pOther = pTab->pIndex;
3419 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
3420 pOther = pOther->pNext;
3421 }
3422 pIndex->pNext = pOther->pNext;
3423 pOther->pNext = pIndex;
3424 }
3425 pIndex = 0;
3426 }
3427
3428 /* Clean up before exiting */
3429 exit_create_index:
3430 if( pIndex ) freeIndex(db, pIndex);
3431 sqlite3ExprDelete(db, pPIWhere);
3432 sqlite3ExprListDelete(db, pList);
3433 sqlite3SrcListDelete(db, pTblName);
3434 sqlite3DbFree(db, zName);
3435 }
3436
3437 /*
3438 ** Fill the Index.aiRowEst[] array with default information - information
3439 ** to be used when we have not run the ANALYZE command.
3440 **
3441 ** aiRowEst[0] is supposed to contain the number of elements in the index.
3442 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
3443 ** number of rows in the table that match any particular value of the
3444 ** first column of the index. aiRowEst[2] is an estimate of the number
3445 ** of rows that match any particular combination of the first 2 columns
3446 ** of the index. And so forth. It must always be the case that
3447 *
3448 ** aiRowEst[N]<=aiRowEst[N-1]
3449 ** aiRowEst[N]>=1
3450 **
3451 ** Apart from that, we have little to go on besides intuition as to
3452 ** how aiRowEst[] should be initialized. The numbers generated here
3453 ** are based on typical values found in actual indices.
3454 */
sqlite3DefaultRowEst(Index * pIdx)3455 void sqlite3DefaultRowEst(Index *pIdx){
3456 /* 10, 9, 8, 7, 6 */
3457 LogEst aVal[] = { 33, 32, 30, 28, 26 };
3458 LogEst *a = pIdx->aiRowLogEst;
3459 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
3460 int i;
3461
3462 /* Indexes with default row estimates should not have stat1 data */
3463 assert( !pIdx->hasStat1 );
3464
3465 /* Set the first entry (number of rows in the index) to the estimated
3466 ** number of rows in the table, or half the number of rows in the table
3467 ** for a partial index. But do not let the estimate drop below 10. */
3468 a[0] = pIdx->pTable->nRowLogEst;
3469 if( pIdx->pPartIdxWhere!=0 ) a[0] -= 10; assert( 10==sqlite3LogEst(2) );
3470 if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) );
3471
3472 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
3473 ** 6 and each subsequent value (if any) is 5. */
3474 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
3475 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
3476 a[i] = 23; assert( 23==sqlite3LogEst(5) );
3477 }
3478
3479 assert( 0==sqlite3LogEst(1) );
3480 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
3481 }
3482
3483 /*
3484 ** This routine will drop an existing named index. This routine
3485 ** implements the DROP INDEX statement.
3486 */
sqlite3DropIndex(Parse * pParse,SrcList * pName,int ifExists)3487 void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
3488 Index *pIndex;
3489 Vdbe *v;
3490 sqlite3 *db = pParse->db;
3491 int iDb;
3492
3493 assert( pParse->nErr==0 ); /* Never called with prior errors */
3494 if( db->mallocFailed ){
3495 goto exit_drop_index;
3496 }
3497 assert( pName->nSrc==1 );
3498 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
3499 goto exit_drop_index;
3500 }
3501 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
3502 if( pIndex==0 ){
3503 if( !ifExists ){
3504 sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
3505 }else{
3506 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
3507 }
3508 pParse->checkSchema = 1;
3509 goto exit_drop_index;
3510 }
3511 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
3512 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
3513 "or PRIMARY KEY constraint cannot be dropped", 0);
3514 goto exit_drop_index;
3515 }
3516 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
3517 #ifndef SQLITE_OMIT_AUTHORIZATION
3518 {
3519 int code = SQLITE_DROP_INDEX;
3520 Table *pTab = pIndex->pTable;
3521 const char *zDb = db->aDb[iDb].zDbSName;
3522 const char *zTab = SCHEMA_TABLE(iDb);
3523 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
3524 goto exit_drop_index;
3525 }
3526 if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
3527 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
3528 goto exit_drop_index;
3529 }
3530 }
3531 #endif
3532
3533 /* Generate code to remove the index and from the master table */
3534 v = sqlite3GetVdbe(pParse);
3535 if( v ){
3536 sqlite3BeginWriteOperation(pParse, 1, iDb);
3537 sqlite3NestedParse(pParse,
3538 "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
3539 db->aDb[iDb].zDbSName, MASTER_NAME, pIndex->zName
3540 );
3541 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
3542 sqlite3ChangeCookie(pParse, iDb);
3543 destroyRootPage(pParse, pIndex->tnum, iDb);
3544 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
3545 }
3546
3547 exit_drop_index:
3548 sqlite3SrcListDelete(db, pName);
3549 }
3550
3551 /*
3552 ** pArray is a pointer to an array of objects. Each object in the
3553 ** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
3554 ** to extend the array so that there is space for a new object at the end.
3555 **
3556 ** When this function is called, *pnEntry contains the current size of
3557 ** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
3558 ** in total).
3559 **
3560 ** If the realloc() is successful (i.e. if no OOM condition occurs), the
3561 ** space allocated for the new object is zeroed, *pnEntry updated to
3562 ** reflect the new size of the array and a pointer to the new allocation
3563 ** returned. *pIdx is set to the index of the new array entry in this case.
3564 **
3565 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
3566 ** unchanged and a copy of pArray returned.
3567 */
sqlite3ArrayAllocate(sqlite3 * db,void * pArray,int szEntry,int * pnEntry,int * pIdx)3568 void *sqlite3ArrayAllocate(
3569 sqlite3 *db, /* Connection to notify of malloc failures */
3570 void *pArray, /* Array of objects. Might be reallocated */
3571 int szEntry, /* Size of each object in the array */
3572 int *pnEntry, /* Number of objects currently in use */
3573 int *pIdx /* Write the index of a new slot here */
3574 ){
3575 char *z;
3576 int n = *pnEntry;
3577 if( (n & (n-1))==0 ){
3578 int sz = (n==0) ? 1 : 2*n;
3579 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
3580 if( pNew==0 ){
3581 *pIdx = -1;
3582 return pArray;
3583 }
3584 pArray = pNew;
3585 }
3586 z = (char*)pArray;
3587 memset(&z[n * szEntry], 0, szEntry);
3588 *pIdx = n;
3589 ++*pnEntry;
3590 return pArray;
3591 }
3592
3593 /*
3594 ** Append a new element to the given IdList. Create a new IdList if
3595 ** need be.
3596 **
3597 ** A new IdList is returned, or NULL if malloc() fails.
3598 */
sqlite3IdListAppend(sqlite3 * db,IdList * pList,Token * pToken)3599 IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){
3600 int i;
3601 if( pList==0 ){
3602 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
3603 if( pList==0 ) return 0;
3604 }
3605 pList->a = sqlite3ArrayAllocate(
3606 db,
3607 pList->a,
3608 sizeof(pList->a[0]),
3609 &pList->nId,
3610 &i
3611 );
3612 if( i<0 ){
3613 sqlite3IdListDelete(db, pList);
3614 return 0;
3615 }
3616 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
3617 return pList;
3618 }
3619
3620 /*
3621 ** Delete an IdList.
3622 */
sqlite3IdListDelete(sqlite3 * db,IdList * pList)3623 void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
3624 int i;
3625 if( pList==0 ) return;
3626 for(i=0; i<pList->nId; i++){
3627 sqlite3DbFree(db, pList->a[i].zName);
3628 }
3629 sqlite3DbFree(db, pList->a);
3630 sqlite3DbFreeNN(db, pList);
3631 }
3632
3633 /*
3634 ** Return the index in pList of the identifier named zId. Return -1
3635 ** if not found.
3636 */
sqlite3IdListIndex(IdList * pList,const char * zName)3637 int sqlite3IdListIndex(IdList *pList, const char *zName){
3638 int i;
3639 if( pList==0 ) return -1;
3640 for(i=0; i<pList->nId; i++){
3641 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
3642 }
3643 return -1;
3644 }
3645
3646 /*
3647 ** Expand the space allocated for the given SrcList object by
3648 ** creating nExtra new slots beginning at iStart. iStart is zero based.
3649 ** New slots are zeroed.
3650 **
3651 ** For example, suppose a SrcList initially contains two entries: A,B.
3652 ** To append 3 new entries onto the end, do this:
3653 **
3654 ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
3655 **
3656 ** After the call above it would contain: A, B, nil, nil, nil.
3657 ** If the iStart argument had been 1 instead of 2, then the result
3658 ** would have been: A, nil, nil, nil, B. To prepend the new slots,
3659 ** the iStart value would be 0. The result then would
3660 ** be: nil, nil, nil, A, B.
3661 **
3662 ** If a memory allocation fails the SrcList is unchanged. The
3663 ** db->mallocFailed flag will be set to true.
3664 */
sqlite3SrcListEnlarge(sqlite3 * db,SrcList * pSrc,int nExtra,int iStart)3665 SrcList *sqlite3SrcListEnlarge(
3666 sqlite3 *db, /* Database connection to notify of OOM errors */
3667 SrcList *pSrc, /* The SrcList to be enlarged */
3668 int nExtra, /* Number of new slots to add to pSrc->a[] */
3669 int iStart /* Index in pSrc->a[] of first new slot */
3670 ){
3671 int i;
3672
3673 /* Sanity checking on calling parameters */
3674 assert( iStart>=0 );
3675 assert( nExtra>=1 );
3676 assert( pSrc!=0 );
3677 assert( iStart<=pSrc->nSrc );
3678
3679 /* Allocate additional space if needed */
3680 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
3681 SrcList *pNew;
3682 int nAlloc = pSrc->nSrc*2+nExtra;
3683 int nGot;
3684 pNew = sqlite3DbRealloc(db, pSrc,
3685 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
3686 if( pNew==0 ){
3687 assert( db->mallocFailed );
3688 return pSrc;
3689 }
3690 pSrc = pNew;
3691 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
3692 pSrc->nAlloc = nGot;
3693 }
3694
3695 /* Move existing slots that come after the newly inserted slots
3696 ** out of the way */
3697 for(i=pSrc->nSrc-1; i>=iStart; i--){
3698 pSrc->a[i+nExtra] = pSrc->a[i];
3699 }
3700 pSrc->nSrc += nExtra;
3701
3702 /* Zero the newly allocated slots */
3703 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
3704 for(i=iStart; i<iStart+nExtra; i++){
3705 pSrc->a[i].iCursor = -1;
3706 }
3707
3708 /* Return a pointer to the enlarged SrcList */
3709 return pSrc;
3710 }
3711
3712
3713 /*
3714 ** Append a new table name to the given SrcList. Create a new SrcList if
3715 ** need be. A new entry is created in the SrcList even if pTable is NULL.
3716 **
3717 ** A SrcList is returned, or NULL if there is an OOM error. The returned
3718 ** SrcList might be the same as the SrcList that was input or it might be
3719 ** a new one. If an OOM error does occurs, then the prior value of pList
3720 ** that is input to this routine is automatically freed.
3721 **
3722 ** If pDatabase is not null, it means that the table has an optional
3723 ** database name prefix. Like this: "database.table". The pDatabase
3724 ** points to the table name and the pTable points to the database name.
3725 ** The SrcList.a[].zName field is filled with the table name which might
3726 ** come from pTable (if pDatabase is NULL) or from pDatabase.
3727 ** SrcList.a[].zDatabase is filled with the database name from pTable,
3728 ** or with NULL if no database is specified.
3729 **
3730 ** In other words, if call like this:
3731 **
3732 ** sqlite3SrcListAppend(D,A,B,0);
3733 **
3734 ** Then B is a table name and the database name is unspecified. If called
3735 ** like this:
3736 **
3737 ** sqlite3SrcListAppend(D,A,B,C);
3738 **
3739 ** Then C is the table name and B is the database name. If C is defined
3740 ** then so is B. In other words, we never have a case where:
3741 **
3742 ** sqlite3SrcListAppend(D,A,0,C);
3743 **
3744 ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
3745 ** before being added to the SrcList.
3746 */
sqlite3SrcListAppend(sqlite3 * db,SrcList * pList,Token * pTable,Token * pDatabase)3747 SrcList *sqlite3SrcListAppend(
3748 sqlite3 *db, /* Connection to notify of malloc failures */
3749 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
3750 Token *pTable, /* Table to append */
3751 Token *pDatabase /* Database of the table */
3752 ){
3753 struct SrcList_item *pItem;
3754 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
3755 assert( db!=0 );
3756 if( pList==0 ){
3757 pList = sqlite3DbMallocRawNN(db, sizeof(SrcList) );
3758 if( pList==0 ) return 0;
3759 pList->nAlloc = 1;
3760 pList->nSrc = 1;
3761 memset(&pList->a[0], 0, sizeof(pList->a[0]));
3762 pList->a[0].iCursor = -1;
3763 }else{
3764 pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
3765 }
3766 if( db->mallocFailed ){
3767 sqlite3SrcListDelete(db, pList);
3768 return 0;
3769 }
3770 pItem = &pList->a[pList->nSrc-1];
3771 if( pDatabase && pDatabase->z==0 ){
3772 pDatabase = 0;
3773 }
3774 if( pDatabase ){
3775 pItem->zName = sqlite3NameFromToken(db, pDatabase);
3776 pItem->zDatabase = sqlite3NameFromToken(db, pTable);
3777 }else{
3778 pItem->zName = sqlite3NameFromToken(db, pTable);
3779 pItem->zDatabase = 0;
3780 }
3781 return pList;
3782 }
3783
3784 /*
3785 ** Assign VdbeCursor index numbers to all tables in a SrcList
3786 */
sqlite3SrcListAssignCursors(Parse * pParse,SrcList * pList)3787 void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
3788 int i;
3789 struct SrcList_item *pItem;
3790 assert(pList || pParse->db->mallocFailed );
3791 if( pList ){
3792 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
3793 if( pItem->iCursor>=0 ) break;
3794 pItem->iCursor = pParse->nTab++;
3795 if( pItem->pSelect ){
3796 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
3797 }
3798 }
3799 }
3800 }
3801
3802 /*
3803 ** Delete an entire SrcList including all its substructure.
3804 */
sqlite3SrcListDelete(sqlite3 * db,SrcList * pList)3805 void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
3806 int i;
3807 struct SrcList_item *pItem;
3808 if( pList==0 ) return;
3809 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
3810 sqlite3DbFree(db, pItem->zDatabase);
3811 sqlite3DbFree(db, pItem->zName);
3812 sqlite3DbFree(db, pItem->zAlias);
3813 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
3814 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
3815 sqlite3DeleteTable(db, pItem->pTab);
3816 sqlite3SelectDelete(db, pItem->pSelect);
3817 sqlite3ExprDelete(db, pItem->pOn);
3818 sqlite3IdListDelete(db, pItem->pUsing);
3819 }
3820 sqlite3DbFreeNN(db, pList);
3821 }
3822
3823 /*
3824 ** This routine is called by the parser to add a new term to the
3825 ** end of a growing FROM clause. The "p" parameter is the part of
3826 ** the FROM clause that has already been constructed. "p" is NULL
3827 ** if this is the first term of the FROM clause. pTable and pDatabase
3828 ** are the name of the table and database named in the FROM clause term.
3829 ** pDatabase is NULL if the database name qualifier is missing - the
3830 ** usual case. If the term has an alias, then pAlias points to the
3831 ** alias token. If the term is a subquery, then pSubquery is the
3832 ** SELECT statement that the subquery encodes. The pTable and
3833 ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
3834 ** parameters are the content of the ON and USING clauses.
3835 **
3836 ** Return a new SrcList which encodes is the FROM with the new
3837 ** term added.
3838 */
sqlite3SrcListAppendFromTerm(Parse * pParse,SrcList * p,Token * pTable,Token * pDatabase,Token * pAlias,Select * pSubquery,Expr * pOn,IdList * pUsing)3839 SrcList *sqlite3SrcListAppendFromTerm(
3840 Parse *pParse, /* Parsing context */
3841 SrcList *p, /* The left part of the FROM clause already seen */
3842 Token *pTable, /* Name of the table to add to the FROM clause */
3843 Token *pDatabase, /* Name of the database containing pTable */
3844 Token *pAlias, /* The right-hand side of the AS subexpression */
3845 Select *pSubquery, /* A subquery used in place of a table name */
3846 Expr *pOn, /* The ON clause of a join */
3847 IdList *pUsing /* The USING clause of a join */
3848 ){
3849 struct SrcList_item *pItem;
3850 sqlite3 *db = pParse->db;
3851 if( !p && (pOn || pUsing) ){
3852 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
3853 (pOn ? "ON" : "USING")
3854 );
3855 goto append_from_error;
3856 }
3857 p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
3858 if( p==0 || NEVER(p->nSrc==0) ){
3859 goto append_from_error;
3860 }
3861 pItem = &p->a[p->nSrc-1];
3862 assert( pAlias!=0 );
3863 if( pAlias->n ){
3864 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
3865 }
3866 pItem->pSelect = pSubquery;
3867 pItem->pOn = pOn;
3868 pItem->pUsing = pUsing;
3869 return p;
3870
3871 append_from_error:
3872 assert( p==0 );
3873 sqlite3ExprDelete(db, pOn);
3874 sqlite3IdListDelete(db, pUsing);
3875 sqlite3SelectDelete(db, pSubquery);
3876 return 0;
3877 }
3878
3879 /*
3880 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
3881 ** element of the source-list passed as the second argument.
3882 */
sqlite3SrcListIndexedBy(Parse * pParse,SrcList * p,Token * pIndexedBy)3883 void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
3884 assert( pIndexedBy!=0 );
3885 if( p && ALWAYS(p->nSrc>0) ){
3886 struct SrcList_item *pItem = &p->a[p->nSrc-1];
3887 assert( pItem->fg.notIndexed==0 );
3888 assert( pItem->fg.isIndexedBy==0 );
3889 assert( pItem->fg.isTabFunc==0 );
3890 if( pIndexedBy->n==1 && !pIndexedBy->z ){
3891 /* A "NOT INDEXED" clause was supplied. See parse.y
3892 ** construct "indexed_opt" for details. */
3893 pItem->fg.notIndexed = 1;
3894 }else{
3895 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
3896 pItem->fg.isIndexedBy = (pItem->u1.zIndexedBy!=0);
3897 }
3898 }
3899 }
3900
3901 /*
3902 ** Add the list of function arguments to the SrcList entry for a
3903 ** table-valued-function.
3904 */
sqlite3SrcListFuncArgs(Parse * pParse,SrcList * p,ExprList * pList)3905 void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
3906 if( p ){
3907 struct SrcList_item *pItem = &p->a[p->nSrc-1];
3908 assert( pItem->fg.notIndexed==0 );
3909 assert( pItem->fg.isIndexedBy==0 );
3910 assert( pItem->fg.isTabFunc==0 );
3911 pItem->u1.pFuncArg = pList;
3912 pItem->fg.isTabFunc = 1;
3913 }else{
3914 sqlite3ExprListDelete(pParse->db, pList);
3915 }
3916 }
3917
3918 /*
3919 ** When building up a FROM clause in the parser, the join operator
3920 ** is initially attached to the left operand. But the code generator
3921 ** expects the join operator to be on the right operand. This routine
3922 ** Shifts all join operators from left to right for an entire FROM
3923 ** clause.
3924 **
3925 ** Example: Suppose the join is like this:
3926 **
3927 ** A natural cross join B
3928 **
3929 ** The operator is "natural cross join". The A and B operands are stored
3930 ** in p->a[0] and p->a[1], respectively. The parser initially stores the
3931 ** operator with A. This routine shifts that operator over to B.
3932 */
sqlite3SrcListShiftJoinType(SrcList * p)3933 void sqlite3SrcListShiftJoinType(SrcList *p){
3934 if( p ){
3935 int i;
3936 for(i=p->nSrc-1; i>0; i--){
3937 p->a[i].fg.jointype = p->a[i-1].fg.jointype;
3938 }
3939 p->a[0].fg.jointype = 0;
3940 }
3941 }
3942
3943 /*
3944 ** Generate VDBE code for a BEGIN statement.
3945 */
sqlite3BeginTransaction(Parse * pParse,int type)3946 void sqlite3BeginTransaction(Parse *pParse, int type){
3947 sqlite3 *db;
3948 Vdbe *v;
3949 int i;
3950
3951 assert( pParse!=0 );
3952 db = pParse->db;
3953 assert( db!=0 );
3954 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
3955 return;
3956 }
3957 v = sqlite3GetVdbe(pParse);
3958 if( !v ) return;
3959 if( type!=TK_DEFERRED ){
3960 for(i=0; i<db->nDb; i++){
3961 sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
3962 sqlite3VdbeUsesBtree(v, i);
3963 }
3964 }
3965 sqlite3VdbeAddOp0(v, OP_AutoCommit);
3966 }
3967
3968 /*
3969 ** Generate VDBE code for a COMMIT or ROLLBACK statement.
3970 ** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
3971 ** code is generated for a COMMIT.
3972 */
sqlite3EndTransaction(Parse * pParse,int eType)3973 void sqlite3EndTransaction(Parse *pParse, int eType){
3974 Vdbe *v;
3975 int isRollback;
3976
3977 assert( pParse!=0 );
3978 assert( pParse->db!=0 );
3979 assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
3980 isRollback = eType==TK_ROLLBACK;
3981 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
3982 isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
3983 return;
3984 }
3985 v = sqlite3GetVdbe(pParse);
3986 if( v ){
3987 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
3988 }
3989 }
3990
3991 /*
3992 ** This function is called by the parser when it parses a command to create,
3993 ** release or rollback an SQL savepoint.
3994 */
sqlite3Savepoint(Parse * pParse,int op,Token * pName)3995 void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
3996 char *zName = sqlite3NameFromToken(pParse->db, pName);
3997 if( zName ){
3998 Vdbe *v = sqlite3GetVdbe(pParse);
3999 #ifndef SQLITE_OMIT_AUTHORIZATION
4000 static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
4001 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
4002 #endif
4003 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
4004 sqlite3DbFree(pParse->db, zName);
4005 return;
4006 }
4007 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
4008 }
4009 }
4010
4011 /*
4012 ** Make sure the TEMP database is open and available for use. Return
4013 ** the number of errors. Leave any error messages in the pParse structure.
4014 */
sqlite3OpenTempDatabase(Parse * pParse)4015 int sqlite3OpenTempDatabase(Parse *pParse){
4016 sqlite3 *db = pParse->db;
4017 if( db->aDb[1].pBt==0 && !pParse->explain ){
4018 int rc;
4019 Btree *pBt;
4020 static const int flags =
4021 SQLITE_OPEN_READWRITE |
4022 SQLITE_OPEN_CREATE |
4023 SQLITE_OPEN_EXCLUSIVE |
4024 SQLITE_OPEN_DELETEONCLOSE |
4025 SQLITE_OPEN_TEMP_DB;
4026
4027 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
4028 if( rc!=SQLITE_OK ){
4029 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
4030 "file for storing temporary tables");
4031 pParse->rc = rc;
4032 return 1;
4033 }
4034 db->aDb[1].pBt = pBt;
4035 assert( db->aDb[1].pSchema );
4036 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
4037 sqlite3OomFault(db);
4038 return 1;
4039 }
4040 }
4041 return 0;
4042 }
4043
4044 /*
4045 ** Record the fact that the schema cookie will need to be verified
4046 ** for database iDb. The code to actually verify the schema cookie
4047 ** will occur at the end of the top-level VDBE and will be generated
4048 ** later, by sqlite3FinishCoding().
4049 */
sqlite3CodeVerifySchema(Parse * pParse,int iDb)4050 void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
4051 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4052
4053 assert( iDb>=0 && iDb<pParse->db->nDb );
4054 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
4055 assert( iDb<SQLITE_MAX_ATTACHED+2 );
4056 assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
4057 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
4058 DbMaskSet(pToplevel->cookieMask, iDb);
4059 if( !OMIT_TEMPDB && iDb==1 ){
4060 sqlite3OpenTempDatabase(pToplevel);
4061 }
4062 }
4063 }
4064
4065 /*
4066 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
4067 ** attached database. Otherwise, invoke it for the database named zDb only.
4068 */
sqlite3CodeVerifyNamedSchema(Parse * pParse,const char * zDb)4069 void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
4070 sqlite3 *db = pParse->db;
4071 int i;
4072 for(i=0; i<db->nDb; i++){
4073 Db *pDb = &db->aDb[i];
4074 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
4075 sqlite3CodeVerifySchema(pParse, i);
4076 }
4077 }
4078 }
4079
4080 /*
4081 ** Generate VDBE code that prepares for doing an operation that
4082 ** might change the database.
4083 **
4084 ** This routine starts a new transaction if we are not already within
4085 ** a transaction. If we are already within a transaction, then a checkpoint
4086 ** is set if the setStatement parameter is true. A checkpoint should
4087 ** be set for operations that might fail (due to a constraint) part of
4088 ** the way through and which will need to undo some writes without having to
4089 ** rollback the whole transaction. For operations where all constraints
4090 ** can be checked before any changes are made to the database, it is never
4091 ** necessary to undo a write and the checkpoint should not be set.
4092 */
sqlite3BeginWriteOperation(Parse * pParse,int setStatement,int iDb)4093 void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
4094 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4095 sqlite3CodeVerifySchema(pParse, iDb);
4096 DbMaskSet(pToplevel->writeMask, iDb);
4097 pToplevel->isMultiWrite |= setStatement;
4098 }
4099
4100 /*
4101 ** Indicate that the statement currently under construction might write
4102 ** more than one entry (example: deleting one row then inserting another,
4103 ** inserting multiple rows in a table, or inserting a row and index entries.)
4104 ** If an abort occurs after some of these writes have completed, then it will
4105 ** be necessary to undo the completed writes.
4106 */
sqlite3MultiWrite(Parse * pParse)4107 void sqlite3MultiWrite(Parse *pParse){
4108 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4109 pToplevel->isMultiWrite = 1;
4110 }
4111
4112 /*
4113 ** The code generator calls this routine if is discovers that it is
4114 ** possible to abort a statement prior to completion. In order to
4115 ** perform this abort without corrupting the database, we need to make
4116 ** sure that the statement is protected by a statement transaction.
4117 **
4118 ** Technically, we only need to set the mayAbort flag if the
4119 ** isMultiWrite flag was previously set. There is a time dependency
4120 ** such that the abort must occur after the multiwrite. This makes
4121 ** some statements involving the REPLACE conflict resolution algorithm
4122 ** go a little faster. But taking advantage of this time dependency
4123 ** makes it more difficult to prove that the code is correct (in
4124 ** particular, it prevents us from writing an effective
4125 ** implementation of sqlite3AssertMayAbort()) and so we have chosen
4126 ** to take the safe route and skip the optimization.
4127 */
sqlite3MayAbort(Parse * pParse)4128 void sqlite3MayAbort(Parse *pParse){
4129 Parse *pToplevel = sqlite3ParseToplevel(pParse);
4130 pToplevel->mayAbort = 1;
4131 }
4132
4133 /*
4134 ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
4135 ** error. The onError parameter determines which (if any) of the statement
4136 ** and/or current transaction is rolled back.
4137 */
sqlite3HaltConstraint(Parse * pParse,int errCode,int onError,char * p4,i8 p4type,u8 p5Errmsg)4138 void sqlite3HaltConstraint(
4139 Parse *pParse, /* Parsing context */
4140 int errCode, /* extended error code */
4141 int onError, /* Constraint type */
4142 char *p4, /* Error message */
4143 i8 p4type, /* P4_STATIC or P4_TRANSIENT */
4144 u8 p5Errmsg /* P5_ErrMsg type */
4145 ){
4146 Vdbe *v = sqlite3GetVdbe(pParse);
4147 assert( (errCode&0xff)==SQLITE_CONSTRAINT );
4148 if( onError==OE_Abort ){
4149 sqlite3MayAbort(pParse);
4150 }
4151 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
4152 sqlite3VdbeChangeP5(v, p5Errmsg);
4153 }
4154
4155 /*
4156 ** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
4157 */
sqlite3UniqueConstraint(Parse * pParse,int onError,Index * pIdx)4158 void sqlite3UniqueConstraint(
4159 Parse *pParse, /* Parsing context */
4160 int onError, /* Constraint type */
4161 Index *pIdx /* The index that triggers the constraint */
4162 ){
4163 char *zErr;
4164 int j;
4165 StrAccum errMsg;
4166 Table *pTab = pIdx->pTable;
4167
4168 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200);
4169 if( pIdx->aColExpr ){
4170 sqlite3XPrintf(&errMsg, "index '%q'", pIdx->zName);
4171 }else{
4172 for(j=0; j<pIdx->nKeyCol; j++){
4173 char *zCol;
4174 assert( pIdx->aiColumn[j]>=0 );
4175 zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
4176 if( j ) sqlite3StrAccumAppend(&errMsg, ", ", 2);
4177 sqlite3StrAccumAppendAll(&errMsg, pTab->zName);
4178 sqlite3StrAccumAppend(&errMsg, ".", 1);
4179 sqlite3StrAccumAppendAll(&errMsg, zCol);
4180 }
4181 }
4182 zErr = sqlite3StrAccumFinish(&errMsg);
4183 sqlite3HaltConstraint(pParse,
4184 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
4185 : SQLITE_CONSTRAINT_UNIQUE,
4186 onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
4187 }
4188
4189
4190 /*
4191 ** Code an OP_Halt due to non-unique rowid.
4192 */
sqlite3RowidConstraint(Parse * pParse,int onError,Table * pTab)4193 void sqlite3RowidConstraint(
4194 Parse *pParse, /* Parsing context */
4195 int onError, /* Conflict resolution algorithm */
4196 Table *pTab /* The table with the non-unique rowid */
4197 ){
4198 char *zMsg;
4199 int rc;
4200 if( pTab->iPKey>=0 ){
4201 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
4202 pTab->aCol[pTab->iPKey].zName);
4203 rc = SQLITE_CONSTRAINT_PRIMARYKEY;
4204 }else{
4205 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
4206 rc = SQLITE_CONSTRAINT_ROWID;
4207 }
4208 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
4209 P5_ConstraintUnique);
4210 }
4211
4212 /*
4213 ** Check to see if pIndex uses the collating sequence pColl. Return
4214 ** true if it does and false if it does not.
4215 */
4216 #ifndef SQLITE_OMIT_REINDEX
collationMatch(const char * zColl,Index * pIndex)4217 static int collationMatch(const char *zColl, Index *pIndex){
4218 int i;
4219 assert( zColl!=0 );
4220 for(i=0; i<pIndex->nColumn; i++){
4221 const char *z = pIndex->azColl[i];
4222 assert( z!=0 || pIndex->aiColumn[i]<0 );
4223 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
4224 return 1;
4225 }
4226 }
4227 return 0;
4228 }
4229 #endif
4230
4231 /*
4232 ** Recompute all indices of pTab that use the collating sequence pColl.
4233 ** If pColl==0 then recompute all indices of pTab.
4234 */
4235 #ifndef SQLITE_OMIT_REINDEX
reindexTable(Parse * pParse,Table * pTab,char const * zColl)4236 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
4237 Index *pIndex; /* An index associated with pTab */
4238
4239 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
4240 if( zColl==0 || collationMatch(zColl, pIndex) ){
4241 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
4242 sqlite3BeginWriteOperation(pParse, 0, iDb);
4243 sqlite3RefillIndex(pParse, pIndex, -1);
4244 }
4245 }
4246 }
4247 #endif
4248
4249 /*
4250 ** Recompute all indices of all tables in all databases where the
4251 ** indices use the collating sequence pColl. If pColl==0 then recompute
4252 ** all indices everywhere.
4253 */
4254 #ifndef SQLITE_OMIT_REINDEX
reindexDatabases(Parse * pParse,char const * zColl)4255 static void reindexDatabases(Parse *pParse, char const *zColl){
4256 Db *pDb; /* A single database */
4257 int iDb; /* The database index number */
4258 sqlite3 *db = pParse->db; /* The database connection */
4259 HashElem *k; /* For looping over tables in pDb */
4260 Table *pTab; /* A table in the database */
4261
4262 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
4263 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
4264 assert( pDb!=0 );
4265 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
4266 pTab = (Table*)sqliteHashData(k);
4267 reindexTable(pParse, pTab, zColl);
4268 }
4269 }
4270 }
4271 #endif
4272
4273 /*
4274 ** Generate code for the REINDEX command.
4275 **
4276 ** REINDEX -- 1
4277 ** REINDEX <collation> -- 2
4278 ** REINDEX ?<database>.?<tablename> -- 3
4279 ** REINDEX ?<database>.?<indexname> -- 4
4280 **
4281 ** Form 1 causes all indices in all attached databases to be rebuilt.
4282 ** Form 2 rebuilds all indices in all databases that use the named
4283 ** collating function. Forms 3 and 4 rebuild the named index or all
4284 ** indices associated with the named table.
4285 */
4286 #ifndef SQLITE_OMIT_REINDEX
sqlite3Reindex(Parse * pParse,Token * pName1,Token * pName2)4287 void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
4288 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
4289 char *z; /* Name of a table or index */
4290 const char *zDb; /* Name of the database */
4291 Table *pTab; /* A table in the database */
4292 Index *pIndex; /* An index associated with pTab */
4293 int iDb; /* The database index number */
4294 sqlite3 *db = pParse->db; /* The database connection */
4295 Token *pObjName; /* Name of the table or index to be reindexed */
4296
4297 /* Read the database schema. If an error occurs, leave an error message
4298 ** and code in pParse and return NULL. */
4299 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
4300 return;
4301 }
4302
4303 if( pName1==0 ){
4304 reindexDatabases(pParse, 0);
4305 return;
4306 }else if( NEVER(pName2==0) || pName2->z==0 ){
4307 char *zColl;
4308 assert( pName1->z );
4309 zColl = sqlite3NameFromToken(pParse->db, pName1);
4310 if( !zColl ) return;
4311 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
4312 if( pColl ){
4313 reindexDatabases(pParse, zColl);
4314 sqlite3DbFree(db, zColl);
4315 return;
4316 }
4317 sqlite3DbFree(db, zColl);
4318 }
4319 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
4320 if( iDb<0 ) return;
4321 z = sqlite3NameFromToken(db, pObjName);
4322 if( z==0 ) return;
4323 zDb = db->aDb[iDb].zDbSName;
4324 pTab = sqlite3FindTable(db, z, zDb);
4325 if( pTab ){
4326 reindexTable(pParse, pTab, 0);
4327 sqlite3DbFree(db, z);
4328 return;
4329 }
4330 pIndex = sqlite3FindIndex(db, z, zDb);
4331 sqlite3DbFree(db, z);
4332 if( pIndex ){
4333 sqlite3BeginWriteOperation(pParse, 0, iDb);
4334 sqlite3RefillIndex(pParse, pIndex, -1);
4335 return;
4336 }
4337 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
4338 }
4339 #endif
4340
4341 /*
4342 ** Return a KeyInfo structure that is appropriate for the given Index.
4343 **
4344 ** The caller should invoke sqlite3KeyInfoUnref() on the returned object
4345 ** when it has finished using it.
4346 */
sqlite3KeyInfoOfIndex(Parse * pParse,Index * pIdx)4347 KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
4348 int i;
4349 int nCol = pIdx->nColumn;
4350 int nKey = pIdx->nKeyCol;
4351 KeyInfo *pKey;
4352 if( pParse->nErr ) return 0;
4353 if( pIdx->uniqNotNull ){
4354 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
4355 }else{
4356 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
4357 }
4358 if( pKey ){
4359 assert( sqlite3KeyInfoIsWriteable(pKey) );
4360 for(i=0; i<nCol; i++){
4361 const char *zColl = pIdx->azColl[i];
4362 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
4363 sqlite3LocateCollSeq(pParse, zColl);
4364 pKey->aSortOrder[i] = pIdx->aSortOrder[i];
4365 }
4366 if( pParse->nErr ){
4367 sqlite3KeyInfoUnref(pKey);
4368 pKey = 0;
4369 }
4370 }
4371 return pKey;
4372 }
4373
4374 #ifndef SQLITE_OMIT_CTE
4375 /*
4376 ** This routine is invoked once per CTE by the parser while parsing a
4377 ** WITH clause.
4378 */
sqlite3WithAdd(Parse * pParse,With * pWith,Token * pName,ExprList * pArglist,Select * pQuery)4379 With *sqlite3WithAdd(
4380 Parse *pParse, /* Parsing context */
4381 With *pWith, /* Existing WITH clause, or NULL */
4382 Token *pName, /* Name of the common-table */
4383 ExprList *pArglist, /* Optional column name list for the table */
4384 Select *pQuery /* Query used to initialize the table */
4385 ){
4386 sqlite3 *db = pParse->db;
4387 With *pNew;
4388 char *zName;
4389
4390 /* Check that the CTE name is unique within this WITH clause. If
4391 ** not, store an error in the Parse structure. */
4392 zName = sqlite3NameFromToken(pParse->db, pName);
4393 if( zName && pWith ){
4394 int i;
4395 for(i=0; i<pWith->nCte; i++){
4396 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
4397 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
4398 }
4399 }
4400 }
4401
4402 if( pWith ){
4403 int nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
4404 pNew = sqlite3DbRealloc(db, pWith, nByte);
4405 }else{
4406 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
4407 }
4408 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
4409
4410 if( db->mallocFailed ){
4411 sqlite3ExprListDelete(db, pArglist);
4412 sqlite3SelectDelete(db, pQuery);
4413 sqlite3DbFree(db, zName);
4414 pNew = pWith;
4415 }else{
4416 pNew->a[pNew->nCte].pSelect = pQuery;
4417 pNew->a[pNew->nCte].pCols = pArglist;
4418 pNew->a[pNew->nCte].zName = zName;
4419 pNew->a[pNew->nCte].zCteErr = 0;
4420 pNew->nCte++;
4421 }
4422
4423 return pNew;
4424 }
4425
4426 /*
4427 ** Free the contents of the With object passed as the second argument.
4428 */
sqlite3WithDelete(sqlite3 * db,With * pWith)4429 void sqlite3WithDelete(sqlite3 *db, With *pWith){
4430 if( pWith ){
4431 int i;
4432 for(i=0; i<pWith->nCte; i++){
4433 struct Cte *pCte = &pWith->a[i];
4434 sqlite3ExprListDelete(db, pCte->pCols);
4435 sqlite3SelectDelete(db, pCte->pSelect);
4436 sqlite3DbFree(db, pCte->zName);
4437 }
4438 sqlite3DbFree(db, pWith);
4439 }
4440 }
4441 #endif /* !defined(SQLITE_OMIT_CTE) */
4442