/*

 ** 2001 September 15

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** This file contains C code routines that are called by the SQLite parser

 ** when syntax rules are reduced.  The routines in this file handle the

 ** following kinds of SQL syntax:

 **

 **     CREATE TABLE

 **     DROP TABLE

 **     CREATE INDEX

 **     DROP INDEX

 **     creating ID lists

 **     BEGIN TRANSACTION

 **     COMMIT

 **     ROLLBACK

 **

 ** $Id$

 */

 #include "sqliteInt.h"

 #include <ctype.h>

 /*

 ** This routine is called when a new SQL statement is beginning to

 ** be parsed.  Initialize the pParse structure as needed.

 */

 void sqlite3BeginParse(Parse *pParse, int explainFlag){

   pParse->explain = explainFlag;

   pParse->nVar = 0;

 }

 #ifndef SQLITE_OMIT_SHARED_CACHE

 /*

 ** The TableLock structure is only used by the sqlite3TableLock() and

 ** codeTableLocks() functions.

 */

 struct TableLock {

   int iDb;             /* The database containing the table to be locked */

   int iTab;            /* The root page of the table to be locked */

   u8 isWriteLock;      /* True for write lock.  False for a read lock */

   const char *zName;   /* Name of the table */

 };

 /*

 ** Record the fact that we want to lock a table at run-time.  

 **

 ** The table to be locked has root page iTab and is found in database iDb.

 ** A read or a write lock can be taken depending on isWritelock.

 **

 ** This routine just records the fact that the lock is desired.  The

 ** code to make the lock occur is generated by a later call to

 ** codeTableLocks() which occurs during sqlite3FinishCoding().

 */

 void sqlite3TableLock(

   Parse *pParse,     /* Parsing context */

   int iDb,           /* Index of the database containing the table to lock */

   int iTab,          /* Root page number of the table to be locked */

   u8 isWriteLock,    /* True for a write lock */

   const char *zName  /* Name of the table to be locked */

 ){

   int i;

   int nBytes;

   TableLock *p;

   if( iDb<0 ){

     return;

   }

   for(i=0; i<pParse->nTableLock; i++){

     p = &pParse->aTableLock[i];

     if( p->iDb==iDb && p->iTab==iTab ){

       p->isWriteLock = (p->isWriteLock || isWriteLock);

       return;

     }

   }

   nBytes = sizeof(TableLock) * (pParse->nTableLock+1);

   pParse->aTableLock = 

       sqlite3DbReallocOrFree(pParse->db, pParse->aTableLock, nBytes);

   if( pParse->aTableLock ){

     p = &pParse->aTableLock[pParse->nTableLock++];

     p->iDb = iDb;

     p->iTab = iTab;

     p->isWriteLock = isWriteLock;

     p->zName = zName;

   }else{

     pParse->nTableLock = 0;

     pParse->db->mallocFailed = 1;

   }

 }

 /*

 ** Code an OP_TableLock instruction for each table locked by the

 ** statement (configured by calls to sqlite3TableLock()).

 */

 static void codeTableLocks(Parse *pParse){

   int i;

   Vdbe *pVdbe; 

   if( 0==(pVdbe = sqlite3GetVdbe(pParse)) ){

     return;

   }

   for(i=0; i<pParse->nTableLock; i++){

     TableLock *p = &pParse->aTableLock[i];

     int p1 = p->iDb;

     if( p->isWriteLock ){

       p1 = -1*(p1+1);

     }

     sqlite3VdbeOp3(pVdbe, OP_TableLock, p1, p->iTab, p->zName, P3_STATIC);

   }

 }

 #else

   #define codeTableLocks(x)

 #endif

 /*

 ** This routine is called after a single SQL statement has been

 ** parsed and a VDBE program to execute that statement has been

 ** prepared.  This routine puts the finishing touches on the

 ** VDBE program and resets the pParse structure for the next

 ** parse.

 **

 ** Note that if an error occurred, it might be the case that

 ** no VDBE code was generated.

 */

 void sqlite3FinishCoding(Parse *pParse){

   sqlite3 *db;

   Vdbe *v;

   db = pParse->db;

   if( db->mallocFailed ) return;

   if( pParse->nested ) return;

   if( !pParse->pVdbe ){

     if( pParse->rc==SQLITE_OK && pParse->nErr ){

       pParse->rc = SQLITE_ERROR;

       return;

     }

   }

   /* Begin by generating some termination code at the end of the

   ** vdbe program

   */

   v = sqlite3GetVdbe(pParse);

   if( v ){

     sqlite3VdbeAddOp(v, OP_Halt, 0, 0);

     /* The cookie mask contains one bit for each database file open.

     ** (Bit 0 is for main, bit 1 is for temp, and so forth.)  Bits are

     ** set for each database that is used.  Generate code to start a

     ** transaction on each used database and to verify the schema cookie

     ** on each used database.

     */

     if( pParse->cookieGoto>0 ){

       u32 mask;

       int iDb;

       sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);

       for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){

         if( (mask & pParse->cookieMask)==0 ) continue;

         sqlite3VdbeUsesBtree(v, iDb);

         sqlite3VdbeAddOp(v, OP_Transaction, iDb, (mask & pParse->writeMask)!=0);

         sqlite3VdbeAddOp(v, OP_VerifyCookie, iDb, pParse->cookieValue[iDb]);

       }

 #ifndef SQLITE_OMIT_VIRTUALTABLE

       if( pParse->pVirtualLock ){

         char *vtab = (char *)pParse->pVirtualLock->pVtab;

         sqlite3VdbeOp3(v, OP_VBegin, 0, 0, vtab, P3_VTAB);

       }

 #endif

       /* Once all the cookies have been verified and transactions opened, 

       ** obtain the required table-locks. This is a no-op unless the 

       ** shared-cache feature is enabled.

       */

       codeTableLocks(pParse);

       sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->cookieGoto);

     }

 #ifndef SQLITE_OMIT_TRACE

     /* Add a No-op that contains the complete text of the compiled SQL

     ** statement as its P3 argument.  This does not change the functionality

     ** of the program. 

     **

     ** This is used to implement sqlite3_trace().

     */

     sqlite3VdbeOp3(v, OP_Noop, 0, 0, pParse->zSql, pParse->zTail-pParse->zSql);

 #endif /* SQLITE_OMIT_TRACE */

   }

   /* Get the VDBE program ready for execution

   */

   if( v && pParse->nErr==0 && !db->mallocFailed ){

 #ifdef SQLITE_DEBUG

     FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;

     sqlite3VdbeTrace(v, trace);

 #endif

     sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem+3,

                          pParse->nTab+3, pParse->explain);

     pParse->rc = SQLITE_DONE;

     pParse->colNamesSet = 0;

   }else if( pParse->rc==SQLITE_OK ){

     pParse->rc = SQLITE_ERROR;

   }

   pParse->nTab = 0;

   pParse->nMem = 0;

   pParse->nSet = 0;

   pParse->nVar = 0;

   pParse->cookieMask = 0;

   pParse->cookieGoto = 0;

 }

 /*

 ** Run the parser and code generator recursively in order to generate

 ** code for the SQL statement given onto the end of the pParse context

 ** currently under construction.  When the parser is run recursively

 ** this way, the final OP_Halt is not appended and other initialization

 ** and finalization steps are omitted because those are handling by the

 ** outermost parser.

 **

 ** Not everything is nestable.  This facility is designed to permit

 ** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER.  Use

 ** care if you decide to try to use this routine for some other purposes.

 */

 void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){

   va_list ap;

   char *zSql;

 # define SAVE_SZ  (sizeof(Parse) - offsetof(Parse,nVar))

   char saveBuf[SAVE_SZ];

   if( pParse->nErr ) return;

   assert( pParse->nested<10 );  /* Nesting should only be of limited depth */

   va_start(ap, zFormat);

   zSql = sqlite3VMPrintf(pParse->db, zFormat, ap);

   va_end(ap);

   if( zSql==0 ){

     pParse->db->mallocFailed = 1;

     return;   /* A malloc must have failed */

   }

   pParse->nested++;

   memcpy(saveBuf, &pParse->nVar, SAVE_SZ);

   memset(&pParse->nVar, 0, SAVE_SZ);

   sqlite3RunParser(pParse, zSql, 0);

   sqlite3_free(zSql);

   memcpy(&pParse->nVar, saveBuf, SAVE_SZ);

   pParse->nested--;

 }

 /*

 ** Locate the in-memory structure that describes a particular database

 ** table given the name of that table and (optionally) the name of the

 ** database containing the table.  Return NULL if not found.

 **

 ** If zDatabase is 0, all databases are searched for the table and the

 ** first matching table is returned.  (No checking for duplicate table

 ** names is done.)  The search order is TEMP first, then MAIN, then any

 ** auxiliary databases added using the ATTACH command.

 **

 ** See also sqlite3LocateTable().

 */

 Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){

   Table *p = 0;

   int i;

   assert( zName!=0 );

   for(i=OMIT_TEMPDB; i<db->nDb; i++){

     int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */

     if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;

     p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, strlen(zName)+1);

     if( p ) break;

   }

   return p;

 }

 /*

 ** Locate the in-memory structure that describes a particular database

 ** table given the name of that table and (optionally) the name of the

 ** database containing the table.  Return NULL if not found.  Also leave an

 ** error message in pParse->zErrMsg.

 **

 ** The difference between this routine and sqlite3FindTable() is that this

 ** routine leaves an error message in pParse->zErrMsg where

 ** sqlite3FindTable() does not.

 */

 Table *sqlite3LocateTable(Parse *pParse, const char *zName, const char *zDbase){

   Table *p;

   /* Read the database schema. If an error occurs, leave an error message

   ** and code in pParse and return NULL. */

   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){

     return 0;

   }

   p = sqlite3FindTable(pParse->db, zName, zDbase);

   if( p==0 ){

     if( zDbase ){

       sqlite3ErrorMsg(pParse, "no such table: %s.%s", zDbase, zName);

     }else{

       sqlite3ErrorMsg(pParse, "no such table: %s", zName);

     }

     pParse->checkSchema = 1;

   }

   return p;

 }

 /*

 ** Locate the in-memory structure that describes 

 ** a particular index given the name of that index

 ** and the name of the database that contains the index.

 ** Return NULL if not found.

 **

 ** If zDatabase is 0, all databases are searched for the

 ** table and the first matching index is returned.  (No checking

 ** for duplicate index names is done.)  The search order is

 ** TEMP first, then MAIN, then any auxiliary databases added

 ** using the ATTACH command.

 */

 Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){

   Index *p = 0;

   int i;

   for(i=OMIT_TEMPDB; i<db->nDb; i++){

     int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */

     Schema *pSchema = db->aDb[j].pSchema;

     if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;

     assert( pSchema || (j==1 && !db->aDb[1].pBt) );

     if( pSchema ){

       p = sqlite3HashFind(&pSchema->idxHash, zName, strlen(zName)+1);

     }

     if( p ) break;

   }

   return p;

 }

 /*

 ** Reclaim the memory used by an index

 */

 static void freeIndex(Index *p){

   sqlite3_free(p->zColAff);

   sqlite3_free(p);

 }

 /*

 ** Remove the given index from the index hash table, and free

 ** its memory structures.

 **

 ** The index is removed from the database hash tables but

 ** it is not unlinked from the Table that it indexes.

 ** Unlinking from the Table must be done by the calling function.

 */

 static void sqliteDeleteIndex(Index *p){

   Index *pOld;

   const char *zName = p->zName;

   pOld = sqlite3HashInsert(&p->pSchema->idxHash, zName, strlen( zName)+1, 0);

   assert( pOld==0 || pOld==p );

   freeIndex(p);

 }

 /*

 ** For the index called zIdxName which is found in the database iDb,

 ** unlike that index from its Table then remove the index from

 ** the index hash table and free all memory structures associated

 ** with the index.

 */

 void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){

   Index *pIndex;

   int len;

   Hash *pHash = &db->aDb[iDb].pSchema->idxHash;

   len = strlen(zIdxName);

   pIndex = sqlite3HashInsert(pHash, zIdxName, len+1, 0);

   if( pIndex ){

     if( pIndex->pTable->pIndex==pIndex ){

       pIndex->pTable->pIndex = pIndex->pNext;

     }else{

       Index *p;

       for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){}

       if( p && p->pNext==pIndex ){

         p->pNext = pIndex->pNext;

       }

     }

     freeIndex(pIndex);

   }

   db->flags |= SQLITE_InternChanges;

 }

 /*

 ** Erase all schema information from the in-memory hash tables of

 ** a single database.  This routine is called to reclaim memory

 ** before the database closes.  It is also called during a rollback

 ** if there were schema changes during the transaction or if a

 ** schema-cookie mismatch occurs.

 **

 ** If iDb<=0 then reset the internal schema tables for all database

 ** files.  If iDb>=2 then reset the internal schema for only the

 ** single file indicated.

 */

 void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){

   int i, j;

   assert( iDb>=0 && iDb<db->nDb );

   for(i=iDb; i<db->nDb; i++){

     Db *pDb = &db->aDb[i];

     if( pDb->pSchema ){

       sqlite3SchemaFree(pDb->pSchema);

     }

     if( iDb>0 ) return;

   }

   assert( iDb==0 );

   db->flags &= ~SQLITE_InternChanges;

   /* If one or more of the auxiliary database files has been closed,

   ** then remove them from the auxiliary database list.  We take the

   ** opportunity to do this here since we have just deleted all of the

   ** schema hash tables and therefore do not have to make any changes

   ** to any of those tables.

   */

   for(i=0; i<db->nDb; i++){

     struct Db *pDb = &db->aDb[i];

     if( pDb->pBt==0 ){

       if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux);

       pDb->pAux = 0;

     }

   }

   for(i=j=2; i<db->nDb; i++){

     struct Db *pDb = &db->aDb[i];

     if( pDb->pBt==0 ){

       sqlite3_free(pDb->zName);

       pDb->zName = 0;

       continue;

     }

     if( j<i ){

       db->aDb[j] = db->aDb[i];

     }

     j++;

   }

   memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));

   db->nDb = j;

   if( db->nDb<=2 && db->aDb!=db->aDbStatic ){

     memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));

     sqlite3_free(db->aDb);

     db->aDb = db->aDbStatic;

   }

 }

 /*

 ** This routine is called when a commit occurs.

 */

 void sqlite3CommitInternalChanges(sqlite3 *db){

   db->flags &= ~SQLITE_InternChanges;

 }

 /*

 ** Clear the column names from a table or view.

 */

 static void sqliteResetColumnNames(Table *pTable){

   int i;

   Column *pCol;

   assert( pTable!=0 );

   if( (pCol = pTable->aCol)!=0 ){

     for(i=0; i<pTable->nCol; i++, pCol++){

       sqlite3_free(pCol->zName);

       sqlite3ExprDelete(pCol->pDflt);

       sqlite3_free(pCol->zType);

       sqlite3_free(pCol->zColl);

     }

     sqlite3_free(pTable->aCol);

   }

   pTable->aCol = 0;

   pTable->nCol = 0;

 }

 /*

 ** Remove the memory data structures associated with the given

 ** Table.  No changes are made to disk by this routine.

 **

 ** This routine just deletes the data structure.  It does not unlink

 ** the table data structure from the hash table.  Nor does it remove

 ** foreign keys from the sqlite.aFKey hash table.  But it does destroy

 ** memory structures of the indices and foreign keys associated with 

 ** the table.

 */

 void sqlite3DeleteTable(Table *pTable){

   Index *pIndex, *pNext;

   FKey *pFKey, *pNextFKey;

   if( pTable==0 ) return;

   /* Do not delete the table until the reference count reaches zero. */

   pTable->nRef--;

   if( pTable->nRef>0 ){

     return;

   }

   assert( pTable->nRef==0 );

   /* Delete all indices associated with this table

   */

   for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){

     pNext = pIndex->pNext;

     assert( pIndex->pSchema==pTable->pSchema );

     sqliteDeleteIndex(pIndex);

   }

 #ifndef SQLITE_OMIT_FOREIGN_KEY

   /* Delete all foreign keys associated with this table.  The keys

   ** should have already been unlinked from the pSchema->aFKey hash table 

   */

   for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){

     pNextFKey = pFKey->pNextFrom;

     assert( sqlite3HashFind(&pTable->pSchema->aFKey,

                            pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey );

     sqlite3_free(pFKey);

   }

 #endif

   /* Delete the Table structure itself.

   */

   sqliteResetColumnNames(pTable);

   sqlite3_free(pTable->zName);

   sqlite3_free(pTable->zColAff);

   sqlite3SelectDelete(pTable->pSelect);

 #ifndef SQLITE_OMIT_CHECK

   sqlite3ExprDelete(pTable->pCheck);

 #endif

   sqlite3VtabClear(pTable);

   sqlite3_free(pTable);

 }

 /*

 ** Unlink the given table from the hash tables and the delete the

 ** table structure with all its indices and foreign keys.

 */

 void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){

   Table *p;

   FKey *pF1, *pF2;

   Db *pDb;

   assert( db!=0 );

   assert( iDb>=0 && iDb<db->nDb );

   assert( zTabName && zTabName[0] );

   pDb = &db->aDb[iDb];

   p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, strlen(zTabName)+1,0);

   if( p ){

 #ifndef SQLITE_OMIT_FOREIGN_KEY

     for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){

       int nTo = strlen(pF1->zTo) + 1;

       pF2 = sqlite3HashFind(&pDb->pSchema->aFKey, pF1->zTo, nTo);

       if( pF2==pF1 ){

         sqlite3HashInsert(&pDb->pSchema->aFKey, pF1->zTo, nTo, pF1->pNextTo);

       }else{

         while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; }

         if( pF2 ){

           pF2->pNextTo = pF1->pNextTo;

         }

       }

     }

 #endif

     sqlite3DeleteTable(p);

   }

   db->flags |= SQLITE_InternChanges;

 }

 /*

 ** Given a token, return a string that consists of the text of that

 ** token with any quotations removed.  Space to hold the returned string

 ** is obtained from sqliteMalloc() and must be freed by the calling

 ** function.

 **

 ** Tokens are often just pointers into the original SQL text and so

 ** are not \000 terminated and are not persistent.  The returned string

 ** is \000 terminated and is persistent.

 */

 char *sqlite3NameFromToken(sqlite3 *db, Token *pName){

   char *zName;

   if( pName ){

     zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);

     sqlite3Dequote(zName);

   }else{

     zName = 0;

   }

   return zName;

 }

 /*

 ** Open the sqlite_master table stored in database number iDb for

 ** writing. The table is opened using cursor 0.

 */

 void sqlite3OpenMasterTable(Parse *p, int iDb){

   Vdbe *v = sqlite3GetVdbe(p);

   sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));

   sqlite3VdbeAddOp(v, OP_Integer, iDb, 0);

   sqlite3VdbeAddOp(v, OP_OpenWrite, 0, MASTER_ROOT);

   sqlite3VdbeAddOp(v, OP_SetNumColumns, 0, 5); /* sqlite_master has 5 columns */

 }

 /*

 ** The token *pName contains the name of a database (either "main" or

 ** "temp" or the name of an attached db). This routine returns the

 ** index of the named database in db->aDb[], or -1 if the named db 

 ** does not exist.

 */

 int sqlite3FindDb(sqlite3 *db, Token *pName){

   int i = -1;    /* Database number */

   int n;         /* Number of characters in the name */

   Db *pDb;       /* A database whose name space is being searched */

   char *zName;   /* Name we are searching for */

   zName = sqlite3NameFromToken(db, pName);

   if( zName ){

     n = strlen(zName);

     for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){

       if( (!OMIT_TEMPDB || i!=1 ) && n==strlen(pDb->zName) && 

           0==sqlite3StrICmp(pDb->zName, zName) ){

         break;

       }

     }

     sqlite3_free(zName);

   }

   return i;

 }

 /* The table or view or trigger name is passed to this routine via tokens

 ** pName1 and pName2. If the table name was fully qualified, for example:

 **

 ** CREATE TABLE xxx.yyy (...);

 ** 

 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if

 ** the table name is not fully qualified, i.e.:

 **

 ** CREATE TABLE yyy(...);

 **

 ** Then pName1 is set to "yyy" and pName2 is "".

 **

 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or

 ** pName2) that stores the unqualified table name.  The index of the

 ** database "xxx" is returned.

 */

 int sqlite3TwoPartName(

   Parse *pParse,      /* Parsing and code generating context */

   Token *pName1,      /* The "xxx" in the name "xxx.yyy" or "xxx" */

   Token *pName2,      /* The "yyy" in the name "xxx.yyy" */

   Token **pUnqual     /* Write the unqualified object name here */

 ){

   int iDb;                    /* Database holding the object */

   sqlite3 *db = pParse->db;

   if( pName2 && pName2->n>0 ){

     assert( !db->init.busy );

     *pUnqual = pName2;

     iDb = sqlite3FindDb(db, pName1);

     if( iDb<0 ){

       sqlite3ErrorMsg(pParse, "unknown database %T", pName1);

       pParse->nErr++;

       return -1;

     }

   }else{

     assert( db->init.iDb==0 || db->init.busy );

     iDb = db->init.iDb;

     *pUnqual = pName1;

   }

   return iDb;

 }

 /*

 ** This routine is used to check if the UTF-8 string zName is a legal

 ** unqualified name for a new schema object (table, index, view or

 ** trigger). All names are legal except those that begin with the string

 ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace

 ** is reserved for internal use.

 */

 int sqlite3CheckObjectName(Parse *pParse, const char *zName){

   if( !pParse->db->init.busy && pParse->nested==0 

           && (pParse->db->flags & SQLITE_WriteSchema)==0

           && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){

     sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);

     return SQLITE_ERROR;

   }

   return SQLITE_OK;

 }

 /*

 ** Begin constructing a new table representation in memory.  This is

 ** the first of several action routines that get called in response

 ** to a CREATE TABLE statement.  In particular, this routine is called

 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp

 ** flag is true if the table should be stored in the auxiliary database

 ** file instead of in the main database file.  This is normally the case

 ** when the "TEMP" or "TEMPORARY" keyword occurs in between

 ** CREATE and TABLE.

 **

 ** The new table record is initialized and put in pParse->pNewTable.

 ** As more of the CREATE TABLE statement is parsed, additional action

 ** routines will be called to add more information to this record.

 ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine

 ** is called to complete the construction of the new table record.

 */

 void sqlite3StartTable(

   Parse *pParse,   /* Parser context */

   Token *pName1,   /* First part of the name of the table or view */

   Token *pName2,   /* Second part of the name of the table or view */

   int isTemp,      /* True if this is a TEMP table */

   int isView,      /* True if this is a VIEW */

   int isVirtual,   /* True if this is a VIRTUAL table */

   int noErr        /* Do nothing if table already exists */

 ){

   Table *pTable;

   char *zName = 0; /* The name of the new table */

   sqlite3 *db = pParse->db;

   Vdbe *v;

   int iDb;         /* Database number to create the table in */

   Token *pName;    /* Unqualified name of the table to create */

   /* The table or view name to create is passed to this routine via tokens

   ** pName1 and pName2. If the table name was fully qualified, for example:

   **

   ** CREATE TABLE xxx.yyy (...);

   ** 

   ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if

   ** the table name is not fully qualified, i.e.:

   **

   ** CREATE TABLE yyy(...);

   **

   ** Then pName1 is set to "yyy" and pName2 is "".

   **

   ** The call below sets the pName pointer to point at the token (pName1 or

   ** pName2) that stores the unqualified table name. The variable iDb is

   ** set to the index of the database that the table or view is to be

   ** created in.

   */

   iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);

   if( iDb<0 ) return;

   if( !OMIT_TEMPDB && isTemp && iDb>1 ){

     /* If creating a temp table, the name may not be qualified */

     sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");

     return;

   }

   if( !OMIT_TEMPDB && isTemp ) iDb = 1;

   pParse->sNameToken = *pName;

   zName = sqlite3NameFromToken(db, pName);

   if( zName==0 ) return;

   if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){

     goto begin_table_error;

   }

   if( db->init.iDb==1 ) isTemp = 1;

 #ifndef SQLITE_OMIT_AUTHORIZATION

   assert( (isTemp & 1)==isTemp );

   {

     int code;

     char *zDb = db->aDb[iDb].zName;

     if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){

       goto begin_table_error;

     }

     if( isView ){

       if( !OMIT_TEMPDB && isTemp ){

         code = SQLITE_CREATE_TEMP_VIEW;

       }else{

         code = SQLITE_CREATE_VIEW;

       }

     }else{

       if( !OMIT_TEMPDB && isTemp ){

         code = SQLITE_CREATE_TEMP_TABLE;

       }else{

         code = SQLITE_CREATE_TABLE;

       }

     }

     if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){

       goto begin_table_error;

     }

   }

 #endif

   /* Make sure the new table name does not collide with an existing

   ** index or table name in the same database.  Issue an error message if

   ** it does. The exception is if the statement being parsed was passed

   ** to an sqlite3_declare_vtab() call. In that case only the column names

   ** and types will be used, so there is no need to test for namespace

   ** collisions.

   */

   if( !IN_DECLARE_VTAB ){

     if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){

       goto begin_table_error;

     }

     pTable = sqlite3FindTable(db, zName, db->aDb[iDb].zName);

     if( pTable ){

       if( !noErr ){

         sqlite3ErrorMsg(pParse, "table %T already exists", pName);

       }

       goto begin_table_error;

     }

     if( sqlite3FindIndex(db, zName, 0)!=0 && (iDb==0 || !db->init.busy) ){

       sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);

       goto begin_table_error;

     }

   }

   pTable = sqlite3DbMallocZero(db, sizeof(Table));

   if( pTable==0 ){

     db->mallocFailed = 1;

     pParse->rc = SQLITE_NOMEM;

     pParse->nErr++;

     goto begin_table_error;

   }

   pTable->zName = zName;

   pTable->iPKey = -1;

   pTable->pSchema = db->aDb[iDb].pSchema;

   pTable->nRef = 1;

   if( pParse->pNewTable ) sqlite3DeleteTable(pParse->pNewTable);

   pParse->pNewTable = pTable;

   /* If this is the magic sqlite_sequence table used by autoincrement,

   ** then record a pointer to this table in the main database structure

   ** so that INSERT can find the table easily.

   */

 #ifndef SQLITE_OMIT_AUTOINCREMENT

   if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){

     pTable->pSchema->pSeqTab = pTable;

   }

 #endif

   /* Begin generating the code that will insert the table record into

   ** the SQLITE_MASTER table.  Note in particular that we must go ahead

   ** and allocate the record number for the table entry now.  Before any

   ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause

   ** indices to be created and the table record must come before the 

   ** indices.  Hence, the record number for the table must be allocated

   ** now.

   */

   if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){

     int lbl;

     int fileFormat;

     sqlite3BeginWriteOperation(pParse, 0, iDb);

 #ifndef SQLITE_OMIT_VIRTUALTABLE

     if( isVirtual ){

       sqlite3VdbeAddOp(v, OP_VBegin, 0, 0);

     }

 #endif

     /* If the file format and encoding in the database have not been set, 

     ** set them now.

     */

     sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 1);   /* file_format */

     sqlite3VdbeUsesBtree(v, iDb);

     lbl = sqlite3VdbeMakeLabel(v);

     sqlite3VdbeAddOp(v, OP_If, 0, lbl);

     fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?

                   1 : SQLITE_MAX_FILE_FORMAT;

     sqlite3VdbeAddOp(v, OP_Integer, fileFormat, 0);

     sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 1);

     sqlite3VdbeAddOp(v, OP_Integer, ENC(db), 0);

     sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 4);

     sqlite3VdbeResolveLabel(v, lbl);

     /* This just creates a place-holder record in the sqlite_master table.

     ** The record created does not contain anything yet.  It will be replaced

     ** by the real entry in code generated at sqlite3EndTable().

     **

     ** The rowid for the new entry is left on the top of the stack.

     ** The rowid value is needed by the code that sqlite3EndTable will

     ** generate.

     */

 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)

     if( isView || isVirtual ){

       sqlite3VdbeAddOp(v, OP_Integer, 0, 0);

     }else

 #endif

     {

       sqlite3VdbeAddOp(v, OP_CreateTable, iDb, 0);

     }

     sqlite3OpenMasterTable(pParse, iDb);

     sqlite3VdbeAddOp(v, OP_NewRowid, 0, 0);

     sqlite3VdbeAddOp(v, OP_Dup, 0, 0);

     sqlite3VdbeAddOp(v, OP_Null, 0, 0);

     sqlite3VdbeAddOp(v, OP_Insert, 0, OPFLAG_APPEND);

     sqlite3VdbeAddOp(v, OP_Close, 0, 0);

     sqlite3VdbeAddOp(v, OP_Pull, 1, 0);

   }

   /* Normal (non-error) return. */

   return;

   /* If an error occurs, we jump here */

 begin_table_error:

   sqlite3_free(zName);

   return;

 }

 /*

 ** This macro is used to compare two strings in a case-insensitive manner.

 ** It is slightly faster than calling sqlite3StrICmp() directly, but

 ** produces larger code.

 **

 ** WARNING: This macro is not compatible with the strcmp() family. It

 ** returns true if the two strings are equal, otherwise false.

 */

 #define STRICMP(x, y) (\

 sqlite3UpperToLower[*(unsigned char *)(x)]==   \

 sqlite3UpperToLower[*(unsigned char *)(y)]     \

 && sqlite3StrICmp((x)+1,(y)+1)==0 )

 /*

 ** Add a new column to the table currently being constructed.

 **

 ** The parser calls this routine once for each column declaration

 ** in a CREATE TABLE statement.  sqlite3StartTable() gets called

 ** first to get things going.  Then this routine is called for each

 ** column.

 */

 void sqlite3AddColumn(Parse *pParse, Token *pName){