System.Data.SQLite

<?xml version="1.0" encoding="UTF-8" ?>
<!--
 *
 * EagleShell.exe.config -
 *
 * Copyright (c) 2007-2010 by Joe Mistachkin.  All rights reserved.
 * Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: $
 *
-->

<?xml version="1.0" encoding="UTF-8" ?>
<!--
 *
 * EagleShell.exe.mda.config -
 *
 * Copyright (c) 2007-2010 by Joe Mistachkin.  All rights reserved.
 * Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: $
 *
-->

            #
            lappend ::env(EAGLELIBPATH) $dir2

            #
            # NOTE: Force Eagle to rebuild the auto-path list for the current
            #       interpreter right now.
            #
            object invoke Utility RefreshAutoPathList
            object invoke Utility RefreshAutoPathList true
          }

          #
          # NOTE: We are done, return success.
          #
          return true
        }

    // Therefore these functions have to be static, and have to be low-level.

    internal static string GetLastError(SQLiteConnectionHandle hdl, IntPtr db)
    {
        if ((hdl == null) || (db == IntPtr.Zero))
            return "null connection or database handle";

        lock (hdl)
        {
        if (hdl.IsClosed || hdl.IsInvalid)
            return "closed or invalid connection handle";
            if (hdl.IsClosed || hdl.IsInvalid)
                return "closed or invalid connection handle";

        lock (hdl)
        {
#if !SQLITE_STANDARD
            int len;
            return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
#else
            return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
#endif
        }

    /// </summary>
    /// <param name="fileName">The filename for a desired connection</param>
    /// <param name="maxPoolSize">The maximum size the connection pool for the filename can be</param>
    /// <param name="version">The pool version the returned connection will belong to</param>
    /// <returns>Returns NULL if no connections were available.  Even if none are, the poolversion will still be a valid pool version</returns>
    internal static SQLiteConnectionHandle Remove(string fileName, int maxPoolSize, out int version)
    {
        Queue<WeakReference> poolQueue;

        //
        // NOTE: This lock cannot be held while checking the queue for available
        //       connections because other methods of this class are called from
        //       the GC finalizer thread and we use the WaitForPendingFinalizers
        //       method (below).  Holding this lock while calling that method
        //       would therefore result in a deadlock.  This lock is held while
        //       a temporary copy of the queue is created.
        //
      lock (_connections)
      {
        Pool queue;
        lock (_connections)
        {
            Pool queue;

        // Default to the highest pool version
        version = _poolVersion;
            // Default to the highest pool version
            version = _poolVersion;

        // If we didn't find a pool for this file, create one even though it will be empty.
        // We have to do this here because otherwise calling ClearPool() on the file will not work for active connections
        // that have never seen the pool yet.
        if (_connections.TryGetValue(fileName, out queue) == false)
        {
          queue = new Pool(_poolVersion, maxPoolSize);
          _connections.Add(fileName, queue);
            // If we didn't find a pool for this file, create one even though it will be empty.
            // We have to do this here because otherwise calling ClearPool() on the file will not work for active connections
            // that have never seen the pool yet.
            if (_connections.TryGetValue(fileName, out queue) == false)
            {
                queue = new Pool(_poolVersion, maxPoolSize);
                _connections.Add(fileName, queue);

          return null;
        }
                return null;
            }

        // We found a pool for this file, so use its version number
        version = queue.PoolVersion;
        queue.MaxPoolSize = maxPoolSize;
            // We found a pool for this file, so use its version number
            version = queue.PoolVersion;
            queue.MaxPoolSize = maxPoolSize;

        ResizePool(queue, false);
            ResizePool(queue, false);

        // Try and get a pooled connection from the queue
        Queue<WeakReference> poolQueue = queue.Queue;
        if (poolQueue == null) return null;
            // Try and get a pooled connection from the queue
            poolQueue = new Queue<WeakReference>(queue.Queue);
            if (poolQueue == null) return null;
        }

        while (poolQueue.Count > 0)
        {
          WeakReference cnn = poolQueue.Dequeue();
          if (cnn == null) continue;
          SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
          if ((hdl != null) && !hdl.IsClosed && !hdl.IsInvalid)
          {
            Interlocked.Increment(ref _poolOpened);
            return hdl;
          }
          cnn.Target = null;
          GC.KeepAlive(hdl);
            WeakReference cnn = poolQueue.Dequeue();
            if (cnn == null) continue;
            SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;

            //
            // BUGFIX: For ticket [996d13cd87], step #1.  After this point,
            //         make sure that the finalizer for the connection handle
            //         just obtained from the queue cannot START running (i.e.
            //         it may still be pending but it will no longer start
            //         after this point).
            //
            GC.SuppressFinalize(hdl);

            try
            {
                //
                // BUGFIX: For ticket [996d13cd87], step #2.  Now, we must wait
                //         for all pending finalizers which have STARTED running
                //         and have not yet COMPLETED.  This must be done just
                //         in case the finalizer for the connection handle just
                //         obtained from the queue has STARTED running at some
                //         point before SuppressFinalize was called on it.
                //
                //         After this point, checking properties of the
                //         connection handle (e.g. IsClosed) should work
                //         reliably without having to worry that they will
                //         (due to the finalizer) change out from under us.
                //
                GC.WaitForPendingFinalizers();

                //
                // BUGFIX: For ticket [996d13cd87], step #3.  Next, verify that
                //         the connection handle is actually valid and [still?]
                //         not closed prior to actually returning it to our
                //         caller.
                //
                if ((hdl != null) && !hdl.IsClosed && !hdl.IsInvalid)
                {
                    Interlocked.Increment(ref _poolOpened);
                    return hdl;
                }
            }
            finally
            {
                //
                // BUGFIX: For ticket [996d13cd87], step #4.  Finally, we must
                //         re-register the connection handle for finalization
                //         now that we have a strong reference to it (i.e. the
                //         finalizer run at least until the connection is
                //         subsequently closed).
                //
                GC.ReRegisterForFinalize(hdl);
            }

#pragma warning disable 162
            GC.KeepAlive(hdl); /* NOTE: Unreachable code. */
#pragma warning restore 162
        }
        return null;
      }

        return null;
    }

    /// <summary>
    /// Clears out all pooled connections and rev's up the default pool version to force all old active objects
    /// not in the pool to get discarded rather than returned to their pools.
    /// </summary>
    internal static void ClearAllPools()

            WeakReference cnn = poolQueue.Dequeue();
            if (cnn == null) continue;
            SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
            if (hdl != null)
            {
              hdl.Dispose();
            }
            cnn.Target = null;
            GC.KeepAlive(hdl);
          }
          
          // Keep track of the highest revision so we can go one higher when we're finished
          if (_poolVersion <= pair.Value.PoolVersion)
            _poolVersion = pair.Value.PoolVersion + 1;
        }

            WeakReference cnn = poolQueue.Dequeue();
            if (cnn == null) continue;
            SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
            if (hdl != null)
            {
              hdl.Dispose();
            }
            cnn.Target = null;
            GC.KeepAlive(hdl);
          }
        }
      }
    }

    /// <summary>

        WeakReference cnn = poolQueue.Dequeue();
        if (cnn == null) continue;
        SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
        if (hdl != null)
        {
          hdl.Dispose();
        }
        cnn.Target = null;
        GC.KeepAlive(hdl);
      }
    }
  }
}

for {set i 1} {$i < 3} {incr i} {
  set pooling [expr {$i == 2 ? True : False}]

  runTest {test [appendArgs tkt-996d13cd87-1. $i] {SQLiteConnection stress} \
      -setup {
    set fileName [appendArgs tkt-996d13cd87-1. $i .db]

    if {[catch {
    object invoke -flags +NonPublic \
        System.Data.SQLite.SQLiteConnectionPool _poolOpened 0
        object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolOpened 0

    object invoke -flags +NonPublic \
        System.Data.SQLite.SQLiteConnectionPool _poolClosed 0
        object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolClosed 0
    }] == 0} then {
      set havePoolCounts true
    } else {
      set havePoolCounts false

      tputs $test_channel [appendArgs \
          "==== WARNING: connection pool counts are not available\n"]
    }
  } -body {
    set id [object invoke Interpreter.GetActive NextId]
    set dataSource [file join [getDatabaseDirectory] $fileName]

    set sql { \
      CREATE TABLE t1(x TEXT); \
      INSERT INTO t1 (x) VALUES(RANDOMBLOB(1000)); \

    }] true true true results errors System.Data.SQLite.dll]

    list $code $results \
        [expr {[info exists errors] ? $errors : ""}] \
        [expr {$code eq "Ok" ? [catch {
          object invoke _Dynamic${id}.Test${id} Main
        } result] : [set result ""]}] $result \
        [expr {$pooling ? [object invoke -flags +NonPublic \
        [expr {$havePoolCounts ? $pooling ? [object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolOpened] > 0 : \
            [object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolOpened] == 0}] \
        [expr {$pooling ? [object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolOpened] == 0} : \
            True] \
        [expr {$havePoolCounts ? $pooling ? [object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolClosed] > 0 : \
            [object invoke -flags +NonPublic \
            System.Data.SQLite.SQLiteConnectionPool _poolClosed] == 0}]
            System.Data.SQLite.SQLiteConnectionPool _poolClosed] == 0} : \
            True]
  } -cleanup {
    object invoke System.Data.SQLite.SQLiteConnection ClearAllPools
    object invoke GC GetTotalMemory true

    cleanupDb $fileName

    unset -nocomplain result results errors code sql dataSource id db fileName
    unset -nocomplain result results errors code sql dataSource id db \
        havePoolCounts fileName
  } -constraints {eagle monoBug28 command.sql compile.DATA\
SQLite System.Data.SQLite} -match regexp -result {^Ok\
System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \d+ True True$}}
}

###############################################################################

unset -nocomplain pooling i

###############################################################################

runSQLiteTestEpilogue
runTestEpilogue