Kibana常用查询命令_kibana查询命令

1.获取所有数据

# 默认情况下，es一次展示10条数据,通过from和size来控制分页
# 索引goods的查询
GET goods/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 100
}

#如果没有查询条件也可以使用最简单的
GET goods/_search

#结果示例
{
  "took": 5,
  "timed_out": false,
  "_shards": {
    "total": 2,
    "successful": 2,
    "skipped": 0,
    "failed": 0
  },
  "hits": {//查询结果的统计对象
    "total": 5545,//命中数
    "max_score": 2.239803,//最大得分
    "hits": [//具体的查询数据
      {
        "_index": "goods",
        "_type": "data",
        "_id": "d6d5cba0b5ef4b20bc995d07418ae533",
        "_score": 2.239803,
        "_source": {
          "PXH": "0",
          "ZLTYPEJC": "问题解答"  
        }
      }
    ]
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2.查询索引结构

GET goods

#text：会分词，不支持聚合
#keyword：不会分词，将全部内容作为一个词条，支持聚合
#可参考https://www.cnblogs.com/candlia/p/11920029.html
#https://blog.csdn.net/qq_32165041/article/details/83688593
#结果示例
{
  "goods": {
    "aliases": {},
    "mappings": {
      "data": {
        "properties": {
          "BQID": {
            "type": "keyword",
            "ignore_above": 10922
          },
          "IVRCONTENT": {
            "type": "text",
            "fields": {//fields可以让同一文本有多种不同的索引方式，
              //比如一个String类型的字段，可以使用text类型做全文检索，使用keyword类型做聚合和排序。
              "keyword": {//类似子名字，随便取得，用的时候IVRCONTENT.field
                "type": "keyword",
                "ignore_above": 10922//ignore_above用于指定字段索引和存储的长度最大值
              }
            },
            "analyzer": "standard"
          }
        }
      }
    },
    "settings": {
      "index": {
        "number_of_shards": "2",//数据所在分片
        "provided_name": "goods",
        "max_result_window": "98854",
        "creation_date": "1631065422638",
        "number_of_replicas": "0",
        "uuid": "VTTVR9blTXiTJgFmJMxLdQ",
        "version": {
          "created": "5061299"
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

3.term和match查询

• 词条查询：term

  词条查询不会对==查询条件==分词，只有当词条和查询字符串完全匹配时才匹配搜索。适合查询type为keyword这种类型的数据。

# term查询，只会查询title里有“华为”两字的数据，不会查询title里只有“华”或“为”的结果
GET goods/_search
{
  "query": {
    "term": {
      "title": {//字段名
        "value": "华为"//字段值
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

• 全文查询：match

  全文查询会对查询条件分词，先将查询条件进行分词，然后查询，默认求并集（or）

# match查询  
# 如果查询的是keyword类型数据，那么完全匹配的数据也能被查询，比如有个keyword字段的值是“问题查询”，那么
# macth查询的时候“问题”、“查询”都不能查到该数据，但“问题查询”可以查到。
# 还有一个matchphrase,查询keyword类型数据与match一样，查询text类型数据时，
# match_phrase的分词结果必须在text字段分词中都包含，而且顺序必须相同，而且必须都是连续的。
# 例如，用“i am Chinese”查询时，“i am”、“ am Chinese”都能匹配，但“i Chinese”、“Chinese am” 不能匹配。
# 它与后面的queryString的区别就是后者不要求顺序
# 可参考https://blog.csdn.net/albertfly/article/details/100705554
# 如果是查询的是nested嵌套对象里的字段可参考：https://learnku.com/articles/54331
GET goods/_search
{
  "query": {
    "match": {
      "title": "华为手机"
    }
  },
  "size": 500
}

#可以指定为and操作
GET goods/_search
{
  "query": {
    "match": {
      "title": {
        "query":  "华为手机",
        "operator": "and"//交集
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

4.分词器

ES默认的分词器对中文不友好，需要安装IKAnalyzer插件支持中文分词。

IK分词器有两种分词模式：

• ik_max_word，将文本做最细粒度的拆分，比如会将“乒乓球明年总冠军”拆分为“乒乓球、乒乓、球、明年、总冠军、冠军。
• ik_smart，将文本做最粗粒度的拆分，比如会将“乒乓球明年总冠军”拆分为乒乓球、明年、总冠军。

#可以通过以下命令来查看分词效果

GET /_analyze
{
  "analyzer": "standard",
  "text": "我爱北京天安门"
}

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "我爱北京天安门"
}

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "我爱北京天安门"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.匹配查询

# wildcard 查询。查询条件分词，模糊查询，查询的字段既可以是keyword也可以是text
# 如果title是text类型数据，那么查询时会对“华为”进行分词，导致查询结果不正确,甚至查询不到结果，此时可以使用fileds给title
# 添加一个keyword类型的别名，然后用title.别名 查询
GET goods/_search
{
  "query": {
    "wildcard": {
      "title": {
        "value": "华为*"
      }
    }
  }
}

# 正则查询
GET goods/_search
{
  "query": {
    "regexp": {
      "title": "\\w+(.)*"
    }
  }
}

# 前缀查询,与item查询的区别是keyword类型的数据用使用第一个字的话，前缀查询可以查到，用item查询无结果
GET goods/_search
{
  "query": {
    "prefix": {
      "brandName": {
        "value": "三"
      }
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

6.范围查询

# 范围查询
GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 2000,
        "lte": 3000
      }
    }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.querystring

# queryString,类似于mysql里的条件查询
# 对于keyword类型的数据，需要完全匹配才能查询到
# 对于text类型的数据，会根据分词结果查询。

GET goods/_search
{
  "query": {
    "query_string": {
      "fields": ["title","categoryName","brandName"], 
      "query": "华为手机"//将"华为手机"分词后依次从"title","categoryName","brandName"
      								//三个属性中查询,默认是and,可以写成“华为 or 手机”
    }
  }
}


GET goods/_search
{
  "query": {
    "simple_query_string": {
      "fields": ["title","categoryName","brandName"], 
      "query": "华为手机"//不支持and or 连接符
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

8.布尔查询

# boolquery 布尔查询
#must（and）：条件必须成立
#must_not（not）：条件必须不成立
#should（or）：条件可以成立
#filter：条件必须成立，性能比must高。不会计算得分，可以用constant_score包裹查询条件，用boost指定分数（Float）
#es相关度计算参考https://blog.csdn.net/miaomiao19971215/category_9729020.html，
# https://blog.csdn.net/ma15732625261/article/details/79537287
#must，filter内按照正常的查询写即可,利用exist可判断字段是否为null或不存在,，如果是嵌套nested类型可参考
# https://blog.csdn.net/TinyNasubi/article/details/101285893，其中的path属性就是对象名
GET goods/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brandName": {
              "value": "华为"
            }
          }
        }
      ],
      "filter":[ 
        {
        "term": {
          "title": "手机"
        }
       },
       {
         "range":{
          "price": {
            "gte": 2000,
            "lte": 3000
         }
         }
       }
      
      ]
    }
  }
}

GET goods/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "brandName": {
              "value": "华为"
            }
          }
        }
      ]
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

9.聚合查询

•指标聚合，相当于MySQL的聚合函数。max、min、avg、sum等
•桶聚合，相当于MySQL的 group by 操作。不要对text类型的数据进行分组，会失败。

# 聚合查询，注意！！！聚合结果在正常的查询结果后面的aggregation部分

# 指标聚合 聚合函数

GET goods/_search
{
  "query": {//查询部分
    "match": {
      "title": "手机"
    }
  },
  "aggs": {//聚合部分
    "max_price": {//聚合结果别名
      "max": {//指标聚合类型
        "field": "price"//字段类型要为number
      }
    }
  }
}

# 桶聚合  分组

GET goods/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "aggs": {
    "goods_brands": {//别名
      "terms": {
        "field": "brandName",//桶聚合字段
        "size": 10//分组结果中展示的数量，比如按brandName分组共有20组，这个设置就是在结果中显示10组
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

10.高亮查询

# ！！！结果在最后的highlight部分，对结果中title属性值的“电视”俩字加前后缀
GET goods/_search
{
  "query": {
    "match": {
      "title": "电视"
    }
  },
  "highlight": {
    "fields": {
      "title": {//字段名
        "pre_tags": "<font color='red'>",//默认的前后缀是<em></em>
        "post_tags": "</font>"
      }
    }
  }
}

# 也有这样写的，这种写法kibana里会有提示
GET goods/_search
{
  "query": {
    "match": {
      "title": "电视"
    }
  },
  "highlight": {
    "fields": {
      "title": {}
    },
    "pre_tags": "<font color='red'>",
    "post_tags": "</font>",
    "fragment_size": 10
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

11.修改索引映射结构

# -------重建索引-----------

# 新建student_index_v1。索引名称必须全部小写

PUT student_index_v1
{
  "mappings": {
    "properties": {
      "birthday":{
        "type": "date"
      }
    }
  }
}

GET student_index_v1

PUT student_index_v1/_doc/1
{
  "birthday":"1999-11-11"
}


GET student_index_v1/_search


PUT student_index_v1/_doc/1
{
  "birthday":"1999年11月11日"
}

# 业务变更了，需要改变birthday字段的类型为text

# 1. 创建新的索引 student_index_v2
# 2. 将student_index_v1 数据拷贝到 student_index_v2

# 创建新的索引 student_index_v2
PUT student_index_v2
{
  "mappings": {
    "properties": {
      "birthday":{
        "type": "text"
      }
    }
  }
}
# 将student_index_v1 数据拷贝到 student_index_v2
# _reindex 拷贝数据
POST _reindex
{
  "source": {
    "index": "student_index_v1"
  },
  "dest": {
    "index": "student_index_v2"
  }
}

GET student_index_v2/_search



PUT student_index_v2/_doc/2
{
  "birthday":"1999年11月11日"
}



# 思考： 现在java代码中操作es，还是使用的实student_index_v1老的索引名称。
# 1. 改代码（不推荐）
# 2. 索引别名（推荐）

# 步骤：
# 0. 先删除student_index_v1
# 1. 给student_index_v2起个别名 student_index_v1



# 先删除student_index_v1
DELETE student_index_v1
# 给student_index_v2起个别名 student_index_v1
POST student_index_v2/_alias/student_index_v1


GET student_index_v1/_search
GET student_index_v2/_search
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88