C# 如何使用2个应该存在的字段编写嵌套查询

TL；DR

Nest正在创建一个额外的内部

Bool.Match

，当我尝试匹配

should

子句中的多个内容时（在Bool上下文中）

---

预期-查询 我正在使用Nest 5.6.1，并尝试编写以下查询：

{
  "query": {
    "bool": {
      "minimum_should_match": 2,
      "should": [
        {
          "exists": {
            "field": "B"
          }
        },
        {
          "exists": {
            "field": "A"
          }
        },
        {
          "match": {
            "fields.MachineName": "MY_Machine"
          }
        }
      ],
      "filter": [
        {
          "range": {
            "@timestamp": {
              "gte": "2018-09-03T00:00:00",
              "lt": "2018-09-04T00:00:00"
            }
          }
        }
      ]
    }
  }
}

---

我试过的 我试图通过以下方式实现这一目标：

var searchResponse = connection.Search<ExcludedCusipsStructLog>(sd => sd
                         .Index(DefaultIndex)
                         .From(0)
                         .Size(1000)
                         .Type(LogType.ProxyLog)
                         .Query(q => q
                             .Bool(b => b
                                .Should(sh => sh
                                        .Exists(e => e
                                        .Field(fi => fi.A)
                                        )
                                      && sh
                                        .Exists(e => e
                                        .Field(fi => fi.B)
                                        )
                                      && sh
                                        .Match(ma => ma
                                        .Field(f => f.MachineName)
                                        .Query("MY_Machine")
                                        )
                                 )
                                .MinimumShouldMatch(2)
                                .Filter(fi => fi
                                        .DateRange(r => r
                                             .Field(f => f.Timestamp)
                                             .GreaterThanOrEquals(dateToSearch)
                                             .LessThan(dateToSearch.AddDays(1))
                                        )
                                 )

                             )
                         )
                    );

---

更多细节

---

我还发现，如果我只查看了Should子句中的一个字段-Nest正在创建一个好的查询-是什么让我认为我应该以不同的方式添加其他字段（我没有找到）

，正如@KozhevnikovDmitry在评论中提到的那样。 我应该使用昏迷而不是

&&

，即正确的方法是：

var searchResponse = connection.Search<ExcludedCusipsStructLog>(sd => sd
                         .Index(DefaultIndex)
                         .From(0)
                         .Size(1000)
                         .Type(LogType.ProxyLog)
                         .Query(q => q
                             .Bool(b => b
                                .Should(sh => sh
                                        .Exists(e => e
                                        .Field(fi => fi.A)
                                        )
                                      ,sh => sh
                                        .Exists(e => e
                                        .Field(fi => fi.B)
                                        )
                                      ,sh => sh
                                        .Match(ma => ma
                                        .Field(f => f.MachineName)
                                        .Query("MY_Machine")
                                        )
                                 )
                                .MinimumShouldMatch(2)
                                .Filter(fi => fi
                                        .DateRange(r => r
                                             .Field(f => f.Timestamp)
                                             .GreaterThanOrEquals(dateToSearch)
                                             .LessThan(dateToSearch.AddDays(1))
                                        )
                                 )

                             )
                         )
                    );

var searchResponse=connection.Search（sd=>sd
.Index（默认索引）
.从（0）
.尺寸（1000）
.Type（LogType.ProxyLog）
.Query（q=>q
.Bool（b=>b
.Should（sh=>sh
.存在（e=>e
.Field（fi=>fi.A）
)
，sh=>sh
.存在（e=>e
.Field（fi=>fi.B）
)
，sh=>sh
.Match（ma=>ma
.Field（f=>f.MachineName）
.Query（“我的机器”）
)
)
.最小值应匹配（2）
.Filter（fi=>fi
.DateRange（r=>r
.Field（f=>f.Timestamp）
.大于或等于（日期搜索）
.LessThan（日期搜索添加天数（1））
)
)
)
)
);

您是否尝试将匹配项作为单独的参数提供给您，如

应该（sh=>sh.Exists（），sh=>sh.Exists（），sh=>sh.Match（））

？我一小时前才发现。我正要上传一个答案。无论如何，谢谢你的提示！我花了一个小时才弄明白…对你有好处！说出你的答案。

var searchResponse = connection.Search<ExcludedCusipsStructLog>(sd => sd
                         .Index(DefaultIndex)
                         .From(0)
                         .Size(1000)
                         .Type(LogType.ProxyLog)
                         .Query(q => q
                             .Bool(b => b
                                .Should(sh => sh
                                        .Exists(e => e
                                        .Field(fi => fi.A)
                                        )
                                      ,sh => sh
                                        .Exists(e => e
                                        .Field(fi => fi.B)
                                        )
                                      ,sh => sh
                                        .Match(ma => ma
                                        .Field(f => f.MachineName)
                                        .Query("MY_Machine")
                                        )
                                 )
                                .MinimumShouldMatch(2)
                                .Filter(fi => fi
                                        .DateRange(r => r
                                             .Field(f => f.Timestamp)
                                             .GreaterThanOrEquals(dateToSearch)
                                             .LessThan(dateToSearch.AddDays(1))
                                        )
                                 )

                             )
                         )
                    );