public static DQueryable <T> SelectMany <T>(this DQueryable <T> query, CollectionElementToken cet) { Type elementType = cet.Parent.Type.ElementType(); var collectionSelector = Expression.Lambda(typeof(Func <,>).MakeGenericType(typeof(object), typeof(IEnumerable <>).MakeGenericType(elementType)), Expression.Call(miDefaultIfEmptyE.MakeGenericMethod(elementType), cet.Parent.BuildExpression(query.Context)), query.Context.Parameter); var elementParameter = cet.CreateParameter(); var properties = query.Context.Replacemens.Values.And(cet.CreateExpression(elementParameter)); var ctor = TupleReflection.TupleChainConstructor(properties); var resultSelector = Expression.Lambda(Expression.Convert(ctor, typeof(object)), query.Context.Parameter, elementParameter); var resultQuery = query.Query.Provider.CreateQuery <object>(Expression.Call(null, miSelectMany.MakeGenericMethod(typeof(object), elementType, typeof(object)), new Expression[] { query.Query.Expression, Expression.Quote(collectionSelector), Expression.Quote(resultSelector) })); var parameter = Expression.Parameter(typeof(object)); var newReplacements = query.Context.Replacemens.Keys.And(cet).Select((a, i) => new { Token = a, Expression = TupleReflection.TupleChainProperty(Expression.Convert(parameter, ctor.Type), i) }).ToDictionary(a => a.Token, a => a.Expression); return(new DQueryable <T>(resultQuery, new BuildExpressionContext(ctor.Type, parameter, newReplacements))); }
private DQueryable <T> GetDQueryable(QueryRequest request) { if (!request.GroupResults) { request.Columns.Insert(0, new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName)); return(Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications()) .Where(request.Filters) .OrderBy(request.Orders) .Select(request.Columns)); } else { var simpleFilters = request.Filters.Where(f => !f.IsAggregate()).ToList(); var aggregateFilters = request.Filters.Where(f => f.IsAggregate()).ToList(); var keys = request.Columns.Select(t => t.Token).Where(t => !(t is AggregateToken)).ToHashSet(); var allAggregates = request.AllTokens().OfType <AggregateToken>().ToHashSet(); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications()) .Where(simpleFilters) .GroupBy(keys, allAggregates) .Where(aggregateFilters) .OrderBy(request.Orders); return(query); } }
public static DQueryable <T> Select <T>(this DQueryable <T> query, HashSet <QueryToken> columns) { BuildExpressionContext newContext; var selector = TupleConstructor(query.Context, columns, out newContext); return(new DQueryable <T>(query.Query.Select(selector), newContext)); }
public override ResultTable ExecuteQueryGroup(QueryRequest request) { DQueryable <T> query = GetDQueryable(request); var result = query.TryPaginate(request.Pagination); return(result.ToResultTable(request)); }
public override async Task <ResultTable> ExecuteQueryGroupAsync(QueryRequest request, CancellationToken token) { DQueryable <T> query = GetDQueryable(request); var result = await query.TryPaginateAsync(request.Pagination, token); return(result.ToResultTable(request)); }
public static DQueryable <T> TryTake <T>(this DQueryable <T> query, int?num) { if (num.HasValue) { return(new DQueryable <T>(query.Query.Take(num.Value), query.Context)); } return(query); }
public static DQueryable <T> SelectMany <T>(this DQueryable <T> query, List <CollectionElementToken> elementTokens) { foreach (var cet in elementTokens) { query = query.SelectMany(cet); } return(query); }
public static DEnumerableCount <T> AllQueryOperations <T>(this DQueryable <T> query, QueryRequest request) { return(query .SelectMany(request.Multiplications) .Where(request.Filters) .OrderBy(request.Orders) .Select(request.Columns) .TryPaginate(request.Pagination)); }
public override async Task<ResultTable> ExecuteQueryGroupAsync(QueryGroupRequest request, CancellationToken token) { DQueryable<T> query = GetDQueryable(request); var values = await query.Query.ToArrayAsync(token); var cols = request.Columns .Select(column => (column, Expression.Lambda(column.Token.BuildExpression(query.Context), query.Context.Parameter))).ToList(); return values.ToResultTable(cols, values.Length, new Pagination.All()); }
public static DQueryable <T> Where <T>(this DQueryable <T> query, List <Filter> filters) { Expression <Func <object, bool> > where = GetWhereExpression(query.Context, filters); if (where == null) { return(query); } return(new DQueryable <T>(query.Query.Where(where), query.Context)); }
public override async Task <ResultTable> ExecuteQueryAsync(QueryRequest request, CancellationToken token) { using (SystemTime.Override(request.SystemTime)) { DQueryable <T> query = GetDQueryable(request); var result = await query.TryPaginateAsync(request.Pagination, request.SystemTime, token); return(result.ToResultTable(request)); } }
public override ResultTable ExecuteQuery(QueryRequest request) { using (SystemTime.Override(request.SystemTime)) { DQueryable <T> query = GetDQueryable(request); var result = query.TryPaginate(request.Pagination); return(result.ToResultTable(request)); } }
public override ResultTable ExecuteQueryGroup(QueryGroupRequest request) { DQueryable<T> query = GetDQueryable(request); var values = query.Query.ToArray(); var cols = request.Columns .Select(column => (column, Expression.Lambda(column.Token.BuildExpression(query.Context), query.Context.Parameter))).ToList(); return values.ToResultTable(cols, values.Length, new Pagination.All()); }
public static DQueryable <T> GroupBy <T>(this DQueryable <T> query, HashSet <QueryToken> keyTokens, HashSet <AggregateToken> aggregateTokens) { var keySelector = KeySelector(query.Context, keyTokens); BuildExpressionContext newContext; LambdaExpression resultSelector = ResultSelectSelectorAndContext(query.Context, keyTokens, aggregateTokens, keySelector.Body.Type, out newContext); var resultQuery = (IQueryable <object>)query.Query.Provider.CreateQuery <object>(Expression.Call(null, miGroupByQ.MakeGenericMethod(typeof(object), keySelector.Body.Type, typeof(object)), new Expression[] { query.Query.Expression, Expression.Quote(keySelector), Expression.Quote(resultSelector) })); return(new DQueryable <T>(resultQuery, newContext)); }
public override DQueryable <object> GetDQueryable(DQueryableRequest request) { request.Columns.Insert(0, new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName)); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .OrderBy(request.Orders) .Where(request.Filters) .Select(request.Columns) .TryTake(request.Count); return(new DQueryable <object>(query.Query, query.Context)); }
public override async Task <ResultTable> ExecuteQueryAsync(QueryRequest request, CancellationToken token) { request.Columns.Insert(0, new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName)); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(request.Filters) .OrderBy(request.Orders) .Select(request.Columns); var result = await query.TryPaginateAsync(request.Pagination, token); return(result.ToResultTable(request)); }
public static DQueryable <T> OrderBy <T>(this DQueryable <T> query, List <Order> orders) { string str = orders.Select(f => QueryUtils.CanOrder(f.Token)).NotNull().ToString("\r\n"); if (str == null) { throw new ApplicationException(str); } var pairs = orders.Select(o => Tuple.Create( Expression.Lambda(OnAddaptForOrderBy(o.Token.BuildExpression(query.Context)), query.Context.Parameter), o.OrderType)).ToList(); return(new DQueryable <T>(query.Query.OrderBy(pairs), query.Context)); }
public override IQueryable <Lite <Entity> > GetEntities(List <Filter> filters) { var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .Where(filters) .Select(new List <Column> { ex }); var exp = Expression.Lambda <Func <object, Lite <Entity> > >(Expression.Convert(ex.Token.BuildExpression(query.Context), typeof(Lite <Entity>)), query.Context.Parameter); return(query.Query.Select(exp)); }
public override ResultTable ExecuteQuery(QueryRequest request) { request.Columns.Insert(0, new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName)); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(request.Filters) .OrderBy(request.Orders) .Select(request.Columns); var result = query.TryPaginate(request.Pagination); return(result.ToResultTable(request)); }
public override Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request) { var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName); DQueryable <T> orderQuery = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(request.Filters) .OrderBy(request.Orders); var result = orderQuery .SelectOne(ex.Token) .Unique(request.UniqueType); return((Lite <Entity>)result); }
public override IQueryable<Lite<Entity>> GetEntities(QueryEntitiesRequest request) { var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName); DQueryable<T> query = Query .ToDQueryable(GetQueryDescription()) .OrderBy(request.Orders) .Where(request.Filters) .Select(new List<Column> { ex }); var exp = Expression.Lambda<Func<object, Lite<Entity>>>(Expression.Convert(ex.Token.BuildExpression(query.Context), typeof(Lite<Entity>)), query.Context.Parameter); var result = query.Query.Select(exp); return result.TryTake(request.Count); }
public override async Task <Lite <Entity>?> ExecuteUniqueEntityAsync(UniqueEntityRequest request, CancellationToken token) { var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName); DQueryable <T> orderQuery = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(request.Filters) .OrderBy(request.Orders); var result = await orderQuery .SelectOne(ex.Token) .UniqueAsync(request.UniqueType, token); return((Lite <Entity>?)result); }
public static DEnumerableCount <T> TryPaginate <T>(this DQueryable <T> query, Pagination pagination) { if (pagination == null) { throw new ArgumentNullException("pagination"); } if (pagination is Pagination.All) { var allList = query.Query.ToList(); return(new DEnumerableCount <T>(allList, query.Context, allList.Count)); } else if (pagination is Pagination.Firsts) { var top = (Pagination.Firsts)pagination; var topList = query.Query.Take(top.TopElements).ToList(); return(new DEnumerableCount <T>(topList, query.Context, null)); } else if (pagination is Pagination.Paginate) { var pag = (Pagination.Paginate)pagination; int?totalElements = null; var q = query.Query.OrderAlsoByKeys(); if (pag.CurrentPage != 1) { q = q.Skip((pag.CurrentPage - 1) * pag.ElementsPerPage); } q = q.Take(pag.ElementsPerPage); var list = q.ToList(); if (list.Count < pag.ElementsPerPage && pag.CurrentPage == 1) { totalElements = list.Count; } return(new DEnumerableCount <T>(list, query.Context, totalElements ?? query.Query.Count())); } throw new InvalidOperationException("pagination type {0} not expexted".FormatWith(pagination.GetType().Name)); }
public override Lite <Entity> ExecuteUniqueEntity(UniqueEntityRequest request) { var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName); DQueryable <T> orderQuery = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(request.Filters) .OrderBy(request.Orders) .Select(new List <Column> { ex }); var exp = Expression.Lambda <Func <object, Lite <IEntity> > >(Expression.Convert(ex.Token.BuildExpression(orderQuery.Context), typeof(Lite <IEntity>)), orderQuery.Context.Parameter); return((Lite <Entity>)orderQuery.Query.Select(exp).Unique(request.UniqueType)); }
private DQueryable<T> GetDQueryable(QueryGroupRequest request) { var simpleFilters = request.Filters.Where(f => !(f.Token is AggregateToken)).ToList(); var aggregateFilters = request.Filters.Where(f => f.Token is AggregateToken).ToList(); var keys = request.Columns.Select(t => t.Token).Where(t => !(t is AggregateToken)).ToHashSet(); var allAggregates = request.AllTokens().OfType<AggregateToken>().ToHashSet(); DQueryable<T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(simpleFilters) .GroupBy(keys, allAggregates) .Where(aggregateFilters) .OrderBy(request.Orders); return query; }
public override IQueryable <Lite <Entity> > GetEntities(QueryEntitiesRequest request) { var ex = new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .OrderBy(request.Orders) .Where(request.Filters) .Select(new List <Column> { ex }); var result = query.Query.Select(query.Context.GetEntitySelector()); if (request.Multiplications.Any()) { result = result.Distinct(); } return(result.TryTake(request.Count)); }
public override ResultTable ExecuteQueryGroup(QueryGroupRequest request) { var simpleFilters = request.Filters.Where(f => !(f.Token is AggregateToken)).ToList(); var aggregateFilters = request.Filters.Where(f => f.Token is AggregateToken).ToList(); var keys = request.Columns.Select(t => t.Token).Where(t => !(t is AggregateToken)).ToHashSet(); var allAggregates = request.AllTokens().OfType <AggregateToken>().ToHashSet(); DQueryable <T> query = Query .ToDQueryable(GetQueryDescription()) .SelectMany(request.Multiplications) .Where(simpleFilters) .GroupBy(keys, allAggregates) .Where(aggregateFilters) .OrderBy(request.Orders); var cols = request.Columns .Select(c => Tuple.Create(c, Expression.Lambda(c.Token.BuildExpression(query.Context), query.Context.Parameter))).ToList(); var values = query.Query.ToArray(); return(values.ToResultTable(cols, values.Length, new Pagination.All())); }
public static DEnumerable <T> ToDEnumerable <T>(this DQueryable <T> query) { return(new DEnumerable <T>(query.Query.ToList(), query.Context)); }
public static DQueryable <T> Where <T>(this DQueryable <T> query, params Filter[] filters) { return(Where(query, filters.NotNull().ToList())); }
public static DQueryable <T> Where <T>(this DQueryable <T> query, Expression <Func <object, bool> > filter) { return(new DQueryable <T>(query.Query.Where(filter), query.Context)); }