/*

** 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 "pragma.h" include file is an automatically generated file that

** that includes the PragType_XXXX macro definitions and the aPragmaName[]

** object. This ensures that the aPragmaName[] table is arranged in

** lexicographical order to facility a binary search of the pragma name.

** Do not edit pragma.h directly. Edit and rerun the script in at

** ../tool/mkpragmatab.tcl. */

#include "pragma.h"

/*

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

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

** unrecognized string argument. The FULL and EXTRA 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 123 */

static const char zText[] = "onoffalseyestruextrafull";

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

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

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

/* on no off false yes true extra full */

int i, n;

if( sqlite3Isdigit(*z) ){

return (u8)sqlite3Atoi(z);

}

n = sqlite3Strlen30(z);

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

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

&& (!omitFull || iValue[i]<=1)

){

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

|| sqlite3BtreeTxnState(db->aDb[1].pBt)!=SQLITE_TXN_NONE

){

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

/*

** Set result column names for a pragma.

*/

static void setPragmaResultColumnNames(

Vdbe *v, /* The query under construction */

const PragmaName *pPragma /* The pragma */

){

u8 n = pPragma->nPragCName;

sqlite3VdbeSetNumCols(v, n==0 ? 1 : n);

if( n==0 ){

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);

}else{

int i, j;

for(i=0, j=pPragma->iPragCName; i<n; i++, j++){

sqlite3VdbeSetColName(v, i, COLNAME_NAME, pragCName[j], SQLITE_STATIC);

}

}

}

/*

** Generate code to return a single integer value.

*/

static void returnSingleInt(Vdbe *v, i64 value){

sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, 1, 0, (const u8*)&value, P4_INT64);

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

}

/*

** Generate code to return a single text value.

*/

static void returnSingleText(

Vdbe *v, /* Prepared statement under construction */

const char *zValue /* Value to be returned */

){

if( zValue ){

sqlite3VdbeLoadString(v, 1, (const char*)zValue);

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 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];

}

/*

** Locate a pragma in the aPragmaName[] array.

*/

static const PragmaName *pragmaLocate(const char *zName){

int upr, lwr, mid = 0, rc;

lwr = 0;

upr = ArraySize(aPragmaName)-1;

while( lwr<=upr ){

mid = (lwr+upr)/2;

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

if( rc==0 ) break;

if( rc<0 ){

upr = mid - 1;

}else{

lwr = mid + 1;

}

}

return lwr>upr ? 0 : &aPragmaName[mid];

}

/*

** Create zero or more entries in the output for the SQL functions

** defined by FuncDef p.

*/

static void pragmaFunclistLine(

Vdbe *v, /* The prepared statement being created */

FuncDef *p, /* A particular function definition */

int isBuiltin, /* True if this is a built-in function */

int showInternFuncs /* True if showing internal functions */

){

u32 mask =

SQLITE_DETERMINISTIC |

SQLITE_DIRECTONLY |

SQLITE_SUBTYPE |

SQLITE_INNOCUOUS |

SQLITE_FUNC_INTERNAL

;

if( showInternFuncs ) mask = 0xffffffff;

for(; p; p=p->pNext){

const char *zType;

static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" };

assert( SQLITE_FUNC_ENCMASK==0x3 );

assert( strcmp(azEnc[SQLITE_UTF8],"utf8")==0 );

assert( strcmp(azEnc[SQLITE_UTF16LE],"utf16le")==0 );

assert( strcmp(azEnc[SQLITE_UTF16BE],"utf16be")==0 );

if( p->xSFunc==0 ) continue;

if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0

&& showInternFuncs==0

){

continue;

}

if( p->xValue!=0 ){

zType = "w";

}else if( p->xFinalize!=0 ){

zType = "a";

}else{

zType = "s";

}

sqlite3VdbeMultiLoad(v, 1, "sissii",

p->zName, isBuiltin,

zType, azEnc[p->funcFlags&SQLITE_FUNC_ENCMASK],

p->nArg,

(p->funcFlags & mask) ^ SQLITE_INNOCUOUS

);

}

}

/*

** Helper subroutine for PRAGMA integrity_check:

**

** Generate code to output a single-column result row with a value of the

** string held in register 3. Decrement the result count in register 1

** and halt if the maximum number of result rows have been issued.

*/

static int integrityCheckResultRow(Vdbe *v){

int addr;

sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);

addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);

VdbeCoverage(v);

sqlite3VdbeAddOp0(v, OP_Halt);

return addr;

}

/*

** Process a pragma statement.

**

** Pragmas are of this form:

**

** PRAGMA [schema.]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 [schema.]id field */

Token *pId2, /* Second part of [schema.]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 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 */

const PragmaName *pPragma; /* The pragma */

/* 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 [schema.] 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->zDbSName : 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.

**

** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed,

** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file

** object corresponding to the database file to which the pragma

** statement refers.

**

** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA

** file control is an array of pointers to strings (char**) in which the

** second element of the array is the name of the pragma and the third

** element is the argument to the pragma or NULL if the pragma has no

** argument.

*/

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 ){

sqlite3VdbeSetNumCols(v, 1);

sqlite3VdbeSetColName(v, 0, COLNAME_NAME, aFcntl[0], SQLITE_TRANSIENT);

returnSingleText(v, aFcntl[0]);

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

pPragma = pragmaLocate(zLeft);

if( pPragma==0 ){

/* IMP: R-43042-22504 No error messages are generated if an

** unknown pragma is issued. */

goto pragma_out;

}

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

if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){

if( sqlite3ReadSchema(pParse) ) goto pragma_out;

}

/* Register the result column names for pragmas that return results */

if( (pPragma->mPragFlg & PragFlg_NoColumns)==0

&& ((pPragma->mPragFlg & PragFlg_NoColumns1)==0 || zRight==0)

){

setPragmaResultColumnNames(v, pPragma);

}

/* Jump to the appropriate pragma handler */

switch( pPragma->ePragTyp ){

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

/*

** PRAGMA [schema.]default_cache_size

** PRAGMA [schema.]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},

};

VdbeOp *aOp;

sqlite3VdbeUsesBtree(v, iDb);

if( !zRight ){

pParse->nMem += 2;

sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize));

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

if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;

aOp[0].p1 = iDb;

aOp[1].p1 = iDb;

aOp[6].p1 = SQLITE_DEFAULT_CACHE_SIZE;

}else{

int size = sqlite3AbsInt32(sqlite3Atoi(zRight));

sqlite3BeginWriteOperation(pParse, 0, iDb);

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

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 [schema.]page_size

** PRAGMA [schema.]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(v, 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,0,0) ){

sqlite3OomFault(db);

}

}

break;

}

/*

** PRAGMA [schema.]secure_delete

** PRAGMA [schema.]secure_delete=ON/OFF/FAST

**

** The first form reports the current setting for the

** secure_delete flag. The second form changes the secure_delete

** flag setting and reports the new value.

*/

case PragTyp_SECURE_DELETE: {

Btree *pBt = pDb->pBt;

int b = -1;

assert( pBt!=0 );

if( zRight ){

if( sqlite3_stricmp(zRight, "fast")==0 ){

b = 2;

}else{

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(v, b);

break;

}

/*

** PRAGMA [schema.]max_page_count

** PRAGMA [schema.]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 [schema.]page_count

**

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

*/

case PragTyp_PAGE_COUNT: {

int iReg;

i64 x = 0;

sqlite3CodeVerifySchema(pParse, iDb);

iReg = ++pParse->nMem;

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

sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);

}else{

if( zRight && sqlite3DecOrHexToI64(zRight,&x)==0 ){

if( x<0 ) x = 0;

else if( x>0xfffffffe ) x = 0xfffffffe;

}else{

x = 0;

}

sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);

}

sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);

break;

}

/*

** PRAGMA [schema.]locking_mode

** PRAGMA [schema.]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);

}

assert( eMode==PAGER_LOCKINGMODE_NORMAL

|| eMode==PAGER_LOCKINGMODE_EXCLUSIVE );

if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){

zRet = "exclusive";

}

returnSingleText(v, zRet);

break;

}

/*

** PRAGMA [schema.]journal_mode

** PRAGMA [schema.]journal_mode =

** (delete|persist|off|truncate|memory|wal|off)

*/

case PragTyp_JOURNAL_MODE: {

int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */

int ii; /* Loop counter */

if( zRight==0 ){

/* If there is no "=MODE" part of the pragma, do a query for the

** current mode */

eMode = PAGER_JOURNALMODE_QUERY;

}else{

const char *zMode;

int n = sqlite3Strlen30(zRight);

for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){

if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;

}

if( !zMode ){

/* If the "=MODE" part does not match any known journal mode,

** then do a query */

eMode = PAGER_JOURNALMODE_QUERY;

}

if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){

/* Do not allow journal-mode "OFF" in defensive since the database

** can become corrupted using ordinary SQL when the journal is off */

eMode = PAGER_JOURNALMODE_QUERY;

}

}

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

/* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */

iDb = 0;

pId2->n = 1;

}

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

if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){

sqlite3VdbeUsesBtree(v, ii);

sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);

}

}

sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);

break;

}

/*

** PRAGMA [schema.]journal_size_limit

** PRAGMA [schema.]journal_size_limit=N

**

** Get or set the size limit on rollback journal files.

*/

case PragTyp_JOURNAL_SIZE_LIMIT: {

Pager *pPager = sqlite3BtreePager(pDb->pBt);

i64 iLimit = -2;

if( zRight ){

sqlite3DecOrHexToI64(zRight, &iLimit);

if( iLimit<-1 ) iLimit = -1;

}

iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);

returnSingleInt(v, iLimit);

break;

}

#endif /* SQLITE_OMIT_PAGER_PRAGMAS */

/*

** PRAGMA [schema.]auto_vacuum

** PRAGMA [schema.]auto_vacuum=N

**

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

** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL

*/

#ifndef SQLITE_OMIT_AUTOVACUUM

case PragTyp_AUTO_VACUUM: {

Btree *pBt = pDb->pBt;

assert( pBt!=0 );

if( !zRight ){

returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt));

}else{

int eAuto = getAutoVacuum(zRight);

assert( eAuto>=0 && eAuto<=2 );

db->nextAutovac = (u8)eAuto;

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

*/

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 int iLn = VDBE_OFFSET_LINENO(2);

static const VdbeOpList setMeta6[] = {

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

{ OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE},

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

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

{ OP_SetCookie, 0, BTREE_INCR_VACUUM, 0}, /* 4 */

};

VdbeOp *aOp;

int iAddr = sqlite3VdbeCurrentAddr(v);

sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6));

aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);

if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;

aOp[0].p1 = iDb;

aOp[1].p1 = iDb;

aOp[2].p2 = iAddr+4;

aOp[4].p1 = iDb;

aOp[4].p3 = eAuto - 1;

sqlite3VdbeUsesBtree(v, iDb);

}

}

break;

}

#endif

/*

** PRAGMA [schema.]incremental_vacuum(N)

**

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

*/

#ifndef SQLITE_OMIT_AUTOVACUUM

case PragTyp_INCREMENTAL_VACUUM: {

int iLimit = 0, addr;

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

iLimit = 0x7fffffff;

}

sqlite3BeginWriteOperation(pParse, 0, iDb);

sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);

addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);

sqlite3VdbeAddOp1(v, OP_ResultRow, 1);

sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);

sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v);

sqlite3VdbeJumpHere(v, addr);

break;

}

#endif

#ifndef SQLITE_OMIT_PAGER_PRAGMAS

/*

** PRAGMA [schema.]cache_size

** PRAGMA [schema.]cache_size=N

**

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

** page cache size. The second form sets the local

** page cache size value. If N is positive then that is the

** number of pages in the cache. If N is negative, then the

** number of pages is adjusted so that the cache uses -N kibibytes

** of memory.

*/

case PragTyp_CACHE_SIZE: {

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

if( !zRight ){

returnSingleInt(v, pDb->pSchema->cache_size);

}else{

int size = sqlite3Atoi(zRight);

pDb->pSchema->cache_size = size;

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

}

break;

}

/*

** PRAGMA [schema.]cache_spill

** PRAGMA cache_spill=BOOLEAN

** PRAGMA [schema.]cache_spill=N

**

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

** page cache spill size. The second form turns cache spill on

** or off. When turnning cache spill on, the size is set to the

** current cache_size. The third form sets a spill size that

** may be different form the cache size.

** If N is positive then that is the

** number of pages in the cache. If N is negative, then the

** number of pages is adjusted so that the cache uses -N kibibytes

** of memory.

**

** If the number of cache_spill pages is less then the number of

** cache_size pages, no spilling occurs until the page count exceeds

** the number of cache_size pages.

**

** The cache_spill=BOOLEAN setting applies to all attached schemas,

** not just the schema specified.

*/

case PragTyp_CACHE_SPILL: {

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

if( !zRight ){

returnSingleInt(v,

(db->flags & SQLITE_CacheSpill)==0 ? 0 :

sqlite3BtreeSetSpillSize(pDb->pBt,0));

}else{

int size = 1;

if( sqlite3GetInt32(zRight, &size) ){

sqlite3BtreeSetSpillSize(pDb->pBt, size);

}

if( sqlite3GetBoolean(zRight, size!=0) ){

db->flags |= SQLITE_CacheSpill;

}else{

db->flags &= ~(u64)SQLITE_CacheSpill;

}

setAllPagerFlags(db);

}

break;

}

/*

** PRAGMA [schema.]mmap_size(N)

**

** Used to set mapping size limit. The mapping size limit is

** used to limit the aggregate size of all memory mapped regions of the

** database file. If this parameter is set to zero, then memory mapping

** is not used at all. If N is negative, then the default memory map

** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.

** The parameter N is measured in bytes.

**

** This value is advisory. The underlying VFS is free to memory map

** as little or as much as it wants. Except, if N is set to 0 then the

** upper layers will never invoke the xFetch interfaces to the VFS.

*/

case PragTyp_MMAP_SIZE: {

sqlite3_int64 sz;

#if SQLITE_MAX_MMAP_SIZE>0

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

if( zRight ){

int ii;

sqlite3DecOrHexToI64(zRight, &sz);

if( sz<0 ) sz = sqlite3GlobalConfig.szMmap;

if( pId2->n==0 ) db->szMmap = sz;

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

if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){

sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);

}

}

}

sz = -1;

rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz);

#else

sz = 0;

rc = SQLITE_OK;

#endif

if( rc==SQLITE_OK ){

returnSingleInt(v, sz);

}else if( rc!=SQLITE_NOTFOUND ){

pParse->nErr++;

pParse->rc = rc;

}

break;

}

/*

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

*/

case PragTyp_TEMP_STORE: {

if( !zRight ){

returnSingleInt(v, db->temp_store);

}else{

changeTempStorage(pParse, zRight);

}

break;

}

/*

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

**

*/

case PragTyp_TEMP_STORE_DIRECTORY: {

sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));

if( !zRight ){

returnSingleText(v, sqlite3_temp_directory);

}else{

#ifndef SQLITE_OMIT_WSD

if( zRight[0] ){

int res;

rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);

if( rc!=SQLITE_OK || res==0 ){

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

sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));

goto pragma_out;

}

}

if( SQLITE_TEMP_STORE==0

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

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

){