Elasticsearch-过滤哪里（嵌套数组之一）和（所有嵌套数组）

Question

TL; DR -我该如何检查是否 之一的 和 所有的 嵌套数组满足规定的标准是什么？

我有一个document。每个对象document都有一个嵌套outer对象数组，这些对象本身都有一个嵌套inner对象列表。我需要对所有文档中
至少一个outer嵌套对象匹配的文档执行过滤器。当我说的比赛，我的意思是 所有
的outer嵌套对象的inner对象以某种方式相匹配。这是一个示例映射，以供参考；

{ "document" : {
    "properties" : {
      "name" : {
        "type" : "string"
      },
      "outer" : {
        "type" : "nested",
        "properties" : {
          "inner" : {
            "type" : "nested",
            "properties" : {
              "match" : {
                "type" : "string",
                "index" : "not_analyzed"
              },
              "type" : {
                "type" : "string",
                "index" : "not_analyzed"
              }
    }}}}}}
}

如果文档没有outer/
inner对象，则认为是匹配的。但是，更糟糕的是，内部对象需要考虑以type某种条件逻辑方式（例如，CASE在SQL中）进行不同的匹配。例如，如果则type是术语，"Country"那么inner如果则match是指定的国家/地区代码（例如），则认为对象匹配ES。文档可能具有inner变化的对象，type并且不能保证将存在特定类型。

来自命令式（Java）编程背景，我在解决如何实现这种过滤方面遇到了难以置信的麻烦。我什至无法想像这种行为。到目前为止，我所拥有的只是过滤查询；

"filtered" : {
      "query" : {
        "match_all" : { }
      },
      "filter" : {
        "bool" : {
          "should" : {
            "missing" : {
              "field" : "outer.inner.type"
            }
    }}}}
}

所以，问题是…

如何才能筛选到谁拥有的文件 至少一个 outer具有对象 的所有 inner匹配基于对象type的inner对象？

根据要求提供更多详细信息-

示例文档JSON

{
    "name":"First",
    "outer":[
        {
            "inner":[
                {"match":"ES","type":"Country"},
                {"match":"Elite","type":"Market"}
            ]
        },{
            "inner":[
                {"match":"GBR","type":"Country"},
                {"match":"1st Class","type":"Market"},
                {"match":"Admin","type":"Role"}
            ]
        }
    ],
    "lockVersion":0,"sourceId":"1"
}

如果我们要提供"1st Class"市场 和 国家"GRB"，则上面的示例应该经过过滤器 ，
因为两个outer对象中的第二个对象因为两个inner对象都匹配而被视为匹配。但是，如果我们提供了国家（地区）国家"GRB"和市场，"Elite"那么我们将不会退回该文档，因为这两个outer对象都不会使它们的inner对象整体上匹配。如果我们希望第二个outer对象匹配，那么所有三个对象inner都需要匹配。请注意，type第三项中有一个额外项inner。这导致一种情况，
如果 存在一个类型， 则 它需要具有一个匹配项 否则 它不需要匹配，因为它不存在。

Answer 1

嵌套数组之一

具有 一个 符合某些条件的嵌套数组 之一
非常简单。甲嵌套滤波器的计算结果为匹配/真，如果任何嵌套对象的阵列的匹配指定内的过滤器。例如，给定一个outer对象数组，其中那些对象中的一个对象具有一个match值为"matching"的字段，则将以下内容视为正确。

"nested": {
   "path": "outer",
   "filter": {
       "term" : { "match" : "matching" } 
   }
}

如果 其中一个 嵌套outer对象具有一个名为matchvalue 的字段，则以上内容将被视为true / matching
"matching"。

所有嵌套数组

仅当数组匹配的 所有
嵌套对象更有趣时，才具有嵌套过滤器。实际上，这是不可能的。但是考虑到如果只有一个嵌套对象与一个过滤器匹配，则认为是匹配的，我们可以颠倒逻辑并说“如果
没有 一个嵌套对象 不
匹配”以达到我们所需要的。例如，给定一个嵌套outer.inner对象数组，其中所有这些对象都具有一个match值为"matching"的字段，则以下内容将被视为true。

"not" : {
   "nested": {
      "path": "outer.inner",
      "filter": {
          "not" : {
              "term" : { "match" : "matching" } 
          }
      }
   }
}

上述将被视为真/匹配，因为 没有 嵌套的outer.inner对象 不
（双阴性）有一个称为字段match具有值"matching"。当然，这与 所有inner具有matchvalue
字段的嵌套对象相同"matching"。

缺少任何嵌套对象

使用传统的缺失过滤器无法检查是否缺少包含嵌套对象的字段。这是因为，嵌套的对象实际上并没有 在
所有的文件，将它们存储在别处。因此，丢失的过滤器将始终被视为正确。但是，您可以做的是检查match_all过滤器是否不返回任何结果。

"not": {
   "nested": {
      "path": "outer",
      "filter": {
          "match_all": {}
       }
    }
 }

如果未match_all找到结果，则认为是正确/匹配。