コード例 #1
0
        /// <summary>根据聚合条件获取统计信息</summary>
        public virtual async Task <SearchStatisticsResult> StatisticsAsync(SearchStatisticsRequest request)
        {
            var provider            = new SearchProvider <Metadata>();
            SearchGroupRules groups = new SearchGroupRules();

            groups.Top    = int.MaxValue / 2;
            groups.Fields = request.Groups;
            var aggs = provider.BuildAggs(groups);

            var searchresponse = await _esAccess.PagingQueryAsync(null, null, null, aggs, 0, 0);

            SearchStatisticsResult result = new SearchStatisticsResult();

            var groupResult = new Dictionary <string, Dictionary <string, long?> >();

            foreach (var agg in searchresponse.Aggregations)
            {
                var aggregates = agg.Value.As <BucketAggregate>().Items;
                Dictionary <string, long?> dic = new Dictionary <string, long?>();
                foreach (var aggregate in aggregates)
                {
                    var keyedBucket = aggregate as Nest.KeyedBucket <object>;
                    if (keyedBucket != null)
                    {
                        dic.Add(keyedBucket.Key.ToString(), keyedBucket.DocCount);
                    }
                }
                groupResult.Add(agg.Key, dic);
            }


            result.Groups = groupResult;
            return(result);
        }
コード例 #2
0
        ///// <summary>
        ///// 获得排序脚本
        ///// </summary>
        ///// <param name="sort">排序规则</param>
        ///// <param name="field">排序字段</param>
        ///// <returns></returns>
        //private static string GetOrderScript(Sort sort, string field)
        //{
        //    var value = sort.Promotion;
        //    var sb = new StringBuilder();
        //    for (int i = 0; i < value.Count + 1; i++)
        //    {
        //        string scriptText;
        //        string itemValue;
        //        if (i == 0)
        //        {
        //            itemValue = value[i].Trim();
        //            // scriptText = $"if('{itemValue}' == doc['{field.KeyWord()}'].value)return 0;";
        //            scriptText = $"'{itemValue}'==doc['{field.KeyWord()}'].value?0";
        //        }
        //        else if (i == value.Count)
        //        {
        //            // scriptText = $"else return {value.Count}";
        //            scriptText = $":{i}";
        //            for (var j = 0; j < value.Count - 1; j++)
        //            {
        //                scriptText += ")";
        //            }
        //        }
        //        else
        //        {
        //            itemValue = value[i];
        //            //scriptText = $"else if('{itemValue}' == doc['{field.KeyWord()}'].value)return {i};";
        //            scriptText = $":('{itemValue}'==doc['{field.KeyWord()}'].value?{i}";
        //        }
        //        sb.Append(scriptText);
        //    }

        //    return sb.ToString();
        //}

        /// <summary>
        /// 根据聚合条件构建聚合器
        /// </summary>
        /// <param name="groups">聚合条件</param>
        /// <returns></returns>
        public AggregationContainerDescriptor <T> BuildAggs(SearchGroupRules groups)
        {
            if (groups == null || groups.Fields.Count == 0)
            {
                return(null);
            }

            var aggsDesc = new AggregationContainerDescriptor <T>();

            foreach (var gfield in groups.Fields)
            {
                aggsDesc.Terms(gfield, s => s.Field(KeyWord(gfield)).Size(groups.Top).OrderDescending("_count"));
            }
            return(aggsDesc);
        }