if (&db->aDb[1].pBt != 0) { sqliteErrorMsg(pParse, "The temporary database already exists - " "its location cannot now be changed"); } else { db->temp_store = getTempStore(zRight); }
changeTempStorage(pParse, zRight);
void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){  char *zLeft = 0;  char *zRight = 0;  sqlite *db = pParse->db;  Vdbe *v = sqliteGetVdbe(pParse);  if( v==0 ) return;  zLeft = sqliteStrNDup(pLeft->z, pLeft->n);  sqliteDequote(zLeft);  if( minusFlag ){    zRight = 0;    sqliteSetNString(&zRight, "-", 1, pRight->z, pRight->n, 0);  }else{    zRight = sqliteStrNDup(pRight->z, pRight->n);    sqliteDequote(zRight);  }  if( sqliteAuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, 0) ){    sqliteFree(zLeft);    sqliteFree(zRight);    return;  }   /*  **  PRAGMA default_cache_size  **  PRAGMA default_cache_size=N  **  ** The first form reports the current persistent setting for the  ** page cache size.  The value returned is the maximum number of  ** pages in the page cache.  The second form sets both the current  ** page cache size value and the persistent page cache size value  ** stored in the database file.  **  ** The default cache size is stored in meta-value 2 of page 1 of the  ** database file.  The cache size is actually the absolute value of  ** this memory location.  The sign of meta-value 2 determines the  ** synchronous setting.  A negative value means synchronous is off  ** and a positive value means synchronous is on.  */  if( sqliteStrICmp(zLeft,"default_cache_size")==0 ){    static VdbeOpList getCacheSize[] = {      { OP_ReadCookie,  0, 2,        0},      { OP_AbsValue,    0, 0,        0},      { OP_Dup,         0, 0,        0},      { OP_Integer,     0, 0,        0},      { OP_Ne,          0, 6,        0},      { OP_Integer,     0, 0,        0},  /* 5 */      { OP_ColumnName,  0, 1,        "cache_size"},      { OP_Callback,    1, 0,        0},    };    int addr;    if( pRight->z==pLeft->z ){      addr = sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);      sqliteVdbeChangeP1(v, addr+5, MAX_PAGES);    }else{      int size = atoi(zRight);      if( size<0 ) size = -size;      sqliteBeginWriteOperation(pParse, 0, 0);      sqliteVdbeAddOp(v, OP_Integer, size, 0);      sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2);      addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0);      sqliteVdbeAddOp(v, OP_Ge, 0, addr+3);      sqliteVdbeAddOp(v, OP_Negative, 0, 0);      sqliteVdbeAddOp(v, OP_SetCookie, 0, 2);      sqliteEndWriteOperation(pParse);      db->cache_size = db->cache_size<0 ? -size : size;      sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);    }  }else  /*  **  PRAGMA cache_size  **  PRAGMA cache_size=N  **  ** The first form reports the current local setting for the  ** page cache size.  The local setting can be different from  ** the persistent cache size value that is stored in the database  ** file itself.  The value returned is the maximum number of  ** pages in the page cache.  The second form sets the local  ** page cache size value.  It does not change the persistent  ** cache size stored on the disk so the cache size will revert  ** to its default value when the database is closed and reopened.  ** N should be a positive integer.  */  if( sqliteStrICmp(zLeft,"cache_size")==0 ){    static VdbeOpList getCacheSize[] = {      { OP_ColumnName,  0, 1,        "cache_size"},      { OP_Callback,    1, 0,        0},    };    if( pRight->z==pLeft->z ){      int size = db->cache_size;;      if( size<0 ) size = -size;      sqliteVdbeAddOp(v, OP_Integer, size, 0);      sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);    }else{      int size = atoi(zRight);      if( size<0 ) size = -size;      if( db->cache_size<0 ) size = -size;      db->cache_size = size;      sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);    }  }else  /*  **  PRAGMA default_synchronous  **  PRAGMA default_synchronous=ON|OFF|NORMAL|FULL  **  ** The first form returns the persistent value of the "synchronous" setting  ** that is stored in the database.  This is the synchronous setting that  ** is used whenever the database is opened unless overridden by a separate  ** "synchronous" pragma.  The second form changes the persistent and the  ** local synchronous setting to the value given.  **  ** If synchronous is OFF, SQLite does not attempt any fsync() systems calls  ** to make sure data is committed to disk.  Write operations are very fast,  ** but a power failure can leave the database in an inconsistent state.  ** If synchronous is ON or NORMAL, SQLite will do an fsync() system call to  ** make sure data is being written to disk.  The risk of corruption due to  ** a power loss in this mode is negligible but non-zero.  If synchronous  ** is FULL, extra fsync()s occur to reduce the risk of corruption to near  ** zero, but with a write performance penalty.  The default mode is NORMAL.  */  if( sqliteStrICmp(zLeft,"default_synchronous")==0 ){    static VdbeOpList getSync[] = {      { OP_ColumnName,  0, 1,        "synchronous"},      { OP_ReadCookie,  0, 3,        0},      { OP_Dup,         0, 0,        0},      { OP_If,          0, 0,        0},  /* 3 */      { OP_ReadCookie,  0, 2,        0},      { OP_Integer,     0, 0,        0},      { OP_Lt,          0, 5,        0},      { OP_AddImm,      1, 0,        0},      { OP_Callback,    1, 0,        0},      { OP_Halt,        0, 0,        0},      { OP_AddImm,     -1, 0,        0},  /* 10 */      { OP_Callback,    1, 0,        0}    };    if( pRight->z==pLeft->z ){      int addr = sqliteVdbeAddOpList(v, ArraySize(getSync), getSync);      sqliteVdbeChangeP2(v, addr+3, addr+10);    }else{      int addr;      int size = db->cache_size;      if( size<0 ) size = -size;      sqliteBeginWriteOperation(pParse, 0, 0);      sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2);      sqliteVdbeAddOp(v, OP_Dup, 0, 0);      addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0);      sqliteVdbeAddOp(v, OP_Ne, 0, addr+3);      sqliteVdbeAddOp(v, OP_AddImm, MAX_PAGES, 0);      sqliteVdbeAddOp(v, OP_AbsValue, 0, 0);      db->safety_level = getSafetyLevel(zRight)+1;      if( db->safety_level==1 ){        sqliteVdbeAddOp(v, OP_Negative, 0, 0);        size = -size;      }      sqliteVdbeAddOp(v, OP_SetCookie, 0, 2);      sqliteVdbeAddOp(v, OP_Integer, db->safety_level, 0);      sqliteVdbeAddOp(v, OP_SetCookie, 0, 3);      sqliteEndWriteOperation(pParse);      db->cache_size = size;      sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);      sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level);    }  }else  /*  **   PRAGMA synchronous  **   PRAGMA synchronous=OFF|ON|NORMAL|FULL  **  ** Return or set the local value of the synchronous flag.  Changing  ** the local value does not make changes to the disk file and the  ** default value will be restored the next time the database is  ** opened.  */  if( sqliteStrICmp(zLeft,"synchronous")==0 ){    static VdbeOpList getSync[] = {      { OP_ColumnName,  0, 1,        "synchronous"},      { OP_Callback,    1, 0,        0},    };    if( pRight->z==pLeft->z ){      sqliteVdbeAddOp(v, OP_Integer, db->safety_level-1, 0);      sqliteVdbeAddOpList(v, ArraySize(getSync), getSync);    }else{      int size = db->cache_size;      if( size<0 ) size = -size;      db->safety_level = getSafetyLevel(zRight)+1;      if( db->safety_level==1 ) size = -size;      db->cache_size = size;      sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);      sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level);    }  }else#ifndef NDEBUG  if( sqliteStrICmp(zLeft, "trigger_overhead_test")==0 ){    if( getBoolean(zRight) ){      always_code_trigger_setup = 1;    }else{      always_code_trigger_setup = 0;    }  }else#endif  if( flagPragma(pParse, zLeft, zRight) ){    /* The flagPragma() call also generates any necessary code */  }else  if( sqliteStrICmp(zLeft, "table_info")==0 ){    Table *pTab;    pTab = sqliteFindTable(db, zRight, 0);    if( pTab ){      static VdbeOpList tableInfoPreface[] = {        { OP_ColumnName,  0, 0,       "cid"},        { OP_ColumnName,  1, 0,       "name"},        { OP_ColumnName,  2, 0,       "type"},        { OP_ColumnName,  3, 0,       "notnull"},        { OP_ColumnName,  4, 0,       "dflt_value"},        { OP_ColumnName,  5, 1,       "pk"},      };      int i;      sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface);      sqliteViewGetColumnNames(pParse, pTab);      for(i=0; i<pTab->nCol; i++){        sqliteVdbeAddOp(v, OP_Integer, i, 0);        sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zName, 0);        sqliteVdbeOp3(v, OP_String, 0, 0,           pTab->aCol[i].zType ? pTab->aCol[i].zType : "numeric", 0);        sqliteVdbeAddOp(v, OP_Integer, pTab->aCol[i].notNull, 0);        sqliteVdbeOp3(v, OP_String, 0, 0,           pTab->aCol[i].zDflt, P3_STATIC);        sqliteVdbeAddOp(v, OP_Integer, pTab->aCol[i].isPrimKey, 0);        sqliteVdbeAddOp(v, OP_Callback, 6, 0);      }    }  }else  if( sqliteStrICmp(zLeft, "index_info")==0 ){    Index *pIdx;    Table *pTab;    pIdx = sqliteFindIndex(db, zRight, 0);    if( pIdx ){      static VdbeOpList tableInfoPreface[] = {        { OP_ColumnName,  0, 0,       "seqno"},        { OP_ColumnName,  1, 0,       "cid"},        { OP_ColumnName,  2, 1,       "name"},      };      int i;      pTab = pIdx->pTable;      sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface);      for(i=0; i<pIdx->nColumn; i++){        int cnum = pIdx->aiColumn[i];        sqliteVdbeAddOp(v, OP_Integer, i, 0);        sqliteVdbeAddOp(v, OP_Integer, cnum, 0);        assert( pTab->nCol>cnum );        sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[cnum].zName, 0);        sqliteVdbeAddOp(v, OP_Callback, 3, 0);      }    }  }else  if( sqliteStrICmp(zLeft, "index_list")==0 ){    Index *pIdx;    Table *pTab;    pTab = sqliteFindTable(db, zRight, 0);    if( pTab ){      v = sqliteGetVdbe(pParse);      pIdx = pTab->pIndex;    }    if( pTab && pIdx ){      int i = 0;       static VdbeOpList indexListPreface[] = {        { OP_ColumnName,  0, 0,       "seq"},        { OP_ColumnName,  1, 0,       "name"},        { OP_ColumnName,  2, 1,       "unique"},      };      sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface);      while(pIdx){        sqliteVdbeAddOp(v, OP_Integer, i, 0);        sqliteVdbeOp3(v, OP_String, 0, 0, pIdx->zName, 0);        sqliteVdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0);        sqliteVdbeAddOp(v, OP_Callback, 3, 0);        ++i;        pIdx = pIdx->pNext;      }    }  }else  if( sqliteStrICmp(zLeft, "foreign_key_list")==0 ){    FKey *pFK;    Table *pTab;    pTab = sqliteFindTable(db, zRight, 0);    if( pTab ){      v = sqliteGetVdbe(pParse);      pFK = pTab->pFKey;    }    if( pTab && pFK ){      int i = 0;       static VdbeOpList indexListPreface[] = {        { OP_ColumnName,  0, 0,       "id"},        { OP_ColumnName,  1, 0,       "seq"},        { OP_ColumnName,  2, 0,       "table"},        { OP_ColumnName,  3, 0,       "from"},        { OP_ColumnName,  4, 1,       "to"},      };      sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface);      while(pFK){        int j;        for(j=0; j<pFK->nCol; j++){          sqliteVdbeAddOp(v, OP_Integer, i, 0);          sqliteVdbeAddOp(v, OP_Integer, j, 0);          sqliteVdbeOp3(v, OP_String, 0, 0, pFK->zTo, 0);          sqliteVdbeOp3(v, OP_String, 0, 0,                           pTab->aCol[pFK->aCol[j].iFrom].zName, 0);          sqliteVdbeOp3(v, OP_String, 0, 0, pFK->aCol[j].zCol, 0);          sqliteVdbeAddOp(v, OP_Callback, 5, 0);        }        ++i;        pFK = pFK->pNextFrom;      }    }  }else  if( sqliteStrICmp(zLeft, "database_list")==0 ){    int i;    static VdbeOpList indexListPreface[] = {      { OP_ColumnName,  0, 0,       "seq"},      { OP_ColumnName,  1, 0,       "name"},      { OP_ColumnName,  2, 1,       "file"},    };    sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface);    for(i=0; i<db->nDb; i++){      if( db->aDb[i].pBt==0 ) continue;      assert( db->aDb[i].zName!=0 );      sqliteVdbeAddOp(v, OP_Integer, i, 0);      sqliteVdbeOp3(v, OP_String, 0, 0, db->aDb[i].zName, 0);      sqliteVdbeOp3(v, OP_String, 0, 0,           sqliteBtreeGetFilename(db->aDb[i].pBt), 0);      sqliteVdbeAddOp(v, OP_Callback, 3, 0);    }  }else  /*  **   PRAGMA temp_store  **   PRAGMA temp_store = "default"|"memory"|"file"  **  ** Return or set the local value of the temp_store flag.  Changing  ** the local value does not make changes to the disk file and the default  ** value will be restored the next time the database is opened.  **  ** Note that it is possible for the library compile-time options to  ** override this setting  */  if( sqliteStrICmp(zLeft, "temp_store")==0 ){    static VdbeOpList getTmpDbLoc[] = {      { OP_ColumnName,  0, 1,        "temp_store"},      { OP_Callback,    1, 0,        0},    };    if( pRight->z==pLeft->z ){      sqliteVdbeAddOp(v, OP_Integer, db->temp_store, 0);      sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc);    }else{      if (&db->aDb[1].pBt != 0) {	sqliteErrorMsg(pParse, "The temporary database already exists - "          "its location cannot now be changed");      } else {	db->temp_store = getTempStore(zRight);      }    }  }else  /*  **   PRAGMA default_temp_store  **   PRAGMA default_temp_store = "default"|"memory"|"file"  **  ** Return or set the value of the persistent temp_store flag (as  ** well as the value currently in force).  **  ** Note that it is possible for the library compile-time options to  ** override this setting  */  if( sqliteStrICmp(zLeft, "default_temp_store")==0 ){    static VdbeOpList getTmpDbLoc[] = {      { OP_ColumnName,  0, 1,        "temp_store"},      { OP_ReadCookie,  0, 5,        0},      { OP_Callback,    1, 0,        0}};    if( pRight->z==pLeft->z ){      sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc);    }else{      if (&db->aDb[1].pBt != 0) {	sqliteErrorMsg(pParse, "The temporary database already exists - "            "its location cannot now be changed");      } else {	sqliteBeginWriteOperation(pParse, 0, 0);	db->temp_store = getTempStore(zRight);	sqliteVdbeAddOp(v, OP_Integer, db->temp_store, 0);	sqliteVdbeAddOp(v, OP_SetCookie, 0, 5);	sqliteEndWriteOperation(pParse);      }    }  }else#ifndef NDEBUG  if( sqliteStrICmp(zLeft, "parser_trace")==0 ){    extern void sqliteParserTrace(FILE*, char *);    if( getBoolean(zRight) ){      sqliteParserTrace(stdout, "parser: ");    }else{      sqliteParserTrace(0, 0);    }  }else#endif  if( sqliteStrICmp(zLeft, "integrity_check")==0 ){    int i, j, addr;    /* Code that initializes the integrity check program.  Set the    ** error count 0    */    static VdbeOpList initCode[] = {      { OP_Integer,     0, 0,        0},      { OP_MemStore,    0, 1,        0},      { OP_ColumnName,  0, 1,        "integrity_check"},    };    /* Code to do an BTree integrity check on a single database file.    */    static VdbeOpList checkDb[] = {      { OP_SetInsert,   0, 0,        "2"},      { OP_Integer,     0, 0,        0},    /* 1 */      { OP_OpenRead,    0, 2,        0},      { OP_Rewind,      0, 7,        0},    /* 3 */      { OP_Column,      0, 3,        0},    /* 4 */      { OP_SetInsert,   0, 0,        0},      { OP_Next,        0, 4,        0},    /* 6 */      { OP_IntegrityCk, 0, 0,        0},    /* 7 */      { OP_Dup,         0, 1,        0},      { OP_String,      0, 0,        "ok"},      { OP_StrEq,       0, 12,       0},    /* 10 */      { OP_MemIncr,     0, 0,        0},      { OP_String,      0, 0,        "*** in database "},      { OP_String,      0, 0,        0},    /* 13 */      { OP_String,      0, 0,        " ***\n"},      { OP_Pull,        3, 0,        0},      { OP_Concat,      4, 1,        0},      { OP_Callback,    1, 0,        0},    };    /* Code that appears at the end of the integrity check.  If no error    ** messages have been generated, output OK.  Otherwise output the    ** error message    */    static VdbeOpList endCode[] = {      { OP_MemLoad,     0, 0,        0},      { OP_Integer,     0, 0,        0},      { OP_Ne,          0, 0,        0},    /* 2 */      { OP_String,      0, 0,        "ok"},      { OP_Callback,    1, 0,        0},    };    /* Initialize the VDBE program */    sqliteVdbeAddOpList(v, ArraySize(initCode), initCode);    /* Do an integrity check on each database file */    for(i=0; i<db->nDb; i++){      HashElem *x;      /* Do an integrity check of the B-Tree      */      addr = sqliteVdbeAddOpList(v, ArraySize(checkDb), checkDb);      sqliteVdbeChangeP1(v, addr+1, i);      sqliteVdbeChangeP2(v, addr+3, addr+7);      sqliteVdbeChangeP2(v, addr+6, addr+4);      sqliteVdbeChangeP2(v, addr+7, i);      sqliteVdbeChangeP2(v, addr+10, addr+ArraySize(checkDb));      sqliteVdbeChangeP3(v, addr+13, db->aDb[i].zName, P3_STATIC);      /* Make sure all the indices are constructed correctly.      */      sqliteCodeVerifySchema(pParse, i);      for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){        Table *pTab = sqliteHashData(x);        Index *pIdx;        int loopTop;        if( pTab->pIndex==0 ) continue;        sqliteVdbeAddOp(v, OP_Integer, i, 0);        sqliteVdbeOp3(v, OP_OpenRead, 1, pTab->tnum, pTab->zName, 0);        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){          if( pIdx->tnum==0 ) continue;          sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0);          sqliteVdbeOp3(v, OP_OpenRead, j+2, pIdx->tnum, pIdx->zName, 0);        }        sqliteVdbeAddOp(v, OP_Integer, 0, 0);        sqliteVdbeAddOp(v, OP_MemStore, 1, 1);        loopTop = sqliteVdbeAddOp(v, OP_Rewind, 1, 0);        sqliteVdbeAddOp(v, OP_MemIncr, 1, 0);        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){          int k, jmp2;          static VdbeOpList idxErr[] = {            { OP_MemIncr,     0,  0,  0},            { OP_String,      0,  0,  "rowid "},            { OP_Recno,       1,  0,  0},            { OP_String,      0,  0,  " missing from index "},            { OP_String,      0,  0,  0},    /* 4 */            { OP_Concat,      4,  0,  0},            { OP_Callback,    1,  0,  0},          };          sqliteVdbeAddOp(v, OP_Recno, 1, 0);          for(k=0; k<pIdx->nColumn; k++){            int idx = pIdx->aiColumn[k];            if( idx==pTab->iPKey ){              sqliteVdbeAddOp(v, OP_Recno, 1, 0);            }else{              sqliteVdbeAddOp(v, OP_Column, 1, idx);            }          }          sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0);          if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx);          jmp2 = sqliteVdbeAddOp(v, OP_Found, j+2, 0);          addr = sqliteVdbeAddOpList(v, ArraySize(idxErr), idxErr);          sqliteVdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC);          sqliteVdbeChangeP2(v, jmp2, sqliteVdbeCurrentAddr(v));        }        sqliteVdbeAddOp(v, OP_Next, 1, loopTop+1);        sqliteVdbeChangeP2(v, loopTop, sqliteVdbeCurrentAddr(v));        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){          static VdbeOpList cntIdx[] = {             { OP_Integer,      0,  0,  0},             { OP_MemStore,     2,  1,  0},             { OP_Rewind,       0,  0,  0},  /* 2 */             { OP_MemIncr,      2,  0,  0},             { OP_Next,         0,  0,  0},  /* 4 */             { OP_MemLoad,      1,  0,  0},             { OP_MemLoad,      2,  0,  0},             { OP_Eq,           0,  0,  0},  /* 7 */             { OP_MemIncr,      0,  0,  0},             { OP_String,       0,  0,  "wrong # of entries in index "},             { OP_String,       0,  0,  0},  /* 10 */             { OP_Concat,       2,  0,  0},             { OP_Callback,     1,  0,  0},          };          if( pIdx->tnum==0 ) continue;          addr = sqliteVdbeAddOpList(v, ArraySize(cntIdx), cntIdx);          sqliteVdbeChangeP1(v, addr+2, j+2);          sqliteVdbeChangeP2(v, addr+2, addr+5);          sqliteVdbeChangeP1(v, addr+4, j+2);          sqliteVdbeChangeP2(v, addr+4, addr+3);          sqliteVdbeChangeP2(v, addr+7, addr+ArraySize(cntIdx));          sqliteVdbeChangeP3(v, addr+10, pIdx->zName, P3_STATIC);        }      }     }    addr = sqliteVdbeAddOpList(v, ArraySize(endCode), endCode);    sqliteVdbeChangeP2(v, addr+2, addr+ArraySize(endCode));  }else  {}  sqliteFree(zLeft);  sqliteFree(zRight);}