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