但行好事 莫问前程

Elasticsearch 查询语句详解

陈明羽 2019-07-10

微信搜索“我是树懒”或扫下方二维码关注公众号

优质文章,第一时间送达

本文主要详细介绍es中常用的查询语句,以及使用的时候一些需要注意的事项

如对es不了解,建议先看 es基础: https://juejin.im/post/5cdc07446fb9a0322e73b5b5

url参数搜索

这种方式就是类似于get请求,将请求参数拼接到链接上,例GET /school/student/_search?参数,多个参数用&分开

查询所有

命令:GET /school/student/_search

返回:

{
  "took": 7, //查询耗时,毫秒
  "timed_out": false, //是否超时,timeout 不是停止执行查询,它仅仅是告知正在协调的节点返回到目前为止收集的结果并且关闭连接
  "_shards": {
    "total": 5, //请求的分片数量,索引拆成了5个分片,所以对于搜索请求,会打到所有的primary shard
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 2, //符合条件的总条数,这里查的是所有
    "max_score": 1, //匹配分数
    "hits": [ //数据
      {
        "_index": "school",
        "_type": "student",
        "_id": "2",
        "_score": 1,
        "_source": {
          "name": "houyi",
          "age": 23,
          "class": 2,
          "gender": "男"
        }
      },
      {
        "_index": "school",
        "_type": "student",
        "_id": "1",
        "_score": 1,
        "_source": {
          "name": "吕布",
          "age": 21,
          "class": 2,
          "gender": "男"
        }
      }
    ]
  }
}

多索引,多type搜索

在URL中指定特殊的索引和类型进行多索引,多type搜索

  1. /_search:在所有的索引中搜索所有的类型
  2. /school/_search:在 school 索引中搜索所有的类型
  3. /school,ad/_search:在 schoolad索引中搜索所有的类型
  4. /s*,a*/_search:在所有以ga开头的索引中所有所有的类型
  5. /school/student/_search:在school索引中搜索student类型
  6. /school,ad/student,phone/_search:在schoolad索引上搜索studentphone类型
  7. /_all/student,phone/_search:在所有的索引中搜索studentphone类型

按条件查询

命令:GET /school/student/_search?q=name:houyi

查询name是houyi的记录

更多查询参数:

查询DSL

elasticsearch提供了基于JSON的完整查询DSL来定义查询,DSL拥有一套查询组件,这些组件可以以无限组合的方式进行搭配,构建各种复杂的查询

叶子语句

叶子语句:就像match语句,被用于将查询的字符串与一个字段或多个字段进行对比(单个条件)
比如:

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "name": "phone"
       }
     }
   }

复合查询

用户合并其他查询语句,比如一个bool语句,允许你在需要的时候组合其他语句,包括mustmust_notshouldfilter语句(多条件组合查询)
比如:

   GET /ad/phone/_search
   {
     "query": {
       "bool": {
         "must": [
           {"match": {
             "name": "phone"
           }}
         ]
         , "must_not": [
           {"match": {
             "color": "red"
           }}
         ]
         , "should": [
           {"match": {
             "price": 5000
           }}
         ]
         , "filter": {
             "term": {
               "label": "phone"
             }
         }
       }
     }
   }

must:表示文档一定要包含查询的内容

must_not:表示文档一定不要包含查询的内容

should:表示如果文档匹配上可以增加文档相关性得分

事实上我们可以使用两种结构化语句: 结构化查询query DSL和结构化过滤Filter DSL

  1. 结构化查询query DSL

    用于检查内容与条件是否匹配,内容查询中使用的bool和match字句,用于计算每个文档的匹配得分,元字段_score表示匹配度,查询的结构中以query参数开始来执行内容查询

  2. 结构化过滤Filter DSL

    只是简单的决定文档是否匹配,内容过滤中使用的term和range字句,会过滤 调不匹配的文档,并且不影响计算文档匹配得分

    使用过滤查询会被es自动缓存用来提高效率

原则上来说,使用查询语句做全文本搜索或其他需要进行相关性评分的时候,剩下的全部用过滤语句

新建一个稍微复杂的索引,添加三条文档

PUT /ad/phone/1
{
  "name":"phone 8",
  "price": 6000,
  "color":"white",
  "ad":"this is a white phone",
  "label":["white","nice"]
}

PUT /ad/phone/2
{
  "name":"xiaomi 8",
  "price": 4000,
  "color":"red",
  "ad":"this is a red phone",
  "label":["white","xiaomi"]
}

PUT /ad/phone/3
{
  "name":"huawei p30",
  "price": 5000,
  "color":"white",
  "ad":"this is a white phone",
  "label":["white","huawei"]
}

查询示例

1. 获取所有

   GET /ad/phone/_search
   {
     "query": {
       "match_all": {}
     }
   }

match_all匹配所有数据,返回的结果中元字段_score得分为1

2. 分页查询,从第二条开始,查两条(不要使用fromsize进行深度分页,会有性能问题)

   GET /ad/phone/_search
   {
     "query": {
       "match_all": {}
     },
     "from": 1,
     "size": 2
   }

这种分页方式如果进行深度分页,比如到100页,每页十条数据,它会从每个分片都查询出100*10条数据,假设有五个分片,就是5000条数据,然后在内存中进行排序,然后返回拍过序之后的集合中的第1000-1010条数据

3. 指定查询出来的数据返回的字段

   GET /ad/phone/_search
   {
     "query": {
       "match_all": {}
     },
     "_source": ["name","price"]
   }

返回的数据中只返回nameprice字段

4. ad字段中包含单词white

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "ad": "white"
       }
     }
   }

返回的结果中元字段_score有评分,说明使用query会计算评分

5. ad字段中包含单词white,并按照价格升序排列

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "ad": "white"
       }
     }, 
     "sort": [
       {
         "price": {
           "order": "asc"
         }
       }
     ]
   }

6. 价格字段大于5000

   GET /ad/phone/_search
   {
     "query": {
       "bool": {
         "filter": {
           "range": {
             "price": {
               "gt": 5000
             }
           }
         }
       }
     }
   }

返回的结果中元字段_score字段等于0,没评分,说明使用filter不会计算评分

7. ad字段中包含单词white,价格字段大于5000

   GET /ad/phone/_search
   {
     "query": {
       "bool": {
         "must": [
           {
             "match": {
               "ad": "white"
             }
           }
         ], 
         "filter": {
           "range": {
             "price": {
               "gt": 5000
             }
           }
         }
       }
     }
   }

8. 查询name字段包含单词phone的文档的数量

   GET /ad/phone/_count
   {
     "query": {
       "match": {
         "name": "phone"
       }
     }
   }

关键词详解

1. match_all查询

查询简单的匹配所有文档

   GET /ad/phone/_search
   {
     "query": {
       "match_all": {}
     }
   }

2. match查询

支持全文搜索和精确查询,取决于字段是否支持全文检索

全文检索:

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "ad": "a red"
       }
     }
   }

全文检索会将查询的字符串先进行分词,a red会分成为ared,然后在倒排索引中进行匹配,所以这条语句会将三条文档都查出来

精确查询:

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "price": "6000"
       }
     }
   }

对于精确值的查询,可以使用 filter 语句来取代 query,因为 filter 将会被缓存

operator操作:

match 查询还可以接受 operator 操作符作为输入参数,默认情况下该操作符是 or 。我们可以将它修改成 and 让所有指定词项都必须匹配

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "ad": {
           "query": "a red",
           "operator": "and"
         }
       }
     }
   }

精确度匹配:

match 查询支持 minimum_should_match 最小匹配参数, 可以指定必须匹配的词项数用来表示一个文档是否相关。我们可以将其设置为某个具体数字(指需要匹配倒排索引的词的数量),更常用的做法是将其设置为一个百分数,因为我们无法控制用户搜索时输入的单词数量

   GET /ad/phone/_search
   {
     "query": {
       "match": {
         "ad": {
           "query": "a red",
           "minimum_should_match": "2"
         }
       }
     }
   }

只会返回匹配上ared两个词的文档返回,如果minimum_should_match是1,则只要匹配上其中一个词,文档就会返回

3. multi_match查询

多字段查询,比如查询colorad字段包含单词red的文档

   GET /ad/phone/_search
   {
     "query": {
       "multi_match": {
         "query": "red",
         "fields": ["color","ad"]
       }
     }
   }

4. range查询

范围查询,查询价格大于4000小于6000的文档

   GET /ad/phone/_search
   {
     "query": {
       "range": {
         "price": {
           "gt": 4000,
           "lt": 6000
         }
       }
     }
   }

范围查询操作符:gt (大于),gte(大于等于),lt(小于),lte(小于等于);

5. term查询

精确值查询

查询price字段等于6000的文档

   GET /ad/phone/_search
   {
     "query": {
       "term": {
         "price": {
           "value": "6000"
         }
       }
     }
   }

查询name字段等于phone 8的文档

   GET /ad/phone/_search
   {
     "query": {
       "term": {
         "name": {
           "value": "phone 8"
         }
       }
     }
   }

返回值如下,没有查询到名称为phone 8的文档

   {
     "took": 5,
     "timed_out": false,
     "_shards": {
       "total": 5,
       "successful": 5,
       "skipped": 0,
       "failed": 0
     },
     "hits": {
       "total": 0,
       "max_score": null,
       "hits": []
     }
   }

为什么没有查到phone 8的这个文档那,这里需要介绍一下term的查询原理

   `term`查询会去倒排索引中寻找确切的`term`,它并不会走分词器,只会去配倒排索引 ,而`name`字段的`type`类型是`text`,会进行分词,将`phone 8 ` 分为`phone`和`8`,我们使用`term`查询`phone 8`时倒排索引中没有`phone 8`,所以没有查询到匹配的文档

term查询与match查询的区别

  • term查询时,不会分词,直接匹配倒排索引
  • match查询时会进行分词,查询phone 8时,会先分词成phone8,然后去匹配倒排索引,所以结果会将phone 8xiaomi 8两个文档都查出来

    还有一点需要注意,因为term查询不会走分词器,但是回去匹配倒排索引,所以查询的结构就跟分词器如何分词有关系,比如新增一个/ad/phone类型下的文档,name字段赋值为Oppo,这时使用term查询Oppo不会查询出文档,这时因为es默认是用的standard分词器,它在分词后会将单词转成小写输出,所以使用oppo查不出文档,使用小写oppo可以查出来

   GET /ad/phone/_search
   {
     "query": {
       "term": {
         "name": {
           "value": "Oppo" //改成oppo可以查出新添加的文档
         }
       }
     }
   }

这里说的并不是想让你了解standard分词器,而是要get到所有像term这类的查询结果跟选择的分词器有关系,了解选择的分词器分词方式有助于我们编写查询语句

6. terms查询

terms查询与term查询一样,但它允许你指定多直进行匹配,如果这个字段包含了指定值中的任何一个值,那么这个文档满足条件

   GET /ad/phone/_search
   {
     "query": {
       "terms": {
         "ad": ["red","blue"]
       }
     }
   }

7. exists 查询和 missing 查询

用于查找那些指定字段中有值 (exists) 或无值 (missing) 的文档

指定name字段有值:

   GET /ad/phone/_search
   {
     "query": {
       "bool": {
         "filter": {
           "exists": {
             "field": "name"
           }
         }
       }
     }
   }

指定name字段无值:

   GET /ad/phone/_search
   {
     "query": {
       "bool": {
         "filter": {
           "missing": {
             "field": "name"
           }
         }
       }
     }
   }

8. match_phrase查询

短语查询,精确匹配,查询a red会匹配ad字段包含a red短语的,而不会进行分词查询,也不会查询出包含a 其他词 red这样的文档

   GET /ad/phone/_search
   {
     "query": {
       "match_phrase": {
         "ad": "a red"
       }
     }
   }

9. scroll查询

类似于分页查询,不支持跳页查询,只能一页一页往下查询,scroll查询不是针对实时用户请求,而是针对处理大量数据,例如为了将一个索引的内容重新索引到具有不同配置的新索引中

   POST /ad/phone/_search?scroll=1m
   {
     "query": {
       "match_all": {}
     },
     "size": 1,
     "from": 0
   }

返回值包含一个 "_scroll_id": "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAAQFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAERZVek91amNjWlQwS0RubmV3YmdIRWFBAAAAAAAAABIWVXpPdWpjY1pUMEtEbm5ld2JnSEVhQQAAAAAAAAATFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAFBZVek91amNjWlQwS0RubmV3YmdIRWFB"

下次查询的时候使用_scroll_id就可以查询下一页的文档

   POST /_search/scroll 
   {
       "scroll" : "1m", 
       "scroll_id" : "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAAYFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAGRZVek91amNjWlQwS0RubmV3YmdIRWFBAAAAAAAAABYWVXpPdWpjY1pUMEtEbm5ld2JnSEVhQQAAAAAAAAAXFlV6T3VqY2NaVDBLRG5uZXdiZ0hFYUEAAAAAAAAAFRZVek91amNjWlQwS0RubmV3YmdIRWFB" 
   }

10. multi get查询

允许基于索引,类型(可选)和id(以及可能的路由)获取多个文档,如果某个文档获取失败则将错误信息包含在响应中

​```json
GET /ad/phone/_mget
{
  "ids": ["1","8"]
}
​

#### 11. `bulk`批量操作

`bulk`批量操作可以在单次API调用中实现多个文档的`create`、`index`、`update`或`delete`。这可以大大提高索引速度

`bulk`请求体如下

```json
{ action: { metadata }}\n 
{ request body        }\n
{ action: { metadata }}\n
{ request body        }\n
...

action必须是以下几种:
| 行为 | 解释 |
| —— | ———————— |
| create | 当文档不存在时创建 |
| index | 创建新文档或替换已有文档 |
| update | 局部更新文档 |
| delete | 删除一个文档 |
在索引、创建、更新或删除时必须指定文档的_index_type_id这些元数据(metadata)

例:

    PUT _bulk
    { "create" : { "_index" : "ad", "_type" : "phone", "_id" : "6" }}
    { "doc" : {"name" : "bulk"}}
    { "index" : { "_index" : "ad", "_type" : "phone", "_id" : "6" }}
    { "doc" : {"name" : "bulk"}}
    { "delete":{  "_index" : "ad", "_type" : "phone", "_id" : "1"}}
    { "update":{  "_index" : "ad", "_type" : "phone", "_id" : "3"}}
    { "doc" : {"name" : "huawei p20"}}

返回:

    {
      "took": 137,
      "errors": true, //如果任意一个文档出错,这里返回true,
      "items": [ //items数组,它罗列了每一个请求的结果,结果的顺序与我们请求的顺序相同
        {
          //create这个文档已经存在,所以异常
          "create": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "6",
            "status": 409,
            "error": {
              "type": "version_conflict_engine_exception",
              "reason": "[phone][6]: version conflict, document already exists (current version [2])",
              "index_uuid": "9F5FHqgISYOra_P09HReVQ",
              "shard": "2",
              "index": "ad"
            }
          }
        },
        {
          //index这个文档已经存在,会覆盖
          "index": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "6",
            "_version": 3,
            "result": "updated",
            "_shards": {
              "total": 2,
              "successful": 1,
              "failed": 0
            },
            "_seq_no": 6,
            "_primary_term": 5,
            "status": 200
          }
        },
        {
          //删除  
          "delete": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "1",
            "_version": 1,
            "result": "not_found",
            "_shards": {
              "total": 2,
              "successful": 1,
              "failed": 0
            },
            "_seq_no": 4,
            "_primary_term": 5,
            "status": 404
          }
        },
        {
          //修改  
          "update": { 
            "_index": "ad",
            "_type": "phone",
            "_id": "3",
            "_version": 3,
            "result": "noop",
            "_shards": {
              "total": 2,
              "successful": 1,
              "failed": 0
            },
            "status": 200
          }
        }
      ]
    }

bulk请求不是原子操作,它们不能实现事务。每个请求操作时分开的,所以每个请求的成功与否不干扰其它操作

12. fuzzy查询

模糊查询,fuzzy 查询会计算与关键词的拼写相似程度

    GET /ad/phone/_search
    {
      "query": {
        "fuzzy": {
          "color":{
            "value": "res"
            , "fuzziness": 2,
            "prefix_length": 1
          }
        }
      }
    }

参数设置:

fuzziness:最大编辑距离,默认为AUTO

prefix_length:不会“模糊化”的初始字符数。这有助于减少必须检查的术语数量,默认为0

max_expansionsfuzzy查询将扩展到 的最大术语数。默认为50,设置小,有助于优化查询

transpositions:是否支持模糊转置(abba),默认是false

13. wildcard查询

支持通配符的模糊查询,?匹配单个字符,*匹配任何字符

为了防止极其缓慢通配符查询,*?通配符项不应该放在通配符的开始

    GET /ad/phone/_search
    {
      "query": {
        "wildcard": {
          "color": "r?d"
        }
      }
    }

未完待续…

使用微信打赏

若你觉得我的文章对你有帮助,欢迎点击上方按钮对我打赏

扫描二维码,分享此文章