Elasticsearch的搜索查询

2020-12-16 07:03:04 编辑 0 阅读量:600

es种有两种查询模式。
# 一、Query String
一种是像传递URL参数一样去传递查询语句，被称为**简单搜索**或**查询字符串(query string)搜索**，比如
```
GET /megacorp/employee/_search //查询全部员工
GET /megacorp/employee/_search?q=last_name:Smith //查询last_name为Smith的员工
```
# 二、Query DSL
另外一种是通过DSL语句来进行查询，被称为**DSL查询(Query DSL)**,DSL是Elasticsearch提供的一种丰富且灵活的查询语言，该语言以json请求体的形式出现，通过restful请求与Elasticsearch进行交互，本文主要讲DSL查询的一些常用规则，在介绍之前，我们先简单插入一个测试用的小例子(假设我们已经有了一个elasticsearch测试环境且装好了分词插件, 如果需要查看如何安装中文环境，可浏览我的另一篇文章Elasticsearch中文搜索环境搭建)。
```
 $curl -XPOST http://localhost:9200/index/doc/1 -d'{"content":"美国留给伊拉克的是个烂摊子吗","title":"标题","tags":["美国","伊拉克","烂摊子"]}'
 $curl -XPOST http://localhost:9200/index/doc/2 -d'{"content":"中国是世界上人口最多的国家","title":"中国","tags":["中国","人口"]}'
 $curl -XPOST http://localhost:9200/index/doc/3 -d'{"content":"同一个世界同一个梦想","title":"北京奥运","tags":["和平"]}'
 $curl -XPOST http://localhost:9200/index/doc/4 -d'{"content":"杭州是一个美丽的城市,欢迎来到杭州","title":"宣传","tags":["旅游","城市"]}'
 ```
检查一下我们的数据是否导入成功
```
$curl -XGET http://localhost:9200/index/doc/_search
{"took":1,"timed_out":false,"_shards":{"total":5,"successful":5,"failed":0},"hits":{"total":4,"max_score":1.0,"hits":[{"_index":"index","_type":"doc","_id":"2","_score":1.0,"_source":{"content":"中国是世界上人口最多的国家","title":"中国","tags":["中国","人口"]}},{"_index":"index","_type":"doc","_id":"4","_score":1.0,"_source":{"content":"杭州是一个美丽的城市,欢迎来到杭州","title":"宣传","tags":["旅游","城市"]}},{"_index":"index","_type":"doc","_id":"1","_score":1.0,"_source":{"content":"美国留给伊拉克的是个烂摊子吗","title":"标题","tags":["美国","伊拉克","烂摊子"]}},{"_index":"index","_type":"doc","_id":"3","_score":1.0,"_source":{"content":"同一个世界同一个梦想","title":"北京奥运","tags":["和平"]}}]}}
```
ok，导入成功，接下来利用这些数据逐步介绍各种常用查询

## 1. term查询

term是代表完全匹配，也就是精确查询，搜索前不会再对搜索词进行分词，所以我们的搜索词必须是文档分词集合中的一个。比如说我们要找标题为北京奥运的所有文档
```
$curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
  "query":{
    "term":{
        "title":"北京奥运"
    }
  }
}'
```
将会得到如下结果
```
{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
    "total": 1,
    "max_score": 0.92055845,
    "hits": [
     {
        "_index": "index",
        "_type": "doc",
        "_id": "3",
        "_score": 0.92055845,
        "_source": {
           "content": "同一个世界同一个梦想",
           "title": "北京奥运",
           "tags": [
               "和平"
            ]
        }
      }
    ]
  }
}
```
搜索title包含`北京`或者`奥运`的，结果也一样，但是如果你搜索词为`京奥`,或者`北京奥`这样的，那么搜索结果将为空
```
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
      "total" : 5,
      "successful" : 5,
      "failed" : 0
  },
  "hits" : {
      "total" : 0,
      "max_score" : null,
      "hits" : [ ]
  }
}
```
这是因为在对文档建立索引时，会将北京奥运分词为北京，奥运，北京奥运，只要搜索词为这三个之一，都可以将这篇文章搜索出来，而京奥和北京奥并不在分词集合里，所以无法搜索到该文档。
如果对于某个字段，你想精确匹配，即搜索什么词匹配什么词，类似sql中的=操作，比如只能通过北京奥运搜索到文档3而不想让北京和奥运也搜索到，那么，你可以在建立索引阶段指定该字段为"index": "not_analyzed",此时，elasticsearch将不会对该字段的值进行分词操作，只保留全文字索引。比如本例子中的tags字段,我在建立索引时设置了"index": "not_analyzed", 搜索时，不管是指定tags为美，还是国，都无法将第一条结果搜索出来
```
$curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
  "query":{
    "term":{
        "tags":"美"
    }
  }
}'
```
搜索结果：
```
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
      "total" : 5,
      "successful" : 5,
      "failed" : 0
  },
  "hits" : {
      "total" : 0,
      "max_score" : null,
      "hits" : [ ]
  }
}
```
而全词美国却可以
```
$curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
  "query":{
    "term":{
        "tags":"美国"
    }
  }
}'
```
搜索结果：
```
{
    "took" : 2,
    "timed_out" : false,
    "_shards" : {
        "total" : 5,
        "successful" : 5,
        "failed" : 0
    },
    "hits" : {
        "total" : 1,
        "max_score" : 0.30685282,
        "hits" : [ {
            "_index" : "index",
            "_type" : "doc",
            "_id" : "1",
            "_score" : 0.30685282,
            "_source" : {
                  "content" : "美国留给伊拉克的是个烂摊子吗",
                  "title" : "标题",
                  "tags" : [ "美国", "伊拉克", "烂摊子" ]
            }
      } ]
  }
}
```
## 2. match类查询

match查询会先对搜索词进行分词,分词完毕后再逐个对分词结果进行匹配，因此相比于term的精确搜索，match是分词匹配搜索,match搜索还有两个相似功能的变种，一个是match_phrase，一个是multi_match，接下来详细介绍一下

### 2.1 match

前面提到match搜索会先对搜索词进行分词，对于最基本的match搜索来说，只要搜索词的分词集合中的一个或多个存在于文档中即可，例如，当我们搜索中国杭州，搜索词会先分词为中国和杭州,只要文档中包含搜索和杭州任意一个词，都会被搜索到
```
$curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
    "query": {
        "match": {
            "content": "中国杭州"
        }
    }
}'
```
文档3正文中有杭州，文档2中有中国，因此搜索结果有两个，文档3中杭州出现两次，所以排在前面，结果如下：
```
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
      "total" : 2,
      "max_score" : 0.99999994,
      "hits" : [ {
            "_index" : "index",
            "_type" : "doc",
            "_id" : "4",
            "_score" : 0.99999994,
            "_source" : {
                 "content" : "杭州是一个美丽的城市,欢迎来到杭州",
                "title" : "宣传",
                "tags" : [ "旅游", "城市" ]
            }
       }, {
            "_index" : "index",
            "_type" : "doc",
            "_id" : "2",
            "_score" : 0.8838835,
            "_source" : {
                  "content" : "中国是世界上人口最多的国家",
                  "title" : "中国",
                  "tags" : [ "中国", "人口" ]
            }
       } ]
    }
}
```
同样的，我们用match的方式搜索中国世界，那么，文档2(含有中国和世界)和文档3(含有世界都会被搜索出来)。如果我们仅仅想搜索中国和世界都包含的文档该怎么办呢？
其实，对于match搜索，可以按照分词后的分词集合的or或者and进行匹配，`默认为or`，这也是为什么我们看到前面的搜索都是只要有一个分词出现在文档中就会被搜索出来，同样的，如果我们希望是所有分词都要出现，那只要把**匹配模式**改成and就行了
```
curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
    "query": {
        "match": {
            "content": {
                "query": "中国世界",
                "operator": "and"
            }
        }
    }
}'
```
如上所示，查询时将operator设置为and，此时，就只会搜索到既包含中国，也包含世界的文档了(因返回的字段较多，后面搜索结果只展示_source中的内容)
```
"_source" : {
    "content" : "中国是世界上人口最多的国家",
    "title" : "中国",
    "tags" : [ "中国", "人口" ]
}
```
### 2.2 match_phrase

match_phrase为按短语搜索，这个可能先用英文来解释会直观一点(中文分词后其实已经是一个一个有具体意思的词语)。英文中以空格分词，因此分词后是一个个的单词，当想搜索类似hope so这样的短语时，你或许并不想将一些只含有hope的文档搜索出来，也不想将一些类似I hope ×××. So ××这样的搜索出来，此时，就可以用match_phrase。
match_phrase的搜索方式和match类似，先对搜索词建立索引，并要求所有分词必须在文档中出现(像不像operator为and的match查询)，除此之外，还必须满足分词在文档中出现的顺序和搜索词中一致且各搜索词之间必须紧邻，因此match_phrase也可以叫做**紧邻搜索**。
所以，当我们搜`美国留给`时
```
curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
  "query": {
    "match_phrase": {
        "content": "美国留给"
    }
  }
}'
```
能搜出文档美国留给伊拉克的是个烂摊子吗
```
    "_source" : {
        "content" : "美国留给伊拉克的是个烂摊子吗",
        "title" : "标题",
        "tags" : [ "美国", "伊拉克", "烂摊子" ]
    }
```
但是我们搜索留给`美国`或`美国伊拉克`时，却没有搜索结果，因为一个顺序不对，一个不是紧邻(隔着留给)。
紧邻对于匹配度要求较高，为了减小精度增加可操作性，引入了`slop`参数。该参数可以指定相隔多少个词仍被算作匹配成功。如下，
```
curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
    "query": {
        "match_phrase": {
            "content": {
                "query": "美国伊拉克",
                "slop": "1"
            }
        }
    }
}'
```
当我们将slop设置为1时，文档1已能被搜索到。
```
  "_source" : {
    "content" : "美国留给伊拉克的是个烂摊子吗",
    "title" : "标题",
    "tags" : [ "美国", "伊拉克", "烂摊子" ]
  }
```
需要注意的是，当slop的值过大时(超出文档总分词数)，那么分词数据将可以是随意的，即跟operator为and的match查询效果一样。比如我们查询
```
curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
    "query": {
        "match_phrase": {
            "content": {
                "query": "伊拉克美国",
                "slop": "12"
            }
        }
    }
}'
```
将会得到与上面一样的结果

### 2.3 multi_match

当我们想对多个字段进行匹配，其中只要一个字段包含分词就被文档就被搜索到时，可以用multi_match
```
curl -XGET http://localhost:9200/index/doc/_search?pretty -d 
'{
    "query": {
        multi_match":{
          "query":"11",
          "fields":["Tr","Tq"]
        }
    }
}'
```

## 3. filter查询
过滤器在概念上类似于查询，但是它们有非常快的执行速度，这种快的执行速度主要有以下两个原因
- 过滤器不会计算相关度的得分，所以它们在计算上更快一些
- 过滤器可以被缓存到内存中，这使得在重复的搜索查询上，其要比相应的查询快出许多。

---

这里转一篇非常好的关于Elasticsearch检索查询的文章：
To illustrate the different query types in Elasticsearch, we will be searching a collection of book documents with the following fields: title, authors, summary, release date, and number of reviews.

But first, let’s create a new index and index some documents using the bulk API:
```
PUT /bookdb_index
    { "settings": { "number_of_shards": 1 }}
POST /bookdb_index/book/_bulk
    { "index": { "_id": 1 }}
    { "title": "Elasticsearch: The Definitive Guide", "authors": ["clinton gormley", "zachary tong"], "summary" : "A distibuted real-time search and analytics engine", "publish_date" : "2015-02-07", "num_reviews": 20, "publisher": "oreilly" }
    { "index": { "_id": 2 }}
    { "title": "Taming Text: How to Find, Organize, and Manipulate It", "authors": ["grant ingersoll", "thomas morton", "drew farris"], "summary" : "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization", "publish_date" : "2013-01-24", "num_reviews": 12, "publisher": "manning" }
    { "index": { "_id": 3 }}
    { "title": "Elasticsearch in Action", "authors": ["radu gheorge", "matthew lee hinman", "roy russo"], "summary" : "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms", "publish_date" : "2015-12-03", "num_reviews": 18, "publisher": "manning" }
    { "index": { "_id": 4 }}
    { "title": "Solr in Action", "authors": ["trey grainger", "timothy potter"], "summary" : "Comprehensive guide to implementing a scalable search engine using Apache Solr", "publish_date" : "2014-04-05", "num_reviews": 23, "publisher": "manning" }
```
Examples
## 1. Basic Match Query
There are a two ways of executing a basic full-text (match) query: using the Search Lite API which expects all the search parameters to be passed in as part of the URL, or using the full JSON request body which allows you use the full Elasticsearch DSL.

Here is a basic match query that searches for the string “guide” in all the fields:
```
GET /bookdb_index/book/_search?q=guide
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.28168046,
        "_source": {
          "title": "Elasticsearch: The Definitive Guide",
          "authors": [
            "clinton gormley",
            "zachary tong"
          ],
          "summary": "A distibuted real-time search and analytics engine",
          "publish_date": "2015-02-07",
          "num_reviews": 20,
          "publisher": "manning"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.24144039,
        "_source": {
          "title": "Solr in Action",
          "authors": [
            "trey grainger",
            "timothy potter"
          ],
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "publish_date": "2014-04-05",
          "num_reviews": 23,
          "publisher": "manning"
        }
      }
    ]
```
The full body version of this query is shown below and produces same results as the above search lite.
```
{
    "query": {
        "multi_match" : {
            "query" : "guide",
            "fields" : ["_all"]
        }
    }
}
```
The multi_match keyword is used in place of the match keyword as a convenient shorthand way of running the same query against multiple fields. The fields property specifies what fields to query against and in this case we want to query against all the fields in the document.

Both APIs also allow you specify what fields you want to search on. For example, to search for books with the words “in Action” in the title field:
```
GET /bookdb_index/book/_search?q=title:in action
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": 0.6259885,
 "_source": {
 "title": "Solr in Action",
 "authors": [
 "trey grainger",
 "timothy potter"
 ],
 "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
 "publish_date": "2014-04-05",
 "num_reviews": 23,
 "publisher": "manning"
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "3",
 "_score": 0.5975345,
 "_source": {
 "title": "Elasticsearch in Action",
 "authors": [
 "radu gheorge",
 "matthew lee hinman",
 "roy russo"
 ],
 "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
 "publish_date": "2015-12-03",
 "num_reviews": 18,
 "publisher": "manning"
 }
 }
 ]
```
However, the full body DSL gives you more flexibility in creating more complicated queries (as we will see later) and in specifying how you want the results back. In the example below, we specify the number of results we want back, the offset to start from (useful for pagination), the document fields we want returned, and term highlighting.
```
POST /bookdb_index/book/_search
{
 "query": {
 "match" : {
 "title" : "in action"
 }
 },
 "size": 2,
 "from": 0,
 "_source": [ "title", "summary", "publish_date" ],
 "highlight": {
 "fields" : {
 "title" : {}
 }
 }
}
[Results]
"hits": {
 "total": 2,
 "max_score": 0.9105287,
 "hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "3",
 "_score": 0.9105287,
 "_source": {
 "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
 "title": "Elasticsearch in Action",
 "publish_date": "2015-12-03"
 },
 "highlight": {
 "title": [
 "Elasticsearch in Action"
 ]
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": 0.9105287,
 "_source": {
 "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
 "title": "Solr in Action",
 "publish_date": "2014-04-05"
 },
 "highlight": {
 "title": [
 "Solr in Action"
 ]
 }
 }
 ]
 }
```
Note: For multi-word queries, the match query lets you specify whether to use the and operator instead of the default or operator. You can also specify the minimum_should_match option to tweak relevance of the returned results. Details can be found in the [Elasticsearch guide](https://www.elastic.co/guide/en/elasticsearch/guide/current/match-multi-word.html).

## 2.Multi-field Search
As we’ve seen already, to query more than one document field in a search (e.g. searching for the same query string in both the title and the summary) you use the multi_match query.
```
POST /bookdb_index/book/_search
{
    "query": {
        "multi_match" : {
            "query" : "elasticsearch guide",
            "fields": ["title", "summary"]
        }
    }
}
[Results]
"hits": {
    "total": 3,
    "max_score": 0.9448582,
    "hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.9448582,
        "_source": {
          "title": "Elasticsearch: The Definitive Guide",
          "authors": [
            "clinton gormley",
            "zachary tong"
          ],
          "summary": "A distibuted real-time search and analytics engine",
          "publish_date": "2015-02-07",
          "num_reviews": 20,
          "publisher": "manning"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 0.17312013,
        "_source": {
          "title": "Elasticsearch in Action",
          "authors": [
            "radu gheorge",
            "matthew lee hinman",
            "roy russo"
          ],
          "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
          "publish_date": "2015-12-03",
          "num_reviews": 18,
          "publisher": "manning"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.14965448,
        "_source": {
          "title": "Solr in Action",
          "authors": [
            "trey grainger",
            "timothy potter"
          ],
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "publish_date": "2014-04-05",
          "num_reviews": 23,
          "publisher": "manning"
        }
      }
    ]
  }
```
Note that hit number 3 matched because the word “guide” was found in the summary.

## 3. Boosting
Since we are searching across multiple fields, we may want to boost the scores in a certain field. In the contrived example below, we boost scores from the summary field by a factor of 3 in order to increase the importance of the summary field, which will in turn increase the relevance of document _id 4.
```
POST /bookdb_index/book/_search
{
    "query": {
        "multi_match" : {
            "query" : "elasticsearch guide",
            "fields": ["title", "summary^3"]
        }
    },
    "_source": ["title", "summary", "publish_date"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.31495273,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.14965448,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 0.13094766,
        "_source": {
          "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
          "title": "Elasticsearch in Action",
          "publish_date": "2015-12-03"
        }
      }
    ]
```
Note: Boosting does not merely imply that the calculated score gets multiplied by the boost factor. The actual boost value that is applied goes through normalization and some internal optimization. More information on how boosting works can be found in the Elasticsearch guide.

## 4. Bool Query
The AND/OR/NOT operators can be used to fine tune our search queries in order to provide more relevant or specific results. This is implemented in the search API as a bool query. The bool query accepts a must parameter (equivalent to AND), a must_not parameter (equivalent to NOT), and a should parameter (equivalent to OR). For example, if I want to search for a book with the word “Elasticsearch” OR “Solr” in the title, AND is authored by “clinton gormley” but NOT authored by “radu gheorge”:
```
POST /bookdb_index/book/_search
{
    "query": {
        "bool": {
            "must": {
                "bool" : { "should": [
                      { "match": { "title": "Elasticsearch" }},
                      { "match": { "title": "Solr" }} ] }
            },
            "must": { "match": { "authors": "clinton gormely" }},
            "must_not": { "match": {"authors": "radu gheorge" }}
        }
    }
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.3672021,
        "_source": {
          "title": "Elasticsearch: The Definitive Guide",
          "authors": [
            "clinton gormley",
            "zachary tong"
          ],
          "summary": "A distibuted real-time search and analytics engine",
          "publish_date": "2015-02-07",
          "num_reviews": 20,
          "publisher": "oreilly"
        }
      }
    ]
```
Note: As you can see, a bool query can wrap any other query type including other bool queries to create arbitrarily complex or deeply nested queries.

## 5. Fuzzy Queries
Fuzzy matching can be enabled on Match and Multi-Match queries to catch spelling errors. The degree of fuzziness is specified based on the Levenshtein distance from the original word.
```
POST /bookdb_index/book/_search
{
    "query": {
        "multi_match" : {
            "query" : "comprihensiv guide",
            "fields": ["title", "summary"],
            "fuzziness": "AUTO"
        }
    },
    "_source": ["title", "summary", "publish_date"],
    "size": 1
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.5961596,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      }
    ]
```
Note: The fuzziness value of "AUTO" is equivalent to specifying a value of 2 when the term length is greater than 5. However, setting 80% of human misspellings have an edit distance of 1 and setting the fuzziness to 1 may improve your overall search performance. See the Typos and Misspellings chapter of Elasticsearch the Definitive Guide for more information.

## 6. Wildcard Query
Wildcard queries allow you to specify a pattern to match instead of the entire term. ? matches any character and * matches zero or more characters. For example, to find all records that have an author whose name begins with the letter ‘t’
```
POST /bookdb_index/book/_search
{
 "query": {
 "wildcard" : {
 "authors" : "t*"
 }
 },
 "_source": ["title", "authors"],
 "highlight": {
 "fields" : {
 "authors" : {}
 }
 }
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "1",
 "_score": 1,
 "_source": {
 "title": "Elasticsearch: The Definitive Guide",
 "authors": [
 "clinton gormley",
 "zachary tong"
 ]
 },
 "highlight": {
 "authors": [
 "zachary tong"
 ]
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "2",
 "_score": 1,
 "_source": {
 "title": "Taming Text: How to Find, Organize, and Manipulate It",
 "authors": [
 "grant ingersoll",
 "thomas morton",
 "drew farris"
 ]
 },
 "highlight": {
 "authors": [
 "thomas morton"
 ]
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": 1,
 "_source": {
 "title": "Solr in Action",
 "authors": [
 "trey grainger",
 "timothy potter"
 ]
 },
 "highlight": {
 "authors": [
 "trey grainger",
 "timothy potter"
 ]
 }
 }
 ]
```
## 7. Regexp Query
Regexp queries allow you specify more complex patterns than wildcard queries.
```
POST /bookdb_index/book/_search
{
 "query": {
 "regexp" : {
 "authors" : "t[a-z]*y"
 }
 },
 "_source": ["title", "authors"],
 "highlight": {
 "fields" : {
 "authors" : {}
 }
 }
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": 1,
 "_source": {
 "title": "Solr in Action",
 "authors": [
 "trey grainger",
 "timothy potter"
 ]
 },
 "highlight": {
 "authors": [
 "trey grainger",
 "timothy potter"
 ]
 }
 }
 ]
```
## 8. Match Phrase Query
The match phrase query requires that all the terms in the query string be present in the document, be in the order specified in the query string and be close to each other. By default, the terms are required to be exactly beside each other but you can specify the slop value which indicates how far apart terms are allowed to be while still considering the document a match.
```
POST /bookdb_index/book/_search
{
 "query": {
 "multi_match" : {
 "query": "search engine",
 "fields": ["title", "summary"],
 "type": "phrase",
 "slop": 3
 }
 },
 "_source": [ "title", "summary", "publish_date" ]
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": 0.22327082,
 "_source": {
 "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
 "title": "Solr in Action",
 "publish_date": "2014-04-05"
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "1",
 "_score": 0.16113183,
 "_source": {
 "summary": "A distibuted real-time search and analytics engine",
 "title": "Elasticsearch: The Definitive Guide",
 "publish_date": "2015-02-07"
 }
 }
 ]
```
Note: in the example above, for a non phrase type query, document _id 1 would normally have a higher score and appear ahead of document _id 4 because its field length is shorter. However, as a phrase query the proximity of the terms is factored in, so document _id 4 scores better.

## 9. Match Phrase Prefix
Match phrase prefix queries provide search-as-you-type or a poor man’s version of autocomplete at query time without needing to prepare your data in any way. Like the match_phrase query, it accepts a slop parameter to make the word order and relative positions somewhat less rigid. It also accepts the max_expansions parameter to limit the number of terms matched in order to reduce resource intensity.
```
POST /bookdb_index/book/_search
{
    "query": {
        "match_phrase_prefix" : {
            "summary": {
                "query": "search en",
                "slop": 3,
                "max_expansions": 10
            }
        }
    },
    "_source": [ "title", "summary", "publish_date" ]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.5161346,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.37248808,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      }
    ]
```
Note: Query-time search-as-you-type has a performance cost. A better solution is index-time search-as-you-type. Check out the Completion Suggester API or the use of Edge-Ngram filters for more information.

## 10. Query String
The query_string query provides a means of executing multi_match queries, bool queries, boosting, fuzzy matching, wildcards, regexp and range queries in a concise shorthand syntax. In the following example, we execute a fuzzy search for the terms “search algorithm” in which one of the book authors is “grant ingersoll” or “tom morton”. We search all fields but apply a boost of 2 to the summary field.
```
POST /bookdb_index/book/_search
{
 "query": {
 "query_string" : {
 "query": "(saerch~1 algorithm~1) AND (grant ingersoll) OR (tom morton)",
 "fields": ["_all", "summary^2"]
 }
 },
 "_source": [ "title", "summary", "authors" ],
 "highlight": {
 "fields" : {
 "summary" : {}
 }
 }
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "2",
 "_score": 0.14558059,
 "_source": {
 "summary": "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization",
 "title": "Taming Text: How to Find, Organize, and Manipulate It",
 "authors": [
 "grant ingersoll",
 "thomas morton",
 "drew farris"
 ]
 },
 "highlight": {
 "summary": [
 "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization"
 ]
 }
 }
 ]
```
## 11. Simple Query String
The simple_query_string query is a version of the query_string query that is more suitable for use in a single search box that is exposed to users because; it replaces the use of AND/OR/NOT with +/|/- respectively, and it discards invalid parts of a query instead of throwing an exception if a user makes a mistake.
```
POST /bookdb_index/book/_search
{
 "query": {
 "simple_query_string" : {
 "query": "(saerch~1 algorithm~1) + (grant ingersoll) | (tom morton)",
 "fields": ["_all", "summary^2"]
 }
 },
 "_source": [ "title", "summary", "authors" ],
 "highlight": {
 "fields" : {
 "summary" : {}
 }
 }
}
```
## 12. Term/Terms Query
The above examples have been examples of full-text search. Sometimes we are more interested in structured search in which we want to find an exact match and return the results. The term and terms queries help us here. In the below example, we are searching for all books in our index published by Manning Publications.
```
POST /bookdb_index/book/_search
{
 "query": {
 "term" : {
 "publisher": "manning"
 }
 },
 "_source" : ["title","publish_date","publisher"]
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "2",
 "_score": 1.2231436,
 "_source": {
 "publisher": "manning",
 "title": "Taming Text: How to Find, Organize, and Manipulate It",
 "publish_date": "2013-01-24"
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "3",
 "_score": 1.2231436,
 "_source": {
 "publisher": "manning",
 "title": "Elasticsearch in Action",
 "publish_date": "2015-12-03"
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": 1.2231436,
 "_source": {
 "publisher": "manning",
 "title": "Solr in Action",
 "publish_date": "2014-04-05"
 }
 }
 ]
```
Multiple terms can be specified by using the terms keyword instead and passing in an array of search terms.
```
{
 "query": {
 "terms" : {
 "publisher": ["oreilly", "packt"]
 }
 }
}
```
## 13. Term Query - Sorted
Term queries results (like any other query results) can easily be sorted. Multilevel sorting is also allowed
```
POST /bookdb_index/book/_search
{
 "query": {
 "term" : {
 "publisher": "manning"
 }
 },
 "_source" : ["title","publish_date","publisher"],
 "sort": [
 { "publish_date": {"order":"desc"}},
 { "title": { "order": "desc" }}
 ]
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "3",
 "_score": null,
 "_source": {
 "publisher": "manning",
 "title": "Elasticsearch in Action",
 "publish_date": "2015-12-03"
 },
 "sort": [
 1449100800000,
 "in"
 ]
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "4",
 "_score": null,
 "_source": {
 "publisher": "manning",
 "title": "Solr in Action",
 "publish_date": "2014-04-05"
 },
 "sort": [
 1396656000000,
 "solr"
 ]
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "2",
 "_score": null,
 "_source": {
 "publisher": "manning",
 "title": "Taming Text: How to Find, Organize, and Manipulate It",
 "publish_date": "2013-01-24"
 },
 "sort": [
 1358985600000,
 "to"
 ]
 }
 ]
```
## 14. Range Query
Another structured query example is the range query. In this example, we search for books published in 2015.
```
POST /bookdb_index/book/_search
{
 "query": {
 "range" : {
 "publish_date": {
 "gte": "2015-01-01",
 "lte": "2015-12-31"
 }
 }
 },
 "_source" : ["title","publish_date","publisher"]
}
[Results]
"hits": [
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "1",
 "_score": 1,
 "_source": {
 "publisher": "oreilly",
 "title": "Elasticsearch: The Definitive Guide",
 "publish_date": "2015-02-07"
 }
 },
 {
 "_index": "bookdb_index",
 "_type": "book",
 "_id": "3",
 "_score": 1,
 "_source": {
 "publisher": "manning",
 "title": "Elasticsearch in Action",
 "publish_date": "2015-12-03"
 }
 }
 ]
```
Note: Range queries work on date, number and string type fields.

## 15. Filtered Query
Filtered queries allow you filter down the results of a query. For our example, we are querying for books with the term “Elasticsearch” in title or summary but we want to filter our results to only those with 20 or more reviews.
```
POST /bookdb_index/book/_search
{
    "query": {
        "filtered": {
            "query" : {
                "multi_match": {
                    "query": "elasticsearch",
                    "fields": ["title","summary"]
                }
            },
            "filter": {
                "range" : {
                    "num_reviews": {
                        "gte": 20
                    }
                }
            }
        }
    },
    "_source" : ["title","summary","publisher", "num_reviews"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.5955761,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "publisher": "oreilly",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide"
        }
      }
    ]
```
Note: Filtered queries do not mandate the presence of a query on which to filter on. If no query is specified then the match_all query is run which basically returns all the documents in the index and then filters on it. In actuality, the filter is run first, reducing the surface area needed to be queried. Also, the filter is cached after the first use which makes it very performant.

UPDATE: Filtered queries have been removed from the upcoming Elasticsearch 5.0 in favor of the bool  query. Here is the same example as above re-written to use the bool query instead. The results returned are exactly the same. 
```
POST /bookdb_index/book/_search
{
    "query": {
        "bool": {
            "must" : {
                "multi_match": {
                    "query": "elasticsearch",
                    "fields": ["title","summary"]
                }
            },
            "filter": {
                "range" : {
                    "num_reviews": {
                        "gte": 20
                    }
                }
            }
        }
    },
    "_source" : ["title","summary","publisher", "num_reviews"]
}
```
This also applies to multiple filters in the example below.

## 16. Multiple Filters
Multiple filters can be combined through the use of the bool filter. In the next example, the filter determines that the returned results must have at least 20 reviews, must not be published before 2015 and should be published by oreilly.
```
POST /bookdb_index/book/_search
{
    "query": {
        "filtered": {
            "query" : {
                "multi_match": {
                    "query": "elasticsearch",
                    "fields": ["title","summary"]
                }
            },
            "filter": {
                "bool": {
                    "must": {
                        "range" : { "num_reviews": { "gte": 20 } }
                    },
                    "must_not": {
                        "range" : { "publish_date": { "lte": "2014-12-31" } }
                    },
                    "should": {
                        "term": { "publisher": "oreilly" }
                    }
                }
            }
        }
    },
    "_source" : ["title","summary","publisher", "num_reviews", "publish_date"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.5955761,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "publisher": "oreilly",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      }
    ]
```
## 17. Function Score: Field Value Factor
There may be a case where you want to factor in the value of a particular field in your document into the calculation of the relevance score. This is typical in scenarios where you want the boost the relevance of a document based on its popularity. In our example, we would like the more popular books (as judged by the number of reviews) to be boosted. This is possible using the field_value_factor function score.
```
POST /bookdb_index/book/_search
{
    "query": {
        "function_score": {
            "query": {
                "multi_match" : {
                    "query" : "search engine",
                    "fields": ["title", "summary"]
                }
            },
            "field_value_factor": {
                "field" : "num_reviews",
                "modifier": "log1p",
                "factor" : 2
            }
        }
    },
    "_source": ["title", "summary", "publish_date", "num_reviews"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.44831306,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.3718407,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "num_reviews": 23,
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 0.046479136,
        "_source": {
          "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
          "num_reviews": 18,
          "title": "Elasticsearch in Action",
          "publish_date": "2015-12-03"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "2",
        "_score": 0.041432835,
        "_source": {
          "summary": "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization",
          "num_reviews": 12,
          "title": "Taming Text: How to Find, Organize, and Manipulate It",
          "publish_date": "2013-01-24"
        }
      }
    ]
```
Note 1: We could have just run a regular multi_match query and sorted by the num_reviews field but then we lose the benefits of having relevance scoring.

Note 2: There are a number of additional parameters that tweak the extent of the boosting effect on the original relevance score such as “modifier”, “factor”, “boost_mode”, etc. These are explored in detail in the Elasticsearch guide.

## 18. Function Score: Decay Functions
Suppose that instead of wanting to boost incrementally by the value of a field, you have an ideal value you want to target and you want the boost factor to decay the further away you move from the value. This is typically useful in boosts based on lat/long, numeric fields like price, or dates. In our contrived example, we are searching for books on “search engines” ideally published around June 2014.
```
POST /bookdb_index/book/_search
{
    "query": {
        "function_score": {
            "query": {
                "multi_match" : {
                    "query" : "search engine",
                    "fields": ["title", "summary"]
                }
            },
            "functions": [
                {
                    "exp": {
                        "publish_date" : {
                            "origin": "2014-06-15",
                            "offset": "7d",
                            "scale" : "30d"
                        }
                    }
                }
            ],
            "boost_mode" : "replace"
        }
    },
    "_source": ["title", "summary", "publish_date", "num_reviews"]
}
[Results]
"hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.27420625,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "num_reviews": 23,
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.005920768,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "2",
        "_score": 0.000011564,
        "_source": {
          "summary": "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization",
          "num_reviews": 12,
          "title": "Taming Text: How to Find, Organize, and Manipulate It",
          "publish_date": "2013-01-24"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 0.0000059171475,
        "_source": {
          "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
          "num_reviews": 18,
          "title": "Elasticsearch in Action",
          "publish_date": "2015-12-03"
        }
      }
    ]
```
## 19. Function Score: Script Scoring
In the case where the built-in scoring functions do not meet your needs, there is the option to specify a Groovy script to use for scoring. In our example, we want to specify a script that takes into consideration the publish_date before deciding how much to factor in the number of reviews. Newer books may not have as many reviews yet so they should not be penalized for that.

The scoring script looks like this:
```
publish_date = doc['publish_date'].value
num_reviews = doc['num_reviews'].value
if (publish_date > Date.parse('yyyy-MM-dd', threshold).getTime()) {
  my_score = Math.log(2.5 + num_reviews)
} else {
  my_score = Math.log(1 + num_reviews)
}
return my_score
```
To use a scoring script dynamically, we use the script_score parameter:
```
POST /bookdb_index/book/_search
{
    "query": {
        "function_score": {
            "query": {
                "multi_match" : {
                    "query" : "search engine",
                    "fields": ["title", "summary"]
                }
            },
            "functions": [
                {
                    "script_score": {
                        "params" : {
                            "threshold": "2015-07-30"
                        },
                        "script": "publish_date = doc['publish_date'].value; num_reviews = doc['num_reviews'].value; if (publish_date > Date.parse('yyyy-MM-dd', threshold).getTime()) { return log(2.5 + num_reviews) }; return log(1 + num_reviews);"
                    }
                }
            ]
        }
    },
    "_source": ["title", "summary", "publish_date", "num_reviews"]
}
[Results]
"hits": {
    "total": 4,
    "max_score": 0.8463001,
    "hits": [
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "1",
        "_score": 0.8463001,
        "_source": {
          "summary": "A distibuted real-time search and analytics engine",
          "num_reviews": 20,
          "title": "Elasticsearch: The Definitive Guide",
          "publish_date": "2015-02-07"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "4",
        "_score": 0.7067348,
        "_source": {
          "summary": "Comprehensive guide to implementing a scalable search engine using Apache Solr",
          "num_reviews": 23,
          "title": "Solr in Action",
          "publish_date": "2014-04-05"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "3",
        "_score": 0.08952084,
        "_source": {
          "summary": "build scalable search applications using Elasticsearch without having to do complex low-level programming or understand advanced data science algorithms",
          "num_reviews": 18,
          "title": "Elasticsearch in Action",
          "publish_date": "2015-12-03"
        }
      },
      {
        "_index": "bookdb_index",
        "_type": "book",
        "_id": "2",
        "_score": 0.07602123,
        "_source": {
          "summary": "organize text using approaches such as full-text search, proper name recognition, clustering, tagging, information extraction, and summarization",
          "num_reviews": 12,
          "title": "Taming Text: How to Find, Organize, and Manipulate It",
          "publish_date": "2013-01-24"
        }
      }
    ]
  }
```
Note 1: To use dynamic scripting, it must be enabled for your Elasticsearch instance in the config/elasticsearch.yaml file. It’s also possible to use scripts that have been stored on the Elasticsearch server. Check out the Elasticsearch reference docs for more information.

Note 2: JSON cannot include embedded newline characters so the semicolon is used to separate statements.

# 个人体会
- 用terms可以在精确的取多个值时，进行更多的排序处理等操作。terms的对象可以是"_id"或者其他,
```
GET lawplatform/criminal_law/_search
{
  "query": {
    "bool": {
      "filter": {
        "terms": {
          "_id": [
            "1",
            "23"
          ]
        }
      }
    }
  },
  "size": 2,
  "_source": "title"
}
```
- 不可以使用"_id"作排序，因为"_id"被当做是字符串，字符串排序往往会出乎你的意料，但是可以自己建一个int的字段来映射"_id"去排序

---
参考：
- [1][elasticsearch 的python api](https://my.oschina.net/u/1458120/blog/684737)
- [2][Elasticsearch查询规则（一）match和term](http://www.jianshu.com/p/eb30eee13923)
- [3][23 Useful Elasticsearch Example Queries](https://dzone.com/articles/23-useful-elasticsearch-example-queries)
- [4][ElasticSearch 2 (18) - 深入搜索系列之控制相关度(重要)](http://www.cnblogs.com/richaaaard/p/5254988.html)
- [5][ElasticSearch相关性打分机制](http://techshow.ctrip.com/archives/2303.html)
- [6][精确值查找](https://www.elastic.co/guide/cn/elasticsearch/guide/current/_finding_exact_values.html)

Elasticsearch的搜索查询

附件: