public static Expression Visit( ParameterExpression param, IFilterDescriptor ex, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And) { Expression expression = Expression.Constant(true); Expression expr = null; if (ex is CompositeFilterDescriptor) { int counter = 0; var compositeFilter = ex as CompositeFilterDescriptor; var left = compositeFilter.FilterDescriptors.FirstOrDefault(); var right = compositeFilter.FilterDescriptors.LastOrDefault(); var expr1 = Visit(param, left); var expr2 = Visit(param, right); expr = CombineExpressions(expr1, expr2, compositeFilter.LogicalOperator); } else if (ex is FilterDescriptor) { var filter = ex as FilterDescriptor; expr = GetExpression(param, filter); } expression = CombineExpressions(expression, expr, connector); return(expression); }
/// <summary> /// Creates a WhereTerm which represents SQL NOT IN clause /// </summary> /// <param name="expr">Expression to be looked up</param> /// <param name="values"></param> /// <returns></returns> public static WhereTerm CreateNotIn(FilterCompositionLogicalOperator relationship, SqlExpression expr, SqlConstantCollection values) { WhereTerm term = CreateNotIn(expr, values); term._Relationship = relationship; return(term); }
public FilterDescriptorCollectionExpressionBuilder(ParameterExpression parameterExpression, IEnumerable <IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator) : base(parameterExpression) { this.filterDescriptors = filterDescriptors; this.logicalOperator = logicalOperator; }
/// <summary> /// Creates a WhereTerm which encapsulates SQL NOT EXISTS clause /// </summary> /// <param name="sql">Sub query for the NOT EXISTS clause</param> /// <returns></returns> public static WhereTerm CreateNotExists(FilterCompositionLogicalOperator relationship, string sql) { WhereTerm term = CreateNotExists(sql); term._Relationship = relationship; return(term); }
/// <summary> /// Creates a WhereTerm which returns TRUE if an expression is NOT NULL /// </summary> /// <param name="expr"></param> /// <returns></returns> public static WhereTerm CreateIsNotNull(FilterCompositionLogicalOperator relationship, SqlExpression expr) { WhereTerm term = CreateIsNotNull(expr); term._Relationship = relationship; return(term); }
/// <summary> /// Creates a WhereTerm which represents SQL NOT IN clause /// </summary> /// <param name="expr">Expression to be looked up</param> /// <param name="sql">Sub query</param> /// <returns></returns> public static WhereTerm CreateNotIn(FilterCompositionLogicalOperator relationship, SqlExpression expr, string sql) { WhereTerm term = CreateNotIn(expr, sql); term._Relationship = relationship; return(term); }
/// <summary> /// Creates a comparison WhereTerm. /// </summary> /// <param name="expr1">Expression on the left side of the operator</param> /// <param name="expr2">Expression on the right side of the operator</param> /// <param name="op">Conditional operator to be applied on the expressions</param> /// <returns>A new conditional WhereTerm</returns> /// <remarks> /// A comparison term compares two expression on the basis of their values. Expressions can be of any type but their results must be of comparible types. /// For instance, you can not compare a database OtherData of type 'date' and a static value of type 'int'. /// </remarks> /// <example> /// <code> /// ... /// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("J%"), CompareOperator.Like)); /// </code> /// </example> public static WhereTerm CreateCompare(FilterCompositionLogicalOperator relationship, SqlExpression expr1, SqlExpression expr2, FilterOperator op) { WhereTerm term = CreateCompare(expr1, expr2, op); term._Relationship = relationship; return(term); }
public FilterDescriptorCollectionExpressionBuilder( ParameterExpression parameterExpression, IEnumerable<IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator) : base(parameterExpression) { this.filterDescriptors = filterDescriptors; this.logicalOperator = logicalOperator; }
/// <summary> /// Creates a WhereTerm which checks weather a value is in a specifed range. /// </summary> /// <param name="expr">Expression which yeilds the value to be checked</param> /// <param name="lowBound">Expression which yeilds the low bound of the range</param> /// <param name="highBound">Expression which yeilds the high bound of the range</param> /// <returns>A new WhereTerm</returns> /// <remarks> /// CreateBetween only accepts expressions which yeild a 'Date' or 'Number' values. /// All expressions must be of compatible types. /// </remarks> public static WhereTerm CreateBetween(FilterCompositionLogicalOperator relationship, SqlExpression expr, SqlExpression lowBound, SqlExpression highBound) { WhereTerm term = CreateBetween(expr, lowBound, highBound); term._Relationship = relationship; return(term); }
private static Expression ComposeExpressions(Expression left, Expression right, FilterCompositionLogicalOperator logicalOperator) { switch (logicalOperator) { case FilterCompositionLogicalOperator.Or: return(Expression.OrElse(left, right)); default: return(Expression.AndAlso(left, right)); } }
/// <summary> /// Creates the filter expression. /// </summary> /// <param name="parameter">The parameter.</param> /// <param name="compositeFilterDescriptor">The composite filter descriptor.</param> /// <param name="columnNamesForFilterClean">The column names for filter clean.</param> /// <returns>The created expression</returns> private Expression CreateFilterExpression( ParameterExpression parameter, CompositeFilterDescriptor compositeFilterDescriptor, params string[] columnNamesForFilterClean) { FilterCompositionLogicalOperator logicalOperator = compositeFilterDescriptor.LogicalOperator; Expression parametreInit; switch (logicalOperator) { case FilterCompositionLogicalOperator.And: parametreInit = Expression.Constant(true); break; case FilterCompositionLogicalOperator.Or: parametreInit = Expression.Constant(false); break; default: throw new ArgumentOutOfRangeException(); } return(compositeFilterDescriptor.FilterDescriptors.Aggregate( parametreInit, (previous, descriptor) => { Expression newFilter = this.CreateFilterExpression(parameter, descriptor); if (previous == null) { return newFilter; } if (newFilter == null) { return Expression.AndAlso(previous, Expression.Constant(true)); } switch (logicalOperator) { case FilterCompositionLogicalOperator.And: return Expression.AndAlso(previous, newFilter); case FilterCompositionLogicalOperator.Or: return Expression.OrElse(previous, newFilter); default: throw new ArgumentOutOfRangeException(); } })); }
private static Expression ComposeExpressions(Expression left, Expression right, FilterCompositionLogicalOperator logicalOperator) { switch (logicalOperator) { case FilterCompositionLogicalOperator.Or: { return Expression.OrElse(left, right); } case FilterCompositionLogicalOperator.And: default: { return Expression.AndAlso(left, right); } } }
public override string ToString() { var result = ""; FilterCompositionLogicalOperator lastConector = FilterCompositionLogicalOperator.And; foreach (var statement in _statements) { if (!string.IsNullOrWhiteSpace(result)) { result += " " + lastConector + " "; } result += statement.ToString(); lastConector = statement.Connector; } return(result.Trim()); }
public FilterStatement(string propertyName, FilterOperator operation, TPropertyType value, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And) { PropertyName = propertyName; Connector = connector; Operation = operation; if (typeof(TPropertyType).IsArray) { if (operation != FilterOperator.Contains) { throw new ArgumentException("Only 'Operacao.Contains' supports arrays as parameters."); } var listType = typeof(List <>); var constructedListType = listType.MakeGenericType(typeof(TPropertyType).GetElementType()); Value = Activator.CreateInstance(constructedListType, value); } else { Value = value; } }
private static Expression CombineExpressions(Expression expr1, Expression expr2, FilterCompositionLogicalOperator connector) { return(connector == FilterCompositionLogicalOperator.And ? Expression.AndAlso(expr1, expr2) : Expression.OrElse(expr1, expr2)); }
/// <summary> /// Renders a relationship operator /// </summary> /// <param name="builder"></param> /// <param name="relationship"></param> protected virtual void RelationshipOperator(StringBuilder builder, FilterCompositionLogicalOperator relationship) { builder.AppendFormat(" {0} ", relationship.ToString().ToLower()); }
public static Expression <Func <T, bool> > GetExpression <T>(IList <IFilterDescriptor> filter, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And) where T : class { var param = Expression.Parameter(typeof(T), "x"); Expression expression = Expression.Constant(true); foreach (var statement in filter) { Expression expr = Visit(param, statement); expression = CombineExpressions(expression, expr, connector); } return(Expression.Lambda <Func <T, bool> >(expression, param)); }
public static void IterateIFilterDescriptors(List <Expression> equalExpressions, ParameterExpression item, IList <IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator = FilterCompositionLogicalOperator.And) { Expression expression = null; if (filterDescriptors.Any(x => x is CompositeFilterDescriptor) && filterDescriptors.Count > 1) { List <Expression> tempEqualExpressions = filterDescriptors.Select(x => (x as FilterDescriptor).GetEqualityExpression(item)).ToList(); Expression compositeExpression = null; if (tempEqualExpressions.Count == 2) { if (logicalOperator == FilterCompositionLogicalOperator.And) { compositeExpression = Expression.And(tempEqualExpressions[0], tempEqualExpressions[1]); } else if (logicalOperator == FilterCompositionLogicalOperator.Or) { compositeExpression = Expression.Or(tempEqualExpressions[0], tempEqualExpressions[1]); } } else if (tempEqualExpressions.Count > 2) { if (logicalOperator == FilterCompositionLogicalOperator.And) { compositeExpression = Expression.And(tempEqualExpressions[0], tempEqualExpressions[1]); } else if (logicalOperator == FilterCompositionLogicalOperator.Or) { compositeExpression = Expression.Or(tempEqualExpressions[0], tempEqualExpressions[1]); } for (int i = 2; i < tempEqualExpressions.Count; i++) { if (logicalOperator == FilterCompositionLogicalOperator.And) { compositeExpression = Expression.And(compositeExpression, tempEqualExpressions[i]); } else if (logicalOperator == FilterCompositionLogicalOperator.Or) { compositeExpression = Expression.Or(compositeExpression, tempEqualExpressions[i]); } } } if (compositeExpression != null) { equalExpressions.Add(compositeExpression); } } foreach (IFilterDescriptor iFilterDescriptor in filterDescriptors) { if (iFilterDescriptor is FilterDescriptor) { expression = (iFilterDescriptor as FilterDescriptor).GetEqualityExpression(item); if (expression != null) { equalExpressions.Add(expression); } } else if (iFilterDescriptor is CompositeFilterDescriptor) { IterateIFilterDescriptors(equalExpressions, item, (iFilterDescriptor as CompositeFilterDescriptor).FilterDescriptors, (iFilterDescriptor as CompositeFilterDescriptor).LogicalOperator); } } }
public static string GetExperssion <T>(this IQueryable <T> items, IList <IFilterDescriptor> filter, FilterCompositionLogicalOperator opr = FilterCompositionLogicalOperator.And) { string q = ""; if (filter.Is(typeof(FilterDescriptor))) { var list = filter.Cast <FilterDescriptor>(); foreach (var i in list) { q += i.Operator.getOerationToString().Replace("y", i.Member).Replace("x", i.Value.ToString()) + " " + (list.Last().Value == i.Value ? " " : " " + opr.ToString() + " "); } } else if (filter.Is(typeof(CompositeFilterDescriptor))) { foreach (var i in filter.Cast <IFilterDescriptor>()) { if (i.GetType() == typeof(CompositeFilterDescriptor)) { q += "(" + items.GetExperssion(((CompositeFilterDescriptor)i).FilterDescriptors, ((CompositeFilterDescriptor)i).LogicalOperator) + " ) " + (filter.Cast <IFilterDescriptor>().Last() == ((CompositeFilterDescriptor)i) ? " " : " And "); } else if (i.GetType() == typeof(FilterDescriptor)) { q += ((FilterDescriptor)i).Operator.getOerationToString().Replace("y", ((FilterDescriptor)i).Member).Replace("x", ((FilterDescriptor)i).Value.ToString()) + " " + (filter.Cast <IFilterDescriptor>().Last() == ((FilterDescriptor)i) ? " " : " " + opr.ToString() + " "); } } } return(q); }
protected virtual Expression VisitFilterList(IList<IFilterDescriptor> filters, FilterCompositionLogicalOperator op) { if (filters == null || filters.Count == 0) return Expression.Constant(true); var expr = Visit(filters.First()); foreach (var filter in filters.Skip(1)) { var filterExpr = Visit(filter); switch (op) { case FilterCompositionLogicalOperator.And: expr = Expression.AndAlso(expr, filterExpr); break; case FilterCompositionLogicalOperator.Or: expr = Expression.OrElse(expr, filterExpr); break; } } return expr; }
public void OnFilterChanged(string columnName, IEnumerable<object> distinctFilterValues, OperatorValueFilterDescriptorBase filter1, OperatorValueFilterDescriptorBase filter2, FilterCompositionLogicalOperator logicalOperator) { Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => { UserFunctions.SaveUserDefaultFilterSettingsAsync("Groups", columnName, distinctFilterValues, filter1, filter2, logicalOperator); })); }
public static string LogicalOperatorToString(FilterCompositionLogicalOperator op) { return(op == FilterCompositionLogicalOperator.And ? "AND" : "OR"); }
public IFilterStatementConnection <TClass> By <TPropertyType>(string propertyName, FilterOperator operation, TPropertyType value, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And) { IFilterStatement statement = null; statement = new FilterStatement <TPropertyType>(propertyName, operation, value, connector); _statements.Add(statement); return(new FilterStatementConnection <TClass>(this, statement)); }
/// <summary> /// Filters a sequence of values based on a collection of <see cref="IFilterDescriptor"/>. /// </summary> /// <param name="source">The source.</param> /// <param name="filterDescriptors">The filter descriptors.</param> /// <param name="logicalOperator">And or Or?.</param> /// <returns> /// An <see cref="IQueryable" /> that contains elements from the input sequence /// that satisfy the conditions specified by each filter descriptor in <paramref name="filterDescriptors" />. /// </returns> public static IQueryable Where(this IQueryable source, IEnumerable <IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator = FilterCompositionLogicalOperator.And) { if (filterDescriptors.Any()) { var parameterExpression = Expression.Parameter(source.ElementType, "item"); var expressionBuilder = new FilterDescriptorCollectionExpressionBuilder(parameterExpression, filterDescriptors, logicalOperator);//Modified By Moravej expressionBuilder.Options.LiftMemberAccessToNull = source.Provider.IsLinqToObjectsProvider(); var predicate = expressionBuilder.CreateFilterExpression(); return(source.Where(predicate)); } return(source); }
/// <summary> /// Creates a new WhereClause /// </summary> /// <param name="relationship">Relationship between all the terms and sub clauses of this clause</param> /// <example> /// <code> /// SelectQuery query = new SelectQuery(); /// ... /// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("John"), CompareOperator.Equal)); /// WhereClause group = new WhereClause(WhereClauseRelationship.Or); /// group.Terms.Add(WhereTerm.CreateBetween(SqlExpression.Field("price", tProducts), SqlExpression.Number(1), SqlExpression.Number(10))); /// group.Terms.Add(WhereTerm.CreateIn(SqlExpression.Field("name", tProducts), new string[] {"Nail", "Hamer", "Skrewdriver"})); /// query.WherePhrase.SubClauses.Add(group); /// </code> /// </example> public WhereClause(FilterCompositionLogicalOperator relationship) { this.relationship = relationship; }