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