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));
}
