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,v 1.96 2005/06/23 03:15:08 drh Exp $ 15 */ 16 #include "sqliteInt.h" 17 #include "os.h" 18 #include <ctype.h> 19 20 /* Ignore this whole file if pragmas are disabled 21 */ 22 #if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER) 23 24 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 25 # include "pager.h" 26 # include "btree.h" 27 #endif 28 29 /* 30 ** Interpret the given string as a safety level. Return 0 for OFF, 31 ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or 32 ** unrecognized string argument. 33 ** 34 ** Note that the values returned are one less that the values that 35 ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done 36 ** to support legacy SQL code. The safety level used to be boolean 37 ** and older scripts may have used numbers 0 for OFF and 1 for ON. 38 */ 39 static int getSafetyLevel(const u8 *z){ 40 /* 123456789 123456789 */ 41 static const char zText[] = "onoffalseyestruefull"; 42 static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16}; 43 static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4}; 44 static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2}; 45 int i, n; 46 if( isdigit(*z) ){ 47 return atoi(z); 48 } 49 n = strlen(z); 50 for(i=0; i<sizeof(iLength); i++){ 51 if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){ 52 return iValue[i]; 53 } 54 } 55 return 1; 56 } 57 58 /* 59 ** Interpret the given string as a boolean value. 60 */ 61 static int getBoolean(const u8 *z){ 62 return getSafetyLevel(z)&1; 63 } 64 65 #ifndef SQLITE_OMIT_PAGER_PRAGMAS 66 /* 67 ** Interpret the given string as a temp db location. Return 1 for file 68 ** backed temporary databases, 2 for the Red-Black tree in memory database 69 ** and 0 to use the compile-time default. 70 */ 71 static int getTempStore(const char *z){ 72 if( z[0]>='0' && z[0]<='2' ){ 73 return z[0] - '0'; 74 }else if( sqlite3StrICmp(z, "file")==0 ){ 75 return 1; 76 }else if( sqlite3StrICmp(z, "memory")==0 ){ 77 return 2; 78 }else{ 79 return 0; 80 } 81 } 82 #endif /* SQLITE_PAGER_PRAGMAS */ 83 84 #ifndef SQLITE_OMIT_PAGER_PRAGMAS 85 /* 86 ** Invalidate temp storage, either when the temp storage is changed 87 ** from default, or when 'file' and the temp_store_directory has changed 88 */ 89 static int invalidateTempStorage(Parse *pParse){ 90 sqlite3 *db = pParse->db; 91 if( db->aDb[1].pBt!=0 ){ 92 if( db->flags & SQLITE_InTrans ){ 93 sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " 94 "from within a transaction"); 95 return SQLITE_ERROR; 96 } 97 sqlite3BtreeClose(db->aDb[1].pBt); 98 db->aDb[1].pBt = 0; 99 sqlite3ResetInternalSchema(db, 0); 100 } 101 return SQLITE_OK; 102 } 103 #endif /* SQLITE_PAGER_PRAGMAS */ 104 105 #ifndef SQLITE_OMIT_PAGER_PRAGMAS 106 /* 107 ** If the TEMP database is open, close it and mark the database schema 108 ** as needing reloading. This must be done when using the TEMP_STORE 109 ** or DEFAULT_TEMP_STORE pragmas. 110 */ 111 static int changeTempStorage(Parse *pParse, const char *zStorageType){ 112 int ts = getTempStore(zStorageType); 113 sqlite3 *db = pParse->db; 114 if( db->temp_store==ts ) return SQLITE_OK; 115 if( invalidateTempStorage( pParse ) != SQLITE_OK ){ 116 return SQLITE_ERROR; 117 } 118 db->temp_store = ts; 119 return SQLITE_OK; 120 } 121 #endif /* SQLITE_PAGER_PRAGMAS */ 122 123 /* 124 ** Generate code to return a single integer value. 125 */ 126 static void returnSingleInt(Parse *pParse, const char *zLabel, int value){ 127 Vdbe *v = sqlite3GetVdbe(pParse); 128 sqlite3VdbeAddOp(v, OP_Integer, value, 0); 129 if( pParse->explain==0 ){ 130 sqlite3VdbeSetNumCols(v, 1); 131 sqlite3VdbeSetColName(v, 0, zLabel, P3_STATIC); 132 } 133 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); 134 } 135 136 #ifndef SQLITE_OMIT_FLAG_PRAGMAS 137 /* 138 ** Check to see if zRight and zLeft refer to a pragma that queries 139 ** or changes one of the flags in db->flags. Return 1 if so and 0 if not. 140 ** Also, implement the pragma. 141 */ 142 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){ 143 static const struct sPragmaType { 144 const char *zName; /* Name of the pragma */ 145 int mask; /* Mask for the db->flags value */ 146 } aPragma[] = { 147 { "vdbe_trace", SQLITE_VdbeTrace }, 148 { "sql_trace", SQLITE_SqlTrace }, 149 { "vdbe_listing", SQLITE_VdbeListing }, 150 { "full_column_names", SQLITE_FullColNames }, 151 { "short_column_names", SQLITE_ShortColNames }, 152 { "count_changes", SQLITE_CountRows }, 153 { "empty_result_callbacks", SQLITE_NullCallback }, 154 /* The following is VERY experimental */ 155 { "writable_schema", SQLITE_WriteSchema }, 156 { "omit_readlock", SQLITE_NoReadlock }, 157 }; 158 int i; 159 const struct sPragmaType *p; 160 for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){ 161 if( sqlite3StrICmp(zLeft, p->zName)==0 ){ 162 sqlite3 *db = pParse->db; 163 Vdbe *v; 164 v = sqlite3GetVdbe(pParse); 165 if( v ){ 166 if( zRight==0 ){ 167 returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 ); 168 }else{ 169 if( getBoolean(zRight) ){ 170 db->flags |= p->mask; 171 }else{ 172 db->flags &= ~p->mask; 173 } 174 } 175 /* If one of these pragmas is executed, any prepared statements 176 ** need to be recompiled. 177 */ 178 sqlite3VdbeAddOp(v, OP_Expire, 0, 0); 179 } 180 return 1; 181 } 182 } 183 return 0; 184 } 185 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */ 186 187 /* 188 ** Process a pragma statement. 189 ** 190 ** Pragmas are of this form: 191 ** 192 ** PRAGMA [database.]id [= value] 193 ** 194 ** The identifier might also be a string. The value is a string, and 195 ** identifier, or a number. If minusFlag is true, then the value is 196 ** a number that was preceded by a minus sign. 197 ** 198 ** If the left side is "database.id" then pId1 is the database name 199 ** and pId2 is the id. If the left side is just "id" then pId1 is the 200 ** id and pId2 is any empty string. 201 */ 202 void sqlite3Pragma( 203 Parse *pParse, 204 Token *pId1, /* First part of [database.]id field */ 205 Token *pId2, /* Second part of [database.]id field, or NULL */ 206 Token *pValue, /* Token for <value>, or NULL */ 207 int minusFlag /* True if a '-' sign preceded <value> */ 208 ){ 209 char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */ 210 char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */ 211 const char *zDb = 0; /* The database name */ 212 Token *pId; /* Pointer to <id> token */ 213 int iDb; /* Database index for <database> */ 214 sqlite3 *db = pParse->db; 215 Db *pDb; 216 Vdbe *v = sqlite3GetVdbe(pParse); 217 if( v==0 ) return; 218 219 /* Interpret the [database.] part of the pragma statement. iDb is the 220 ** index of the database this pragma is being applied to in db.aDb[]. */ 221 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); 222 if( iDb<0 ) return; 223 pDb = &db->aDb[iDb]; 224 225 zLeft = sqlite3NameFromToken(pId); 226 if( !zLeft ) return; 227 if( minusFlag ){ 228 zRight = sqlite3MPrintf("-%T", pValue); 229 }else{ 230 zRight = sqlite3NameFromToken(pValue); 231 } 232 233 zDb = ((iDb>0)?pDb->zName:0); 234 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ 235 goto pragma_out; 236 } 237 238 #ifndef SQLITE_OMIT_PAGER_PRAGMAS 239 /* 240 ** PRAGMA [database.]default_cache_size 241 ** PRAGMA [database.]default_cache_size=N 242 ** 243 ** The first form reports the current persistent setting for the 244 ** page cache size. The value returned is the maximum number of 245 ** pages in the page cache. The second form sets both the current 246 ** page cache size value and the persistent page cache size value 247 ** stored in the database file. 248 ** 249 ** The default cache size is stored in meta-value 2 of page 1 of the 250 ** database file. The cache size is actually the absolute value of 251 ** this memory location. The sign of meta-value 2 determines the 252 ** synchronous setting. A negative value means synchronous is off 253 ** and a positive value means synchronous is on. 254 */ 255 if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){ 256 static const VdbeOpList getCacheSize[] = { 257 { OP_ReadCookie, 0, 2, 0}, /* 0 */ 258 { OP_AbsValue, 0, 0, 0}, 259 { OP_Dup, 0, 0, 0}, 260 { OP_Integer, 0, 0, 0}, 261 { OP_Ne, 0, 6, 0}, 262 { OP_Integer, 0, 0, 0}, /* 5 */ 263 { OP_Callback, 1, 0, 0}, 264 }; 265 int addr; 266 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 267 if( !zRight ){ 268 sqlite3VdbeSetNumCols(v, 1); 269 sqlite3VdbeSetColName(v, 0, "cache_size", P3_STATIC); 270 addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); 271 sqlite3VdbeChangeP1(v, addr, iDb); 272 sqlite3VdbeChangeP1(v, addr+5, MAX_PAGES); 273 }else{ 274 int size = atoi(zRight); 275 if( size<0 ) size = -size; 276 sqlite3BeginWriteOperation(pParse, 0, iDb); 277 sqlite3VdbeAddOp(v, OP_Integer, size, 0); 278 sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2); 279 addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0); 280 sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3); 281 sqlite3VdbeAddOp(v, OP_Negative, 0, 0); 282 sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2); 283 pDb->cache_size = size; 284 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->cache_size); 285 } 286 }else 287 288 /* 289 ** PRAGMA [database.]page_size 290 ** PRAGMA [database.]page_size=N 291 ** 292 ** The first form reports the current setting for the 293 ** database page size in bytes. The second form sets the 294 ** database page size value. The value can only be set if 295 ** the database has not yet been created. 296 */ 297 if( sqlite3StrICmp(zLeft,"page_size")==0 ){ 298 Btree *pBt = pDb->pBt; 299 if( !zRight ){ 300 int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0; 301 returnSingleInt(pParse, "page_size", size); 302 }else{ 303 sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1); 304 } 305 }else 306 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */ 307 308 /* 309 ** PRAGMA [database.]auto_vacuum 310 ** PRAGMA [database.]auto_vacuum=N 311 ** 312 ** Get or set the (boolean) value of the database 'auto-vacuum' parameter. 313 */ 314 #ifndef SQLITE_OMIT_AUTOVACUUM 315 if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){ 316 Btree *pBt = pDb->pBt; 317 if( !zRight ){ 318 int auto_vacuum = 319 pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM; 320 returnSingleInt(pParse, "auto_vacuum", auto_vacuum); 321 }else{ 322 sqlite3BtreeSetAutoVacuum(pBt, getBoolean(zRight)); 323 } 324 }else 325 #endif 326 327 #ifndef SQLITE_OMIT_PAGER_PRAGMAS 328 /* 329 ** PRAGMA [database.]cache_size 330 ** PRAGMA [database.]cache_size=N 331 ** 332 ** The first form reports the current local setting for the 333 ** page cache size. The local setting can be different from 334 ** the persistent cache size value that is stored in the database 335 ** file itself. The value returned is the maximum number of 336 ** pages in the page cache. The second form sets the local 337 ** page cache size value. It does not change the persistent 338 ** cache size stored on the disk so the cache size will revert 339 ** to its default value when the database is closed and reopened. 340 ** N should be a positive integer. 341 */ 342 if( sqlite3StrICmp(zLeft,"cache_size")==0 ){ 343 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 344 if( !zRight ){ 345 returnSingleInt(pParse, "cache_size", pDb->cache_size); 346 }else{ 347 int size = atoi(zRight); 348 if( size<0 ) size = -size; 349 pDb->cache_size = size; 350 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->cache_size); 351 } 352 }else 353 354 /* 355 ** PRAGMA temp_store 356 ** PRAGMA temp_store = "default"|"memory"|"file" 357 ** 358 ** Return or set the local value of the temp_store flag. Changing 359 ** the local value does not make changes to the disk file and the default 360 ** value will be restored the next time the database is opened. 361 ** 362 ** Note that it is possible for the library compile-time options to 363 ** override this setting 364 */ 365 if( sqlite3StrICmp(zLeft, "temp_store")==0 ){ 366 if( !zRight ){ 367 returnSingleInt(pParse, "temp_store", db->temp_store); 368 }else{ 369 changeTempStorage(pParse, zRight); 370 } 371 }else 372 373 /* 374 ** PRAGMA temp_store_directory 375 ** PRAGMA temp_store_directory = ""|"directory_name" 376 ** 377 ** Return or set the local value of the temp_store_directory flag. Changing 378 ** the value sets a specific directory to be used for temporary files. 379 ** Setting to a null string reverts to the default temporary directory search. 380 ** If temporary directory is changed, then invalidateTempStorage. 381 ** 382 */ 383 if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){ 384 if( !zRight ){ 385 if( sqlite3_temp_directory ){ 386 sqlite3VdbeSetNumCols(v, 1); 387 sqlite3VdbeSetColName(v, 0, "temp_store_directory", P3_STATIC); 388 sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0); 389 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); 390 } 391 }else{ 392 if( zRight[0] && !sqlite3OsIsDirWritable(zRight) ){ 393 sqlite3ErrorMsg(pParse, "not a writable directory"); 394 goto pragma_out; 395 } 396 if( TEMP_STORE==0 397 || (TEMP_STORE==1 && db->temp_store<=1) 398 || (TEMP_STORE==2 && db->temp_store==1) 399 ){ 400 invalidateTempStorage(pParse); 401 } 402 sqliteFree(sqlite3_temp_directory); 403 if( zRight[0] ){ 404 sqlite3_temp_directory = zRight; 405 zRight = 0; 406 }else{ 407 sqlite3_temp_directory = 0; 408 } 409 } 410 }else 411 412 /* 413 ** PRAGMA [database.]synchronous 414 ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL 415 ** 416 ** Return or set the local value of the synchronous flag. Changing 417 ** the local value does not make changes to the disk file and the 418 ** default value will be restored the next time the database is 419 ** opened. 420 */ 421 if( sqlite3StrICmp(zLeft,"synchronous")==0 ){ 422 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 423 if( !zRight ){ 424 returnSingleInt(pParse, "synchronous", pDb->safety_level-1); 425 }else{ 426 if( !db->autoCommit ){ 427 sqlite3ErrorMsg(pParse, 428 "Safety level may not be changed inside a transaction"); 429 }else{ 430 pDb->safety_level = getSafetyLevel(zRight)+1; 431 sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level); 432 } 433 } 434 }else 435 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */ 436 437 #ifndef SQLITE_OMIT_FLAG_PRAGMAS 438 if( flagPragma(pParse, zLeft, zRight) ){ 439 /* The flagPragma() subroutine also generates any necessary code 440 ** there is nothing more to do here */ 441 }else 442 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */ 443 444 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS 445 /* 446 ** PRAGMA table_info(<table>) 447 ** 448 ** Return a single row for each column of the named table. The columns of 449 ** the returned data set are: 450 ** 451 ** cid: Column id (numbered from left to right, starting at 0) 452 ** name: Column name 453 ** type: Column declaration type. 454 ** notnull: True if 'NOT NULL' is part of column declaration 455 ** dflt_value: The default value for the column, if any. 456 */ 457 if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){ 458 Table *pTab; 459 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 460 pTab = sqlite3FindTable(db, zRight, zDb); 461 if( pTab ){ 462 int i; 463 sqlite3VdbeSetNumCols(v, 6); 464 sqlite3VdbeSetColName(v, 0, "cid", P3_STATIC); 465 sqlite3VdbeSetColName(v, 1, "name", P3_STATIC); 466 sqlite3VdbeSetColName(v, 2, "type", P3_STATIC); 467 sqlite3VdbeSetColName(v, 3, "notnull", P3_STATIC); 468 sqlite3VdbeSetColName(v, 4, "dflt_value", P3_STATIC); 469 sqlite3VdbeSetColName(v, 5, "pk", P3_STATIC); 470 sqlite3ViewGetColumnNames(pParse, pTab); 471 for(i=0; i<pTab->nCol; i++){ 472 sqlite3VdbeAddOp(v, OP_Integer, i, 0); 473 sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[i].zName, 0); 474 sqlite3VdbeOp3(v, OP_String8, 0, 0, 475 pTab->aCol[i].zType ? pTab->aCol[i].zType : "numeric", 0); 476 sqlite3VdbeAddOp(v, OP_Integer, pTab->aCol[i].notNull, 0); 477 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); 478 sqlite3VdbeAddOp(v, OP_Integer, pTab->aCol[i].isPrimKey, 0); 479 sqlite3VdbeAddOp(v, OP_Callback, 6, 0); 480 } 481 } 482 }else 483 484 if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){ 485 Index *pIdx; 486 Table *pTab; 487 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 488 pIdx = sqlite3FindIndex(db, zRight, zDb); 489 if( pIdx ){ 490 int i; 491 pTab = pIdx->pTable; 492 sqlite3VdbeSetNumCols(v, 3); 493 sqlite3VdbeSetColName(v, 0, "seqno", P3_STATIC); 494 sqlite3VdbeSetColName(v, 1, "cid", P3_STATIC); 495 sqlite3VdbeSetColName(v, 2, "name", P3_STATIC); 496 for(i=0; i<pIdx->nColumn; i++){ 497 int cnum = pIdx->aiColumn[i]; 498 sqlite3VdbeAddOp(v, OP_Integer, i, 0); 499 sqlite3VdbeAddOp(v, OP_Integer, cnum, 0); 500 assert( pTab->nCol>cnum ); 501 sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0); 502 sqlite3VdbeAddOp(v, OP_Callback, 3, 0); 503 } 504 } 505 }else 506 507 if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){ 508 Index *pIdx; 509 Table *pTab; 510 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 511 pTab = sqlite3FindTable(db, zRight, zDb); 512 if( pTab ){ 513 v = sqlite3GetVdbe(pParse); 514 pIdx = pTab->pIndex; 515 if( pIdx ){ 516 int i = 0; 517 sqlite3VdbeSetNumCols(v, 3); 518 sqlite3VdbeSetColName(v, 0, "seq", P3_STATIC); 519 sqlite3VdbeSetColName(v, 1, "name", P3_STATIC); 520 sqlite3VdbeSetColName(v, 2, "unique", P3_STATIC); 521 while(pIdx){ 522 sqlite3VdbeAddOp(v, OP_Integer, i, 0); 523 sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0); 524 sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0); 525 sqlite3VdbeAddOp(v, OP_Callback, 3, 0); 526 ++i; 527 pIdx = pIdx->pNext; 528 } 529 } 530 } 531 }else 532 533 if( sqlite3StrICmp(zLeft, "database_list")==0 ){ 534 int i; 535 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 536 sqlite3VdbeSetNumCols(v, 3); 537 sqlite3VdbeSetColName(v, 0, "seq", P3_STATIC); 538 sqlite3VdbeSetColName(v, 1, "name", P3_STATIC); 539 sqlite3VdbeSetColName(v, 2, "file", P3_STATIC); 540 for(i=0; i<db->nDb; i++){ 541 if( db->aDb[i].pBt==0 ) continue; 542 assert( db->aDb[i].zName!=0 ); 543 sqlite3VdbeAddOp(v, OP_Integer, i, 0); 544 sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0); 545 sqlite3VdbeOp3(v, OP_String8, 0, 0, 546 sqlite3BtreeGetFilename(db->aDb[i].pBt), 0); 547 sqlite3VdbeAddOp(v, OP_Callback, 3, 0); 548 } 549 }else 550 551 if( sqlite3StrICmp(zLeft, "collation_list")==0 ){ 552 int i = 0; 553 HashElem *p; 554 sqlite3VdbeSetNumCols(v, 2); 555 sqlite3VdbeSetColName(v, 0, "seq", P3_STATIC); 556 sqlite3VdbeSetColName(v, 1, "name", P3_STATIC); 557 for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ 558 CollSeq *pColl = (CollSeq *)sqliteHashData(p); 559 sqlite3VdbeAddOp(v, OP_Integer, i++, 0); 560 sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0); 561 sqlite3VdbeAddOp(v, OP_Callback, 2, 0); 562 } 563 }else 564 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */ 565 566 #ifndef SQLITE_OMIT_FOREIGN_KEY 567 if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){ 568 FKey *pFK; 569 Table *pTab; 570 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 571 pTab = sqlite3FindTable(db, zRight, zDb); 572 if( pTab ){ 573 v = sqlite3GetVdbe(pParse); 574 pFK = pTab->pFKey; 575 if( pFK ){ 576 int i = 0; 577 sqlite3VdbeSetNumCols(v, 5); 578 sqlite3VdbeSetColName(v, 0, "id", P3_STATIC); 579 sqlite3VdbeSetColName(v, 1, "seq", P3_STATIC); 580 sqlite3VdbeSetColName(v, 2, "table", P3_STATIC); 581 sqlite3VdbeSetColName(v, 3, "from", P3_STATIC); 582 sqlite3VdbeSetColName(v, 4, "to", P3_STATIC); 583 while(pFK){ 584 int j; 585 for(j=0; j<pFK->nCol; j++){ 586 char *zCol = pFK->aCol[j].zCol; 587 sqlite3VdbeAddOp(v, OP_Integer, i, 0); 588 sqlite3VdbeAddOp(v, OP_Integer, j, 0); 589 sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0); 590 sqlite3VdbeOp3(v, OP_String8, 0, 0, 591 pTab->aCol[pFK->aCol[j].iFrom].zName, 0); 592 sqlite3VdbeOp3(v, zCol ? OP_String8 : OP_Null, 0, 0, zCol, 0); 593 sqlite3VdbeAddOp(v, OP_Callback, 5, 0); 594 } 595 ++i; 596 pFK = pFK->pNextFrom; 597 } 598 } 599 } 600 }else 601 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ 602 603 #ifndef NDEBUG 604 if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){ 605 extern void sqlite3ParserTrace(FILE*, char *); 606 if( getBoolean(zRight) ){ 607 sqlite3ParserTrace(stdout, "parser: "); 608 }else{ 609 sqlite3ParserTrace(0, 0); 610 } 611 }else 612 #endif 613 614 #ifndef SQLITE_OMIT_INTEGRITY_CHECK 615 if( sqlite3StrICmp(zLeft, "integrity_check")==0 ){ 616 int i, j, addr; 617 618 /* Code that initializes the integrity check program. Set the 619 ** error count 0 620 */ 621 static const VdbeOpList initCode[] = { 622 { OP_Integer, 0, 0, 0}, 623 { OP_MemStore, 0, 1, 0}, 624 }; 625 626 /* Code that appears at the end of the integrity check. If no error 627 ** messages have been generated, output OK. Otherwise output the 628 ** error message 629 */ 630 static const VdbeOpList endCode[] = { 631 { OP_MemLoad, 0, 0, 0}, 632 { OP_Integer, 0, 0, 0}, 633 { OP_Ne, 0, 0, 0}, /* 2 */ 634 { OP_String8, 0, 0, "ok"}, 635 { OP_Callback, 1, 0, 0}, 636 }; 637 638 /* Initialize the VDBE program */ 639 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 640 sqlite3VdbeSetNumCols(v, 1); 641 sqlite3VdbeSetColName(v, 0, "integrity_check", P3_STATIC); 642 sqlite3VdbeAddOpList(v, ArraySize(initCode), initCode); 643 644 /* Do an integrity check on each database file */ 645 for(i=0; i<db->nDb; i++){ 646 HashElem *x; 647 int cnt = 0; 648 649 if( OMIT_TEMPDB && i==1 ) continue; 650 651 sqlite3CodeVerifySchema(pParse, i); 652 653 /* Do an integrity check of the B-Tree 654 */ 655 for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){ 656 Table *pTab = sqliteHashData(x); 657 Index *pIdx; 658 sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0); 659 cnt++; 660 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ 661 if( sqlite3CheckIndexCollSeq(pParse, pIdx) ) goto pragma_out; 662 sqlite3VdbeAddOp(v, OP_Integer, pIdx->tnum, 0); 663 cnt++; 664 } 665 } 666 assert( cnt>0 ); 667 sqlite3VdbeAddOp(v, OP_IntegrityCk, cnt, i); 668 sqlite3VdbeAddOp(v, OP_Dup, 0, 1); 669 addr = sqlite3VdbeOp3(v, OP_String8, 0, 0, "ok", P3_STATIC); 670 sqlite3VdbeAddOp(v, OP_Eq, 0, addr+6); 671 sqlite3VdbeOp3(v, OP_String8, 0, 0, 672 sqlite3MPrintf("*** in database %s ***\n", db->aDb[i].zName), 673 P3_DYNAMIC); 674 sqlite3VdbeAddOp(v, OP_Pull, 1, 0); 675 sqlite3VdbeAddOp(v, OP_Concat, 0, 1); 676 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); 677 678 /* Make sure all the indices are constructed correctly. 679 */ 680 sqlite3CodeVerifySchema(pParse, i); 681 for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){ 682 Table *pTab = sqliteHashData(x); 683 Index *pIdx; 684 int loopTop; 685 686 if( pTab->pIndex==0 ) continue; 687 sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead); 688 sqlite3VdbeAddOp(v, OP_Integer, 0, 0); 689 sqlite3VdbeAddOp(v, OP_MemStore, 1, 1); 690 loopTop = sqlite3VdbeAddOp(v, OP_Rewind, 1, 0); 691 sqlite3VdbeAddOp(v, OP_MemIncr, 1, 0); 692 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ 693 int jmp2; 694 static const VdbeOpList idxErr[] = { 695 { OP_MemIncr, 0, 0, 0}, 696 { OP_String8, 0, 0, "rowid "}, 697 { OP_Rowid, 1, 0, 0}, 698 { OP_String8, 0, 0, " missing from index "}, 699 { OP_String8, 0, 0, 0}, /* 4 */ 700 { OP_Concat, 2, 0, 0}, 701 { OP_Callback, 1, 0, 0}, 702 }; 703 sqlite3GenerateIndexKey(v, pIdx, 1); 704 jmp2 = sqlite3VdbeAddOp(v, OP_Found, j+2, 0); 705 addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr); 706 sqlite3VdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC); 707 sqlite3VdbeChangeP2(v, jmp2, sqlite3VdbeCurrentAddr(v)); 708 } 709 sqlite3VdbeAddOp(v, OP_Next, 1, loopTop+1); 710 sqlite3VdbeChangeP2(v, loopTop, sqlite3VdbeCurrentAddr(v)); 711 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ 712 static const VdbeOpList cntIdx[] = { 713 { OP_Integer, 0, 0, 0}, 714 { OP_MemStore, 2, 1, 0}, 715 { OP_Rewind, 0, 0, 0}, /* 2 */ 716 { OP_MemIncr, 2, 0, 0}, 717 { OP_Next, 0, 0, 0}, /* 4 */ 718 { OP_MemLoad, 1, 0, 0}, 719 { OP_MemLoad, 2, 0, 0}, 720 { OP_Eq, 0, 0, 0}, /* 7 */ 721 { OP_MemIncr, 0, 0, 0}, 722 { OP_String8, 0, 0, "wrong # of entries in index "}, 723 { OP_String8, 0, 0, 0}, /* 10 */ 724 { OP_Concat, 0, 0, 0}, 725 { OP_Callback, 1, 0, 0}, 726 }; 727 if( pIdx->tnum==0 ) continue; 728 addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx); 729 sqlite3VdbeChangeP1(v, addr+2, j+2); 730 sqlite3VdbeChangeP2(v, addr+2, addr+5); 731 sqlite3VdbeChangeP1(v, addr+4, j+2); 732 sqlite3VdbeChangeP2(v, addr+4, addr+3); 733 sqlite3VdbeChangeP2(v, addr+7, addr+ArraySize(cntIdx)); 734 sqlite3VdbeChangeP3(v, addr+10, pIdx->zName, P3_STATIC); 735 } 736 } 737 } 738 addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode); 739 sqlite3VdbeChangeP2(v, addr+2, addr+ArraySize(endCode)); 740 }else 741 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ 742 743 #ifndef SQLITE_OMIT_UTF16 744 /* 745 ** PRAGMA encoding 746 ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" 747 ** 748 ** In it's first form, this pragma returns the encoding of the main 749 ** database. If the database is not initialized, it is initialized now. 750 ** 751 ** The second form of this pragma is a no-op if the main database file 752 ** has not already been initialized. In this case it sets the default 753 ** encoding that will be used for the main database file if a new file 754 ** is created. If an existing main database file is opened, then the 755 ** default text encoding for the existing database is used. 756 ** 757 ** In all cases new databases created using the ATTACH command are 758 ** created to use the same default text encoding as the main database. If 759 ** the main database has not been initialized and/or created when ATTACH 760 ** is executed, this is done before the ATTACH operation. 761 ** 762 ** In the second form this pragma sets the text encoding to be used in 763 ** new database files created using this database handle. It is only 764 ** useful if invoked immediately after the main database i 765 */ 766 if( sqlite3StrICmp(zLeft, "encoding")==0 ){ 767 static struct EncName { 768 char *zName; 769 u8 enc; 770 } encnames[] = { 771 { "UTF-8", SQLITE_UTF8 }, 772 { "UTF8", SQLITE_UTF8 }, 773 { "UTF-16le", SQLITE_UTF16LE }, 774 { "UTF16le", SQLITE_UTF16LE }, 775 { "UTF-16be", SQLITE_UTF16BE }, 776 { "UTF16be", SQLITE_UTF16BE }, 777 { "UTF-16", 0 /* Filled in at run-time */ }, 778 { "UTF16", 0 /* Filled in at run-time */ }, 779 { 0, 0 } 780 }; 781 struct EncName *pEnc; 782 encnames[6].enc = encnames[7].enc = SQLITE_UTF16NATIVE; 783 if( !zRight ){ /* "PRAGMA encoding" */ 784 if( sqlite3ReadSchema(pParse) ) goto pragma_out; 785 sqlite3VdbeSetNumCols(v, 1); 786 sqlite3VdbeSetColName(v, 0, "encoding", P3_STATIC); 787 sqlite3VdbeAddOp(v, OP_String8, 0, 0); 788 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ 789 if( pEnc->enc==pParse->db->enc ){ 790 sqlite3VdbeChangeP3(v, -1, pEnc->zName, P3_STATIC); 791 break; 792 } 793 } 794 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); 795 }else{ /* "PRAGMA encoding = XXX" */ 796 /* Only change the value of sqlite.enc if the database handle is not 797 ** initialized. If the main database exists, the new sqlite.enc value 798 ** will be overwritten when the schema is next loaded. If it does not 799 ** already exists, it will be created to use the new encoding value. 800 */ 801 if( !(pParse->db->flags&SQLITE_Initialized) ){ 802 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ 803 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ 804 pParse->db->enc = pEnc->enc; 805 break; 806 } 807 } 808 if( !pEnc->zName ){ 809 sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); 810 } 811 } 812 } 813 }else 814 #endif /* SQLITE_OMIT_UTF16 */ 815 816 #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS 817 /* 818 ** PRAGMA [database.]schema_version 819 ** PRAGMA [database.]schema_version = <integer> 820 ** 821 ** PRAGMA [database.]user_version 822 ** PRAGMA [database.]user_version = <integer> 823 ** 824 ** The pragma's schema_version and user_version are used to set or get 825 ** the value of the schema-version and user-version, respectively. Both 826 ** the schema-version and the user-version are 32-bit signed integers 827 ** stored in the database header. 828 ** 829 ** The schema-cookie is usually only manipulated internally by SQLite. It 830 ** is incremented by SQLite whenever the database schema is modified (by 831 ** creating or dropping a table or index). The schema version is used by 832 ** SQLite each time a query is executed to ensure that the internal cache 833 ** of the schema used when compiling the SQL query matches the schema of 834 ** the database against which the compiled query is actually executed. 835 ** Subverting this mechanism by using "PRAGMA schema_version" to modify 836 ** the schema-version is potentially dangerous and may lead to program 837 ** crashes or database corruption. Use with caution! 838 ** 839 ** The user-version is not used internally by SQLite. It may be used by 840 ** applications for any purpose. 841 */ 842 if( sqlite3StrICmp(zLeft, "schema_version")==0 || 843 sqlite3StrICmp(zLeft, "user_version")==0 ){ 844 845 int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */ 846 if( zLeft[0]=='s' || zLeft[0]=='S' ){ 847 iCookie = 0; 848 }else{ 849 iCookie = 5; 850 } 851 852 if( zRight ){ 853 /* Write the specified cookie value */ 854 static const VdbeOpList setCookie[] = { 855 { OP_Transaction, 0, 1, 0}, /* 0 */ 856 { OP_Integer, 0, 0, 0}, /* 1 */ 857 { OP_SetCookie, 0, 0, 0}, /* 2 */ 858 }; 859 int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie); 860 sqlite3VdbeChangeP1(v, addr, iDb); 861 sqlite3VdbeChangeP1(v, addr+1, atoi(zRight)); 862 sqlite3VdbeChangeP1(v, addr+2, iDb); 863 sqlite3VdbeChangeP2(v, addr+2, iCookie); 864 }else{ 865 /* Read the specified cookie value */ 866 static const VdbeOpList readCookie[] = { 867 { OP_ReadCookie, 0, 0, 0}, /* 0 */ 868 { OP_Callback, 1, 0, 0} 869 }; 870 int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie); 871 sqlite3VdbeChangeP1(v, addr, iDb); 872 sqlite3VdbeChangeP2(v, addr, iCookie); 873 sqlite3VdbeSetNumCols(v, 1); 874 } 875 } 876 #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ 877 878 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 879 /* 880 ** Report the current state of file logs for all databases 881 */ 882 if( sqlite3StrICmp(zLeft, "lock_status")==0 ){ 883 static const char *const azLockName[] = { 884 "unlocked", "shared", "reserved", "pending", "exclusive" 885 }; 886 int i; 887 Vdbe *v = sqlite3GetVdbe(pParse); 888 sqlite3VdbeSetNumCols(v, 2); 889 sqlite3VdbeSetColName(v, 0, "database", P3_STATIC); 890 sqlite3VdbeSetColName(v, 1, "status", P3_STATIC); 891 for(i=0; i<db->nDb; i++){ 892 Btree *pBt; 893 Pager *pPager; 894 if( db->aDb[i].zName==0 ) continue; 895 sqlite3VdbeOp3(v, OP_String, 0, 0, db->aDb[i].zName, P3_STATIC); 896 pBt = db->aDb[i].pBt; 897 if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){ 898 sqlite3VdbeOp3(v, OP_String, 0, 0, "closed", P3_STATIC); 899 }else{ 900 int j = sqlite3pager_lockstate(pPager); 901 sqlite3VdbeOp3(v, OP_String, 0, 0, 902 (j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC); 903 } 904 sqlite3VdbeAddOp(v, OP_Callback, 2, 0); 905 } 906 }else 907 #endif 908 909 #ifdef SQLITE_SSE 910 /* 911 ** Check to see if the sqlite_statements table exists. Create it 912 ** if it does not. 913 */ 914 if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){ 915 extern int sqlite3CreateStatementsTable(Parse*); 916 sqlite3CreateStatementsTable(pParse); 917 }else 918 #endif 919 920 {} 921 922 if( v ){ 923 /* Code an OP_Expire at the end of each PRAGMA program to cause 924 ** the VDBE implementing the pragma to expire. Most (all?) pragmas 925 ** are only valid for a single execution. 926 */ 927 sqlite3VdbeAddOp(v, OP_Expire, 1, 0); 928 } 929 pragma_out: 930 sqliteFree(zLeft); 931 sqliteFree(zRight); 932 } 933 934 #endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */ 935