/*

** 2008 June 18

**

** 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 module implements the sqlite3_status() interface and related

** functionality.

*/

#include "sqliteInt.h"

#include "vdbeInt.h"

/*

** Variables in which to record status information.

*/

#if SQLITE_PTRSIZE>4

typedef sqlite3_int64 sqlite3StatValueType;

#else

typedef u32 sqlite3StatValueType;

#endif

typedef struct sqlite3StatType sqlite3StatType;

static SQLITE_WSD struct sqlite3StatType {

sqlite3StatValueType nowValue[10]; /* Current value */

sqlite3StatValueType mxValue[10]; /* Maximum value */

} sqlite3Stat = { {0,}, {0,} };

/*

** Elements of sqlite3Stat[] are protected by either the memory allocator

** mutex, or by the pcache1 mutex. The following array determines which.

*/

static const char statMutex[] = {

0, /* SQLITE_STATUS_MEMORY_USED */

1, /* SQLITE_STATUS_PAGECACHE_USED */

1, /* SQLITE_STATUS_PAGECACHE_OVERFLOW */

0, /* SQLITE_STATUS_SCRATCH_USED */

0, /* SQLITE_STATUS_SCRATCH_OVERFLOW */

0, /* SQLITE_STATUS_MALLOC_SIZE */

0, /* SQLITE_STATUS_PARSER_STACK */

1, /* SQLITE_STATUS_PAGECACHE_SIZE */

0, /* SQLITE_STATUS_SCRATCH_SIZE */

0, /* SQLITE_STATUS_MALLOC_COUNT */

};

/* The "wsdStat" macro will resolve to the status information

** state vector. If writable static data is unsupported on the target,

** we have to locate the state vector at run-time. In the more common

** case where writable static data is supported, wsdStat can refer directly

** to the "sqlite3Stat" state vector declared above.

*/

#ifdef SQLITE_OMIT_WSD

# define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat)

# define wsdStat x[0]

#else

# define wsdStatInit

# define wsdStat sqlite3Stat

#endif

/*

** Return the current value of a status parameter. The caller must

** be holding the appropriate mutex.

*/

sqlite3_int64 sqlite3StatusValue(int op){

wsdStatInit;

assert( op>=0 && op<ArraySize(wsdStat.nowValue) );

assert( op>=0 && op<ArraySize(statMutex) );

assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()

: sqlite3MallocMutex()) );

return wsdStat.nowValue[op];

}

/*

** Add N to the value of a status record. The caller must hold the

** appropriate mutex. (Locking is checked by assert()).

**

** The StatusUp() routine can accept positive or negative values for N.

** The value of N is added to the current status value and the high-water

** mark is adjusted if necessary.

**

** The StatusDown() routine lowers the current value by N. The highwater

** mark is unchanged. N must be non-negative for StatusDown().

*/

void sqlite3StatusUp(int op, int N){

wsdStatInit;

assert( op>=0 && op<ArraySize(wsdStat.nowValue) );

assert( op>=0 && op<ArraySize(statMutex) );

assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()

: sqlite3MallocMutex()) );

wsdStat.nowValue[op] += N;

if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){

wsdStat.mxValue[op] = wsdStat.nowValue[op];

}

}

void sqlite3StatusDown(int op, int N){

wsdStatInit;

assert( N>=0 );

assert( op>=0 && op<ArraySize(statMutex) );

assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()

: sqlite3MallocMutex()) );

assert( op>=0 && op<ArraySize(wsdStat.nowValue) );

wsdStat.nowValue[op] -= N;

}

/*

** Adjust the highwater mark if necessary.

** The caller must hold the appropriate mutex.

*/

void sqlite3StatusHighwater(int op, int X){

sqlite3StatValueType newValue;

wsdStatInit;

assert( X>=0 );

newValue = (sqlite3StatValueType)X;

assert( op>=0 && op<ArraySize(wsdStat.nowValue) );

assert( op>=0 && op<ArraySize(statMutex) );

assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()

: sqlite3MallocMutex()) );

assert( op==SQLITE_STATUS_MALLOC_SIZE

|| op==SQLITE_STATUS_PAGECACHE_SIZE

|| op==SQLITE_STATUS_PARSER_STACK );

if( newValue>wsdStat.mxValue[op] ){

wsdStat.mxValue[op] = newValue;

}

}

/*

** Query status information.

*/

int sqlite3_status64(

int op,

sqlite3_int64 *pCurrent,

sqlite3_int64 *pHighwater,

int resetFlag

){

sqlite3_mutex *pMutex;

wsdStatInit;

if( op<0 || op>=ArraySize(wsdStat.nowValue) ){

return SQLITE_MISUSE_BKPT;

}

#ifdef SQLITE_ENABLE_API_ARMOR

if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;

#endif

pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();

sqlite3_mutex_enter(pMutex);

*pCurrent = wsdStat.nowValue[op];

*pHighwater = wsdStat.mxValue[op];

if( resetFlag ){

wsdStat.mxValue[op] = wsdStat.nowValue[op];

}

sqlite3_mutex_leave(pMutex);

(void)pMutex; /* Prevent warning when SQLITE_THREADSAFE=0 */

return SQLITE_OK;

}

int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){

sqlite3_int64 iCur = 0, iHwtr = 0;

int rc;

#ifdef SQLITE_ENABLE_API_ARMOR

if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;

#endif

rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);

if( rc==0 ){

*pCurrent = (int)iCur;

*pHighwater = (int)iHwtr;

}

return rc;

}

/*

** Return the number of LookasideSlot elements on the linked list

*/

static u32 countLookasideSlots(LookasideSlot *p){

u32 cnt = 0;

while( p ){

p = p->pNext;

cnt++;

}

return cnt;

}

/*

** Count the number of slots of lookaside memory that are outstanding

*/

int sqlite3LookasideUsed(sqlite3 *db, int *pHighwater){

u32 nInit = countLookasideSlots(db->lookaside.pInit);

u32 nFree = countLookasideSlots(db->lookaside.pFree);

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

nInit += countLookasideSlots(db->lookaside.pSmallInit);

nFree += countLookasideSlots(db->lookaside.pSmallFree);

#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */

if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit;

return db->lookaside.nSlot - (nInit+nFree);

}

/*

** Query status information for a single database connection

*/

int sqlite3_db_status(

sqlite3 *db, /* The database connection whose status is desired */

int op, /* Status verb */

int *pCurrent, /* Write current value here */

int *pHighwater, /* Write high-water mark here */

int resetFlag /* Reset high-water mark if true */

){

int rc = SQLITE_OK; /* Return code */

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){

return SQLITE_MISUSE_BKPT;

}

#endif

sqlite3_mutex_enter(db->mutex);

switch( op ){

case SQLITE_DBSTATUS_LOOKASIDE_USED: {

*pCurrent = sqlite3LookasideUsed(db, pHighwater);

if( resetFlag ){

LookasideSlot *p = db->lookaside.pFree;

if( p ){

while( p->pNext ) p = p->pNext;

p->pNext = db->lookaside.pInit;

db->lookaside.pInit = db->lookaside.pFree;

db->lookaside.pFree = 0;

}

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

p = db->lookaside.pSmallFree;

if( p ){

while( p->pNext ) p = p->pNext;

p->pNext = db->lookaside.pSmallInit;

db->lookaside.pSmallInit = db->lookaside.pSmallFree;

db->lookaside.pSmallFree = 0;

}

#endif

}

break;

}

case SQLITE_DBSTATUS_LOOKASIDE_HIT:

case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:

case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {

testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );

testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );

testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );

assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );

assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );

*pCurrent = 0;

*pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];

if( resetFlag ){

db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;

}

break;

}

/*

** Return an approximation for the amount of memory currently used

** by all pagers associated with the given database connection. The

** highwater mark is meaningless and is returned as zero.

*/

case SQLITE_DBSTATUS_CACHE_USED_SHARED:

case SQLITE_DBSTATUS_CACHE_USED: {

int totalUsed = 0;

int i;

sqlite3BtreeEnterAll(db);

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

Btree *pBt = db->aDb[i].pBt;

if( pBt ){

Pager *pPager = sqlite3BtreePager(pBt);

int nByte = sqlite3PagerMemUsed(pPager);

if( op==SQLITE_DBSTATUS_CACHE_USED_SHARED ){

nByte = nByte / sqlite3BtreeConnectionCount(pBt);

}

totalUsed += nByte;

}

}

sqlite3BtreeLeaveAll(db);

*pCurrent = totalUsed;

*pHighwater = 0;

break;

}

/*

** *pCurrent gets an accurate estimate of the amount of memory used

** to store the schema for all databases (main, temp, and any ATTACHed

** databases. *pHighwater is set to zero.

*/

case SQLITE_DBSTATUS_SCHEMA_USED: {

int i; /* Used to iterate through schemas */

int nByte = 0; /* Used to accumulate return value */

sqlite3BtreeEnterAll(db);

db->pnBytesFreed = &nByte;

assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );

db->lookaside.pEnd = db->lookaside.pStart;

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

Schema *pSchema = db->aDb[i].pSchema;

if( ALWAYS(pSchema!=0) ){

HashElem *p;

nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (

pSchema->tblHash.count

+ pSchema->trigHash.count

+ pSchema->idxHash.count

+ pSchema->fkeyHash.count

);

nByte += sqlite3_msize(pSchema->tblHash.ht);

nByte += sqlite3_msize(pSchema->trigHash.ht);

nByte += sqlite3_msize(pSchema->idxHash.ht);

nByte += sqlite3_msize(pSchema->fkeyHash.ht);

for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){

sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));

}

for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){

sqlite3DeleteTable(db, (Table *)sqliteHashData(p));

}

}

}

db->pnBytesFreed = 0;

db->lookaside.pEnd = db->lookaside.pTrueEnd;

sqlite3BtreeLeaveAll(db);

*pHighwater = 0;

*pCurrent = nByte;

break;

}

/*

** *pCurrent gets an accurate estimate of the amount of memory used

** to store all prepared statements.

** *pHighwater is set to zero.

*/

case SQLITE_DBSTATUS_STMT_USED: {

struct Vdbe *pVdbe; /* Used to iterate through VMs */

int nByte = 0; /* Used to accumulate return value */

db->pnBytesFreed = &nByte;

assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );

db->lookaside.pEnd = db->lookaside.pStart;

for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pVNext){

sqlite3VdbeDelete(pVdbe);

}

db->lookaside.pEnd = db->lookaside.pTrueEnd;

db->pnBytesFreed = 0;

*pHighwater = 0; /* IMP: R-64479-57858 */

*pCurrent = nByte;

break;

}

/*

** Set *pCurrent to the total cache hits or misses encountered by all

** pagers the database handle is connected to. *pHighwater is always set

** to zero.

*/

case SQLITE_DBSTATUS_CACHE_SPILL:

op = SQLITE_DBSTATUS_CACHE_WRITE+1;

/* no break */ deliberate_fall_through

case SQLITE_DBSTATUS_CACHE_HIT:

case SQLITE_DBSTATUS_CACHE_MISS:

case SQLITE_DBSTATUS_CACHE_WRITE:{

int i;

u64 nRet = 0;

assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );

assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 );

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

if( db->aDb[i].pBt ){

Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);

sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);

}

}

*pHighwater = 0; /* IMP: R-42420-56072 */

/* IMP: R-54100-20147 */

/* IMP: R-29431-39229 */

*pCurrent = (int)nRet & 0x7fffffff;

break;

}

/* Set *pCurrent to non-zero if there are unresolved deferred foreign

** key constraints. Set *pCurrent to zero if all foreign key constraints

** have been satisfied. The *pHighwater is always set to zero.

*/

case SQLITE_DBSTATUS_DEFERRED_FKS: {

*pHighwater = 0; /* IMP: R-11967-56545 */

*pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;

break;

}

default: {

rc = SQLITE_ERROR;

}

}

sqlite3_mutex_leave(db->mutex);

return rc;

}