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()));
}
/// <summary>
/// 查询组
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public QueryGroupResponse QueryGroup(QueryGroupRequest request)
{
var response = new QueryGroupResponse();
var datalist = _groupInfoRepository.QueryGroup(request.ImUserId, request.GroupName, request.PageIndex, request.PageSize, out var total);
response.TotalCount = total;
response.EntityList = datalist;
return(response);
}
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 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 QueryGroupRequest ToRequest(this QueryGroupOptions options)
{
QueryDescription qd = GetQueryDescription(options.QueryName);
ColumnOption.SetColumnTokens(options.ColumnOptions, qd, canAggregate: true);
FilterOption.SetFilterTokens(options.FilterOptions, qd, canAggregate: true);
OrderOption.SetOrderTokens(options.OrderOptions, qd, canAggregate: true);
var request = new QueryGroupRequest
{
QueryName = options.QueryName,
Filters = options.FilterOptions.Select(f => f.ToFilter()).ToList(),
Orders = options.OrderOptions.Select(f => f.ToOrder()).ToList(),
Columns = options.ColumnOptions.Select(f => f.ToColumn()).ToList(),
};
return(request);
}
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;
}
/// <summary>
///
/// </summary>
/// <param name="imUserId"></param>
/// <param name="groupname"></param>
/// <param name="page"></param>
/// <param name="limit"></param>
/// <returns></returns>
public ActionResult QueryGroup(string imUserId, string groupname, int page = 1, int limit = 20)
{
var request = new QueryGroupRequest();
request.ImUserId = imUserId.ToGuid();
request.GroupName = groupname;
request.PageIndex = page;
request.PageSize = limit;
var response = _imUserInfoService.QueryGroup(request);
if (response.IsSuccess && response.EntityList != null)
{
response.EntityList.ForEach(e =>
{
e.GroupPicture = string.IsNullOrEmpty(e.GroupPicture) ? "../Content/Images/defaultimg.jpg" : e.GroupPicture;
});
}
return(ToJsonResult(new { code = 0, data = response.EntityList.Select(e => e.As <GroupUserModel>()).ToList(), count = response.TotalCount }));
}
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 ResultTable ExecuteGroupQuery(QueryGroupRequest request)
{
return(Execute(ExecuteType.ExecuteGroupQuery, request.QueryName, request, dqb => dqb.Core.Value.ExecuteQueryGroup(request)));
}
public ResultTable ExecuteQueryGroup(QueryGroupRequest request)
{
return(Return(MethodInfo.GetCurrentMethod(), request.QueryName.ToString(),
() => DynamicQueryManager.Current.ExecuteGroupQuery(request)));
}
public static void QueryGroupBatch(this QueryGroupRequest request, Action <ResultTable> onResult, Action @finally)
{
Finder.Manager.AssertFindable(request.QueryName);
Enqueue(request, obj => onResult((ResultTable)obj), @finally);
}
public override ResultTable ExecuteQueryGroup(QueryGroupRequest request)
{
throw new NotImplementedException();
}
private static ResultTable QueryGroup(this QueryGroupRequest request)
{
Finder.Manager.AssertFindable(request.QueryName);
return(Server.Return((IDynamicQueryServer s) => s.ExecuteQueryGroup(request)));
}
public static object[][] RetrieveData(this PredictorEntity predictor)
{
QueryRequest mainQuery = predictor.ToQueryRequest();
ResultTable mainResult = DynamicQueryManager.Current.ExecuteQuery(mainQuery);
Implementations mainQueryImplementations = DynamicQueryManager.Current.GetEntityImplementations(predictor.Query.ToQueryName());
List <MultiColumnQuery> mcqs = new List <MultiColumnQuery>();
foreach (var c in predictor.Columns.Where(a => a.Type == PredictorColumnType.MultiColumn))
{
QueryGroupRequest multiColumnQuery = predictor.ToMultiColumnQuery(mainQueryImplementations, c.MultiColumn);
ResultTable multiColumnResult = DynamicQueryManager.Current.ExecuteGroupQuery(multiColumnQuery);
var entityGroupKey = multiColumnResult.Columns.FirstEx();
var remainingKeys = multiColumnResult.Columns.Take(c.MultiColumn.GroupKeys.Count).Skip(1).ToArray();
var aggregates = multiColumnResult.Columns.Take(c.MultiColumn.GroupKeys.Count).Skip(1).ToArray();
var groupedValues = multiColumnResult.Rows.AgGroupToDictionary(row => (Lite <Entity>)row[entityGroupKey], gr =>
gr.ToDictionaryEx(
row => row.GetValues(remainingKeys),
row => row.GetValues(aggregates),
ObjectArrayComparer.Instance));
mcqs.Add(new MultiColumnQuery
{
MultiColumnEntity = c.MultiColumn,
Query = multiColumnQuery,
Result = multiColumnResult,
GroupedValues = groupedValues,
Aggregates = aggregates,
});
}
var dicMultiColumns = mcqs.ToDictionary(a => a.MultiColumnEntity);
List <ColumnDescription> columns = new List <ColumnDescription>();
columns.AddRange(mainResult.Columns.Select(rc => new ColumnDescription {
Column = rc
}));
foreach (var mc in mcqs)
{
var distinctKeys = mc.GroupedValues.SelectMany(a => a.Value.Values).Distinct(ObjectArrayComparer.Instance).ToList();
distinctKeys.Sort(ObjectArrayComparer.Instance);
foreach (var k in distinctKeys)
{
for (int i = 0; i < mc.Aggregates.Length; i++)
{
columns.Add(new ColumnDescription
{
MultiColumn = mc.MultiColumnEntity,
Key = k,
Column = mc.Aggregates[i],
AggregateIndex = i,
});
}
}
}
object[][] rows = new object[mainResult.Rows.Length][];
for (int i = 0; i < rows.Length; i++)
{
var mainRow = mainResult.Rows[i];
var row = new object[columns.Count];
for (int j = 0; j < columns.Count; j++)
{
var c = columns[j];
if (c.MultiColumn == null)
{
row[j] = mainRow[c.Column];
}
else
{
var dic = dicMultiColumns[c.MultiColumn].GroupedValues;
var array = dic.TryGetC(mainRow.Entity)?.TryGetC(c.Key);
row[j] = array == null ? null : array[c.AggregateIndex];
}
}
rows[i] = row;
}
return(rows);
}
public Task <ResultTable> ExecuteGroupQueryAsync(QueryGroupRequest request, CancellationToken token)
{
return(ExecuteAsync(ExecuteType.ExecuteGroupQuery, request.QueryName, request, dqb => dqb.Core.Value.ExecuteQueryGroupAsync(request, token)));
}
public override ResultTable ExecuteQueryGroup(QueryGroupRequest request) => Task.Run(() => ExecuteQueryGroupAsync(request, CancellationToken.None)).Result;
public abstract ResultTable ExecuteQueryGroup(QueryGroupRequest request);