ElasticSearch 7嵌套7从结果中返回属性所有结果

Question

我正在使用 ElarsticSearch 7.7 和 NEST 7.7，在我的网页上，每页有 9 个搜索结果文档。即使我在页面上显示前 9 个结果，我也需要从所有结果中返回一些属性值，以便在网页上进行侧过滤。

例如：如果我搜索“LapTop”，我的页面将在第一页显示 9 个结果。另外，我需要显示所有搜索结果中的所有“制造商”。不仅制造商在首页结果中。然后客户可以按制造商筛选，而不仅仅是显示在第一页上。 我尝试过 GlobalAggregation，但它返回类别并仅在所选页面中制造项目。

  public SearchResult Search(SearchType searchType, string searchQuery, int storeId, int pageNumber = 1, int pageSize = 12, IList<SearchFilter> requestFilter = null, decimal? priceFrom = 0, decimal? priceTo = 100000000, string sortBy = null, int totalCount = 0)
            {
                var queryContainer = new QueryContainer();
    
                var sorts = new List<ISort>();
                sorts.Add(new FieldSort { Field = "_score", Order = SortOrder.Descending });
                switch (sortBy)
                {
                    case "z-a":
                        sorts.Add(new FieldSort { Field = Field<ElasticIndexGroupProduct>(p => p.SortValue), Order = SortOrder.Descending });
                        break;
                    case "a-z":
                        sorts.Add(new FieldSort { Field = Field<ElasticIndexGroupProduct>(p => p.SortValue), Order = SortOrder.Ascending });
                        break;               
                }
    
    
                var aggrigations = new AggregationDictionary
                 {
                    {"average_per_child", new 
 AverageAggregation("average_per_child",Field<ElasticIndexGroupProduct>(d =>  d.Price))},
                   {"max_per_child", new MaxAggregation("max_per_child",Field<ElasticIndexGroupProduct>(d => d.Price))},
                    {"min_per_child", new MinAggregation("min_per_child", Field<ElasticIndexGroupProduct>(d => d.Price))},
                    {
                     "globle_filter_aggrigation", new GlobalAggregation("globle_filter_aggrigation")
                    {
                       Aggregations =new AggregationDictionary
                      {
                        {"category_flow",  new TermsAggregation("category_flow"){Field = Field<ElasticIndexGroupProduct>(p => p.CategoryFlow)} },
                        {"manufacturers", new TermsAggregation("manufacturers"){Field = Field<ElasticIndexGroupProduct>(p => p.Manufacturer)} }
                     }
                   }
                  }                   
                };
               
                var searchRequest = new SearchRequest<ElasticIndexGroupProduct>()
                {
                    Profile = true,
                    From = (pageNumber - 1) * pageSize,
                    Size = pageSize,
                    Version = true,
                    Sort = sorts,
                    //Scroll = Time.MinusOne,
                    Aggregations = aggrigations
                };
    
                 var multiMatch = new QueryStringQuery
                 {
                        Query = searchQuery,
                        Fields = GetSearchFields(searchType),
                        Boost = 1.1,
                        Name = "named_query",
                        DefaultOperator = Operator.Or,
                        Analyzer = "standard",
                        QuoteAnalyzer = "keyword",
                        AllowLeadingWildcard = true,
                        MaximumDeterminizedStates = 2,
                        Escape = true,
                        FuzzyPrefixLength = 2,
                        FuzzyMaxExpansions = 3,
                        FuzzyRewrite = MultiTermQueryRewrite.ConstantScore,
                        Rewrite = MultiTermQueryRewrite.ConstantScore,
                        Fuzziness = Fuzziness.Auto,
                        TieBreaker = 1,
                        AnalyzeWildcard = true,
                        MinimumShouldMatch = 2,
                        QuoteFieldSuffix = "'",
                        Lenient = true,
                        AutoGenerateSynonymsPhraseQuery = false
                };
    
                searchRequest.Query = new BoolQuery
                {
                        Must = new QueryContainer[] { multiMatch },
                        Filter = new QueryContainer[] { queryContainer }
                };
    
           var searchResponse = _client.Search<ElasticIndexGroupProduct>(searchRequest);

          var categoryFlowsGlobe = new List<string>();
          var allAggregations = searchResponse.Aggregations.Global("globle_filter_aggrigation");
          var categories = allAggregations.Terms("category_flow");
          foreach (var aggItem in categories.Buckets)
          {
             if (!categoryFlowsGlobe.Any(x => x == aggItem.Key))
             {
               categoryFlowsGlobe.Add(aggItem.Key);
             }
           }
              
    }

Answer 1

这是 Post filter 的确切用例 - 运行返回命中和聚合的搜索请求，然后在聚合完成后对命中应用 过滤计算出来的。

对于制造商，可以在搜索请求中使用术语聚合来检索这些 - 如果您需要返回 所有 制造商，您可以调整聚合的大小，否则您可能决定只返回顶部 x。