/*

 ** 2003 April 6

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** This file contains code used to implement the PRAGMA command.

 **

 ** $Id$

 */

 #include "sqliteInt.h"

 #include <ctype.h>

 /* Ignore this whole file if pragmas are disabled

 */

 #if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER)

 /*

 ** Interpret the given string as a safety level.  Return 0 for OFF,

 ** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or 

 ** unrecognized string argument.

 **

 ** Note that the values returned are one less that the values that

 ** should be passed into sqlite3BtreeSetSafetyLevel().  The is done

 ** to support legacy SQL code.  The safety level used to be boolean

 ** and older scripts may have used numbers 0 for OFF and 1 for ON.

 */

 static int getSafetyLevel(const char *z){

                              /* 123456789 123456789 */

   static const char zText[] = "onoffalseyestruefull";

   static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};

   static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};

   static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};

   int i, n;

   if( isdigit(*z) ){

     return atoi(z);

   }

   n = strlen(z);

   for(i=0; i<sizeof(iLength); i++){

     if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){

       return iValue[i];

     }

   }

   return 1;

 }

 /*

 ** Interpret the given string as a boolean value.

 */

 static int getBoolean(const char *z){

   return getSafetyLevel(z)&1;

 }

 /*

 ** Interpret the given string as a locking mode value.

 */

 static int getLockingMode(const char *z){

   if( z ){

     if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;

     if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;

   }

   return PAGER_LOCKINGMODE_QUERY;

 }

 #ifndef SQLITE_OMIT_AUTOVACUUM

 /*

 ** Interpret the given string as an auto-vacuum mode value.

 **

 ** The following strings, "none", "full" and "incremental" are 

 ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.

 */

 static int getAutoVacuum(const char *z){

   int i;

   if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;

   if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;

   if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;

   i = atoi(z);

   return ((i>=0&&i<=2)?i:0);

 }

 #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */

 #ifndef SQLITE_OMIT_PAGER_PRAGMAS

 /*

 ** Interpret the given string as a temp db location. Return 1 for file

 ** backed temporary databases, 2 for the Red-Black tree in memory database

 ** and 0 to use the compile-time default.

 */

 static int getTempStore(const char *z){

   if( z[0]>='0' && z[0]<='2' ){

     return z[0] - '0';

   }else if( sqlite3StrICmp(z, "file")==0 ){

     return 1;

   }else if( sqlite3StrICmp(z, "memory")==0 ){

     return 2;

   }else{

     return 0;

   }

 }

 #endif /* SQLITE_PAGER_PRAGMAS */

 #ifndef SQLITE_OMIT_PAGER_PRAGMAS

 /*

 ** Invalidate temp storage, either when the temp storage is changed

 ** from default, or when 'file' and the temp_store_directory has changed

 */

 static int invalidateTempStorage(Parse *pParse){

   sqlite3 *db = pParse->db;

   if( db->aDb[1].pBt!=0 ){

     if( !db->autoCommit ){

       sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "

         "from within a transaction");

       return SQLITE_ERROR;

     }

     sqlite3BtreeClose(db->aDb[1].pBt);

     db->aDb[1].pBt = 0;

     sqlite3ResetInternalSchema(db, 0);

   }

   return SQLITE_OK;

 }

 #endif /* SQLITE_PAGER_PRAGMAS */

 #ifndef SQLITE_OMIT_PAGER_PRAGMAS

 /*

 ** If the TEMP database is open, close it and mark the database schema

 ** as needing reloading.  This must be done when using the TEMP_STORE

 ** or DEFAULT_TEMP_STORE pragmas.

 */

 static int changeTempStorage(Parse *pParse, const char *zStorageType){

   int ts = getTempStore(zStorageType);

   sqlite3 *db = pParse->db;

   if( db->temp_store==ts ) return SQLITE_OK;

   if( invalidateTempStorage( pParse ) != SQLITE_OK ){

     return SQLITE_ERROR;

   }

   db->temp_store = ts;

   return SQLITE_OK;

 }

 #endif /* SQLITE_PAGER_PRAGMAS */

 /*

 ** Generate code to return a single integer value.

 */

 static void returnSingleInt(Parse *pParse, const char *zLabel, int value){

   Vdbe *v = sqlite3GetVdbe(pParse);

   sqlite3VdbeAddOp(v, OP_Integer, value, 0);

   if( pParse->explain==0 ){

     sqlite3VdbeSetNumCols(v, 1);

     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P3_STATIC);

   }

   sqlite3VdbeAddOp(v, OP_Callback, 1, 0);

 }

 #ifndef SQLITE_OMIT_FLAG_PRAGMAS

 /*

 ** Check to see if zRight and zLeft refer to a pragma that queries

 ** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.

 ** Also, implement the pragma.

 */

 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){

   static const struct sPragmaType {

     const char *zName;  /* Name of the pragma */

     int mask;           /* Mask for the db->flags value */

   } aPragma[] = {

     { "full_column_names",        SQLITE_FullColNames  },

     { "short_column_names",       SQLITE_ShortColNames },

     { "count_changes",            SQLITE_CountRows     },

     { "empty_result_callbacks",   SQLITE_NullCallback  },

     { "legacy_file_format",       SQLITE_LegacyFileFmt },

     { "fullfsync",                SQLITE_FullFSync     },

 #ifdef SQLITE_DEBUG

     { "sql_trace",                SQLITE_SqlTrace      },

     { "vdbe_listing",             SQLITE_VdbeListing   },

     { "vdbe_trace",               SQLITE_VdbeTrace     },

 #endif

 #ifndef SQLITE_OMIT_CHECK

     { "ignore_check_constraints", SQLITE_IgnoreChecks  },

 #endif

     /* The following is VERY experimental */

     { "writable_schema",          SQLITE_WriteSchema|SQLITE_RecoveryMode },

     { "omit_readlock",            SQLITE_NoReadlock    },

     /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted

     ** flag if there are any active statements. */

     { "read_uncommitted",         SQLITE_ReadUncommitted },

   };

   int i;

   const struct sPragmaType *p;

   for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){

     if( sqlite3StrICmp(zLeft, p->zName)==0 ){

       sqlite3 *db = pParse->db;

       Vdbe *v;

       v = sqlite3GetVdbe(pParse);

       if( v ){

         if( zRight==0 ){

           returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );

         }else{

           if( getBoolean(zRight) ){

             db->flags |= p->mask;

           }else{

             db->flags &= ~p->mask;

           }

         }

       }

       return 1;

     }

   }

   return 0;

 }

 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */

 /*

 ** Process a pragma statement.  

 **

 ** Pragmas are of this form:

 **

 **      PRAGMA [database.]id [= value]

 **

 ** The identifier might also be a string.  The value is a string, and

 ** identifier, or a number.  If minusFlag is true, then the value is

 ** a number that was preceded by a minus sign.

 **

 ** If the left side is "database.id" then pId1 is the database name

 ** and pId2 is the id.  If the left side is just "id" then pId1 is the

 ** id and pId2 is any empty string.

 */

 void sqlite3Pragma(

   Parse *pParse, 

   Token *pId1,        /* First part of [database.]id field */

   Token *pId2,        /* Second part of [database.]id field, or NULL */

   Token *pValue,      /* Token for <value>, or NULL */

   int minusFlag       /* True if a '-' sign preceded <value> */

 ){

   char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */

   char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */

   const char *zDb = 0;   /* The database name */

   Token *pId;            /* Pointer to <id> token */

   int iDb;               /* Database index for <database> */

   sqlite3 *db = pParse->db;

   Db *pDb;

   Vdbe *v = sqlite3GetVdbe(pParse);

   if( v==0 ) return;

   /* Interpret the [database.] part of the pragma statement. iDb is the

   ** index of the database this pragma is being applied to in db.aDb[]. */

   iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);

   if( iDb<0 ) return;

   pDb = &db->aDb[iDb];

   /* If the temp database has been explicitly named as part of the 

   ** pragma, make sure it is open. 

   */

   if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){

     return;

   }

   zLeft = sqlite3NameFromToken(db, pId);

   if( !zLeft ) return;

   if( minusFlag ){

     zRight = sqlite3MPrintf(db, "-%T", pValue);

   }else{

     zRight = sqlite3NameFromToken(db, pValue);

   }

   zDb = ((iDb>0)?pDb->zName:0);

   if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){

     goto pragma_out;

   }

 #ifndef SQLITE_OMIT_PAGER_PRAGMAS

   /*

   **  PRAGMA [database.]default_cache_size

   **  PRAGMA [database.]default_cache_size=N

   **

   ** The first form reports the current persistent setting for the

   ** page cache size.  The value returned is the maximum number of

   ** pages in the page cache.  The second form sets both the current

   ** page cache size value and the persistent page cache size value

   ** stored in the database file.

   **

   ** The default cache size is stored in meta-value 2 of page 1 of the

   ** database file.  The cache size is actually the absolute value of

   ** this memory location.  The sign of meta-value 2 determines the

   ** synchronous setting.  A negative value means synchronous is off

   ** and a positive value means synchronous is on.

   */

   if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){

     static const VdbeOpList getCacheSize[] = {

       { OP_ReadCookie,  0, 2,        0},  /* 0 */

       { OP_AbsValue,    0, 0,        0},

       { OP_Dup,         0, 0,        0},

       { OP_Integer,     0, 0,        0},

       { OP_Ne,          0, 6,        0},

       { OP_Integer,     0, 0,        0},  /* 5 */

       { OP_Callback,    1, 0,        0},

     };

     int addr;

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     sqlite3VdbeUsesBtree(v, iDb);

     if( !zRight ){

       sqlite3VdbeSetNumCols(v, 1);

       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P3_STATIC);

       addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);

       sqlite3VdbeChangeP1(v, addr, iDb);

       sqlite3VdbeChangeP1(v, addr+5, SQLITE_DEFAULT_CACHE_SIZE);

     }else{

       int size = atoi(zRight);

       if( size<0 ) size = -size;

       sqlite3BeginWriteOperation(pParse, 0, iDb);

       sqlite3VdbeAddOp(v, OP_Integer, size, 0);

       sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2);

       addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0);

       sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3);

       sqlite3VdbeAddOp(v, OP_Negative, 0, 0);

       sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2);

       pDb->pSchema->cache_size = size;

       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);

     }

   }else

   /*

   **  PRAGMA [database.]page_size

   **  PRAGMA [database.]page_size=N

   **

   ** The first form reports the current setting for the

   ** database page size in bytes.  The second form sets the

   ** database page size value.  The value can only be set if

   ** the database has not yet been created.

   */

   if( sqlite3StrICmp(zLeft,"page_size")==0 ){

     Btree *pBt = pDb->pBt;

     if( !zRight ){

       int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;

       returnSingleInt(pParse, "page_size", size);

     }else{

       /* Malloc may fail when setting the page-size, as there is an internal

       ** buffer that the pager module resizes using sqlite3_realloc().

       */

       if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1) ){

         db->mallocFailed = 1;

       }

     }

   }else

   /*

   **  PRAGMA [database.]max_page_count

   **  PRAGMA [database.]max_page_count=N

   **

   ** The first form reports the current setting for the

   ** maximum number of pages in the database file.  The 

   ** second form attempts to change this setting.  Both

   ** forms return the current setting.

   */

   if( sqlite3StrICmp(zLeft,"max_page_count")==0 ){

     Btree *pBt = pDb->pBt;

     int newMax = 0;

     if( zRight ){

       newMax = atoi(zRight);

     }

     if( pBt ){

       newMax = sqlite3BtreeMaxPageCount(pBt, newMax);

     }

     returnSingleInt(pParse, "max_page_count", newMax);

   }else

   /*

   **  PRAGMA [database.]locking_mode

   **  PRAGMA [database.]locking_mode = (normal|exclusive)

   */

   if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){

     const char *zRet = "normal";

     int eMode = getLockingMode(zRight);

     if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){

       /* Simple "PRAGMA locking_mode;" statement. This is a query for

       ** the current default locking mode (which may be different to

       ** the locking-mode of the main database).

       */

       eMode = db->dfltLockMode;

     }else{

       Pager *pPager;

       if( pId2->n==0 ){

         /* This indicates that no database name was specified as part

         ** of the PRAGMA command. In this case the locking-mode must be

         ** set on all attached databases, as well as the main db file.

         **

         ** Also, the sqlite3.dfltLockMode variable is set so that

         ** any subsequently attached databases also use the specified

         ** locking mode.

         */

         int ii;

         assert(pDb==&db->aDb[0]);

         for(ii=2; ii<db->nDb; ii++){

           pPager = sqlite3BtreePager(db->aDb[ii].pBt);

           sqlite3PagerLockingMode(pPager, eMode);

         }

         db->dfltLockMode = eMode;

       }

       pPager = sqlite3BtreePager(pDb->pBt);

       eMode = sqlite3PagerLockingMode(pPager, eMode);

     }

     assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);

     if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){

       zRet = "exclusive";

     }

     sqlite3VdbeSetNumCols(v, 1);

     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", P3_STATIC);

     sqlite3VdbeOp3(v, OP_String8, 0, 0, zRet, 0);

     sqlite3VdbeAddOp(v, OP_Callback, 1, 0);

   }else

 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */

   /*

   **  PRAGMA [database.]auto_vacuum

   **  PRAGMA [database.]auto_vacuum=N

   **

   ** Get or set the (boolean) value of the database 'auto-vacuum' parameter.

   */

 #ifndef SQLITE_OMIT_AUTOVACUUM

   if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){

     Btree *pBt = pDb->pBt;

     if( sqlite3ReadSchema(pParse) ){

       goto pragma_out;

     }

     if( !zRight ){

       int auto_vacuum = 

           pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;

       returnSingleInt(pParse, "auto_vacuum", auto_vacuum);

     }else{

       int eAuto = getAutoVacuum(zRight);

       if( eAuto>=0 ){

         /* Call SetAutoVacuum() to set initialize the internal auto and

         ** incr-vacuum flags. This is required in case this connection

         ** creates the database file. It is important that it is created

         ** as an auto-vacuum capable db.

         */

         int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);

         if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){

           /* When setting the auto_vacuum mode to either "full" or 

           ** "incremental", write the value of meta[6] in the database

           ** file. Before writing to meta[6], check that meta[3] indicates

           ** that this really is an auto-vacuum capable database.

           */

           static const VdbeOpList setMeta6[] = {

             { OP_Transaction,    0,               1,        0},    /* 0 */

             { OP_ReadCookie,     0,               3,        0},    /* 1 */

             { OP_If,             0,               0,        0},    /* 2 */

             { OP_Halt,           SQLITE_OK,       OE_Abort, 0},    /* 3 */

             { OP_Integer,        0,               0,        0},    /* 4 */

             { OP_SetCookie,      0,               6,        0},    /* 5 */

           };

           int iAddr;

           iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);

           sqlite3VdbeChangeP1(v, iAddr, iDb);

           sqlite3VdbeChangeP1(v, iAddr+1, iDb);

           sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);

           sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);

           sqlite3VdbeChangeP1(v, iAddr+5, iDb);

           sqlite3VdbeUsesBtree(v, iDb);

         }

       }

     }

   }else

 #endif

   /*

   **  PRAGMA [database.]incremental_vacuum(N)

   **

   ** Do N steps of incremental vacuuming on a database.

   */

 #ifndef SQLITE_OMIT_AUTOVACUUM

   if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){

     int iLimit, addr;

     if( sqlite3ReadSchema(pParse) ){

       goto pragma_out;

     }

     if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){

       iLimit = 0x7fffffff;

     }

     sqlite3BeginWriteOperation(pParse, 0, iDb);

     sqlite3VdbeAddOp(v, OP_MemInt, iLimit, 0);

     addr = sqlite3VdbeAddOp(v, OP_IncrVacuum, iDb, 0);

     sqlite3VdbeAddOp(v, OP_Callback, 0, 0);

     sqlite3VdbeAddOp(v, OP_MemIncr, -1, 0);

     sqlite3VdbeAddOp(v, OP_IfMemPos, 0, addr);

     sqlite3VdbeJumpHere(v, addr);

   }else

 #endif

 #ifndef SQLITE_OMIT_PAGER_PRAGMAS

   /*

   **  PRAGMA [database.]cache_size

   **  PRAGMA [database.]cache_size=N

   **

   ** The first form reports the current local setting for the

   ** page cache size.  The local setting can be different from

   ** the persistent cache size value that is stored in the database

   ** file itself.  The value returned is the maximum number of

   ** pages in the page cache.  The second form sets the local

   ** page cache size value.  It does not change the persistent

   ** cache size stored on the disk so the cache size will revert

   ** to its default value when the database is closed and reopened.

   ** N should be a positive integer.

   */

   if( sqlite3StrICmp(zLeft,"cache_size")==0 ){

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     if( !zRight ){

       returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);

     }else{

       int size = atoi(zRight);

       if( size<0 ) size = -size;

       pDb->pSchema->cache_size = size;

       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);

     }

   }else

   /*

   **   PRAGMA temp_store

   **   PRAGMA temp_store = "default"|"memory"|"file"

   **

   ** Return or set the local value of the temp_store flag.  Changing

   ** the local value does not make changes to the disk file and the default

   ** value will be restored the next time the database is opened.

   **

   ** Note that it is possible for the library compile-time options to

   ** override this setting

   */

   if( sqlite3StrICmp(zLeft, "temp_store")==0 ){

     if( !zRight ){

       returnSingleInt(pParse, "temp_store", db->temp_store);

     }else{

       changeTempStorage(pParse, zRight);

     }

   }else

   /*

   **   PRAGMA temp_store_directory

   **   PRAGMA temp_store_directory = ""|"directory_name"

   **

   ** Return or set the local value of the temp_store_directory flag.  Changing

   ** the value sets a specific directory to be used for temporary files.

   ** Setting to a null string reverts to the default temporary directory search.

   ** If temporary directory is changed, then invalidateTempStorage.

   **

   */

   if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){

     if( !zRight ){

       if( sqlite3_temp_directory ){

         sqlite3VdbeSetNumCols(v, 1);

         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, 

             "temp_store_directory", P3_STATIC);

         sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0);

         sqlite3VdbeAddOp(v, OP_Callback, 1, 0);

       }

     }else{

       if( zRight[0] 

        && !sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE) 

       ){

         sqlite3ErrorMsg(pParse, "not a writable directory");

         goto pragma_out;

       }

       if( TEMP_STORE==0

        || (TEMP_STORE==1 && db->temp_store<=1)

        || (TEMP_STORE==2 && db->temp_store==1)

       ){

         invalidateTempStorage(pParse);

       }

       sqlite3_free(sqlite3_temp_directory);

       if( zRight[0] ){

         sqlite3_temp_directory = zRight;

         zRight = 0;

       }else{

         sqlite3_temp_directory = 0;

       }

     }

   }else

   /*

   **   PRAGMA [database.]synchronous

   **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL

   **

   ** Return or set the local value of the synchronous flag.  Changing

   ** the local value does not make changes to the disk file and the

   ** default value will be restored the next time the database is

   ** opened.

   */

   if( sqlite3StrICmp(zLeft,"synchronous")==0 ){

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     if( !zRight ){

       returnSingleInt(pParse, "synchronous", pDb->safety_level-1);

     }else{

       if( !db->autoCommit ){

         sqlite3ErrorMsg(pParse, 

             "Safety level may not be changed inside a transaction");

       }else{

         pDb->safety_level = getSafetyLevel(zRight)+1;

       }

     }

   }else

 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */

 #ifndef SQLITE_OMIT_FLAG_PRAGMAS

   if( flagPragma(pParse, zLeft, zRight) ){

     /* The flagPragma() subroutine also generates any necessary code

     ** there is nothing more to do here */

   }else

 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */

 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS

   /*

   **   PRAGMA table_info(<table>)

   **

   ** Return a single row for each column of the named table. The columns of

   ** the returned data set are:

   **

   ** cid:        Column id (numbered from left to right, starting at 0)

   ** name:       Column name

   ** type:       Column declaration type.

   ** notnull:    True if 'NOT NULL' is part of column declaration

   ** dflt_value: The default value for the column, if any.

   */

   if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){

     Table *pTab;

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     pTab = sqlite3FindTable(db, zRight, zDb);

     if( pTab ){

       int i;

       int nHidden = 0;

       Column *pCol;

       sqlite3VdbeSetNumCols(v, 6);

       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P3_STATIC);

       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);

       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P3_STATIC);

       sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P3_STATIC);

       sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P3_STATIC);

       sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P3_STATIC);

       sqlite3ViewGetColumnNames(pParse, pTab);

       for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){

         const Token *pDflt;

         if( IsHiddenColumn(pCol) ){

           nHidden++;

           continue;

         }

         sqlite3VdbeAddOp(v, OP_Integer, i-nHidden, 0);

         sqlite3VdbeOp3(v, OP_String8, 0, 0, pCol->zName, 0);

         sqlite3VdbeOp3(v, OP_String8, 0, 0,

            pCol->zType ? pCol->zType : "", 0);

         sqlite3VdbeAddOp(v, OP_Integer, pCol->notNull, 0);

         if( pCol->pDflt && (pDflt = &pCol->pDflt->span)->z ){

           sqlite3VdbeOp3(v, OP_String8, 0, 0, (char*)pDflt->z, pDflt->n);

         }else{

           sqlite3VdbeAddOp(v, OP_Null, 0, 0);

         }

         sqlite3VdbeAddOp(v, OP_Integer, pCol->isPrimKey, 0);

         sqlite3VdbeAddOp(v, OP_Callback, 6, 0);

       }

     }

   }else

   if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){

     Index *pIdx;

     Table *pTab;

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     pIdx = sqlite3FindIndex(db, zRight, zDb);

     if( pIdx ){

       int i;

       pTab = pIdx->pTable;

       sqlite3VdbeSetNumCols(v, 3);

       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P3_STATIC);

       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P3_STATIC);

       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P3_STATIC);

       for(i=0; i<pIdx->nColumn; i++){

         int cnum = pIdx->aiColumn[i];

         sqlite3VdbeAddOp(v, OP_Integer, i, 0);

         sqlite3VdbeAddOp(v, OP_Integer, cnum, 0);

         assert( pTab->nCol>cnum );

         sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0);

         sqlite3VdbeAddOp(v, OP_Callback, 3, 0);

       }

     }

   }else

   if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){

     Index *pIdx;

     Table *pTab;

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     pTab = sqlite3FindTable(db, zRight, zDb);

     if( pTab ){

       v = sqlite3GetVdbe(pParse);

       pIdx = pTab->pIndex;

       if( pIdx ){

         int i = 0; 

         sqlite3VdbeSetNumCols(v, 3);

         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC);

         sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);

         sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P3_STATIC);

         while(pIdx){

           sqlite3VdbeAddOp(v, OP_Integer, i, 0);

           sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0);

           sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0);

           sqlite3VdbeAddOp(v, OP_Callback, 3, 0);

           ++i;

           pIdx = pIdx->pNext;

         }

       }

     }

   }else

   if( sqlite3StrICmp(zLeft, "database_list")==0 ){

     int i;

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     sqlite3VdbeSetNumCols(v, 3);

     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC);

     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);

     sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P3_STATIC);

     for(i=0; i<db->nDb; i++){

       if( db->aDb[i].pBt==0 ) continue;

       assert( db->aDb[i].zName!=0 );

       sqlite3VdbeAddOp(v, OP_Integer, i, 0);

       sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0);

       sqlite3VdbeOp3(v, OP_String8, 0, 0,

            sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);

       sqlite3VdbeAddOp(v, OP_Callback, 3, 0);

     }

   }else

   if( sqlite3StrICmp(zLeft, "collation_list")==0 ){

     int i = 0;

     HashElem *p;

     sqlite3VdbeSetNumCols(v, 2);

     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC);

     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);

     for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){

       CollSeq *pColl = (CollSeq *)sqliteHashData(p);

       sqlite3VdbeAddOp(v, OP_Integer, i++, 0);

       sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0);

       sqlite3VdbeAddOp(v, OP_Callback, 2, 0);

     }

   }else

 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */

 #ifndef SQLITE_OMIT_FOREIGN_KEY

   if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){

     FKey *pFK;

     Table *pTab;

     if( sqlite3ReadSchema(pParse) ) goto pragma_out;

     pTab = sqlite3FindTable(db, zRight, zDb);

     if( pTab ){

       v = sqlite3GetVdbe(pParse);

       pFK = pTab->pFKey;

       if( pFK ){

         int i = 0; 

         sqlite3VdbeSetNumCols(v, 5);

         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P3_STATIC);

         sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P3_STATIC);

         sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P3_STATIC);

         sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P3_STATIC);

         sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P3_STATIC);

         while(pFK){

           int j;

           for(j=0; j<pFK->nCol; j++){

             char *zCol = pFK->aCol[j].zCol;

             sqlite3VdbeAddOp(v, OP_Integer, i, 0);

             sqlite3VdbeAddOp(v, OP_Integer, j, 0);

             sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0);

             sqlite3VdbeOp3(v, OP_String8, 0, 0,

                              pTab->aCol[pFK->aCol[j].iFrom].zName, 0);

             sqlite3VdbeOp3(v, zCol ? OP_String8 : OP_Null, 0, 0, zCol, 0);

             sqlite3VdbeAddOp(v, OP_Callback, 5, 0);

           }

           ++i;

           pFK = pFK->pNextFrom;

         }

       }

     }

   }else

 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */

 #ifndef NDEBUG

   if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){

     if( zRight ){

       if( getBoolean(zRight) ){

         sqlite3ParserTrace(stderr, "parser: ");

       }else{

         sqlite3ParserTrace(0, 0);

       }

     }

   }else

 #endif

   /* Reinstall the LIKE and GLOB functions.  The variant of LIKE

   ** used will be case sensitive or not depending on the RHS.

   */

   if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){

     if( zRight ){