build.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:110k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2001 September 15
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This file contains C code routines that are called by the SQLite parser
  13. ** when syntax rules are reduced.  The routines in this file handle the
  14. ** following kinds of SQL syntax:
  15. **
  16. **     CREATE TABLE
  17. **     DROP TABLE
  18. **     CREATE INDEX
  19. **     DROP INDEX
  20. **     creating ID lists
  21. **     BEGIN TRANSACTION
  22. **     COMMIT
  23. **     ROLLBACK
  24. **
  25. ** $Id: build.c,v 1.480 2008/04/11 17:11:27 danielk1977 Exp $
  26. */
  27. #include "sqliteInt.h"
  28. #include <ctype.h>
  29. /*
  30. ** This routine is called when a new SQL statement is beginning to
  31. ** be parsed.  Initialize the pParse structure as needed.
  32. */
  33. void sqlite3BeginParse(Parse *pParse, int explainFlag){
  34.   pParse->explain = explainFlag;
  35.   pParse->nVar = 0;
  36. }
  37. #ifndef SQLITE_OMIT_SHARED_CACHE
  38. /*
  39. ** The TableLock structure is only used by the sqlite3TableLock() and
  40. ** codeTableLocks() functions.
  41. */
  42. struct TableLock {
  43.   int iDb;             /* The database containing the table to be locked */
  44.   int iTab;            /* The root page of the table to be locked */
  45.   u8 isWriteLock;      /* True for write lock.  False for a read lock */
  46.   const char *zName;   /* Name of the table */
  47. };
  48. /*
  49. ** Record the fact that we want to lock a table at run-time.  
  50. **
  51. ** The table to be locked has root page iTab and is found in database iDb.
  52. ** A read or a write lock can be taken depending on isWritelock.
  53. **
  54. ** This routine just records the fact that the lock is desired.  The
  55. ** code to make the lock occur is generated by a later call to
  56. ** codeTableLocks() which occurs during sqlite3FinishCoding().
  57. */
  58. void sqlite3TableLock(
  59.   Parse *pParse,     /* Parsing context */
  60.   int iDb,           /* Index of the database containing the table to lock */
  61.   int iTab,          /* Root page number of the table to be locked */
  62.   u8 isWriteLock,    /* True for a write lock */
  63.   const char *zName  /* Name of the table to be locked */
  64. ){
  65.   int i;
  66.   int nBytes;
  67.   TableLock *p;
  68.   if( iDb<0 ){
  69.     return;
  70.   }
  71.   for(i=0; i<pParse->nTableLock; i++){
  72.     p = &pParse->aTableLock[i];
  73.     if( p->iDb==iDb && p->iTab==iTab ){
  74.       p->isWriteLock = (p->isWriteLock || isWriteLock);
  75.       return;
  76.     }
  77.   }
  78.   nBytes = sizeof(TableLock) * (pParse->nTableLock+1);
  79.   pParse->aTableLock = 
  80.       sqlite3DbReallocOrFree(pParse->db, pParse->aTableLock, nBytes);
  81.   if( pParse->aTableLock ){
  82.     p = &pParse->aTableLock[pParse->nTableLock++];
  83.     p->iDb = iDb;
  84.     p->iTab = iTab;
  85.     p->isWriteLock = isWriteLock;
  86.     p->zName = zName;
  87.   }else{
  88.     pParse->nTableLock = 0;
  89.     pParse->db->mallocFailed = 1;
  90.   }
  91. }
  92. /*
  93. ** Code an OP_TableLock instruction for each table locked by the
  94. ** statement (configured by calls to sqlite3TableLock()).
  95. */
  96. static void codeTableLocks(Parse *pParse){
  97.   int i;
  98.   Vdbe *pVdbe; 
  99.   if( 0==(pVdbe = sqlite3GetVdbe(pParse)) ){
  100.     return;
  101.   }
  102.   for(i=0; i<pParse->nTableLock; i++){
  103.     TableLock *p = &pParse->aTableLock[i];
  104.     int p1 = p->iDb;
  105.     sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
  106.                       p->zName, P4_STATIC);
  107.   }
  108. }
  109. #else
  110.   #define codeTableLocks(x)
  111. #endif
  112. /*
  113. ** This routine is called after a single SQL statement has been
  114. ** parsed and a VDBE program to execute that statement has been
  115. ** prepared.  This routine puts the finishing touches on the
  116. ** VDBE program and resets the pParse structure for the next
  117. ** parse.
  118. **
  119. ** Note that if an error occurred, it might be the case that
  120. ** no VDBE code was generated.
  121. */
  122. void sqlite3FinishCoding(Parse *pParse){
  123.   sqlite3 *db;
  124.   Vdbe *v;
  125.   db = pParse->db;
  126.   if( db->mallocFailed ) return;
  127.   if( pParse->nested ) return;
  128.   if( pParse->nErr ) return;
  129.   if( !pParse->pVdbe ){
  130.     if( pParse->rc==SQLITE_OK && pParse->nErr ){
  131.       pParse->rc = SQLITE_ERROR;
  132.       return;
  133.     }
  134.   }
  135.   /* Begin by generating some termination code at the end of the
  136.   ** vdbe program
  137.   */
  138.   v = sqlite3GetVdbe(pParse);
  139.   if( v ){
  140.     sqlite3VdbeAddOp0(v, OP_Halt);
  141.     /* The cookie mask contains one bit for each database file open.
  142.     ** (Bit 0 is for main, bit 1 is for temp, and so forth.)  Bits are
  143.     ** set for each database that is used.  Generate code to start a
  144.     ** transaction on each used database and to verify the schema cookie
  145.     ** on each used database.
  146.     */
  147.     if( pParse->cookieGoto>0 ){
  148.       u32 mask;
  149.       int iDb;
  150.       sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);
  151.       for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
  152.         if( (mask & pParse->cookieMask)==0 ) continue;
  153.         sqlite3VdbeUsesBtree(v, iDb);
  154.         sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
  155.         sqlite3VdbeAddOp2(v,OP_VerifyCookie, iDb, pParse->cookieValue[iDb]);
  156.       }
  157. #ifndef SQLITE_OMIT_VIRTUALTABLE
  158.       if( pParse->pVirtualLock ){
  159.         char *vtab = (char *)pParse->pVirtualLock->pVtab;
  160.         sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
  161.       }
  162. #endif
  163.       /* Once all the cookies have been verified and transactions opened, 
  164.       ** obtain the required table-locks. This is a no-op unless the 
  165.       ** shared-cache feature is enabled.
  166.       */
  167.       codeTableLocks(pParse);
  168.       sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
  169.     }
  170. #ifndef SQLITE_OMIT_TRACE
  171.     if( !db->init.busy ){
  172.       /* Change the P4 argument of the first opcode (which will always be
  173.       ** an OP_Trace) to be the complete text of the current SQL statement.
  174.       */
  175.       VdbeOp *pOp = sqlite3VdbeGetOp(v, 0);
  176.       if( pOp && pOp->opcode==OP_Trace ){
  177.         sqlite3VdbeChangeP4(v, 0, pParse->zSql, pParse->zTail-pParse->zSql);
  178.       }
  179.     }
  180. #endif /* SQLITE_OMIT_TRACE */
  181.   }
  182.   /* Get the VDBE program ready for execution
  183.   */
  184.   if( v && pParse->nErr==0 && !db->mallocFailed ){
  185. #ifdef SQLITE_DEBUG
  186.     FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
  187.     sqlite3VdbeTrace(v, trace);
  188. #endif
  189.     assert( pParse->disableColCache==0 );  /* Disables and re-enables match */
  190.     sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem+3,
  191.                          pParse->nTab+3, pParse->explain);
  192.     pParse->rc = SQLITE_DONE;
  193.     pParse->colNamesSet = 0;
  194.   }else if( pParse->rc==SQLITE_OK ){
  195.     pParse->rc = SQLITE_ERROR;
  196.   }
  197.   pParse->nTab = 0;
  198.   pParse->nMem = 0;
  199.   pParse->nSet = 0;
  200.   pParse->nVar = 0;
  201.   pParse->cookieMask = 0;
  202.   pParse->cookieGoto = 0;
  203. }
  204. /*
  205. ** Run the parser and code generator recursively in order to generate
  206. ** code for the SQL statement given onto the end of the pParse context
  207. ** currently under construction.  When the parser is run recursively
  208. ** this way, the final OP_Halt is not appended and other initialization
  209. ** and finalization steps are omitted because those are handling by the
  210. ** outermost parser.
  211. **
  212. ** Not everything is nestable.  This facility is designed to permit
  213. ** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER.  Use
  214. ** care if you decide to try to use this routine for some other purposes.
  215. */
  216. void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
  217.   va_list ap;
  218.   char *zSql;
  219. # define SAVE_SZ  (sizeof(Parse) - offsetof(Parse,nVar))
  220.   char saveBuf[SAVE_SZ];
  221.   if( pParse->nErr ) return;
  222.   assert( pParse->nested<10 );  /* Nesting should only be of limited depth */
  223.   va_start(ap, zFormat);
  224.   zSql = sqlite3VMPrintf(pParse->db, zFormat, ap);
  225.   va_end(ap);
  226.   if( zSql==0 ){
  227.     pParse->db->mallocFailed = 1;
  228.     return;   /* A malloc must have failed */
  229.   }
  230.   pParse->nested++;
  231.   memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
  232.   memset(&pParse->nVar, 0, SAVE_SZ);
  233.   sqlite3RunParser(pParse, zSql, 0);
  234.   sqlite3_free(zSql);
  235.   memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
  236.   pParse->nested--;
  237. }
  238. /*
  239. ** Locate the in-memory structure that describes a particular database
  240. ** table given the name of that table and (optionally) the name of the
  241. ** database containing the table.  Return NULL if not found.
  242. **
  243. ** If zDatabase is 0, all databases are searched for the table and the
  244. ** first matching table is returned.  (No checking for duplicate table
  245. ** names is done.)  The search order is TEMP first, then MAIN, then any
  246. ** auxiliary databases added using the ATTACH command.
  247. **
  248. ** See also sqlite3LocateTable().
  249. */
  250. Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
  251.   Table *p = 0;
  252.   int i;
  253.   assert( zName!=0 );
  254.   for(i=OMIT_TEMPDB; i<db->nDb; i++){
  255.     int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
  256.     if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
  257.     p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, strlen(zName)+1);
  258.     if( p ) break;
  259.   }
  260.   return p;
  261. }
  262. /*
  263. ** Locate the in-memory structure that describes a particular database
  264. ** table given the name of that table and (optionally) the name of the
  265. ** database containing the table.  Return NULL if not found.  Also leave an
  266. ** error message in pParse->zErrMsg.
  267. **
  268. ** The difference between this routine and sqlite3FindTable() is that this
  269. ** routine leaves an error message in pParse->zErrMsg where
  270. ** sqlite3FindTable() does not.
  271. */
  272. Table *sqlite3LocateTable(
  273.   Parse *pParse,         /* context in which to report errors */
  274.   int isView,            /* True if looking for a VIEW rather than a TABLE */
  275.   const char *zName,     /* Name of the table we are looking for */
  276.   const char *zDbase     /* Name of the database.  Might be NULL */
  277. ){
  278.   Table *p;
  279.   /* Read the database schema. If an error occurs, leave an error message
  280.   ** and code in pParse and return NULL. */
  281.   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
  282.     return 0;
  283.   }
  284.   p = sqlite3FindTable(pParse->db, zName, zDbase);
  285.   if( p==0 ){
  286.     const char *zMsg = isView ? "no such view" : "no such table";
  287.     if( zDbase ){
  288.       sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
  289.     }else{
  290.       sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
  291.     }
  292.     pParse->checkSchema = 1;
  293.   }
  294.   return p;
  295. }
  296. /*
  297. ** Locate the in-memory structure that describes 
  298. ** a particular index given the name of that index
  299. ** and the name of the database that contains the index.
  300. ** Return NULL if not found.
  301. **
  302. ** If zDatabase is 0, all databases are searched for the
  303. ** table and the first matching index is returned.  (No checking
  304. ** for duplicate index names is done.)  The search order is
  305. ** TEMP first, then MAIN, then any auxiliary databases added
  306. ** using the ATTACH command.
  307. */
  308. Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
  309.   Index *p = 0;
  310.   int i;
  311.   for(i=OMIT_TEMPDB; i<db->nDb; i++){
  312.     int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
  313.     Schema *pSchema = db->aDb[j].pSchema;
  314.     if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
  315.     assert( pSchema || (j==1 && !db->aDb[1].pBt) );
  316.     if( pSchema ){
  317.       p = sqlite3HashFind(&pSchema->idxHash, zName, strlen(zName)+1);
  318.     }
  319.     if( p ) break;
  320.   }
  321.   return p;
  322. }
  323. /*
  324. ** Reclaim the memory used by an index
  325. */
  326. static void freeIndex(Index *p){
  327.   sqlite3_free(p->zColAff);
  328.   sqlite3_free(p);
  329. }
  330. /*
  331. ** Remove the given index from the index hash table, and free
  332. ** its memory structures.
  333. **
  334. ** The index is removed from the database hash tables but
  335. ** it is not unlinked from the Table that it indexes.
  336. ** Unlinking from the Table must be done by the calling function.
  337. */
  338. static void sqliteDeleteIndex(Index *p){
  339.   Index *pOld;
  340.   const char *zName = p->zName;
  341.   pOld = sqlite3HashInsert(&p->pSchema->idxHash, zName, strlen( zName)+1, 0);
  342.   assert( pOld==0 || pOld==p );
  343.   freeIndex(p);
  344. }
  345. /*
  346. ** For the index called zIdxName which is found in the database iDb,
  347. ** unlike that index from its Table then remove the index from
  348. ** the index hash table and free all memory structures associated
  349. ** with the index.
  350. */
  351. void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
  352.   Index *pIndex;
  353.   int len;
  354.   Hash *pHash = &db->aDb[iDb].pSchema->idxHash;
  355.   len = strlen(zIdxName);
  356.   pIndex = sqlite3HashInsert(pHash, zIdxName, len+1, 0);
  357.   if( pIndex ){
  358.     if( pIndex->pTable->pIndex==pIndex ){
  359.       pIndex->pTable->pIndex = pIndex->pNext;
  360.     }else{
  361.       Index *p;
  362.       for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){}
  363.       if( p && p->pNext==pIndex ){
  364.         p->pNext = pIndex->pNext;
  365.       }
  366.     }
  367.     freeIndex(pIndex);
  368.   }
  369.   db->flags |= SQLITE_InternChanges;
  370. }
  371. /*
  372. ** Erase all schema information from the in-memory hash tables of
  373. ** a single database.  This routine is called to reclaim memory
  374. ** before the database closes.  It is also called during a rollback
  375. ** if there were schema changes during the transaction or if a
  376. ** schema-cookie mismatch occurs.
  377. **
  378. ** If iDb<=0 then reset the internal schema tables for all database
  379. ** files.  If iDb>=2 then reset the internal schema for only the
  380. ** single file indicated.
  381. */
  382. void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
  383.   int i, j;
  384.   assert( iDb>=0 && iDb<db->nDb );
  385.   if( iDb==0 ){
  386.     sqlite3BtreeEnterAll(db);
  387.   }
  388.   for(i=iDb; i<db->nDb; i++){
  389.     Db *pDb = &db->aDb[i];
  390.     if( pDb->pSchema ){
  391.       assert(i==1 || (pDb->pBt && sqlite3BtreeHoldsMutex(pDb->pBt)));
  392.       sqlite3SchemaFree(pDb->pSchema);
  393.     }
  394.     if( iDb>0 ) return;
  395.   }
  396.   assert( iDb==0 );
  397.   db->flags &= ~SQLITE_InternChanges;
  398.   sqlite3BtreeLeaveAll(db);
  399.   /* If one or more of the auxiliary database files has been closed,
  400.   ** then remove them from the auxiliary database list.  We take the
  401.   ** opportunity to do this here since we have just deleted all of the
  402.   ** schema hash tables and therefore do not have to make any changes
  403.   ** to any of those tables.
  404.   */
  405.   for(i=0; i<db->nDb; i++){
  406.     struct Db *pDb = &db->aDb[i];
  407.     if( pDb->pBt==0 ){
  408.       if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux);
  409.       pDb->pAux = 0;
  410.     }
  411.   }
  412.   for(i=j=2; i<db->nDb; i++){
  413.     struct Db *pDb = &db->aDb[i];
  414.     if( pDb->pBt==0 ){
  415.       sqlite3_free(pDb->zName);
  416.       pDb->zName = 0;
  417.       continue;
  418.     }
  419.     if( j<i ){
  420.       db->aDb[j] = db->aDb[i];
  421.     }
  422.     j++;
  423.   }
  424.   memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
  425.   db->nDb = j;
  426.   if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
  427.     memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
  428.     sqlite3_free(db->aDb);
  429.     db->aDb = db->aDbStatic;
  430.   }
  431. }
  432. /*
  433. ** This routine is called when a commit occurs.
  434. */
  435. void sqlite3CommitInternalChanges(sqlite3 *db){
  436.   db->flags &= ~SQLITE_InternChanges;
  437. }
  438. /*
  439. ** Clear the column names from a table or view.
  440. */
  441. static void sqliteResetColumnNames(Table *pTable){
  442.   int i;
  443.   Column *pCol;
  444.   assert( pTable!=0 );
  445.   if( (pCol = pTable->aCol)!=0 ){
  446.     for(i=0; i<pTable->nCol; i++, pCol++){
  447.       sqlite3_free(pCol->zName);
  448.       sqlite3ExprDelete(pCol->pDflt);
  449.       sqlite3_free(pCol->zType);
  450.       sqlite3_free(pCol->zColl);
  451.     }
  452.     sqlite3_free(pTable->aCol);
  453.   }
  454.   pTable->aCol = 0;
  455.   pTable->nCol = 0;
  456. }
  457. /*
  458. ** Remove the memory data structures associated with the given
  459. ** Table.  No changes are made to disk by this routine.
  460. **
  461. ** This routine just deletes the data structure.  It does not unlink
  462. ** the table data structure from the hash table.  Nor does it remove
  463. ** foreign keys from the sqlite.aFKey hash table.  But it does destroy
  464. ** memory structures of the indices and foreign keys associated with 
  465. ** the table.
  466. */
  467. void sqlite3DeleteTable(Table *pTable){
  468.   Index *pIndex, *pNext;
  469.   FKey *pFKey, *pNextFKey;
  470.   if( pTable==0 ) return;
  471.   /* Do not delete the table until the reference count reaches zero. */
  472.   pTable->nRef--;
  473.   if( pTable->nRef>0 ){
  474.     return;
  475.   }
  476.   assert( pTable->nRef==0 );
  477.   /* Delete all indices associated with this table
  478.   */
  479.   for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
  480.     pNext = pIndex->pNext;
  481.     assert( pIndex->pSchema==pTable->pSchema );
  482.     sqliteDeleteIndex(pIndex);
  483.   }
  484. #ifndef SQLITE_OMIT_FOREIGN_KEY
  485.   /* Delete all foreign keys associated with this table.  The keys
  486.   ** should have already been unlinked from the pSchema->aFKey hash table 
  487.   */
  488.   for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){
  489.     pNextFKey = pFKey->pNextFrom;
  490.     assert( sqlite3HashFind(&pTable->pSchema->aFKey,
  491.                            pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey );
  492.     sqlite3_free(pFKey);
  493.   }
  494. #endif
  495.   /* Delete the Table structure itself.
  496.   */
  497.   sqliteResetColumnNames(pTable);
  498.   sqlite3_free(pTable->zName);
  499.   sqlite3_free(pTable->zColAff);
  500.   sqlite3SelectDelete(pTable->pSelect);
  501. #ifndef SQLITE_OMIT_CHECK
  502.   sqlite3ExprDelete(pTable->pCheck);
  503. #endif
  504.   sqlite3VtabClear(pTable);
  505.   sqlite3_free(pTable);
  506. }
  507. /*
  508. ** Unlink the given table from the hash tables and the delete the
  509. ** table structure with all its indices and foreign keys.
  510. */
  511. void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
  512.   Table *p;
  513.   FKey *pF1, *pF2;
  514.   Db *pDb;
  515.   assert( db!=0 );
  516.   assert( iDb>=0 && iDb<db->nDb );
  517.   assert( zTabName && zTabName[0] );
  518.   pDb = &db->aDb[iDb];
  519.   p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, strlen(zTabName)+1,0);
  520.   if( p ){
  521. #ifndef SQLITE_OMIT_FOREIGN_KEY
  522.     for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){
  523.       int nTo = strlen(pF1->zTo) + 1;
  524.       pF2 = sqlite3HashFind(&pDb->pSchema->aFKey, pF1->zTo, nTo);
  525.       if( pF2==pF1 ){
  526.         sqlite3HashInsert(&pDb->pSchema->aFKey, pF1->zTo, nTo, pF1->pNextTo);
  527.       }else{
  528.         while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; }
  529.         if( pF2 ){
  530.           pF2->pNextTo = pF1->pNextTo;
  531.         }
  532.       }
  533.     }
  534. #endif
  535.     sqlite3DeleteTable(p);
  536.   }
  537.   db->flags |= SQLITE_InternChanges;
  538. }
  539. /*
  540. ** Given a token, return a string that consists of the text of that
  541. ** token with any quotations removed.  Space to hold the returned string
  542. ** is obtained from sqliteMalloc() and must be freed by the calling
  543. ** function.
  544. **
  545. ** Tokens are often just pointers into the original SQL text and so
  546. ** are not 00 terminated and are not persistent.  The returned string
  547. ** is 00 terminated and is persistent.
  548. */
  549. char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
  550.   char *zName;
  551.   if( pName ){
  552.     zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
  553.     sqlite3Dequote(zName);
  554.   }else{
  555.     zName = 0;
  556.   }
  557.   return zName;
  558. }
  559. /*
  560. ** Open the sqlite_master table stored in database number iDb for
  561. ** writing. The table is opened using cursor 0.
  562. */
  563. void sqlite3OpenMasterTable(Parse *p, int iDb){
  564.   Vdbe *v = sqlite3GetVdbe(p);
  565.   sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
  566.   sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, 5);/* sqlite_master has 5 columns */
  567.   sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
  568. }
  569. /*
  570. ** The token *pName contains the name of a database (either "main" or
  571. ** "temp" or the name of an attached db). This routine returns the
  572. ** index of the named database in db->aDb[], or -1 if the named db 
  573. ** does not exist.
  574. */
  575. int sqlite3FindDb(sqlite3 *db, Token *pName){
  576.   int i = -1;    /* Database number */
  577.   int n;         /* Number of characters in the name */
  578.   Db *pDb;       /* A database whose name space is being searched */
  579.   char *zName;   /* Name we are searching for */
  580.   zName = sqlite3NameFromToken(db, pName);
  581.   if( zName ){
  582.     n = strlen(zName);
  583.     for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
  584.       if( (!OMIT_TEMPDB || i!=1 ) && n==strlen(pDb->zName) && 
  585.           0==sqlite3StrICmp(pDb->zName, zName) ){
  586.         break;
  587.       }
  588.     }
  589.     sqlite3_free(zName);
  590.   }
  591.   return i;
  592. }
  593. /* The table or view or trigger name is passed to this routine via tokens
  594. ** pName1 and pName2. If the table name was fully qualified, for example:
  595. **
  596. ** CREATE TABLE xxx.yyy (...);
  597. ** 
  598. ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
  599. ** the table name is not fully qualified, i.e.:
  600. **
  601. ** CREATE TABLE yyy(...);
  602. **
  603. ** Then pName1 is set to "yyy" and pName2 is "".
  604. **
  605. ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
  606. ** pName2) that stores the unqualified table name.  The index of the
  607. ** database "xxx" is returned.
  608. */
  609. int sqlite3TwoPartName(
  610.   Parse *pParse,      /* Parsing and code generating context */
  611.   Token *pName1,      /* The "xxx" in the name "xxx.yyy" or "xxx" */
  612.   Token *pName2,      /* The "yyy" in the name "xxx.yyy" */
  613.   Token **pUnqual     /* Write the unqualified object name here */
  614. ){
  615.   int iDb;                    /* Database holding the object */
  616.   sqlite3 *db = pParse->db;
  617.   if( pName2 && pName2->n>0 ){
  618.     assert( !db->init.busy );
  619.     *pUnqual = pName2;
  620.     iDb = sqlite3FindDb(db, pName1);
  621.     if( iDb<0 ){
  622.       sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
  623.       pParse->nErr++;
  624.       return -1;
  625.     }
  626.   }else{
  627.     assert( db->init.iDb==0 || db->init.busy );
  628.     iDb = db->init.iDb;
  629.     *pUnqual = pName1;
  630.   }
  631.   return iDb;
  632. }
  633. /*
  634. ** This routine is used to check if the UTF-8 string zName is a legal
  635. ** unqualified name for a new schema object (table, index, view or
  636. ** trigger). All names are legal except those that begin with the string
  637. ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
  638. ** is reserved for internal use.
  639. */
  640. int sqlite3CheckObjectName(Parse *pParse, const char *zName){
  641.   if( !pParse->db->init.busy && pParse->nested==0 
  642.           && (pParse->db->flags & SQLITE_WriteSchema)==0
  643.           && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
  644.     sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
  645.     return SQLITE_ERROR;
  646.   }
  647.   return SQLITE_OK;
  648. }
  649. /*
  650. ** Begin constructing a new table representation in memory.  This is
  651. ** the first of several action routines that get called in response
  652. ** to a CREATE TABLE statement.  In particular, this routine is called
  653. ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
  654. ** flag is true if the table should be stored in the auxiliary database
  655. ** file instead of in the main database file.  This is normally the case
  656. ** when the "TEMP" or "TEMPORARY" keyword occurs in between
  657. ** CREATE and TABLE.
  658. **
  659. ** The new table record is initialized and put in pParse->pNewTable.
  660. ** As more of the CREATE TABLE statement is parsed, additional action
  661. ** routines will be called to add more information to this record.
  662. ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
  663. ** is called to complete the construction of the new table record.
  664. */
  665. void sqlite3StartTable(
  666.   Parse *pParse,   /* Parser context */
  667.   Token *pName1,   /* First part of the name of the table or view */
  668.   Token *pName2,   /* Second part of the name of the table or view */
  669.   int isTemp,      /* True if this is a TEMP table */
  670.   int isView,      /* True if this is a VIEW */
  671.   int isVirtual,   /* True if this is a VIRTUAL table */
  672.   int noErr        /* Do nothing if table already exists */
  673. ){
  674.   Table *pTable;
  675.   char *zName = 0; /* The name of the new table */
  676.   sqlite3 *db = pParse->db;
  677.   Vdbe *v;
  678.   int iDb;         /* Database number to create the table in */
  679.   Token *pName;    /* Unqualified name of the table to create */
  680.   /* The table or view name to create is passed to this routine via tokens
  681.   ** pName1 and pName2. If the table name was fully qualified, for example:
  682.   **
  683.   ** CREATE TABLE xxx.yyy (...);
  684.   ** 
  685.   ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
  686.   ** the table name is not fully qualified, i.e.:
  687.   **
  688.   ** CREATE TABLE yyy(...);
  689.   **
  690.   ** Then pName1 is set to "yyy" and pName2 is "".
  691.   **
  692.   ** The call below sets the pName pointer to point at the token (pName1 or
  693.   ** pName2) that stores the unqualified table name. The variable iDb is
  694.   ** set to the index of the database that the table or view is to be
  695.   ** created in.
  696.   */
  697.   iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
  698.   if( iDb<0 ) return;
  699.   if( !OMIT_TEMPDB && isTemp && iDb>1 ){
  700.     /* If creating a temp table, the name may not be qualified */
  701.     sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
  702.     return;
  703.   }
  704.   if( !OMIT_TEMPDB && isTemp ) iDb = 1;
  705.   pParse->sNameToken = *pName;
  706.   zName = sqlite3NameFromToken(db, pName);
  707.   if( zName==0 ) return;
  708.   if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
  709.     goto begin_table_error;
  710.   }
  711.   if( db->init.iDb==1 ) isTemp = 1;
  712. #ifndef SQLITE_OMIT_AUTHORIZATION
  713.   assert( (isTemp & 1)==isTemp );
  714.   {
  715.     int code;
  716.     char *zDb = db->aDb[iDb].zName;
  717.     if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
  718.       goto begin_table_error;
  719.     }
  720.     if( isView ){
  721.       if( !OMIT_TEMPDB && isTemp ){
  722.         code = SQLITE_CREATE_TEMP_VIEW;
  723.       }else{
  724.         code = SQLITE_CREATE_VIEW;
  725.       }
  726.     }else{
  727.       if( !OMIT_TEMPDB && isTemp ){
  728.         code = SQLITE_CREATE_TEMP_TABLE;
  729.       }else{
  730.         code = SQLITE_CREATE_TABLE;
  731.       }
  732.     }
  733.     if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
  734.       goto begin_table_error;
  735.     }
  736.   }
  737. #endif
  738.   /* Make sure the new table name does not collide with an existing
  739.   ** index or table name in the same database.  Issue an error message if
  740.   ** it does. The exception is if the statement being parsed was passed
  741.   ** to an sqlite3_declare_vtab() call. In that case only the column names
  742.   ** and types will be used, so there is no need to test for namespace
  743.   ** collisions.
  744.   */
  745.   if( !IN_DECLARE_VTAB ){
  746.     if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
  747.       goto begin_table_error;
  748.     }
  749.     pTable = sqlite3FindTable(db, zName, db->aDb[iDb].zName);
  750.     if( pTable ){
  751.       if( !noErr ){
  752.         sqlite3ErrorMsg(pParse, "table %T already exists", pName);
  753.       }
  754.       goto begin_table_error;
  755.     }
  756.     if( sqlite3FindIndex(db, zName, 0)!=0 && (iDb==0 || !db->init.busy) ){
  757.       sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
  758.       goto begin_table_error;
  759.     }
  760.   }
  761.   pTable = sqlite3DbMallocZero(db, sizeof(Table));
  762.   if( pTable==0 ){
  763.     db->mallocFailed = 1;
  764.     pParse->rc = SQLITE_NOMEM;
  765.     pParse->nErr++;
  766.     goto begin_table_error;
  767.   }
  768.   pTable->zName = zName;
  769.   pTable->iPKey = -1;
  770.   pTable->pSchema = db->aDb[iDb].pSchema;
  771.   pTable->nRef = 1;
  772.   if( pParse->pNewTable ) sqlite3DeleteTable(pParse->pNewTable);
  773.   pParse->pNewTable = pTable;
  774.   /* If this is the magic sqlite_sequence table used by autoincrement,
  775.   ** then record a pointer to this table in the main database structure
  776.   ** so that INSERT can find the table easily.
  777.   */
  778. #ifndef SQLITE_OMIT_AUTOINCREMENT
  779.   if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
  780.     pTable->pSchema->pSeqTab = pTable;
  781.   }
  782. #endif
  783.   /* Begin generating the code that will insert the table record into
  784.   ** the SQLITE_MASTER table.  Note in particular that we must go ahead
  785.   ** and allocate the record number for the table entry now.  Before any
  786.   ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
  787.   ** indices to be created and the table record must come before the 
  788.   ** indices.  Hence, the record number for the table must be allocated
  789.   ** now.
  790.   */
  791.   if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
  792.     int j1;
  793.     int fileFormat;
  794.     int reg1, reg2, reg3;
  795.     sqlite3BeginWriteOperation(pParse, 0, iDb);
  796. #ifndef SQLITE_OMIT_VIRTUALTABLE
  797.     if( isVirtual ){
  798.       sqlite3VdbeAddOp0(v, OP_VBegin);
  799.     }
  800. #endif
  801.     /* If the file format and encoding in the database have not been set, 
  802.     ** set them now.
  803.     */
  804.     reg1 = pParse->regRowid = ++pParse->nMem;
  805.     reg2 = pParse->regRoot = ++pParse->nMem;
  806.     reg3 = ++pParse->nMem;
  807.     sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, 1);   /* file_format */
  808.     sqlite3VdbeUsesBtree(v, iDb);
  809.     j1 = sqlite3VdbeAddOp1(v, OP_If, reg3);
  810.     fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
  811.                   1 : SQLITE_MAX_FILE_FORMAT;
  812.     sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);
  813.     sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 1, reg3);
  814.     sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
  815.     sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 4, reg3);
  816.     sqlite3VdbeJumpHere(v, j1);
  817.     /* This just creates a place-holder record in the sqlite_master table.
  818.     ** The record created does not contain anything yet.  It will be replaced
  819.     ** by the real entry in code generated at sqlite3EndTable().
  820.     **
  821.     ** The rowid for the new entry is left on the top of the stack.
  822.     ** The rowid value is needed by the code that sqlite3EndTable will
  823.     ** generate.
  824.     */
  825. #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
  826.     if( isView || isVirtual ){
  827.       sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
  828.     }else
  829. #endif
  830.     {
  831.       sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
  832.     }
  833.     sqlite3OpenMasterTable(pParse, iDb);
  834.     sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
  835.     sqlite3VdbeAddOp2(v, OP_Null, 0, reg3);
  836.     sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
  837.     sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
  838.     sqlite3VdbeAddOp0(v, OP_Close);
  839.   }
  840.   /* Normal (non-error) return. */
  841.   return;
  842.   /* If an error occurs, we jump here */
  843. begin_table_error:
  844.   sqlite3_free(zName);
  845.   return;
  846. }
  847. /*
  848. ** This macro is used to compare two strings in a case-insensitive manner.
  849. ** It is slightly faster than calling sqlite3StrICmp() directly, but
  850. ** produces larger code.
  851. **
  852. ** WARNING: This macro is not compatible with the strcmp() family. It
  853. ** returns true if the two strings are equal, otherwise false.
  854. */
  855. #define STRICMP(x, y) (
  856. sqlite3UpperToLower[*(unsigned char *)(x)]==   
  857. sqlite3UpperToLower[*(unsigned char *)(y)]     
  858. && sqlite3StrICmp((x)+1,(y)+1)==0 )
  859. /*
  860. ** Add a new column to the table currently being constructed.
  861. **
  862. ** The parser calls this routine once for each column declaration
  863. ** in a CREATE TABLE statement.  sqlite3StartTable() gets called
  864. ** first to get things going.  Then this routine is called for each
  865. ** column.
  866. */
  867. void sqlite3AddColumn(Parse *pParse, Token *pName){
  868.   Table *p;
  869.   int i;
  870.   char *z;
  871.   Column *pCol;
  872.   sqlite3 *db = pParse->db;
  873.   if( (p = pParse->pNewTable)==0 ) return;
  874. #if SQLITE_MAX_COLUMN
  875.   if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
  876.     sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
  877.     return;
  878.   }
  879. #endif
  880.   z = sqlite3NameFromToken(pParse->db, pName);
  881.   if( z==0 ) return;
  882.   for(i=0; i<p->nCol; i++){
  883.     if( STRICMP(z, p->aCol[i].zName) ){
  884.       sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
  885.       sqlite3_free(z);
  886.       return;
  887.     }
  888.   }
  889.   if( (p->nCol & 0x7)==0 ){
  890.     Column *aNew;
  891.     aNew = sqlite3DbRealloc(pParse->db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
  892.     if( aNew==0 ){
  893.       sqlite3_free(z);
  894.       return;
  895.     }
  896.     p->aCol = aNew;
  897.   }
  898.   pCol = &p->aCol[p->nCol];
  899.   memset(pCol, 0, sizeof(p->aCol[0]));
  900.   pCol->zName = z;
  901.  
  902.   /* If there is no type specified, columns have the default affinity
  903.   ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will
  904.   ** be called next to set pCol->affinity correctly.
  905.   */
  906.   pCol->affinity = SQLITE_AFF_NONE;
  907.   p->nCol++;
  908. }
  909. /*
  910. ** This routine is called by the parser while in the middle of
  911. ** parsing a CREATE TABLE statement.  A "NOT NULL" constraint has
  912. ** been seen on a column.  This routine sets the notNull flag on
  913. ** the column currently under construction.
  914. */
  915. void sqlite3AddNotNull(Parse *pParse, int onError){
  916.   Table *p;
  917.   int i;
  918.   if( (p = pParse->pNewTable)==0 ) return;
  919.   i = p->nCol-1;
  920.   if( i>=0 ) p->aCol[i].notNull = onError;
  921. }
  922. /*
  923. ** Scan the column type name zType (length nType) and return the
  924. ** associated affinity type.
  925. **
  926. ** This routine does a case-independent search of zType for the 
  927. ** substrings in the following table. If one of the substrings is
  928. ** found, the corresponding affinity is returned. If zType contains
  929. ** more than one of the substrings, entries toward the top of 
  930. ** the table take priority. For example, if zType is 'BLOBINT', 
  931. ** SQLITE_AFF_INTEGER is returned.
  932. **
  933. ** Substring     | Affinity
  934. ** --------------------------------
  935. ** 'INT'         | SQLITE_AFF_INTEGER
  936. ** 'CHAR'        | SQLITE_AFF_TEXT
  937. ** 'CLOB'        | SQLITE_AFF_TEXT
  938. ** 'TEXT'        | SQLITE_AFF_TEXT
  939. ** 'BLOB'        | SQLITE_AFF_NONE
  940. ** 'REAL'        | SQLITE_AFF_REAL
  941. ** 'FLOA'        | SQLITE_AFF_REAL
  942. ** 'DOUB'        | SQLITE_AFF_REAL
  943. **
  944. ** If none of the substrings in the above table are found,
  945. ** SQLITE_AFF_NUMERIC is returned.
  946. */
  947. char sqlite3AffinityType(const Token *pType){
  948.   u32 h = 0;
  949.   char aff = SQLITE_AFF_NUMERIC;
  950.   const unsigned char *zIn = pType->z;
  951.   const unsigned char *zEnd = &pType->z[pType->n];
  952.   while( zIn!=zEnd ){
  953.     h = (h<<8) + sqlite3UpperToLower[*zIn];
  954.     zIn++;
  955.     if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */
  956.       aff = SQLITE_AFF_TEXT; 
  957.     }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */
  958.       aff = SQLITE_AFF_TEXT;
  959.     }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){       /* TEXT */
  960.       aff = SQLITE_AFF_TEXT;
  961.     }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b')          /* BLOB */
  962.         && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
  963.       aff = SQLITE_AFF_NONE;
  964. #ifndef SQLITE_OMIT_FLOATING_POINT
  965.     }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l')          /* REAL */
  966.         && aff==SQLITE_AFF_NUMERIC ){
  967.       aff = SQLITE_AFF_REAL;
  968.     }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a')          /* FLOA */
  969.         && aff==SQLITE_AFF_NUMERIC ){
  970.       aff = SQLITE_AFF_REAL;
  971.     }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b')          /* DOUB */
  972.         && aff==SQLITE_AFF_NUMERIC ){
  973.       aff = SQLITE_AFF_REAL;
  974. #endif
  975.     }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){    /* INT */
  976.       aff = SQLITE_AFF_INTEGER;
  977.       break;
  978.     }
  979.   }
  980.   return aff;
  981. }
  982. /*
  983. ** This routine is called by the parser while in the middle of
  984. ** parsing a CREATE TABLE statement.  The pFirst token is the first
  985. ** token in the sequence of tokens that describe the type of the
  986. ** column currently under construction.   pLast is the last token
  987. ** in the sequence.  Use this information to construct a string
  988. ** that contains the typename of the column and store that string
  989. ** in zType.
  990. */ 
  991. void sqlite3AddColumnType(Parse *pParse, Token *pType){
  992.   Table *p;
  993.   int i;
  994.   Column *pCol;
  995.   if( (p = pParse->pNewTable)==0 ) return;
  996.   i = p->nCol-1;
  997.   if( i<0 ) return;
  998.   pCol = &p->aCol[i];
  999.   sqlite3_free(pCol->zType);
  1000.   pCol->zType = sqlite3NameFromToken(pParse->db, pType);
  1001.   pCol->affinity = sqlite3AffinityType(pType);
  1002. }
  1003. /*
  1004. ** The expression is the default value for the most recently added column
  1005. ** of the table currently under construction.
  1006. **
  1007. ** Default value expressions must be constant.  Raise an exception if this
  1008. ** is not the case.
  1009. **
  1010. ** This routine is called by the parser while in the middle of
  1011. ** parsing a CREATE TABLE statement.
  1012. */
  1013. void sqlite3AddDefaultValue(Parse *pParse, Expr *pExpr){
  1014.   Table *p;
  1015.   Column *pCol;
  1016.   if( (p = pParse->pNewTable)!=0 ){
  1017.     pCol = &(p->aCol[p->nCol-1]);
  1018.     if( !sqlite3ExprIsConstantOrFunction(pExpr) ){
  1019.       sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
  1020.           pCol->zName);
  1021.     }else{
  1022.       Expr *pCopy;
  1023.       sqlite3 *db = pParse->db;
  1024.       sqlite3ExprDelete(pCol->pDflt);
  1025.       pCol->pDflt = pCopy = sqlite3ExprDup(db, pExpr);
  1026.       if( pCopy ){
  1027.         sqlite3TokenCopy(db, &pCopy->span, &pExpr->span);
  1028.       }
  1029.     }
  1030.   }
  1031.   sqlite3ExprDelete(pExpr);
  1032. }
  1033. /*
  1034. ** Designate the PRIMARY KEY for the table.  pList is a list of names 
  1035. ** of columns that form the primary key.  If pList is NULL, then the
  1036. ** most recently added column of the table is the primary key.
  1037. **
  1038. ** A table can have at most one primary key.  If the table already has
  1039. ** a primary key (and this is the second primary key) then create an
  1040. ** error.
  1041. **
  1042. ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
  1043. ** then we will try to use that column as the rowid.  Set the Table.iPKey
  1044. ** field of the table under construction to be the index of the
  1045. ** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is
  1046. ** no INTEGER PRIMARY KEY.
  1047. **
  1048. ** If the key is not an INTEGER PRIMARY KEY, then create a unique
  1049. ** index for the key.  No index is created for INTEGER PRIMARY KEYs.
  1050. */
  1051. void sqlite3AddPrimaryKey(
  1052.   Parse *pParse,    /* Parsing context */
  1053.   ExprList *pList,  /* List of field names to be indexed */
  1054.   int onError,      /* What to do with a uniqueness conflict */
  1055.   int autoInc,      /* True if the AUTOINCREMENT keyword is present */
  1056.   int sortOrder     /* SQLITE_SO_ASC or SQLITE_SO_DESC */
  1057. ){
  1058.   Table *pTab = pParse->pNewTable;
  1059.   char *zType = 0;
  1060.   int iCol = -1, i;
  1061.   if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
  1062.   if( pTab->hasPrimKey ){
  1063.     sqlite3ErrorMsg(pParse, 
  1064.       "table "%s" has more than one primary key", pTab->zName);
  1065.     goto primary_key_exit;
  1066.   }
  1067.   pTab->hasPrimKey = 1;
  1068.   if( pList==0 ){
  1069.     iCol = pTab->nCol - 1;
  1070.     pTab->aCol[iCol].isPrimKey = 1;
  1071.   }else{
  1072.     for(i=0; i<pList->nExpr; i++){
  1073.       for(iCol=0; iCol<pTab->nCol; iCol++){
  1074.         if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
  1075.           break;
  1076.         }
  1077.       }
  1078.       if( iCol<pTab->nCol ){
  1079.         pTab->aCol[iCol].isPrimKey = 1;
  1080.       }
  1081.     }
  1082.     if( pList->nExpr>1 ) iCol = -1;
  1083.   }
  1084.   if( iCol>=0 && iCol<pTab->nCol ){
  1085.     zType = pTab->aCol[iCol].zType;
  1086.   }
  1087.   if( zType && sqlite3StrICmp(zType, "INTEGER")==0
  1088.         && sortOrder==SQLITE_SO_ASC ){
  1089.     pTab->iPKey = iCol;
  1090.     pTab->keyConf = onError;
  1091.     pTab->autoInc = autoInc;
  1092.   }else if( autoInc ){
  1093. #ifndef SQLITE_OMIT_AUTOINCREMENT
  1094.     sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
  1095.        "INTEGER PRIMARY KEY");
  1096. #endif
  1097.   }else{
  1098.     sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);
  1099.     pList = 0;
  1100.   }
  1101. primary_key_exit:
  1102.   sqlite3ExprListDelete(pList);
  1103.   return;
  1104. }
  1105. /*
  1106. ** Add a new CHECK constraint to the table currently under construction.
  1107. */
  1108. void sqlite3AddCheckConstraint(
  1109.   Parse *pParse,    /* Parsing context */
  1110.   Expr *pCheckExpr  /* The check expression */
  1111. ){
  1112. #ifndef SQLITE_OMIT_CHECK
  1113.   Table *pTab = pParse->pNewTable;
  1114.   sqlite3 *db = pParse->db;
  1115.   if( pTab && !IN_DECLARE_VTAB ){
  1116.     /* The CHECK expression must be duplicated so that tokens refer
  1117.     ** to malloced space and not the (ephemeral) text of the CREATE TABLE
  1118.     ** statement */
  1119.     pTab->pCheck = sqlite3ExprAnd(db, pTab->pCheck, 
  1120.                                   sqlite3ExprDup(db, pCheckExpr));
  1121.   }
  1122. #endif
  1123.   sqlite3ExprDelete(pCheckExpr);
  1124. }
  1125. /*
  1126. ** Set the collation function of the most recently parsed table column
  1127. ** to the CollSeq given.
  1128. */
  1129. void sqlite3AddCollateType(Parse *pParse, Token *pToken){
  1130.   Table *p;
  1131.   int i;
  1132.   char *zColl;              /* Dequoted name of collation sequence */
  1133.   if( (p = pParse->pNewTable)==0 ) return;
  1134.   i = p->nCol-1;
  1135.   zColl = sqlite3NameFromToken(pParse->db, pToken);
  1136.   if( !zColl ) return;
  1137.   if( sqlite3LocateCollSeq(pParse, zColl, -1) ){
  1138.     Index *pIdx;
  1139.     p->aCol[i].zColl = zColl;
  1140.   
  1141.     /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
  1142.     ** then an index may have been created on this column before the
  1143.     ** collation type was added. Correct this if it is the case.
  1144.     */
  1145.     for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
  1146.       assert( pIdx->nColumn==1 );
  1147.       if( pIdx->aiColumn[0]==i ){
  1148.         pIdx->azColl[0] = p->aCol[i].zColl;
  1149.       }
  1150.     }
  1151.   }else{
  1152.     sqlite3_free(zColl);
  1153.   }
  1154. }
  1155. /*
  1156. ** This function returns the collation sequence for database native text
  1157. ** encoding identified by the string zName, length nName.
  1158. **
  1159. ** If the requested collation sequence is not available, or not available
  1160. ** in the database native encoding, the collation factory is invoked to
  1161. ** request it. If the collation factory does not supply such a sequence,
  1162. ** and the sequence is available in another text encoding, then that is
  1163. ** returned instead.
  1164. **
  1165. ** If no versions of the requested collations sequence are available, or
  1166. ** another error occurs, NULL is returned and an error message written into
  1167. ** pParse.
  1168. **
  1169. ** This routine is a wrapper around sqlite3FindCollSeq().  This routine
  1170. ** invokes the collation factory if the named collation cannot be found
  1171. ** and generates an error message.
  1172. */
  1173. CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName, int nName){
  1174.   sqlite3 *db = pParse->db;
  1175.   u8 enc = ENC(db);
  1176.   u8 initbusy = db->init.busy;
  1177.   CollSeq *pColl;
  1178.   pColl = sqlite3FindCollSeq(db, enc, zName, nName, initbusy);
  1179.   if( !initbusy && (!pColl || !pColl->xCmp) ){
  1180.     pColl = sqlite3GetCollSeq(db, pColl, zName, nName);
  1181.     if( !pColl ){
  1182.       if( nName<0 ){
  1183.         nName = strlen(zName);
  1184.       }
  1185.       sqlite3ErrorMsg(pParse, "no such collation sequence: %.*s", nName, zName);
  1186.       pColl = 0;
  1187.     }
  1188.   }
  1189.   return pColl;
  1190. }
  1191. /*
  1192. ** Generate code that will increment the schema cookie.
  1193. **
  1194. ** The schema cookie is used to determine when the schema for the
  1195. ** database changes.  After each schema change, the cookie value
  1196. ** changes.  When a process first reads the schema it records the
  1197. ** cookie.  Thereafter, whenever it goes to access the database,
  1198. ** it checks the cookie to make sure the schema has not changed
  1199. ** since it was last read.
  1200. **
  1201. ** This plan is not completely bullet-proof.  It is possible for
  1202. ** the schema to change multiple times and for the cookie to be
  1203. ** set back to prior value.  But schema changes are infrequent
  1204. ** and the probability of hitting the same cookie value is only
  1205. ** 1 chance in 2^32.  So we're safe enough.
  1206. */
  1207. void sqlite3ChangeCookie(Parse *pParse, int iDb){
  1208.   int r1 = sqlite3GetTempReg(pParse);
  1209.   sqlite3 *db = pParse->db;
  1210.   Vdbe *v = pParse->pVdbe;
  1211.   sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
  1212.   sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 0, r1);
  1213.   sqlite3ReleaseTempReg(pParse, r1);
  1214. }
  1215. /*
  1216. ** Measure the number of characters needed to output the given
  1217. ** identifier.  The number returned includes any quotes used
  1218. ** but does not include the null terminator.
  1219. **
  1220. ** The estimate is conservative.  It might be larger that what is
  1221. ** really needed.
  1222. */
  1223. static int identLength(const char *z){
  1224.   int n;
  1225.   for(n=0; *z; n++, z++){
  1226.     if( *z=='"' ){ n++; }
  1227.   }
  1228.   return n + 2;
  1229. }
  1230. /*
  1231. ** Write an identifier onto the end of the given string.  Add
  1232. ** quote characters as needed.
  1233. */
  1234. static void identPut(char *z, int *pIdx, char *zSignedIdent){
  1235.   unsigned char *zIdent = (unsigned char*)zSignedIdent;
  1236.   int i, j, needQuote;
  1237.   i = *pIdx;
  1238.   for(j=0; zIdent[j]; j++){
  1239.     if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
  1240.   }
  1241.   needQuote =  zIdent[j]!=0 || isdigit(zIdent[0])
  1242.                   || sqlite3KeywordCode(zIdent, j)!=TK_ID;
  1243.   if( needQuote ) z[i++] = '"';
  1244.   for(j=0; zIdent[j]; j++){
  1245.     z[i++] = zIdent[j];
  1246.     if( zIdent[j]=='"' ) z[i++] = '"';
  1247.   }
  1248.   if( needQuote ) z[i++] = '"';
  1249.   z[i] = 0;
  1250.   *pIdx = i;
  1251. }
  1252. /*
  1253. ** Generate a CREATE TABLE statement appropriate for the given
  1254. ** table.  Memory to hold the text of the statement is obtained
  1255. ** from sqliteMalloc() and must be freed by the calling function.
  1256. */
  1257. static char *createTableStmt(sqlite3 *db, Table *p, int isTemp){
  1258.   int i, k, n;
  1259.   char *zStmt;
  1260.   char *zSep, *zSep2, *zEnd, *z;
  1261.   Column *pCol;
  1262.   n = 0;
  1263.   for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
  1264.     n += identLength(pCol->zName);
  1265.     z = pCol->zType;
  1266.     if( z ){
  1267.       n += (strlen(z) + 1);
  1268.     }
  1269.   }
  1270.   n += identLength(p->zName);
  1271.   if( n<50 ){
  1272.     zSep = "";
  1273.     zSep2 = ",";
  1274.     zEnd = ")";
  1275.   }else{
  1276.     zSep = "n  ";
  1277.     zSep2 = ",n  ";
  1278.     zEnd = "n)";
  1279.   }
  1280.   n += 35 + 6*p->nCol;
  1281.   zStmt = sqlite3_malloc( n );
  1282.   if( zStmt==0 ){
  1283.     db->mallocFailed = 1;
  1284.     return 0;
  1285.   }
  1286.   sqlite3_snprintf(n, zStmt,
  1287.                   !OMIT_TEMPDB&&isTemp ? "CREATE TEMP TABLE ":"CREATE TABLE ");
  1288.   k = strlen(zStmt);
  1289.   identPut(zStmt, &k, p->zName);
  1290.   zStmt[k++] = '(';
  1291.   for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
  1292.     sqlite3_snprintf(n-k, &zStmt[k], zSep);
  1293.     k += strlen(&zStmt[k]);
  1294.     zSep = zSep2;
  1295.     identPut(zStmt, &k, pCol->zName);
  1296.     if( (z = pCol->zType)!=0 ){
  1297.       zStmt[k++] = ' ';
  1298.       assert( strlen(z)+k+1<=n );
  1299.       sqlite3_snprintf(n-k, &zStmt[k], "%s", z);
  1300.       k += strlen(z);
  1301.     }
  1302.   }
  1303.   sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
  1304.   return zStmt;
  1305. }
  1306. /*
  1307. ** This routine is called to report the final ")" that terminates
  1308. ** a CREATE TABLE statement.
  1309. **
  1310. ** The table structure that other action routines have been building
  1311. ** is added to the internal hash tables, assuming no errors have
  1312. ** occurred.
  1313. **
  1314. ** An entry for the table is made in the master table on disk, unless
  1315. ** this is a temporary table or db->init.busy==1.  When db->init.busy==1
  1316. ** it means we are reading the sqlite_master table because we just
  1317. ** connected to the database or because the sqlite_master table has
  1318. ** recently changed, so the entry for this table already exists in
  1319. ** the sqlite_master table.  We do not want to create it again.
  1320. **
  1321. ** If the pSelect argument is not NULL, it means that this routine
  1322. ** was called to create a table generated from a 
  1323. ** "CREATE TABLE ... AS SELECT ..." statement.  The column names of
  1324. ** the new table will match the result set of the SELECT.
  1325. */
  1326. void sqlite3EndTable(
  1327.   Parse *pParse,          /* Parse context */
  1328.   Token *pCons,           /* The ',' token after the last column defn. */
  1329.   Token *pEnd,            /* The final ')' token in the CREATE TABLE */
  1330.   Select *pSelect         /* Select from a "CREATE ... AS SELECT" */
  1331. ){
  1332.   Table *p;
  1333.   sqlite3 *db = pParse->db;
  1334.   int iDb;
  1335.   if( (pEnd==0 && pSelect==0) || pParse->nErr || db->mallocFailed ) {
  1336.     return;
  1337.   }
  1338.   p = pParse->pNewTable;
  1339.   if( p==0 ) return;
  1340.   assert( !db->init.busy || !pSelect );
  1341.   iDb = sqlite3SchemaToIndex(db, p->pSchema);
  1342. #ifndef SQLITE_OMIT_CHECK
  1343.   /* Resolve names in all CHECK constraint expressions.
  1344.   */
  1345.   if( p->pCheck ){
  1346.     SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
  1347.     NameContext sNC;                /* Name context for pParse->pNewTable */
  1348.     memset(&sNC, 0, sizeof(sNC));
  1349.     memset(&sSrc, 0, sizeof(sSrc));
  1350.     sSrc.nSrc = 1;
  1351.     sSrc.a[0].zName = p->zName;
  1352.     sSrc.a[0].pTab = p;
  1353.     sSrc.a[0].iCursor = -1;
  1354.     sNC.pParse = pParse;
  1355.     sNC.pSrcList = &sSrc;
  1356.     sNC.isCheck = 1;
  1357.     if( sqlite3ExprResolveNames(&sNC, p->pCheck) ){
  1358.       return;
  1359.     }
  1360.   }
  1361. #endif /* !defined(SQLITE_OMIT_CHECK) */
  1362.   /* If the db->init.busy is 1 it means we are reading the SQL off the
  1363.   ** "sqlite_master" or "sqlite_temp_master" table on the disk.
  1364.   ** So do not write to the disk again.  Extract the root page number
  1365.   ** for the table from the db->init.newTnum field.  (The page number
  1366.   ** should have been put there by the sqliteOpenCb routine.)
  1367.   */
  1368.   if( db->init.busy ){
  1369.     p->tnum = db->init.newTnum;
  1370.   }
  1371.   /* If not initializing, then create a record for the new table
  1372.   ** in the SQLITE_MASTER table of the database.  The record number
  1373.   ** for the new table entry should already be on the stack.
  1374.   **
  1375.   ** If this is a TEMPORARY table, write the entry into the auxiliary
  1376.   ** file instead of into the main database file.
  1377.   */
  1378.   if( !db->init.busy ){
  1379.     int n;
  1380.     Vdbe *v;
  1381.     char *zType;    /* "view" or "table" */
  1382.     char *zType2;   /* "VIEW" or "TABLE" */
  1383.     char *zStmt;    /* Text of the CREATE TABLE or CREATE VIEW statement */
  1384.     v = sqlite3GetVdbe(pParse);
  1385.     if( v==0 ) return;
  1386.     sqlite3VdbeAddOp1(v, OP_Close, 0);
  1387.     /* Create the rootpage for the new table and push it onto the stack.
  1388.     ** A view has no rootpage, so just push a zero onto the stack for
  1389.     ** views.  Initialize zType at the same time.
  1390.     */
  1391.     if( p->pSelect==0 ){
  1392.       /* A regular table */
  1393.       zType = "table";
  1394.       zType2 = "TABLE";
  1395. #ifndef SQLITE_OMIT_VIEW
  1396.     }else{
  1397.       /* A view */
  1398.       zType = "view";
  1399.       zType2 = "VIEW";
  1400. #endif
  1401.     }
  1402.     /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
  1403.     ** statement to populate the new table. The root-page number for the
  1404.     ** new table is on the top of the vdbe stack.
  1405.     **
  1406.     ** Once the SELECT has been coded by sqlite3Select(), it is in a
  1407.     ** suitable state to query for the column names and types to be used
  1408.     ** by the new table.
  1409.     **
  1410.     ** A shared-cache write-lock is not required to write to the new table,
  1411.     ** as a schema-lock must have already been obtained to create it. Since
  1412.     ** a schema-lock excludes all other database users, the write-lock would
  1413.     ** be redundant.
  1414.     */
  1415.     if( pSelect ){
  1416.       SelectDest dest;
  1417.       Table *pSelTab;
  1418.       sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
  1419.       sqlite3VdbeChangeP5(v, 1);
  1420.       pParse->nTab = 2;
  1421.       sqlite3SelectDestInit(&dest, SRT_Table, 1);
  1422.       sqlite3Select(pParse, pSelect, &dest, 0, 0, 0, 0);
  1423.       sqlite3VdbeAddOp1(v, OP_Close, 1);
  1424.       if( pParse->nErr==0 ){
  1425.         pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSelect);
  1426.         if( pSelTab==0 ) return;
  1427.         assert( p->aCol==0 );
  1428.         p->nCol = pSelTab->nCol;
  1429.         p->aCol = pSelTab->aCol;
  1430.         pSelTab->nCol = 0;
  1431.         pSelTab->aCol = 0;
  1432.         sqlite3DeleteTable(pSelTab);
  1433.       }
  1434.     }
  1435.     /* Compute the complete text of the CREATE statement */
  1436.     if( pSelect ){
  1437.       zStmt = createTableStmt(db, p, p->pSchema==db->aDb[1].pSchema);
  1438.     }else{
  1439.       n = pEnd->z - pParse->sNameToken.z + 1;
  1440.       zStmt = sqlite3MPrintf(db, 
  1441.           "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
  1442.       );
  1443.     }
  1444.     /* A slot for the record has already been allocated in the 
  1445.     ** SQLITE_MASTER table.  We just need to update that slot with all
  1446.     ** the information we've collected.  The rowid for the preallocated
  1447.     ** slot is the 2nd item on the stack.  The top of the stack is the
  1448.     ** root page for the new table (or a 0 if this is a view).
  1449.     */
  1450.     sqlite3NestedParse(pParse,
  1451.       "UPDATE %Q.%s "
  1452.          "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
  1453.        "WHERE rowid=#%d",
  1454.       db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
  1455.       zType,
  1456.       p->zName,
  1457.       p->zName,
  1458.       pParse->regRoot,
  1459.       zStmt,
  1460.       pParse->regRowid
  1461.     );
  1462.     sqlite3_free(zStmt);
  1463.     sqlite3ChangeCookie(pParse, iDb);
  1464. #ifndef SQLITE_OMIT_AUTOINCREMENT
  1465.     /* Check to see if we need to create an sqlite_sequence table for
  1466.     ** keeping track of autoincrement keys.
  1467.     */
  1468.     if( p->autoInc ){
  1469.       Db *pDb = &db->aDb[iDb];
  1470.       if( pDb->pSchema->pSeqTab==0 ){
  1471.         sqlite3NestedParse(pParse,
  1472.           "CREATE TABLE %Q.sqlite_sequence(name,seq)",
  1473.           pDb->zName
  1474.         );
  1475.       }
  1476.     }
  1477. #endif
  1478.     /* Reparse everything to update our internal data structures */
  1479.     sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0,
  1480.         sqlite3MPrintf(db, "tbl_name='%q'",p->zName), P4_DYNAMIC);
  1481.   }
  1482.   /* Add the table to the in-memory representation of the database.
  1483.   */
  1484.   if( db->init.busy && pParse->nErr==0 ){
  1485.     Table *pOld;
  1486.     FKey *pFKey; 
  1487.     Schema *pSchema = p->pSchema;
  1488.     pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, strlen(p->zName)+1,p);
  1489.     if( pOld ){
  1490.       assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
  1491.       db->mallocFailed = 1;
  1492.       return;
  1493.     }
  1494. #ifndef SQLITE_OMIT_FOREIGN_KEY
  1495.     for(pFKey=p->pFKey; pFKey; pFKey=pFKey->pNextFrom){
  1496.       void *data;
  1497.       int nTo = strlen(pFKey->zTo) + 1;
  1498.       pFKey->pNextTo = sqlite3HashFind(&pSchema->aFKey, pFKey->zTo, nTo);
  1499.       data = sqlite3HashInsert(&pSchema->aFKey, pFKey->zTo, nTo, pFKey);
  1500.       if( data==(void *)pFKey ){
  1501.         db->mallocFailed = 1;
  1502.       }
  1503.     }
  1504. #endif
  1505.     pParse->pNewTable = 0;
  1506.     db->nTable++;
  1507.     db->flags |= SQLITE_InternChanges;
  1508. #ifndef SQLITE_OMIT_ALTERTABLE
  1509.     if( !p->pSelect ){
  1510.       const char *zName = (const char *)pParse->sNameToken.z;
  1511.       int nName;
  1512.       assert( !pSelect && pCons && pEnd );
  1513.       if( pCons->z==0 ){
  1514.         pCons = pEnd;
  1515.       }
  1516.       nName = (const char *)pCons->z - zName;
  1517.       p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
  1518.     }
  1519. #endif
  1520.   }
  1521. }
  1522. #ifndef SQLITE_OMIT_VIEW
  1523. /*
  1524. ** The parser calls this routine in order to create a new VIEW
  1525. */
  1526. void sqlite3CreateView(
  1527.   Parse *pParse,     /* The parsing context */
  1528.   Token *pBegin,     /* The CREATE token that begins the statement */
  1529.   Token *pName1,     /* The token that holds the name of the view */
  1530.   Token *pName2,     /* The token that holds the name of the view */
  1531.   Select *pSelect,   /* A SELECT statement that will become the new view */
  1532.   int isTemp,        /* TRUE for a TEMPORARY view */
  1533.   int noErr          /* Suppress error messages if VIEW already exists */
  1534. ){
  1535.   Table *p;
  1536.   int n;
  1537.   const unsigned char *z;
  1538.   Token sEnd;
  1539.   DbFixer sFix;
  1540.   Token *pName;
  1541.   int iDb;
  1542.   sqlite3 *db = pParse->db;
  1543.   if( pParse->nVar>0 ){
  1544.     sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
  1545.     sqlite3SelectDelete(pSelect);
  1546.     return;
  1547.   }
  1548.   sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
  1549.   p = pParse->pNewTable;
  1550.   if( p==0 || pParse->nErr ){
  1551.     sqlite3SelectDelete(pSelect);
  1552.     return;
  1553.   }
  1554.   sqlite3TwoPartName(pParse, pName1, pName2, &pName);
  1555.   iDb = sqlite3SchemaToIndex(db, p->pSchema);
  1556.   if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
  1557.     && sqlite3FixSelect(&sFix, pSelect)
  1558.   ){
  1559.     sqlite3SelectDelete(pSelect);
  1560.     return;
  1561.   }
  1562.   /* Make a copy of the entire SELECT statement that defines the view.
  1563.   ** This will force all the Expr.token.z values to be dynamically
  1564.   ** allocated rather than point to the input string - which means that
  1565.   ** they will persist after the current sqlite3_exec() call returns.
  1566.   */
  1567.   p->pSelect = sqlite3SelectDup(db, pSelect);
  1568.   sqlite3SelectDelete(pSelect);
  1569.   if( db->mallocFailed ){
  1570.     return;
  1571.   }
  1572.   if( !db->init.busy ){
  1573.     sqlite3ViewGetColumnNames(pParse, p);
  1574.   }
  1575.   /* Locate the end of the CREATE VIEW statement.  Make sEnd point to
  1576.   ** the end.
  1577.   */
  1578.   sEnd = pParse->sLastToken;
  1579.   if( sEnd.z[0]!=0 && sEnd.z[0]!=';' ){
  1580.     sEnd.z += sEnd.n;
  1581.   }
  1582.   sEnd.n = 0;
  1583.   n = sEnd.z - pBegin->z;
  1584.   z = (const unsigned char*)pBegin->z;
  1585.   while( n>0 && (z[n-1]==';' || isspace(z[n-1])) ){ n--; }
  1586.   sEnd.z = &z[n-1];
  1587.   sEnd.n = 1;
  1588.   /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
  1589.   sqlite3EndTable(pParse, 0, &sEnd, 0);
  1590.   return;
  1591. }
  1592. #endif /* SQLITE_OMIT_VIEW */
  1593. #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
  1594. /*
  1595. ** The Table structure pTable is really a VIEW.  Fill in the names of
  1596. ** the columns of the view in the pTable structure.  Return the number
  1597. ** of errors.  If an error is seen leave an error message in pParse->zErrMsg.
  1598. */
  1599. int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
  1600.   Table *pSelTab;   /* A fake table from which we get the result set */
  1601.   Select *pSel;     /* Copy of the SELECT that implements the view */
  1602.   int nErr = 0;     /* Number of errors encountered */
  1603.   int n;            /* Temporarily holds the number of cursors assigned */
  1604.   sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
  1605.   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
  1606.   assert( pTable );
  1607. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1608.   if( sqlite3VtabCallConnect(pParse, pTable) ){
  1609.     return SQLITE_ERROR;
  1610.   }
  1611.   if( IsVirtual(pTable) ) return 0;
  1612. #endif
  1613. #ifndef SQLITE_OMIT_VIEW
  1614.   /* A positive nCol means the columns names for this view are
  1615.   ** already known.
  1616.   */
  1617.   if( pTable->nCol>0 ) return 0;
  1618.   /* A negative nCol is a special marker meaning that we are currently
  1619.   ** trying to compute the column names.  If we enter this routine with
  1620.   ** a negative nCol, it means two or more views form a loop, like this:
  1621.   **
  1622.   **     CREATE VIEW one AS SELECT * FROM two;
  1623.   **     CREATE VIEW two AS SELECT * FROM one;
  1624.   **
  1625.   ** Actually, this error is caught previously and so the following test
  1626.   ** should always fail.  But we will leave it in place just to be safe.
  1627.   */
  1628.   if( pTable->nCol<0 ){
  1629.     sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
  1630.     return 1;
  1631.   }
  1632.   assert( pTable->nCol>=0 );
  1633.   /* If we get this far, it means we need to compute the table names.
  1634.   ** Note that the call to sqlite3ResultSetOfSelect() will expand any
  1635.   ** "*" elements in the results set of the view and will assign cursors
  1636.   ** to the elements of the FROM clause.  But we do not want these changes
  1637.   ** to be permanent.  So the computation is done on a copy of the SELECT
  1638.   ** statement that defines the view.
  1639.   */
  1640.   assert( pTable->pSelect );
  1641.   pSel = sqlite3SelectDup(db, pTable->pSelect);
  1642.   if( pSel ){
  1643.     n = pParse->nTab;
  1644.     sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
  1645.     pTable->nCol = -1;
  1646. #ifndef SQLITE_OMIT_AUTHORIZATION
  1647.     xAuth = db->xAuth;
  1648.     db->xAuth = 0;
  1649.     pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel);
  1650.     db->xAuth = xAuth;
  1651. #else
  1652.     pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel);
  1653. #endif
  1654.     pParse->nTab = n;
  1655.     if( pSelTab ){
  1656.       assert( pTable->aCol==0 );
  1657.       pTable->nCol = pSelTab->nCol;
  1658.       pTable->aCol = pSelTab->aCol;
  1659.       pSelTab->nCol = 0;
  1660.       pSelTab->aCol = 0;
  1661.       sqlite3DeleteTable(pSelTab);
  1662.       pTable->pSchema->flags |= DB_UnresetViews;
  1663.     }else{
  1664.       pTable->nCol = 0;
  1665.       nErr++;
  1666.     }
  1667.     sqlite3SelectDelete(pSel);
  1668.   } else {
  1669.     nErr++;
  1670.   }
  1671. #endif /* SQLITE_OMIT_VIEW */
  1672.   return nErr;  
  1673. }
  1674. #endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
  1675. #ifndef SQLITE_OMIT_VIEW
  1676. /*
  1677. ** Clear the column names from every VIEW in database idx.
  1678. */
  1679. static void sqliteViewResetAll(sqlite3 *db, int idx){
  1680.   HashElem *i;
  1681.   if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
  1682.   for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
  1683.     Table *pTab = sqliteHashData(i);
  1684.     if( pTab->pSelect ){
  1685.       sqliteResetColumnNames(pTab);
  1686.     }
  1687.   }
  1688.   DbClearProperty(db, idx, DB_UnresetViews);
  1689. }
  1690. #else
  1691. # define sqliteViewResetAll(A,B)
  1692. #endif /* SQLITE_OMIT_VIEW */
  1693. /*
  1694. ** This function is called by the VDBE to adjust the internal schema
  1695. ** used by SQLite when the btree layer moves a table root page. The
  1696. ** root-page of a table or index in database iDb has changed from iFrom
  1697. ** to iTo.
  1698. **
  1699. ** Ticket #1728:  The symbol table might still contain information
  1700. ** on tables and/or indices that are the process of being deleted.
  1701. ** If you are unlucky, one of those deleted indices or tables might
  1702. ** have the same rootpage number as the real table or index that is
  1703. ** being moved.  So we cannot stop searching after the first match 
  1704. ** because the first match might be for one of the deleted indices
  1705. ** or tables and not the table/index that is actually being moved.
  1706. ** We must continue looping until all tables and indices with
  1707. ** rootpage==iFrom have been converted to have a rootpage of iTo
  1708. ** in order to be certain that we got the right one.
  1709. */
  1710. #ifndef SQLITE_OMIT_AUTOVACUUM
  1711. void sqlite3RootPageMoved(Db *pDb, int iFrom, int iTo){
  1712.   HashElem *pElem;
  1713.   Hash *pHash;
  1714.   pHash = &pDb->pSchema->tblHash;
  1715.   for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
  1716.     Table *pTab = sqliteHashData(pElem);
  1717.     if( pTab->tnum==iFrom ){
  1718.       pTab->tnum = iTo;
  1719.     }
  1720.   }
  1721.   pHash = &pDb->pSchema->idxHash;
  1722.   for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
  1723.     Index *pIdx = sqliteHashData(pElem);
  1724.     if( pIdx->tnum==iFrom ){
  1725.       pIdx->tnum = iTo;
  1726.     }
  1727.   }
  1728. }
  1729. #endif
  1730. /*
  1731. ** Write code to erase the table with root-page iTable from database iDb.
  1732. ** Also write code to modify the sqlite_master table and internal schema
  1733. ** if a root-page of another table is moved by the btree-layer whilst
  1734. ** erasing iTable (this can happen with an auto-vacuum database).
  1735. */ 
  1736. static void destroyRootPage(Parse *pParse, int iTable, int iDb){
  1737.   Vdbe *v = sqlite3GetVdbe(pParse);
  1738.   int r1 = sqlite3GetTempReg(pParse);
  1739.   sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
  1740. #ifndef SQLITE_OMIT_AUTOVACUUM
  1741.   /* OP_Destroy stores an in integer r1. If this integer
  1742.   ** is non-zero, then it is the root page number of a table moved to
  1743.   ** location iTable. The following code modifies the sqlite_master table to
  1744.   ** reflect this.
  1745.   **
  1746.   ** The "#%d" in the SQL is a special constant that means whatever value
  1747.   ** is on the top of the stack.  See sqlite3RegisterExpr().
  1748.   */
  1749.   sqlite3NestedParse(pParse, 
  1750.      "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
  1751.      pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
  1752. #endif
  1753.   sqlite3ReleaseTempReg(pParse, r1);
  1754. }
  1755. /*
  1756. ** Write VDBE code to erase table pTab and all associated indices on disk.
  1757. ** Code to update the sqlite_master tables and internal schema definitions
  1758. ** in case a root-page belonging to another table is moved by the btree layer
  1759. ** is also added (this can happen with an auto-vacuum database).
  1760. */
  1761. static void destroyTable(Parse *pParse, Table *pTab){
  1762. #ifdef SQLITE_OMIT_AUTOVACUUM
  1763.   Index *pIdx;
  1764.   int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  1765.   destroyRootPage(pParse, pTab->tnum, iDb);
  1766.   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
  1767.     destroyRootPage(pParse, pIdx->tnum, iDb);
  1768.   }
  1769. #else
  1770.   /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
  1771.   ** is not defined), then it is important to call OP_Destroy on the
  1772.   ** table and index root-pages in order, starting with the numerically 
  1773.   ** largest root-page number. This guarantees that none of the root-pages
  1774.   ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
  1775.   ** following were coded:
  1776.   **
  1777.   ** OP_Destroy 4 0
  1778.   ** ...
  1779.   ** OP_Destroy 5 0
  1780.   **
  1781.   ** and root page 5 happened to be the largest root-page number in the
  1782.   ** database, then root page 5 would be moved to page 4 by the 
  1783.   ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
  1784.   ** a free-list page.
  1785.   */
  1786.   int iTab = pTab->tnum;
  1787.   int iDestroyed = 0;
  1788.   while( 1 ){
  1789.     Index *pIdx;
  1790.     int iLargest = 0;
  1791.     if( iDestroyed==0 || iTab<iDestroyed ){
  1792.       iLargest = iTab;
  1793.     }
  1794.     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
  1795.       int iIdx = pIdx->tnum;
  1796.       assert( pIdx->pSchema==pTab->pSchema );
  1797.       if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
  1798.         iLargest = iIdx;
  1799.       }
  1800.     }
  1801.     if( iLargest==0 ){
  1802.       return;
  1803.     }else{
  1804.       int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  1805.       destroyRootPage(pParse, iLargest, iDb);
  1806.       iDestroyed = iLargest;
  1807.     }
  1808.   }
  1809. #endif
  1810. }
  1811. /*
  1812. ** This routine is called to do the work of a DROP TABLE statement.
  1813. ** pName is the name of the table to be dropped.
  1814. */
  1815. void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
  1816.   Table *pTab;
  1817.   Vdbe *v;
  1818.   sqlite3 *db = pParse->db;
  1819.   int iDb;
  1820.   if( pParse->nErr || db->mallocFailed ){
  1821.     goto exit_drop_table;
  1822.   }
  1823.   assert( pName->nSrc==1 );
  1824.   pTab = sqlite3LocateTable(pParse, isView, 
  1825.                             pName->a[0].zName, pName->a[0].zDatabase);
  1826.   if( pTab==0 ){
  1827.     if( noErr ){
  1828.       sqlite3ErrorClear(pParse);
  1829.     }
  1830.     goto exit_drop_table;
  1831.   }
  1832.   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  1833.   assert( iDb>=0 && iDb<db->nDb );
  1834.   /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
  1835.   ** it is initialized.
  1836.   */
  1837.   if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
  1838.     goto exit_drop_table;
  1839.   }
  1840. #ifndef SQLITE_OMIT_AUTHORIZATION
  1841.   {
  1842.     int code;
  1843.     const char *zTab = SCHEMA_TABLE(iDb);
  1844.     const char *zDb = db->aDb[iDb].zName;
  1845.     const char *zArg2 = 0;
  1846.     if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
  1847.       goto exit_drop_table;
  1848.     }
  1849.     if( isView ){
  1850.       if( !OMIT_TEMPDB && iDb==1 ){
  1851.         code = SQLITE_DROP_TEMP_VIEW;
  1852.       }else{
  1853.         code = SQLITE_DROP_VIEW;
  1854.       }
  1855. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1856.     }else if( IsVirtual(pTab) ){
  1857.       code = SQLITE_DROP_VTABLE;
  1858.       zArg2 = pTab->pMod->zName;
  1859. #endif
  1860.     }else{
  1861.       if( !OMIT_TEMPDB && iDb==1 ){
  1862.         code = SQLITE_DROP_TEMP_TABLE;
  1863.       }else{
  1864.         code = SQLITE_DROP_TABLE;
  1865.       }
  1866.     }
  1867.     if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
  1868.       goto exit_drop_table;
  1869.     }
  1870.     if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
  1871.       goto exit_drop_table;
  1872.     }
  1873.   }
  1874. #endif
  1875.   if( pTab->readOnly || pTab==db->aDb[iDb].pSchema->pSeqTab ){
  1876.     sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
  1877.     goto exit_drop_table;
  1878.   }
  1879. #ifndef SQLITE_OMIT_VIEW
  1880.   /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
  1881.   ** on a table.
  1882.   */
  1883.   if( isView && pTab->pSelect==0 ){
  1884.     sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
  1885.     goto exit_drop_table;
  1886.   }
  1887.   if( !isView && pTab->pSelect ){
  1888.     sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
  1889.     goto exit_drop_table;
  1890.   }
  1891. #endif
  1892.   /* Generate code to remove the table from the master table
  1893.   ** on disk.
  1894.   */
  1895.   v = sqlite3GetVdbe(pParse);
  1896.   if( v ){
  1897.     Trigger *pTrigger;
  1898.     Db *pDb = &db->aDb[iDb];
  1899.     sqlite3BeginWriteOperation(pParse, 1, iDb);
  1900. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1901.     if( IsVirtual(pTab) ){
  1902.       Vdbe *v = sqlite3GetVdbe(pParse);
  1903.       if( v ){
  1904.         sqlite3VdbeAddOp0(v, OP_VBegin);
  1905.       }
  1906.     }
  1907. #endif
  1908.     /* Drop all triggers associated with the table being dropped. Code
  1909.     ** is generated to remove entries from sqlite_master and/or
  1910.     ** sqlite_temp_master if required.
  1911.     */
  1912.     pTrigger = pTab->pTrigger;
  1913.     while( pTrigger ){
  1914.       assert( pTrigger->pSchema==pTab->pSchema || 
  1915.           pTrigger->pSchema==db->aDb[1].pSchema );
  1916.       sqlite3DropTriggerPtr(pParse, pTrigger);
  1917.       pTrigger = pTrigger->pNext;
  1918.     }
  1919. #ifndef SQLITE_OMIT_AUTOINCREMENT
  1920.     /* Remove any entries of the sqlite_sequence table associated with
  1921.     ** the table being dropped. This is done before the table is dropped
  1922.     ** at the btree level, in case the sqlite_sequence table needs to
  1923.     ** move as a result of the drop (can happen in auto-vacuum mode).
  1924.     */
  1925.     if( pTab->autoInc ){
  1926.       sqlite3NestedParse(pParse,
  1927.         "DELETE FROM %s.sqlite_sequence WHERE name=%Q",
  1928.         pDb->zName, pTab->zName
  1929.       );
  1930.     }
  1931. #endif
  1932.     /* Drop all SQLITE_MASTER table and index entries that refer to the
  1933.     ** table. The program name loops through the master table and deletes
  1934.     ** every row that refers to a table of the same name as the one being
  1935.     ** dropped. Triggers are handled seperately because a trigger can be
  1936.     ** created in the temp database that refers to a table in another
  1937.     ** database.
  1938.     */
  1939.     sqlite3NestedParse(pParse, 
  1940.         "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
  1941.         pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
  1942.     /* Drop any statistics from the sqlite_stat1 table, if it exists */
  1943.     if( sqlite3FindTable(db, "sqlite_stat1", db->aDb[iDb].zName) ){
  1944.       sqlite3NestedParse(pParse,
  1945.         "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q", pDb->zName, pTab->zName
  1946.       );
  1947.     }
  1948.     if( !isView && !IsVirtual(pTab) ){
  1949.       destroyTable(pParse, pTab);
  1950.     }
  1951.     /* Remove the table entry from SQLite's internal schema and modify
  1952.     ** the schema cookie.
  1953.     */
  1954.     if( IsVirtual(pTab) ){
  1955.       sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
  1956.     }
  1957.     sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
  1958.     sqlite3ChangeCookie(pParse, iDb);
  1959.   }
  1960.   sqliteViewResetAll(db, iDb);
  1961. exit_drop_table:
  1962.   sqlite3SrcListDelete(pName);
  1963. }
  1964. /*
  1965. ** This routine is called to create a new foreign key on the table
  1966. ** currently under construction.  pFromCol determines which columns
  1967. ** in the current table point to the foreign key.  If pFromCol==0 then
  1968. ** connect the key to the last column inserted.  pTo is the name of
  1969. ** the table referred to.  pToCol is a list of tables in the other
  1970. ** pTo table that the foreign key points to.  flags contains all
  1971. ** information about the conflict resolution algorithms specified
  1972. ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
  1973. **
  1974. ** An FKey structure is created and added to the table currently
  1975. ** under construction in the pParse->pNewTable field.  The new FKey
  1976. ** is not linked into db->aFKey at this point - that does not happen
  1977. ** until sqlite3EndTable().
  1978. **
  1979. ** The foreign key is set for IMMEDIATE processing.  A subsequent call
  1980. ** to sqlite3DeferForeignKey() might change this to DEFERRED.
  1981. */
  1982. void sqlite3CreateForeignKey(
  1983.   Parse *pParse,       /* Parsing context */
  1984.   ExprList *pFromCol,  /* Columns in this table that point to other table */
  1985.   Token *pTo,          /* Name of the other table */
  1986.   ExprList *pToCol,    /* Columns in the other table */
  1987.   int flags            /* Conflict resolution algorithms. */
  1988. ){
  1989. #ifndef SQLITE_OMIT_FOREIGN_KEY
  1990.   FKey *pFKey = 0;
  1991.   Table *p = pParse->pNewTable;
  1992.   int nByte;
  1993.   int i;
  1994.   int nCol;
  1995.   char *z;
  1996.   assert( pTo!=0 );
  1997.   if( p==0 || pParse->nErr || IN_DECLARE_VTAB ) goto fk_end;
  1998.   if( pFromCol==0 ){
  1999.     int iCol = p->nCol-1;
  2000.     if( iCol<0 ) goto fk_end;
  2001.     if( pToCol && pToCol->nExpr!=1 ){
  2002.       sqlite3ErrorMsg(pParse, "foreign key on %s"
  2003.          " should reference only one column of table %T",
  2004.          p->aCol[iCol].zName, pTo);
  2005.       goto fk_end;
  2006.     }
  2007.     nCol = 1;
  2008.   }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
  2009.     sqlite3ErrorMsg(pParse,
  2010.         "number of columns in foreign key does not match the number of "
  2011.         "columns in the referenced table");
  2012.     goto fk_end;
  2013.   }else{
  2014.     nCol = pFromCol->nExpr;
  2015.   }
  2016.   nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1;
  2017.   if( pToCol ){
  2018.     for(i=0; i<pToCol->nExpr; i++){
  2019.       nByte += strlen(pToCol->a[i].zName) + 1;
  2020.     }
  2021.   }
  2022.   pFKey = sqlite3DbMallocZero(pParse->db, nByte );
  2023.   if( pFKey==0 ){
  2024.     goto fk_end;
  2025.   }
  2026.   pFKey->pFrom = p;
  2027.   pFKey->pNextFrom = p->pFKey;
  2028.   z = (char*)&pFKey[1];
  2029.   pFKey->aCol = (struct sColMap*)z;
  2030.   z += sizeof(struct sColMap)*nCol;
  2031.   pFKey->zTo = z;
  2032.   memcpy(z, pTo->z, pTo->n);
  2033.   z[pTo->n] = 0;
  2034.   z += pTo->n+1;
  2035.   pFKey->pNextTo = 0;
  2036.   pFKey->nCol = nCol;
  2037.   if( pFromCol==0 ){
  2038.     pFKey->aCol[0].iFrom = p->nCol-1;
  2039.   }else{
  2040.     for(i=0; i<nCol; i++){
  2041.       int j;
  2042.       for(j=0; j<p->nCol; j++){
  2043.         if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
  2044.           pFKey->aCol[i].iFrom = j;
  2045.           break;
  2046.         }
  2047.       }
  2048.       if( j>=p->nCol ){
  2049.         sqlite3ErrorMsg(pParse, 
  2050.           "unknown column "%s" in foreign key definition", 
  2051.           pFromCol->a[i].zName);
  2052.         goto fk_end;
  2053.       }
  2054.     }
  2055.   }
  2056.   if( pToCol ){
  2057.     for(i=0; i<nCol; i++){
  2058.       int n = strlen(pToCol->a[i].zName);
  2059.       pFKey->aCol[i].zCol = z;
  2060.       memcpy(z, pToCol->a[i].zName, n);
  2061.       z[n] = 0;
  2062.       z += n+1;
  2063.     }
  2064.   }
  2065.   pFKey->isDeferred = 0;
  2066.   pFKey->deleteConf = flags & 0xff;
  2067.   pFKey->updateConf = (flags >> 8 ) & 0xff;
  2068.   pFKey->insertConf = (flags >> 16 ) & 0xff;
  2069.   /* Link the foreign key to the table as the last step.
  2070.   */
  2071.   p->pFKey = pFKey;
  2072.   pFKey = 0;
  2073. fk_end:
  2074.   sqlite3_free(pFKey);
  2075. #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
  2076.   sqlite3ExprListDelete(pFromCol);
  2077.   sqlite3ExprListDelete(pToCol);
  2078. }
  2079. /*
  2080. ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
  2081. ** clause is seen as part of a foreign key definition.  The isDeferred
  2082. ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
  2083. ** The behavior of the most recently created foreign key is adjusted
  2084. ** accordingly.
  2085. */
  2086. void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
  2087. #ifndef SQLITE_OMIT_FOREIGN_KEY
  2088.   Table *pTab;
  2089.   FKey *pFKey;
  2090.   if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
  2091.   pFKey->isDeferred = isDeferred;
  2092. #endif
  2093. }
  2094. /*
  2095. ** Generate code that will erase and refill index *pIdx.  This is
  2096. ** used to initialize a newly created index or to recompute the
  2097. ** content of an index in response to a REINDEX command.
  2098. **
  2099. ** if memRootPage is not negative, it means that the index is newly
  2100. ** created.  The register specified by memRootPage contains the
  2101. ** root page number of the index.  If memRootPage is negative, then
  2102. ** the index already exists and must be cleared before being refilled and
  2103. ** the root page number of the index is taken from pIndex->tnum.
  2104. */
  2105. static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
  2106.   Table *pTab = pIndex->pTable;  /* The table that is indexed */
  2107.   int iTab = pParse->nTab;       /* Btree cursor used for pTab */
  2108.   int iIdx = pParse->nTab+1;     /* Btree cursor used for pIndex */
  2109.   int addr1;                     /* Address of top of loop */
  2110.   int tnum;                      /* Root page of index */
  2111.   Vdbe *v;                       /* Generate code into this virtual machine */
  2112.   KeyInfo *pKey;                 /* KeyInfo for index */
  2113.   int regIdxKey;                 /* Registers containing the index key */
  2114.   int regRecord;                 /* Register holding assemblied index record */
  2115.   sqlite3 *db = pParse->db;      /* The database connection */
  2116.   int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
  2117. #ifndef SQLITE_OMIT_AUTHORIZATION
  2118.   if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
  2119.       db->aDb[iDb].zName ) ){
  2120.     return;
  2121.   }
  2122. #endif
  2123.   /* Require a write-lock on the table to perform this operation */
  2124.   sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
  2125.   v = sqlite3GetVdbe(pParse);
  2126.   if( v==0 ) return;
  2127.   if( memRootPage>=0 ){
  2128.     tnum = memRootPage;
  2129.   }else{
  2130.     tnum = pIndex->tnum;
  2131.     sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
  2132.   }
  2133.   pKey = sqlite3IndexKeyinfo(pParse, pIndex);
  2134.   sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb, 
  2135.                     (char *)pKey, P4_KEYINFO_HANDOFF);
  2136.   if( memRootPage>=0 ){
  2137.     sqlite3VdbeChangeP5(v, 1);
  2138.   }
  2139.   sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
  2140.   addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
  2141.   regRecord = sqlite3GetTempReg(pParse);
  2142.   regIdxKey = sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
  2143.   if( pIndex->onError!=OE_None ){
  2144.     int j1, j2;
  2145.     int regRowid;
  2146.     regRowid = regIdxKey + pIndex->nColumn;
  2147.     j1 = sqlite3VdbeAddOp3(v, OP_IsNull, regIdxKey, 0, pIndex->nColumn);
  2148.     j2 = sqlite3VdbeAddOp4(v, OP_IsUnique, iIdx,
  2149.                            0, regRowid, (char*)(sqlite3_intptr_t)regRecord, P4_INT32);
  2150.     sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, OE_Abort, 0,
  2151.                     "indexed columns are not unique", P4_STATIC);
  2152.     sqlite3VdbeJumpHere(v, j1);
  2153.     sqlite3VdbeJumpHere(v, j2);
  2154.   }
  2155.   sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
  2156.   sqlite3ReleaseTempReg(pParse, regRecord);
  2157.   sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1);
  2158.   sqlite3VdbeJumpHere(v, addr1);
  2159.   sqlite3VdbeAddOp1(v, OP_Close, iTab);
  2160.   sqlite3VdbeAddOp1(v, OP_Close, iIdx);
  2161. }
  2162. /*
  2163. ** Create a new index for an SQL table.  pName1.pName2 is the name of the index 
  2164. ** and pTblList is the name of the table that is to be indexed.  Both will 
  2165. ** be NULL for a primary key or an index that is created to satisfy a
  2166. ** UNIQUE constraint.  If pTable and pIndex are NULL, use pParse->pNewTable
  2167. ** as the table to be indexed.  pParse->pNewTable is a table that is
  2168. ** currently being constructed by a CREATE TABLE statement.
  2169. **
  2170. ** pList is a list of columns to be indexed.  pList will be NULL if this
  2171. ** is a primary key or unique-constraint on the most recent column added
  2172. ** to the table currently under construction.  
  2173. */
  2174. void sqlite3CreateIndex(
  2175.   Parse *pParse,     /* All information about this parse */
  2176.   Token *pName1,     /* First part of index name. May be NULL */
  2177.   Token *pName2,     /* Second part of index name. May be NULL */
  2178.   SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
  2179.   ExprList *pList,   /* A list of columns to be indexed */
  2180.   int onError,       /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
  2181.   Token *pStart,     /* The CREATE token that begins this statement */
  2182.   Token *pEnd,       /* The ")" that closes the CREATE INDEX statement */
  2183.   int sortOrder,     /* Sort order of primary key when pList==NULL */
  2184.   int ifNotExist     /* Omit error if index already exists */
  2185. ){
  2186.   Table *pTab = 0;     /* Table to be indexed */
  2187.   Index *pIndex = 0;   /* The index to be created */
  2188.   char *zName = 0;     /* Name of the index */
  2189.   int nName;           /* Number of characters in zName */
  2190.   int i, j;
  2191.   Token nullId;        /* Fake token for an empty ID list */
  2192.   DbFixer sFix;        /* For assigning database names to pTable */
  2193.   int sortOrderMask;   /* 1 to honor DESC in index.  0 to ignore. */
  2194.   sqlite3 *db = pParse->db;
  2195.   Db *pDb;             /* The specific table containing the indexed database */
  2196.   int iDb;             /* Index of the database that is being written */
  2197.   Token *pName = 0;    /* Unqualified name of the index to create */
  2198.   struct ExprList_item *pListItem; /* For looping over pList */
  2199.   int nCol;
  2200.   int nExtra = 0;
  2201.   char *zExtra;
  2202.   if( pParse->nErr || db->mallocFailed || IN_DECLARE_VTAB ){
  2203.     goto exit_create_index;
  2204.   }
  2205.   /*
  2206.   ** Find the table that is to be indexed.  Return early if not found.
  2207.   */
  2208.   if( pTblName!=0 ){
  2209.     /* Use the two-part index name to determine the database 
  2210.     ** to search for the table. 'Fix' the table name to this db
  2211.     ** before looking up the table.
  2212.     */
  2213.     assert( pName1 && pName2 );
  2214.     iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
  2215.     if( iDb<0 ) goto exit_create_index;
  2216. #ifndef SQLITE_OMIT_TEMPDB
  2217.     /* If the index name was unqualified, check if the the table
  2218.     ** is a temp table. If so, set the database to 1. Do not do this
  2219.     ** if initialising a database schema.
  2220.     */
  2221.     if( !db->init.busy ){
  2222.       pTab = sqlite3SrcListLookup(pParse, pTblName);
  2223.       if( pName2 && pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
  2224.         iDb = 1;
  2225.       }
  2226.     }
  2227. #endif
  2228.     if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
  2229.         sqlite3FixSrcList(&sFix, pTblName)
  2230.     ){
  2231.       /* Because the parser constructs pTblName from a single identifier,
  2232.       ** sqlite3FixSrcList can never fail. */
  2233.       assert(0);
  2234.     }
  2235.     pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName, 
  2236.         pTblName->a[0].zDatabase);
  2237.     if( !pTab ) goto exit_create_index;
  2238.     assert( db->aDb[iDb].pSchema==pTab->pSchema );
  2239.   }else{
  2240.     assert( pName==0 );
  2241.     pTab = pParse->pNewTable;
  2242.     if( !pTab ) goto exit_create_index;
  2243.     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  2244.   }
  2245.   pDb = &db->aDb[iDb];
  2246.   if( pTab==0 || pParse->nErr ) goto exit_create_index;
  2247.   if( pTab->readOnly ){
  2248.     sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
  2249.     goto exit_create_index;
  2250.   }
  2251. #ifndef SQLITE_OMIT_VIEW
  2252.   if( pTab->pSelect ){
  2253.     sqlite3ErrorMsg(pParse, "views may not be indexed");
  2254.     goto exit_create_index;
  2255.   }
  2256. #endif
  2257. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2258.   if( IsVirtual(pTab) ){
  2259.     sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
  2260.     goto exit_create_index;
  2261.   }
  2262. #endif
  2263.   /*
  2264.   ** Find the name of the index.  Make sure there is not already another
  2265.   ** index or table with the same name.  
  2266.   **
  2267.   ** Exception:  If we are reading the names of permanent indices from the
  2268.   ** sqlite_master table (because some other process changed the schema) and
  2269.   ** one of the index names collides with the name of a temporary table or
  2270.   ** index, then we will continue to process this index.
  2271.   **
  2272.   ** If pName==0 it means that we are
  2273.   ** dealing with a primary key or UNIQUE constraint.  We have to invent our
  2274.   ** own name.
  2275.   */
  2276.   if( pName ){
  2277.     zName = sqlite3NameFromToken(db, pName);
  2278.     if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index;
  2279.     if( zName==0 ) goto exit_create_index;
  2280.     if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
  2281.       goto exit_create_index;
  2282.     }
  2283.     if( !db->init.busy ){
  2284.       if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index;
  2285.       if( sqlite3FindTable(db, zName, 0)!=0 ){
  2286.         sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
  2287.         goto exit_create_index;
  2288.       }
  2289.     }
  2290.     if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
  2291.       if( !ifNotExist ){
  2292.         sqlite3ErrorMsg(pParse, "index %s already exists", zName);
  2293.       }
  2294.       goto exit_create_index;
  2295.     }
  2296.   }else{
  2297.     char zBuf[30];
  2298.     int n;
  2299.     Index *pLoop;
  2300.     for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
  2301.     sqlite3_snprintf(sizeof(zBuf),zBuf,"_%d",n);
  2302.     zName = 0;
  2303.     sqlite3SetString(&zName, "sqlite_autoindex_", pTab->zName, zBuf, (char*)0);
  2304.     if( zName==0 ){
  2305.       db->mallocFailed = 1;
  2306.       goto exit_create_index;
  2307.     }
  2308.   }
  2309.   /* Check for authorization to create an index.
  2310.   */
  2311. #ifndef SQLITE_OMIT_AUTHORIZATION
  2312.   {
  2313.     const char *zDb = pDb->zName;
  2314.     if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
  2315.       goto exit_create_index;
  2316.     }
  2317.     i = SQLITE_CREATE_INDEX;
  2318.     if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
  2319.     if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
  2320.       goto exit_create_index;
  2321.     }
  2322.   }
  2323. #endif
  2324.   /* If pList==0, it means this routine was called to make a primary
  2325.   ** key out of the last column added to the table under construction.
  2326.   ** So create a fake list to simulate this.
  2327.   */
  2328.   if( pList==0 ){
  2329.     nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName;
  2330.     nullId.n = strlen((char*)nullId.z);
  2331.     pList = sqlite3ExprListAppend(pParse, 0, 0, &nullId);
  2332.     if( pList==0 ) goto exit_create_index;
  2333.     pList->a[0].sortOrder = sortOrder;
  2334.   }
  2335.   /* Figure out how many bytes of space are required to store explicitly
  2336.   ** specified collation sequence names.
  2337.   */
  2338.   for(i=0; i<pList->nExpr; i++){
  2339.     Expr *pExpr = pList->a[i].pExpr;
  2340.     if( pExpr ){
  2341.       nExtra += (1 + strlen(pExpr->pColl->zName));
  2342.     }
  2343.   }
  2344.   /* 
  2345.   ** Allocate the index structure. 
  2346.   */
  2347.   nName = strlen(zName);
  2348.   nCol = pList->nExpr;
  2349.   pIndex = sqlite3DbMallocZero(db, 
  2350.       sizeof(Index) +              /* Index structure  */
  2351.       sizeof(int)*nCol +           /* Index.aiColumn   */
  2352.       sizeof(int)*(nCol+1) +       /* Index.aiRowEst   */
  2353.       sizeof(char *)*nCol +        /* Index.azColl     */
  2354.       sizeof(u8)*nCol +            /* Index.aSortOrder */
  2355.       nName + 1 +                  /* Index.zName      */
  2356.       nExtra                       /* Collation sequence names */
  2357.   );
  2358.   if( db->mallocFailed ){
  2359.     goto exit_create_index;
  2360.   }
  2361.   pIndex->azColl = (char**)(&pIndex[1]);
  2362.   pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
  2363.   pIndex->aiRowEst = (unsigned *)(&pIndex->aiColumn[nCol]);
  2364.   pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]);
  2365.   pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
  2366.   zExtra = (char *)(&pIndex->zName[nName+1]);
  2367.   memcpy(pIndex->zName, zName, nName+1);
  2368.   pIndex->pTable = pTab;
  2369.   pIndex->nColumn = pList->nExpr;
  2370.   pIndex->onError = onError;
  2371.   pIndex->autoIndex = pName==0;
  2372.   pIndex->pSchema = db->aDb[iDb].pSchema;
  2373.   /* Check to see if we should honor DESC requests on index columns
  2374.   */
  2375.   if( pDb->pSchema->file_format>=4 ){
  2376.     sortOrderMask = -1;   /* Honor DESC */
  2377.   }else{
  2378.     sortOrderMask = 0;    /* Ignore DESC */
  2379.   }
  2380.   /* Scan the names of the columns of the table to be indexed and
  2381.   ** load the column indices into the Index structure.  Report an error
  2382.   ** if any column is not found.
  2383.   */
  2384.   for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
  2385.     const char *zColName = pListItem->zName;
  2386.     Column *pTabCol;
  2387.     int requestedSortOrder;
  2388.     char *zColl;                   /* Collation sequence name */
  2389.     for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
  2390.       if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
  2391.     }
  2392.     if( j>=pTab->nCol ){
  2393.       sqlite3ErrorMsg(pParse, "table %s has no column named %s",
  2394.         pTab->zName, zColName);
  2395.       goto exit_create_index;
  2396.     }
  2397.     /* TODO:  Add a test to make sure that the same column is not named
  2398.     ** more than once within the same index.  Only the first instance of
  2399.     ** the column will ever be used by the optimizer.  Note that using the
  2400.     ** same column more than once cannot be an error because that would 
  2401.     ** break backwards compatibility - it needs to be a warning.
  2402.     */
  2403.     pIndex->aiColumn[i] = j;
  2404.     if( pListItem->pExpr ){
  2405.       assert( pListItem->pExpr->pColl );
  2406.       zColl = zExtra;
  2407.       sqlite3_snprintf(nExtra, zExtra, "%s", pListItem->pExpr->pColl->zName);
  2408.       zExtra += (strlen(zColl) + 1);
  2409.     }else{
  2410.       zColl = pTab->aCol[j].zColl;
  2411.       if( !zColl ){
  2412.         zColl = db->pDfltColl->zName;
  2413.       }
  2414.     }
  2415.     if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl, -1) ){
  2416.       goto exit_create_index;
  2417.     }
  2418.     pIndex->azColl[i] = zColl;
  2419.     requestedSortOrder = pListItem->sortOrder & sortOrderMask;
  2420.     pIndex->aSortOrder[i] = requestedSortOrder;
  2421.   }
  2422.   sqlite3DefaultRowEst(pIndex);
  2423.   if( pTab==pParse->pNewTable ){
  2424.     /* This routine has been called to create an automatic index as a
  2425.     ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
  2426.     ** a PRIMARY KEY or UNIQUE clause following the column definitions.
  2427.     ** i.e. one of:
  2428.     **
  2429.     ** CREATE TABLE t(x PRIMARY KEY, y);
  2430.     ** CREATE TABLE t(x, y, UNIQUE(x, y));
  2431.     **
  2432.     ** Either way, check to see if the table already has such an index. If
  2433.     ** so, don't bother creating this one. This only applies to
  2434.     ** automatically created indices. Users can do as they wish with
  2435.     ** explicit indices.
  2436.     */
  2437.     Index *pIdx;
  2438.     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
  2439.       int k;
  2440.       assert( pIdx->onError!=OE_None );
  2441.       assert( pIdx->autoIndex );
  2442.       assert( pIndex->onError!=OE_None );
  2443.       if( pIdx->nColumn!=pIndex->nColumn ) continue;
  2444.       for(k=0; k<pIdx->nColumn; k++){
  2445.         const char *z1 = pIdx->azColl[k];
  2446.         const char *z2 = pIndex->azColl[k];
  2447.         if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
  2448.         if( pIdx->aSortOrder[k]!=pIndex->aSortOrder[k] ) break;
  2449.         if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break;
  2450.       }
  2451.       if( k==pIdx->nColumn ){
  2452.         if( pIdx->onError!=pIndex->onError ){
  2453.           /* This constraint creates the same index as a previous
  2454.           ** constraint specified somewhere in the CREATE TABLE statement.
  2455.           ** However the ON CONFLICT clauses are different. If both this 
  2456.           ** constraint and the previous equivalent constraint have explicit
  2457.           ** ON CONFLICT clauses this is an error. Otherwise, use the
  2458.           ** explicitly specified behaviour for the index.
  2459.           */
  2460.           if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
  2461.             sqlite3ErrorMsg(pParse, 
  2462.                 "conflicting ON CONFLICT clauses specified", 0);
  2463.           }
  2464.           if( pIdx->onError==OE_Default ){
  2465.             pIdx->onError = pIndex->onError;
  2466.           }
  2467.         }
  2468.         goto exit_create_index;
  2469.       }
  2470.     }
  2471.   }
  2472.   /* Link the new Index structure to its table and to the other
  2473.   ** in-memory database structures. 
  2474.   */
  2475.   if( db->init.busy ){
  2476.     Index *p;
  2477.     p = sqlite3HashInsert(&pIndex->pSchema->idxHash, 
  2478.                          pIndex->zName, strlen(pIndex->zName)+1, pIndex);
  2479.     if( p ){
  2480.       assert( p==pIndex );  /* Malloc must have failed */
  2481.       db->mallocFailed = 1;
  2482.       goto exit_create_index;
  2483.     }
  2484.     db->flags |= SQLITE_InternChanges;
  2485.     if( pTblName!=0 ){
  2486.       pIndex->tnum = db->init.newTnum;
  2487.     }
  2488.   }
  2489.   /* If the db->init.busy is 0 then create the index on disk.  This
  2490.   ** involves writing the index into the master table and filling in the
  2491.   ** index with the current table contents.
  2492.   **
  2493.   ** The db->init.busy is 0 when the user first enters a CREATE INDEX 
  2494.   ** command.  db->init.busy is 1 when a database is opened and 
  2495.   ** CREATE INDEX statements are read out of the master table.  In
  2496.   ** the latter case the index already exists on disk, which is why
  2497.   ** we don't want to recreate it.
  2498.   **
  2499.   ** If pTblName==0 it means this index is generated as a primary key
  2500.   ** or UNIQUE constraint of a CREATE TABLE statement.  Since the table
  2501.   ** has just been created, it contains no data and the index initialization
  2502.   ** step can be skipped.
  2503.   */
  2504.   else if( db->init.busy==0 ){
  2505.     Vdbe *v;
  2506.     char *zStmt;
  2507.     int iMem = ++pParse->nMem;
  2508.     v = sqlite3GetVdbe(pParse);
  2509.     if( v==0 ) goto exit_create_index;
  2510.     /* Create the rootpage for the index
  2511.     */
  2512.     sqlite3BeginWriteOperation(pParse, 1, iDb);
  2513.     sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
  2514.     /* Gather the complete text of the CREATE INDEX statement into
  2515.     ** the zStmt variable
  2516.     */
  2517.     if( pStart && pEnd ){
  2518.       /* A named index with an explicit CREATE INDEX statement */
  2519.       zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
  2520.         onError==OE_None ? "" : " UNIQUE",
  2521.         pEnd->z - pName->z + 1,
  2522.         pName->z);
  2523.     }else{
  2524.       /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
  2525.       /* zStmt = sqlite3MPrintf(""); */
  2526.       zStmt = 0;
  2527.     }
  2528.     /* Add an entry in sqlite_master for this index
  2529.     */
  2530.     sqlite3NestedParse(pParse, 
  2531.         "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
  2532.         db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
  2533.         pIndex->zName,
  2534.         pTab->zName,
  2535.         iMem,
  2536.         zStmt
  2537.     );
  2538.     sqlite3_free(zStmt);
  2539.     /* Fill the index with data and reparse the schema. Code an OP_Expire
  2540.     ** to invalidate all pre-compiled statements.
  2541.     */
  2542.     if( pTblName ){
  2543.       sqlite3RefillIndex(pParse, pIndex, iMem);
  2544.       sqlite3ChangeCookie(pParse, iDb);
  2545.       sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0,
  2546.          sqlite3MPrintf(db, "name='%q'", pIndex->zName), P4_DYNAMIC);
  2547.       sqlite3VdbeAddOp1(v, OP_Expire, 0);
  2548.     }
  2549.   }
  2550.   /* When adding an index to the list of indices for a table, make
  2551.   ** sure all indices labeled OE_Replace come after all those labeled
  2552.   ** OE_Ignore.  This is necessary for the correct operation of UPDATE
  2553.   ** and INSERT.
  2554.   */
  2555.   if( db->init.busy || pTblName==0 ){
  2556.     if( onError!=OE_Replace || pTab->pIndex==0
  2557.          || pTab->pIndex->onError==OE_Replace){
  2558.       pIndex->pNext = pTab->pIndex;
  2559.       pTab->pIndex = pIndex;
  2560.     }else{
  2561.       Index *pOther = pTab->pIndex;
  2562.       while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
  2563.         pOther = pOther->pNext;
  2564.       }
  2565.       pIndex->pNext = pOther->pNext;
  2566.       pOther->pNext = pIndex;
  2567.     }
  2568.     pIndex = 0;
  2569.   }
  2570.   /* Clean up before exiting */
  2571. exit_create_index:
  2572.   if( pIndex ){
  2573.     freeIndex(pIndex);
  2574.   }
  2575.   sqlite3ExprListDelete(pList);
  2576.   sqlite3SrcListDelete(pTblName);
  2577.   sqlite3_free(zName);
  2578.   return;
  2579. }
  2580. /*
  2581. ** Generate code to make sure the file format number is at least minFormat.
  2582. ** The generated code will increase the file format number if necessary.
  2583. */
  2584. void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
  2585.   Vdbe *v;
  2586.   v = sqlite3GetVdbe(pParse);
  2587.   if( v ){
  2588.     int r1 = sqlite3GetTempReg(pParse);
  2589.     int r2 = sqlite3GetTempReg(pParse);
  2590.     int j1;
  2591.     sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, 1);
  2592.     sqlite3VdbeUsesBtree(v, iDb);
  2593.     sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
  2594.     j1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
  2595.     sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 1, r2);
  2596.     sqlite3VdbeJumpHere(v, j1);
  2597.     sqlite3ReleaseTempReg(pParse, r1);
  2598.     sqlite3ReleaseTempReg(pParse, r2);
  2599.   }
  2600. }
  2601. /*
  2602. ** Fill the Index.aiRowEst[] array with default information - information
  2603. ** to be used when we have not run the ANALYZE command.
  2604. **
  2605. ** aiRowEst[0] is suppose to contain the number of elements in the index.
  2606. ** Since we do not know, guess 1 million.  aiRowEst[1] is an estimate of the
  2607. ** number of rows in the table that match any particular value of the
  2608. ** first column of the index.  aiRowEst[2] is an estimate of the number
  2609. ** of rows that match any particular combiniation of the first 2 columns
  2610. ** of the index.  And so forth.  It must always be the case that
  2611. *
  2612. **           aiRowEst[N]<=aiRowEst[N-1]
  2613. **           aiRowEst[N]>=1
  2614. **
  2615. ** Apart from that, we have little to go on besides intuition as to
  2616. ** how aiRowEst[] should be initialized.  The numbers generated here
  2617. ** are based on typical values found in actual indices.
  2618. */
  2619. void sqlite3DefaultRowEst(Index *pIdx){
  2620.   unsigned *a = pIdx->aiRowEst;
  2621.   int i;
  2622.   assert( a!=0 );
  2623.   a[0] = 1000000;
  2624.   for(i=pIdx->nColumn; i>=5; i--){
  2625.     a[i] = 5;
  2626.   }
  2627.   while( i>=1 ){
  2628.     a[i] = 11 - i;
  2629.     i--;
  2630.   }
  2631.   if( pIdx->onError!=OE_None ){
  2632.     a[pIdx->nColumn] = 1;
  2633.   }
  2634. }
  2635. /*
  2636. ** This routine will drop an existing named index.  This routine
  2637. ** implements the DROP INDEX statement.
  2638. */
  2639. void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
  2640.   Index *pIndex;
  2641.   Vdbe *v;
  2642.   sqlite3 *db = pParse->db;
  2643.   int iDb;
  2644.   if( pParse->nErr || db->mallocFailed ){
  2645.     goto exit_drop_index;
  2646.   }
  2647.   assert( pName->nSrc==1 );
  2648.   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
  2649.     goto exit_drop_index;
  2650.   }
  2651.   pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
  2652.   if( pIndex==0 ){
  2653.     if( !ifExists ){
  2654.       sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
  2655.     }
  2656.     pParse->checkSchema = 1;
  2657.     goto exit_drop_index;
  2658.   }
  2659.   if( pIndex->autoIndex ){
  2660.     sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
  2661.       "or PRIMARY KEY constraint cannot be dropped", 0);
  2662.     goto exit_drop_index;
  2663.   }
  2664.   iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
  2665. #ifndef SQLITE_OMIT_AUTHORIZATION
  2666.   {
  2667.     int code = SQLITE_DROP_INDEX;
  2668.     Table *pTab = pIndex->pTable;
  2669.     const char *zDb = db->aDb[iDb].zName;
  2670.     const char *zTab = SCHEMA_TABLE(iDb);
  2671.     if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
  2672.       goto exit_drop_index;
  2673.     }
  2674.     if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
  2675.     if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
  2676.       goto exit_drop_index;
  2677.     }
  2678.   }
  2679. #endif
  2680.   /* Generate code to remove the index and from the master table */
  2681.   v = sqlite3GetVdbe(pParse);
  2682.   if( v ){
  2683.     sqlite3BeginWriteOperation(pParse, 1, iDb);
  2684.     sqlite3NestedParse(pParse,
  2685.        "DELETE FROM %Q.%s WHERE name=%Q",
  2686.        db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
  2687.        pIndex->zName
  2688.     );
  2689.     if( sqlite3FindTable(db, "sqlite_stat1", db->aDb[iDb].zName) ){
  2690.       sqlite3NestedParse(pParse,
  2691.         "DELETE FROM %Q.sqlite_stat1 WHERE idx=%Q",
  2692.         db->aDb[iDb].zName, pIndex->zName
  2693.       );
  2694.     }
  2695.     sqlite3ChangeCookie(pParse, iDb);
  2696.     destroyRootPage(pParse, pIndex->tnum, iDb);
  2697.     sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
  2698.   }
  2699. exit_drop_index:
  2700.   sqlite3SrcListDelete(pName);
  2701. }
  2702. /*
  2703. ** pArray is a pointer to an array of objects.  Each object in the
  2704. ** array is szEntry bytes in size.  This routine allocates a new
  2705. ** object on the end of the array.
  2706. **
  2707. ** *pnEntry is the number of entries already in use.  *pnAlloc is
  2708. ** the previously allocated size of the array.  initSize is the
  2709. ** suggested initial array size allocation.
  2710. **
  2711. ** The index of the new entry is returned in *pIdx.
  2712. **
  2713. ** This routine returns a pointer to the array of objects.  This
  2714. ** might be the same as the pArray parameter or it might be a different
  2715. ** pointer if the array was resized.
  2716. */
  2717. void *sqlite3ArrayAllocate(
  2718.   sqlite3 *db,      /* Connection to notify of malloc failures */
  2719.   void *pArray,     /* Array of objects.  Might be reallocated */
  2720.   int szEntry,      /* Size of each object in the array */
  2721.   int initSize,     /* Suggested initial allocation, in elements */
  2722.   int *pnEntry,     /* Number of objects currently in use */
  2723.   int *pnAlloc,     /* Current size of the allocation, in elements */
  2724.   int *pIdx         /* Write the index of a new slot here */
  2725. ){
  2726.   char *z;
  2727.   if( *pnEntry >= *pnAlloc ){
  2728.     void *pNew;
  2729.     int newSize;
  2730.     newSize = (*pnAlloc)*2 + initSize;
  2731.     pNew = sqlite3DbRealloc(db, pArray, newSize*szEntry);
  2732.     if( pNew==0 ){
  2733.       *pIdx = -1;
  2734.       return pArray;
  2735.     }
  2736.     *pnAlloc = newSize;
  2737.     pArray = pNew;
  2738.   }
  2739.   z = (char*)pArray;
  2740.   memset(&z[*pnEntry * szEntry], 0, szEntry);
  2741.   *pIdx = *pnEntry;
  2742.   ++*pnEntry;
  2743.   return pArray;
  2744. }
  2745. /*
  2746. ** Append a new element to the given IdList.  Create a new IdList if
  2747. ** need be.
  2748. **
  2749. ** A new IdList is returned, or NULL if malloc() fails.
  2750. */
  2751. IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){
  2752.   int i;
  2753.   if( pList==0 ){
  2754.     pList = sqlite3DbMallocZero(db, sizeof(IdList) );
  2755.     if( pList==0 ) return 0;
  2756.     pList->nAlloc = 0;
  2757.   }
  2758.   pList->a = sqlite3ArrayAllocate(
  2759.       db,
  2760.       pList->a,
  2761.       sizeof(pList->a[0]),
  2762.       5,
  2763.       &pList->nId,
  2764.       &pList->nAlloc,
  2765.       &i
  2766.   );
  2767.   if( i<0 ){
  2768.     sqlite3IdListDelete(pList);
  2769.     return 0;
  2770.   }
  2771.   pList->a[i].zName = sqlite3NameFromToken(db, pToken);
  2772.   return pList;
  2773. }
  2774. /*
  2775. ** Delete an IdList.
  2776. */
  2777. void sqlite3IdListDelete(IdList *pList){
  2778.   int i;
  2779.   if( pList==0 ) return;
  2780.   for(i=0; i<pList->nId; i++){
  2781.     sqlite3_free(pList->a[i].zName);
  2782.   }
  2783.   sqlite3_free(pList->a);
  2784.   sqlite3_free(pList);
  2785. }
  2786. /*
  2787. ** Return the index in pList of the identifier named zId.  Return -1
  2788. ** if not found.
  2789. */
  2790. int sqlite3IdListIndex(IdList *pList, const char *zName){
  2791.   int i;
  2792.   if( pList==0 ) return -1;
  2793.   for(i=0; i<pList->nId; i++){
  2794.     if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
  2795.   }
  2796.   return -1;
  2797. }
  2798. /*
  2799. ** Append a new table name to the given SrcList.  Create a new SrcList if
  2800. ** need be.  A new entry is created in the SrcList even if pToken is NULL.
  2801. **
  2802. ** A new SrcList is returned, or NULL if malloc() fails.
  2803. **
  2804. ** If pDatabase is not null, it means that the table has an optional
  2805. ** database name prefix.  Like this:  "database.table".  The pDatabase
  2806. ** points to the table name and the pTable points to the database name.
  2807. ** The SrcList.a[].zName field is filled with the table name which might
  2808. ** come from pTable (if pDatabase is NULL) or from pDatabase.  
  2809. ** SrcList.a[].zDatabase is filled with the database name from pTable,
  2810. ** or with NULL if no database is specified.
  2811. **
  2812. ** In other words, if call like this:
  2813. **
  2814. **         sqlite3SrcListAppend(D,A,B,0);
  2815. **
  2816. ** Then B is a table name and the database name is unspecified.  If called
  2817. ** like this:
  2818. **
  2819. **         sqlite3SrcListAppend(D,A,B,C);
  2820. **
  2821. ** Then C is the table name and B is the database name.
  2822. */
  2823. SrcList *sqlite3SrcListAppend(
  2824.   sqlite3 *db,        /* Connection to notify of malloc failures */
  2825.   SrcList *pList,     /* Append to this SrcList. NULL creates a new SrcList */
  2826.   Token *pTable,      /* Table to append */
  2827.   Token *pDatabase    /* Database of the table */
  2828. ){
  2829.   struct SrcList_item *pItem;
  2830.   if( pList==0 ){
  2831.     pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
  2832.     if( pList==0 ) return 0;
  2833.     pList->nAlloc = 1;
  2834.   }
  2835.   if( pList->nSrc>=pList->nAlloc ){
  2836.     SrcList *pNew;
  2837.     pList->nAlloc *= 2;
  2838.     pNew = sqlite3DbRealloc(db, pList,
  2839.                sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) );
  2840.     if( pNew==0 ){
  2841.       sqlite3SrcListDelete(pList);
  2842.       return 0;
  2843.     }
  2844.     pList = pNew;
  2845.   }
  2846.   pItem = &pList->a[pList->nSrc];
  2847.   memset(pItem, 0, sizeof(pList->a[0]));
  2848.   if( pDatabase && pDatabase->z==0 ){
  2849.     pDatabase = 0;
  2850.   }
  2851.   if( pDatabase && pTable ){
  2852.     Token *pTemp = pDatabase;
  2853.     pDatabase = pTable;
  2854.     pTable = pTemp;
  2855.   }
  2856.   pItem->zName = sqlite3NameFromToken(db, pTable);
  2857.   pItem->zDatabase = sqlite3NameFromToken(db, pDatabase);
  2858.   pItem->iCursor = -1;
  2859.   pItem->isPopulated = 0;
  2860.   pList->nSrc++;
  2861.   return pList;
  2862. }
  2863. /*
  2864. ** Assign cursors to all tables in a SrcList
  2865. */
  2866. void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
  2867.   int i;
  2868.   struct SrcList_item *pItem;
  2869.   assert(pList || pParse->db->mallocFailed );
  2870.   if( pList ){
  2871.     for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
  2872.       if( pItem->iCursor>=0 ) break;
  2873.       pItem->iCursor = pParse->nTab++;
  2874.       if( pItem->pSelect ){
  2875.         sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
  2876.       }
  2877.     }
  2878.   }
  2879. }
  2880. /*
  2881. ** Delete an entire SrcList including all its substructure.
  2882. */
  2883. void sqlite3SrcListDelete(SrcList *pList){
  2884.   int i;
  2885.   struct SrcList_item *pItem;
  2886.   if( pList==0 ) return;
  2887.   for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
  2888.     sqlite3_free(pItem->zDatabase);
  2889.     sqlite3_free(pItem->zName);
  2890.     sqlite3_free(pItem->zAlias);
  2891.     sqlite3DeleteTable(pItem->pTab);
  2892.     sqlite3SelectDelete(pItem->pSelect);
  2893.     sqlite3ExprDelete(pItem->pOn);
  2894.     sqlite3IdListDelete(pItem->pUsing);
  2895.   }
  2896.   sqlite3_free(pList);
  2897. }
  2898. /*
  2899. ** This routine is called by the parser to add a new term to the
  2900. ** end of a growing FROM clause.  The "p" parameter is the part of
  2901. ** the FROM clause that has already been constructed.  "p" is NULL
  2902. ** if this is the first term of the FROM clause.  pTable and pDatabase
  2903. ** are the name of the table and database named in the FROM clause term.
  2904. ** pDatabase is NULL if the database name qualifier is missing - the
  2905. ** usual case.  If the term has a alias, then pAlias points to the
  2906. ** alias token.  If the term is a subquery, then pSubquery is the
  2907. ** SELECT statement that the subquery encodes.  The pTable and
  2908. ** pDatabase parameters are NULL for subqueries.  The pOn and pUsing
  2909. ** parameters are the content of the ON and USING clauses.
  2910. **
  2911. ** Return a new SrcList which encodes is the FROM with the new
  2912. ** term added.
  2913. */
  2914. SrcList *sqlite3SrcListAppendFromTerm(
  2915.   Parse *pParse,          /* Parsing context */
  2916.   SrcList *p,             /* The left part of the FROM clause already seen */
  2917.   Token *pTable,          /* Name of the table to add to the FROM clause */
  2918.   Token *pDatabase,       /* Name of the database containing pTable */
  2919.   Token *pAlias,          /* The right-hand side of the AS subexpression */
  2920.   Select *pSubquery,      /* A subquery used in place of a table name */
  2921.   Expr *pOn,              /* The ON clause of a join */
  2922.   IdList *pUsing          /* The USING clause of a join */
  2923. ){
  2924.   struct SrcList_item *pItem;
  2925.   sqlite3 *db = pParse->db;
  2926.   p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
  2927.   if( p==0 || p->nSrc==0 ){
  2928.     sqlite3ExprDelete(pOn);
  2929.     sqlite3IdListDelete(pUsing);
  2930.     sqlite3SelectDelete(pSubquery);
  2931.     return p;
  2932.   }
  2933.   pItem = &p->a[p->nSrc-1];
  2934.   if( pAlias && pAlias->n ){
  2935.     pItem->zAlias = sqlite3NameFromToken(db, pAlias);
  2936.   }
  2937.   pItem->pSelect = pSubquery;
  2938.   pItem->pOn = pOn;
  2939.   pItem->pUsing = pUsing;
  2940.   return p;
  2941. }
  2942. /*
  2943. ** When building up a FROM clause in the parser, the join operator
  2944. ** is initially attached to the left operand.  But the code generator
  2945. ** expects the join operator to be on the right operand.  This routine
  2946. ** Shifts all join operators from left to right for an entire FROM
  2947. ** clause.
  2948. **
  2949. ** Example: Suppose the join is like this:
  2950. **
  2951. **           A natural cross join B
  2952. **
  2953. ** The operator is "natural cross join".  The A and B operands are stored
  2954. ** in p->a[0] and p->a[1], respectively.  The parser initially stores the
  2955. ** operator with A.  This routine shifts that operator over to B.
  2956. */
  2957. void sqlite3SrcListShiftJoinType(SrcList *p){
  2958.   if( p && p->a ){
  2959.     int i;
  2960.     for(i=p->nSrc-1; i>0; i--){
  2961.       p->a[i].jointype = p->a[i-1].jointype;
  2962.     }
  2963.     p->a[0].jointype = 0;
  2964.   }
  2965. }
  2966. /*
  2967. ** Begin a transaction
  2968. */
  2969. void sqlite3BeginTransaction(Parse *pParse, int type){
  2970.   sqlite3 *db;
  2971.   Vdbe *v;
  2972.   int i;
  2973.   if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
  2974.   if( pParse->nErr || db->mallocFailed ) return;
  2975.   if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return;
  2976.   v = sqlite3GetVdbe(pParse);
  2977.   if( !v ) return;
  2978.   if( type!=TK_DEFERRED ){
  2979.     for(i=0; i<db->nDb; i++){
  2980.       sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
  2981.       sqlite3VdbeUsesBtree(v, i);
  2982.     }
  2983.   }
  2984.   sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
  2985. }
  2986. /*
  2987. ** Commit a transaction
  2988. */
  2989. void sqlite3CommitTransaction(Parse *pParse){
  2990.   sqlite3 *db;
  2991.   Vdbe *v;
  2992.   if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
  2993.   if( pParse->nErr || db->mallocFailed ) return;
  2994.   if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return;
  2995.   v = sqlite3GetVdbe(pParse);
  2996.   if( v ){
  2997.     sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
  2998.   }
  2999. }
  3000. /*
  3001. ** Rollback a transaction
  3002. */
  3003. void sqlite3RollbackTransaction(Parse *pParse){
  3004.   sqlite3 *db;
  3005.   Vdbe *v;
  3006.   if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
  3007.   if( pParse->nErr || db->mallocFailed ) return;
  3008.   if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return;
  3009.   v = sqlite3GetVdbe(pParse);
  3010.   if( v ){
  3011.     sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
  3012.   }
  3013. }
  3014. /*
  3015. ** Make sure the TEMP database is open and available for use.  Return
  3016. ** the number of errors.  Leave any error messages in the pParse structure.
  3017. */
  3018. int sqlite3OpenTempDatabase(Parse *pParse){
  3019.   sqlite3 *db = pParse->db;
  3020.   if( db->aDb[1].pBt==0 && !pParse->explain ){
  3021.     int rc;
  3022.     static const int flags = 
  3023.           SQLITE_OPEN_READWRITE |
  3024.           SQLITE_OPEN_CREATE |
  3025.           SQLITE_OPEN_EXCLUSIVE |
  3026.           SQLITE_OPEN_DELETEONCLOSE |
  3027.           SQLITE_OPEN_TEMP_DB;
  3028.     rc = sqlite3BtreeFactory(db, 0, 0, SQLITE_DEFAULT_CACHE_SIZE, flags,
  3029.                                  &db->aDb[1].pBt);
  3030.     if( rc!=SQLITE_OK ){
  3031.       sqlite3ErrorMsg(pParse, "unable to open a temporary database "
  3032.         "file for storing temporary tables");
  3033.       pParse->rc = rc;
  3034.       return 1;
  3035.     }
  3036.     assert( (db->flags & SQLITE_InTrans)==0 || db->autoCommit );
  3037.     assert( db->aDb[1].pSchema );
  3038.   }
  3039.   return 0;
  3040. }
  3041. /*
  3042. ** Generate VDBE code that will verify the schema cookie and start
  3043. ** a read-transaction for all named database files.
  3044. **
  3045. ** It is important that all schema cookies be verified and all
  3046. ** read transactions be started before anything else happens in
  3047. ** the VDBE program.  But this routine can be called after much other
  3048. ** code has been generated.  So here is what we do:
  3049. **
  3050. ** The first time this routine is called, we code an OP_Goto that
  3051. ** will jump to a subroutine at the end of the program.  Then we
  3052. ** record every database that needs its schema verified in the
  3053. ** pParse->cookieMask field.  Later, after all other code has been
  3054. ** generated, the subroutine that does the cookie verifications and
  3055. ** starts the transactions will be coded and the OP_Goto P2 value
  3056. ** will be made to point to that subroutine.  The generation of the
  3057. ** cookie verification subroutine code happens in sqlite3FinishCoding().
  3058. **
  3059. ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
  3060. ** schema on any databases.  This can be used to position the OP_Goto
  3061. ** early in the code, before we know if any database tables will be used.
  3062. */
  3063. void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
  3064.   sqlite3 *db;
  3065.   Vdbe *v;
  3066.   int mask;
  3067.   v = sqlite3GetVdbe(pParse);
  3068.   if( v==0 ) return;  /* This only happens if there was a prior error */
  3069.   db = pParse->db;
  3070.   if( pParse->cookieGoto==0 ){
  3071.     pParse->cookieGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0)+1;
  3072.   }
  3073.   if( iDb>=0 ){
  3074.     assert( iDb<db->nDb );
  3075.     assert( db->aDb[iDb].pBt!=0 || iDb==1 );
  3076.     assert( iDb<SQLITE_MAX_ATTACHED+2 );
  3077.     mask = 1<<iDb;
  3078.     if( (pParse->cookieMask & mask)==0 ){
  3079.       pParse->cookieMask |= mask;
  3080.       pParse->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
  3081.       if( !OMIT_TEMPDB && iDb==1 ){
  3082.         sqlite3OpenTempDatabase(pParse);
  3083.       }
  3084.     }
  3085.   }
  3086. }
  3087. /*
  3088. ** Generate VDBE code that prepares for doing an operation that
  3089. ** might change the database.
  3090. **
  3091. ** This routine starts a new transaction if we are not already within
  3092. ** a transaction.  If we are already within a transaction, then a checkpoint
  3093. ** is set if the setStatement parameter is true.  A checkpoint should
  3094. ** be set for operations that might fail (due to a constraint) part of
  3095. ** the way through and which will need to undo some writes without having to
  3096. ** rollback the whole transaction.  For operations where all constraints
  3097. ** can be checked before any changes are made to the database, it is never
  3098. ** necessary to undo a write and the checkpoint should not be set.
  3099. **
  3100. ** Only database iDb and the temp database are made writable by this call.
  3101. ** If iDb==0, then the main and temp databases are made writable.   If
  3102. ** iDb==1 then only the temp database is made writable.  If iDb>1 then the
  3103. ** specified auxiliary database and the temp database are made writable.
  3104. */
  3105. void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
  3106.   Vdbe *v = sqlite3GetVdbe(pParse);
  3107.   if( v==0 ) return;
  3108.   sqlite3CodeVerifySchema(pParse, iDb);
  3109.   pParse->writeMask |= 1<<iDb;
  3110.   if( setStatement && pParse->nested==0 ){
  3111.     sqlite3VdbeAddOp1(v, OP_Statement, iDb);
  3112.   }
  3113.   if( (OMIT_TEMPDB || iDb!=1) && pParse->db->aDb[1].pBt!=0 ){
  3114.     sqlite3BeginWriteOperation(pParse, setStatement, 1);
  3115.   }
  3116. }
  3117. /*
  3118. ** Check to see if pIndex uses the collating sequence pColl.  Return
  3119. ** true if it does and false if it does not.
  3120. */
  3121. #ifndef SQLITE_OMIT_REINDEX
  3122. static int collationMatch(const char *zColl, Index *pIndex){
  3123.   int i;
  3124.   for(i=0; i<pIndex->nColumn; i++){
  3125.     const char *z = pIndex->azColl[i];
  3126.     if( z==zColl || (z && zColl && 0==sqlite3StrICmp(z, zColl)) ){
  3127.       return 1;
  3128.     }
  3129.   }
  3130.   return 0;
  3131. }
  3132. #endif
  3133. /*
  3134. ** Recompute all indices of pTab that use the collating sequence pColl.
  3135. ** If pColl==0 then recompute all indices of pTab.
  3136. */
  3137. #ifndef SQLITE_OMIT_REINDEX
  3138. static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
  3139.   Index *pIndex;              /* An index associated with pTab */
  3140.   for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
  3141.     if( zColl==0 || collationMatch(zColl, pIndex) ){
  3142.       int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
  3143.       sqlite3BeginWriteOperation(pParse, 0, iDb);
  3144.       sqlite3RefillIndex(pParse, pIndex, -1);
  3145.     }
  3146.   }
  3147. }
  3148. #endif
  3149. /*
  3150. ** Recompute all indices of all tables in all databases where the
  3151. ** indices use the collating sequence pColl.  If pColl==0 then recompute
  3152. ** all indices everywhere.
  3153. */
  3154. #ifndef SQLITE_OMIT_REINDEX
  3155. static void reindexDatabases(Parse *pParse, char const *zColl){
  3156.   Db *pDb;                    /* A single database */
  3157.   int iDb;                    /* The database index number */
  3158.   sqlite3 *db = pParse->db;   /* The database connection */
  3159.   HashElem *k;                /* For looping over tables in pDb */
  3160.   Table *pTab;                /* A table in the database */
  3161.   for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
  3162.     assert( pDb!=0 );
  3163.     for(k=sqliteHashFirst(&pDb->pSchema->tblHash);  k; k=sqliteHashNext(k)){
  3164.       pTab = (Table*)sqliteHashData(k);
  3165.       reindexTable(pParse, pTab, zColl);
  3166.     }
  3167.   }
  3168. }
  3169. #endif
  3170. /*
  3171. ** Generate code for the REINDEX command.
  3172. **
  3173. **        REINDEX                            -- 1
  3174. **        REINDEX  <collation>               -- 2
  3175. **        REINDEX  ?<database>.?<tablename>  -- 3
  3176. **        REINDEX  ?<database>.?<indexname>  -- 4
  3177. **
  3178. ** Form 1 causes all indices in all attached databases to be rebuilt.
  3179. ** Form 2 rebuilds all indices in all databases that use the named
  3180. ** collating function.  Forms 3 and 4 rebuild the named index or all
  3181. ** indices associated with the named table.
  3182. */
  3183. #ifndef SQLITE_OMIT_REINDEX
  3184. void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
  3185.   CollSeq *pColl;             /* Collating sequence to be reindexed, or NULL */
  3186.   char *z;                    /* Name of a table or index */
  3187.   const char *zDb;            /* Name of the database */
  3188.   Table *pTab;                /* A table in the database */
  3189.   Index *pIndex;              /* An index associated with pTab */
  3190.   int iDb;                    /* The database index number */
  3191.   sqlite3 *db = pParse->db;   /* The database connection */
  3192.   Token *pObjName;            /* Name of the table or index to be reindexed */
  3193.   /* Read the database schema. If an error occurs, leave an error message
  3194.   ** and code in pParse and return NULL. */
  3195.   if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
  3196.     return;
  3197.   }
  3198.   if( pName1==0 || pName1->z==0 ){
  3199.     reindexDatabases(pParse, 0);
  3200.     return;
  3201.   }else if( pName2==0 || pName2->z==0 ){
  3202.     char *zColl;
  3203.     assert( pName1->z );
  3204.     zColl = sqlite3NameFromToken(pParse->db, pName1);
  3205.     if( !zColl ) return;
  3206.     pColl = sqlite3FindCollSeq(db, ENC(db), zColl, -1, 0);
  3207.     if( pColl ){
  3208.       if( zColl ){
  3209.         reindexDatabases(pParse, zColl);
  3210.         sqlite3_free(zColl);
  3211.       }
  3212.       return;
  3213.     }
  3214.     sqlite3_free(zColl);
  3215.   }
  3216.   iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
  3217.   if( iDb<0 ) return;
  3218.   z = sqlite3NameFromToken(db, pObjName);
  3219.   if( z==0 ) return;
  3220.   zDb = db->aDb[iDb].zName;
  3221.   pTab = sqlite3FindTable(db, z, zDb);
  3222.   if( pTab ){
  3223.     reindexTable(pParse, pTab, 0);
  3224.     sqlite3_free(z);
  3225.     return;
  3226.   }
  3227.   pIndex = sqlite3FindIndex(db, z, zDb);
  3228.   sqlite3_free(z);
  3229.   if( pIndex ){
  3230.     sqlite3BeginWriteOperation(pParse, 0, iDb);
  3231.     sqlite3RefillIndex(pParse, pIndex, -1);
  3232.     return;
  3233.   }
  3234.   sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
  3235. }
  3236. #endif
  3237. /*
  3238. ** Return a dynamicly allocated KeyInfo structure that can be used
  3239. ** with OP_OpenRead or OP_OpenWrite to access database index pIdx.
  3240. **
  3241. ** If successful, a pointer to the new structure is returned. In this case
  3242. ** the caller is responsible for calling sqlite3_free() on the returned 
  3243. ** pointer. If an error occurs (out of memory or missing collation 
  3244. ** sequence), NULL is returned and the state of pParse updated to reflect
  3245. ** the error.
  3246. */
  3247. KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
  3248.   int i;
  3249.   int nCol = pIdx->nColumn;
  3250.   int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
  3251.   KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(pParse->db, nBytes);
  3252.   if( pKey ){
  3253.     pKey->db = pParse->db;
  3254.     pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
  3255.     assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
  3256.     for(i=0; i<nCol; i++){
  3257.       char *zColl = pIdx->azColl[i];
  3258.       assert( zColl );
  3259.       pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl, -1);
  3260.       pKey->aSortOrder[i] = pIdx->aSortOrder[i];
  3261.     }
  3262.     pKey->nField = nCol;
  3263.   }
  3264.   if( pParse->nErr ){
  3265.     sqlite3_free(pKey);
  3266.     pKey = 0;
  3267.   }
  3268.   return pKey;
  3269. }