pragma.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:43k
源码类别:

数据库系统

开发平台:

C/C++

  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.174 2008/03/27 22:42:52 drh Exp $
  15. */
  16. #include "sqliteInt.h"
  17. #include <ctype.h>
  18. /* Ignore this whole file if pragmas are disabled
  19. */
  20. #if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER)
  21. /*
  22. ** Interpret the given string as a safety level.  Return 0 for OFF,
  23. ** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or 
  24. ** unrecognized string argument.
  25. **
  26. ** Note that the values returned are one less that the values that
  27. ** should be passed into sqlite3BtreeSetSafetyLevel().  The is done
  28. ** to support legacy SQL code.  The safety level used to be boolean
  29. ** and older scripts may have used numbers 0 for OFF and 1 for ON.
  30. */
  31. static int getSafetyLevel(const char *z){
  32.                              /* 123456789 123456789 */
  33.   static const char zText[] = "onoffalseyestruefull";
  34.   static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
  35.   static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
  36.   static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};
  37.   int i, n;
  38.   if( isdigit(*z) ){
  39.     return atoi(z);
  40.   }
  41.   n = strlen(z);
  42.   for(i=0; i<sizeof(iLength); i++){
  43.     if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
  44.       return iValue[i];
  45.     }
  46.   }
  47.   return 1;
  48. }
  49. /*
  50. ** Interpret the given string as a boolean value.
  51. */
  52. static int getBoolean(const char *z){
  53.   return getSafetyLevel(z)&1;
  54. }
  55. /*
  56. ** Interpret the given string as a locking mode value.
  57. */
  58. static int getLockingMode(const char *z){
  59.   if( z ){
  60.     if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
  61.     if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
  62.   }
  63.   return PAGER_LOCKINGMODE_QUERY;
  64. }
  65. #ifndef SQLITE_OMIT_AUTOVACUUM
  66. /*
  67. ** Interpret the given string as an auto-vacuum mode value.
  68. **
  69. ** The following strings, "none", "full" and "incremental" are 
  70. ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
  71. */
  72. static int getAutoVacuum(const char *z){
  73.   int i;
  74.   if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
  75.   if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
  76.   if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
  77.   i = atoi(z);
  78.   return ((i>=0&&i<=2)?i:0);
  79. }
  80. #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
  81. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  82. /*
  83. ** Interpret the given string as a temp db location. Return 1 for file
  84. ** backed temporary databases, 2 for the Red-Black tree in memory database
  85. ** and 0 to use the compile-time default.
  86. */
  87. static int getTempStore(const char *z){
  88.   if( z[0]>='0' && z[0]<='2' ){
  89.     return z[0] - '0';
  90.   }else if( sqlite3StrICmp(z, "file")==0 ){
  91.     return 1;
  92.   }else if( sqlite3StrICmp(z, "memory")==0 ){
  93.     return 2;
  94.   }else{
  95.     return 0;
  96.   }
  97. }
  98. #endif /* SQLITE_PAGER_PRAGMAS */
  99. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  100. /*
  101. ** Invalidate temp storage, either when the temp storage is changed
  102. ** from default, or when 'file' and the temp_store_directory has changed
  103. */
  104. static int invalidateTempStorage(Parse *pParse){
  105.   sqlite3 *db = pParse->db;
  106.   if( db->aDb[1].pBt!=0 ){
  107.     if( !db->autoCommit ){
  108.       sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
  109.         "from within a transaction");
  110.       return SQLITE_ERROR;
  111.     }
  112.     sqlite3BtreeClose(db->aDb[1].pBt);
  113.     db->aDb[1].pBt = 0;
  114.     sqlite3ResetInternalSchema(db, 0);
  115.   }
  116.   return SQLITE_OK;
  117. }
  118. #endif /* SQLITE_PAGER_PRAGMAS */
  119. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  120. /*
  121. ** If the TEMP database is open, close it and mark the database schema
  122. ** as needing reloading.  This must be done when using the TEMP_STORE
  123. ** or DEFAULT_TEMP_STORE pragmas.
  124. */
  125. static int changeTempStorage(Parse *pParse, const char *zStorageType){
  126.   int ts = getTempStore(zStorageType);
  127.   sqlite3 *db = pParse->db;
  128.   if( db->temp_store==ts ) return SQLITE_OK;
  129.   if( invalidateTempStorage( pParse ) != SQLITE_OK ){
  130.     return SQLITE_ERROR;
  131.   }
  132.   db->temp_store = ts;
  133.   return SQLITE_OK;
  134. }
  135. #endif /* SQLITE_PAGER_PRAGMAS */
  136. /*
  137. ** Generate code to return a single integer value.
  138. */
  139. static void returnSingleInt(Parse *pParse, const char *zLabel, int value){
  140.   Vdbe *v = sqlite3GetVdbe(pParse);
  141.   int mem = ++pParse->nMem;
  142.   sqlite3VdbeAddOp2(v, OP_Integer, value, mem);
  143.   if( pParse->explain==0 ){
  144.     sqlite3VdbeSetNumCols(v, 1);
  145.     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P4_STATIC);
  146.   }
  147.   sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
  148. }
  149. #ifndef SQLITE_OMIT_FLAG_PRAGMAS
  150. /*
  151. ** Check to see if zRight and zLeft refer to a pragma that queries
  152. ** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.
  153. ** Also, implement the pragma.
  154. */
  155. static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
  156.   static const struct sPragmaType {
  157.     const char *zName;  /* Name of the pragma */
  158.     int mask;           /* Mask for the db->flags value */
  159.   } aPragma[] = {
  160.     { "full_column_names",        SQLITE_FullColNames  },
  161.     { "short_column_names",       SQLITE_ShortColNames },
  162.     { "count_changes",            SQLITE_CountRows     },
  163.     { "empty_result_callbacks",   SQLITE_NullCallback  },
  164.     { "legacy_file_format",       SQLITE_LegacyFileFmt },
  165.     { "fullfsync",                SQLITE_FullFSync     },
  166. #ifdef SQLITE_DEBUG
  167.     { "sql_trace",                SQLITE_SqlTrace      },
  168.     { "vdbe_listing",             SQLITE_VdbeListing   },
  169.     { "vdbe_trace",               SQLITE_VdbeTrace     },
  170. #endif
  171. #ifndef SQLITE_OMIT_CHECK
  172.     { "ignore_check_constraints", SQLITE_IgnoreChecks  },
  173. #endif
  174.     /* The following is VERY experimental */
  175.     { "writable_schema",          SQLITE_WriteSchema|SQLITE_RecoveryMode },
  176.     { "omit_readlock",            SQLITE_NoReadlock    },
  177.     /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
  178.     ** flag if there are any active statements. */
  179.     { "read_uncommitted",         SQLITE_ReadUncommitted },
  180.   };
  181.   int i;
  182.   const struct sPragmaType *p;
  183.   for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){
  184.     if( sqlite3StrICmp(zLeft, p->zName)==0 ){
  185.       sqlite3 *db = pParse->db;
  186.       Vdbe *v;
  187.       v = sqlite3GetVdbe(pParse);
  188.       if( v ){
  189.         if( zRight==0 ){
  190.           returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
  191.         }else{
  192.           if( getBoolean(zRight) ){
  193.             db->flags |= p->mask;
  194.           }else{
  195.             db->flags &= ~p->mask;
  196.           }
  197.           /* Many of the flag-pragmas modify the code generated by the SQL 
  198.           ** compiler (eg. count_changes). So add an opcode to expire all
  199.           ** compiled SQL statements after modifying a pragma value.
  200.           */
  201.           sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
  202.         }
  203.       }
  204.       return 1;
  205.     }
  206.   }
  207.   return 0;
  208. }
  209. #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
  210. /*
  211. ** Process a pragma statement.  
  212. **
  213. ** Pragmas are of this form:
  214. **
  215. **      PRAGMA [database.]id [= value]
  216. **
  217. ** The identifier might also be a string.  The value is a string, and
  218. ** identifier, or a number.  If minusFlag is true, then the value is
  219. ** a number that was preceded by a minus sign.
  220. **
  221. ** If the left side is "database.id" then pId1 is the database name
  222. ** and pId2 is the id.  If the left side is just "id" then pId1 is the
  223. ** id and pId2 is any empty string.
  224. */
  225. void sqlite3Pragma(
  226.   Parse *pParse, 
  227.   Token *pId1,        /* First part of [database.]id field */
  228.   Token *pId2,        /* Second part of [database.]id field, or NULL */
  229.   Token *pValue,      /* Token for <value>, or NULL */
  230.   int minusFlag       /* True if a '-' sign preceded <value> */
  231. ){
  232.   char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */
  233.   char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */
  234.   const char *zDb = 0;   /* The database name */
  235.   Token *pId;            /* Pointer to <id> token */
  236.   int iDb;               /* Database index for <database> */
  237.   sqlite3 *db = pParse->db;
  238.   Db *pDb;
  239.   Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
  240.   if( v==0 ) return;
  241.   pParse->nMem = 2;
  242.   /* Interpret the [database.] part of the pragma statement. iDb is the
  243.   ** index of the database this pragma is being applied to in db.aDb[]. */
  244.   iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
  245.   if( iDb<0 ) return;
  246.   pDb = &db->aDb[iDb];
  247.   /* If the temp database has been explicitly named as part of the 
  248.   ** pragma, make sure it is open. 
  249.   */
  250.   if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
  251.     return;
  252.   }
  253.   zLeft = sqlite3NameFromToken(db, pId);
  254.   if( !zLeft ) return;
  255.   if( minusFlag ){
  256.     zRight = sqlite3MPrintf(db, "-%T", pValue);
  257.   }else{
  258.     zRight = sqlite3NameFromToken(db, pValue);
  259.   }
  260.   zDb = ((iDb>0)?pDb->zName:0);
  261.   if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
  262.     goto pragma_out;
  263.   }
  264.  
  265. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  266.   /*
  267.   **  PRAGMA [database.]default_cache_size
  268.   **  PRAGMA [database.]default_cache_size=N
  269.   **
  270.   ** The first form reports the current persistent setting for the
  271.   ** page cache size.  The value returned is the maximum number of
  272.   ** pages in the page cache.  The second form sets both the current
  273.   ** page cache size value and the persistent page cache size value
  274.   ** stored in the database file.
  275.   **
  276.   ** The default cache size is stored in meta-value 2 of page 1 of the
  277.   ** database file.  The cache size is actually the absolute value of
  278.   ** this memory location.  The sign of meta-value 2 determines the
  279.   ** synchronous setting.  A negative value means synchronous is off
  280.   ** and a positive value means synchronous is on.
  281.   */
  282.   if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
  283.     static const VdbeOpList getCacheSize[] = {
  284.       { OP_ReadCookie,  0, 1,        2},  /* 0 */
  285.       { OP_IfPos,       1, 6,        0},
  286.       { OP_Integer,     0, 2,        0},
  287.       { OP_Subtract,    1, 2,        1},
  288.       { OP_IfPos,       1, 6,        0},
  289.       { OP_Integer,     0, 1,        0},  /* 5 */
  290.       { OP_ResultRow,   1, 1,        0},
  291.     };
  292.     int addr;
  293.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  294.     sqlite3VdbeUsesBtree(v, iDb);
  295.     if( !zRight ){
  296.       sqlite3VdbeSetNumCols(v, 1);
  297.       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P4_STATIC);
  298.       pParse->nMem += 2;
  299.       addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
  300.       sqlite3VdbeChangeP1(v, addr, iDb);
  301.       sqlite3VdbeChangeP1(v, addr+5, SQLITE_DEFAULT_CACHE_SIZE);
  302.     }else{
  303.       int size = atoi(zRight);
  304.       if( size<0 ) size = -size;
  305.       sqlite3BeginWriteOperation(pParse, 0, iDb);
  306.       sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
  307.       sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, 2, 2);
  308.       addr = sqlite3VdbeAddOp2(v, OP_IfPos, 2, 0);
  309.       sqlite3VdbeAddOp2(v, OP_Integer, -size, 1);
  310.       sqlite3VdbeJumpHere(v, addr);
  311.       sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 2, 1);
  312.       pDb->pSchema->cache_size = size;
  313.       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
  314.     }
  315.   }else
  316.   /*
  317.   **  PRAGMA [database.]page_size
  318.   **  PRAGMA [database.]page_size=N
  319.   **
  320.   ** The first form reports the current setting for the
  321.   ** database page size in bytes.  The second form sets the
  322.   ** database page size value.  The value can only be set if
  323.   ** the database has not yet been created.
  324.   */
  325.   if( sqlite3StrICmp(zLeft,"page_size")==0 ){
  326.     Btree *pBt = pDb->pBt;
  327.     if( !zRight ){
  328.       int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;
  329.       returnSingleInt(pParse, "page_size", size);
  330.     }else{
  331.       /* Malloc may fail when setting the page-size, as there is an internal
  332.       ** buffer that the pager module resizes using sqlite3_realloc().
  333.       */
  334.       db->nextPagesize = atoi(zRight);
  335.       if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1) ){
  336.         db->mallocFailed = 1;
  337.       }
  338.     }
  339.   }else
  340.   /*
  341.   **  PRAGMA [database.]max_page_count
  342.   **  PRAGMA [database.]max_page_count=N
  343.   **
  344.   ** The first form reports the current setting for the
  345.   ** maximum number of pages in the database file.  The 
  346.   ** second form attempts to change this setting.  Both
  347.   ** forms return the current setting.
  348.   */
  349.   if( sqlite3StrICmp(zLeft,"max_page_count")==0 ){
  350.     Btree *pBt = pDb->pBt;
  351.     int newMax = 0;
  352.     if( zRight ){
  353.       newMax = atoi(zRight);
  354.     }
  355.     if( pBt ){
  356.       newMax = sqlite3BtreeMaxPageCount(pBt, newMax);
  357.     }
  358.     returnSingleInt(pParse, "max_page_count", newMax);
  359.   }else
  360.   /*
  361.   **  PRAGMA [database.]locking_mode
  362.   **  PRAGMA [database.]locking_mode = (normal|exclusive)
  363.   */
  364.   if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){
  365.     const char *zRet = "normal";
  366.     int eMode = getLockingMode(zRight);
  367.     if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
  368.       /* Simple "PRAGMA locking_mode;" statement. This is a query for
  369.       ** the current default locking mode (which may be different to
  370.       ** the locking-mode of the main database).
  371.       */
  372.       eMode = db->dfltLockMode;
  373.     }else{
  374.       Pager *pPager;
  375.       if( pId2->n==0 ){
  376.         /* This indicates that no database name was specified as part
  377.         ** of the PRAGMA command. In this case the locking-mode must be
  378.         ** set on all attached databases, as well as the main db file.
  379.         **
  380.         ** Also, the sqlite3.dfltLockMode variable is set so that
  381.         ** any subsequently attached databases also use the specified
  382.         ** locking mode.
  383.         */
  384.         int ii;
  385.         assert(pDb==&db->aDb[0]);
  386.         for(ii=2; ii<db->nDb; ii++){
  387.           pPager = sqlite3BtreePager(db->aDb[ii].pBt);
  388.           sqlite3PagerLockingMode(pPager, eMode);
  389.         }
  390.         db->dfltLockMode = eMode;
  391.       }
  392.       pPager = sqlite3BtreePager(pDb->pBt);
  393.       eMode = sqlite3PagerLockingMode(pPager, eMode);
  394.     }
  395.     assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
  396.     if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
  397.       zRet = "exclusive";
  398.     }
  399.     sqlite3VdbeSetNumCols(v, 1);
  400.     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", P4_STATIC);
  401.     sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
  402.     sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
  403.   }else
  404. #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
  405.   /*
  406.   **  PRAGMA [database.]auto_vacuum
  407.   **  PRAGMA [database.]auto_vacuum=N
  408.   **
  409.   ** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
  410.   */
  411. #ifndef SQLITE_OMIT_AUTOVACUUM
  412.   if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
  413.     Btree *pBt = pDb->pBt;
  414.     if( sqlite3ReadSchema(pParse) ){
  415.       goto pragma_out;
  416.     }
  417.     if( !zRight ){
  418.       int auto_vacuum = 
  419.           pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;
  420.       returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
  421.     }else{
  422.       int eAuto = getAutoVacuum(zRight);
  423.       db->nextAutovac = eAuto;
  424.       if( eAuto>=0 ){
  425.         /* Call SetAutoVacuum() to set initialize the internal auto and
  426.         ** incr-vacuum flags. This is required in case this connection
  427.         ** creates the database file. It is important that it is created
  428.         ** as an auto-vacuum capable db.
  429.         */
  430.         int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
  431.         if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
  432.           /* When setting the auto_vacuum mode to either "full" or 
  433.           ** "incremental", write the value of meta[6] in the database
  434.           ** file. Before writing to meta[6], check that meta[3] indicates
  435.           ** that this really is an auto-vacuum capable database.
  436.           */
  437.           static const VdbeOpList setMeta6[] = {
  438.             { OP_Transaction,    0,               1,        0},    /* 0 */
  439.             { OP_ReadCookie,     0,               1,        3},    /* 1 */
  440.             { OP_If,             1,               0,        0},    /* 2 */
  441.             { OP_Halt,           SQLITE_OK,       OE_Abort, 0},    /* 3 */
  442.             { OP_Integer,        0,               1,        0},    /* 4 */
  443.             { OP_SetCookie,      0,               6,        1},    /* 5 */
  444.           };
  445.           int iAddr;
  446.           iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
  447.           sqlite3VdbeChangeP1(v, iAddr, iDb);
  448.           sqlite3VdbeChangeP1(v, iAddr+1, iDb);
  449.           sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
  450.           sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
  451.           sqlite3VdbeChangeP1(v, iAddr+5, iDb);
  452.           sqlite3VdbeUsesBtree(v, iDb);
  453.         }
  454.       }
  455.     }
  456.   }else
  457. #endif
  458.   /*
  459.   **  PRAGMA [database.]incremental_vacuum(N)
  460.   **
  461.   ** Do N steps of incremental vacuuming on a database.
  462.   */
  463. #ifndef SQLITE_OMIT_AUTOVACUUM
  464.   if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){
  465.     int iLimit, addr;
  466.     if( sqlite3ReadSchema(pParse) ){
  467.       goto pragma_out;
  468.     }
  469.     if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
  470.       iLimit = 0x7fffffff;
  471.     }
  472.     sqlite3BeginWriteOperation(pParse, 0, iDb);
  473.     sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
  474.     addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
  475.     sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
  476.     sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
  477.     sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
  478.     sqlite3VdbeJumpHere(v, addr);
  479.   }else
  480. #endif
  481. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  482.   /*
  483.   **  PRAGMA [database.]cache_size
  484.   **  PRAGMA [database.]cache_size=N
  485.   **
  486.   ** The first form reports the current local setting for the
  487.   ** page cache size.  The local setting can be different from
  488.   ** the persistent cache size value that is stored in the database
  489.   ** file itself.  The value returned is the maximum number of
  490.   ** pages in the page cache.  The second form sets the local
  491.   ** page cache size value.  It does not change the persistent
  492.   ** cache size stored on the disk so the cache size will revert
  493.   ** to its default value when the database is closed and reopened.
  494.   ** N should be a positive integer.
  495.   */
  496.   if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
  497.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  498.     if( !zRight ){
  499.       returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
  500.     }else{
  501.       int size = atoi(zRight);
  502.       if( size<0 ) size = -size;
  503.       pDb->pSchema->cache_size = size;
  504.       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
  505.     }
  506.   }else
  507.   /*
  508.   **   PRAGMA temp_store
  509.   **   PRAGMA temp_store = "default"|"memory"|"file"
  510.   **
  511.   ** Return or set the local value of the temp_store flag.  Changing
  512.   ** the local value does not make changes to the disk file and the default
  513.   ** value will be restored the next time the database is opened.
  514.   **
  515.   ** Note that it is possible for the library compile-time options to
  516.   ** override this setting
  517.   */
  518.   if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
  519.     if( !zRight ){
  520.       returnSingleInt(pParse, "temp_store", db->temp_store);
  521.     }else{
  522.       changeTempStorage(pParse, zRight);
  523.     }
  524.   }else
  525.   /*
  526.   **   PRAGMA temp_store_directory
  527.   **   PRAGMA temp_store_directory = ""|"directory_name"
  528.   **
  529.   ** Return or set the local value of the temp_store_directory flag.  Changing
  530.   ** the value sets a specific directory to be used for temporary files.
  531.   ** Setting to a null string reverts to the default temporary directory search.
  532.   ** If temporary directory is changed, then invalidateTempStorage.
  533.   **
  534.   */
  535.   if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
  536.     if( !zRight ){
  537.       if( sqlite3_temp_directory ){
  538.         sqlite3VdbeSetNumCols(v, 1);
  539.         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, 
  540.             "temp_store_directory", P4_STATIC);
  541.         sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
  542.         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
  543.       }
  544.     }else{
  545.       if( zRight[0] 
  546.        && sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE)==0 
  547.       ){
  548.         sqlite3ErrorMsg(pParse, "not a writable directory");
  549.         goto pragma_out;
  550.       }
  551.       if( TEMP_STORE==0
  552.        || (TEMP_STORE==1 && db->temp_store<=1)
  553.        || (TEMP_STORE==2 && db->temp_store==1)
  554.       ){
  555.         invalidateTempStorage(pParse);
  556.       }
  557.       sqlite3_free(sqlite3_temp_directory);
  558.       if( zRight[0] ){
  559.         sqlite3_temp_directory = zRight;
  560.         zRight = 0;
  561.       }else{
  562.         sqlite3_temp_directory = 0;
  563.       }
  564.     }
  565.   }else
  566.   /*
  567.   **   PRAGMA [database.]synchronous
  568.   **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
  569.   **
  570.   ** Return or set the local value of the synchronous flag.  Changing
  571.   ** the local value does not make changes to the disk file and the
  572.   ** default value will be restored the next time the database is
  573.   ** opened.
  574.   */
  575.   if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
  576.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  577.     if( !zRight ){
  578.       returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
  579.     }else{
  580.       if( !db->autoCommit ){
  581.         sqlite3ErrorMsg(pParse, 
  582.             "Safety level may not be changed inside a transaction");
  583.       }else{
  584.         pDb->safety_level = getSafetyLevel(zRight)+1;
  585.       }
  586.     }
  587.   }else
  588. #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
  589. #ifndef SQLITE_OMIT_FLAG_PRAGMAS
  590.   if( flagPragma(pParse, zLeft, zRight) ){
  591.     /* The flagPragma() subroutine also generates any necessary code
  592.     ** there is nothing more to do here */
  593.   }else
  594. #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
  595. #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
  596.   /*
  597.   **   PRAGMA table_info(<table>)
  598.   **
  599.   ** Return a single row for each column of the named table. The columns of
  600.   ** the returned data set are:
  601.   **
  602.   ** cid:        Column id (numbered from left to right, starting at 0)
  603.   ** name:       Column name
  604.   ** type:       Column declaration type.
  605.   ** notnull:    True if 'NOT NULL' is part of column declaration
  606.   ** dflt_value: The default value for the column, if any.
  607.   */
  608.   if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
  609.     Table *pTab;
  610.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  611.     pTab = sqlite3FindTable(db, zRight, zDb);
  612.     if( pTab ){
  613.       int i;
  614.       int nHidden = 0;
  615.       Column *pCol;
  616.       sqlite3VdbeSetNumCols(v, 6);
  617.       pParse->nMem = 6;
  618.       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P4_STATIC);
  619.       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
  620.       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P4_STATIC);
  621.       sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P4_STATIC);
  622.       sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P4_STATIC);
  623.       sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P4_STATIC);
  624.       sqlite3ViewGetColumnNames(pParse, pTab);
  625.       for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
  626.         const Token *pDflt;
  627.         if( IsHiddenColumn(pCol) ){
  628.           nHidden++;
  629.           continue;
  630.         }
  631.         sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
  632.         sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
  633.         sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
  634.            pCol->zType ? pCol->zType : "", 0);
  635.         sqlite3VdbeAddOp2(v, OP_Integer, pCol->notNull, 4);
  636.         if( pCol->pDflt && (pDflt = &pCol->pDflt->span)->z ){
  637.           sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pDflt->z, pDflt->n);
  638.         }else{
  639.           sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
  640.         }
  641.         sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
  642.         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
  643.       }
  644.     }
  645.   }else
  646.   if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
  647.     Index *pIdx;
  648.     Table *pTab;
  649.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  650.     pIdx = sqlite3FindIndex(db, zRight, zDb);
  651.     if( pIdx ){
  652.       int i;
  653.       pTab = pIdx->pTable;
  654.       sqlite3VdbeSetNumCols(v, 3);
  655.       pParse->nMem = 3;
  656.       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P4_STATIC);
  657.       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P4_STATIC);
  658.       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P4_STATIC);
  659.       for(i=0; i<pIdx->nColumn; i++){
  660.         int cnum = pIdx->aiColumn[i];
  661.         sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
  662.         sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
  663.         assert( pTab->nCol>cnum );
  664.         sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
  665.         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
  666.       }
  667.     }
  668.   }else
  669.   if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
  670.     Index *pIdx;
  671.     Table *pTab;
  672.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  673.     pTab = sqlite3FindTable(db, zRight, zDb);
  674.     if( pTab ){
  675.       v = sqlite3GetVdbe(pParse);
  676.       pIdx = pTab->pIndex;
  677.       if( pIdx ){
  678.         int i = 0; 
  679.         sqlite3VdbeSetNumCols(v, 3);
  680.         pParse->nMem = 3;
  681.         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
  682.         sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
  683.         sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P4_STATIC);
  684.         while(pIdx){
  685.           sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
  686.           sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
  687.           sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
  688.           sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
  689.           ++i;
  690.           pIdx = pIdx->pNext;
  691.         }
  692.       }
  693.     }
  694.   }else
  695.   if( sqlite3StrICmp(zLeft, "database_list")==0 ){
  696.     int i;
  697.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  698.     sqlite3VdbeSetNumCols(v, 3);
  699.     pParse->nMem = 3;
  700.     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
  701.     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
  702.     sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P4_STATIC);
  703.     for(i=0; i<db->nDb; i++){
  704.       if( db->aDb[i].pBt==0 ) continue;
  705.       assert( db->aDb[i].zName!=0 );
  706.       sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
  707.       sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
  708.       sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
  709.            sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
  710.       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
  711.     }
  712.   }else
  713.   if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
  714.     int i = 0;
  715.     HashElem *p;
  716.     sqlite3VdbeSetNumCols(v, 2);
  717.     pParse->nMem = 2;
  718.     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
  719.     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
  720.     for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
  721.       CollSeq *pColl = (CollSeq *)sqliteHashData(p);
  722.       sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
  723.       sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
  724.       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
  725.     }
  726.   }else
  727. #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
  728. #ifndef SQLITE_OMIT_FOREIGN_KEY
  729.   if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
  730.     FKey *pFK;
  731.     Table *pTab;
  732.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  733.     pTab = sqlite3FindTable(db, zRight, zDb);
  734.     if( pTab ){
  735.       v = sqlite3GetVdbe(pParse);
  736.       pFK = pTab->pFKey;
  737.       if( pFK ){
  738.         int i = 0; 
  739.         sqlite3VdbeSetNumCols(v, 5);
  740.         pParse->nMem = 5;
  741.         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P4_STATIC);
  742.         sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P4_STATIC);
  743.         sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P4_STATIC);
  744.         sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P4_STATIC);
  745.         sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P4_STATIC);
  746.         while(pFK){
  747.           int j;
  748.           for(j=0; j<pFK->nCol; j++){
  749.             char *zCol = pFK->aCol[j].zCol;
  750.             sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
  751.             sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
  752.             sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
  753.             sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
  754.                               pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
  755.             sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
  756.             sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
  757.           }
  758.           ++i;
  759.           pFK = pFK->pNextFrom;
  760.         }
  761.       }
  762.     }
  763.   }else
  764. #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
  765. #ifndef NDEBUG
  766.   if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
  767.     if( zRight ){
  768.       if( getBoolean(zRight) ){
  769.         sqlite3ParserTrace(stderr, "parser: ");
  770.       }else{
  771.         sqlite3ParserTrace(0, 0);
  772.       }
  773.     }
  774.   }else
  775. #endif
  776.   /* Reinstall the LIKE and GLOB functions.  The variant of LIKE
  777.   ** used will be case sensitive or not depending on the RHS.
  778.   */
  779.   if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
  780.     if( zRight ){
  781.       sqlite3RegisterLikeFunctions(db, getBoolean(zRight));
  782.     }
  783.   }else
  784. #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
  785. # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
  786. #endif
  787. #ifndef SQLITE_OMIT_INTEGRITY_CHECK
  788.   /* Pragma "quick_check" is an experimental reduced version of 
  789.   ** integrity_check designed to detect most database corruption
  790.   ** without most of the overhead of a full integrity-check.
  791.   */
  792.   if( sqlite3StrICmp(zLeft, "integrity_check")==0
  793.    || sqlite3StrICmp(zLeft, "quick_check")==0 
  794.   ){
  795.     int i, j, addr, mxErr;
  796.     /* Code that appears at the end of the integrity check.  If no error
  797.     ** messages have been generated, output OK.  Otherwise output the
  798.     ** error message
  799.     */
  800.     static const VdbeOpList endCode[] = {
  801.       { OP_AddImm,      1, 0,        0},    /* 0 */
  802.       { OP_IfNeg,       1, 0,        0},    /* 1 */
  803.       { OP_String8,     0, 3,        0},    /* 2 */
  804.       { OP_ResultRow,   3, 1,        0},
  805.     };
  806.     int isQuick = (zLeft[0]=='q');
  807.     /* Initialize the VDBE program */
  808.     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  809.     pParse->nMem = 6;
  810.     sqlite3VdbeSetNumCols(v, 1);
  811.     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P4_STATIC);
  812.     /* Set the maximum error count */
  813.     mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
  814.     if( zRight ){
  815.       mxErr = atoi(zRight);
  816.       if( mxErr<=0 ){
  817.         mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
  818.       }
  819.     }
  820.     sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1);  /* reg[1] holds errors left */
  821.     /* Do an integrity check on each database file */
  822.     for(i=0; i<db->nDb; i++){
  823.       HashElem *x;
  824.       Hash *pTbls;
  825.       int cnt = 0;
  826.       if( OMIT_TEMPDB && i==1 ) continue;
  827.       sqlite3CodeVerifySchema(pParse, i);
  828.       addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
  829.       sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
  830.       sqlite3VdbeJumpHere(v, addr);
  831.       /* Do an integrity check of the B-Tree
  832.       **
  833.       ** Begin by filling registers 2, 3, ... with the root pages numbers
  834.       ** for all tables and indices in the database.
  835.       */
  836.       pTbls = &db->aDb[i].pSchema->tblHash;
  837.       for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
  838.         Table *pTab = sqliteHashData(x);
  839.         Index *pIdx;
  840.         sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
  841.         cnt++;
  842.         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
  843.           sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
  844.           cnt++;
  845.         }
  846.       }
  847.       if( cnt==0 ) continue;
  848.       /* Make sure sufficient number of registers have been allocated */
  849.       if( pParse->nMem < cnt+4 ){
  850.         pParse->nMem = cnt+4;
  851.       }
  852.       /* Do the b-tree integrity checks */
  853.       sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
  854.       sqlite3VdbeChangeP5(v, i);
  855.       addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
  856.       sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
  857.          sqlite3MPrintf(db, "*** in database %s ***n", db->aDb[i].zName),
  858.          P4_DYNAMIC);
  859.       sqlite3VdbeAddOp2(v, OP_Move, 2, 4);
  860.       sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
  861.       sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
  862.       sqlite3VdbeJumpHere(v, addr);
  863.       /* Make sure all the indices are constructed correctly.
  864.       */
  865.       for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
  866.         Table *pTab = sqliteHashData(x);
  867.         Index *pIdx;
  868.         int loopTop;
  869.         if( pTab->pIndex==0 ) continue;
  870.         addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);  /* Stop if out of errors */
  871.         sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
  872.         sqlite3VdbeJumpHere(v, addr);
  873.         sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
  874.         sqlite3VdbeAddOp2(v, OP_Integer, 0, 2);  /* reg(2) will count entries */
  875.         loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);
  876.         sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1);   /* increment entry count */
  877.         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
  878.           int jmp2;
  879.           static const VdbeOpList idxErr[] = {
  880.             { OP_AddImm,      1, -1,  0},
  881.             { OP_String8,     0,  3,  0},    /* 1 */
  882.             { OP_Rowid,       1,  4,  0},
  883.             { OP_String8,     0,  5,  0},    /* 3 */
  884.             { OP_String8,     0,  6,  0},    /* 4 */
  885.             { OP_Concat,      4,  3,  3},
  886.             { OP_Concat,      5,  3,  3},
  887.             { OP_Concat,      6,  3,  3},
  888.             { OP_ResultRow,   3,  1,  0},
  889.             { OP_IfPos,       1,  0,  0},    /* 9 */
  890.             { OP_Halt,        0,  0,  0},
  891.           };
  892.           sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 1);
  893.           jmp2 = sqlite3VdbeAddOp3(v, OP_Found, j+2, 0, 3);
  894.           addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
  895.           sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
  896.           sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
  897.           sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_STATIC);
  898.           sqlite3VdbeJumpHere(v, addr+9);
  899.           sqlite3VdbeJumpHere(v, jmp2);
  900.         }
  901.         sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
  902.         sqlite3VdbeJumpHere(v, loopTop);
  903.         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
  904.           static const VdbeOpList cntIdx[] = {
  905.              { OP_Integer,      0,  3,  0},
  906.              { OP_Rewind,       0,  0,  0},  /* 1 */
  907.              { OP_AddImm,       3,  1,  0},
  908.              { OP_Next,         0,  0,  0},  /* 3 */
  909.              { OP_Eq,           2,  0,  3},  /* 4 */
  910.              { OP_AddImm,       1, -1,  0},
  911.              { OP_String8,      0,  2,  0},  /* 6 */
  912.              { OP_String8,      0,  3,  0},  /* 7 */
  913.              { OP_Concat,       3,  2,  2},
  914.              { OP_ResultRow,    2,  1,  0},
  915.           };
  916.           if( pIdx->tnum==0 ) continue;
  917.           addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
  918.           sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
  919.           sqlite3VdbeJumpHere(v, addr);
  920.           addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
  921.           sqlite3VdbeChangeP1(v, addr+1, j+2);
  922.           sqlite3VdbeChangeP2(v, addr+1, addr+4);
  923.           sqlite3VdbeChangeP1(v, addr+3, j+2);
  924.           sqlite3VdbeChangeP2(v, addr+3, addr+2);
  925.           sqlite3VdbeJumpHere(v, addr+4);
  926.           sqlite3VdbeChangeP4(v, addr+6, 
  927.                      "wrong # of entries in index ", P4_STATIC);
  928.           sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_STATIC);
  929.         }
  930.       } 
  931.     }
  932.     addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
  933.     sqlite3VdbeChangeP2(v, addr, -mxErr);
  934.     sqlite3VdbeJumpHere(v, addr+1);
  935.     sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
  936.   }else
  937. #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
  938. #ifndef SQLITE_OMIT_UTF16
  939.   /*
  940.   **   PRAGMA encoding
  941.   **   PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
  942.   **
  943.   ** In its first form, this pragma returns the encoding of the main
  944.   ** database. If the database is not initialized, it is initialized now.
  945.   **
  946.   ** The second form of this pragma is a no-op if the main database file
  947.   ** has not already been initialized. In this case it sets the default
  948.   ** encoding that will be used for the main database file if a new file
  949.   ** is created. If an existing main database file is opened, then the
  950.   ** default text encoding for the existing database is used.
  951.   ** 
  952.   ** In all cases new databases created using the ATTACH command are
  953.   ** created to use the same default text encoding as the main database. If
  954.   ** the main database has not been initialized and/or created when ATTACH
  955.   ** is executed, this is done before the ATTACH operation.
  956.   **
  957.   ** In the second form this pragma sets the text encoding to be used in
  958.   ** new database files created using this database handle. It is only
  959.   ** useful if invoked immediately after the main database i
  960.   */
  961.   if( sqlite3StrICmp(zLeft, "encoding")==0 ){
  962.     static const struct EncName {
  963.       char *zName;
  964.       u8 enc;
  965.     } encnames[] = {
  966.       { "UTF-8",    SQLITE_UTF8        },
  967.       { "UTF8",     SQLITE_UTF8        },
  968.       { "UTF-16le", SQLITE_UTF16LE     },
  969.       { "UTF16le",  SQLITE_UTF16LE     },
  970.       { "UTF-16be", SQLITE_UTF16BE     },
  971.       { "UTF16be",  SQLITE_UTF16BE     },
  972.       { "UTF-16",   0                  }, /* SQLITE_UTF16NATIVE */
  973.       { "UTF16",    0                  }, /* SQLITE_UTF16NATIVE */
  974.       { 0, 0 }
  975.     };
  976.     const struct EncName *pEnc;
  977.     if( !zRight ){    /* "PRAGMA encoding" */
  978.       if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  979.       sqlite3VdbeSetNumCols(v, 1);
  980.       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P4_STATIC);
  981.       sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
  982.       for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
  983.         if( pEnc->enc==ENC(pParse->db) ){
  984.           sqlite3VdbeChangeP4(v, -1, pEnc->zName, P4_STATIC);
  985.           break;
  986.         }
  987.       }
  988.       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
  989.     }else{                        /* "PRAGMA encoding = XXX" */
  990.       /* Only change the value of sqlite.enc if the database handle is not
  991.       ** initialized. If the main database exists, the new sqlite.enc value
  992.       ** will be overwritten when the schema is next loaded. If it does not
  993.       ** already exists, it will be created to use the new encoding value.
  994.       */
  995.       if( 
  996.         !(DbHasProperty(db, 0, DB_SchemaLoaded)) || 
  997.         DbHasProperty(db, 0, DB_Empty) 
  998.       ){
  999.         for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
  1000.           if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
  1001.             ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
  1002.             break;
  1003.           }
  1004.         }
  1005.         if( !pEnc->zName ){
  1006.           sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
  1007.         }
  1008.       }
  1009.     }
  1010.   }else
  1011. #endif /* SQLITE_OMIT_UTF16 */
  1012. #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
  1013.   /*
  1014.   **   PRAGMA [database.]schema_version
  1015.   **   PRAGMA [database.]schema_version = <integer>
  1016.   **
  1017.   **   PRAGMA [database.]user_version
  1018.   **   PRAGMA [database.]user_version = <integer>
  1019.   **
  1020.   ** The pragma's schema_version and user_version are used to set or get
  1021.   ** the value of the schema-version and user-version, respectively. Both
  1022.   ** the schema-version and the user-version are 32-bit signed integers
  1023.   ** stored in the database header.
  1024.   **
  1025.   ** The schema-cookie is usually only manipulated internally by SQLite. It
  1026.   ** is incremented by SQLite whenever the database schema is modified (by
  1027.   ** creating or dropping a table or index). The schema version is used by
  1028.   ** SQLite each time a query is executed to ensure that the internal cache
  1029.   ** of the schema used when compiling the SQL query matches the schema of
  1030.   ** the database against which the compiled query is actually executed.
  1031.   ** Subverting this mechanism by using "PRAGMA schema_version" to modify
  1032.   ** the schema-version is potentially dangerous and may lead to program
  1033.   ** crashes or database corruption. Use with caution!
  1034.   **
  1035.   ** The user-version is not used internally by SQLite. It may be used by
  1036.   ** applications for any purpose.
  1037.   */
  1038.   if( sqlite3StrICmp(zLeft, "schema_version")==0 
  1039.    || sqlite3StrICmp(zLeft, "user_version")==0 
  1040.    || sqlite3StrICmp(zLeft, "freelist_count")==0 
  1041.   ){
  1042.     int iCookie;   /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */
  1043.     sqlite3VdbeUsesBtree(v, iDb);
  1044.     switch( zLeft[0] ){
  1045.       case 's': case 'S':
  1046.         iCookie = 0;
  1047.         break;
  1048.       case 'f': case 'F':
  1049.         iCookie = 1;
  1050.         iDb = (-1*(iDb+1));
  1051.         assert(iDb<=0);
  1052.         break;
  1053.       default:
  1054.         iCookie = 5;
  1055.         break;
  1056.     }
  1057.     if( zRight && iDb>=0 ){
  1058.       /* Write the specified cookie value */
  1059.       static const VdbeOpList setCookie[] = {
  1060.         { OP_Transaction,    0,  1,  0},    /* 0 */
  1061.         { OP_Integer,        0,  1,  0},    /* 1 */
  1062.         { OP_SetCookie,      0,  0,  1},    /* 2 */
  1063.       };
  1064.       int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
  1065.       sqlite3VdbeChangeP1(v, addr, iDb);
  1066.       sqlite3VdbeChangeP1(v, addr+1, atoi(zRight));
  1067.       sqlite3VdbeChangeP1(v, addr+2, iDb);
  1068.       sqlite3VdbeChangeP2(v, addr+2, iCookie);
  1069.     }else{
  1070.       /* Read the specified cookie value */
  1071.       static const VdbeOpList readCookie[] = {
  1072.         { OP_ReadCookie,      0,  1,  0},    /* 0 */
  1073.         { OP_ResultRow,       1,  1,  0}
  1074.       };
  1075.       int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
  1076.       sqlite3VdbeChangeP1(v, addr, iDb);
  1077.       sqlite3VdbeChangeP3(v, addr, iCookie);
  1078.       sqlite3VdbeSetNumCols(v, 1);
  1079.       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, P4_TRANSIENT);
  1080.     }
  1081.   }else
  1082. #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
  1083. #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
  1084.   /*
  1085.   ** Report the current state of file logs for all databases
  1086.   */
  1087.   if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
  1088.     static const char *const azLockName[] = {
  1089.       "unlocked", "shared", "reserved", "pending", "exclusive"
  1090.     };
  1091.     int i;
  1092.     Vdbe *v = sqlite3GetVdbe(pParse);
  1093.     sqlite3VdbeSetNumCols(v, 2);
  1094.     pParse->nMem = 2;
  1095.     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P4_STATIC);
  1096.     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P4_STATIC);
  1097.     for(i=0; i<db->nDb; i++){
  1098.       Btree *pBt;
  1099.       Pager *pPager;
  1100.       const char *zState = "unknown";
  1101.       int j;
  1102.       if( db->aDb[i].zName==0 ) continue;
  1103.       sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
  1104.       pBt = db->aDb[i].pBt;
  1105.       if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
  1106.         zState = "closed";
  1107.       }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0, 
  1108.                                      SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
  1109.          zState = azLockName[j];
  1110.       }
  1111.       sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
  1112.       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
  1113.     }
  1114.   }else
  1115. #endif
  1116. #ifdef SQLITE_SSE
  1117.   /*
  1118.   ** Check to see if the sqlite_statements table exists.  Create it
  1119.   ** if it does not.
  1120.   */
  1121.   if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){
  1122.     extern int sqlite3CreateStatementsTable(Parse*);
  1123.     sqlite3CreateStatementsTable(pParse);
  1124.   }else
  1125. #endif
  1126. #if SQLITE_HAS_CODEC
  1127.   if( sqlite3StrICmp(zLeft, "key")==0 ){
  1128.     sqlite3_key(db, zRight, strlen(zRight));
  1129.   }else
  1130. #endif
  1131. #if SQLITE_HAS_CODEC || defined(SQLITE_ENABLE_CEROD)
  1132.   if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){
  1133. #if SQLITE_HAS_CODEC
  1134.     if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
  1135.       extern void sqlite3_activate_see(const char*);
  1136.       sqlite3_activate_see(&zRight[4]);
  1137.     }
  1138. #endif
  1139. #ifdef SQLITE_ENABLE_CEROD
  1140.     if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
  1141.       extern void sqlite3_activate_cerod(const char*);
  1142.       sqlite3_activate_cerod(&zRight[6]);
  1143.     }
  1144. #endif
  1145.   }
  1146. #endif
  1147.   {}
  1148.   if( v ){
  1149.     /* Code an OP_Expire at the end of each PRAGMA program to cause
  1150.     ** the VDBE implementing the pragma to expire. Most (all?) pragmas
  1151.     ** are only valid for a single execution.
  1152.     */
  1153.     sqlite3VdbeAddOp2(v, OP_Expire, 1, 0);
  1154.     /*
  1155.     ** Reset the safety level, in case the fullfsync flag or synchronous
  1156.     ** setting changed.
  1157.     */
  1158. #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  1159.     if( db->autoCommit ){
  1160.       sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
  1161.                  (db->flags&SQLITE_FullFSync)!=0);
  1162.     }
  1163. #endif
  1164.   }
  1165. pragma_out:
  1166.   sqlite3_free(zLeft);
  1167.   sqlite3_free(zRight);
  1168. }
  1169. #endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */