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只是确保文档只有在should中至少与给定的最小bool query次匹配时才会返回。

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

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如何运作，你是对的。它尝试匹配bool查询中“应该”部分下的最小可能查询。

Answer 2

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

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

{
  "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字段上匹配，如果2个应该查询匹配，则文档与整个查询匹配。

与嵌套必须bool

2 个答案: