<!--秀川譯--> ###提高查詢得分 當然，`bool`查詢并不僅僅是組合多個簡單的一個詞的`match`查詢。他可以組合任何其他查詢，包括`bool`查詢。`bool`查詢通常會通過組合幾個不同查詢的得分為每個文檔調整相關性得分。 假設我們想查找關于"full-text search"的文檔，但是我們又想給涉及到“Elasticsearch”或者“Lucene”的文檔更高的權重。我們的用意是想涉及到"Elasticsearch" 或者 "Lucene"的文檔的相關性得分會比那些沒有涉及到的文檔的得分要高，也就是說這些文檔會出現在結果集更靠前的位置。 一個簡單的`bool`查詢允許我們寫出像下面一樣的非常復雜的邏輯： ```javascript GET /_search { "query": { "bool": { "must": { "match": { "content": { (1) "query": "full text search", "operator": "and" } } }, "should": [ (2) { "match": { "content": "Elasticsearch" }}, { "match": { "content": "Lucene" }} ] } } } ``` 1. `content`字段必須包含`full`,`text`,`search`這三個單詞。 2. 如果`content`字段也包含了“Elasticsearch”或者“Lucene”，則文檔會有一個更高的得分。 匹配的`should`子句越多，文檔的相關性就越強。到目前為止一切都很好。但是如果我們想給包含“Lucene”一詞的文檔比較高的得分，甚至給包含“Elasticsearch”一詞更高的得分要怎么做呢？ 我們可以在任何查詢子句中指定一個`boost`值來控制相對權重，默認值為1。一個大于1的`boost`值可以提高查詢子句的相對權重。因此我們可以像下面一樣重寫之前的查詢： ```javascript GET /_search { "query": { "bool": { "must": { "match": { (1) "content": { "query": "full text search", "operator": "and" } } }, "should": [ { "match": { "content": { "query": "Elasticsearch", "boost": 3 (2) } }}, { "match": { "content": { "query": "Lucene", "boost": 2 (3) } }} ] } } } ``` 1. 這些查詢子句的`boost`值為默認值`1`。 2. 這個子句是最重要的，因為他有最高的`boost`值。 3. 這個子句比第一個查詢子句的要重要，但是沒有“Elasticsearch”子句重要。 > 注意： > > 1. `boost`參數用于提高子句的相對權重（`boost`值大于`1`）或者降低子句的相對權重（`boost`值在`0`-`1`之間），但是提高和降低并非是線性的。換句話說，`boost`值為2并不能夠使結果變成兩部的得分。 > > 2. 另外，`boost`值被使用了以后新的得分是標準的。每個查詢類型都會有一個獨有的標準算法，算法的詳細內容并不在本書的范疇。簡單的概括一下，一個更大的`boost`值可以得到一個更高的得分。 > > 3. 如果你自己實現了沒有基于TF/IDF的得分模型，但是你想得到更多的對于提高得分過程的控制，你可以使用`function_score`查詢來調整一個文檔的boost值而不用通過標準的步驟。 我們會在下一章介紹更多的組合查詢，[【multi-field-search】](https://github.com/looly/elasticsearch-definitive-guide-cn/tree/master/110_Multi_Field_Search)。但是首先讓我們一起來看一下查詢的另外一個重要的特征：文本分析。 <!-- === Boosting Query Clauses Of course, the `bool` query isn't restricted ((("full text search", "boosting query clauses")))to combining simple one-word `match` queries. It can combine any other query, including other `bool` queries.((("relevance scores", "controlling weight of query clauses"))) It is commonly used to fine-tune the relevance `_score` for each document by combining the scores from several distinct queries. Imagine that we want to search for documents((("bool query", "boosting weight of query clauses")))((("weight", "controlling for query clauses"))) about "full-text search," but we want to give more _weight_ to documents that also mention "Elasticsearch" or "Lucene." By _more weight_, we mean that documents mentioning "Elasticsearch" or "Lucene" will receive a higher relevance `_score` than those that don't, which means that they will appear higher in the list of results. A simple `bool` _query_ allows us to write this fairly complex logic as follows: [source,js] -------------------------------------------------- GET /_search { "query": { "bool": { "must": { "match": { "content": { <1> "query": "full text search", "operator": "and" } } }, "should": [ <2> { "match": { "content": "Elasticsearch" }}, { "match": { "content": "Lucene" }} ] } } } -------------------------------------------------- // SENSE: 100_Full_Text_Search/25_Boost.json <1> The `content` field must contain all of the words `full`, `text`, and `search`. <2> If the `content` field also contains `Elasticsearch` or `Lucene`, the document will receive a higher `_score`. The more `should` clauses that match, the more relevant the document. So far, so good. But what if we want to give more weight to the docs that contain `Lucene` and even more weight to the docs containing `Elasticsearch`? We can control ((("boost parameter")))the relative weight of any query clause by specifying a `boost` value, which defaults to `1`. A `boost` value greater than `1` increases the relative weight of that clause. So we could rewrite the preceding query as follows: [source,js] -------------------------------------------------- GET /_search { "query": { "bool": { "must": { "match": { <1> "content": { "query": "full text search", "operator": "and" } } }, "should": [ { "match": { "content": { "query": "Elasticsearch", "boost": 3 <2> } }}, { "match": { "content": { "query": "Lucene", "boost": 2 <3> } }} ] } } } -------------------------------------------------- // SENSE: 100_Full_Text_Search/25_Boost.json <1> These clauses use the default `boost` of `1`. <2> This clause is the most important, as it has the highest `boost`. <3> This clause is more important than the default, but not as important as the `Elasticsearch` clause. [NOTE] [[boost-normalization]] ==== The `boost` parameter is used to increase((("boost parameter", "score normalied after boost applied"))) the relative weight of a clause (with a `boost` greater than `1`) or decrease the relative weight (with a `boost` between `0` and `1`), but the increase or decrease is not linear. In other words, a `boost` of `2` does not result in double the `_score`. Instead, the new `_score` is _normalized_ after((("normalization", "score normalied after boost applied"))) the boost is applied. Each type of query has its own normalization algorithm, and the details are beyond the scope of this book. Suffice to say that a higher `boost` value results in a higher `_score`. If you are implementing your own scoring model not based on TF/IDF and you need more control over the boosting process, you can use the <<function-score-query,`function_score` query>> to((("function_score query"))) manipulate a document's boost without the normalization step. ==== We present other ways of combining queries in the next chapter, <<multi-field-search>>. But first, let's take a look at the other important feature of queries: text analysis. -->