public static DEnumerable <T> Select <T>(this DEnumerable <T> collection, HashSet <QueryToken> columns)
{
BuildExpressionContext newContext;
var selector = TupleConstructor(collection.Context, columns, out newContext);
return(new DEnumerable <T>(collection.Collection.Select(selector.Compile()), newContext));
}
public static DEnumerable <T> TryTake <T>(this DEnumerable <T> collection, int?num)
{
if (num.HasValue)
{
return(new DEnumerable <T>(collection.Collection.Take(num.Value), collection.Context));
}
return(collection);
}
public static DEnumerable <T> OrderBy <T>(this DEnumerable <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 DEnumerable <T>(collection.Collection.OrderBy(pairs), collection.Context));
}
public static DEnumerable <T> GroupBy <T>(this DEnumerable <T> collection, HashSet <QueryToken> keyTokens, HashSet <AggregateToken> aggregateTokens)
{
var keySelector = KeySelector(collection.Context, keyTokens);
BuildExpressionContext newContext;
LambdaExpression resultSelector = ResultSelectSelectorAndContext(collection.Context, keyTokens, aggregateTokens, keySelector.Body.Type, out newContext);
var resultCollection = giGroupByE.GetInvoker(typeof(object), keySelector.Body.Type, typeof(object))(collection.Collection, keySelector.Compile(), resultSelector.Compile());
return(new DEnumerable <T>(resultCollection, newContext));
}
public static DEnumerable <T> Where <T>(this DEnumerable <T> collection, List <Filter> filters)
{
Expression <Func <object, bool> > where = GetWhereExpression(collection.Context, filters);
if (where == null)
{
return(collection);
}
return(new DEnumerable <T>(collection.Collection.Where(where.Compile()), collection.Context));
}
public static DEnumerable <T> Concat <T>(this DEnumerable <T> collection, DEnumerable <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 DEnumerable <T>(collection.Collection.Concat(other.Collection), collection.Context));
}
public override async Task <Lite <Entity>?> ExecuteUniqueEntityAsync(UniqueEntityRequest request, CancellationToken cancellationToken)
{
var req = new QueryRequest
{
QueryName = request.QueryName,
Filters = request.Filters,
Orders = request.Orders,
Columns = new List <Column> {
new Column(this.EntityColumnFactory().BuildColumnDescription(), QueryName)
},
Pagination = new Pagination.Firsts(2),
};
DEnumerable <T> mr = await Execute(req, GetQueryDescription(), cancellationToken);
return((Lite <Entity>)mr.Collection.Select(entitySelector.Value).Unique(request.UniqueType));
}
public static DEnumerableCount <T> TryPaginate <T>(this DEnumerable <T> collection, Pagination pagination)
{
if (pagination == null)
{
throw new ArgumentNullException("pagination");
}
if (pagination is Pagination.All)
{
var allList = collection.Collection.ToList();
return(new DEnumerableCount <T>(allList, collection.Context, allList.Count));
}
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;
int?totalElements = null;
var q = collection.Collection;
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, collection.Context, totalElements ?? collection.Collection.Count()));
}
throw new InvalidOperationException("pagination type {0} not expexted".FormatWith(pagination.GetType().Name));
}
public static DEnumerable <T> Where <T>(this DEnumerable <T> collection, Func <object, bool> filter)
{
return(new DEnumerable <T>(collection.Collection.Where(filter).ToList(), collection.Context));
}
public static DEnumerable <T> Where <T>(this DEnumerable <T> collection, params Filter[] filters)
{
return(Where(collection, filters.NotNull().ToList()));
}
public static DEnumerable <T> Select <T>(this DEnumerable <T> query, List <Column> columns)
{
return(Select <T>(query, new HashSet <QueryToken>(columns.Select(c => c.Token))));
}
