System.Data.SQLite

                    }

                    if (reader != null)
                    {
                        reader._disposeCommand = true;

                        //
                        // HACK: Copy the statement list to our active reader,
                        //       after adding a reference to each one of the
                        //       valid statements.
                        //
                        if (_statementList != null)
                        {
                            foreach (SQLiteStatement statement in _statementList)
                            {
                                if (statement == null) continue;
                                statement.AddReference();
                            }

                            reader._statementList = _statementList;
                        }
                        else
                        {
                            reader._statementList = null;
                        }

                        _activeReader = null;
                        skippedDispose = true;
                        return;
                    }

                    Connection = null;

        }
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    private void DisposeStatements()
    {
        DisposeStatements(true, ref _statementList);
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    internal static void DisposeStatements(
        bool force,
        ref List<SQLiteStatement> statements
        )
    {
        if (statements == null) return;

        int x = statements.Count;

        for (int n = 0; n < x; n++)
        {
            SQLiteStatement stmt = statements[n];

            if (stmt == null) continue;

            if ((stmt.RemoveReference() <= 0) || force)
                stmt.Dispose();
        }

        statements = null;
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

          if (_statementList == null)
            _remainingText = _commandText;

          stmt = _cnn._sql.Prepare(_cnn, this, _remainingText, (_statementList == null) ? null : _statementList[_statementList.Count - 1], (uint)(_commandTimeout * 1000), ref _remainingText);

          if (stmt != null)
          {
            stmt.AddReference();
            stmt._command = this;

            if (_statementList == null)
              _statementList = new List<SQLiteStatement>();

            _statementList.Add(stmt);

            _parameterCollection.MapParameters(stmt);
            stmt.BindParameters();
          }
        }
        return stmt;
      }
      catch (Exception)
      {
        if (stmt != null)
        {
          if ((_statementList != null) && _statementList.Contains(stmt))
            _statementList.Remove(stmt);

          if (stmt.RemoveReference() <= 0)
            stmt.Dispose();
        }

        // If we threw an error compiling the statement, we cannot continue on so set the remaining text to null.
        _remainingText = null;

        throw;
      }
    }

    internal SQLiteStatement GetStatement(int index)
    {
      // Haven't built any statements yet
      if (_statementList == null) return BuildNextCommand();

      // If we're at the last built statement and want the next unbuilt statement, then build it
      if (index >= _statementList.Count)
      {
        if (String.IsNullOrEmpty(_remainingText) == false) return BuildNextCommand();
        else return null; // No more commands
      }

      SQLiteStatement stmt = _statementList[index];
      stmt.BindParameters();

            string text = _commandText;
            uint timeout = (uint)(_commandTimeout * 1000);
            SQLiteStatement previousStatement = null;

            while ((text != null) && (text.Length > 0))
            {
                currentStatement = sqlBase.Prepare(
                    connection, this, text, previousStatement,
                    timeout, ref text); /* throw */

                previousStatement = currentStatement;

                if (currentStatement != null)
                {
                    if (statements == null)
                        statements = new List<SQLiteStatement>();

    /// <summary>
    /// Internal constructor, initializes the datareader and sets up to begin executing statements
    /// </summary>
    /// <param name="cmd">The SQLiteCommand this data reader is for</param>
    /// <param name="behave">The expected behavior of the data reader</param>
    internal SQLiteDataReader(SQLiteCommand cmd, CommandBehavior behave)
    {
      ResetIterationState();

      _throwOnDisposed = true;
      _command = cmd;
      _version = _command.Connection._version;
      _baseSchemaName = _command.Connection._baseSchemaName;

      _commandBehavior = behave;



      RefreshFlags();

      SQLiteConnection connection = GetConnection(this);

      if (SQLiteConnection.CanOnChanged(connection, false))
      {
          SQLiteConnection.OnChanged(connection,
              new ConnectionEventArgs(SQLiteConnectionEventType.NewDataReader,
              null, null, _command, this, null, null, new object[] { behave }));
      }

      if (_command != null)
          NextResult();
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    #region Private Methods
    private void ResetIterationState()
    {
        _activeStatementIndex = -1;
        _activeStatement = null;

        _readingState = 0;
        _rowsAffected = -1;
        _fieldCount = 0;
        _stepCount = 0;

        _fieldIndexes = null;
        _fieldTypeArray = null;

        if (_keyInfo != null)
        {
            _keyInfo.Dispose();
            _keyInfo = null;
        }

        if (_command != null)
        {
            _command.ResetDataReader();
            _command = null;
        }
    }
    #endregion

    ///////////////////////////////////////////////////////////////////////////////////////////////

    #region IDisposable "Pattern" Members
    private bool disposed;
    private void CheckDisposed() /* throw */
    {

                if (disposing)
                {
                    ////////////////////////////////////
                    // dispose managed resources here...
                    ////////////////////////////////////

                    SQLiteCommand.DisposeStatements(
                        false, ref _statementList);
                }

                //////////////////////////////////////
                // release unmanaged resources here...
                //////////////////////////////////////

                //
                // NOTE: Fix for ticket [e1b2e0f769],
                //       do NOT throw exceptions while
                //       we are being disposed.
                //
                _throwOnDisposed = false;
            }
        }
        finally
        {
            base.Dispose(disposing);

/********************************************************
 * ADO.NET 2.0 Data Provider for SQLite Version 3.X
 * Written by Robert Simpson (robert@blackcastlesoft.com)
 *
 * Released to the public domain, use at your own risk!
 ********************************************************/

namespace System.Data.SQLite
{
  using System;
  using System.Globalization;
  using System.Threading;

  /// <summary>
  /// Represents a single SQL statement in SQLite.
  /// </summary>
  internal sealed class SQLiteStatement : IDisposable
  {
    /// <summary>

    /// <summary>
    /// The flags associated with the parent connection object.
    /// </summary>
    private SQLiteConnectionFlags _flags;

    private string[] _types;

    /// <summary>
    /// The reference count for this statement, which may be shared between
    /// a <see cref="SQLiteCommand" /> and a <see cref="SQLiteDataReader" />.
    /// </summary>
    private int _referenceCount;

    /// <summary>
    /// Initializes the statement and attempts to get all information about parameters in the statement
    /// </summary>
    /// <param name="sqlbase">The base SQLite object</param>
    /// <param name="flags">The flags associated with the parent connection object</param>
    /// <param name="stmt">The statement</param>
    /// <param name="strCommand">The command text for this statement</param>

            _unnamedParameters++;
          }
          _paramNames[x] = s;
          _paramValues[x] = null;
        }
      }
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    #region Reference Count Members
    internal int AddReference()
    {
        return Interlocked.Increment(ref _referenceCount);
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    internal int RemoveReference()
    {
        return Interlocked.Decrement(ref _referenceCount);
    }
    #endregion

    ///////////////////////////////////////////////////////////////////////////////////////////////

    #region IDisposable Members
    /// <summary>
    /// Disposes and finalizes the statement
    /// </summary>

  cleanupDb $fileName

  unset -nocomplain result db fileName
} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite} -result \
{1 {unknown error -- no pooled connection available}}}

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

runTest {test pool-2.1 {connection pool stress} -setup {
  set fileName pool-2.1.db
} -body {
  set fileName [file join [getTemporaryDirectory] $fileName]

  foreach usePooling [list True False] {
    foreach useDataReader [list True False] {
      object invoke -flags +NonPublic \
          System.Data.SQLite.SQLiteConnectionPool ClearAllPools

      for {set i 0} {$i < 100} {incr i} {
        setupDb $fileName "" "" "" "" \
            [appendArgs Pooling= $usePooling \;] false false

        sql execute $db {CREATE TABLE IF NOT EXISTS t1(x);}
        set transaction [sql transaction begin $db]

        for {set j 0} {$j < 10} {incr j} {
          sql execute $db {
            INSERT INTO t1(x) VALUES(RANDOMBLOB(1024));
          }
        }

        sql transaction commit $transaction

        if {$useDataReader} then {
          set dataReader [sql execute -execute reader -format \
              dataReader -alias $db {SELECT x FROM t1 ORDER BY x;}]

          for {set k 0} {$k < $i % 10} {incr k} {
            $dataReader Read
          }

          unset dataReader
        } else {
          sql execute -execute reader -format list $db \
              {SELECT hex(x) FROM t1 ORDER BY x;}
        }

        cleanupDb $fileName db true false false false false
      }
    }
  }

  list success
} -cleanup {
  catch {
    object invoke -flags +NonPublic \
        System.Data.SQLite.SQLiteConnectionPool ClearAllPools
  }

  catch {
    object invoke -flags +NonPublic \
        System.Data.SQLite.SQLiteConnectionPool TerminateAndReset \
        null
  }

  cleanupDb $fileName

  unset -nocomplain i j k usePooling useDataReader transaction dataReader
  unset -nocomplain db fileName
} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite} -match regexp -result {success}}

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

runSQLiteTestEpilogue
runTestEpilogue