« 复合查询 提升查询 »
Elastic 文档 ›Elasticsearch 指南 [8.14] ›查询 DSL ›复合查询

布尔查询

编辑

布尔查询编辑

一个查询，它匹配满足其他查询的布尔组合的文档。布尔查询映射到 Lucene BooleanQuery。它使用一个或多个布尔子句构建，每个子句都有一个类型的出现。出现类型是

出现 描述

must

该子句（查询）必须出现在匹配的文档中，并将有助于评分。

filter

该子句（查询）必须出现在匹配的文档中。但是，与 must 不同，查询的评分将被忽略。过滤器子句在 过滤器上下文 中执行，这意味着评分被忽略，并且子句被视为缓存。

should

该子句（查询）应该出现在匹配的文档中。

must_not

该子句（查询）不能出现在匹配的文档中。子句在 过滤器上下文 中执行，这意味着评分被忽略，并且子句被视为缓存。由于评分被忽略，因此所有文档的评分都返回 0。

bool 查询采用更多匹配更好的方法，因此每个匹配的 must 或 should 子句的评分将加在一起，以提供每个文档的最终 _score。

resp = client.search(
    body={
        "query": {
            "bool": {
                "must": {"term": {"user.id": "kimchy"}},
                "filter": {"term": {"tags": "production"}},
                "must_not": {"range": {"age": {"gte": 10, "lte": 20}}},
                "should": [
                    {"term": {"tags": "env1"}},
                    {"term": {"tags": "deployed"}},
                ],
                "minimum_should_match": 1,
                "boost": 1,
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      bool: {
        must: {
          term: {
            'user.id' => 'kimchy'
          }
        },
        filter: {
          term: {
            tags: 'production'
          }
        },
        must_not: {
          range: {
            age: {
              gte: 10,
              lte: 20
            }
          }
        },
        should: [
          {
            term: {
              tags: 'env1'
            }
          },
          {
            term: {
              tags: 'deployed'
            }
          }
        ],
        minimum_should_match: 1,
        boost: 1
      }
    }
  }
)
puts response
POST _search
{
  "query": {
    "bool" : {
      "must" : {
        "term" : { "user.id" : "kimchy" }
      },
      "filter": {
        "term" : { "tags" : "production" }
      },
      "must_not" : {
        "range" : {
          "age" : { "gte" : 10, "lte" : 20 }
        }
      },
      "should" : [
        { "term" : { "tags" : "env1" } },
        { "term" : { "tags" : "deployed" } }
      ],
      "minimum_should_match" : 1,
      "boost" : 1.0
    }
  }
}

使用 minimum_should_match编辑

您可以使用 minimum_should_match 参数来指定返回的文档必须匹配的 should 子句的数量或百分比。

如果 bool 查询包含至少一个 should 子句，并且没有 must 或 filter 子句，则默认值为 1。否则，默认值为 0。

有关其他有效值，请参阅 minimum_should_match 参数。

使用 bool.filter 评分编辑

在 filter 元素下指定的查询对评分没有影响——评分返回为 0。评分仅受已指定查询的影响。例如，以下三个查询都返回 status 字段包含术语 active 的所有文档。

第一个查询将所有文档的评分分配为 0，因为没有指定评分查询

$params = [
    'body' => [
        'query' => [
            'bool' => [
                'filter' => [
                    'term' => [
                        'status' => 'active',
                    ],
                ],
            ],
        ],
    ],
];
$response = $client->search($params);
resp = client.search(
    body={"query": {"bool": {"filter": {"term": {"status": "active"}}}}},
)
print(resp)
response = client.search(
  body: {
    query: {
      bool: {
        filter: {
          term: {
            status: 'active'
          }
        }
      }
    }
  }
)
puts response
res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "bool": {
	      "filter": {
	        "term": {
	          "status": "active"
	        }
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)
const response = await client.search({
  body: {
    query: {
      bool: {
        filter: {
          term: {
            status: 'active'
          }
        }
      }
    }
  }
})
console.log(response)
GET _search
{
  "query": {
    "bool": {
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

此 bool 查询具有一个 match_all 查询，它将所有文档的评分分配为 1.0。

$params = [
    'body' => [
        'query' => [
            'bool' => [
                'must' => [
                    'match_all' => [
                    ],
                ],
                'filter' => [
                    'term' => [
                        'status' => 'active',
                    ],
                ],
            ],
        ],
    ],
];
$response = $client->search($params);
resp = client.search(
    body={
        "query": {
            "bool": {
                "must": {"match_all": {}},
                "filter": {"term": {"status": "active"}},
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      bool: {
        must: {
          match_all: {}
        },
        filter: {
          term: {
            status: 'active'
          }
        }
      }
    }
  }
)
puts response
res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "bool": {
	      "must": {
	        "match_all": {}
	      },
	      "filter": {
	        "term": {
	          "status": "active"
	        }
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)
const response = await client.search({
  body: {
    query: {
      bool: {
        must: {
          match_all: {}
        },
        filter: {
          term: {
            status: 'active'
          }
        }
      }
    }
  }
})
console.log(response)
GET _search
{
  "query": {
    "bool": {
      "must": {
        "match_all": {}
      },
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

此 constant_score 查询的行为与上面的第二个示例完全相同。 constant_score 查询将所有由过滤器匹配的文档的评分分配为 1.0。

$params = [
    'body' => [
        'query' => [
            'constant_score' => [
                'filter' => [
                    'term' => [
                        'status' => 'active',
                    ],
                ],
            ],
        ],
    ],
];
$response = $client->search($params);
resp = client.search(
    body={
        "query": {
            "constant_score": {"filter": {"term": {"status": "active"}}}
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      constant_score: {
        filter: {
          term: {
            status: 'active'
          }
        }
      }
    }
  }
)
puts response
res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "constant_score": {
	      "filter": {
	        "term": {
	          "status": "active"
	        }
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)
const response = await client.search({
  body: {
    query: {
      constant_score: {
        filter: {
          term: {
            status: 'active'
          }
        }
      }
    }
  }
})
console.log(response)
GET _search
{
  "query": {
    "constant_score": {
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

命名查询编辑

每个查询在其顶层定义中接受一个 _name。您可以使用命名查询来跟踪哪些查询匹配返回的文档。如果使用命名查询，则响应将为每个命中包含一个 matched_queries 属性。

在同一个请求中提供重复的 _name 值会导致未定义的行为。具有重复名称的查询可能会互相覆盖。查询名称假定在单个请求中是唯一的。

resp = client.search(
    body={
        "query": {
            "bool": {
                "should": [
                    {
                        "match": {
                            "name.first": {
                                "query": "shay",
                                "_name": "first",
                            }
                        }
                    },
                    {
                        "match": {
                            "name.last": {
                                "query": "banon",
                                "_name": "last",
                            }
                        }
                    },
                ],
                "filter": {
                    "terms": {
                        "name.last": ["banon", "kimchy"],
                        "_name": "test",
                    }
                },
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      bool: {
        should: [
          {
            match: {
              'name.first' => {
                query: 'shay',
                _name: 'first'
              }
            }
          },
          {
            match: {
              'name.last' => {
                query: 'banon',
                _name: 'last'
              }
            }
          }
        ],
        filter: {
          terms: {
            'name.last' => [
              'banon',
              'kimchy'
            ],
            _name: 'test'
          }
        }
      }
    }
  }
)
puts response
GET /_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "name.first": { "query": "shay", "_name": "first" } } },
        { "match": { "name.last": { "query": "banon", "_name": "last" } } }
      ],
      "filter": {
        "terms": {
          "name.last": [ "banon", "kimchy" ],
          "_name": "test"
        }
      }
    }
  }
}

名为 include_named_queries_score 的请求参数控制是否返回与匹配的查询相关的评分。设置后，响应将包含一个 matched_queries 映射，该映射包含匹配的查询的名称作为键，其关联的评分作为值。

请注意，评分可能没有对文档的最终评分做出贡献，例如出现在过滤器或 must_not 上下文中的命名查询，或者在忽略或修改评分的子句（如 constant_score 或 function_score_query）中。

resp = client.search(
    include_named_queries_score=True,
    body={
        "query": {
            "bool": {
                "should": [
                    {
                        "match": {
                            "name.first": {
                                "query": "shay",
                                "_name": "first",
                            }
                        }
                    },
                    {
                        "match": {
                            "name.last": {
                                "query": "banon",
                                "_name": "last",
                            }
                        }
                    },
                ],
                "filter": {
                    "terms": {
                        "name.last": ["banon", "kimchy"],
                        "_name": "test",
                    }
                },
            }
        }
    },
)
print(resp)
response = client.search(
  include_named_queries_score: true,
  body: {
    query: {
      bool: {
        should: [
          {
            match: {
              'name.first' => {
                query: 'shay',
                _name: 'first'
              }
            }
          },
          {
            match: {
              'name.last' => {
                query: 'banon',
                _name: 'last'
              }
            }
          }
        ],
        filter: {
          terms: {
            'name.last' => [
              'banon',
              'kimchy'
            ],
            _name: 'test'
          }
        }
      }
    }
  }
)
puts response
GET /_search?include_named_queries_score
{
  "query": {
    "bool": {
      "should": [
        { "match": { "name.first": { "query": "shay", "_name": "first" } } },
        { "match": { "name.last": { "query": "banon", "_name": "last" } } }
      ],
      "filter": {
        "terms": {
          "name.last": [ "banon", "kimchy" ],
          "_name": "test"
        }
      }
    }
  }
}

此功能在搜索响应中的每个命中上重新运行每个命名查询。通常，这会给请求增加少量开销。但是，在大量命中上使用计算量大的命名查询可能会增加大量开销。例如，命名查询与许多桶上的 top_hits 聚合组合使用可能会导致响应时间更长。

« 复合查询 提升查询 »