private static AggregationResponse GetAggregation(AggregationRequest aggregationRequest, IDictionary <string, Filter> valueFilters, IndexSearcher searcher, bool sortValues, int?maxValuesCount, ICollection <string> availableFields)
        {
            AggregationResponse result = null;

            if (aggregationRequest != null)
            {
                if (valueFilters != null)
                {
                    var commonFilter = LuceneSearchFilterBuilder.GetFilterRecursive(aggregationRequest.Filter, availableFields);
                    var values       = valueFilters.Select(kvp => GetAggregationValue(kvp.Key, kvp.Value, commonFilter, searcher))
                                       .Where(v => v != null);

                    if (sortValues)
                    {
                        values = values
                                 .OrderByDescending(v => v.Count)
                                 .ThenBy(v => v.Id);
                    }

                    if (maxValuesCount > 0)
                    {
                        values = values.Take(maxValuesCount.Value);
                    }

                    result = new AggregationResponse
                    {
                        Id     = aggregationRequest.Id ?? aggregationRequest.FieldName,
                        Values = values.ToArray(),
                    };
                }
            }

            return(result);
        }
        static string GetArgsString(AggregationRequest request)
        {
            var args = new List <object>();

            request.SerializeRedisArgs(args);
            return(string.Join(" ", args));
        }
        /// <summary>
        /// Perform an aggregate query
        /// </summary>
        /// <param name="query">The query to watch</param>
        public async Task <AggregationResult> AggregateAsync(AggregationRequest query)
        {
            var args = new List <object>();

            args.Add(_boxedIndexName);
            query.SerializeRedisArgs(args);

            var resp = await _db.ExecuteAsync("FT.AGGREGATE", args).ConfigureAwait(false);

            return(new AggregationResult(resp));
        }
        /// <summary>
        /// Perform an aggregate query
        /// </summary>
        /// <param name="query">The query to watch</param>
        public AggregationResult Aggregate(AggregationRequest query)
        {
            var args = new List <object>();

            args.Add(_boxedIndexName);
            query.SerializeRedisArgs(args);

            var resp = DbSync.Execute("FT.AGGREGATE", args);

            return(new AggregationResult(resp));
        }
        public IList <AggregationRequest> GetAggregationRequests(ProductSearchCriteria criteria, FiltersContainer allFilters)
        {
            var result = new List <AggregationRequest>();

            var browseFilters = _browseFilterService.GetBrowseFilters(criteria);

            if (browseFilters != null)
            {
                foreach (var filter in browseFilters)
                {
                    var existingFilters = allFilters.GetFiltersExceptSpecified(filter.Key);

                    var attributeFilter  = filter as AttributeFilter;
                    var priceRangeFilter = filter as PriceRangeFilter;
                    var rangeFilter      = filter as RangeFilter;

                    AggregationRequest         aggregationRequest  = null;
                    IList <AggregationRequest> aggregationRequests = null;

                    if (attributeFilter != null)
                    {
                        aggregationRequest = GetAttributeFilterAggregationRequest(attributeFilter, existingFilters);
                    }
                    else if (rangeFilter != null)
                    {
                        aggregationRequests = GetRangeFilterAggregationRequests(rangeFilter, existingFilters);
                    }
                    else if (priceRangeFilter != null && priceRangeFilter.Currency.EqualsInvariant(criteria.Currency))
                    {
                        aggregationRequests = GetPriceRangeFilterAggregationRequests(priceRangeFilter, criteria, existingFilters);
                    }

                    if (aggregationRequest != null)
                    {
                        result.Add(aggregationRequest);
                    }

                    if (aggregationRequests != null)
                    {
                        result.AddRange(aggregationRequests.Where(f => f != null));
                    }
                }
            }

            return(result);
        }
Beispiel #6
0
        private static AggregationResponse GetAggregation(AggregationRequest aggregationRequest, FacetResults facets)
        {
            AggregationResponse result = null;

            switch (aggregationRequest)
            {
            case TermAggregationRequest termAggregationRequest:
                result = GetTermAggregation(termAggregationRequest, facets);
                break;

            case RangeAggregationRequest rangeAggregationRequest:
                result = GetRangeAggregation(rangeAggregationRequest, facets);
                break;
            }

            return(result);
        }
Beispiel #7
0
        public async Task <IList <AggregationRequest> > GetAggregationRequestsAsync(ProductIndexedSearchCriteria criteria, FiltersContainer allFilters)
        {
            var result = new List <AggregationRequest>();

            var browseFilters = await _browseFilterService.GetBrowseFiltersAsync(criteria);

            if (browseFilters != null)
            {
                foreach (var filter in browseFilters)
                {
                    var existingFilters = allFilters.GetFiltersExceptSpecified(filter.Key);

                    AggregationRequest         aggregationRequest  = null;
                    IList <AggregationRequest> aggregationRequests = null;

                    switch (filter)
                    {
                    case AttributeFilter attributeFilter:
                        aggregationRequest = GetAttributeFilterAggregationRequest(attributeFilter, existingFilters);
                        break;

                    case RangeFilter rangeFilter:
                        aggregationRequests = GetRangeFilterAggregationRequests(rangeFilter, existingFilters);
                        break;

                    case PriceRangeFilter priceRangeFilter when priceRangeFilter.Currency.EqualsInvariant(criteria.Currency):
                        aggregationRequests = GetPriceRangeFilterAggregationRequests(priceRangeFilter, criteria, existingFilters);

                        break;
                    }

                    if (aggregationRequest != null)
                    {
                        result.Add(aggregationRequest);
                    }

                    if (aggregationRequests != null)
                    {
                        result.AddRange(aggregationRequests.Where(f => f != null));
                    }
                }
            }

            return(result);
        }
        private static AggregationResponse GetAggregation(AggregationRequest aggregation, IndexSearcher searcher, ICollection <string> availableFields)
        {
            AggregationResponse result = null;

            var termAggregationRequest  = aggregation as TermAggregationRequest;
            var rangeAggregationRequest = aggregation as RangeAggregationRequest;

            if (termAggregationRequest != null)
            {
                result = CreateTermAggregationResponse(termAggregationRequest, searcher, availableFields);
            }
            else if (rangeAggregationRequest != null)
            {
                result = CreateRangeAggregationResponse(rangeAggregationRequest, searcher, availableFields);
            }

            return(result);
        }
        public void testAggregation()
        {
            Assert.Equal("*", GetArgsString(new AggregationRequest()));
            AggregationRequest r = new AggregationRequest().
                                   GroupBy("@actor", Count().As("cnt")).
                                   SortBy(Descending("@cnt"));

            Assert.Equal("* GROUPBY 1 @actor REDUCE COUNT 0 AS cnt SORTBY 2 @cnt DESC", GetArgsString(r));

            r = new AggregationRequest().GroupBy("@brand",
                                                 Quantile("@price", 0.50).As("q50"),
                                                 Quantile("@price", 0.90).As("q90"),
                                                 Quantile("@price", 0.95).As("q95"),
                                                 Avg("@price"),
                                                 Count().As("count")).
                SortByDescending("@count").
                Limit(10);
            Assert.Equal("* GROUPBY 1 @brand REDUCE QUANTILE 2 @price 0.5 AS q50 REDUCE QUANTILE 2 @price 0.9 AS q90 REDUCE QUANTILE 2 @price 0.95 AS q95 REDUCE AVG 1 @price REDUCE COUNT 0 AS count LIMIT 0 10 SORTBY 2 @count DESC",
                         GetArgsString(r));
        }
        public void testAggregations()
        {
            /**
             * 127.0.0.1:6379> FT.CREATE test_index SCHEMA name TEXT SORTABLE count NUMERIC SORTABLE
             * OK
             * 127.0.0.1:6379> FT.ADD test_index data1 1.0 FIELDS name abc count 10
             * OK
             * 127.0.0.1:6379> FT.ADD test_index data2 1.0 FIELDS name def count 5
             * OK
             * 127.0.0.1:6379> FT.ADD test_index data3 1.0 FIELDS name def count 25
             */

            Client cl = GetClient();
            Schema sc = new Schema();

            sc.AddSortableTextField("name", 1.0);
            sc.AddSortableNumericField("count");
            cl.CreateIndex(sc, Client.IndexOptions.Default);
            cl.AddDocument(new Document("data1").Set("name", "abc").Set("count", 10));
            cl.AddDocument(new Document("data2").Set("name", "def").Set("count", 5));
            cl.AddDocument(new Document("data3").Set("name", "def").Set("count", 25));

            AggregationRequest r = new AggregationRequest()
                                   .GroupBy("@name", Reducers.Sum("@count").As("sum"))
                                   .SortBy(SortedField.Descending("@sum"), 10);


            // actual search
            AggregationResult res = cl.Aggregate(r);
            var r1 = res.GetRow(0);

            Assert.NotNull(r1);
            Assert.Equal("def", r1.Value.GetString("name"));
            Assert.Equal(30, r1.Value.GetInt64("sum"));

            var r2 = res.GetRow(1);

            Assert.NotNull(r2);
            Assert.Equal("abc", r2.Value.GetString("name"));
            Assert.Equal(10, r2.Value.GetInt64("sum"));
        }