public override SqlFragment Visit(DbFilterExpression expression)
 {
     SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, 
         expression.Input.VariableName, expression.Input.VariableType);
     select = WrapIfNotCompatible(select, expression.ExpressionKind);
     select.Where = expression.Predicate.Accept(this);
     return select;
 }

        public override Expression Visit(DbFilterExpression expression)
        {
            Expression source = this.Visit(expression.Input.Expression);
            Type elementType = TypeHelper.GetElementType(source.Type);

            ParameterExpression param = Expression.Parameter(elementType, expression.Input.VariableName);

            using (this.CreateVariable(param, expression.Input.VariableName))
            {
                Expression predicate = this.Visit(expression.Predicate);
                LambdaExpression predicateLambda = Expression.Lambda(predicate, param);

                return queryMethodExpressionBuilder.Where(source, predicateLambda);
            }
        }

 /// <summary>
 /// This method called before the one below it when a filtering is already exists in the query (e.g. fetch an entity by id)
 /// so we apply the dynamic filtering at this level
 /// </summary>
 public override DbExpression Visit(DbFilterExpression expression)
 {
     var column = TenantAwareAttribute.GetTenantColumnName(expression.Input.Variable.ResultType.EdmType);
     if (!_injectedDynamicFilter && !string.IsNullOrEmpty(column))
     {
         var newFilterExpression = BuildFilterExpression(expression.Input, expression.Predicate, column);
         if (newFilterExpression != null)
         {
             //  If not null, a new DbFilterExpression has been created with our dynamic filters.
             return base.Visit(newFilterExpression);
         }
         
     }
     return base.Visit(expression);
 }

        public override DbExpression Visit(DbFilterExpression expression)
        {
            //  If the query contains it's own filter condition (in a .Where() for example), this will be called
            //  before Visit(DbScanExpression).  And it will contain the Predicate specified in that filter.
            //  Need to inject our dynamic filters here and then 'and' the Predicate.  This is necessary so that
            //  the expressions are properly ()'d.
            //  It also allows us to attach our dynamic filter into the same DbExpressionBinding so it will avoid
            //  creating a new sub-query in MS SQL Server.

            string entityName = expression.Input.Variable.ResultType.EdmType.Name;
            var containers = _ObjectContext.MetadataWorkspace.GetItems<EntityContainer>(DataSpace.SSpace).First();
            var filterList = FindFiltersForEntitySet(expression.Input.Variable.ResultType.EdmType.MetadataProperties, containers);

            var newFilterExpression = BuildFilterExpressionWithDynamicFilters(entityName, filterList, expression.Input, expression.Predicate);
            if (newFilterExpression != null)
            {
                //  If not null, a new DbFilterExpression has been created with our dynamic filters.
                return newFilterExpression;
            }

            return base.Visit(expression);
        }

        public override DbExpression Visit(DbFilterExpression expression)
        {
            //  If the query contains it's own filter condition (in a .Where() for example), this will be called
            //  before Visit(DbScanExpression).  And it will contain the Predicate specified in that filter.
            //  Need to inject our dynamic filters here and then 'and' the Predicate.  This is necessary so that
            //  the expressions are properly ()'d.
            //  It also allows us to attach our dynamic filter into the same DbExpressionBinding so it will avoid
            //  creating a new sub-query in MS SQL Server.

            string entityName = expression.Input.Variable.ResultType.EdmType.Name;
            var filterList = expression.Input.Variable.ResultType.EdmType.MetadataProperties
                                .Where(mp => mp.Name.Contains("customannotation:" + DynamicFilterConstants.AttributeNamePrefix))
                                .Select(m => m.Value as DynamicFilterDefinition);

            var newFilterExpression = BuildFilterExpressionWithDynamicFilters(entityName, filterList, expression.Input, expression.Predicate);
            if (newFilterExpression != null)
            {
                //  If not null, a new DbFilterExpression has been created with our dynamic filters.
                return newFilterExpression;
            }

            return base.Visit(expression);
        }

            // For Distinct, Limit, OfType there is no need to override the base visitor behavior.

            public override DbExpression Visit(DbFilterExpression expression)
            {
                Check.NotNull(expression, "expression");

                // Only consider the Filter input
                var found = Find(expression.Input.Expression);
                if (!ReferenceEquals(found, expression.Input.Expression))
                {
                    return found.BindAs(expression.Input.VariableName).Filter(expression.Predicate);
                }
                else
                {
                    return expression;
                }
            }

 public override void Visit(DbFilterExpression e)
 {
     VisitExprKind(e.ExpressionKind);
     _key.Append('(');
     VisitBinding(e.Input);
     _key.Append('(');
     e.Predicate.Accept(this);
     _key.Append("))");
 }

 internal override DbExpression Filter(DbFilterExpression filter)
 {
     return filter;
 }

 public override void Visit(DbFilterExpression e)
 {
     Begin(e);
     Dump(e.Input, "Input");
     Dump(e.Predicate, "Predicate");
     End(e);
 }

 public override void Visit(DbFilterExpression expression) { }

 public override DbExpression Visit(DbFilterExpression expression)
 {
     System.Diagnostics.Debug.Print("Visit(DbFilterExpression): {0}", expression);
     return base.Visit(expression);
 }

        /// <summary>
        ///     Visitor pattern method for <see cref="DbFilterExpression" />.
        /// </summary>
        /// <param name="expression"> The DbFilterExpression that is being visited. </param>
        /// <exception cref="ArgumentNullException">
        ///     <paramref name="expression" />
        ///     is null
        /// </exception>
        public override void Visit(DbFilterExpression expression)
        {
            Check.NotNull(expression, "expression");

            VisitExpressionBindingPre(expression.Input);
            VisitExpression(expression.Predicate);
            VisitExpressionBindingPost(expression.Input);
        }

        /// <summary>
        /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbFilterExpression"/>.
        /// </summary>
        /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbFilterExpression"/> that is visited.</param>
        public override void Visit(DbFilterExpression expression)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            expression.Input.Expression.Accept(this);
            expression.Predicate.Accept(this);
        }

 public override void Visit(DbFilterExpression expression)
 {
     Contract.Requires(expression != null);
 }

 // For Distinct, Limit, OfType there is no need to override the base visitor behavior.
 
 public override DbExpression Visit(DbFilterExpression expression)
 {
     // Only consider the Filter input
     DbExpression found = Find(expression.Input.Expression);
     if(!object.ReferenceEquals(found, expression.Input.Expression))
     {
         return found.BindAs(expression.Input.VariableName).Filter(expression.Predicate);
     }
     else
     {
         return expression;
     }
 }

                protected DbFilterExpression ComposeFilter(DbExpression input, DbProjectExpression first, DbFilterExpression second)
                {
                    // source.Project(first).Filter(second) -> source.Filter(e => second(first(e)))

                    // create lambda expression representing the filter (e => second(e))
                    DbLambda secondLambda = DbExpressionBuilder.Lambda(second.Predicate, second.Input.Variable);

                    // invoke lambda with variable from the project
                    DbFilterExpression composed = first.Input.Filter(secondLambda.Invoke(first.Projection));

                    return RebindFilter(input, composed);
                }

		public override void Visit(DbFilterExpression expression)
		{
			throw new NotSupportedException("Visit(\"FilterExpression\") is not supported.");
		}

 protected DbFilterExpression RebindFilter(DbExpression input, DbFilterExpression filter)
 {
     DbExpressionBinding inputBinding = input.BindAs(filter.Input.VariableName);
     return inputBinding.Filter(filter.Predicate);
 }

        internal static bool TryMatchDiscriminatorPredicate(DbFilterExpression filter, Action<DbComparisonExpression, object> onMatchedComparison)
        {
            EdmProperty discriminatorProperty = null;

            // check each assignment in predicate
            foreach (var term in FlattenOr(filter.Predicate))
            {
                DbPropertyExpression currentDiscriminator;
                object discriminatorValue;
                if (!TryMatchPropertyEqualsValue(term, filter.Input.VariableName, out currentDiscriminator, out discriminatorValue))
                {
                    return false;
                }

                // must be the same discriminator in every case
                if (null == discriminatorProperty)
                {
                    discriminatorProperty = (EdmProperty)currentDiscriminator.Property;
                }
                else if (discriminatorProperty != currentDiscriminator.Property)
                {
                    return false;
                }

                onMatchedComparison((DbComparisonExpression)term, discriminatorValue);
            }

            return true;
        }

 public override void Visit(DbFilterExpression expression)
 {
   if (expression == null) throw new ArgumentException("expression");
   VisitExpressionBindingPre(expression.Input);
   VisitExpression(expression.Predicate);
   VisitExpressionBindingPost(expression.Input);
 }