Annotation of embedaddon/php/ext/sqlite/libsqlite/src/build.c, revision 1.1.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>