System.Data.SQLite

          </td>
        </tr>
      </table>
    </div>
    <div id="mainSection">
    <div id="mainBody">
    <h1 class="heading">Version History</h1>
    <p><b>1.0.118.0 - April XX, 2023 <font color="red">(release scheduled)</font></b></p>
    <ul>
      <li>Add the ConnectionStringPreview, SqlStringPreview, and Canceled connection events.</li>
      <li>Add support for the sqlite3_is_interrupted core library API. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/b6a707bffb">[b6a707bffb]</a>.</li>
      <li>Add support for the sqlite_trace_v2 core library API. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/1c418d7edc">[1c418d7edc]</a>.</li>
      <li>Add TextHexPassword connection string property for use with <a href="https://www.sqlite.org/see">SEE</a>.</li>
    </ul>
    <p><b>1.0.117.0 - November 28, 2022</b></p>
    <ul>
      <li>Updated to <a href="https://www.sqlite.org/releaselog/3_40_0.html">SQLite 3.40.0</a>.</li>
      <li>Add support for creating custom window functions. Pursuant to forum post <a href="https://www.sqlite.org/forum/forumpost/21de219031">[21de219031]</a>.</li>
      <li>Suppress finalizer calls for SQLite3 objects that are closed. Fix for <a href="https://system.data.sqlite.org/index.html/info/ce4d70ea6f">[ce4d70ea6f]</a>.</li>
      <li>Improvements to object disposal diagnostics. Pursuant to <a href="https://system.data.sqlite.org/index.html/info/ce4d70ea6f">[ce4d70ea6f]</a>.</li>

  /// both the native interop assembly and the core managed assemblies; otherwise,
  /// using this parameter may result in an exception being thrown when attempting
  /// to open the connection.
  /// </description>
  /// <description>N</description>
  /// <description></description>
  /// </item>
  /// <item>
  /// <description>TextHexPassword</description>
  /// <description>
  /// {hexPassword} - Must contain a sequence of zero or more hexadecimal encoded
  /// byte values without a leading "0x" prefix.  Using this parameter requires
  /// that the legacy CryptoAPI based codec (or the SQLite Encryption Extension)
  /// be enabled at compile-time for both the native interop assembly and the
  /// core managed assemblies; otherwise, using this parameter may result in an
  /// exception being thrown when attempting to open the connection.
  /// </description>
  /// <description>N</description>
  /// <description></description>
  /// </item>
  /// <item>
  /// <description>Enlist</description>
  /// <description>
  /// <b>Y</b> - Automatically enlist in distributed transactions
  /// <br/>
  /// <b>N</b> - No automatic enlistment
  /// </description>

    internal const SQLiteDateFormats DefaultDateTimeFormat = SQLiteDateFormats.Default;
    internal const DateTimeKind DefaultDateTimeKind = DateTimeKind.Unspecified;
    internal const string DefaultDateTimeFormatString = null;
    private const string DefaultDataSource = null;
    private const string DefaultUri = null;
    private const string DefaultFullUri = null;
    private const string DefaultTextPassword = null;
    private const string DefaultTextHexPassword = null;
    private const string DefaultHexPassword = null;
    private const string DefaultPassword = null;
    private const int DefaultVersion = 3;
    private const int DefaultPageSize = 4096;
    private const int DefaultMaxPageCount = 0;
    private const int DefaultCacheSize = -2000;
    private const int DefaultMaxPoolSize = 100;

#if INTEROP_CODEC || INTEROP_INCLUDE_SEE
    /// <summary>
    /// Temporary password storage, emptied after the database has been opened
    /// </summary>
    private byte[] _password;

    /// <summary>
    /// This will be non-zero if the "TextPassword" or "TextHexPassword"
    /// connection string properties were used.  When this value is non-zero,
    /// <see cref="ChangePassword(Byte[])" /> will retain treatment of the
    /// password as a NUL-terminated text string.
    /// </summary>
    private bool _passwordWasText;
#endif

    /// <summary>
    /// The "stub" (i.e. placeholder) base schema name to use when returning
    /// column schema information.

    /// </returns>
    internal static byte[] FromHexString(
        string text
        )
    {
        string error = null;

        return FromHexString(text, true, ref error);
    }

    /// <summary>
    /// Creates and returns a string containing the hexadecimal encoded byte
    /// values from the input array.
    /// </summary>
    /// <param name="array">

    /// encoded byte values and returns the resulting byte array.  The
    /// "0x" prefix is not allowed on the input string.
    /// </summary>
    /// <param name="text">
    /// The input string containing zero or more hexadecimal encoded byte
    /// values.
    /// </param>
    /// <param name="allowNul">
    /// When zero, byte values of zero are not allowed and will be changed
    /// to <see cref="Byte.MaxValue" /> instead.
    /// </param>
    /// <param name="error">
    /// Upon failure, this will contain an appropriate error message.
    /// </param>
    /// <returns>
    /// A byte array containing the parsed byte values or null if an error
    /// was encountered.
    /// </returns>
    private static byte[] FromHexString(
        string text,
        bool allowNul,
        ref string error
        )
    {
        if (text == null)
        {
            error = "string is null";
            return null;
        }

        if (text.Length % 2 != 0)
        {
            error = "string contains an odd number of characters";
            return null;
        }

        byte[] result = new byte[text.Length / 2];

        for (int index = 0; index < text.Length; index += 2)
        {
            string value = text.Substring(index, 2);
            int outIndex = index / 2;

            if (!TryParseByte(value,
                    NumberStyles.HexNumber, out result[outIndex]))
            {
                error = HelperMethods.StringFormat(
                    CultureInfo.CurrentCulture,
                    "string contains \"{0}\", which cannot be converted to a byte value",
                    value);

                return null;
            }

            if (!allowNul && (result[outIndex] == 0))
                result[outIndex] = byte.MaxValue;
        }

        return result;
    }

    /// <summary>
    /// This method figures out what the default connection pool setting should

                  continue;
              }

              if (String.Equals(
                    pair.Key, "TextPassword",
                    StringComparison.OrdinalIgnoreCase))
              {
                  continue;
              }

              if (String.Equals(
                    pair.Key, "TextHexPassword",
                    StringComparison.OrdinalIgnoreCase))
              {
                  continue;
              }

              eventArgOpts.Add(pair.Key, pair.Value);
          }

          eventArgConnectionString = BuildConnectionString(

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

        if (stringValue != null)
            _binaryGuid = SQLiteConvert.ToBoolean(stringValue);

#if INTEROP_CODEC || INTEROP_INCLUDE_SEE
        string error; /* REUSED */
        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}",
                    error));
            }

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

            _sql.SetPassword(textHexPasswordBytes, true);
            _passwordWasText = true;
        }
        else
        {
            string textPassword = FindKey(opts, "TextPassword", DefaultTextPassword);

            if (textPassword != null)
            {


                byte[] textPasswordBytes = UTF8Encoding.UTF8.GetBytes(
                    textPassword); /* throw */



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



                _sql.SetPassword(textPasswordBytes, true);
                _passwordWasText = true;
            }
            else
            {
                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}",
                            error));
                    }

                    _sql.SetPassword(hexPasswordBytes, false);
                    _passwordWasText = false;
                }
                else
                {
                    string password = FindKey(opts, "Password", DefaultPassword);

                    if (password != null)
                    {
                        byte[] passwordBytes = UTF8Encoding.UTF8.GetBytes(
                            password); /* throw */

                        _sql.SetPassword(passwordBytes, false);
                        _passwordWasText = false;
                    }
                    else if (_password != null)
                    {
                        _sql.SetPassword(_password, _passwordWasText);
                    }

                    password = null; /* IMMUTABLE */
                }

                hexPassword = null; /* IMMUTABLE */
            }
        }

        textPassword = null; /* IMMUTABLE */
        _password = null; /* IMMUTABLE */

        if (hidePassword)
        {
            if (opts.ContainsKey("TextHexPassword"))
                opts["TextHexPassword"] = String.Empty;

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

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

            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");
        }

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

            return null;
        }
        set
        {
            this["textpassword"] = value;
        }
    }

    /// <summary>
    /// Gets/sets the database encryption textual password in hexadecimal
    /// </summary>
    [DisplayName("Textual Hexadecimal Password")]
    [Browsable(true)]
    [PasswordPropertyText(true)]
    [DefaultValue(null)]
    public byte[] TextHexPassword
    {
        get
        {
            object value;

            if (TryGetValue("texthexpassword", out value))
            {
                if (value is string)
                    return SQLiteConnection.FromHexString((string)value);
                else if (value != null)
                    return (byte[])value;
            }

            return null;
        }
        set
        {
            this["texthexpassword"] = SQLiteConnection.ToHexString(value);
        }
    }

    /// <summary>
    /// Gets/Sets the page size for the connection.
    /// </summary>
    [DisplayName("Page Size")]
    [Browsable(true)]
    [DefaultValue(4096)]

                   Password "Page Size" "Max Page Count" "Cache Size" \
                   DateTimeFormat DateTimeKind DateTimeFormatString \
                   BaseSchemaName "Journal Mode" "Default IsolationLevel" \
                   "Foreign Keys" Flags SetDefaults ToFullPath HexPassword \
                   DefaultDbType DefaultTypeName NoSharedFlags PrepareRetries \
                   ZipVfsVersion VfsName BusyTimeout ProgressOps \
                   NoDefaultFlags "Recursive Triggers" WaitTimeout \
                   TextPassword TextHexPassword]

    set values [list null 3 Normal True False \
                     True test.db test.db file:test.db 60 \
                     120 False True False True \
                     secret 4096 1024 8192 \
                     UnixEpoch Utc yyyy-MM-dd sqlite_schema \
                     Memory Serializable False \
                     Default False False 736563726574 String \
                     TEXT True 20 v2 test 1000 2000 True True 30000 \
                     textsecret 736563726574]

    set propertyNames [list null Version SyncMode UseUTF16Encoding Pooling \
                            BinaryGUID DataSource Uri FullUri DefaultTimeout \
                            DefaultMaximumSleepTime \
                            Enlist FailIfMissing LegacyFormat ReadOnly \
                            Password PageSize MaxPageCount CacheSize \
                            DateTimeFormat DateTimeKind DateTimeFormatString \
                            BaseSchemaName JournalMode DefaultIsolationLevel \
                            ForeignKeys Flags SetDefaults ToFullPath \
                            HexPassword DefaultDbType DefaultTypeName \
                            NoSharedFlags PrepareRetries ZipVfsVersion \
                            VfsName BusyTimeout ProgressOps NoDefaultFlags \
                            RecursiveTriggers WaitTimeout TextPassword \
                            TextHexPassword]

    foreach key $keys value $values propertyName $propertyNames {
      set code [catchCSharp {
        object invoke _Dynamic${id}.Test${id} GetConnectionString \
            $key $value $propertyName
      } result]

Max Page Count=1024\} 0 \{8192, Cache Size=8192\} 0 \{UnixEpoch,\
DateTimeFormat=UnixEpoch\} 0 \{Utc, DateTimeKind=Utc\} 0 \{yyyy-MM-dd,\
DateTimeFormatString=yyyy-MM-dd\} 0 \{sqlite_schema,\
BaseSchemaName=sqlite_schema\} 0 \{Memory, Journal Mode=Memory\} 0\
\{Serializable, Default IsolationLevel=Serializable\} 0 \{False, Foreign\
Keys=False\} 0 \{(?:Default|LogCallbackException),\
Flags=(?:Default|LogCallbackException)\} 0 \{False, SetDefaults=False\} 0\
\{False, ToFullPath=False\} 0 \{736563726574, HexPassword=736563726574\} 0\
\{String, DefaultDbType=String\} 0 \{TEXT, DefaultTypeName=TEXT\} 0 \{True,\
NoSharedFlags=True\} 0 \{20, PrepareRetries=20\} 0 \{v2, ZipVfsVersion=v2\} 0\
\{test, VfsName=test\} 0 \{1000, BusyTimeout=1000\} 0 \{2000,\
ProgressOps=2000\} 0 \{True, NoDefaultFlags=True\} 0 \{True, Recursive\
Triggers=True\} 0 \{30000, WaitTimeout=30000\} 0 \{textsecret,\
TextPassword=textsecret\} 0 \{736563726574, TextHexPassword=736563726574\}$}}

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

runTest {test data-1.18 {SQLiteConvert ToDateTime (Julian Day)} -body {
  set dateTime [object invoke -create System.Data.SQLite.SQLiteConvert \
      ToDateTime 2455928.0 Utc]

} -constraints {eagle System.Data.SQLite.Encryption monoBug28 command.sql\
compile.DATA SQLite System.Data.SQLite} -match regexp -result {^1 \{(?:file is\
not a database|database disk image is malformed)\} 1 \{(?:file is not a\
database|database disk image is malformed)\} 0 1 0 2$}}

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

runTest {test data-1.106 {TextHexPassword error (no encryption support)} -body {
  list [catch {
    setupDb [set fileName data-1.106.db] "" "" "" "" "TextHexPassword=1234;"
  } msg] [extractSystemDataSQLiteExceptionMessage $msg]
} -cleanup {
  cleanupDb $fileName

  unset -nocomplain msg db fileName
} -constraints [fixConstraints {eagle !System.Data.SQLite.Encryption monoBug28\
command.sql compile.DATA SQLite System.Data.SQLite}] -result {1 {SQL logic\
error -- Cannot use "TextHexPassword" connection string property: library was\
not built with encryption support, please see "https://www.sqlite.org/see" for\
more information}}}

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

runTest {test data-1.107 {encrypted database, w/TextHexPassword} -setup {
  setupDb [set fileName data-1.107.db] "" "" "" "" "TextHexPassword=1234;"
} -body {
  sql execute $db "CREATE TABLE t1(x);"
  sql execute $db "INSERT INTO t1 (x) VALUES(1);"

  cleanupDb $fileName db true false false
  setupDb $fileName "" "" "" "" "Password=1234;" true false

  set result [list]

  lappend result [catch {sql execute -execute scalar $db \
      "SELECT COUNT(*) FROM t1;"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  lappend result [catch {sql execute $db \
      "INSERT INTO t1 (x) VALUES(1);"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  cleanupDb $fileName db true false false
  setupDb $fileName "" "" "" "" "TextHexPassword=1234;" true false

  lappend result [catch {sql execute $db \
      "INSERT INTO t1 (x) VALUES(1);"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  lappend result [catch {sql execute -execute scalar $db \
      "SELECT COUNT(*) FROM t1;"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  set result
} -cleanup {
  cleanupDb $fileName

  unset -nocomplain error result db fileName
} -constraints {eagle System.Data.SQLite.Encryption monoBug28 command.sql\
compile.DATA SQLite System.Data.SQLite} -match regexp -result {^1 \{(?:file is\
not a database|database disk image is malformed)\} 1 \{(?:file is not a\
database|database disk image is malformed)\} 0 1 0 2$}}

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

runTest {test data-1.108 {contrib math functions} -setup {
  setupDb [set fileName data-1.108.db]
} -body {
  set results [list]

  set functionCalls [list \
      acos(0) acosh(1) asin(0) asinh(0) \
      atan(0) atan2(0,0) atn2(0,0) \
      atanh(0) ceil(0) ceiling(0) cos(0) \

{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
regexp -result {^0 1\.5707\d* 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0\
0\.6420\d* 0 1\.3130\d* 0 0 0 1 0 0 0 0 0 0 0 3\.1415\d* 0 1 0 0 0 0 0 0 0 0 0\
0 0 0 0 0 0 0$}}

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

runTest {test data-1.109 {contrib math functions w/NoCoreFunctions} -setup {
  setupDb [set fileName data-1.109.db] "" "" "" NoCoreFunctions
} -body {
  set results [list]

  set functionCalls [list \
      acos(0) acosh(1) asin(0) asinh(0) \
      atan(0) atan2(0,0) atn2(0,0) \
      atanh(0) ceil(0) ceiling(0) cos(0) \

} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite sqlite3_c99_math} -match regexp -result {^0 1\.5707\d* 0 0 0\
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0\.6420\d* 0 1\.3130\d* 0 0 0 1 0 0 0 0\
0 0 0 3\.1415\d* 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0$}}

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

runTest {test data-1.110 {core-only math functions} -setup {
  setupDb [set fileName data-1.110.db]
} -body {
  set results [list]

  set functionCalls [list \
      ln(1) log(2,1) log2(1) mod(1,1) \
      pow(0,0) trunc(0)]

  unset -nocomplain functionCall functionCalls
  unset -nocomplain db fileName
} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
System.Data.SQLite sqlite3_c99_math} -result {0 0 0 0 0 0 0 0 0 1 0 0}}

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

runTest {test data-1.111 {core-only math functions w/NoCoreFunctions} -setup {
  setupDb [set fileName data-1.111.db] "" "" "" NoCoreFunctions
} -body {
  set results [list]

  set functionCalls [list \
      ln(1) log(2,1) log2(1) mod(1,1) \
      pow(0,0) trunc(0)]

  lappend result [expr {
    [string first ";HexPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextHexPassword=;" [$connection ConnectionString]] != -1
  }]

  set result
} -cleanup {
  freeDbConnection

  unset -nocomplain connection

  lappend result [expr {
    [string first ";HexPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextHexPassword=;" [$connection ConnectionString]] != -1
  }]

  set result
} -cleanup {
  freeDbConnection

  unset -nocomplain connection

  lappend result [expr {
    [string first ";HexPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextHexPassword=;" [$connection ConnectionString]] != -1
  }]

  set result
} -cleanup {
  freeDbConnection

  unset -nocomplain connection

  cleanupDb $fileName

  unset -nocomplain error result db fileName
} -constraints {eagle System.Data.SQLite.Encryption monoBug28 command.sql\
compile.DATA SQLite System.Data.SQLite} -result \
{0 1 0 1 0 2 {} False False False True}}

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

runTest {test tkt-23d8d6171e-1.4 {HidePassword flag w/TextHexPassword} -setup {
  setupDb [set fileName tkt-23d8d6171e-1.4.db] "" "" "" HidePassword \
      "TextHexPassword=1234;"
} -body {
  sql execute $db "CREATE TABLE t1(x);"
  sql execute $db "INSERT INTO t1 (x) VALUES(1);"

  set result [list]

  lappend result [catch {sql execute -execute scalar $db \
      "SELECT COUNT(*) FROM t1;"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  lappend result [catch {sql execute $db \
      "INSERT INTO t1 (x) VALUES(1);"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  lappend result [catch {sql execute -execute scalar $db \
      "SELECT COUNT(*) FROM t1;"} error] \
      [extractSystemDataSQLiteExceptionMessage $error]

  set connection [getDbConnection]

  lappend result [$connection -flags +NonPublic _password]

  lappend result [expr {
    [string first 1234 [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";Password=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";HexPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextPassword=;" [$connection ConnectionString]] != -1
  }]

  lappend result [expr {
    [string first ";TextHexPassword=;" [$connection ConnectionString]] != -1
  }]

  set result
} -cleanup {
  freeDbConnection

  unset -nocomplain connection

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title></title>
</head>
<body>
ADO.NET SQLite Data Provider<br />
Version 1.0.118.0 - April XX, 2023 <font color="red">(release scheduled)</font><br />
Using <a href="https://www.sqlite.org/releaselog/3_40_0.html">SQLite 3.40.0</a><br />Originally written by Robert Simpson<br />
Released to the public domain, use at your own risk!<br />
Official provider website:&nbsp;<a href="https://system.data.sqlite.org/">https://system.data.sqlite.org/</a><br />
Legacy versions:&nbsp;<a href="https://sourceforge.net/projects/sqlite-dotnet2/">https://sourceforge.net/projects/sqlite-dotnet2/</a><br />
<br />
The current development version can be downloaded from <a href="https://system.data.sqlite.org/index.html/timeline?y=ci">
https://system.data.sqlite.org/index.html/timeline?y=ci</a>

designed for robustness and maximum backward compatibility with previously
released versions of System.Data.SQLite.
</p>

<h2><b>Version History</b></h2>

<p>
    <b>1.0.118.0 - April XX, 2023 <font color="red">(release scheduled)</font></b>
</p>
<ul>
    <li>Add the ConnectionStringPreview, SqlStringPreview, and Canceled connection events.</li>
    <li>Add support for the sqlite3_is_interrupted core library API. Pursuant to forum post [b6a707bffb].</li>
    <li>Add support for the sqlite_trace_v2 core library API. Pursuant to forum post [1c418d7edc].</li>
    <li>Add TextHexPassword connection string property for use with <a href="https://www.sqlite.org/see">SEE</a>.</li>
</ul>
<p>
    <b>1.0.117.0 - November 28, 2022</b>
</p>
<ul>
    <li>Updated to <a href="https://www.sqlite.org/releaselog/3_40_0.html">SQLite 3.40.0</a>.</li>
    <li>Add support for creating custom window functions. Pursuant to forum post [21de219031].</li>

    Access to archived release packages will be granted on a case-by-case basis.
  </li>
</ul>

<div align="center"><h2><b>Version History</b></h2></div>

<p>
    <b>1.0.118.0 - April XX, 2023 <font color="red">(release scheduled)</font></b>
</p>
<ul>
    <li>Add the ConnectionStringPreview, SqlStringPreview, and Canceled connection events.</li>
    <li>Add support for the sqlite3_is_interrupted core library API. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/b6a707bffb|b6a707bffb].</li>
    <li>Add support for the sqlite_trace_v2 core library API. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/1c418d7edc|1c418d7edc].</li>
    <li>Add TextHexPassword connection string property for use with [https://www.sqlite.org/see|SEE].</li>
</ul>
<p>
    <b>1.0.117.0 - November 28, 2022</b>
</p>
<ul>
    <li>Updated to [https://www.sqlite.org/releaselog/3_40_0.html|SQLite 3.40.0].</li>
    <li>Add support for creating custom window functions. Pursuant to forum post [https://www.sqlite.org/forum/forumpost/21de219031|21de219031].</li>