System.Data.SQLite
Check-in [5c62d58e23]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Merge updates from trunk.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | preRelease
Files: files | file ages | folders
SHA1: 5c62d58e237f8df468f36983a752246317191a3c
User & Date: mistachkin 2015-07-30 18:00:48
Context
2015-07-30
18:03
Revise new section (for .NET Framework 4.6) to match the existing ones. check-in: 4d23db1287 user: mistachkin tags: preRelease
18:00
Merge updates from trunk. check-in: 5c62d58e23 user: mistachkin tags: preRelease
17:59
Improve robustness of the download page update script. check-in: a2473ecc36 user: mistachkin tags: trunk
2015-07-24
00:32
Preliminary updates to the download page. check-in: 7dbf8439b5 user: mistachkin tags: preRelease
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to Doc/Extra/Core/lang_createtable.html.

   352    352     returned if the table cannot be created because of an existing index, even 
   353    353     if the "IF NOT EXISTS" clause is specified.
   354    354   
   355    355   <p>It is not an error to create a table that has the same name as an 
   356    356     existing <a href="lang_createtrigger.html">trigger</a>.
   357    357   
   358    358   <p>Tables are removed using the <a href="lang_droptable.html">DROP TABLE</a> statement.  </p>
          359  +
          360  +<a name="createtabas"></a>
   359    361   
   360    362   <h3>CREATE TABLE ... AS SELECT Statements</h3>
   361    363   
   362    364   <p>A "CREATE TABLE ... AS SELECT" statement creates and populates a database
   363    365   table based on the results of a SELECT statement. The table has the same
   364    366   number of columns as the rows returned by the SELECT statement. The name of
   365    367   each column is the same as the name of the corresponding column in the result

Changes to Doc/Extra/Core/pragma.html.

   221    221   <li><a href="#pragma_application_id">application_id</a>
   222    222   <li><a href="#pragma_auto_vacuum">auto_vacuum</a>
   223    223   <li><a href="#pragma_automatic_index">automatic_index</a>
   224    224   <li><a href="#pragma_busy_timeout">busy_timeout</a>
   225    225   <li><a href="#pragma_cache_size">cache_size</a>
   226    226   <li><a href="#pragma_cache_spill">cache_spill</a>
   227    227   <li><a href="#pragma_case_sensitive_like">case_sensitive_like</a>
          228  +<li><a href="#pragma_cell_size_check">cell_size_check</a>
   228    229   <li><a href="#pragma_checkpoint_fullfsync">checkpoint_fullfsync</a>
   229    230   <li><a href="#pragma_collation_list">collation_list</a>
   230    231   <li><a href="#pragma_compile_options">compile_options</a>
   231    232   <li><a href="#pragma_count_changes"><s>count_changes</s></a>&sup1;
   232    233   <li><a href="#pragma_data_store_directory"><s>data_store_directory</s></a>&sup1;
   233    234   <li><a href="#pragma_data_version">data_version</a>
   234    235   <li><a href="#pragma_database_list">database_list</a>
................................................................................
   257    258   <li><a href="#pragma_mmap_size">mmap_size</a>
   258    259   <li><a href="#pragma_page_count">page_count</a>
   259    260   <li><a href="#pragma_page_size">page_size</a>
   260    261   <li><a href="#pragma_parser_trace"><i>parser_trace</i></a>&sup2;
   261    262   <li><a href="#pragma_query_only">query_only</a>
   262    263   <li><a href="#pragma_quick_check">quick_check</a>
   263    264   <li><a href="#pragma_read_uncommitted">read_uncommitted</a>
   264         -</ul></td><td valign="top" align="left"><ul>
   265    265   <li><a href="#pragma_recursive_triggers">recursive_triggers</a>
          266  +</ul></td><td valign="top" align="left"><ul>
   266    267   <li><a href="#pragma_reverse_unordered_selects">reverse_unordered_selects</a>
   267    268   <li><a href="#pragma_schema_version">schema_version</a>
   268    269   <li><a href="#pragma_secure_delete">secure_delete</a>
   269    270   <li><a href="#pragma_short_column_names"><s>short_column_names</s></a>&sup1;
   270    271   <li><a href="#pragma_shrink_memory">shrink_memory</a>
   271    272   <li><a href="#pragma_soft_heap_limit">soft_heap_limit</a>
   272    273   <li><a href="#pragma_stats"><i>stats</i></a>&sup3;
................................................................................
   447    448       expressed.  When case_sensitive_like is enabled, case becomes
   448    449       significant.  So, for example,
   449    450       <b>'a' LIKE 'A'</b> is false but <b>'a' LIKE 'a'</b> is still true.</p>
   450    451   
   451    452       <p>This pragma uses <a href="c3ref/create_function.html">sqlite3_create_function()</a> to overload the
   452    453       LIKE and GLOB functions, which may override previous implementations
   453    454       of LIKE and GLOB registered by the application.</p>
          455  +<a name="pragma_cell_size_check"></a>
          456  +<hr>
          457  +    <p><b>PRAGMA cell_size_check
          458  +       <br>PRAGMA cell_size_check = </b><i>boolean</i><b>;</b></p>
          459  +    <p>The cell_size_check pragma enables or disables additional sanity
          460  +    checking on database b-tree pages as they are initially read from disk.
          461  +    With cell size checking enabled, database corruption is detected earlier
          462  +    and is less likely to "spread".  However, there is a small performance
          463  +    hit for doing the extra checks and so cell size checking is turned off
          464  +    by default.
   454    465   <a name="pragma_checkpoint_fullfsync"></a>
   455    466   <hr>
   456    467       <p><b>PRAGMA checkpoint_fullfsync
   457    468          <br>PRAGMA checkpoint_fullfsync = </b><i>boolean</i><b>;</b></p>
   458    469       <p>Query or change the fullfsync flag for <a href="wal.html#ckpt">checkpoint</a> operations.
   459    470       If this flag is set, then the F_FULLFSYNC syncing method is used
   460    471       during checkpoint operations on systems that support F_FULLFSYNC. 

Changes to Doc/Extra/Provider/version.html.

    41     41         </table>
    42     42       </div>
    43     43       <div id="mainSection">
    44     44       <div id="mainBody">
    45     45       <h1 class="heading">Version History</h1>
    46     46       <p><b>1.0.98.0 - August XX, 2015 <font color="red">(release scheduled)</font></b></p>
    47     47       <ul>
    48         -      <li>Updated to <a href="https://www.sqlite.org/draft/releaselog/3_8_11.html">SQLite 3.8.11</a>.</li>
           48  +      <li>Updated to <a href="https://www.sqlite.org/releaselog/3_8_11_1.html">SQLite 3.8.11.1</a>.</li>
    49     49         <li>Add full support for Visual Studio 2015 and the .NET Framework 4.6.</li>
    50     50         <li>Implement the Substring method for LINQ using the &quot;substr&quot; core SQL function.&nbsp;<b>** Potentially Incompatible Change **</b></li>
           51  +      <li>Honor the second argument to Math.Round when using LINQ.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    51     52         <li>Honor the pre-existing flags for connections during the Open method. Fix for <a href="https://system.data.sqlite.org/index.html/info/964063da16">[964063da16]</a>.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    52     53         <li>Remove errant semi-colons from the SQL used by LINQ to INSERT and then SELECT rows with composite primary keys. Fix for <a href="https://system.data.sqlite.org/index.html/info/9d353b0bd8">[9d353b0bd8]</a>.</li>
    53     54         <li>Change the base type for the SQLiteConnectionFlags enumeration to long integer.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    54     55         <li>Add extended return codes to the SQLiteErrorCode enumeration. Pursuant to <a href="https://system.data.sqlite.org/index.html/info/71bedaca19">[71bedaca19]</a>.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    55     56         <li>Improve exception handling in all native callbacks implemented in the SQLiteConnection class.</li>
    56     57         <li>Add Progress event and ProgressOps connection string property to enable raising progress events during long-running queries.</li>
           58  +      <li>Add &quot;Recursive Triggers&quot; connection string property to enable or disable the recursive trigger capability. Pursuant to <a href="https://system.data.sqlite.org/index.html/info/3a82ee635b">[3a82ee635b]</a>.</li>
    57     59         <li>Add NoDefaultFlags connection string property to prevent the default connection flags from being used. Pursuant to <a href="https://system.data.sqlite.org/index.html/info/964063da16">[964063da16]</a>.</li>
    58     60         <li>Add VfsName connection string property to allow a non-default VFS to be used by the SQLite core library.</li>
    59     61         <li>Add BusyTimeout connection string property to set the busy timeout to be used by the SQLite core library.</li>
    60     62         <li>Add UnbindFunction and UnbindAllFunctions methods to the SQLiteConnection class.</li>
    61     63         <li>Enable integration with the <a href="http://www.hwaci.com/sw/sqlite/zipvfs.html">ZipVFS</a> extension.</li>
    62     64       </ul>
    63     65       <p><b>1.0.97.0 - May 26, 2015</b></p>

Changes to Externals/Eagle/lib/Eagle1.0/vendor.eagle.

   336    336       #
   337    337       checkForTestOverrides stdout [expr {[info exists test_overrides] ? \
   338    338           $test_overrides : [list binary_directory build_base_directory \
   339    339           build_directory common_directory connection_flags database_directory \
   340    340           datetime_format execute_on_setup release_version scratch_directory \
   341    341           temporary_directory test_clr test_clr_v2 test_clr_v4 \
   342    342           test_configuration test_configurations test_constraints test_machine \
   343         -        test_net_fx test_overrides test_platform test_suite test_year \
   344         -        test_years test_year_clr_v2 test_year_clr_v4 vendor_directory \
   345         -        vendor_test_directory]}] false
          343  +        test_net_fx test_net_fx_2005 test_net_fx_2008 test_net_fx_2010 \
          344  +        test_net_fx_2012 test_net_fx_2013 test_net_fx_2015 test_overrides \
          345  +        test_platform test_suite test_year test_years test_year_clr_v2 \
          346  +        test_year_clr_v4 vendor_directory vendor_test_directory]}] false
   346    347   
   347    348       #
   348    349       # NOTE: Set the name of the running test suite, if necessary.
   349    350       #
   350    351       if {![info exists test_suite]} then {
   351    352         set test_suite "System.Data.SQLite Test Suite for Eagle"
   352    353       }

Changes to SQLite.Interop/props/sqlite3.props.

     5      5    *
     6      6    * Written by Joe Mistachkin.
     7      7    * Released to the public domain, use at your own risk!
     8      8    *
     9      9   -->
    10     10   <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
    11     11     <PropertyGroup Label="UserMacros">
    12         -    <SQLITE_MANIFEST_VERSION>3.8.11.0</SQLITE_MANIFEST_VERSION>
    13         -    <SQLITE_RC_VERSION>3,8,11,0</SQLITE_RC_VERSION>
           12  +    <SQLITE_MANIFEST_VERSION>3.8.11.1</SQLITE_MANIFEST_VERSION>
           13  +    <SQLITE_RC_VERSION>3,8,11,1</SQLITE_RC_VERSION>
    14     14       <SQLITE_COMMON_DEFINES>_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS;SQLITE_THREADSAFE=1;SQLITE_USE_URI=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_STAT4=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_FTS5=1;SQLITE_ENABLE_LOAD_EXTENSION=1;SQLITE_ENABLE_RTREE=1;SQLITE_SOUNDEX=1;SQLITE_ENABLE_MEMORY_MANAGEMENT=1</SQLITE_COMMON_DEFINES>
    15     15       <SQLITE_EXTRA_DEFINES>SQLITE_PLACEHOLDER=1;SQLITE_HAS_CODEC=1</SQLITE_EXTRA_DEFINES>
    16     16       <SQLITE_WINCE_200X_DEFINES>SQLITE_OMIT_WAL=1</SQLITE_WINCE_200X_DEFINES>
    17     17       <SQLITE_WINCE_2013_DEFINES>HAVE_ERRNO_H=1;SQLITE_MSVC_LOCALTIME_API=1</SQLITE_WINCE_2013_DEFINES>
    18     18       <SQLITE_DEBUG_DEFINES>SQLITE_DEBUG=1;SQLITE_MEMDEBUG=1;SQLITE_ENABLE_EXPENSIVE_ASSERT=1</SQLITE_DEBUG_DEFINES>
    19     19       <SQLITE_RELEASE_DEFINES>SQLITE_WIN32_MALLOC=1</SQLITE_RELEASE_DEFINES>
    20     20       <SQLITE_DISABLE_WARNINGS>4055;4100;4127;4146;4210;4232;4244;4245;4267;4306;4389;4701;4703;4706</SQLITE_DISABLE_WARNINGS>

Changes to SQLite.Interop/props/sqlite3.vsprops.

    10     10   <VisualStudioPropertySheet
    11     11   	ProjectType="Visual C++"
    12     12   	Version="8.00"
    13     13   	Name="sqlite3"
    14     14   	>
    15     15   	<UserMacro
    16     16   		Name="SQLITE_MANIFEST_VERSION"
    17         -		Value="3.8.11.0"
           17  +		Value="3.8.11.1"
    18     18   		PerformEnvironmentSet="true"
    19     19   	/>
    20     20   	<UserMacro
    21     21   		Name="SQLITE_RC_VERSION"
    22         -		Value="3,8,11,0"
           22  +		Value="3,8,11,1"
    23     23   		PerformEnvironmentSet="true"
    24     24   	/>
    25     25   	<UserMacro
    26     26   		Name="SQLITE_COMMON_DEFINES"
    27     27   		Value="_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_DEPRECATE;_CRT_NONSTDC_NO_WARNINGS;SQLITE_THREADSAFE=1;SQLITE_USE_URI=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_STAT4=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_FTS5=1;SQLITE_ENABLE_LOAD_EXTENSION=1;SQLITE_ENABLE_RTREE=1;SQLITE_SOUNDEX=1;SQLITE_ENABLE_MEMORY_MANAGEMENT=1"
    28     28   		PerformEnvironmentSet="true"
    29     29   	/>

Changes to SQLite.Interop/src/core/sqlite3.c.

     1      1   /******************************************************************************
     2      2   ** This file is an amalgamation of many separate C source files from SQLite
     3         -** version 3.8.11.  By combining all the individual C code files into this 
            3  +** version 3.8.11.1.  By combining all the individual C code files into this 
     4      4   ** single large file, the entire code can be compiled as a single translation
     5      5   ** unit.  This allows many compilers to do optimizations that would not be
     6      6   ** possible if the files were compiled separately.  Performance improvements
     7      7   ** of 5% or more are commonly seen when SQLite is compiled as a single
     8      8   ** translation unit.
     9      9   **
    10     10   ** This file is all you need to compile SQLite.  To use SQLite in other
................................................................................
   321    321   ** string contains the date and time of the check-in (UTC) and an SHA1
   322    322   ** hash of the entire source tree.
   323    323   **
   324    324   ** See also: [sqlite3_libversion()],
   325    325   ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
   326    326   ** [sqlite_version()] and [sqlite_source_id()].
   327    327   */
   328         -#define SQLITE_VERSION        "3.8.11"
          328  +#define SQLITE_VERSION        "3.8.11.1"
   329    329   #define SQLITE_VERSION_NUMBER 3008011
   330         -#define SQLITE_SOURCE_ID      "2015-07-24 00:02:15 119883a21bdcab66c15d1e80f3da20addda328ad"
          330  +#define SQLITE_SOURCE_ID      "2015-07-29 20:00:57 cf538e2783e468bbc25e7cb2a9ee64d3e0e80b2f"
   331    331   
   332    332   /*
   333    333   ** CAPI3REF: Run-Time Library Version Numbers
   334    334   ** KEYWORDS: sqlite3_version, sqlite3_sourceid
   335    335   **
   336    336   ** These interfaces provide the same information as the [SQLITE_VERSION],
   337    337   ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
  3772   3772   SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*, int);
  3773   3773   SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
  3774   3774   SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
  3775   3775   SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
  3776   3776                            void(*)(void*), unsigned char encoding);
  3777   3777   SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
  3778   3778   SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
         3779  +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64);
  3779   3780   
  3780   3781   /*
  3781   3782   ** CAPI3REF: Number Of SQL Parameters
  3782   3783   ** METHOD: sqlite3_stmt
  3783   3784   **
  3784   3785   ** ^This routine can be used to find the number of [SQL parameters]
  3785   3786   ** in a [prepared statement].  SQL parameters are tokens of the
................................................................................
  4744   4745   ** Refer to the [SQL parameter] documentation for additional information.
  4745   4746   **
  4746   4747   ** ^The sqlite3_result_blob() interface sets the result from
  4747   4748   ** an application-defined function to be the BLOB whose content is pointed
  4748   4749   ** to by the second parameter and which is N bytes long where N is the
  4749   4750   ** third parameter.
  4750   4751   **
  4751         -** ^The sqlite3_result_zeroblob() interfaces set the result of
  4752         -** the application-defined function to be a BLOB containing all zero
  4753         -** bytes and N bytes in size, where N is the value of the 2nd parameter.
         4752  +** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N)
         4753  +** interfaces set the result of the application-defined function to be
         4754  +** a BLOB containing all zero bytes and N bytes in size.
  4754   4755   **
  4755   4756   ** ^The sqlite3_result_double() interface sets the result from
  4756   4757   ** an application-defined function to be a floating point value specified
  4757   4758   ** by its 2nd argument.
  4758   4759   **
  4759   4760   ** ^The sqlite3_result_error() and sqlite3_result_error16() functions
  4760   4761   ** cause the implemented SQL function to throw an exception.
................................................................................
  4861   4862   SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
  4862   4863                              void(*)(void*), unsigned char encoding);
  4863   4864   SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
  4864   4865   SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
  4865   4866   SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
  4866   4867   SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*);
  4867   4868   SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*, int n);
         4869  +SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);
  4868   4870   
  4869   4871   /*
  4870   4872   ** CAPI3REF: Define New Collating Sequences
  4871   4873   ** METHOD: sqlite3
  4872   4874   **
  4873   4875   ** ^These functions add, remove, or modify a [collation] associated
  4874   4876   ** with the [database connection] specified as the first argument.
................................................................................
  8359   8361   #  define SQLITE_NOINLINE
  8360   8362   #endif
  8361   8363   
  8362   8364   /*
  8363   8365   ** Make sure that the compiler intrinsics we desire are enabled when
  8364   8366   ** compiling with an appropriate version of MSVC.
  8365   8367   */
  8366         -#if defined(_MSC_VER) && _MSC_VER>=1300 && !defined(_WIN32_WCE)
  8367         -#  include <intrin.h>
  8368         -#  pragma intrinsic(_byteswap_ushort)
  8369         -#  pragma intrinsic(_byteswap_ulong)
         8368  +#if defined(_MSC_VER) && _MSC_VER>=1300
         8369  +#  if !defined(_WIN32_WCE)
         8370  +#    include <intrin.h>
         8371  +#    pragma intrinsic(_byteswap_ushort)
         8372  +#    pragma intrinsic(_byteswap_ulong)
         8373  +#  else
         8374  +#    include <cmnintrin.h>
         8375  +#  endif
  8370   8376   #endif
  8371   8377   
  8372   8378   /*
  8373   8379   ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
  8374   8380   ** 0 means mutexes are permanently disable and the library is never
  8375   8381   ** threadsafe.  1 means the library is serialized which is the highest
  8376   8382   ** level of threadsafety.  2 means the library is multithreaded - multiple
................................................................................
 70297  70303   /**************************** sqlite3_value_  *******************************
 70298  70304   ** The following routines extract information from a Mem or sqlite3_value
 70299  70305   ** structure.
 70300  70306   */
 70301  70307   SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value *pVal){
 70302  70308     Mem *p = (Mem*)pVal;
 70303  70309     if( p->flags & (MEM_Blob|MEM_Str) ){
 70304         -    sqlite3VdbeMemExpandBlob(p);
        70310  +    if( sqlite3VdbeMemExpandBlob(p)!=SQLITE_OK ){
        70311  +      assert( p->flags==MEM_Null && p->z==0 );
        70312  +      return 0;
        70313  +    }
 70305  70314       p->flags |= MEM_Blob;
 70306  70315       return p->n ? p->z : 0;
 70307  70316     }else{
 70308  70317       return sqlite3_value_text(pVal);
 70309  70318     }
 70310  70319   }
 70311  70320   SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value *pVal){
................................................................................
 70558  70567   SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
 70559  70568     assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
 70560  70569     sqlite3VdbeMemCopy(pCtx->pOut, pValue);
 70561  70570   }
 70562  70571   SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
 70563  70572     assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
 70564  70573     sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
        70574  +}
        70575  +SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
        70576  +  Mem *pOut = pCtx->pOut;
        70577  +  assert( sqlite3_mutex_held(pOut->db->mutex) );
        70578  +  if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
        70579  +    return SQLITE_TOOBIG;
        70580  +  }
        70581  +  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
        70582  +  return SQLITE_OK;
 70565  70583   }
 70566  70584   SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
 70567  70585     pCtx->isError = errCode;
 70568  70586     pCtx->fErrorOrAux = 1;
 70569  70587   #ifdef SQLITE_DEBUG
 70570  70588     if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
 70571  70589   #endif
................................................................................
 71537  71555     Vdbe *p = (Vdbe *)pStmt;
 71538  71556     rc = vdbeUnbind(p, i);
 71539  71557     if( rc==SQLITE_OK ){
 71540  71558       sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
 71541  71559       sqlite3_mutex_leave(p->db->mutex);
 71542  71560     }
 71543  71561     return rc;
        71562  +}
        71563  +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
        71564  +  int rc;
        71565  +  Vdbe *p = (Vdbe *)pStmt;
        71566  +  sqlite3_mutex_enter(p->db->mutex);
        71567  +  if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
        71568  +    rc = SQLITE_TOOBIG;
        71569  +  }else{
        71570  +    assert( (n & 0x7FFFFFFF)==n );
        71571  +    rc = sqlite3_bind_zeroblob(pStmt, i, n);
        71572  +  }
        71573  +  rc = sqlite3ApiExit(p->db, rc);
        71574  +  sqlite3_mutex_leave(p->db->mutex);
        71575  +  return rc;
 71544  71576   }
 71545  71577   
 71546  71578   /*
 71547  71579   ** Return the number of wildcards that can be potentially bound to.
 71548  71580   ** This routine is added to support DBD::SQLite.  
 71549  71581   */
 71550  71582   SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
................................................................................
 74754  74786     pRec = pLast;
 74755  74787     do{
 74756  74788       assert( memIsValid(pRec) );
 74757  74789       pRec->uTemp = serial_type = sqlite3VdbeSerialType(pRec, file_format);
 74758  74790       len = sqlite3VdbeSerialTypeLen(serial_type);
 74759  74791       if( pRec->flags & MEM_Zero ){
 74760  74792         if( nData ){
 74761         -        sqlite3VdbeMemExpandBlob(pRec);
        74793  +        if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem;
 74762  74794         }else{
 74763  74795           nZero += pRec->u.nZero;
 74764  74796           len -= pRec->u.nZero;
 74765  74797         }
 74766  74798       }
 74767  74799       nData += len;
 74768  74800       testcase( serial_type==127 );
................................................................................
 98639  98671   */
 98640  98672   static void zeroblobFunc(
 98641  98673     sqlite3_context *context,
 98642  98674     int argc,
 98643  98675     sqlite3_value **argv
 98644  98676   ){
 98645  98677     i64 n;
 98646         -  sqlite3 *db = sqlite3_context_db_handle(context);
        98678  +  int rc;
 98647  98679     assert( argc==1 );
 98648  98680     UNUSED_PARAMETER(argc);
 98649  98681     n = sqlite3_value_int64(argv[0]);
 98650         -  testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
 98651         -  testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
 98652         -  if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
 98653         -    sqlite3_result_error_toobig(context);
 98654         -  }else{
 98655         -    sqlite3_result_zeroblob(context, (int)n); /* IMP: R-00293-64994 */
        98682  +  if( n<0 ) n = 0;
        98683  +  rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
        98684  +  if( rc ){
        98685  +    sqlite3_result_error_code(context, rc);
 98656  98686     }
 98657  98687   }
 98658  98688   
 98659  98689   /*
 98660  98690   ** The replace() function.  Three arguments are all strings: call
 98661  98691   ** them A, B, and C. The result is also a string which is derived
 98662  98692   ** from A by replacing every occurrence of B with C.  The match
................................................................................
102718 102748       sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
102719 102749       sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
102720 102750     }else{
102721 102751       sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
102722 102752       sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
102723 102753     }
102724 102754     for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
102725         -    u8 useSeekResult = 0;
       102755  +    u8 idxInsFlags = 0;
102726 102756       for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
102727 102757         if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
102728 102758       }
102729 102759       assert( pSrcIdx );
102730 102760       sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
102731 102761       sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
102732 102762       VdbeComment((v, "%s", pSrcIdx->zName));
................................................................................
102753 102783         ** sorted order.  */
102754 102784         for(i=0; i<pSrcIdx->nColumn; i++){
102755 102785           char *zColl = pSrcIdx->azColl[i];
102756 102786           assert( zColl!=0 );
102757 102787           if( sqlite3_stricmp("BINARY", zColl) ) break;
102758 102788         }
102759 102789         if( i==pSrcIdx->nColumn ){
102760         -        useSeekResult = OPFLAG_USESEEKRESULT;
       102790  +        idxInsFlags = OPFLAG_USESEEKRESULT;
102761 102791           sqlite3VdbeAddOp3(v, OP_Last, iDest, 0, -1);
102762 102792         }
       102793  +    }
       102794  +    if( !HasRowid(pSrc) && pDestIdx->idxType==2 ){
       102795  +      idxInsFlags |= OPFLAG_NCHANGE;
102763 102796       }
102764 102797       sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
102765         -    sqlite3VdbeChangeP5(v, useSeekResult);
       102798  +    sqlite3VdbeChangeP5(v, idxInsFlags);
102766 102799       sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
102767 102800       sqlite3VdbeJumpHere(v, addr1);
102768 102801       sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
102769 102802       sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
102770 102803     }
102771 102804     if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
102772 102805     sqlite3ReleaseTempReg(pParse, regRowid);
................................................................................
103219 103252                           void(*)(void*));
103220 103253     void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
103221 103254                            void(*)(void*), unsigned char);
103222 103255     int (*strglob)(const char*,const char*);
103223 103256     /* Version 3.8.11 and later */
103224 103257     sqlite3_value *(*value_dup)(const sqlite3_value*);
103225 103258     void (*value_free)(sqlite3_value*);
       103259  +  int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
       103260  +  int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
103226 103261   };
103227 103262   
103228 103263   /*
103229 103264   ** The following macros redefine the API routines so that they are
103230 103265   ** redirected through the global sqlite3_api structure.
103231 103266   **
103232 103267   ** This header file is also used by the loadext.c source file
................................................................................
103452 103487   #define sqlite3_reset_auto_extension   sqlite3_api->reset_auto_extension
103453 103488   #define sqlite3_result_blob64          sqlite3_api->result_blob64
103454 103489   #define sqlite3_result_text64          sqlite3_api->result_text64
103455 103490   #define sqlite3_strglob                sqlite3_api->strglob
103456 103491   /* Version 3.8.11 and later */
103457 103492   #define sqlite3_value_dup              sqlite3_api->value_dup
103458 103493   #define sqlite3_value_free             sqlite3_api->value_free
       103494  +#define sqlite3_result_zeroblob64      sqlite3_api->result_zeroblob64
       103495  +#define sqlite3_bind_zeroblob64        sqlite3_api->bind_zeroblob64
103459 103496   #endif /* SQLITE_CORE */
103460 103497   
103461 103498   #ifndef SQLITE_CORE
103462 103499     /* This case when the file really is being compiled as a loadable 
103463 103500     ** extension */
103464 103501   # define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
103465 103502   # define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;
................................................................................
103861 103898     sqlite3_realloc64,
103862 103899     sqlite3_reset_auto_extension,
103863 103900     sqlite3_result_blob64,
103864 103901     sqlite3_result_text64,
103865 103902     sqlite3_strglob,
103866 103903     /* Version 3.8.11 and later */
103867 103904     (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup,
103868         -  sqlite3_value_free
       103905  +  sqlite3_value_free,
       103906  +  sqlite3_result_zeroblob64,
       103907  +  sqlite3_bind_zeroblob64
103869 103908   };
103870 103909   
103871 103910   /*
103872 103911   ** Attempt to load an SQLite extension library contained in the file
103873 103912   ** zFile.  The entry point is zProc.  zProc may be 0 in which case a
103874 103913   ** default entry point name (sqlite3_extension_init) is used.  Use
103875 103914   ** of the default name is recommended.
................................................................................
105426 105465       if( !zRight ){
105427 105466         if( sqlite3ReadSchema(pParse) ) goto pragma_out;
105428 105467         returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
105429 105468       }else{
105430 105469         int size = sqlite3Atoi(zRight);
105431 105470         pDb->pSchema->cache_size = size;
105432 105471         sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
       105472  +      if( sqlite3ReadSchema(pParse) ) goto pragma_out;
105433 105473       }
105434 105474       break;
105435 105475     }
105436 105476   
105437 105477     /*
105438 105478     **  PRAGMA [database.]mmap_size(N)
105439 105479     **
................................................................................
138648 138688     ** scanned in forward order, and the phrase consists of 
138649 138689     ** MAX_INCR_PHRASE_TOKENS or fewer tokens, none of which are are "^first"
138650 138690     ** tokens or prefix tokens that cannot use a prefix-index.  */
138651 138691     int bHaveIncr = 0;
138652 138692     int bIncrOk = (bOptOk 
138653 138693      && pCsr->bDesc==pTab->bDescIdx 
138654 138694      && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0
138655         -   && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0
138656 138695   #ifdef SQLITE_TEST
138657 138696      && pTab->bNoIncrDoclist==0
138658 138697   #endif
138659 138698     );
138660 138699     for(i=0; bIncrOk==1 && i<p->nToken; i++){
138661 138700       Fts3PhraseToken *pToken = &p->aToken[i];
138662 138701       if( pToken->bFirst || (pToken->pSegcsr!=0 && !pToken->pSegcsr->bLookup) ){
................................................................................
156920 156959   **  update database than is strictly necessary.
156921 156960   ** 
156922 156961   */
156923 156962   
156924 156963   /* #include <assert.h> */
156925 156964   /* #include <string.h> */
156926 156965   /* #include <stdio.h> */
156927         -/* #include <unistd.h> */
       156966  +
       156967  +#if !defined(_WIN32)
       156968  +/* #  include <unistd.h> */
       156969  +#endif
156928 156970   
156929 156971   /* #include "sqlite3.h" */
156930 156972   
156931 156973   #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
156932 156974   /************** Include sqlite3rbu.h in the middle of sqlite3rbu.c ***********/
156933 156975   /************** Begin file sqlite3rbu.h **************************************/
156934 156976   /*
................................................................................
157827 157869   */
157828 157870   static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
157829 157871     int rc;
157830 157872     memset(pIter, 0, sizeof(RbuObjIter));
157831 157873   
157832 157874     rc = prepareAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg, 
157833 157875         "SELECT substr(name, 6) FROM sqlite_master "
157834         -      "WHERE type='table' AND name LIKE 'data_%'"
       157876  +      "WHERE type IN ('table', 'view') AND name LIKE 'data_%'"
157835 157877     );
157836 157878   
157837 157879     if( rc==SQLITE_OK ){
157838 157880       rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
157839 157881           "SELECT name, rootpage, sql IS NULL OR substr(8, 6)=='UNIQUE' "
157840 157882           "  FROM main.sqlite_master "
157841 157883           "  WHERE type='index' AND tbl_name = ?"
................................................................................
157879 157921   **
157880 157922   ** If an error occurs, an error code and error message is stored in the
157881 157923   ** RBU handle. If an error has already occurred when this function is
157882 157924   ** called, it is a no-op.
157883 157925   */
157884 157926   static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){
157885 157927     va_list ap;
       157928  +  char *zSql;
157886 157929     va_start(ap, zFmt);
157887         -  char *zSql = sqlite3_vmprintf(zFmt, ap);
       157930  +  zSql = sqlite3_vmprintf(zFmt, ap);
157888 157931     if( p->rc==SQLITE_OK ){
157889 157932       if( zSql==0 ){
157890 157933         p->rc = SQLITE_NOMEM;
157891 157934       }else{
157892 157935         p->rc = sqlite3_exec(db, zSql, 0, 0, &p->zErrmsg);
157893 157936       }
157894 157937     }
................................................................................
159899 159942   */
159900 159943   static void rbuCreateVfs(sqlite3rbu *p){
159901 159944     int rnd;
159902 159945     char zRnd[64];
159903 159946   
159904 159947     assert( p->rc==SQLITE_OK );
159905 159948     sqlite3_randomness(sizeof(int), (void*)&rnd);
159906         -  sprintf(zRnd, "rbu_vfs_%d", rnd);
       159949  +  sqlite3_snprintf(sizeof(zRnd), zRnd, "rbu_vfs_%d", rnd);
159907 159950     p->rc = sqlite3rbu_create_vfs(zRnd, 0);
159908 159951     if( p->rc==SQLITE_OK ){
159909 159952       sqlite3_vfs *pVfs = sqlite3_vfs_find(zRnd);
159910 159953       assert( pVfs );
159911 159954       p->zVfsName = pVfs->zName;
159912 159955     }
159913 159956   }
................................................................................
160784 160827   }
160785 160828   
160786 160829   /*
160787 160830   ** Close the dynamic library handle pHandle.
160788 160831   */
160789 160832   static void rbuVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
160790 160833     sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
160791         -  return pRealVfs->xDlClose(pRealVfs, pHandle);
       160834  +  pRealVfs->xDlClose(pRealVfs, pHandle);
160792 160835   }
160793 160836   #endif /* SQLITE_OMIT_LOAD_EXTENSION */
160794 160837   
160795 160838   /*
160796 160839   ** Populate the buffer pointed to by zBufOut with nByte bytes of 
160797 160840   ** random data.
160798 160841   */

Changes to SQLite.Interop/src/core/sqlite3.h.

   107    107   ** string contains the date and time of the check-in (UTC) and an SHA1
   108    108   ** hash of the entire source tree.
   109    109   **
   110    110   ** See also: [sqlite3_libversion()],
   111    111   ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
   112    112   ** [sqlite_version()] and [sqlite_source_id()].
   113    113   */
   114         -#define SQLITE_VERSION        "3.8.11"
          114  +#define SQLITE_VERSION        "3.8.11.1"
   115    115   #define SQLITE_VERSION_NUMBER 3008011
   116         -#define SQLITE_SOURCE_ID      "2015-07-24 00:02:15 119883a21bdcab66c15d1e80f3da20addda328ad"
          116  +#define SQLITE_SOURCE_ID      "2015-07-29 20:00:57 cf538e2783e468bbc25e7cb2a9ee64d3e0e80b2f"
   117    117   
   118    118   /*
   119    119   ** CAPI3REF: Run-Time Library Version Numbers
   120    120   ** KEYWORDS: sqlite3_version, sqlite3_sourceid
   121    121   **
   122    122   ** These interfaces provide the same information as the [SQLITE_VERSION],
   123    123   ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
  3558   3558   SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*, int);
  3559   3559   SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
  3560   3560   SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
  3561   3561   SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
  3562   3562                            void(*)(void*), unsigned char encoding);
  3563   3563   SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
  3564   3564   SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
         3565  +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64);
  3565   3566   
  3566   3567   /*
  3567   3568   ** CAPI3REF: Number Of SQL Parameters
  3568   3569   ** METHOD: sqlite3_stmt
  3569   3570   **
  3570   3571   ** ^This routine can be used to find the number of [SQL parameters]
  3571   3572   ** in a [prepared statement].  SQL parameters are tokens of the
................................................................................
  4530   4531   ** Refer to the [SQL parameter] documentation for additional information.
  4531   4532   **
  4532   4533   ** ^The sqlite3_result_blob() interface sets the result from
  4533   4534   ** an application-defined function to be the BLOB whose content is pointed
  4534   4535   ** to by the second parameter and which is N bytes long where N is the
  4535   4536   ** third parameter.
  4536   4537   **
  4537         -** ^The sqlite3_result_zeroblob() interfaces set the result of
  4538         -** the application-defined function to be a BLOB containing all zero
  4539         -** bytes and N bytes in size, where N is the value of the 2nd parameter.
         4538  +** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N)
         4539  +** interfaces set the result of the application-defined function to be
         4540  +** a BLOB containing all zero bytes and N bytes in size.
  4540   4541   **
  4541   4542   ** ^The sqlite3_result_double() interface sets the result from
  4542   4543   ** an application-defined function to be a floating point value specified
  4543   4544   ** by its 2nd argument.
  4544   4545   **
  4545   4546   ** ^The sqlite3_result_error() and sqlite3_result_error16() functions
  4546   4547   ** cause the implemented SQL function to throw an exception.
................................................................................
  4647   4648   SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
  4648   4649                              void(*)(void*), unsigned char encoding);
  4649   4650   SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
  4650   4651   SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
  4651   4652   SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
  4652   4653   SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*);
  4653   4654   SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*, int n);
         4655  +SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);
  4654   4656   
  4655   4657   /*
  4656   4658   ** CAPI3REF: Define New Collating Sequences
  4657   4659   ** METHOD: sqlite3
  4658   4660   **
  4659   4661   ** ^These functions add, remove, or modify a [collation] associated
  4660   4662   ** with the [database connection] specified as the first argument.

Changes to SQLite.Interop/src/core/sqlite3ext.h.

   266    266                           void(*)(void*));
   267    267     void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
   268    268                            void(*)(void*), unsigned char);
   269    269     int (*strglob)(const char*,const char*);
   270    270     /* Version 3.8.11 and later */
   271    271     sqlite3_value *(*value_dup)(const sqlite3_value*);
   272    272     void (*value_free)(sqlite3_value*);
          273  +  int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
          274  +  int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
   273    275   };
   274    276   
   275    277   /*
   276    278   ** The following macros redefine the API routines so that they are
   277    279   ** redirected through the global sqlite3_api structure.
   278    280   **
   279    281   ** This header file is also used by the loadext.c source file
................................................................................
   499    501   #define sqlite3_reset_auto_extension   sqlite3_api->reset_auto_extension
   500    502   #define sqlite3_result_blob64          sqlite3_api->result_blob64
   501    503   #define sqlite3_result_text64          sqlite3_api->result_text64
   502    504   #define sqlite3_strglob                sqlite3_api->strglob
   503    505   /* Version 3.8.11 and later */
   504    506   #define sqlite3_value_dup              sqlite3_api->value_dup
   505    507   #define sqlite3_value_free             sqlite3_api->value_free
          508  +#define sqlite3_result_zeroblob64      sqlite3_api->result_zeroblob64
          509  +#define sqlite3_bind_zeroblob64        sqlite3_api->bind_zeroblob64
   506    510   #endif /* SQLITE_CORE */
   507    511   
   508    512   #ifndef SQLITE_CORE
   509    513     /* This case when the file really is being compiled as a loadable 
   510    514     ** extension */
   511    515   # define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
   512    516   # define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;

Changes to SQLite.Interop/src/ext/fts5.c.

  2836   2836   
  2837   2837     i64 iRowid;                     /* Current rowid */
  2838   2838     Fts5ExprNearset *pNear;         /* For FTS5_STRING - cluster of phrases */
  2839   2839   
  2840   2840     /* Child nodes. For a NOT node, this array always contains 2 entries. For 
  2841   2841     ** AND or OR nodes, it contains 2 or more entries.  */
  2842   2842     int nChild;                     /* Number of child nodes */
  2843         -  Fts5ExprNode *apChild[0];       /* Array of child nodes */
         2843  +  Fts5ExprNode *apChild[1];       /* Array of child nodes */
  2844   2844   };
  2845   2845   
  2846   2846   #define Fts5NodeIsString(p) ((p)->eType==FTS5_TERM || (p)->eType==FTS5_STRING)
  2847   2847   
  2848   2848   /*
  2849   2849   ** An instance of the following structure represents a single search term
  2850   2850   ** or term prefix.
................................................................................
  4395   4395         nChild = 2;
  4396   4396       }else if( eType==FTS5_AND || eType==FTS5_OR ){
  4397   4397         nChild = 2;
  4398   4398         if( pLeft->eType==eType ) nChild += pLeft->nChild-1;
  4399   4399         if( pRight->eType==eType ) nChild += pRight->nChild-1;
  4400   4400       }
  4401   4401   
  4402         -    nByte = sizeof(Fts5ExprNode) + sizeof(Fts5ExprNode*)*nChild;
         4402  +    nByte = sizeof(Fts5ExprNode) + sizeof(Fts5ExprNode*)*(nChild-1);
  4403   4403       pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
  4404   4404   
  4405   4405       if( pRet ){
  4406   4406         pRet->eType = eType;
  4407   4407         pRet->pNear = pNear;
  4408   4408         if( eType==FTS5_STRING ){
  4409   4409           int iPhrase;
................................................................................
  9037   9037     bOldest = (pLvlOut->nSeg==1 && pStruct->nLevel==iLvl+2);
  9038   9038   
  9039   9039     assert( iLvl>=0 );
  9040   9040     for(fts5MultiIterNew(p, pStruct, 0, 0, 0, 0, iLvl, nInput, &pIter);
  9041   9041         fts5MultiIterEof(p, pIter)==0;
  9042   9042         fts5MultiIterNext(p, pIter, 0, 0)
  9043   9043     ){
  9044         -    Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
         9044  +    Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
  9045   9045       int nPos;                     /* position-list size field value */
  9046   9046       int nTerm;
  9047   9047       const u8 *pTerm;
  9048   9048   
  9049   9049       /* Check for key annihilation. */
  9050         -    if( pSeg->nPos==0 && (bOldest || pSeg->bDel==0) ) continue;
         9050  +    if( pSegIter->nPos==0 && (bOldest || pSegIter->bDel==0) ) continue;
  9051   9051   
  9052   9052       pTerm = fts5MultiIterTerm(pIter, &nTerm);
  9053   9053       if( nTerm!=term.n || memcmp(pTerm, term.p, nTerm) ){
  9054   9054         if( pnRem && writer.nLeafWritten>nRem ){
  9055   9055           break;
  9056   9056         }
  9057   9057   
................................................................................
  9062   9062         fts5WriteAppendTerm(p, &writer, nTerm, pTerm);
  9063   9063         fts5BufferSet(&p->rc, &term, nTerm, pTerm);
  9064   9064         bRequireDoclistTerm = 1;
  9065   9065       }
  9066   9066   
  9067   9067       /* Append the rowid to the output */
  9068   9068       /* WRITEPOSLISTSIZE */
  9069         -    nPos = pSeg->nPos*2 + pSeg->bDel;
         9069  +    nPos = pSegIter->nPos*2 + pSegIter->bDel;
  9070   9070       fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter), nPos);
  9071   9071   
  9072   9072       /* Append the position-list data to the output */
  9073         -    fts5ChunkIterate(p, pSeg, (void*)&writer, fts5MergeChunkCallback);
         9073  +    fts5ChunkIterate(p, pSegIter, (void*)&writer, fts5MergeChunkCallback);
  9074   9074     }
  9075   9075   
  9076   9076     /* Flush the last leaf page to disk. Set the output segment b-tree height
  9077   9077     ** and last leaf page number at the same time.  */
  9078   9078     fts5WriteFinish(p, &writer, &pSeg->nHeight, &pSeg->pgnoLast);
  9079   9079   
  9080   9080     if( fts5MultiIterEof(p, pIter) ){
................................................................................
 13244  13244   */
 13245  13245   static void fts5SourceIdFunc(
 13246  13246     sqlite3_context *pCtx,          /* Function call context */
 13247  13247     int nArg,                       /* Number of args */
 13248  13248     sqlite3_value **apVal           /* Function arguments */
 13249  13249   ){
 13250  13250     assert( nArg==0 );
 13251         -  sqlite3_result_text(pCtx, "fts5: 2015-07-16 20:17:57 e9bf275cd969eca6fb41384d3637528d6a19f819", -1, SQLITE_TRANSIENT);
        13251  +  sqlite3_result_text(pCtx, "fts5: 2015-07-24 23:28:05 db129149812cb4eadb4cd79ad293d14962d2638d", -1, SQLITE_TRANSIENT);
 13252  13252   }
 13253  13253   
 13254  13254   #ifdef _WIN32
 13255  13255   __declspec(dllexport)
 13256  13256   #endif
 13257  13257   int sqlite3_fts5_init(
 13258  13258     sqlite3 *db,

Changes to Setup/updateFileInfo.tcl.

    57     57   
    58     58   #
    59     59   # NOTE: Grab the name of the file to be updated from the command line, if
    60     60   #       available; otherwise, use the default (i.e. "../www/downloads.wiki").
    61     61   #
    62     62   if {[info exists argv] && [llength $argv] > 0} then {
    63     63     set updateFileName [lindex $argv 0]
    64         -} else {
           64  +}
           65  +
           66  +if {![info exists updateFileName] || \
           67  +    [string length $updateFileName] == 0} then {
    65     68     set updateFileName [file join $root www downloads.wiki]
    66     69   }
    67     70   
    68     71   #
    69     72   # NOTE: Grab the directory containing the files referenced in the data of the
    70     73   #       file to be updated from the command line, if available; otherwise, use
    71     74   #       the default (i.e. "./Output").
    72     75   #
    73     76   if {[info exists argv] && [llength $argv] > 1} then {
    74         -  set directory [lindex $argv 1]
    75         -} else {
    76         -  set directory [file join $path Output]
           77  +  set outputDirectory [lindex $argv 1]
           78  +}
           79  +
           80  +if {![info exists outputDirectory] || \
           81  +    [string length $outputDirectory] == 0} then {
           82  +  set outputDirectory [file join $path Output]
    77     83   }
    78     84   
    79     85   #
    80         -# NOTE: Setup the regular expression pattern with the necessary captures.  This
    81         -#       pattern is mostly non-greedy; however, at the end we need to match
    82         -#       exactly 40 hexadecimal characters.  In theory, in Tcl, this could have
    83         -#       an undefined result due to the mixing of greedy and non-greedy
           86  +# NOTE: Setup the regular expression patterns with the necessary captures.
           87  +#       These patterns are mostly non-greedy; however, at the end we need to
           88  +#       match exactly 40 hexadecimal characters.  In theory, in Tcl, this could
           89  +#       have an undefined result due to the mixing of greedy and non-greedy
    84     90   #       quantifiers; however, in practice, this seems to work properly.  Also,
    85     91   #       this pattern assumes a particular structure for the [HTML] file to be
    86     92   #       updated.
    87     93   #
    88     94   set pattern1 {<a\
    89     95       href=".*?/(.*?\.(?:exe|zip|nupkg))">.*?\((\d+?\.\d+?) MiB\).*?sha1:\
    90     96       ([0-9A-F]{40})}
    91     97   
    92     98   set pattern2 {<a\
    93     99       href=".*?/package/.*?/\d+\.\d+\.\d+\.\d+">(.*?)</a>.*?\((\d+?\.\d+?)\
    94    100       MiB\).*?sha1: ([0-9A-F]{40})}
    95    101   
          102  +set pattern3 {href="/downloads/(.*?)"}
          103  +set pattern4 {\(sha1: ([0-9A-F]{40})\)}
          104  +
    96    105   #
    97    106   # NOTE: Grab all the data from the file to be updated.
    98    107   #
    99    108   set data [readFile $updateFileName]
   100    109   
   101    110   #
   102    111   # NOTE: Initialize the total number of changes made to zero.
................................................................................
   113    122     #
   114    123     foreach {dummy fileName fileSize fileHash} \
   115    124         [regexp -all -inline -nocase -- $pattern $data] {
   116    125       #
   117    126       # NOTE: Get the fully qualified file name based on the configured
   118    127       #       directory.
   119    128       #
   120         -    set fullFileName [file join $directory [file tail $fileName]]
          129  +    set fullFileName [file join $outputDirectory [file tail $fileName]]
   121    130   
   122    131       #
   123    132       # NOTE: If the file does not exist, issue a warning and skip it.
   124    133       #
   125    134       if {![file exists $fullFileName]} then {
   126    135         puts stdout "WARNING: File \"$fullFileName\" does not exist, skipped."
   127    136         continue
................................................................................
   169    178         incr count [regsub -nocase -start $start -- "***=$fileHash" $data \
   170    179             $newFileHash data]
   171    180   
   172    181         incr start [string length $fileHash]
   173    182       }
   174    183     }
   175    184   }
          185  +
          186  +#
          187  +# NOTE: Attempt to verify that each file name now has the correct SHA1 hash
          188  +#       associated with it on the page.
          189  +#
          190  +foreach {dummy3 fileName} [regexp -all -inline -nocase -- $pattern3 $data] \
          191  +        {dummy4 fileHash} [regexp -all -inline -nocase -- $pattern4 $data] {
          192  +  #
          193  +  # NOTE: Get the fully qualified file name based on the configured
          194  +  #       directory.
          195  +  #
          196  +  set fullFileName [file join $outputDirectory [file tail $fileName]]
          197  +
          198  +  #
          199  +  # NOTE: Make sure the file hash from the [modified] data matches the
          200  +  #       calculated hash for the file.  If not, fail.
          201  +  #
          202  +  set fullFileHash [getFileHash $fullFileName]
          203  +
          204  +  if {$fileHash ne $fullFileHash} then {
          205  +    puts stdout "ERROR: SHA1 hash mismatch for\
          206  +        file \"$fullFileName\", have \"$fileHash\" (from data),\
          207  +        need \"$fullFileHash\" (calculated)."
          208  +  }
          209  +}
   176    210   
   177    211   #
   178    212   # NOTE: Write the [modified] data to the file to be updated.
   179    213   #
   180    214   if {$count > 0} then {
   181    215     writeFile $updateFileName $data
   182    216   } else {
   183    217     puts stdout "WARNING: No changes, update of \"$updateFileName\" skipped."
   184    218   }

Changes to System.Data.SQLite.Linq/SQL Generation/SqlGenerator.cs.

  2957   2957         //result.Append(" + '.') - LEN('.')");
  2958   2958   
  2959   2959         return result;
  2960   2960       }
  2961   2961   
  2962   2962       /// <summary>
  2963   2963       /// Round(numericExpression) -> Round(numericExpression, 0);
         2964  +    /// Round(numericExpression, N) -> Round(numericExpression, N);
  2964   2965       /// </summary>
  2965   2966       /// <param name="sqlgen"></param>
  2966   2967       /// <param name="e"></param>
  2967   2968       /// <returns></returns>
  2968   2969       private static ISqlFragment HandleCanonicalFunctionRound(SqlGenerator sqlgen, DbFunctionExpression e)
  2969   2970       {
  2970   2971         SqlBuilder result = new SqlBuilder();
  2971   2972   
  2972   2973         result.Append("ROUND(");
  2973   2974   
  2974         -      Debug.Assert(e.Arguments.Count == 1, "Round should have one argument");
         2975  +      Debug.Assert(e.Arguments.Count == 1 || e.Arguments.Count == 2, "Round should have one or two arguments");
  2975   2976         result.Append(e.Arguments[0].Accept(sqlgen));
  2976   2977   
  2977         -      result.Append(", 0)");
         2978  +      if (e.Arguments.Count == 2)
         2979  +      {
         2980  +        result.Append(", ");
         2981  +        result.Append(e.Arguments[1].Accept(sqlgen));
         2982  +        result.Append(")");
         2983  +      }
         2984  +      else
         2985  +      {
         2986  +        result.Append(", 0)");
         2987  +      }
  2978   2988   
  2979   2989         return result;
  2980   2990       }
  2981   2991   
  2982   2992       /// <summary>
  2983   2993       /// TRIM(string) -> LTRIM(RTRIM(string))
  2984   2994       /// </summary>

Changes to System.Data.SQLite/SQLiteConnection.cs.

   165    165     /// <description>Version</description>
   166    166     /// <description>3</description>
   167    167     /// <description>N</description>
   168    168     /// <description>3</description>
   169    169     /// </item>
   170    170     /// <item>
   171    171     /// <description>UseUTF16Encoding</description>
   172         -  /// <description><b>True</b><br/><b>False</b></description>
          172  +  /// <description>
          173  +  /// <b>True</b> - The UTF-16 encoding should be used.
          174  +  /// <br/>
          175  +  /// <b>False</b> - The UTF-8 encoding should be used.
          176  +  /// </description>
   173    177     /// <description>N</description>
   174    178     /// <description>False</description>
   175    179     /// </item>
   176    180     /// <item>
   177    181     /// <description>DefaultDbType</description>
   178    182     /// <description>
   179    183     /// This is the default <see cref="DbType" /> to use when one cannot be determined based on the
................................................................................
   197    201     /// <b>True</b> - Do not combine the specified (or existing) connection flags with the value of the
   198    202     /// <see cref="DefaultFlags" /> property.
   199    203     /// <br/>
   200    204     /// <b>False</b> - Combine the specified (or existing) connection flags with the value of the
   201    205     /// <see cref="DefaultFlags" /> property.
   202    206     /// </description>
   203    207     /// <description>N</description>
   204         -  /// <description>false</description>
          208  +  /// <description>False</description>
   205    209     /// </item>
   206    210     /// <item>
   207    211     /// <description>NoSharedFlags</description>
   208    212     /// <description>
   209    213     /// <b>True</b> - Do not combine the specified (or existing) connection flags with the value of the
   210    214     /// <see cref="SharedFlags" /> property.
   211    215     /// <br/>
   212    216     /// <b>False</b> - Combine the specified (or existing) connection flags with the value of the
   213    217     /// <see cref="SharedFlags" /> property.
   214    218     /// </description>
   215    219     /// <description>N</description>
   216         -  /// <description>false</description>
          220  +  /// <description>False</description>
   217    221     /// </item>
   218    222     /// <item>
   219    223     /// <description>VfsName</description>
   220    224     /// <description>
   221    225     /// The name of the VFS to use when opening the database connection.
   222    226     /// If this is not specified, the default VFS will be used.
   223    227     /// </description>
................................................................................
   248    252     /// <b>InvariantCulture</b> - Any culture-independent string value that the .NET Framework can interpret as a valid DateTime.<br/>
   249    253     /// <b>CurrentCulture</b> - Any string value that the .NET Framework can interpret as a valid DateTime using the current culture.</description>
   250    254     /// <description>N</description>
   251    255     /// <description>ISO8601</description>
   252    256     /// </item>
   253    257     /// <item>
   254    258     /// <description>DateTimeKind</description>
   255         -  /// <description><b>Unspecified</b> - Not specified as either UTC or local time.<br/><b>Utc</b> - The time represented is UTC.<br/><b>Local</b> - The time represented is local time.</description>
          259  +  /// <description>
          260  +  /// <b>Unspecified</b> - Not specified as either UTC or local time.
          261  +  /// <br/>
          262  +  /// <b>Utc</b> - The time represented is UTC.
          263  +  /// <br/>
          264  +  /// <b>Local</b> - The time represented is local time.
          265  +  /// </description>
   256    266     /// <description>N</description>
   257    267     /// <description>Unspecified</description>
   258    268     /// </item>
   259    269     /// <item>
   260    270     /// <description>DateTimeFormatString</description>
   261         -  /// <description>The exact DateTime format string to use for all formatting and parsing of all DateTime
   262         -  /// values for this connection.</description>
          271  +  /// <description>
          272  +  /// The exact DateTime format string to use for all formatting and parsing of all DateTime
          273  +  /// values for this connection.
          274  +  /// </description>
   263    275     /// <description>N</description>
   264    276     /// <description>null</description>
   265    277     /// </item>
   266    278     /// <item>
   267    279     /// <description>BaseSchemaName</description>
   268         -  /// <description>Some base data classes in the framework (e.g. those that build SQL queries dynamically)
          280  +  /// <description>
          281  +  /// Some base data classes in the framework (e.g. those that build SQL queries dynamically)
   269    282     /// assume that an ADO.NET provider cannot support an alternate catalog (i.e. database) without supporting
   270    283     /// alternate schemas as well; however, SQLite does not fit into this model.  Therefore, this value is used
   271         -  /// as a placeholder and removed prior to preparing any SQL statements that may contain it.</description>
          284  +  /// as a placeholder and removed prior to preparing any SQL statements that may contain it.
          285  +  /// </description>
   272    286     /// <description>N</description>
   273    287     /// <description>sqlite_default_schema</description>
   274    288     /// </item>
   275    289     /// <item>
   276    290     /// <description>BinaryGUID</description>
   277         -  /// <description><b>True</b> - Store GUID columns in binary form<br/><b>False</b> - Store GUID columns as text</description>
          291  +  /// <description>
          292  +  /// <b>True</b> - Store GUID columns in binary form
          293  +  /// <br/>
          294  +  /// <b>False</b> - Store GUID columns as text
          295  +  /// </description>
   278    296     /// <description>N</description>
   279    297     /// <description>True</description>
   280    298     /// </item>
   281    299     /// <item>
   282    300     /// <description>Cache Size</description>
   283    301     /// <description>{size in bytes}</description>
   284    302     /// <description>N</description>
   285    303     /// <description>2000</description>
   286    304     /// </item>
   287    305     /// <item>
   288    306     /// <description>Synchronous</description>
   289         -  /// <description><b>Normal</b> - Normal file flushing behavior<br/><b>Full</b> - Full flushing after all writes<br/><b>Off</b> - Underlying OS flushes I/O's</description>
          307  +  /// <description>
          308  +  /// <b>Normal</b> - Normal file flushing behavior
          309  +  /// <br/>
          310  +  /// <b>Full</b> - Full flushing after all writes
          311  +  /// <br/>
          312  +  /// <b>Off</b> - Underlying OS flushes I/O's
          313  +  /// </description>
   290    314     /// <description>N</description>
   291    315     /// <description>Full</description>
   292    316     /// </item>
   293    317     /// <item>
   294    318     /// <description>Page Size</description>
   295    319     /// <description>{size in bytes}</description>
   296    320     /// <description>N</description>
   297    321     /// <description>1024</description>
   298    322     /// </item>
   299    323     /// <item>
   300    324     /// <description>Password</description>
   301         -  /// <description>{password} - Using this parameter requires that the CryptoAPI based codec 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>
          325  +  /// <description>
          326  +  /// {password} - Using this parameter requires that the CryptoAPI based codec
          327  +  /// be enabled at compile-time for both the native interop assembly and the
          328  +  /// core managed assemblies; otherwise, using this parameter may result in an
          329  +  /// exception being thrown when attempting to open the connection.
          330  +  /// </description>
   302    331     /// <description>N</description>
   303    332     /// <description></description>
   304    333     /// </item>
   305    334     /// <item>
   306    335     /// <description>HexPassword</description>
   307         -  /// <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 CryptoAPI based codec 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>
          336  +  /// <description>
          337  +  /// {hexPassword} - Must contain a sequence of zero or more hexadecimal encoded
          338  +  /// byte values without a leading "0x" prefix.  Using this parameter requires
          339  +  /// that the CryptoAPI based codec be enabled at compile-time for both the native
          340  +  /// interop assembly and the core managed assemblies; otherwise, using this
          341  +  /// parameter may result in an exception being thrown when attempting to open
          342  +  /// the connection.
          343  +  /// </description>
   308    344     /// <description>N</description>
   309    345     /// <description></description>
   310    346     /// </item>
   311    347     /// <item>
   312    348     /// <description>Enlist</description>
   313         -  /// <description><b>Y</b> - Automatically enlist in distributed transactions<br/><b>N</b> - No automatic enlistment</description>
          349  +  /// <description>
          350  +  /// <b>Y</b> - Automatically enlist in distributed transactions
          351  +  /// <br/>
          352  +  /// <b>N</b> - No automatic enlistment
          353  +  /// </description>
   314    354     /// <description>N</description>
   315    355     /// <description>Y</description>
   316    356     /// </item>
   317    357     /// <item>
   318    358     /// <description>Pooling</description>
   319    359     /// <description>
   320    360     /// <b>True</b> - Use connection pooling.<br/>
................................................................................
   325    365     /// can occur during the finalization of some COM objects.
   326    366     /// </description>
   327    367     /// <description>N</description>
   328    368     /// <description>False</description>
   329    369     /// </item>
   330    370     /// <item>
   331    371     /// <description>FailIfMissing</description>
   332         -  /// <description><b>True</b> - Don't create the database if it does not exist, throw an error instead<br/><b>False</b> - Automatically create the database if it does not exist</description>
          372  +  /// <description>
          373  +  /// <b>True</b> - Don't create the database if it does not exist, throw an error instead
          374  +  /// <br/>
          375  +  /// <b>False</b> - Automatically create the database if it does not exist
          376  +  /// </description>
   333    377     /// <description>N</description>
   334    378     /// <description>False</description>
   335    379     /// </item>
   336    380     /// <item>
   337    381     /// <description>Max Page Count</description>
   338    382     /// <description>{size in pages} - Limits the maximum number of pages (limits the size) of the database</description>
   339    383     /// <description>N</description>
   340    384     /// <description>0</description>
   341    385     /// </item>
   342    386     /// <item>
   343    387     /// <description>Legacy Format</description>
   344         -  /// <description><b>True</b> - Use the more compatible legacy 3.x database format<br/><b>False</b> - Use the newer 3.3x database format which compresses numbers more effectively</description>
          388  +  /// <description>
          389  +  /// <b>True</b> - Use the more compatible legacy 3.x database format
          390  +  /// <br/>
          391  +  /// <b>False</b> - Use the newer 3.3x database format which compresses numbers more effectively
          392  +  /// </description>
   345    393     /// <description>N</description>
   346    394     /// <description>False</description>
   347    395     /// </item>
   348    396     /// <item>
   349    397     /// <description>Default Timeout</description>
   350    398     /// <description>{time in seconds}<br/>The default command timeout</description>
   351    399     /// <description>N</description>
................................................................................
   355    403     /// <description>BusyTimeout</description>
   356    404     /// <description>{time in milliseconds}<br/>Sets the busy timeout for the core library.</description>
   357    405     /// <description>N</description>
   358    406     /// <description>0</description>
   359    407     /// </item>
   360    408     /// <item>
   361    409     /// <description>Journal Mode</description>
   362         -  /// <description><b>Delete</b> - Delete the journal file after a commit<br/><b>Persist</b> - Zero out and leave the journal file on disk after a commit<br/><b>Off</b> - Disable the rollback journal entirely</description>
          410  +  /// <description>
          411  +  /// <b>Delete</b> - Delete the journal file after a commit.
          412  +  /// <br/>
          413  +  /// <b>Persist</b> - Zero out and leave the journal file on disk after a
          414  +  /// commit.
          415  +  /// <br/>
          416  +  /// <b>Off</b> - Disable the rollback journal entirely.  This saves disk I/O
          417  +  /// but at the expense of database safety and integrity.  If the application
          418  +  /// using SQLite crashes in the middle of a transaction when this journaling
          419  +  /// mode is set, then the database file will very likely go corrupt.
          420  +  /// <br/>
          421  +  /// <b>Truncate</b> - Truncate the journal file to zero-length instead of
          422  +  /// deleting it.
          423  +  /// <br/>
          424  +  /// <b>Memory</b> - Store the journal in volatile RAM.  This saves disk I/O
          425  +  /// but at the expense of database safety and integrity.  If the application
          426  +  /// using SQLite crashes in the middle of a transaction when this journaling
          427  +  /// mode is set, then the database file will very likely go corrupt.
          428  +  /// <br/>
          429  +  /// <b>Wal</b> - Use a write-ahead log instead of a rollback journal.
          430  +  /// </description>
   363    431     /// <description>N</description>
   364    432     /// <description>Delete</description>
   365    433     /// </item>
   366    434     /// <item>
   367    435     /// <description>Read Only</description>
   368         -  /// <description><b>True</b> - Open the database for read only access<br/><b>False</b> - Open the database for normal read/write access</description>
          436  +  /// <description>
          437  +  /// <b>True</b> - Open the database for read only access
          438  +  /// <br/>
          439  +  /// <b>False</b> - Open the database for normal read/write access
          440  +  /// </description>
   369    441     /// <description>N</description>
   370    442     /// <description>False</description>
   371    443     /// </item>
   372    444     /// <item>
   373    445     /// <description>Max Pool Size</description>
   374    446     /// <description>The maximum number of connections for the given connection string that can be in the connection pool</description>
   375    447     /// <description>N</description>
................................................................................
   401    473     /// </description>
   402    474     /// <description>N</description>
   403    475     /// <description>True</description>
   404    476     /// </item>
   405    477     /// <item>
   406    478     /// <description>ToFullPath</description>
   407    479     /// <description>
   408         -  /// <b>True</b> - Attempt to expand the data source file name to a fully qualified path before opening.<br/>
          480  +  /// <b>True</b> - Attempt to expand the data source file name to a fully qualified path before opening.
          481  +  /// <br/>
   409    482     /// <b>False</b> - Skip attempting to expand the data source file name to a fully qualified path before opening.
   410    483     /// </description>
   411    484     /// <description>N</description>
   412    485     /// <description>True</description>
   413    486     /// </item>
   414    487     /// <item>
   415    488     /// <description>PrepareRetries</description>
................................................................................
   427    500     /// The approximate number of virtual machine instructions between progress
   428    501     /// events.  In order for progress events to actually fire, the event handler
   429    502     /// must be added to the <see cref="Progress" /> event as well.
   430    503     /// </description>
   431    504     /// <description>N</description>
   432    505     /// <description>0</description>
   433    506     /// </item>
          507  +  /// <item>
          508  +  /// <description>Recursive Triggers</description>
          509  +  /// <description>
          510  +  /// <b>True</b> - Enable the recursive trigger capability.
          511  +  /// <b>False</b> - Disable the recursive trigger capability.
          512  +  /// </description>
          513  +  /// <description>N</description>
          514  +  /// <description>False</description>
          515  +  /// </item>
   434    516     /// </list>
   435    517     /// </remarks>
   436    518     public sealed partial class SQLiteConnection : DbConnection, ICloneable, IDisposable
   437    519     {
   438    520       #region Private Constants
   439    521       /// <summary>
   440    522       /// The "invalid value" for the <see cref="DbType" /> enumeration used
................................................................................
   482    564       private const bool DefaultReadOnly = false;
   483    565       internal const bool DefaultBinaryGUID = true;
   484    566       private const bool DefaultUseUTF16Encoding = false;
   485    567       private const bool DefaultToFullPath = true;
   486    568       private const bool DefaultPooling = false; // TODO: Maybe promote this to static property?
   487    569       private const bool DefaultLegacyFormat = false;
   488    570       private const bool DefaultForeignKeys = false;
          571  +    private const bool DefaultRecursiveTriggers = false;
   489    572       private const bool DefaultEnlist = true;
   490    573       private const bool DefaultSetDefaults = true;
   491    574       internal const int DefaultPrepareRetries = 3;
   492    575       private const string DefaultVfsName = null;
   493    576       private const int DefaultProgressOps = 0;
   494    577   
   495    578   #if INTEROP_INCLUDE_ZIPVFS
................................................................................
  1825   1908         SQLiteConnectionPool.ClearAllPools();
  1826   1909       }
  1827   1910   
  1828   1911       /// <summary>
  1829   1912       /// The connection string containing the parameters for the connection
  1830   1913       /// </summary>
  1831   1914       /// <remarks>
  1832         -    /// <list type="table">
  1833         -    /// <listheader>
  1834         -    /// <term>Parameter</term>
  1835         -    /// <term>Values</term>
  1836         -    /// <term>Required</term>
  1837         -    /// <term>Default</term>
  1838         -    /// </listheader>
  1839         -    /// <item>
  1840         -    /// <description>Data Source</description>
  1841         -    /// <description>
  1842         -    /// This may be a file name, the string ":memory:", or any supported URI (starting with SQLite 3.7.7).
  1843         -    /// Starting with release 1.0.86.0, in order to use more than one consecutive backslash (e.g. for a
  1844         -    /// UNC path), each of the adjoining backslash characters must be doubled (e.g. "\\Network\Share\test.db"
  1845         -    /// would become "\\\\Network\Share\test.db").
  1846         -    /// </description>
  1847         -    /// <description>Y</description>
  1848         -    /// <description></description>
  1849         -    /// </item>
  1850         -    /// <item>
  1851         -    /// <description>Version</description>
  1852         -    /// <description>3</description>
  1853         -    /// <description>N</description>
  1854         -    /// <description>3</description>
  1855         -    /// </item>
  1856         -    /// <item>
  1857         -    /// <description>UseUTF16Encoding</description>
  1858         -    /// <description><b>True</b><br/><b>False</b></description>
  1859         -    /// <description>N</description>
  1860         -    /// <description>False</description>
  1861         -    /// </item>
  1862         -    /// <item>
  1863         -    /// <description>DateTimeFormat</description>
  1864         -    /// <description>
  1865         -    /// <b>Ticks</b> - Use the value of DateTime.Ticks.<br/>
  1866         -    /// <b>ISO8601</b> - Use the ISO-8601 format.  Uses the "yyyy-MM-dd HH:mm:ss.FFFFFFFK" format for UTC
  1867         -    /// DateTime values and "yyyy-MM-dd HH:mm:ss.FFFFFFF" format for local DateTime values).<br/>
  1868         -    /// <b>JulianDay</b> - The interval of time in days and fractions of a day since January 1, 4713 BC.<br/>
  1869         -    /// <b>UnixEpoch</b> - The whole number of seconds since the Unix epoch (January 1, 1970).<br/>
  1870         -    /// <b>InvariantCulture</b> - Any culture-independent string value that the .NET Framework can interpret as a valid DateTime.<br/>
  1871         -    /// <b>CurrentCulture</b> - Any string value that the .NET Framework can interpret as a valid DateTime using the current culture.</description>
  1872         -    /// <description>N</description>
  1873         -    /// <description>ISO8601</description>
  1874         -    /// </item>
  1875         -    /// <item>
  1876         -    /// <description>DateTimeKind</description>
  1877         -    /// <description><b>Unspecified</b> - Not specified as either UTC or local time.<br/><b>Utc</b> - The time represented is UTC.<br/><b>Local</b> - The time represented is local time.</description>
  1878         -    /// <description>N</description>
  1879         -    /// <description>Unspecified</description>
  1880         -    /// </item>
  1881         -    /// <item>
  1882         -    /// <description>DateTimeFormatString</description>
  1883         -    /// <description>The exact DateTime format string to use for all formatting and parsing of all DateTime
  1884         -    /// values for this connection.</description>
  1885         -    /// <description>N</description>
  1886         -    /// <description>null</description>
  1887         -    /// </item>
  1888         -    /// <item>
  1889         -    /// <description>BaseSchemaName</description>
  1890         -    /// <description>Some base data classes in the framework (e.g. those that build SQL queries dynamically)
  1891         -    /// assume that an ADO.NET provider cannot support an alternate catalog (i.e. database) without supporting
  1892         -    /// alternate schemas as well; however, SQLite does not fit into this model.  Therefore, this value is used
  1893         -    /// as a placeholder and removed prior to preparing any SQL statements that may contain it.</description>
  1894         -    /// <description>N</description>
  1895         -    /// <description>sqlite_default_schema</description>
  1896         -    /// </item>
  1897         -    /// <item>
  1898         -    /// <description>BinaryGUID</description>
  1899         -    /// <description><b>True</b> - Store GUID columns in binary form<br/><b>False</b> - Store GUID columns as text</description>
  1900         -    /// <description>N</description>
  1901         -    /// <description>True</description>
  1902         -    /// </item>
  1903         -    /// <item>
  1904         -    /// <description>Cache Size</description>
  1905         -    /// <description>{size in bytes}</description>
  1906         -    /// <description>N</description>
  1907         -    /// <description>2000</description>
  1908         -    /// </item>
  1909         -    /// <item>
  1910         -    /// <description>Synchronous</description>
  1911         -    /// <description><b>Normal</b> - Normal file flushing behavior<br/><b>Full</b> - Full flushing after all writes<br/><b>Off</b> - Underlying OS flushes I/O's</description>
  1912         -    /// <description>N</description>
  1913         -    /// <description>Full</description>
  1914         -    /// </item>
  1915         -    /// <item>
  1916         -    /// <description>Page Size</description>
  1917         -    /// <description>{size in bytes}</description>
  1918         -    /// <description>N</description>
  1919         -    /// <description>1024</description>
  1920         -    /// </item>
  1921         -    /// <item>
  1922         -    /// <description>Password</description>
  1923         -    /// <description>{password} - Using this parameter requires that the CryptoAPI based codec 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>
  1924         -    /// <description>N</description>
  1925         -    /// <description></description>
  1926         -    /// </item>
  1927         -    /// <item>
  1928         -    /// <description>HexPassword</description>
  1929         -    /// <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 CryptoAPI based codec 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>
  1930         -    /// <description>N</description>
  1931         -    /// <description></description>
  1932         -    /// </item>
  1933         -    /// <item>
  1934         -    /// <description>Enlist</description>
  1935         -    /// <description><b>Y</b> - Automatically enlist in distributed transactions<br/><b>N</b> - No automatic enlistment</description>
  1936         -    /// <description>N</description>
  1937         -    /// <description>Y</description>
  1938         -    /// </item>
  1939         -    /// <item>
  1940         -    /// <description>Pooling</description>
  1941         -    /// <description>
  1942         -    /// <b>True</b> - Use connection pooling.<br/>
  1943         -    /// <b>False</b> - Do not use connection pooling.<br/><br/>
  1944         -    /// <b>WARNING:</b> When using the default connection pool implementation,
  1945         -    /// setting this property to True should be avoided by applications that
  1946         -    /// make use of COM (either directly or indirectly) due to possible
  1947         -    /// deadlocks that can occur during the finalization of some COM objects.
  1948         -    /// </description>
  1949         -    /// <description>N</description>
  1950         -    /// <description>False</description>
  1951         -    /// </item>
  1952         -    /// <item>
  1953         -    /// <description>FailIfMissing</description>
  1954         -    /// <description><b>True</b> - Don't create the database if it does not exist, throw an error instead<br/><b>False</b> - Automatically create the database if it does not exist</description>
  1955         -    /// <description>N</description>
  1956         -    /// <description>False</description>
  1957         -    /// </item>
  1958         -    /// <item>
  1959         -    /// <description>Max Page Count</description>
  1960         -    /// <description>{size in pages} - Limits the maximum number of pages (limits the size) of the database</description>
  1961         -    /// <description>N</description>
  1962         -    /// <description>0</description>
  1963         -    /// </item>
  1964         -    /// <item>
  1965         -    /// <description>Legacy Format</description>
  1966         -    /// <description><b>True</b> - Use the more compatible legacy 3.x database format<br/><b>False</b> - Use the newer 3.3x database format which compresses numbers more effectively</description>
  1967         -    /// <description>N</description>
  1968         -    /// <description>False</description>
  1969         -    /// </item>
  1970         -    /// <item>
  1971         -    /// <description>Default Timeout</description>
  1972         -    /// <description>{time in seconds}<br/>The default command timeout</description>
  1973         -    /// <description>N</description>
  1974         -    /// <description>30</description>
  1975         -    /// </item>
  1976         -    /// <item>
  1977         -    /// <description>Journal Mode</description>
  1978         -    /// <description><b>Delete</b> - Delete the journal file after a commit<br/><b>Persist</b> - Zero out and leave the journal file on disk after a commit<br/><b>Off</b> - Disable the rollback journal entirely</description>
  1979         -    /// <description>N</description>
  1980         -    /// <description>Delete</description>
  1981         -    /// </item>
  1982         -    /// <item>
  1983         -    /// <description>Read Only</description>
  1984         -    /// <description><b>True</b> - Open the database for read only access<br/><b>False</b> - Open the database for normal read/write access</description>
  1985         -    /// <description>N</description>
  1986         -    /// <description>False</description>
  1987         -    /// </item>
  1988         -    /// <item>
  1989         -    /// <description>Max Pool Size</description>
  1990         -    /// <description>The maximum number of connections for the given connection string that can be in the connection pool</description>
  1991         -    /// <description>N</description>
  1992         -    /// <description>100</description>
  1993         -    /// </item>
  1994         -    /// <item>
  1995         -    /// <description>Default IsolationLevel</description>
  1996         -    /// <description>The default transaciton isolation level</description>
  1997         -    /// <description>N</description>
  1998         -    /// <description>Serializable</description>
  1999         -    /// </item>
  2000         -    /// <item>
  2001         -    /// <description>Foreign Keys</description>
  2002         -    /// <description>Enable foreign key constraints</description>
  2003         -    /// <description>N</description>
  2004         -    /// <description>False</description>
  2005         -    /// </item>
  2006         -    /// <item>
  2007         -    /// <description>Flags</description>
  2008         -    /// <description>Extra behavioral flags for the connection.  See the <see cref="SQLiteConnectionFlags" /> enumeration for possible values.</description>
  2009         -    /// <description>N</description>
  2010         -    /// <description>Default</description>
  2011         -    /// </item>
  2012         -    /// <item>
  2013         -    /// <description>SetDefaults</description>
  2014         -    /// <description>
  2015         -    /// <b>True</b> - Apply the default connection settings to the opened database.<br/>
  2016         -    /// <b>False</b> - Skip applying the default connection settings to the opened database.
  2017         -    /// </description>
  2018         -    /// <description>N</description>
  2019         -    /// <description>True</description>
  2020         -    /// </item>
  2021         -    /// <item>
  2022         -    /// <description>ToFullPath</description>
  2023         -    /// <description>
  2024         -    /// <b>True</b> - Attempt to expand the data source file name to a fully qualified path before opening.<br/>
  2025         -    /// <b>False</b> - Skip attempting to expand the data source file name to a fully qualified path before opening.
  2026         -    /// </description>
  2027         -    /// <description>N</description>
  2028         -    /// <description>True</description>
  2029         -    /// </item>
  2030         -    /// <item>
  2031         -    /// <description>PrepareRetries</description>
  2032         -    /// <description>
  2033         -    /// The maximum number of retries when preparing SQL to be executed.  This
  2034         -    /// normally only applies to preparation errors resulting from the database
  2035         -    /// schema being changed.
  2036         -    /// </description>
  2037         -    /// <description>N</description>
  2038         -    /// <description>3</description>
  2039         -    /// </item>
  2040         -    /// </list>
         1915  +    /// For the complete list of supported connection string properties,
         1916  +    /// please see <see cref="SQLiteConnection" />.
  2041   1917       /// </remarks>
  2042   1918   #if !PLATFORM_COMPACTFRAMEWORK
  2043   1919       [RefreshProperties(RefreshProperties.All), DefaultValue("")]
  2044   1920       [Editor("SQLite.Designer.SQLiteConnectionStringEditor, SQLite.Designer, Version=" + SQLite3.DesignerVersion + ", Culture=neutral, PublicKeyToken=db937bc2d44ff139", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
  2045   1921   #endif
  2046   1922       public override string ConnectionString
  2047   1923       {
................................................................................
  2968   2844                     strValue = FindKey(opts, "Foreign Keys", DefaultForeignKeys.ToString());
  2969   2845                     boolValue = SQLiteConvert.ToBoolean(strValue);
  2970   2846                     if (boolValue != DefaultForeignKeys)
  2971   2847                     {
  2972   2848                         cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA foreign_keys={0}", boolValue ? "ON" : "OFF");
  2973   2849                         cmd.ExecuteNonQuery();
  2974   2850                     }
         2851  +
         2852  +                  strValue = FindKey(opts, "Recursive Triggers", DefaultRecursiveTriggers.ToString());
         2853  +                  boolValue = SQLiteConvert.ToBoolean(strValue);
         2854  +                  if (boolValue != DefaultRecursiveTriggers)
         2855  +                  {
         2856  +                      cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA recursive_triggers={0}", boolValue ? "ON" : "OFF");
         2857  +                      cmd.ExecuteNonQuery();
         2858  +                  }
  2975   2859                 }
  2976   2860             }
  2977   2861   
  2978   2862             if (_progressHandler != null)
  2979   2863                 _sql.SetProgressHook(_progressOps, _progressCallback);
  2980   2864   
  2981   2865             if (_authorizerHandler != null)

Changes to System.Data.SQLite/SQLiteConnectionStringBuilder.cs.

   754    754               return SQLiteConvert.ToBoolean(value);
   755    755           }
   756    756           set
   757    757           {
   758    758               this["foreign keys"] = value;
   759    759           }
   760    760       }
          761  +
          762  +    /// <summary>
          763  +    /// Enable or disable the recursive trigger capability.
          764  +    /// </summary>
          765  +    [DisplayName("Recursive Triggers")]
          766  +    [Browsable(true)]
          767  +    [DefaultValue(false)]
          768  +    public bool RecursiveTriggers
          769  +    {
          770  +        get
          771  +        {
          772  +            object value;
          773  +            TryGetValue("recursive triggers", out value);
          774  +            return SQLiteConvert.ToBoolean(value);
          775  +        }
          776  +        set
          777  +        {
          778  +            this["recursive triggers"] = value;
          779  +        }
          780  +    }
   761    781   
   762    782       /// <summary>
   763    783       /// If non-null, this is the version of ZipVFS to use.  This requires the
   764    784       /// System.Data.SQLite interop assembly -AND- primary managed assembly to
   765    785       /// be compiled with the INTEROP_INCLUDE_ZIPVFS option; otherwise, this
   766    786       /// property does nothing.
   767    787       /// </summary>

Changes to Tests/basic.eagle.

  1051   1051                      Enlist FailIfMissing "Legacy Format" "Read Only" \
  1052   1052                      Password "Page Size" "Max Page Count" "Cache Size" \
  1053   1053                      DateTimeFormat DateTimeKind DateTimeFormatString \
  1054   1054                      BaseSchemaName "Journal Mode" "Default IsolationLevel" \
  1055   1055                      "Foreign Keys" Flags SetDefaults ToFullPath HexPassword \
  1056   1056                      DefaultDbType DefaultTypeName NoSharedFlags PrepareRetries \
  1057   1057                      ZipVfsVersion VfsName BusyTimeout ProgressOps \
  1058         -                   NoDefaultFlags]
         1058  +                   NoDefaultFlags "Recursive Triggers"]
  1059   1059   
  1060   1060       set values [list null 3 Normal True False \
  1061   1061                        True test.db test.db file:test.db 60 \
  1062   1062                        False True False True \
  1063   1063                        secret 4096 1024 8192 \
  1064   1064                        UnixEpoch Utc yyyy-MM-dd sqlite_schema \
  1065   1065                        Memory Serializable False \
  1066   1066                        Default False False 736563726574 String \
  1067         -                     TEXT True 20 v2 test 1000 2000 True]
         1067  +                     TEXT True 20 v2 test 1000 2000 True True]
  1068   1068   
  1069   1069       set propertyNames [list null Version SyncMode UseUTF16Encoding Pooling \
  1070   1070                               BinaryGUID DataSource Uri FullUri DefaultTimeout \
  1071   1071                               Enlist FailIfMissing LegacyFormat ReadOnly \
  1072   1072                               Password PageSize MaxPageCount CacheSize \
  1073   1073                               DateTimeFormat DateTimeKind DateTimeFormatString \
  1074   1074                               BaseSchemaName JournalMode DefaultIsolationLevel \
  1075   1075                               ForeignKeys Flags SetDefaults ToFullPath \
  1076   1076                               HexPassword DefaultDbType DefaultTypeName \
  1077   1077                               NoSharedFlags PrepareRetries ZipVfsVersion \
  1078         -                            VfsName BusyTimeout ProgressOps NoDefaultFlags]
         1078  +                            VfsName BusyTimeout ProgressOps NoDefaultFlags \
         1079  +                            RecursiveTriggers]
  1079   1080   
  1080   1081       foreach key $keys value $values propertyName $propertyNames {
  1081   1082         set code [catch {
  1082   1083           object invoke _Dynamic${id}.Test${id} GetConnectionString \
  1083   1084               $key $value $propertyName
  1084   1085         } result]
  1085   1086   
................................................................................
  1107   1108   \{Serializable, Default IsolationLevel=Serializable\} 0 \{False, Foreign\
  1108   1109   Keys=False\} 0 \{(?:Default|LogCallbackException),\
  1109   1110   Flags=(?:Default|LogCallbackException)\} 0 \{False, SetDefaults=False\} 0\
  1110   1111   \{False, ToFullPath=False\} 0 {736563726574, HexPassword=736563726574} 0\
  1111   1112   \{String, DefaultDbType=String\} 0 \{TEXT, DefaultTypeName=TEXT\} 0 \{True,\
  1112   1113   NoSharedFlags=True\} 0 \{20, PrepareRetries=20\} 0 \{v2, ZipVfsVersion=v2\} 0\
  1113   1114   \{test, VfsName=test\} 0 \{1000, BusyTimeout=1000\} 0 \{2000,\
  1114         -ProgressOps=2000\} 0 \{True, NoDefaultFlags=True\}$}}
         1115  +ProgressOps=2000\} 0 \{True, NoDefaultFlags=True\} 0 \{True, Recursive\
         1116  +Triggers=True\}$}}
  1115   1117   
  1116   1118   ###############################################################################
  1117   1119   
  1118   1120   runTest {test data-1.18 {SQLiteConvert ToDateTime (Julian Day)} -body {
  1119   1121     set dateTime [object invoke -create System.Data.SQLite.SQLiteConvert \
  1120   1122         ToDateTime 2455928.0 Utc]
  1121   1123   

Changes to Tests/linq.eagle.

    52     52   
    53     53     set result
    54     54   } -cleanup {
    55     55     unset -nocomplain code output error result
    56     56   } -constraints {eagle monoToDo SQLite file_System.Data.SQLite.dll testExec\
    57     57   file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db} \
    58     58   -result {0 {inserted 1 updated 1}}}
           59  +
           60  +###############################################################################
           61  +
           62  +runTest {test linq-1.2 {ROUND function with two arguments} -body {
           63  +  #
           64  +  # NOTE: Re-copy the reference database file used for this unit test to the
           65  +  #       build directory in case it has been changed by a previous test run.
           66  +  #
           67  +  file copy -force $northwindEfDbFile \
           68  +      [file join [getBuildDirectory] [file tail $northwindEfDbFile]]
           69  +
           70  +  set result [list]
           71  +  set output ""
           72  +
           73  +  set code [catch {
           74  +    testClrExec $testLinqExeFile [list -eventflags Wait -directory \
           75  +        [file dirname $testLinqExeFile] -nocarriagereturns -stdout output \
           76  +        -success 0] -round
           77  +  } error]
           78  +
           79  +  tlog "---- BEGIN STDOUT OUTPUT\n"
           80  +  tlog $output
           81  +  tlog "\n---- END STDOUT OUTPUT\n"
           82  +
           83  +  lappend result $code
           84  +
           85  +  if {$code == 0} then {
           86  +    lappend result [string trim $output]
           87  +  } else {
           88  +    lappend result [string trim $error]
           89  +  }
           90  +
           91  +  set result
           92  +} -cleanup {
           93  +  unset -nocomplain code output error result
           94  +} -constraints {eagle monoToDo SQLite file_System.Data.SQLite.dll testExec\
           95  +file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db} \
           96  +-result {0 {{ NewUnitPrice = 21.0 } { NewUnitPrice = 21.1 } { NewUnitPrice =\
           97  +21.05 } { NewUnitPrice = 23.0 } { NewUnitPrice = 23.3 } { NewUnitPrice = 23.25\
           98  +} { NewUnitPrice = 21.0 } { NewUnitPrice = 21.4 } { NewUnitPrice = 21.35 }}}}
    59     99   
    60    100   ###############################################################################
    61    101   
    62    102   runSQLiteTestFilesEpilogue
    63    103   runSQLiteTestEpilogue
    64    104   runTestEpilogue

Changes to Tests/stress.eagle.

   136    136   
   137    137     proc initTest { indicator } {
   138    138       set ::eagle_tests(constraints) $::test_constraints
   139    139     }
   140    140   
   141    141     #############################################################################
   142    142   
   143         -  proc delayTest { {extra 0} } {
   144         -    after [expr {int((rand() * 1000) + $extra)}]
          143  +  proc delayTest { base extra } {
          144  +    if {$base < 0} then {
          145  +      set base 1000
          146  +    }
          147  +    if {$base > 0 || $extra > 0} then {
          148  +      after [expr {int((rand() * $base) + $extra)}]
          149  +    }
   145    150     }
   146    151   
   147    152     #############################################################################
   148    153   
   149    154     proc waitTest { indicator } {
   150    155       if {![$::event WaitOne $::timeout]} then {
   151    156         error [appendArgs "timeout while starting workload #" \
................................................................................
   152    157             [expr {[string ordinal $indicator 0] - [string ordinal A 0] + 1}]]
   153    158       }
   154    159     }
   155    160   
   156    161     #############################################################################
   157    162   
   158    163     proc showTest { indicator } {
          164  +    showTestWithDelay $indicator -1 $::count(2)
          165  +  }
          166  +
          167  +  #############################################################################
          168  +
          169  +  proc showTestWithDelay { indicator base extra } {
   159    170       tputs $::test_channel $indicator
   160    171       append ::indicators $indicator
   161         -    delayTest $::count(2)
          172  +    delayTest $base $extra
   162    173     }
   163    174   
   164    175     #############################################################################
   165    176   
   166    177     proc doneTest { {indicator ""} } {
   167    178       if {[string length $indicator] > 0} then {
   168    179         lappend ::status(done) $indicator
................................................................................
   197    208         tputs $::test_channel $indicator
   198    209   
   199    210         if {![info exists ::failures($indicator)]} then {
   200    211           set ::failures($indicator) 0
   201    212         }
   202    213   
   203    214         incr ::failures($indicator)
   204         -      delayTest $::count(2)
          215  +      delayTest -1 $::count(2)
   205    216       }
   206    217     }
   207    218   
   208    219     #############################################################################
   209    220   
   210    221     proc allocMem { size } {
   211    222       if {$::coTaskMem} then {
................................................................................
   263    274       #       [return] command in [allocMem].
   264    275       #
   265    276       object dispose $ptr
   266    277     }
   267    278   
   268    279     #############################################################################
   269    280   
          281  +  proc releaseMem { size } {
          282  +    set nFree 0; set resetOk false; set nLargest 0
          283  +
          284  +    set code [object invoke \
          285  +        System.Data.SQLite.SQLiteConnection ReleaseMemory \
          286  +        $size true true nFree resetOk nLargest]
          287  +
          288  +    return [list $code $nFree $resetOk $nLargest]
          289  +  }
          290  +
          291  +  #############################################################################
          292  +
   270    293     proc setupLogging { fileName } {
   271    294       if {![info exists ::logListener]} then {
   272    295         set ::logListener [object create -alias \
   273    296             System.Diagnostics.TextWriterTraceListener $fileName]
   274    297       }
   275    298   
   276    299       object invoke System.Diagnostics.Trace.Listeners Add $::logListener
................................................................................
   308    331     #############################################################################
   309    332   
   310    333     #
   311    334     # NOTE: Setup the default values for the tunable workload parameters.  Any,
   312    335     #       all, or none of these may be overriden via the command line.
   313    336     #
   314    337     set count(0) 3;         # Workload repeat count (i.e. total full runs).
   315         -  set count(1) 5;         # Workload iteration count (i.e. within a run).
   316         -  set count(2) 200;       # Workload iteration delay, in milliseconds.
          338  +  set count(1) 5;         # Workload iteration count (within a run).
          339  +  set count(2) 200;       # Workload iteration delay (milliseconds).
   317    340     set count(3) 57;        # Workload "small" data chunk size, in bytes.
   318    341     set count(4) 10000;     # Workload "big" data chunk size, in bytes.
   319    342     set count(5) 209715200; # Maximum heap memory to exclude at one time.
          343  +  set count(6) 15;        # Workload auxiliary iteration count (within a run).
          344  +  set count(7) 100;       # Workload auxiliary iteration delay (milliseconds).
          345  +  set count(8) 5000;      # Workload auxiliary data value (for use by run).
   320    346     set noWorkload [list];  # Workloads to be omitted from the run, by index.
   321    347     set priorities [list];  # Dictionary of workload thread priorities.
   322    348     set exitOnFail false;   # Halt testing and exit process on test failure?
   323    349     set coTaskMem true;     # Use AllocCoTaskMem/FreeCoTaskMem for memory?
   324    350     set noTrace false;      # Disable SQLite trace logging to a file?
   325    351   
   326    352     #############################################################################
................................................................................
   335    361           {-StopOnUnknownOption +IgnoreOnUnknownOption SkipOnUnknownOption} -- \
   336    362           [list [list null MustHaveIntegerValue -1 -1 -count0 $count(0)] \
   337    363           [list null MustHaveIntegerValue -1 -1 -count1 $count(1)] \
   338    364           [list null MustHaveIntegerValue -1 -1 -count2 $count(2)] \
   339    365           [list null MustHaveIntegerValue -1 -1 -count3 $count(3)] \
   340    366           [list null MustHaveIntegerValue -1 -1 -count4 $count(4)] \
   341    367           [list null MustHaveIntegerValue -1 -1 -count5 $count(5)] \
          368  +        [list null MustHaveIntegerValue -1 -1 -count6 $count(6)] \
          369  +        [list null MustHaveIntegerValue -1 -1 -count7 $count(7)] \
          370  +        [list null MustHaveIntegerValue -1 -1 -count8 $count(8)] \
   342    371           [list null MustHaveListValue -1 -1 -noWorkload $noWorkload] \
   343    372           [list null MustHaveListValue -1 -1 -priorities $priorities] \
   344    373           [list null MustHaveBooleanValue -1 -1 -exitOnFail $exitOnFail] \
   345    374           [list null MustHaveBooleanValue -1 -1 -coTaskMem $coTaskMem] \
   346    375           [list null MustHaveBooleanValue -1 -1 -noTrace $noTrace]] $argv
   347    376   
   348    377       set count(0) $options(-count0,value)
   349    378       set count(1) $options(-count1,value)
   350    379       set count(2) $options(-count2,value)
   351    380       set count(3) $options(-count3,value)
   352    381       set count(4) $options(-count4,value)
   353    382       set count(5) $options(-count5,value)
          383  +    set count(6) $options(-count6,value)
          384  +    set count(7) $options(-count7,value)
          385  +    set count(8) $options(-count8,value)
   354    386       set noWorkload $options(-noWorkload,value)
   355    387       set priorities $options(-priorities,value)
   356    388       set exitOnFail $options(-exitOnFail,value)
   357    389       set coTaskMem $options(-coTaskMem,value)
   358    390       set noTrace $options(-noTrace,value)
   359    391     }
   360    392   
................................................................................
   427    459         "---- small chunk size is " $count(3) " byte(s)\n"]
   428    460   
   429    461     tputs $test_channel [appendArgs \
   430    462         "---- big chunk size is " $count(4) " byte(s)\n"]
   431    463   
   432    464     tputs $test_channel [appendArgs \
   433    465         "---- maximum excluded heap memory is " $count(5) " byte(s)\n"]
          466  +
          467  +  tputs $test_channel [appendArgs \
          468  +      "---- workloads will have an auxiliary iteration count of " \
          469  +      $count(6) \n]
          470  +
          471  +  tputs $test_channel [appendArgs \
          472  +      "---- workloads will have an auxiliary iteration delay of " \
          473  +      $count(7) " millisecond(s)\n"]
          474  +
          475  +  tputs $test_channel [appendArgs \
          476  +      "---- workloads will have an auxiliary data value of " \
          477  +      $count(8) \n]
   434    478   
   435    479     tputs $test_channel [appendArgs \
   436    480         "---- workloads to be skipped... " \
   437    481         [expr {[llength $noWorkload] > 0 ? $noWorkload : "none"}] \n]
   438    482   
   439    483     tputs $test_channel [appendArgs \
   440    484         "---- workloads priority overrides... " \
................................................................................
  1122   1166         set maxSize $::count(5)
  1123   1167         object invoke GC AddMemoryPressure $maxSize
  1124   1168         try {
  1125   1169           for {set index 1} {$index <= $count1} {incr index} {
  1126   1170             if {[catch {
  1127   1171               set size [expr {int(min($maxSize, abs($count3 * $index * 5.0)))}]
  1128   1172               set ptr [allocMem $size]; # throw
  1129         -            useMem $ptr $size; delayTest $count2
         1173  +            useMem $ptr $size; delayTest -1 $count2
  1130   1174               freeMem $ptr; unset -nocomplain ptr
  1131   1175               showTest P
  1132   1176             } error]} then {
  1133   1177               if {[isExpectedError $error]} then {
  1134   1178                 showTest p
  1135   1179               } else {
  1136   1180                 failTest p $error
................................................................................
  1331   1375               failTest t $error
  1332   1376             }
  1333   1377           }
  1334   1378         }
  1335   1379         doneTest T
  1336   1380       }] 0]
  1337   1381     }]
         1382  +
         1383  +  #############################################################################
         1384  +  #                              WORKLOAD #21 (U)                             #
         1385  +  #############################################################################
         1386  +
         1387  +  set workload(21) [list \
         1388  +      [list srcFileName dstFileName table count1 count2 count3] {
         1389  +    #
         1390  +    # NOTE: Workload #21, rapidly try to release all non-essential memory.
         1391  +    #
         1392  +    waitTest U
         1393  +    lappend ::times(21) [lindex [time {
         1394  +      initTest U
         1395  +      for {set index 1} {$index <= $::count(6)} {incr index} {
         1396  +        if {[catch {
         1397  +          releaseMem -1
         1398  +          showTestWithDelay U 0 $::count(7)
         1399  +        } error]} then {
         1400  +          if {[isExpectedError $error]} then {
         1401  +            showTest u
         1402  +          } else {
         1403  +            failTest u $error
         1404  +          }
         1405  +        }
         1406  +      }
         1407  +      doneTest U
         1408  +    }] 0]
         1409  +  }]
         1410  +
         1411  +  #############################################################################
         1412  +  #                              WORKLOAD #22 (V)                             #
         1413  +  #############################################################################
         1414  +
         1415  +  set workload(22) [list \
         1416  +      [list srcFileName dstFileName table count1 count2 count3] {
         1417  +    #
         1418  +    # NOTE: Workload #22, rapidly try to change the default cache size.
         1419  +    #
         1420  +    waitTest V
         1421  +    lappend ::times(22) [lindex [time {
         1422  +      initTest V
         1423  +      setupWorkloadFileDb $dstFileName db
         1424  +      for {set index 1} {$index <= $::count(6)} {incr index} {
         1425  +        if {[catch {
         1426  +          sql execute $db [appendArgs \
         1427  +              "PRAGMA default_cache_size=" \
         1428  +              [expr {int(rand() * $::count(8))}] \;]
         1429  +          showTestWithDelay V 0 $::count(7)
         1430  +        } error]} then {
         1431  +          if {[isExpectedError $error]} then {
         1432  +            showTest v
         1433  +          } else {
         1434  +            failTest v $error
         1435  +          }
         1436  +        }
         1437  +      }
         1438  +      cleanupDb $dstFileName db false true false
         1439  +      doneTest V
         1440  +    }] 0]
         1441  +  }]
  1338   1442   } -body {
  1339   1443     set workloadNames(all) [array names workload]
  1340   1444   
  1341   1445     tputs $test_channel [appendArgs \
  1342   1446         "---- there are " [llength $workloadNames(all)] \
  1343   1447         " total workloads, their names are: " $workloadNames(all) \n]
  1344   1448   
................................................................................
  1492   1596     foreach index(0) [array names thread] {
  1493   1597       if {[info exists thread($index(0))] && \
  1494   1598           [cleanupThread $thread($index(0))]} then {
  1495   1599         unset -nocomplain thread($index(0))
  1496   1600       }
  1497   1601     }
  1498   1602   
         1603  +  rename releaseMem ""
  1499   1604     rename freeMem ""
  1500   1605     rename useMem ""
  1501   1606     rename allocMem ""
  1502   1607     rename failTest ""
  1503   1608     rename doneTest ""
         1609  +  rename showTestWithDelay ""
  1504   1610     rename showTest ""
  1505   1611     rename waitTest ""
  1506   1612     rename delayTest ""
  1507   1613     rename initTest ""
  1508   1614     rename isExpectedError ""
  1509   1615     rename formatWorkloadTime ""
  1510   1616     rename formatWorkloadResult ""

Changes to lib/System.Data.SQLite/common.eagle.

   175    175             [string length $::test_net_fx] > 0} then {
   176    176           #
   177    177           # NOTE: Use the specified test .NET Framework.
   178    178           #
   179    179           return $::test_net_fx
   180    180         } else {
   181    181           set year [getBuildYear]
   182         -
   183         -        switch -exact -- $year {
   184         -          2005 {
   185         -            return netFx20
   186         -          }
   187         -          2008 {
   188         -            return netFx35
   189         -          }
   190         -          2010 {
   191         -            return netFx40
   192         -          }
   193         -          2012 {
   194         -            return netFx45
   195         -          }
   196         -          2013 {
   197         -            return netFx451
   198         -            # return netFx452
   199         -          }
   200         -          2015 {
   201         -            return netFx46
   202         -          }
   203         -          default {
   204         -            return netFx35; # TODO: Good "fallback" default?
          182  +        set yearVarName [appendArgs ::test_net_fx_ $year]
          183  +
          184  +        if {[info exists $yearVarName] && \
          185  +            [string length [set $yearVarName]] > 0} then {
          186  +          #
          187  +          # NOTE: Use the specified test .NET Framework, based on the build
          188  +          #       year.
          189  +          #
          190  +          return [set $yearVarName]
          191  +        } else {
          192  +          #
          193  +          # NOTE: Fallback to the "well known" .NET Framework version that
          194  +          #       is most closely associated with a particular version of
          195  +          #       Visual Studio.
          196  +          #
          197  +          switch -exact -- $year {
          198  +            2005 {
          199  +              return netFx20
          200  +            }
          201  +            2008 {
          202  +              return netFx35
          203  +            }
          204  +            2010 {
          205  +              return netFx40
          206  +            }
          207  +            2012 {
          208  +              return netFx45
          209  +            }
          210  +            2013 {
          211  +              return netFx451; # TODO: Or "netFx452"?
          212  +            }
          213  +            2015 {
          214  +              return netFx46
          215  +            }
          216  +            default {
          217  +              return netFx35; # TODO: Good "fallback" default?
          218  +            }
   205    219             }
   206    220           }
   207    221         }
   208    222       }
   209    223   
   210    224       #
   211    225       # NOTE: This procedure should return non-zero if the configured test

Changes to readme.htm.

     2      2   <html>
     3      3   <head>
     4      4   <title></title>
     5      5   </head>
     6      6   <body>
     7      7   ADO.NET SQLite Data Provider<br />
     8      8   Version 1.0.98.0 - August XX, 2015 <font color="red">(release scheduled)</font><br />
     9         -Using <a href="https://www.sqlite.org/draft/releaselog/3_8_11.html">SQLite 3.8.11</a><br />
            9  +Using <a href="https://www.sqlite.org/releaselog/3_8_11_1.html">SQLite 3.8.11.1</a><br />
    10     10   Originally written by Robert Simpson<br />
    11     11   Released to the public domain, use at your own risk!<br />
    12     12   Official provider website:&nbsp;<a href="https://system.data.sqlite.org/">https://system.data.sqlite.org/</a><br />
    13     13   Legacy versions:&nbsp;<a href="http://sqlite.phxsoftware.com/">http://sqlite.phxsoftware.com/</a><br />
    14     14   <br />
    15     15   The current development version can be downloaded from <a href="https://system.data.sqlite.org/index.html/timeline?y=ci">
    16     16   https://system.data.sqlite.org/index.html/timeline?y=ci</a>
................................................................................
   208    208   
   209    209   <h2><b>Version History</b></h2>
   210    210   
   211    211   <p>
   212    212       <b>1.0.98.0 - August XX, 2015 <font color="red">(release scheduled)</font></b>
   213    213   </p>
   214    214   <ul>
   215         -    <li>Updated to <a href="https://www.sqlite.org/draft/releaselog/3_8_11.html">SQLite 3.8.11</a>.</li>
          215  +    <li>Updated to <a href="https://www.sqlite.org/releaselog/3_8_11_1.html">SQLite 3.8.11.1</a>.</li>
   216    216       <li>Add full support for Visual Studio 2015 and the .NET Framework 4.6.</li>
   217    217       <li>Implement the Substring method for LINQ using the &quot;substr&quot; core SQL function.&nbsp;<b>** Potentially Incompatible Change **</b></li>
          218  +    <li>Honor the second argument to Math.Round when using LINQ.&nbsp;<b>** Potentially Incompatible Change **</b></li>
   218    219       <li>Honor the pre-existing flags for connections during the Open method. Fix for [964063da16].&nbsp;<b>** Potentially Incompatible Change **</b></li>
   219    220       <li>Remove errant semi-colons from the SQL used by LINQ to INSERT and then SELECT rows with composite primary keys. Fix for [9d353b0bd8].</li>
   220    221       <li>Change the base type for the SQLiteConnectionFlags enumeration to long integer.&nbsp;<b>** Potentially Incompatible Change **</b></li>
   221    222       <li>Add extended return codes to the SQLiteErrorCode enumeration. Pursuant to [71bedaca19].&nbsp;<b>** Potentially Incompatible Change **</b></li>
   222    223       <li>Improve exception handling in all native callbacks implemented in the SQLiteConnection class.</li>
   223    224       <li>Add Progress event and ProgressOps connection string property to enable raising progress events during long-running queries.</li>
          225  +    <li>Add &quot;Recursive Triggers&quot; connection string property to enable or disable the recursive trigger capability. Pursuant to [3a82ee635b].</li>
   224    226       <li>Add NoDefaultFlags connection string property to prevent the default connection flags from being used. Pursuant to [964063da16].</li>
   225    227       <li>Add VfsName connection string property to allow a non-default VFS to be used by the SQLite core library.</li>
   226    228       <li>Add BusyTimeout connection string property to set the busy timeout to be used by the SQLite core library.</li>
   227    229       <li>Add UnbindFunction and UnbindAllFunctions methods to the SQLiteConnection class.</li>
   228    230       <li>Enable integration with the <a href="http://www.hwaci.com/sw/sqlite/zipvfs.html">ZipVFS</a> extension.</li>
   229    231   </ul>
   230    232   <p>

Changes to testlinq/Program.cs.

   185    185   
   186    186                                 return 1;
   187    187                             }
   188    188                         }
   189    189   
   190    190                         return BinaryGuidTest2(value);
   191    191                     }
          192  +#endif
          193  +#if NET_40 || NET_45 || NET_451 || NET_46
          194  +              case "round":
          195  +                  {
          196  +                      return RoundTest();
          197  +                  }
   192    198   #endif
   193    199                 default:
   194    200                     {
   195    201                         Console.WriteLine("unknown test \"{0}\"", arg);
   196    202                         return 1;
   197    203                     }
   198    204             }
................................................................................
   784    790                     "AppendManifestToken_SQLiteProviderManifest",
   785    791                     null);
   786    792             }
   787    793   
   788    794             Environment.SetEnvironmentVariable("SQLite_ForceLogPrepare", null);
   789    795             Trace.Listeners.Remove(listener);
   790    796         }
          797  +
          798  +#if NET_40 || NET_45 || NET_451 || NET_46
          799  +      //
          800  +      // NOTE: Used to test the ROUND fix (i.e. being able to properly handle
          801  +      //       the two argument form).
          802  +      //
          803  +      private static int RoundTest()
          804  +      {
          805  +            using (northwindEFEntities db = new northwindEFEntities())
          806  +            {
          807  +                bool once = false;
          808  +
          809  +                foreach (int[] i in new int[][] {
          810  +                        new int[] { 10503, 65 },
          811  +                        new int[] { 10503, 14 },
          812  +                        new int[] { 10635, 5 }
          813  +                    })
          814  +                {
          815  +                    for (int j = 0; j < 3; j++)
          816  +                    {
          817  +                        int oid = i[0];
          818  +                        int pid = i[1];
          819  +
          820  +                        var query = from o in db.OrderDetails
          821  +                                    where o.OrderID == oid && o.ProductID == pid
          822  +                                    select new { NewUnitPrice = Math.Round(o.UnitPrice, j) };
          823  +
          824  +                        foreach (object o in query)
          825  +                        {
          826  +                            if (once)
          827  +                                Console.Write(' ');
          828  +
          829  +                            Console.Write("{0}", o);
          830  +
          831  +                            once = true;
          832  +                        }
          833  +                    }
          834  +                }
          835  +            }
          836  +
          837  +            return 0;
          838  +      }
          839  +#endif
   791    840   
   792    841       private static int OldTests()
   793    842       {
   794    843         using (northwindEFEntities db = new northwindEFEntities())
   795    844         {
   796    845           {
   797    846             string entitySQL = "SELECT VALUE o FROM Orders AS o WHERE SQLite.DatePart('yyyy', o.OrderDate) = 1997 ORDER BY o.OrderID;";

Changes to www/downloads.wiki.

   479    479           required.
   480    480           <br />
   481    481           <big><b>This is the only setup package that is capable of installing the
   482    482           design-time components for Visual Studio 2005.
   483    483           <br />
   484    484           <br />
   485    485           However, if you do not require the design-time components, please
   486         -        consider downloading the associated
   487         -        <a href="/downloads/1.0.97.0/sqlite-netFx20-binary-bundle-Win32-2005-1.0.97.0.zip">Precompiled Binaries</a>
          486  +        consider downloading the associated &quot;Precompiled Binaries&quot;
   488    487           instead.</b></big>
   489    488           <br />
   490    489           <br />
   491    490           (sha1: daa0f42621b93769755fb7a6546eddd3d56b8e72)
   492    491         </td>
   493    492       </tr>
   494    493   
................................................................................
   579    578           required.
   580    579           <br />
   581    580           <big><b>This is the only setup package that is capable of installing the
   582    581           design-time components for Visual Studio 2008.
   583    582           <br />
   584    583           <br />
   585    584           However, if you do not require the design-time components, please
   586         -        consider downloading the associated
   587         -        <a href="/downloads/1.0.97.0/sqlite-netFx35-binary-bundle-Win32-2008-1.0.97.0.zip">Precompiled Binaries</a>
          585  +        consider downloading the associated &quot;Precompiled Binaries&quot;
   588    586           instead.</b></big>
   589    587           <br />
   590    588           <br />
   591    589           (sha1: 03d86dba982e89dadfd19fc9bce775dcab040632)
   592    590         </td>
   593    591       </tr>
   594    592   
................................................................................
   678    676           SP1 runtime for x86 is included.  The .NET Framework 4.0 is required.
   679    677           <br />
   680    678           <big><b>This is the only setup package that is capable of installing the
   681    679           design-time components for Visual Studio 2010.
   682    680           <br />
   683    681           <br />
   684    682           However, if you do not require the design-time components, please
   685         -        consider downloading the associated
   686         -        <a href="/downloads/1.0.97.0/sqlite-netFx40-binary-bundle-Win32-2010-1.0.97.0.zip">Precompiled Binaries</a>
   687         -        instead.</b></big></b></big>
          683  +        consider downloading the associated &quot;Precompiled Binaries&quot;
          684  +        instead.</b></big>
   688    685           <br />
   689    686           <br />
   690    687           (sha1: 182ae1db5c4747a4d24a8498a0c8ab14dfea3a55)
   691    688         </td>
   692    689       </tr>
   693    690   
   694    691       <tr>
................................................................................
   777    774           required.
   778    775           <br />
   779    776           <big><b>This is the only setup package that is capable of installing the
   780    777           design-time components for Visual Studio 2012.
   781    778           <br />
   782    779           <br />
   783    780           However, if you do not require the design-time components, please
   784         -        consider downloading the associated
   785         -        <a href="/downloads/1.0.97.0/sqlite-netFx45-binary-bundle-Win32-2012-1.0.97.0.zip">Precompiled Binaries</a>
   786         -        instead.
          781  +        consider downloading the associated &quot;Precompiled Binaries&quot;
          782  +        instead.</b></big>
   787    783           <br />
   788    784           <br />
   789         -        Using Entity Framework 6 design-time support may require installing the
   790         -        Visual Studio 2012 &quot;flavor&quot; of the
          785  +        <big><b>Using Entity Framework 6 design-time support may require
          786  +        installing the Visual Studio 2012 &quot;flavor&quot; of the
   791    787           <a href="https://www.microsoft.com/en-us/download/details.aspx?id=40762">
   792    788           Entity Framework 6 Tools for Visual Studio 2012 &amp; 2013</a>.</b></big>
   793    789           <br />
   794    790           <br />
   795    791           (sha1: ff9df099dce5e3f0d478e33f587a2866cae9c8ab)
   796    792         </td>
   797    793       </tr>
................................................................................
   883    879           required.
   884    880           <br />
   885    881           <big><b>This is the only setup package that is capable of installing the
   886    882           design-time components for Visual Studio 2013.
   887    883           <br />
   888    884           <br />
   889    885           However, if you do not require the design-time components, please
   890         -        consider downloading the associated
   891         -        <a href="/downloads/1.0.97.0/sqlite-netFx451-binary-bundle-Win32-2013-1.0.97.0.zip">Precompiled Binaries</a>
   892         -        instead.
          886  +        consider downloading the associated &quot;Precompiled Binaries&quot;
          887  +        instead.</b></big>
   893    888           <br />
   894    889           <br />
   895         -        Using Entity Framework 6 design-time support may require installing the
   896         -        Visual Studio 2013 &quot;flavor&quot; of the
          890  +        <big><b>Using Entity Framework 6 design-time support may require
          891  +        installing the Visual Studio 2013 &quot;flavor&quot; of the
   897    892           <a href="https://www.microsoft.com/en-us/download/details.aspx?id=40762">
   898    893           Entity Framework 6 Tools for Visual Studio 2012 &amp; 2013</a>.</b></big>
   899    894           <br />
   900    895           <br />
   901    896           (sha1: 15e31d48589c72d17e2269f72110c7e7a32cb6e3)
   902    897         </td>
   903    898       </tr>
................................................................................
  1089   1084         <td width="5"></td>
  1090   1085         <td valign="top">
  1091   1086           This binary package features the mixed-mode assembly and contains all
  1092   1087           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1093   1088           (3.8.10.2) package.  The Visual C++ 2005 SP1 runtime for x86 and the .NET
  1094   1089           Framework 2.0 SP2 are required.
  1095   1090           <br />
  1096         -        (sha1: 0afeb372cb78ec87e661440151599b91df4b8546)
         1091  +        (sha1: cc734b0a7054a9a982667faaf6faf86c94f37b6f)
  1097   1092         </td>
  1098   1093       </tr>
  1099   1094   
  1100   1095       <tr>
  1101   1096         <td width="10">&nbsp;</td>
  1102   1097         <td width="30%" valign="top" align="right">
  1103   1098           <a name="sqlite-netFx20-binary-Win32-2005"></a>
................................................................................
  1107   1102         </td>
  1108   1103         <td width="5"></td>
  1109   1104         <td valign="top">
  1110   1105           This binary package contains all the binaries for the x86 version of the
  1111   1106           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2005 SP1
  1112   1107           runtime for x86 and the .NET Framework 2.0 SP2 are required.
  1113   1108           <br />
  1114         -        (sha1: 8f4acc7c21aa1c18f6caaf335182c1b524d458a1)
         1109  +        (sha1: 72574347632bf2aada0703142ccaac197135c1cc)
  1115   1110         </td>
  1116   1111       </tr>
  1117   1112   
  1118   1113       <tr>
  1119   1114         <td colspan="4">
  1120   1115           <b>Precompiled Binaries for 64-bit Windows (.NET Framework 2.0 SP2)</b>
  1121   1116         </td>
................................................................................
  1132   1127         <td width="5"></td>
  1133   1128         <td valign="top">
  1134   1129           This binary package features the mixed-mode assembly and contains all
  1135   1130           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1136   1131           (3.8.10.2) package.  The Visual C++ 2005 SP1 runtime for x64 and the .NET
  1137   1132           Framework 2.0 SP2 are required.
  1138   1133           <br />
  1139         -        (sha1: c1d1b139698b588e10db6254cb59172c0cac7ff0)
         1134  +        (sha1: 3214c23872b129b3d1d955708f5e755b73635cc8)
  1140   1135         </td>
  1141   1136       </tr>
  1142   1137   
  1143   1138       <tr>
  1144   1139         <td width="10">&nbsp;</td>
  1145   1140         <td width="30%" valign="top" align="right">
  1146   1141           <a name="sqlite-netFx20-binary-x64-2005"></a>
................................................................................
  1150   1145         </td>
  1151   1146         <td width="5"></td>
  1152   1147         <td valign="top">
  1153   1148           This binary package contains all the binaries for the x64 version of the
  1154   1149           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2005 SP1
  1155   1150           runtime for x64 and the .NET Framework 2.0 SP2 are required.
  1156   1151           <br />
  1157         -        (sha1: 16f924ace19b1866757f055020b27e7d12aec004)
         1152  +        (sha1: 3c56ff6cc15dd0c0f2883fade40a0a352c205c87)
  1158   1153         </td>
  1159   1154       </tr>
  1160   1155   
  1161   1156       <tr>
  1162   1157         <td colspan="4">
  1163   1158           <b>Precompiled Binaries for 32-bit Windows (.NET Framework 3.5 SP1)</b>
  1164   1159         </td>
................................................................................
  1175   1170         <td width="5"></td>
  1176   1171         <td valign="top">
  1177   1172           This binary package features the mixed-mode assembly and contains all
  1178   1173           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1179   1174           (3.8.10.2) package.  The Visual C++ 2008 SP1 runtime for x86 and the .NET
  1180   1175           Framework 3.5 SP1 are required.
  1181   1176           <br />
  1182         -        (sha1: be8ccc073d46a733e2109092104545a7d30932cb)
         1177  +        (sha1: 68557106ccf5966c1b273e5d52e44203d0704d6e)
  1183   1178         </td>
  1184   1179       </tr>
  1185   1180   
  1186   1181       <tr>
  1187   1182         <td width="10">&nbsp;</td>
  1188   1183         <td width="30%" valign="top" align="right">
  1189   1184           <a name="sqlite-netFx35-binary-Win32-2008"></a>
................................................................................
  1193   1188         </td>
  1194   1189         <td width="5"></td>
  1195   1190         <td valign="top">
  1196   1191           This binary package contains all the binaries for the x86 version of the
  1197   1192           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2008 SP1
  1198   1193           runtime for x86 and the .NET Framework 3.5 SP1 are required.
  1199   1194           <br />
  1200         -        (sha1: 6ad84dfc749cad5a26dd277ed26ec2ab3dd6e7fb)
         1195  +        (sha1: 3b8e7799d1463458fa0dcf8ca35b28b57d30da9e)
  1201   1196         </td>
  1202   1197       </tr>
  1203   1198   
  1204   1199       <tr>
  1205   1200         <td colspan="4">
  1206   1201           <b>Precompiled Binaries for 64-bit Windows (.NET Framework 3.5 SP1)</b>
  1207   1202         </td>
................................................................................
  1218   1213         <td width="5"></td>
  1219   1214         <td valign="top">
  1220   1215           This binary package features the mixed-mode assembly and contains all
  1221   1216           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1222   1217           (3.8.10.2) package.  The Visual C++ 2008 SP1 runtime for x64 and the .NET
  1223   1218           Framework 3.5 SP1 are required.
  1224   1219           <br />
  1225         -        (sha1: 91124d0b9967b8417d03bf2e453a68c7ba8e3dc9)
         1220  +        (sha1: 8b3197f83606afe6cc288da72a69310d5f797362)
  1226   1221         </td>
  1227   1222       </tr>
  1228   1223   
  1229   1224       <tr>
  1230   1225         <td width="10">&nbsp;</td>
  1231   1226         <td width="30%" valign="top" align="right">
  1232   1227           <a name="sqlite-netFx35-binary-x64-2008"></a>
................................................................................
  1236   1231         </td>
  1237   1232         <td width="5"></td>
  1238   1233         <td valign="top">
  1239   1234           This binary package contains all the binaries for the x64 version of the
  1240   1235           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2008 SP1
  1241   1236           runtime for x64 and the .NET Framework 3.5 SP1 are required.
  1242   1237           <br />
  1243         -        (sha1: 8ef4afdddb1b0de8b294392267c87dbcc5528120)
         1238  +        (sha1: e30e32261f5003ca588eaaea789a0a49e0b20a08)
  1244   1239         </td>
  1245   1240       </tr>
  1246   1241   
  1247   1242       <tr>
  1248   1243         <td colspan="4">
  1249   1244           <b>Precompiled Binaries for 32-bit Windows (.NET Framework 4.0)</b>
  1250   1245         </td>
................................................................................
  1261   1256         <td width="5"></td>
  1262   1257         <td valign="top">
  1263   1258           This binary package features the mixed-mode assembly and contains all
  1264   1259           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1265   1260           (3.8.10.2) package.  The Visual C++ 2010 SP1 runtime for x86 and the .NET
  1266   1261           Framework 4.0 are required.
  1267   1262           <br />
  1268         -        (sha1: 553fda6d6ed177cee668137d6bbe58af29eaa078)
         1263  +        (sha1: a6c4403b321b8bf64e4f6c629e1734564fc68646)
  1269   1264         </td>
  1270   1265       </tr>
  1271   1266   
  1272   1267       <tr>
  1273   1268         <td width="10">&nbsp;</td>
  1274   1269         <td width="30%" valign="top" align="right">
  1275   1270           <a name="sqlite-netFx40-binary-Win32-2010"></a>
................................................................................
  1279   1274         </td>
  1280   1275         <td width="5"></td>
  1281   1276         <td valign="top">
  1282   1277           This binary package contains all the binaries for the x86 version of the
  1283   1278           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2010 SP1
  1284   1279           runtime for x86 and the .NET Framework 4.0 are required.
  1285   1280           <br />
  1286         -        (sha1: 404a5c35683d78eba1fa4de78546a8e6dd0d7f74)
         1281  +        (sha1: b1cd74abb20dd6f724cb25d34fab302c981fc46a)
  1287   1282         </td>
  1288   1283       </tr>
  1289   1284   
  1290   1285       <tr>
  1291   1286         <td colspan="4">
  1292   1287           <b>Precompiled Binaries for 64-bit Windows (.NET Framework 4.0)</b>
  1293   1288         </td>
................................................................................
  1304   1299         <td width="5"></td>
  1305   1300         <td valign="top">
  1306   1301           This binary package features the mixed-mode assembly and contains all
  1307   1302           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1308   1303           (3.8.10.2) package.  The Visual C++ 2010 SP1 runtime for x64 and the .NET
  1309   1304           Framework 4.0 are required.
  1310   1305           <br />
  1311         -        (sha1: 3d12f81cebd56bbfc486697bf07c0c95448e67e0)
         1306  +        (sha1: 65d4f10bcdf5ce4bf6831de50740c174f879cb64)
  1312   1307         </td>
  1313   1308       </tr>
  1314   1309   
  1315   1310       <tr>
  1316   1311         <td width="10">&nbsp;</td>
  1317   1312         <td width="30%" valign="top" align="right">
  1318   1313           <a name="sqlite-netFx40-binary-x64-2010"></a>
................................................................................
  1322   1317         </td>
  1323   1318         <td width="5"></td>
  1324   1319         <td valign="top">
  1325   1320           This binary package contains all the binaries for the x64 version of the
  1326   1321           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2010 SP1
  1327   1322           runtime for x64 and the .NET Framework 4.0 are required.
  1328   1323           <br />
  1329         -        (sha1: 50995dab87ba2cf0a8afd6a1ebd78c5ef3d71d39)
         1324  +        (sha1: d3de79ff9101c370def18a69f2cd0902ccbcaef3)
  1330   1325         </td>
  1331   1326       </tr>
  1332   1327   
  1333   1328       <tr>
  1334   1329         <td colspan="4">
  1335   1330           <b>Precompiled Binaries for 32-bit Windows (.NET Framework 4.5)</b>
  1336   1331         </td>
................................................................................
  1338   1333   
  1339   1334       <tr>
  1340   1335         <td width="10">&nbsp;</td>
  1341   1336         <td width="30%" valign="top" align="right">
  1342   1337           <a name="sqlite-netFx45-binary-bundle-Win32-2012"></a>
  1343   1338           <a href="/downloads/1.0.97.0/sqlite-netFx45-binary-bundle-Win32-2012-1.0.97.0.zip">sqlite-netFx45-binary-bundle-Win32-2012-1.0.97.0.zip</a>
  1344   1339           <br />
  1345         -        (2.09 MiB)
         1340  +        (2.08 MiB)
  1346   1341         </td>
  1347   1342         <td width="5"></td>
  1348   1343         <td valign="top">
  1349   1344           This binary package features the mixed-mode assembly and contains all
  1350   1345           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1351   1346           (3.8.10.2) package.  The Visual C++ 2012 Update 4 runtime for x86 and
  1352   1347           the .NET Framework 4.5 are required.
  1353   1348           <br />
  1354         -        (sha1: df630c257106eecd6e901b49dd4939f10b2abb0e)
         1349  +        (sha1: 1adff0b8f1c8c855f047972ca7be1a6ea99eee5c)
  1355   1350         </td>
  1356   1351       </tr>
  1357   1352   
  1358   1353       <tr>
  1359   1354         <td width="10">&nbsp;</td>
  1360   1355         <td width="30%" valign="top" align="right">
  1361   1356           <a name="sqlite-netFx45-binary-Win32-2012"></a>
................................................................................
  1365   1360         </td>
  1366   1361         <td width="5"></td>
  1367   1362         <td valign="top">
  1368   1363           This binary package contains all the binaries for the x86 version of the
  1369   1364           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2012
  1370   1365           Update 4 runtime for x86 and the .NET Framework 4.5 are required.
  1371   1366           <br />
  1372         -        (sha1: 0be4dda13cc849059850918d54704d1f466f24f3)
         1367  +        (sha1: 7702faa724ec29a627ddea3cae5a69bd915320e2)
  1373   1368         </td>
  1374   1369       </tr>
  1375   1370   
  1376   1371       <tr>
  1377   1372         <td colspan="4">
  1378   1373           <b>Precompiled Binaries for 64-bit Windows (.NET Framework 4.5)</b>
  1379   1374         </td>
................................................................................
  1390   1385         <td width="5"></td>
  1391   1386         <td valign="top">
  1392   1387           This binary package features the mixed-mode assembly and contains all
  1393   1388           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1394   1389           (3.8.10.2) package.  The Visual C++ 2012 Update 4 runtime for x64 and
  1395   1390           the .NET Framework 4.5 are required.
  1396   1391           <br />
  1397         -        (sha1: a8aab51c076d4d6b605d968fd5d49219ef2ad074)
         1392  +        (sha1: e3d1c61f1d960b8535577fc62ebad8651cf39cc6)
  1398   1393         </td>
  1399   1394       </tr>
  1400   1395   
  1401   1396       <tr>
  1402   1397         <td width="10">&nbsp;</td>
  1403   1398         <td width="30%" valign="top" align="right">
  1404   1399           <a name="sqlite-netFx45-binary-x64-2012"></a>
................................................................................
  1408   1403         </td>
  1409   1404         <td width="5"></td>
  1410   1405         <td valign="top">
  1411   1406           This binary package contains all the binaries for the x64 version of the
  1412   1407           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2012
  1413   1408           Update 4 runtime for x64 and the .NET Framework 4.5 are required.
  1414   1409           <br />
  1415         -        (sha1: 5660021666d3e1652259cad43bfad21c117bd0a9)
         1410  +        (sha1: a4959439e8caec0a886c7a2758c336f3927df9a2)
  1416   1411         </td>
  1417   1412       </tr>
  1418   1413   
  1419   1414       <tr>
  1420   1415         <td colspan="4">
  1421   1416           <b>Precompiled Binaries for 32-bit Windows (.NET Framework 4.5.1)</b>
  1422   1417         </td>
................................................................................
  1424   1419   
  1425   1420       <tr>
  1426   1421         <td width="10">&nbsp;</td>
  1427   1422         <td width="30%" valign="top" align="right">
  1428   1423           <a name="sqlite-netFx451-binary-bundle-Win32-2013"></a>
  1429   1424           <a href="/downloads/1.0.97.0/sqlite-netFx451-binary-bundle-Win32-2013-1.0.97.0.zip">sqlite-netFx451-binary-bundle-Win32-2013-1.0.97.0.zip</a>
  1430   1425           <br />
  1431         -        (2.08 MiB)
         1426  +        (2.09 MiB)
  1432   1427         </td>
  1433   1428         <td width="5"></td>
  1434   1429         <td valign="top">
  1435   1430           This binary package features the mixed-mode assembly and contains all
  1436   1431           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1437   1432           (3.8.10.2) package.  The Visual C++ 2013 Update 2 runtime for x86 and the
  1438   1433           .NET Framework 4.5.1 are required.
  1439   1434           <br />
  1440         -        (sha1: a59cf2a937288cf97417d2ad4e3b91e16e85709f)
         1435  +        (sha1: 1969fdc760e2b35633b9c5f33df17a7d9a37c656)
  1441   1436         </td>
  1442   1437       </tr>
  1443   1438   
  1444   1439       <tr>
  1445   1440         <td width="10">&nbsp;</td>
  1446   1441         <td width="30%" valign="top" align="right">
  1447   1442           <a name="sqlite-netFx451-binary-Win32-2013"></a>
................................................................................
  1451   1446         </td>
  1452   1447         <td width="5"></td>
  1453   1448         <td valign="top">
  1454   1449           This binary package contains all the binaries for the x86 version of the
  1455   1450           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2013
  1456   1451           Update 2 runtime for x86 and the .NET Framework 4.5.1 are required.
  1457   1452           <br />
  1458         -        (sha1: 482c26ca4a69f6b36617867164997a8ae7a1d9ff)
         1453  +        (sha1: cc50caf9a77fe4559d58823849d953d8178603e9)
  1459   1454         </td>
  1460   1455       </tr>
  1461   1456   
  1462   1457       <tr>
  1463   1458         <td colspan="4">
  1464   1459           <b>Precompiled Binaries for 64-bit Windows (.NET Framework 4.5.1)</b>
  1465   1460         </td>
................................................................................
  1476   1471         <td width="5"></td>
  1477   1472         <td valign="top">
  1478   1473           This binary package features the mixed-mode assembly and contains all
  1479   1474           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1480   1475           (3.8.10.2) package.  The Visual C++ 2013 Update 2 runtime for x64 and the
  1481   1476           .NET Framework 4.5.1 are required.
  1482   1477           <br />
  1483         -        (sha1: 604abde66847e3fa9a5ccb6510a21335c066c581)
         1478  +        (sha1: c945cd9013326d90dcb1b7473088b2d3b4a95d47)
  1484   1479         </td>
  1485   1480       </tr>
  1486   1481   
  1487   1482       <tr>
  1488   1483         <td width="10">&nbsp;</td>
  1489   1484         <td width="30%" valign="top" align="right">
  1490   1485           <a name="sqlite-netFx451-binary-x64-2013"></a>
................................................................................
  1494   1489         </td>
  1495   1490         <td width="5"></td>
  1496   1491         <td valign="top">
  1497   1492           This binary package contains all the binaries for the x64 version of the
  1498   1493           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2013
  1499   1494           Update 2 runtime for x64 and the .NET Framework 4.5.1 are required.
  1500   1495           <br />
  1501         -        (sha1: f7874685b635893906cc7fdedbc9616c8c94c3db)
         1496  +        (sha1: 6faf09655f805ba76ab0909ad0d4acf2b1a23712)
  1502   1497         </td>
  1503   1498       </tr>
  1504   1499   
  1505   1500       <tr>
  1506   1501         <td colspan="4">
  1507   1502           <b>Precompiled Binaries for 32-bit Windows (.NET Framework 4.6)</b>
  1508   1503         </td>
................................................................................
  1605   1600         <td width="5"></td>
  1606   1601         <td valign="top">
  1607   1602           This binary package features the mixed-mode assembly and contains all
  1608   1603           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1609   1604           (3.8.10.2) package.  The Visual C++ 2005 SP1 runtime for x86 is statically
  1610   1605           linked.  The .NET Framework 2.0 SP2 is required.
  1611   1606           <br />
  1612         -        (sha1: 47d4eeea85541e364b93d5ce804479c1d7d70da2)
         1607  +        (sha1: 25577f16a03b9cebdf87de65590c8dcb10ec39c8)
  1613   1608         </td>
  1614   1609       </tr>
  1615   1610   
  1616   1611       <tr>
  1617   1612         <td width="10">&nbsp;</td>
  1618   1613         <td width="30%" valign="top" align="right">
  1619   1614           <a name="sqlite-netFx20-static-binary-Win32-2005"></a>
................................................................................
  1624   1619         <td width="5"></td>
  1625   1620         <td valign="top">
  1626   1621           This binary package contains all the binaries for the x86 version of the
  1627   1622           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2005 SP1
  1628   1623           runtime for x86 is statically linked.  The .NET Framework 2.0 SP2 is
  1629   1624           required.
  1630   1625           <br />
  1631         -        (sha1: 98311f72a1c2f30c907ae6d57db9117b183814d1)
         1626  +        (sha1: 6a53f04340d0f577c0902087f9ae14c953331272)
  1632   1627         </td>
  1633   1628       </tr>
  1634   1629   
  1635   1630       <tr>
  1636   1631         <td colspan="4">
  1637   1632           <b>Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 2.0 SP2)</b>
  1638   1633         </td>
................................................................................
  1649   1644         <td width="5"></td>
  1650   1645         <td valign="top">
  1651   1646           This binary package features the mixed-mode assembly and contains all
  1652   1647           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1653   1648           (3.8.10.2) package.  The Visual C++ 2005 SP1 runtime for x64 is statically
  1654   1649           linked.  The .NET Framework 2.0 SP2 is required.
  1655   1650           <br />
  1656         -        (sha1: f1cfddbdd78eb2e0f8f3e07d70171a0e3b573f53)
         1651  +        (sha1: 1f15cd9479633f7698213f33280353a508674087)
  1657   1652         </td>
  1658   1653       </tr>
  1659   1654   
  1660   1655       <tr>
  1661   1656         <td width="10">&nbsp;</td>
  1662   1657         <td width="30%" valign="top" align="right">
  1663   1658           <a name="sqlite-netFx20-static-binary-x64-2005"></a>
................................................................................
  1668   1663         <td width="5"></td>
  1669   1664         <td valign="top">
  1670   1665           This binary package contains all the binaries for the x64 version of the
  1671   1666           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2005 SP1
  1672   1667           runtime for x64 is statically linked.  The .NET Framework 2.0 SP2 is
  1673   1668           required.
  1674   1669           <br />
  1675         -        (sha1: d417275b621c1567560bff6ba6ae162cb553f998)
         1670  +        (sha1: 712ae5e5d34b3eddd17b20d25ebe0764ea710272)
  1676   1671         </td>
  1677   1672       </tr>
  1678   1673   
  1679   1674       <tr>
  1680   1675         <td colspan="4">
  1681   1676           <b>Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 3.5 SP1)</b>
  1682   1677         </td>
................................................................................
  1693   1688         <td width="5"></td>
  1694   1689         <td valign="top">
  1695   1690           This binary package features the mixed-mode assembly and contains all
  1696   1691           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1697   1692           (3.8.10.2) package.  The Visual C++ 2008 SP1 runtime for x86 is statically
  1698   1693           linked.  The .NET Framework 3.5 SP1 is required.
  1699   1694           <br />
  1700         -        (sha1: d9fc1b8f6f223ee028f088c180b0c40e0d1c21c0)
         1695  +        (sha1: b307177dde284527d6daf8d7625376ee3db35d76)
  1701   1696         </td>
  1702   1697       </tr>
  1703   1698   
  1704   1699       <tr>
  1705   1700         <td width="10">&nbsp;</td>
  1706   1701         <td width="30%" valign="top" align="right">
  1707   1702           <a name="sqlite-netFx35-static-binary-Win32-2008"></a>
................................................................................
  1712   1707         <td width="5"></td>
  1713   1708         <td valign="top">
  1714   1709           This binary package contains all the binaries for the x86 version of the
  1715   1710           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2008 SP1
  1716   1711           runtime for x86 is statically linked.  The .NET Framework 3.5 SP1 is
  1717   1712           required.
  1718   1713           <br />
  1719         -        (sha1: 72f12dfa8275e8b0bf30c1c22b9d4fbf9d37a8dd)
         1714  +        (sha1: b5a820573ede8ee2d39e7539349e972d973eb32f)
  1720   1715         </td>
  1721   1716       </tr>
  1722   1717   
  1723   1718       <tr>
  1724   1719         <td colspan="4">
  1725   1720           <b>Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 3.5 SP1)</b>
  1726   1721         </td>
................................................................................
  1728   1723   
  1729   1724       <tr>
  1730   1725         <td width="10">&nbsp;</td>
  1731   1726         <td width="30%" valign="top" align="right">
  1732   1727           <a name="sqlite-netFx35-static-binary-bundle-x64-2008"></a>
  1733   1728           <a href="/downloads/1.0.97.0/sqlite-netFx35-static-binary-bundle-x64-2008-1.0.97.0.zip">sqlite-netFx35-static-binary-bundle-x64-2008-1.0.97.0.zip</a>
  1734   1729           <br />
  1735         -        (2.21 MiB)
         1730  +        (2.20 MiB)
  1736   1731         </td>
  1737   1732         <td width="5"></td>
  1738   1733         <td valign="top">
  1739   1734           This binary package features the mixed-mode assembly and contains all
  1740   1735           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1741   1736           (3.8.10.2) package.  The Visual C++ 2008 SP1 runtime for x64 is statically
  1742   1737           linked.  The .NET Framework 3.5 SP1 is required.
  1743   1738           <br />
  1744         -        (sha1: 0d8571821f8feed3e56e3e6455767558ccd309e5)
         1739  +        (sha1: bbad7b401adc4ca39d11ddb994272fa4fa34d563)
  1745   1740         </td>
  1746   1741       </tr>
  1747   1742   
  1748   1743       <tr>
  1749   1744         <td width="10">&nbsp;</td>
  1750   1745         <td width="30%" valign="top" align="right">
  1751   1746           <a name="sqlite-netFx35-static-binary-x64-2008"></a>
................................................................................
  1756   1751         <td width="5"></td>
  1757   1752         <td valign="top">
  1758   1753           This binary package contains all the binaries for the x64 version of the
  1759   1754           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2008 SP1
  1760   1755           runtime for x64 is statically linked.  The .NET Framework 3.5 SP1 is
  1761   1756           required.
  1762   1757           <br />
  1763         -        (sha1: 10a7bdd6691210e78945a616e2a16a1a63a74cb3)
         1758  +        (sha1: 1f1ad2fedbcb24a31ccd786282e2cec738e03064)
  1764   1759         </td>
  1765   1760       </tr>
  1766   1761   
  1767   1762       <tr>
  1768   1763         <td colspan="4">
  1769   1764           <b>Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.0)</b>
  1770   1765         </td>
................................................................................
  1781   1776         <td width="5"></td>
  1782   1777         <td valign="top">
  1783   1778           This binary package features the mixed-mode assembly and contains all
  1784   1779           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1785   1780           (3.8.10.2) package.  The Visual C++ 2010 SP1 runtime for x86 is statically
  1786   1781           linked.  The .NET Framework 4.0 is required.
  1787   1782           <br />
  1788         -        (sha1: b1639019c79a47b0644b64436b94cec4d0a8db9d)
         1783  +        (sha1: ddd78662fef2e9e9718bfcbd54c3a50b6668f5b7)
  1789   1784         </td>
  1790   1785       </tr>
  1791   1786   
  1792   1787       <tr>
  1793   1788         <td width="10">&nbsp;</td>
  1794   1789         <td width="30%" valign="top" align="right">
  1795   1790           <a name="sqlite-netFx40-static-binary-Win32-2010"></a>
................................................................................
  1800   1795         <td width="5"></td>
  1801   1796         <td valign="top">
  1802   1797           This binary package contains all the binaries for the x86 version of the
  1803   1798           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2010 SP1
  1804   1799           runtime for x86 is statically linked.  The .NET Framework 4.0 is
  1805   1800           required.
  1806   1801           <br />
  1807         -        (sha1: 2939f91f78bd9f240c395f734b8a59e593568ef3)
         1802  +        (sha1: 4bc249674a5fa43372e7a4dfcf025eafee1436a4)
  1808   1803         </td>
  1809   1804       </tr>
  1810   1805   
  1811   1806       <tr>
  1812   1807         <td colspan="4">
  1813   1808           <b>Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.0)</b>
  1814   1809         </td>
................................................................................
  1825   1820         <td width="5"></td>
  1826   1821         <td valign="top">
  1827   1822           This binary package features the mixed-mode assembly and contains all
  1828   1823           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1829   1824           (3.8.10.2) package.  The Visual C++ 2010 SP1 runtime for x64 is statically
  1830   1825           linked.  The .NET Framework 4.0 is required.
  1831   1826           <br />
  1832         -        (sha1: c44bd06ccf6579edd3cdd2fc5143567e5f23e3c8)
         1827  +        (sha1: 5dc31fa8bb58e25196654407d877c26ef841c468)
  1833   1828         </td>
  1834   1829       </tr>
  1835   1830   
  1836   1831       <tr>
  1837   1832         <td width="10">&nbsp;</td>
  1838   1833         <td width="30%" valign="top" align="right">
  1839   1834           <a name="sqlite-netFx40-static-binary-x64-2010"></a>
................................................................................
  1844   1839         <td width="5"></td>
  1845   1840         <td valign="top">
  1846   1841           This binary package contains all the binaries for the x64 version of the
  1847   1842           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2010 SP1
  1848   1843           runtime for x64 is statically linked.  The .NET Framework 4.0 is
  1849   1844           required.
  1850   1845           <br />
  1851         -        (sha1: b0baf3c902118d8712bd42607ddfc0e0a1c22dd2)
         1846  +        (sha1: 7b07e8e6015a4d455cb8fd832b19c453972092c4)
  1852   1847         </td>
  1853   1848       </tr>
  1854   1849   
  1855   1850       <tr>
  1856   1851         <td colspan="4">
  1857   1852           <b>Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.5)</b>
  1858   1853         </td>
................................................................................
  1869   1864         <td width="5"></td>
  1870   1865         <td valign="top">
  1871   1866           This binary package features the mixed-mode assembly and contains all
  1872   1867           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1873   1868           (3.8.10.2) package.  The Visual C++ 2012 Update 4 runtime for x86 is
  1874   1869           statically linked.  The .NET Framework 4.5 is required.
  1875   1870           <br />
  1876         -        (sha1: 712d4525d6d6aa6bc0dd324aec28fd1c6be5e199)
         1871  +        (sha1: 241f027ddb2f5496f98ffea9d9abb6158b6dd97b)
  1877   1872         </td>
  1878   1873       </tr>
  1879   1874   
  1880   1875       <tr>
  1881   1876         <td width="10">&nbsp;</td>
  1882   1877         <td width="30%" valign="top" align="right">
  1883   1878           <a name="sqlite-netFx45-static-binary-Win32-2012"></a>
................................................................................
  1888   1883         <td width="5"></td>
  1889   1884         <td valign="top">
  1890   1885           This binary package contains all the binaries for the x86 version of the
  1891   1886           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2012
  1892   1887           Update 4 runtime for x86 is statically linked.  The .NET Framework 4.5
  1893   1888           is required.
  1894   1889           <br />
  1895         -        (sha1: 67392a8395b8d150e504db23176b644712f34526)
         1890  +        (sha1: a0474dde94bcea51de93f1d944df44a728326f40)
  1896   1891         </td>
  1897   1892       </tr>
  1898   1893   
  1899   1894       <tr>
  1900   1895         <td colspan="4">
  1901   1896           <b>Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.5)</b>
  1902   1897         </td>
................................................................................
  1913   1908         <td width="5"></td>
  1914   1909         <td valign="top">
  1915   1910           This binary package features the mixed-mode assembly and contains all
  1916   1911           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  1917   1912           (3.8.10.2) package.  The Visual C++ 2012 Update 4 runtime for x64 is
  1918   1913           statically linked.  The .NET Framework 4.5 is required.
  1919   1914           <br />
  1920         -        (sha1: 511ab1ba7388070bb20b966d67f80add487d241a)
         1915  +        (sha1: 8c2a819f4cb4ec30a8aa7559a4ec4fe86960f9ff)
  1921   1916         </td>
  1922   1917       </tr>
  1923   1918   
  1924   1919       <tr>
  1925   1920         <td width="10">&nbsp;</td>
  1926   1921         <td width="30%" valign="top" align="right">
  1927   1922           <a name="sqlite-netFx45-static-binary-x64-2012"></a>
................................................................................
  1932   1927         <td width="5"></td>
  1933   1928         <td valign="top">
  1934   1929           This binary package contains all the binaries for the x64 version of the
  1935   1930           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2012
  1936   1931           Update 4 runtime for x64 is statically linked.  The .NET Framework 4.5
  1937   1932           is required.
  1938   1933           <br />
  1939         -        (sha1: bd1a6abdedd130b90cb826d77432d4149326acca)
         1934  +        (sha1: 8e1505424513e9d3721172c582e3a8e900d88aab)
  1940   1935         </td>
  1941   1936       </tr>
  1942   1937   
  1943   1938       <tr>
  1944   1939         <td colspan="4">
  1945   1940           <b>Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.5.1)</b>
  1946   1941         </td>
................................................................................
  1957   1952         <td width="5"></td>
  1958   1953         <td valign="top">
  1959   1954           This binary package features the mixed-mode assembly and contains all
  1960   1955           the binaries for the x86 version of the System.Data.SQLite 1.0.97.0
  1961   1956           (3.8.10.2) package.  The Visual C++ 2013 Update 2 runtime for x86 is
  1962   1957           statically linked.  The .NET Framework 4.5.1 is required.
  1963   1958           <br />
  1964         -        (sha1: 479ef51145999822fbee9fcb1182a9a44bfbff86)
         1959  +        (sha1: c71a13e48be86edd5679fcda601991d97ddbf5d7)
  1965   1960         </td>
  1966   1961       </tr>
  1967   1962   
  1968   1963       <tr>
  1969   1964         <td width="10">&nbsp;</td>
  1970   1965         <td width="30%" valign="top" align="right">
  1971   1966           <a name="sqlite-netFx451-static-binary-Win32-2013"></a>
................................................................................
  1976   1971         <td width="5"></td>
  1977   1972         <td valign="top">
  1978   1973           This binary package contains all the binaries for the x86 version of the
  1979   1974           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2013
  1980   1975           Update 2 runtime for x86 is statically linked.  The .NET Framework 4.5.1
  1981   1976           is required.
  1982   1977           <br />
  1983         -        (sha1: 79a35b8a552e49350c3bdca2c13c463c1b666076)
         1978  +        (sha1: 62bad2092267770842b0da94e56d54bb21e14371)
  1984   1979         </td>
  1985   1980       </tr>
  1986   1981   
  1987   1982       <tr>
  1988   1983         <td colspan="4">
  1989   1984           <b>Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.5.1)</b>
  1990   1985         </td>
................................................................................
  2001   1996         <td width="5"></td>
  2002   1997         <td valign="top">
  2003   1998           This binary package features the mixed-mode assembly and contains all
  2004   1999           the binaries for the x64 version of the System.Data.SQLite 1.0.97.0
  2005   2000           (3.8.10.2) package.  The Visual C++ 2013 Update 2 runtime for x64 is
  2006   2001           statically linked.  The .NET Framework 4.5.1 is required.
  2007   2002           <br />
  2008         -        (sha1: 0215f5024574c0192c27803201b8c6dcf97d7485)
         2003  +        (sha1: 7884b038ffe7c913f31104cdca418c2b96eedfde)
  2009   2004         </td>
  2010   2005       </tr>
  2011   2006   
  2012   2007       <tr>
  2013   2008         <td width="10">&nbsp;</td>
  2014   2009         <td width="30%" valign="top" align="right">
  2015   2010           <a name="sqlite-netFx451-static-binary-x64-2013"></a>
................................................................................
  2020   2015         <td width="5"></td>
  2021   2016         <td valign="top">
  2022   2017           This binary package contains all the binaries for the x64 version of the
  2023   2018           System.Data.SQLite 1.0.97.0 (3.8.10.2) package.  The Visual C++ 2013
  2024   2019           Update 2 runtime for x64 is statically linked.  The .NET Framework 4.5.1
  2025   2020           is required.
  2026   2021           <br />
  2027         -        (sha1: 009bb7b8d4dbf4c3497d35714b949697d8432a6d)
         2022  +        (sha1: 0640bb7f4013b5276b5c78a34c90dee82ca9af1d)
  2028   2023         </td>
  2029   2024       </tr>
  2030   2025   
  2031   2026       <tr>
  2032   2027         <td colspan="4">
  2033   2028           <b>Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.6)</b>
  2034   2029         </td>

Changes to www/news.wiki.

     2      2   
     3      3   <b>Version History</b>
     4      4   
     5      5   <p>
     6      6       <b>1.0.98.0 - August XX, 2015 <font color="red">(release scheduled)</font></b>
     7      7   </p>
     8      8   <ul>
     9         -    <li>Updated to [https://www.sqlite.org/draft/releaselog/3_8_11.html|SQLite 3.8.11].</li>
            9  +    <li>Updated to [https://www.sqlite.org/releaselog/3_8_11_1.html|SQLite 3.8.11.1].</li>
    10     10       <li>Add full support for Visual Studio 2015 and the .NET Framework 4.6.</li>
    11     11       <li>Implement the Substring method for LINQ using the &quot;substr&quot; core SQL function.&nbsp;<b>** Potentially Incompatible Change **</b></li>
           12  +    <li>Honor the second argument to Math.Round when using LINQ.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    12     13       <li>Honor the pre-existing flags for connections during the Open method. Fix for [964063da16].&nbsp;<b>** Potentially Incompatible Change **</b></li>
    13     14       <li>Remove errant semi-colons from the SQL used by LINQ to INSERT and then SELECT rows with composite primary keys. Fix for [9d353b0bd8].</li>
    14     15       <li>Change the base type for the SQLiteConnectionFlags enumeration to long integer.&nbsp;<b>** Potentially Incompatible Change **</b></li>
    15     16       <li>Add extended return codes to the SQLiteErrorCode enumeration. Pursuant to [71bedaca19].&nbsp;<b>** Potentially Incompatible Change **</b></li>
    16     17       <li>Improve exception handling in all native callbacks implemented in the SQLiteConnection class.</li>
    17     18       <li>Add Progress event and ProgressOps connection string property to enable raising progress events during long-running queries.</li>
           19  +    <li>Add &quot;Recursive Triggers&quot; connection string property to enable or disable the recursive trigger capability. Pursuant to [3a82ee635b].</li>
    18     20       <li>Add NoDefaultFlags connection string property to prevent the default connection flags from being used. Pursuant to [964063da16].</li>
    19     21       <li>Add VfsName connection string property to allow a non-default VFS to be used by the SQLite core library.</li>
    20     22       <li>Add BusyTimeout connection string property to set the busy timeout to be used by the SQLite core library.</li>
    21     23       <li>Add UnbindFunction and UnbindAllFunctions methods to the SQLiteConnection class.</li>
    22     24       <li>Enable integration with the [http://www.hwaci.com/sw/sqlite/zipvfs.html|ZipVFS] extension.</li>
    23     25   </ul>
    24     26   <p>