System.Data.SQLite
Check-in [832002b852]
Not logged in

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

Overview
Comment:1.0.60.0
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | sourceforge
Files: files | file ages | folders
SHA1: 832002b852b540fb442b971c5086af8024675bc5
User & Date: rmsimpson 2008-10-05 16:29:29
Context
2009-04-28
16:16
1.0.61.0 check-in: 16e6852a8a user: rmsimpson tags: sourceforge
2008-10-05
16:29
1.0.60.0 check-in: 832002b852 user: rmsimpson tags: sourceforge
16:20
1.0.60.0 check-in: 792a4b099d user: rmsimpson tags: sourceforge
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to System.Data.SQLite.Linq/SQL.

     1         -/********************************************************
     2         - * ADO.NET 2.0 Data Provider for SQLite Version 3.X
     3         - * Written by Robert Simpson (robert@blackcastlesoft.com)
     4         - * 
     5         - * Released to the public domain, use at your own risk!
     6         - ********************************************************/
            1  +//---------------------------------------------------------------------
            2  +// <copyright file="DmlSqlGenerator.cs" company="Microsoft">
            3  +//      Copyright (c) Microsoft Corporation.  All rights reserved.
            4  +// </copyright>
            5  +//---------------------------------------------------------------------
     7      6   
     8      7   namespace System.Data.SQLite
     9      8   {
    10      9     using System;
    11     10     using System.Collections.Generic;
           11  +  using System.Diagnostics;
           12  +  using System.Globalization;
           13  +  using System.IO;
           14  +  using System.Text;
    12     15     using System.Data;
           16  +  using System.Data.Common;
           17  +  using System.Data.Metadata.Edm;
    13     18     using System.Data.Common.CommandTrees;
    14         -  using System.Data.Entity;
    15         -  using System.Runtime.CompilerServices;
           19  +  using System.Data.Common.Utils;
           20  +  using System.Data.Mapping.Update.Internal;
    16     21   
    17         -  internal class SqlChecker : DbExpressionVisitor<bool>
           22  +  /// <summary>
           23  +  /// Class generating SQL for a DML command tree.
           24  +  /// </summary>
           25  +  internal static class DmlSqlGenerator
    18     26     {
    19         -    private static Type sql8rewriter;
           27  +    private static readonly int s_commandTextBuilderInitialCapacity = 256;
    20     28   
    21         -    static SqlChecker()
           29  +    internal static string GenerateUpdateSql(DbUpdateCommandTree tree, out List<DbParameter> parameters)
           30  +    {
           31  +      StringBuilder commandText = new StringBuilder(s_commandTextBuilderInitialCapacity);
           32  +      ExpressionTranslator translator = new ExpressionTranslator(commandText, tree, null != tree.Returning, "UpdateFunction");
           33  +
           34  +      // update [schemaName].[tableName]
           35  +      commandText.Append("UPDATE ");
           36  +      tree.Target.Expression.Accept(translator);
           37  +      commandText.AppendLine();
           38  +
           39  +      // set c1 = ..., c2 = ..., ...
           40  +      bool first = true;
           41  +      commandText.Append("SET ");
           42  +      foreach (DbSetClause setClause in tree.SetClauses)
           43  +      {
           44  +        if (first) { first = false; }
           45  +        else { commandText.Append(", "); }
           46  +        setClause.Property.Accept(translator);
           47  +        commandText.Append(" = ");
           48  +        setClause.Value.Accept(translator);
           49  +      }
           50  +
           51  +      if (first)
           52  +      {
           53  +        // If first is still true, it indicates there were no set
           54  +        // clauses. Introduce a fake set clause so that:
           55  +        // - we acquire the appropriate locks
           56  +        // - server-gen columns (e.g. timestamp) get recomputed
           57  +        //
           58  +        // We use the following pattern:
           59  +        //
           60  +        //  update Foo
           61  +        //  set @i = 0
           62  +        //  where ...
           63  +        DbParameter parameter = translator.CreateParameter(default(Int32), DbType.Int32);
           64  +        commandText.Append(parameter.ParameterName);
           65  +        commandText.Append(" = 0");
           66  +      }
           67  +      commandText.AppendLine();
           68  +
           69  +      // where c1 = ..., c2 = ...
           70  +      commandText.Append("WHERE ");
           71  +      tree.Predicate.Accept(translator);
           72  +      commandText.AppendLine();
           73  +
           74  +      // generate returning sql
           75  +      GenerateReturningSql(commandText, tree, translator, tree.Returning);
           76  +
           77  +      parameters = translator.Parameters;
           78  +      return commandText.ToString();
           79  +    }
           80  +
           81  +    internal static string GenerateDeleteSql(DbDeleteCommandTree tree, out List<DbParameter> parameters)
           82  +    {
           83  +      StringBuilder commandText = new StringBuilder(s_commandTextBuilderInitialCapacity);
           84  +      ExpressionTranslator translator = new ExpressionTranslator(commandText, tree, false, "DeleteFunction");
           85  +
           86  +      // delete [schemaName].[tableName]
           87  +      commandText.Append("DELETE FROM ");
           88  +      tree.Target.Expression.Accept(translator);
           89  +      commandText.AppendLine();
           90  +
           91  +      // where c1 = ... AND c2 = ...
           92  +      commandText.Append("WHERE ");
           93  +      tree.Predicate.Accept(translator);
           94  +
           95  +      parameters = translator.Parameters;
           96  +
           97  +      commandText.AppendLine(";");
           98  +      return commandText.ToString();
           99  +    }
          100  +
          101  +    internal static string GenerateInsertSql(DbInsertCommandTree tree, out List<DbParameter> parameters)
          102  +    {
          103  +      StringBuilder commandText = new StringBuilder(s_commandTextBuilderInitialCapacity);
          104  +      ExpressionTranslator translator = new ExpressionTranslator(commandText, tree, null != tree.Returning, "InsertFunction");
          105  +
          106  +      // insert [schemaName].[tableName]
          107  +      commandText.Append("INSERT INTO ");
          108  +      tree.Target.Expression.Accept(translator);
          109  +
          110  +      if (tree.SetClauses.Count > 0)
          111  +      {
          112  +        // (c1, c2, c3, ...)
          113  +        commandText.Append("(");
          114  +        bool first = true;
          115  +        foreach (DbSetClause setClause in tree.SetClauses)
          116  +        {
          117  +          if (first) { first = false; }
          118  +          else { commandText.Append(", "); }
          119  +          setClause.Property.Accept(translator);
          120  +        }
          121  +        commandText.AppendLine(")");
          122  +
          123  +        // values c1, c2, ...
          124  +        first = true;
          125  +        commandText.Append(" VALUES (");
          126  +        foreach (DbSetClause setClause in tree.SetClauses)
          127  +        {
          128  +          if (first) { first = false; }
          129  +          else { commandText.Append(", "); }
          130  +          setClause.Value.Accept(translator);
          131  +
          132  +          translator.RegisterMemberValue(setClause.Property, setClause.Value);
          133  +        }
          134  +        commandText.AppendLine(");");
          135  +      }
          136  +      else // No columns specified.  Insert an empty row containing default values by inserting null into the rowid
          137  +      {
          138  +        commandText.AppendLine(" DEFAULT VALUES;");
          139  +      }
          140  +
          141  +      // generate returning sql
          142  +      GenerateReturningSql(commandText, tree, translator, tree.Returning);
          143  +
          144  +      parameters = translator.Parameters;
          145  +      return commandText.ToString();
          146  +    }
          147  +
          148  +    // Generates T-SQL describing a member
          149  +    // Requires: member must belong to an entity type (a safe requirement for DML
          150  +    // SQL gen, where we only access table columns)
          151  +    private static string GenerateMemberTSql(EdmMember member)
    22    152       {
    23         -      sql8rewriter = Type.GetType("System.Data.SqlClient.SqlGen.Sql8ExpressionRewriter, System.Data.Entity, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", false);
          153  +      return SqlGenerator.QuoteIdentifier(member.Name);
    24    154       }
    25    155   
    26         -    private SqlChecker()
          156  +    /// <summary>
          157  +    /// Generates SQL fragment returning server-generated values.
          158  +    /// Requires: translator knows about member values so that we can figure out
          159  +    /// how to construct the key predicate.
          160  +    /// <code>
          161  +    /// Sample SQL:
          162  +    ///     
          163  +    ///     select IdentityValue
          164  +    ///     from dbo.MyTable
          165  +    ///     where @@ROWCOUNT > 0 and IdentityValue = scope_identity()
          166  +    /// 
          167  +    /// or
          168  +    /// 
          169  +    ///     select TimestamptValue
          170  +    ///     from dbo.MyTable
          171  +    ///     where @@ROWCOUNT > 0 and Id = 1
          172  +    /// 
          173  +    /// Note that we filter on rowcount to ensure no rows are returned if no rows were modified.
          174  +    /// </code>
          175  +    /// </summary>
          176  +    /// <param name="commandText">Builder containing command text</param>
          177  +    /// <param name="tree">Modification command tree</param>
          178  +    /// <param name="translator">Translator used to produce DML SQL statement
          179  +    /// for the tree</param>
          180  +    /// <param name="returning">Returning expression. If null, the method returns
          181  +    /// immediately without producing a SELECT statement.</param>
          182  +    private static void GenerateReturningSql(StringBuilder commandText, DbModificationCommandTree tree,
          183  +        ExpressionTranslator translator, DbExpression returning)
    27    184       {
          185  +      // Nothing to do if there is no Returning expression
          186  +      if (null == returning) { return; }
          187  +
          188  +      // select
          189  +      commandText.Append("SELECT ");
          190  +      returning.Accept(translator);
          191  +      commandText.AppendLine();
          192  +
          193  +      // from
          194  +      commandText.Append("FROM ");
          195  +      tree.Target.Expression.Accept(translator);
          196  +      commandText.AppendLine();
          197  +
          198  +      // where
          199  +      commandText.Append("WHERE last_rows_affected() > 0");
          200  +      EntitySetBase table = ((DbScanExpression)tree.Target.Expression).Target;
          201  +      bool identity = false;
          202  +      foreach (EdmMember keyMember in table.ElementType.KeyMembers)
          203  +      {
          204  +        commandText.Append(" AND ");
          205  +        commandText.Append(GenerateMemberTSql(keyMember));
          206  +        commandText.Append(" = ");
          207  +
          208  +        // retrieve member value sql. the translator remembers member values
          209  +        // as it constructs the DML statement (which precedes the "returning"
          210  +        // SQL)
          211  +        DbParameter value;
          212  +        if (translator.MemberValues.TryGetValue(keyMember, out value))
          213  +        {
          214  +          commandText.Append(value.ParameterName);
          215  +        }
          216  +        else
          217  +        {
          218  +          // if no value is registered for the key member, it means it is an identity
          219  +          // which can be retrieved using the scope_identity() function
          220  +          if (identity)
          221  +          {
          222  +            // there can be only one server generated key
          223  +            throw new NotSupportedException(string.Format("Server generated keys are only supported for identity columns. More than one key column is marked as server generated in table '{0}'.", table.Name));
          224  +          }
          225  +          commandText.AppendLine("last_insert_rowid();");
          226  +          identity = true;
          227  +        }
          228  +      }
    28    229       }
    29    230   
    30    231       /// <summary>
    31         -    /// SQLite doesn't support things like SKIP and a few other things.  So determine if the query has to be rewritten
          232  +    /// Lightweight expression translator for DML expression trees, which have constrained
          233  +    /// scope and support.
    32    234       /// </summary>
    33         -    /// <remarks>
    34         -    /// Microsoft went to all the trouble of making things like SKIP work on Sql Server 2000 by doing a rewrite of the commandtree.
    35         -    /// However, all that fancy stuff is hidden from us.  Thanks to reflection however, we can go ahead and use the Sql 2000 rewriter code
    36         -    /// they made.
    37         -    /// </remarks>
    38         -    /// <param name="tree">The tree to inspect for a rewrite</param>
    39         -    /// <returns>Returns a new query tree if it needs rewriting</returns>
    40         -    internal static DbQueryCommandTree Rewrite(DbQueryCommandTree tree)
          235  +    private class ExpressionTranslator : DbExpressionVisitor
    41    236       {
    42         -      SqlChecker visitor = new SqlChecker();
    43         -      if (tree.Query.Accept<bool>(visitor))
          237  +      /// <summary>
          238  +      /// Initialize a new expression translator populating the given string builder
          239  +      /// with command text. Command text builder and command tree must not be null.
          240  +      /// </summary>
          241  +      /// <param name="commandText">Command text with which to populate commands</param>
          242  +      /// <param name="commandTree">Command tree generating SQL</param>
          243  +      /// <param name="preserveMemberValues">Indicates whether the translator should preserve
          244  +      /// member values while compiling t-SQL (only needed for server generation)</param>
          245  +      internal ExpressionTranslator(StringBuilder commandText, DbModificationCommandTree commandTree,
          246  +          bool preserveMemberValues, string kind)
          247  +      {
          248  +        Debug.Assert(null != commandText);
          249  +        Debug.Assert(null != commandTree);
          250  +        _kind = kind;
          251  +        _commandText = commandText;
          252  +        _commandTree = commandTree;
          253  +        _parameters = new List<DbParameter>();
          254  +        _memberValues = preserveMemberValues ? new Dictionary<EdmMember, DbParameter>() :
          255  +            null;
          256  +      }
          257  +
          258  +      private readonly StringBuilder _commandText;
          259  +      private readonly DbModificationCommandTree _commandTree;
          260  +      private readonly List<DbParameter> _parameters;
          261  +      private readonly Dictionary<EdmMember, DbParameter> _memberValues;
          262  +      private int parameterNameCount = 0;
          263  +      private string _kind;
          264  +
          265  +      internal List<DbParameter> Parameters { get { return _parameters; } }
          266  +      internal Dictionary<EdmMember, DbParameter> MemberValues { get { return _memberValues; } }
          267  +
          268  +      // generate parameter (name based on parameter ordinal)
          269  +      internal SQLiteParameter CreateParameter(object value, TypeUsage type)
          270  +      {
          271  +        PrimitiveTypeKind primitiveType = MetadataHelpers.GetPrimitiveTypeKind(type);
          272  +        DbType dbType = MetadataHelpers.GetDbType(primitiveType);
          273  +        return CreateParameter(value, dbType);
          274  +      }
          275  +
          276  +      // Creates a new parameter for a value in this expression translator
          277  +      internal SQLiteParameter CreateParameter(object value, DbType dbType)
          278  +      {
          279  +        string parameterName = string.Concat("@p", parameterNameCount.ToString(CultureInfo.InvariantCulture));
          280  +        parameterNameCount++;
          281  +        SQLiteParameter parameter = new SQLiteParameter(parameterName, value);
          282  +        parameter.DbType = dbType;
          283  +        _parameters.Add(parameter);
          284  +        return parameter;
          285  +      }
          286  +
          287  +      #region Basics
          288  +
          289  +      public override void Visit(DbApplyExpression expression)
          290  +      {
          291  +        if (expression == null) throw new ArgumentException("expression");
          292  +
          293  +        VisitExpressionBindingPre(expression.Input);
          294  +        if (expression.Apply != null)
          295  +        {
          296  +          VisitExpression(expression.Apply.Expression);
          297  +        }
          298  +        VisitExpressionBindingPost(expression.Input);
          299  +      }
          300  +
          301  +      public override void Visit(DbArithmeticExpression expression)
          302  +      {
          303  +        if (expression == null) throw new ArgumentException("expression");
          304  +        VisitExpressionList(expression.Arguments);
          305  +      }
          306  +
          307  +      public override void Visit(DbCaseExpression expression)
          308  +      {
          309  +        if (expression == null) throw new ArgumentException("expression");
          310  +        VisitExpressionList(expression.When);
          311  +        VisitExpressionList(expression.Then);
          312  +        VisitExpression(expression.Else);
          313  +      }
          314  +
          315  +      public override void Visit(DbCastExpression expression)
          316  +      {
          317  +        VisitUnaryExpression(expression);
          318  +      }
          319  +
          320  +      public override void Visit(DbCrossJoinExpression expression)
          321  +      {
          322  +        if (expression == null) throw new ArgumentException("expression");
          323  +        foreach (DbExpressionBinding binding in expression.Inputs)
          324  +        {
          325  +          VisitExpressionBindingPre(binding);
          326  +        }
          327  +        foreach (DbExpressionBinding binding2 in expression.Inputs)
          328  +        {
          329  +          VisitExpressionBindingPost(binding2);
          330  +        }
          331  +      }
          332  +
          333  +      public override void Visit(DbDerefExpression expression)
          334  +      {
          335  +        VisitUnaryExpression(expression);
          336  +      }
          337  +
          338  +      public override void Visit(DbDistinctExpression expression)
          339  +      {
          340  +        VisitUnaryExpression(expression);
          341  +      }
          342  +
          343  +      public override void Visit(DbElementExpression expression)
          344  +      {
          345  +        VisitUnaryExpression(expression);
          346  +      }
          347  +
          348  +      public override void Visit(DbEntityRefExpression expression)
          349  +      {
          350  +        VisitUnaryExpression(expression);
          351  +      }
          352  +
          353  +      public override void Visit(DbExceptExpression expression)
          354  +      {
          355  +        VisitBinary(expression);
          356  +      }
          357  +
          358  +      protected virtual void VisitBinary(DbBinaryExpression expression)
          359  +      {
          360  +        if (expression == null) throw new ArgumentException("expression");
          361  +        this.VisitExpression(expression.Left);
          362  +        this.VisitExpression(expression.Right);
          363  +      }
          364  +
          365  +      public override void Visit(DbExpression expression)
          366  +      {
          367  +        if (expression == null) throw new ArgumentException("expression");
          368  +        throw new NotSupportedException("DbExpression");
          369  +      }
          370  +
          371  +      public override void Visit(DbFilterExpression expression)
          372  +      {
          373  +        if (expression == null) throw new ArgumentException("expression");
          374  +        VisitExpressionBindingPre(expression.Input);
          375  +        VisitExpression(expression.Predicate);
          376  +        VisitExpressionBindingPost(expression.Input);
          377  +      }
          378  +
          379  +      public override void Visit(DbFunctionExpression expression)
          380  +      {
          381  +        if (expression == null) throw new ArgumentException("expression");
          382  +        VisitExpressionList(expression.Arguments);
          383  +        //if (expression.IsLambda)
          384  +        //{
          385  +        //  VisitLambdaFunctionPre(expression.Function, expression.LambdaBody);
          386  +        //  VisitExpression(expression.LambdaBody);
          387  +        //  VisitLambdaFunctionPost(expression.Function, expression.LambdaBody);
          388  +        //}
          389  +      }
          390  +
          391  +      public override void Visit(DbGroupByExpression expression)
          392  +      {
          393  +        if (expression == null) throw new ArgumentException("expression");
          394  +        VisitGroupExpressionBindingPre(expression.Input);
          395  +        VisitExpressionList(expression.Keys);
          396  +        VisitGroupExpressionBindingMid(expression.Input);
          397  +        VisitAggregateList(expression.Aggregates);
          398  +        VisitGroupExpressionBindingPost(expression.Input);
          399  +      }
          400  +
          401  +      public override void Visit(DbIntersectExpression expression)
          402  +      {
          403  +        VisitBinary(expression);
          404  +      }
          405  +
          406  +      public override void Visit(DbIsEmptyExpression expression)
          407  +      {
          408  +        VisitUnaryExpression(expression);
          409  +      }
          410  +
          411  +      public override void Visit(DbIsOfExpression expression)
          412  +      {
          413  +        VisitUnaryExpression(expression);
          414  +      }
          415  +
          416  +      public override void Visit(DbJoinExpression expression)
          417  +      {
          418  +        if (expression == null) throw new ArgumentException("expression");
          419  +        VisitExpressionBindingPre(expression.Left);
          420  +        VisitExpressionBindingPre(expression.Right);
          421  +        VisitExpression(expression.JoinCondition);
          422  +        VisitExpressionBindingPost(expression.Left);
          423  +        VisitExpressionBindingPost(expression.Right);
          424  +      }
          425  +
          426  +      public override void Visit(DbLikeExpression expression)
          427  +      {
          428  +        if (expression == null) throw new ArgumentException("expression");
          429  +        VisitExpression(expression.Argument);
          430  +        VisitExpression(expression.Pattern);
          431  +        VisitExpression(expression.Escape);
          432  +      }
          433  +
          434  +      public override void Visit(DbLimitExpression expression)
          435  +      {
          436  +        if (expression == null) throw new ArgumentException("expression");
          437  +        VisitExpression(expression.Argument);
          438  +        VisitExpression(expression.Limit);
          439  +      }
          440  +
          441  +      public override void Visit(DbOfTypeExpression expression)
          442  +      {
          443  +        VisitUnaryExpression(expression);
          444  +      }
          445  +
          446  +      public override void Visit(DbParameterReferenceExpression expression)
          447  +      {
          448  +        if (expression == null) throw new ArgumentException("expression");
          449  +      }
          450  +
          451  +      public override void Visit(DbProjectExpression expression)
          452  +      {
          453  +        if (expression == null) throw new ArgumentException("expression");
          454  +        VisitExpressionBindingPre(expression.Input);
          455  +        VisitExpression(expression.Projection);
          456  +        VisitExpressionBindingPost(expression.Input);
          457  +      }
          458  +
          459  +      public override void Visit(DbQuantifierExpression expression)
          460  +      {
          461  +        if (expression == null) throw new ArgumentException("expression");
          462  +        VisitExpressionBindingPre(expression.Input);
          463  +        VisitExpression(expression.Predicate);
          464  +        VisitExpressionBindingPost(expression.Input);
          465  +      }
          466  +
          467  +      public override void Visit(DbRefExpression expression)
          468  +      {
          469  +        VisitUnaryExpression(expression);
          470  +      }
          471  +
          472  +      public override void Visit(DbRefKeyExpression expression)
          473  +      {
          474  +        VisitUnaryExpression(expression);
          475  +      }
          476  +
          477  +      public override void Visit(DbRelationshipNavigationExpression expression)
          478  +      {
          479  +        if (expression == null) throw new ArgumentException("expression");
          480  +        VisitExpression(expression.NavigationSource);
          481  +      }
          482  +
          483  +      public override void Visit(DbSkipExpression expression)
          484  +      {
          485  +        if (expression == null) throw new ArgumentException("expression");
          486  +        VisitExpressionBindingPre(expression.Input);
          487  +        foreach (DbSortClause clause in expression.SortOrder)
          488  +        {
          489  +          VisitExpression(clause.Expression);
          490  +        }
          491  +        VisitExpressionBindingPost(expression.Input);
          492  +        VisitExpression(expression.Count);
          493  +      }
          494  +
          495  +      public override void Visit(DbSortExpression expression)
          496  +      {
          497  +        if (expression == null) throw new ArgumentException("expression");
          498  +        VisitExpressionBindingPre(expression.Input);
          499  +        for (int i = 0; i < expression.SortOrder.Count; i++)
          500  +        {
          501  +          VisitExpression(expression.SortOrder[i].Expression);
          502  +        }
          503  +        VisitExpressionBindingPost(expression.Input);
          504  +      }
          505  +
          506  +      public override void Visit(DbTreatExpression expression)
          507  +      {
          508  +        VisitUnaryExpression(expression);
          509  +      }
          510  +
          511  +      public override void Visit(DbUnionAllExpression expression)
          512  +      {
          513  +        VisitBinary(expression);
          514  +      }
          515  +
          516  +      public override void Visit(DbVariableReferenceExpression expression)
          517  +      {
          518  +        if (expression == null) throw new ArgumentException("expression");
          519  +      }
          520  +
          521  +      public virtual void VisitAggregate(DbAggregate aggregate)
          522  +      {
          523  +        if (aggregate == null) throw new ArgumentException("aggregate");
          524  +        VisitExpressionList(aggregate.Arguments);
          525  +      }
          526  +
          527  +      public virtual void VisitAggregateList(IList<DbAggregate> aggregates)
          528  +      {
          529  +        if (aggregates == null) throw new ArgumentException("aggregates");
          530  +        for (int i = 0; i < aggregates.Count; i++)
          531  +        {
          532  +          VisitAggregate(aggregates[i]);
          533  +        }
          534  +      }
          535  +
          536  +      public virtual void VisitExpression(DbExpression expression)
          537  +      {
          538  +        if (expression == null) throw new ArgumentException("expression");
          539  +        expression.Accept(this);
          540  +      }
          541  +
          542  +      protected virtual void VisitExpressionBindingPost(DbExpressionBinding binding)
          543  +      {
          544  +      }
          545  +
          546  +      protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
          547  +      {
          548  +        if (binding == null) throw new ArgumentException("binding");
          549  +        VisitExpression(binding.Expression);
          550  +      }
          551  +
          552  +      public virtual void VisitExpressionList(IList<DbExpression> expressionList)
          553  +      {
          554  +        if (expressionList == null) throw new ArgumentException("expressionList");
          555  +        for (int i = 0; i < expressionList.Count; i++)
          556  +        {
          557  +          VisitExpression(expressionList[i]);
          558  +        }
          559  +      }
          560  +
          561  +      protected virtual void VisitGroupExpressionBindingMid(DbGroupExpressionBinding binding)
          562  +      {
          563  +      }
          564  +
          565  +      protected virtual void VisitGroupExpressionBindingPost(DbGroupExpressionBinding binding)
          566  +      {
          567  +      }
          568  +
          569  +      protected virtual void VisitGroupExpressionBindingPre(DbGroupExpressionBinding binding)
          570  +      {
          571  +        if (binding == null) throw new ArgumentException("binding");
          572  +        VisitExpression(binding.Expression);
          573  +      }
          574  +
          575  +      protected virtual void VisitLambdaFunctionPost(EdmFunction function, DbExpression body)
          576  +      {
          577  +      }
          578  +
          579  +      protected virtual void VisitLambdaFunctionPre(EdmFunction function, DbExpression body)
          580  +      {
          581  +        if (function == null) throw new ArgumentException("function");
          582  +        if (body == null) throw new ArgumentException("body");
          583  +      }
          584  +
          585  +      //internal virtual void VisitRelatedEntityReference(DbRelatedEntityRef relatedEntityRef)
          586  +      //{
          587  +      //  VisitExpression(relatedEntityRef.TargetEntityReference);
          588  +      //}
          589  +
          590  +      //internal virtual void VisitRelatedEntityReferenceList(IList<DbRelatedEntityRef> relatedEntityReferences)
          591  +      //{
          592  +      //  for (int i = 0; i < relatedEntityReferences.Count; i++)
          593  +      //  {
          594  +      //    VisitRelatedEntityReference(relatedEntityReferences[i]);
          595  +      //  }
          596  +      //}
          597  +
          598  +      protected virtual void VisitUnaryExpression(DbUnaryExpression expression)
          599  +      {
          600  +        if (expression == null) throw new ArgumentException("expression");
          601  +        VisitExpression(expression.Argument);
          602  +      }
          603  +      #endregion
          604  +
          605  +      public override void Visit(DbAndExpression expression)
          606  +      {
          607  +        VisitBinary(expression, " AND ");
          608  +      }
          609  +
          610  +      public override void Visit(DbOrExpression expression)
          611  +      {
          612  +        VisitBinary(expression, " OR ");
          613  +      }
          614  +
          615  +      public override void Visit(DbComparisonExpression expression)
          616  +      {
          617  +        Debug.Assert(expression.ExpressionKind == DbExpressionKind.Equals,
          618  +            "only equals comparison expressions are produced in DML command trees in V1");
          619  +
          620  +        VisitBinary(expression, " = ");
          621  +
          622  +        RegisterMemberValue(expression.Left, expression.Right);
          623  +      }
          624  +
          625  +      /// <summary>
          626  +      /// Call this method to register a property value pair so the translator "remembers"
          627  +      /// the values for members of the row being modified. These values can then be used
          628  +      /// to form a predicate for server-generation (based on the key of the row)
          629  +      /// </summary>
          630  +      /// <param name="propertyExpression">DbExpression containing the column reference (property expression).</param>
          631  +      /// <param name="value">DbExpression containing the value of the column.</param>
          632  +      internal void RegisterMemberValue(DbExpression propertyExpression, DbExpression value)
          633  +      {
          634  +        if (null != _memberValues)
          635  +        {
          636  +          // register the value for this property
          637  +          Debug.Assert(propertyExpression.ExpressionKind == DbExpressionKind.Property,
          638  +              "DML predicates and setters must be of the form property = value");
          639  +
          640  +          // get name of left property 
          641  +          EdmMember property = ((DbPropertyExpression)propertyExpression).Property;
          642  +
          643  +          // don't track null values
          644  +          if (value.ExpressionKind != DbExpressionKind.Null)
          645  +          {
          646  +            Debug.Assert(value.ExpressionKind == DbExpressionKind.Constant,
          647  +                "value must either constant or null");
          648  +            // retrieve the last parameter added (which describes the parameter)
          649  +            _memberValues[property] = _parameters[_parameters.Count - 1];
          650  +          }
          651  +        }
          652  +      }
          653  +
          654  +      public override void Visit(DbIsNullExpression expression)
          655  +      {
          656  +        expression.Argument.Accept(this);
          657  +        _commandText.Append(" IS NULL");
          658  +      }
          659  +
          660  +      public override void Visit(DbNotExpression expression)
    44    661         {
    45         -        tree = sql8rewriter.InvokeMember("Rewrite", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Static, null, null, new object[] { tree }) as DbQueryCommandTree;
    46         -      }      
    47         -      return tree;
    48         -    }
          662  +        _commandText.Append("NOT (");
          663  +        expression.Accept(this);
          664  +        _commandText.Append(")");
          665  +      }
    49    666   
    50         -    public override bool Visit(DbAndExpression expression)
    51         -    {
    52         -      return VisitBinaryExpression(expression);
    53         -    }
          667  +      public override void Visit(DbConstantExpression expression)
          668  +      {
          669  +        SQLiteParameter parameter = CreateParameter(expression.Value, expression.ResultType);
          670  +        _commandText.Append(parameter.ParameterName);
          671  +      }
    54    672   
    55         -    public override bool Visit(DbApplyExpression expression)
    56         -    {
    57         -      throw new NotSupportedException("apply expression");
    58         -    }
    59         -
    60         -    public override bool Visit(DbArithmeticExpression expression)
    61         -    {
    62         -      return VisitExpressionList(expression.Arguments);
    63         -    }
          673  +      public override void Visit(DbScanExpression expression)
          674  +      {
          675  +        string definingQuery = MetadataHelpers.TryGetValueForMetadataProperty<string>(expression.Target, "DefiningQuery");
          676  +        if (definingQuery != null)
          677  +        {
          678  +          throw new NotSupportedException(String.Format("Unable to update the EntitySet '{0}' because it has a DefiningQuery and no <{1}> element exists in the <ModificationFunctionMapping> element to support the current operation.", expression.Target.Name, _kind));
          679  +        }
          680  +        _commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
          681  +      }
    64    682   
    65         -    public override bool Visit(DbCaseExpression expression)
    66         -    {
    67         -      bool flag1 = VisitExpressionList(expression.When);
    68         -      bool flag2 = VisitExpressionList(expression.Then);
    69         -      bool flag3 = VisitExpression(expression.Else);
    70         -
    71         -      return (flag1 || flag2 || flag3);
    72         -    }
    73         -
    74         -    public override bool Visit(DbCastExpression expression)
    75         -    {
    76         -      return VisitUnaryExpression(expression);
    77         -    }
    78         -
    79         -    public override bool Visit(DbComparisonExpression expression)
    80         -    {
    81         -      return VisitBinaryExpression(expression);
    82         -    }
          683  +      public override void Visit(DbPropertyExpression expression)
          684  +      {
          685  +        _commandText.Append(GenerateMemberTSql(expression.Property));
          686  +      }
    83    687   
    84         -    public override bool Visit(DbConstantExpression expression)
    85         -    {
    86         -      return false;
    87         -    }
    88         -
    89         -    public override bool Visit(DbCrossJoinExpression expression)
    90         -    {
    91         -      return VisitExpressionBindingList(expression.Inputs);
    92         -    }
    93         -
    94         -    public override bool Visit(DbDerefExpression expression)
    95         -    {
    96         -      return VisitUnaryExpression(expression);
    97         -    }
    98         -
    99         -    public override bool Visit(DbDistinctExpression expression)
   100         -    {
   101         -      return VisitUnaryExpression(expression);
   102         -    }
   103         -
   104         -    public override bool Visit(DbElementExpression expression)
   105         -    {
   106         -      return VisitUnaryExpression(expression);
   107         -    }
   108         -
   109         -    public override bool Visit(DbEntityRefExpression expression)
   110         -    {
   111         -      return VisitUnaryExpression(expression);
   112         -    }
   113         -
   114         -    public override bool Visit(DbExceptExpression expression)
   115         -    {
   116         -      VisitExpression(expression.Left);
   117         -      VisitExpression(expression.Right);
   118         -      return true;
   119         -    }
   120         -
   121         -    public override bool Visit(DbExpression expression)
   122         -    {
   123         -      throw new NotSupportedException(expression.GetType().FullName);
   124         -    }
          688  +      public override void Visit(DbNullExpression expression)
          689  +      {
          690  +        _commandText.Append("NULL");
          691  +      }
   125    692   
   126         -    public override bool Visit(DbFilterExpression expression)
   127         -    {
   128         -      bool flag1 = VisitExpressionBinding(expression.Input);
   129         -      bool flag2 = VisitExpression(expression.Predicate);
   130         -
   131         -      return (flag1 || flag2);
   132         -    }
   133         -
   134         -    public override bool Visit(DbFunctionExpression expression)
   135         -    {
   136         -      return VisitExpressionList(expression.Arguments);
   137         -    }
   138         -
   139         -    public override bool Visit(DbGroupByExpression expression)
   140         -    {
   141         -      bool flag1 = VisitExpression(expression.Input.Expression);
   142         -      bool flag2 = VisitExpressionList(expression.Keys);
   143         -      bool flag3 = VisitAggregateList(expression.Aggregates);
   144         -
   145         -      return (flag1 || flag2 || flag3);
   146         -    }
   147         -
   148         -    public override bool Visit(DbIntersectExpression expression)
   149         -    {
   150         -      VisitExpression(expression.Left);
   151         -      VisitExpression(expression.Right);
   152         -      return true;
   153         -    }
   154         -
   155         -    public override bool Visit(DbIsEmptyExpression expression)
   156         -    {
   157         -      return VisitUnaryExpression(expression);
   158         -    }
   159         -
   160         -    public override bool Visit(DbIsNullExpression expression)
   161         -    {
   162         -      return VisitUnaryExpression(expression);
   163         -    }
   164         -
   165         -    public override bool Visit(DbIsOfExpression expression)
   166         -    {
   167         -      return VisitUnaryExpression(expression);
   168         -    }
   169         -
   170         -    public override bool Visit(DbJoinExpression expression)
   171         -    {
   172         -      bool flag1 = VisitExpressionBinding(expression.Left);
   173         -      bool flag2 = VisitExpressionBinding(expression.Right);
   174         -      bool flag3 = VisitExpression(expression.JoinCondition);
   175         -      return (flag1 || flag2 || flag3);
   176         -    }
   177         -
   178         -    public override bool Visit(DbLikeExpression expression)
   179         -    {
   180         -      bool flag1 = VisitExpression(expression.Argument);
   181         -      bool flag2 = VisitExpression(expression.Pattern);
   182         -      bool flag3 = VisitExpression(expression.Escape);
   183         -      return (flag1 || flag2 || flag3);
   184         -    }
   185         -
   186         -    public override bool Visit(DbLimitExpression expression)
   187         -    {
   188         -      return VisitExpression(expression.Argument);
   189         -    }
   190         -
   191         -    public override bool Visit(DbNewInstanceExpression expression)
   192         -    {
   193         -      return VisitExpressionList(expression.Arguments);
   194         -    }
   195         -
   196         -    public override bool Visit(DbNotExpression expression)
   197         -    {
   198         -      return VisitUnaryExpression(expression);
   199         -    }
          693  +      public override void Visit(DbNewInstanceExpression expression)
          694  +      {
          695  +        // assumes all arguments are self-describing (no need to use aliases
          696  +        // because no renames are ever used in the projection)
          697  +        bool first = true;
          698  +        foreach (DbExpression argument in expression.Arguments)
          699  +        {
          700  +          if (first) { first = false; }
          701  +          else { _commandText.Append(", "); }
          702  +          argument.Accept(this);
          703  +        }
          704  +      }
   200    705   
   201         -    public override bool Visit(DbNullExpression expression)
   202         -    {
   203         -      return false;
   204         -    }
   205         -
   206         -    public override bool Visit(DbOfTypeExpression expression)
   207         -    {
   208         -      return VisitUnaryExpression(expression);
   209         -    }
   210         -
   211         -    public override bool Visit(DbOrExpression expression)
   212         -    {
   213         -      return VisitBinaryExpression(expression);
   214         -    }
   215         -
   216         -    public override bool Visit(DbParameterReferenceExpression expression)
   217         -    {
   218         -      return false;
   219         -    }
   220         -
   221         -    public override bool Visit(DbProjectExpression expression)
   222         -    {
   223         -      bool flag1 = VisitExpressionBinding(expression.Input);
   224         -      bool flag2 = VisitExpression(expression.Projection);
   225         -      return (flag1 || flag2);
   226         -    }
   227         -
   228         -    public override bool Visit(DbPropertyExpression expression)
   229         -    {
   230         -      return VisitExpression(expression.Instance);
   231         -    }
   232         -
   233         -    public override bool Visit(DbQuantifierExpression expression)
   234         -    {
   235         -      bool flag1 = VisitExpressionBinding(expression.Input);
   236         -      bool flag2 = VisitExpression(expression.Predicate);
   237         -      return (flag1 || flag2);
   238         -    }
   239         -
   240         -    public override bool Visit(DbRefExpression expression)
   241         -    {
   242         -      return VisitUnaryExpression(expression);
   243         -    }
   244         -
   245         -    public override bool Visit(DbRefKeyExpression expression)
   246         -    {
   247         -      return VisitUnaryExpression(expression);
   248         -    }
   249         -
   250         -    public override bool Visit(DbRelationshipNavigationExpression expression)
   251         -    {
   252         -      return VisitExpression(expression.NavigationSource);
   253         -    }
   254         -
   255         -    public override bool Visit(DbScanExpression expression)
   256         -    {
   257         -      return false;
   258         -    }
   259         -
   260         -    public override bool Visit(DbSkipExpression expression)
   261         -    {
   262         -      VisitExpressionBinding(expression.Input);
   263         -      VisitSortClauseList(expression.SortOrder);
   264         -      VisitExpression(expression.Count);
   265         -      return true;
   266         -    }
   267         -
   268         -    public override bool Visit(DbSortExpression expression)
   269         -    {
   270         -      bool flag1 = VisitExpressionBinding(expression.Input);
   271         -      bool flag2 = VisitSortClauseList(expression.SortOrder);
   272         -      return (flag1 || flag2);
   273         -    }
   274         -
   275         -    public override bool Visit(DbTreatExpression expression)
   276         -    {
   277         -      return VisitUnaryExpression(expression);
   278         -    }
   279         -
   280         -    public override bool Visit(DbUnionAllExpression expression)
   281         -    {
   282         -      return VisitBinaryExpression(expression);
   283         -    }
   284         -
   285         -    public override bool Visit(DbVariableReferenceExpression expression)
   286         -    {
   287         -      return false;
   288         -    }
   289         -
   290         -    private bool VisitAggregate(DbAggregate aggregate)
   291         -    {
   292         -      return VisitExpressionList(aggregate.Arguments);
   293         -    }
   294         -
   295         -    private bool VisitAggregateList(IList<DbAggregate> list)
   296         -    {
   297         -      return VisitList<DbAggregate>(new ListElementHandler<DbAggregate>(VisitAggregate), list);
   298         -    }
   299         -
   300         -    private bool VisitBinaryExpression(DbBinaryExpression expr)
   301         -    {
   302         -      bool flag1 = VisitExpression(expr.Left);
   303         -      bool flag2 = VisitExpression(expr.Right);
   304         -      return (flag1 || flag2);
   305         -    }
   306         -
   307         -    private bool VisitExpression(DbExpression expression)
   308         -    {
   309         -      if (expression == null)
          706  +      private void VisitBinary(DbBinaryExpression expression, string separator)
   310    707         {
   311         -        return false;
          708  +        _commandText.Append("(");
          709  +        expression.Left.Accept(this);
          710  +        _commandText.Append(separator);
          711  +        expression.Right.Accept(this);
          712  +        _commandText.Append(")");
   312    713         }
   313         -      return expression.Accept<bool>(this);
   314    714       }
   315         -
   316         -    private bool VisitExpressionBinding(DbExpressionBinding expressionBinding)
   317         -    {
   318         -      return VisitExpression(expressionBinding.Expression);
   319         -    }
   320         -
   321         -    private bool VisitExpressionBindingList(IList<DbExpressionBinding> list)
   322         -    {
   323         -      return VisitList<DbExpressionBinding>(new ListElementHandler<DbExpressionBinding>(VisitExpressionBinding), list);
   324         -    }
   325         -
   326         -    private bool VisitExpressionList(IList<DbExpression> list)
   327         -    {
   328         -      return VisitList<DbExpression>(new ListElementHandler<DbExpression>(VisitExpression), list);
   329         -    }
   330         -
   331         -    private static bool VisitList<TElementType>(ListElementHandler<TElementType> handler, IList<TElementType> list)
   332         -    {
   333         -      bool flag = false;
   334         -      foreach (TElementType local in list)
   335         -      {
   336         -        bool flag2 = handler(local);
   337         -        flag = flag || flag2;
   338         -      }
   339         -      return flag;
   340         -    }
   341         -
   342         -    private bool VisitSortClause(DbSortClause sortClause)
   343         -    {
   344         -      return VisitExpression(sortClause.Expression);
   345         -    }
   346         -
   347         -    private bool VisitSortClauseList(IList<DbSortClause> list)
   348         -    {
   349         -      return VisitList<DbSortClause>(new ListElementHandler<DbSortClause>(VisitSortClause), list);
   350         -    }
   351         -
   352         -    private bool VisitUnaryExpression(DbUnaryExpression expr)
   353         -    {
   354         -      return VisitExpression(expr.Argument);
   355         -    }
   356         -
   357         -    private delegate bool ListElementHandler<TElementType>(TElementType element);
   358    715     }
   359    716   }
          717  +

Changes to testce/testce.csproj.

     7      7       <ProjectGuid>{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}</ProjectGuid>
     8      8       <OutputType>WinExe</OutputType>
     9      9       <AppDesignerFolder>Properties</AppDesignerFolder>
    10     10       <RootNamespace>test</RootNamespace>
    11     11       <AssemblyName>testce</AssemblyName>
    12     12       <ProjectTypeGuids>{4D628B5B-2FBC-4AA6-8C16-197242AEB884};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
    13     13       <PlatformFamilyName>PocketPC</PlatformFamilyName>
    14         -    <PlatformID>b2c48bd2-963d-4549-9169-1fa021dce484</PlatformID>
    15         -    <OSVersion>5.02</OSVersion>
           14  +    <PlatformID>3C41C503-53EF-4c2a-8DD4-A8217CAD115E</PlatformID>
           15  +    <OSVersion>4.20</OSVersion>
    16     16       <DeployDirSuffix>testce</DeployDirSuffix>
    17     17       <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
    18     18       <FormFactorID>
    19     19       </FormFactorID>
    20     20       <StartupObject>
    21     21       </StartupObject>
    22     22       <DeployDirPrefix>%25CSIDL_PROGRAM_FILES%25</DeployDirPrefix>
    23     23       <FileUpgradeFlags>
    24     24       </FileUpgradeFlags>
    25     25       <OldToolsVersion>2.0</OldToolsVersion>
    26         -    <NativePlatformName>Windows Mobile 6 Professional SDK</NativePlatformName>
           26  +    <NativePlatformName>Pocket PC 2003</NativePlatformName>
    27     27       <UpgradeBackupLocation>
    28     28       </UpgradeBackupLocation>
    29     29     </PropertyGroup>
    30     30     <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    31     31       <DebugSymbols>true</DebugSymbols>
    32     32       <DebugType>full</DebugType>
    33     33       <Optimize>false</Optimize>
................................................................................
    59     59         <Private>False</Private>
    60     60       </Reference>
    61     61       <Reference Include="System.Data">
    62     62         <Private>False</Private>
    63     63       </Reference>
    64     64       <Reference Include="System.Data.SQLite, Version=1.0.47.0, Culture=neutral, PublicKeyToken=1fdb50b1b62b4c84, processorArchitecture=x86">
    65     65         <SpecificVersion>False</SpecificVersion>
           66  +      <Private>True</Private>
    66     67       </Reference>
    67     68       <Reference Include="System.Drawing">
    68     69         <Private>False</Private>
    69     70       </Reference>
    70     71       <Reference Include="System.Windows.Forms">
    71     72         <Private>False</Private>
    72     73       </Reference>

Changes to testlinq/northwindEF.db.

cannot compute difference between binary files

Changes to tools/install/InstallDesigner.cs.

   291    291                   using (RegistryKey subkey = key.CreateSubKey("SQLite", RegistryKeyPermissionCheck.ReadWriteSubTree))
   292    292                   {
   293    293                     subkey.SetValue(null, path);
   294    294                   }
   295    295                 }
   296    296               }
   297    297             }
          298  +
          299  +          for (int n = 0; n < compactFrameworks.Length; n++)
          300  +          {
          301  +            using (RegistryKey key = Registry.LocalMachine.OpenSubKey(String.Format("Software\\Microsoft\\.NETCompactFramework\\v3.5.0.0\\{0}\\AssemblyFoldersEx", compactFrameworks[n]), true))
          302  +            {
          303  +
          304  +              if (key != null)
          305  +              {
          306  +                using (RegistryKey subkey = key.CreateSubKey("SQLite", RegistryKeyPermissionCheck.ReadWriteSubTree))
          307  +                {
          308  +                  subkey.SetValue(null, path);
          309  +                }
          310  +              }
          311  +            }
          312  +          }
   298    313           }
   299    314   
   300    315           for (int n = 0; n < 2; n++)
   301    316           {
   302    317             // Add factory support to the machine.config file.
   303    318             try
   304    319             {
................................................................................
   354    369         }
   355    370         else // No checkboxes are checked, remove some global settings
   356    371         {
   357    372           try
   358    373           {
   359    374             Registry.LocalMachine.DeleteSubKey("Software\\Microsoft\\.NETFramework\\v2.0.50727\\AssemblyFoldersEx\\SQLite");
   360    375   
   361         -          for (int n = 0; n < compactFrameworks.Length; n++)
          376  +          string[] versions = { "v2.0.0.0", "v3.5.0.0" };
          377  +          for (int x = 0; x < versions.Length; x++)
   362    378             {
   363         -            using (RegistryKey key = Registry.LocalMachine.OpenSubKey(String.Format("Software\\Microsoft\\.NETCompactFramework\\v2.0.0.0\\{0}\\DataProviders", compactFrameworks[n]), true))
          379  +            for (int n = 0; n < compactFrameworks.Length; n++)
   364    380               {
   365         -              try
          381  +              using (RegistryKey key = Registry.LocalMachine.OpenSubKey(String.Format("Software\\Microsoft\\.NETCompactFramework\\{1}\\{0}\\DataProviders", compactFrameworks[n], versions[x]), true))
   366    382                 {
   367         -                if (key != null) key.DeleteSubKey(standardDataProviderGuid.ToString("B"));
   368         -              }
   369         -              catch
   370         -              {
          383  +                try
          384  +                {
          385  +                  if (key != null) key.DeleteSubKey(standardDataProviderGuid.ToString("B"));
          386  +                }
          387  +                catch
          388  +                {
          389  +                }
   371    390                 }
   372    391               }
   373    392             }
   374    393   
   375    394             for (int n = 0; n < compactFrameworks.Length; n++)
   376    395             {
   377    396               using (RegistryKey key = Registry.LocalMachine.OpenSubKey(String.Format("Software\\Microsoft\\.NETCompactFramework\\v2.0.0.0\\{0}\\AssemblyFoldersEx", compactFrameworks[n]), true))
................................................................................
   471    490             }
   472    491             catch
   473    492             {
   474    493             }
   475    494             finally
   476    495             {
   477    496               File.Delete(tempPath);
   478         -            if (File.Exists(Path.GetFullPath("System.Data.SQLite.Linq.DLL")) == true)
   479         -              AssemblyCache.InstallAssembly(Path.GetFullPath("System.Data.SQLite.Linq.DLL"), null, AssemblyCommitFlags.Default);
          497  +            if (File.Exists(Path.GetFullPath("..\\System.Data.SQLite.Linq.DLL")) == true)
          498  +              AssemblyCache.InstallAssembly(Path.GetFullPath("..\\System.Data.SQLite.Linq.DLL"), null, AssemblyCommitFlags.Default);
   480    499   
   481    500               AssemblyCache.InstallAssembly(Path.GetFullPath("SQLite.Designer.DLL"), null, AssemblyCommitFlags.Default);
   482    501               AssemblyCache.InstallAssembly(SQLiteLocation, null, AssemblyCommitFlags.Default);
   483    502             }
   484    503           }
   485    504         }
   486    505         catch
................................................................................
   632    651         //    }
   633    652         //  }
   634    653         //}
   635    654         //catch
   636    655         //{
   637    656         //}
   638    657   
   639         -      for (int n = 0; n < compactFrameworks.Length; n++)
          658  +      string[] versions = { "v2.0.0.0", "v3.5.0.0" };
          659  +
          660  +      for (int x = 0; x < versions.Length; x++)
   640    661         {
   641         -        using (RegistryKey key = Registry.LocalMachine.OpenSubKey(String.Format("Software\\Microsoft\\.NETCompactFramework\\v2.0.0.0\\{0}\\DataProviders", compactFrameworks[n]), true))
          662  +        for (int n = 0; n < compactFrameworks.Length; n++)
   642    663           {
   643         -          if (key != null)
          664  +          using (RegistryKey key = Registry.LocalMachine.CreateSubKey(String.Format("Software\\Microsoft\\.NETCompactFramework\\{1}\\{0}\\DataProviders", compactFrameworks[n], versions[x])))
   644    665             {
   645         -            using (RegistryKey subkey = key.CreateSubKey(standardDataProviderGuid.ToString("B"), RegistryKeyPermissionCheck.ReadWriteSubTree))
          666  +            if (key != null)
   646    667               {
   647         -              subkey.SetValue(null, ".NET Framework Data Provider for SQLite");
   648         -              subkey.SetValue("InvariantName", "System.Data.SQLite");
   649         -              subkey.SetValue("RuntimeAssembly", "System.Data.SQLite.DLL");
          668  +              using (RegistryKey subkey = key.CreateSubKey(standardDataProviderGuid.ToString("B"), RegistryKeyPermissionCheck.ReadWriteSubTree))
          669  +              {
          670  +                subkey.SetValue(null, ".NET Framework Data Provider for SQLite");
          671  +                subkey.SetValue("InvariantName", "System.Data.SQLite");
          672  +                subkey.SetValue("RuntimeAssembly", "System.Data.SQLite.DLL");
          673  +              }
   650    674               }
   651    675             }
   652    676           }
   653    677         }
   654    678   
   655    679         if (usePackage)
   656    680         {

Changes to tools/install/Properties/Resources.Designer.cs.

     1      1   //------------------------------------------------------------------------------
     2      2   // <auto-generated>
     3      3   //     This code was generated by a tool.
     4         -//     Runtime Version:2.0.50727.1433
            4  +//     Runtime Version:2.0.50727.3053
     5      5   //
     6      6   //     Changes to this file may cause incorrect behavior and will be lost if
     7      7   //     the code is regenerated.
     8      8   // </auto-generated>
     9      9   //------------------------------------------------------------------------------
    10     10   
    11     11   namespace install.Properties {

Changes to tools/install/Properties/Resources.resx.

   115    115       <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   116    116     </resheader>
   117    117     <resheader name="writer">
   118    118       <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   119    119     </resheader>
   120    120     <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
   121    121     <data name="System_Data_SQLite" type="System.Resources.ResXFileRef, System.Windows.Forms">
   122         -    <value>..\Resources\System.Data.SQLite.DLL;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
          122  +    <value>..\Resources\System.Data.SQLite.dll;System.Byte[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   123    123     </data>
   124    124   </root>

Changes to tools/install/install.csproj.

     1      1   <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
     2      2     <PropertyGroup>
     3      3       <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     4      4       <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     5         -    <ProductVersion>9.0.30428</ProductVersion>
            5  +    <ProductVersion>9.0.30729</ProductVersion>
     6      6       <SchemaVersion>2.0</SchemaVersion>
     7      7       <ProjectGuid>{71EED886-B5BF-488E-A4AA-1403E393D224}</ProjectGuid>
     8      8       <OutputType>WinExe</OutputType>
     9      9       <AppDesignerFolder>Properties</AppDesignerFolder>
    10     10       <RootNamespace>install</RootNamespace>
    11     11       <AssemblyName>install</AssemblyName>
    12     12       <FileUpgradeFlags>
................................................................................
    71     71       </Compile>
    72     72       <Compile Include="InstallDesigner.Designer.cs">
    73     73         <DependentUpon>InstallDesigner.cs</DependentUpon>
    74     74       </Compile>
    75     75       <Compile Include="Program.cs">
    76     76       </Compile>
    77     77       <Compile Include="Properties\AssemblyInfo.cs" />
           78  +    <Compile Include="Properties\Resources.Designer.cs">
           79  +      <AutoGen>True</AutoGen>
           80  +      <DesignTime>True</DesignTime>
           81  +      <DependentUpon>Resources.resx</DependentUpon>
           82  +    </Compile>
    78     83       <EmbeddedResource Include="InstallDesigner.resx">
    79     84         <SubType>Designer</SubType>
    80     85         <DependentUpon>InstallDesigner.cs</DependentUpon>
    81     86       </EmbeddedResource>
    82     87       <EmbeddedResource Include="Properties\Resources.resx">
    83     88         <Generator>ResXFileCodeGenerator</Generator>
    84     89         <LastGenOutput>Resources.Designer.cs</LastGenOutput>
    85         -      <SubType>Designer</SubType>
    86     90       </EmbeddedResource>
    87         -    <Compile Include="Properties\Resources.Designer.cs">
    88         -      <AutoGen>True</AutoGen>
    89         -      <DependentUpon>Resources.resx</DependentUpon>
    90         -      <DesignTime>True</DesignTime>
    91         -    </Compile>
    92     91     </ItemGroup>
    93     92     <ItemGroup>
    94     93       <None Include="app.config" />
    95     94       <None Include="install.exe.manifest" />
    96         -    <None Include="Resources\System.Data.SQLite.DLL" />
    97     95     </ItemGroup>
    98     96     <ItemGroup>
    99     97       <BootstrapperPackage Include="Microsoft.Net.Framework.2.0">
   100     98         <Visible>False</Visible>
   101     99         <ProductName>.NET Framework 2.0 %28x86%29</ProductName>
   102    100         <Install>true</Install>
   103    101       </BootstrapperPackage>
................................................................................
   110    108         <Visible>False</Visible>
   111    109         <ProductName>.NET Framework 3.5</ProductName>
   112    110         <Install>false</Install>
   113    111       </BootstrapperPackage>
   114    112     </ItemGroup>
   115    113     <ItemGroup>
   116    114       <Content Include="install.ico" />
          115  +    <None Include="Resources\System.Data.SQLite.dll" />
   117    116     </ItemGroup>
   118    117     <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   119    118     <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
   120    119          Other similar extension points exist, see Microsoft.Common.targets.
   121    120     <Target Name="BeforeBuild">
   122    121     </Target>
   123    122     <Target Name="AfterBuild">

Changes to tools/setup/exe/setup/setup.rc.

    53     53   
    54     54   /////////////////////////////////////////////////////////////////////////////
    55     55   //
    56     56   // Version
    57     57   //
    58     58   
    59     59   VS_VERSION_INFO VERSIONINFO
    60         - FILEVERSION 1,0,59,0
           60  + FILEVERSION 1,0,60,0
    61     61    PRODUCTVERSION 1,0,0,0
    62     62    FILEFLAGSMASK 0x17L
    63     63   #ifdef _DEBUG
    64     64    FILEFLAGS 0x1L
    65     65   #else
    66     66    FILEFLAGS 0x0L
    67     67   #endif
................................................................................
    71     71   BEGIN
    72     72       BLOCK "StringFileInfo"
    73     73       BEGIN
    74     74           BLOCK "040904b0"
    75     75           BEGIN
    76     76               VALUE "Comments", "http://sqlite.phxsoftware.com"
    77     77               VALUE "FileDescription", "SQLite ADO.NET 2.0 Setup"
    78         -            VALUE "FileVersion", "1.0.59.0"
           78  +            VALUE "FileVersion", "1.0.60.0"
    79     79               VALUE "InternalName", "setup"
    80     80               VALUE "LegalCopyright", "Released to the public domain"
    81     81               VALUE "OriginalFilename", "setup.exe"
    82     82               VALUE "ProductName", "System.Data.SQLite"
    83     83               VALUE "ProductVersion", "1.0"
    84     84           END
    85     85       END

Changes to tools/setup/sqlite_setup.suo.

cannot compute difference between binary files

Changes to tools/setup/sqlite_setup.vdproj.

    29     29           {
    30     30           "MsmKey" = "8:_1A571C82DAEBE73A54E0D256CAAD80DF"
    31     31           "OwnerKey" = "8:_3578C7AADEF926410602B18EDBBEFFF9"
    32     32           "MsmSig" = "8:_UNDEFINED"
    33     33           }
    34     34           "Entry"
    35     35           {
    36         -        "MsmKey" = "8:_200C9E264509441F9AAB7EBE82A905DB"
    37         -        "OwnerKey" = "8:_UNDEFINED"
    38         -        "MsmSig" = "8:_UNDEFINED"
    39         -        }
    40         -        "Entry"
    41         -        {
    42     36           "MsmKey" = "8:_244D4945EA335F5E4E54085BFD020CC1"
    43     37           "OwnerKey" = "8:_A7448E608040319F6C5E12637881B1F6"
    44     38           "MsmSig" = "8:_UNDEFINED"
    45     39           }
    46         -        "Entry"
    47         -        {
    48         -        "MsmKey" = "8:_2560D913B1D74BAAB2B910FD325E9721"
    49         -        "OwnerKey" = "8:_UNDEFINED"
    50         -        "MsmSig" = "8:_UNDEFINED"
    51         -        }
    52     40           "Entry"
    53     41           {
    54     42           "MsmKey" = "8:_26E74AC417994018832F9B82462AA3AF"
    55     43           "OwnerKey" = "8:_UNDEFINED"
    56     44           "MsmSig" = "8:_UNDEFINED"
    57     45           }
    58     46           "Entry"
................................................................................
   143    131           {
   144    132           "MsmKey" = "8:_9352653B827F735B8C3BE81D11522ECC"
   145    133           "OwnerKey" = "8:_B00FB4712154B7A5894294702C96689D"
   146    134           "MsmSig" = "8:_UNDEFINED"
   147    135           }
   148    136           "Entry"
   149    137           {
   150         -        "MsmKey" = "8:_A18DBDB7776215EAD9A52C96F8CA1E91"
   151         -        "OwnerKey" = "8:_40F352185F3B41A485F42BFC64BF9162"
   152         -        "MsmSig" = "8:_UNDEFINED"
   153         -        }
   154         -        "Entry"
   155         -        {
   156    138           "MsmKey" = "8:_A7448E608040319F6C5E12637881B1F6"
   157    139           "OwnerKey" = "8:_CD3CE5CDAB13405EA6EAAADC95F88D2E"
   158    140           "MsmSig" = "8:_UNDEFINED"
   159    141           }
   160    142           "Entry"
   161    143           {
   162    144           "MsmKey" = "8:_A94B50ED5C9281DF5EFEFA0C1D91142C"
................................................................................
   184    166           "Entry"
   185    167           {
   186    168           "MsmKey" = "8:_B6156897CBBB4E929D9C1F7358CE9E90"
   187    169           "OwnerKey" = "8:_UNDEFINED"
   188    170           "MsmSig" = "8:_UNDEFINED"
   189    171           }
   190    172           "Entry"
          173  +        {
          174  +        "MsmKey" = "8:_C5435F188DCA474EA777C28201046580"
          175  +        "OwnerKey" = "8:_UNDEFINED"
          176  +        "MsmSig" = "8:_UNDEFINED"
          177  +        }
          178  +        "Entry"
   191    179           {
   192    180           "MsmKey" = "8:_C8E329AC56AD4C88A986481E639F72A5"
   193    181           "OwnerKey" = "8:_UNDEFINED"
   194    182           "MsmSig" = "8:_UNDEFINED"
   195    183           }
          184  +        "Entry"
          185  +        {
          186  +        "MsmKey" = "8:_CA378DC7967442BAA821EDC0F78B57B7"
          187  +        "OwnerKey" = "8:_UNDEFINED"
          188  +        "MsmSig" = "8:_UNDEFINED"
          189  +        }
   196    190           "Entry"
   197    191           {
   198    192           "MsmKey" = "8:_CD3CE5CDAB13405EA6EAAADC95F88D2E"
   199    193           "OwnerKey" = "8:_UNDEFINED"
   200    194           "MsmSig" = "8:_UNDEFINED"
   201    195           }
   202    196           "Entry"
................................................................................
   262    256           "Entry"
   263    257           {
   264    258           "MsmKey" = "8:_E6DB5A9B08AC4645A19C948BBFDD0348"
   265    259           "OwnerKey" = "8:_244D4945EA335F5E4E54085BFD020CC1"
   266    260           "MsmSig" = "8:_UNDEFINED"
   267    261           }
   268    262           "Entry"
          263  +        {
          264  +        "MsmKey" = "8:_ED19EC4A19234BB8B89EA24B3F613547"
          265  +        "OwnerKey" = "8:_UNDEFINED"
          266  +        "MsmSig" = "8:_UNDEFINED"
          267  +        }
          268  +        "Entry"
   269    269           {
   270    270           "MsmKey" = "8:_F320FBAE871DA320178BEEA242900CC7"
   271    271           "OwnerKey" = "8:_2C7EDFF06B61482393D94E3A63D90113"
   272    272           "MsmSig" = "8:_UNDEFINED"
   273    273           }
   274    274           "Entry"
   275    275           {
................................................................................
   282    282           "MsmKey" = "8:_UNDEFINED"
   283    283           "OwnerKey" = "8:_B29C75F5F4D24817846DCEF9951068E1"
   284    284           "MsmSig" = "8:_UNDEFINED"
   285    285           }
   286    286           "Entry"
   287    287           {
   288    288           "MsmKey" = "8:_UNDEFINED"
   289         -        "OwnerKey" = "8:_CE9E3EF0722342DB8DE0860C0DDCD39E"
          289  +        "OwnerKey" = "8:_CA378DC7967442BAA821EDC0F78B57B7"
          290  +        "MsmSig" = "8:_UNDEFINED"
          291  +        }
          292  +        "Entry"
          293  +        {
          294  +        "MsmKey" = "8:_UNDEFINED"
          295  +        "OwnerKey" = "8:_40F352185F3B41A485F42BFC64BF9162"
   290    296           "MsmSig" = "8:_UNDEFINED"
   291    297           }
   292    298           "Entry"
   293    299           {
   294    300           "MsmKey" = "8:_UNDEFINED"
   295    301           "OwnerKey" = "8:_E6DB5A9B08AC4645A19C948BBFDD0348"
   296    302           "MsmSig" = "8:_UNDEFINED"
................................................................................
   297    303           }
   298    304           "Entry"
   299    305           {
   300    306           "MsmKey" = "8:_UNDEFINED"
   301    307           "OwnerKey" = "8:_D02FA65544C54EDE80CFCBDE5F083939"
   302    308           "MsmSig" = "8:_UNDEFINED"
   303    309           }
          310  +        "Entry"
          311  +        {
          312  +        "MsmKey" = "8:_UNDEFINED"
          313  +        "OwnerKey" = "8:_CE9E3EF0722342DB8DE0860C0DDCD39E"
          314  +        "MsmSig" = "8:_UNDEFINED"
          315  +        }
   304    316           "Entry"
   305    317           {
   306    318           "MsmKey" = "8:_UNDEFINED"
   307    319           "OwnerKey" = "8:_CD3CE5CDAB13405EA6EAAADC95F88D2E"
   308    320           "MsmSig" = "8:_UNDEFINED"
   309    321           }
   310    322           "Entry"
................................................................................
   333    345           }
   334    346           "Entry"
   335    347           {
   336    348           "MsmKey" = "8:_UNDEFINED"
   337    349           "OwnerKey" = "8:_40F352185F3B41A485F42BFC64BF9162"
   338    350           "MsmSig" = "8:_UNDEFINED"
   339    351           }
   340         -        "Entry"
   341         -        {
   342         -        "MsmKey" = "8:_UNDEFINED"
   343         -        "OwnerKey" = "8:_A18DBDB7776215EAD9A52C96F8CA1E91"
   344         -        "MsmSig" = "8:_UNDEFINED"
   345         -        }
   346    352           "Entry"
   347    353           {
   348    354           "MsmKey" = "8:_UNDEFINED"
   349    355           "OwnerKey" = "8:_40DFF08BA903482D807E715A041CA8B1"
   350    356           "MsmSig" = "8:_UNDEFINED"
   351    357           }
   352    358           "Entry"
................................................................................
   587    593               "SharedLegacy" = "11:FALSE"
   588    594               "PackageAs" = "3:1"
   589    595               "Register" = "3:1"
   590    596               "Exclude" = "11:TRUE"
   591    597               "IsDependency" = "11:TRUE"
   592    598               "IsolateTo" = "8:"
   593    599               }
   594         -            "{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_200C9E264509441F9AAB7EBE82A905DB"
   595         -            {
   596         -            "SourcePath" = "8:..\\..\\bin\\CompactFramework\\SQLite.Interop.059.lib"
   597         -            "TargetName" = "8:SQLite.Interop.059.lib"
   598         -            "Tag" = "8:"
   599         -            "Folder" = "8:_10C8E86E2EEF451BB40F774C35C5466F"
   600         -            "Condition" = "8:"
   601         -            "Transitive" = "11:FALSE"
   602         -            "Vital" = "11:TRUE"
   603         -            "ReadOnly" = "11:FALSE"
   604         -            "Hidden" = "11:FALSE"
   605         -            "System" = "11:FALSE"
   606         -            "Permanent" = "11:FALSE"
   607         -            "SharedLegacy" = "11:FALSE"
   608         -            "PackageAs" = "3:1"
   609         -            "Register" = "3:1"
   610         -            "Exclude" = "11:FALSE"
   611         -            "IsDependency" = "11:FALSE"
   612         -            "IsolateTo" = "8:"
   613         -            }
   614    600               "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_244D4945EA335F5E4E54085BFD020CC1"
   615    601               {
   616    602               "AssemblyRegister" = "3:1"
   617    603               "AssemblyIsInGAC" = "11:TRUE"
   618    604               "AssemblyAsmDisplayName" = "8:Microsoft.VisualStudio.Shell.Interop.8.0, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
   619    605                   "ScatterAssemblies"
   620    606                   {
................................................................................
   638    624               "SharedLegacy" = "11:FALSE"
   639    625               "PackageAs" = "3:1"
   640    626               "Register" = "3:1"
   641    627               "Exclude" = "11:TRUE"
   642    628               "IsDependency" = "11:TRUE"
   643    629               "IsolateTo" = "8:"
   644    630               }
   645         -            "{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_2560D913B1D74BAAB2B910FD325E9721"
   646         -            {
   647         -            "SourcePath" = "8:..\\..\\bin\\CompactFramework\\SQLite.Interop.059.DLL"
   648         -            "TargetName" = "8:SQLite.Interop.059.DLL"
   649         -            "Tag" = "8:"
   650         -            "Folder" = "8:_10C8E86E2EEF451BB40F774C35C5466F"
   651         -            "Condition" = "8:"
   652         -            "Transitive" = "11:FALSE"
   653         -            "Vital" = "11:TRUE"
   654         -            "ReadOnly" = "11:FALSE"
   655         -            "Hidden" = "11:FALSE"
   656         -            "System" = "11:FALSE"
   657         -            "Permanent" = "11:FALSE"
   658         -            "SharedLegacy" = "11:FALSE"
   659         -            "PackageAs" = "3:1"
   660         -            "Register" = "3:1"
   661         -            "Exclude" = "11:FALSE"
   662         -            "IsDependency" = "11:FALSE"
   663         -            "IsolateTo" = "8:"
   664         -            }
   665    631               "{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_26E74AC417994018832F9B82462AA3AF"
   666    632               {
   667    633               "SourcePath" = "8:..\\..\\bin\\x64\\System.Data.SQLite.lib"
   668    634               "TargetName" = "8:System.Data.SQLite.lib"
   669    635               "Tag" = "8:"
   670    636               "Folder" = "8:_66DBD0998AA8499691D4F5E42417697D"
   671    637               "Condition" = "8:"
................................................................................
   682    648               "IsDependency" = "11:FALSE"
   683    649               "IsolateTo" = "8:"
   684    650               }
   685    651               "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_2C7EDFF06B61482393D94E3A63D90113"
   686    652               {
   687    653               "AssemblyRegister" = "3:1"
   688    654               "AssemblyIsInGAC" = "11:FALSE"
   689         -            "AssemblyAsmDisplayName" = "8:test, Version=1.0.0.13492, Culture=neutral, processorArchitecture=x86"
          655  +            "AssemblyAsmDisplayName" = "8:test, Version=1.0.0.16237, Culture=neutral, processorArchitecture=x86"
   690    656                   "ScatterAssemblies"
   691    657                   {
   692    658                       "_2C7EDFF06B61482393D94E3A63D90113"
   693    659                       {
   694    660                       "Name" = "8:test.exe"
   695    661                       "Attributes" = "3:512"
   696    662                       }
................................................................................
   795    761               "IsDependency" = "11:TRUE"
   796    762               "IsolateTo" = "8:"
   797    763               }
   798    764               "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_40DFF08BA903482D807E715A041CA8B1"
   799    765               {
   800    766               "AssemblyRegister" = "3:1"
   801    767               "AssemblyIsInGAC" = "11:FALSE"
   802         -            "AssemblyAsmDisplayName" = "8:install, Version=1.0.0.13866, Culture=neutral, processorArchitecture=x86"
          768  +            "AssemblyAsmDisplayName" = "8:install, Version=1.0.0.14741, Culture=neutral, processorArchitecture=x86"
   803    769                   "ScatterAssemblies"
   804    770                   {
   805    771                       "_40DFF08BA903482D807E715A041CA8B1"
   806    772                       {
   807    773                       "Name" = "8:install.exe"
   808    774                       "Attributes" = "3:512"
   809    775                       }
................................................................................
   826    792               "IsDependency" = "11:FALSE"
   827    793               "IsolateTo" = "8:"
   828    794               }
   829    795               "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_40F352185F3B41A485F42BFC64BF9162"
   830    796               {
   831    797               "AssemblyRegister" = "3:1"
   832    798               "AssemblyIsInGAC" = "11:FALSE"
   833         -            "AssemblyAsmDisplayName" = "8:testce, Version=1.0.0.13580, Culture=neutral, processorArchitecture=MSIL"
          799  +            "AssemblyAsmDisplayName" = "8:testce, Version=1.0.0.40795, Culture=neutral, processorArchitecture=MSIL"
   834    800                   "ScatterAssemblies"
   835    801                   {
   836    802                       "_40F352185F3B41A485F42BFC64BF9162"
   837    803                       {
   838    804                       "Name" = "8:testce.exe"
   839    805                       "Attributes" = "3:512"
   840    806                       }
................................................................................
   952    918               "Hidden" = "11:FALSE"
   953    919               "System" = "11:FALSE"
   954    920               "Permanent" = "11:FALSE"
   955    921               "SharedLegacy" = "11:FALSE"
   956    922               "PackageAs" = "3:1"
   957    923               "Register" = "3:1"
   958    924               "Exclude" = "11:TRUE"
   959         -            "IsDependency" = "11:TRUE"
   960         -            "IsolateTo" = "8:"
   961         -            }
   962         -            "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_A18DBDB7776215EAD9A52C96F8CA1E91"
   963         -            {
   964         -            "AssemblyRegister" = "3:1"
   965         -            "AssemblyIsInGAC" = "11:FALSE"
   966         -            "AssemblyAsmDisplayName" = "8:System.Data.SQLite, Version=1.0.59.0, Culture=neutral, PublicKeyToken=1fdb50b1b62b4c84, processorArchitecture=MSIL"
   967         -                "ScatterAssemblies"
   968         -                {
   969         -                    "_A18DBDB7776215EAD9A52C96F8CA1E91"
   970         -                    {
   971         -                    "Name" = "8:System.Data.SQLite.DLL"
   972         -                    "Attributes" = "3:512"
   973         -                    }
   974         -                }
   975         -            "SourcePath" = "8:System.Data.SQLite.DLL"
   976         -            "TargetName" = "8:"
   977         -            "Tag" = "8:"
   978         -            "Folder" = "8:_10C8E86E2EEF451BB40F774C35C5466F"
   979         -            "Condition" = "8:"
   980         -            "Transitive" = "11:FALSE"
   981         -            "Vital" = "11:TRUE"
   982         -            "ReadOnly" = "11:FALSE"
   983         -            "Hidden" = "11:FALSE"
   984         -            "System" = "11:FALSE"
   985         -            "Permanent" = "11:FALSE"
   986         -            "SharedLegacy" = "11:FALSE"
   987         -            "PackageAs" = "3:1"
   988         -            "Register" = "3:1"
   989         -            "Exclude" = "11:FALSE"
   990    925               "IsDependency" = "11:TRUE"
   991    926               "IsolateTo" = "8:"
   992    927               }
   993    928               "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_A7448E608040319F6C5E12637881B1F6"
   994    929               {
   995    930               "AssemblyRegister" = "3:1"
   996    931               "AssemblyIsInGAC" = "11:TRUE"
................................................................................
  1118   1053               "Permanent" = "11:FALSE"
  1119   1054               "SharedLegacy" = "11:FALSE"
  1120   1055               "PackageAs" = "3:1"
  1121   1056               "Register" = "3:1"
  1122   1057               "Exclude" = "11:TRUE"
  1123   1058               "IsDependency" = "11:FALSE"
  1124   1059               "IsolateTo" = "8:"
         1060  +            }
         1061  +            "{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_C5435F188DCA474EA777C28201046580"
         1062  +            {
         1063  +            "SourcePath" = "8:..\\..\\bin\\CompactFramework\\SQLite.Interop.060.DLL"
         1064  +            "TargetName" = "8:SQLite.Interop.060.DLL"
         1065  +            "Tag" = "8:"
         1066  +            "Folder" = "8:_10C8E86E2EEF451BB40F774C35C5466F"
         1067  +            "Condition" = "8:"
         1068  +            "Transitive" = "11:FALSE"
         1069  +            "Vital" = "11:TRUE"
         1070  +            "ReadOnly" = "11:FALSE"
         1071  +            "Hidden" = "11:FALSE"
         1072  +            "System" = "11:FALSE"
         1073  +            "Permanent" = "11:FALSE"
         1074  +            "SharedLegacy" = "11:FALSE"
         1075  +            "PackageAs" = "3:1"
         1076  +            "Register" = "3:1"
         1077  +            "Exclude" = "11:FALSE"
         1078  +            "IsDependency" = "11:FALSE"
         1079  +            "IsolateTo" = "8:"
  1125   1080               }
  1126   1081               "{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_C8E329AC56AD4C88A986481E639F72A5"
  1127   1082               {
  1128   1083               "SourcePath" = "8:..\\..\\readme.htm"
  1129   1084               "TargetName" = "8:readme.htm"
  1130   1085               "Tag" = "8:"
  1131   1086               "Folder" = "8:_A0841E79B7874F7288672343934C7657"
  1132   1087               "Condition" = "8:"
         1088  +            "Transitive" = "11:FALSE"
         1089  +            "Vital" = "11:TRUE"
         1090  +            "ReadOnly" = "11:FALSE"
         1091  +            "Hidden" = "11:FALSE"
         1092  +            "System" = "11:FALSE"
         1093  +            "Permanent" = "11:FALSE"
         1094  +            "SharedLegacy" = "11:FALSE"
         1095  +            "PackageAs" = "3:1"
         1096  +            "Register" = "3:1"
         1097  +            "Exclude" = "11:FALSE"
         1098  +            "IsDependency" = "11:FALSE"
         1099  +            "IsolateTo" = "8:"
         1100  +            }
         1101  +            "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_CA378DC7967442BAA821EDC0F78B57B7"
         1102  +            {
         1103  +            "AssemblyRegister" = "3:1"
         1104  +            "AssemblyIsInGAC" = "11:FALSE"
         1105  +            "AssemblyAsmDisplayName" = "8:System.Data.SQLite, Version=1.0.60.0, Culture=neutral, PublicKeyToken=1fdb50b1b62b4c84, processorArchitecture=MSIL"
         1106  +                "ScatterAssemblies"
         1107  +                {
         1108  +                    "_CA378DC7967442BAA821EDC0F78B57B7"
         1109  +                    {
         1110  +                    "Name" = "8:System.Data.SQLite.dll"
         1111  +                    "Attributes" = "3:512"
         1112  +                    }
         1113  +                }
         1114  +            "SourcePath" = "8:..\\..\\bin\\CompactFramework\\System.Data.SQLite.dll"
         1115  +            "TargetName" = "8:"
         1116  +            "Tag" = "8:"
         1117  +            "Folder" = "8:_10C8E86E2EEF451BB40F774C35C5466F"
         1118  +            "Condition" = "8:"
  1133   1119               "Transitive" = "11:FALSE"
  1134   1120               "Vital" = "11:TRUE"
  1135   1121               "ReadOnly" = "11:FALSE"
  1136   1122               "Hidden" = "11:FALSE"
  1137   1123               "System" = "11:FALSE"
  1138   1124               "Permanent" = "11:FALSE"
  1139   1125               "SharedLegacy" = "11:FALSE"
................................................................................
  1302   1288               "Permanent" = "11:FALSE"
  1303   1289               "SharedLegacy" = "11:FALSE"
  1304   1290               "PackageAs" = "3:1"
  1305   1291               "Register" = "3:1"
  1306   1292               "Exclude" = "11:TRUE"
  1307   1293               "IsDependency" = "11:TRUE"
  1308   1294               "IsolateTo" = "8:"
         1295  +            }
         1296  +            "{1FB2D0AE-D3B9-43D4-B9DD-F88EC61E35DE}:_ED19EC4A19234BB8B89EA24B3F613547"
         1297  +            {
         1298  +            "SourcePath" = "8:..\\..\\bin\\CompactFramework\\SQLite.Interop.060.lib"
         1299  +            "TargetName" = "8:SQLite.Interop.060.lib"
         1300  +            "Tag" = "8:"
         1301  +            "Folder" = "8:_10C8E86E2EEF451BB40F774C35C5466F"
         1302  +            "Condition" = "8:"
         1303  +            "Transitive" = "11:FALSE"
         1304  +            "Vital" = "11:TRUE"
         1305  +            "ReadOnly" = "11:FALSE"
         1306  +            "Hidden" = "11:FALSE"
         1307  +            "System" = "11:FALSE"
         1308  +            "Permanent" = "11:FALSE"
         1309  +            "SharedLegacy" = "11:FALSE"
         1310  +            "PackageAs" = "3:1"
         1311  +            "Register" = "3:1"
         1312  +            "Exclude" = "11:FALSE"
         1313  +            "IsDependency" = "11:FALSE"
         1314  +            "IsolateTo" = "8:"
  1309   1315               }
  1310   1316               "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_F320FBAE871DA320178BEEA242900CC7"
  1311   1317               {
  1312   1318               "AssemblyRegister" = "3:1"
  1313   1319               "AssemblyIsInGAC" = "11:FALSE"
  1314         -            "AssemblyAsmDisplayName" = "8:System.Data.SQLite, Version=1.0.59.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=x86"
         1320  +            "AssemblyAsmDisplayName" = "8:System.Data.SQLite, Version=1.0.60.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=x86"
  1315   1321                   "ScatterAssemblies"
  1316   1322                   {
  1317   1323                       "_F320FBAE871DA320178BEEA242900CC7"
  1318   1324                       {
  1319   1325                       "Name" = "8:System.Data.SQLite.DLL"
  1320   1326                       "Attributes" = "3:512"
  1321   1327                       }
................................................................................
  1467   1473           "LangId" = "3:1033"
  1468   1474           "RequiresElevation" = "11:FALSE"
  1469   1475           }
  1470   1476           "Product"
  1471   1477           {
  1472   1478           "Name" = "8:Microsoft Visual Studio"
  1473   1479           "ProductName" = "8:SQLite ADO.NET 2.0 Provider"
  1474         -        "ProductCode" = "8:{718F7D6C-4CA0-4A7E-8F31-4EFE34F7ACE6}"
  1475         -        "PackageCode" = "8:{E7E5C8DD-10BB-4BA9-B896-B45FDE9F0250}"
         1480  +        "ProductCode" = "8:{6C047B82-5C03-4F84-9B27-53743EB95128}"
         1481  +        "PackageCode" = "8:{FFDFA941-E460-4318-B901-DD7D44D518AA}"
  1476   1482           "UpgradeCode" = "8:{78329A82-AFB1-453B-AF00-D46AC911DA89}"
  1477   1483           "RestartWWWService" = "11:FALSE"
  1478   1484           "RemovePreviousVersions" = "11:TRUE"
  1479   1485           "DetectNewerInstalledVersion" = "11:TRUE"
  1480   1486           "InstallAllUsers" = "11:TRUE"
  1481         -        "ProductVersion" = "8:1.059.0"
         1487  +        "ProductVersion" = "8:1.060.0"
  1482   1488           "Manufacturer" = "8:Phoenix Software Solutions, LLC"
  1483   1489           "ARPHELPTELEPHONE" = "8:"
  1484   1490           "ARPHELPLINK" = "8:http://sqlite.phxsoftware.com"
  1485   1491           "Title" = "8:SQLite ADO.NET 2.0 Provider"
  1486   1492           "Subject" = "8:"
  1487   1493           "ARPCONTACT" = "8:Phoenix Software Solutions, LLC"
  1488   1494           "Keywords" = "8:"