Projects/Vocaluxe
2
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

compiled Community.CsharpSqlite.dll for target AnyCPU, added source code

Browse Source
This commit is contained in:
Alexander Eckart committed 2012-06-19 18:29:58 +02:00
1 parent 5b87c37e3a
commit b4d155a5a3
93 files changed
+121260 -2
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Community.CsharpSqlite/src/status_c.cs
+277
View File
@@ -0,0 +1,277 @@
using System;
using System.Diagnostics;
using System.Text;
namespace Community.CsharpSqlite
{
using sqlite3_value = Sqlite3.Mem;
public partial class Sqlite3
{
/*
** 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.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-05-19 13:26:54 ed1da510a239ea767a01dc332b667119fa3c908e
**
*************************************************************************
*/
//#include "sqliteInt.h"
//#include "vdbeInt.h"
/*
** Variables in which to record status information.
*/
//typedef struct sqlite3StatType sqlite3StatType;
public class sqlite3StatType
{
public int[] nowValue = new int[10]; /* Current value */
public int[] mxValue = new int[10]; /* Maximum value */
}
public static sqlite3StatType sqlite3Stat = new sqlite3StatType();
/* 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.
*/
#if SQLITE_OMIT_WSD
//# define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat)
//# define wsdStat x[0]
#else
//# define wsdStatInit
static void wsdStatInit()
{
}
//# define wsdStat sqlite3Stat
static sqlite3StatType wsdStat = sqlite3Stat;
#endif
/*
** Return the current value of a status parameter.
*/
static int sqlite3StatusValue( int op )
{
wsdStatInit();
Debug.Assert( op >= 0 && op < ArraySize( wsdStat.nowValue ) );
return wsdStat.nowValue[op];
}
/*
** Add N to the value of a status record. It is assumed that the
** caller holds appropriate locks.
*/
static void sqlite3StatusAdd( int op, int N )
{
wsdStatInit();
Debug.Assert( op >= 0 && op < ArraySize( wsdStat.nowValue ) );
wsdStat.nowValue[op] += N;
if ( wsdStat.nowValue[op] > wsdStat.mxValue[op] )
{
wsdStat.mxValue[op] = wsdStat.nowValue[op];
}
}
/*
** Set the value of a status to X.
*/
static void sqlite3StatusSet( int op, int X )
{
wsdStatInit();
Debug.Assert( op >= 0 && op < ArraySize( wsdStat.nowValue ) );
wsdStat.nowValue[op] = X;
if ( wsdStat.nowValue[op] > wsdStat.mxValue[op] )
{
wsdStat.mxValue[op] = wsdStat.nowValue[op];
}
}
/*
** Query status information.
**
** This implementation assumes that reading or writing an aligned
** 32-bit integer is an atomic operation. If that assumption is not true,
** then this routine is not threadsafe.
*/
static int sqlite3_status( int op, ref int pCurrent, ref int pHighwater, int resetFlag )
{
wsdStatInit();
if ( op < 0 || op >= ArraySize( wsdStat.nowValue ) )
{
return SQLITE_MISUSE_BKPT();
}
pCurrent = wsdStat.nowValue[op];
pHighwater = wsdStat.mxValue[op];
if ( resetFlag != 0 )
{
wsdStat.mxValue[op] = wsdStat.nowValue[op];
}
return SQLITE_OK;
}
/*
** Query status information for a single database connection
*/
static int sqlite3_db_status(
sqlite3 db, /* The database connection whose status is desired */
int op, /* Status verb */
ref int pCurrent, /* Write current value here */
ref int pHighwater, /* Write high-water mark here */
int resetFlag /* Reset high-water mark if true */
)
{
int rc = SQLITE_OK; /* Return code */
sqlite3_mutex_enter( db.mutex );
switch ( op )
{
case SQLITE_DBSTATUS_LOOKASIDE_USED:
{
pCurrent = db.lookaside.nOut;
pHighwater = db.lookaside.mxOut;
if ( resetFlag != 0 )
{
db.lookaside.mxOut = db.lookaside.nOut;
}
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 );
Debug.Assert( ( op - SQLITE_DBSTATUS_LOOKASIDE_HIT ) >= 0 );
Debug.Assert( ( op - SQLITE_DBSTATUS_LOOKASIDE_HIT ) < 3 );
pCurrent = 0;
pHighwater = db.lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
if ( resetFlag != 0 )
{
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:
{
int totalUsed = 0;
int i;
sqlite3BtreeEnterAll( db );
for ( i = 0; i < db.nDb; i++ )
{
Btree pBt = db.aDb[i].pBt;
if ( pBt != null )
{
Pager pPager = sqlite3BtreePager( pBt );
totalUsed += sqlite3PagerMemUsed( pPager );
}
}
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;
for ( i = 0; i < db.nDb; i++ )
{
Schema pSchema = db.aDb[i].pSchema;
if ( ALWAYS( pSchema != null ) )
{
HashElem p;
//nByte += (int)(sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
// pSchema.tblHash.count
// + pSchema.trigHash.count
// + pSchema.idxHash.count
// + pSchema.fkeyHash.count
//));
//nByte += (int)sqlite3MallocSize( pSchema.tblHash.ht );
//nByte += (int)sqlite3MallocSize( pSchema.trigHash.ht );
//nByte += (int)sqlite3MallocSize( pSchema.idxHash.ht );
//nByte += (int)sqlite3MallocSize( pSchema.fkeyHash.ht );
for ( p = sqliteHashFirst( pSchema.trigHash ); p != null; p = sqliteHashNext( p ) )
{
Trigger t = (Trigger)sqliteHashData( p );
sqlite3DeleteTrigger( db, ref t );
}
for ( p = sqliteHashFirst( pSchema.tblHash ); p != null; p = sqliteHashNext( p ) )
{
Table t = (Table)sqliteHashData( p );
sqlite3DeleteTable( db, ref t );
}
}
}
db.pnBytesFreed = 0;
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:
{
Vdbe pVdbe; /* Used to iterate through VMs */
int nByte = 0; /* Used to accumulate return value */
//db.pnBytesFreed = nByte;
for ( pVdbe = db.pVdbe; pVdbe != null; pVdbe = pVdbe.pNext )
{
sqlite3VdbeDeleteObject( db, ref pVdbe );
}
db.pnBytesFreed = 0;
pHighwater = 0;
pCurrent = nByte;
break;
}
default:
{
rc = SQLITE_ERROR;
break;
}
}
sqlite3_mutex_leave( db.mutex );
return rc;
}
}
}