Don't simplify filter with custom functions over projection

src/EntityFramework/Core/Common/CommandTrees/DbCommandTree.cs

@@ -17,6 +17,7 @@ public abstract class DbCommandTree
         private readonly MetadataWorkspace _metadata;
         private readonly DataSpace _dataSpace;
         private readonly bool _useDatabaseNullSemantics;
+        private readonly bool _disableFilterOverProjectionSimplificationForCustomFunctions;
 
         internal DbCommandTree()
         {
@@ -30,7 +31,7 @@ internal DbCommandTree()
         // <param name="dataSpace"> The logical 'space' that metadata in the expressions used in this command tree must belong to. </param>
         // <param name="useDatabaseNullSemantics">A boolean that indicates whether database null semantics are exhibited when comparing
         // two operands, both of which are potentially nullable. The default value is true.</param>
-        internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, bool useDatabaseNullSemantics = true)
+        internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, bool useDatabaseNullSemantics = true, bool disableFilterOverProjectionSimplificationForCustomFunctions = false)
         {
             // Ensure the metadata workspace is non-null
             DebugCheck.NotNull(metadata);
@@ -44,6 +45,7 @@ internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, bool use
             _metadata = metadata;
             _dataSpace = dataSpace;
             _useDatabaseNullSemantics = useDatabaseNullSemantics;
+            _disableFilterOverProjectionSimplificationForCustomFunctions = disableFilterOverProjectionSimplificationForCustomFunctions;
         }
 
         /// <summary>
@@ -68,6 +70,11 @@ public bool UseDatabaseNullSemantics
             get { return _useDatabaseNullSemantics; }
         }
 
+        public bool DisableFilterOverProjectionSimplificationForCustomFunctions
+        {
+            get { return _disableFilterOverProjectionSimplificationForCustomFunctions; }
+        }
+
         /// <summary>
         /// Gets the name and corresponding type of each parameter that can be referenced within this
         /// <see

src/EntityFramework/Core/Common/CommandTrees/DbQueryCommandTree.cs

@@ -29,6 +29,8 @@ public sealed class DbQueryCommandTree : DbCommandTree
         /// <param name="validate"> When set to false the validation of the tree is turned off. </param>
         /// <param name="useDatabaseNullSemantics">A boolean that indicates whether database null semantics are exhibited when comparing
         /// two operands, both of which are potentially nullable.</param>
+        /// <param name="disableFilterOverProjectionSimplificationForCustomFunctions">A boolean that indicates whether 
+        /// filter over projection simplification should be used.</param>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="metadata" />
         /// or
@@ -39,8 +41,8 @@ public sealed class DbQueryCommandTree : DbCommandTree
         /// <paramref name="dataSpace" />
         /// does not represent a valid data space
         /// </exception>
-        public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query, bool validate, bool useDatabaseNullSemantics)
-            : base(metadata, dataSpace, useDatabaseNullSemantics)
+        public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query, bool validate, bool useDatabaseNullSemantics, bool disableFilterOverProjectionSimplificationForCustomFunctions)
+            : base(metadata, dataSpace, useDatabaseNullSemantics, disableFilterOverProjectionSimplificationForCustomFunctions)
         {
             // Ensure the query expression is non-null
             Check.NotNull(query, "query");
@@ -57,6 +59,32 @@ public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExp
             _query = query;
         }
 
+        /// <summary>
+        /// Constructs a new DbQueryCommandTree that uses the specified metadata workspace.
+        /// </summary>
+        /// <param name="metadata"> The metadata workspace that the command tree should use. </param>
+        /// <param name="dataSpace"> The logical 'space' that metadata in the expressions used in this command tree must belong to. </param>
+        /// <param name="query">
+        /// A <see cref="DbExpression" /> that defines the logic of the query.
+        /// </param>
+        /// <param name="validate"> When set to false the validation of the tree is turned off. </param>
+        /// <param name="useDatabaseNullSemantics">A boolean that indicates whether database null semantics are exhibited when comparing
+        /// two operands, both of which are potentially nullable.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="metadata" />
+        /// or
+        /// <paramref name="query" />
+        /// is null
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        /// <paramref name="dataSpace" />
+        /// does not represent a valid data space
+        /// </exception>
+        public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query, bool validate, bool useDatabaseNullSemantics)
+            : this(metadata, dataSpace, query, validate, useDatabaseNullSemantics, false)
+        {
+        }
+
         /// <summary>
         /// Constructs a new DbQueryCommandTree that uses the specified metadata workspace, using database null semantics.
         /// </summary>
@@ -77,7 +105,7 @@ public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExp
         /// does not represent a valid data space
         /// </exception>
         public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query, bool validate)
-            : this(metadata, dataSpace, query, validate, true)
+            : this(metadata, dataSpace, query, validate, true, false)
         {
         }
 
@@ -100,7 +128,7 @@ public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExp
         /// does not represent a valid data space
         /// </exception>
         public DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query)
-            : this(metadata, dataSpace, query, true, true)
+            : this(metadata, dataSpace, query, true, true, false)
         {
         }
 
@@ -147,15 +175,16 @@ internal override string PrintTree(ExpressionPrinter printer)
         }
 
         internal static DbQueryCommandTree FromValidExpression(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query, 
-            bool useDatabaseNullSemantics)
+            bool useDatabaseNullSemantics, bool disableFilterOverProjectionSimplificationForCustomFunctions)
         {
             return new DbQueryCommandTree(metadata, dataSpace, query, 
 #if DEBUG
                 true,
 #else
                 false, 
 #endif
-                useDatabaseNullSemantics);
+                useDatabaseNullSemantics,
+                disableFilterOverProjectionSimplificationForCustomFunctions);
         }
     }
 }

src/EntityFramework/Core/Common/CommandTrees/Internal/ViewSimplifier.cs

@@ -58,7 +58,7 @@ private DbQueryCommandTree Simplify(DbQueryCommandTree view)
             queryExpression = simplifier(queryExpression);
 
             view = DbQueryCommandTree.FromValidExpression(
-                view.MetadataWorkspace, view.DataSpace, queryExpression, view.UseDatabaseNullSemantics);
+                view.MetadataWorkspace, view.DataSpace, queryExpression, view.UseDatabaseNullSemantics, view.DisableFilterOverProjectionSimplificationForCustomFunctions);
             return view;
         }
 

src/EntityFramework/Core/Common/DbProviderServices.cs

@@ -39,6 +39,7 @@ private static readonly ConcurrentDictionary<ExecutionStrategyKey, Func<IDbExecu
 
         private readonly ResolverChain _resolvers = new ResolverChain();
 
+
         /// <summary>
         /// Constructs an EF provider that will use the <see cref="IDbDependencyResolver" /> obtained from
         /// the app domain <see cref="DbConfiguration" /> Singleton for resolving EF dependencies such

src/EntityFramework/Core/Common/EntitySql/SemanticAnalyzer.cs

@@ -254,7 +254,7 @@ private static ParseResult ConvertQueryStatementToDbCommandTree(Statement astSta
             return new ParseResult(
                 DbQueryCommandTree.FromValidExpression(
                     sr.TypeResolver.Perspective.MetadataWorkspace, sr.TypeResolver.Perspective.TargetDataspace, converted, 
-                    useDatabaseNullSemantics: true),
+                    useDatabaseNullSemantics: true, disableFilterOverProjectionSimplificationForCustomFunctions: false),
                 functionDefs);
         }
 

src/EntityFramework/Core/Mapping/FunctionImportMappingComposable.cs

@@ -403,7 +403,7 @@ internal DbQueryCommandTree GenerateFunctionView(out DiscriminatorMap discrimina
             // Generate parameterized command, where command parameters are semantically the c-space function parameters.
             return DbQueryCommandTree.FromValidExpression(
                 _containerMapping.StorageMappingItemCollection.Workspace, TargetPerspective.TargetPerspectiveDataSpace, queryExpression,
-                useDatabaseNullSemantics: true);
+                useDatabaseNullSemantics: true, disableFilterOverProjectionSimplificationForCustomFunctions: false);
         }
 
         private IEnumerable<DbExpression> GetParametersForTargetFunctionCall()

src/EntityFramework/Core/Mapping/ViewGeneration/CqlGenerator.cs

@@ -107,7 +107,7 @@ internal DbQueryCommandTree GenerateCqt()
 
             return DbQueryCommandTree.FromValidExpression(
                 m_mappingItemCollection.Workspace, TargetPerspective.TargetPerspectiveDataSpace, query,
-                useDatabaseNullSemantics: true);
+                useDatabaseNullSemantics: true, disableFilterOverProjectionSimplificationForCustomFunctions: false);
         }
 
         // <summary>

src/EntityFramework/Core/Objects/ELinq/CompiledELinqQueryState.cs

@@ -57,6 +57,7 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
             ObjectQueryExecutionPlan plan = null;
             var cacheEntry = _cacheEntry;
             var useCSharpNullComparisonBehavior = ObjectContext.ContextOptions.UseCSharpNullComparisonBehavior;
+            var disableFilterOverProjectionSimplificationForCustomFunctions = ObjectContext.ContextOptions.DisableFilterOverProjectionSimplificationForCustomFunctions;
             if (cacheEntry != null)
             {
                 // The cache entry has already been retrieved, so compute the effective merge option with the following precedence:
@@ -77,7 +78,7 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
 
                     // Prepare the execution plan using the command tree and the computed effective merge option
                     var tree = DbQueryCommandTree.FromValidExpression(
-                        ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression, !useCSharpNullComparisonBehavior);
+                        ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression, !useCSharpNullComparisonBehavior, disableFilterOverProjectionSimplificationForCustomFunctions);
                     plan = _objectQueryExecutionPlanFactory.Prepare(
                         ObjectContext, tree, ElementType, mergeOption, EffectiveStreamingBehavior, converter.PropagatedSpan, parameters,
                         converter.AliasGenerator);
@@ -110,7 +111,7 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
                     var queryExpression = converter.Convert();
                     var parameters = converter.GetParameters();
                     var tree = DbQueryCommandTree.FromValidExpression(
-                        ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression, !useCSharpNullComparisonBehavior);
+                        ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression, !useCSharpNullComparisonBehavior, disableFilterOverProjectionSimplificationForCustomFunctions);
 
                     // If a cache entry for this compiled query's cache key was not successfully retrieved, then it must be created now.
                     // Note that this is only possible after converting the LINQ expression and discovering the propagated merge option,

src/EntityFramework/Core/Objects/ELinq/ELinqQueryState.cs

@@ -25,6 +25,7 @@ internal class ELinqQueryState : ObjectQueryState
         private Func<bool> _recompileRequired;
         private IEnumerable<Tuple<ObjectParameter, QueryParameterExpression>> _linqParameters;
         private bool _useCSharpNullComparisonBehavior;
+        private bool _disableFilterOverProjectionSimplificationForCustomFunctions;
         private readonly ObjectQueryExecutionPlanFactory _objectQueryExecutionPlanFactory;
 
         #endregion
@@ -53,6 +54,7 @@ internal ELinqQueryState(
 
             _expression = expression;
             _useCSharpNullComparisonBehavior = context.ContextOptions.UseCSharpNullComparisonBehavior;
+            _disableFilterOverProjectionSimplificationForCustomFunctions = context.ContextOptions.DisableFilterOverProjectionSimplificationForCustomFunctions;
             _objectQueryExecutionPlanFactory = objectQueryExecutionPlanFactory ?? new ObjectQueryExecutionPlanFactory();
         }
 
@@ -102,7 +104,8 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
                 if ((explicitMergeOption.HasValue &&
                      explicitMergeOption.Value != plan.MergeOption)
                     || _recompileRequired()
-                    || ObjectContext.ContextOptions.UseCSharpNullComparisonBehavior != _useCSharpNullComparisonBehavior)
+                    || ObjectContext.ContextOptions.UseCSharpNullComparisonBehavior != _useCSharpNullComparisonBehavior
+                    || ObjectContext.ContextOptions.DisableFilterOverProjectionSimplificationForCustomFunctions != _disableFilterOverProjectionSimplificationForCustomFunctions)
                 {
                     plan = null;
                 }
@@ -133,6 +136,7 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
                     converter.PropagatedMergeOption);
 
                 _useCSharpNullComparisonBehavior = ObjectContext.ContextOptions.UseCSharpNullComparisonBehavior;
+                _disableFilterOverProjectionSimplificationForCustomFunctions = ObjectContext.ContextOptions.DisableFilterOverProjectionSimplificationForCustomFunctions;
 
                 // If parameters were aggregated from referenced (non-LINQ) ObjectQuery instances then add them to the parameters collection
                 _linqParameters = converter.GetParameters();
@@ -186,7 +190,7 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
                 if (plan == null)
                 {
                     var tree = DbQueryCommandTree.FromValidExpression(
-                        ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression, !_useCSharpNullComparisonBehavior);
+                        ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression, !_useCSharpNullComparisonBehavior, _disableFilterOverProjectionSimplificationForCustomFunctions);
                     plan = _objectQueryExecutionPlanFactory.Prepare(
                         ObjectContext, tree, ElementType, mergeOption, EffectiveStreamingBehavior, converter.PropagatedSpan, null,
                         converter.AliasGenerator);

src/EntityFramework/Core/Objects/Internal/EntitySqlQueryState.cs

@@ -186,7 +186,7 @@ internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMerg
                 Debug.Assert(queryExpression != null, "EntitySqlQueryState.Parse returned null expression?");
                 var tree = DbQueryCommandTree.FromValidExpression(
                     ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression,
-                    useDatabaseNullSemantics: true);
+                    useDatabaseNullSemantics: true, disableFilterOverProjectionSimplificationForCustomFunctions: false);
                 plan = _objectQueryExecutionPlanFactory.Prepare(
                     ObjectContext, tree, ElementType, mergeOption, EffectiveStreamingBehavior, Span, null,
                     DbExpressionBuilder.AliasGenerator);

src/EntityFramework/Core/Objects/Internal/ObjectQueryExecutionPlanFactory.cs

@@ -35,7 +35,7 @@ public virtual ObjectQueryExecutionPlan Prepare(
             if (ObjectSpanRewriter.TryRewrite(tree, span, mergeOption, aliasGenerator, out spannedQuery, out spanInfo))
             {
                 tree = DbQueryCommandTree.FromValidExpression(
-                    tree.MetadataWorkspace, tree.DataSpace, spannedQuery, tree.UseDatabaseNullSemantics);
+                    tree.MetadataWorkspace, tree.DataSpace, spannedQuery, tree.UseDatabaseNullSemantics, tree.DisableFilterOverProjectionSimplificationForCustomFunctions);
             }
             else
             {

src/EntityFramework/Core/Objects/ObjectContext.cs

@@ -2869,7 +2869,7 @@ internal virtual Tuple<ObjectQueryExecutionPlan, int> PrepareRefreshQuery(
 
             // Initialize the command tree used to issue the refresh query.
             var tree = DbQueryCommandTree.FromValidExpression(
-                MetadataWorkspace, DataSpace.CSpace, refreshQuery, useDatabaseNullSemantics: true);
+                MetadataWorkspace, DataSpace.CSpace, refreshQuery, useDatabaseNullSemantics: true, disableFilterOverProjectionSimplificationForCustomFunctions: false);
 
             // Evaluate the refresh query using ObjectQuery<T> and process the results to update the ObjectStateManager.
             var mergeOption = (RefreshMode.StoreWins == refreshMode

src/EntityFramework/Core/Objects/ObjectContextOptions.cs

@@ -62,5 +62,7 @@ internal ObjectContextOptions()
         /// </remarks>
         /// <returns>true if the C# NullComparison behavior should be used; otherwise, false.</returns>
         public bool UseCSharpNullComparisonBehavior { get; set; }
+
+        public bool DisableFilterOverProjectionSimplificationForCustomFunctions { get; set; }
     }
 }

src/EntityFramework/Core/Query/PlanCompiler/CTreeGenerator.cs

@@ -370,7 +370,7 @@ private CTreeGenerator(Command itree, Node toConvert)
             // Create the query command tree using database null semantics because this class is only
             // used during the CodeGen phase which occurs after the NullSemantics phase of plan compiler.
             _queryTree = DbQueryCommandTree.FromValidExpression(
-                itree.MetadataWorkspace, DataSpace.SSpace, queryExpression, useDatabaseNullSemantics: true);
+                itree.MetadataWorkspace, DataSpace.SSpace, queryExpression, useDatabaseNullSemantics: true, disableFilterOverProjectionSimplificationForCustomFunctions: false);
         }
 
         #endregion

src/EntityFramework/Core/Query/PlanCompiler/FilterOpRules.cs

@@ -3,6 +3,7 @@
 namespace System.Data.Entity.Core.Query.PlanCompiler
 {
     using System.Collections.Generic;
+    using System.Data.Entity.Core.Common;
     using System.Data.Entity.Core.Query.InternalTrees;
     using System.Diagnostics.CodeAnalysis;
 
@@ -144,6 +145,12 @@ private static bool ProcessFilterOverProject(RuleProcessingContext context, Node
                 return false;
             }
 
+            // check to see that this predicate doesn't reference user-defined functions 
+            if (trc.IncludeCustomFunctionOp(predicateNode, varMap))
+            {
+                return false;
+            }
+
             //
             // Try to remap the predicate in terms of the definitions of the Vars
             //

src/EntityFramework/Core/Query/PlanCompiler/PlanCompiler.cs

@@ -181,6 +181,11 @@ internal ConstraintManager ConstraintManager
             }
         }
 
+        internal bool DisableFilterOverProjectionSimplificationForCustomFunctions
+        {
+            get { return m_ctree.DisableFilterOverProjectionSimplificationForCustomFunctions; }
+        }
+
 #if DEBUG
         /// <summary>
         /// Get the current plan compiler phase