public override void Visit(DbFilterExpression e)
{
Begin(e);
Dump(e.Input, "Input");
Dump(e.Predicate, "Predicate");
End(e);
}
internal static bool TryMatchDiscriminatorPredicate(
DbFilterExpression filter,
Action <DbComparisonExpression, object> onMatchedComparison)
{
EdmProperty edmProperty = (EdmProperty)null;
foreach (DbExpression expression in ViewSimplifier.FlattenOr(filter.Predicate))
{
DbPropertyExpression property;
object obj;
if (!ViewSimplifier.TryMatchPropertyEqualsValue(expression, filter.Input.VariableName, out property, out obj))
{
return(false);
}
if (edmProperty == null)
{
edmProperty = (EdmProperty)property.Property;
}
else if (edmProperty != property.Property)
{
return(false);
}
onMatchedComparison((DbComparisonExpression)expression, obj);
}
return(true);
}
private RowType GetRowTypeFromCommandTree(DbCommandTree tree)
{
DbQueryCommandTree commandTree = tree as DbQueryCommandTree;
if (commandTree == null)
{
return(null);
}
DbProjectExpression projectExpression = commandTree.Query as DbProjectExpression;
// Try filter then
if (projectExpression == null)
{
DbFilterExpression filterExpression = commandTree.Query as DbFilterExpression;
if (filterExpression != null && filterExpression.Input != null)
{
projectExpression = filterExpression.Input.Expression as DbProjectExpression;
}
}
if (projectExpression != null)
{
var newExpression = projectExpression.Projection;
if (newExpression != null)
{
return(newExpression.ResultType.EdmType as RowType);
}
}
return(null);
}
public override bool Visit(DbFilterExpression expression)
{
bool flag1 = VisitExpressionBinding(expression.Input);
bool flag2 = VisitExpression(expression.Predicate);
return(flag1 || flag2);
}
public override void Visit(DbFilterExpression expression)
{
EntityUtils.CheckArgumentNull <DbFilterExpression>(expression, nameof(expression));
this.VisitExpressionBindingPre(expression.Input);
this.VisitExpression(expression.Predicate);
this.VisitExpressionBindingPost(expression.Input);
}
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;
if (!_InjectedDynamicFilters.Contains(entityName))
{
var filterList = expression.Input.Variable.ResultType.EdmType.MetadataProperties
.Where(mp => mp.Name.Contains("customannotation:" + DynamicFilterConstants.ATTRIBUTE_NAME_PREFIX))
.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(base.Visit(newFilterExpression));
}
}
return(base.Visit(expression));
}
/// <summary>
/// Walks the structure
/// </summary>
/// <param name="expression">The DbFilterExpression that is being visited.</param>
/// <returns></returns>
public override bool Visit(DbFilterExpression expression)
{
bool inputNeedsRewrite = VisitExpressionBinding(expression.Input);
bool predicateNeedsRewrite = VisitExpression(expression.Predicate);
return(inputNeedsRewrite || predicateNeedsRewrite);
}
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)
{
Write(expression);
_depth++;
Write("Input", expression.Input);
Write("Predicate", expression.Predicate);
_depth--;
}
public override TreeNode Visit(DbFilterExpression e)
{
TreeNode retInfo = NodeFromExpression(e);
retInfo.Children.Add(this.VisitBinding("Input", e.Input));
retInfo.Children.Add(this.Visit("Predicate", e.Predicate));
return(retInfo);
}
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 LegacyCommandTrees.DbExpression Visit(DbFilterExpression expression)
{
Debug.Assert(expression != null, "expression != null");
return(expression.Input.Expression.Accept(this)
.BindAs(expression.Input.VariableName)
.Filter(expression.Predicate.Accept(this)));
}
public override void Visit(DbFilterExpression e)
{
Check.NotNull <DbFilterExpression>(e, nameof(e));
this.Begin((DbExpression)e);
this.Dump(e.Input, "Input");
this.Dump(e.Predicate, "Predicate");
this.End((DbExpression)e);
}
public async Task CanRetrievePagedResultsOnFilteredQuery()
{
var result = await _dbContext.Vessels
.Where(DbFilterExpression.LikeOneOf <Vessel>(nameof(Vessel.Name), new[] { "Nau%", "%stat%" }))
.ToPagedResultAsync(1, 2);
Assert.Equal(1, result.PageNumber);
Assert.Equal(2, result.TotalNumberOfItems);
}
/// <summary>
/// Walks the structure
/// </summary>
/// <param name="expression"> The DbFilterExpression that is being visited. </param>
/// <returns> </returns>
public override bool Visit(DbFilterExpression expression)
{
Check.NotNull(expression, "expression");
var inputNeedsRewrite = VisitExpressionBinding(expression.Input);
var predicateNeedsRewrite = VisitExpression(expression.Predicate);
return(inputNeedsRewrite || predicateNeedsRewrite);
}
/// <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)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
Check.NotNull(expression, "expression");
VisitExpressionBindingPre(expression.Input);
VisitExpression(expression.Predicate);
VisitExpressionBindingPost(expression.Input);
}
internal override DbExpression Filter(DbFilterExpression filter)
{
// source.Sort(o).Project(p).Filter(f) -> source.Filter(e => f(p(e))).Sort(o).Project(p)
return(RebindProject(
RebindSort(
ComposeFilter(_source, _project, filter),
_sort),
_project));
}
public override TreeNode Visit(DbFilterExpression e)
{
Check.NotNull <DbFilterExpression>(e, nameof(e));
TreeNode treeNode = ExpressionPrinter.PrinterVisitor.NodeFromExpression((DbExpression)e);
treeNode.Children.Add(this.VisitBinding("Input", e.Input));
treeNode.Children.Add(this.Visit("Predicate", e.Predicate));
return(treeNode);
}
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)
{
// source.Skip(k, o).Project(p).Filter(f) -> source.Skip(k, o).Filter(e => f(p(e))).Sort(o).Project(p)
return(RebindProject(
ApplySkipOrderToSort(
ComposeFilter(_skip, _project, filter),
_skip),
_project));
}
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);
}
/// <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 e)
{
Check.NotNull <DbFilterExpression>(e, nameof(e));
this.VisitExprKind(e.ExpressionKind);
this._key.Append('(');
this.VisitBinding(e.Input);
this._key.Append('(');
e.Predicate.Accept((DbExpressionVisitor)this);
this._key.Append("))");
}
public override void Visit(DbFilterExpression expression)
{
if (expression == null)
{
throw new ArgumentException("expression");
}
VisitExpressionBindingPre(expression.Input);
VisitExpression(expression.Predicate);
VisitExpressionBindingPost(expression.Input);
}
public override TreeNode Visit(DbFilterExpression e)
{
Check.NotNull(e, "e");
var retInfo = NodeFromExpression(e);
retInfo.Children.Add(VisitBinding("Input", e.Input));
retInfo.Children.Add(Visit("Predicate", e.Predicate));
return(retInfo);
}
/// <summary>
/// Constructs a new pattern that is matched iff the argument expression is a <see cref="DbFilterExpression"/> with input and predicate subexpressions that match the corresponding <paramref name="inputPattern"/> and <paramref name="predicatePattern"/> patterns
/// </summary>
internal static Func <DbExpression, bool> MatchFilter(Func <DbExpression, bool> inputPattern, Func <DbExpression, bool> predicatePattern)
{
return(e => { if (e.ExpressionKind != DbExpressionKind.Filter)
{
return false;
}
else
{
DbFilterExpression filterEx = (DbFilterExpression)e; return inputPattern(filterEx.Input.Expression) && predicatePattern(filterEx.Predicate);
} });
}
public override DbExpression Visit(DbFilterExpression expression)
{
Check.NotNull <DbFilterExpression>(expression, nameof(expression));
DbExpression input = this.Find(expression.Input.Expression);
if (!object.ReferenceEquals((object)input, (object)expression.Input.Expression))
{
return((DbExpression)input.BindAs(expression.Input.VariableName).Filter(expression.Predicate));
}
return((DbExpression)expression);
}
public override bool Visit(DbFilterExpression expression)
{
Check.NotNull <DbFilterExpression>(expression, nameof(expression));
bool flag1 = this.VisitExpressionBinding(expression.Input);
bool flag2 = this.VisitExpression(expression.Predicate);
if (!flag1)
{
return(flag2);
}
return(true);
}
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));
}
/// <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 = TenantAttribute.GetTenantColumnName(expression.Input.Variable.ResultType.EdmType);
if (_injectedDynamicFilter || string.IsNullOrEmpty(column))
{
return(base.Visit(expression));
}
var newFilterExpression = BuildFilterExpression(expression.Input, expression.Predicate, column);
return(base.Visit(newFilterExpression ?? expression));
}
// 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);
}
}
/// <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 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);
}
}
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);
}
internal override DbExpression Filter(DbFilterExpression filter)
{
// source.Sort(o).Filter(f) -> source.Filter(f).Sort(o)
return RebindSort(RebindFilter(_source, filter), _sort);
}
public override void Visit(DbFilterExpression expression)
{
Contract.Requires(expression != null);
}
public override void Visit(DbFilterExpression e)
{
VisitExprKind(e.ExpressionKind);
_key.Append('(');
VisitBinding(e.Input);
_key.Append('(');
e.Predicate.Accept(this);
_key.Append("))");
}
public override void Visit(DbFilterExpression expression)
{
throw new NotSupportedException("Visit(\"FilterExpression\") is not supported.");
}
/// <summary> /// Visitor pattern method for DbFilterExpression. /// </summary> /// <param name="expression"> The DbFilterExpression that is being visited. </param> public abstract void Visit(DbFilterExpression expression);
public override void Visit(DbFilterExpression e)
{
Begin(e);
Dump(e.Input, "Input");
Dump(e.Predicate, "Predicate");
End(e);
}
/// <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 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)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
Check.NotNull(expression, "expression");
VisitExpressionBindingPre(expression.Input);
VisitExpression(expression.Predicate);
VisitExpressionBindingPost(expression.Input);
}
// 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 RebindFilter(DbExpression input, DbFilterExpression filter)
{
DbExpressionBinding inputBinding = input.BindAs(filter.Input.VariableName);
return inputBinding.Filter(filter.Predicate);
}
/// <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);
}
internal override DbExpression Filter(DbFilterExpression filter)
{
// source.Sort(o).Limit(k).Filter(f) -> source.Sort(o).Limit(k).Filter(f).Sort(o)
return RebindSort(filter, _sort);
}
public override void Visit(DbFilterExpression expression) { }
internal override DbExpression Filter(DbFilterExpression filter)
{
// source.Sort(o).Project(p).Filter(f) -> source.Filter(e => f(p(e))).Sort(o).Project(p)
return RebindProject(
RebindSort(
ComposeFilter(_source, _project, filter),
_sort),
_project);
}
internal override DbExpression Filter(DbFilterExpression filter)
{
// source.Skip(k, o).Project(p).Filter(f) -> source.Skip(k, o).Filter(e => f(p(e))).Sort(o).Project(p)
return RebindProject(
ApplySkipOrderToSort(
ComposeFilter(_skip, _project, filter),
_skip),
_project);
}
internal override DbExpression Filter(DbFilterExpression filter)
{
// source.Skip(k, o).Filter(f) -> source.Skip(k, o).Filter(f).Sort(o)
return ApplySkipOrderToSort(filter, _skip);
}
internal override DbExpression Filter(DbFilterExpression filter)
{
return filter;
}
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;
}
// 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 expression)
{
if (expression == null) throw new ArgumentException("expression");
VisitExpressionBindingPre(expression.Input);
VisitExpression(expression.Predicate);
VisitExpressionBindingPost(expression.Input);
}
internal abstract DbExpression Filter(DbFilterExpression filter);
/// <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)
{
VisitExpressionBindingPre(expression.Input);
VisitExpression(expression.Predicate);
VisitExpressionBindingPost(expression.Input);
}
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);
}
