当前位置: 首页 > 知识库问答 >
问题:

数组字段中的布尔查询

弘康安
2023-03-14

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

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是假的。如何进行查询以避免检索到此文档?

谢天谢地,吉尔默

共有2个答案

云焱
2023-03-14

另一种方法是将数组_字段_1放入。字符串\字段\ 3查询以及与布尔字段相关的布尔查询:

"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)OR(A AND(B OR C OR D))

宋宇
2023-03-14

这就是我的解决方案:

"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}}
                                                            ]
                                                        }
                                                      }
                                                }
                                              ]
                                          }
                                       }
                                   ]
                               }
        }
    ]
    }
}
 类似资料:
  • 问题内容: 这可能是一个非常愚蠢的问题,但是对数据库表中的布尔字段建立索引是否会有很多好处? 在常见情况下,例如标记为“无效”的“软删除”记录,因此大多数查询都包含,这将有助于对该字段进行单独索引,还是应将其与其他常见搜索字段组合在一起?不同的索引? 问题答案: 没有。 您可以对要搜索的字段具有较高的选择性/基数进行索引。几乎所有表都消除了布尔字段的基数。如果有的话,它将使您的写入速度变慢(降低的

  • 我们已经将Findbugs配置为通过Maven在Jenkins上运行。 除其他外,它抱怨以下代码行SE_BAD_FIELD: 这个bug的描述是 Se:可序列化类中的非瞬态非可序列化实例字段(Se\u BAD\u字段) 这个可序列化类定义了一个非原语实例字段,它既不是瞬态的、可序列化的,也不是java的。并且似乎没有实现可外部化的接口或readObject()和writeObject()方法。如果

  • 我被一件简单的事情困住了。我有一个名为“tags”的布尔值数组能够通过布尔值访问数组的每个元素对我来说很重要: 我传入trackTags数组并将布尔值赋给它(比如说[true,true,true,false])。因此,当我调用trackTags[0]时,我得到了“true”但是,当我打印“Energy”(能量)时,它应该与trackTags(0)相同,该值始终为false。我知道booleans

  • 我尝试使用函数JSON\u array\u elements()卸载JSON数组,并尝试使用JSON\u array\u length(field\u name)计算数组的元素,但没有成功。我使用的是PostgreSQL 9.4.5。 我想查询元素“name”的结果,这是json类型数组field crew | json[]上保存的数据。

  • 问题内容: 我们将Findbugs配置为通过Maven在我们的Jenkins上运行。 除其他外,它在以下代码行上抱怨SE_BAD_FIELD: 此错误的说明说 Se:可序列化类(SE_BAD_FIELD)中的非瞬态不可序列化实例字段 该Serializable类定义了一个非基本实例字段,该实例字段既不是临时的,Serializable的也不是java.lang.Object,并且似乎没有实现Ext