/*

** 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.

*/

#include "sqliteInt.h"

#if !defined(SQLITE_ENABLE_LOCKING_STYLE)

# if defined(__APPLE__)

# define SQLITE_ENABLE_LOCKING_STYLE 1

# else

# define SQLITE_ENABLE_LOCKING_STYLE 0

# endif

#endif

/***************************************************************************

** The next block of code, including the PragTyp_XXXX macro definitions and

** the aPragmaName[] object is composed of generated code. DO NOT EDIT.

**

** To add new pragmas, edit the code in ../tool/mkpragmatab.tcl and rerun

** that script. Then copy/paste the output in place of the following:

*/

#define PragTyp_HEADER_VALUE 0

#define PragTyp_AUTO_VACUUM 1

#define PragTyp_FLAG 2

#define PragTyp_BUSY_TIMEOUT 3

#define PragTyp_CACHE_SIZE 4

#define PragTyp_CASE_SENSITIVE_LIKE 5

#define PragTyp_COLLATION_LIST 6

#define PragTyp_COMPILE_OPTIONS 7

#define PragTyp_DATA_STORE_DIRECTORY 8

#define PragTyp_DATABASE_LIST 9

#define PragTyp_DEFAULT_CACHE_SIZE 10

#define PragTyp_ENCODING 11

#define PragTyp_FOREIGN_KEY_CHECK 12

#define PragTyp_FOREIGN_KEY_LIST 13

#define PragTyp_INCREMENTAL_VACUUM 14

#define PragTyp_INDEX_INFO 15

#define PragTyp_INDEX_LIST 16

#define PragTyp_INTEGRITY_CHECK 17

#define PragTyp_JOURNAL_MODE 18

#define PragTyp_JOURNAL_SIZE_LIMIT 19

#define PragTyp_LOCK_PROXY_FILE 20

#define PragTyp_LOCKING_MODE 21

#define PragTyp_PAGE_COUNT 22

#define PragTyp_MMAP_SIZE 23

#define PragTyp_PAGE_SIZE 24

#define PragTyp_SECURE_DELETE 25

#define PragTyp_SHRINK_MEMORY 26

#define PragTyp_SOFT_HEAP_LIMIT 27

#define PragTyp_STATS 28

#define PragTyp_SYNCHRONOUS 29

#define PragTyp_TABLE_INFO 30

#define PragTyp_TEMP_STORE 31

#define PragTyp_TEMP_STORE_DIRECTORY 32

#define PragTyp_WAL_AUTOCHECKPOINT 33

#define PragTyp_WAL_CHECKPOINT 34

#define PragTyp_ACTIVATE_EXTENSIONS 35

#define PragTyp_HEXKEY 36

#define PragTyp_KEY 37

#define PragTyp_REKEY 38

#define PragTyp_LOCK_STATUS 39

#define PragTyp_PARSER_TRACE 40

#define PragFlag_NeedSchema 0x01

static const struct sPragmaNames {

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

u8 ePragTyp; /* PragTyp_XXX value */

u8 mPragFlag; /* Zero or more PragFlag_XXX values */

u32 iArg; /* Extra argument */

} aPragmaNames[] = {

#if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)

{ /* zName: */ "activate_extensions",

/* ePragTyp: */ PragTyp_ACTIVATE_EXTENSIONS,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

{ /* zName: */ "application_id",

/* ePragTyp: */ PragTyp_HEADER_VALUE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_AUTOVACUUM)

{ /* zName: */ "auto_vacuum",

/* ePragTyp: */ PragTyp_AUTO_VACUUM,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

#if !defined(SQLITE_OMIT_AUTOMATIC_INDEX)

{ /* zName: */ "automatic_index",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_AutoIndex },

#endif

#endif

{ /* zName: */ "busy_timeout",

/* ePragTyp: */ PragTyp_BUSY_TIMEOUT,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

{ /* zName: */ "cache_size",

/* ePragTyp: */ PragTyp_CACHE_SIZE,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "cache_spill",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_CacheSpill },

#endif

{ /* zName: */ "case_sensitive_like",

/* ePragTyp: */ PragTyp_CASE_SENSITIVE_LIKE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "checkpoint_fullfsync",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_CkptFullFSync },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

{ /* zName: */ "collation_list",

/* ePragTyp: */ PragTyp_COLLATION_LIST,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)

{ /* zName: */ "compile_options",

/* ePragTyp: */ PragTyp_COMPILE_OPTIONS,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "count_changes",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_CountRows },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN

{ /* zName: */ "data_store_directory",

/* ePragTyp: */ PragTyp_DATA_STORE_DIRECTORY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

{ /* zName: */ "database_list",

/* ePragTyp: */ PragTyp_DATABASE_LIST,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)

{ /* zName: */ "default_cache_size",

/* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)

{ /* zName: */ "defer_foreign_keys",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_DeferFKs },

#endif

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "empty_result_callbacks",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_NullCallback },

#endif

#if !defined(SQLITE_OMIT_UTF16)

{ /* zName: */ "encoding",

/* ePragTyp: */ PragTyp_ENCODING,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)

{ /* zName: */ "foreign_key_check",

/* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FOREIGN_KEY)

{ /* zName: */ "foreign_key_list",

/* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)

{ /* zName: */ "foreign_keys",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_ForeignKeys },

#endif

#endif

#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

{ /* zName: */ "freelist_count",

/* ePragTyp: */ PragTyp_HEADER_VALUE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "full_column_names",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_FullColNames },

{ /* zName: */ "fullfsync",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_FullFSync },

#endif

#if defined(SQLITE_HAS_CODEC)

{ /* zName: */ "hexkey",

/* ePragTyp: */ PragTyp_HEXKEY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

{ /* zName: */ "hexrekey",

/* ePragTyp: */ PragTyp_HEXKEY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

#if !defined(SQLITE_OMIT_CHECK)

{ /* zName: */ "ignore_check_constraints",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_IgnoreChecks },

#endif

#endif

#if !defined(SQLITE_OMIT_AUTOVACUUM)

{ /* zName: */ "incremental_vacuum",

/* ePragTyp: */ PragTyp_INCREMENTAL_VACUUM,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

{ /* zName: */ "index_info",

/* ePragTyp: */ PragTyp_INDEX_INFO,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

{ /* zName: */ "index_list",

/* ePragTyp: */ PragTyp_INDEX_LIST,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)

{ /* zName: */ "integrity_check",

/* ePragTyp: */ PragTyp_INTEGRITY_CHECK,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

{ /* zName: */ "journal_mode",

/* ePragTyp: */ PragTyp_JOURNAL_MODE,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

{ /* zName: */ "journal_size_limit",

/* ePragTyp: */ PragTyp_JOURNAL_SIZE_LIMIT,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if defined(SQLITE_HAS_CODEC)

{ /* zName: */ "key",

/* ePragTyp: */ PragTyp_KEY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "legacy_file_format",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_LegacyFileFmt },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE

{ /* zName: */ "lock_proxy_file",

/* ePragTyp: */ PragTyp_LOCK_PROXY_FILE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)

{ /* zName: */ "lock_status",

/* ePragTyp: */ PragTyp_LOCK_STATUS,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

{ /* zName: */ "locking_mode",

/* ePragTyp: */ PragTyp_LOCKING_MODE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

{ /* zName: */ "max_page_count",

/* ePragTyp: */ PragTyp_PAGE_COUNT,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

{ /* zName: */ "mmap_size",

/* ePragTyp: */ PragTyp_MMAP_SIZE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

{ /* zName: */ "page_count",

/* ePragTyp: */ PragTyp_PAGE_COUNT,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

{ /* zName: */ "page_size",

/* ePragTyp: */ PragTyp_PAGE_SIZE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if defined(SQLITE_DEBUG)

{ /* zName: */ "parser_trace",

/* ePragTyp: */ PragTyp_PARSER_TRACE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "query_only",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_QueryOnly },

#endif

#if !defined(SQLITE_OMIT_INTEGRITY_CHECK)

{ /* zName: */ "quick_check",

/* ePragTyp: */ PragTyp_INTEGRITY_CHECK,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "read_uncommitted",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_ReadUncommitted },

{ /* zName: */ "recursive_triggers",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_RecTriggers },

#endif

#if defined(SQLITE_HAS_CODEC)

{ /* zName: */ "rekey",

/* ePragTyp: */ PragTyp_REKEY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "reverse_unordered_selects",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_ReverseOrder },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

{ /* zName: */ "schema_version",

/* ePragTyp: */ PragTyp_HEADER_VALUE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

{ /* zName: */ "secure_delete",

/* ePragTyp: */ PragTyp_SECURE_DELETE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "short_column_names",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_ShortColNames },

#endif

{ /* zName: */ "shrink_memory",

/* ePragTyp: */ PragTyp_SHRINK_MEMORY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

{ /* zName: */ "soft_heap_limit",

/* ePragTyp: */ PragTyp_SOFT_HEAP_LIMIT,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

#if defined(SQLITE_DEBUG)

{ /* zName: */ "sql_trace",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_SqlTrace },

#endif

#endif

#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

{ /* zName: */ "stats",

/* ePragTyp: */ PragTyp_STATS,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

{ /* zName: */ "synchronous",

/* ePragTyp: */ PragTyp_SYNCHRONOUS,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

{ /* zName: */ "table_info",

/* ePragTyp: */ PragTyp_TABLE_INFO,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

{ /* zName: */ "temp_store",

/* ePragTyp: */ PragTyp_TEMP_STORE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

{ /* zName: */ "temp_store_directory",

/* ePragTyp: */ PragTyp_TEMP_STORE_DIRECTORY,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

{ /* zName: */ "user_version",

/* ePragTyp: */ PragTyp_HEADER_VALUE,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

#if defined(SQLITE_DEBUG)

{ /* zName: */ "vdbe_addoptrace",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_VdbeAddopTrace },

{ /* zName: */ "vdbe_debug",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace },

{ /* zName: */ "vdbe_eqp",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_VdbeEQP },

{ /* zName: */ "vdbe_listing",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_VdbeListing },

{ /* zName: */ "vdbe_trace",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_VdbeTrace },

#endif

#endif

#if !defined(SQLITE_OMIT_WAL)

{ /* zName: */ "wal_autocheckpoint",

/* ePragTyp: */ PragTyp_WAL_AUTOCHECKPOINT,

/* ePragFlag: */ 0,

/* iArg: */ 0 },

{ /* zName: */ "wal_checkpoint",

/* ePragTyp: */ PragTyp_WAL_CHECKPOINT,

/* ePragFlag: */ PragFlag_NeedSchema,

/* iArg: */ 0 },

#endif

#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)

{ /* zName: */ "writable_schema",

/* ePragTyp: */ PragTyp_FLAG,

/* ePragFlag: */ 0,

/* iArg: */ SQLITE_WriteSchema|SQLITE_RecoveryMode },

#endif

};

/* Number of pragmas: 56 on by default, 69 total. */

/* End of the automatically generated pragma table.

***************************************************************************/

/*

** 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. The FULL option is disallowed

** if the omitFull parameter it 1.

**

** 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 u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){

/* 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( sqlite3Isdigit(*z) ){

return (u8)sqlite3Atoi(z);

}

n = sqlite3Strlen30(z);

for(i=0; i<ArraySize(iLength)-omitFull; i++){

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

return iValue[i];

}

}

return dflt;

}

/*

** Interpret the given string as a boolean value.

*/

u8 sqlite3GetBoolean(const char *z, u8 dflt){

return getSafetyLevel(z,1,dflt)!=0;

}

/* The sqlite3GetBoolean() function is used by other modules but the

** remainder of this file is specific to PRAGMA processing. So omit

** the rest of the file if PRAGMAs are omitted from the build.

*/

#if !defined(SQLITE_OMIT_PRAGMA)

/*

** 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 = sqlite3Atoi(z);

return (u8)((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 || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){

sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "

"from within a transaction");

return SQLITE_ERROR;

}

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

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

sqlite3ResetAllSchemasOfConnection(db);

}

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 SQLITE_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 = (u8)ts;

return SQLITE_OK;

}

#endif /* SQLITE_PAGER_PRAGMAS */

/*

** Generate code to return a single integer value.

*/

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

Vdbe *v = sqlite3GetVdbe(pParse);

int mem = ++pParse->nMem;

i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));

if( pI64 ){

memcpy(pI64, &value, sizeof(value));

}

sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);

sqlite3VdbeSetNumCols(v, 1);

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

sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);

}

/*

** Set the safety_level and pager flags for pager iDb. Or if iDb<0

** set these values for all pagers.

*/

#ifndef SQLITE_OMIT_PAGER_PRAGMAS

static void setAllPagerFlags(sqlite3 *db){

if( db->autoCommit ){

Db *pDb = db->aDb;

int n = db->nDb;

assert( SQLITE_FullFSync==PAGER_FULLFSYNC );

assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC );

assert( SQLITE_CacheSpill==PAGER_CACHESPILL );

assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL)

== PAGER_FLAGS_MASK );

assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );

while( (n--) > 0 ){

if( pDb->pBt ){

sqlite3BtreeSetPagerFlags(pDb->pBt,

pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );

}

pDb++;

}

}

}

#else

# define setAllPagerFlags(X) /* no-op */

#endif

/*

** Return a human-readable name for a constraint resolution action.

*/

#ifndef SQLITE_OMIT_FOREIGN_KEY

static const char *actionName(u8 action){

const char *zName;

switch( action ){

case OE_SetNull: zName = "SET NULL"; break;

case OE_SetDflt: zName = "SET DEFAULT"; break;

case OE_Cascade: zName = "CASCADE"; break;

case OE_Restrict: zName = "RESTRICT"; break;

default: zName = "NO ACTION";

assert( action==OE_None ); break;

}

return zName;

}

#endif

/*

** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants

** defined in pager.h. This function returns the associated lowercase

** journal-mode name.

*/

const char *sqlite3JournalModename(int eMode){

static char * const azModeName[] = {

"delete", "persist", "off", "truncate", "memory"

#ifndef SQLITE_OMIT_WAL

, "wal"

#endif

};

assert( PAGER_JOURNALMODE_DELETE==0 );

assert( PAGER_JOURNALMODE_PERSIST==1 );

assert( PAGER_JOURNALMODE_OFF==2 );

assert( PAGER_JOURNALMODE_TRUNCATE==3 );

assert( PAGER_JOURNALMODE_MEMORY==4 );

assert( PAGER_JOURNALMODE_WAL==5 );

assert( eMode>=0 && eMode<=ArraySize(azModeName) );

if( eMode==ArraySize(azModeName) ) return 0;

return azModeName[eMode];

}

/*

** 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 */

char *aFcntl[4]; /* Argument to SQLITE_FCNTL_PRAGMA */

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

int lwr, upr, mid; /* Binary search bounds */

int rc; /* return value form SQLITE_FCNTL_PRAGMA */

sqlite3 *db = pParse->db; /* The database connection */

Db *pDb; /* The specific database being pragmaed */

Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

extern int sqlcipher_codec_pragma(sqlite3*, int, Parse *, const char *, const char *);

#endif

/* END SQLCIPHER */

if( v==0 ) return;

sqlite3VdbeRunOnlyOnce(v);

pParse->nMem = 2;

/* 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);

}

assert( pId2 );

zDb = pId2->n>0 ? pDb->zName : 0;

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

goto pragma_out;

}

/* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS

** connection. If it returns SQLITE_OK, then assume that the VFS

** handled the pragma and generate a no-op prepared statement.

*/

aFcntl[0] = 0;

aFcntl[1] = zLeft;

aFcntl[2] = zRight;

aFcntl[3] = 0;

db->busyHandler.nBusy = 0;

rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);

if( rc==SQLITE_OK ){

if( aFcntl[0] ){

int mem = ++pParse->nMem;

sqlite3VdbeAddOp4(v, OP_String8, 0, mem, 0, aFcntl[0], 0);

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "result", SQLITE_STATIC);

sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);

sqlite3_free(aFcntl[0]);

}

goto pragma_out;

}

if( rc!=SQLITE_NOTFOUND ){

if( aFcntl[0] ){

sqlite3ErrorMsg(pParse, "%s", aFcntl[0]);

sqlite3_free(aFcntl[0]);

}

pParse->nErr++;

pParse->rc = rc;

goto pragma_out;

}

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

if(sqlcipher_codec_pragma(db, iDb, pParse, zLeft, zRight)) {

/* sqlcipher_codec_pragma executes internal */

goto pragma_out;

}

#endif

/* END SQLCIPHER */

/* Locate the pragma in the lookup table */

lwr = 0;

upr = ArraySize(aPragmaNames)-1;

while( lwr<=upr ){

mid = (lwr+upr)/2;

rc = sqlite3_stricmp(zLeft, aPragmaNames[mid].zName);

if( rc==0 ) break;

if( rc<0 ){

upr = mid - 1;

}else{

lwr = mid + 1;

}

}

if( lwr>upr ) goto pragma_out;

/* Make sure the database schema is loaded if the pragma requires that */

if( (aPragmaNames[mid].mPragFlag & PragFlag_NeedSchema)!=0 ){

if( sqlite3ReadSchema(pParse) ) goto pragma_out;

}

/* Jump to the appropriate pragma handler */

switch( aPragmaNames[mid].ePragTyp ){

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)

/*

** 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.

**

** Older versions of SQLite would set the default cache size to a

** negative number to indicate synchronous=OFF. These days, synchronous

** is always on by default regardless of the sign of the default cache

** size. But continue to take the absolute value of the default cache

** size of historical compatibility.

*/

case PragTyp_DEFAULT_CACHE_SIZE: {

static const int iLn = VDBE_OFFSET_LINENO(2);

static const VdbeOpList getCacheSize[] = {

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

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

{ OP_IfPos, 1, 8, 0},

{ OP_Integer, 0, 2, 0},

{ OP_Subtract, 1, 2, 1},

{ OP_IfPos, 1, 8, 0},

{ OP_Integer, 0, 1, 0}, /* 6 */

{ OP_Noop, 0, 0, 0},

{ OP_ResultRow, 1, 1, 0},

};

int addr;

sqlite3VdbeUsesBtree(v, iDb);

if( !zRight ){

sqlite3VdbeSetNumCols(v, 1);

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

pParse->nMem += 2;

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

sqlite3VdbeChangeP1(v, addr, iDb);

sqlite3VdbeChangeP1(v, addr+1, iDb);

sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);

}else{

int size = sqlite3AbsInt32(sqlite3Atoi(zRight));

sqlite3BeginWriteOperation(pParse, 0, iDb);

sqlite3VdbeAddOp2(v, OP_Integer, size, 1);

sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);

assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

pDb->pSchema->cache_size = size;

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

}

break;

}

#endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */

#if !defined(SQLITE_OMIT_PAGER_PRAGMAS)

/*

** 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.

*/

case PragTyp_PAGE_SIZE: {

Btree *pBt = pDb->pBt;

assert( pBt!=0 );

if( !zRight ){

int size = ALWAYS(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().

*/

db->nextPagesize = sqlite3Atoi(zRight);

if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){

db->mallocFailed = 1;

}

}

break;

}

/*

** PRAGMA [database.]secure_delete

** PRAGMA [database.]secure_delete=ON/OFF

**

** The first form reports the current setting for the

** secure_delete flag. The second form changes the secure_delete

** flag setting and reports thenew value.

*/

case PragTyp_SECURE_DELETE: {

Btree *pBt = pDb->pBt;

int b = -1;

assert( pBt!=0 );

if( zRight ){

b = sqlite3GetBoolean(zRight, 0);

}

if( pId2->n==0 && b>=0 ){

int ii;

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

sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);

}

}

b = sqlite3BtreeSecureDelete(pBt, b);

returnSingleInt(pParse, "secure_delete", b);

break;

}

/*

** 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.

**

** The absolute value of N is used. This is undocumented and might

** change. The only purpose is to provide an easy way to test

** the sqlite3AbsInt32() function.

**

** PRAGMA [database.]page_count

**

** Return the number of pages in the specified database.

*/

case PragTyp_PAGE_COUNT: {

int iReg;

sqlite3CodeVerifySchema(pParse, iDb);

iReg = ++pParse->nMem;

if( sqlite3Tolower(zLeft[0])=='p' ){

sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);

}else{

sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg,

sqlite3AbsInt32(sqlite3Atoi(zRight)));

}

sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);

break;

}

/*

** PRAGMA [database.]locking_mode

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

*/

case PragTyp_LOCKING_MODE: {

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 = (u8)eMode;

}

pPager = sqlite3BtreePager(pDb->pBt);

eMode = sqlite3PagerLockingMode(pPager, eMode);

}