数组字段中的布尔查询

Question

关于查询嵌套到数组字段的布尔字段和字符串字段，我有一个非常特殊的问题。索引映射如下：

indexes :string_field_1, type: 'string'
indexes :string_field_2, type: 'string'
indexes :boolean_field_1, type: 'boolean'
indexes :array_field_1 do
           indexes :boolean_field_2, type: 'boolean'
           indexes :string_field_3, type: 'string'
end
indexes :array_field_2 do
           indexes :integer_field_1, type: 'integer'
end
indexes :array_field_3 do
           indexes :integer_field_2, type: 'integer'
end

文档索引还有许多其他字段，它们没有嵌套到数组字段中，但必须包含在查询字段中。 我尝试了一种使用过滤器和布尔查询的方法，如下所示：

"query":
        {"bool":
                {"must":
                        [
                                {"query_string":
                                        {"query":"text which is being searched",
                                        "fields":[
                                                "string_field_1",
                                                "string_field_2",
                                                "array_field_1.string_field_3"
                                                ],
                                        "fuzziness":"1","analyze_wildcard":true,"auto_generate_phrase_queries":false,"analyzer":"brazilian","default_operator":"AND"}
                                }
                        ],
                        "filter":[
                                {"bool":
                                        {"must":
                                                [
                                                        {"bool":
                                                                {"should":
                                                                        [
                                                                                {"term":{"boolean_field_1":false}},
                                                                                {"terms":{"array_field_2.integer_field_1":[x,z]}},
                                                                                {"term":{"array_field_3.integer_field_2":y}}]}},
                                                        {"bool":
                                                                {"should":
                                                                        [
                                                                                {"term":{"array_field_1.boolean_field_2":true}},
                                                                                {"terms":{"array_field_2.integer_field_1":[x,z]}},
                                                                                {"term":{"array_field_3.integer_field_2":y}}]}},
                                                                        ]
                                                                }
                                                        }
                                                ]
                                        }
                                }
                        ]
                }
}

这个查询的问题在于它返回的文档在我看来是不必返回的。 在这种情况下，文档如下所示：

_source": {
    "string_field_1": "text 1",
    "string_field_2": "text 2",
    "boolean_field_1": false, 
    "array_field_1": [
        {
            "boolean_field_2": true,
            "string_field_3": "some text which is not being searched"
        },
        {
            "boolean_field_2": true,
            "string_field_3": "some text which is not being searched"
        },
        {
            "boolean_field_2": false,
            "string_field_3": "text which is being searched"
        },
        {
            "boolean_field_2": true,
            "string_field_3": "some text which is not being searched"
        }
    ],
    "array_field_2": [
        {
            "integer_field_1": A
        }
    ],
    "array_field_3": [
        {
            "integer_field_2": B
        }
    ]
}

如您所见，array_field_1 的第三项包含 boolean_field_2: false 以及正在搜索的文本。但是，根据我的 filter: 子句，只有 array_field_1.boolean_field_2 为真的文档必须被检索，除非 array_field_2.integer_field_1: 或 array_field_3.integer_field_1 出现，根据我的查询部分，这不是真的。 似乎弹性没有考虑到 array_field_1[2] 是 boolean_field_2 为假的那个。 如何进行查询，以免检索到此文档？

谢谢提前， 吉尔赫姆

Answer 1

这是我的解决方案：

"query":{
    "bool":{
        "should":
        [
            {
                "query_string":
                    {
                        "query":"text which is being searched",
                        "fields":
                            [
                                "string_field_1",
                                                       "string_field_2"
                            ],
                            "fuzziness":"1","analyze_wildcard":true,"auto_generate_phrase_queries":false,"analyzer":"brazilian","default_operator":"AND"
                    }
            },
            {
                 bool: {
                                   should:[
                                       {
                                           query:{
                                               nested: {
                                                   path: 'array_field_1',
                                                   query: {
                                                       bool: {
                                                           must: [
                                                               { match: { "array_field_1.string_field_3": "text which is being searched"} },
                                                               {term: {"array_field_1.boolean_field_2": true}}
                                                           ]
                                                       }
                                                  }
                                              }
                                          }
                                       },
                                       {
                                          bool:
                                          {
                                            must: [
                                             {
                                                     query:{
                                                         nested: {
                                                             path: 'movimentos',
                                                             query: {
                                                                 bool: {
                                                                     must: [
                                                                         { match: { "array_field_1.string_field_3": "text which is being searched"} },
                                                                         {term: {"array_field_1.boolean_field_2": false
                                                                     ]
                                                                 }
                                                             }
                                                         }
                                                     }
                                                },
                                                {
                                                  query: {
                                                    bool: {
                                                            should: [
                                                              {"terms":{"array_field_2.integer_field_1":[x,z]}},
                                                              {"term":{"array_field_3.integer_field_2":y}}
                                                            ]
                                                        }
                                                      }
                                                }
                                              ]
                                          }
                                       }
                                   ]
                               }
        }
    ]
    }
}

Answer 2

另一种方法是将 array_field_1.string_field_3 查询与与布尔字段相关的 bool 查询放在一起：

"query":{
    "bool":{
        "should":
        [
            {
                "query_string":
                    {
                        "query":"text which is being searched",
                        "fields":
                            [
                                "string_field_1",
                                "string_field_2"
                            ],
                            "fuzziness":"1","analyze_wildcard":true,"auto_generate_phrase_queries":false,"analyzer":"brazilian","default_operator":"AND"
                    }
            },
            {
                "bool":{
                    "must":
                    [
                        {
                            "query_string":
                            {
                                "query":"text which is being searched",
                                "fields":["array_field_1.string_field_3"],
                                "fuzziness":"1","analyze_wildcard":true,"auto_generate_phrase_queries":false,"analyzer":"brazilian","default_operator":"AND"
                            }
                        },
                        {
                            "bool":{
                                "should":
                                [
                                    {"term":{"array_field_1.boolean_field_2":true}},
                                    {"terms":{"array_field_2.integer_field_1":[x,z]}},
                                    {"term":{"array_field_3.integer_field_2":y}}
                                ]
                            }
                        }
                    ]
                }
            }
        ],
        "filter":
        [
            {
                "bool":{
                    "should":
                    [
                        {"term":{"boolean_field_1":false}},
                        {"terms":{"array_field_2.integer_field_1":[x,z]}},
                        {"term":{"array_field_3.integer_field_2":y}}
                    ]
                }
            }
        ]
    }
}

不幸的是，此查询还检索文档。我真的不知道如何正确构建这个查询。

上面的查询组织为： (X) 或 (A 与 (B 或 C 或 D)))