示例#1
0
        /// <summary>
        /// 获取聚合
        /// </summary>
        /// <param name="agg"></param>
        /// <param name="ci"></param>
        /// <returns></returns>
        private IAggregationContainer Get_Agg(AggregationContainerDescriptor <T> agg, QueryDes qd)
        {
            var ls = qd.Aggs;

            if (ls == null)
            {
                return(agg);
            }

            foreach (var s in ls)
            {
                switch (s)
                {
                case 1:
                    agg.Terms("m_area", t => t.Field("m_area").Size(33));
                    break;

                case 2:
                    agg.Range("od_regm", r => r.Field("od_regm").Ranges(rs => rs.To(100), rs => rs.From(100).To(500), rs => rs.From(500).To(1000),
                                                                        rs => rs.From(1000)));
                    break;

                case 3:
                    agg.DateHistogram("od_regdate", t => t.Field("od_regdate").Interval(DateInterval.Year)
                                      .MinimumDocumentCount(1).ExtendedBounds(new DateTime(1900, 1, 1), DateTime.Now));
                    break;
                }
            }
            return(agg);
        }
示例#2
0
        public static AggregationContainerDescriptor <T> IntoDateHistogram <T>(this AggregationContainerDescriptor <T> innerAggregation,
                                                                               Expression <Func <T, object> > fieldGetter, DateInterval interval) where T : class
        {
            AggregationContainerDescriptor <T> v = new AggregationContainerDescriptor <T>();
            var fieldName = GetName(fieldGetter);

            v.DateHistogram(fieldName, dr =>
            {
                DateHistogramAggregationDescriptor <T> dateAggDesc = new DateHistogramAggregationDescriptor <T>();
                dateAggDesc.Field(fieldGetter).Interval(interval);
                return(dateAggDesc.Aggregations(x => innerAggregation));
            });

            return(v);
        }
示例#3
0
        private static IAggregationContainer GetAggContainer(AggregationContainerDescriptor <Person> agg, SearchParam p)
        {
            if (p.aggs != null)
            {
                foreach (var a in p.aggs)
                {
                    switch (a)
                    {
                    case PersonEnum.age:
                        agg.Range("age", r => r.Field(f => f.age).Ranges(rs => rs.To(20),
                                                                         rs => rs.From(20).To(30),
                                                                         rs => rs.From(30).To(40),
                                                                         rs => rs.From(40).To(50),
                                                                         rs => rs.From(50).To(60),
                                                                         rs => rs.From(60)));
                        break;

                    case PersonEnum.graduate:
                        agg.DateHistogram("graduate", d => d.Field(f => f.graduate)
                                          .Interval(DateInterval.Year)
                                          .MinimumDocumentCount(1)
                                          .ExtendedBounds("1980", "2050"));
                        break;

                    case PersonEnum.isMan:
                        agg.Terms("isMan", t => t.Field(f => f.isMan));
                        break;

                    case PersonEnum.city:
                        agg.Terms("city", t => t.Field(f => f.city));
                        break;
                    }
                }
            }
            return(agg);
        }
示例#4
0
 public static AggregationContainerDescriptor <T> DateHistogram <T>(this AggregationContainerDescriptor <T> agg,
                                                                    Expression <Func <T, object> > fieldGetter, DateInterval dateInterval) where T : class
 {
     return(agg.DateHistogram(GetName(fieldGetter), x => x.Field(fieldGetter).Interval(dateInterval)));
 }