public static IQueryProvider<TSource> HasWhere<TSource>(this IQueryProvider<TSource> query, object target, Expression<Func<TSource, bool>> whExpression) { if (target != null) { query = query.Where(whExpression); } return query; }
private static IQueryProvider <T> Contains <T>( this IQueryProvider <T> query, string property, IEnumerable values) { if (values == null || !values.Cast <object>().Any()) { return(query); } var parameterExpression = Expression.Parameter(typeof(T), "x"); var propertyExpression = (Expression)Expression.Property(parameterExpression, property); var constantExpression = Expression.Constant(values); var propertyExpressionIsNullable = propertyExpression.Type.IsGenericType && propertyExpression.Type.GetGenericTypeDefinition() == typeof(Nullable <>) && constantExpression.Type.GetElementType() != propertyExpression.Type; if (propertyExpressionIsNullable) { propertyExpression = Expression.Property(propertyExpression, "Value"); } Expression callExpression = Expression.Call( typeof(Enumerable), "Contains", new[] { propertyExpression.Type }, constantExpression, propertyExpression); if (propertyExpressionIsNullable) { var nullablePropertyExpression = Expression.Property(parameterExpression, property); var notEqual = Expression.NotEqual(nullablePropertyExpression, Expression.Constant(null, nullablePropertyExpression.Type)); callExpression = Expression.AndAlso(notEqual, callExpression); } var lambda = Expression.Lambda <Func <T, bool> >(callExpression, parameterExpression); return(query.Where(lambda)); }
private static IQueryProvider <T> Where <T>( this IQueryProvider <T> query, string property, Type valueType, object value) { var parameterExpression = Expression.Parameter(typeof(T), "x"); var propertyExpression = Expression.Property(parameterExpression, property); var method = typeof(ExpressionHelper).GetMethod("WrappedConstant"); var genericMethod = method.MakeGenericMethod(valueType); var constantExpression = (MemberExpression)genericMethod.Invoke(null, new[] { value }); var comparandExpression = Nullable.GetUnderlyingType(propertyExpression.Type) != null ? Expression.Convert(constantExpression, propertyExpression.Type) : (Expression)constantExpression; var equalExpression = Expression.Equal(propertyExpression, comparandExpression); var lambdaExpression = Expression.Lambda <Func <T, bool> >(equalExpression, parameterExpression); return(query.Where(lambdaExpression)); }
private IQueryProvider <T> FilterData <T>(IQueryProvider <T> objectList, string search, string sortBy, string sortOrder, bool searchStartOnly, bool caseSensitive) { string query = ""; if (!objectList.Any()) { return(objectList); } //Dynamic Search if (!search.IsNullOrWhiteSpace()) { search = search.ToLower(); query = SearchQueryGenerator(objectList, search, searchStartOnly, caseSensitive); objectList = objectList.Where(query); } //Dynamic Order By if (!sortBy.IsNullOrWhiteSpace() && !sortOrder.IsNullOrWhiteSpace()) { var isAscending = sortOrder.ToLower() == "asc" ? true : false; objectList = objectList.OrderByField(sortBy, isAscending); } return(objectList); }
public static IQueryProvider <RecursionUser> IncludeSecurity(this IQueryProvider <RecursionUser> query) { return(query.Where(x => new Sql(string.Format("exists (select 1 from {1} where Id = {0}.Id)", x.DatabaseType.EscapeTableName(x.GetAliasFor(z => z.CreatedBy)), x.GetPocoDataFor <RecursionUser>().TableInfo.TableName)))); }
public static HashSet <TReturn> ToHashSet <TReturn>(this IQueryProvider <TReturn> enumerable, Expression <Func <TReturn, bool> > expression) { return(enumerable.Where(expression).ToEnumerable().ToHashSet()); }
public virtual IFluentQueryable <T> Where(System.Linq.Expressions.Expression <Func <T, bool> > predicate) { _queryProvider = _queryProvider.Where(predicate); return(this); }
private static IQueryProvider <T> Range <T, TRange>( this IQueryProvider <T> query, string property, IRange <TRange> range) where TRange : struct { var parameterExpression = Expression.Parameter(typeof(T), "x"); var propertyExpression = Expression.Property(parameterExpression, property); Expression minConstantExpression = null; if (range.MinValue.HasValue) { var minValueExpression = Expression.Constant(range.MinValue); minConstantExpression = minValueExpression.Type != propertyExpression.Type ? Expression.Convert(minValueExpression, propertyExpression.Type) : (Expression)minValueExpression; } BinaryExpression minGreaterExpression = null; if (minConstantExpression != null) { minGreaterExpression = range.IsMinInclusive ? Expression.GreaterThanOrEqual(propertyExpression, minConstantExpression) : Expression.GreaterThan(propertyExpression, minConstantExpression); } Expression maxConstantExpression = null; if (range.MaxValue.HasValue) { var maxValueExpression = Expression.Constant(range.MaxValue); maxConstantExpression = maxValueExpression.Type != propertyExpression.Type ? Expression.Convert(maxValueExpression, propertyExpression.Type) : (Expression)maxValueExpression; } BinaryExpression maxLessExpression = null; if (maxConstantExpression != null) { maxLessExpression = range.IsMaxInclusive ? Expression.LessThanOrEqual(propertyExpression, maxConstantExpression) : Expression.LessThan(propertyExpression, maxConstantExpression); } Expression logicExpression; if (minGreaterExpression != null && maxLessExpression != null) { logicExpression = Expression.AndAlso(minGreaterExpression, maxLessExpression); } else if (minGreaterExpression != null) { logicExpression = minGreaterExpression; } else { logicExpression = maxLessExpression; } var lambdaExpression = Expression.Lambda <Func <T, bool> >(logicExpression, parameterExpression); return(query.Where(lambdaExpression)); }