000001 /*
000002 ** 2001 September 15
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 ** This file contains C code routines that are called by the SQLite parser
000013 ** when syntax rules are reduced. The routines in this file handle the
000014 ** following kinds of SQL syntax:
000015 **
000016 ** CREATE TABLE
000017 ** DROP TABLE
000018 ** CREATE INDEX
000019 ** DROP INDEX
000020 ** creating ID lists
000021 ** BEGIN TRANSACTION
000022 ** COMMIT
000023 ** ROLLBACK
000024 */
000025 #include "sqliteInt.h"
000026
000027 #ifndef SQLITE_OMIT_SHARED_CACHE
000028 /*
000029 ** The TableLock structure is only used by the sqlite3TableLock() and
000030 ** codeTableLocks() functions.
000031 */
000032 struct TableLock {
000033 int iDb; /* The database containing the table to be locked */
000034 int iTab; /* The root page of the table to be locked */
000035 u8 isWriteLock; /* True for write lock. False for a read lock */
000036 const char *zLockName; /* Name of the table */
000037 };
000038
000039 /*
000040 ** Record the fact that we want to lock a table at run-time.
000041 **
000042 ** The table to be locked has root page iTab and is found in database iDb.
000043 ** A read or a write lock can be taken depending on isWritelock.
000044 **
000045 ** This routine just records the fact that the lock is desired. The
000046 ** code to make the lock occur is generated by a later call to
000047 ** codeTableLocks() which occurs during sqlite3FinishCoding().
000048 */
000049 void sqlite3TableLock(
000050 Parse *pParse, /* Parsing context */
000051 int iDb, /* Index of the database containing the table to lock */
000052 int iTab, /* Root page number of the table to be locked */
000053 u8 isWriteLock, /* True for a write lock */
000054 const char *zName /* Name of the table to be locked */
000055 ){
000056 Parse *pToplevel = sqlite3ParseToplevel(pParse);
000057 int i;
000058 int nBytes;
000059 TableLock *p;
000060 assert( iDb>=0 );
000061
000062 if( iDb==1 ) return;
000063 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
000064 for(i=0; i<pToplevel->nTableLock; i++){
000065 p = &pToplevel->aTableLock[i];
000066 if( p->iDb==iDb && p->iTab==iTab ){
000067 p->isWriteLock = (p->isWriteLock || isWriteLock);
000068 return;
000069 }
000070 }
000071
000072 nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
000073 pToplevel->aTableLock =
000074 sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
000075 if( pToplevel->aTableLock ){
000076 p = &pToplevel->aTableLock[pToplevel->nTableLock++];
000077 p->iDb = iDb;
000078 p->iTab = iTab;
000079 p->isWriteLock = isWriteLock;
000080 p->zLockName = zName;
000081 }else{
000082 pToplevel->nTableLock = 0;
000083 sqlite3OomFault(pToplevel->db);
000084 }
000085 }
000086
000087 /*
000088 ** Code an OP_TableLock instruction for each table locked by the
000089 ** statement (configured by calls to sqlite3TableLock()).
000090 */
000091 static void codeTableLocks(Parse *pParse){
000092 int i;
000093 Vdbe *pVdbe;
000094
000095 pVdbe = sqlite3GetVdbe(pParse);
000096 assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
000097
000098 for(i=0; i<pParse->nTableLock; i++){
000099 TableLock *p = &pParse->aTableLock[i];
000100 int p1 = p->iDb;
000101 sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
000102 p->zLockName, P4_STATIC);
000103 }
000104 }
000105 #else
000106 #define codeTableLocks(x)
000107 #endif
000108
000109 /*
000110 ** Return TRUE if the given yDbMask object is empty - if it contains no
000111 ** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero()
000112 ** macros when SQLITE_MAX_ATTACHED is greater than 30.
000113 */
000114 #if SQLITE_MAX_ATTACHED>30
000115 int sqlite3DbMaskAllZero(yDbMask m){
000116 int i;
000117 for(i=0; i<sizeof(yDbMask); i++) if( m[i] ) return 0;
000118 return 1;
000119 }
000120 #endif
000121
000122 /*
000123 ** This routine is called after a single SQL statement has been
000124 ** parsed and a VDBE program to execute that statement has been
000125 ** prepared. This routine puts the finishing touches on the
000126 ** VDBE program and resets the pParse structure for the next
000127 ** parse.
000128 **
000129 ** Note that if an error occurred, it might be the case that
000130 ** no VDBE code was generated.
000131 */
000132 void sqlite3FinishCoding(Parse *pParse){
000133 sqlite3 *db;
000134 Vdbe *v;
000135
000136 assert( pParse->pToplevel==0 );
000137 db = pParse->db;
000138 if( pParse->nested ) return;
000139 if( db->mallocFailed || pParse->nErr ){
000140 if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;
000141 return;
000142 }
000143
000144 /* Begin by generating some termination code at the end of the
000145 ** vdbe program
000146 */
000147 v = sqlite3GetVdbe(pParse);
000148 assert( !pParse->isMultiWrite
000149 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
000150 if( v ){
000151 sqlite3VdbeAddOp0(v, OP_Halt);
000152
000153 #if SQLITE_USER_AUTHENTICATION
000154 if( pParse->nTableLock>0 && db->init.busy==0 ){
000155 sqlite3UserAuthInit(db);
000156 if( db->auth.authLevel<UAUTH_User ){
000157 sqlite3ErrorMsg(pParse, "user not authenticated");
000158 pParse->rc = SQLITE_AUTH_USER;
000159 return;
000160 }
000161 }
000162 #endif
000163
000164 /* The cookie mask contains one bit for each database file open.
000165 ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
000166 ** set for each database that is used. Generate code to start a
000167 ** transaction on each used database and to verify the schema cookie
000168 ** on each used database.
000169 */
000170 if( db->mallocFailed==0
000171 && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)
000172 ){
000173 int iDb, i;
000174 assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
000175 sqlite3VdbeJumpHere(v, 0);
000176 for(iDb=0; iDb<db->nDb; iDb++){
000177 Schema *pSchema;
000178 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
000179 sqlite3VdbeUsesBtree(v, iDb);
000180 pSchema = db->aDb[iDb].pSchema;
000181 sqlite3VdbeAddOp4Int(v,
000182 OP_Transaction, /* Opcode */
000183 iDb, /* P1 */
000184 DbMaskTest(pParse->writeMask,iDb), /* P2 */
000185 pSchema->schema_cookie, /* P3 */
000186 pSchema->iGeneration /* P4 */
000187 );
000188 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
000189 VdbeComment((v,
000190 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
000191 }
000192 #ifndef SQLITE_OMIT_VIRTUALTABLE
000193 for(i=0; i<pParse->nVtabLock; i++){
000194 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
000195 sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
000196 }
000197 pParse->nVtabLock = 0;
000198 #endif
000199
000200 /* Once all the cookies have been verified and transactions opened,
000201 ** obtain the required table-locks. This is a no-op unless the
000202 ** shared-cache feature is enabled.
000203 */
000204 codeTableLocks(pParse);
000205
000206 /* Initialize any AUTOINCREMENT data structures required.
000207 */
000208 sqlite3AutoincrementBegin(pParse);
000209
000210 /* Code constant expressions that where factored out of inner loops */
000211 if( pParse->pConstExpr ){
000212 ExprList *pEL = pParse->pConstExpr;
000213 pParse->okConstFactor = 0;
000214 for(i=0; i<pEL->nExpr; i++){
000215 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
000216 }
000217 }
000218
000219 /* Finally, jump back to the beginning of the executable code. */
000220 sqlite3VdbeGoto(v, 1);
000221 }
000222 }
000223
000224
000225 /* Get the VDBE program ready for execution
000226 */
000227 if( v && pParse->nErr==0 && !db->mallocFailed ){
000228 /* A minimum of one cursor is required if autoincrement is used
000229 * See ticket [a696379c1f08866] */
000230 assert( pParse->pAinc==0 || pParse->nTab>0 );
000231 sqlite3VdbeMakeReady(v, pParse);
000232 pParse->rc = SQLITE_DONE;
000233 }else{
000234 pParse->rc = SQLITE_ERROR;
000235 }
000236 }
000237
000238 /*
000239 ** Run the parser and code generator recursively in order to generate
000240 ** code for the SQL statement given onto the end of the pParse context
000241 ** currently under construction. When the parser is run recursively
000242 ** this way, the final OP_Halt is not appended and other initialization
000243 ** and finalization steps are omitted because those are handling by the
000244 ** outermost parser.
000245 **
000246 ** Not everything is nestable. This facility is designed to permit
000247 ** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use
000248 ** care if you decide to try to use this routine for some other purposes.
000249 */
000250 void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
000251 va_list ap;
000252 char *zSql;
000253 char *zErrMsg = 0;
000254 sqlite3 *db = pParse->db;
000255 char saveBuf[PARSE_TAIL_SZ];
000256
000257 if( pParse->nErr ) return;
000258 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
000259 va_start(ap, zFormat);
000260 zSql = sqlite3VMPrintf(db, zFormat, ap);
000261 va_end(ap);
000262 if( zSql==0 ){
000263 /* This can result either from an OOM or because the formatted string
000264 ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set
000265 ** an error */
000266 if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
000267 pParse->nErr++;
000268 return;
000269 }
000270 pParse->nested++;
000271 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
000272 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
000273 sqlite3RunParser(pParse, zSql, &zErrMsg);
000274 sqlite3DbFree(db, zErrMsg);
000275 sqlite3DbFree(db, zSql);
000276 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
000277 pParse->nested--;
000278 }
000279
000280 #if SQLITE_USER_AUTHENTICATION
000281 /*
000282 ** Return TRUE if zTable is the name of the system table that stores the
000283 ** list of users and their access credentials.
000284 */
000285 int sqlite3UserAuthTable(const char *zTable){
000286 return sqlite3_stricmp(zTable, "sqlite_user")==0;
000287 }
000288 #endif
000289
000290 /*
000291 ** Locate the in-memory structure that describes a particular database
000292 ** table given the name of that table and (optionally) the name of the
000293 ** database containing the table. Return NULL if not found.
000294 **
000295 ** If zDatabase is 0, all databases are searched for the table and the
000296 ** first matching table is returned. (No checking for duplicate table
000297 ** names is done.) The search order is TEMP first, then MAIN, then any
000298 ** auxiliary databases added using the ATTACH command.
000299 **
000300 ** See also sqlite3LocateTable().
000301 */
000302 Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
000303 Table *p = 0;
000304 int i;
000305
000306 /* All mutexes are required for schema access. Make sure we hold them. */
000307 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
000308 #if SQLITE_USER_AUTHENTICATION
000309 /* Only the admin user is allowed to know that the sqlite_user table
000310 ** exists */
000311 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
000312 return 0;
000313 }
000314 #endif
000315 while(1){
000316 for(i=OMIT_TEMPDB; i<db->nDb; i++){
000317 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
000318 if( zDatabase==0 || sqlite3StrICmp(zDatabase, db->aDb[j].zDbSName)==0 ){
000319 assert( sqlite3SchemaMutexHeld(db, j, 0) );
000320 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
000321 if( p ) return p;
000322 }
000323 }
000324 /* Not found. If the name we were looking for was temp.sqlite_master
000325 ** then change the name to sqlite_temp_master and try again. */
000326 if( sqlite3StrICmp(zName, MASTER_NAME)!=0 ) break;
000327 if( sqlite3_stricmp(zDatabase, db->aDb[1].zDbSName)!=0 ) break;
000328 zName = TEMP_MASTER_NAME;
000329 }
000330 return 0;
000331 }
000332
000333 /*
000334 ** Locate the in-memory structure that describes a particular database
000335 ** table given the name of that table and (optionally) the name of the
000336 ** database containing the table. Return NULL if not found. Also leave an
000337 ** error message in pParse->zErrMsg.
000338 **
000339 ** The difference between this routine and sqlite3FindTable() is that this
000340 ** routine leaves an error message in pParse->zErrMsg where
000341 ** sqlite3FindTable() does not.
000342 */
000343 Table *sqlite3LocateTable(
000344 Parse *pParse, /* context in which to report errors */
000345 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
000346 const char *zName, /* Name of the table we are looking for */
000347 const char *zDbase /* Name of the database. Might be NULL */
000348 ){
000349 Table *p;
000350 sqlite3 *db = pParse->db;
000351
000352 /* Read the database schema. If an error occurs, leave an error message
000353 ** and code in pParse and return NULL. */
000354 if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
000355 && SQLITE_OK!=sqlite3ReadSchema(pParse)
000356 ){
000357 return 0;
000358 }
000359
000360 p = sqlite3FindTable(db, zName, zDbase);
000361 if( p==0 ){
000362 #ifndef SQLITE_OMIT_VIRTUALTABLE
000363 /* If zName is the not the name of a table in the schema created using
000364 ** CREATE, then check to see if it is the name of an virtual table that
000365 ** can be an eponymous virtual table. */
000366 if( pParse->disableVtab==0 ){
000367 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
000368 if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
000369 pMod = sqlite3PragmaVtabRegister(db, zName);
000370 }
000371 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
000372 return pMod->pEpoTab;
000373 }
000374 }
000375 #endif
000376 if( flags & LOCATE_NOERR ) return 0;
000377 pParse->checkSchema = 1;
000378 }else if( IsVirtual(p) && pParse->disableVtab ){
000379 p = 0;
000380 }
000381
000382 if( p==0 ){
000383 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
000384 if( zDbase ){
000385 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
000386 }else{
000387 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
000388 }
000389 }
000390
000391 return p;
000392 }
000393
000394 /*
000395 ** Locate the table identified by *p.
000396 **
000397 ** This is a wrapper around sqlite3LocateTable(). The difference between
000398 ** sqlite3LocateTable() and this function is that this function restricts
000399 ** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
000400 ** non-NULL if it is part of a view or trigger program definition. See
000401 ** sqlite3FixSrcList() for details.
000402 */
000403 Table *sqlite3LocateTableItem(
000404 Parse *pParse,
000405 u32 flags,
000406 struct SrcList_item *p
000407 ){
000408 const char *zDb;
000409 assert( p->pSchema==0 || p->zDatabase==0 );
000410 if( p->pSchema ){
000411 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
000412 zDb = pParse->db->aDb[iDb].zDbSName;
000413 }else{
000414 zDb = p->zDatabase;
000415 }
000416 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
000417 }
000418
000419 /*
000420 ** Locate the in-memory structure that describes
000421 ** a particular index given the name of that index
000422 ** and the name of the database that contains the index.
000423 ** Return NULL if not found.
000424 **
000425 ** If zDatabase is 0, all databases are searched for the
000426 ** table and the first matching index is returned. (No checking
000427 ** for duplicate index names is done.) The search order is
000428 ** TEMP first, then MAIN, then any auxiliary databases added
000429 ** using the ATTACH command.
000430 */
000431 Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
000432 Index *p = 0;
000433 int i;
000434 /* All mutexes are required for schema access. Make sure we hold them. */
000435 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
000436 for(i=OMIT_TEMPDB; i<db->nDb; i++){
000437 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
000438 Schema *pSchema = db->aDb[j].pSchema;
000439 assert( pSchema );
000440 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zDbSName) ) continue;
000441 assert( sqlite3SchemaMutexHeld(db, j, 0) );
000442 p = sqlite3HashFind(&pSchema->idxHash, zName);
000443 if( p ) break;
000444 }
000445 return p;
000446 }
000447
000448 /*
000449 ** Reclaim the memory used by an index
000450 */
000451 void sqlite3FreeIndex(sqlite3 *db, Index *p){
000452 #ifndef SQLITE_OMIT_ANALYZE
000453 sqlite3DeleteIndexSamples(db, p);
000454 #endif
000455 sqlite3ExprDelete(db, p->pPartIdxWhere);
000456 sqlite3ExprListDelete(db, p->aColExpr);
000457 sqlite3DbFree(db, p->zColAff);
000458 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
000459 #ifdef SQLITE_ENABLE_STAT4
000460 sqlite3_free(p->aiRowEst);
000461 #endif
000462 sqlite3DbFree(db, p);
000463 }
000464
000465 /*
000466 ** For the index called zIdxName which is found in the database iDb,
000467 ** unlike that index from its Table then remove the index from
000468 ** the index hash table and free all memory structures associated
000469 ** with the index.
000470 */
000471 void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
000472 Index *pIndex;
000473 Hash *pHash;
000474
000475 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
000476 pHash = &db->aDb[iDb].pSchema->idxHash;
000477 pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
000478 if( ALWAYS(pIndex) ){
000479 if( pIndex->pTable->pIndex==pIndex ){
000480 pIndex->pTable->pIndex = pIndex->pNext;
000481 }else{
000482 Index *p;
000483 /* Justification of ALWAYS(); The index must be on the list of
000484 ** indices. */
000485 p = pIndex->pTable->pIndex;
000486 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
000487 if( ALWAYS(p && p->pNext==pIndex) ){
000488 p->pNext = pIndex->pNext;
000489 }
000490 }
000491 sqlite3FreeIndex(db, pIndex);
000492 }
000493 db->mDbFlags |= DBFLAG_SchemaChange;
000494 }
000495
000496 /*
000497 ** Look through the list of open database files in db->aDb[] and if
000498 ** any have been closed, remove them from the list. Reallocate the
000499 ** db->aDb[] structure to a smaller size, if possible.
000500 **
000501 ** Entry 0 (the "main" database) and entry 1 (the "temp" database)
000502 ** are never candidates for being collapsed.
000503 */
000504 void sqlite3CollapseDatabaseArray(sqlite3 *db){
000505 int i, j;
000506 for(i=j=2; i<db->nDb; i++){
000507 struct Db *pDb = &db->aDb[i];
000508 if( pDb->pBt==0 ){
000509 sqlite3DbFree(db, pDb->zDbSName);
000510 pDb->zDbSName = 0;
000511 continue;
000512 }
000513 if( j<i ){
000514 db->aDb[j] = db->aDb[i];
000515 }
000516 j++;
000517 }
000518 db->nDb = j;
000519 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
000520 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
000521 sqlite3DbFree(db, db->aDb);
000522 db->aDb = db->aDbStatic;
000523 }
000524 }
000525
000526 /*
000527 ** Reset the schema for the database at index iDb. Also reset the
000528 ** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
000529 ** Deferred resets may be run by calling with iDb<0.
000530 */
000531 void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
000532 int i;
000533 assert( iDb<db->nDb );
000534
000535 if( iDb>=0 ){
000536 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
000537 DbSetProperty(db, iDb, DB_ResetWanted);
000538 DbSetProperty(db, 1, DB_ResetWanted);
000539 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
000540 }
000541
000542 if( db->nSchemaLock==0 ){
000543 for(i=0; i<db->nDb; i++){
000544 if( DbHasProperty(db, i, DB_ResetWanted) ){
000545 sqlite3SchemaClear(db->aDb[i].pSchema);
000546 }
000547 }
000548 }
000549 }
000550
000551 /*
000552 ** Erase all schema information from all attached databases (including
000553 ** "main" and "temp") for a single database connection.
000554 */
000555 void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
000556 int i;
000557 sqlite3BtreeEnterAll(db);
000558 for(i=0; i<db->nDb; i++){
000559 Db *pDb = &db->aDb[i];
000560 if( pDb->pSchema ){
000561 if( db->nSchemaLock==0 ){
000562 sqlite3SchemaClear(pDb->pSchema);
000563 }else{
000564 DbSetProperty(db, i, DB_ResetWanted);
000565 }
000566 }
000567 }
000568 db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
000569 sqlite3VtabUnlockList(db);
000570 sqlite3BtreeLeaveAll(db);
000571 if( db->nSchemaLock==0 ){
000572 sqlite3CollapseDatabaseArray(db);
000573 }
000574 }
000575
000576 /*
000577 ** This routine is called when a commit occurs.
000578 */
000579 void sqlite3CommitInternalChanges(sqlite3 *db){
000580 db->mDbFlags &= ~DBFLAG_SchemaChange;
000581 }
000582
000583 /*
000584 ** Delete memory allocated for the column names of a table or view (the
000585 ** Table.aCol[] array).
000586 */
000587 void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
000588 int i;
000589 Column *pCol;
000590 assert( pTable!=0 );
000591 if( (pCol = pTable->aCol)!=0 ){
000592 for(i=0; i<pTable->nCol; i++, pCol++){
000593 sqlite3DbFree(db, pCol->zName);
000594 sqlite3ExprDelete(db, pCol->pDflt);
000595 sqlite3DbFree(db, pCol->zColl);
000596 }
000597 sqlite3DbFree(db, pTable->aCol);
000598 }
000599 }
000600
000601 /*
000602 ** Remove the memory data structures associated with the given
000603 ** Table. No changes are made to disk by this routine.
000604 **
000605 ** This routine just deletes the data structure. It does not unlink
000606 ** the table data structure from the hash table. But it does destroy
000607 ** memory structures of the indices and foreign keys associated with
000608 ** the table.
000609 **
000610 ** The db parameter is optional. It is needed if the Table object
000611 ** contains lookaside memory. (Table objects in the schema do not use
000612 ** lookaside memory, but some ephemeral Table objects do.) Or the
000613 ** db parameter can be used with db->pnBytesFreed to measure the memory
000614 ** used by the Table object.
000615 */
000616 static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
000617 Index *pIndex, *pNext;
000618
000619 #ifdef SQLITE_DEBUG
000620 /* Record the number of outstanding lookaside allocations in schema Tables
000621 ** prior to doing any free() operations. Since schema Tables do not use
000622 ** lookaside, this number should not change.
000623 **
000624 ** If malloc has already failed, it may be that it failed while allocating
000625 ** a Table object that was going to be marked ephemeral. So do not check
000626 ** that no lookaside memory is used in this case either. */
000627 int nLookaside = 0;
000628 if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){
000629 nLookaside = sqlite3LookasideUsed(db, 0);
000630 }
000631 #endif
000632
000633 /* Delete all indices associated with this table. */
000634 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
000635 pNext = pIndex->pNext;
000636 assert( pIndex->pSchema==pTable->pSchema
000637 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
000638 if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){
000639 char *zName = pIndex->zName;
000640 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
000641 &pIndex->pSchema->idxHash, zName, 0
000642 );
000643 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
000644 assert( pOld==pIndex || pOld==0 );
000645 }
000646 sqlite3FreeIndex(db, pIndex);
000647 }
000648
000649 /* Delete any foreign keys attached to this table. */
000650 sqlite3FkDelete(db, pTable);
000651
000652 /* Delete the Table structure itself.
000653 */
000654 sqlite3DeleteColumnNames(db, pTable);
000655 sqlite3DbFree(db, pTable->zName);
000656 sqlite3DbFree(db, pTable->zColAff);
000657 sqlite3SelectDelete(db, pTable->pSelect);
000658 sqlite3ExprListDelete(db, pTable->pCheck);
000659 #ifndef SQLITE_OMIT_VIRTUALTABLE
000660 sqlite3VtabClear(db, pTable);
000661 #endif
000662 sqlite3DbFree(db, pTable);
000663
000664 /* Verify that no lookaside memory was used by schema tables */
000665 assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) );
000666 }
000667 void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
000668 /* Do not delete the table until the reference count reaches zero. */
000669 if( !pTable ) return;
000670 if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return;
000671 deleteTable(db, pTable);
000672 }
000673
000674
000675 /*
000676 ** Unlink the given table from the hash tables and the delete the
000677 ** table structure with all its indices and foreign keys.
000678 */
000679 void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
000680 Table *p;
000681 Db *pDb;
000682
000683 assert( db!=0 );
000684 assert( iDb>=0 && iDb<db->nDb );
000685 assert( zTabName );
000686 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
000687 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
000688 pDb = &db->aDb[iDb];
000689 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
000690 sqlite3DeleteTable(db, p);
000691 db->mDbFlags |= DBFLAG_SchemaChange;
000692 }
000693
000694 /*
000695 ** Given a token, return a string that consists of the text of that
000696 ** token. Space to hold the returned string
000697 ** is obtained from sqliteMalloc() and must be freed by the calling
000698 ** function.
000699 **
000700 ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
000701 ** surround the body of the token are removed.
000702 **
000703 ** Tokens are often just pointers into the original SQL text and so
000704 ** are not \000 terminated and are not persistent. The returned string
000705 ** is \000 terminated and is persistent.
000706 */
000707 char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
000708 char *zName;
000709 if( pName ){
000710 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
000711 sqlite3Dequote(zName);
000712 }else{
000713 zName = 0;
000714 }
000715 return zName;
000716 }
000717
000718 /*
000719 ** Open the sqlite_master table stored in database number iDb for
000720 ** writing. The table is opened using cursor 0.
000721 */
000722 void sqlite3OpenMasterTable(Parse *p, int iDb){
000723 Vdbe *v = sqlite3GetVdbe(p);
000724 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, MASTER_NAME);
000725 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
000726 if( p->nTab==0 ){
000727 p->nTab = 1;
000728 }
000729 }
000730
000731 /*
000732 ** Parameter zName points to a nul-terminated buffer containing the name
000733 ** of a database ("main", "temp" or the name of an attached db). This
000734 ** function returns the index of the named database in db->aDb[], or
000735 ** -1 if the named db cannot be found.
000736 */
000737 int sqlite3FindDbName(sqlite3 *db, const char *zName){
000738 int i = -1; /* Database number */
000739 if( zName ){
000740 Db *pDb;
000741 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
000742 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
000743 /* "main" is always an acceptable alias for the primary database
000744 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
000745 if( i==0 && 0==sqlite3_stricmp("main", zName) ) break;
000746 }
000747 }
000748 return i;
000749 }
000750
000751 /*
000752 ** The token *pName contains the name of a database (either "main" or
000753 ** "temp" or the name of an attached db). This routine returns the
000754 ** index of the named database in db->aDb[], or -1 if the named db
000755 ** does not exist.
000756 */
000757 int sqlite3FindDb(sqlite3 *db, Token *pName){
000758 int i; /* Database number */
000759 char *zName; /* Name we are searching for */
000760 zName = sqlite3NameFromToken(db, pName);
000761 i = sqlite3FindDbName(db, zName);
000762 sqlite3DbFree(db, zName);
000763 return i;
000764 }
000765
000766 /* The table or view or trigger name is passed to this routine via tokens
000767 ** pName1 and pName2. If the table name was fully qualified, for example:
000768 **
000769 ** CREATE TABLE xxx.yyy (...);
000770 **
000771 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
000772 ** the table name is not fully qualified, i.e.:
000773 **
000774 ** CREATE TABLE yyy(...);
000775 **
000776 ** Then pName1 is set to "yyy" and pName2 is "".
000777 **
000778 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
000779 ** pName2) that stores the unqualified table name. The index of the
000780 ** database "xxx" is returned.
000781 */
000782 int sqlite3TwoPartName(
000783 Parse *pParse, /* Parsing and code generating context */
000784 Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
000785 Token *pName2, /* The "yyy" in the name "xxx.yyy" */
000786 Token **pUnqual /* Write the unqualified object name here */
000787 ){
000788 int iDb; /* Database holding the object */
000789 sqlite3 *db = pParse->db;
000790
000791 assert( pName2!=0 );
000792 if( pName2->n>0 ){
000793 if( db->init.busy ) {
000794 sqlite3ErrorMsg(pParse, "corrupt database");
000795 return -1;
000796 }
000797 *pUnqual = pName2;
000798 iDb = sqlite3FindDb(db, pName1);
000799 if( iDb<0 ){
000800 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
000801 return -1;
000802 }
000803 }else{
000804 assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT
000805 || (db->mDbFlags & DBFLAG_Vacuum)!=0);
000806 iDb = db->init.iDb;
000807 *pUnqual = pName1;
000808 }
000809 return iDb;
000810 }
000811
000812 /*
000813 ** True if PRAGMA writable_schema is ON
000814 */
000815 int sqlite3WritableSchema(sqlite3 *db){
000816 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
000817 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
000818 SQLITE_WriteSchema );
000819 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
000820 SQLITE_Defensive );
000821 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
000822 (SQLITE_WriteSchema|SQLITE_Defensive) );
000823 return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
000824 }
000825
000826 /*
000827 ** This routine is used to check if the UTF-8 string zName is a legal
000828 ** unqualified name for a new schema object (table, index, view or
000829 ** trigger). All names are legal except those that begin with the string
000830 ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
000831 ** is reserved for internal use.
000832 **
000833 ** When parsing the sqlite_master table, this routine also checks to
000834 ** make sure the "type", "name", and "tbl_name" columns are consistent
000835 ** with the SQL.
000836 */
000837 int sqlite3CheckObjectName(
000838 Parse *pParse, /* Parsing context */
000839 const char *zName, /* Name of the object to check */
000840 const char *zType, /* Type of this object */
000841 const char *zTblName /* Parent table name for triggers and indexes */
000842 ){
000843 sqlite3 *db = pParse->db;
000844 if( sqlite3WritableSchema(db) || db->init.imposterTable ){
000845 /* Skip these error checks for writable_schema=ON */
000846 return SQLITE_OK;
000847 }
000848 if( db->init.busy ){
000849 if( sqlite3_stricmp(zType, db->init.azInit[0])
000850 || sqlite3_stricmp(zName, db->init.azInit[1])
000851 || sqlite3_stricmp(zTblName, db->init.azInit[2])
000852 ){
000853 if( sqlite3Config.bExtraSchemaChecks ){
000854 sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
000855 return SQLITE_ERROR;
000856 }
000857 }
000858 }else{
000859 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
000860 || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
000861 ){
000862 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
000863 zName);
000864 return SQLITE_ERROR;
000865 }
000866
000867 }
000868 return SQLITE_OK;
000869 }
000870
000871 /*
000872 ** Return the PRIMARY KEY index of a table
000873 */
000874 Index *sqlite3PrimaryKeyIndex(Table *pTab){
000875 Index *p;
000876 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
000877 return p;
000878 }
000879
000880 /*
000881 ** Convert an table column number into a index column number. That is,
000882 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
000883 ** find the (first) offset of that column in index pIdx. Or return -1
000884 ** if column iCol is not used in index pIdx.
000885 */
000886 i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
000887 int i;
000888 for(i=0; i<pIdx->nColumn; i++){
000889 if( iCol==pIdx->aiColumn[i] ) return i;
000890 }
000891 return -1;
000892 }
000893
000894 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
000895 /* Convert a storage column number into a table column number.
000896 **
000897 ** The storage column number (0,1,2,....) is the index of the value
000898 ** as it appears in the record on disk. The true column number
000899 ** is the index (0,1,2,...) of the column in the CREATE TABLE statement.
000900 **
000901 ** The storage column number is less than the table column number if
000902 ** and only there are VIRTUAL columns to the left.
000903 **
000904 ** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
000905 */
000906 i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
000907 if( pTab->tabFlags & TF_HasVirtual ){
000908 int i;
000909 for(i=0; i<=iCol; i++){
000910 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
000911 }
000912 }
000913 return iCol;
000914 }
000915 #endif
000916
000917 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
000918 /* Convert a table column number into a storage column number.
000919 **
000920 ** The storage column number (0,1,2,....) is the index of the value
000921 ** as it appears in the record on disk. Or, if the input column is
000922 ** the N-th virtual column (zero-based) then the storage number is
000923 ** the number of non-virtual columns in the table plus N.
000924 **
000925 ** The true column number is the index (0,1,2,...) of the column in
000926 ** the CREATE TABLE statement.
000927 **
000928 ** If the input column is a VIRTUAL column, then it should not appear
000929 ** in storage. But the value sometimes is cached in registers that
000930 ** follow the range of registers used to construct storage. This
000931 ** avoids computing the same VIRTUAL column multiple times, and provides
000932 ** values for use by OP_Param opcodes in triggers. Hence, if the
000933 ** input column is a VIRTUAL table, put it after all the other columns.
000934 **
000935 ** In the following, N means "normal column", S means STORED, and
000936 ** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
000937 **
000938 ** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
000939 ** -- 0 1 2 3 4 5 6 7 8
000940 **
000941 ** Then the mapping from this function is as follows:
000942 **
000943 ** INPUTS: 0 1 2 3 4 5 6 7 8
000944 ** OUTPUTS: 0 1 6 2 3 7 4 5 8
000945 **
000946 ** So, in other words, this routine shifts all the virtual columns to
000947 ** the end.
000948 **
000949 ** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and
000950 ** this routine is a no-op macro. If the pTab does not have any virtual
000951 ** columns, then this routine is no-op that always return iCol. If iCol
000952 ** is negative (indicating the ROWID column) then this routine return iCol.
000953 */
000954 i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
000955 int i;
000956 i16 n;
000957 assert( iCol<pTab->nCol );
000958 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
000959 for(i=0, n=0; i<iCol; i++){
000960 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
000961 }
000962 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
000963 /* iCol is a virtual column itself */
000964 return pTab->nNVCol + i - n;
000965 }else{
000966 /* iCol is a normal or stored column */
000967 return n;
000968 }
000969 }
000970 #endif
000971
000972 /*
000973 ** Begin constructing a new table representation in memory. This is
000974 ** the first of several action routines that get called in response
000975 ** to a CREATE TABLE statement. In particular, this routine is called
000976 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
000977 ** flag is true if the table should be stored in the auxiliary database
000978 ** file instead of in the main database file. This is normally the case
000979 ** when the "TEMP" or "TEMPORARY" keyword occurs in between
000980 ** CREATE and TABLE.
000981 **
000982 ** The new table record is initialized and put in pParse->pNewTable.
000983 ** As more of the CREATE TABLE statement is parsed, additional action
000984 ** routines will be called to add more information to this record.
000985 ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
000986 ** is called to complete the construction of the new table record.
000987 */
000988 void sqlite3StartTable(
000989 Parse *pParse, /* Parser context */
000990 Token *pName1, /* First part of the name of the table or view */
000991 Token *pName2, /* Second part of the name of the table or view */
000992 int isTemp, /* True if this is a TEMP table */
000993 int isView, /* True if this is a VIEW */
000994 int isVirtual, /* True if this is a VIRTUAL table */
000995 int noErr /* Do nothing if table already exists */
000996 ){
000997 Table *pTable;
000998 char *zName = 0; /* The name of the new table */
000999 sqlite3 *db = pParse->db;
001000 Vdbe *v;
001001 int iDb; /* Database number to create the table in */
001002 Token *pName; /* Unqualified name of the table to create */
001003
001004 if( db->init.busy && db->init.newTnum==1 ){
001005 /* Special case: Parsing the sqlite_master or sqlite_temp_master schema */
001006 iDb = db->init.iDb;
001007 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
001008 pName = pName1;
001009 }else{
001010 /* The common case */
001011 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
001012 if( iDb<0 ) return;
001013 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
001014 /* If creating a temp table, the name may not be qualified. Unless
001015 ** the database name is "temp" anyway. */
001016 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
001017 return;
001018 }
001019 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
001020 zName = sqlite3NameFromToken(db, pName);
001021 if( IN_RENAME_OBJECT ){
001022 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
001023 }
001024 }
001025 pParse->sNameToken = *pName;
001026 if( zName==0 ) return;
001027 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
001028 goto begin_table_error;
001029 }
001030 if( db->init.iDb==1 ) isTemp = 1;
001031 #ifndef SQLITE_OMIT_AUTHORIZATION
001032 assert( isTemp==0 || isTemp==1 );
001033 assert( isView==0 || isView==1 );
001034 {
001035 static const u8 aCode[] = {
001036 SQLITE_CREATE_TABLE,
001037 SQLITE_CREATE_TEMP_TABLE,
001038 SQLITE_CREATE_VIEW,
001039 SQLITE_CREATE_TEMP_VIEW
001040 };
001041 char *zDb = db->aDb[iDb].zDbSName;
001042 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
001043 goto begin_table_error;
001044 }
001045 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
001046 zName, 0, zDb) ){
001047 goto begin_table_error;
001048 }
001049 }
001050 #endif
001051
001052 /* Make sure the new table name does not collide with an existing
001053 ** index or table name in the same database. Issue an error message if
001054 ** it does. The exception is if the statement being parsed was passed
001055 ** to an sqlite3_declare_vtab() call. In that case only the column names
001056 ** and types will be used, so there is no need to test for namespace
001057 ** collisions.
001058 */
001059 if( !IN_SPECIAL_PARSE ){
001060 char *zDb = db->aDb[iDb].zDbSName;
001061 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
001062 goto begin_table_error;
001063 }
001064 pTable = sqlite3FindTable(db, zName, zDb);
001065 if( pTable ){
001066 if( !noErr ){
001067 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
001068 }else{
001069 assert( !db->init.busy || CORRUPT_DB );
001070 sqlite3CodeVerifySchema(pParse, iDb);
001071 }
001072 goto begin_table_error;
001073 }
001074 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
001075 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
001076 goto begin_table_error;
001077 }
001078 }
001079
001080 pTable = sqlite3DbMallocZero(db, sizeof(Table));
001081 if( pTable==0 ){
001082 assert( db->mallocFailed );
001083 pParse->rc = SQLITE_NOMEM_BKPT;
001084 pParse->nErr++;
001085 goto begin_table_error;
001086 }
001087 pTable->zName = zName;
001088 pTable->iPKey = -1;
001089 pTable->pSchema = db->aDb[iDb].pSchema;
001090 pTable->nTabRef = 1;
001091 #ifdef SQLITE_DEFAULT_ROWEST
001092 pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
001093 #else
001094 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
001095 #endif
001096 assert( pParse->pNewTable==0 );
001097 pParse->pNewTable = pTable;
001098
001099 /* If this is the magic sqlite_sequence table used by autoincrement,
001100 ** then record a pointer to this table in the main database structure
001101 ** so that INSERT can find the table easily.
001102 */
001103 #ifndef SQLITE_OMIT_AUTOINCREMENT
001104 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
001105 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
001106 pTable->pSchema->pSeqTab = pTable;
001107 }
001108 #endif
001109
001110 /* Begin generating the code that will insert the table record into
001111 ** the SQLITE_MASTER table. Note in particular that we must go ahead
001112 ** and allocate the record number for the table entry now. Before any
001113 ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
001114 ** indices to be created and the table record must come before the
001115 ** indices. Hence, the record number for the table must be allocated
001116 ** now.
001117 */
001118 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
001119 int addr1;
001120 int fileFormat;
001121 int reg1, reg2, reg3;
001122 /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */
001123 static const char nullRow[] = { 6, 0, 0, 0, 0, 0 };
001124 sqlite3BeginWriteOperation(pParse, 1, iDb);
001125
001126 #ifndef SQLITE_OMIT_VIRTUALTABLE
001127 if( isVirtual ){
001128 sqlite3VdbeAddOp0(v, OP_VBegin);
001129 }
001130 #endif
001131
001132 /* If the file format and encoding in the database have not been set,
001133 ** set them now.
001134 */
001135 reg1 = pParse->regRowid = ++pParse->nMem;
001136 reg2 = pParse->regRoot = ++pParse->nMem;
001137 reg3 = ++pParse->nMem;
001138 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
001139 sqlite3VdbeUsesBtree(v, iDb);
001140 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
001141 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
001142 1 : SQLITE_MAX_FILE_FORMAT;
001143 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
001144 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
001145 sqlite3VdbeJumpHere(v, addr1);
001146
001147 /* This just creates a place-holder record in the sqlite_master table.
001148 ** The record created does not contain anything yet. It will be replaced
001149 ** by the real entry in code generated at sqlite3EndTable().
001150 **
001151 ** The rowid for the new entry is left in register pParse->regRowid.
001152 ** The root page number of the new table is left in reg pParse->regRoot.
001153 ** The rowid and root page number values are needed by the code that
001154 ** sqlite3EndTable will generate.
001155 */
001156 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
001157 if( isView || isVirtual ){
001158 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
001159 }else
001160 #endif
001161 {
001162 pParse->addrCrTab =
001163 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
001164 }
001165 sqlite3OpenMasterTable(pParse, iDb);
001166 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
001167 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
001168 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
001169 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
001170 sqlite3VdbeAddOp0(v, OP_Close);
001171 }
001172
001173 /* Normal (non-error) return. */
001174 return;
001175
001176 /* If an error occurs, we jump here */
001177 begin_table_error:
001178 sqlite3DbFree(db, zName);
001179 return;
001180 }
001181
001182 /* Set properties of a table column based on the (magical)
001183 ** name of the column.
001184 */
001185 #if SQLITE_ENABLE_HIDDEN_COLUMNS
001186 void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
001187 if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
001188 pCol->colFlags |= COLFLAG_HIDDEN;
001189 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
001190 pTab->tabFlags |= TF_OOOHidden;
001191 }
001192 }
001193 #endif
001194
001195
001196 /*
001197 ** Add a new column to the table currently being constructed.
001198 **
001199 ** The parser calls this routine once for each column declaration
001200 ** in a CREATE TABLE statement. sqlite3StartTable() gets called
001201 ** first to get things going. Then this routine is called for each
001202 ** column.
001203 */
001204 void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){
001205 Table *p;
001206 int i;
001207 char *z;
001208 char *zType;
001209 Column *pCol;
001210 sqlite3 *db = pParse->db;
001211 if( (p = pParse->pNewTable)==0 ) return;
001212 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
001213 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
001214 return;
001215 }
001216 z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
001217 if( z==0 ) return;
001218 if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName);
001219 memcpy(z, pName->z, pName->n);
001220 z[pName->n] = 0;
001221 sqlite3Dequote(z);
001222 for(i=0; i<p->nCol; i++){
001223 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
001224 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
001225 sqlite3DbFree(db, z);
001226 return;
001227 }
001228 }
001229 if( (p->nCol & 0x7)==0 ){
001230 Column *aNew;
001231 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
001232 if( aNew==0 ){
001233 sqlite3DbFree(db, z);
001234 return;
001235 }
001236 p->aCol = aNew;
001237 }
001238 pCol = &p->aCol[p->nCol];
001239 memset(pCol, 0, sizeof(p->aCol[0]));
001240 pCol->zName = z;
001241 sqlite3ColumnPropertiesFromName(p, pCol);
001242
001243 if( pType->n==0 ){
001244 /* If there is no type specified, columns have the default affinity
001245 ** 'BLOB' with a default size of 4 bytes. */
001246 pCol->affinity = SQLITE_AFF_BLOB;
001247 pCol->szEst = 1;
001248 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
001249 if( 4>=sqlite3GlobalConfig.szSorterRef ){
001250 pCol->colFlags |= COLFLAG_SORTERREF;
001251 }
001252 #endif
001253 }else{
001254 zType = z + sqlite3Strlen30(z) + 1;
001255 memcpy(zType, pType->z, pType->n);
001256 zType[pType->n] = 0;
001257 sqlite3Dequote(zType);
001258 pCol->affinity = sqlite3AffinityType(zType, pCol);
001259 pCol->colFlags |= COLFLAG_HASTYPE;
001260 }
001261 p->nCol++;
001262 p->nNVCol++;
001263 pParse->constraintName.n = 0;
001264 }
001265
001266 /*
001267 ** This routine is called by the parser while in the middle of
001268 ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
001269 ** been seen on a column. This routine sets the notNull flag on
001270 ** the column currently under construction.
001271 */
001272 void sqlite3AddNotNull(Parse *pParse, int onError){
001273 Table *p;
001274 Column *pCol;
001275 p = pParse->pNewTable;
001276 if( p==0 || NEVER(p->nCol<1) ) return;
001277 pCol = &p->aCol[p->nCol-1];
001278 pCol->notNull = (u8)onError;
001279 p->tabFlags |= TF_HasNotNull;
001280
001281 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
001282 ** on this column. */
001283 if( pCol->colFlags & COLFLAG_UNIQUE ){
001284 Index *pIdx;
001285 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
001286 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
001287 if( pIdx->aiColumn[0]==p->nCol-1 ){
001288 pIdx->uniqNotNull = 1;
001289 }
001290 }
001291 }
001292 }
001293
001294 /*
001295 ** Scan the column type name zType (length nType) and return the
001296 ** associated affinity type.
001297 **
001298 ** This routine does a case-independent search of zType for the
001299 ** substrings in the following table. If one of the substrings is
001300 ** found, the corresponding affinity is returned. If zType contains
001301 ** more than one of the substrings, entries toward the top of
001302 ** the table take priority. For example, if zType is 'BLOBINT',
001303 ** SQLITE_AFF_INTEGER is returned.
001304 **
001305 ** Substring | Affinity
001306 ** --------------------------------
001307 ** 'INT' | SQLITE_AFF_INTEGER
001308 ** 'CHAR' | SQLITE_AFF_TEXT
001309 ** 'CLOB' | SQLITE_AFF_TEXT
001310 ** 'TEXT' | SQLITE_AFF_TEXT
001311 ** 'BLOB' | SQLITE_AFF_BLOB
001312 ** 'REAL' | SQLITE_AFF_REAL
001313 ** 'FLOA' | SQLITE_AFF_REAL
001314 ** 'DOUB' | SQLITE_AFF_REAL
001315 **
001316 ** If none of the substrings in the above table are found,
001317 ** SQLITE_AFF_NUMERIC is returned.
001318 */
001319 char sqlite3AffinityType(const char *zIn, Column *pCol){
001320 u32 h = 0;
001321 char aff = SQLITE_AFF_NUMERIC;
001322 const char *zChar = 0;
001323
001324 assert( zIn!=0 );
001325 while( zIn[0] ){
001326 h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
001327 zIn++;
001328 if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
001329 aff = SQLITE_AFF_TEXT;
001330 zChar = zIn;
001331 }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
001332 aff = SQLITE_AFF_TEXT;
001333 }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
001334 aff = SQLITE_AFF_TEXT;
001335 }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
001336 && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
001337 aff = SQLITE_AFF_BLOB;
001338 if( zIn[0]=='(' ) zChar = zIn;
001339 #ifndef SQLITE_OMIT_FLOATING_POINT
001340 }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
001341 && aff==SQLITE_AFF_NUMERIC ){
001342 aff = SQLITE_AFF_REAL;
001343 }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
001344 && aff==SQLITE_AFF_NUMERIC ){
001345 aff = SQLITE_AFF_REAL;
001346 }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
001347 && aff==SQLITE_AFF_NUMERIC ){
001348 aff = SQLITE_AFF_REAL;
001349 #endif
001350 }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
001351 aff = SQLITE_AFF_INTEGER;
001352 break;
001353 }
001354 }
001355
001356 /* If pCol is not NULL, store an estimate of the field size. The
001357 ** estimate is scaled so that the size of an integer is 1. */
001358 if( pCol ){
001359 int v = 0; /* default size is approx 4 bytes */
001360 if( aff<SQLITE_AFF_NUMERIC ){
001361 if( zChar ){
001362 while( zChar[0] ){
001363 if( sqlite3Isdigit(zChar[0]) ){
001364 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
001365 sqlite3GetInt32(zChar, &v);
001366 break;
001367 }
001368 zChar++;
001369 }
001370 }else{
001371 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
001372 }
001373 }
001374 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
001375 if( v>=sqlite3GlobalConfig.szSorterRef ){
001376 pCol->colFlags |= COLFLAG_SORTERREF;
001377 }
001378 #endif
001379 v = v/4 + 1;
001380 if( v>255 ) v = 255;
001381 pCol->szEst = v;
001382 }
001383 return aff;
001384 }
001385
001386 /*
001387 ** The expression is the default value for the most recently added column
001388 ** of the table currently under construction.
001389 **
001390 ** Default value expressions must be constant. Raise an exception if this
001391 ** is not the case.
001392 **
001393 ** This routine is called by the parser while in the middle of
001394 ** parsing a CREATE TABLE statement.
001395 */
001396 void sqlite3AddDefaultValue(
001397 Parse *pParse, /* Parsing context */
001398 Expr *pExpr, /* The parsed expression of the default value */
001399 const char *zStart, /* Start of the default value text */
001400 const char *zEnd /* First character past end of defaut value text */
001401 ){
001402 Table *p;
001403 Column *pCol;
001404 sqlite3 *db = pParse->db;
001405 p = pParse->pNewTable;
001406 if( p!=0 ){
001407 pCol = &(p->aCol[p->nCol-1]);
001408 if( !sqlite3ExprIsConstantOrFunction(pExpr, db->init.busy) ){
001409 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
001410 pCol->zName);
001411 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
001412 }else if( pCol->colFlags & COLFLAG_GENERATED ){
001413 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
001414 testcase( pCol->colFlags & COLFLAG_STORED );
001415 sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
001416 #endif
001417 }else{
001418 /* A copy of pExpr is used instead of the original, as pExpr contains
001419 ** tokens that point to volatile memory.
001420 */
001421 Expr x;
001422 sqlite3ExprDelete(db, pCol->pDflt);
001423 memset(&x, 0, sizeof(x));
001424 x.op = TK_SPAN;
001425 x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
001426 x.pLeft = pExpr;
001427 x.flags = EP_Skip;
001428 pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
001429 sqlite3DbFree(db, x.u.zToken);
001430 }
001431 }
001432 if( IN_RENAME_OBJECT ){
001433 sqlite3RenameExprUnmap(pParse, pExpr);
001434 }
001435 sqlite3ExprDelete(db, pExpr);
001436 }
001437
001438 /*
001439 ** Backwards Compatibility Hack:
001440 **
001441 ** Historical versions of SQLite accepted strings as column names in
001442 ** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example:
001443 **
001444 ** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim)
001445 ** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC);
001446 **
001447 ** This is goofy. But to preserve backwards compatibility we continue to
001448 ** accept it. This routine does the necessary conversion. It converts
001449 ** the expression given in its argument from a TK_STRING into a TK_ID
001450 ** if the expression is just a TK_STRING with an optional COLLATE clause.
001451 ** If the expression is anything other than TK_STRING, the expression is
001452 ** unchanged.
001453 */
001454 static void sqlite3StringToId(Expr *p){
001455 if( p->op==TK_STRING ){
001456 p->op = TK_ID;
001457 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
001458 p->pLeft->op = TK_ID;
001459 }
001460 }
001461
001462 /*
001463 ** Tag the given column as being part of the PRIMARY KEY
001464 */
001465 static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){
001466 pCol->colFlags |= COLFLAG_PRIMKEY;
001467 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
001468 if( pCol->colFlags & COLFLAG_GENERATED ){
001469 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
001470 testcase( pCol->colFlags & COLFLAG_STORED );
001471 sqlite3ErrorMsg(pParse,
001472 "generated columns cannot be part of the PRIMARY KEY");
001473 }
001474 #endif
001475 }
001476
001477 /*
001478 ** Designate the PRIMARY KEY for the table. pList is a list of names
001479 ** of columns that form the primary key. If pList is NULL, then the
001480 ** most recently added column of the table is the primary key.
001481 **
001482 ** A table can have at most one primary key. If the table already has
001483 ** a primary key (and this is the second primary key) then create an
001484 ** error.
001485 **
001486 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
001487 ** then we will try to use that column as the rowid. Set the Table.iPKey
001488 ** field of the table under construction to be the index of the
001489 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
001490 ** no INTEGER PRIMARY KEY.
001491 **
001492 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
001493 ** index for the key. No index is created for INTEGER PRIMARY KEYs.
001494 */
001495 void sqlite3AddPrimaryKey(
001496 Parse *pParse, /* Parsing context */
001497 ExprList *pList, /* List of field names to be indexed */
001498 int onError, /* What to do with a uniqueness conflict */
001499 int autoInc, /* True if the AUTOINCREMENT keyword is present */
001500 int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
001501 ){
001502 Table *pTab = pParse->pNewTable;
001503 Column *pCol = 0;
001504 int iCol = -1, i;
001505 int nTerm;
001506 if( pTab==0 ) goto primary_key_exit;
001507 if( pTab->tabFlags & TF_HasPrimaryKey ){
001508 sqlite3ErrorMsg(pParse,
001509 "table \"%s\" has more than one primary key", pTab->zName);
001510 goto primary_key_exit;
001511 }
001512 pTab->tabFlags |= TF_HasPrimaryKey;
001513 if( pList==0 ){
001514 iCol = pTab->nCol - 1;
001515 pCol = &pTab->aCol[iCol];
001516 makeColumnPartOfPrimaryKey(pParse, pCol);
001517 nTerm = 1;
001518 }else{
001519 nTerm = pList->nExpr;
001520 for(i=0; i<nTerm; i++){
001521 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
001522 assert( pCExpr!=0 );
001523 sqlite3StringToId(pCExpr);
001524 if( pCExpr->op==TK_ID ){
001525 const char *zCName = pCExpr->u.zToken;
001526 for(iCol=0; iCol<pTab->nCol; iCol++){
001527 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
001528 pCol = &pTab->aCol[iCol];
001529 makeColumnPartOfPrimaryKey(pParse, pCol);
001530 break;
001531 }
001532 }
001533 }
001534 }
001535 }
001536 if( nTerm==1
001537 && pCol
001538 && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
001539 && sortOrder!=SQLITE_SO_DESC
001540 ){
001541 if( IN_RENAME_OBJECT && pList ){
001542 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
001543 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
001544 }
001545 pTab->iPKey = iCol;
001546 pTab->keyConf = (u8)onError;
001547 assert( autoInc==0 || autoInc==1 );
001548 pTab->tabFlags |= autoInc*TF_Autoincrement;
001549 if( pList ) pParse->iPkSortOrder = pList->a[0].sortFlags;
001550 (void)sqlite3HasExplicitNulls(pParse, pList);
001551 }else if( autoInc ){
001552 #ifndef SQLITE_OMIT_AUTOINCREMENT
001553 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
001554 "INTEGER PRIMARY KEY");
001555 #endif
001556 }else{
001557 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
001558 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY);
001559 pList = 0;
001560 }
001561
001562 primary_key_exit:
001563 sqlite3ExprListDelete(pParse->db, pList);
001564 return;
001565 }
001566
001567 /*
001568 ** Add a new CHECK constraint to the table currently under construction.
001569 */
001570 void sqlite3AddCheckConstraint(
001571 Parse *pParse, /* Parsing context */
001572 Expr *pCheckExpr /* The check expression */
001573 ){
001574 #ifndef SQLITE_OMIT_CHECK
001575 Table *pTab = pParse->pNewTable;
001576 sqlite3 *db = pParse->db;
001577 if( pTab && !IN_DECLARE_VTAB
001578 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
001579 ){
001580 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
001581 if( pParse->constraintName.n ){
001582 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
001583 }
001584 }else
001585 #endif
001586 {
001587 sqlite3ExprDelete(pParse->db, pCheckExpr);
001588 }
001589 }
001590
001591 /*
001592 ** Set the collation function of the most recently parsed table column
001593 ** to the CollSeq given.
001594 */
001595 void sqlite3AddCollateType(Parse *pParse, Token *pToken){
001596 Table *p;
001597 int i;
001598 char *zColl; /* Dequoted name of collation sequence */
001599 sqlite3 *db;
001600
001601 if( (p = pParse->pNewTable)==0 ) return;
001602 i = p->nCol-1;
001603 db = pParse->db;
001604 zColl = sqlite3NameFromToken(db, pToken);
001605 if( !zColl ) return;
001606
001607 if( sqlite3LocateCollSeq(pParse, zColl) ){
001608 Index *pIdx;
001609 sqlite3DbFree(db, p->aCol[i].zColl);
001610 p->aCol[i].zColl = zColl;
001611
001612 /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
001613 ** then an index may have been created on this column before the
001614 ** collation type was added. Correct this if it is the case.
001615 */
001616 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
001617 assert( pIdx->nKeyCol==1 );
001618 if( pIdx->aiColumn[0]==i ){
001619 pIdx->azColl[0] = p->aCol[i].zColl;
001620 }
001621 }
001622 }else{
001623 sqlite3DbFree(db, zColl);
001624 }
001625 }
001626
001627 /* Change the most recently parsed column to be a GENERATED ALWAYS AS
001628 ** column.
001629 */
001630 void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
001631 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
001632 u8 eType = COLFLAG_VIRTUAL;
001633 Table *pTab = pParse->pNewTable;
001634 Column *pCol;
001635 if( pTab==0 ){
001636 /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
001637 goto generated_done;
001638 }
001639 pCol = &(pTab->aCol[pTab->nCol-1]);
001640 if( IN_DECLARE_VTAB ){
001641 sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
001642 goto generated_done;
001643 }
001644 if( pCol->pDflt ) goto generated_error;
001645 if( pType ){
001646 if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
001647 /* no-op */
001648 }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
001649 eType = COLFLAG_STORED;
001650 }else{
001651 goto generated_error;
001652 }
001653 }
001654 if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
001655 pCol->colFlags |= eType;
001656 assert( TF_HasVirtual==COLFLAG_VIRTUAL );
001657 assert( TF_HasStored==COLFLAG_STORED );
001658 pTab->tabFlags |= eType;
001659 if( pCol->colFlags & COLFLAG_PRIMKEY ){
001660 makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
001661 }
001662 pCol->pDflt = pExpr;
001663 pExpr = 0;
001664 goto generated_done;
001665
001666 generated_error:
001667 sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
001668 pCol->zName);
001669 generated_done:
001670 sqlite3ExprDelete(pParse->db, pExpr);
001671 #else
001672 /* Throw and error for the GENERATED ALWAYS AS clause if the
001673 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
001674 sqlite3ErrorMsg(pParse, "generated columns not supported");
001675 sqlite3ExprDelete(pParse->db, pExpr);
001676 #endif
001677 }
001678
001679 /*
001680 ** Generate code that will increment the schema cookie.
001681 **
001682 ** The schema cookie is used to determine when the schema for the
001683 ** database changes. After each schema change, the cookie value
001684 ** changes. When a process first reads the schema it records the
001685 ** cookie. Thereafter, whenever it goes to access the database,
001686 ** it checks the cookie to make sure the schema has not changed
001687 ** since it was last read.
001688 **
001689 ** This plan is not completely bullet-proof. It is possible for
001690 ** the schema to change multiple times and for the cookie to be
001691 ** set back to prior value. But schema changes are infrequent
001692 ** and the probability of hitting the same cookie value is only
001693 ** 1 chance in 2^32. So we're safe enough.
001694 **
001695 ** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
001696 ** the schema-version whenever the schema changes.
001697 */
001698 void sqlite3ChangeCookie(Parse *pParse, int iDb){
001699 sqlite3 *db = pParse->db;
001700 Vdbe *v = pParse->pVdbe;
001701 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
001702 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
001703 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
001704 }
001705
001706 /*
001707 ** Measure the number of characters needed to output the given
001708 ** identifier. The number returned includes any quotes used
001709 ** but does not include the null terminator.
001710 **
001711 ** The estimate is conservative. It might be larger that what is
001712 ** really needed.
001713 */
001714 static int identLength(const char *z){
001715 int n;
001716 for(n=0; *z; n++, z++){
001717 if( *z=='"' ){ n++; }
001718 }
001719 return n + 2;
001720 }
001721
001722 /*
001723 ** The first parameter is a pointer to an output buffer. The second
001724 ** parameter is a pointer to an integer that contains the offset at
001725 ** which to write into the output buffer. This function copies the
001726 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
001727 ** to the specified offset in the buffer and updates *pIdx to refer
001728 ** to the first byte after the last byte written before returning.
001729 **
001730 ** If the string zSignedIdent consists entirely of alpha-numeric
001731 ** characters, does not begin with a digit and is not an SQL keyword,
001732 ** then it is copied to the output buffer exactly as it is. Otherwise,
001733 ** it is quoted using double-quotes.
001734 */
001735 static void identPut(char *z, int *pIdx, char *zSignedIdent){
001736 unsigned char *zIdent = (unsigned char*)zSignedIdent;
001737 int i, j, needQuote;
001738 i = *pIdx;
001739
001740 for(j=0; zIdent[j]; j++){
001741 if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
001742 }
001743 needQuote = sqlite3Isdigit(zIdent[0])
001744 || sqlite3KeywordCode(zIdent, j)!=TK_ID
001745 || zIdent[j]!=0
001746 || j==0;
001747
001748 if( needQuote ) z[i++] = '"';
001749 for(j=0; zIdent[j]; j++){
001750 z[i++] = zIdent[j];
001751 if( zIdent[j]=='"' ) z[i++] = '"';
001752 }
001753 if( needQuote ) z[i++] = '"';
001754 z[i] = 0;
001755 *pIdx = i;
001756 }
001757
001758 /*
001759 ** Generate a CREATE TABLE statement appropriate for the given
001760 ** table. Memory to hold the text of the statement is obtained
001761 ** from sqliteMalloc() and must be freed by the calling function.
001762 */
001763 static char *createTableStmt(sqlite3 *db, Table *p){
001764 int i, k, n;
001765 char *zStmt;
001766 char *zSep, *zSep2, *zEnd;
001767 Column *pCol;
001768 n = 0;
001769 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
001770 n += identLength(pCol->zName) + 5;
001771 }
001772 n += identLength(p->zName);
001773 if( n<50 ){
001774 zSep = "";
001775 zSep2 = ",";
001776 zEnd = ")";
001777 }else{
001778 zSep = "\n ";
001779 zSep2 = ",\n ";
001780 zEnd = "\n)";
001781 }
001782 n += 35 + 6*p->nCol;
001783 zStmt = sqlite3DbMallocRaw(0, n);
001784 if( zStmt==0 ){
001785 sqlite3OomFault(db);
001786 return 0;
001787 }
001788 sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
001789 k = sqlite3Strlen30(zStmt);
001790 identPut(zStmt, &k, p->zName);
001791 zStmt[k++] = '(';
001792 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
001793 static const char * const azType[] = {
001794 /* SQLITE_AFF_BLOB */ "",
001795 /* SQLITE_AFF_TEXT */ " TEXT",
001796 /* SQLITE_AFF_NUMERIC */ " NUM",
001797 /* SQLITE_AFF_INTEGER */ " INT",
001798 /* SQLITE_AFF_REAL */ " REAL"
001799 };
001800 int len;
001801 const char *zType;
001802
001803 sqlite3_snprintf(n-k, &zStmt[k], zSep);
001804 k += sqlite3Strlen30(&zStmt[k]);
001805 zSep = zSep2;
001806 identPut(zStmt, &k, pCol->zName);
001807 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
001808 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
001809 testcase( pCol->affinity==SQLITE_AFF_BLOB );
001810 testcase( pCol->affinity==SQLITE_AFF_TEXT );
001811 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
001812 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
001813 testcase( pCol->affinity==SQLITE_AFF_REAL );
001814
001815 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
001816 len = sqlite3Strlen30(zType);
001817 assert( pCol->affinity==SQLITE_AFF_BLOB
001818 || pCol->affinity==sqlite3AffinityType(zType, 0) );
001819 memcpy(&zStmt[k], zType, len);
001820 k += len;
001821 assert( k<=n );
001822 }
001823 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
001824 return zStmt;
001825 }
001826
001827 /*
001828 ** Resize an Index object to hold N columns total. Return SQLITE_OK
001829 ** on success and SQLITE_NOMEM on an OOM error.
001830 */
001831 static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
001832 char *zExtra;
001833 int nByte;
001834 if( pIdx->nColumn>=N ) return SQLITE_OK;
001835 assert( pIdx->isResized==0 );
001836 nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
001837 zExtra = sqlite3DbMallocZero(db, nByte);
001838 if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
001839 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
001840 pIdx->azColl = (const char**)zExtra;
001841 zExtra += sizeof(char*)*N;
001842 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
001843 pIdx->aiColumn = (i16*)zExtra;
001844 zExtra += sizeof(i16)*N;
001845 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
001846 pIdx->aSortOrder = (u8*)zExtra;
001847 pIdx->nColumn = N;
001848 pIdx->isResized = 1;
001849 return SQLITE_OK;
001850 }
001851
001852 /*
001853 ** Estimate the total row width for a table.
001854 */
001855 static void estimateTableWidth(Table *pTab){
001856 unsigned wTable = 0;
001857 const Column *pTabCol;
001858 int i;
001859 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
001860 wTable += pTabCol->szEst;
001861 }
001862 if( pTab->iPKey<0 ) wTable++;
001863 pTab->szTabRow = sqlite3LogEst(wTable*4);
001864 }
001865
001866 /*
001867 ** Estimate the average size of a row for an index.
001868 */
001869 static void estimateIndexWidth(Index *pIdx){
001870 unsigned wIndex = 0;
001871 int i;
001872 const Column *aCol = pIdx->pTable->aCol;
001873 for(i=0; i<pIdx->nColumn; i++){
001874 i16 x = pIdx->aiColumn[i];
001875 assert( x<pIdx->pTable->nCol );
001876 wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
001877 }
001878 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
001879 }
001880
001881 /* Return true if column number x is any of the first nCol entries of aiCol[].
001882 ** This is used to determine if the column number x appears in any of the
001883 ** first nCol entries of an index.
001884 */
001885 static int hasColumn(const i16 *aiCol, int nCol, int x){
001886 while( nCol-- > 0 ){
001887 assert( aiCol[0]>=0 );
001888 if( x==*(aiCol++) ){
001889 return 1;
001890 }
001891 }
001892 return 0;
001893 }
001894
001895 /*
001896 ** Return true if any of the first nKey entries of index pIdx exactly
001897 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
001898 ** PRIMARY KEY index. pIdx is an index on the same table. pIdx may
001899 ** or may not be the same index as pPk.
001900 **
001901 ** The first nKey entries of pIdx are guaranteed to be ordinary columns,
001902 ** not a rowid or expression.
001903 **
001904 ** This routine differs from hasColumn() in that both the column and the
001905 ** collating sequence must match for this routine, but for hasColumn() only
001906 ** the column name must match.
001907 */
001908 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
001909 int i, j;
001910 assert( nKey<=pIdx->nColumn );
001911 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
001912 assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
001913 assert( pPk->pTable->tabFlags & TF_WithoutRowid );
001914 assert( pPk->pTable==pIdx->pTable );
001915 testcase( pPk==pIdx );
001916 j = pPk->aiColumn[iCol];
001917 assert( j!=XN_ROWID && j!=XN_EXPR );
001918 for(i=0; i<nKey; i++){
001919 assert( pIdx->aiColumn[i]>=0 || j>=0 );
001920 if( pIdx->aiColumn[i]==j
001921 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
001922 ){
001923 return 1;
001924 }
001925 }
001926 return 0;
001927 }
001928
001929 /* Recompute the colNotIdxed field of the Index.
001930 **
001931 ** colNotIdxed is a bitmask that has a 0 bit representing each indexed
001932 ** columns that are within the first 63 columns of the table. The
001933 ** high-order bit of colNotIdxed is always 1. All unindexed columns
001934 ** of the table have a 1.
001935 **
001936 ** 2019-10-24: For the purpose of this computation, virtual columns are
001937 ** not considered to be covered by the index, even if they are in the
001938 ** index, because we do not trust the logic in whereIndexExprTrans() to be
001939 ** able to find all instances of a reference to the indexed table column
001940 ** and convert them into references to the index. Hence we always want
001941 ** the actual table at hand in order to recompute the virtual column, if
001942 ** necessary.
001943 **
001944 ** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
001945 ** to determine if the index is covering index.
001946 */
001947 static void recomputeColumnsNotIndexed(Index *pIdx){
001948 Bitmask m = 0;
001949 int j;
001950 Table *pTab = pIdx->pTable;
001951 for(j=pIdx->nColumn-1; j>=0; j--){
001952 int x = pIdx->aiColumn[j];
001953 if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
001954 testcase( x==BMS-1 );
001955 testcase( x==BMS-2 );
001956 if( x<BMS-1 ) m |= MASKBIT(x);
001957 }
001958 }
001959 pIdx->colNotIdxed = ~m;
001960 assert( (pIdx->colNotIdxed>>63)==1 );
001961 }
001962
001963 /*
001964 ** This routine runs at the end of parsing a CREATE TABLE statement that
001965 ** has a WITHOUT ROWID clause. The job of this routine is to convert both
001966 ** internal schema data structures and the generated VDBE code so that they
001967 ** are appropriate for a WITHOUT ROWID table instead of a rowid table.
001968 ** Changes include:
001969 **
001970 ** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL.
001971 ** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
001972 ** into BTREE_BLOBKEY.
001973 ** (3) Bypass the creation of the sqlite_master table entry
001974 ** for the PRIMARY KEY as the primary key index is now
001975 ** identified by the sqlite_master table entry of the table itself.
001976 ** (4) Set the Index.tnum of the PRIMARY KEY Index object in the
001977 ** schema to the rootpage from the main table.
001978 ** (5) Add all table columns to the PRIMARY KEY Index object
001979 ** so that the PRIMARY KEY is a covering index. The surplus
001980 ** columns are part of KeyInfo.nAllField and are not used for
001981 ** sorting or lookup or uniqueness checks.
001982 ** (6) Replace the rowid tail on all automatically generated UNIQUE
001983 ** indices with the PRIMARY KEY columns.
001984 **
001985 ** For virtual tables, only (1) is performed.
001986 */
001987 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
001988 Index *pIdx;
001989 Index *pPk;
001990 int nPk;
001991 int nExtra;
001992 int i, j;
001993 sqlite3 *db = pParse->db;
001994 Vdbe *v = pParse->pVdbe;
001995
001996 /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables)
001997 */
001998 if( !db->init.imposterTable ){
001999 for(i=0; i<pTab->nCol; i++){
002000 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){
002001 pTab->aCol[i].notNull = OE_Abort;
002002 }
002003 }
002004 pTab->tabFlags |= TF_HasNotNull;
002005 }
002006
002007 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
002008 ** into BTREE_BLOBKEY.
002009 */
002010 if( pParse->addrCrTab ){
002011 assert( v );
002012 sqlite3VdbeChangeP3(v, pParse->addrCrTab, BTREE_BLOBKEY);
002013 }
002014
002015 /* Locate the PRIMARY KEY index. Or, if this table was originally
002016 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
002017 */
002018 if( pTab->iPKey>=0 ){
002019 ExprList *pList;
002020 Token ipkToken;
002021 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
002022 pList = sqlite3ExprListAppend(pParse, 0,
002023 sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
002024 if( pList==0 ) return;
002025 if( IN_RENAME_OBJECT ){
002026 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
002027 }
002028 pList->a[0].sortFlags = pParse->iPkSortOrder;
002029 assert( pParse->pNewTable==pTab );
002030 pTab->iPKey = -1;
002031 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
002032 SQLITE_IDXTYPE_PRIMARYKEY);
002033 if( db->mallocFailed || pParse->nErr ) return;
002034 pPk = sqlite3PrimaryKeyIndex(pTab);
002035 assert( pPk->nKeyCol==1 );
002036 }else{
002037 pPk = sqlite3PrimaryKeyIndex(pTab);
002038 assert( pPk!=0 );
002039
002040 /*
002041 ** Remove all redundant columns from the PRIMARY KEY. For example, change
002042 ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later
002043 ** code assumes the PRIMARY KEY contains no repeated columns.
002044 */
002045 for(i=j=1; i<pPk->nKeyCol; i++){
002046 if( isDupColumn(pPk, j, pPk, i) ){
002047 pPk->nColumn--;
002048 }else{
002049 testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
002050 pPk->azColl[j] = pPk->azColl[i];
002051 pPk->aSortOrder[j] = pPk->aSortOrder[i];
002052 pPk->aiColumn[j++] = pPk->aiColumn[i];
002053 }
002054 }
002055 pPk->nKeyCol = j;
002056 }
002057 assert( pPk!=0 );
002058 pPk->isCovering = 1;
002059 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
002060 nPk = pPk->nColumn = pPk->nKeyCol;
002061
002062 /* Bypass the creation of the PRIMARY KEY btree and the sqlite_master
002063 ** table entry. This is only required if currently generating VDBE
002064 ** code for a CREATE TABLE (not when parsing one as part of reading
002065 ** a database schema). */
002066 if( v && pPk->tnum>0 ){
002067 assert( db->init.busy==0 );
002068 sqlite3VdbeChangeOpcode(v, pPk->tnum, OP_Goto);
002069 }
002070
002071 /* The root page of the PRIMARY KEY is the table root page */
002072 pPk->tnum = pTab->tnum;
002073
002074 /* Update the in-memory representation of all UNIQUE indices by converting
002075 ** the final rowid column into one or more columns of the PRIMARY KEY.
002076 */
002077 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
002078 int n;
002079 if( IsPrimaryKeyIndex(pIdx) ) continue;
002080 for(i=n=0; i<nPk; i++){
002081 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
002082 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
002083 n++;
002084 }
002085 }
002086 if( n==0 ){
002087 /* This index is a superset of the primary key */
002088 pIdx->nColumn = pIdx->nKeyCol;
002089 continue;
002090 }
002091 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
002092 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
002093 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
002094 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
002095 pIdx->aiColumn[j] = pPk->aiColumn[i];
002096 pIdx->azColl[j] = pPk->azColl[i];
002097 if( pPk->aSortOrder[i] ){
002098 /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
002099 pIdx->bAscKeyBug = 1;
002100 }
002101 j++;
002102 }
002103 }
002104 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
002105 assert( pIdx->nColumn>=j );
002106 }
002107
002108 /* Add all table columns to the PRIMARY KEY index
002109 */
002110 nExtra = 0;
002111 for(i=0; i<pTab->nCol; i++){
002112 if( !hasColumn(pPk->aiColumn, nPk, i)
002113 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
002114 }
002115 if( resizeIndexObject(db, pPk, nPk+nExtra) ) return;
002116 for(i=0, j=nPk; i<pTab->nCol; i++){
002117 if( !hasColumn(pPk->aiColumn, j, i)
002118 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
002119 ){
002120 assert( j<pPk->nColumn );
002121 pPk->aiColumn[j] = i;
002122 pPk->azColl[j] = sqlite3StrBINARY;
002123 j++;
002124 }
002125 }
002126 assert( pPk->nColumn==j );
002127 assert( pTab->nNVCol<=j );
002128 recomputeColumnsNotIndexed(pPk);
002129 }
002130
002131 #ifndef SQLITE_OMIT_VIRTUALTABLE
002132 /*
002133 ** Return true if zName is a shadow table name in the current database
002134 ** connection.
002135 **
002136 ** zName is temporarily modified while this routine is running, but is
002137 ** restored to its original value prior to this routine returning.
002138 */
002139 int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
002140 char *zTail; /* Pointer to the last "_" in zName */
002141 Table *pTab; /* Table that zName is a shadow of */
002142 Module *pMod; /* Module for the virtual table */
002143
002144 zTail = strrchr(zName, '_');
002145 if( zTail==0 ) return 0;
002146 *zTail = 0;
002147 pTab = sqlite3FindTable(db, zName, 0);
002148 *zTail = '_';
002149 if( pTab==0 ) return 0;
002150 if( !IsVirtual(pTab) ) return 0;
002151 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
002152 if( pMod==0 ) return 0;
002153 if( pMod->pModule->iVersion<3 ) return 0;
002154 if( pMod->pModule->xShadowName==0 ) return 0;
002155 return pMod->pModule->xShadowName(zTail+1);
002156 }
002157 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
002158
002159 /*
002160 ** This routine is called to report the final ")" that terminates
002161 ** a CREATE TABLE statement.
002162 **
002163 ** The table structure that other action routines have been building
002164 ** is added to the internal hash tables, assuming no errors have
002165 ** occurred.
002166 **
002167 ** An entry for the table is made in the master table on disk, unless
002168 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
002169 ** it means we are reading the sqlite_master table because we just
002170 ** connected to the database or because the sqlite_master table has
002171 ** recently changed, so the entry for this table already exists in
002172 ** the sqlite_master table. We do not want to create it again.
002173 **
002174 ** If the pSelect argument is not NULL, it means that this routine
002175 ** was called to create a table generated from a
002176 ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
002177 ** the new table will match the result set of the SELECT.
002178 */
002179 void sqlite3EndTable(
002180 Parse *pParse, /* Parse context */
002181 Token *pCons, /* The ',' token after the last column defn. */
002182 Token *pEnd, /* The ')' before options in the CREATE TABLE */
002183 u8 tabOpts, /* Extra table options. Usually 0. */
002184 Select *pSelect /* Select from a "CREATE ... AS SELECT" */
002185 ){
002186 Table *p; /* The new table */
002187 sqlite3 *db = pParse->db; /* The database connection */
002188 int iDb; /* Database in which the table lives */
002189 Index *pIdx; /* An implied index of the table */
002190
002191 if( pEnd==0 && pSelect==0 ){
002192 return;
002193 }
002194 assert( !db->mallocFailed );
002195 p = pParse->pNewTable;
002196 if( p==0 ) return;
002197
002198 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
002199 p->tabFlags |= TF_Shadow;
002200 }
002201
002202 /* If the db->init.busy is 1 it means we are reading the SQL off the
002203 ** "sqlite_master" or "sqlite_temp_master" table on the disk.
002204 ** So do not write to the disk again. Extract the root page number
002205 ** for the table from the db->init.newTnum field. (The page number
002206 ** should have been put there by the sqliteOpenCb routine.)
002207 **
002208 ** If the root page number is 1, that means this is the sqlite_master
002209 ** table itself. So mark it read-only.
002210 */
002211 if( db->init.busy ){
002212 if( pSelect ){
002213 sqlite3ErrorMsg(pParse, "");
002214 return;
002215 }
002216 p->tnum = db->init.newTnum;
002217 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
002218 }
002219
002220 assert( (p->tabFlags & TF_HasPrimaryKey)==0
002221 || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
002222 assert( (p->tabFlags & TF_HasPrimaryKey)!=0
002223 || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
002224
002225 /* Special processing for WITHOUT ROWID Tables */
002226 if( tabOpts & TF_WithoutRowid ){
002227 if( (p->tabFlags & TF_Autoincrement) ){
002228 sqlite3ErrorMsg(pParse,
002229 "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
002230 return;
002231 }
002232 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
002233 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
002234 return;
002235 }
002236 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
002237 convertToWithoutRowidTable(pParse, p);
002238 }
002239 iDb = sqlite3SchemaToIndex(db, p->pSchema);
002240
002241 #ifndef SQLITE_OMIT_CHECK
002242 /* Resolve names in all CHECK constraint expressions.
002243 */
002244 if( p->pCheck ){
002245 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
002246 if( pParse->nErr ){
002247 /* If errors are seen, delete the CHECK constraints now, else they might
002248 ** actually be used if PRAGMA writable_schema=ON is set. */
002249 sqlite3ExprListDelete(db, p->pCheck);
002250 p->pCheck = 0;
002251 }
002252 }
002253 #endif /* !defined(SQLITE_OMIT_CHECK) */
002254 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
002255 if( p->tabFlags & TF_HasGenerated ){
002256 int ii, nNG = 0;
002257 testcase( p->tabFlags & TF_HasVirtual );
002258 testcase( p->tabFlags & TF_HasStored );
002259 for(ii=0; ii<p->nCol; ii++){
002260 u32 colFlags = p->aCol[ii].colFlags;
002261 if( (colFlags & COLFLAG_GENERATED)!=0 ){
002262 Expr *pX = p->aCol[ii].pDflt;
002263 testcase( colFlags & COLFLAG_VIRTUAL );
002264 testcase( colFlags & COLFLAG_STORED );
002265 if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
002266 /* If there are errors in resolving the expression, change the
002267 ** expression to a NULL. This prevents code generators that operate
002268 ** on the expression from inserting extra parts into the expression
002269 ** tree that have been allocated from lookaside memory, which is
002270 ** illegal in a schema and will lead to errors heap corruption when
002271 ** the database connection closes. */
002272 sqlite3ExprDelete(db, pX);
002273 p->aCol[ii].pDflt = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
002274 }
002275 }else{
002276 nNG++;
002277 }
002278 }
002279 if( nNG==0 ){
002280 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
002281 return;
002282 }
002283 }
002284 #endif
002285
002286 /* Estimate the average row size for the table and for all implied indices */
002287 estimateTableWidth(p);
002288 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
002289 estimateIndexWidth(pIdx);
002290 }
002291
002292 /* If not initializing, then create a record for the new table
002293 ** in the SQLITE_MASTER table of the database.
002294 **
002295 ** If this is a TEMPORARY table, write the entry into the auxiliary
002296 ** file instead of into the main database file.
002297 */
002298 if( !db->init.busy ){
002299 int n;
002300 Vdbe *v;
002301 char *zType; /* "view" or "table" */
002302 char *zType2; /* "VIEW" or "TABLE" */
002303 char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
002304
002305 v = sqlite3GetVdbe(pParse);
002306 if( NEVER(v==0) ) return;
002307
002308 sqlite3VdbeAddOp1(v, OP_Close, 0);
002309
002310 /*
002311 ** Initialize zType for the new view or table.
002312 */
002313 if( p->pSelect==0 ){
002314 /* A regular table */
002315 zType = "table";
002316 zType2 = "TABLE";
002317 #ifndef SQLITE_OMIT_VIEW
002318 }else{
002319 /* A view */
002320 zType = "view";
002321 zType2 = "VIEW";
002322 #endif
002323 }
002324
002325 /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
002326 ** statement to populate the new table. The root-page number for the
002327 ** new table is in register pParse->regRoot.
002328 **
002329 ** Once the SELECT has been coded by sqlite3Select(), it is in a
002330 ** suitable state to query for the column names and types to be used
002331 ** by the new table.
002332 **
002333 ** A shared-cache write-lock is not required to write to the new table,
002334 ** as a schema-lock must have already been obtained to create it. Since
002335 ** a schema-lock excludes all other database users, the write-lock would
002336 ** be redundant.
002337 */
002338 if( pSelect ){
002339 SelectDest dest; /* Where the SELECT should store results */
002340 int regYield; /* Register holding co-routine entry-point */
002341 int addrTop; /* Top of the co-routine */
002342 int regRec; /* A record to be insert into the new table */
002343 int regRowid; /* Rowid of the next row to insert */
002344 int addrInsLoop; /* Top of the loop for inserting rows */
002345 Table *pSelTab; /* A table that describes the SELECT results */
002346
002347 regYield = ++pParse->nMem;
002348 regRec = ++pParse->nMem;
002349 regRowid = ++pParse->nMem;
002350 assert(pParse->nTab==1);
002351 sqlite3MayAbort(pParse);
002352 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
002353 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
002354 pParse->nTab = 2;
002355 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
002356 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
002357 if( pParse->nErr ) return;
002358 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB);
002359 if( pSelTab==0 ) return;
002360 assert( p->aCol==0 );
002361 p->nCol = p->nNVCol = pSelTab->nCol;
002362 p->aCol = pSelTab->aCol;
002363 pSelTab->nCol = 0;
002364 pSelTab->aCol = 0;
002365 sqlite3DeleteTable(db, pSelTab);
002366 sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
002367 sqlite3Select(pParse, pSelect, &dest);
002368 if( pParse->nErr ) return;
002369 sqlite3VdbeEndCoroutine(v, regYield);
002370 sqlite3VdbeJumpHere(v, addrTop - 1);
002371 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
002372 VdbeCoverage(v);
002373 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
002374 sqlite3TableAffinity(v, p, 0);
002375 sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid);
002376 sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid);
002377 sqlite3VdbeGoto(v, addrInsLoop);
002378 sqlite3VdbeJumpHere(v, addrInsLoop);
002379 sqlite3VdbeAddOp1(v, OP_Close, 1);
002380 }
002381
002382 /* Compute the complete text of the CREATE statement */
002383 if( pSelect ){
002384 zStmt = createTableStmt(db, p);
002385 }else{
002386 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
002387 n = (int)(pEnd2->z - pParse->sNameToken.z);
002388 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
002389 zStmt = sqlite3MPrintf(db,
002390 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
002391 );
002392 }
002393
002394 /* A slot for the record has already been allocated in the
002395 ** SQLITE_MASTER table. We just need to update that slot with all
002396 ** the information we've collected.
002397 */
002398 sqlite3NestedParse(pParse,
002399 "UPDATE %Q.%s "
002400 "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
002401 "WHERE rowid=#%d",
002402 db->aDb[iDb].zDbSName, MASTER_NAME,
002403 zType,
002404 p->zName,
002405 p->zName,
002406 pParse->regRoot,
002407 zStmt,
002408 pParse->regRowid
002409 );
002410 sqlite3DbFree(db, zStmt);
002411 sqlite3ChangeCookie(pParse, iDb);
002412
002413 #ifndef SQLITE_OMIT_AUTOINCREMENT
002414 /* Check to see if we need to create an sqlite_sequence table for
002415 ** keeping track of autoincrement keys.
002416 */
002417 if( (p->tabFlags & TF_Autoincrement)!=0 ){
002418 Db *pDb = &db->aDb[iDb];
002419 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
002420 if( pDb->pSchema->pSeqTab==0 ){
002421 sqlite3NestedParse(pParse,
002422 "CREATE TABLE %Q.sqlite_sequence(name,seq)",
002423 pDb->zDbSName
002424 );
002425 }
002426 }
002427 #endif
002428
002429 /* Reparse everything to update our internal data structures */
002430 sqlite3VdbeAddParseSchemaOp(v, iDb,
002431 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
002432 }
002433
002434 /* Add the table to the in-memory representation of the database.
002435 */
002436 if( db->init.busy ){
002437 Table *pOld;
002438 Schema *pSchema = p->pSchema;
002439 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
002440 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
002441 if( pOld ){
002442 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
002443 sqlite3OomFault(db);
002444 return;
002445 }
002446 pParse->pNewTable = 0;
002447 db->mDbFlags |= DBFLAG_SchemaChange;
002448
002449 #ifndef SQLITE_OMIT_ALTERTABLE
002450 if( !p->pSelect ){
002451 const char *zName = (const char *)pParse->sNameToken.z;
002452 int nName;
002453 assert( !pSelect && pCons && pEnd );
002454 if( pCons->z==0 ){
002455 pCons = pEnd;
002456 }
002457 nName = (int)((const char *)pCons->z - zName);
002458 p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
002459 }
002460 #endif
002461 }
002462 }
002463
002464 #ifndef SQLITE_OMIT_VIEW
002465 /*
002466 ** The parser calls this routine in order to create a new VIEW
002467 */
002468 void sqlite3CreateView(
002469 Parse *pParse, /* The parsing context */
002470 Token *pBegin, /* The CREATE token that begins the statement */
002471 Token *pName1, /* The token that holds the name of the view */
002472 Token *pName2, /* The token that holds the name of the view */
002473 ExprList *pCNames, /* Optional list of view column names */
002474 Select *pSelect, /* A SELECT statement that will become the new view */
002475 int isTemp, /* TRUE for a TEMPORARY view */
002476 int noErr /* Suppress error messages if VIEW already exists */
002477 ){
002478 Table *p;
002479 int n;
002480 const char *z;
002481 Token sEnd;
002482 DbFixer sFix;
002483 Token *pName = 0;
002484 int iDb;
002485 sqlite3 *db = pParse->db;
002486
002487 if( pParse->nVar>0 ){
002488 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
002489 goto create_view_fail;
002490 }
002491 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
002492 p = pParse->pNewTable;
002493 if( p==0 || pParse->nErr ) goto create_view_fail;
002494 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
002495 iDb = sqlite3SchemaToIndex(db, p->pSchema);
002496 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
002497 if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail;
002498
002499 /* Make a copy of the entire SELECT statement that defines the view.
002500 ** This will force all the Expr.token.z values to be dynamically
002501 ** allocated rather than point to the input string - which means that
002502 ** they will persist after the current sqlite3_exec() call returns.
002503 */
002504 pSelect->selFlags |= SF_View;
002505 if( IN_RENAME_OBJECT ){
002506 p->pSelect = pSelect;
002507 pSelect = 0;
002508 }else{
002509 p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
002510 }
002511 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
002512 if( db->mallocFailed ) goto create_view_fail;
002513
002514 /* Locate the end of the CREATE VIEW statement. Make sEnd point to
002515 ** the end.
002516 */
002517 sEnd = pParse->sLastToken;
002518 assert( sEnd.z[0]!=0 || sEnd.n==0 );
002519 if( sEnd.z[0]!=';' ){
002520 sEnd.z += sEnd.n;
002521 }
002522 sEnd.n = 0;
002523 n = (int)(sEnd.z - pBegin->z);
002524 assert( n>0 );
002525 z = pBegin->z;
002526 while( sqlite3Isspace(z[n-1]) ){ n--; }
002527 sEnd.z = &z[n-1];
002528 sEnd.n = 1;
002529
002530 /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
002531 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
002532
002533 create_view_fail:
002534 sqlite3SelectDelete(db, pSelect);
002535 if( IN_RENAME_OBJECT ){
002536 sqlite3RenameExprlistUnmap(pParse, pCNames);
002537 }
002538 sqlite3ExprListDelete(db, pCNames);
002539 return;
002540 }
002541 #endif /* SQLITE_OMIT_VIEW */
002542
002543 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
002544 /*
002545 ** The Table structure pTable is really a VIEW. Fill in the names of
002546 ** the columns of the view in the pTable structure. Return the number
002547 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
002548 */
002549 int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
002550 Table *pSelTab; /* A fake table from which we get the result set */
002551 Select *pSel; /* Copy of the SELECT that implements the view */
002552 int nErr = 0; /* Number of errors encountered */
002553 int n; /* Temporarily holds the number of cursors assigned */
002554 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
002555 #ifndef SQLITE_OMIT_VIRTUALTABLE
002556 int rc;
002557 #endif
002558 #ifndef SQLITE_OMIT_AUTHORIZATION
002559 sqlite3_xauth xAuth; /* Saved xAuth pointer */
002560 #endif
002561
002562 assert( pTable );
002563
002564 #ifndef SQLITE_OMIT_VIRTUALTABLE
002565 db->nSchemaLock++;
002566 rc = sqlite3VtabCallConnect(pParse, pTable);
002567 db->nSchemaLock--;
002568 if( rc ){
002569 return 1;
002570 }
002571 if( IsVirtual(pTable) ) return 0;
002572 #endif
002573
002574 #ifndef SQLITE_OMIT_VIEW
002575 /* A positive nCol means the columns names for this view are
002576 ** already known.
002577 */
002578 if( pTable->nCol>0 ) return 0;
002579
002580 /* A negative nCol is a special marker meaning that we are currently
002581 ** trying to compute the column names. If we enter this routine with
002582 ** a negative nCol, it means two or more views form a loop, like this:
002583 **
002584 ** CREATE VIEW one AS SELECT * FROM two;
002585 ** CREATE VIEW two AS SELECT * FROM one;
002586 **
002587 ** Actually, the error above is now caught prior to reaching this point.
002588 ** But the following test is still important as it does come up
002589 ** in the following:
002590 **
002591 ** CREATE TABLE main.ex1(a);
002592 ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
002593 ** SELECT * FROM temp.ex1;
002594 */
002595 if( pTable->nCol<0 ){
002596 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
002597 return 1;
002598 }
002599 assert( pTable->nCol>=0 );
002600
002601 /* If we get this far, it means we need to compute the table names.
002602 ** Note that the call to sqlite3ResultSetOfSelect() will expand any
002603 ** "*" elements in the results set of the view and will assign cursors
002604 ** to the elements of the FROM clause. But we do not want these changes
002605 ** to be permanent. So the computation is done on a copy of the SELECT
002606 ** statement that defines the view.
002607 */
002608 assert( pTable->pSelect );
002609 pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
002610 if( pSel ){
002611 #ifndef SQLITE_OMIT_ALTERTABLE
002612 u8 eParseMode = pParse->eParseMode;
002613 pParse->eParseMode = PARSE_MODE_NORMAL;
002614 #endif
002615 n = pParse->nTab;
002616 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
002617 pTable->nCol = -1;
002618 DisableLookaside;
002619 #ifndef SQLITE_OMIT_AUTHORIZATION
002620 xAuth = db->xAuth;
002621 db->xAuth = 0;
002622 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
002623 db->xAuth = xAuth;
002624 #else
002625 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
002626 #endif
002627 pParse->nTab = n;
002628 if( pSelTab==0 ){
002629 pTable->nCol = 0;
002630 nErr++;
002631 }else if( pTable->pCheck ){
002632 /* CREATE VIEW name(arglist) AS ...
002633 ** The names of the columns in the table are taken from
002634 ** arglist which is stored in pTable->pCheck. The pCheck field
002635 ** normally holds CHECK constraints on an ordinary table, but for
002636 ** a VIEW it holds the list of column names.
002637 */
002638 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
002639 &pTable->nCol, &pTable->aCol);
002640 if( db->mallocFailed==0
002641 && pParse->nErr==0
002642 && pTable->nCol==pSel->pEList->nExpr
002643 ){
002644 sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel,
002645 SQLITE_AFF_NONE);
002646 }
002647 }else{
002648 /* CREATE VIEW name AS... without an argument list. Construct
002649 ** the column names from the SELECT statement that defines the view.
002650 */
002651 assert( pTable->aCol==0 );
002652 pTable->nCol = pSelTab->nCol;
002653 pTable->aCol = pSelTab->aCol;
002654 pSelTab->nCol = 0;
002655 pSelTab->aCol = 0;
002656 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
002657 }
002658 pTable->nNVCol = pTable->nCol;
002659 sqlite3DeleteTable(db, pSelTab);
002660 sqlite3SelectDelete(db, pSel);
002661 EnableLookaside;
002662 #ifndef SQLITE_OMIT_ALTERTABLE
002663 pParse->eParseMode = eParseMode;
002664 #endif
002665 } else {
002666 nErr++;
002667 }
002668 pTable->pSchema->schemaFlags |= DB_UnresetViews;
002669 if( db->mallocFailed ){
002670 sqlite3DeleteColumnNames(db, pTable);
002671 pTable->aCol = 0;
002672 pTable->nCol = 0;
002673 }
002674 #endif /* SQLITE_OMIT_VIEW */
002675 return nErr;
002676 }
002677 #endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
002678
002679 #ifndef SQLITE_OMIT_VIEW
002680 /*
002681 ** Clear the column names from every VIEW in database idx.
002682 */
002683 static void sqliteViewResetAll(sqlite3 *db, int idx){
002684 HashElem *i;
002685 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
002686 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
002687 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
002688 Table *pTab = sqliteHashData(i);
002689 if( pTab->pSelect ){
002690 sqlite3DeleteColumnNames(db, pTab);
002691 pTab->aCol = 0;
002692 pTab->nCol = 0;
002693 }
002694 }
002695 DbClearProperty(db, idx, DB_UnresetViews);
002696 }
002697 #else
002698 # define sqliteViewResetAll(A,B)
002699 #endif /* SQLITE_OMIT_VIEW */
002700
002701 /*
002702 ** This function is called by the VDBE to adjust the internal schema
002703 ** used by SQLite when the btree layer moves a table root page. The
002704 ** root-page of a table or index in database iDb has changed from iFrom
002705 ** to iTo.
002706 **
002707 ** Ticket #1728: The symbol table might still contain information
002708 ** on tables and/or indices that are the process of being deleted.
002709 ** If you are unlucky, one of those deleted indices or tables might
002710 ** have the same rootpage number as the real table or index that is
002711 ** being moved. So we cannot stop searching after the first match
002712 ** because the first match might be for one of the deleted indices
002713 ** or tables and not the table/index that is actually being moved.
002714 ** We must continue looping until all tables and indices with
002715 ** rootpage==iFrom have been converted to have a rootpage of iTo
002716 ** in order to be certain that we got the right one.
002717 */
002718 #ifndef SQLITE_OMIT_AUTOVACUUM
002719 void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
002720 HashElem *pElem;
002721 Hash *pHash;
002722 Db *pDb;
002723
002724 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
002725 pDb = &db->aDb[iDb];
002726 pHash = &pDb->pSchema->tblHash;
002727 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
002728 Table *pTab = sqliteHashData(pElem);
002729 if( pTab->tnum==iFrom ){
002730 pTab->tnum = iTo;
002731 }
002732 }
002733 pHash = &pDb->pSchema->idxHash;
002734 for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
002735 Index *pIdx = sqliteHashData(pElem);
002736 if( pIdx->tnum==iFrom ){
002737 pIdx->tnum = iTo;
002738 }
002739 }
002740 }
002741 #endif
002742
002743 /*
002744 ** Write code to erase the table with root-page iTable from database iDb.
002745 ** Also write code to modify the sqlite_master table and internal schema
002746 ** if a root-page of another table is moved by the btree-layer whilst
002747 ** erasing iTable (this can happen with an auto-vacuum database).
002748 */
002749 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
002750 Vdbe *v = sqlite3GetVdbe(pParse);
002751 int r1 = sqlite3GetTempReg(pParse);
002752 if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
002753 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
002754 sqlite3MayAbort(pParse);
002755 #ifndef SQLITE_OMIT_AUTOVACUUM
002756 /* OP_Destroy stores an in integer r1. If this integer
002757 ** is non-zero, then it is the root page number of a table moved to
002758 ** location iTable. The following code modifies the sqlite_master table to
002759 ** reflect this.
002760 **
002761 ** The "#NNN" in the SQL is a special constant that means whatever value
002762 ** is in register NNN. See grammar rules associated with the TK_REGISTER
002763 ** token for additional information.
002764 */
002765 sqlite3NestedParse(pParse,
002766 "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
002767 pParse->db->aDb[iDb].zDbSName, MASTER_NAME, iTable, r1, r1);
002768 #endif
002769 sqlite3ReleaseTempReg(pParse, r1);
002770 }
002771
002772 /*
002773 ** Write VDBE code to erase table pTab and all associated indices on disk.
002774 ** Code to update the sqlite_master tables and internal schema definitions
002775 ** in case a root-page belonging to another table is moved by the btree layer
002776 ** is also added (this can happen with an auto-vacuum database).
002777 */
002778 static void destroyTable(Parse *pParse, Table *pTab){
002779 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
002780 ** is not defined), then it is important to call OP_Destroy on the
002781 ** table and index root-pages in order, starting with the numerically
002782 ** largest root-page number. This guarantees that none of the root-pages
002783 ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
002784 ** following were coded:
002785 **
002786 ** OP_Destroy 4 0
002787 ** ...
002788 ** OP_Destroy 5 0
002789 **
002790 ** and root page 5 happened to be the largest root-page number in the
002791 ** database, then root page 5 would be moved to page 4 by the
002792 ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
002793 ** a free-list page.
002794 */
002795 int iTab = pTab->tnum;
002796 int iDestroyed = 0;
002797
002798 while( 1 ){
002799 Index *pIdx;
002800 int iLargest = 0;
002801
002802 if( iDestroyed==0 || iTab<iDestroyed ){
002803 iLargest = iTab;
002804 }
002805 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
002806 int iIdx = pIdx->tnum;
002807 assert( pIdx->pSchema==pTab->pSchema );
002808 if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
002809 iLargest = iIdx;
002810 }
002811 }
002812 if( iLargest==0 ){
002813 return;
002814 }else{
002815 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
002816 assert( iDb>=0 && iDb<pParse->db->nDb );
002817 destroyRootPage(pParse, iLargest, iDb);
002818 iDestroyed = iLargest;
002819 }
002820 }
002821 }
002822
002823 /*
002824 ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
002825 ** after a DROP INDEX or DROP TABLE command.
002826 */
002827 static void sqlite3ClearStatTables(
002828 Parse *pParse, /* The parsing context */
002829 int iDb, /* The database number */
002830 const char *zType, /* "idx" or "tbl" */
002831 const char *zName /* Name of index or table */
002832 ){
002833 int i;
002834 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
002835 for(i=1; i<=4; i++){
002836 char zTab[24];
002837 sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
002838 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
002839 sqlite3NestedParse(pParse,
002840 "DELETE FROM %Q.%s WHERE %s=%Q",
002841 zDbName, zTab, zType, zName
002842 );
002843 }
002844 }
002845 }
002846
002847 /*
002848 ** Generate code to drop a table.
002849 */
002850 void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
002851 Vdbe *v;
002852 sqlite3 *db = pParse->db;
002853 Trigger *pTrigger;
002854 Db *pDb = &db->aDb[iDb];
002855
002856 v = sqlite3GetVdbe(pParse);
002857 assert( v!=0 );
002858 sqlite3BeginWriteOperation(pParse, 1, iDb);
002859
002860 #ifndef SQLITE_OMIT_VIRTUALTABLE
002861 if( IsVirtual(pTab) ){
002862 sqlite3VdbeAddOp0(v, OP_VBegin);
002863 }
002864 #endif
002865
002866 /* Drop all triggers associated with the table being dropped. Code
002867 ** is generated to remove entries from sqlite_master and/or
002868 ** sqlite_temp_master if required.
002869 */
002870 pTrigger = sqlite3TriggerList(pParse, pTab);
002871 while( pTrigger ){
002872 assert( pTrigger->pSchema==pTab->pSchema ||
002873 pTrigger->pSchema==db->aDb[1].pSchema );
002874 sqlite3DropTriggerPtr(pParse, pTrigger);
002875 pTrigger = pTrigger->pNext;
002876 }
002877
002878 #ifndef SQLITE_OMIT_AUTOINCREMENT
002879 /* Remove any entries of the sqlite_sequence table associated with
002880 ** the table being dropped. This is done before the table is dropped
002881 ** at the btree level, in case the sqlite_sequence table needs to
002882 ** move as a result of the drop (can happen in auto-vacuum mode).
002883 */
002884 if( pTab->tabFlags & TF_Autoincrement ){
002885 sqlite3NestedParse(pParse,
002886 "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
002887 pDb->zDbSName, pTab->zName
002888 );
002889 }
002890 #endif
002891
002892 /* Drop all SQLITE_MASTER table and index entries that refer to the
002893 ** table. The program name loops through the master table and deletes
002894 ** every row that refers to a table of the same name as the one being
002895 ** dropped. Triggers are handled separately because a trigger can be
002896 ** created in the temp database that refers to a table in another
002897 ** database.
002898 */
002899 sqlite3NestedParse(pParse,
002900 "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
002901 pDb->zDbSName, MASTER_NAME, pTab->zName);
002902 if( !isView && !IsVirtual(pTab) ){
002903 destroyTable(pParse, pTab);
002904 }
002905
002906 /* Remove the table entry from SQLite's internal schema and modify
002907 ** the schema cookie.
002908 */
002909 if( IsVirtual(pTab) ){
002910 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
002911 sqlite3MayAbort(pParse);
002912 }
002913 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
002914 sqlite3ChangeCookie(pParse, iDb);
002915 sqliteViewResetAll(db, iDb);
002916 }
002917
002918 /*
002919 ** Return TRUE if shadow tables should be read-only in the current
002920 ** context.
002921 */
002922 int sqlite3ReadOnlyShadowTables(sqlite3 *db){
002923 #ifndef SQLITE_OMIT_VIRTUALTABLE
002924 if( (db->flags & SQLITE_Defensive)!=0
002925 && db->pVtabCtx==0
002926 && db->nVdbeExec==0
002927 ){
002928 return 1;
002929 }
002930 #endif
002931 return 0;
002932 }
002933
002934 /*
002935 ** Return true if it is not allowed to drop the given table
002936 */
002937 static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
002938 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
002939 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
002940 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
002941 return 1;
002942 }
002943 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
002944 return 1;
002945 }
002946 return 0;
002947 }
002948
002949 /*
002950 ** This routine is called to do the work of a DROP TABLE statement.
002951 ** pName is the name of the table to be dropped.
002952 */
002953 void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
002954 Table *pTab;
002955 Vdbe *v;
002956 sqlite3 *db = pParse->db;
002957 int iDb;
002958
002959 if( db->mallocFailed ){
002960 goto exit_drop_table;
002961 }
002962 assert( pParse->nErr==0 );
002963 assert( pName->nSrc==1 );
002964 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
002965 if( noErr ) db->suppressErr++;
002966 assert( isView==0 || isView==LOCATE_VIEW );
002967 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
002968 if( noErr ) db->suppressErr--;
002969
002970 if( pTab==0 ){
002971 if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
002972 goto exit_drop_table;
002973 }
002974 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
002975 assert( iDb>=0 && iDb<db->nDb );
002976
002977 /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
002978 ** it is initialized.
002979 */
002980 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
002981 goto exit_drop_table;
002982 }
002983 #ifndef SQLITE_OMIT_AUTHORIZATION
002984 {
002985 int code;
002986 const char *zTab = SCHEMA_TABLE(iDb);
002987 const char *zDb = db->aDb[iDb].zDbSName;
002988 const char *zArg2 = 0;
002989 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
002990 goto exit_drop_table;
002991 }
002992 if( isView ){
002993 if( !OMIT_TEMPDB && iDb==1 ){
002994 code = SQLITE_DROP_TEMP_VIEW;
002995 }else{
002996 code = SQLITE_DROP_VIEW;
002997 }
002998 #ifndef SQLITE_OMIT_VIRTUALTABLE
002999 }else if( IsVirtual(pTab) ){
003000 code = SQLITE_DROP_VTABLE;
003001 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
003002 #endif
003003 }else{
003004 if( !OMIT_TEMPDB && iDb==1 ){
003005 code = SQLITE_DROP_TEMP_TABLE;
003006 }else{
003007 code = SQLITE_DROP_TABLE;
003008 }
003009 }
003010 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
003011 goto exit_drop_table;
003012 }
003013 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
003014 goto exit_drop_table;
003015 }
003016 }
003017 #endif
003018 if( tableMayNotBeDropped(db, pTab) ){
003019 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
003020 goto exit_drop_table;
003021 }
003022
003023 #ifndef SQLITE_OMIT_VIEW
003024 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
003025 ** on a table.
003026 */
003027 if( isView && pTab->pSelect==0 ){
003028 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
003029 goto exit_drop_table;
003030 }
003031 if( !isView && pTab->pSelect ){
003032 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
003033 goto exit_drop_table;
003034 }
003035 #endif
003036
003037 /* Generate code to remove the table from the master table
003038 ** on disk.
003039 */
003040 v = sqlite3GetVdbe(pParse);
003041 if( v ){
003042 sqlite3BeginWriteOperation(pParse, 1, iDb);
003043 if( !isView ){
003044 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
003045 sqlite3FkDropTable(pParse, pName, pTab);
003046 }
003047 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
003048 }
003049
003050 exit_drop_table:
003051 sqlite3SrcListDelete(db, pName);
003052 }
003053
003054 /*
003055 ** This routine is called to create a new foreign key on the table
003056 ** currently under construction. pFromCol determines which columns
003057 ** in the current table point to the foreign key. If pFromCol==0 then
003058 ** connect the key to the last column inserted. pTo is the name of
003059 ** the table referred to (a.k.a the "parent" table). pToCol is a list
003060 ** of tables in the parent pTo table. flags contains all
003061 ** information about the conflict resolution algorithms specified
003062 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
003063 **
003064 ** An FKey structure is created and added to the table currently
003065 ** under construction in the pParse->pNewTable field.
003066 **
003067 ** The foreign key is set for IMMEDIATE processing. A subsequent call
003068 ** to sqlite3DeferForeignKey() might change this to DEFERRED.
003069 */
003070 void sqlite3CreateForeignKey(
003071 Parse *pParse, /* Parsing context */
003072 ExprList *pFromCol, /* Columns in this table that point to other table */
003073 Token *pTo, /* Name of the other table */
003074 ExprList *pToCol, /* Columns in the other table */
003075 int flags /* Conflict resolution algorithms. */
003076 ){
003077 sqlite3 *db = pParse->db;
003078 #ifndef SQLITE_OMIT_FOREIGN_KEY
003079 FKey *pFKey = 0;
003080 FKey *pNextTo;
003081 Table *p = pParse->pNewTable;
003082 int nByte;
003083 int i;
003084 int nCol;
003085 char *z;
003086
003087 assert( pTo!=0 );
003088 if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
003089 if( pFromCol==0 ){
003090 int iCol = p->nCol-1;
003091 if( NEVER(iCol<0) ) goto fk_end;
003092 if( pToCol && pToCol->nExpr!=1 ){
003093 sqlite3ErrorMsg(pParse, "foreign key on %s"
003094 " should reference only one column of table %T",
003095 p->aCol[iCol].zName, pTo);
003096 goto fk_end;
003097 }
003098 nCol = 1;
003099 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
003100 sqlite3ErrorMsg(pParse,
003101 "number of columns in foreign key does not match the number of "
003102 "columns in the referenced table");
003103 goto fk_end;
003104 }else{
003105 nCol = pFromCol->nExpr;
003106 }
003107 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
003108 if( pToCol ){
003109 for(i=0; i<pToCol->nExpr; i++){
003110 nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
003111 }
003112 }
003113 pFKey = sqlite3DbMallocZero(db, nByte );
003114 if( pFKey==0 ){
003115 goto fk_end;
003116 }
003117 pFKey->pFrom = p;
003118 pFKey->pNextFrom = p->pFKey;
003119 z = (char*)&pFKey->aCol[nCol];
003120 pFKey->zTo = z;
003121 if( IN_RENAME_OBJECT ){
003122 sqlite3RenameTokenMap(pParse, (void*)z, pTo);
003123 }
003124 memcpy(z, pTo->z, pTo->n);
003125 z[pTo->n] = 0;
003126 sqlite3Dequote(z);
003127 z += pTo->n+1;
003128 pFKey->nCol = nCol;
003129 if( pFromCol==0 ){
003130 pFKey->aCol[0].iFrom = p->nCol-1;
003131 }else{
003132 for(i=0; i<nCol; i++){
003133 int j;
003134 for(j=0; j<p->nCol; j++){
003135 if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
003136 pFKey->aCol[i].iFrom = j;
003137 break;
003138 }
003139 }
003140 if( j>=p->nCol ){
003141 sqlite3ErrorMsg(pParse,
003142 "unknown column \"%s\" in foreign key definition",
003143 pFromCol->a[i].zName);
003144 goto fk_end;
003145 }
003146 if( IN_RENAME_OBJECT ){
003147 sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zName);
003148 }
003149 }
003150 }
003151 if( pToCol ){
003152 for(i=0; i<nCol; i++){
003153 int n = sqlite3Strlen30(pToCol->a[i].zName);
003154 pFKey->aCol[i].zCol = z;
003155 if( IN_RENAME_OBJECT ){
003156 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zName);
003157 }
003158 memcpy(z, pToCol->a[i].zName, n);
003159 z[n] = 0;
003160 z += n+1;
003161 }
003162 }
003163 pFKey->isDeferred = 0;
003164 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
003165 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
003166
003167 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
003168 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
003169 pFKey->zTo, (void *)pFKey
003170 );
003171 if( pNextTo==pFKey ){
003172 sqlite3OomFault(db);
003173 goto fk_end;
003174 }
003175 if( pNextTo ){
003176 assert( pNextTo->pPrevTo==0 );
003177 pFKey->pNextTo = pNextTo;
003178 pNextTo->pPrevTo = pFKey;
003179 }
003180
003181 /* Link the foreign key to the table as the last step.
003182 */
003183 p->pFKey = pFKey;
003184 pFKey = 0;
003185
003186 fk_end:
003187 sqlite3DbFree(db, pFKey);
003188 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
003189 sqlite3ExprListDelete(db, pFromCol);
003190 sqlite3ExprListDelete(db, pToCol);
003191 }
003192
003193 /*
003194 ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
003195 ** clause is seen as part of a foreign key definition. The isDeferred
003196 ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
003197 ** The behavior of the most recently created foreign key is adjusted
003198 ** accordingly.
003199 */
003200 void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
003201 #ifndef SQLITE_OMIT_FOREIGN_KEY
003202 Table *pTab;
003203 FKey *pFKey;
003204 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
003205 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
003206 pFKey->isDeferred = (u8)isDeferred;
003207 #endif
003208 }
003209
003210 /*
003211 ** Generate code that will erase and refill index *pIdx. This is
003212 ** used to initialize a newly created index or to recompute the
003213 ** content of an index in response to a REINDEX command.
003214 **
003215 ** if memRootPage is not negative, it means that the index is newly
003216 ** created. The register specified by memRootPage contains the
003217 ** root page number of the index. If memRootPage is negative, then
003218 ** the index already exists and must be cleared before being refilled and
003219 ** the root page number of the index is taken from pIndex->tnum.
003220 */
003221 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
003222 Table *pTab = pIndex->pTable; /* The table that is indexed */
003223 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
003224 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
003225 int iSorter; /* Cursor opened by OpenSorter (if in use) */
003226 int addr1; /* Address of top of loop */
003227 int addr2; /* Address to jump to for next iteration */
003228 int tnum; /* Root page of index */
003229 int iPartIdxLabel; /* Jump to this label to skip a row */
003230 Vdbe *v; /* Generate code into this virtual machine */
003231 KeyInfo *pKey; /* KeyInfo for index */
003232 int regRecord; /* Register holding assembled index record */
003233 sqlite3 *db = pParse->db; /* The database connection */
003234 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
003235
003236 #ifndef SQLITE_OMIT_AUTHORIZATION
003237 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
003238 db->aDb[iDb].zDbSName ) ){
003239 return;
003240 }
003241 #endif
003242
003243 /* Require a write-lock on the table to perform this operation */
003244 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
003245
003246 v = sqlite3GetVdbe(pParse);
003247 if( v==0 ) return;
003248 if( memRootPage>=0 ){
003249 tnum = memRootPage;
003250 }else{
003251 tnum = pIndex->tnum;
003252 }
003253 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
003254 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
003255
003256 /* Open the sorter cursor if we are to use one. */
003257 iSorter = pParse->nTab++;
003258 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
003259 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
003260
003261 /* Open the table. Loop through all rows of the table, inserting index
003262 ** records into the sorter. */
003263 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
003264 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
003265 regRecord = sqlite3GetTempReg(pParse);
003266 sqlite3MultiWrite(pParse);
003267
003268 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
003269 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
003270 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
003271 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
003272 sqlite3VdbeJumpHere(v, addr1);
003273 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
003274 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
003275 (char *)pKey, P4_KEYINFO);
003276 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
003277
003278 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
003279 if( IsUniqueIndex(pIndex) ){
003280 int j2 = sqlite3VdbeGoto(v, 1);
003281 addr2 = sqlite3VdbeCurrentAddr(v);
003282 sqlite3VdbeVerifyAbortable(v, OE_Abort);
003283 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
003284 pIndex->nKeyCol); VdbeCoverage(v);
003285 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
003286 sqlite3VdbeJumpHere(v, j2);
003287 }else{
003288 /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
003289 ** abort. The exception is if one of the indexed expressions contains a
003290 ** user function that throws an exception when it is evaluated. But the
003291 ** overhead of adding a statement journal to a CREATE INDEX statement is
003292 ** very small (since most of the pages written do not contain content that
003293 ** needs to be restored if the statement aborts), so we call
003294 ** sqlite3MayAbort() for all CREATE INDEX statements. */
003295 sqlite3MayAbort(pParse);
003296 addr2 = sqlite3VdbeCurrentAddr(v);
003297 }
003298 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
003299 if( !pIndex->bAscKeyBug ){
003300 /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
003301 ** faster by avoiding unnecessary seeks. But the optimization does
003302 ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
003303 ** with DESC primary keys, since those indexes have there keys in
003304 ** a different order from the main table.
003305 ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
003306 */
003307 sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
003308 }
003309 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
003310 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
003311 sqlite3ReleaseTempReg(pParse, regRecord);
003312 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
003313 sqlite3VdbeJumpHere(v, addr1);
003314
003315 sqlite3VdbeAddOp1(v, OP_Close, iTab);
003316 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
003317 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
003318 }
003319
003320 /*
003321 ** Allocate heap space to hold an Index object with nCol columns.
003322 **
003323 ** Increase the allocation size to provide an extra nExtra bytes
003324 ** of 8-byte aligned space after the Index object and return a
003325 ** pointer to this extra space in *ppExtra.
003326 */
003327 Index *sqlite3AllocateIndexObject(
003328 sqlite3 *db, /* Database connection */
003329 i16 nCol, /* Total number of columns in the index */
003330 int nExtra, /* Number of bytes of extra space to alloc */
003331 char **ppExtra /* Pointer to the "extra" space */
003332 ){
003333 Index *p; /* Allocated index object */
003334 int nByte; /* Bytes of space for Index object + arrays */
003335
003336 nByte = ROUND8(sizeof(Index)) + /* Index structure */
003337 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
003338 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
003339 sizeof(i16)*nCol + /* Index.aiColumn */
003340 sizeof(u8)*nCol); /* Index.aSortOrder */
003341 p = sqlite3DbMallocZero(db, nByte + nExtra);
003342 if( p ){
003343 char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
003344 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
003345 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
003346 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
003347 p->aSortOrder = (u8*)pExtra;
003348 p->nColumn = nCol;
003349 p->nKeyCol = nCol - 1;
003350 *ppExtra = ((char*)p) + nByte;
003351 }
003352 return p;
003353 }
003354
003355 /*
003356 ** If expression list pList contains an expression that was parsed with
003357 ** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
003358 ** pParse and return non-zero. Otherwise, return zero.
003359 */
003360 int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
003361 if( pList ){
003362 int i;
003363 for(i=0; i<pList->nExpr; i++){
003364 if( pList->a[i].bNulls ){
003365 u8 sf = pList->a[i].sortFlags;
003366 sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
003367 (sf==0 || sf==3) ? "FIRST" : "LAST"
003368 );
003369 return 1;
003370 }
003371 }
003372 }
003373 return 0;
003374 }
003375
003376 /*
003377 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
003378 ** and pTblList is the name of the table that is to be indexed. Both will
003379 ** be NULL for a primary key or an index that is created to satisfy a
003380 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
003381 ** as the table to be indexed. pParse->pNewTable is a table that is
003382 ** currently being constructed by a CREATE TABLE statement.
003383 **
003384 ** pList is a list of columns to be indexed. pList will be NULL if this
003385 ** is a primary key or unique-constraint on the most recent column added
003386 ** to the table currently under construction.
003387 */
003388 void sqlite3CreateIndex(
003389 Parse *pParse, /* All information about this parse */
003390 Token *pName1, /* First part of index name. May be NULL */
003391 Token *pName2, /* Second part of index name. May be NULL */
003392 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
003393 ExprList *pList, /* A list of columns to be indexed */
003394 int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
003395 Token *pStart, /* The CREATE token that begins this statement */
003396 Expr *pPIWhere, /* WHERE clause for partial indices */
003397 int sortOrder, /* Sort order of primary key when pList==NULL */
003398 int ifNotExist, /* Omit error if index already exists */
003399 u8 idxType /* The index type */
003400 ){
003401 Table *pTab = 0; /* Table to be indexed */
003402 Index *pIndex = 0; /* The index to be created */
003403 char *zName = 0; /* Name of the index */
003404 int nName; /* Number of characters in zName */
003405 int i, j;
003406 DbFixer sFix; /* For assigning database names to pTable */
003407 int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
003408 sqlite3 *db = pParse->db;
003409 Db *pDb; /* The specific table containing the indexed database */
003410 int iDb; /* Index of the database that is being written */
003411 Token *pName = 0; /* Unqualified name of the index to create */
003412 struct ExprList_item *pListItem; /* For looping over pList */
003413 int nExtra = 0; /* Space allocated for zExtra[] */
003414 int nExtraCol; /* Number of extra columns needed */
003415 char *zExtra = 0; /* Extra space after the Index object */
003416 Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */
003417
003418 if( db->mallocFailed || pParse->nErr>0 ){
003419 goto exit_create_index;
003420 }
003421 if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
003422 goto exit_create_index;
003423 }
003424 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
003425 goto exit_create_index;
003426 }
003427 if( sqlite3HasExplicitNulls(pParse, pList) ){
003428 goto exit_create_index;
003429 }
003430
003431 /*
003432 ** Find the table that is to be indexed. Return early if not found.
003433 */
003434 if( pTblName!=0 ){
003435
003436 /* Use the two-part index name to determine the database
003437 ** to search for the table. 'Fix' the table name to this db
003438 ** before looking up the table.
003439 */
003440 assert( pName1 && pName2 );
003441 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
003442 if( iDb<0 ) goto exit_create_index;
003443 assert( pName && pName->z );
003444
003445 #ifndef SQLITE_OMIT_TEMPDB
003446 /* If the index name was unqualified, check if the table
003447 ** is a temp table. If so, set the database to 1. Do not do this
003448 ** if initialising a database schema.
003449 */
003450 if( !db->init.busy ){
003451 pTab = sqlite3SrcListLookup(pParse, pTblName);
003452 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
003453 iDb = 1;
003454 }
003455 }
003456 #endif
003457
003458 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
003459 if( sqlite3FixSrcList(&sFix, pTblName) ){
003460 /* Because the parser constructs pTblName from a single identifier,
003461 ** sqlite3FixSrcList can never fail. */
003462 assert(0);
003463 }
003464 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
003465 assert( db->mallocFailed==0 || pTab==0 );
003466 if( pTab==0 ) goto exit_create_index;
003467 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
003468 sqlite3ErrorMsg(pParse,
003469 "cannot create a TEMP index on non-TEMP table \"%s\"",
003470 pTab->zName);
003471 goto exit_create_index;
003472 }
003473 if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
003474 }else{
003475 assert( pName==0 );
003476 assert( pStart==0 );
003477 pTab = pParse->pNewTable;
003478 if( !pTab ) goto exit_create_index;
003479 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
003480 }
003481 pDb = &db->aDb[iDb];
003482
003483 assert( pTab!=0 );
003484 assert( pParse->nErr==0 );
003485 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
003486 && db->init.busy==0
003487 && pTblName!=0
003488 #if SQLITE_USER_AUTHENTICATION
003489 && sqlite3UserAuthTable(pTab->zName)==0
003490 #endif
003491 #ifdef SQLITE_ALLOW_SQLITE_MASTER_INDEX
003492 && sqlite3StrICmp(&pTab->zName[7],"master")!=0
003493 #endif
003494 ){
003495 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
003496 goto exit_create_index;
003497 }
003498 #ifndef SQLITE_OMIT_VIEW
003499 if( pTab->pSelect ){
003500 sqlite3ErrorMsg(pParse, "views may not be indexed");
003501 goto exit_create_index;
003502 }
003503 #endif
003504 #ifndef SQLITE_OMIT_VIRTUALTABLE
003505 if( IsVirtual(pTab) ){
003506 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
003507 goto exit_create_index;
003508 }
003509 #endif
003510
003511 /*
003512 ** Find the name of the index. Make sure there is not already another
003513 ** index or table with the same name.
003514 **
003515 ** Exception: If we are reading the names of permanent indices from the
003516 ** sqlite_master table (because some other process changed the schema) and
003517 ** one of the index names collides with the name of a temporary table or
003518 ** index, then we will continue to process this index.
003519 **
003520 ** If pName==0 it means that we are
003521 ** dealing with a primary key or UNIQUE constraint. We have to invent our
003522 ** own name.
003523 */
003524 if( pName ){
003525 zName = sqlite3NameFromToken(db, pName);
003526 if( zName==0 ) goto exit_create_index;
003527 assert( pName->z!=0 );
003528 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
003529 goto exit_create_index;
003530 }
003531 if( !IN_RENAME_OBJECT ){
003532 if( !db->init.busy ){
003533 if( sqlite3FindTable(db, zName, 0)!=0 ){
003534 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
003535 goto exit_create_index;
003536 }
003537 }
003538 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
003539 if( !ifNotExist ){
003540 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
003541 }else{
003542 assert( !db->init.busy );
003543 sqlite3CodeVerifySchema(pParse, iDb);
003544 }
003545 goto exit_create_index;
003546 }
003547 }
003548 }else{
003549 int n;
003550 Index *pLoop;
003551 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
003552 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
003553 if( zName==0 ){
003554 goto exit_create_index;
003555 }
003556
003557 /* Automatic index names generated from within sqlite3_declare_vtab()
003558 ** must have names that are distinct from normal automatic index names.
003559 ** The following statement converts "sqlite3_autoindex..." into
003560 ** "sqlite3_butoindex..." in order to make the names distinct.
003561 ** The "vtab_err.test" test demonstrates the need of this statement. */
003562 if( IN_SPECIAL_PARSE ) zName[7]++;
003563 }
003564
003565 /* Check for authorization to create an index.
003566 */
003567 #ifndef SQLITE_OMIT_AUTHORIZATION
003568 if( !IN_RENAME_OBJECT ){
003569 const char *zDb = pDb->zDbSName;
003570 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
003571 goto exit_create_index;
003572 }
003573 i = SQLITE_CREATE_INDEX;
003574 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
003575 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
003576 goto exit_create_index;
003577 }
003578 }
003579 #endif
003580
003581 /* If pList==0, it means this routine was called to make a primary
003582 ** key out of the last column added to the table under construction.
003583 ** So create a fake list to simulate this.
003584 */
003585 if( pList==0 ){
003586 Token prevCol;
003587 Column *pCol = &pTab->aCol[pTab->nCol-1];
003588 pCol->colFlags |= COLFLAG_UNIQUE;
003589 sqlite3TokenInit(&prevCol, pCol->zName);
003590 pList = sqlite3ExprListAppend(pParse, 0,
003591 sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
003592 if( pList==0 ) goto exit_create_index;
003593 assert( pList->nExpr==1 );
003594 sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
003595 }else{
003596 sqlite3ExprListCheckLength(pParse, pList, "index");
003597 if( pParse->nErr ) goto exit_create_index;
003598 }
003599
003600 /* Figure out how many bytes of space are required to store explicitly
003601 ** specified collation sequence names.
003602 */
003603 for(i=0; i<pList->nExpr; i++){
003604 Expr *pExpr = pList->a[i].pExpr;
003605 assert( pExpr!=0 );
003606 if( pExpr->op==TK_COLLATE ){
003607 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
003608 }
003609 }
003610
003611 /*
003612 ** Allocate the index structure.
003613 */
003614 nName = sqlite3Strlen30(zName);
003615 nExtraCol = pPk ? pPk->nKeyCol : 1;
003616 assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
003617 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
003618 nName + nExtra + 1, &zExtra);
003619 if( db->mallocFailed ){
003620 goto exit_create_index;
003621 }
003622 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
003623 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
003624 pIndex->zName = zExtra;
003625 zExtra += nName + 1;
003626 memcpy(pIndex->zName, zName, nName+1);
003627 pIndex->pTable = pTab;
003628 pIndex->onError = (u8)onError;
003629 pIndex->uniqNotNull = onError!=OE_None;
003630 pIndex->idxType = idxType;
003631 pIndex->pSchema = db->aDb[iDb].pSchema;
003632 pIndex->nKeyCol = pList->nExpr;
003633 if( pPIWhere ){
003634 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
003635 pIndex->pPartIdxWhere = pPIWhere;
003636 pPIWhere = 0;
003637 }
003638 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
003639
003640 /* Check to see if we should honor DESC requests on index columns
003641 */
003642 if( pDb->pSchema->file_format>=4 ){
003643 sortOrderMask = -1; /* Honor DESC */
003644 }else{
003645 sortOrderMask = 0; /* Ignore DESC */
003646 }
003647
003648 /* Analyze the list of expressions that form the terms of the index and
003649 ** report any errors. In the common case where the expression is exactly
003650 ** a table column, store that column in aiColumn[]. For general expressions,
003651 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
003652 **
003653 ** TODO: Issue a warning if two or more columns of the index are identical.
003654 ** TODO: Issue a warning if the table primary key is used as part of the
003655 ** index key.
003656 */
003657 pListItem = pList->a;
003658 if( IN_RENAME_OBJECT ){
003659 pIndex->aColExpr = pList;
003660 pList = 0;
003661 }
003662 for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
003663 Expr *pCExpr; /* The i-th index expression */
003664 int requestedSortOrder; /* ASC or DESC on the i-th expression */
003665 const char *zColl; /* Collation sequence name */
003666
003667 sqlite3StringToId(pListItem->pExpr);
003668 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
003669 if( pParse->nErr ) goto exit_create_index;
003670 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
003671 if( pCExpr->op!=TK_COLUMN ){
003672 if( pTab==pParse->pNewTable ){
003673 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
003674 "UNIQUE constraints");
003675 goto exit_create_index;
003676 }
003677 if( pIndex->aColExpr==0 ){
003678 pIndex->aColExpr = pList;
003679 pList = 0;
003680 }
003681 j = XN_EXPR;
003682 pIndex->aiColumn[i] = XN_EXPR;
003683 pIndex->uniqNotNull = 0;
003684 }else{
003685 j = pCExpr->iColumn;
003686 assert( j<=0x7fff );
003687 if( j<0 ){
003688 j = pTab->iPKey;
003689 }else{
003690 if( pTab->aCol[j].notNull==0 ){
003691 pIndex->uniqNotNull = 0;
003692 }
003693 if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
003694 pIndex->bHasVCol = 1;
003695 }
003696 }
003697 pIndex->aiColumn[i] = (i16)j;
003698 }
003699 zColl = 0;
003700 if( pListItem->pExpr->op==TK_COLLATE ){
003701 int nColl;
003702 zColl = pListItem->pExpr->u.zToken;
003703 nColl = sqlite3Strlen30(zColl) + 1;
003704 assert( nExtra>=nColl );
003705 memcpy(zExtra, zColl, nColl);
003706 zColl = zExtra;
003707 zExtra += nColl;
003708 nExtra -= nColl;
003709 }else if( j>=0 ){
003710 zColl = pTab->aCol[j].zColl;
003711 }
003712 if( !zColl ) zColl = sqlite3StrBINARY;
003713 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
003714 goto exit_create_index;
003715 }
003716 pIndex->azColl[i] = zColl;
003717 requestedSortOrder = pListItem->sortFlags & sortOrderMask;
003718 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
003719 }
003720
003721 /* Append the table key to the end of the index. For WITHOUT ROWID
003722 ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For
003723 ** normal tables (when pPk==0) this will be the rowid.
003724 */
003725 if( pPk ){
003726 for(j=0; j<pPk->nKeyCol; j++){
003727 int x = pPk->aiColumn[j];
003728 assert( x>=0 );
003729 if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
003730 pIndex->nColumn--;
003731 }else{
003732 testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
003733 pIndex->aiColumn[i] = x;
003734 pIndex->azColl[i] = pPk->azColl[j];
003735 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
003736 i++;
003737 }
003738 }
003739 assert( i==pIndex->nColumn );
003740 }else{
003741 pIndex->aiColumn[i] = XN_ROWID;
003742 pIndex->azColl[i] = sqlite3StrBINARY;
003743 }
003744 sqlite3DefaultRowEst(pIndex);
003745 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
003746
003747 /* If this index contains every column of its table, then mark
003748 ** it as a covering index */
003749 assert( HasRowid(pTab)
003750 || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
003751 recomputeColumnsNotIndexed(pIndex);
003752 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
003753 pIndex->isCovering = 1;
003754 for(j=0; j<pTab->nCol; j++){
003755 if( j==pTab->iPKey ) continue;
003756 if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue;
003757 pIndex->isCovering = 0;
003758 break;
003759 }
003760 }
003761
003762 if( pTab==pParse->pNewTable ){
003763 /* This routine has been called to create an automatic index as a
003764 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
003765 ** a PRIMARY KEY or UNIQUE clause following the column definitions.
003766 ** i.e. one of:
003767 **
003768 ** CREATE TABLE t(x PRIMARY KEY, y);
003769 ** CREATE TABLE t(x, y, UNIQUE(x, y));
003770 **
003771 ** Either way, check to see if the table already has such an index. If
003772 ** so, don't bother creating this one. This only applies to
003773 ** automatically created indices. Users can do as they wish with
003774 ** explicit indices.
003775 **
003776 ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
003777 ** (and thus suppressing the second one) even if they have different
003778 ** sort orders.
003779 **
003780 ** If there are different collating sequences or if the columns of
003781 ** the constraint occur in different orders, then the constraints are
003782 ** considered distinct and both result in separate indices.
003783 */
003784 Index *pIdx;
003785 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
003786 int k;
003787 assert( IsUniqueIndex(pIdx) );
003788 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
003789 assert( IsUniqueIndex(pIndex) );
003790
003791 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
003792 for(k=0; k<pIdx->nKeyCol; k++){
003793 const char *z1;
003794 const char *z2;
003795 assert( pIdx->aiColumn[k]>=0 );
003796 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
003797 z1 = pIdx->azColl[k];
003798 z2 = pIndex->azColl[k];
003799 if( sqlite3StrICmp(z1, z2) ) break;
003800 }
003801 if( k==pIdx->nKeyCol ){
003802 if( pIdx->onError!=pIndex->onError ){
003803 /* This constraint creates the same index as a previous
003804 ** constraint specified somewhere in the CREATE TABLE statement.
003805 ** However the ON CONFLICT clauses are different. If both this
003806 ** constraint and the previous equivalent constraint have explicit
003807 ** ON CONFLICT clauses this is an error. Otherwise, use the
003808 ** explicitly specified behavior for the index.
003809 */
003810 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
003811 sqlite3ErrorMsg(pParse,
003812 "conflicting ON CONFLICT clauses specified", 0);
003813 }
003814 if( pIdx->onError==OE_Default ){
003815 pIdx->onError = pIndex->onError;
003816 }
003817 }
003818 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
003819 if( IN_RENAME_OBJECT ){
003820 pIndex->pNext = pParse->pNewIndex;
003821 pParse->pNewIndex = pIndex;
003822 pIndex = 0;
003823 }
003824 goto exit_create_index;
003825 }
003826 }
003827 }
003828
003829 if( !IN_RENAME_OBJECT ){
003830
003831 /* Link the new Index structure to its table and to the other
003832 ** in-memory database structures.
003833 */
003834 assert( pParse->nErr==0 );
003835 if( db->init.busy ){
003836 Index *p;
003837 assert( !IN_SPECIAL_PARSE );
003838 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
003839 if( pTblName!=0 ){
003840 pIndex->tnum = db->init.newTnum;
003841 if( sqlite3IndexHasDuplicateRootPage(pIndex) ){
003842 sqlite3ErrorMsg(pParse, "invalid rootpage");
003843 pParse->rc = SQLITE_CORRUPT_BKPT;
003844 goto exit_create_index;
003845 }
003846 }
003847 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
003848 pIndex->zName, pIndex);
003849 if( p ){
003850 assert( p==pIndex ); /* Malloc must have failed */
003851 sqlite3OomFault(db);
003852 goto exit_create_index;
003853 }
003854 db->mDbFlags |= DBFLAG_SchemaChange;
003855 }
003856
003857 /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
003858 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
003859 ** emit code to allocate the index rootpage on disk and make an entry for
003860 ** the index in the sqlite_master table and populate the index with
003861 ** content. But, do not do this if we are simply reading the sqlite_master
003862 ** table to parse the schema, or if this index is the PRIMARY KEY index
003863 ** of a WITHOUT ROWID table.
003864 **
003865 ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
003866 ** or UNIQUE index in a CREATE TABLE statement. Since the table
003867 ** has just been created, it contains no data and the index initialization
003868 ** step can be skipped.
003869 */
003870 else if( HasRowid(pTab) || pTblName!=0 ){
003871 Vdbe *v;
003872 char *zStmt;
003873 int iMem = ++pParse->nMem;
003874
003875 v = sqlite3GetVdbe(pParse);
003876 if( v==0 ) goto exit_create_index;
003877
003878 sqlite3BeginWriteOperation(pParse, 1, iDb);
003879
003880 /* Create the rootpage for the index using CreateIndex. But before
003881 ** doing so, code a Noop instruction and store its address in
003882 ** Index.tnum. This is required in case this index is actually a
003883 ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
003884 ** that case the convertToWithoutRowidTable() routine will replace
003885 ** the Noop with a Goto to jump over the VDBE code generated below. */
003886 pIndex->tnum = sqlite3VdbeAddOp0(v, OP_Noop);
003887 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
003888
003889 /* Gather the complete text of the CREATE INDEX statement into
003890 ** the zStmt variable
003891 */
003892 assert( pName!=0 || pStart==0 );
003893 if( pStart ){
003894 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
003895 if( pName->z[n-1]==';' ) n--;
003896 /* A named index with an explicit CREATE INDEX statement */
003897 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
003898 onError==OE_None ? "" : " UNIQUE", n, pName->z);
003899 }else{
003900 /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
003901 /* zStmt = sqlite3MPrintf(""); */
003902 zStmt = 0;
003903 }
003904
003905 /* Add an entry in sqlite_master for this index
003906 */
003907 sqlite3NestedParse(pParse,
003908 "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
003909 db->aDb[iDb].zDbSName, MASTER_NAME,
003910 pIndex->zName,
003911 pTab->zName,
003912 iMem,
003913 zStmt
003914 );
003915 sqlite3DbFree(db, zStmt);
003916
003917 /* Fill the index with data and reparse the schema. Code an OP_Expire
003918 ** to invalidate all pre-compiled statements.
003919 */
003920 if( pTblName ){
003921 sqlite3RefillIndex(pParse, pIndex, iMem);
003922 sqlite3ChangeCookie(pParse, iDb);
003923 sqlite3VdbeAddParseSchemaOp(v, iDb,
003924 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
003925 sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
003926 }
003927
003928 sqlite3VdbeJumpHere(v, pIndex->tnum);
003929 }
003930 }
003931 if( db->init.busy || pTblName==0 ){
003932 pIndex->pNext = pTab->pIndex;
003933 pTab->pIndex = pIndex;
003934 pIndex = 0;
003935 }
003936 else if( IN_RENAME_OBJECT ){
003937 assert( pParse->pNewIndex==0 );
003938 pParse->pNewIndex = pIndex;
003939 pIndex = 0;
003940 }
003941
003942 /* Clean up before exiting */
003943 exit_create_index:
003944 if( pIndex ) sqlite3FreeIndex(db, pIndex);
003945 if( pTab ){ /* Ensure all REPLACE indexes are at the end of the list */
003946 Index **ppFrom = &pTab->pIndex;
003947 Index *pThis;
003948 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
003949 Index *pNext;
003950 if( pThis->onError!=OE_Replace ) continue;
003951 while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
003952 *ppFrom = pNext;
003953 pThis->pNext = pNext->pNext;
003954 pNext->pNext = pThis;
003955 ppFrom = &pNext->pNext;
003956 }
003957 break;
003958 }
003959 }
003960 sqlite3ExprDelete(db, pPIWhere);
003961 sqlite3ExprListDelete(db, pList);
003962 sqlite3SrcListDelete(db, pTblName);
003963 sqlite3DbFree(db, zName);
003964 }
003965
003966 /*
003967 ** Fill the Index.aiRowEst[] array with default information - information
003968 ** to be used when we have not run the ANALYZE command.
003969 **
003970 ** aiRowEst[0] is supposed to contain the number of elements in the index.
003971 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
003972 ** number of rows in the table that match any particular value of the
003973 ** first column of the index. aiRowEst[2] is an estimate of the number
003974 ** of rows that match any particular combination of the first 2 columns
003975 ** of the index. And so forth. It must always be the case that
003976 *
003977 ** aiRowEst[N]<=aiRowEst[N-1]
003978 ** aiRowEst[N]>=1
003979 **
003980 ** Apart from that, we have little to go on besides intuition as to
003981 ** how aiRowEst[] should be initialized. The numbers generated here
003982 ** are based on typical values found in actual indices.
003983 */
003984 void sqlite3DefaultRowEst(Index *pIdx){
003985 /* 10, 9, 8, 7, 6 */
003986 LogEst aVal[] = { 33, 32, 30, 28, 26 };
003987 LogEst *a = pIdx->aiRowLogEst;
003988 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
003989 int i;
003990
003991 /* Indexes with default row estimates should not have stat1 data */
003992 assert( !pIdx->hasStat1 );
003993
003994 /* Set the first entry (number of rows in the index) to the estimated
003995 ** number of rows in the table, or half the number of rows in the table
003996 ** for a partial index. But do not let the estimate drop below 10. */
003997 a[0] = pIdx->pTable->nRowLogEst;
003998 if( pIdx->pPartIdxWhere!=0 ) a[0] -= 10; assert( 10==sqlite3LogEst(2) );
003999 if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) );
004000
004001 /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
004002 ** 6 and each subsequent value (if any) is 5. */
004003 memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
004004 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
004005 a[i] = 23; assert( 23==sqlite3LogEst(5) );
004006 }
004007
004008 assert( 0==sqlite3LogEst(1) );
004009 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
004010 }
004011
004012 /*
004013 ** This routine will drop an existing named index. This routine
004014 ** implements the DROP INDEX statement.
004015 */
004016 void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
004017 Index *pIndex;
004018 Vdbe *v;
004019 sqlite3 *db = pParse->db;
004020 int iDb;
004021
004022 assert( pParse->nErr==0 ); /* Never called with prior errors */
004023 if( db->mallocFailed ){
004024 goto exit_drop_index;
004025 }
004026 assert( pName->nSrc==1 );
004027 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
004028 goto exit_drop_index;
004029 }
004030 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
004031 if( pIndex==0 ){
004032 if( !ifExists ){
004033 sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
004034 }else{
004035 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
004036 }
004037 pParse->checkSchema = 1;
004038 goto exit_drop_index;
004039 }
004040 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
004041 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
004042 "or PRIMARY KEY constraint cannot be dropped", 0);
004043 goto exit_drop_index;
004044 }
004045 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
004046 #ifndef SQLITE_OMIT_AUTHORIZATION
004047 {
004048 int code = SQLITE_DROP_INDEX;
004049 Table *pTab = pIndex->pTable;
004050 const char *zDb = db->aDb[iDb].zDbSName;
004051 const char *zTab = SCHEMA_TABLE(iDb);
004052 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
004053 goto exit_drop_index;
004054 }
004055 if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
004056 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
004057 goto exit_drop_index;
004058 }
004059 }
004060 #endif
004061
004062 /* Generate code to remove the index and from the master table */
004063 v = sqlite3GetVdbe(pParse);
004064 if( v ){
004065 sqlite3BeginWriteOperation(pParse, 1, iDb);
004066 sqlite3NestedParse(pParse,
004067 "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
004068 db->aDb[iDb].zDbSName, MASTER_NAME, pIndex->zName
004069 );
004070 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
004071 sqlite3ChangeCookie(pParse, iDb);
004072 destroyRootPage(pParse, pIndex->tnum, iDb);
004073 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
004074 }
004075
004076 exit_drop_index:
004077 sqlite3SrcListDelete(db, pName);
004078 }
004079
004080 /*
004081 ** pArray is a pointer to an array of objects. Each object in the
004082 ** array is szEntry bytes in size. This routine uses sqlite3DbRealloc()
004083 ** to extend the array so that there is space for a new object at the end.
004084 **
004085 ** When this function is called, *pnEntry contains the current size of
004086 ** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
004087 ** in total).
004088 **
004089 ** If the realloc() is successful (i.e. if no OOM condition occurs), the
004090 ** space allocated for the new object is zeroed, *pnEntry updated to
004091 ** reflect the new size of the array and a pointer to the new allocation
004092 ** returned. *pIdx is set to the index of the new array entry in this case.
004093 **
004094 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
004095 ** unchanged and a copy of pArray returned.
004096 */
004097 void *sqlite3ArrayAllocate(
004098 sqlite3 *db, /* Connection to notify of malloc failures */
004099 void *pArray, /* Array of objects. Might be reallocated */
004100 int szEntry, /* Size of each object in the array */
004101 int *pnEntry, /* Number of objects currently in use */
004102 int *pIdx /* Write the index of a new slot here */
004103 ){
004104 char *z;
004105 sqlite3_int64 n = *pIdx = *pnEntry;
004106 if( (n & (n-1))==0 ){
004107 sqlite3_int64 sz = (n==0) ? 1 : 2*n;
004108 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
004109 if( pNew==0 ){
004110 *pIdx = -1;
004111 return pArray;
004112 }
004113 pArray = pNew;
004114 }
004115 z = (char*)pArray;
004116 memset(&z[n * szEntry], 0, szEntry);
004117 ++*pnEntry;
004118 return pArray;
004119 }
004120
004121 /*
004122 ** Append a new element to the given IdList. Create a new IdList if
004123 ** need be.
004124 **
004125 ** A new IdList is returned, or NULL if malloc() fails.
004126 */
004127 IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
004128 sqlite3 *db = pParse->db;
004129 int i;
004130 if( pList==0 ){
004131 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
004132 if( pList==0 ) return 0;
004133 }
004134 pList->a = sqlite3ArrayAllocate(
004135 db,
004136 pList->a,
004137 sizeof(pList->a[0]),
004138 &pList->nId,
004139 &i
004140 );
004141 if( i<0 ){
004142 sqlite3IdListDelete(db, pList);
004143 return 0;
004144 }
004145 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
004146 if( IN_RENAME_OBJECT && pList->a[i].zName ){
004147 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
004148 }
004149 return pList;
004150 }
004151
004152 /*
004153 ** Delete an IdList.
004154 */
004155 void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
004156 int i;
004157 if( pList==0 ) return;
004158 for(i=0; i<pList->nId; i++){
004159 sqlite3DbFree(db, pList->a[i].zName);
004160 }
004161 sqlite3DbFree(db, pList->a);
004162 sqlite3DbFreeNN(db, pList);
004163 }
004164
004165 /*
004166 ** Return the index in pList of the identifier named zId. Return -1
004167 ** if not found.
004168 */
004169 int sqlite3IdListIndex(IdList *pList, const char *zName){
004170 int i;
004171 if( pList==0 ) return -1;
004172 for(i=0; i<pList->nId; i++){
004173 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
004174 }
004175 return -1;
004176 }
004177
004178 /*
004179 ** Maximum size of a SrcList object.
004180 ** The SrcList object is used to represent the FROM clause of a
004181 ** SELECT statement, and the query planner cannot deal with more
004182 ** than 64 tables in a join. So any value larger than 64 here
004183 ** is sufficient for most uses. Smaller values, like say 10, are
004184 ** appropriate for small and memory-limited applications.
004185 */
004186 #ifndef SQLITE_MAX_SRCLIST
004187 # define SQLITE_MAX_SRCLIST 200
004188 #endif
004189
004190 /*
004191 ** Expand the space allocated for the given SrcList object by
004192 ** creating nExtra new slots beginning at iStart. iStart is zero based.
004193 ** New slots are zeroed.
004194 **
004195 ** For example, suppose a SrcList initially contains two entries: A,B.
004196 ** To append 3 new entries onto the end, do this:
004197 **
004198 ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
004199 **
004200 ** After the call above it would contain: A, B, nil, nil, nil.
004201 ** If the iStart argument had been 1 instead of 2, then the result
004202 ** would have been: A, nil, nil, nil, B. To prepend the new slots,
004203 ** the iStart value would be 0. The result then would
004204 ** be: nil, nil, nil, A, B.
004205 **
004206 ** If a memory allocation fails or the SrcList becomes too large, leave
004207 ** the original SrcList unchanged, return NULL, and leave an error message
004208 ** in pParse.
004209 */
004210 SrcList *sqlite3SrcListEnlarge(
004211 Parse *pParse, /* Parsing context into which errors are reported */
004212 SrcList *pSrc, /* The SrcList to be enlarged */
004213 int nExtra, /* Number of new slots to add to pSrc->a[] */
004214 int iStart /* Index in pSrc->a[] of first new slot */
004215 ){
004216 int i;
004217
004218 /* Sanity checking on calling parameters */
004219 assert( iStart>=0 );
004220 assert( nExtra>=1 );
004221 assert( pSrc!=0 );
004222 assert( iStart<=pSrc->nSrc );
004223
004224 /* Allocate additional space if needed */
004225 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
004226 SrcList *pNew;
004227 sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
004228 sqlite3 *db = pParse->db;
004229
004230 if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
004231 sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
004232 SQLITE_MAX_SRCLIST);
004233 return 0;
004234 }
004235 if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST;
004236 pNew = sqlite3DbRealloc(db, pSrc,
004237 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
004238 if( pNew==0 ){
004239 assert( db->mallocFailed );
004240 return 0;
004241 }
004242 pSrc = pNew;
004243 pSrc->nAlloc = nAlloc;
004244 }
004245
004246 /* Move existing slots that come after the newly inserted slots
004247 ** out of the way */
004248 for(i=pSrc->nSrc-1; i>=iStart; i--){
004249 pSrc->a[i+nExtra] = pSrc->a[i];
004250 }
004251 pSrc->nSrc += nExtra;
004252
004253 /* Zero the newly allocated slots */
004254 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
004255 for(i=iStart; i<iStart+nExtra; i++){
004256 pSrc->a[i].iCursor = -1;
004257 }
004258
004259 /* Return a pointer to the enlarged SrcList */
004260 return pSrc;
004261 }
004262
004263
004264 /*
004265 ** Append a new table name to the given SrcList. Create a new SrcList if
004266 ** need be. A new entry is created in the SrcList even if pTable is NULL.
004267 **
004268 ** A SrcList is returned, or NULL if there is an OOM error or if the
004269 ** SrcList grows to large. The returned
004270 ** SrcList might be the same as the SrcList that was input or it might be
004271 ** a new one. If an OOM error does occurs, then the prior value of pList
004272 ** that is input to this routine is automatically freed.
004273 **
004274 ** If pDatabase is not null, it means that the table has an optional
004275 ** database name prefix. Like this: "database.table". The pDatabase
004276 ** points to the table name and the pTable points to the database name.
004277 ** The SrcList.a[].zName field is filled with the table name which might
004278 ** come from pTable (if pDatabase is NULL) or from pDatabase.
004279 ** SrcList.a[].zDatabase is filled with the database name from pTable,
004280 ** or with NULL if no database is specified.
004281 **
004282 ** In other words, if call like this:
004283 **
004284 ** sqlite3SrcListAppend(D,A,B,0);
004285 **
004286 ** Then B is a table name and the database name is unspecified. If called
004287 ** like this:
004288 **
004289 ** sqlite3SrcListAppend(D,A,B,C);
004290 **
004291 ** Then C is the table name and B is the database name. If C is defined
004292 ** then so is B. In other words, we never have a case where:
004293 **
004294 ** sqlite3SrcListAppend(D,A,0,C);
004295 **
004296 ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
004297 ** before being added to the SrcList.
004298 */
004299 SrcList *sqlite3SrcListAppend(
004300 Parse *pParse, /* Parsing context, in which errors are reported */
004301 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
004302 Token *pTable, /* Table to append */
004303 Token *pDatabase /* Database of the table */
004304 ){
004305 struct SrcList_item *pItem;
004306 sqlite3 *db;
004307 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
004308 assert( pParse!=0 );
004309 assert( pParse->db!=0 );
004310 db = pParse->db;
004311 if( pList==0 ){
004312 pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
004313 if( pList==0 ) return 0;
004314 pList->nAlloc = 1;
004315 pList->nSrc = 1;
004316 memset(&pList->a[0], 0, sizeof(pList->a[0]));
004317 pList->a[0].iCursor = -1;
004318 }else{
004319 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
004320 if( pNew==0 ){
004321 sqlite3SrcListDelete(db, pList);
004322 return 0;
004323 }else{
004324 pList = pNew;
004325 }
004326 }
004327 pItem = &pList->a[pList->nSrc-1];
004328 if( pDatabase && pDatabase->z==0 ){
004329 pDatabase = 0;
004330 }
004331 if( pDatabase ){
004332 pItem->zName = sqlite3NameFromToken(db, pDatabase);
004333 pItem->zDatabase = sqlite3NameFromToken(db, pTable);
004334 }else{
004335 pItem->zName = sqlite3NameFromToken(db, pTable);
004336 pItem->zDatabase = 0;
004337 }
004338 return pList;
004339 }
004340
004341 /*
004342 ** Assign VdbeCursor index numbers to all tables in a SrcList
004343 */
004344 void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
004345 int i;
004346 struct SrcList_item *pItem;
004347 assert(pList || pParse->db->mallocFailed );
004348 if( pList ){
004349 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
004350 if( pItem->iCursor>=0 ) break;
004351 pItem->iCursor = pParse->nTab++;
004352 if( pItem->pSelect ){
004353 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
004354 }
004355 }
004356 }
004357 }
004358
004359 /*
004360 ** Delete an entire SrcList including all its substructure.
004361 */
004362 void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
004363 int i;
004364 struct SrcList_item *pItem;
004365 if( pList==0 ) return;
004366 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
004367 sqlite3DbFree(db, pItem->zDatabase);
004368 sqlite3DbFree(db, pItem->zName);
004369 sqlite3DbFree(db, pItem->zAlias);
004370 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
004371 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
004372 sqlite3DeleteTable(db, pItem->pTab);
004373 sqlite3SelectDelete(db, pItem->pSelect);
004374 sqlite3ExprDelete(db, pItem->pOn);
004375 sqlite3IdListDelete(db, pItem->pUsing);
004376 }
004377 sqlite3DbFreeNN(db, pList);
004378 }
004379
004380 /*
004381 ** This routine is called by the parser to add a new term to the
004382 ** end of a growing FROM clause. The "p" parameter is the part of
004383 ** the FROM clause that has already been constructed. "p" is NULL
004384 ** if this is the first term of the FROM clause. pTable and pDatabase
004385 ** are the name of the table and database named in the FROM clause term.
004386 ** pDatabase is NULL if the database name qualifier is missing - the
004387 ** usual case. If the term has an alias, then pAlias points to the
004388 ** alias token. If the term is a subquery, then pSubquery is the
004389 ** SELECT statement that the subquery encodes. The pTable and
004390 ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
004391 ** parameters are the content of the ON and USING clauses.
004392 **
004393 ** Return a new SrcList which encodes is the FROM with the new
004394 ** term added.
004395 */
004396 SrcList *sqlite3SrcListAppendFromTerm(
004397 Parse *pParse, /* Parsing context */
004398 SrcList *p, /* The left part of the FROM clause already seen */
004399 Token *pTable, /* Name of the table to add to the FROM clause */
004400 Token *pDatabase, /* Name of the database containing pTable */
004401 Token *pAlias, /* The right-hand side of the AS subexpression */
004402 Select *pSubquery, /* A subquery used in place of a table name */
004403 Expr *pOn, /* The ON clause of a join */
004404 IdList *pUsing /* The USING clause of a join */
004405 ){
004406 struct SrcList_item *pItem;
004407 sqlite3 *db = pParse->db;
004408 if( !p && (pOn || pUsing) ){
004409 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
004410 (pOn ? "ON" : "USING")
004411 );
004412 goto append_from_error;
004413 }
004414 p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
004415 if( p==0 ){
004416 goto append_from_error;
004417 }
004418 assert( p->nSrc>0 );
004419 pItem = &p->a[p->nSrc-1];
004420 assert( (pTable==0)==(pDatabase==0) );
004421 assert( pItem->zName==0 || pDatabase!=0 );
004422 if( IN_RENAME_OBJECT && pItem->zName ){
004423 Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
004424 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
004425 }
004426 assert( pAlias!=0 );
004427 if( pAlias->n ){
004428 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
004429 }
004430 pItem->pSelect = pSubquery;
004431 pItem->pOn = pOn;
004432 pItem->pUsing = pUsing;
004433 return p;
004434
004435 append_from_error:
004436 assert( p==0 );
004437 sqlite3ExprDelete(db, pOn);
004438 sqlite3IdListDelete(db, pUsing);
004439 sqlite3SelectDelete(db, pSubquery);
004440 return 0;
004441 }
004442
004443 /*
004444 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
004445 ** element of the source-list passed as the second argument.
004446 */
004447 void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
004448 assert( pIndexedBy!=0 );
004449 if( p && pIndexedBy->n>0 ){
004450 struct SrcList_item *pItem;
004451 assert( p->nSrc>0 );
004452 pItem = &p->a[p->nSrc-1];
004453 assert( pItem->fg.notIndexed==0 );
004454 assert( pItem->fg.isIndexedBy==0 );
004455 assert( pItem->fg.isTabFunc==0 );
004456 if( pIndexedBy->n==1 && !pIndexedBy->z ){
004457 /* A "NOT INDEXED" clause was supplied. See parse.y
004458 ** construct "indexed_opt" for details. */
004459 pItem->fg.notIndexed = 1;
004460 }else{
004461 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
004462 pItem->fg.isIndexedBy = 1;
004463 }
004464 }
004465 }
004466
004467 /*
004468 ** Add the list of function arguments to the SrcList entry for a
004469 ** table-valued-function.
004470 */
004471 void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
004472 if( p ){
004473 struct SrcList_item *pItem = &p->a[p->nSrc-1];
004474 assert( pItem->fg.notIndexed==0 );
004475 assert( pItem->fg.isIndexedBy==0 );
004476 assert( pItem->fg.isTabFunc==0 );
004477 pItem->u1.pFuncArg = pList;
004478 pItem->fg.isTabFunc = 1;
004479 }else{
004480 sqlite3ExprListDelete(pParse->db, pList);
004481 }
004482 }
004483
004484 /*
004485 ** When building up a FROM clause in the parser, the join operator
004486 ** is initially attached to the left operand. But the code generator
004487 ** expects the join operator to be on the right operand. This routine
004488 ** Shifts all join operators from left to right for an entire FROM
004489 ** clause.
004490 **
004491 ** Example: Suppose the join is like this:
004492 **
004493 ** A natural cross join B
004494 **
004495 ** The operator is "natural cross join". The A and B operands are stored
004496 ** in p->a[0] and p->a[1], respectively. The parser initially stores the
004497 ** operator with A. This routine shifts that operator over to B.
004498 */
004499 void sqlite3SrcListShiftJoinType(SrcList *p){
004500 if( p ){
004501 int i;
004502 for(i=p->nSrc-1; i>0; i--){
004503 p->a[i].fg.jointype = p->a[i-1].fg.jointype;
004504 }
004505 p->a[0].fg.jointype = 0;
004506 }
004507 }
004508
004509 /*
004510 ** Generate VDBE code for a BEGIN statement.
004511 */
004512 void sqlite3BeginTransaction(Parse *pParse, int type){
004513 sqlite3 *db;
004514 Vdbe *v;
004515 int i;
004516
004517 assert( pParse!=0 );
004518 db = pParse->db;
004519 assert( db!=0 );
004520 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
004521 return;
004522 }
004523 v = sqlite3GetVdbe(pParse);
004524 if( !v ) return;
004525 if( type!=TK_DEFERRED ){
004526 for(i=0; i<db->nDb; i++){
004527 sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
004528 sqlite3VdbeUsesBtree(v, i);
004529 }
004530 }
004531 sqlite3VdbeAddOp0(v, OP_AutoCommit);
004532 }
004533
004534 /*
004535 ** Generate VDBE code for a COMMIT or ROLLBACK statement.
004536 ** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise
004537 ** code is generated for a COMMIT.
004538 */
004539 void sqlite3EndTransaction(Parse *pParse, int eType){
004540 Vdbe *v;
004541 int isRollback;
004542
004543 assert( pParse!=0 );
004544 assert( pParse->db!=0 );
004545 assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
004546 isRollback = eType==TK_ROLLBACK;
004547 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
004548 isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
004549 return;
004550 }
004551 v = sqlite3GetVdbe(pParse);
004552 if( v ){
004553 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
004554 }
004555 }
004556
004557 /*
004558 ** This function is called by the parser when it parses a command to create,
004559 ** release or rollback an SQL savepoint.
004560 */
004561 void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
004562 char *zName = sqlite3NameFromToken(pParse->db, pName);
004563 if( zName ){
004564 Vdbe *v = sqlite3GetVdbe(pParse);
004565 #ifndef SQLITE_OMIT_AUTHORIZATION
004566 static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
004567 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
004568 #endif
004569 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
004570 sqlite3DbFree(pParse->db, zName);
004571 return;
004572 }
004573 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
004574 }
004575 }
004576
004577 /*
004578 ** Make sure the TEMP database is open and available for use. Return
004579 ** the number of errors. Leave any error messages in the pParse structure.
004580 */
004581 int sqlite3OpenTempDatabase(Parse *pParse){
004582 sqlite3 *db = pParse->db;
004583 if( db->aDb[1].pBt==0 && !pParse->explain ){
004584 int rc;
004585 Btree *pBt;
004586 static const int flags =
004587 SQLITE_OPEN_READWRITE |
004588 SQLITE_OPEN_CREATE |
004589 SQLITE_OPEN_EXCLUSIVE |
004590 SQLITE_OPEN_DELETEONCLOSE |
004591 SQLITE_OPEN_TEMP_DB;
004592
004593 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
004594 if( rc!=SQLITE_OK ){
004595 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
004596 "file for storing temporary tables");
004597 pParse->rc = rc;
004598 return 1;
004599 }
004600 db->aDb[1].pBt = pBt;
004601 assert( db->aDb[1].pSchema );
004602 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
004603 sqlite3OomFault(db);
004604 return 1;
004605 }
004606 }
004607 return 0;
004608 }
004609
004610 /*
004611 ** Record the fact that the schema cookie will need to be verified
004612 ** for database iDb. The code to actually verify the schema cookie
004613 ** will occur at the end of the top-level VDBE and will be generated
004614 ** later, by sqlite3FinishCoding().
004615 */
004616 void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
004617 Parse *pToplevel = sqlite3ParseToplevel(pParse);
004618
004619 assert( iDb>=0 && iDb<pParse->db->nDb );
004620 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
004621 assert( iDb<SQLITE_MAX_ATTACHED+2 );
004622 assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
004623 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
004624 DbMaskSet(pToplevel->cookieMask, iDb);
004625 if( !OMIT_TEMPDB && iDb==1 ){
004626 sqlite3OpenTempDatabase(pToplevel);
004627 }
004628 }
004629 }
004630
004631 /*
004632 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
004633 ** attached database. Otherwise, invoke it for the database named zDb only.
004634 */
004635 void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
004636 sqlite3 *db = pParse->db;
004637 int i;
004638 for(i=0; i<db->nDb; i++){
004639 Db *pDb = &db->aDb[i];
004640 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
004641 sqlite3CodeVerifySchema(pParse, i);
004642 }
004643 }
004644 }
004645
004646 /*
004647 ** Generate VDBE code that prepares for doing an operation that
004648 ** might change the database.
004649 **
004650 ** This routine starts a new transaction if we are not already within
004651 ** a transaction. If we are already within a transaction, then a checkpoint
004652 ** is set if the setStatement parameter is true. A checkpoint should
004653 ** be set for operations that might fail (due to a constraint) part of
004654 ** the way through and which will need to undo some writes without having to
004655 ** rollback the whole transaction. For operations where all constraints
004656 ** can be checked before any changes are made to the database, it is never
004657 ** necessary to undo a write and the checkpoint should not be set.
004658 */
004659 void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
004660 Parse *pToplevel = sqlite3ParseToplevel(pParse);
004661 sqlite3CodeVerifySchema(pParse, iDb);
004662 DbMaskSet(pToplevel->writeMask, iDb);
004663 pToplevel->isMultiWrite |= setStatement;
004664 }
004665
004666 /*
004667 ** Indicate that the statement currently under construction might write
004668 ** more than one entry (example: deleting one row then inserting another,
004669 ** inserting multiple rows in a table, or inserting a row and index entries.)
004670 ** If an abort occurs after some of these writes have completed, then it will
004671 ** be necessary to undo the completed writes.
004672 */
004673 void sqlite3MultiWrite(Parse *pParse){
004674 Parse *pToplevel = sqlite3ParseToplevel(pParse);
004675 pToplevel->isMultiWrite = 1;
004676 }
004677
004678 /*
004679 ** The code generator calls this routine if is discovers that it is
004680 ** possible to abort a statement prior to completion. In order to
004681 ** perform this abort without corrupting the database, we need to make
004682 ** sure that the statement is protected by a statement transaction.
004683 **
004684 ** Technically, we only need to set the mayAbort flag if the
004685 ** isMultiWrite flag was previously set. There is a time dependency
004686 ** such that the abort must occur after the multiwrite. This makes
004687 ** some statements involving the REPLACE conflict resolution algorithm
004688 ** go a little faster. But taking advantage of this time dependency
004689 ** makes it more difficult to prove that the code is correct (in
004690 ** particular, it prevents us from writing an effective
004691 ** implementation of sqlite3AssertMayAbort()) and so we have chosen
004692 ** to take the safe route and skip the optimization.
004693 */
004694 void sqlite3MayAbort(Parse *pParse){
004695 Parse *pToplevel = sqlite3ParseToplevel(pParse);
004696 pToplevel->mayAbort = 1;
004697 }
004698
004699 /*
004700 ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
004701 ** error. The onError parameter determines which (if any) of the statement
004702 ** and/or current transaction is rolled back.
004703 */
004704 void sqlite3HaltConstraint(
004705 Parse *pParse, /* Parsing context */
004706 int errCode, /* extended error code */
004707 int onError, /* Constraint type */
004708 char *p4, /* Error message */
004709 i8 p4type, /* P4_STATIC or P4_TRANSIENT */
004710 u8 p5Errmsg /* P5_ErrMsg type */
004711 ){
004712 Vdbe *v = sqlite3GetVdbe(pParse);
004713 assert( (errCode&0xff)==SQLITE_CONSTRAINT );
004714 if( onError==OE_Abort ){
004715 sqlite3MayAbort(pParse);
004716 }
004717 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
004718 sqlite3VdbeChangeP5(v, p5Errmsg);
004719 }
004720
004721 /*
004722 ** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
004723 */
004724 void sqlite3UniqueConstraint(
004725 Parse *pParse, /* Parsing context */
004726 int onError, /* Constraint type */
004727 Index *pIdx /* The index that triggers the constraint */
004728 ){
004729 char *zErr;
004730 int j;
004731 StrAccum errMsg;
004732 Table *pTab = pIdx->pTable;
004733
004734 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
004735 pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
004736 if( pIdx->aColExpr ){
004737 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
004738 }else{
004739 for(j=0; j<pIdx->nKeyCol; j++){
004740 char *zCol;
004741 assert( pIdx->aiColumn[j]>=0 );
004742 zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
004743 if( j ) sqlite3_str_append(&errMsg, ", ", 2);
004744 sqlite3_str_appendall(&errMsg, pTab->zName);
004745 sqlite3_str_append(&errMsg, ".", 1);
004746 sqlite3_str_appendall(&errMsg, zCol);
004747 }
004748 }
004749 zErr = sqlite3StrAccumFinish(&errMsg);
004750 sqlite3HaltConstraint(pParse,
004751 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
004752 : SQLITE_CONSTRAINT_UNIQUE,
004753 onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
004754 }
004755
004756
004757 /*
004758 ** Code an OP_Halt due to non-unique rowid.
004759 */
004760 void sqlite3RowidConstraint(
004761 Parse *pParse, /* Parsing context */
004762 int onError, /* Conflict resolution algorithm */
004763 Table *pTab /* The table with the non-unique rowid */
004764 ){
004765 char *zMsg;
004766 int rc;
004767 if( pTab->iPKey>=0 ){
004768 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
004769 pTab->aCol[pTab->iPKey].zName);
004770 rc = SQLITE_CONSTRAINT_PRIMARYKEY;
004771 }else{
004772 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
004773 rc = SQLITE_CONSTRAINT_ROWID;
004774 }
004775 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
004776 P5_ConstraintUnique);
004777 }
004778
004779 /*
004780 ** Check to see if pIndex uses the collating sequence pColl. Return
004781 ** true if it does and false if it does not.
004782 */
004783 #ifndef SQLITE_OMIT_REINDEX
004784 static int collationMatch(const char *zColl, Index *pIndex){
004785 int i;
004786 assert( zColl!=0 );
004787 for(i=0; i<pIndex->nColumn; i++){
004788 const char *z = pIndex->azColl[i];
004789 assert( z!=0 || pIndex->aiColumn[i]<0 );
004790 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
004791 return 1;
004792 }
004793 }
004794 return 0;
004795 }
004796 #endif
004797
004798 /*
004799 ** Recompute all indices of pTab that use the collating sequence pColl.
004800 ** If pColl==0 then recompute all indices of pTab.
004801 */
004802 #ifndef SQLITE_OMIT_REINDEX
004803 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
004804 if( !IsVirtual(pTab) ){
004805 Index *pIndex; /* An index associated with pTab */
004806
004807 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
004808 if( zColl==0 || collationMatch(zColl, pIndex) ){
004809 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
004810 sqlite3BeginWriteOperation(pParse, 0, iDb);
004811 sqlite3RefillIndex(pParse, pIndex, -1);
004812 }
004813 }
004814 }
004815 }
004816 #endif
004817
004818 /*
004819 ** Recompute all indices of all tables in all databases where the
004820 ** indices use the collating sequence pColl. If pColl==0 then recompute
004821 ** all indices everywhere.
004822 */
004823 #ifndef SQLITE_OMIT_REINDEX
004824 static void reindexDatabases(Parse *pParse, char const *zColl){
004825 Db *pDb; /* A single database */
004826 int iDb; /* The database index number */
004827 sqlite3 *db = pParse->db; /* The database connection */
004828 HashElem *k; /* For looping over tables in pDb */
004829 Table *pTab; /* A table in the database */
004830
004831 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
004832 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
004833 assert( pDb!=0 );
004834 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
004835 pTab = (Table*)sqliteHashData(k);
004836 reindexTable(pParse, pTab, zColl);
004837 }
004838 }
004839 }
004840 #endif
004841
004842 /*
004843 ** Generate code for the REINDEX command.
004844 **
004845 ** REINDEX -- 1
004846 ** REINDEX <collation> -- 2
004847 ** REINDEX ?<database>.?<tablename> -- 3
004848 ** REINDEX ?<database>.?<indexname> -- 4
004849 **
004850 ** Form 1 causes all indices in all attached databases to be rebuilt.
004851 ** Form 2 rebuilds all indices in all databases that use the named
004852 ** collating function. Forms 3 and 4 rebuild the named index or all
004853 ** indices associated with the named table.
004854 */
004855 #ifndef SQLITE_OMIT_REINDEX
004856 void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
004857 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
004858 char *z; /* Name of a table or index */
004859 const char *zDb; /* Name of the database */
004860 Table *pTab; /* A table in the database */
004861 Index *pIndex; /* An index associated with pTab */
004862 int iDb; /* The database index number */
004863 sqlite3 *db = pParse->db; /* The database connection */
004864 Token *pObjName; /* Name of the table or index to be reindexed */
004865
004866 /* Read the database schema. If an error occurs, leave an error message
004867 ** and code in pParse and return NULL. */
004868 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
004869 return;
004870 }
004871
004872 if( pName1==0 ){
004873 reindexDatabases(pParse, 0);
004874 return;
004875 }else if( NEVER(pName2==0) || pName2->z==0 ){
004876 char *zColl;
004877 assert( pName1->z );
004878 zColl = sqlite3NameFromToken(pParse->db, pName1);
004879 if( !zColl ) return;
004880 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
004881 if( pColl ){
004882 reindexDatabases(pParse, zColl);
004883 sqlite3DbFree(db, zColl);
004884 return;
004885 }
004886 sqlite3DbFree(db, zColl);
004887 }
004888 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
004889 if( iDb<0 ) return;
004890 z = sqlite3NameFromToken(db, pObjName);
004891 if( z==0 ) return;
004892 zDb = db->aDb[iDb].zDbSName;
004893 pTab = sqlite3FindTable(db, z, zDb);
004894 if( pTab ){
004895 reindexTable(pParse, pTab, 0);
004896 sqlite3DbFree(db, z);
004897 return;
004898 }
004899 pIndex = sqlite3FindIndex(db, z, zDb);
004900 sqlite3DbFree(db, z);
004901 if( pIndex ){
004902 sqlite3BeginWriteOperation(pParse, 0, iDb);
004903 sqlite3RefillIndex(pParse, pIndex, -1);
004904 return;
004905 }
004906 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
004907 }
004908 #endif
004909
004910 /*
004911 ** Return a KeyInfo structure that is appropriate for the given Index.
004912 **
004913 ** The caller should invoke sqlite3KeyInfoUnref() on the returned object
004914 ** when it has finished using it.
004915 */
004916 KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
004917 int i;
004918 int nCol = pIdx->nColumn;
004919 int nKey = pIdx->nKeyCol;
004920 KeyInfo *pKey;
004921 if( pParse->nErr ) return 0;
004922 if( pIdx->uniqNotNull ){
004923 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
004924 }else{
004925 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
004926 }
004927 if( pKey ){
004928 assert( sqlite3KeyInfoIsWriteable(pKey) );
004929 for(i=0; i<nCol; i++){
004930 const char *zColl = pIdx->azColl[i];
004931 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
004932 sqlite3LocateCollSeq(pParse, zColl);
004933 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
004934 assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
004935 }
004936 if( pParse->nErr ){
004937 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
004938 if( pIdx->bNoQuery==0 ){
004939 /* Deactivate the index because it contains an unknown collating
004940 ** sequence. The only way to reactive the index is to reload the
004941 ** schema. Adding the missing collating sequence later does not
004942 ** reactive the index. The application had the chance to register
004943 ** the missing index using the collation-needed callback. For
004944 ** simplicity, SQLite will not give the application a second chance.
004945 */
004946 pIdx->bNoQuery = 1;
004947 pParse->rc = SQLITE_ERROR_RETRY;
004948 }
004949 sqlite3KeyInfoUnref(pKey);
004950 pKey = 0;
004951 }
004952 }
004953 return pKey;
004954 }
004955
004956 #ifndef SQLITE_OMIT_CTE
004957 /*
004958 ** This routine is invoked once per CTE by the parser while parsing a
004959 ** WITH clause.
004960 */
004961 With *sqlite3WithAdd(
004962 Parse *pParse, /* Parsing context */
004963 With *pWith, /* Existing WITH clause, or NULL */
004964 Token *pName, /* Name of the common-table */
004965 ExprList *pArglist, /* Optional column name list for the table */
004966 Select *pQuery /* Query used to initialize the table */
004967 ){
004968 sqlite3 *db = pParse->db;
004969 With *pNew;
004970 char *zName;
004971
004972 /* Check that the CTE name is unique within this WITH clause. If
004973 ** not, store an error in the Parse structure. */
004974 zName = sqlite3NameFromToken(pParse->db, pName);
004975 if( zName && pWith ){
004976 int i;
004977 for(i=0; i<pWith->nCte; i++){
004978 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
004979 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
004980 }
004981 }
004982 }
004983
004984 if( pWith ){
004985 sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
004986 pNew = sqlite3DbRealloc(db, pWith, nByte);
004987 }else{
004988 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
004989 }
004990 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
004991
004992 if( db->mallocFailed ){
004993 sqlite3ExprListDelete(db, pArglist);
004994 sqlite3SelectDelete(db, pQuery);
004995 sqlite3DbFree(db, zName);
004996 pNew = pWith;
004997 }else{
004998 pNew->a[pNew->nCte].pSelect = pQuery;
004999 pNew->a[pNew->nCte].pCols = pArglist;
005000 pNew->a[pNew->nCte].zName = zName;
005001 pNew->a[pNew->nCte].zCteErr = 0;
005002 pNew->nCte++;
005003 }
005004
005005 return pNew;
005006 }
005007
005008 /*
005009 ** Free the contents of the With object passed as the second argument.
005010 */
005011 void sqlite3WithDelete(sqlite3 *db, With *pWith){
005012 if( pWith ){
005013 int i;
005014 for(i=0; i<pWith->nCte; i++){
005015 struct Cte *pCte = &pWith->a[i];
005016 sqlite3ExprListDelete(db, pCte->pCols);
005017 sqlite3SelectDelete(db, pCte->pSelect);
005018 sqlite3DbFree(db, pCte->zName);
005019 }
005020 sqlite3DbFree(db, pWith);
005021 }
005022 }
005023 #endif /* !defined(SQLITE_OMIT_CTE) */