System.Data.SQLite

    <div id="mainBody">
    <h1 class="heading">Version History</h1>
    <p><b>1.0.119.0 - May XX, 2024 <font color="red">(release scheduled)</font></b></p>
    <ul>
      <li>Updated to <a href="https://www.sqlite.org/releaselog/3_45_3.html">SQLite 3.45.3</a>.</li>
      <li>Update internal resource list of reserved SQL words.</li>
      <li>Avoid NullReferenceException from Path.Combine method when the PublishSingleFile property is enabled for a project. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/66a0d2716a">[66a0d2716a]</a>.</li>
      <li>Avoid setting up for the Changed event when it will not be fired. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/25cafb35e5">[25cafb35e5]</a>.</li>
      <li>Add the VfsName connection string property.</li>
      <li>Fix rarely seen NullReferenceException in the StaticWeakConnectionPool.Add method.</li>
      <li>Revise the calculation used to bind DateTime values. Fix for <a href="https://system.data.sqlite.org/index.html/info/bbddfeb773">[bbddfeb773]</a>.</li>
      <li>Fix support for unnamed parameters using the ?NNN syntax. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/76cb35b58d">[76cb35b58d]</a>.</li>
    </ul>
    <p><b>1.0.118.0 - June 10, 2023</b></p>
    <ul>

  Tests/data/wal.db
  Tests/function.eagle
  Tests/installer.eagle
  Tests/linq.eagle
  Tests/memory.eagle
  Tests/pool.eagle
  Tests/progress.eagle
  Tests/pst-25cafb35e5.eagle
  Tests/pst-4db2934c2e.eagle
  Tests/pst-76cb35b58d.eagle
  Tests/pst-eeaefb84ec.eagle
  Tests/pst-f4e718891d.eagle
  Tests/session.eagle
  Tests/speed.eagle
  Tests/stress.eagle

        if (db != IntPtr.Zero)
        {
            _sql = new SQLiteConnectionHandle(db, ownHandle);
            _fileName = fileName;
            _returnToFileName = fileName;

            if (SQLiteConnection.CanOnChanged(null))
            {
                SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                    SQLiteConnectionEventType.NewCriticalHandle, null,
                    null, null, null, _sql, fileName, new object[] {
                    typeof(SQLite3), fmt, kind, fmtString, db, fileName,
                    ownHandle }));
            }
        }
    }

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

    #region Query Diagnostics Support
    /// <summary>

#if INTEROP_VIRTUAL_TABLE
                  DisposeModules();
#endif

                  SQLiteConnectionPool.Add(_returnToFileName, _sql, _poolVersion);

                  if (SQLiteConnection.CanOnChanged(null))
                  {
                      SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                          SQLiteConnectionEventType.ClosedToPool, null, null,
                          null, null, _sql, _returnToFileName, new object[] {
                          typeof(SQLite3), !disposing, _returnToFileName, _poolVersion }));
                  }

#if !NET_COMPACT_20 && TRACE_CONNECTION
                  Trace.WriteLine(HelperMethods.StringFormat(
                      CultureInfo.CurrentCulture,
                      "Close (Pool) Success: {0}",
                      HandleToString()));
#endif

      _returnToFileName = strFilename;
      _flags = connectionFlags;

      if (usePool)
      {
        _sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);

        if (SQLiteConnection.CanOnChanged(null))
        {
            SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                SQLiteConnectionEventType.OpenedFromPool, null, null,
                null, null, _sql, strFilename, new object[] {
                typeof(SQLite3), strFilename, vfsName, connectionFlags,
                openFlags, maxPoolSize, usePool, _poolVersion }));
        }

#if !NET_COMPACT_20 && TRACE_CONNECTION
        Trace.WriteLine(HelperMethods.StringFormat(
            CultureInfo.CurrentCulture,
            "Open (Pool): {0}", HandleToString()));
#endif
      }

          if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, null);
          _sql = new SQLiteConnectionHandle(db, true);
          BumpCreateCount();
        }
        lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }

        if (SQLiteConnection.CanOnChanged(null))
        {
            SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                SQLiteConnectionEventType.NewCriticalHandle, null,
                null, null, null, _sql, strFilename, new object[] {
                typeof(SQLite3), strFilename, vfsName, connectionFlags,
                openFlags, maxPoolSize, usePool }));
        }
      }

      // Bind functions to this connection.  If any previous functions of the same name
      // were already bound, then the new bindings replace the old.
      if (!HelperMethods.HasFlags(connectionFlags, SQLiteConnectionFlags.NoBindFunctions))
      {
          if (_functions == null)

              if (statementHandle != null) statementHandle.Dispose();
              statementHandle = new SQLiteStatementHandle(_sql, stmt);
            }
          }

          if (statementHandle != null)
          {
              if (SQLiteConnection.CanOnChanged(null))
              {
                  SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                      SQLiteConnectionEventType.NewCriticalHandle, null, null,
                      null, null, statementHandle, strSql, new object[] {
                      typeof(SQLite3), cnn, strSql, previous, timeoutMS }));
              }
          }

          if (ShouldThrowForCancel())
          {
              if ((n == SQLiteErrorCode.Ok) ||
                  (n == SQLiteErrorCode.Row) ||
                  (n == SQLiteErrorCode.Done))

                else
                    throw new SQLiteException("failed to initialize backup");
            }

            backupHandle = new SQLiteBackupHandle(destHandle, backup);
        }

        if (SQLiteConnection.CanOnChanged(null))
        {
            SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                SQLiteConnectionEventType.NewCriticalHandle, null,
                null, null, null, backupHandle, null, new object[] {
                typeof(SQLite3), destCnn, destName, sourceName }));
        }

        return new SQLiteBackup(
            this, backupHandle, destHandle, zDestName, sourceHandle,
            zSourceName);
    }

    /// <summary>

      _returnToFileName = strFilename;
      _flags = connectionFlags;

      if (usePool)
      {
        _sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);

        if (SQLiteConnection.CanOnChanged(null))
        {
            SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                SQLiteConnectionEventType.OpenedFromPool, null, null,
                null, null, _sql, strFilename, new object[] {
                typeof(SQLite3_UTF16), strFilename, vfsName,
                connectionFlags, openFlags, maxPoolSize, usePool,
                _poolVersion }));
        }

#if !NET_COMPACT_20 && TRACE_CONNECTION
        Trace.WriteLine(HelperMethods.StringFormat(
            CultureInfo.CurrentCulture,
            "Open16 (Pool): {0}",
            HandleToString()));
#endif

          if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, null);
          _sql = new SQLiteConnectionHandle(db, true);
          BumpCreateCount();
        }
        lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }

        if (SQLiteConnection.CanOnChanged(null))
        {
            SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
                SQLiteConnectionEventType.NewCriticalHandle, null,
                null, null, null, _sql, strFilename, new object[] {
                typeof(SQLite3_UTF16), strFilename, vfsName,
                connectionFlags, openFlags, maxPoolSize, usePool }));
        }
      }

      // Bind functions to this connection.  If any previous functions of the same name
      // were already bound, then the new bindings replace the old.
      if (!HelperMethods.HasFlags(connectionFlags, SQLiteConnectionFlags.NoBindFunctions))
      {
          if (_functions == null)

                if (rc != SQLiteErrorCode.Ok)
                    throw new SQLiteException(rc, null);

                blob = new SQLiteBlobHandle(handle, ptrBlob);
            }

            if (SQLiteConnection.CanOnChanged(connection))
            {
                SQLiteConnection.OnChanged(connection, new ConnectionEventArgs(
                    SQLiteConnectionEventType.NewCriticalHandle, null, null,
                    null, null, blob, null, new object[] { typeof(SQLiteBlob),
                    databaseName, tableName, columnName, rowId, readOnly }));
            }

            return new SQLiteBlob(sqlite3, blob);
        }
        #endregion

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

        _commandTimeout = connection.DefaultTimeout;
        _maximumSleepTime = connection.DefaultMaximumSleepTime;
      }

      if (transaction != null)
        Transaction = transaction;

      if (SQLiteConnection.CanOnChanged(connection))
      {
          SQLiteConnection.OnChanged(connection, new ConnectionEventArgs(
              SQLiteConnectionEventType.NewCommand, null, transaction, this,
              null, null, null, null));
      }
    }

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

    [Conditional("CHECK_STATE")]
    internal static void Check(SQLiteCommand command)
    {

    /// <summary>
    /// Disposes of the command and clears all member variables
    /// </summary>
    /// <param name="disposing">Whether or not the class is being explicitly or implicitly disposed</param>
    protected override void Dispose(bool disposing)
    {
        if (SQLiteConnection.CanOnChanged(_cnn))
        {
            SQLiteConnection.OnChanged(_cnn, new ConnectionEventArgs(
                SQLiteConnectionEventType.DisposingCommand, null, _transaction, this,
                null, null, null, new object[] { disposing, disposed }));
        }

        bool skippedDispose = false;

        try
        {
            if (!disposed)
            {

      }
      set
      {
        CheckDisposed();

        string newCommandText = value;

        if (SQLiteConnection.CanOnChanged(_cnn))
        {
            ConnectionEventArgs previewEventArgs = new ConnectionEventArgs(
                SQLiteConnectionEventType.SqlStringPreview,
                null, null, null, null, null, null, null, null);

            previewEventArgs.Result = newCommandText;
            SQLiteConnection.OnChanged(_cnn, previewEventArgs);
            newCommandText = previewEventArgs.Result;
        }

        if (_commandText == newCommandText) return;

        if (_activeReader != null && _activeReader.IsAlive)
        {
          throw new InvalidOperationException("Cannot set CommandText while a DataReader is active");
        }

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

  /// <summary>
  /// Event data for connection event handlers.
  /// </summary>
  public class ConnectionEventArgs : EventArgs
  {
      /// <summary>
      /// Returns the number of instances of this class that have been created
      /// within this application domain.
      /// </summary>
      private static long createCount;
      public static long CreateCount
      {
          get { return createCount; }
      }

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

      /// <summary>
      /// The type of event being raised.
      /// </summary>
      public readonly SQLiteConnectionEventType EventType;

      /// <summary>
      /// The <see cref="StateChangeEventArgs" /> associated with this event, if any.

          object criticalHandle,
#endif
          string text,
          object data,
          string result
          )
      {
          Interlocked.Increment(ref createCount);

          EventType = eventType;
          EventArgs = eventArgs;
          Transaction = transaction;
          Command = command;
          DataReader = dataReader;
          CriticalHandle = criticalHandle;
          Text = text;

#if SQLITE_STANDARD && !PLATFORM_COMPACTFRAMEWORK
    /// <summary>
    /// Used to hold the active library version number of SQLite.
    /// </summary>
    private static int _versionNumber;
#endif

    /// <summary>
    /// Used to hold the number of times the <see cref="Changed" /> event
    /// should have been fired.
    /// </summary>
    private static long _onChangedHit;

    /// <summary>
    /// Used to hold the number of times the <see cref="Changed" /> event
    /// should have been skipped.
    /// </summary>
    private static long _onChangedMiss;
    #endregion

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

    #region Private Data
    /// <summary>
    /// State of the current connection

                    throw new NotImplementedException();
                }
        }
    }

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

    /// <summary>
    /// Attempts to determine if <see cref="Changed" /> events can be
    /// raised.
    /// </summary>
    /// <param name="connection">
    /// The connection associated with this event, if any.
    /// </param>
    /// <returns>
    /// Non-zero if <see cref="Changed" /> events are currently enabled
    /// for the specified connection; otherwise, zero.
    /// </returns>
    internal static bool CanOnChanged(
        SQLiteConnection connection
        )
    {
        if (connection != null)
        {
            if (connection.disposed)
            {
                Interlocked.Increment(ref _onChangedMiss);
                return false;
            }

#if !PLATFORM_COMPACTFRAMEWORK
            if (!connection.CanRaiseEvents)
            {
                Interlocked.Increment(ref _onChangedMiss);
                return false;
            }
#endif
        }

        //
        // BUGFIX: *PERF* If there are no event handlers, we do not
        //         attempt to handle any events -AND- skip creating
        //         data for event arguments.  This should minimize
        //         "wasted" heap allocations.
        //
        lock (_syncRoot)
        {
            if (_handlers != null)
            {
                Interlocked.Increment(ref _onChangedHit);
                return true;
            }
            else
            {
                Interlocked.Increment(ref _onChangedMiss);
                return false;
            }
        }
    }

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

    /// <summary>
    /// Raises the <see cref="Changed" /> event.
    /// </summary>
    /// <param name="connection">
    /// The connection associated with this event.  If this parameter is not
    /// null and the specified connection cannot raise events, then the
    /// registered event handlers will not be invoked.
    /// </param>
    /// <param name="e">
    /// A <see cref="ConnectionEventArgs" /> that contains the event data.
    /// </param>
    internal static void OnChanged(
        SQLiteConnection connection,
        ConnectionEventArgs e
        )
    {








        SQLiteConnectionEventHandler handlers;

        lock (_syncRoot)
        {
            if (_handlers != null)
                handlers = _handlers.Clone() as SQLiteConnectionEventHandler;
            else

        {
            result = (nativeHandle != IntPtr.Zero) ?
                new SQLiteConnectionHandle(nativeHandle, true) : null;
        }

        if (result != null)
        {
            if (CanOnChanged(null))
            {
                OnChanged(null, new ConnectionEventArgs(
                    SQLiteConnectionEventType.NewCriticalHandle, null,
                    null, null, null, result, null, new object[] {
                    typeof(SQLiteConnection), nativeHandle }));
            }
        }

        return result;
    }

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

    /// Cleans up resources (native and managed) associated with the current instance.
    /// </summary>
    /// <param name="disposing">
    /// Zero when being disposed via garbage collection; otherwise, non-zero.
    /// </param>
    protected override void Dispose(bool disposing)
    {
        if (CanOnChanged(this))
        {
            OnChanged(this, new ConnectionEventArgs(
                disposing ?
                    SQLiteConnectionEventType.DisposingConnection :
                    SQLiteConnectionEventType.FinalizingConnection,
                null, null, null, null, null, null, null));
        }

#if !NET_COMPACT_20 && TRACE_WARNING
        if (HelperMethods.HasFlags(_flags, SQLiteConnectionFlags.TraceWarning))
        {
            if (_noDispose)
            {
                System.Diagnostics.Trace.WriteLine(HelperMethods.StringFormat(

            base.Dispose(disposing);

            //
            // NOTE: Everything should be fully disposed at this point.
            //
            disposed = true;

            if (CanOnChanged(this))
            {
                OnChanged(this, new ConnectionEventArgs(
                    disposing ?
                        SQLiteConnectionEventType.DisposedConnection :
                        SQLiteConnectionEventType.FinalizedConnection,
                    null, null, null, null, null, null, null));
            }
        }
    }
    #endregion

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

#if PLATFORM_COMPACTFRAMEWORK

      }
      else
      {
          transaction = new SQLiteTransaction(
              this, isolationLevel != ImmediateIsolationLevel);
      }

      if (CanOnChanged(this))
      {
          OnChanged(this, new ConnectionEventArgs(
              SQLiteConnectionEventType.NewTransaction, null, transaction,
              null, null, null, null, null));
      }

      return transaction;
    }

    /// <summary>
    /// This method is not implemented; however, the <see cref="Changed" />
    /// event will still be raised.
    /// </summary>
    /// <param name="databaseName"></param>
    public override void ChangeDatabase(string databaseName)
    {
      CheckDisposed();

      if (CanOnChanged(this))
      {
          OnChanged(this, new ConnectionEventArgs(
              SQLiteConnectionEventType.ChangeDatabase, null, null, null, null,
              null, databaseName, null));
      }

      throw new NotImplementedException(); // NOTE: For legacy compatibility.
    }

    /// <summary>
    /// When the database connection is closed, all commands linked to this connection are automatically reset.
    /// </summary>
    public override void Close()
    {
      CheckDisposed();

      if (Object.ReferenceEquals(_lastConnectionInOpen, this))
          _lastConnectionInOpen = null; /* THREAD-SAFE: per-thread datum. */

      if (CanOnChanged(this))
      {
          OnChanged(this, new ConnectionEventArgs(
              SQLiteConnectionEventType.Closing, null, null, null, null, null,
              null, null));
      }

      if (_sql != null)
      {
#if !PLATFORM_COMPACTFRAMEWORK
        lock (_enlistmentSyncRoot) /* TRANSACTIONAL */
        {
          SQLiteEnlistment enlistment = _enlistment;

          _sql = null;
        }
        _transactionLevel = 0;
        _transactionSequence = 0;
      }
      else
      {
          if (CanOnChanged(this))
          {
              OnChanged(this, new ConnectionEventArgs(
                  SQLiteConnectionEventType.NothingToDo,
                  null, null, null, null, null, null, null));
          }
      }

      StateChangeEventArgs eventArgs = null;
      OnStateChange(ConnectionState.Closed, ref eventArgs);

      if (CanOnChanged(this))
      {
          OnChanged(this, new ConnectionEventArgs(
              SQLiteConnectionEventType.Closed, eventArgs, null, null, null,
              null, null, null));
      }
    }

    /// <summary>
    /// Returns the number of pool entries for the file name associated with this connection.
    /// </summary>
    public int PoolCount
    {

            bool strictEnlistment = HelperMethods.HasFlags(
                _flags, SQLiteConnectionFlags.StrictEnlistment);

            _enlistment = new SQLiteEnlistment(this, transaction,
                GetFallbackDefaultIsolationLevel(), strictEnlistment,
                strictEnlistment);

            if (CanOnChanged(this))
            {
                OnChanged(this, new ConnectionEventArgs(
                    SQLiteConnectionEventType.EnlistTransaction, null, null, null, null,
                    null, null, new object[] { _enlistment }));
            }
        }
    }
#endif

#if !PLATFORM_COMPACTFRAMEWORK
    /// <summary>
    /// <b>EXPERIMENTAL</b> --

    /// </summary>
    public override void Open()
    {
      CheckDisposed();

      _lastConnectionInOpen = this; /* THREAD-SAFE: per-thread datum. */

      if (CanOnChanged(this))
      {
          OnChanged(this, new ConnectionEventArgs(
              SQLiteConnectionEventType.Opening, null, null, null, null, null,
              null, null));
      }

      if (_connectionState != ConnectionState.Closed)
        throw new InvalidOperationException();

      Close();

      if (CanOnChanged(this))
      {
          ConnectionEventArgs previewEventArgs = new ConnectionEventArgs(
              SQLiteConnectionEventType.ConnectionStringPreview,
              null, null, null, null, null, null, null, null);

          previewEventArgs.Result = _connectionString;
          OnChanged(this, previewEventArgs);
          _connectionString = previewEventArgs.Result;
      }

      SortedList<string, string> opts = ParseConnectionString(
          this, _connectionString, _parseViaFramework, false, false);

      string stringValue;
      object enumValue;

          }

          eventArgConnectionString = BuildConnectionString(
              eventArgOpts);
      }
#endif

      if (CanOnChanged(this))
      {
          OnChanged(this, new ConnectionEventArgs(
              SQLiteConnectionEventType.ConnectionString, null, null, null, null,
              null, eventArgConnectionString, new object[] { eventArgOpts }));
      }

      stringValue = FindKey(opts, "DefaultDbType", null);

      if (stringValue != null)
      {
          enumValue = TryParseEnum(typeof(DbType), stringValue, true);
          _defaultDbType = (enumValue is DbType) ? (DbType)enumValue : (DbType?)null;

#endif

          _connectionState = oldstate;

          StateChangeEventArgs eventArgs = null;
          OnStateChange(ConnectionState.Open, ref eventArgs);

          if (CanOnChanged(this))
          {
              OnChanged(this, new ConnectionEventArgs(
                  SQLiteConnectionEventType.Opened, eventArgs, null, null, null,
                  null, eventArgConnectionString, new object[] { eventArgOpts }));
          }

#if DEBUG
          _debugString = HelperMethods.StringFormat(
              CultureInfo.InvariantCulture,
              "openThreadId = {0}, connectionString = {1}",
              HelperMethods.GetThreadId(),
              eventArgConnectionString);

        CheckDisposed();

        if (_sql == null)
            throw new InvalidOperationException("Database connection not valid for query cancellation.");

        _sql.Cancel(); /* throw */

        if (CanOnChanged(this))
        {
            OnChanged(this, new ConnectionEventArgs(
                SQLiteConnectionEventType.Canceled,
                null, null, null, null, null, null, null));
        }
    }

    /// <summary>
    /// This method checks if the database operation for this connection has been
    /// interrupted.
    /// </summary>
    /// <returns>

      _commandBehavior = behave;
      _activeStatementIndex = -1;
      _rowsAffected = -1;

      RefreshFlags();

      SQLiteConnection connection = GetConnection(this);

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

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

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

    /// <summary>
    /// Dispose of all resources used by this datareader.
    /// </summary>
    /// <param name="disposing"></param>
    protected override void Dispose(bool disposing)
    {
        SQLiteConnection connection = GetConnection(this);

        if (SQLiteConnection.CanOnChanged(connection))
        {
            SQLiteConnection.OnChanged(connection,
                new ConnectionEventArgs(SQLiteConnectionEventType.DisposingDataReader,
                null, null, _command, this, null, null, new object[] { disposing,
                disposed, _commandBehavior, _readingState, _rowsAffected, _stepCount,
                _fieldCount, _disposeCommand, _throwOnDisposed }));
        }

        try
        {
            if (!disposed)
            {
                //if (disposing)
                //{

    /// <summary>
    /// Closes the datareader, potentially closing the connection as well if CommandBehavior.CloseConnection was specified.
    /// </summary>
    public override void Close()
    {
      CheckDisposed();

      SQLiteConnection connection = GetConnection(this);

      if (SQLiteConnection.CanOnChanged(connection))
      {
          SQLiteConnection.OnChanged(connection,
              new ConnectionEventArgs(SQLiteConnectionEventType.ClosingDataReader,
              null, null, _command, this, null, null, new object[] { _commandBehavior,
              _readingState, _rowsAffected, _stepCount, _fieldCount, _disposeCommand,
              _throwOnDisposed }));
      }

      try
      {
        if (_command != null)
        {
          try
          {

###############################################################################
#
# pst-25cafb35e5.eagle --
#
# Written by Joe Mistachkin.
# Released to the public domain, use at your own risk!
#
###############################################################################

package require Eagle
package require Eagle.Library
package require Eagle.Test

runTestPrologue

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

package require System.Data.SQLite.Test
runSQLiteTestPrologue

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

proc getChangedCounts {} {
  return [list \
      hit [object invoke -flags +NonPublic \
          System.Data.SQLite.SQLiteConnection \
          _onChangedHit] \
      miss [object invoke -flags +NonPublic \
          System.Data.SQLite.SQLiteConnection \
          _onChangedMiss] \
      data [object invoke \
          System.Data.SQLite.ConnectionEventArgs \
          CreateCount]]
}

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

proc subtractChangedCounts { dict1 dict2 } {
  set result [list]

  foreach name [list hit miss data] {
    set count1 [getDictionaryValue $dict1 $name]
    set count2 [getDictionaryValue $dict2 $name]

    lappend result $name [expr {$count2 - $count1}]
  }

  return $result
}

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

runTest {test pst-25cafb35e5-1.1 {without Changed events} -body {
  set result [list]
  set counts(before) [getChangedCounts]

  setupDb [set fileName pst-25cafb35e5-1.1.db]

  sql execute $db {
    CREATE TABLE t1(x TEXT);
    INSERT INTO t1 (x) VALUES('1');
    INSERT INTO t1 (x) VALUES('2');
    INSERT INTO t1 (x) VALUES('3');
  }

  lappend result [sql execute -execute reader -format list -- \
      $db {SELECT x FROM t1 ORDER BY x;}]

  cleanupDb $fileName

  set counts(after) [getChangedCounts]

  list $result [subtractChangedCounts $counts(before) $counts(after)]
} -cleanup {
  cleanupDb $fileName

  unset -nocomplain result counts fileName
} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite} -result {{{1 2 3}} {hit 0 miss 35 data 0}}}

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

runTest {test pst-25cafb35e5-1.2 {with Changed events} -setup {
  proc onChanged { sender e } {
    #
    # NOTE: For the purposes of this issue, there isn't a pressing
    #       need to do anything specific here; however, keep track
    #       of the event type for additional verification that the
    #       correct set of events is still being fired.
    #
    lappend ::result [$e EventType]
  }

  set callback onChanged
  object invoke System.Data.SQLite.SQLiteConnection add_Changed $callback
} -body {
  set result [list]
  set counts(before) [getChangedCounts]

  setupDb [set fileName pst-25cafb35e5-1.2.db]

  sql execute $db {
    CREATE TABLE t1(x TEXT);
    INSERT INTO t1 (x) VALUES('1');
    INSERT INTO t1 (x) VALUES('2');
    INSERT INTO t1 (x) VALUES('3');
  }

  lappend result [sql execute -execute reader -format list -- \
      $db {SELECT x FROM t1 ORDER BY x;}]

  cleanupDb $fileName

  set counts(after) [getChangedCounts]

  list $result [subtractChangedCounts $counts(before) $counts(after)]
} -cleanup {
  object invoke System.Data.SQLite.SQLiteConnection remove_Changed $callback
  catch {object removecallback $callback}

  cleanupDb $fileName

  unset -nocomplain callback result counts fileName

  rename onChanged ""
} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite} -result {{Opening Closing NothingToDo Closed\
ConnectionStringPreview ConnectionString NewCriticalHandle NewCommand\
DisposingCommand Opened NewCommand SqlStringPreview NewDataReader\
NewCriticalHandle DisposingDataReader ClosingDataReader DisposingCommand\
NewCommand SqlStringPreview NewDataReader NewCriticalHandle NewCriticalHandle\
NewCriticalHandle NewCriticalHandle DisposingDataReader ClosingDataReader\
DisposingCommand NewCommand SqlStringPreview NewDataReader NewCriticalHandle\
ClosingDataReader DisposingCommand {1 2 3} Closing Closed} {hit 35 miss 0 data\
35}}}

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

rename subtractChangedCounts ""
rename getChangedCounts ""

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

runSQLiteTestEpilogue
runTestEpilogue

<p>
    <b>1.0.119.0 - May XX, 2024 <font color="red">(release scheduled)</font></b>
</p>
<ul>
    <li>Updated to <a href="https://www.sqlite.org/releaselog/3_45_3.html">SQLite 3.45.3</a>.</li>
    <li>Update internal resource list of reserved SQL words.</li>
    <li>Avoid NullReferenceException from Path.Combine method when the PublishSingleFile property is enabled for a project. Pursuant to forum post [66a0d2716a].</li>
    <li>Avoid setting up for the Changed event when it will not be fired. Pursuant to forum post [25cafb35e5].</li>
    <li>Add the VfsName connection string property.</li>
    <li>Fix rarely seen NullReferenceException in the StaticWeakConnectionPool.Add method.</li>
    <li>Revise the calculation used to bind DateTime values. Fix for [bbddfeb773].</li>
    <li>Fix support for unnamed parameters using the ?NNN syntax. Pursuant to forum post [76cb35b58d].</li>
</ul>
<p>
    <b>1.0.118.0 - June 10, 2023</b>

<p>
    <b>1.0.119.0 - May XX, 2024 <font color="red">(release scheduled)</font></b>
</p>
<ul>
    <li>Updated to [https://www.sqlite.org/releaselog/3_45_3.html|SQLite 3.45.3].</li>
    <li>Update internal resource list of reserved SQL words.</li>
    <li>Avoid NullReferenceException from Path.Combine method when the PublishSingleFile property is enabled for a project. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/66a0d2716a|66a0d2716a].</li>
    <li>Avoid setting up for the Changed event when it will not be fired. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/25cafb35e5|25cafb35e5]</a>.</li>
    <li>Add the VfsName connection string property.</li>
    <li>Fix rarely seen NullReferenceException in the StaticWeakConnectionPool.Add method.</li>
    <li>Revise the calculation used to bind DateTime values. Fix for [bbddfeb773].</li>
    <li>Fix support for unnamed parameters using the ?NNN syntax. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/76cb35b58d|76cb35b58d].</li>
</ul>
<p>
    <b>1.0.118.0 - June 10, 2023</b>