Kibana的HTTP操作类似，可以看四、Kibana安装部署及使用 5. 查询语句

1. 查看ES各种信息

1.1 检查ES是否可用

  1. GET IP:9200

image.png

1.2 查看有多少节点

  1. GET IP:9200/_cat/nodes

image.png

1.3 查看集群健康状态

  1. GET IP:9200/_cluster/health?pretty
**status**
字段只是这当前集群在总体上是否工作正常，他的三种颜色含义如下：
green
 所有的主分片和副本分片都正常运行
yellow
 所有的主分片都运行正常，但不是所有的副本分片都正常运行
red
 有主分片没能正常运行

image.png

1.4 查看所有索引及索引状态

  1. GET IP:9200/_cat/indices?v

image.png

1.5 使用分词器分析词条

  1. GET /_analyze
  2. {
  3.  "analyzer": "standard",
  4.  "text": "hello world"
  5. }
  7. # "analyzer": "standard"：
  8. # 是指定使用哪个分词器，standard是自带分词器
  9. # 如果装了ik分词器
  10. # 1. 可以使用ik_max_word --- 会将文本做最细粒度的拆分
  11. # 2. 还可以使用ik_smart --- 会将文本做最粗粒度的拆分
  12. # "text": "hello world"是指定文本

2. 索引

对比关系型数据库，索引就等同于数据库

2.1 创建

  1. PUT    http://hadoop101:9200/shopping
  3. # 无body

2.2 创建索引同时创建映射、设置分片和副本

  1. PUT http://hadoop101:9200/student1
  3. # body如下：
  4. {
  5.     "settings" : {
  6.             "number_of_shards" : 3,        // 3个主分片
  7.             "number_of_replicas" : 1    // 每个分片1个副本
  8.         },
  9.     "mapping":{
  10.         "properties":{
  11.             "name":{
  12.                 "type":"text",      // 文本类型，会分词
  13.                 "index":true        // 索引，该字段可以搜索，默认true
  14.             },
  15.             "sex":{
  16.                 "type":"keyword",   // 关键字类型，不分词，必须整条记录搜索才能搜到
  17.                 "index":true        // 索引，该字段可以搜索，默认true
  18.             },
  19.             "tel":{
  20.                 "type":"text",      // 文本类型，会分词
  21.                 "store":true        // 是否单独存储，默认数据会存储到_source中，如果配置store为true，会将该字段单独存储，查询会非常快，但会占用更多的空间
  22.             }
  23.         }    
  24.     }
  25. }

2.3 修改副本分片数

  1. PUT http://hadoop101:9200/person1/_settings
  2. {
  3.  "number_of_replicas" : 2
  4. }

2.4 查询所有

  1. GET http://hadoop101:9200/_cat/indices?v
  3. # 结果如下：
  4. health status index    uuid                   pri rep docs.count docs.deleted store.size pri.store.size
  5. green  open   student1 fgI0uB9zTZGXVo3geDtn9w   1   1          0            0       416b           208b
  6. green  open   user     gQAHQT92Q7mbLC394fHtDw   1   1          1            0      7.6kb          3.8kb
  7. green  open   shopping LsvqKvmSTo6yhllrQL-oEw   1   1          3            0     22.8kb         11.4kb

image.png

2.5 查询单个

  1. GET http://hadoop101:9200/shopping

2.6 删除

  1. DELETE http://hadoop101:9200/shopping

2.7 刷新索引

慎用 ES默认1s刷新一次 在索引构建时，可以先关闭自动刷新，让索引构建更快，待开始使用索引时再打开 如果不需要近实时搜索，可以调大刷新间隔，提高索引效率

  1. PUT /users/_settings    # 关闭自动刷新
  2. {
  3.   "refresh_interval": -1 
  4. } 
  6. PUT /users/_settings    # 每一秒刷新
  7. {
  8.  "refresh_interval": "1s" 
  9. }
  11. PUT /users/_refresh # 手动刷新

3. 映射

对比关系型数据库，映射就等同于表结构

映射数据说明：

映射 类型 描述
type text（String类型） 可分词
keyword（String类型） 不可分词，数据会作为完整字段进行匹配
long、integer、short、byte、double、float、half_float 基本数据类型
scaled_float 浮点数的高精度类型
Date 日期类型
Array 数组类型
Object 对象
index true/false true：默认，字段会被索引，则可以用来进行搜索
false：字段不会被索引，不能用来搜索
store true/false 原始的文本会存储在_source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置”store”: true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。
analyzer ik 分词器

3.1 创建

  1. PUT http://hadoop101:9200/shopping/_mapping
  3. # body如下：
  4. {
  5.     "properties":{
  6.         "name":{                                // 字段名，任意填写
  7.             "type":"text",      // 文本类型，会分词
  8.             "index":true        // 索引，该字段可以搜索，默认true
  9.         },
  10.         "sex":{
  11.             "type":"keyword",   // 关键字类型，不分词，必须整条记录搜索才能搜到
  12.             "index":true        // 索引，该字段可以搜索，默认true
  13.         },
  14.         "tel":{
  15.             "type":"text",      // 文本类型，会分词
  16.             "store":true        // 是否单独存储，默认数据会存储到_source中，如果配置store为true，会将该字段单独存储，查询会非常快，但会占用更多的空间
  17.         }
  18.     }    
  19. }

3.2 创建索引同时创建映射

参考：1.2 创建索引同时创建映射、设置分片和副本

3.3 查看映射

  1. GET http://hadoop101:9200/user/_mapping

4. 文档

对比关系型数据库，文档就等同于数据

4.1 新增

4.1.1 随机_id

  1. POST http://hadoop101:9200/shopping/_doc
  3. # body如下：
  4. {
  5.  "title":"小米手机",
  6.  "category":"小米",
  7.  "images":"http://www.gulixueyuan.com/xm.jpg",
  8.  "price":3999.00
  9. }

4.1.2 自定义_id

  1. POST http://hadoop101:9200/shopping/_doc/1001
  3. # body如下：
  4. {
  5.  "title":"小米手机",
  6.  "category":"小米",
  7.  "images":"http://www.gulixueyuan.com/xm.jpg",
  8.  "price":3999.00
  9. }

4.2 查询

4.2.1 主键查询

  1. GET http://hadoop101:9200/shopping/_doc/1001

4.2.2 全部查询

  1. GET http://hadoop101:9200/shopping/_doc/_search

4.2.3 高级查询

参考：4. 高级查询

4.3 修改

4.3.1 某条记录某个字段

  1. POST http://hadoop101:9200/shopping/_update/1001
  3. {
  4.     "doc":{
  5.         "title":"华为手机"
  6.     }
  7. }

4.3.2 某条记录全字段

  1. POST http://hadoop101:9200/shopping/_doc/1001
  3. # body如下：
  4. {
  5.  "title":"小米手机",
  6.  "category":"小米",
  7.  "images":"http://www.gulixueyuan.com/xm.jpg",
  8.  "price":4999.00
  9. }

4.4 删除

4.4.1 主键删除

  1. DELETE http://hadoop101:9200/shopping/_doc/1002

4.4.2 条件删除

  1. POST http://hadoop101:9200/shopping/_delete_by_query
  3. # body如下；
  4. {
  5.     "query":{
  6.         "match":{
  7.             "price":3999.00
  8.         }
  9.     } 
  10. }

5. 高级查询

5.1 查询所有—-match_all

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query": {
  6.         "match_all": {}
  7.     } 
  8. }

5.2 分词词条匹配查询

5.2.1 单字段分词词条匹配查询—-match

将查询条件先分词，根据分词后的每一个词条去匹配，词条之间是or的关系，结果取并集

match查询keyword字段，match会被分词，而keyword不会被分词，match的条件需要跟keyword的完全匹配才可以。 match查询text字段，match分词，text也分词，只要match的分词结果和text的分词结果有相同的就匹配。

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "match":{
  7.             "title":"华为手机"
  8.         }
  9.     }
  10. }

5.2.2 多字段分词词条匹配查询—-multi_match

将查询条件先分词，根据分词后的每一个词条在多个字段中去匹配（text类似于多词条like，keyword需要词条完全匹配），词条之间是or的关系，结果取并集

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "multi_match":{
  7.             "query":"华为",
  8.             "fields":["catgory","title"]
  9.         }
  10.     }
  11. }

5.3 短语匹配查询—-match_phrase

match_phrase匹配keyword字段。match_phrase会被分词，而keyword不会被分词，match_phrase需要跟keyword的完全匹配才可以。 match_phrase匹配text字段。match_phrase是分词的，text也是分词的。match_phrase的分词结果必须在text字段分词中都包含，而且顺序必须相同，而且必须都是连续的。类似于like

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "match_phrase":{
  7.             "title":"华为手机"
  8.         }
  9.     }
  10. }

5.4 关键字精确查询

5.4.1 单关键词精确查询—-term

term查询keyword字段，term不会分词。而keyword字段也不分词。需要完全匹配才可以。 term查询text字段，因为text字段会分词，而term不分词，所以term查询的条件必须是text字段分词后的某一个词条。

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "term":{
  7.             "title":{
  8.                 "value":"华"
  9.             }
  10.         }
  11.     }
  12. }

5.4.2 多关键字精确查询—-terms

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "terms":{
  7.             "title":["华","为"]
  8.         }
  9.     }
  10. }

5.5 （不）返回指定字段查询—-includes、excludes

  1. GET http://hadoop101:9200/shopping/_search
  3. # includes的body如下：
  4. {
  5.     "_source":{
  6.         "includes":["title"]
  7.     }
  8. }
  10. # excludes的body如下：
  11. {
  12.     "_source":{
  13.         "excludes":["title"]
  14.     }
  15. }

5.6 组合查询—-bool

bool 把各种其它查询通过 **must** （必须 ）、 **must_not** （必须不）、 **should** （应该）的方式进行组合

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "bool":{
  7.             "must":[
  8.                 {
  9.                     "match":{
  10.                         "title":"手机"
  11.                     }
  12.                 },
  13.                 {
  14.                     "match":{
  15.                         "price":3999
  16.                     }
  17.                 }
  18.             ]
  19.         }
  20.     }
  21. }

5.7 范围查询—-range

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "bool":{
  7.             "must":[
  8.                 {
  9.                     "match":{
  10.                         "title":"手机"
  11.                     }
  12.                 }
  13.             ],
  14.             "filter":{
  15.                 "range":{
  16.                     "price":{
  17.                         "gt":4000
  18.                     }
  19.                 }
  20.             }
  21.         }
  22.     }
  23. }

5.8 通配符查询—-wildcard

wildcard查询text字段，wildcard不分词，text分词，需要通配符匹配text分词后的词条 wildcard查询keyword字段，wildcard不分词，keyword不分词，通配符匹配，完全like模式

  1. GET http://hadoop101:9200/user/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "wildcard":{
  7.             "sex":"*的"
  8.         }
  9.     }
  10. }

5.9 纠错查询—-fuzzy

例：输入个“吴疫烦”，也能把“吴亦凡”查出来，有一定的纠错能力 通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离。实际就是能容忍 错/少 几个字符，比如“吴疫烦”和“吴亦凡”fuzziness就是2

image.png
image.png
image.png
image.png

5.10 排序查询—-sort、order

text字段不支持聚合和排序

5.10.1 单字段排序查询

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "match_all":{
  8.         }
  9.     },
  10.     "sort":{
  11.         "price":{
  12.             "order":"desc"
  13.         }
  14.     }
  15. }

5.10.2 多字段排序查询

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "match_all":{
  8.         }
  9.     },
  10.     "sort":[
  11.         {
  12.             "price":{
  13.                 "order":"desc"
  14.             }
  15.         },
  16.         {
  17.             "_score":{
  18.                 "order":"desc"
  19.             }
  20.         }
  21.     ]
  22. }

5.11 高亮查询—-highlight

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "match":{
  7.             "title":"华为"
  8.         }
  9.     },
  10.     "highlight": {
  11.         "pre_tags": "<font color='red'>", // 前缀
  12.         "post_tags": "</font>",           // 后缀
  13.                 "fields": {
  14.                     "title": {}                     //高亮字段
  15.                 }
  16.         }
  17. }

5.12 分页查询—-from、size

  1. GET http://hadoop101:9200/shopping/_search
  3. # body如下：
  4. {
  5.     "query":{
  6.         "match_all":{
  8.         }
  9.     },
  10.     "from":0,        // 从第几条开始，from=(页数-1)*size
  11.     "size":1        // 每页多少量
  12. }

5.13 聚合查询—-aggs

text字段不支持聚合和排序

  1. GET http://hadoop101:9200/shopping/_search
  3. // 分组(桶聚合查询)
  4. {
  5.     "aggs":{                    // 分组查询
  6.         "price_group":{         // 名称，随意起名
  7.             "terms":{           // 分组
  8.                 "field":"price" // 分组字段
  9.             }
  10.         }
  11.     },
  12.     "size": 0                   // 如果不想查询结果中带有原始数据，可以设置size为0 
  13. }
  15. // 平均值
  16. {
  17.     "aggs":{                    // 分组查询
  18.         "price_avg":{           // 名称，随意起名
  19.             "avg":{             // 平均值
  20.                 "field":"price" // 分组字段
  21.             }
  22.         }
  23.     },
  24.     "size":0                    // 如果不想查询结果中带有原始数据，可以设置size为0 
  25. }
  27. // 最大值
  28. {
  29.     "aggs":{                    // 分组查询
  30.         "price_max":{           // 名称，随意起名
  31.             "max":{             // 最大值
  32.                 "field":"price" // 分组字段
  33.             }
  34.         }
  35.     },
  36.     "size":0                    // 如果不想查询结果中带有原始数据，可以设置size为0
  37. }
  39. // 最小值
  40. {
  41.     "aggs":{                    // 分组查询
  42.         "price_min":{           // 名称，随意起名
  43.             "min":{             // 最小值
  44.                 "field":"price" // 分组字段
  45.             }
  46.         }
  47.     },
  48.     "size":0                    // 如果不想查询结果中带有原始数据，可以设置size为0
  49. }
  51. // 去重后取总数
  52. {
  53.     "aggs":{                    // 分组查询
  54.         "distinct_price":{        // 名称，随意起名                
  55.             "cardinality":{        // 去重取总数
  56.                 "field":"price"    // 去重字段
  57.             }
  58.         }
  59.     },
  60.     "size":0
  61. }
  63. // state聚合，对某个字段一次性返回 count，max，min，avg 和 sum 五个指标
  64. {
  65.     "aggs":{                     // 分组查询
  66.         "stats_age":{             // 名称，随意起名
  67.             "stats":{             // state聚合
  68.                 "field":"age"     // 聚合字段
  69.             }
  70.         }
  71.     },
  72.     "size":0
  73. }

5.14 桶聚合查询—-aggs、terms

桶聚和相当于 sql 中的 group by 语句 text字段不支持聚合和排序

  1. GET http://hadoop101:9200/shopping/_search
  3. # terms聚合，分组统计，body如下：
  4. {
  5.     "aggs":{
  6.         "price_groupby":{
  7.             "terms":{"field":"price"}
  8.         }
  9.     },
  10.     "size":0
  11. }
  13. # 在terms分组下再进行聚合，body如下：
  14. {
  15.     "aggs":{
  16.         "price_groupby":{
  17.             "terms":{"field":"price"},
  18.             "aggs":{
  19.                 "sum_price":{
  20.                     "sum":{
  21.                         "field":"price"
  22.                     }
  23.                 }
  24.             }
  25.         }
  26.     },
  27.     "size":0
  28. }