System.Data.SQLite

      <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 &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>
    <p><b>1.0.118.0 - June 10, 2023</b></p>
    <ul>

    internal static partial class HelperMethods
    {
        #region Private Constants
        private const string DisplayNullObject = "<nullObject>";
        private const string DisplayEmptyString = "<emptyString>";
        private const string DisplayStringFormat = "\"{0}\"";

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

        private const string DisplayNullArray = "<nullArray>";
        private const string DisplayEmptyArray = "<emptyArray>";

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

        private const string TraceDateTimeFormat = "yyyy-MM-dd HH:mm:ss.fffffff";

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

        private const char ArrayOpen = '[';
        private const string ElementSeparator = ", ";
        private const char ArrayClose = ']';

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

        private static readonly char[] SpaceChars = {
            '\t', '\n', '\r', '\v', '\f', ' '
        };

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

        private static readonly char[] SeparatorChars = {
            '\t', '\n', ' ', ','
        };
        #endregion

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

        #region Private Data
        /// <summary>
        /// This lock is used to protect the static <see cref="isMono" /> and
        /// <see cref="isDotNetCore" /> fields.
        /// </summary>
        private static readonly object staticSyncRoot = new object();

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// This type is only present when running on Mono.
        /// </summary>
        private static readonly string MonoRuntimeType = "Mono.Runtime";

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// This type is only present when running on .NET Core.
        /// </summary>
        private static readonly string DotNetCoreLibType = "System.CoreLib";

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Keeps track of whether we are running on Mono.  Initially null, it
        /// is set by the <see cref="IsMono" /> method on its first call.
        /// Later, it is returned verbatim by the <see cref="IsMono" /> method.
        /// </summary>
        private static bool? isMono = null;

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Keeps track of whether we are running on .NET Core.  Initially null,
        /// it is set by the <see cref="IsDotNetCore" /> method on its first
        /// call.  Later, it is returned verbatim by the
        /// <see cref="IsDotNetCore" /> method.
        /// </summary>
        private static bool? isDotNetCore = null;

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Keeps track of whether we successfully invoked the
        /// <see cref="Debugger.Break" /> method.  Initially null, it is set by
        /// the <see cref="MaybeBreakIntoDebugger" /> method on its first call.
        /// </summary>
        private static bool? debuggerBreak = null;

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// These are the currently enabled categories of trace messages.  If a
        /// trace message belongs to one of these categories, it will be emitted;
        /// otherwise, it will be silently dropped.
        /// </summary>
        private static TraceCategory traceCategories = TraceCategory.Default;

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// This boolean flag will be non-zero when the enabled trace categories
        /// have been setup.
        /// </summary>
        private static bool traceCategoriesSet = false;
        #endregion

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

        #region Private Methods
        /// <summary>
        /// Determines the ID of the current process.  Only used for debugging.
        /// </summary>
        /// <returns>
        /// The ID of the current process -OR- zero if it cannot be determined.

            {
                // do nothing.
            }

            return false;
        }

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Determines if the specified trace category is enabled.  Disabled
        /// trace categories will not have any associated messages emitted.
        /// </summary>
        /// <param name="category">
        /// The trace category to check.
        /// </param>

            TraceCategory category
            )
        {
            return (traceCategories & category) == category; /* NO-LOCK */
        }
        #endregion

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

        #region Internal Methods
        /// <summary>
        /// Resets the cached value for the "PreLoadSQLite_BreakIntoDebugger"
        /// configuration setting.
        /// </summary>
        internal static void ResetBreakIntoDebugger()
        {
            lock (staticSyncRoot)
            {
                debuggerBreak = null;
            }
        }

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

        /// <summary>
        /// If the "PreLoadSQLite_BreakIntoDebugger" configuration setting is
        /// present (e.g. via the environment), give the interactive user an
        /// opportunity to attach a debugger to the current process; otherwise,
        /// do nothing.
        /// </summary>

                lock (staticSyncRoot)
                {
                    debuggerBreak = false;
                }
            }
        }

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Determines the ID of the current thread.  Only used for debugging.
        /// </summary>
        /// <returns>
        /// The ID of the current thread -OR- zero if it cannot be determined.
        /// </returns>
        internal static int GetThreadId()
        {
#if !PLATFORM_COMPACTFRAMEWORK
            return AppDomain.GetCurrentThreadId();
#else
            return 0;
#endif
        }

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Determines if the current process is running on one of the Windows
        /// [sub-]platforms.
        /// </summary>
        /// <returns>
        /// Non-zero when running on Windows; otherwise, zero.
        /// </returns>

            {
                return true;
            }

            return false;
        }

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// This is a wrapper around the
        /// <see cref="String.Format(IFormatProvider,String,Object[])" />
        /// method.  On Mono, it has to call the method overload without the
        /// <see cref="IFormatProvider" /> parameter, due to a bug in Mono.
        /// </summary>
        /// <param name="provider">
        /// This is used for culture-specific formatting.
        /// </param>
        /// <param name="format">
        /// The format string.

            {
                // do nothing.
            }

            return false;
        }

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Attempts to determine which trace categories should be enabled based
        /// on the specified string value, which must be in the following general
        /// format:
        ///
        ///     [prefix1][name1][separator1] ... [prefixN][nameN][separatorN]
        ///

                    }
                }
            }

            return categories;
        }

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

        /// <summary>
        /// Determines if the enabled trace categories have already been set.
        /// </summary>
        /// <returns>
        /// Non-zero if the enabled trace categories have already been set;
        /// otherwise, zero.
        /// </returns>
        internal static bool AreTraceCategoriesSet()
        {
            return traceCategoriesSet;
        }

        ///////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Changes the set of trace categories that are enabled.  Disabled
        /// trace categories will not have any associated messages emitted.
        /// </summary>
        /// <param name="categories">
        /// The trace categories to enable.  Any trace categories not present
        /// in this mask will be disabled.
        /// </param>
        internal static void SetTraceCategories(
            TraceCategory categories
            )
        {
            traceCategories = categories; /* NO-LOCK */
            traceCategoriesSet = true; /* NO-LOCK */

            Trace(String.Format(
                "Trace categories overridden to: {0}", categories),
                TraceCategory.Self);
        }

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

        /// <summary>
        /// Attempts to emit a message to the tracing subsystem via the
        /// <see cref="System.Diagnostics.Trace.WriteLine(String)" /> method.
        /// </summary>
        /// <param name="message">
        /// The message to emit.

                System.Diagnostics.Trace.WriteLine(
                    String.Format("[{0}] System.Data.SQLite ({1}): {2}",
                    DateTime.Now.ToString(TraceDateTimeFormat), category,
                    message));
            }
        }

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

        /// <summary>
        /// Attempts to convert an object value to a string suitable for display
        /// to humans.
        /// </summary>
        /// <param name="value">
        /// The object value to create a string representation of.

                return stringValue;

            return StringFormat(
                CultureInfo.InvariantCulture, DisplayStringFormat,
                stringValue);
        }

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

        /// <summary>
        /// Attempts to convert an array value to a string suitable for display
        /// to humans.
        /// </summary>
        /// <param name="array">
        /// The array value to create a string representation of.

  using System.Runtime.InteropServices;
  using System.IO;
  using System.Text;
  using System.Threading;

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

#if INTEROP_CODEC || INTEROP_INCLUDE_SEE
  /// <summary>
  /// This enumeration is used with the
  /// <see cref="SQLiteGetPasswordCallback" /> callback in order
  /// to determine which of the connection string properties is
  /// to be set with its returned string value.
  /// </summary>
  public enum PasswordMode
  {
    /// <summary>
    /// No password mode, skip setting the password.
    /// </summary>
    None = 0x0,

    /// <summary>
    /// Use the "Password" connection string property.
    /// </summary>
    Password = 0x1000,

    /// <summary>
    /// Use the "HexPassword" connection string property.
    /// </summary>
    HexPassword = 0x2000,

    /// <summary>
    /// Use the "TextPassword" connection string property.
    /// </summary>
    TextPassword = 0x4000,

    /// <summary>
    /// Use the "TextHexPassword" connection string property.
    /// </summary>
    TextHexPassword = 0x8000
  }
#endif

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

  /// <summary>
  /// This class represents a single value to be returned
  /// from the <see cref="SQLiteDataReader" /> class via
  /// its <see cref="SQLiteDataReader.GetBlob" />,
  /// <see cref="SQLiteDataReader.GetBoolean" />,
  /// <see cref="SQLiteDataReader.GetByte" />,
  /// <see cref="SQLiteDataReader.GetBytes" />,

      SQLiteConnectionFlags flags,
      SQLiteReadEventArgs eventArgs,
      string typeName,
      int index,
      object userData,
      out bool complete
  );

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

#if INTEROP_CODEC || INTEROP_INCLUDE_SEE
  /// <summary>
  /// This represents a method to be called to obtain the encryption
  /// password for the associated connection, which is passed in the
  /// <paramref name="connection" /> parameter.
  /// </summary>
  /// <param name="connection">
  /// The connection being opened.
  /// </param>
  /// <param name="passwordMode">
  /// The called method may modify this parameter in order to change
  /// which connection string property is used to setup the password.
  /// </param>
  /// <returns>
  /// The password string to use when opening the connection.
  /// </returns>
  public delegate string SQLiteGetPasswordCallback(
      SQLiteConnection connection,  /* in */
      ref PasswordMode passwordMode /* in, out */
  );
#endif

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

  /// <summary>
  /// This class represents the custom data type handling callbacks
  /// for a single type name.
  /// </summary>

            case IsolationLevel.Serializable:
            case IsolationLevel.Snapshot:
                return ImmediateIsolationLevel;
            default:
                return GetFallbackDefaultIsolationLevel();
        }
    }

#if INTEROP_CODEC || INTEROP_INCLUDE_SEE
    /// <summary>
    /// Gets or sets the callback method that can be used to provide a
    /// connection string password when one is NOT already specified in
    /// the connection string itself.
    /// </summary>
    private SQLiteGetPasswordCallback _getPasswordCallback;
    public SQLiteGetPasswordCallback GetPasswordCallback
    {
        get { CheckDisposed(); return _getPasswordCallback; }
        set { CheckDisposed(); _getPasswordCallback = value; }
    }
#endif

    /// <summary>
    /// Opens the connection using the parameters found in the <see cref="ConnectionString" />.
    /// </summary>
    public override void Open()
    {
      CheckDisposed();

        string textHexPassword = FindKey(opts, "TextHexPassword", DefaultTextHexPassword);

        if (textHexPassword != null)
        {
            byte[] textHexPasswordBytes;

            error = null;

            textHexPasswordBytes = FromHexString(textHexPassword, false, ref error);

            if (textHexPasswordBytes == null)
            {
                throw new FormatException(HelperMethods.StringFormat(
                    CultureInfo.CurrentCulture,
                    "Cannot parse 'TextHexPassword' property value into byte values: {0}",

                string hexPassword = FindKey(opts, "HexPassword", DefaultHexPassword);

                if (hexPassword != null)
                {
                    byte[] hexPasswordBytes;

                    error = null;

                    hexPasswordBytes = FromHexString(hexPassword, true, ref error);

                    if (hexPasswordBytes == null)
                    {
                        throw new FormatException(HelperMethods.StringFormat(
                            CultureInfo.CurrentCulture,
                            "Cannot parse 'HexPassword' property value into byte values: {0}",

                        _sql.SetPassword(passwordBytes, false);
                        _passwordWasText = false;
                        _passwordWasHex = false;
                    }
                    else if (_password != null)
                    {
                        _sql.SetPassword(_password, _passwordWasText);
                    }
                    else if (_getPasswordCallback != null)
                    {
                        byte[] passwordBytes;
                        PasswordMode passwordMode = PasswordMode.Password;

                        password = _getPasswordCallback(this, ref passwordMode);

                        switch (passwordMode)
                        {
                            case PasswordMode.None:
                                {
                                    //
                                    // NOTE: Do nothing, ignore password.
                                    //
                                    break;
                                }
                            case PasswordMode.Password:
                                {
                                    passwordBytes = UTF8Encoding.UTF8.GetBytes(password);

                                    _sql.SetPassword(passwordBytes, false);
                                    _passwordWasText = false;
                                    _passwordWasHex = false;
                                    break;
                                }
                            case PasswordMode.HexPassword:
                                {
                                    error = null;

                                    passwordBytes = FromHexString(password, true, ref error);

                                    if (passwordBytes == null)
                                    {
                                        throw new FormatException(
                                            HelperMethods.StringFormat(CultureInfo.CurrentCulture,
                                            "Cannot parse 'HexPassword' property value into byte values: {0}",
                                            error));
                                    }

                                    _sql.SetPassword(passwordBytes, false);
                                    _passwordWasText = false;
                                    _passwordWasHex = true;
                                    break;
                                }
                            case PasswordMode.TextPassword:
                                {
                                    passwordBytes = UTF8Encoding.UTF8.GetBytes(password);

                                    Array.Resize(
                                        ref passwordBytes, passwordBytes.Length + 1);

                                    _sql.SetPassword(passwordBytes, true);
                                    _passwordWasText = true;
                                    _passwordWasHex = false;
                                    break;
                                }
                            case PasswordMode.TextHexPassword:
                                {
                                    error = null;

                                    passwordBytes = FromHexString(password, false, ref error);

                                    if (passwordBytes == null)
                                    {
                                        throw new FormatException(
                                            HelperMethods.StringFormat(CultureInfo.CurrentCulture,
                                            "Cannot parse 'TextHexPassword' property value into byte values: {0}",
                                            error));
                                    }

                                    Array.Resize(
                                        ref passwordBytes, passwordBytes.Length + 1);

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

                    password = null; /* IMMUTABLE */
                }

                hexPassword = null; /* IMMUTABLE */
            }

    <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 &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>
<p>
    <b>1.0.118.0 - June 10, 2023</b>

    <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 &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>
<p>
    <b>1.0.118.0 - June 10, 2023</b>