public void TreeCreated(DbCommandTree commandTree, DbCommandTreeInterceptionContext interceptionContext)
 {
     if (interceptionContext.DbContexts.Contains(_context, ReferenceEquals))
     {
         _commandTrees.Add(commandTree);
     }
 }

        internal static EntityCommandDefinition CreateCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
        {
            DebugCheck.NotNull(storeProviderFactory);
            DebugCheck.NotNull(commandTree);

            return new EntityCommandDefinition(storeProviderFactory, commandTree);
        }

        protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
        {
            Check.NotNull(providerManifest, "providerManifest");
            Check.NotNull(commandTree, "commandTree");

            return CreateDbCommandDefinition(providerManifest, commandTree, new DbInterceptionContext());
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DbCommandInfo"/> class.
        /// </summary>
        public DbCommandInfo(DbCommandTree tree, DbCache cache, IDbCachingPolicy policy, DbTransactionInterceptor txHandler)
        {
            Debug.Assert(tree != null);
            Debug.Assert(cache != null);
            Debug.Assert(txHandler != null);

            var qryTree = tree as DbQueryCommandTree;

            if (qryTree != null)
            {
                _isModification = false;

                _affectedEntitySets = GetAffectedEntitySets(qryTree.Query);
            }
            else
            {
                _isModification = true;

                var modify = tree as DbModificationCommandTree;

                if (modify != null)
                    _affectedEntitySets = GetAffectedEntitySets(modify.Target.Expression);
                else
                    // Functions (stored procedures) are not supported.
                    Debug.Assert(tree is DbFunctionCommandTree);
            }

            _cache = cache;
            _policy = policy;
            _txHandler = txHandler;
        }

        public void IsQuery_false_for_non_DbQueryCommandTree()
        {
            var collectionExpression =
                TypeUsage.CreateDefaultTypeUsage(
                    PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)
                        .GetCollectionType())
                    .NewEmptyCollection();

            var commandTrees = new DbCommandTree[]
                {
                    new DbInsertCommandTree(
                        new MetadataWorkspace(),
                        DataSpace.CSpace,
                        collectionExpression.Bind(),
                        new List<DbModificationClause>().AsReadOnly(),
                        collectionExpression),

                    new DbUpdateCommandTree(
                        new MetadataWorkspace(),
                        DataSpace.CSpace,
                        collectionExpression.Bind(),
                        DbExpressionBuilder.Constant(3),
                        new List<DbModificationClause>().AsReadOnly(),
                        collectionExpression),
                };

            foreach (var commandTree in commandTrees)
            {
                Assert.False(new CommandTreeFacts(commandTree).IsQuery);
            }
        }

    public override string GenerateSQL(DbCommandTree tree)
    {
      DbInsertCommandTree commandTree = tree as DbInsertCommandTree;

      InsertStatement statement = new InsertStatement();

      DbExpressionBinding e = commandTree.Target;
      statement.Target = (InputFragment)e.Expression.Accept(this);

      scope.Add("target", statement.Target);

      foreach (DbSetClause setClause in commandTree.SetClauses)
        statement.Sets.Add(setClause.Property.Accept(this));

      if (values == null)
        values = new Dictionary<EdmMember, SqlFragment>();

      foreach (DbSetClause setClause in commandTree.SetClauses)
      {
        DbExpression value = setClause.Value;
        SqlFragment valueFragment = value.Accept(this);
        statement.Values.Add(valueFragment);

        if (value.ExpressionKind != DbExpressionKind.Null)
        {
          EdmMember property = ((DbPropertyExpression)setClause.Property).Property;
          values.Add(property, valueFragment);
        }
      }

      if (commandTree.Returning != null)
        statement.ReturningSelect = GenerateReturningSql(commandTree, commandTree.Returning);

      return statement.ToString();
    }

    public override string GenerateSQL(DbCommandTree commandTree)
    {
      DbFunctionCommandTree tree = (commandTree as DbFunctionCommandTree);
      EdmFunction function = tree.EdmFunction;
      CommandType = CommandType.StoredProcedure;

      string cmdText = (string)function.MetadataProperties["CommandTextAttribute"].Value;
      if (String.IsNullOrEmpty(cmdText))
      {
        string schema = (string)function.MetadataProperties["Schema"].Value;
        if (String.IsNullOrEmpty(schema))
          schema = function.NamespaceName;

        string functionName = (string)function.MetadataProperties["StoreFunctionNameAttribute"].Value;
        if (String.IsNullOrEmpty(functionName))
          functionName = function.Name;

        return String.Format("`{0}`", functionName);
      }
      else
      {
        CommandType = CommandType.Text;
        return cmdText;
      }
    }

        public virtual void VisitCommandTree(DbCommandTree commandTree)
        {
            Contract.Requires(commandTree != null);
            switch (commandTree.CommandTreeKind)
            {
                case DbCommandTreeKind.Delete:
                    VisitDeleteCommandTree((DbDeleteCommandTree)commandTree);
                    break;

                case DbCommandTreeKind.Function:
                    VisitFunctionCommandTree((DbFunctionCommandTree)commandTree);
                    break;

                case DbCommandTreeKind.Insert:
                    VisitInsertCommandTree((DbInsertCommandTree)commandTree);
                    break;

                case DbCommandTreeKind.Query:
                    VisitQueryCommandTree((DbQueryCommandTree)commandTree);
                    break;

                case DbCommandTreeKind.Update:
                    VisitUpdateCommandTree((DbUpdateCommandTree)commandTree);
                    break;

                default:
                    throw new NotSupportedException();
            }
        }

        internal static EntityCommandDefinition CreateCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
        {
            Contract.Requires(storeProviderFactory != null);
            Contract.Requires(commandTree != null);

            return new EntityCommandDefinition(storeProviderFactory, commandTree);
        }

    public override string GenerateSQL(DbCommandTree tree)
    {
      DbUpdateCommandTree commandTree = tree as DbUpdateCommandTree;

      UpdateStatement statement = new UpdateStatement();

      _onReturningSelect = false;
      statement.Target = commandTree.Target.Expression.Accept(this);
      scope.Add("target", statement.Target as InputFragment);

      if (values == null)
        values = new Dictionary<EdmMember, SqlFragment>();

      foreach (DbSetClause setClause in commandTree.SetClauses)
      {
        statement.Properties.Add(setClause.Property.Accept(this));
        DbExpression value = setClause.Value;
        SqlFragment valueFragment = value.Accept(this);
        statement.Values.Add(valueFragment);

        if (value.ExpressionKind != DbExpressionKind.Null)
        {
          EdmMember property = ((DbPropertyExpression)setClause.Property).Property;
          values.Add(property, valueFragment);
        }
      }
      
      statement.Where = commandTree.Predicate.Accept(this);

      _onReturningSelect = true;
      if (commandTree.Returning != null)
        statement.ReturningSelect = GenerateReturningSql(commandTree, commandTree.Returning);

      return statement.ToString();
    }

        /// <summary>
        ///     Constructs a new ObjectSpanRewriter that will attempt to apply spanning to the specified query
        ///     (represented as a DbExpression) when <see cref="RewriteQuery" /> is called.
        /// </summary>
        /// <param name="toRewrite">
        ///     A <see cref="DbExpression" /> representing the query to span.
        /// </param>
        internal ObjectSpanRewriter(DbCommandTree tree, DbExpression toRewrite, AliasGenerator aliasGenerator)
        {
            DebugCheck.NotNull(toRewrite);

            _toRewrite = toRewrite;
            _tree = tree;
            _aliasGenerator = aliasGenerator;
        }

 /// <summary>
 /// Ensures that the data space of the specified command tree is the model (C-) space
 /// </summary>
 /// <param name="commandTree">The command tree for which the data space should be validated</param>
 internal override void ValidateDataSpace(DbCommandTree commandTree)
 {
     if (commandTree.DataSpace
         != DataSpace.CSpace)
     {
         throw new ProviderIncompatibleException(Strings.EntityClient_RequiresNonStoreCommandTree);
     }
 }

        /// <summary>
        ///     Create a Command Definition object, given the connection and command tree
        /// </summary>
        /// <param name="connection"> connection to the underlying provider </param>
        /// <param name="commandTree"> command tree for the statement </param>
        /// <returns> an executable command definition object </returns>
        /// <exception cref="ArgumentNullException">connection and commandTree arguments must not be null</exception>
        protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
        {
            Check.NotNull(providerManifest, "providerManifest");
            Check.NotNull(commandTree, "commandTree");

            var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
            return CreateCommandDefinition(storeMetadata.StoreProviderFactory, commandTree);
        }

 protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
 {
     return new CachingCommandDefinition(
         _providerServices.CreateCommandDefinition(providerManifest, commandTree), 
         new CommandTreeFacts(commandTree),
         _cacheTransactionHandler,
         _cachingPolicy);
 }

        /// <summary>
        ///     Constructs a new ObjectSpanRewriter that will attempt to apply spanning to the specified query
        ///     (represented as a DbExpression) when <see cref="RewriteQuery" /> is called.
        /// </summary>
        /// <param name="toRewrite"> A <see cref="DbExpression" /> representing the query to span. </param>
        internal ObjectSpanRewriter(DbCommandTree tree, DbExpression toRewrite, AliasGenerator aliasGenerator)
        {
            Debug.Assert(toRewrite != null, "Expression to rewrite cannot be null");

            _toRewrite = toRewrite;
            _tree = tree;
            _aliasGenerator = aliasGenerator;
        }

        internal ParseResult(DbCommandTree commandTree, List<FunctionDefinition> functionDefs)
        {
            Contract.Requires(commandTree != null);
            Contract.Requires(functionDefs != null);

            _commandTree = commandTree;
            _functionDefs = functionDefs.AsReadOnly();
        }

        internal ParseResult(DbCommandTree commandTree, List<FunctionDefinition> functionDefs)
        {
            DebugCheck.NotNull(commandTree);
            DebugCheck.NotNull(functionDefs);

            _commandTree = commandTree;
            _functionDefs = new ReadOnlyCollection<FunctionDefinition>(functionDefs);
        }

        internal static EntityCommandDefinition CreateCommandDefinition(
            DbProviderFactory storeProviderFactory, DbCommandTree commandTree, IDbDependencyResolver resolver = null)
        {
            DebugCheck.NotNull(storeProviderFactory);
            DebugCheck.NotNull(commandTree);

            return new EntityCommandDefinition(storeProviderFactory, commandTree, resolver);
        }

        protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
        {
            Debug.Assert(providerManifest != null, "CreateCommandDefinition passed null provider manifest to CreateDbCommandDefinition?");
            Debug.Assert(commandTree != null, "CreateCommandDefinition did not validate commandTree argument?");

            var prototype = CreateCommand(providerManifest, commandTree);
            var result = CreateCommandDefinition(prototype);
            return result;
        }

        /// <summary>
        ///     Create a Command Definition object given a command tree.
        /// </summary>
        /// <param name="commandTree"> command tree for the statement </param>
        /// <returns> an executable command definition object </returns>
        /// <remarks>
        ///     This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
        /// </remarks>
        public DbCommandDefinition CreateCommandDefinition(DbCommandTree commandTree)
        {
            Contract.Requires(commandTree != null);
            ValidateDataSpace(commandTree);
            var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
            Contract.Assert(storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?");

            return CreateDbCommandDefinition(storeMetadata.StoreProviderManifest, commandTree);
        }