SQLite

  int nFetchOut;                /* Number of outstanding xFetch references */
  HANDLE hMap;                  /* Handle for accessing memory mapping */
  void *pMapRegion;             /* Area memory mapped */
  sqlite3_int64 mmapSize;       /* Usable size of mapped region */
  sqlite3_int64 mmapSizeActual; /* Actual size of mapped region */
  sqlite3_int64 mmapSizeMax;    /* Configured FCNTL_MMAP_SIZE value */
#endif
  SQLiteThread *preCacheThread; /* Thread used to pre-cache file contents */
};

/*
** Allowed values for winFile.ctrlFlags
*/
#define WINFILE_RDONLY          0x02   /* Connection is read only */
#define WINFILE_PERSIST_WAL     0x04   /* Persistent WAL mode */

#else
  { "CreateFileMappingFromApp", (SYSCALL)0,                      0 },
#endif

#define osCreateFileMappingFromApp ((HANDLE(WINAPI*)(HANDLE, \
        LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[75].pCurrent)

  { "DuplicateHandle",          (SYSCALL)DuplicateHandle,        0 },

#define osDuplicateHandle ((BOOL(WINAPI*)(HANDLE, \
        HANDLE,HANDLE,LPHANDLE,DWORD,BOOL,DWORD))aSyscall[76].pCurrent)

}; /* End of the overrideable system calls */

/*
** This is the xSetSystemCall() method of sqlite3_vfs for all of the
** "win32" VFSes.  Return SQLITE_OK opon successfully updating the
** system call pointer, or SQLITE_NOTFOUND if there is no configurable
** system call named zName.

  assert( id!=0 );
#ifndef SQLITE_OMIT_WAL
  assert( pFile->pShm==0 );
#endif
  assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
  OSTRACE(("CLOSE file=%p\n", pFile->h));

#if SQLITE_MAX_WORKER_THREADS>0
  if( pFile->preCacheThread ){
    void *pOut = 0;
    sqlite3ThreadJoin(pFile->preCacheThread, &pOut);
  }
#endif

#if SQLITE_MAX_MMAP_SIZE>0
  winUnmapfile(pFile);
#endif

  do{
    rc = osCloseHandle(pFile->h);

** Return a vector of device characteristics.
*/
static int winDeviceCharacteristics(sqlite3_file *id){
  winFile *p = (winFile*)id;
  return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN |
         ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);
}

/*
** Thread routine that seeks to the end of an open file and reads one byte.
** This is used to provide a hint to the operating system that the entire
** file should be held in the cache.
*/
static void *winPreCacheThread(void *pCtx){
  winFile *pFile = (winFile*)pCtx;
  void *pBuf = 0;
  DWORD lastErrno;
  HANDLE dupHandle = NULL;
  DWORD dwSize, dwRet;
  DWORD dwAmt;
  DWORD nRead;

  if( !osDuplicateHandle(GetCurrentProcess(), pFile->h, GetCurrentProcess(),
                         &dupHandle, 0, FALSE, DUPLICATE_SAME_ACCESS) ){
    pFile->lastErrno = osGetLastError();
    OSTRACE(("PRE-CACHE file=%p, rc=SQLITE_IOERR\n", dupHandle));
    return winLogError(SQLITE_IOERR, pFile->lastErrno,
                       "winPreCacheThread1", pFile->zPath);
  }
  dwSize = osSetFilePointer(dupHandle, 0, 0, FILE_END);
  if( (dwSize==INVALID_SET_FILE_POINTER
      && ((lastErrno = osGetLastError())!=NO_ERROR)) ){
    pFile->lastErrno = lastErrno;
    osCloseHandle(dupHandle);
    OSTRACE(("PRE-CACHE file=%p, rc=SQLITE_IOERR_SEEK\n", dupHandle));
    return winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
                       "winPreCacheThread2", pFile->zPath);
  }
  dwRet = osSetFilePointer(dupHandle, 0, 0, FILE_BEGIN);
  if( (dwRet==INVALID_SET_FILE_POINTER
      && ((lastErrno = osGetLastError())!=NO_ERROR)) ){
    pFile->lastErrno = lastErrno;
    osCloseHandle(dupHandle);
    OSTRACE(("PRE-CACHE file=%p, rc=SQLITE_IOERR_SEEK\n", dupHandle));
    return winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
                       "winPreCacheThread2", pFile->zPath);
  }
  dwAmt = 4194304; /* TODO: Tuning. */
  if( dwSize<dwAmt ){
    dwAmt = dwSize;
  }
  pBuf = sqlite3MallocZero( dwAmt );
  if( pBuf==0 ){
    osCloseHandle(dupHandle);
    OSTRACE(("PRE-CACHE file=%p, rc=SQLITE_IOERR_NOMEM\n", dupHandle));
    return SQLITE_IOERR_NOMEM;
  }
  while( 1 ){
    if( !osReadFile(dupHandle, pBuf, dwAmt, &nRead, 0) ){
      pFile->lastErrno = osGetLastError();
      osCloseHandle(dupHandle);
      OSTRACE(("PRE-CACHE file=%p, rc=SQLITE_IOERR_READ\n", dupHandle));
      return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
                         "winPreCacheThread3", pFile->zPath);
    }
    if( nRead<dwAmt ){
      osCloseHandle(dupHandle);
      OSTRACE(("PRE-CACHE file=%p, rc=SQLITE_IOERR_SHORT_READ\n", dupHandle));
      return winLogError(SQLITE_IOERR_SHORT_READ, pFile->lastErrno,
                         "winPreCacheThread4", pFile->zPath);
    }
    dwSize -= dwAmt;
    if( dwSize==0 ){
      break;
    }
  }
  osCloseHandle(dupHandle);
  return SQLITE_OK;
}

/* 
** Windows will only let you create file view mappings
** on allocation size granularity boundaries.
** During sqlite3_os_init() we do a GetSystemInfo()
** to get the granularity size.
*/

#if SQLITE_MAX_MMAP_SIZE>0
  pFile->hMap = NULL;
  pFile->pMapRegion = 0;
  pFile->mmapSize = 0;
  pFile->mmapSizeActual = 0;
  pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
#endif
#if SQLITE_MAX_WORKER_THREADS>0
  sqlite3ThreadCreate(&pFile->preCacheThread, winPreCacheThread, pFile);

  {
    void *pOut = 0;
    sqlite3ThreadJoin(pFile->preCacheThread, &pOut);
    pFile->preCacheThread = 0;
  }
#endif

  OpenCounter(+1);
  return rc;
}

/*
** Delete the named file.

    winGetSystemCall,    /* xGetSystemCall */
    winNextSystemCall,   /* xNextSystemCall */
  };
#endif

  /* Double-check that the aSyscall[] array has been constructed
  ** correctly.  See ticket [bb3a86e890c8e96ab] */
  assert( ArraySize(aSyscall)==77 );

  /* get memory map allocation granularity */
  memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
#if SQLITE_OS_WINRT
  osGetNativeSystemInfo(&winSysInfo);
#else
  osGetSystemInfo(&winSysInfo);