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