rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/sqlite3/SqliteWrapper/mem_Pool.cs

@@ -0,0 +1,394 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+using sqlite3_int64 = System.Int64;
+using System.Text;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    *************************************************************************
+    **
+    ** This file contains low-level memory & pool allocation drivers 
+    **
+    ** This file contains implementations of the low-level memory allocation
+    ** routines specified in the sqlite3_mem_methods object.
+    **
+    *************************************************************************
+    **  $Header$
+    *************************************************************************
+    */
+
+    /*
+    ** Like malloc(), but remember the size of the allocation
+    ** so that we can find it later using sqlite3MemSize().
+    **
+    ** For this low-level routine, we are guaranteed that nByte>0 because
+    ** cases of nByte<=0 will be intercepted and dealt with by higher level
+    ** routines.
+    */
+#if SQLITE_POOL_MEM
+#if TRUE
+static byte[] sqlite3MemMalloc(int nByte) { return new byte[nByte]; }
+static int[] sqlite3MemMallocInt(int nInt) { return new int[nInt]; }
+#else
+    static byte[] sqlite3MemMalloc(int nByte)
+    {
+      byte[] pByte = null;
+      int savej = -1;
+      int BestSize = int.MaxValue;
+      if (nByte > mem0.aByteSize[0])
+      {
+        int i;
+        for (i = 0; i < mem0.aByteSize.Length - 1; i++) if (nByte <= mem0.aByteSize[i]) break;
+        mem0.mr_Byte++;
+        for (int j = 0; j <= mem0.aByte_used[i]; j++)
+          if (mem0.aByte[i][j] != null)
+          {
+            if (mem0.aByte[i][j].Length == nByte)
+            {
+              pByte = mem0.aByte[i][j]; mem0.aByte[i][j] = null; mem0.cf_Byte++;
+              if (j == mem0.aByte_used[i]) mem0.aByte_used[i]--;
+              break;
+            }
+            if (mem0.aByte[i][j].Length > nByte)
+            {
+              if (mem0.aByte[i][j].Length < BestSize)
+              {
+                BestSize = mem0.aByte[i][j].Length;
+                savej = j;
+              }
+            }
+          }
+        if (pByte == null && savej >= 0)
+        {
+          pByte = mem0.aByte[i][savej]; mem0.aByte[i][savej] = null; mem0.cf_Byte++;
+          Array.Resize(ref pByte, nByte);
+        }
+        if (mem0.aByte_used[i] >=0 && mem0.aByte[i][mem0.aByte_used[i]] == null) mem0.aByte_used[i]--;
+      }
+      if (pByte == null) pByte = new byte[nByte];
+      return pByte;
+    }
+    static int[] sqlite3MemMallocInt(int nInt)
+    {
+      int[] pInt = null;
+      int savei = -1;
+      int BestSize = int.MaxValue;
+      if (nInt >=10)
+      {
+        mem0.mr_Int++;
+        int i;
+        for (i = 0; i < mem0.hw_Int; i++)
+          if (mem0.aInt[i] != null)
+          {
+            if (mem0.aInt[i].Length == nInt)
+            {
+              pInt = mem0.aInt[i]; mem0.aInt[i] = null; mem0.cf_Int++; break;
+            }
+            if (mem0.aInt[i].Length > nInt)
+            {
+              if (mem0.aInt[i].Length < BestSize)
+              {
+                BestSize = mem0.aInt[i].Length;
+                savei = i;
+              }
+            }
+          }
+        if (pInt == null && savei >= 0)
+        {
+          pInt = mem0.aInt[savei]; mem0.aInt[savei] = null; mem0.cf_Int++;
+        }
+      }
+      if (pInt == null) pInt = new int[nInt];
+      return pInt;
+    }
+#endif
+
+static Mem sqlite3MemMallocMem(Mem dummy)
+    {
+      Mem pMem;
+      mem0.msMem.alloc++;
+      if ( mem0.msMem.next > 0 && mem0.aMem[mem0.msMem.next] != null )
+      {
+        pMem = mem0.aMem[mem0.msMem.next];
+        mem0.aMem[mem0.msMem.next] = null;
+        mem0.msMem.cached++;
+        mem0.msMem.next--;
+      }
+      else pMem = new Mem();
+      return pMem;
+    }
+    static BtCursor sqlite3MemMallocBtCursor( BtCursor dummy )
+    {
+      BtCursor pBtCursor;
+      mem0.msBtCursor.alloc++;
+      if (mem0.msBtCursor.next > 0 && mem0.aBtCursor[mem0.msBtCursor.next] != null)
+      {
+        pBtCursor = mem0.aBtCursor[mem0.msBtCursor.next];
+        mem0.aBtCursor[mem0.msBtCursor.next] = null;
+        mem0.msBtCursor.cached++;
+        mem0.msBtCursor.next--;
+      }
+      else pBtCursor = new BtCursor();
+      return pBtCursor;
+    }
+#endif
+    /*
+    ** Free memory.
+    */
+    // -- overloads ---------------------------------------
+    static void sqlite3MemFree<T>(ref T x) where T : class
+    { x = null; }
+    static void sqlite3MemFree(ref  string x) { x = null; }
+    //
+
+    /*
+    ** Like free() but works for allocations obtained from sqlite3MemMalloc()
+    ** or sqlite3MemRealloc().
+    **
+    ** For this low-level routine, we already know that pPrior!=0 since
+    ** cases where pPrior==0 will have been intecepted and dealt with
+    ** by higher-level routines.
+    */
+#if SQLITE_POOL_MEM
+#if TRUE
+    static void sqlite3MemFreeInt(ref int[] pPrior) { pPrior = null; }
+#else
+    static void sqlite3MemFree(ref byte[] pPrior)
+    {
+      if (pPrior == null) return;
+      if (pPrior.Length > mem0.aByteSize[0])
+      {
+        int savej = -1;
+        int Smallest = int.MaxValue;
+        int i;
+        for (i = 0; i < mem0.aByteSize.Length - 1; i++) if (pPrior.Length <= mem0.aByteSize[i]) break;
+#if DEBUG
+for (int j = 0; j < mem0.aByte[i].Length; j++) if (mem0.aByte[i][j] != null && mem0.aByte[i][j] == pPrior) Debugger.Break();
+#endif
+        mem0.mf_Byte++;
+        for (int j = 0; j <= mem0.aByte_used[i]; j++)
+        {
+          if (mem0.aByte[i][j] == null)
+          {
+            mem0.aByte[i][j] = pPrior;
+            pPrior = null;
+            return;
+          }
+          if (mem0.aByte[i][j].Length < Smallest)
+          {
+            savej = j;
+            Smallest = mem0.aByte[i][j].Length;
+          }
+        }
+
+        if (mem0.aByte_used[i] < mem0.aByte[i].Length - 1) mem0.aByte[i][++mem0.aByte_used[i]] = pPrior;
+        else if (savej >= 0) mem0.aByte[i][savej] = pPrior;
+      }
+      pPrior = null;
+      return;
+    }
+    static void sqlite3MemFreeInt(ref int[] pPrior)
+    {
+      if (pPrior == null) return;
+      if (pPrior.Length >= 10)
+      {
+        int savei = -1;
+        int Smallest = int.MaxValue;
+#if DEBUG
+for (int i = 0; i < mem0.aInt.Length; i++) if (mem0.aInt[i] != null && mem0.aInt[i] == pPrior) Debugger.Break();
+#endif
+        mem0.mf_Int++;
+        for (int i = 0; i < mem0.aInt.Length; i++)
+        {
+          if (mem0.aInt[i] == null)
+          {
+            mem0.aInt[i] = pPrior;
+            pPrior = null;
+            return;
+          }
+          if (mem0.aInt[i].Length < Smallest)
+          {
+            savei = i;
+            Smallest = mem0.aInt[i].Length;
+          }
+        }
+        if (savei >= 0) mem0.aInt[savei] = pPrior;
+      }
+      pPrior = null;
+      return;
+    }
+#endif
+    static void sqlite3MemFreeMem(ref Mem pPrior)
+    {
+      if (pPrior == null) return;
+#if FALSE && DEBUG
+for (int i = mem0.msMem.next - 1; i >= 0; i--) if (mem0.aMem[i] != null && mem0.aMem[i] == pPrior) Debugger.Break();
+#endif
+      mem0.msMem.dealloc++;
+      if ( mem0.msMem.next < mem0.aMem.Length - 1 )
+        {
+          pPrior.db = null;
+          pPrior._SumCtx = null;
+          pPrior._MD5Context = null;
+          pPrior._SubProgram = null;
+          pPrior.flags = MEM_Null;
+          pPrior.r = 0;
+          pPrior.u.i = 0;
+          pPrior.n = 0;
+          if (pPrior.zBLOB != null) sqlite3MemFree(ref pPrior.zBLOB);
+          mem0.aMem[++mem0.msMem.next] = pPrior;
+          if ( mem0.msMem.next > mem0.msMem.max ) mem0.msMem.max = mem0.msMem.next;
+
+        }
+      //Array.Resize( ref mem0.aMem, (int)(mem0.hw_Mem * 1.5 + 1 ));
+      //mem0.aMem[mem0.hw_Mem] = pPrior;
+      //mem0.hw_Mem = mem0.aMem.Length;
+      pPrior = null;
+      return;
+    }
+    static void sqlite3MemFreeBtCursor( ref BtCursor pPrior )
+    {
+      if ( pPrior == null ) return;
+#if FALSE && DEBUG
+      for ( int i = mem0.msBtCursor.next - 1; i >= 0; i-- ) if ( mem0.aBtCursor[i] != null && mem0.aBtCursor[i] == pPrior ) Debugger.Break();
+#endif
+      mem0.msBtCursor.dealloc++;
+      if ( mem0.msBtCursor.next < mem0.aBtCursor.Length - 1 )
+      {
+        mem0.aBtCursor[++mem0.msBtCursor.next] = pPrior;
+        if ( mem0.msBtCursor.next > mem0.msBtCursor.max ) mem0.msBtCursor.max = mem0.msBtCursor.next;
+      }
+      //Array.Resize( ref mem0.aBtCursor, (int)(mem0.hw_BtCursor * 1.5 + 1 ));
+      //mem0.aBtCursor[mem0.hw_BtCursor] = pPrior;
+      //mem0.hw_BtCursor = mem0.aBtCursor.Length;
+      pPrior = null;
+      return;
+    }
+    /*
+    ** Like realloc().  Resize an allocation previously obtained from
+    ** sqlite3MemMalloc().
+    **
+    ** For this low-level interface, we know that pPrior!=0.  Cases where
+    ** pPrior==0 while have been intercepted by higher-level routine and
+    ** redirected to xMalloc.  Similarly, we know that nByte>0 becauses
+    ** cases where nByte<=0 will have been intercepted by higher-level
+    ** routines and redirected to xFree.
+    */
+    static byte[] sqlite3MemRealloc(ref byte[] pPrior, int nByte)
+    {
+      //  sqlite3_int64 p = (sqlite3_int64*)pPrior;
+      //  Debug.Assert(pPrior!=0 && nByte>0 );
+      //  nByte = ROUND8( nByte );
+      //  p = (sqlite3_int64*)pPrior;
+      //  p--;
+      //  p = realloc(p, nByte+8 );
+      //  if( p ){
+      //    p[0] = nByte;
+      //    p++;
+      //  }
+      //  return (void*)p;
+      Array.Resize(ref pPrior, nByte);
+      return pPrior;
+    }
+#else
+    /*
+** No-op versions of all memory allocation routines
+*/
+static byte[] sqlite3MemMalloc(int nByte) { return new byte[nByte]; }
+static int[] sqlite3MemMallocInt(int nInt) { return new int[nInt]; }
+static Mem sqlite3MemMallocMem( Mem pMem) { return new Mem(); }
+static void sqlite3MemFree( ref byte[] pPrior ) { pPrior = null; }
+static void sqlite3MemFreeInt( ref int[] pPrior ) { pPrior = null; }
+static void sqlite3MemFreeMem(ref Mem pPrior) { pPrior = null; }
+static int sqlite3MemInit() { return SQLITE_OK; }
+static void sqlite3MemShutdown() { }
+static BtCursor sqlite3MemMallocBtCursor( BtCursor dummy ){return new BtCursor();}
+static void sqlite3MemFreeBtCursor(ref BtCursor pPrior) { pPrior = null; }
+#endif
+
+    static byte[] sqlite3MemRealloc(byte[] pPrior, int nByte) { Array.Resize(ref pPrior, nByte); return pPrior; }
+
+    /*
+    ** Report the allocated size of a prior return from xMalloc()
+    ** or xRealloc().
+    */
+    static int sqlite3MemSize(byte[] pPrior)
+    {
+      //  sqlite3_int64 p;
+      //  if( pPrior==0 ) return 0;
+      //  p = (sqlite3_int64*)pPrior;
+      //  p--;
+      //  return p[0];
+      return (int)pPrior.Length;
+    }
+
+    /*
+    ** Round up a request size to the next valid allocation size.
+    */
+    static int sqlite3MemRoundup(int n)
+    {
+      return ROUND8(n);
+    }
+
+    /*
+    ** Initialize this module.
+    */
+    static int sqlite3MemInit(object NotUsed)
+    {
+      UNUSED_PARAMETER(NotUsed);
+      if (!sqlite3GlobalConfig.bMemstat)
+      {
+        /* If memory status is enabled, then the malloc.c wrapper will already
+        ** hold the STATIC_MEM mutex when the routines here are invoked. */
+        mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
+      }
+      return SQLITE_OK;
+    }
+
+    /*
+    ** Deinitialize this module.
+    */
+    static void sqlite3MemShutdown(object NotUsed)
+    {
+
+      UNUSED_PARAMETER(NotUsed);
+      return;
+    }
+
+    /*
+    ** This routine is the only routine in this file with external linkage.
+    **
+    ** Populate the low-level memory allocation function pointers in
+    ** sqlite3GlobalConfig.m with pointers to the routines in this file.
+    */
+    static void sqlite3MemSetDefault()
+    {
+      sqlite3_mem_methods defaultMethods = new sqlite3_mem_methods(
+      sqlite3MemMalloc,
+      sqlite3MemMallocInt,
+      sqlite3MemMallocMem,
+      sqlite3MemFree,
+      sqlite3MemFreeInt,
+      sqlite3MemFreeMem,
+      sqlite3MemRealloc,
+      sqlite3MemSize,
+      sqlite3MemRoundup,
+      (dxMemInit)sqlite3MemInit,
+      (dxMemShutdown)sqlite3MemShutdown,
+      0
+      );
+      sqlite3_config(SQLITE_CONFIG_MALLOC, defaultMethods);
+    }
+
+    static void sqlite3DbFree(sqlite3 db, ref int[] pPrior) { if (pPrior != null)sqlite3MemFreeInt(ref pPrior); }
+    static void sqlite3DbFree(sqlite3 db, ref Mem pPrior) { if (pPrior != null)sqlite3MemFreeMem(ref pPrior); }
+    static void sqlite3DbFree(sqlite3 db, ref Mem[] pPrior) { if (pPrior != null) for (int i = 0; i < pPrior.Length; i++)sqlite3MemFreeMem(ref pPrior[i]); }
+    static void sqlite3DbFree<T>(sqlite3 db, ref T pT) where T : class { }
+    static void sqlite3DbFree(sqlite3 db, ref string pString) { }
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/memjournal_c.cs

@@ -0,0 +1,315 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+
+using Bitmask = System.UInt64;
+using u8 = System.Byte;
+using u16 = System.UInt16;
+using u32 = System.UInt32;
+
+namespace Community.CsharpSqlite
+{
+  using sqlite3_int64 = System.Int64;
+  using MemJournal = Sqlite3.sqlite3_file;
+
+  public partial class Sqlite3
+  {
+    /*
+    ** 2007 August 22
+    **
+    ** 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 contains code use to implement an in-memory rollback journal.
+    ** The in-memory rollback journal is used to journal transactions for
+    ** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
+    *************************************************************************
+    **  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: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header: Community.CsharpSqlite/src/memjournal_c.cs,v bcbd36f24b23 2010/02/18 17:35:24 Noah $
+    *************************************************************************
+    */
+
+    //#include "sqliteInt.h"
+
+    /* Forward references to internal structures */
+    //typedef struct MemJournal MemJournal;
+    //typedef struct FilePoint FilePoint;
+    //typedef struct FileChunk FileChunk;
+
+    /* Space to hold the rollback journal is allocated in increments of
+    ** this many bytes.
+    **
+    ** The size chosen is a little less than a power of two.  That way,
+    ** the FileChunk object will have a size that almost exactly fills
+    ** a power-of-two allocation.  This mimimizes wasted space in power-of-two
+    ** memory allocators.
+    */
+    //#define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
+    const int JOURNAL_CHUNKSIZE = 4096;
+
+    /* Macro to find the minimum of two numeric values.
+    */
+    //#if ! MIN
+    //# define MIN(x,y) ((x)<(y)?(x):(y))
+    //#endif
+    static int MIN( int x, int y ) { return ( x < y ) ? x : y; }
+    static int MIN( int x, u32 y ) { return ( x < y ) ? x : (int)y; }
+
+    /*
+    ** The rollback journal is composed of a linked list of these structures.
+    */
+    public class FileChunk
+    {
+      public FileChunk pNext;                             /* Next chunk in the journal */
+      public byte[] zChunk = new byte[JOURNAL_CHUNKSIZE]; /* Content of this chunk */
+    };
+
+    /*
+    ** An instance of this object serves as a cursor into the rollback journal.
+    ** The cursor can be either for reading or writing.
+    */
+    public class FilePoint
+    {
+      public int iOffset;           /* Offset from the beginning of the file */
+      public FileChunk pChunk;      /* Specific chunk into which cursor points */
+    };
+
+    /*
+    ** This subclass is a subclass of sqlite3_file.  Each open memory-journal
+    ** is an instance of this class.
+    */
+    public partial class sqlite3_file
+    {
+      //public sqlite3_io_methods pMethods; /* Parent class. MUST BE FIRST */
+      public FileChunk pFirst;              /* Head of in-memory chunk-list */
+      public FilePoint endpoint;            /* Pointer to the end of the file */
+      public FilePoint readpoint;           /* Pointer to the end of the last xRead() */
+    };
+
+    /*
+    ** Read data from the in-memory journal file.  This is the implementation
+    ** of the sqlite3_vfs.xRead method.
+    */
+    static int memjrnlRead(
+    sqlite3_file pJfd,     /* The journal file from which to read */
+    byte[] zBuf,           /* Put the results here */
+    int iAmt,              /* Number of bytes to read */
+    sqlite3_int64 iOfst    /* Begin reading at this offset */
+    )
+    {
+      MemJournal p = (MemJournal)pJfd;
+      byte[] zOut = zBuf;
+      int nRead = iAmt;
+      int iChunkOffset;
+      FileChunk pChunk;
+
+      /* SQLite never tries to read past the end of a rollback journal file */
+      Debug.Assert( iOfst + iAmt <= p.endpoint.iOffset );
+
+      if ( p.readpoint.iOffset != iOfst || iOfst == 0 )
+      {
+        int iOff = 0;
+        for ( pChunk = p.pFirst;
+        ALWAYS( pChunk != null ) && ( iOff + JOURNAL_CHUNKSIZE ) <= iOfst;
+        pChunk = pChunk.pNext
+        )
+        {
+          iOff += JOURNAL_CHUNKSIZE;
+        }
+      }
+      else
+      {
+        pChunk = p.readpoint.pChunk;
+      }
+
+      iChunkOffset = (int)( iOfst % JOURNAL_CHUNKSIZE );
+      int izOut = 0;
+      do
+      {
+        int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset;
+        int nCopy = MIN( nRead, ( JOURNAL_CHUNKSIZE - iChunkOffset ) );
+        Buffer.BlockCopy( pChunk.zChunk, iChunkOffset, zOut, izOut, nCopy ); //memcpy( zOut, pChunk.zChunk[iChunkOffset], nCopy );
+        izOut += nCopy;// zOut += nCopy;
+        nRead -= iSpace;
+        iChunkOffset = 0;
+      } while ( nRead >= 0 && ( pChunk = pChunk.pNext ) != null && nRead > 0 );
+      p.readpoint.iOffset = (int)( iOfst + iAmt );
+      p.readpoint.pChunk = pChunk;
+
+      return SQLITE_OK;
+    }
+
+    /*
+    ** Write data to the file.
+    */
+    static int memjrnlWrite(
+    sqlite3_file pJfd,    /* The journal file into which to write */
+    byte[] zBuf,          /* Take data to be written from here */
+    int iAmt,             /* Number of bytes to write */
+    sqlite3_int64 iOfst   /* Begin writing at this offset into the file */
+    )
+    {
+      MemJournal p = (MemJournal)pJfd;
+      int nWrite = iAmt;
+      byte[] zWrite = zBuf;
+      int izWrite = 0;
+
+      /* An in-memory journal file should only ever be appended to. Random
+      ** access writes are not required by sqlite.
+      */
+      Debug.Assert( iOfst == p.endpoint.iOffset );
+      UNUSED_PARAMETER( iOfst );
+
+      while ( nWrite > 0 )
+      {
+        FileChunk pChunk = p.endpoint.pChunk;
+        int iChunkOffset = (int)( p.endpoint.iOffset % JOURNAL_CHUNKSIZE );
+        int iSpace = MIN( nWrite, JOURNAL_CHUNKSIZE - iChunkOffset );
+
+        if ( iChunkOffset == 0 )
+        {
+          /* New chunk is required to extend the file. */
+          FileChunk pNew = new FileChunk();// sqlite3_malloc( sizeof( FileChunk ) );
+          if ( null == pNew )
+          {
+            return SQLITE_IOERR_NOMEM;
+          }
+          pNew.pNext = null;
+          if ( pChunk != null )
+          {
+            Debug.Assert( p.pFirst != null );
+            pChunk.pNext = pNew;
+          }
+          else
+          {
+            Debug.Assert( null == p.pFirst );
+            p.pFirst = pNew;
+          }
+          p.endpoint.pChunk = pNew;
+        }
+
+        Buffer.BlockCopy( zWrite, izWrite, p.endpoint.pChunk.zChunk, iChunkOffset, iSpace ); //memcpy( &p.endpoint.pChunk.zChunk[iChunkOffset], zWrite, iSpace );
+        izWrite += iSpace;//zWrite += iSpace;
+        nWrite -= iSpace;
+        p.endpoint.iOffset += iSpace;
+      }
+
+      return SQLITE_OK;
+    }
+
+    /*
+    ** Truncate the file.
+    */
+    static int memjrnlTruncate( sqlite3_file pJfd, sqlite3_int64 size )
+    {
+      MemJournal p = (MemJournal)pJfd;
+      FileChunk pChunk;
+      Debug.Assert( size == 0 );
+      UNUSED_PARAMETER( size );
+      pChunk = p.pFirst;
+      while ( pChunk != null )
+      {
+        FileChunk pTmp = pChunk;
+        pChunk = pChunk.pNext;
+        //sqlite3_free( ref pTmp );
+      }
+      sqlite3MemJournalOpen( pJfd );
+      return SQLITE_OK;
+    }
+
+    /*
+    ** Close the file.
+    */
+    static int memjrnlClose( MemJournal pJfd )
+    {
+      memjrnlTruncate( pJfd, 0 );
+      return SQLITE_OK;
+    }
+
+
+    /*
+    ** Sync the file.
+    **
+    ** Syncing an in-memory journal is a no-op.  And, in fact, this routine
+    ** is never called in a working implementation.  This implementation
+    ** exists purely as a contingency, in case some malfunction in some other
+    ** part of SQLite causes Sync to be called by mistake.
+    */
+    static int memjrnlSync( sqlite3_file NotUsed, int NotUsed2 )
+    {   /*NO_TEST*/
+      UNUSED_PARAMETER2( NotUsed, NotUsed2 );                      /*NO_TEST*/
+      Debug.Assert( false );                                       /*NO_TEST*/
+      return SQLITE_OK;                                            /*NO_TEST*/
+    }                                                              /*NO_TEST*/
+
+    /*
+    ** Query the size of the file in bytes.
+    */
+    static int memjrnlFileSize( sqlite3_file pJfd, ref int pSize )
+    {
+      MemJournal p = (MemJournal)pJfd;
+      pSize = p.endpoint.iOffset;
+      return SQLITE_OK;
+    }
+
+    /*
+    ** Table of methods for MemJournal sqlite3_file object.
+    */
+    static sqlite3_io_methods MemJournalMethods = new sqlite3_io_methods(
+    1,                /* iVersion */
+    (dxClose)memjrnlClose,       /* xClose */
+    (dxRead)memjrnlRead,         /* xRead */
+    (dxWrite)memjrnlWrite,       /* xWrite */
+    (dxTruncate)memjrnlTruncate, /* xTruncate */
+    (dxSync)memjrnlSync,         /* xSync */
+    (dxFileSize)memjrnlFileSize, /* xFileSize */
+    null,                        /* xLock */
+    null,                        /* xUnlock */
+    null,                        /* xCheckReservedLock */
+    null,                        /* xFileControl */
+    null,                        /* xSectorSize */
+    null                         /* xDeviceCharacteristics */
+    );
+
+    /*
+    ** Open a journal file.
+    */
+    static void sqlite3MemJournalOpen( sqlite3_file pJfd )
+    {
+      MemJournal p = (MemJournal)pJfd;
+      //memset( p, 0, sqlite3MemJournalSize() );
+      p.pFirst = null;
+      p.endpoint = new FilePoint();
+      p.readpoint = new FilePoint();
+      p.pMethods = MemJournalMethods;
+    }
+
+    /*
+    ** Return true if the file-handle passed as an argument is
+    ** an in-memory journal
+    */
+    static bool sqlite3IsMemJournal( sqlite3_file pJfd )
+    {
+      return pJfd.pMethods == MemJournalMethods;
+    }
+
+    /*
+    ** Return the number of bytes required to store a MemJournal that uses vfs
+    ** pVfs to create the underlying on-disk files.
+    */
+    static int sqlite3MemJournalSize()
+    {
+      return 3096; // sizeof( MemJournal );
+    }
+  }
+}