minimum_number_should_match 与嵌套必须 bool

Question

我在 elasticsearch 中有一些文档，其中包含键值对列表。以下是一些示例。

document 1:
{
    data: [
        {
            key: key1,
            value: value1
        },
        {
            key: key1,
            value: value2
        },
    ]
}

document 2:
{
    data: [
        {
            key: key2,
            value: blah
        },
        {
            key: key1,
            value: value2
        },
    ]
}

document 3:
{
    data: [
        {
            key: key1,
            value: value3
        },
        {
            key: key1,
            value: value2
        },
        {
            key: key1,
            value: somevalue
        }
    ]
}

document 4:
{
    data: [
        {
            key: key3,
            value: blah
        }
    ]
}

现在我想要所有具有 至少 2 个值 [value1, value2, value3] 和键 key1 的文档。 因此，从示例中，我需要文档 1 和 3，但 不是 2 或 4。

到目前为止，我的查询如下所示：

"query": {
    "nested": {
        "path": "data",
        "query": {
            "bool": {
                "should": [
                    {
                        "bool": {
                            "must": [
                                {
                                    "term": {
                                        "key": key1
                                    }
                                },
                                {
                                    "term": {
                                        "value": {
                                            "value": "value1",
                                        }
                                    }
                                }
                            ]
                        }
                    },
                    {
                        "bool": {
                            "must": [
                                {
                                    "term": {
                                        "key": key1
                                    }
                                },
                                {
                                    "term": {
                                        "value": {
                                            "value": "value2",
                                        }
                                    }
                                }
                            ]
                        }
                    },
                    {
                        "bool": {
                            "must": [
                                {
                                    "term": {
                                        "key": key1
                                    }
                                },
                                {
                                    "term": {
                                        "value": {
                                            "value": "value3",
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ],
                "minimum_number_should_match": 2
            }
        }
    }
}

但它根本不返回任何匹配项。 据我了解，minimum_number_should_match 只是确保仅当文档至少匹配bool query 中给定的最小should 出现次数时才会返回。

• Minimum Should Match Documentation
• Bool Query Documentation

但我似乎并不完全理解它是如何工作的。 我究竟如何让minimum_number_should_match 使用嵌套布尔查询，或者有其他方法可以做到这一点？

Answer 1

这个查询应该适合你。我怀疑它会出错的唯一地方是使用关键字“value”作为字段。你可以试试。这是查询：

{
  "query": {
    "nested": {
      "path": "data",
      "query": {
        "bool": {
          "must": [
            {
              "term": {
                "key": {
                  "value": "key1"
                }
              }
            }
          ],"should": [
            {
              "term": {
                "value": {
                  "value": "value1"
                }
              }
            },{
              "term": {
                "value": {
                  "value": "value2"
                }
              }
            },{
              "term": {
                "value": {
                  "value": "value3"
                }
              }
            },{
              "term": {
                "value": {
                  "value": "value4"
                }
              }
            }
          ],"minimum_number_should_match": 2
        }
      }
    }
  }
}

关于 minimum_number_should_match 的工作原理，您是对的。它尝试匹配布尔查询的“应该”部分下的最小可能查询。

Answer 2

问题在于嵌套查询进入每个data 对象并查看单个键、值 对。 因此它不可能匹配多个值（每个 key, value 对只有一个值）。

我必须将每个值匹配拆分为它自己的嵌套查询：

{
  "query": {
    "bool": {
      "should": [
        {
          "nested": {
            "path": "data",
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "key": "key1"
                    }
                  },
                  {
                    "term": {
                      "value": {
                        "value": "value1"
                      }
                    }
                  }
                ]
              }
            }
          }
        },
        {
          "nested": {
            "path": "data",
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "key": "key1"
                    }
                  },
                  {
                    "term": {
                      "value": {
                        "value": "value2"
                      }
                    }
                  }
                ]
              }
            }
          }
        },
        {
          "nested": {
            "path": "data",
            "bool": {
              "must": [
                {
                  "term": {
                    "key": "key1"
                  }
                },
                {
                  "term": {
                    "value": {
                      "value": "value3"
                    }
                  }
                }
              ]
            }
          }
        }
      ],
      "minimum_should_match": 2
    }
  }
}

这意味着查询可以匹配多个data 字段，如果有两个应该查询匹配，则文档匹配整个查询。