Annotation of embedaddon/php/ext/sqlite/libsqlite/src/build.c, revision 1.1

1.1     ! misho       1: /*
        !             2: ** 2001 September 15
        !             3: **
        !             4: ** The author disclaims copyright to this source code.  In place of
        !             5: ** a legal notice, here is a blessing:
        !             6: **
        !             7: **    May you do good and not evil.
        !             8: **    May you find forgiveness for yourself and forgive others.
        !             9: **    May you share freely, never taking more than you give.
        !            10: **
        !            11: *************************************************************************
        !            12: ** This file contains C code routines that are called by the SQLite parser
        !            13: ** when syntax rules are reduced.  The routines in this file handle the
        !            14: ** following kinds of SQL syntax:
        !            15: **
        !            16: **     CREATE TABLE
        !            17: **     DROP TABLE
        !            18: **     CREATE INDEX
        !            19: **     DROP INDEX
        !            20: **     creating ID lists
        !            21: **     BEGIN TRANSACTION
        !            22: **     COMMIT
        !            23: **     ROLLBACK
        !            24: **     PRAGMA
        !            25: **
        !            26: ** $Id: build.c 195361 2005-09-07 15:11:33Z iliaa $
        !            27: */
        !            28: #include "sqliteInt.h"
        !            29: #include <ctype.h>
        !            30: 
        !            31: /*
        !            32: ** This routine is called when a new SQL statement is beginning to
        !            33: ** be parsed.  Check to see if the schema for the database needs
        !            34: ** to be read from the SQLITE_MASTER and SQLITE_TEMP_MASTER tables.
        !            35: ** If it does, then read it.
        !            36: */
        !            37: void sqliteBeginParse(Parse *pParse, int explainFlag){
        !            38:   sqlite *db = pParse->db;
        !            39:   int i;
        !            40:   pParse->explain = explainFlag;
        !            41:   if((db->flags & SQLITE_Initialized)==0 && db->init.busy==0 ){
        !            42:     int rc = sqliteInit(db, &pParse->zErrMsg);
        !            43:     if( rc!=SQLITE_OK ){
        !            44:       pParse->rc = rc;
        !            45:       pParse->nErr++;
        !            46:     }
        !            47:   }
        !            48:   for(i=0; i<db->nDb; i++){
        !            49:     DbClearProperty(db, i, DB_Locked);
        !            50:     if( !db->aDb[i].inTrans ){
        !            51:       DbClearProperty(db, i, DB_Cookie);
        !            52:     }
        !            53:   }
        !            54:   pParse->nVar = 0;
        !            55: }
        !            56: 
        !            57: /*
        !            58: ** This routine is called after a single SQL statement has been
        !            59: ** parsed and we want to execute the VDBE code to implement 
        !            60: ** that statement.  Prior action routines should have already
        !            61: ** constructed VDBE code to do the work of the SQL statement.
        !            62: ** This routine just has to execute the VDBE code.
        !            63: **
        !            64: ** Note that if an error occurred, it might be the case that
        !            65: ** no VDBE code was generated.
        !            66: */
        !            67: void sqliteExec(Parse *pParse){
        !            68:   sqlite *db = pParse->db;
        !            69:   Vdbe *v = pParse->pVdbe;
        !            70: 
        !            71:   if( v==0 && (v = sqliteGetVdbe(pParse))!=0 ){
        !            72:     sqliteVdbeAddOp(v, OP_Halt, 0, 0);
        !            73:   }
        !            74:   if( sqlite_malloc_failed ) return;
        !            75:   if( v && pParse->nErr==0 ){
        !            76:     FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
        !            77:     sqliteVdbeTrace(v, trace);
        !            78:     sqliteVdbeMakeReady(v, pParse->nVar, pParse->explain);
        !            79:     pParse->rc = pParse->nErr ? SQLITE_ERROR : SQLITE_DONE;
        !            80:     pParse->colNamesSet = 0;
        !            81:   }else if( pParse->rc==SQLITE_OK ){
        !            82:     pParse->rc = SQLITE_ERROR;
        !            83:   }
        !            84:   pParse->nTab = 0;
        !            85:   pParse->nMem = 0;
        !            86:   pParse->nSet = 0;
        !            87:   pParse->nAgg = 0;
        !            88:   pParse->nVar = 0;
        !            89: }
        !            90: 
        !            91: /*
        !            92: ** Locate the in-memory structure that describes 
        !            93: ** a particular database table given the name
        !            94: ** of that table and (optionally) the name of the database
        !            95: ** containing the table.  Return NULL if not found.
        !            96: **
        !            97: ** If zDatabase is 0, all databases are searched for the
        !            98: ** table and the first matching table is returned.  (No checking
        !            99: ** for duplicate table names is done.)  The search order is
        !           100: ** TEMP first, then MAIN, then any auxiliary databases added
        !           101: ** using the ATTACH command.
        !           102: **
        !           103: ** See also sqliteLocateTable().
        !           104: */
        !           105: Table *sqliteFindTable(sqlite *db, const char *zName, const char *zDatabase){
        !           106:   Table *p = 0;
        !           107:   int i;
        !           108:   for(i=0; i<db->nDb; i++){
        !           109:     int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
        !           110:     if( zDatabase!=0 && sqliteStrICmp(zDatabase, db->aDb[j].zName) ) continue;
        !           111:     p = sqliteHashFind(&db->aDb[j].tblHash, zName, strlen(zName)+1);
        !           112:     if( p ) break;
        !           113:   }
        !           114:   return p;
        !           115: }
        !           116: 
        !           117: /*
        !           118: ** Locate the in-memory structure that describes 
        !           119: ** a particular database table given the name
        !           120: ** of that table and (optionally) the name of the database
        !           121: ** containing the table.  Return NULL if not found.
        !           122: ** Also leave an error message in pParse->zErrMsg.
        !           123: **
        !           124: ** The difference between this routine and sqliteFindTable()
        !           125: ** is that this routine leaves an error message in pParse->zErrMsg
        !           126: ** where sqliteFindTable() does not.
        !           127: */
        !           128: Table *sqliteLocateTable(Parse *pParse, const char *zName, const char *zDbase){
        !           129:   Table *p;
        !           130: 
        !           131:   p = sqliteFindTable(pParse->db, zName, zDbase);
        !           132:   if( p==0 ){
        !           133:     if( zDbase ){
        !           134:       sqliteErrorMsg(pParse, "no such table: %s.%s", zDbase, zName);
        !           135:     }else if( sqliteFindTable(pParse->db, zName, 0)!=0 ){
        !           136:       sqliteErrorMsg(pParse, "table \"%s\" is not in database \"%s\"",
        !           137:          zName, zDbase);
        !           138:     }else{
        !           139:       sqliteErrorMsg(pParse, "no such table: %s", zName);
        !           140:     }
        !           141:   }
        !           142:   return p;
        !           143: }
        !           144: 
        !           145: /*
        !           146: ** Locate the in-memory structure that describes 
        !           147: ** a particular index given the name of that index
        !           148: ** and the name of the database that contains the index.
        !           149: ** Return NULL if not found.
        !           150: **
        !           151: ** If zDatabase is 0, all databases are searched for the
        !           152: ** table and the first matching index is returned.  (No checking
        !           153: ** for duplicate index names is done.)  The search order is
        !           154: ** TEMP first, then MAIN, then any auxiliary databases added
        !           155: ** using the ATTACH command.
        !           156: */
        !           157: Index *sqliteFindIndex(sqlite *db, const char *zName, const char *zDb){
        !           158:   Index *p = 0;
        !           159:   int i;
        !           160:   for(i=0; i<db->nDb; i++){
        !           161:     int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
        !           162:     if( zDb && sqliteStrICmp(zDb, db->aDb[j].zName) ) continue;
        !           163:     p = sqliteHashFind(&db->aDb[j].idxHash, zName, strlen(zName)+1);
        !           164:     if( p ) break;
        !           165:   }
        !           166:   return p;
        !           167: }
        !           168: 
        !           169: /*
        !           170: ** Remove the given index from the index hash table, and free
        !           171: ** its memory structures.
        !           172: **
        !           173: ** The index is removed from the database hash tables but
        !           174: ** it is not unlinked from the Table that it indexes.
        !           175: ** Unlinking from the Table must be done by the calling function.
        !           176: */
        !           177: static void sqliteDeleteIndex(sqlite *db, Index *p){
        !           178:   Index *pOld;
        !           179: 
        !           180:   assert( db!=0 && p->zName!=0 );
        !           181:   pOld = sqliteHashInsert(&db->aDb[p->iDb].idxHash, p->zName,
        !           182:                           strlen(p->zName)+1, 0);
        !           183:   if( pOld!=0 && pOld!=p ){
        !           184:     sqliteHashInsert(&db->aDb[p->iDb].idxHash, pOld->zName,
        !           185:                      strlen(pOld->zName)+1, pOld);
        !           186:   }
        !           187:   sqliteFree(p);
        !           188: }
        !           189: 
        !           190: /*
        !           191: ** Unlink the given index from its table, then remove
        !           192: ** the index from the index hash table and free its memory
        !           193: ** structures.
        !           194: */
        !           195: void sqliteUnlinkAndDeleteIndex(sqlite *db, Index *pIndex){
        !           196:   if( pIndex->pTable->pIndex==pIndex ){
        !           197:     pIndex->pTable->pIndex = pIndex->pNext;
        !           198:   }else{
        !           199:     Index *p;
        !           200:     for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){}
        !           201:     if( p && p->pNext==pIndex ){
        !           202:       p->pNext = pIndex->pNext;
        !           203:     }
        !           204:   }
        !           205:   sqliteDeleteIndex(db, pIndex);
        !           206: }
        !           207: 
        !           208: /*
        !           209: ** Erase all schema information from the in-memory hash tables of
        !           210: ** database connection.  This routine is called to reclaim memory
        !           211: ** before the connection closes.  It is also called during a rollback
        !           212: ** if there were schema changes during the transaction.
        !           213: **
        !           214: ** If iDb<=0 then reset the internal schema tables for all database
        !           215: ** files.  If iDb>=2 then reset the internal schema for only the
        !           216: ** single file indicated.
        !           217: */
        !           218: void sqliteResetInternalSchema(sqlite *db, int iDb){
        !           219:   HashElem *pElem;
        !           220:   Hash temp1;
        !           221:   Hash temp2;
        !           222:   int i, j;
        !           223: 
        !           224:   assert( iDb>=0 && iDb<db->nDb );
        !           225:   db->flags &= ~SQLITE_Initialized;
        !           226:   for(i=iDb; i<db->nDb; i++){
        !           227:     Db *pDb = &db->aDb[i];
        !           228:     temp1 = pDb->tblHash;
        !           229:     temp2 = pDb->trigHash;
        !           230:     sqliteHashInit(&pDb->trigHash, SQLITE_HASH_STRING, 0);
        !           231:     sqliteHashClear(&pDb->aFKey);
        !           232:     sqliteHashClear(&pDb->idxHash);
        !           233:     for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){
        !           234:       Trigger *pTrigger = sqliteHashData(pElem);
        !           235:       sqliteDeleteTrigger(pTrigger);
        !           236:     }
        !           237:     sqliteHashClear(&temp2);
        !           238:     sqliteHashInit(&pDb->tblHash, SQLITE_HASH_STRING, 0);
        !           239:     for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){
        !           240:       Table *pTab = sqliteHashData(pElem);
        !           241:       sqliteDeleteTable(db, pTab);
        !           242:     }
        !           243:     sqliteHashClear(&temp1);
        !           244:     DbClearProperty(db, i, DB_SchemaLoaded);
        !           245:     if( iDb>0 ) return;
        !           246:   }
        !           247:   assert( iDb==0 );
        !           248:   db->flags &= ~SQLITE_InternChanges;
        !           249: 
        !           250:   /* If one or more of the auxiliary database files has been closed,
        !           251:   ** then remove then from the auxiliary database list.  We take the
        !           252:   ** opportunity to do this here since we have just deleted all of the
        !           253:   ** schema hash tables and therefore do not have to make any changes
        !           254:   ** to any of those tables.
        !           255:   */
        !           256:   for(i=0; i<db->nDb; i++){
        !           257:     struct Db *pDb = &db->aDb[i];
        !           258:     if( pDb->pBt==0 ){
        !           259:       if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux);
        !           260:       pDb->pAux = 0;
        !           261:     }
        !           262:   }
        !           263:   for(i=j=2; i<db->nDb; i++){
        !           264:     struct Db *pDb = &db->aDb[i];
        !           265:     if( pDb->pBt==0 ){
        !           266:       sqliteFree(pDb->zName);
        !           267:       pDb->zName = 0;
        !           268:       continue;
        !           269:     }
        !           270:     if( j<i ){
        !           271:       db->aDb[j] = db->aDb[i];
        !           272:     }
        !           273:     j++;
        !           274:   }
        !           275:   memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
        !           276:   db->nDb = j;
        !           277:   if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
        !           278:     memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
        !           279:     sqliteFree(db->aDb);
        !           280:     db->aDb = db->aDbStatic;
        !           281:   }
        !           282: }
        !           283: 
        !           284: /*
        !           285: ** This routine is called whenever a rollback occurs.  If there were
        !           286: ** schema changes during the transaction, then we have to reset the
        !           287: ** internal hash tables and reload them from disk.
        !           288: */
        !           289: void sqliteRollbackInternalChanges(sqlite *db){
        !           290:   if( db->flags & SQLITE_InternChanges ){
        !           291:     sqliteResetInternalSchema(db, 0);
        !           292:   }
        !           293: }
        !           294: 
        !           295: /*
        !           296: ** This routine is called when a commit occurs.
        !           297: */
        !           298: void sqliteCommitInternalChanges(sqlite *db){
        !           299:   db->aDb[0].schema_cookie = db->next_cookie;
        !           300:   db->flags &= ~SQLITE_InternChanges;
        !           301: }
        !           302: 
        !           303: /*
        !           304: ** Remove the memory data structures associated with the given
        !           305: ** Table.  No changes are made to disk by this routine.
        !           306: **
        !           307: ** This routine just deletes the data structure.  It does not unlink
        !           308: ** the table data structure from the hash table.  Nor does it remove
        !           309: ** foreign keys from the sqlite.aFKey hash table.  But it does destroy
        !           310: ** memory structures of the indices and foreign keys associated with 
        !           311: ** the table.
        !           312: **
        !           313: ** Indices associated with the table are unlinked from the "db"
        !           314: ** data structure if db!=NULL.  If db==NULL, indices attached to
        !           315: ** the table are deleted, but it is assumed they have already been
        !           316: ** unlinked.
        !           317: */
        !           318: void sqliteDeleteTable(sqlite *db, Table *pTable){
        !           319:   int i;
        !           320:   Index *pIndex, *pNext;
        !           321:   FKey *pFKey, *pNextFKey;
        !           322: 
        !           323:   if( pTable==0 ) return;
        !           324: 
        !           325:   /* Delete all indices associated with this table
        !           326:   */
        !           327:   for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
        !           328:     pNext = pIndex->pNext;
        !           329:     assert( pIndex->iDb==pTable->iDb || (pTable->iDb==0 && pIndex->iDb==1) );
        !           330:     sqliteDeleteIndex(db, pIndex);
        !           331:   }
        !           332: 
        !           333:   /* Delete all foreign keys associated with this table.  The keys
        !           334:   ** should have already been unlinked from the db->aFKey hash table 
        !           335:   */
        !           336:   for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){
        !           337:     pNextFKey = pFKey->pNextFrom;
        !           338:     assert( pTable->iDb<db->nDb );
        !           339:     assert( sqliteHashFind(&db->aDb[pTable->iDb].aFKey,
        !           340:                            pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey );
        !           341:     sqliteFree(pFKey);
        !           342:   }
        !           343: 
        !           344:   /* Delete the Table structure itself.
        !           345:   */
        !           346:   for(i=0; i<pTable->nCol; i++){
        !           347:     sqliteFree(pTable->aCol[i].zName);
        !           348:     sqliteFree(pTable->aCol[i].zDflt);
        !           349:     sqliteFree(pTable->aCol[i].zType);
        !           350:   }
        !           351:   sqliteFree(pTable->zName);
        !           352:   sqliteFree(pTable->aCol);
        !           353:   sqliteSelectDelete(pTable->pSelect);
        !           354:   sqliteFree(pTable);
        !           355: }
        !           356: 
        !           357: /*
        !           358: ** Unlink the given table from the hash tables and the delete the
        !           359: ** table structure with all its indices and foreign keys.
        !           360: */
        !           361: static void sqliteUnlinkAndDeleteTable(sqlite *db, Table *p){
        !           362:   Table *pOld;
        !           363:   FKey *pF1, *pF2;
        !           364:   int i = p->iDb;
        !           365:   assert( db!=0 );
        !           366:   pOld = sqliteHashInsert(&db->aDb[i].tblHash, p->zName, strlen(p->zName)+1, 0);
        !           367:   assert( pOld==0 || pOld==p );
        !           368:   for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){
        !           369:     int nTo = strlen(pF1->zTo) + 1;
        !           370:     pF2 = sqliteHashFind(&db->aDb[i].aFKey, pF1->zTo, nTo);
        !           371:     if( pF2==pF1 ){
        !           372:       sqliteHashInsert(&db->aDb[i].aFKey, pF1->zTo, nTo, pF1->pNextTo);
        !           373:     }else{
        !           374:       while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; }
        !           375:       if( pF2 ){
        !           376:         pF2->pNextTo = pF1->pNextTo;
        !           377:       }
        !           378:     }
        !           379:   }
        !           380:   sqliteDeleteTable(db, p);
        !           381: }
        !           382: 
        !           383: /*
        !           384: ** Construct the name of a user table or index from a token.
        !           385: **
        !           386: ** Space to hold the name is obtained from sqliteMalloc() and must
        !           387: ** be freed by the calling function.
        !           388: */
        !           389: char *sqliteTableNameFromToken(Token *pName){
        !           390:   char *zName = sqliteStrNDup(pName->z, pName->n);
        !           391:   sqliteDequote(zName);
        !           392:   return zName;
        !           393: }
        !           394: 
        !           395: /*
        !           396: ** Generate code to open the appropriate master table.  The table
        !           397: ** opened will be SQLITE_MASTER for persistent tables and 
        !           398: ** SQLITE_TEMP_MASTER for temporary tables.  The table is opened
        !           399: ** on cursor 0.
        !           400: */
        !           401: void sqliteOpenMasterTable(Vdbe *v, int isTemp){
        !           402:   sqliteVdbeAddOp(v, OP_Integer, isTemp, 0);
        !           403:   sqliteVdbeAddOp(v, OP_OpenWrite, 0, 2);
        !           404: }
        !           405: 
        !           406: /*
        !           407: ** Begin constructing a new table representation in memory.  This is
        !           408: ** the first of several action routines that get called in response
        !           409: ** to a CREATE TABLE statement.  In particular, this routine is called
        !           410: ** after seeing tokens "CREATE" and "TABLE" and the table name.  The
        !           411: ** pStart token is the CREATE and pName is the table name.  The isTemp
        !           412: ** flag is true if the table should be stored in the auxiliary database
        !           413: ** file instead of in the main database file.  This is normally the case
        !           414: ** when the "TEMP" or "TEMPORARY" keyword occurs in between
        !           415: ** CREATE and TABLE.
        !           416: **
        !           417: ** The new table record is initialized and put in pParse->pNewTable.
        !           418: ** As more of the CREATE TABLE statement is parsed, additional action
        !           419: ** routines will be called to add more information to this record.
        !           420: ** At the end of the CREATE TABLE statement, the sqliteEndTable() routine
        !           421: ** is called to complete the construction of the new table record.
        !           422: */
        !           423: void sqliteStartTable(
        !           424:   Parse *pParse,   /* Parser context */
        !           425:   Token *pStart,   /* The "CREATE" token */
        !           426:   Token *pName,    /* Name of table or view to create */
        !           427:   int isTemp,      /* True if this is a TEMP table */
        !           428:   int isView       /* True if this is a VIEW */
        !           429: ){
        !           430:   Table *pTable;
        !           431:   Index *pIdx;
        !           432:   char *zName;
        !           433:   sqlite *db = pParse->db;
        !           434:   Vdbe *v;
        !           435:   int iDb;
        !           436: 
        !           437:   pParse->sFirstToken = *pStart;
        !           438:   zName = sqliteTableNameFromToken(pName);
        !           439:   if( zName==0 ) return;
        !           440:   if( db->init.iDb==1 ) isTemp = 1;
        !           441: #ifndef SQLITE_OMIT_AUTHORIZATION
        !           442:   assert( (isTemp & 1)==isTemp );
        !           443:   {
        !           444:     int code;
        !           445:     char *zDb = isTemp ? "temp" : "main";
        !           446:     if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
        !           447:       sqliteFree(zName);
        !           448:       return;
        !           449:     }
        !           450:     if( isView ){
        !           451:       if( isTemp ){
        !           452:         code = SQLITE_CREATE_TEMP_VIEW;
        !           453:       }else{
        !           454:         code = SQLITE_CREATE_VIEW;
        !           455:       }
        !           456:     }else{
        !           457:       if( isTemp ){
        !           458:         code = SQLITE_CREATE_TEMP_TABLE;
        !           459:       }else{
        !           460:         code = SQLITE_CREATE_TABLE;
        !           461:       }
        !           462:     }
        !           463:     if( sqliteAuthCheck(pParse, code, zName, 0, zDb) ){
        !           464:       sqliteFree(zName);
        !           465:       return;
        !           466:     }
        !           467:   }
        !           468: #endif
        !           469:  
        !           470: 
        !           471:   /* Before trying to create a temporary table, make sure the Btree for
        !           472:   ** holding temporary tables is open.
        !           473:   */
        !           474:   if( isTemp && db->aDb[1].pBt==0 && !pParse->explain ){
        !           475:     int rc = sqliteBtreeFactory(db, 0, 0, MAX_PAGES, &db->aDb[1].pBt);
        !           476:     if( rc!=SQLITE_OK ){
        !           477:       sqliteErrorMsg(pParse, "unable to open a temporary database "
        !           478:         "file for storing temporary tables");
        !           479:       pParse->nErr++;
        !           480:       return;
        !           481:     }
        !           482:     if( db->flags & SQLITE_InTrans ){
        !           483:       rc = sqliteBtreeBeginTrans(db->aDb[1].pBt);
        !           484:       if( rc!=SQLITE_OK ){
        !           485:         sqliteErrorMsg(pParse, "unable to get a write lock on "
        !           486:           "the temporary database file");
        !           487:         return;
        !           488:       }
        !           489:     }
        !           490:   }
        !           491: 
        !           492:   /* Make sure the new table name does not collide with an existing
        !           493:   ** index or table name.  Issue an error message if it does.
        !           494:   **
        !           495:   ** If we are re-reading the sqlite_master table because of a schema
        !           496:   ** change and a new permanent table is found whose name collides with
        !           497:   ** an existing temporary table, that is not an error.
        !           498:   */
        !           499:   pTable = sqliteFindTable(db, zName, 0);
        !           500:   iDb = isTemp ? 1 : db->init.iDb;
        !           501:   if( pTable!=0 && (pTable->iDb==iDb || !db->init.busy) ){
        !           502:     sqliteErrorMsg(pParse, "table %T already exists", pName);
        !           503:     sqliteFree(zName);
        !           504:     return;
        !           505:   }
        !           506:   if( (pIdx = sqliteFindIndex(db, zName, 0))!=0 &&
        !           507:           (pIdx->iDb==0 || !db->init.busy) ){
        !           508:     sqliteErrorMsg(pParse, "there is already an index named %s", zName);
        !           509:     sqliteFree(zName);
        !           510:     return;
        !           511:   }
        !           512:   pTable = sqliteMalloc( sizeof(Table) );
        !           513:   if( pTable==0 ){
        !           514:     sqliteFree(zName);
        !           515:     return;
        !           516:   }
        !           517:   pTable->zName = zName;
        !           518:   pTable->nCol = 0;
        !           519:   pTable->aCol = 0;
        !           520:   pTable->iPKey = -1;
        !           521:   pTable->pIndex = 0;
        !           522:   pTable->iDb = iDb;
        !           523:   if( pParse->pNewTable ) sqliteDeleteTable(db, pParse->pNewTable);
        !           524:   pParse->pNewTable = pTable;
        !           525: 
        !           526:   /* Begin generating the code that will insert the table record into
        !           527:   ** the SQLITE_MASTER table.  Note in particular that we must go ahead
        !           528:   ** and allocate the record number for the table entry now.  Before any
        !           529:   ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
        !           530:   ** indices to be created and the table record must come before the 
        !           531:   ** indices.  Hence, the record number for the table must be allocated
        !           532:   ** now.
        !           533:   */
        !           534:   if( !db->init.busy && (v = sqliteGetVdbe(pParse))!=0 ){
        !           535:     sqliteBeginWriteOperation(pParse, 0, isTemp);
        !           536:     if( !isTemp ){
        !           537:       sqliteVdbeAddOp(v, OP_Integer, db->file_format, 0);
        !           538:       sqliteVdbeAddOp(v, OP_SetCookie, 0, 1);
        !           539:     }
        !           540:     sqliteOpenMasterTable(v, isTemp);
        !           541:     sqliteVdbeAddOp(v, OP_NewRecno, 0, 0);
        !           542:     sqliteVdbeAddOp(v, OP_Dup, 0, 0);
        !           543:     sqliteVdbeAddOp(v, OP_String, 0, 0);
        !           544:     sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0);
        !           545:   }
        !           546: }
        !           547: 
        !           548: /*
        !           549: ** Add a new column to the table currently being constructed.
        !           550: **
        !           551: ** The parser calls this routine once for each column declaration
        !           552: ** in a CREATE TABLE statement.  sqliteStartTable() gets called
        !           553: ** first to get things going.  Then this routine is called for each
        !           554: ** column.
        !           555: */
        !           556: void sqliteAddColumn(Parse *pParse, Token *pName){
        !           557:   Table *p;
        !           558:   int i;
        !           559:   char *z = 0;
        !           560:   Column *pCol;
        !           561:   if( (p = pParse->pNewTable)==0 ) return;
        !           562:   sqliteSetNString(&z, pName->z, pName->n, 0);
        !           563:   if( z==0 ) return;
        !           564:   sqliteDequote(z);
        !           565:   for(i=0; i<p->nCol; i++){
        !           566:     if( sqliteStrICmp(z, p->aCol[i].zName)==0 ){
        !           567:       sqliteErrorMsg(pParse, "duplicate column name: %s", z);
        !           568:       sqliteFree(z);
        !           569:       return;
        !           570:     }
        !           571:   }
        !           572:   if( (p->nCol & 0x7)==0 ){
        !           573:     Column *aNew;
        !           574:     aNew = sqliteRealloc( p->aCol, (p->nCol+8)*sizeof(p->aCol[0]));
        !           575:     if( aNew==0 ) return;
        !           576:     p->aCol = aNew;
        !           577:   }
        !           578:   pCol = &p->aCol[p->nCol];
        !           579:   memset(pCol, 0, sizeof(p->aCol[0]));
        !           580:   pCol->zName = z;
        !           581:   pCol->sortOrder = SQLITE_SO_NUM;
        !           582:   p->nCol++;
        !           583: }
        !           584: 
        !           585: /*
        !           586: ** This routine is called by the parser while in the middle of
        !           587: ** parsing a CREATE TABLE statement.  A "NOT NULL" constraint has
        !           588: ** been seen on a column.  This routine sets the notNull flag on
        !           589: ** the column currently under construction.
        !           590: */
        !           591: void sqliteAddNotNull(Parse *pParse, int onError){
        !           592:   Table *p;
        !           593:   int i;
        !           594:   if( (p = pParse->pNewTable)==0 ) return;
        !           595:   i = p->nCol-1;
        !           596:   if( i>=0 ) p->aCol[i].notNull = onError;
        !           597: }
        !           598: 
        !           599: /*
        !           600: ** This routine is called by the parser while in the middle of
        !           601: ** parsing a CREATE TABLE statement.  The pFirst token is the first
        !           602: ** token in the sequence of tokens that describe the type of the
        !           603: ** column currently under construction.   pLast is the last token
        !           604: ** in the sequence.  Use this information to construct a string
        !           605: ** that contains the typename of the column and store that string
        !           606: ** in zType.
        !           607: */ 
        !           608: void sqliteAddColumnType(Parse *pParse, Token *pFirst, Token *pLast){
        !           609:   Table *p;
        !           610:   int i, j;
        !           611:   int n;
        !           612:   char *z, **pz;
        !           613:   Column *pCol;
        !           614:   if( (p = pParse->pNewTable)==0 ) return;
        !           615:   i = p->nCol-1;
        !           616:   if( i<0 ) return;
        !           617:   pCol = &p->aCol[i];
        !           618:   pz = &pCol->zType;
        !           619:   n = pLast->n + Addr(pLast->z) - Addr(pFirst->z);
        !           620:   sqliteSetNString(pz, pFirst->z, n, 0);
        !           621:   z = *pz;
        !           622:   if( z==0 ) return;
        !           623:   for(i=j=0; z[i]; i++){
        !           624:     int c = z[i];
        !           625:     if( isspace(c) ) continue;
        !           626:     z[j++] = c;
        !           627:   }
        !           628:   z[j] = 0;
        !           629:   if( pParse->db->file_format>=4 ){
        !           630:     pCol->sortOrder = sqliteCollateType(z, n);
        !           631:   }else{
        !           632:     pCol->sortOrder = SQLITE_SO_NUM;
        !           633:   }
        !           634: }
        !           635: 
        !           636: /*
        !           637: ** The given token is the default value for the last column added to
        !           638: ** the table currently under construction.  If "minusFlag" is true, it
        !           639: ** means the value token was preceded by a minus sign.
        !           640: **
        !           641: ** This routine is called by the parser while in the middle of
        !           642: ** parsing a CREATE TABLE statement.
        !           643: */
        !           644: void sqliteAddDefaultValue(Parse *pParse, Token *pVal, int minusFlag){
        !           645:   Table *p;
        !           646:   int i;
        !           647:   char **pz;
        !           648:   if( (p = pParse->pNewTable)==0 ) return;
        !           649:   i = p->nCol-1;
        !           650:   if( i<0 ) return;
        !           651:   pz = &p->aCol[i].zDflt;
        !           652:   if( minusFlag ){
        !           653:     sqliteSetNString(pz, "-", 1, pVal->z, pVal->n, 0);
        !           654:   }else{
        !           655:     sqliteSetNString(pz, pVal->z, pVal->n, 0);
        !           656:   }
        !           657:   sqliteDequote(*pz);
        !           658: }
        !           659: 
        !           660: /*
        !           661: ** Designate the PRIMARY KEY for the table.  pList is a list of names 
        !           662: ** of columns that form the primary key.  If pList is NULL, then the
        !           663: ** most recently added column of the table is the primary key.
        !           664: **
        !           665: ** A table can have at most one primary key.  If the table already has
        !           666: ** a primary key (and this is the second primary key) then create an
        !           667: ** error.
        !           668: **
        !           669: ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
        !           670: ** then we will try to use that column as the row id.  (Exception:
        !           671: ** For backwards compatibility with older databases, do not do this
        !           672: ** if the file format version number is less than 1.)  Set the Table.iPKey
        !           673: ** field of the table under construction to be the index of the
        !           674: ** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is
        !           675: ** no INTEGER PRIMARY KEY.
        !           676: **
        !           677: ** If the key is not an INTEGER PRIMARY KEY, then create a unique
        !           678: ** index for the key.  No index is created for INTEGER PRIMARY KEYs.
        !           679: */
        !           680: void sqliteAddPrimaryKey(Parse *pParse, IdList *pList, int onError){
        !           681:   Table *pTab = pParse->pNewTable;
        !           682:   char *zType = 0;
        !           683:   int iCol = -1, i;
        !           684:   if( pTab==0 ) goto primary_key_exit;
        !           685:   if( pTab->hasPrimKey ){
        !           686:     sqliteErrorMsg(pParse, 
        !           687:       "table \"%s\" has more than one primary key", pTab->zName);
        !           688:     goto primary_key_exit;
        !           689:   }
        !           690:   pTab->hasPrimKey = 1;
        !           691:   if( pList==0 ){
        !           692:     iCol = pTab->nCol - 1;
        !           693:     pTab->aCol[iCol].isPrimKey = 1;
        !           694:   }else{
        !           695:     for(i=0; i<pList->nId; i++){
        !           696:       for(iCol=0; iCol<pTab->nCol; iCol++){
        !           697:         if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ) break;
        !           698:       }
        !           699:       if( iCol<pTab->nCol ) pTab->aCol[iCol].isPrimKey = 1;
        !           700:     }
        !           701:     if( pList->nId>1 ) iCol = -1;
        !           702:   }
        !           703:   if( iCol>=0 && iCol<pTab->nCol ){
        !           704:     zType = pTab->aCol[iCol].zType;
        !           705:   }
        !           706:   if( pParse->db->file_format>=1 && 
        !           707:            zType && sqliteStrICmp(zType, "INTEGER")==0 ){
        !           708:     pTab->iPKey = iCol;
        !           709:     pTab->keyConf = onError;
        !           710:   }else{
        !           711:     sqliteCreateIndex(pParse, 0, 0, pList, onError, 0, 0);
        !           712:     pList = 0;
        !           713:   }
        !           714: 
        !           715: primary_key_exit:
        !           716:   sqliteIdListDelete(pList);
        !           717:   return;
        !           718: }
        !           719: 
        !           720: /*
        !           721: ** Return the appropriate collating type given a type name.
        !           722: **
        !           723: ** The collation type is text (SQLITE_SO_TEXT) if the type
        !           724: ** name contains the character stream "text" or "blob" or
        !           725: ** "clob".  Any other type name is collated as numeric
        !           726: ** (SQLITE_SO_NUM).
        !           727: */
        !           728: int sqliteCollateType(const char *zType, int nType){
        !           729:   int i;
        !           730:   for(i=0; i<nType-3; i++){
        !           731:     int c = *(zType++) | 0x60;
        !           732:     if( (c=='b' || c=='c') && sqliteStrNICmp(zType, "lob", 3)==0 ){
        !           733:       return SQLITE_SO_TEXT;
        !           734:     }
        !           735:     if( c=='c' && sqliteStrNICmp(zType, "har", 3)==0 ){
        !           736:       return SQLITE_SO_TEXT;
        !           737:     }
        !           738:     if( c=='t' && sqliteStrNICmp(zType, "ext", 3)==0 ){
        !           739:       return SQLITE_SO_TEXT;
        !           740:     }
        !           741:   }
        !           742:   return SQLITE_SO_NUM;
        !           743: }
        !           744: 
        !           745: /*
        !           746: ** This routine is called by the parser while in the middle of
        !           747: ** parsing a CREATE TABLE statement.  A "COLLATE" clause has
        !           748: ** been seen on a column.  This routine sets the Column.sortOrder on
        !           749: ** the column currently under construction.
        !           750: */
        !           751: void sqliteAddCollateType(Parse *pParse, int collType){
        !           752:   Table *p;
        !           753:   int i;
        !           754:   if( (p = pParse->pNewTable)==0 ) return;
        !           755:   i = p->nCol-1;
        !           756:   if( i>=0 ) p->aCol[i].sortOrder = collType;
        !           757: }
        !           758: 
        !           759: /*
        !           760: ** Come up with a new random value for the schema cookie.  Make sure
        !           761: ** the new value is different from the old.
        !           762: **
        !           763: ** The schema cookie is used to determine when the schema for the
        !           764: ** database changes.  After each schema change, the cookie value
        !           765: ** changes.  When a process first reads the schema it records the
        !           766: ** cookie.  Thereafter, whenever it goes to access the database,
        !           767: ** it checks the cookie to make sure the schema has not changed
        !           768: ** since it was last read.
        !           769: **
        !           770: ** This plan is not completely bullet-proof.  It is possible for
        !           771: ** the schema to change multiple times and for the cookie to be
        !           772: ** set back to prior value.  But schema changes are infrequent
        !           773: ** and the probability of hitting the same cookie value is only
        !           774: ** 1 chance in 2^32.  So we're safe enough.
        !           775: */
        !           776: void sqliteChangeCookie(sqlite *db, Vdbe *v){
        !           777:   if( db->next_cookie==db->aDb[0].schema_cookie ){
        !           778:     unsigned char r;
        !           779:     sqliteRandomness(1, &r);
        !           780:     db->next_cookie = db->aDb[0].schema_cookie + r + 1;
        !           781:     db->flags |= SQLITE_InternChanges;
        !           782:     sqliteVdbeAddOp(v, OP_Integer, db->next_cookie, 0);
        !           783:     sqliteVdbeAddOp(v, OP_SetCookie, 0, 0);
        !           784:   }
        !           785: }
        !           786: 
        !           787: /*
        !           788: ** Measure the number of characters needed to output the given
        !           789: ** identifier.  The number returned includes any quotes used
        !           790: ** but does not include the null terminator.
        !           791: */
        !           792: static int identLength(const char *z){
        !           793:   int n;
        !           794:   int needQuote = 0;
        !           795:   for(n=0; *z; n++, z++){
        !           796:     if( *z=='\'' ){ n++; needQuote=1; }
        !           797:   }
        !           798:   return n + needQuote*2;
        !           799: }
        !           800: 
        !           801: /*
        !           802: ** Write an identifier onto the end of the given string.  Add
        !           803: ** quote characters as needed.
        !           804: */
        !           805: static void identPut(char *z, int *pIdx, char *zIdent){
        !           806:   int i, j, needQuote;
        !           807:   i = *pIdx;
        !           808:   for(j=0; zIdent[j]; j++){
        !           809:     if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
        !           810:   }
        !           811:   needQuote =  zIdent[j]!=0 || isdigit(zIdent[0])
        !           812:                   || sqliteKeywordCode(zIdent, j)!=TK_ID;
        !           813:   if( needQuote ) z[i++] = '\'';
        !           814:   for(j=0; zIdent[j]; j++){
        !           815:     z[i++] = zIdent[j];
        !           816:     if( zIdent[j]=='\'' ) z[i++] = '\'';
        !           817:   }
        !           818:   if( needQuote ) z[i++] = '\'';
        !           819:   z[i] = 0;
        !           820:   *pIdx = i;
        !           821: }
        !           822: 
        !           823: /*
        !           824: ** Generate a CREATE TABLE statement appropriate for the given
        !           825: ** table.  Memory to hold the text of the statement is obtained
        !           826: ** from sqliteMalloc() and must be freed by the calling function.
        !           827: */
        !           828: static char *createTableStmt(Table *p){
        !           829:   int i, k, n;
        !           830:   char *zStmt;
        !           831:   char *zSep, *zSep2, *zEnd;
        !           832:   n = 0;
        !           833:   for(i=0; i<p->nCol; i++){
        !           834:     n += identLength(p->aCol[i].zName);
        !           835:   }
        !           836:   n += identLength(p->zName);
        !           837:   if( n<40 ){
        !           838:     zSep = "";
        !           839:     zSep2 = ",";
        !           840:     zEnd = ")";
        !           841:   }else{
        !           842:     zSep = "\n  ";
        !           843:     zSep2 = ",\n  ";
        !           844:     zEnd = "\n)";
        !           845:   }
        !           846:   n += 35 + 6*p->nCol;
        !           847:   zStmt = sqliteMallocRaw( n );
        !           848:   if( zStmt==0 ) return 0;
        !           849:   strcpy(zStmt, p->iDb==1 ? "CREATE TEMP TABLE " : "CREATE TABLE ");
        !           850:   k = strlen(zStmt);
        !           851:   identPut(zStmt, &k, p->zName);
        !           852:   zStmt[k++] = '(';
        !           853:   for(i=0; i<p->nCol; i++){
        !           854:     strcpy(&zStmt[k], zSep);
        !           855:     k += strlen(&zStmt[k]);
        !           856:     zSep = zSep2;
        !           857:     identPut(zStmt, &k, p->aCol[i].zName);
        !           858:   }
        !           859:   strcpy(&zStmt[k], zEnd);
        !           860:   return zStmt;
        !           861: }
        !           862: 
        !           863: /*
        !           864: ** This routine is called to report the final ")" that terminates
        !           865: ** a CREATE TABLE statement.
        !           866: **
        !           867: ** The table structure that other action routines have been building
        !           868: ** is added to the internal hash tables, assuming no errors have
        !           869: ** occurred.
        !           870: **
        !           871: ** An entry for the table is made in the master table on disk, unless
        !           872: ** this is a temporary table or db->init.busy==1.  When db->init.busy==1
        !           873: ** it means we are reading the sqlite_master table because we just
        !           874: ** connected to the database or because the sqlite_master table has
        !           875: ** recently changes, so the entry for this table already exists in
        !           876: ** the sqlite_master table.  We do not want to create it again.
        !           877: **
        !           878: ** If the pSelect argument is not NULL, it means that this routine
        !           879: ** was called to create a table generated from a 
        !           880: ** "CREATE TABLE ... AS SELECT ..." statement.  The column names of
        !           881: ** the new table will match the result set of the SELECT.
        !           882: */
        !           883: void sqliteEndTable(Parse *pParse, Token *pEnd, Select *pSelect){
        !           884:   Table *p;
        !           885:   sqlite *db = pParse->db;
        !           886: 
        !           887:   if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite_malloc_failed ) return;
        !           888:   p = pParse->pNewTable;
        !           889:   if( p==0 ) return;
        !           890: 
        !           891:   /* If the table is generated from a SELECT, then construct the
        !           892:   ** list of columns and the text of the table.
        !           893:   */
        !           894:   if( pSelect ){
        !           895:     Table *pSelTab = sqliteResultSetOfSelect(pParse, 0, pSelect);
        !           896:     if( pSelTab==0 ) return;
        !           897:     assert( p->aCol==0 );
        !           898:     p->nCol = pSelTab->nCol;
        !           899:     p->aCol = pSelTab->aCol;
        !           900:     pSelTab->nCol = 0;
        !           901:     pSelTab->aCol = 0;
        !           902:     sqliteDeleteTable(0, pSelTab);
        !           903:   }
        !           904: 
        !           905:   /* If the db->init.busy is 1 it means we are reading the SQL off the
        !           906:   ** "sqlite_master" or "sqlite_temp_master" table on the disk.
        !           907:   ** So do not write to the disk again.  Extract the root page number
        !           908:   ** for the table from the db->init.newTnum field.  (The page number
        !           909:   ** should have been put there by the sqliteOpenCb routine.)
        !           910:   */
        !           911:   if( db->init.busy ){
        !           912:     p->tnum = db->init.newTnum;
        !           913:   }
        !           914: 
        !           915:   /* If not initializing, then create a record for the new table
        !           916:   ** in the SQLITE_MASTER table of the database.  The record number
        !           917:   ** for the new table entry should already be on the stack.
        !           918:   **
        !           919:   ** If this is a TEMPORARY table, write the entry into the auxiliary
        !           920:   ** file instead of into the main database file.
        !           921:   */
        !           922:   if( !db->init.busy ){
        !           923:     int n;
        !           924:     Vdbe *v;
        !           925: 
        !           926:     v = sqliteGetVdbe(pParse);
        !           927:     if( v==0 ) return;
        !           928:     if( p->pSelect==0 ){
        !           929:       /* A regular table */
        !           930:       sqliteVdbeOp3(v, OP_CreateTable, 0, p->iDb, (char*)&p->tnum, P3_POINTER);
        !           931:     }else{
        !           932:       /* A view */
        !           933:       sqliteVdbeAddOp(v, OP_Integer, 0, 0);
        !           934:     }
        !           935:     p->tnum = 0;
        !           936:     sqliteVdbeAddOp(v, OP_Pull, 1, 0);
        !           937:     sqliteVdbeOp3(v, OP_String, 0, 0, p->pSelect==0?"table":"view", P3_STATIC);
        !           938:     sqliteVdbeOp3(v, OP_String, 0, 0, p->zName, 0);
        !           939:     sqliteVdbeOp3(v, OP_String, 0, 0, p->zName, 0);
        !           940:     sqliteVdbeAddOp(v, OP_Dup, 4, 0);
        !           941:     sqliteVdbeAddOp(v, OP_String, 0, 0);
        !           942:     if( pSelect ){
        !           943:       char *z = createTableStmt(p);
        !           944:       n = z ? strlen(z) : 0;
        !           945:       sqliteVdbeChangeP3(v, -1, z, n);
        !           946:       sqliteFree(z);
        !           947:     }else{
        !           948:       assert( pEnd!=0 );
        !           949:       n = Addr(pEnd->z) - Addr(pParse->sFirstToken.z) + 1;
        !           950:       sqliteVdbeChangeP3(v, -1, pParse->sFirstToken.z, n);
        !           951:     }
        !           952:     sqliteVdbeAddOp(v, OP_MakeRecord, 5, 0);
        !           953:     sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0);
        !           954:     if( !p->iDb ){
        !           955:       sqliteChangeCookie(db, v);
        !           956:     }
        !           957:     sqliteVdbeAddOp(v, OP_Close, 0, 0);
        !           958:     if( pSelect ){
        !           959:       sqliteVdbeAddOp(v, OP_Integer, p->iDb, 0);
        !           960:       sqliteVdbeAddOp(v, OP_OpenWrite, 1, 0);
        !           961:       pParse->nTab = 2;
        !           962:       sqliteSelect(pParse, pSelect, SRT_Table, 1, 0, 0, 0);
        !           963:     }
        !           964:     sqliteEndWriteOperation(pParse);
        !           965:   }
        !           966: 
        !           967:   /* Add the table to the in-memory representation of the database.
        !           968:   */
        !           969:   if( pParse->explain==0 && pParse->nErr==0 ){
        !           970:     Table *pOld;
        !           971:     FKey *pFKey;
        !           972:     pOld = sqliteHashInsert(&db->aDb[p->iDb].tblHash, 
        !           973:                             p->zName, strlen(p->zName)+1, p);
        !           974:     if( pOld ){
        !           975:       assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
        !           976:       return;
        !           977:     }
        !           978:     for(pFKey=p->pFKey; pFKey; pFKey=pFKey->pNextFrom){
        !           979:       int nTo = strlen(pFKey->zTo) + 1;
        !           980:       pFKey->pNextTo = sqliteHashFind(&db->aDb[p->iDb].aFKey, pFKey->zTo, nTo);
        !           981:       sqliteHashInsert(&db->aDb[p->iDb].aFKey, pFKey->zTo, nTo, pFKey);
        !           982:     }
        !           983:     pParse->pNewTable = 0;
        !           984:     db->nTable++;
        !           985:     db->flags |= SQLITE_InternChanges;
        !           986:   }
        !           987: }
        !           988: 
        !           989: /*
        !           990: ** The parser calls this routine in order to create a new VIEW
        !           991: */
        !           992: void sqliteCreateView(
        !           993:   Parse *pParse,     /* The parsing context */
        !           994:   Token *pBegin,     /* The CREATE token that begins the statement */
        !           995:   Token *pName,      /* The token that holds the name of the view */
        !           996:   Select *pSelect,   /* A SELECT statement that will become the new view */
        !           997:   int isTemp         /* TRUE for a TEMPORARY view */
        !           998: ){
        !           999:   Table *p;
        !          1000:   int n;
        !          1001:   const char *z;
        !          1002:   Token sEnd;
        !          1003:   DbFixer sFix;
        !          1004: 
        !          1005:   sqliteStartTable(pParse, pBegin, pName, isTemp, 1);
        !          1006:   p = pParse->pNewTable;
        !          1007:   if( p==0 || pParse->nErr ){
        !          1008:     sqliteSelectDelete(pSelect);
        !          1009:     return;
        !          1010:   }
        !          1011:   if( sqliteFixInit(&sFix, pParse, p->iDb, "view", pName)
        !          1012:     && sqliteFixSelect(&sFix, pSelect)
        !          1013:   ){
        !          1014:     sqliteSelectDelete(pSelect);
        !          1015:     return;
        !          1016:   }
        !          1017: 
        !          1018:   /* Make a copy of the entire SELECT statement that defines the view.
        !          1019:   ** This will force all the Expr.token.z values to be dynamically
        !          1020:   ** allocated rather than point to the input string - which means that
        !          1021:   ** they will persist after the current sqlite_exec() call returns.
        !          1022:   */
        !          1023:   p->pSelect = sqliteSelectDup(pSelect);
        !          1024:   sqliteSelectDelete(pSelect);
        !          1025:   if( !pParse->db->init.busy ){
        !          1026:     sqliteViewGetColumnNames(pParse, p);
        !          1027:   }
        !          1028: 
        !          1029:   /* Locate the end of the CREATE VIEW statement.  Make sEnd point to
        !          1030:   ** the end.
        !          1031:   */
        !          1032:   sEnd = pParse->sLastToken;
        !          1033:   if( sEnd.z[0]!=0 && sEnd.z[0]!=';' ){
        !          1034:     sEnd.z += sEnd.n;
        !          1035:   }
        !          1036:   sEnd.n = 0;
        !          1037:   n = sEnd.z - pBegin->z;
        !          1038:   z = pBegin->z;
        !          1039:   while( n>0 && (z[n-1]==';' || isspace(z[n-1])) ){ n--; }
        !          1040:   sEnd.z = &z[n-1];
        !          1041:   sEnd.n = 1;
        !          1042: 
        !          1043:   /* Use sqliteEndTable() to add the view to the SQLITE_MASTER table */
        !          1044:   sqliteEndTable(pParse, &sEnd, 0);
        !          1045:   return;
        !          1046: }
        !          1047: 
        !          1048: /*
        !          1049: ** The Table structure pTable is really a VIEW.  Fill in the names of
        !          1050: ** the columns of the view in the pTable structure.  Return the number
        !          1051: ** of errors.  If an error is seen leave an error message in pParse->zErrMsg.
        !          1052: */
        !          1053: int sqliteViewGetColumnNames(Parse *pParse, Table *pTable){
        !          1054:   ExprList *pEList;
        !          1055:   Select *pSel;
        !          1056:   Table *pSelTab;
        !          1057:   int nErr = 0;
        !          1058: 
        !          1059:   assert( pTable );
        !          1060: 
        !          1061:   /* A positive nCol means the columns names for this view are
        !          1062:   ** already known.
        !          1063:   */
        !          1064:   if( pTable->nCol>0 ) return 0;
        !          1065: 
        !          1066:   /* A negative nCol is a special marker meaning that we are currently
        !          1067:   ** trying to compute the column names.  If we enter this routine with
        !          1068:   ** a negative nCol, it means two or more views form a loop, like this:
        !          1069:   **
        !          1070:   **     CREATE VIEW one AS SELECT * FROM two;
        !          1071:   **     CREATE VIEW two AS SELECT * FROM one;
        !          1072:   **
        !          1073:   ** Actually, this error is caught previously and so the following test
        !          1074:   ** should always fail.  But we will leave it in place just to be safe.
        !          1075:   */
        !          1076:   if( pTable->nCol<0 ){
        !          1077:     sqliteErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
        !          1078:     return 1;
        !          1079:   }
        !          1080: 
        !          1081:   /* If we get this far, it means we need to compute the table names.
        !          1082:   */
        !          1083:   assert( pTable->pSelect ); /* If nCol==0, then pTable must be a VIEW */
        !          1084:   pSel = pTable->pSelect;
        !          1085: 
        !          1086:   /* Note that the call to sqliteResultSetOfSelect() will expand any
        !          1087:   ** "*" elements in this list.  But we will need to restore the list
        !          1088:   ** back to its original configuration afterwards, so we save a copy of
        !          1089:   ** the original in pEList.
        !          1090:   */
        !          1091:   pEList = pSel->pEList;
        !          1092:   pSel->pEList = sqliteExprListDup(pEList);
        !          1093:   if( pSel->pEList==0 ){
        !          1094:     pSel->pEList = pEList;
        !          1095:     return 1;  /* Malloc failed */
        !          1096:   }
        !          1097:   pTable->nCol = -1;
        !          1098:   pSelTab = sqliteResultSetOfSelect(pParse, 0, pSel);
        !          1099:   if( pSelTab ){
        !          1100:     assert( pTable->aCol==0 );
        !          1101:     pTable->nCol = pSelTab->nCol;
        !          1102:     pTable->aCol = pSelTab->aCol;
        !          1103:     pSelTab->nCol = 0;
        !          1104:     pSelTab->aCol = 0;
        !          1105:     sqliteDeleteTable(0, pSelTab);
        !          1106:     DbSetProperty(pParse->db, pTable->iDb, DB_UnresetViews);
        !          1107:   }else{
        !          1108:     pTable->nCol = 0;
        !          1109:     nErr++;
        !          1110:   }
        !          1111:   sqliteSelectUnbind(pSel);
        !          1112:   sqliteExprListDelete(pSel->pEList);
        !          1113:   pSel->pEList = pEList;
        !          1114:   return nErr;  
        !          1115: }
        !          1116: 
        !          1117: /*
        !          1118: ** Clear the column names from the VIEW pTable.
        !          1119: **
        !          1120: ** This routine is called whenever any other table or view is modified.
        !          1121: ** The view passed into this routine might depend directly or indirectly
        !          1122: ** on the modified or deleted table so we need to clear the old column
        !          1123: ** names so that they will be recomputed.
        !          1124: */
        !          1125: static void sqliteViewResetColumnNames(Table *pTable){
        !          1126:   int i;
        !          1127:   Column *pCol;
        !          1128:   assert( pTable!=0 && pTable->pSelect!=0 );
        !          1129:   for(i=0, pCol=pTable->aCol; i<pTable->nCol; i++, pCol++){
        !          1130:     sqliteFree(pCol->zName);
        !          1131:     sqliteFree(pCol->zDflt);
        !          1132:     sqliteFree(pCol->zType);
        !          1133:   }
        !          1134:   sqliteFree(pTable->aCol);
        !          1135:   pTable->aCol = 0;
        !          1136:   pTable->nCol = 0;
        !          1137: }
        !          1138: 
        !          1139: /*
        !          1140: ** Clear the column names from every VIEW in database idx.
        !          1141: */
        !          1142: static void sqliteViewResetAll(sqlite *db, int idx){
        !          1143:   HashElem *i;
        !          1144:   if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
        !          1145:   for(i=sqliteHashFirst(&db->aDb[idx].tblHash); i; i=sqliteHashNext(i)){
        !          1146:     Table *pTab = sqliteHashData(i);
        !          1147:     if( pTab->pSelect ){
        !          1148:       sqliteViewResetColumnNames(pTab);
        !          1149:     }
        !          1150:   }
        !          1151:   DbClearProperty(db, idx, DB_UnresetViews);
        !          1152: }
        !          1153: 
        !          1154: /*
        !          1155: ** Given a token, look up a table with that name.  If not found, leave
        !          1156: ** an error for the parser to find and return NULL.
        !          1157: */
        !          1158: Table *sqliteTableFromToken(Parse *pParse, Token *pTok){
        !          1159:   char *zName;
        !          1160:   Table *pTab;
        !          1161:   zName = sqliteTableNameFromToken(pTok);
        !          1162:   if( zName==0 ) return 0;
        !          1163:   pTab = sqliteFindTable(pParse->db, zName, 0);
        !          1164:   sqliteFree(zName);
        !          1165:   if( pTab==0 ){
        !          1166:     sqliteErrorMsg(pParse, "no such table: %T", pTok);
        !          1167:   }
        !          1168:   return pTab;
        !          1169: }
        !          1170: 
        !          1171: /*
        !          1172: ** This routine is called to do the work of a DROP TABLE statement.
        !          1173: ** pName is the name of the table to be dropped.
        !          1174: */
        !          1175: void sqliteDropTable(Parse *pParse, Token *pName, int isView){
        !          1176:   Table *pTable;
        !          1177:   Vdbe *v;
        !          1178:   int base;
        !          1179:   sqlite *db = pParse->db;
        !          1180:   int iDb;
        !          1181: 
        !          1182:   if( pParse->nErr || sqlite_malloc_failed ) return;
        !          1183:   pTable = sqliteTableFromToken(pParse, pName);
        !          1184:   if( pTable==0 ) return;
        !          1185:   iDb = pTable->iDb;
        !          1186:   assert( iDb>=0 && iDb<db->nDb );
        !          1187: #ifndef SQLITE_OMIT_AUTHORIZATION
        !          1188:   {
        !          1189:     int code;
        !          1190:     const char *zTab = SCHEMA_TABLE(pTable->iDb);
        !          1191:     const char *zDb = db->aDb[pTable->iDb].zName;
        !          1192:     if( sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
        !          1193:       return;
        !          1194:     }
        !          1195:     if( isView ){
        !          1196:       if( iDb==1 ){
        !          1197:         code = SQLITE_DROP_TEMP_VIEW;
        !          1198:       }else{
        !          1199:         code = SQLITE_DROP_VIEW;
        !          1200:       }
        !          1201:     }else{
        !          1202:       if( iDb==1 ){
        !          1203:         code = SQLITE_DROP_TEMP_TABLE;
        !          1204:       }else{
        !          1205:         code = SQLITE_DROP_TABLE;
        !          1206:       }
        !          1207:     }
        !          1208:     if( sqliteAuthCheck(pParse, code, pTable->zName, 0, zDb) ){
        !          1209:       return;
        !          1210:     }
        !          1211:     if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTable->zName, 0, zDb) ){
        !          1212:       return;
        !          1213:     }
        !          1214:   }
        !          1215: #endif
        !          1216:   if( pTable->readOnly ){
        !          1217:     sqliteErrorMsg(pParse, "table %s may not be dropped", pTable->zName);
        !          1218:     pParse->nErr++;
        !          1219:     return;
        !          1220:   }
        !          1221:   if( isView && pTable->pSelect==0 ){
        !          1222:     sqliteErrorMsg(pParse, "use DROP TABLE to delete table %s", pTable->zName);
        !          1223:     return;
        !          1224:   }
        !          1225:   if( !isView && pTable->pSelect ){
        !          1226:     sqliteErrorMsg(pParse, "use DROP VIEW to delete view %s", pTable->zName);
        !          1227:     return;
        !          1228:   }
        !          1229: 
        !          1230:   /* Generate code to remove the table from the master table
        !          1231:   ** on disk.
        !          1232:   */
        !          1233:   v = sqliteGetVdbe(pParse);
        !          1234:   if( v ){
        !          1235:     static VdbeOpList dropTable[] = {
        !          1236:       { OP_Rewind,     0, ADDR(8),  0},
        !          1237:       { OP_String,     0, 0,        0}, /* 1 */
        !          1238:       { OP_MemStore,   1, 1,        0},
        !          1239:       { OP_MemLoad,    1, 0,        0}, /* 3 */
        !          1240:       { OP_Column,     0, 2,        0},
        !          1241:       { OP_Ne,         0, ADDR(7),  0},
        !          1242:       { OP_Delete,     0, 0,        0},
        !          1243:       { OP_Next,       0, ADDR(3),  0}, /* 7 */
        !          1244:     };
        !          1245:     Index *pIdx;
        !          1246:     Trigger *pTrigger;
        !          1247:     sqliteBeginWriteOperation(pParse, 0, pTable->iDb);
        !          1248: 
        !          1249:     /* Drop all triggers associated with the table being dropped */
        !          1250:     pTrigger = pTable->pTrigger;
        !          1251:     while( pTrigger ){
        !          1252:       assert( pTrigger->iDb==pTable->iDb || pTrigger->iDb==1 );
        !          1253:       sqliteDropTriggerPtr(pParse, pTrigger, 1);
        !          1254:       if( pParse->explain ){
        !          1255:         pTrigger = pTrigger->pNext;
        !          1256:       }else{
        !          1257:         pTrigger = pTable->pTrigger;
        !          1258:       }
        !          1259:     }
        !          1260: 
        !          1261:     /* Drop all SQLITE_MASTER entries that refer to the table */
        !          1262:     sqliteOpenMasterTable(v, pTable->iDb);
        !          1263:     base = sqliteVdbeAddOpList(v, ArraySize(dropTable), dropTable);
        !          1264:     sqliteVdbeChangeP3(v, base+1, pTable->zName, 0);
        !          1265: 
        !          1266:     /* Drop all SQLITE_TEMP_MASTER entries that refer to the table */
        !          1267:     if( pTable->iDb!=1 ){
        !          1268:       sqliteOpenMasterTable(v, 1);
        !          1269:       base = sqliteVdbeAddOpList(v, ArraySize(dropTable), dropTable);
        !          1270:       sqliteVdbeChangeP3(v, base+1, pTable->zName, 0);
        !          1271:     }
        !          1272: 
        !          1273:     if( pTable->iDb==0 ){
        !          1274:       sqliteChangeCookie(db, v);
        !          1275:     }
        !          1276:     sqliteVdbeAddOp(v, OP_Close, 0, 0);
        !          1277:     if( !isView ){
        !          1278:       sqliteVdbeAddOp(v, OP_Destroy, pTable->tnum, pTable->iDb);
        !          1279:       for(pIdx=pTable->pIndex; pIdx; pIdx=pIdx->pNext){
        !          1280:         sqliteVdbeAddOp(v, OP_Destroy, pIdx->tnum, pIdx->iDb);
        !          1281:       }
        !          1282:     }
        !          1283:     sqliteEndWriteOperation(pParse);
        !          1284:   }
        !          1285: 
        !          1286:   /* Delete the in-memory description of the table.
        !          1287:   **
        !          1288:   ** Exception: if the SQL statement began with the EXPLAIN keyword,
        !          1289:   ** then no changes should be made.
        !          1290:   */
        !          1291:   if( !pParse->explain ){
        !          1292:     sqliteUnlinkAndDeleteTable(db, pTable);
        !          1293:     db->flags |= SQLITE_InternChanges;
        !          1294:   }
        !          1295:   sqliteViewResetAll(db, iDb);
        !          1296: }
        !          1297: 
        !          1298: /*
        !          1299: ** This routine constructs a P3 string suitable for an OP_MakeIdxKey
        !          1300: ** opcode and adds that P3 string to the most recently inserted instruction
        !          1301: ** in the virtual machine.  The P3 string consists of a single character
        !          1302: ** for each column in the index pIdx of table pTab.  If the column uses
        !          1303: ** a numeric sort order, then the P3 string character corresponding to
        !          1304: ** that column is 'n'.  If the column uses a text sort order, then the
        !          1305: ** P3 string is 't'.  See the OP_MakeIdxKey opcode documentation for
        !          1306: ** additional information.  See also the sqliteAddKeyType() routine.
        !          1307: */
        !          1308: void sqliteAddIdxKeyType(Vdbe *v, Index *pIdx){
        !          1309:   char *zType;
        !          1310:   Table *pTab;
        !          1311:   int i, n;
        !          1312:   assert( pIdx!=0 && pIdx->pTable!=0 );
        !          1313:   pTab = pIdx->pTable;
        !          1314:   n = pIdx->nColumn;
        !          1315:   zType = sqliteMallocRaw( n+1 );
        !          1316:   if( zType==0 ) return;
        !          1317:   for(i=0; i<n; i++){
        !          1318:     int iCol = pIdx->aiColumn[i];
        !          1319:     assert( iCol>=0 && iCol<pTab->nCol );
        !          1320:     if( (pTab->aCol[iCol].sortOrder & SQLITE_SO_TYPEMASK)==SQLITE_SO_TEXT ){
        !          1321:       zType[i] = 't';
        !          1322:     }else{
        !          1323:       zType[i] = 'n';
        !          1324:     }
        !          1325:   }
        !          1326:   zType[n] = 0;
        !          1327:   sqliteVdbeChangeP3(v, -1, zType, n);
        !          1328:   sqliteFree(zType);
        !          1329: }
        !          1330: 
        !          1331: /*
        !          1332: ** This routine is called to create a new foreign key on the table
        !          1333: ** currently under construction.  pFromCol determines which columns
        !          1334: ** in the current table point to the foreign key.  If pFromCol==0 then
        !          1335: ** connect the key to the last column inserted.  pTo is the name of
        !          1336: ** the table referred to.  pToCol is a list of tables in the other
        !          1337: ** pTo table that the foreign key points to.  flags contains all
        !          1338: ** information about the conflict resolution algorithms specified
        !          1339: ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
        !          1340: **
        !          1341: ** An FKey structure is created and added to the table currently
        !          1342: ** under construction in the pParse->pNewTable field.  The new FKey
        !          1343: ** is not linked into db->aFKey at this point - that does not happen
        !          1344: ** until sqliteEndTable().
        !          1345: **
        !          1346: ** The foreign key is set for IMMEDIATE processing.  A subsequent call
        !          1347: ** to sqliteDeferForeignKey() might change this to DEFERRED.
        !          1348: */
        !          1349: void sqliteCreateForeignKey(
        !          1350:   Parse *pParse,       /* Parsing context */
        !          1351:   IdList *pFromCol,    /* Columns in this table that point to other table */
        !          1352:   Token *pTo,          /* Name of the other table */
        !          1353:   IdList *pToCol,      /* Columns in the other table */
        !          1354:   int flags            /* Conflict resolution algorithms. */
        !          1355: ){
        !          1356:   Table *p = pParse->pNewTable;
        !          1357:   int nByte;
        !          1358:   int i;
        !          1359:   int nCol;
        !          1360:   char *z;
        !          1361:   FKey *pFKey = 0;
        !          1362: 
        !          1363:   assert( pTo!=0 );
        !          1364:   if( p==0 || pParse->nErr ) goto fk_end;
        !          1365:   if( pFromCol==0 ){
        !          1366:     int iCol = p->nCol-1;
        !          1367:     if( iCol<0 ) goto fk_end;
        !          1368:     if( pToCol && pToCol->nId!=1 ){
        !          1369:       sqliteErrorMsg(pParse, "foreign key on %s"
        !          1370:          " should reference only one column of table %T",
        !          1371:          p->aCol[iCol].zName, pTo);
        !          1372:       goto fk_end;
        !          1373:     }
        !          1374:     nCol = 1;
        !          1375:   }else if( pToCol && pToCol->nId!=pFromCol->nId ){
        !          1376:     sqliteErrorMsg(pParse,
        !          1377:         "number of columns in foreign key does not match the number of "
        !          1378:         "columns in the referenced table");
        !          1379:     goto fk_end;
        !          1380:   }else{
        !          1381:     nCol = pFromCol->nId;
        !          1382:   }
        !          1383:   nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1;
        !          1384:   if( pToCol ){
        !          1385:     for(i=0; i<pToCol->nId; i++){
        !          1386:       nByte += strlen(pToCol->a[i].zName) + 1;
        !          1387:     }
        !          1388:   }
        !          1389:   pFKey = sqliteMalloc( nByte );
        !          1390:   if( pFKey==0 ) goto fk_end;
        !          1391:   pFKey->pFrom = p;
        !          1392:   pFKey->pNextFrom = p->pFKey;
        !          1393:   z = (char*)&pFKey[1];
        !          1394:   pFKey->aCol = (struct sColMap*)z;
        !          1395:   z += sizeof(struct sColMap)*nCol;
        !          1396:   pFKey->zTo = z;
        !          1397:   memcpy(z, pTo->z, pTo->n);
        !          1398:   z[pTo->n] = 0;
        !          1399:   z += pTo->n+1;
        !          1400:   pFKey->pNextTo = 0;
        !          1401:   pFKey->nCol = nCol;
        !          1402:   if( pFromCol==0 ){
        !          1403:     pFKey->aCol[0].iFrom = p->nCol-1;
        !          1404:   }else{
        !          1405:     for(i=0; i<nCol; i++){
        !          1406:       int j;
        !          1407:       for(j=0; j<p->nCol; j++){
        !          1408:         if( sqliteStrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
        !          1409:           pFKey->aCol[i].iFrom = j;
        !          1410:           break;
        !          1411:         }
        !          1412:       }
        !          1413:       if( j>=p->nCol ){
        !          1414:         sqliteErrorMsg(pParse, 
        !          1415:           "unknown column \"%s\" in foreign key definition", 
        !          1416:           pFromCol->a[i].zName);
        !          1417:         goto fk_end;
        !          1418:       }
        !          1419:     }
        !          1420:   }
        !          1421:   if( pToCol ){
        !          1422:     for(i=0; i<nCol; i++){
        !          1423:       int n = strlen(pToCol->a[i].zName);
        !          1424:       pFKey->aCol[i].zCol = z;
        !          1425:       memcpy(z, pToCol->a[i].zName, n);
        !          1426:       z[n] = 0;
        !          1427:       z += n+1;
        !          1428:     }
        !          1429:   }
        !          1430:   pFKey->isDeferred = 0;
        !          1431:   pFKey->deleteConf = flags & 0xff;
        !          1432:   pFKey->updateConf = (flags >> 8 ) & 0xff;
        !          1433:   pFKey->insertConf = (flags >> 16 ) & 0xff;
        !          1434: 
        !          1435:   /* Link the foreign key to the table as the last step.
        !          1436:   */
        !          1437:   p->pFKey = pFKey;
        !          1438:   pFKey = 0;
        !          1439: 
        !          1440: fk_end:
        !          1441:   sqliteFree(pFKey);
        !          1442:   sqliteIdListDelete(pFromCol);
        !          1443:   sqliteIdListDelete(pToCol);
        !          1444: }
        !          1445: 
        !          1446: /*
        !          1447: ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
        !          1448: ** clause is seen as part of a foreign key definition.  The isDeferred
        !          1449: ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
        !          1450: ** The behavior of the most recently created foreign key is adjusted
        !          1451: ** accordingly.
        !          1452: */
        !          1453: void sqliteDeferForeignKey(Parse *pParse, int isDeferred){
        !          1454:   Table *pTab;
        !          1455:   FKey *pFKey;
        !          1456:   if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
        !          1457:   pFKey->isDeferred = isDeferred;
        !          1458: }
        !          1459: 
        !          1460: /*
        !          1461: ** Create a new index for an SQL table.  pIndex is the name of the index 
        !          1462: ** and pTable is the name of the table that is to be indexed.  Both will 
        !          1463: ** be NULL for a primary key or an index that is created to satisfy a
        !          1464: ** UNIQUE constraint.  If pTable and pIndex are NULL, use pParse->pNewTable
        !          1465: ** as the table to be indexed.  pParse->pNewTable is a table that is
        !          1466: ** currently being constructed by a CREATE TABLE statement.
        !          1467: **
        !          1468: ** pList is a list of columns to be indexed.  pList will be NULL if this
        !          1469: ** is a primary key or unique-constraint on the most recent column added
        !          1470: ** to the table currently under construction.  
        !          1471: */
        !          1472: void sqliteCreateIndex(
        !          1473:   Parse *pParse,   /* All information about this parse */
        !          1474:   Token *pName,    /* Name of the index.  May be NULL */
        !          1475:   SrcList *pTable, /* Name of the table to index.  Use pParse->pNewTable if 0 */
        !          1476:   IdList *pList,   /* A list of columns to be indexed */
        !          1477:   int onError,     /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
        !          1478:   Token *pStart,   /* The CREATE token that begins a CREATE TABLE statement */
        !          1479:   Token *pEnd      /* The ")" that closes the CREATE INDEX statement */
        !          1480: ){
        !          1481:   Table *pTab;     /* Table to be indexed */
        !          1482:   Index *pIndex;   /* The index to be created */
        !          1483:   char *zName = 0;
        !          1484:   int i, j;
        !          1485:   Token nullId;    /* Fake token for an empty ID list */
        !          1486:   DbFixer sFix;    /* For assigning database names to pTable */
        !          1487:   int isTemp;      /* True for a temporary index */
        !          1488:   sqlite *db = pParse->db;
        !          1489: 
        !          1490:   if( pParse->nErr || sqlite_malloc_failed ) goto exit_create_index;
        !          1491:   if( db->init.busy 
        !          1492:      && sqliteFixInit(&sFix, pParse, db->init.iDb, "index", pName)
        !          1493:      && sqliteFixSrcList(&sFix, pTable)
        !          1494:   ){
        !          1495:     goto exit_create_index;
        !          1496:   }
        !          1497: 
        !          1498:   /*
        !          1499:   ** Find the table that is to be indexed.  Return early if not found.
        !          1500:   */
        !          1501:   if( pTable!=0 ){
        !          1502:     assert( pName!=0 );
        !          1503:     assert( pTable->nSrc==1 );
        !          1504:     pTab =  sqliteSrcListLookup(pParse, pTable);
        !          1505:   }else{
        !          1506:     assert( pName==0 );
        !          1507:     pTab =  pParse->pNewTable;
        !          1508:   }
        !          1509:   if( pTab==0 || pParse->nErr ) goto exit_create_index;
        !          1510:   if( pTab->readOnly ){
        !          1511:     sqliteErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
        !          1512:     goto exit_create_index;
        !          1513:   }
        !          1514:   if( pTab->iDb>=2 && db->init.busy==0 ){
        !          1515:     sqliteErrorMsg(pParse, "table %s may not have indices added", pTab->zName);
        !          1516:     goto exit_create_index;
        !          1517:   }
        !          1518:   if( pTab->pSelect ){
        !          1519:     sqliteErrorMsg(pParse, "views may not be indexed");
        !          1520:     goto exit_create_index;
        !          1521:   }
        !          1522:   isTemp = pTab->iDb==1;
        !          1523: 
        !          1524:   /*
        !          1525:   ** Find the name of the index.  Make sure there is not already another
        !          1526:   ** index or table with the same name.  
        !          1527:   **
        !          1528:   ** Exception:  If we are reading the names of permanent indices from the
        !          1529:   ** sqlite_master table (because some other process changed the schema) and
        !          1530:   ** one of the index names collides with the name of a temporary table or
        !          1531:   ** index, then we will continue to process this index.
        !          1532:   **
        !          1533:   ** If pName==0 it means that we are
        !          1534:   ** dealing with a primary key or UNIQUE constraint.  We have to invent our
        !          1535:   ** own name.
        !          1536:   */
        !          1537:   if( pName && !db->init.busy ){
        !          1538:     Index *pISameName;    /* Another index with the same name */
        !          1539:     Table *pTSameName;    /* A table with same name as the index */
        !          1540:     zName = sqliteTableNameFromToken(pName);
        !          1541:     if( zName==0 ) goto exit_create_index;
        !          1542:     if( (pISameName = sqliteFindIndex(db, zName, 0))!=0 ){
        !          1543:       sqliteErrorMsg(pParse, "index %s already exists", zName);
        !          1544:       goto exit_create_index;
        !          1545:     }
        !          1546:     if( (pTSameName = sqliteFindTable(db, zName, 0))!=0 ){
        !          1547:       sqliteErrorMsg(pParse, "there is already a table named %s", zName);
        !          1548:       goto exit_create_index;
        !          1549:     }
        !          1550:   }else if( pName==0 ){
        !          1551:     char zBuf[30];
        !          1552:     int n;
        !          1553:     Index *pLoop;
        !          1554:     for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
        !          1555:     sprintf(zBuf,"%d)",n);
        !          1556:     zName = 0;
        !          1557:     sqliteSetString(&zName, "(", pTab->zName, " autoindex ", zBuf, (char*)0);
        !          1558:     if( zName==0 ) goto exit_create_index;
        !          1559:   }else{
        !          1560:     zName = sqliteTableNameFromToken(pName);
        !          1561:   }
        !          1562: 
        !          1563:   /* Check for authorization to create an index.
        !          1564:   */
        !          1565: #ifndef SQLITE_OMIT_AUTHORIZATION
        !          1566:   {
        !          1567:     const char *zDb = db->aDb[pTab->iDb].zName;
        !          1568: 
        !          1569:     assert( pTab->iDb==db->init.iDb || isTemp );
        !          1570:     if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
        !          1571:       goto exit_create_index;
        !          1572:     }
        !          1573:     i = SQLITE_CREATE_INDEX;
        !          1574:     if( isTemp ) i = SQLITE_CREATE_TEMP_INDEX;
        !          1575:     if( sqliteAuthCheck(pParse, i, zName, pTab->zName, zDb) ){
        !          1576:       goto exit_create_index;
        !          1577:     }
        !          1578:   }
        !          1579: #endif
        !          1580: 
        !          1581:   /* If pList==0, it means this routine was called to make a primary
        !          1582:   ** key out of the last column added to the table under construction.
        !          1583:   ** So create a fake list to simulate this.
        !          1584:   */
        !          1585:   if( pList==0 ){
        !          1586:     nullId.z = pTab->aCol[pTab->nCol-1].zName;
        !          1587:     nullId.n = strlen(nullId.z);
        !          1588:     pList = sqliteIdListAppend(0, &nullId);
        !          1589:     if( pList==0 ) goto exit_create_index;
        !          1590:   }
        !          1591: 
        !          1592:   /* 
        !          1593:   ** Allocate the index structure. 
        !          1594:   */
        !          1595:   pIndex = sqliteMalloc( sizeof(Index) + strlen(zName) + 1 +
        !          1596:                         sizeof(int)*pList->nId );
        !          1597:   if( pIndex==0 ) goto exit_create_index;
        !          1598:   pIndex->aiColumn = (int*)&pIndex[1];
        !          1599:   pIndex->zName = (char*)&pIndex->aiColumn[pList->nId];
        !          1600:   strcpy(pIndex->zName, zName);
        !          1601:   pIndex->pTable = pTab;
        !          1602:   pIndex->nColumn = pList->nId;
        !          1603:   pIndex->onError = onError;
        !          1604:   pIndex->autoIndex = pName==0;
        !          1605:   pIndex->iDb = isTemp ? 1 : db->init.iDb;
        !          1606: 
        !          1607:   /* Scan the names of the columns of the table to be indexed and
        !          1608:   ** load the column indices into the Index structure.  Report an error
        !          1609:   ** if any column is not found.
        !          1610:   */
        !          1611:   for(i=0; i<pList->nId; i++){
        !          1612:     for(j=0; j<pTab->nCol; j++){
        !          1613:       if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[j].zName)==0 ) break;
        !          1614:     }
        !          1615:     if( j>=pTab->nCol ){
        !          1616:       sqliteErrorMsg(pParse, "table %s has no column named %s",
        !          1617:         pTab->zName, pList->a[i].zName);
        !          1618:       sqliteFree(pIndex);
        !          1619:       goto exit_create_index;
        !          1620:     }
        !          1621:     pIndex->aiColumn[i] = j;
        !          1622:   }
        !          1623: 
        !          1624:   /* Link the new Index structure to its table and to the other
        !          1625:   ** in-memory database structures. 
        !          1626:   */
        !          1627:   if( !pParse->explain ){
        !          1628:     Index *p;
        !          1629:     p = sqliteHashInsert(&db->aDb[pIndex->iDb].idxHash, 
        !          1630:                          pIndex->zName, strlen(pIndex->zName)+1, pIndex);
        !          1631:     if( p ){
        !          1632:       assert( p==pIndex );  /* Malloc must have failed */
        !          1633:       sqliteFree(pIndex);
        !          1634:       goto exit_create_index;
        !          1635:     }
        !          1636:     db->flags |= SQLITE_InternChanges;
        !          1637:   }
        !          1638: 
        !          1639:   /* When adding an index to the list of indices for a table, make
        !          1640:   ** sure all indices labeled OE_Replace come after all those labeled
        !          1641:   ** OE_Ignore.  This is necessary for the correct operation of UPDATE
        !          1642:   ** and INSERT.
        !          1643:   */
        !          1644:   if( onError!=OE_Replace || pTab->pIndex==0
        !          1645:        || pTab->pIndex->onError==OE_Replace){
        !          1646:     pIndex->pNext = pTab->pIndex;
        !          1647:     pTab->pIndex = pIndex;
        !          1648:   }else{
        !          1649:     Index *pOther = pTab->pIndex;
        !          1650:     while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
        !          1651:       pOther = pOther->pNext;
        !          1652:     }
        !          1653:     pIndex->pNext = pOther->pNext;
        !          1654:     pOther->pNext = pIndex;
        !          1655:   }
        !          1656: 
        !          1657:   /* If the db->init.busy is 1 it means we are reading the SQL off the
        !          1658:   ** "sqlite_master" table on the disk.  So do not write to the disk
        !          1659:   ** again.  Extract the table number from the db->init.newTnum field.
        !          1660:   */
        !          1661:   if( db->init.busy && pTable!=0 ){
        !          1662:     pIndex->tnum = db->init.newTnum;
        !          1663:   }
        !          1664: 
        !          1665:   /* If the db->init.busy is 0 then create the index on disk.  This
        !          1666:   ** involves writing the index into the master table and filling in the
        !          1667:   ** index with the current table contents.
        !          1668:   **
        !          1669:   ** The db->init.busy is 0 when the user first enters a CREATE INDEX 
        !          1670:   ** command.  db->init.busy is 1 when a database is opened and 
        !          1671:   ** CREATE INDEX statements are read out of the master table.  In
        !          1672:   ** the latter case the index already exists on disk, which is why
        !          1673:   ** we don't want to recreate it.
        !          1674:   **
        !          1675:   ** If pTable==0 it means this index is generated as a primary key
        !          1676:   ** or UNIQUE constraint of a CREATE TABLE statement.  Since the table
        !          1677:   ** has just been created, it contains no data and the index initialization
        !          1678:   ** step can be skipped.
        !          1679:   */
        !          1680:   else if( db->init.busy==0 ){
        !          1681:     int n;
        !          1682:     Vdbe *v;
        !          1683:     int lbl1, lbl2;
        !          1684:     int i;
        !          1685:     int addr;
        !          1686: 
        !          1687:     v = sqliteGetVdbe(pParse);
        !          1688:     if( v==0 ) goto exit_create_index;
        !          1689:     if( pTable!=0 ){
        !          1690:       sqliteBeginWriteOperation(pParse, 0, isTemp);
        !          1691:       sqliteOpenMasterTable(v, isTemp);
        !          1692:     }
        !          1693:     sqliteVdbeAddOp(v, OP_NewRecno, 0, 0);
        !          1694:     sqliteVdbeOp3(v, OP_String, 0, 0, "index", P3_STATIC);
        !          1695:     sqliteVdbeOp3(v, OP_String, 0, 0, pIndex->zName, 0);
        !          1696:     sqliteVdbeOp3(v, OP_String, 0, 0, pTab->zName, 0);
        !          1697:     sqliteVdbeOp3(v, OP_CreateIndex, 0, isTemp,(char*)&pIndex->tnum,P3_POINTER);
        !          1698:     pIndex->tnum = 0;
        !          1699:     if( pTable ){
        !          1700:       sqliteVdbeCode(v,
        !          1701:           OP_Dup,       0,      0,
        !          1702:           OP_Integer,   isTemp, 0,
        !          1703:           OP_OpenWrite, 1,      0,
        !          1704:       0);
        !          1705:     }
        !          1706:     addr = sqliteVdbeAddOp(v, OP_String, 0, 0);
        !          1707:     if( pStart && pEnd ){
        !          1708:       n = Addr(pEnd->z) - Addr(pStart->z) + 1;
        !          1709:       sqliteVdbeChangeP3(v, addr, pStart->z, n);
        !          1710:     }
        !          1711:     sqliteVdbeAddOp(v, OP_MakeRecord, 5, 0);
        !          1712:     sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0);
        !          1713:     if( pTable ){
        !          1714:       sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0);
        !          1715:       sqliteVdbeOp3(v, OP_OpenRead, 2, pTab->tnum, pTab->zName, 0);
        !          1716:       lbl2 = sqliteVdbeMakeLabel(v);
        !          1717:       sqliteVdbeAddOp(v, OP_Rewind, 2, lbl2);
        !          1718:       lbl1 = sqliteVdbeAddOp(v, OP_Recno, 2, 0);
        !          1719:       for(i=0; i<pIndex->nColumn; i++){
        !          1720:         int iCol = pIndex->aiColumn[i];
        !          1721:         if( pTab->iPKey==iCol ){
        !          1722:           sqliteVdbeAddOp(v, OP_Dup, i, 0);
        !          1723:         }else{
        !          1724:           sqliteVdbeAddOp(v, OP_Column, 2, iCol);
        !          1725:         }
        !          1726:       }
        !          1727:       sqliteVdbeAddOp(v, OP_MakeIdxKey, pIndex->nColumn, 0);
        !          1728:       if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIndex);
        !          1729:       sqliteVdbeOp3(v, OP_IdxPut, 1, pIndex->onError!=OE_None,
        !          1730:                       "indexed columns are not unique", P3_STATIC);
        !          1731:       sqliteVdbeAddOp(v, OP_Next, 2, lbl1);
        !          1732:       sqliteVdbeResolveLabel(v, lbl2);
        !          1733:       sqliteVdbeAddOp(v, OP_Close, 2, 0);
        !          1734:       sqliteVdbeAddOp(v, OP_Close, 1, 0);
        !          1735:     }
        !          1736:     if( pTable!=0 ){
        !          1737:       if( !isTemp ){
        !          1738:         sqliteChangeCookie(db, v);
        !          1739:       }
        !          1740:       sqliteVdbeAddOp(v, OP_Close, 0, 0);
        !          1741:       sqliteEndWriteOperation(pParse);
        !          1742:     }
        !          1743:   }
        !          1744: 
        !          1745:   /* Clean up before exiting */
        !          1746: exit_create_index:
        !          1747:   sqliteIdListDelete(pList);
        !          1748:   sqliteSrcListDelete(pTable);
        !          1749:   sqliteFree(zName);
        !          1750:   return;
        !          1751: }
        !          1752: 
        !          1753: /*
        !          1754: ** This routine will drop an existing named index.  This routine
        !          1755: ** implements the DROP INDEX statement.
        !          1756: */
        !          1757: void sqliteDropIndex(Parse *pParse, SrcList *pName){
        !          1758:   Index *pIndex;
        !          1759:   Vdbe *v;
        !          1760:   sqlite *db = pParse->db;
        !          1761: 
        !          1762:   if( pParse->nErr || sqlite_malloc_failed ) return;
        !          1763:   assert( pName->nSrc==1 );
        !          1764:   pIndex = sqliteFindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
        !          1765:   if( pIndex==0 ){
        !          1766:     sqliteErrorMsg(pParse, "no such index: %S", pName, 0);
        !          1767:     goto exit_drop_index;
        !          1768:   }
        !          1769:   if( pIndex->autoIndex ){
        !          1770:     sqliteErrorMsg(pParse, "index associated with UNIQUE "
        !          1771:       "or PRIMARY KEY constraint cannot be dropped", 0);
        !          1772:     goto exit_drop_index;
        !          1773:   }
        !          1774:   if( pIndex->iDb>1 ){
        !          1775:     sqliteErrorMsg(pParse, "cannot alter schema of attached "
        !          1776:        "databases", 0);
        !          1777:     goto exit_drop_index;
        !          1778:   }
        !          1779: #ifndef SQLITE_OMIT_AUTHORIZATION
        !          1780:   {
        !          1781:     int code = SQLITE_DROP_INDEX;
        !          1782:     Table *pTab = pIndex->pTable;
        !          1783:     const char *zDb = db->aDb[pIndex->iDb].zName;
        !          1784:     const char *zTab = SCHEMA_TABLE(pIndex->iDb);
        !          1785:     if( sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
        !          1786:       goto exit_drop_index;
        !          1787:     }
        !          1788:     if( pIndex->iDb ) code = SQLITE_DROP_TEMP_INDEX;
        !          1789:     if( sqliteAuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
        !          1790:       goto exit_drop_index;
        !          1791:     }
        !          1792:   }
        !          1793: #endif
        !          1794: 
        !          1795:   /* Generate code to remove the index and from the master table */
        !          1796:   v = sqliteGetVdbe(pParse);
        !          1797:   if( v ){
        !          1798:     static VdbeOpList dropIndex[] = {
        !          1799:       { OP_Rewind,     0, ADDR(9), 0}, 
        !          1800:       { OP_String,     0, 0,       0}, /* 1 */
        !          1801:       { OP_MemStore,   1, 1,       0},
        !          1802:       { OP_MemLoad,    1, 0,       0}, /* 3 */
        !          1803:       { OP_Column,     0, 1,       0},
        !          1804:       { OP_Eq,         0, ADDR(8), 0},
        !          1805:       { OP_Next,       0, ADDR(3), 0},
        !          1806:       { OP_Goto,       0, ADDR(9), 0},
        !          1807:       { OP_Delete,     0, 0,       0}, /* 8 */
        !          1808:     };
        !          1809:     int base;
        !          1810: 
        !          1811:     sqliteBeginWriteOperation(pParse, 0, pIndex->iDb);
        !          1812:     sqliteOpenMasterTable(v, pIndex->iDb);
        !          1813:     base = sqliteVdbeAddOpList(v, ArraySize(dropIndex), dropIndex);
        !          1814:     sqliteVdbeChangeP3(v, base+1, pIndex->zName, 0);
        !          1815:     if( pIndex->iDb==0 ){
        !          1816:       sqliteChangeCookie(db, v);
        !          1817:     }
        !          1818:     sqliteVdbeAddOp(v, OP_Close, 0, 0);
        !          1819:     sqliteVdbeAddOp(v, OP_Destroy, pIndex->tnum, pIndex->iDb);
        !          1820:     sqliteEndWriteOperation(pParse);
        !          1821:   }
        !          1822: 
        !          1823:   /* Delete the in-memory description of this index.
        !          1824:   */
        !          1825:   if( !pParse->explain ){
        !          1826:     sqliteUnlinkAndDeleteIndex(db, pIndex);
        !          1827:     db->flags |= SQLITE_InternChanges;
        !          1828:   }
        !          1829: 
        !          1830: exit_drop_index:
        !          1831:   sqliteSrcListDelete(pName);
        !          1832: }
        !          1833: 
        !          1834: /*
        !          1835: ** Append a new element to the given IdList.  Create a new IdList if
        !          1836: ** need be.
        !          1837: **
        !          1838: ** A new IdList is returned, or NULL if malloc() fails.
        !          1839: */
        !          1840: IdList *sqliteIdListAppend(IdList *pList, Token *pToken){
        !          1841:   if( pList==0 ){
        !          1842:     pList = sqliteMalloc( sizeof(IdList) );
        !          1843:     if( pList==0 ) return 0;
        !          1844:     pList->nAlloc = 0;
        !          1845:   }
        !          1846:   if( pList->nId>=pList->nAlloc ){
        !          1847:     struct IdList_item *a;
        !          1848:     pList->nAlloc = pList->nAlloc*2 + 5;
        !          1849:     a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0]) );
        !          1850:     if( a==0 ){
        !          1851:       sqliteIdListDelete(pList);
        !          1852:       return 0;
        !          1853:     }
        !          1854:     pList->a = a;
        !          1855:   }
        !          1856:   memset(&pList->a[pList->nId], 0, sizeof(pList->a[0]));
        !          1857:   if( pToken ){
        !          1858:     char **pz = &pList->a[pList->nId].zName;
        !          1859:     sqliteSetNString(pz, pToken->z, pToken->n, 0);
        !          1860:     if( *pz==0 ){
        !          1861:       sqliteIdListDelete(pList);
        !          1862:       return 0;
        !          1863:     }else{
        !          1864:       sqliteDequote(*pz);
        !          1865:     }
        !          1866:   }
        !          1867:   pList->nId++;
        !          1868:   return pList;
        !          1869: }
        !          1870: 
        !          1871: /*
        !          1872: ** Append a new table name to the given SrcList.  Create a new SrcList if
        !          1873: ** need be.  A new entry is created in the SrcList even if pToken is NULL.
        !          1874: **
        !          1875: ** A new SrcList is returned, or NULL if malloc() fails.
        !          1876: **
        !          1877: ** If pDatabase is not null, it means that the table has an optional
        !          1878: ** database name prefix.  Like this:  "database.table".  The pDatabase
        !          1879: ** points to the table name and the pTable points to the database name.
        !          1880: ** The SrcList.a[].zName field is filled with the table name which might
        !          1881: ** come from pTable (if pDatabase is NULL) or from pDatabase.  
        !          1882: ** SrcList.a[].zDatabase is filled with the database name from pTable,
        !          1883: ** or with NULL if no database is specified.
        !          1884: **
        !          1885: ** In other words, if call like this:
        !          1886: **
        !          1887: **         sqliteSrcListAppend(A,B,0);
        !          1888: **
        !          1889: ** Then B is a table name and the database name is unspecified.  If called
        !          1890: ** like this:
        !          1891: **
        !          1892: **         sqliteSrcListAppend(A,B,C);
        !          1893: **
        !          1894: ** Then C is the table name and B is the database name.
        !          1895: */
        !          1896: SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){
        !          1897:   if( pList==0 ){
        !          1898:     pList = sqliteMalloc( sizeof(SrcList) );
        !          1899:     if( pList==0 ) return 0;
        !          1900:     pList->nAlloc = 1;
        !          1901:   }
        !          1902:   if( pList->nSrc>=pList->nAlloc ){
        !          1903:     SrcList *pNew;
        !          1904:     pList->nAlloc *= 2;
        !          1905:     pNew = sqliteRealloc(pList,
        !          1906:                sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) );
        !          1907:     if( pNew==0 ){
        !          1908:       sqliteSrcListDelete(pList);
        !          1909:       return 0;
        !          1910:     }
        !          1911:     pList = pNew;
        !          1912:   }
        !          1913:   memset(&pList->a[pList->nSrc], 0, sizeof(pList->a[0]));
        !          1914:   if( pDatabase && pDatabase->z==0 ){
        !          1915:     pDatabase = 0;
        !          1916:   }
        !          1917:   if( pDatabase && pTable ){
        !          1918:     Token *pTemp = pDatabase;
        !          1919:     pDatabase = pTable;
        !          1920:     pTable = pTemp;
        !          1921:   }
        !          1922:   if( pTable ){
        !          1923:     char **pz = &pList->a[pList->nSrc].zName;
        !          1924:     sqliteSetNString(pz, pTable->z, pTable->n, 0);
        !          1925:     if( *pz==0 ){
        !          1926:       sqliteSrcListDelete(pList);
        !          1927:       return 0;
        !          1928:     }else{
        !          1929:       sqliteDequote(*pz);
        !          1930:     }
        !          1931:   }
        !          1932:   if( pDatabase ){
        !          1933:     char **pz = &pList->a[pList->nSrc].zDatabase;
        !          1934:     sqliteSetNString(pz, pDatabase->z, pDatabase->n, 0);
        !          1935:     if( *pz==0 ){
        !          1936:       sqliteSrcListDelete(pList);
        !          1937:       return 0;
        !          1938:     }else{
        !          1939:       sqliteDequote(*pz);
        !          1940:     }
        !          1941:   }
        !          1942:   pList->a[pList->nSrc].iCursor = -1;
        !          1943:   pList->nSrc++;
        !          1944:   return pList;
        !          1945: }
        !          1946: 
        !          1947: /*
        !          1948: ** Assign cursors to all tables in a SrcList
        !          1949: */
        !          1950: void sqliteSrcListAssignCursors(Parse *pParse, SrcList *pList){
        !          1951:   int i;
        !          1952:   for(i=0; i<pList->nSrc; i++){
        !          1953:     if( pList->a[i].iCursor<0 ){
        !          1954:       pList->a[i].iCursor = pParse->nTab++;
        !          1955:     }
        !          1956:   }
        !          1957: }
        !          1958: 
        !          1959: /*
        !          1960: ** Add an alias to the last identifier on the given identifier list.
        !          1961: */
        !          1962: void sqliteSrcListAddAlias(SrcList *pList, Token *pToken){
        !          1963:   if( pList && pList->nSrc>0 ){
        !          1964:     int i = pList->nSrc - 1;
        !          1965:     sqliteSetNString(&pList->a[i].zAlias, pToken->z, pToken->n, 0);
        !          1966:     sqliteDequote(pList->a[i].zAlias);
        !          1967:   }
        !          1968: }
        !          1969: 
        !          1970: /*
        !          1971: ** Delete an IdList.
        !          1972: */
        !          1973: void sqliteIdListDelete(IdList *pList){
        !          1974:   int i;
        !          1975:   if( pList==0 ) return;
        !          1976:   for(i=0; i<pList->nId; i++){
        !          1977:     sqliteFree(pList->a[i].zName);
        !          1978:   }
        !          1979:   sqliteFree(pList->a);
        !          1980:   sqliteFree(pList);
        !          1981: }
        !          1982: 
        !          1983: /*
        !          1984: ** Return the index in pList of the identifier named zId.  Return -1
        !          1985: ** if not found.
        !          1986: */
        !          1987: int sqliteIdListIndex(IdList *pList, const char *zName){
        !          1988:   int i;
        !          1989:   if( pList==0 ) return -1;
        !          1990:   for(i=0; i<pList->nId; i++){
        !          1991:     if( sqliteStrICmp(pList->a[i].zName, zName)==0 ) return i;
        !          1992:   }
        !          1993:   return -1;
        !          1994: }
        !          1995: 
        !          1996: /*
        !          1997: ** Delete an entire SrcList including all its substructure.
        !          1998: */
        !          1999: void sqliteSrcListDelete(SrcList *pList){
        !          2000:   int i;
        !          2001:   if( pList==0 ) return;
        !          2002:   for(i=0; i<pList->nSrc; i++){
        !          2003:     sqliteFree(pList->a[i].zDatabase);
        !          2004:     sqliteFree(pList->a[i].zName);
        !          2005:     sqliteFree(pList->a[i].zAlias);
        !          2006:     if( pList->a[i].pTab && pList->a[i].pTab->isTransient ){
        !          2007:       sqliteDeleteTable(0, pList->a[i].pTab);
        !          2008:     }
        !          2009:     sqliteSelectDelete(pList->a[i].pSelect);
        !          2010:     sqliteExprDelete(pList->a[i].pOn);
        !          2011:     sqliteIdListDelete(pList->a[i].pUsing);
        !          2012:   }
        !          2013:   sqliteFree(pList);
        !          2014: }
        !          2015: 
        !          2016: /*
        !          2017: ** Begin a transaction
        !          2018: */
        !          2019: void sqliteBeginTransaction(Parse *pParse, int onError){
        !          2020:   sqlite *db;
        !          2021: 
        !          2022:   if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
        !          2023:   if( pParse->nErr || sqlite_malloc_failed ) return;
        !          2024:   if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return;
        !          2025:   if( db->flags & SQLITE_InTrans ){
        !          2026:     sqliteErrorMsg(pParse, "cannot start a transaction within a transaction");
        !          2027:     return;
        !          2028:   }
        !          2029:   sqliteBeginWriteOperation(pParse, 0, 0);
        !          2030:   if( !pParse->explain ){
        !          2031:     db->flags |= SQLITE_InTrans;
        !          2032:     db->onError = onError;
        !          2033:   }
        !          2034: }
        !          2035: 
        !          2036: /*
        !          2037: ** Commit a transaction
        !          2038: */
        !          2039: void sqliteCommitTransaction(Parse *pParse){
        !          2040:   sqlite *db;
        !          2041: 
        !          2042:   if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
        !          2043:   if( pParse->nErr || sqlite_malloc_failed ) return;
        !          2044:   if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return;
        !          2045:   if( (db->flags & SQLITE_InTrans)==0 ){
        !          2046:     sqliteErrorMsg(pParse, "cannot commit - no transaction is active");
        !          2047:     return;
        !          2048:   }
        !          2049:   if( !pParse->explain ){
        !          2050:     db->flags &= ~SQLITE_InTrans;
        !          2051:   }
        !          2052:   sqliteEndWriteOperation(pParse);
        !          2053:   if( !pParse->explain ){
        !          2054:     db->onError = OE_Default;
        !          2055:   }
        !          2056: }
        !          2057: 
        !          2058: /*
        !          2059: ** Rollback a transaction
        !          2060: */
        !          2061: void sqliteRollbackTransaction(Parse *pParse){
        !          2062:   sqlite *db;
        !          2063:   Vdbe *v;
        !          2064: 
        !          2065:   if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
        !          2066:   if( pParse->nErr || sqlite_malloc_failed ) return;
        !          2067:   if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return;
        !          2068:   if( (db->flags & SQLITE_InTrans)==0 ){
        !          2069:     sqliteErrorMsg(pParse, "cannot rollback - no transaction is active");
        !          2070:     return; 
        !          2071:   }
        !          2072:   v = sqliteGetVdbe(pParse);
        !          2073:   if( v ){
        !          2074:     sqliteVdbeAddOp(v, OP_Rollback, 0, 0);
        !          2075:   }
        !          2076:   if( !pParse->explain ){
        !          2077:     db->flags &= ~SQLITE_InTrans;
        !          2078:     db->onError = OE_Default;
        !          2079:   }
        !          2080: }
        !          2081: 
        !          2082: /*
        !          2083: ** Generate VDBE code that will verify the schema cookie for all
        !          2084: ** named database files.
        !          2085: */
        !          2086: void sqliteCodeVerifySchema(Parse *pParse, int iDb){
        !          2087:   sqlite *db = pParse->db;
        !          2088:   Vdbe *v = sqliteGetVdbe(pParse);
        !          2089:   assert( iDb>=0 && iDb<db->nDb );
        !          2090:   assert( db->aDb[iDb].pBt!=0 );
        !          2091:   if( iDb!=1 && !DbHasProperty(db, iDb, DB_Cookie) ){
        !          2092:     sqliteVdbeAddOp(v, OP_VerifyCookie, iDb, db->aDb[iDb].schema_cookie);
        !          2093:     DbSetProperty(db, iDb, DB_Cookie);
        !          2094:   }
        !          2095: }
        !          2096: 
        !          2097: /*
        !          2098: ** Generate VDBE code that prepares for doing an operation that
        !          2099: ** might change the database.
        !          2100: **
        !          2101: ** This routine starts a new transaction if we are not already within
        !          2102: ** a transaction.  If we are already within a transaction, then a checkpoint
        !          2103: ** is set if the setCheckpoint parameter is true.  A checkpoint should
        !          2104: ** be set for operations that might fail (due to a constraint) part of
        !          2105: ** the way through and which will need to undo some writes without having to
        !          2106: ** rollback the whole transaction.  For operations where all constraints
        !          2107: ** can be checked before any changes are made to the database, it is never
        !          2108: ** necessary to undo a write and the checkpoint should not be set.
        !          2109: **
        !          2110: ** Only database iDb and the temp database are made writable by this call.
        !          2111: ** If iDb==0, then the main and temp databases are made writable.   If
        !          2112: ** iDb==1 then only the temp database is made writable.  If iDb>1 then the
        !          2113: ** specified auxiliary database and the temp database are made writable.
        !          2114: */
        !          2115: void sqliteBeginWriteOperation(Parse *pParse, int setCheckpoint, int iDb){
        !          2116:   Vdbe *v;
        !          2117:   sqlite *db = pParse->db;
        !          2118:   if( DbHasProperty(db, iDb, DB_Locked) ) return;
        !          2119:   v = sqliteGetVdbe(pParse);
        !          2120:   if( v==0 ) return;
        !          2121:   if( !db->aDb[iDb].inTrans ){
        !          2122:     sqliteVdbeAddOp(v, OP_Transaction, iDb, 0);
        !          2123:     DbSetProperty(db, iDb, DB_Locked);
        !          2124:     sqliteCodeVerifySchema(pParse, iDb);
        !          2125:     if( iDb!=1 ){
        !          2126:       sqliteBeginWriteOperation(pParse, setCheckpoint, 1);
        !          2127:     }
        !          2128:   }else if( setCheckpoint ){
        !          2129:     sqliteVdbeAddOp(v, OP_Checkpoint, iDb, 0);
        !          2130:     DbSetProperty(db, iDb, DB_Locked);
        !          2131:   }
        !          2132: }
        !          2133: 
        !          2134: /*
        !          2135: ** Generate code that concludes an operation that may have changed
        !          2136: ** the database.  If a statement transaction was started, then emit
        !          2137: ** an OP_Commit that will cause the changes to be committed to disk.
        !          2138: **
        !          2139: ** Note that checkpoints are automatically committed at the end of
        !          2140: ** a statement.  Note also that there can be multiple calls to 
        !          2141: ** sqliteBeginWriteOperation() but there should only be a single
        !          2142: ** call to sqliteEndWriteOperation() at the conclusion of the statement.
        !          2143: */
        !          2144: void sqliteEndWriteOperation(Parse *pParse){
        !          2145:   Vdbe *v;
        !          2146:   sqlite *db = pParse->db;
        !          2147:   if( pParse->trigStack ) return; /* if this is in a trigger */
        !          2148:   v = sqliteGetVdbe(pParse);
        !          2149:   if( v==0 ) return;
        !          2150:   if( db->flags & SQLITE_InTrans ){
        !          2151:     /* A BEGIN has executed.  Do not commit until we see an explicit
        !          2152:     ** COMMIT statement. */
        !          2153:   }else{
        !          2154:     sqliteVdbeAddOp(v, OP_Commit, 0, 0);
        !          2155:   }
        !          2156: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>