public override async Task <ResultTable> ExecuteQueryGroupAsync(QueryRequest request, CancellationToken cancellationToken)
{
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();
var qr = new QueryRequest
{
Columns = keys.Concat(allAggregates.Select(at => at.Parent).NotNull()).Distinct().Select(t => new Column(t, t.NiceName())).ToList(),
Orders = new List <Order>(),
Filters = simpleFilters,
QueryName = request.QueryName,
Pagination = new Pagination.All(),
};
DEnumerableCount <T> plainCollection = await Execute(qr, GetQueryDescription(), cancellationToken);
var groupCollection = plainCollection
.GroupBy(keys, allAggregates)
.Where(aggregateFilters)
.OrderBy(request.Orders);
var cols = groupCollection.TryPaginate(request.Pagination);
return(cols.ToResultTable(request));
}
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();
DEnumerableCount <T> plainCollection = Execute(new QueryRequest
{
Columns = keys.Concat(allAggregates.Select(at => at.Parent).NotNull()).Distinct().Select(t => new Column(t, t.NiceName())).ToList(),
Orders = new List <Order>(),
Filters = simpleFilters,
QueryName = request.QueryName,
Pagination = new Pagination.All(),
}, GetQueryDescription());
var groupCollection = plainCollection
.GroupBy(keys, allAggregates)
.Where(aggregateFilters)
.OrderBy(request.Orders);
var cols = request.Columns
.Select(column => (column, Expression.Lambda(column.Token.BuildExpression(groupCollection.Context), groupCollection.Context.Parameter))).ToList();
var values = groupCollection.Collection.ToArray();
return(values.ToResultTable(cols, values.Length, new Pagination.All()));
}
public static DEnumerableCount <T> TryPaginate <T>(this DEnumerableCount <T> collection, Pagination pagination)
{
if (pagination == null)
{
throw new ArgumentNullException("pagination");
}
if (pagination is Pagination.All)
{
return(new DEnumerableCount <T>(collection.Collection, collection.Context, collection.TotalElements));
}
else if (pagination is Pagination.Firsts)
{
var top = (Pagination.Firsts)pagination;
var topList = collection.Collection.Take(top.TopElements).ToList();
return(new DEnumerableCount <T>(topList, collection.Context, null));
}
else if (pagination is Pagination.Paginate)
{
var pag = (Pagination.Paginate)pagination;
var c = collection.Collection;
if (pag.CurrentPage != 1)
{
c = c.Skip((pag.CurrentPage - 1) * pag.ElementsPerPage);
}
c = c.Take(pag.ElementsPerPage);
return(new DEnumerableCount <T>(c, collection.Context, collection.TotalElements));
}
throw new InvalidOperationException("pagination type {0} not expexted".FormatWith(pagination.GetType().Name));
}
public override async Task <ResultTable> ExecuteQueryAsync(QueryRequest request, CancellationToken cancellationToken)
{
request.Columns.Insert(0, new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName));
DEnumerableCount <T> manualResult = await Execute(request, GetQueryDescription(), cancellationToken);
return(manualResult.ToResultTable(request));
}
public override ResultTable ExecuteQuery(QueryRequest request)
{
request.Columns.Insert(0, new _EntityColumn(EntityColumnFactory().BuildColumnDescription(), QueryName));
DEnumerableCount <T> manualResult = Execute(request, GetQueryDescription());
return(manualResult.ToResultTable(request));
}
public static ResultTable ToResultTable <T>(this DEnumerableCount <T> collection, QueryRequest req)
{
object[] array = collection.Collection as object[] ?? collection.Collection.ToArray();
var columnAccesors = req.Columns.Select(c => Tuple.Create(c,
Expression.Lambda(c.Token.BuildExpression(collection.Context), collection.Context.Parameter))).ToList();
return(ToResultTable(array, columnAccesors, collection.TotalElements, req.Pagination));
}
public static DEnumerableCount <T> OrderBy <T>(this DEnumerableCount <T> collection, List <Order> orders)
{
var pairs = orders.Select(o => Tuple.Create(
Expression.Lambda(OnAddaptForOrderBy(o.Token.BuildExpression(collection.Context)), collection.Context.Parameter),
o.OrderType)).ToList();
return(new DEnumerableCount <T>(collection.Collection.OrderBy(pairs), collection.Context, collection.TotalElements));
}
public static DEnumerableCount <T> Concat <T>(this DEnumerableCount <T> collection, DEnumerableCount <T> other)
{
if (collection.Context.TupleType != other.Context.TupleType)
{
throw new InvalidOperationException("Enumerable's TupleType does not match Other's one.\r\n Enumerable: {0}: \r\n Other: {1}".FormatWith(
collection.Context.TupleType.TypeName(),
other.Context.TupleType.TypeName()));
}
return(new DEnumerableCount <T>(collection.Collection.Concat(other.Collection), collection.Context, collection.TotalElements + other.TotalElements));
}
