System.Data.SQLite

    <ul>
      <li>Updated to <a href="https://www.sqlite.org/releaselog/3_46_0.html">SQLite 3.46.0</a>.</li>
      <li>Update internal resource list of reserved SQL words.</li>
      <li>Add experimental support for using NuGet runtime identifiers to help locate the interop assembly. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/3757f4365b">[3757f4365b]</a>.</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>Add the ConnectionPoolOnly and AggressiveDisposal connection flags.&nbsp;<b>** Potentially Incompatible Change **</b></li>
      <li>Add the &quot;compress&quot; and &quot;zipfile&quot; extensions to the interop assembly.</li>
      <li>Add the GetPasswordCallback property to the SQLiteConnection class for use with <a href="https://www.sqlite.org/see">SEE</a>.</li>
      <li>Add the NoCase property to the SQLiteParameterCollection class.</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>

      /// <summary>
      /// If a connection cannot be opened using the connection pool, throw
      /// an exception instead of default behavior of falling back to using
      /// a non-pooled connection.
      /// </summary>
      ConnectionPoolOnly = 0x10000000000000,

      /// <summary>
      /// Be more aggressive about disposing of unused native resources,
      /// e.g. connections, transactions, commands, data readers, etc.
      /// </summary>
      AggressiveDisposal = 0x20000000000000,

      /// <summary>
      /// When binding parameter values or returning column values, always
      /// treat them as though they were plain text (i.e. no numeric,
      /// date/time, or other conversions should be attempted).
      /// </summary>
      BindAndGetAllAsText = BindAllAsText | GetAllAsText,

#else
      LogDefault = LogCallbackException,
#endif

      /// <summary>
      /// The default extra flags for new connections.
      /// </summary>
      Default = LogDefault | BindInvariantDecimal | GetInvariantDecimal |
                AggressiveDisposal,

      /// <summary>
      /// The default extra flags for new connections with all logging enabled.
      /// </summary>
      DefaultAndLogAll = Default | LogAll
  }

                        }
                    }

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

                        if (HelperMethods.HasFlags(reader._flags,
                                SQLiteConnectionFlags.AggressiveDisposal))
                        {
                            //
                            // 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;
                    }

    }

    /// <summary>
    /// Builds an array of prepared statements for each complete SQL statement in the command text
    /// </summary>
    internal SQLiteStatement BuildNextCommand()
    {
        SQLiteStatement stmt = null;

        try
        {
            if ((_cnn != null) && (_cnn._sql != 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) ||
                    !HelperMethods.HasFlags(
                        SQLiteConnection.GetFlags(_cnn),
                        SQLiteConnectionFlags.AggressiveDisposal))
                {
                    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();

                                    _sql.SetPassword(passwordBytes, true);
                                    _passwordWasText = true;
                                    _passwordWasHex = true;
                                    break;
                                }
                        }

                        Array.Clear(passwordBytes, 0, passwordBytes.Length);
                        passwordBytes = null;
                    }

                    password = null; /* IMMUTABLE */
                }

                hexPassword = null; /* IMMUTABLE */
            }

            if (opts.ContainsKey("Password"))
                opts["Password"] = String.Empty;

            _connectionString = BuildConnectionString(opts);
        }
#else

        if (FindKey(opts, "TextHexPassword", null) != null)
        {
            throw new SQLiteException(SQLiteErrorCode.Error,
                "Cannot use \"TextHexPassword\" connection string property: " +
                "library was not built with encryption support, please " +
                "see \"https://www.sqlite.org/see\" for more information");
        }

    /// <summary>
    /// Underlying command this reader is attached to
    /// </summary>
    private SQLiteCommand _command;
    /// <summary>
    /// The flags pertaining to the associated connection (via the command).
    /// </summary>
    internal SQLiteConnectionFlags _flags;
    /// <summary>
    /// Index of the current statement in the command being processed
    /// </summary>
    private int _activeStatementIndex;
    /// <summary>
    /// Current statement being Read()
    /// </summary>

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

                    if (HelperMethods.HasFlags(_flags,
                            SQLiteConnectionFlags.AggressiveDisposal))
                    {
                        SQLiteCommand.DisposeStatements(
                            false, ref _statementList);
                    }
                }

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

                //

      /// Data read from the file system appears to be incorrect.
      /// </summary>
      IoErr_Data = (IoErr | (32 << 8)),
      /// <summary>
      /// File system corruption was detected during a read or write.
      /// </summary>
      IoErr_CorruptFs = (IoErr | (33 << 8)),
      /// <summary>
      /// An exception was caught during use of mapped memory.
      /// In general, this applies only to the WAL journal mode.
      /// </summary>
      IoErr_In_Page = (IoErr | (34 << 8)),
      /// <summary>
      /// A database table is locked in shared-cache mode.
      /// </summary>
      Locked_SharedCache = (Locked | (1 << 8)),
      /// <summary>
      /// A virtual table in the database is locked.
      /// </summary>

    /// clauses, expression indexes, partial indexes, and generated columns unless
    /// the function is tagged with SQLITE_INNOCUOUS. Most built-in functions are
    /// innocuous. Developers are advised to avoid using the SQLITE_INNOCUOUS flag
    /// for application-defined functions unless the function has been carefully
    /// audited and found to be free of potentially security-adverse side-effects
    /// and information-leaks.
    /// </summary>
    SQLITE_INNOCUOUS = 0x200000,
    /// <summary>
    /// The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function
    /// might call sqlite3_result_subtype() to cause a sub-type to be
    /// associated with its result.  Every function that invokes
    /// sqlite3_result_subtype() should have this property.  If it does not,
    /// then the call to sqlite3_result_subtype() might become a no-op if the
    /// function is used as term in an expression index.  On the other hand,
    /// SQL functions that never invoke sqlite3_result_subtype() should avoid
    /// setting this property, as the purpose of this property is to disable
    /// certain optimizations that are incompatible with subtypes.
    /// </summary>
    SQLITE_RESULT_SUBTYPE = 0x1000000
  }

  /// <summary>
  /// This abstract class is designed to handle user-defined functions easily.  An instance of the derived class is made for each
  /// connection to the database.
  /// </summary>
  /// <remarks>

IoErr_Delete 2570
IoErr_Delete_NoEnt 5898
IoErr_Dir_Close 4362
IoErr_Dir_Fsync 1290
IoErr_Fstat 1802
IoErr_Fsync 1034
IoErr_GetTempPath 6410
IoErr_In_Page 8714
IoErr_Lock 3850
IoErr_Mmap 6154
IoErr_NoMem 3082
IoErr_RdLock 2314
IoErr_Read 266
IoErr_Rollback_Atomic 7946
IoErr_Seek 5642

<ul>
    <li>Updated to <a href="https://www.sqlite.org/releaselog/3_46_0.html">SQLite 3.46.0</a>.</li>
    <li>Update internal resource list of reserved SQL words.</li>
    <li>Add experimental support for using NuGet runtime identifiers to help locate the interop assembly. Pursuant to forum post [3757f4365b].</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>Add the ConnectionPoolOnly and AggressiveDisposal connection flags.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    <li>Add the &quot;compress&quot; and &quot;zipfile&quot; extensions to the interop assembly.</li>
    <li>Add the GetPasswordCallback property to the SQLiteConnection class for use with <a href="https://www.sqlite.org/see">SEE</a>.</li>
    <li>Add the NoCase property to the SQLiteParameterCollection class.</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>

<ul>
    <li>Updated to [https://www.sqlite.org/releaselog/3_46_0.html|SQLite 3.46.0].</li>
    <li>Update internal resource list of reserved SQL words.</li>
    <li>Add experimental support for using NuGet runtime identifiers to help locate the interop assembly. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/3757f4365b|3757f4365b].</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>Add the ConnectionPoolOnly and AggressiveDisposal connection flags.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    <li>Add the &quot;compress&quot; and &quot;zipfile&quot; extensions to the interop assembly.</li>
    <li>Add the GetPasswordCallback property to the SQLiteConnection class for use with [https://www.sqlite.org/see|SEE].</li>
    <li>Add the NoCase property to the SQLiteParameterCollection class.</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>