Annotation of embedaddon/php/ext/sqlite/libsqlite/src/pragma.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2003 April 6
! 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 code used to implement the PRAGMA command.
! 13: **
! 14: ** $Id: pragma.c 195361 2005-09-07 15:11:33Z iliaa $
! 15: */
! 16: #include "sqliteInt.h"
! 17: #include <ctype.h>
! 18:
! 19: /*
! 20: ** Interpret the given string as a boolean value.
! 21: */
! 22: static int getBoolean(const char *z){
! 23: static char *azTrue[] = { "yes", "on", "true" };
! 24: int i;
! 25: if( z[0]==0 ) return 0;
! 26: if( isdigit(z[0]) || (z[0]=='-' && isdigit(z[1])) ){
! 27: return atoi(z);
! 28: }
! 29: for(i=0; i<sizeof(azTrue)/sizeof(azTrue[0]); i++){
! 30: if( sqliteStrICmp(z,azTrue[i])==0 ) return 1;
! 31: }
! 32: return 0;
! 33: }
! 34:
! 35: /*
! 36: ** Interpret the given string as a safety level. Return 0 for OFF,
! 37: ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or
! 38: ** unrecognized string argument.
! 39: **
! 40: ** Note that the values returned are one less that the values that
! 41: ** should be passed into sqliteBtreeSetSafetyLevel(). The is done
! 42: ** to support legacy SQL code. The safety level used to be boolean
! 43: ** and older scripts may have used numbers 0 for OFF and 1 for ON.
! 44: */
! 45: static int getSafetyLevel(char *z){
! 46: static const struct {
! 47: const char *zWord;
! 48: int val;
! 49: } aKey[] = {
! 50: { "no", 0 },
! 51: { "off", 0 },
! 52: { "false", 0 },
! 53: { "yes", 1 },
! 54: { "on", 1 },
! 55: { "true", 1 },
! 56: { "full", 2 },
! 57: };
! 58: int i;
! 59: if( z[0]==0 ) return 1;
! 60: if( isdigit(z[0]) || (z[0]=='-' && isdigit(z[1])) ){
! 61: return atoi(z);
! 62: }
! 63: for(i=0; i<sizeof(aKey)/sizeof(aKey[0]); i++){
! 64: if( sqliteStrICmp(z,aKey[i].zWord)==0 ) return aKey[i].val;
! 65: }
! 66: return 1;
! 67: }
! 68:
! 69: /*
! 70: ** Interpret the given string as a temp db location. Return 1 for file
! 71: ** backed temporary databases, 2 for the Red-Black tree in memory database
! 72: ** and 0 to use the compile-time default.
! 73: */
! 74: static int getTempStore(const char *z){
! 75: if( z[0]>='0' && z[0]<='2' ){
! 76: return z[0] - '0';
! 77: }else if( sqliteStrICmp(z, "file")==0 ){
! 78: return 1;
! 79: }else if( sqliteStrICmp(z, "memory")==0 ){
! 80: return 2;
! 81: }else{
! 82: return 0;
! 83: }
! 84: }
! 85:
! 86: /*
! 87: ** If the TEMP database is open, close it and mark the database schema
! 88: ** as needing reloading. This must be done when using the TEMP_STORE
! 89: ** or DEFAULT_TEMP_STORE pragmas.
! 90: */
! 91: static int changeTempStorage(Parse *pParse, const char *zStorageType){
! 92: int ts = getTempStore(zStorageType);
! 93: sqlite *db = pParse->db;
! 94: if( db->temp_store==ts ) return SQLITE_OK;
! 95: if( db->aDb[1].pBt!=0 ){
! 96: if( db->flags & SQLITE_InTrans ){
! 97: sqliteErrorMsg(pParse, "temporary storage cannot be changed "
! 98: "from within a transaction");
! 99: return SQLITE_ERROR;
! 100: }
! 101: sqliteBtreeClose(db->aDb[1].pBt);
! 102: db->aDb[1].pBt = 0;
! 103: sqliteResetInternalSchema(db, 0);
! 104: }
! 105: db->temp_store = ts;
! 106: return SQLITE_OK;
! 107: }
! 108:
! 109: /*
! 110: ** Check to see if zRight and zLeft refer to a pragma that queries
! 111: ** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
! 112: ** Also, implement the pragma.
! 113: */
! 114: static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
! 115: static const struct {
! 116: const char *zName; /* Name of the pragma */
! 117: int mask; /* Mask for the db->flags value */
! 118: } aPragma[] = {
! 119: { "vdbe_trace", SQLITE_VdbeTrace },
! 120: { "full_column_names", SQLITE_FullColNames },
! 121: { "short_column_names", SQLITE_ShortColNames },
! 122: { "show_datatypes", SQLITE_ReportTypes },
! 123: { "count_changes", SQLITE_CountRows },
! 124: { "empty_result_callbacks", SQLITE_NullCallback },
! 125: };
! 126: int i;
! 127: for(i=0; i<sizeof(aPragma)/sizeof(aPragma[0]); i++){
! 128: if( sqliteStrICmp(zLeft, aPragma[i].zName)==0 ){
! 129: sqlite *db = pParse->db;
! 130: Vdbe *v;
! 131: if( strcmp(zLeft,zRight)==0 && (v = sqliteGetVdbe(pParse))!=0 ){
! 132: sqliteVdbeOp3(v, OP_ColumnName, 0, 1, aPragma[i].zName, P3_STATIC);
! 133: sqliteVdbeOp3(v, OP_ColumnName, 1, 0, "boolean", P3_STATIC);
! 134: sqliteVdbeCode(v, OP_Integer, (db->flags & aPragma[i].mask)!=0, 0,
! 135: OP_Callback, 1, 0,
! 136: 0);
! 137: }else if( getBoolean(zRight) ){
! 138: db->flags |= aPragma[i].mask;
! 139: }else{
! 140: db->flags &= ~aPragma[i].mask;
! 141: }
! 142: return 1;
! 143: }
! 144: }
! 145: return 0;
! 146: }
! 147:
! 148: /*
! 149: ** Process a pragma statement.
! 150: **
! 151: ** Pragmas are of this form:
! 152: **
! 153: ** PRAGMA id = value
! 154: **
! 155: ** The identifier might also be a string. The value is a string, and
! 156: ** identifier, or a number. If minusFlag is true, then the value is
! 157: ** a number that was preceded by a minus sign.
! 158: */
! 159: void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){
! 160: char *zLeft = 0;
! 161: char *zRight = 0;
! 162: sqlite *db = pParse->db;
! 163: Vdbe *v = sqliteGetVdbe(pParse);
! 164: if( v==0 ) return;
! 165:
! 166: zLeft = sqliteStrNDup(pLeft->z, pLeft->n);
! 167: sqliteDequote(zLeft);
! 168: if( minusFlag ){
! 169: zRight = 0;
! 170: sqliteSetNString(&zRight, "-", 1, pRight->z, pRight->n, 0);
! 171: }else{
! 172: zRight = sqliteStrNDup(pRight->z, pRight->n);
! 173: sqliteDequote(zRight);
! 174: }
! 175: if( sqliteAuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, 0) ){
! 176: sqliteFree(zLeft);
! 177: sqliteFree(zRight);
! 178: return;
! 179: }
! 180:
! 181: /*
! 182: ** PRAGMA default_cache_size
! 183: ** PRAGMA default_cache_size=N
! 184: **
! 185: ** The first form reports the current persistent setting for the
! 186: ** page cache size. The value returned is the maximum number of
! 187: ** pages in the page cache. The second form sets both the current
! 188: ** page cache size value and the persistent page cache size value
! 189: ** stored in the database file.
! 190: **
! 191: ** The default cache size is stored in meta-value 2 of page 1 of the
! 192: ** database file. The cache size is actually the absolute value of
! 193: ** this memory location. The sign of meta-value 2 determines the
! 194: ** synchronous setting. A negative value means synchronous is off
! 195: ** and a positive value means synchronous is on.
! 196: */
! 197: if( sqliteStrICmp(zLeft,"default_cache_size")==0 ){
! 198: static VdbeOpList getCacheSize[] = {
! 199: { OP_ReadCookie, 0, 2, 0},
! 200: { OP_AbsValue, 0, 0, 0},
! 201: { OP_Dup, 0, 0, 0},
! 202: { OP_Integer, 0, 0, 0},
! 203: { OP_Ne, 0, 6, 0},
! 204: { OP_Integer, 0, 0, 0}, /* 5 */
! 205: { OP_ColumnName, 0, 1, "cache_size"},
! 206: { OP_Callback, 1, 0, 0},
! 207: };
! 208: int addr;
! 209: if( pRight->z==pLeft->z ){
! 210: addr = sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
! 211: sqliteVdbeChangeP1(v, addr+5, MAX_PAGES);
! 212: }else{
! 213: int size = atoi(zRight);
! 214: if( size<0 ) size = -size;
! 215: sqliteBeginWriteOperation(pParse, 0, 0);
! 216: sqliteVdbeAddOp(v, OP_Integer, size, 0);
! 217: sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2);
! 218: addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0);
! 219: sqliteVdbeAddOp(v, OP_Ge, 0, addr+3);
! 220: sqliteVdbeAddOp(v, OP_Negative, 0, 0);
! 221: sqliteVdbeAddOp(v, OP_SetCookie, 0, 2);
! 222: sqliteEndWriteOperation(pParse);
! 223: db->cache_size = db->cache_size<0 ? -size : size;
! 224: sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);
! 225: }
! 226: }else
! 227:
! 228: /*
! 229: ** PRAGMA cache_size
! 230: ** PRAGMA cache_size=N
! 231: **
! 232: ** The first form reports the current local setting for the
! 233: ** page cache size. The local setting can be different from
! 234: ** the persistent cache size value that is stored in the database
! 235: ** file itself. The value returned is the maximum number of
! 236: ** pages in the page cache. The second form sets the local
! 237: ** page cache size value. It does not change the persistent
! 238: ** cache size stored on the disk so the cache size will revert
! 239: ** to its default value when the database is closed and reopened.
! 240: ** N should be a positive integer.
! 241: */
! 242: if( sqliteStrICmp(zLeft,"cache_size")==0 ){
! 243: static VdbeOpList getCacheSize[] = {
! 244: { OP_ColumnName, 0, 1, "cache_size"},
! 245: { OP_Callback, 1, 0, 0},
! 246: };
! 247: if( pRight->z==pLeft->z ){
! 248: int size = db->cache_size;;
! 249: if( size<0 ) size = -size;
! 250: sqliteVdbeAddOp(v, OP_Integer, size, 0);
! 251: sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
! 252: }else{
! 253: int size = atoi(zRight);
! 254: if( size<0 ) size = -size;
! 255: if( db->cache_size<0 ) size = -size;
! 256: db->cache_size = size;
! 257: sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);
! 258: }
! 259: }else
! 260:
! 261: /*
! 262: ** PRAGMA default_synchronous
! 263: ** PRAGMA default_synchronous=ON|OFF|NORMAL|FULL
! 264: **
! 265: ** The first form returns the persistent value of the "synchronous" setting
! 266: ** that is stored in the database. This is the synchronous setting that
! 267: ** is used whenever the database is opened unless overridden by a separate
! 268: ** "synchronous" pragma. The second form changes the persistent and the
! 269: ** local synchronous setting to the value given.
! 270: **
! 271: ** If synchronous is OFF, SQLite does not attempt any fsync() systems calls
! 272: ** to make sure data is committed to disk. Write operations are very fast,
! 273: ** but a power failure can leave the database in an inconsistent state.
! 274: ** If synchronous is ON or NORMAL, SQLite will do an fsync() system call to
! 275: ** make sure data is being written to disk. The risk of corruption due to
! 276: ** a power loss in this mode is negligible but non-zero. If synchronous
! 277: ** is FULL, extra fsync()s occur to reduce the risk of corruption to near
! 278: ** zero, but with a write performance penalty. The default mode is NORMAL.
! 279: */
! 280: if( sqliteStrICmp(zLeft,"default_synchronous")==0 ){
! 281: static VdbeOpList getSync[] = {
! 282: { OP_ColumnName, 0, 1, "synchronous"},
! 283: { OP_ReadCookie, 0, 3, 0},
! 284: { OP_Dup, 0, 0, 0},
! 285: { OP_If, 0, 0, 0}, /* 3 */
! 286: { OP_ReadCookie, 0, 2, 0},
! 287: { OP_Integer, 0, 0, 0},
! 288: { OP_Lt, 0, 5, 0},
! 289: { OP_AddImm, 1, 0, 0},
! 290: { OP_Callback, 1, 0, 0},
! 291: { OP_Halt, 0, 0, 0},
! 292: { OP_AddImm, -1, 0, 0}, /* 10 */
! 293: { OP_Callback, 1, 0, 0}
! 294: };
! 295: if( pRight->z==pLeft->z ){
! 296: int addr = sqliteVdbeAddOpList(v, ArraySize(getSync), getSync);
! 297: sqliteVdbeChangeP2(v, addr+3, addr+10);
! 298: }else{
! 299: int addr;
! 300: int size = db->cache_size;
! 301: if( size<0 ) size = -size;
! 302: sqliteBeginWriteOperation(pParse, 0, 0);
! 303: sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2);
! 304: sqliteVdbeAddOp(v, OP_Dup, 0, 0);
! 305: addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0);
! 306: sqliteVdbeAddOp(v, OP_Ne, 0, addr+3);
! 307: sqliteVdbeAddOp(v, OP_AddImm, MAX_PAGES, 0);
! 308: sqliteVdbeAddOp(v, OP_AbsValue, 0, 0);
! 309: db->safety_level = getSafetyLevel(zRight)+1;
! 310: if( db->safety_level==1 ){
! 311: sqliteVdbeAddOp(v, OP_Negative, 0, 0);
! 312: size = -size;
! 313: }
! 314: sqliteVdbeAddOp(v, OP_SetCookie, 0, 2);
! 315: sqliteVdbeAddOp(v, OP_Integer, db->safety_level, 0);
! 316: sqliteVdbeAddOp(v, OP_SetCookie, 0, 3);
! 317: sqliteEndWriteOperation(pParse);
! 318: db->cache_size = size;
! 319: sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);
! 320: sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level);
! 321: }
! 322: }else
! 323:
! 324: /*
! 325: ** PRAGMA synchronous
! 326: ** PRAGMA synchronous=OFF|ON|NORMAL|FULL
! 327: **
! 328: ** Return or set the local value of the synchronous flag. Changing
! 329: ** the local value does not make changes to the disk file and the
! 330: ** default value will be restored the next time the database is
! 331: ** opened.
! 332: */
! 333: if( sqliteStrICmp(zLeft,"synchronous")==0 ){
! 334: static VdbeOpList getSync[] = {
! 335: { OP_ColumnName, 0, 1, "synchronous"},
! 336: { OP_Callback, 1, 0, 0},
! 337: };
! 338: if( pRight->z==pLeft->z ){
! 339: sqliteVdbeAddOp(v, OP_Integer, db->safety_level-1, 0);
! 340: sqliteVdbeAddOpList(v, ArraySize(getSync), getSync);
! 341: }else{
! 342: int size = db->cache_size;
! 343: if( size<0 ) size = -size;
! 344: db->safety_level = getSafetyLevel(zRight)+1;
! 345: if( db->safety_level==1 ) size = -size;
! 346: db->cache_size = size;
! 347: sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size);
! 348: sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level);
! 349: }
! 350: }else
! 351:
! 352: #ifndef NDEBUG
! 353: if( sqliteStrICmp(zLeft, "trigger_overhead_test")==0 ){
! 354: if( getBoolean(zRight) ){
! 355: always_code_trigger_setup = 1;
! 356: }else{
! 357: always_code_trigger_setup = 0;
! 358: }
! 359: }else
! 360: #endif
! 361:
! 362: if( flagPragma(pParse, zLeft, zRight) ){
! 363: /* The flagPragma() call also generates any necessary code */
! 364: }else
! 365:
! 366: if( sqliteStrICmp(zLeft, "table_info")==0 ){
! 367: Table *pTab;
! 368: pTab = sqliteFindTable(db, zRight, 0);
! 369: if( pTab ){
! 370: static VdbeOpList tableInfoPreface[] = {
! 371: { OP_ColumnName, 0, 0, "cid"},
! 372: { OP_ColumnName, 1, 0, "name"},
! 373: { OP_ColumnName, 2, 0, "type"},
! 374: { OP_ColumnName, 3, 0, "notnull"},
! 375: { OP_ColumnName, 4, 0, "dflt_value"},
! 376: { OP_ColumnName, 5, 1, "pk"},
! 377: };
! 378: int i;
! 379: sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface);
! 380: sqliteViewGetColumnNames(pParse, pTab);
! 381: for(i=0; i<pTab->nCol; i++){
! 382: sqliteVdbeAddOp(v, OP_Integer, i, 0);
! 383: sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zName, 0);
! 384: sqliteVdbeOp3(v, OP_String, 0, 0,
! 385: pTab->aCol[i].zType ? pTab->aCol[i].zType : "numeric", 0);
! 386: sqliteVdbeAddOp(v, OP_Integer, pTab->aCol[i].notNull, 0);
! 387: sqliteVdbeOp3(v, OP_String, 0, 0,
! 388: pTab->aCol[i].zDflt, P3_STATIC);
! 389: sqliteVdbeAddOp(v, OP_Integer, pTab->aCol[i].isPrimKey, 0);
! 390: sqliteVdbeAddOp(v, OP_Callback, 6, 0);
! 391: }
! 392: }
! 393: }else
! 394:
! 395: if( sqliteStrICmp(zLeft, "index_info")==0 ){
! 396: Index *pIdx;
! 397: Table *pTab;
! 398: pIdx = sqliteFindIndex(db, zRight, 0);
! 399: if( pIdx ){
! 400: static VdbeOpList tableInfoPreface[] = {
! 401: { OP_ColumnName, 0, 0, "seqno"},
! 402: { OP_ColumnName, 1, 0, "cid"},
! 403: { OP_ColumnName, 2, 1, "name"},
! 404: };
! 405: int i;
! 406: pTab = pIdx->pTable;
! 407: sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface);
! 408: for(i=0; i<pIdx->nColumn; i++){
! 409: int cnum = pIdx->aiColumn[i];
! 410: sqliteVdbeAddOp(v, OP_Integer, i, 0);
! 411: sqliteVdbeAddOp(v, OP_Integer, cnum, 0);
! 412: assert( pTab->nCol>cnum );
! 413: sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[cnum].zName, 0);
! 414: sqliteVdbeAddOp(v, OP_Callback, 3, 0);
! 415: }
! 416: }
! 417: }else
! 418:
! 419: if( sqliteStrICmp(zLeft, "index_list")==0 ){
! 420: Index *pIdx;
! 421: Table *pTab;
! 422: pTab = sqliteFindTable(db, zRight, 0);
! 423: if( pTab ){
! 424: v = sqliteGetVdbe(pParse);
! 425: pIdx = pTab->pIndex;
! 426: }
! 427: if( pTab && pIdx ){
! 428: int i = 0;
! 429: static VdbeOpList indexListPreface[] = {
! 430: { OP_ColumnName, 0, 0, "seq"},
! 431: { OP_ColumnName, 1, 0, "name"},
! 432: { OP_ColumnName, 2, 1, "unique"},
! 433: };
! 434:
! 435: sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface);
! 436: while(pIdx){
! 437: sqliteVdbeAddOp(v, OP_Integer, i, 0);
! 438: sqliteVdbeOp3(v, OP_String, 0, 0, pIdx->zName, 0);
! 439: sqliteVdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0);
! 440: sqliteVdbeAddOp(v, OP_Callback, 3, 0);
! 441: ++i;
! 442: pIdx = pIdx->pNext;
! 443: }
! 444: }
! 445: }else
! 446:
! 447: if( sqliteStrICmp(zLeft, "foreign_key_list")==0 ){
! 448: FKey *pFK;
! 449: Table *pTab;
! 450: pTab = sqliteFindTable(db, zRight, 0);
! 451: if( pTab ){
! 452: v = sqliteGetVdbe(pParse);
! 453: pFK = pTab->pFKey;
! 454: }
! 455: if( pTab && pFK ){
! 456: int i = 0;
! 457: static VdbeOpList indexListPreface[] = {
! 458: { OP_ColumnName, 0, 0, "id"},
! 459: { OP_ColumnName, 1, 0, "seq"},
! 460: { OP_ColumnName, 2, 0, "table"},
! 461: { OP_ColumnName, 3, 0, "from"},
! 462: { OP_ColumnName, 4, 1, "to"},
! 463: };
! 464:
! 465: sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface);
! 466: while(pFK){
! 467: int j;
! 468: for(j=0; j<pFK->nCol; j++){
! 469: sqliteVdbeAddOp(v, OP_Integer, i, 0);
! 470: sqliteVdbeAddOp(v, OP_Integer, j, 0);
! 471: sqliteVdbeOp3(v, OP_String, 0, 0, pFK->zTo, 0);
! 472: sqliteVdbeOp3(v, OP_String, 0, 0,
! 473: pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
! 474: sqliteVdbeOp3(v, OP_String, 0, 0, pFK->aCol[j].zCol, 0);
! 475: sqliteVdbeAddOp(v, OP_Callback, 5, 0);
! 476: }
! 477: ++i;
! 478: pFK = pFK->pNextFrom;
! 479: }
! 480: }
! 481: }else
! 482:
! 483: if( sqliteStrICmp(zLeft, "database_list")==0 ){
! 484: int i;
! 485: static VdbeOpList indexListPreface[] = {
! 486: { OP_ColumnName, 0, 0, "seq"},
! 487: { OP_ColumnName, 1, 0, "name"},
! 488: { OP_ColumnName, 2, 1, "file"},
! 489: };
! 490:
! 491: sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface);
! 492: for(i=0; i<db->nDb; i++){
! 493: if( db->aDb[i].pBt==0 ) continue;
! 494: assert( db->aDb[i].zName!=0 );
! 495: sqliteVdbeAddOp(v, OP_Integer, i, 0);
! 496: sqliteVdbeOp3(v, OP_String, 0, 0, db->aDb[i].zName, 0);
! 497: sqliteVdbeOp3(v, OP_String, 0, 0,
! 498: sqliteBtreeGetFilename(db->aDb[i].pBt), 0);
! 499: sqliteVdbeAddOp(v, OP_Callback, 3, 0);
! 500: }
! 501: }else
! 502:
! 503:
! 504: /*
! 505: ** PRAGMA temp_store
! 506: ** PRAGMA temp_store = "default"|"memory"|"file"
! 507: **
! 508: ** Return or set the local value of the temp_store flag. Changing
! 509: ** the local value does not make changes to the disk file and the default
! 510: ** value will be restored the next time the database is opened.
! 511: **
! 512: ** Note that it is possible for the library compile-time options to
! 513: ** override this setting
! 514: */
! 515: if( sqliteStrICmp(zLeft, "temp_store")==0 ){
! 516: static VdbeOpList getTmpDbLoc[] = {
! 517: { OP_ColumnName, 0, 1, "temp_store"},
! 518: { OP_Callback, 1, 0, 0},
! 519: };
! 520: if( pRight->z==pLeft->z ){
! 521: sqliteVdbeAddOp(v, OP_Integer, db->temp_store, 0);
! 522: sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc);
! 523: }else{
! 524: changeTempStorage(pParse, zRight);
! 525: }
! 526: }else
! 527:
! 528: /*
! 529: ** PRAGMA default_temp_store
! 530: ** PRAGMA default_temp_store = "default"|"memory"|"file"
! 531: **
! 532: ** Return or set the value of the persistent temp_store flag. Any
! 533: ** change does not take effect until the next time the database is
! 534: ** opened.
! 535: **
! 536: ** Note that it is possible for the library compile-time options to
! 537: ** override this setting
! 538: */
! 539: if( sqliteStrICmp(zLeft, "default_temp_store")==0 ){
! 540: static VdbeOpList getTmpDbLoc[] = {
! 541: { OP_ColumnName, 0, 1, "temp_store"},
! 542: { OP_ReadCookie, 0, 5, 0},
! 543: { OP_Callback, 1, 0, 0}};
! 544: if( pRight->z==pLeft->z ){
! 545: sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc);
! 546: }else{
! 547: sqliteBeginWriteOperation(pParse, 0, 0);
! 548: sqliteVdbeAddOp(v, OP_Integer, getTempStore(zRight), 0);
! 549: sqliteVdbeAddOp(v, OP_SetCookie, 0, 5);
! 550: sqliteEndWriteOperation(pParse);
! 551: }
! 552: }else
! 553:
! 554: #ifndef NDEBUG
! 555: if( sqliteStrICmp(zLeft, "parser_trace")==0 ){
! 556: extern void sqliteParserTrace(FILE*, char *);
! 557: if( getBoolean(zRight) ){
! 558: sqliteParserTrace(stdout, "parser: ");
! 559: }else{
! 560: sqliteParserTrace(0, 0);
! 561: }
! 562: }else
! 563: #endif
! 564:
! 565: if( sqliteStrICmp(zLeft, "integrity_check")==0 ){
! 566: int i, j, addr;
! 567:
! 568: /* Code that initializes the integrity check program. Set the
! 569: ** error count 0
! 570: */
! 571: static VdbeOpList initCode[] = {
! 572: { OP_Integer, 0, 0, 0},
! 573: { OP_MemStore, 0, 1, 0},
! 574: { OP_ColumnName, 0, 1, "integrity_check"},
! 575: };
! 576:
! 577: /* Code to do an BTree integrity check on a single database file.
! 578: */
! 579: static VdbeOpList checkDb[] = {
! 580: { OP_SetInsert, 0, 0, "2"},
! 581: { OP_Integer, 0, 0, 0}, /* 1 */
! 582: { OP_OpenRead, 0, 2, 0},
! 583: { OP_Rewind, 0, 7, 0}, /* 3 */
! 584: { OP_Column, 0, 3, 0}, /* 4 */
! 585: { OP_SetInsert, 0, 0, 0},
! 586: { OP_Next, 0, 4, 0}, /* 6 */
! 587: { OP_IntegrityCk, 0, 0, 0}, /* 7 */
! 588: { OP_Dup, 0, 1, 0},
! 589: { OP_String, 0, 0, "ok"},
! 590: { OP_StrEq, 0, 12, 0}, /* 10 */
! 591: { OP_MemIncr, 0, 0, 0},
! 592: { OP_String, 0, 0, "*** in database "},
! 593: { OP_String, 0, 0, 0}, /* 13 */
! 594: { OP_String, 0, 0, " ***\n"},
! 595: { OP_Pull, 3, 0, 0},
! 596: { OP_Concat, 4, 1, 0},
! 597: { OP_Callback, 1, 0, 0},
! 598: };
! 599:
! 600: /* Code that appears at the end of the integrity check. If no error
! 601: ** messages have been generated, output OK. Otherwise output the
! 602: ** error message
! 603: */
! 604: static VdbeOpList endCode[] = {
! 605: { OP_MemLoad, 0, 0, 0},
! 606: { OP_Integer, 0, 0, 0},
! 607: { OP_Ne, 0, 0, 0}, /* 2 */
! 608: { OP_String, 0, 0, "ok"},
! 609: { OP_Callback, 1, 0, 0},
! 610: };
! 611:
! 612: /* Initialize the VDBE program */
! 613: sqliteVdbeAddOpList(v, ArraySize(initCode), initCode);
! 614:
! 615: /* Do an integrity check on each database file */
! 616: for(i=0; i<db->nDb; i++){
! 617: HashElem *x;
! 618:
! 619: /* Do an integrity check of the B-Tree
! 620: */
! 621: addr = sqliteVdbeAddOpList(v, ArraySize(checkDb), checkDb);
! 622: sqliteVdbeChangeP1(v, addr+1, i);
! 623: sqliteVdbeChangeP2(v, addr+3, addr+7);
! 624: sqliteVdbeChangeP2(v, addr+6, addr+4);
! 625: sqliteVdbeChangeP2(v, addr+7, i);
! 626: sqliteVdbeChangeP2(v, addr+10, addr+ArraySize(checkDb));
! 627: sqliteVdbeChangeP3(v, addr+13, db->aDb[i].zName, P3_STATIC);
! 628:
! 629: /* Make sure all the indices are constructed correctly.
! 630: */
! 631: sqliteCodeVerifySchema(pParse, i);
! 632: for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){
! 633: Table *pTab = sqliteHashData(x);
! 634: Index *pIdx;
! 635: int loopTop;
! 636:
! 637: if( pTab->pIndex==0 ) continue;
! 638: sqliteVdbeAddOp(v, OP_Integer, i, 0);
! 639: sqliteVdbeOp3(v, OP_OpenRead, 1, pTab->tnum, pTab->zName, 0);
! 640: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
! 641: if( pIdx->tnum==0 ) continue;
! 642: sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0);
! 643: sqliteVdbeOp3(v, OP_OpenRead, j+2, pIdx->tnum, pIdx->zName, 0);
! 644: }
! 645: sqliteVdbeAddOp(v, OP_Integer, 0, 0);
! 646: sqliteVdbeAddOp(v, OP_MemStore, 1, 1);
! 647: loopTop = sqliteVdbeAddOp(v, OP_Rewind, 1, 0);
! 648: sqliteVdbeAddOp(v, OP_MemIncr, 1, 0);
! 649: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
! 650: int k, jmp2;
! 651: static VdbeOpList idxErr[] = {
! 652: { OP_MemIncr, 0, 0, 0},
! 653: { OP_String, 0, 0, "rowid "},
! 654: { OP_Recno, 1, 0, 0},
! 655: { OP_String, 0, 0, " missing from index "},
! 656: { OP_String, 0, 0, 0}, /* 4 */
! 657: { OP_Concat, 4, 0, 0},
! 658: { OP_Callback, 1, 0, 0},
! 659: };
! 660: sqliteVdbeAddOp(v, OP_Recno, 1, 0);
! 661: for(k=0; k<pIdx->nColumn; k++){
! 662: int idx = pIdx->aiColumn[k];
! 663: if( idx==pTab->iPKey ){
! 664: sqliteVdbeAddOp(v, OP_Recno, 1, 0);
! 665: }else{
! 666: sqliteVdbeAddOp(v, OP_Column, 1, idx);
! 667: }
! 668: }
! 669: sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0);
! 670: if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx);
! 671: jmp2 = sqliteVdbeAddOp(v, OP_Found, j+2, 0);
! 672: addr = sqliteVdbeAddOpList(v, ArraySize(idxErr), idxErr);
! 673: sqliteVdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC);
! 674: sqliteVdbeChangeP2(v, jmp2, sqliteVdbeCurrentAddr(v));
! 675: }
! 676: sqliteVdbeAddOp(v, OP_Next, 1, loopTop+1);
! 677: sqliteVdbeChangeP2(v, loopTop, sqliteVdbeCurrentAddr(v));
! 678: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
! 679: static VdbeOpList cntIdx[] = {
! 680: { OP_Integer, 0, 0, 0},
! 681: { OP_MemStore, 2, 1, 0},
! 682: { OP_Rewind, 0, 0, 0}, /* 2 */
! 683: { OP_MemIncr, 2, 0, 0},
! 684: { OP_Next, 0, 0, 0}, /* 4 */
! 685: { OP_MemLoad, 1, 0, 0},
! 686: { OP_MemLoad, 2, 0, 0},
! 687: { OP_Eq, 0, 0, 0}, /* 7 */
! 688: { OP_MemIncr, 0, 0, 0},
! 689: { OP_String, 0, 0, "wrong # of entries in index "},
! 690: { OP_String, 0, 0, 0}, /* 10 */
! 691: { OP_Concat, 2, 0, 0},
! 692: { OP_Callback, 1, 0, 0},
! 693: };
! 694: if( pIdx->tnum==0 ) continue;
! 695: addr = sqliteVdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
! 696: sqliteVdbeChangeP1(v, addr+2, j+2);
! 697: sqliteVdbeChangeP2(v, addr+2, addr+5);
! 698: sqliteVdbeChangeP1(v, addr+4, j+2);
! 699: sqliteVdbeChangeP2(v, addr+4, addr+3);
! 700: sqliteVdbeChangeP2(v, addr+7, addr+ArraySize(cntIdx));
! 701: sqliteVdbeChangeP3(v, addr+10, pIdx->zName, P3_STATIC);
! 702: }
! 703: }
! 704: }
! 705: addr = sqliteVdbeAddOpList(v, ArraySize(endCode), endCode);
! 706: sqliteVdbeChangeP2(v, addr+2, addr+ArraySize(endCode));
! 707: }else
! 708:
! 709: {}
! 710: sqliteFree(zLeft);
! 711: sqliteFree(zRight);
! 712: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pragma.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