rhodes 2.3.2 → 2.4.0.beta.1

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

@@ -0,0 +1,344 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2007 August 14
+    **
+    ** 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 the C functions that implement mutexes for win32
+    *************************************************************************
+    **  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: 2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+
+    /*
+    ** The code in this file is only used if we are compiling multithreaded
+    ** on a win32 system.
+    */
+#if SQLITE_MUTEX_W32
+
+
+/*
+** Each recursive mutex is an instance of the following structure.
+*/
+struct sqlite3_mutex {
+  CRITICAL_SECTION mutex;    /* Mutex controlling the lock */
+  int id;                    /* Mutex type */
+  int nRef;                  /* Number of enterances */
+  DWORD owner;               /* Thread holding this mutex */
+#if SQLITE_DEBUG
+  int trace;                 /* True to trace changes */
+#endif
+};
+//#define SQLITE_W32_MUTEX_INITIALIZER { 0 }
+#if SQLITE_DEBUG
+//#define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, 0L, (DWORD)0, 0 }
+#else
+//#define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, 0L, (DWORD)0 }
+#endif
+
+/*
+** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
+** or WinCE.  Return false (zero) for Win95, Win98, or WinME.
+**
+** Here is an interesting observation:  Win95, Win98, and WinME lack
+** the LockFileEx() API.  But we can still statically link against that
+** API as long as we don't call it win running Win95/98/ME.  A call to
+** this routine is used to determine if the host is Win95/98/ME or
+** WinNT/2K/XP so that we will know whether or not we can safely call
+** the LockFileEx() API.
+**
+** mutexIsNT() is only used for the TryEnterCriticalSection() API call,
+** which is only available if your application was compiled with
+** _WIN32_WINNT defined to a value >= 0x0400.  Currently, the only
+** call to TryEnterCriticalSection() is #ifdef'ed out, so #if
+** this out as well.
+*/
+#if FALSE
+#if SQLITE_OS_WINCE
+//# define mutexIsNT()  (1)
+#else
+static int mutexIsNT(void){
+static int osType = 0;
+if( osType==0 ){
+OSVERSIONINFO sInfo;
+sInfo.dwOSVersionInfoSize = sizeof(sInfo);
+GetVersionEx(&sInfo);
+osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
+}
+return osType==2;
+}
+#endif //* SQLITE_OS_WINCE */
+#endif
+
+#if SQLITE_DEBUG
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use only inside Debug.Assert() statements.
+*/
+static int winMutexHeld(sqlite3_mutex p){
+return p.nRef!=0 && p.owner==GetCurrentThreadId();
+}
+static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){
+  return p->nRef==0 || p->owner!=tid;
+}
+static int winMutexNotheld(sqlite3_mutex *p){
+  DWORD tid = GetCurrentThreadId(); 
+  return winMutexNotheld2(p, tid);
+}
+#endif
+
+
+/*
+** Initialize and deinitialize the mutex subsystem.
+*/
+static sqlite3_mutex winMutex_staticMutexes[6] = {
+  SQLITE3_MUTEX_INITIALIZER,
+  SQLITE3_MUTEX_INITIALIZER,
+  SQLITE3_MUTEX_INITIALIZER,
+  SQLITE3_MUTEX_INITIALIZER,
+  SQLITE3_MUTEX_INITIALIZER,
+  SQLITE3_MUTEX_INITIALIZER
+};
+static int winMutex_isInit = 0;
+/* As winMutexInit() and winMutexEnd() are called as part
+** of the sqlite3_initialize and sqlite3_shutdown()
+** processing, the "interlocked" magic is probably not
+** strictly necessary.
+*/
+static long winMutex_lock = 0;
+
+static int winMutexInit(void){
+/* The first to increment to 1 does actual initialization */
+if( InterlockedCompareExchange(winMutex_lock, 1, 0)==0 ){
+int i;
+for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
+InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
+}
+winMutex_isInit = 1;
+}else{
+/* Someone else is in the process of initing the static mutexes */
+while( !winMutex_isInit ){
+Sleep(1);
+}
+}
+return SQLITE_OK;
+}
+
+static int winMutexEnd(void){
+/* The first to decrement to 0 does actual shutdown
+** (which should be the last to shutdown.) */
+if( InterlockedCompareExchange(winMutex_lock, 0, 1)==1 ){
+if( winMutex_isInit==1 ){
+int i;
+for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
+DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
+}
+winMutex_isInit = 0;
+}
+}
+return SQLITE_OK;
+}
+
+/*
+** The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it.  If it returns NULL
+** that means that a mutex could not be allocated.  SQLite
+** will unwind its stack and return an error.  The argument
+** to sqlite3_mutex_alloc() is one of these integer constants:
+**
+** <ul>
+** <li>  SQLITE_MUTEX_FAST
+** <li>  SQLITE_MUTEX_RECURSIVE
+** <li>  SQLITE_MUTEX_STATIC_MASTER
+** <li>  SQLITE_MUTEX_STATIC_MEM
+** <li>  SQLITE_MUTEX_STATIC_MEM2
+** <li>  SQLITE_MUTEX_STATIC_PRNG
+** <li>  SQLITE_MUTEX_STATIC_LRU
+** <li>  SQLITE_MUTEX_STATIC_LRU2
+** </ul>
+**
+** The first two constants cause sqlite3_mutex_alloc() to create
+** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
+** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
+** The mutex implementation does not need to make a distinction
+** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
+** not want to.  But SQLite will only request a recursive mutex in
+** cases where it really needs one.  If a faster non-recursive mutex
+** implementation is available on the host platform, the mutex subsystem
+** might return such a mutex in response to SQLITE_MUTEX_FAST.
+**
+** The other allowed parameters to sqlite3_mutex_alloc() each return
+** a pointer to a static preexisting mutex.  Six static mutexes are
+** used by the current version of SQLite.  Future versions of SQLite
+** may add additional static mutexes.  Static mutexes are for internal
+** use by SQLite only.  Applications that use SQLite mutexes should
+** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
+** SQLITE_MUTEX_RECURSIVE.
+**
+** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
+** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
+** returns a different mutex on every call.  But for the static
+** mutex types, the same mutex is returned on every call that has
+** the same type number.
+*/
+static sqlite3_mutex *winMutexAlloc(int iType){
+sqlite3_mutex p;
+
+switch( iType ){
+case SQLITE_MUTEX_FAST:
+case SQLITE_MUTEX_RECURSIVE: {
+p = sqlite3MallocZero( sizeof(*p) );
+if( p ){
+p.id = iType;
+InitializeCriticalSection(p.mutex);
+}
+break;
+}
+default: {
+Debug.Assert( winMutex_isInit==1 );
+Debug.Assert(iType-2 >= 0 );
+assert( iType-2 < ArraySize(winMutex_staticMutexes) );
+p = &winMutex_staticMutexes[iType-2];
+p.id = iType;
+break;
+}
+}
+return p;
+}
+
+
+/*
+** This routine deallocates a previously
+** allocated mutex.  SQLite is careful to deallocate every
+** mutex that it allocates.
+*/
+static void winMutexFree(sqlite3_mutex p){
+Debug.Assert(p );
+Debug.Assert(p.nRef==0 );
+Debug.Assert(p.id==SQLITE_MUTEX_FAST || p.id==SQLITE_MUTEX_RECURSIVE );
+DeleteCriticalSection(p.mutex);
+sqlite3DbFree(db,p);
+}
+
+/*
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex.  If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
+** be entered multiple times by the same thread.  In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  If the same thread tries to enter any other kind of mutex
+** more than once, the behavior is undefined.
+*/
+static void winMutexEnter(sqlite3_mutex p){
+  DWORD tid = GetCurrentThreadId(); 
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
+  EnterCriticalSection(&p->mutex);
+  p->owner = tid; 
+  p->nRef++;
+#if SQLITE_DEBUG
+  if( p->trace ){
+    printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
+  }
+#endif
+}
+static int winMutexTry(sqlite3_mutex *p){
+#if !NDEBUG
+  DWORD tid = GetCurrentThreadId(); 
+#endif
+int rc = SQLITE_BUSY;
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
+/*
+** The sqlite3_mutex_try() routine is very rarely used, and when it
+** is used it is merely an optimization.  So it is OK for it to always
+** fail.
+**
+** The TryEnterCriticalSection() interface is only available on WinNT.
+** And some windows compilers complain if you try to use it without
+** first doing some #defines that prevent SQLite from building on Win98.
+** For that reason, we will omit this optimization for now.  See
+** ticket #2685.
+*/
+#if FALSE
+if( mutexIsNT() && TryEnterCriticalSection(p.mutex) ){
+p.owner = tid;
+p.nRef++;
+rc = SQLITE_OK;
+}
+#else
+UNUSED_PARAMETER(p);
+#endif
+#if SQLITE_DEBUG
+  if( rc==SQLITE_OK && p->trace ){
+    printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
+  }
+#endif
+return rc;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  The behavior
+** is undefined if the mutex is not currently entered or
+** is not currently allocated.  SQLite will never do either.
+*/
+static void winMutexLeave(sqlite3_mutex p){
+#if !NDEBUG
+  DWORD tid = GetCurrentThreadId();
+#endif
+    Debug.Assert(p.nRef>0 );
+Debug.Assert(p.owner==tid );
+p.nRef--;
+Debug.Assert(p.nRef==0 || p.id==SQLITE_MUTEX_RECURSIVE );
+LeaveCriticalSection(p.mutex);
+#if SQLITE_DEBUG
+  if( p->trace ){
+    printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
+  }
+#endif
+}
+
+sqlite3_mutex_methods *sqlite3DefaultMutex(void){
+static sqlite3_mutex_methods sMutex = {
+winMutexInit,
+winMutexEnd,
+winMutexAlloc,
+winMutexFree,
+winMutexEnter,
+winMutexTry,
+winMutexLeave,
+#if SQLITE_DEBUG
+winMutexHeld,
+winMutexNotheld
+#else
+null,
+null
+#endif
+};
+
+return &sMutex;
+}
+#endif // * SQLITE_MUTEX_W32 */
+  }
+}
+

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

@@ -0,0 +1,347 @@
+using System.Diagnostics;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2009 March 3
+    **
+    ** 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 the implementation of the sqlite3_unlock_notify()
+    ** API method and its associated 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: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+    //#include "btreeInt.h"
+
+    /* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */
+#if SQLITE_ENABLE_UNLOCK_NOTIFY
+
+/*
+** Public interfaces:
+**
+**   sqlite3ConnectionBlocked()
+**   sqlite3ConnectionUnlocked()
+**   sqlite3ConnectionClosed()
+**   sqlite3_unlock_notify()
+*/
+
+//#define assertMutexHeld() \
+assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) )
+
+/*
+** Head of a linked list of all sqlite3 objects created by this process
+** for which either sqlite3.pBlockingConnection or sqlite3.pUnlockConnection
+** is not NULL. This variable may only accessed while the STATIC_MASTER
+** mutex is held.
+*/
+static sqlite3 *SQLITE_WSD sqlite3BlockedList = 0;
+
+#if !NDEBUG
+/*
+** This function is a complex assert() that verifies the following
+** properties of the blocked connections list:
+**
+**   1) Each entry in the list has a non-NULL value for either
+**      pUnlockConnection or pBlockingConnection, or both.
+**
+**   2) All entries in the list that share a common value for
+**      xUnlockNotify are grouped together.
+**
+**   3) If the argument db is not NULL, then none of the entries in the
+**      blocked connections list have pUnlockConnection or pBlockingConnection
+**      set to db. This is used when closing connection db.
+*/
+static void checkListProperties(sqlite3 *db){
+sqlite3 *p;
+for(p=sqlite3BlockedList; p; p=p->pNextBlocked){
+int seen = 0;
+sqlite3 *p2;
+
+/* Verify property (1) */
+assert( p->pUnlockConnection || p->pBlockingConnection );
+
+/* Verify property (2) */
+for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){
+if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
+assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
+assert( db==0 || p->pUnlockConnection!=db );
+assert( db==0 || p->pBlockingConnection!=db );
+}
+}
+}
+#else
+//# define checkListProperties(x)
+#endif
+
+/*
+** Remove connection db from the blocked connections list. If connection
+** db is not currently a part of the list, this function is a no-op.
+*/
+static void removeFromBlockedList(sqlite3 *db){
+sqlite3 **pp;
+assertMutexHeld();
+for(pp=&sqlite3BlockedList; *pp; pp = &(*pp)->pNextBlocked){
+if( *pp==db ){
+*pp = (*pp)->pNextBlocked;
+break;
+}
+}
+}
+
+/*
+** Add connection db to the blocked connections list. It is assumed
+** that it is not already a part of the list.
+*/
+static void addToBlockedList(sqlite3 *db){
+sqlite3 **pp;
+assertMutexHeld();
+for(
+pp=&sqlite3BlockedList;
+*pp && (*pp)->xUnlockNotify!=db->xUnlockNotify;
+pp=&(*pp)->pNextBlocked
+);
+db->pNextBlocked = *pp;
+*pp = db;
+}
+
+/*
+** Obtain the STATIC_MASTER mutex.
+*/
+static void enterMutex(){
+sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
+checkListProperties(0);
+}
+
+/*
+** Release the STATIC_MASTER mutex.
+*/
+static void leaveMutex(){
+assertMutexHeld();
+checkListProperties(0);
+sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
+}
+
+/*
+** Register an unlock-notify callback.
+**
+** This is called after connection "db" has attempted some operation
+** but has received an SQLITE_LOCKED error because another connection
+** (call it pOther) in the same process was busy using the same shared
+** cache.  pOther is found by looking at db->pBlockingConnection.
+**
+** If there is no blocking connection, the callback is invoked immediately,
+** before this routine returns.
+**
+** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
+** a deadlock.
+**
+** Otherwise, make arrangements to invoke xNotify when pOther drops
+** its locks.
+**
+** Each call to this routine overrides any prior callbacks registered
+** on the same "db".  If xNotify==0 then any prior callbacks are immediately
+** cancelled.
+*/
+int sqlite3_unlock_notify(
+sqlite3 *db,
+void (*xNotify)(void **, int),
+void *pArg
+){
+int rc = SQLITE_OK;
+
+sqlite3_mutex_enter(db->mutex);
+enterMutex();
+
+if( xNotify==0 ){
+removeFromBlockedList(db);
+db->pUnlockConnection = 0;
+db->xUnlockNotify = 0;
+db->pUnlockArg = 0;
+}else if( 0==db->pBlockingConnection ){
+/* The blocking transaction has been concluded. Or there never was a
+** blocking transaction. In either case, invoke the notify callback
+** immediately.
+*/
+xNotify(&pArg, 1);
+}else{
+sqlite3 *p;
+
+for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){}
+if( p ){
+rc = SQLITE_LOCKED;              /* Deadlock detected. */
+}else{
+db->pUnlockConnection = db->pBlockingConnection;
+db->xUnlockNotify = xNotify;
+db->pUnlockArg = pArg;
+removeFromBlockedList(db);
+addToBlockedList(db);
+}
+}
+
+leaveMutex();
+assert( !db->mallocFailed );
+sqlite3Error(db, rc, (rc?"database is deadlocked":0));
+sqlite3_mutex_leave(db->mutex);
+return rc;
+}
+
+/*
+** This function is called while stepping or preparing a statement
+** associated with connection db. The operation will return SQLITE_LOCKED
+** to the user because it requires a lock that will not be available
+** until connection pBlocker concludes its current transaction.
+*/
+void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){
+enterMutex();
+if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){
+addToBlockedList(db);
+}
+db->pBlockingConnection = pBlocker;
+leaveMutex();
+}
+
+/*
+** This function is called when
+** the transaction opened by database db has just finished. Locks held
+** by database connection db have been released.
+**
+** This function loops through each entry in the blocked connections
+** list and does the following:
+**
+**   1) If the sqlite3.pBlockingConnection member of a list entry is
+**      set to db, then set pBlockingConnection=0.
+**
+**   2) If the sqlite3.pUnlockConnection member of a list entry is
+**      set to db, then invoke the configured unlock-notify callback and
+**      set pUnlockConnection=0.
+**
+**   3) If the two steps above mean that pBlockingConnection==0 and
+**      pUnlockConnection==0, remove the entry from the blocked connections
+**      list.
+*/
+void sqlite3ConnectionUnlocked(sqlite3 *db){
+void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */
+int nArg = 0;                            /* Number of entries in aArg[] */
+sqlite3 **pp;                            /* Iterator variable */
+void **aArg;               /* Arguments to the unlock callback */
+void **aDyn = 0;           /* Dynamically allocated space for aArg[] */
+void *aStatic[16];         /* Starter space for aArg[].  No malloc required */
+
+aArg = aStatic;
+enterMutex();         /* Enter STATIC_MASTER mutex */
+
+/* This loop runs once for each entry in the blocked-connections list. */
+for(pp=&sqlite3BlockedList; *pp; /* no-op */ ){
+sqlite3 *p = *pp;
+
+/* Step 1. */
+if( p->pBlockingConnection==db ){
+p->pBlockingConnection = 0;
+}
+
+/* Step 2. */
+if( p->pUnlockConnection==db ){
+assert( p->xUnlockNotify );
+if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){
+xUnlockNotify(aArg, nArg);
+nArg = 0;
+}
+
+sqlite3BeginBenignMalloc();
+assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
+assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
+if( (!aDyn && nArg==(int)ArraySize(aStatic))
+|| (aDyn && nArg==(int)(sqlite3DbMallocSize(db, aDyn)/sizeof(void*)))
+){
+/* The aArg[] array needs to grow. */
+void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
+if( pNew ){
+memcpy(pNew, aArg, nArg*sizeof(void *));
+//sqlite3_free(aDyn);
+aDyn = aArg = pNew;
+}else{
+/* This occurs when the array of context pointers that need to
+** be passed to the unlock-notify callback is larger than the
+** aStatic[] array allocated on the stack and the attempt to
+** allocate a larger array from the heap has failed.
+**
+** This is a difficult situation to handle. Returning an error
+** code to the caller is insufficient, as even if an error code
+** is returned the transaction on connection db will still be
+** closed and the unlock-notify callbacks on blocked connections
+** will go unissued. This might cause the application to wait
+** indefinitely for an unlock-notify callback that will never
+** arrive.
+**
+** Instead, invoke the unlock-notify callback with the context
+** array already accumulated. We can then clear the array and
+** begin accumulating any further context pointers without
+** requiring any dynamic allocation. This is sub-optimal because
+** it means that instead of one callback with a large array of
+** context pointers the application will receive two or more
+** callbacks with smaller arrays of context pointers, which will
+** reduce the applications ability to prioritize multiple
+** connections. But it is the best that can be done under the
+** circumstances.
+*/
+xUnlockNotify(aArg, nArg);
+nArg = 0;
+}
+}
+sqlite3EndBenignMalloc();
+
+aArg[nArg++] = p->pUnlockArg;
+xUnlockNotify = p->xUnlockNotify;
+p->pUnlockConnection = 0;
+p->xUnlockNotify = 0;
+p->pUnlockArg = 0;
+}
+
+/* Step 3. */
+if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){
+/* Remove connection p from the blocked connections list. */
+*pp = p->pNextBlocked;
+p->pNextBlocked = 0;
+}else{
+pp = &p->pNextBlocked;
+}
+}
+
+if( nArg!=0 ){
+xUnlockNotify(aArg, nArg);
+}
+//sqlite3_free(aDyn);
+leaveMutex();         /* Leave STATIC_MASTER mutex */
+}
+
+/*
+** This is called when the database connection passed as an argument is
+** being closed. The connection is removed from the blocked list.
+*/
+void sqlite3ConnectionClosed(sqlite3 *db){
+sqlite3ConnectionUnlocked(db);
+enterMutex();
+removeFromBlockedList(db);
+checkListProperties(db);
+leaveMutex();
+}
+#endif
+  }
+}