设为首页 收藏本站
云服务器等爆品抢先购,低至4.2元/月
查看: 1566|回复: 0

[经验分享] Elasticsearch Index API & Aggregations API & Query DSL

[复制链接]
累计签到:1 天
连续签到:1 天
发表于 2016-10-17 10:19:24 | 显示全部楼层 |阅读模式
这篇小菜给大家演示和讲解一些Elasticsearch的API,如在工作中用到时,方便查阅。

一、Index API

创建索引库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
curl -XPUT 'http://127.0.0.1:9200/test_index/' -d '{
    "settings" : {
      "index" : {
      "number_of_shards" : 3,
      "number_of_replicas" : 1
      }
    },
    "mappings" : {
      "type_test_01" : {
        "properties" : {
          "field1" : { "type" : "string"},
          "field2" : { "type" : "string"}
        }
      },
      "type_test_02" : {
        "properties" : {
          "field1" : { "type" : "string"},
          "field2" : { "type" : "string"}
        }
      }
    }
}'




验证索引库是否存在
1
curl –XHEAD -i 'http://127.0.0.1:9200/test_index?pretty'



注: 这里加上的?pretty参数,是为了让输出的格式更好看。

查看索引库的mapping信息
1
curl –XGET -i 'http://127.0.0.1:9200/test_index/_mapping?pretty'




验证当前库type为article是否存在
1
curl -XHEAD -i 'http://127.0.0.1:9200/test_index/article'




查看test_index索引库type为type_test_01的mapping信息
1
curl –XGET -i 'http://127.0.0.1:9200/test_index/_mapping/type_test_01/?pretty'




测试索引分词器
1
2
3
4
5
curl -XGET 'http://127.0.0.1:9200/_analyze?pretty' -d '
{
  "analyzer" : "standard",
  "text" : "this is a test"
}'




输出索引库的状态信息
1
curl 'http://127.0.0.1:9200/test_index/_stats?pretty'




输出索引库的分片相关信息
1
curl -XGET 'http://127.0.0.1:9200/test_index/_segments?pretty'




删除索引库
1
curl -XDELETE http://127.0.0.1:9200/logstash-nginxacclog-2016.09.20/




二、Count API

简易语法
curl -XGET 'http://elasticsearch_server:port/索引库名称/_type(当前索引类型,没有可以不写)/_count

用例:
1、统计 logstash-nginxacclog-2016.10.09 索引库有多少条记录
1
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_count'




2、统计 logstash-nginxacclog-2016.10.09 索引库status为200的有多少条记录
1
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_count?q=status:200'




DSL 写法
1
2
3
4
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_count' -d '
{ "query":
  { "term":{"status":"200"}}
}'




三、Aggregations API (数据分析和统计)

注: 聚合相关的API只能对数值、日期 类型的字段做计算。

1、求平均数
业务场景: 统计访问日志中的平均响应时长
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"avg_num" : { "avg" : { "field" : "responsetime" } }
},"size":0  # 这里的 size:0 表示不输出匹配到数据,只输出聚合结果。
}'


{
  "took" : 598,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 32523067,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "avg_num" : {
      "value" : 0.0472613558675975
    }
  }
}

# 得到平均响应时长为 0.0472613558675975 秒




2、求最大值
业务场景:获取访问日志中最长的响应时间
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"max_num" : { "max" : { "field" : "responsetime" } }
},"size":0
}'


{
  "took" : 29813,
  "timed_out" : false,
  "_shards" : {
    "total" : 431,
    "successful" : 431,
    "failed" : 0
  },
  "hits" : {
    "total" : 476952009,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "max_num" : {
      "value" : 65.576
    }
  }
}

# 得到最大响应时长为 65.576 秒




3、求最小值
业务场景: 获取访问日志中最快的响应时间
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"min_num" : { "min" : { "field" : "responsetime" } }
},"size":0
}'


{
  "took" : 2145,
  "timed_out" : false,
  "_shards" : {
    "total" : 431,
    "successful" : 431,
    "failed" : 0
  },
  "hits" : {
    "total" : 477156773,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "min_num" : {
      "value" : 0.0
    }
  }
}

# 看来最快的响应时间竟然是0,笔者通过查询日志发现,原来这些响应时间为0的请求是被nginx拒绝掉的。




4、数值求和
业务场景: 统计一天的访问日志中为响应请求总共输出了多少流量。
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"sim_num" : { "sum" : { "field" : "size" } }
},"size":0
}'

{
  "took" : 1226,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 32523067,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "sim_num" : {
      "value" : 6.9285945505E10
    }
  }
}

# 这个数有点大,后面的E10 表示 6.9285945505 X 10^10 ,笔者算了下,大概 70GB 流量。




5、获取常用的数据统计指标
其中包括( 最大值、最小值、平均值、求和、个数 )

业务场景: 求访问日志中的 responsetime ( 最大值、最小值、平均值、求和、个数 )
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"like_stats" : { "stats" : { "field" : "responsetime" } }
},"size":0
}'


{
  "took" : 2868,
  "timed_out" : false,
  "_shards" : {
    "total" : 431,
    "successful" : 431,
    "failed" : 0
  },
  "hits" : {
    "total" : 477797577,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "like_stats" : {
      "count" : 469345191,
      "min" : 0.0,
      "max" : 65.576,
      "avg" : 0.06088492952649428,
      "sum" : 2.8576048877634E7
    }
  }
}




这个是上面统计方式的增强版,新增了几个统计数据
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"like_stats" : { "extended_stats" : { "field" : "responsetime" } }
},"size":0
}'


{
  "took" : 2830,
  "timed_out" : false,
  "_shards" : {
    "total" : 431,
    "successful" : 431,
    "failed" : 0
  },
  "hits" : {
    "total" : 478145456,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "like_stats" : {
      "count" : 469687072,
      "min" : 0.0,
      "max" : 65.576,
      "avg" : 0.06087745173159307,
      "sum" : 2.859335205463328E7,
      "sum_of_squares" : 1.3162790273264633E7,
      "variance" : 0.02431853151732958,
      "std_deviation" : 0.1559440012226491,
      "std_deviation_bounds" : {
        "upper" : 0.3727654541768913,
        "lower" : -0.2510105507137051
      }
    }
  }
}

# 其中新增的三个返回结果分别是:

# sum_of_squares  平方和

# variance  方差

# std_deviation  标准差




6、统计数据在某个区间所占的百分比
业务场景: 求出访问日志中响应时间的各个区间,所占的百分比
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"outlier" : { "percentiles" : { "field" : "responsetime" } }
},"size":0
}'

{
  "took" : 60737,
  "timed_out" : false,
  "_shards" : {
    "total" : 431,
    "successful" : 431,
    "failed" : 0
  },
  "hits" : {
    "total" : 478287997,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "outlier" : {
      "values" : {
        "1.0" : 0.0,
        "5.0" : 0.0,
        "25.0" : 0.02,
        "50.0" : 0.038999979789136247,
        "75.0" : 0.06247223731250421,
        "95.0" : 0.16479760590682113,
        "99.0" : 0.520510492464275
      }
    }
  }
}

# values 对应的列为所占的百分比,右边则是对应的数据值。表示:

# 响应时间小于或等于0的请求占 1%

# 响应时间小于或等于0的请求占 5%

# 响应时间小于或等于0.02的请求占 25%

# 响应时间小于或等于0.038999979789136247的请求占 50%

# 响应时间小于或等于0.06247223731250421的请求占 75%

# 响应时间小于或等于0.16479760590682113的请求占 95%

# 响应时间小于或等于0.520510492464275的请求占 99%


# 还可以通过 percents 参数,自定义一些百分比区间,如 10%,30%,60%,90% 等。

# 注: 经笔者测试,这个方法只能对数值类型的字段进行统计,无法操作字符串类型的字段。


curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"outlier" : { "percentiles" : {
                                  "field" : "status",
                                  "percents":[5, 10, 20, 50, 99.9]
                                  }
              }
},"size":0
}'




7、求指定字段数值在各个区间所占的百分比
业务场景:求响应时间 0, 0.01, 0.1, 0.2 在整个日志文件中,分别所占的百分比。
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"outlier" : { "percentile_ranks" : {
"field" : "responsetime",
"values":[0, 0.01, 0.1, 0.2]
}
}
},"size":0
}'

{
  "took" : 6950,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 32523067,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "outlier" : {
      "values" : {
        "0.0" : 8.79897648675993,
        "0.01" : 17.90331319256336,
        "0.1" : 91.18297638776373,
        "0.2" : 98.22564774611764
      }
    }
  }
}

# 响应时间小于或等于0的请求占 8.7%

# 响应时间小于或等于0.01的请求占 17.9%

# 响应时间小于或等于0.1的请求占 91.1%

# 响应时间小于或等于0.2的请求占 98.2%




8、求该数值范围内有多少文档匹配

业务场景: 求访问日志中的响应时间为,0 ~ 0.02、0.02 ~ 0.1 、大于 0.1 这三个数值区间内,各有多少文档匹配。

"ranges":[{"to": 0.02}, {"from":0.02,"to":0.1},{"from":0.1}]


{"to": 0.02} 求响应时间 0 ~ 0.02 区间内的匹配文档数  

{"from":0.02,"to":0.1} 求响应时间 0.02 ~ 0.1 区间内匹配的文档数

{"from":0.1} 求响应时间大于 0.1 匹配的文档数
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"range_info" : { "range" : {
"field" : "responsetime",
"ranges":[{"to": 0.02}, {"from":0.02,"to":0.1},{"from":0.1}]
}
}
},"size":0
}'


{
  "took" : 474,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 32523067,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "range_info" : {
      "buckets" : [ {
        "key" : "*-0.02",
        "to" : 0.02,
        "to_as_string" : "0.02",
        "doc_count" : 9093600
      }, {
        "key" : "0.02-0.1",
        "from" : 0.02,
        "from_as_string" : "0.02",
        "to" : 0.1,
        "to_as_string" : "0.1",
        "doc_count" : 20547128
      }, {
        "key" : "0.1-*",
        "from" : 0.1,
        "from_as_string" : "0.1",
        "doc_count" : 2879418
      } ]
    }
  }
}

  "aggregations" : {
    "range_info" : {
      "buckets" : [ {
        "key" : "*-0.02",
        "to" : 0.02,
        "to_as_string" : "0.02",
        "doc_count" : 9093600
      } # 响应时间在 0 ~ 0.02 的文档数是 9093600

      , {
        "key" : "0.02-0.1",
        "from" : 0.02,
        "from_as_string" : "0.02",
        "to" : 0.1,
        "to_as_string" : "0.1",
        "doc_count" : 20547128
      } # 响应时间在 0.02 ~ 0.1 的文档数是 20547128

      , {
        "key" : "0.1-*",
        "from" : 0.1,
        "from_as_string" : "0.1",
        "doc_count" : 2879418
      } # 响应时间在大于 0.1 的文档数是 2879418
       ]
    }
  }




9、求时间范围内有多少文档匹配
业务场景:求访问日志中,在 2016-10-09T01:00:00 之前的文档有多少。 和在 2016-10-09T02:00: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
35
36
37
38
39
40
41
42
43
44
45
46
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "match_all" : {} },

"aggs" : {
"range_info" : { "date_range" : {
"field" : "@timestamp",
"ranges":[{"to": "2016-10-09T01:00:00"},{"from":"2016-10-09T02:00:00"}]
}
}
},"size":0
}'


{
  "took" : 432,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 32523067,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "range_info" : {
      "buckets" : [ {
        "key" : "*-2016-10-09T01:00:00.000Z",
        "to" : 1.4759748E12,
        "to_as_string" : "2016-10-09T01:00:00.000Z",
        "doc_count" : 613460
      }, # 在 2016-10-09T01:00:00 之前的文档数有 613460

      {
        "key" : "2016-10-09T02:00:00.000Z-*",
        "from" : 1.4759784E12,
        "from_as_string" : "2016-10-09T02:00:00.000Z",
        "doc_count" : 31264881
      } # 在 2016-10-09T02:00:00 之后的文档数有 31264881
      ]
    }
  }
}




10、聚合结果不依赖于查询结果集 "global":{}
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
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "term" : { "status" : "200" } },

"aggs" :{
"all_articles":{
"global":{},
"aggs":{
"sum_like": {"sum":{"field": "responsetime"}}
}
}
},"size":0
}'


{
  "took" : 1519,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 26686196,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "all_articles" : {
      "doc_count" : 32523067,
      "sum_like" : {
        "value" : 1536946.1929722272
      }
    }
  }
}

# 可以看到查询结果集hits total部分才匹配到 26686196 条记录。 而聚合的文档数则是 32523067 多于查询结果匹配到的文档。
# 聚合结果为 1536946.1929722272


# 我们再看看没有引用 "global":{} 参数的方式

curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :
{ "term" : { "status" : "200" } },
"aggs":{
"sum_like": {"sum":{"field": "responsetime"}}

},"size":0                                   
}'


{
  "took" : 1326,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 26686196,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "sum_like" : {
      "value" : 1526710.3929916811
    }
  }
}

# 聚合结果小于上诉的结果。 表示这次的聚合的值,是依赖于检索匹配到的文档。




11、分组聚合
用于统计指定字段在自定义的固定增长区间下,每个增长后的值,所匹配的文档数量。
1
2
3
4
5
6
7
8
9
10
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"aggs" :{
"like_histogram":{
"histogram":{"field": "status", "interval": 200,
        "min_doc_count": 1}
}
},"size":0
}'

# 对 status 字段操作,增长区间为 200 ,为了避免有的区间匹配为0所导致空数据,所以这里指定最小文档数为 1 "histogram":{"field": "status", "interval": 200, "min_doc_count": 1}




12、分组聚合-基于时间做分组
"date_histogram":{"field": "@timestamp", "interval": "1d","format": "yyyy-MM-dd",}

"field": "@timestamp"  指定记录时间的字段

"interval": "1d"  分组区间为每天.  1M 每月、1H 每小时、1m 每分钟

"format": "yyyy-MM-dd" 指定时间的输出格式

统计每天产生的日志数量
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-*/_search?pretty' -d '{
"aggs" :{
"date_histogram_info":{
"date_histogram":{"field": "@timestamp", "interval": "1d","format": "yyyy-MM-dd",
"min_doc_count": 1}
}
}
}'


"aggregations" : {
    "date_histogram_info" : {
      "buckets" : [ {
        "key_as_string" : "2016-09-27",
        "key" : 1474934400000,
        "doc_count" : 6895375
      }, {
        "key_as_string" : "2016-09-28",
        "key" : 1475020800000,
        "doc_count" : 1255775
      }, {
        "key_as_string" : "2016-09-29",
        "key" : 1475107200000,
        "doc_count" : 38512862
      }, {
        "key_as_string" : "2016-09-30",
        "key" : 1475193600000,
        "doc_count" : 35314225
      }, {
        "key_as_string" : "2016-10-01",
        "key" : 1475280000000,
        "doc_count" : 45358162
      }, {
        "key_as_string" : "2016-10-02",
        "key" : 1475366400000,
        "doc_count" : 42058056
      }, {
        "key_as_string" : "2016-10-03",
        "key" : 1475452800000,
        "doc_count" : 39945587
      }, {
        "key_as_string" : "2016-10-04",
        "key" : 1475539200000,
        "doc_count" : 39509128
      }, {
        "key_as_string" : "2016-10-05",
        "key" : 1475625600000,
        "doc_count" : 40506342
      }, {
        "key_as_string" : "2016-10-06",
        "key" : 1475712000000,
        "doc_count" : 43303499
      }, {
        "key_as_string" : "2016-10-07",
        "key" : 1475798400000,
        "doc_count" : 44234780
      }, {
        "key_as_string" : "2016-10-08",
        "key" : 1475884800000,
        "doc_count" : 32880600
      }, {
        "key_as_string" : "2016-10-09",
        "key" : 1475971200000,
        "doc_count" : 32523067
      }, {
        "key_as_string" : "2016-10-10",
        "key" : 1476057600000,
        "doc_count" : 31454044
      }, {
        "key_as_string" : "2016-10-11",
        "key" : 1476144000000,
        "doc_count" : 2018401
      } ]
    }
  }
}


# 基于小时做分组

# 统计当天每小时产生的日志数量

curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"aggs" :{
"date_histogram_info":{
"date_histogram":{"field": "@timestamp", "interval": "1H","format": "yyyy-MM-dd-H",
"min_doc_count": 1}
}
},"size":0
}'


{
  "took" : 530,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 32523067,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "date_histogram_info" : {
      "buckets" : [ {
        "key_as_string" : "2016-10-09-0",
        "key" : 1475971200000,
        "doc_count" : 613460
      }, {
        "key_as_string" : "2016-10-09-1",
        "key" : 1475974800000,
        "doc_count" : 644726
      }, {
        "key_as_string" : "2016-10-09-2",
        "key" : 1475978400000,
        "doc_count" : 687196
      }, {
        "key_as_string" : "2016-10-09-3",
        "key" : 1475982000000,
        "doc_count" : 730831
      }, {
        "key_as_string" : "2016-10-09-4",
        "key" : 1475985600000,
        "doc_count" : 1460320
      }, {
        "key_as_string" : "2016-10-09-5",
        "key" : 1475989200000,
        "doc_count" : 1469098
      }, {
        "key_as_string" : "2016-10-09-6",
        "key" : 1475992800000,
        "doc_count" : 1004399
      }, {
        "key_as_string" : "2016-10-09-7",
        "key" : 1475996400000,
        "doc_count" : 962843
      }, {
        "key_as_string" : "2016-10-09-8",
        "key" : 1476000000000,
        "doc_count" : 1232560
      }, {
        "key_as_string" : "2016-10-09-9",
        "key" : 1476003600000,
        "doc_count" : 1809741
      }, {
        "key_as_string" : "2016-10-09-10",
        "key" : 1476007200000,
        "doc_count" : 2802804
      }, {
        "key_as_string" : "2016-10-09-11",
        "key" : 1476010800000,
        "doc_count" : 3941192
      }, {
        "key_as_string" : "2016-10-09-12",
        "key" : 1476014400000,
        "doc_count" : 4631032
      }, {
        "key_as_string" : "2016-10-09-13",
        "key" : 1476018000000,
        "doc_count" : 3651968
      }, {
        "key_as_string" : "2016-10-09-14",
        "key" : 1476021600000,
        "doc_count" : 2079933
      }, {
        "key_as_string" : "2016-10-09-15",
        "key" : 1476025200000,
        "doc_count" : 973578
      }, {
        "key_as_string" : "2016-10-09-16",
        "key" : 1476028800000,
        "doc_count" : 517435
      }, {
        "key_as_string" : "2016-10-09-17",
        "key" : 1476032400000,
        "doc_count" : 388382
      }, {
        "key_as_string" : "2016-10-09-18",
        "key" : 1476036000000,
        "doc_count" : 361296
      }, {
        "key_as_string" : "2016-10-09-19",
        "key" : 1476039600000,
        "doc_count" : 345926
      }, {
        "key_as_string" : "2016-10-09-20",
        "key" : 1476043200000,
        "doc_count" : 342214
      }, {
        "key_as_string" : "2016-10-09-21",
        "key" : 1476046800000,
        "doc_count" : 360897
      }, {
        "key_as_string" : "2016-10-09-22",
        "key" : 1476050400000,
        "doc_count" : 714336
      }, {
        "key_as_string" : "2016-10-09-23",
        "key" : 1476054000000,
        "doc_count" : 796900
      } ]
    }
  }
}

# 可以看到当天 0 ~ 23 点每个时段产生的日志数量。 通过这个数据,我们是不是很容易就可以得到,业务的高峰时段呢?




四、Query DSL

1
2
3
4
curl -XGET 'http://127.0.0.1:9200/search_test/article/_count?pretty' -d '{
  "query" :
  { "term" : { "title" : "article" } }
}'




在 Query DSL 中有两种子句:

1、Leaf query clauses (简单叶子节点查询子句)

2、Compound query clauses (复合查询子句)

Query context & Filter context

在 Query context 查询上下文中 ,关注的是当前文档和查询子句的匹配度。 而在 Filter context 中关注的是当前文档是否匹配查询子句,不计算相似度分值。

{"match_all":{}} 匹配全部
{"match_all":{"boost":{"boost":1.2}}}  手动指定_score返回值

Term level queries
返回文档:在user字段的倒排索引中包含"kitty"的文档 (精确匹配)
1
2
3
{
  "term":{"user":"kitty"}
}




用例:
1
2
3
4
curl -XGET 'http://169.254.135.217:9200/search_test/article/_count?pretty' -d '{
  "query" :
  { "term" : { "user" : "kitty" } }
}'




Term level Range query (范围查询)
wKioL1gAXCvA-pvRAAB1p-s_Yfs789.jpg

用例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '
{
"query" :
        { "range" :{
                      "status" :{ "gt" : 200, "lte" : 500, "boost" : 2.0 }
                    }

        }
,"size":1
}'

# 这里的"size":1 表示只返回一条数据,类似SQL里面的limit。 最大指定10000

# 如果要返回更多的数据,则可以加上?scroll参数,如/_search?scroll=1m ,这里的1m 表示1分钟。

# 详细请参考: https://www.elastic.co/guide/en/ ... ons.html#time-units




Term level Exists query (存在查询)
wKioL1gAXKrR2ChiAACY-JAJjXI771.jpg

用例:
1
2
3
4
5
6
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '
{
"query":
    { "exists":{ "field":"status" }
}
}'




Term level Prefix and Wildcard
wKioL1gAXN_ji90YAACw3p9P1xQ935.jpg

前缀查询用例:
1
2
3
4
5
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
  "query" :{
  "prefix" :{"agent": "io" }
  }
}'




通配符查询用例:
1
2
3
4
5
curl -XGET 'http://127.0.0.1:9200/logstash-nginxacclog-2016.10.09/_search?pretty' -d '{
"query" :{
"wildcard" :{"agent": "io*" }
}
}'




Compound query : Bool Query

Bool Query 常用的三个分支:
1、Must 表示必须包含的字符串
2、Must not 表示需要过滤掉的条件
3、should 类似 or 条件,"minimum_should_match" 表示最少要匹配几个条件才通过。

假设我在should 里面定义了三个条件,并且把minimum_should_match 设置为 2 ,表示我这三个条件中,只要要有两个条件能被匹配才能通过。 如果minimum_should_match 改为 3 表示这三个条件需要同时匹配才通过。


"should" : [ { "term" : { "body" : "article" } }, { "term" : { "body" : "document" } }, { "term" : { "body" : "tuchao" } } ],  "minimum_should_match" : 3,


用例:
wKioL1gAX06woMlJAACD0ahm1Zw324.jpg

在这里可以看到,我给should 加了一个它决定不可能匹配到的条件,body:'tuchao' ,因为文档里面根本就没有这个字符串,然后我把 minimum_should_match 设置为 2 .  让它最小匹配2个条件就可以。 果然查询到了

wKiom1gAX2Ky054yAABML50fTyY822.jpg

接下来我把minimum_should_match 改为 3 让它最少要匹配三个条件,它显然做不到,就查不出来了

Request body search : Sort
wKioL1gAX6Owj1KQAACErjYpYuw082.jpg


运维网声明 1、欢迎大家加入本站运维交流群:群②:261659950 群⑤:202807635 群⑦870801961 群⑧679858003
2、本站所有主题由该帖子作者发表,该帖子作者与运维网享有帖子相关版权
3、所有作品的著作权均归原作者享有,请您和我们一样尊重他人的著作权等合法权益。如果您对作品感到满意,请购买正版
4、禁止制作、复制、发布和传播具有反动、淫秽、色情、暴力、凶杀等内容的信息,一经发现立即删除。若您因此触犯法律,一切后果自负,我们对此不承担任何责任
5、所有资源均系网友上传或者通过网络收集,我们仅提供一个展示、介绍、观摩学习的平台,我们不对其内容的准确性、可靠性、正当性、安全性、合法性等负责,亦不承担任何法律责任
6、所有作品仅供您个人学习、研究或欣赏,不得用于商业或者其他用途,否则,一切后果均由您自己承担,我们对此不承担任何法律责任
7、如涉及侵犯版权等问题,请您及时通知我们,我们将立即采取措施予以解决
8、联系人Email:admin@iyunv.com 网址:www.yunweiku.com

所有资源均系网友上传或者通过网络收集,我们仅提供一个展示、介绍、观摩学习的平台,我们不对其承担任何法律责任,如涉及侵犯版权等问题,请您及时通知我们,我们将立即处理,联系人Email:kefu@iyunv.com,QQ:1061981298 本贴地址:https://www.yunweiku.com/thread-287369-1-1.html 上篇帖子: Elasticsearch 基础理论 & 配置调优 下篇帖子: Elasticsearch安装配置
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

扫码加入运维网微信交流群X

扫码加入运维网微信交流群

扫描二维码加入运维网微信交流群,最新一手资源尽在官方微信交流群!快快加入我们吧...

扫描微信二维码查看详情

客服E-mail:kefu@iyunv.com 客服QQ:1061981298


QQ群⑦:运维网交流群⑦ QQ群⑧:运维网交流群⑧ k8s群:运维网kubernetes交流群


提醒:禁止发布任何违反国家法律、法规的言论与图片等内容;本站内容均来自个人观点与网络等信息,非本站认同之观点.


本站大部分资源是网友从网上搜集分享而来,其版权均归原作者及其网站所有,我们尊重他人的合法权益,如有内容侵犯您的合法权益,请及时与我们联系进行核实删除!



合作伙伴: 青云cloud

快速回复 返回顶部 返回列表