elasticsearch 布尔查询中的多个异或筛选器

在1.x版本的Nest ie中，允许使用多个异或过滤器，如下面的原始查询

由于orFilters在2.x中不再推荐，因此可以用什么来替代它。如何在Bool查询中拥有多个排他的should（或filters）和Must

来自1.x的原始查询

  {
       "bool": {
         "must": [
           {
             "bool": {
               "must": [
                 {
                   "term": {
                     "EntityType": "ITSTrucks"
                   }
                 },
                 {
                   "or": {
                     "filters": [
                       {
                         "term": {
                           "AvailableDate": 36523
                         }
                       },
                       {
                         "range": {
                           "AvailableDate": {
                             "gte": "42036"
                           }
                         }
                       }
                     ],
                     "_name": "date"
                   }
                 },
                 {
                   "or": {
                     "filters": [
                       {
                         "geo_distance": {
                           "OriginCoordinate": "42.815656,-73.942324",
                           "distance": "100miles",
                           "distance_type": "plane"
                         }
                       }
                     ],
                     "_name": "OriginOrFilter"
                   }
                 },
                 {
                   "or": {
                     "filters": [
                       {
                         "term": {
                           "IsOpen": true
                         }
                       },
                       {
                         "term": {
                           "IsDestinationBoundaryNull": true
                         }
                       }
                     ],
                     "_name": "DestinationOrFilter"
                   }
                 }
               ]
             }
           }
         ]
       }
     }

像这样的东西好吗

    BoolQueryDescriptor<AvailableTrucks>  queryParameterMust= new BoolQueryDescriptor<AvailableTrucks>();
    BoolQueryDescriptor<AvailableTrucks> queryParameterShouldFirst= new BoolQueryDescriptor<AvailableTrucks>();
    BoolQueryDescriptor<AvailableTrucks> queryParameterShouldSecond= new BoolQueryDescriptor<AvailableTrucks>();
    BoolQueryDescriptor<AvailableTrucks> queryParameterShouldThird= new BoolQueryDescriptor<AvailableTrucks>();
    if (mustfc.Count > 0)
    {
        queryParameterMust.Must(mustfc.ToArray());
    }
    if (shouldQueryListFirst.Count > 0)
    {
        queryParameterShouldFirst.Should(shouldQueryListFirst.ToArray());
    }
    if (ShouldQueryListSecond.Count > 0)
    {
        queryParameterShouldSecond.Should(ShouldQueryListSecond.ToArray());
    }
    if (ShouldQueryListThird.Count > 0)
    {
        queryParameterShouldThird.Should(ShouldQueryListThird.ToArray());
    }
elasticClient.Search<Truck>(s => s.Query(f => f.Bool(c => c.Must(u => u.MatchAll()).Filter(q => q.Bool(b => queryParameterMust && queryParameterShouldFirst && queryParameterShouldSecond && queryParameterShouldThird)))))>Index("Trucks")

BoolQueryDescriptor queryParameterMust=new BoolQueryDescriptor（）；
BoolQueryDescriptor queryParameterShouldFirst=新建BoolQueryDescriptor（）；
BoolQueryDescriptor queryParameterShouldSecond=新的BoolQueryDescriptor（）；
BoolQueryDescriptor queryParametersShouldThird=新建BoolQueryDescriptor（）；
如果（mustfc.Count>0）
{
queryParameterMust.Must（mustfc.ToArray（））；
}
如果（shouldQueryListFirst.Count>0）
{
queryParameterShouldFirst.Should（shouldQueryListFirst.ToArray（））；
}
如果（ShouldQueryListSecond.Count>0）
{
queryParameterShouldSecond.Should（ShouldQueryListSecond.ToArray（））；
}
如果（ShouldQueryListThird.Count>0）
{
queryParameterShouldThird.Should（ShouldQueryListThird.ToArray（））；
}
elasticClient.Search（s=>s.Query（f=>f.Bool（c=>c.Must（u=>u.MatchAll（））.Filter（q=>q.Bool（b=>queryParameterMust&&queryParameterShouldFirst&&queryParameterShouldSecond&&queryParameterShouldThird `'））>Index（“Trucks”）

在2.x.x版本中，您可以使用

Should

术语来表示逻辑或查询

例如：

{
    "bool" : {
        "must" : {
            "term" : { "user" : "kimchy" }
        }
        "should" : [
            {
                "term" : { "tag" : "wow" }
            },
            {
                "term" : { "tag" : "elasticsearch" }
            }
        ],
        "minimum_should_match" : 1
    }
}

请注意，您也可以嵌套这些术语

要使用NEST构建查询，您可以尝试：

var mustMatchQueries = new List<QueryContainer>()
var shouldMatchQueries = new List<QueryContainer>();

// ... add queries to both lists

// aggregate queries
var mustMatchAggregatedTerms = mustMatchQueries.Aggregate(new QueryContainer(), (s, ff) => s &= ff);
var shouldMatchAggregatedTerms = shouldMatchQueries.Aggregate(new QueryContainer(), (s, ff) => s |= ff);

// build descriptor
var descriptor = new SearchDescriptor<DocumentClassName>()
descriptor.Query(q => q.Bool(b => b.Must(m => mustMatchAggregatedTerms && m.Bool(c => c.Should(shouldMatchAggregatedTerms)))));

var mustmatchquerys=new List（）
var shouldMatchQueries=新列表（）；
// ... 向两个列表中添加查询
//聚合查询
var mustMatchAggregatedTerms=mustmatchquerys.Aggregate（新的QueryContainer（），（s，ff）=>s&=ff）；
var shouldMatchAggregatedTerms=shouldMatchQueries.Aggregate（新QueryContainer（），（s，ff）=>s |=ff）；
//构建描述符
var descriptor=新的SearchDescriptor（）
descriptor.Query（q=>q.Bool（b=>b.Must（m=>mustMatchAggregatedTerms&&m.Bool（c=>c.Should（shouldMatchAggregatedTerms'））；

在2.x.x版本中，您可以使用

Should

术语来表示逻辑或查询

例如：

{
    "bool" : {
        "must" : {
            "term" : { "user" : "kimchy" }
        }
        "should" : [
            {
                "term" : { "tag" : "wow" }
            },
            {
                "term" : { "tag" : "elasticsearch" }
            }
        ],
        "minimum_should_match" : 1
    }
}

请注意，您也可以嵌套这些术语

要使用NEST构建查询，您可以尝试：

var mustMatchQueries = new List<QueryContainer>()
var shouldMatchQueries = new List<QueryContainer>();

// ... add queries to both lists

// aggregate queries
var mustMatchAggregatedTerms = mustMatchQueries.Aggregate(new QueryContainer(), (s, ff) => s &= ff);
var shouldMatchAggregatedTerms = shouldMatchQueries.Aggregate(new QueryContainer(), (s, ff) => s |= ff);

// build descriptor
var descriptor = new SearchDescriptor<DocumentClassName>()
descriptor.Query(q => q.Bool(b => b.Must(m => mustMatchAggregatedTerms && m.Bool(c => c.Should(shouldMatchAggregatedTerms)))));

var mustmatchquerys=new List（）
var shouldMatchQueries=新列表（）；
// ... 向两个列表中添加查询
//聚合查询
var mustMatchAggregatedTerms=mustmatchquerys.Aggregate（新的QueryContainer（），（s，ff）=>s&=ff）；
var shouldMatchAggregatedTerms=shouldMatchQueries.Aggregate（新QueryContainer（），（s，ff）=>s |=ff）；
//构建描述符
var descriptor=新的SearchDescriptor（）
descriptor.Query（q=>q.Bool（b=>b.Must（m=>mustMatchAggregatedTerms&&m.Bool（c=>c.Should（shouldMatchAggregatedTerms'））；

我不知道elasticsearch中是否有EXOR功能，但您有和（必须）或（应该）和不（必须），因此您可以制作自己的EXOR。a EXOR b==（a而不是b）或（b而不是a）我不知道elasticsearch中有EXOR功能，但你有和（必须），或（应该）和不（必须），所以你可以自己做EXOR。EXOR b==（a而不是b）或（b而不是a）

在查询上下文中的行为应该与过滤器上下文中的行为不同。我认为OP希望它位于过滤器上下文中。
在查询上下文中的行为应该与过滤器上下文中的行为不同。我认为OP希望它在过滤器上下文中。