Elasticsearch查询操作(一)

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
// 准备数据
PUT /shop/goods/1
{
"name": "2017新款女装冬季外套ulzzang棉袄中长款棉衣韩版百搭棉服面包服",
"desc": "",
"price": 268,
"quantity": 9267,
"colors": [
"绿色",
"黑色"
],
"is_discount": true,
"create_date": "2018-01-31 12:10:30",
"ip_addr": "192.168.10.1",
"location": "39.92733,116.39507",
"merchant": {
"id": 999,
"shop_name": "阿依莉旗舰店"
},
"params": [
{
"id": 1,
"label": "型号",
"value": "A30566"
},
{
"id": 2,
"label": "品牌",
"value": "阿依莉"
}
],
"activity": "买一送一"
}
PUT /shop/goods/2
{
"name": "2018春季长袖t恤女加绒加厚圆领宽松套头毛衣女装韩版学生毛线衣",
"price": 108,
"quantity": 268,
"colors": [
"白蓝红",
"红白黑"
],
"is_discount": false,
"create_date": "2017-01-31 12:10:30",
"ip_addr": "192.168.10.1",
"location": "39.92733,116.39507",
"merchant": {
"id": 6666,
"shop_name": "美特斯邦威旗舰店"
},
"params": [
{
"id": 1,
"label": "型号",
"value": "HWT8030"
},
{
"id": 2,
"label": "品牌",
"value": "美特斯邦威"
}
]
}
PUT /account/users/1
{
"username": "xiaoming",
"nickname": "小明的老师",
"age": 6,
"height": 1.68,
"birthday": "2017-01-31",
"hobbies": ["吃", "喝", "嫖", "赌"]
}
PUT /accounts/users/1
{
"username": "teacher",
"nickname": "谁能求姐",
"age": 6,
"height": 1.68,
"birthday": "2017-01-31",
"hobbies": ["批评小明"]
}

1
2
3
4
5
6
7
GET /_search
// 空查询：查询所有索引下的所有文档
GET /{index}/_search
// 查询某个索引下的前10条文档
GET /{index}/{type}/_search
// 查询某个索引下某个类型的前10条文档

1
2
3
4
5
6
7
8
9
多索引，多类型
GET /{index1},{index2}/_search
// 查询多个索引下的文档
GET /{index*}/_search
// 索引支持*号通配符
GET /{index*},{index*}/_search
GET /_all/_search
// 和GET /_search效果一样，_all：表示所有索引
GET /{index}/{type1},{type2}/_search

1
2
3
4
5
6
7
8
9
10
// 示例
GET /_search
GET /shop/_search
GET /shop/goods/_search
POST /shop/goods/_search
GET /shop,account/_search
GET /account*/_search
GET /account*,sho*/_search
GET /_all/_search
GET /shop/goods,products/_search

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// q好像对中文查询不出啦？？？可以通过其他方式进行查询
// 查询字段包含的字符串q=filed:value, 类似于SQL中的where last_name like '%Smith%'
GET /{index}/{type}/_search?q=last_name:Smith
// 加号+：表示必须存在，每部分都是包含的意思, 类似于SQL中的where fist_name like '%join%' and like '%Smith%'
// + 前缀表示必须与查询条件匹配。类似地， - 前缀表示一定不与查询条件匹配。
// 没有 + 或者 - 的所有其他条件都是可选的，类似于or——匹配的越多，文档就越相关
GET /{index}/{type}/_search?q=fist_name:join+last_name:Smith'
// -号代表不包含， 类似于SQL中的 where name not like '%join%'
GET /{index}/{type}/_search?q=-name:join
// name包含join但tweet不包含jmary的, 类似于SQL中的 where name like '%join%' and tweet not like '%mary%'
GET /{index}/{type}/_search?q=name:join+-tweet:mary
// 查询所有索引所有类型所有字段中包含mary关键字的文档， _all:可以代表所有索引或者所有类型或者所有字段，
// 每个文档都有一个隐形的_all字段，它的数据类型是文本型，它的值是以空格的形式将文档的所有字段的值拼接起来, 例如一个文档有三个值 age: 15, name:zhangsan, birthday:2018-09-15, 那么_all的值为“15 zhangsan 2018-09-15”
// _all会被分词，如果字段中包含日期，例如2018-09-15会被分析成2018，09， 15 三个词条(token)
GET /{index}/{type}/_search?q=_all:mary
// 如果不指定字段则默认是_all字段, _all字段是String类型
GET /{index}/{type}/_search?q=mary
POST /shop/goods/_search?_source=name,price
POST /shop/goods/_search?timeout=10ms
POST /shop/goods/_search?from=0&size=5
POST /shop/goods/_search?sort=create_date:desc&sort=_score

1
2
3
4
5
6
7
// 使用DSL查询肯能条件很多，比较复杂，可以通过使用验证API来检查一个查询是否有效
GET /{index}/{type}/_validate/query?explain
{
"query": {
...
}
} 

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
89
90
91
92
93
94
95
GET /shop/goods/_search
{
"query": {
"match": {
"name": "女装"
}
}
}
// 多词查询 ：使用空格隔离多个单词
// 查询name中包含“外套” 或者or 包含 “休闲” 的文档，多个关键字使用空格分隔，如果不指定operator默认是or
GET /shop/goods/_search
{
"query": {
"match": {
"name": "外套 休闲"
}
}
}
// "name": "外套 休闲" or 等价于bool中的should
GET /shop/goods/_search
{
"query": {
"bool": {
"should": [
"match": { "name": "外套" },
"match": { "name": "休闲" },
]
}
}
}
// 查询name中包含“外套” 并且 包含 “休闲” 的文档，多个关键字使用空格分隔
GET /shop/goods/_search
{
"query": {
"match": {
"name": "外套 休闲"，
"operator": "and"
}
}
}
// "name": "外套 休闲" and 等价于bool中的must
GET /shop/goods/_search
{
"query": {
"bool": {
"must": [
"match": { "name": "外套" },
"match": { "name": "休闲" },
]
}
}
}
// 多词查询中使用or只需要满足一个即可，要求太低，使用and又必须所有词项都必须满足，要求又太高，
// 使用minimum_should_match折中一下，最小匹配：可以指定一个百分比，
// 例如指定4个词项，一个是词项是25%，设置成50%就是至少要满足2个词项
GET /shop/goods/_search
{
"query": {
"match": {
"name": {
"query": "春季 长袖 圆领 学生",
"minimum_should_match": "50%"
}
}
}
}
// 效果和上面一样，等价的
GET /shop/goods/_search
{
"query" : {
"bool": {
"filter": {
"bool" : {
"should" : [
{ "term" : {"name" : "春季"}},
{ "term" : {"name" : "长袖"}},
{ "term" : {"name" : "圆领"}},
{ "term" : {"name" : "学生"}}
],
"minimum_should_match": 2
}
}
}
}
}
// 查询日期
GET /shop/goods/_search
{
"query": {
"match": {
"create_date": "2018-01-31"
}
}
}

1
2
3
4
5
6
7
8
9
10
11
GET /shop/goods/_search
{
"query": {
"match_all": {}
}
}
// 上面简写成这样，效果是一样的
GET /shop/goods/_search
{}
// 同样也可以去掉{},更加简洁
GET /shop/goods/_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
// match如果对一小段文本进行查询，match首先对字段值进行分词，然后对分词进行匹配，相当于SQL中的name like '%女装%' or name like '%冬季%' or name like '%外套%'
GET /shop/goods/_search
{
"query": {
"match": {
"name": "女装冬季外套"
}
}
}
GET /shop/goods/_search
{
"query": {
"match_phrase": {
"name": "女装冬季外套"
}
}
}
// slop:让相对词序位置不那么严格
// 注意上面使用的是“女装冬季外套”，而现在使用的是“套女装冬季”， slop:允许每个词放宽的间隔
// 尽管词语的顺序不正确，查询仍然能匹配，因为我们为它设置了足够高的slop值使匹配时的词序有更大的灵活性。
GET /shop/goods/_search
{
"query": {
"match_phrase": {
"name": {
"query": "外套女装冬季",
"slop":
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
GET /shop/goods/_search
{
"query": {
"match_phrase_prefix": {
"name": "女装冬季外套"
}
}
}
// slop:让相对词序位置不那么严格
// 注意上面使用的是“女装冬季外套”，而现在使用的是“套女装冬季”， slop:允许每个词放宽的间隔
// 尽管词语的顺序不正确，查询仍然能匹配，因为我们为它设置了足够高的slop值使匹配时的词序有更大的灵活性。
GET /shop/goods/_search
{
"query": {
"match_phrase_prefix": {
"name": {
"query": "外套女装冬季",
"slop":
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
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
## edge_ngram 自定义过滤器、分词器
PUT /my_index
{
"settings": {
"number_of_shards": 1,
"analysis": {
"filter": {
"autocomplete_filter": {
"type":
"edge_ngram",
"min_gram": 1,
"max_gram": 20
}
},
"analyzer": {
"autocomplete": {
"type":
"custom",
"tokenizer": "standard",
"filter": [
"lowercase",
"autocomplete_filter"
]
}
}
}
}
}
## 测试分词
GET /my_index/_analyze
{
"analyzer": "autocomplete",
"text": "quick brown"
}
PUT /my_index/_mapping/my_type
{
"my_type": {
"properties": {
"name": {
"type":
"text",
"analyzer": "autocomplete",
## 使用自定义的分词器
"search_analyzer": "standard" ## 配置查询对应的分词器
}
}
}
}
POST /my_index/my_type/_bulk
{ "index": { "_id": 1
}}
{ "name": "Brown foxes"
}
{ "index": { "_id": 2
}}
{ "name": "Yellow furballs" }
## 搜索
GET /my_index/my_type/_search
{
"query": {
"match": {
"name": {
"query":
"brown fo"
}
}
}
}

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
GET /shop/goods/_search
{
"query": {
"multi_match": {
"query": 268,
"fields": ["price", "quantity"]
}
}
}
// 两者效果相同
GET /shop/goods/_search
{
"query": {
"bool": {
"should": [
{ "term": { "price": { "value": 268 } } },
{ "term": { "quantity": { "value": 268 } } }
]
}
}
}
// 查询字段名称的模糊匹配
// 字段名称可以用模糊匹配的方式给出：任何与模糊模式正则匹配的字段都会被包括在搜索条件中，
例如可以使用以下方式同时匹配 book_title 、 chapter_title 和 section_title （书名、章名、节名）这三个字段：
{
"multi_match": {
"query":
"Quick brown fox",
"fields": "*_title"
}
}
// 提升单个字段的权重
// 可以使用 ^ 字符语法为单个字段提升权重，在字段名称的末尾添加 ^boost ，其中 boost 是一个浮点数：
// chapter_title 这个字段的 boost 值为 2 ，而*_title 字段的默认 boost 值为 1
{
"multi_match": {
"query":
"Quick brown fox",
"fields": [ "*_title", "chapter_title^2" ] (1)
}
}

1
2
3
4
5
6
7
8
9
10
11
12
GET /shop/goods/_search
{
"query": {
"constant_score": {
"filter": {
"term": {
"price": 268.00
}
}
}
}
}

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
PUT /my_index
{
"mappings": {
"address": {
"properties": {
"postcode": {
"type":
"keyword"
}
}
}
}
}
PUT /my_index/address/1
{ "postcode": "W1V 3DG" }
PUT /my_index/address/2
{ "postcode": "W2F 8HW" }
PUT /my_index/address/3
{ "postcode": "W1F 7HW" }
PUT /my_index/address/4
{ "postcode": "WC1N 1LZ" }
PUT /my_index/address/5
{ "postcode": "SW5 0BE" }
// prefix 查询
GET /my_index/address/_search
{
"query": {
"prefix": {
"postcode": {
"value": "W1"
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
GET /my_index/address/_search
{
"query": {
"wildcard": {
"postcode": "W?F*HW"
}
}
}
// 词必须以 W 开头，紧跟 0 至 9 之间的任何一个数字，然后接一或多个其他字符
GET /my_index/address/_search
{
"query": {
"regexp": {
"postcode": "W[0-9].+"
}
}
}

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
GET /shop/goods/_search
{
"query": {
"range": {
"price": {
"gt": 200,
"lte": 500
}
}
}
}
// 日期类型
GET /shop/goods/_search
{
"query": {
"range": {
"create_date": {
"gt" : "2014-01-01 00:00:00",
"lt" : "2014-01-07 00:00:00"
}
}
}
}
// 日期计算：过去一小时
GET /shop/goods/_search
{
"query": {
"range": {
"create_date": {
"gt" : "now-1h"
}
}
}
}
// 日期计算：早于 2014 年 1 月 1 日加 1 月（2014 年 2 月 1 日 零时）
GET /shop/goods/_search
{
"query": {
"range": {
"create_date": {
"gt" : "2014-01-01 00:00:00",
"lt" : "2014-01-01 00:00:00||+1M"
}
}
}
}
// 作用于字符串，性能相对较慢
"range" : {
"title" : {
"gte" : "a",
"lt" :
"b"
}
}

1
2
3
4
5
6
7
8
9
10
GET /shop/goods/_search
{
"query": {
"term": {
"is_discount": {
"value": true
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
GET /shop/goods/_search
{
"query": {
"terms": {
"colors": [
"白蓝红",
"绿色"
]
}
}
}

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
// 存在某个字段
GET /shop/goods/_search
{
"query": {
"bool": {
"filter": {
"exists": {
"field": "activity"
}
}
}
}
}
// 不存在某个字段
GET /shop/goods/_search
{
"query": {
"bool": {
"must_not": {
"exists": {
"field": "activity"
}
}
}
}
}
POST /my_index/posts/_bulk
{ "index": { "_id": "1"
}}
{ "tags" : ["search"]
}
{ "index": { "_id": "2"
}}
{ "tags" : ["search", "open_source"] }
{ "index": { "_id": "3"
}}
{ "other_field" : "some data"
}
{ "index": { "_id": "4"
}}
{ "tags" : null
}
{ "index": { "_id": "5"
}}
{ "tags" : ["search", null]
}
以上文档集合中 tags 字段对应的倒排索引如下：
Token DocIDs
open_source 2
search 1,2,5
1. tags 字段有 1 个值。
2. tags 字段有 2 个值。
3. tags 字段缺失。
4. tags 字段被置为 null 。
5. tags 字段有 1 个值和 1 个 null 。
// 1,2,5 满足条件
GET /my_index/posts/_search
{
"query" : {
"constant_score" : {
"filter" : {
"exists" : { "field" : "tags" }
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 高亮： 匹配的结果会被 <em></em> HTML字符包裹住：
curl -i -H 'Content-Type: application/json'
-XGET 'http://localhost:9200/megacorp/employee/_search' -d '
{
"query" : {
"match_phrase" : {
"about" : "rock climbing"
}
},
"highlight": {
"pre_tags" : ["<font color='red'>"],
"post_tags" : ["</font>"],
"fields" : {
"about" : {}
}
}
}'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 排序,默认情况下是按照相关性评分排序的，最相关的文档排在最前， 默认按_score排序的
// 多级排序，使用date, _score排序
GET /_search
{
"query" : {
"bool" : {
"must":
{ "match": { "tweet": "manage text search" }},
"filter" : { "term" : { "user_id" : 2 }}
}
},
"sort": [
{ "date":
{ "order": "desc" }},
{ "_score": { "order": "desc" }},
{ "ids" : { "order": "asc", "mode":
"min"}}
]
}
mode:一般用于数组，可以使用min 、 max 、 avg 或是 sum，统计计算数组的指定值排序

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
// fields 多字段：相当于对同一个字段值起不同的名字，赋予这个字段不同的属性(如类型不同，分词器不同等)
PUT /school
{
"mappings": {
"students": {
"properties": {
"name": {
"type": "text",
"analyzer": "ik_max_word",
"fields": {
"raw": {
"type": "keyword"
}
}
}
}
}
}
}
// _score 和 max_score 字段都是 null 。计算 _score 的花销巨大，通常仅用于排序； 我们并不根据相关性排序，所以记录 _score 是没有意义的。如果无论如何你都要计算 _score ， 你可以将 track_scores 参数设置为 true
GET /school/students/_search
{
"query": { "match": { "name": "abc" } },
"sort": [ { "name.raw": { "order": "desc" } } ]
}
// 强制计算评分
GET /school/students/_search
{
"track_scores": true,
"query": { "match": { "name": "abc" } },
"sort": [ { "name.raw": { "order": "desc"} } ]
}

1
2
3
4
5
GET /shop/goods/_search
{
"from": 0,
"size": 20
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 保持游标查询窗口一分钟
// 关键字 _doc 是最有效的排序顺序。
GET /shop/goods/_search?scroll=1m
{
"query": {"match_all": {}},
"sort": ["_doc"],
"size": 1000
}
// 这个查询的返回结果包括一个字段 _scroll_id， 它是一个base64编码的长字符串 。 现在我们能传递字段 _scroll_id 到 _search/scroll
{
"_scroll_id": "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAMoFmQ0clZDNEg4UWYtYTBzVTg0QWRFdmcAAAAAAAADKRZkNHJWQzRIOFFmLWEwc1U4NEFkRXZnAAAAAAAAAyoWZDRyVkM0SDhRZi1hMHNVODRBZEV2ZwAAAAAAAAMrFmQ0clZDNEg4UWYtYTBzVTg0QWRFdmcAAAAAAAADLBZkNHJWQzRIOFFmLWEwc1U4NEFkRXZn",
"took": 1,
"timed_out": false,
...
}
// 查询接口获取下一批结果：
GET /_search/scroll
{
"scroll": "1m",
"scroll_id": "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAAAKbFmQ0clZDNEg4UWYtYTBzVTg0QWRFdmcAAAAAAAACnBZkNHJWQzRIOFFmLWEwc1U4NEFkRXZnAAAAAAAAAp0WZDRyVkM0SDhRZi1hMHNVODRBZEV2ZwAAAAAAAAKeFmQ0clZDNEg4UWYtYTBzVTg0QWRFdmcAAAAAAAACnxZkNHJWQzRIOFFmLWEwc1U4NEFkRXZn"
}

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
GET /shop/goods/_search
{
"query": {
"bool": {
"must": [
{"term": {
"quantity": {
"value": 999
}
}}
],
"must_not": [
{
"term": {
"quantity": {
"value": 9267
}
}
}
],
"should": [
{
"term": {
"is_discount": {
"value": true
}
}
}
],
"filter": {
"range": {
"price": {
"gte": 7777,
"lte": 9999
}
}
}
}
}
}

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
// filter中也可以嵌套bool查询，这样内部的bool查询就不参与评分了
// bool中的must must_not should 等会计算评分的，如果不希望计算评分，可将bool放入到filter中,这样既不计算评分又可以使用bool中的逻辑
// 直接使用bool中的filter和将bool再次嵌入到filter中都不计算评分
GET /shop/goods/_search
{
"query": {
"bool": {
"must":
{ "match": { "title": "how to make millions" }},
"must_not": { "match": { "tag":
"spam" }},
"should": [
{ "match": { "tag": "starred" }}
],
"filter": {
"bool": {
"must": [
{ "range": { "date": { "gte": "2014-01-01" }}},
{ "range": { "price": { "lte": 29.99 }}}
],
"must_not": [
{ "term": { "category": "ebooks" }}
]
}
}
}
}
}
// 就像我们能控制 match 查询的精度 一样，我们可以通过 minimum_should_match 参数控制需要匹配的
// should 语句的数量， 它既可以是一个绝对的数字，又可以是个百分比：
// 这个查询结果会将所有满足以下条件的文档返回：
// title 字段包含 "brown" AND "fox" 、 "brown" AND "dog" 或 "fox" AND "dog" 。
// 如果有文档包含所有三个条件，它会比只包含两个的文档更相关。
GET /my_index/my_type/_search
{
"query": {
"bool": {
"should": [
{ "match": { "title": "brown" }},
{ "match": { "title": "fox"
}},
{ "match": { "title": "dog"
}}
],
"minimum_should_match": 2
}
}
}
// boost 参数被用来提升一个语句的相对权重（ boost 值大于 1 ）或降低相对权重（ boost 值处于 0 到 1 之间），
// 但是这种提升或降低并不是线性的，换句话说，如果一个 boost 值为 2 ，并不能获得两倍的评分 _score 。
// 通过指定 boost 来控制任何查询语句的相对的权重， boost 的默认值为 1 ，大于 1 会提升一个语句的相对权重。
// 更高的 boost 值为我们带来更高的评分 _score
GET /_search
{
"query": {
"bool": {
"must": {
"match": {
"content": {
"query":
"full text search",
"operator": "and"
}
}
},
"should": [
{ "match": {
"content": {
"query": "Elasticsearch",
"boost": 3
}
}},
{ "match": {
"content": {
"query": "Lucene",
"boost": 2
}
}}
]
}
}
}

1
2
3
4
5
6
7
8
9
PUT /{index}/_mapping/{type}
{
"properties": {
"FILED": {
"type": "text",
"fielddata": true
}
}
}

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
// 统计数组中每个元素出现的次数，中文有问题，现在中文分词是按单个字分词的，估计需要指定对该字段不分词
GET /shop/goods/_search
{
"aggs": {
"xxx": {
"terms": {
"field": "colors",
"size": 10
}
}
}
}
// aggs可以嵌套在aggs中使用
// 嵌套聚合，分级汇总，在聚合中可以进行再聚合，意思是对分组的文档进行其他聚合，而不是对聚合结果进行处理
GET /shop/goods/_search
{
"aggs": {
"xxx": {
"terms": {
"field": "colors",
"size": 10
},
"aggs": {
"yyy": {
"avg": {
"field": "price"
}
}
}
}
}
}

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
// 路径中不包含index、type、id
GET /_mget
{
"docs" : [
{
"_index" : "shop",
"_type" :
"goods",
"_id" :
2
},
{
"_index" : "account",
"_type" :
"users",
"_id" :
1,
"_source": "nickname"
}
]
}
// 路径中包含index、type, 如果参数中没有指定index、type就使用路径中的，如果参数中明确指定了，就使用参数中的索引和类型
GET /{index}/{type}/_mget
{
"docs" : [
{ "_id" : 2 },
{ "_type" : "account", "_id" : 1 }
]
}
// 路径中指定了索引和类型，通过ids数组指定多个id值
GET /{index}/{type}/_mget'
{
"ids" : [ "2", "1" ]
}

1
2
3
4
5
6
7
{ action: { metadata }}n
{ request body
}n
{ action: { metadata }}n
{ request body
}n
...

1
2
3
4
5
6
7
8
9
10
11
POST /_bulk
{ "create": { "_index": "shop", "_type": "goods", "_id": 123 }}
{ "name":
"My first blog post" }
{ "index":
{ "_index": "shop", "_type": "goods" }}
{ "name":
"My second blog post" }
{ "update": { "_index": "shop", "_type": "goods", "_id": 123, "retry_on_conflict" : 3} }
{ "doc" : {"title" : "My updated blog post"} }
{ "delete": { "_index": "shop", "_type": "goods", "_id": 1234 }}