Elasticsearch查询 - Bool查询

Bool Query

在Elasticsearch中，Bool查询是一种组合查询，可以用于将多个查询组合在一起，并使用逻辑运算符（AND、OR、NOT）对它们进行组合。与其他三种基本查询不同，Bool查询可以实现更为复杂的查询需求。

下面对四种基本查询和Bool查询进行简单对比：

• Term Query: 精确匹配单个值，无法进行多个值的匹配，也无法进行多字段查询。
• Match Query: 支持分词匹配，可以进行多字段查询，但无法进行精确匹配和多个值的匹配。
• Range Query: 对数值型、日期型和字符串型的字段进行范围查询。
• Terms Query: 对某个字段精确匹配多个值。

基本语法

Bool查询则可以实现上述查询的组合，并支持多字段查询和精确匹配、模糊匹配、范围匹配等多种查询方式。下面我们来看一下Bool查询的基本语法：

{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "Search" }},
        { "match": { "content": "Elasticsearch" }}
      ],
      "filter": [
        { "term":  { "status": "published" }},
        { "range": { "publish_date": { "gte": "2019-01-01" }}} 
      ],
      "should": [
        { "match": { "author": "John" }},
        { "match": { "author": "Doe" }}
      ],
      "must_not": [
        { "match": { "category": "Marketing" }}
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• must：表示必须匹配的条件，相当于AND。
• filter：表示过滤条件，可以提高查询效率，相当于WHERE。
• should：表示应该匹配的条件，可以有多个，相当于OR。
• must_not：表示必须不匹配的条件，相当于NOT。

在这个查询中，必须同时匹配 title 和 content 字段，同时 status 字段必须为 published，publish_date 字段必须大于等于 2019-01-01，并且 author 字段必须匹配 John 或者 Doe 中的至少一个，同时 category 字段不能匹配 Marketing。

JavaAPI查询示例

SearchRequest searchRequest = new SearchRequest("index-name");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 创建Bool查询,并组合Match查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
    .must(QueryBuilders.matchQuery("title", "Search"))
    .must(QueryBuilders.matchQuery("content", "Elasticsearch"));
searchSourceBuilder.query(boolQuery);
searchRequest.source(searchSourceBuilder);

SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
SearchHits hits = searchResponse.getHits();
for (SearchHit hit : hits) {
    // handle search result
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

必须、不必须、应该、过滤

在Bool查询中，我们可以使用must、must_not、should关键词进行组合查询，它们分别代表了“必须满足”、“必须不满足”、“应该满足”的查询条件。具体来说，must和must_not是互斥的，而should与其它两个关键词则可以同时使用。

必须(must)

must：代表必须满足的查询条件，类似于“与”的关系。例如，查询文档中同时包含关键词“Elasticsearch”和“Java”的文档，可以使用如下查询：

GET /my_index/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "Elasticsearch" }},
        { "match": { "content": "search" }}
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

JavaAPI示例

BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
    .must(QueryBuilders.matchQuery("title", "Elasticsearch"))
    .must(QueryBuilders.matchQuery("content", "Java"));

1
2
3
4

不必须(must_not)

must_not：代表不能满足的查询条件，类似于“非”的关系。例如，查询文档中不包含关键词“Elasticsearch”的文档，可以使用如下查询：

GET /my_index/_search
{
 "query": {
   "bool": {
     "must_not": [
       { "match": { "title": "Elasticsearch" }},
       { "match": { "content": "search" }}
     ]
   }
 }
}
1
2
3
4
5
6
7
8
9
10
11

JavaAPI查询示例

BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
    .mustNot(QueryBuilders.matchQuery("title", "Elasticsearch"))
    .mustNot(QueryBuilders.matchQuery("content", "search"));
1
2
3

应该(should)

should：代表可选满足的查询条件，类似于“或”的关系。例如，查询文档中同时包含关键词“Elasticsearch”和“Java”，或者包含关键词“Elastic”，可以使用如下查询：

GET /my_index/_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "title": "Elasticsearch" }},
        { "match": { "content": "search" }}
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

JavaAPI查询示例

BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
    .should(QueryBuilders.boolQuery()
        .must(QueryBuilders.matchQuery("title", "Elasticsearch"))
        .must(QueryBuilders.matchQuery("content", "search")));

1
2
3
4
5

结果过滤(filter)

filter：代表无论是否满足都会参与计算的查询条件，它不会影响计算分数，只会过滤结果。例如，查询文档中发布时间在某个范围内的文档，可以使用如下查询：

GET /my_index/_search
{
  "query": {
    "bool": {
      "filter": [
        { "range": { "age": { "gte": 18, "lte": 30 }}},
        { "term": { "gender": "male" }}
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

JavaAPI查询示例

SearchRequest searchRequest = new SearchRequest("my_index"); 
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); 
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery() 
.filter(QueryBuilders.rangeQuery("age").gte(18).lte(30)) 
.filter(QueryBuilders.termQuery("gender", "male"));
1
2
3
4
5

组合查询示例

Bool查询中还可以嵌套其他的查询，从而实现更加复杂的查询逻辑。例如，可以将一个Range查询嵌套在一个must或should语句中，以实现范围查询和关键词查询的组合。

下面是一个示例，它将Range查询和Match查询进行了组合：

GET /my_index/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "age": {
              "gte": 18,
              "lte": 30
            }
          }
        },
        {
          "match": {
            "name": "John"
          }
        }
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这个查询的含义是，查询名字中包含"John"，并且年龄在18到30岁之间的文档。在这个查询中，must的作用是将两个条件必须同时满足。

总结

Bool查询是Elasticsearch中最为强大的查询方式之一，它能够通过将多个子查询进行逻辑组合的方式，实现复杂的查询需求。

在Bool查询中，可以使用must、must_not、should和filter这四种不同类型的子查询。其中，must代表必须满足的查询条件，must_not代表不能满足的查询条件，should代表可选满足的查询条件，而filter则是无论是否满足都会参与计算的查询条件。通过这些子查询的逻辑组合，可以实现复杂的查询需求。

在使用Bool查询时，需要使用QueryBuilders.boolQuery()创建一个BoolQueryBuilder对象，然后使用它的方法来添加子查询，最后将BoolQueryBuilder对象设置到SearchSourceBuilder对象中的query方法中即可完成查询。同时，Bool查询也支持一些其他的可选参数，如minimum_should_match、boost等，可根据实际需求进行设置。

总之，Bool查询是Elasticsearch中非常强大和灵活的查询方式，可以满足各种复杂的查询需求。