SQLite

         fts3_snippet.lo fts3_tokenizer.lo fts3_tokenizer1.lo fts3_write.lo \
         func.lo global.lo hash.lo \
         icu.lo insert.lo journal.lo legacy.lo loadext.lo \
         main.lo malloc.lo mem0.lo mem1.lo mem2.lo mem3.lo mem5.lo \
         memjournal.lo \
         mutex.lo mutex_noop.lo mutex_os2.lo mutex_unix.lo mutex_w32.lo \
         notify.lo opcodes.lo os.lo os_os2.lo os_unix.lo os_win.lo \
         pager.lo parse.lo pcache.lo pcache1.lo pcache2.lo \
         pragma.lo prepare.lo printf.lo \
         random.lo resolve.lo rowset.lo rtree.lo select.lo status.lo \
         table.lo tokenize.lo trigger.lo \
         update.lo util.lo vacuum.lo \
         vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbemem.lo vdbetrace.lo \
         wal.lo walker.lo where.lo utf.lo vtab.lo

# Object files for the amalgamation.

  $(TOP)/src/os_win.c \
  $(TOP)/src/pager.c \
  $(TOP)/src/pager.h \
  $(TOP)/src/parse.y \
  $(TOP)/src/pcache.c \
  $(TOP)/src/pcache.h \
  $(TOP)/src/pcache1.c \
  $(TOP)/src/pcache2.c \
  $(TOP)/src/pragma.c \
  $(TOP)/src/prepare.c \
  $(TOP)/src/printf.c \
  $(TOP)/src/random.c \
  $(TOP)/src/resolve.c \
  $(TOP)/src/rowset.c \
  $(TOP)/src/select.c \

  $(TOP)/src/pager.c \
  $(TOP)/src/pragma.c \
  $(TOP)/src/prepare.c \
  $(TOP)/src/printf.c \
  $(TOP)/src/random.c \
  $(TOP)/src/pcache.c \
  $(TOP)/src/pcache1.c \
  $(TOP)/src/pcache2.c \
  $(TOP)/src/select.c \
  $(TOP)/src/tokenize.c \
  $(TOP)/src/utf.c \
  $(TOP)/src/util.c \
  $(TOP)/src/vdbeapi.c \
  $(TOP)/src/vdbeaux.c \
  $(TOP)/src/vdbe.c \

	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pager.c

pcache.lo:	$(TOP)/src/pcache.c $(HDR) $(TOP)/src/pcache.h
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pcache.c

pcache1.lo:	$(TOP)/src/pcache1.c $(HDR) $(TOP)/src/pcache.h
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pcache1.c

pcache2.lo:	$(TOP)/src/pcache2.c $(HDR) $(TOP)/src/pcache.h
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pcache2.c

os.lo:	$(TOP)/src/os.c $(HDR)
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/os.c

os_unix.lo:	$(TOP)/src/os_unix.c $(HDR)
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/os_unix.c

         fts3_snippet.o fts3_tokenizer.o fts3_tokenizer1.o fts3_write.o \
         func.o global.o hash.o \
         icu.o insert.o journal.o legacy.o loadext.o \
         main.o malloc.o mem0.o mem1.o mem2.o mem3.o mem5.o \
         memjournal.o \
         mutex.o mutex_noop.o mutex_os2.o mutex_unix.o mutex_w32.o \
         notify.o opcodes.o os.o os_os2.o os_unix.o os_win.o \
         pager.o parse.o pcache.o pcache1.o pcache2.o \
         pragma.o prepare.o printf.o \
         random.o resolve.o rowset.o rtree.o select.o status.o \
         table.o tokenize.o trigger.o \
         update.o util.o vacuum.o \
         vdbe.o vdbeapi.o vdbeaux.o vdbeblob.o vdbemem.o vdbetrace.o \
         wal.o walker.o where.o utf.o vtab.o

  $(TOP)/src/os_win.c \
  $(TOP)/src/pager.c \
  $(TOP)/src/pager.h \
  $(TOP)/src/parse.y \
  $(TOP)/src/pcache.c \
  $(TOP)/src/pcache.h \
  $(TOP)/src/pcache1.c \
  $(TOP)/src/pcache2.c \
  $(TOP)/src/pragma.c \
  $(TOP)/src/prepare.c \
  $(TOP)/src/printf.c \
  $(TOP)/src/random.c \
  $(TOP)/src/resolve.c \
  $(TOP)/src/rowset.c \
  $(TOP)/src/select.c \

  $(TOP)/src/pager.c \
  $(TOP)/src/pragma.c \
  $(TOP)/src/prepare.c \
  $(TOP)/src/printf.c \
  $(TOP)/src/random.c \
  $(TOP)/src/pcache.c \
  $(TOP)/src/pcache1.c \
  $(TOP)/src/pcache2.c \
  $(TOP)/src/select.c \
  $(TOP)/src/tokenize.c \
  $(TOP)/src/utf.c \
  $(TOP)/src/util.c \
  $(TOP)/src/vdbeapi.c \
  $(TOP)/src/vdbeaux.c \
  $(TOP)/src/vdbe.c \

**
** This file implements the default page cache implementation (the
** sqlite3_pcache interface). It also contains part of the implementation
** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features.
** If the default page cache implementation is overriden, then neither of
** these two features are available.
*/
#ifndef SQLITE_INDEPENDENT_PCACHE

#include "sqliteInt.h"

typedef struct PCache1 PCache1;
typedef struct PgHdr1 PgHdr1;
typedef struct PgFreeslot PgFreeslot;

  }
  *pnCurrent = pcache1.nCurrentPage;
  *pnMax = pcache1.nMaxPage;
  *pnMin = pcache1.nMinPage;
  *pnRecyclable = nRecyclable;
}
#endif

#endif /* defined(SQLITE_INDEPENDENT_PCACHE) */

/*
** 2011 January 13
**
** 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 provides page cache implementation (the sqlite3_pcache
** interface) for when each pager has its own private pcache and
** never has to share it with other pagers.
**
** The advantage to this implementation is that it does not require
** a mutex and hence scales better to multiple threads.  The disadvantage
** is that it will use more memory.  Hence, this implementation is 
** suited for multithreaded applications on multicore workstations
** where memory is plentiful and mutexes are expensive.
**
** The SQLITE_CONFIG_PAGECACHE option to sqlite3_config() and the
** sqlite3_release_memory() interface are no-ops when this particular
** page cache implementation is used.
*/
#ifdef SQLITE_INDEPENDENT_PCACHE

#include "sqliteInt.h"

typedef struct PCache2 PCache2;
typedef struct PgHdr2 PgHdr2;
typedef struct PgFreeslot PgFreeslot;

/* Each page cache is an instance of the following object.  Every
** open database file (including each in-memory database and each
** temporary or transient database) has a single page cache which
** is an instance of this object.
**
** Pointers to structures of this type are cast and returned as 
** opaque sqlite3_pcache* handles.
*/
struct PCache2 {
  /* Cache configuration parameters. Page size (szPage) and the purgeable
  ** flag (bPurgeable) are set when the cache is created. nMax may be 
  ** modified at any time by a call to the pcache2CacheSize() method.
  */
  int szPage;                         /* Size of allocated pages in bytes */
  int bPurgeable;                     /* True if cache is purgeable */
  unsigned int nMax;                  /* Configured "cache_size" value */

  /* Hash table of all pages. The following variables may only be accessed
  ** when the accessor is holding the global mutex (see pcache2EnterMutex() 
  ** and pcache2LeaveMutex()).
  */
  unsigned int nRecyclable;           /* Number of pages in the LRU list */
  unsigned int nPage;                 /* Total number of pages in apHash */
  unsigned int nHash;                 /* Number of slots in apHash[] */
  PgHdr2 **apHash;                    /* Hash table for fast lookup by key */
  PgHdr2 *pLruHead, *pLruTail;        /* LRU list of unpinned pages */

  unsigned int iMaxKey;               /* Largest key seen since xTruncate() */
};

/*
** Each cache entry is represented by an instance of the following 
** structure. A buffer of PgHdr2->pCache->szPage bytes is allocated 
** directly before this structure in memory (see the PGHDR2_TO_PAGE() 
** macro below).
*/
struct PgHdr2 {
  unsigned int iKey;             /* Key value (page number) */
  PgHdr2 *pNext;                 /* Next in hash table chain */
  PCache2 *pCache;               /* Cache that this page belongs to */
  PgHdr2 *pLruNext;              /* Next in LRU list of unpinned pages */
  PgHdr2 *pLruPrev;              /* Previous in LRU list of unpinned pages */
};

/*
** When a PgHdr2 structure is allocated, the associated PCache2.szPage
** bytes of data are located directly before it in memory (i.e. the total
** size of the allocation is sizeof(PgHdr2)+PCache2.szPage byte). The
** PGHDR2_TO_PAGE() macro takes a pointer to a PgHdr2 structure as
** an argument and returns a pointer to the associated block of szPage
** bytes. The PAGE_TO_PGHDR2() macro does the opposite: its argument is
** a pointer to a block of szPage bytes of data and the return value is
** a pointer to the associated PgHdr2 structure.
**
**   assert( PGHDR2_TO_PAGE(PAGE_TO_PGHDR2(pCache, X))==X );
*/
#define PGHDR2_TO_PAGE(p)    (void*)(((char*)p) - p->pCache->szPage)
#define PAGE_TO_PGHDR2(c, p) (PgHdr2*)(((char*)p) + c->szPage)

/******************************************************************************/
/******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/

/*
** This function is called during initialization if a static buffer is 
** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE
** verb to sqlite3_config(). Parameter pBuf points to an allocation large
** enough to contain 'n' buffers of 'sz' bytes each.
*/
void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
  /* Not used with an independent page cache.  All memory from malloc() */
}

/*
** Allocate a new page object initially associated with cache pCache.
*/
static PgHdr2 *pcache2AllocPage(PCache2 *pCache){
  int nByte = sizeof(PgHdr2) + pCache->szPage;
  void *pPg = sqlite3Malloc(nByte);
  return pPg ? PAGE_TO_PGHDR2(pCache, pPg) : 0;
}

/*
** Free a page object allocated by pcache2AllocPage().
**
** The pointer is allowed to be NULL, which is prudent.  But it turns out
** that the current implementation happens to never call this routine
** with a NULL pointer, so we mark the NULL test with ALWAYS().
*/
static void pcache2FreePage(PgHdr2 *p){
  sqlite3_free(PGHDR2_TO_PAGE(p));
}

/*
** Malloc function used by SQLite to obtain space from the buffer configured
** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer
** exists, this function falls back to sqlite3Malloc().
*/
void *sqlite3PageMalloc(int sz){
  return sqlite3Malloc(sz);
}

/*
** Free an allocated buffer obtained from sqlite3PageMalloc().
*/
void sqlite3PageFree(void *p){
  sqlite3_free(p);
}

/******************************************************************************/
/******** General Implementation Functions ************************************/

/*
** This function is used to resize the hash table used by the cache passed
** as the first argument.
*/
static int pcache2ResizeHash(PCache2 *p){
  PgHdr2 **apNew;
  unsigned int nNew;
  unsigned int i;

  nNew = p->nHash*2;
  if( nNew<256 ){
    nNew = 256;
  }
  if( p->nHash ){ sqlite3BeginBenignMalloc(); }
  apNew = (PgHdr2 **)sqlite3_malloc(sizeof(PgHdr2 *)*nNew);
  if( p->nHash ){ sqlite3EndBenignMalloc(); }
  if( apNew ){
    memset(apNew, 0, sizeof(PgHdr2 *)*nNew);
    for(i=0; i<p->nHash; i++){
      PgHdr2 *pPage;
      PgHdr2 *pNext = p->apHash[i];
      while( (pPage = pNext)!=0 ){
        unsigned int h = pPage->iKey % nNew;
        pNext = pPage->pNext;
        pPage->pNext = apNew[h];
        apNew[h] = pPage;
      }
    }
    sqlite3_free(p->apHash);
    p->apHash = apNew;
    p->nHash = nNew;
  }
  return (p->apHash ? SQLITE_OK : SQLITE_NOMEM);
}

/*
** This function is used internally to remove the page pPage from the 
** global LRU list, if is part of it. If pPage is not part of the global
** LRU list, then this function is a no-op.
*/
static void pcache2PinPage(PgHdr2 *pPage){
  PCache2 *pCache = pPage->pCache;
  if( pPage && (pPage->pLruNext || pPage==pCache->pLruTail) ){
    if( pPage->pLruPrev ){
      pPage->pLruPrev->pLruNext = pPage->pLruNext;
    }
    if( pPage->pLruNext ){
      pPage->pLruNext->pLruPrev = pPage->pLruPrev;
    }
    if( pCache->pLruHead==pPage ){
      pCache->pLruHead = pPage->pLruNext;
    }
    if( pCache->pLruTail==pPage ){
      pCache->pLruTail = pPage->pLruPrev;
    }
    pPage->pLruNext = 0;
    pPage->pLruPrev = 0;
    pPage->pCache->nRecyclable--;
  }
}


/*
** Remove the page supplied as an argument from the hash table 
** (PCache2.apHash structure) that it is currently stored in.
*/
static void pcache2RemoveFromHash(PgHdr2 *pPage){
  unsigned int h;
  PCache2 *pCache = pPage->pCache;
  PgHdr2 **pp;

  h = pPage->iKey % pCache->nHash;
  for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
  *pp = (*pp)->pNext;

  pCache->nPage--;
}

/*
** If there are currently more than pcache.nMaxPage pages allocated, try
** to recycle pages to reduce the number allocated to pcache.nMaxPage.
*/
static void pcache2EnforceMaxPage(PCache2 *pCache){
  while( pCache->nPage>pCache->nMax && pCache->pLruTail ){
    PgHdr2 *p = pCache->pLruTail;
    pcache2PinPage(p);
    pcache2RemoveFromHash(p);
    pcache2FreePage(p);
  }
}

/*
** Discard all pages from cache pCache with a page number (key value) 
** greater than or equal to iLimit. Any pinned pages that meet this 
** criteria are unpinned before they are discarded.
*/
static void pcache2TruncateUnsafe(
  PCache2 *pCache, 
  unsigned int iLimit 
){
  TESTONLY(unsigned int nPage = 0;) /* To assert pCache->nPage is correct */
  unsigned int h;
  for(h=0; h<pCache->nHash; h++){
    PgHdr2 **pp = &pCache->apHash[h]; 
    PgHdr2 *pPage;
    while( (pPage = *pp)!=0 ){
      if( pPage->iKey>=iLimit ){
        pCache->nPage--;
        *pp = pPage->pNext;
        pcache2PinPage(pPage);
        pcache2FreePage(pPage);
      }else{
        pp = &pPage->pNext;
        TESTONLY( nPage++; )
      }
    }
  }
  assert( pCache->nPage==nPage );
}

/******************************************************************************/
/******** sqlite3_pcache Methods **********************************************/

/*
** Implementation of the sqlite3_pcache.xInit method.
*/
static int pcache2Init(void *NotUsed){
  UNUSED_PARAMETER(NotUsed);
  return SQLITE_OK;
}

/*
** Implementation of the sqlite3_pcache.xShutdown method.
** Note that the static mutex allocated in xInit does 
** not need to be freed.
*/
static void pcache2Shutdown(void *NotUsed){
  UNUSED_PARAMETER(NotUsed);
}

/*
** Implementation of the sqlite3_pcache.xCreate method.
**
** Allocate a new cache.
*/
static sqlite3_pcache *pcache2Create(int szPage, int bPurgeable){
  PCache2 *pCache;

  pCache = (PCache2 *)sqlite3_malloc(sizeof(PCache2));
  if( pCache ){
    memset(pCache, 0, sizeof(PCache2));
    pCache->szPage = szPage;
    pCache->bPurgeable = (bPurgeable ? 1 : 0);
  }
  return (sqlite3_pcache *)pCache;
}

/*
** Implementation of the sqlite3_pcache.xCachesize method. 
**
** Configure the cache_size limit for a cache.
*/
static void pcache2Cachesize(sqlite3_pcache *p, int nMax){
  PCache2 *pCache = (PCache2 *)p;
  if( pCache->bPurgeable ){
    pCache->nMax = nMax;
    pcache2EnforceMaxPage(pCache);
  }
}

/*
** Implementation of the sqlite3_pcache.xPagecount method. 
*/
static int pcache2Pagecount(sqlite3_pcache *p){
  int n;
  n = ((PCache2 *)p)->nPage;
  return n;
}

/*
** Implementation of the sqlite3_pcache.xFetch method. 
**
** Fetch a page by key value.
**
** Whether or not a new page may be allocated by this function depends on
** the value of the createFlag argument.  0 means do not allocate a new
** page.  1 means allocate a new page if space is easily available.  2 
** means to try really hard to allocate a new page.
**
** For a non-purgeable cache (a cache used as the storage for an in-memory
** database) there is really no difference between createFlag 1 and 2.  So
** the calling function (pcache.c) will never have a createFlag of 1 on
** a non-purgable cache.
**
** There are three different approaches to obtaining space for a page,
** depending on the value of parameter createFlag (which may be 0, 1 or 2).
**
**   1. Regardless of the value of createFlag, the cache is searched for a 
**      copy of the requested page. If one is found, it is returned.
**
**   2. If createFlag==0 and the page is not already in the cache, NULL is
**      returned.
**
**   3. If createFlag is 1, and the page is not already in the cache, then
**      return NULL (do not allocate a new page) if any of the following
**      conditions are true:
**
**       (a) the number of pages pinned by the cache is greater than
**           PCache2.nMax, or
**
**   4. If none of the first three conditions apply and the cache is marked
**      as purgeable, and if one of the following is true:
**
**       (a) The number of pages allocated for the cache is already 
**           PCache2.nMax
**
**      then attempt to recycle a page from the LRU list.
**
**   5. Otherwise, allocate and return a new page buffer.
*/
static void *pcache2Fetch(sqlite3_pcache *p, unsigned int iKey, int createFlag){
  unsigned int nPinned;
  PCache2 *pCache = (PCache2 *)p;
  PgHdr2 *pPage = 0;

  assert( pCache->bPurgeable || createFlag!=1 );
  if( createFlag==1 ) sqlite3BeginBenignMalloc();

  /* Search the hash table for an existing entry. */
  if( pCache->nHash>0 ){
    unsigned int h = iKey % pCache->nHash;
    for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
  }

  if( pPage ){
    pcache2PinPage(pPage);
    goto fetch_out;
  }
  if( createFlag==0 ){
    goto fetch_out;
  }

  /* Step 3 of header comment. */
  nPinned = pCache->nPage - pCache->nRecyclable;
  if( createFlag==1 && nPinned>=pCache->nMax ){
    goto fetch_out;
  }

  if( pCache->nPage>=pCache->nHash && pcache2ResizeHash(pCache) ){
    goto fetch_out;
  }

  /* Step 4. Try to recycle a page buffer if appropriate. */
  if( pCache->bPurgeable && pCache->pLruTail ){
    pPage = pCache->pLruTail;
    pcache2RemoveFromHash(pPage);
    pcache2PinPage(pPage);
  }

  /* Step 5. If a usable page buffer has still not been found, 
  ** attempt to allocate a new one. 
  */
  if( !pPage ){
    pPage = pcache2AllocPage(pCache);
  }

  if( pPage ){
    unsigned int h = iKey % pCache->nHash;
    pCache->nPage++;
    pPage->iKey = iKey;
    pPage->pNext = pCache->apHash[h];
    pPage->pCache = pCache;
    pPage->pLruPrev = 0;
    pPage->pLruNext = 0;
    *(void **)(PGHDR2_TO_PAGE(pPage)) = 0;
    pCache->apHash[h] = pPage;
  }

fetch_out:
  if( pPage && iKey>pCache->iMaxKey ){
    pCache->iMaxKey = iKey;
  }
  if( createFlag==1 ) sqlite3EndBenignMalloc();
  return (pPage ? PGHDR2_TO_PAGE(pPage) : 0);
}


/*
** Implementation of the sqlite3_pcache.xUnpin method.
**
** Mark a page as unpinned (eligible for asynchronous recycling).
*/
static void pcache2Unpin(sqlite3_pcache *p, void *pPg, int reuseUnlikely){
  PCache2 *pCache = (PCache2 *)p;
  PgHdr2 *pPage = PAGE_TO_PGHDR2(pCache, pPg);
 
  assert( pPage->pCache==pCache );

  /* It is an error to call this function if the page is already 
  ** unpinned.
  */
  assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
  assert( pCache->pLruHead!=pPage && pCache->pLruTail!=pPage );

  if( reuseUnlikely || pCache->nPage>pCache->nMax ){
    pcache2RemoveFromHash(pPage);
    pcache2FreePage(pPage);
  }else{
    /* Add the page to the LRU list. */
    if( pCache->pLruHead ){
      pCache->pLruHead->pLruPrev = pPage;
      pPage->pLruNext = pCache->pLruHead;
      pCache->pLruHead = pPage;
      assert( pPage->pLruPrev==0 );
    }else{
      pCache->pLruTail = pPage;
      pCache->pLruHead = pPage;
      assert( pPage->pLruPrev==0 );
      assert( pPage->pLruNext==0 );
    }
    pCache->nRecyclable++;
  }
}

/*
** Implementation of the sqlite3_pcache.xRekey method. 
*/
static void pcache2Rekey(
  sqlite3_pcache *p,
  void *pPg,
  unsigned int iOld,
  unsigned int iNew
){
  PCache2 *pCache = (PCache2 *)p;
  PgHdr2 *pPage = PAGE_TO_PGHDR2(pCache, pPg);
  PgHdr2 **pp;
  unsigned int h; 
  assert( pPage->iKey==iOld );
  assert( pPage->pCache==pCache );

  h = iOld%pCache->nHash;
  pp = &pCache->apHash[h];
  while( (*pp)!=pPage ){
    pp = &(*pp)->pNext;
  }
  *pp = pPage->pNext;

  h = iNew%pCache->nHash;
  pPage->iKey = iNew;
  pPage->pNext = pCache->apHash[h];
  pCache->apHash[h] = pPage;
  if( iNew>pCache->iMaxKey ){
    pCache->iMaxKey = iNew;
  }
}

/*
** Implementation of the sqlite3_pcache.xTruncate method. 
**
** Discard all unpinned pages in the cache with a page number equal to
** or greater than parameter iLimit. Any pinned pages with a page number
** equal to or greater than iLimit are implicitly unpinned.
*/
static void pcache2Truncate(sqlite3_pcache *p, unsigned int iLimit){
  PCache2 *pCache = (PCache2 *)p;
  if( iLimit<=pCache->iMaxKey ){
    pcache2TruncateUnsafe(pCache, iLimit);
    pCache->iMaxKey = iLimit-1;
  }
}

/*
** Implementation of the sqlite3_pcache.xDestroy method. 
**
** Destroy a cache allocated using pcache2Create().
*/
static void pcache2Destroy(sqlite3_pcache *p){
  PCache2 *pCache = (PCache2 *)p;
  assert( pCache->bPurgeable || pCache->nMax==0 );
  pcache2TruncateUnsafe(pCache, 0);
  pcache2EnforceMaxPage(pCache);
  sqlite3_free(pCache->apHash);
  sqlite3_free(pCache);
}

/*
** This function is called during initialization (sqlite3_initialize()) to
** install the default pluggable cache module, assuming the user has not
** already provided an alternative.
*/
void sqlite3PCacheSetDefault(void){
  static const sqlite3_pcache_methods defaultMethods = {
    0,                       /* pArg */
    pcache2Init,             /* xInit */
    pcache2Shutdown,         /* xShutdown */
    pcache2Create,           /* xCreate */
    pcache2Cachesize,        /* xCachesize */
    pcache2Pagecount,        /* xPagecount */
    pcache2Fetch,            /* xFetch */
    pcache2Unpin,            /* xUnpin */
    pcache2Rekey,            /* xRekey */
    pcache2Truncate,         /* xTruncate */
    pcache2Destroy           /* xDestroy */
  };
  sqlite3_config(SQLITE_CONFIG_PCACHE, &defaultMethods);
}

#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
/*
** This function is called to free superfluous dynamically allocated memory
** held by the pager system. Memory in use by any SQLite pager allocated
** by the current thread may be sqlite3_free()ed.
**
** nReq is the number of bytes of memory required. Once this much has
** been released, the function returns. The return value is the total number 
** of bytes of memory released.
*/
int sqlite3PcacheReleaseMemory(int nReq){
  return 0;
}
#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */

#ifdef SQLITE_TEST
/*
** This function is used by test procedures to inspect the internal state
** of the global cache.
*/
void sqlite3PcacheStats(
  int *pnCurrent,      /* OUT: Total number of pages cached */
  int *pnMax,          /* OUT: Global maximum cache size */
  int *pnMin,          /* OUT: Sum of PCache2.nMin for purgeable caches */
  int *pnRecyclable    /* OUT: Total number of pages available for recycling */
){
  *pnCurrent = 0;
  *pnMax = 0;
  *pnMin = 0;
  *pnRecyclable = 0;
}
#endif

#endif /* SQLITE_INDEPENDENT_PCACHE */

   os_os2.c
   os_unix.c
   os_win.c

   bitvec.c
   pcache.c
   pcache1.c
   pcache2.c
   rowset.c
   pager.c
   wal.c

   btmutex.c
   btree.c
   backup.c