介绍

elasticsearch是一个高效的、可扩展的全文搜索引擎

基本概念

  • Near Realtime(NRT): es是一个接近实时查询平台，意味从存储一条数据到可以索引到数据时差很小，通常在1s内
  • Cluster: es是一个分布式、可扩展的平台, 可由一个或多个服务器通过定义的cluster.name（默认为elasticsearch）标识共建同一个集群
  • Node: 通常一台服务器上部署一台es node，作为集群的一部分，用于数据的存储和提供搜索功能，在一个集群中节点通过node.name区分，默认在node启动时随机生成一个的字符串做为节点名称，可配置
  • Index: 类似于关系型数据库中的database，用于组织一类功能相似的数据，在一个集群中可以定义任意个索引，索引的名称只能由小写字母组成，在数据索引，更新，搜索，删除时作为数据标识的一部分
  • Type: 类似于关系型数据库中的table，在Index中可以定义多个Type，原则上一个Type是由相同属性组成的数据集合
  • Document: 类似于关系型数据库中的record，是数据的最基本存储单元，使用json形式表示，Document在物理上存储在Index下，但是在逻辑上会分配到具体的Type下
  • Shards & Replica:
    一个Index可能存储大量的数据(超过单个节点的硬件限制)，不管是数据存储还是数据索引，为解决数据单节点存储并提高并发，es将每一个Index物理分为多个片，从而水平扩展存储容量，提高并发（可以同时对个shard进行索引和搜索）
    为防止某个存储单元出现故障后数据不能索引的情况，es提供将shard进行复制功能，将主shard出现故障后，复制shard替代主shard进行数据索引操作，已此方式实现其高可用性，因为在搜索时可以使用复制shard，从而提高的数据搜索的并发性
    在Index创建时可以进行分片数量和复制数量的设置，默认创建每个Index设置5个shard和1个Replica，表示该Index由5个逻辑存储单元进行存储，每个逻辑存储单元具有一个复制节点进行备灾，注意，shard只能在创建Index时进行设置，shard数量与document分配到哪个shard上存储有关(通常使用hash(document _id) % shard num计算 document存储在哪个shard上)
    在es将主shard和replic分片在不同的Node上

安装

  • elasticsearch使用java语言实现，在使用时必须安装java虚拟机（目前es1.6和1.7版本均可选择1.8版本java）
  • 下载地址
  • 解压到安装目录 C:\Program Files\elasticsearch
  • 运行 cd "C:\Program Files\elasticsearch\bin" && elasticsearch.bat
  • 安装到服务 service install elasticsearch
  • 启动服务 net start elasticsearch
  • 停止服务 net stop elasticsearch
  • 测试
    访问地址: http://localhost:9200
    访问结果:

    1
2
3
4
5
6
7
8
9
10
11
12
13

    {  status: 200,
  name: "Smart Alec",
  cluster_name: "elasticsearch",
  version: {    number: "1.6.0",
    build_hash: "cdd3ac4dde4f69524ec0a14de3828cb95bbb86d0",
    build_timestamp: "2015-06-09T13:36:34Z",
    build_snapshot: false,
    lucene_version: "4.10.4"
  },
  tagline: "You Know, for Search"
}

接口

es对外提供标准RESTAPI接口，使用他进行集群的所有操作：

  • 集群、节点、索引的状态和统计信息查看
  • 管理集群、节点、索引和类型
  • 执行CURD操作（创建，更新，读取，删除）和索引
  • 执行高级搜索功能，比如排序，分页，筛选，聚合，js脚本执行等

格式：curl -X<REST verb> <Node>:<Port>/<Index>/<Type>/<ID>

使用marvel插件

  • 运行 cd "C:\Program Files\elasticsearch\bin" && plugin -i elasticsearch/marvel/latest
  • 访问地址
  • marvel提供sense工具调用es的RESTAPI借口, 访问地址, 以下操作使用sense或使用linux curl命令行练习

状态查询

  • 集群状态查询
    输入: GET _cat/health?v
    输出:

    1
2

    epoch      timestamp cluster       status node.total node.data shards pri relo init unassign pending_tasks
1442227489 18:44:49  elasticsearch yellow          1         1     50  50    0    0       50             0

说明:
status:表示集群的健康状态，值可能为green,yellow,red, green表示主shard和replica(至少一个)正常，yellow表示主shard正常但replica都不正常，red表示有的主shard和replica都有问题
node.total:表示集群中节点的数量

  • 节点状态查询
    输入: GET /_cat/nodes?v
    输出:

    1
2

    host      ip             heap.percent ram.percent load node.role master name
silence   192.168.1.111            30          51      d         *      Thunderbird

查询所有索引

输入: GET /_cat/indices?v
输出:

1
2
3

health status index              pri rep docs.count docs.deleted store.size pri.store.size
yellow open   .marvel-2015.09.02   1   1      93564            0     78.4mb         78.4mb
yellow open   .marvel-2015.09.01   1   1      39581            0     45.9mb         45.9mb

创建索引

输入: PUT /test1?pretty
输出:

1
2
3

{  "acknowledged" : true
}

查询所有索引:

1
2

health status index              pri rep docs.count docs.deleted store.size pri.store.size
yellow open   test1                5   1          0            0       575b           575b

说明:
health:由于只运行一个节点，replica不能与主shard在同一node中，因此replica不正常，该index的状态为yellow
index:为索引名称
pri:表示主shard个数
rep:表示每个shard的复制个数
docs.count:表示index中document的个数

索引、读取、删除文档

索引文档

  • 方法1:
    输入:

    1
2

    PUT /test1/user/1?pretty
{"name": "silence1"}

输出:

1
2
3
4
5
6
7

{  "_index" : "test1
  "_type" : "user",
  "_id" : "1",
  "_version" : 1,
  "created" : true
}
  • 方法2:
    输入:

    1
2

    POST /test1/user/2?pretty
{"name": "silence2"}

输出:

1
2
3
4
5
6
7

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "2",
  "_version" : 1,
  "created" : true
}
  • 方法3:
    输入:

    1
2

    POST /test1/user?pretty
{"name": "silence3"}

输出:

1
2
3
4
5
6
7

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "AU_MdQoXRYiHSIs7UGBQ",
  "_version" : 1,
  "created" : true
}

说明: 在索引文档时若需要指定文档ID值则需要使用PUT或者POST提交数据并显示指定ID值，若需要由es自动生成ID，则需要使用POST提交数据

读取文档：
输入: GET /test1/user/1?pretty
输出:

1
2
3
4
5
6
7
8

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "_source":{"name": "silence1"}
}

说明:
_index,_type:表示文档存储的Index和Type信息
_id:表示文档的编号
_version:表示文档的版本号，主要用于并发处理时使用乐观锁防止脏数据
found:表示请求的文档是否存在
_souce:格式为json，为文档的内容

注意:在之前我们并未创建user的Type，在进行文档索引时自动创建了user，在es中可以不显示的创建Index和Type而使用默认参数或者根据提交数据自定义，但不建议这么使用，在不清楚可能导致什么情况时显示创建Index和Type并设置参数

删除文档:
输入: DELETE /test1/user/1?pretty
输出:

1
2
3
4
5
6
7

{  "found" : true,
  "_index" : "test1",
  "_type" : "user",
  "_id" : "1",
  "_version" : 2
}

再次读取文档输出:

1
2
3
4
5
6

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "1",
  "found" : false
}

删除索引

输入: DELETE /test1?pretty
输出:

1
2
3

{  "acknowledged" : true
}

修改文档

初始化文档输入:

1
2

PUT /test1/user/1?pretty
{"name" : "silence2", "age":28}

修改文档输入:

1
2

PUT /test1/user/1?pretty
{"name" : "silence1"}

读取文档输出:

1
2
3
4
5
6
7
8

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "1",
  "_version" : 2,
  "found" : true,
  "_source":{"name" : "silence1"}
}

更新文档

更新数据输入:

1
2

POST /test1/user/1/_update?pretty
{"doc" : {"name" : "silence3", "age":28}}

读取数据输出:

1
2
3
4
5
6
7
8

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "1",
  "_version" : 3,
  "found" : true,
  "_source":{"name":"silence3","age":28}
}

更新文档输入:

1
2

POST /test1/user/1/_update?pretty
{"script" : "ctx._source.age += 1"}

读取文档输出:

1
2
3
4
5
6
7
8

{  "_index" : "test1",
  "_type" : "user",
  "_id" : "1",
  "_version" : 4,
  "found" : true,
  "_source":{"name":"silence3","age":29}
}

说明：需要POST使用script则必须在elasticsearch/config/elasticsearch.yml配置script.groovy.sandbox.enabled: true
修改(PUT)和更新(POST+_update)的区别在于修改使用提交的文档覆盖es中的文档，更新使用提交的参数值覆盖es中文档对应的参数值

根据查询删除文档

输入:

1
2

DELETE /test1/user/_query?pretty
{"query" : {"match" : {"name" : "silence3"}}}

输出:

1
2
3
4
5
6
7
8
9
10
11

{  "_indices" : {    "test1" : {      "_shards" : {        "total" : 5,
        "successful" : 5,
        "failed" : 0
      }
    }
  }
}

获取文档数量

输入: GET /test1/user/_count?pretty
输出:

1
2
3
4
5
6
7
8

{  "count" : 0,
  "_shards" : {    "total" : 5,
    "successful" : 5,
    "failed" : 0
  }
}

批量操作

输入:

1
2
3
4
5
6
7
8
9

POST /test1/user/_bulk?pretty
{"index" : {"_id" : 1}}
{"name" : "silence1"}
{"index" : {"_id" : 2}}
{"name" : "silence2"}
{"index" : {}}
{"name" : "silence3"}
{"index" : {}}
{"name" : "silence4"}

输入:

1
2
3
4

POST /test1/user/_bulk?pretty
{"update" : {"_id" : 1}}
{"doc" : {"age" : 28}}
{"delete" : {"_id" : 2}}

通过文件导入数据: curl -XPOST "localhost:9200/test1/account/_bulk?pretty" --data-binary @accounts.json

Query查询

查询可以通过两种方式进行，一种为使用查询字符串进行提交参数查询，一种为使用RESTAPI提交requesbody提交参数查询

获取所有文档输入: GET /test1/user/_search?q=*&pretty

1
2
3
4

POST /test1/user/_search?pretty
{  "query" : {"match_all" : {}}
}

输出：

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

{   "took": 2,
   "timed_out": false,
   "_shards": {      "total": 5,
      "successful": 5,
      "failed": 0
   },
   "hits": {      "total": 3,
      "max_score": 1,
      "hits": [
         {            "_index": "test1",
            "_type": "user",
            "_id": "1",
            "_score": 1,
            "_source": {               "name": "silence1",
               "age": 28
            }
         },
         {            "_index": "test1",
            "_type": "user",
            "_id": "AU_M2zgwLNdQvgqQS3MP",
            "_score": 1,
            "_source": {               "name": "silence3"
            }
         },
         {            "_index": "test1",
            "_type": "user",
            "_id": "AU_M2zgwLNdQvgqQS3MQ",
            "_score": 1,
            "_source": {               "name": "silence4"
            }
         }
      ]
   }
}

说明:
took: 执行查询的时间(单位为毫秒)
timed_out: 执行不能超时
_shards: 提示有多少shard参与查询以及查询成功和失败shard数量
hits: 查询结果
hits.total: 文档总数
_score, max_score: 为文档与查询条件匹配度和最大匹配度

Query SDL

输入:

1
2
3
4
5
6
7
8
9

POST /test1/account/_search?pretty
{  "query" : {"match_all":{}},
  "size": 2,
  "from" : 6,
  "sort" : {    "age" : {"order" : "asc"}
  }
}

说明:
query: 用于定义查询条件过滤
match_all: 表示查询所有文档
size: 表示查询返回文档数量，若未设置默认为10
from: 表示开始位置, es使用0作为开始索引，常与size组合进行分页查询，若未设置默认为0
sort: 用于设置排序属性和规则

  • 使用_source设置查询结果返回的文档属性
    输入:

    1
2
3
4
5
6
7

    POST /test1/account/_search?pretty
{  "query": {    "match_all": {}
  },
  "_source":["firstname", "lastname", "age"]
}

输出:

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

{   "took": 5,
   "timed_out": false,
   "_shards": {      "total": 5,
      "successful": 5,
      "failed": 0
   },
   "hits": {      "total": 1000,
      "max_score": 1,
      "hits": [
         {            "_index": "test1",
            "_type": "account",
            "_id": "4",
            "_score": 1,
            "_source": {               "firstname": "Rodriquez",
               "age": 31,
               "lastname": "Flores"
            }
         },
         {            "_index": "test1",
            "_type": "account",
            "_id": "9",
            "_score": 1,
            "_source": {               "firstname": "Opal",
               "age": 39,
               "lastname": "Meadows"
            }
         }
      ]
   }
}
  • 使用match设置查询匹配值
    输入:

    1
2
3
4
5
6
7

    POST /test1/account/_search?pretty
{  "query": {    "match": {"address" : "986 Wyckoff Avenue"}
  },
  "size" : 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
46
47
48
49
50
51
52
53

{   "took": 1,
   "timed_out": false,
   "_shards": {      "total": 5,
      "successful": 5,
      "failed": 0
   },
   "hits": {      "total": 216,
      "max_score": 4.1231737,
      "hits": [
         {            "_index": "test1",
            "_type": "account",
            "_id": "4",
            "_score": 4.1231737,
            "_source": {               "account_number": 4,
               "balance": 27658,
               "firstname": "Rodriquez",
               "lastname": "Flores",
               "age": 31,
               "gender": "F",
               "address": "986 Wyckoff Avenue",
               "employer": "Tourmania",
               "email": "rodriquezflores@tourmania.com",
               "city": "Eastvale",
               "state": "HI"
            }
         },
         {            "_index": "test1",
            "_type": "account",
            "_id": "34",
            "_score": 0.59278774,
            "_source": {               "account_number": 34,
               "balance": 35379,
               "firstname": "Ellison",
               "lastname": "Kim",
               "age": 30,
               "gender": "F",
               "address": "986 Revere Place",
               "employer": "Signity",
               "email": "ellisonkim@signity.com",
               "city": "Sehili",
               "state": "IL"
            }
         }
      ]
   }
}

说明：根据查询结果可见在查询结果中并非只查询address包含”986 Wyckoff Avenue”的文档，而是包含986,wychoff,Avenue三个词中任意一个，这就是es分词的强大之处
可见查询结果中_score(与查询条件匹配度)按从大到小的顺序排列
此时你可能想要值查询address包含”986 Wyckoff Avenue”的文档，怎么办呢？使用match_phrase
输入:

1
2
3
4
5
6

POST /test1/account/_search?pretty
{  "query": {    "match_phrase": {"address" : "986 Wyckoff Avenue"}
  }
}

可能你已经注意到, 以上query中只有一个条件，若存在多个条件，我们必须使用bool query将多个条件进行组合
输入:

1
2
3
4
5
6
7
8
9
10
11

POST /test1/account/_search?pretty
{  "query": {    "bool" : {      "must":[
        {"match_phrase": {"address" : "986 Wyckoff Avenue"}},
        {"match" : {"age" : 31}}
      ]
    }
  }
}

说明: 查询所有条件都满足的结果

输入:

1
2
3
4
5
6
7
8
9
10
11

POST /test1/account/_search
{  "query": {    "bool" : {      "should":[
        {"match_phrase": {"address" : "986 Wyckoff Avenue"}},
        {"match_phrase": {"address" : "963 Neptune Avenue"}}
      ]
    }
  }
}

说明: 查询有一个条件满足的结果
输入:

1
2
3
4
5
6
7
8
9
10
11

POST /test1/account/_search
{  "query": {    "bool" : {      "must_not":[
        {"match": {"city" : "Eastvale"}},
        {"match": {"city" : "Olney"}}
      ]
    }
  }
}

说明: 查询有条件都不满足的结果

在Query SDL中可以将must, must_not和should组合使用
输入:

1
2
3
4
5
6
7
8
9
10
11
12
13

POST /test1/account/_search
{  "query": {    "bool" : {      "must": [{        "match" : {"age":20}
      }],
      "must_not":[
        {"match": {"city" : "Steinhatchee"}}
      ]
    }
  }
}

Filters 查询

在使用Query 查询时可以看到在查询结果中都有_score值, _score值需要进行计算, 在某些情况下我们并不需要_socre值，在es中提供了Filters查询，它类似于Query查询，但是效率较高，原因:

  1. 不需要对查询结果进行_score值的计算
  2. Filters可以被缓存在内存中，可被重复搜索从而提高查询效率
  • range 过滤器， 用于设置条件在某个范围内
    输入:

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

    POST /test1/account/_search?pretty
{  "query": {    "filtered":{      "query": {        "match_all" : {}
      },
      "filter": {        "range" : {          "age" : {            "gte" : 20,
            "lt" : 28
          }
        }
      }
    }
  }
}

判断使用filter还是使用query的最简单方法就是是否关注_score值，若关注则使用query，若不关注则使用filter

聚合分析

es提供Aggregations支持分组和聚合查询，类似于关系型数据库中的GROUP BY和聚合函数，在ES调用聚合RESTAPI时返回结果包含文档查询结果和聚合结果，也可以返回多个聚合结果，从而简化API调用和减少网络流量使用
输入:

1
2
3
4
5
6
7
8
9

POST /test1/account/_search?pretty
{  "size" : 0,
  "aggs" : {    "group_by_gender" : {      "terms" : {"field":"gender"}
    }
  }
}

输出:

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

{   "took": 1,
   "timed_out": false,
   "_shards": {      "total": 5,
      "successful": 5,
      "failed": 0
   },
   "hits": {      "total": 1000,
      "max_score": 0,
      "hits": []
   },
   "aggregations": {      "group_by_gender": {         "doc_count_error_upper_bound": 0,
         "sum_other_doc_count": 0,
         "buckets": [
            {               "key": "m",
               "doc_count": 507
            },
            {               "key": "f",
               "doc_count": 493
            }
         ]
      }
   }
}

说明:
size: 返回文档查询结果数量
aggs: 用于设置聚合分类
terms: 设置group by属性值

输入:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

POST /test1/account/_search?pretty
{  "size" : 0,
  "aggs" : {    "group_by_gender" : {      "terms" : {        "field":"state",
        "order" : {"avg_age":"desc"},
        "size" : 3
      },
      "aggs" : {        "avg_age" : {          "avg" : {"field" : "age"}
        },
        "max_age" : {          "max" : {"field": "age"}
        },
        "min_age" : {          "min": {"field":"age"}
        }
      }
    }
  }
}

输出:

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

{   "took": 9,
   "timed_out": false,
   "_shards": {      "total": 5,
      "successful": 5,
      "failed": 0
   },
   "hits": {      "total": 1000,
      "max_score": 0,
      "hits": []
   },
   "aggregations": {      "group_by_gender": {         "doc_count_error_upper_bound": -1,
         "sum_other_doc_count": 992,
         "buckets": [
            {               "key": "de",
               "doc_count": 1,
               "max_age": {                  "value": 37
               },
               "avg_age": {                  "value": 37
               },
               "min_age": {                  "value": 37
               }
            },
            {               "key": "il",
               "doc_count": 3,
               "max_age": {                  "value": 39
               },
               "avg_age": {                  "value": 36.333333333333336
               },
               "min_age": {                  "value": 32
               }
            },
            {               "key": "in",
               "doc_count": 4,
               "max_age": {                  "value": 39
               },
               "avg_age": {                  "value": 36
               },
               "min_age": {                  "value": 34
               }
            }
         ]
      }
   }
}

说明:根据state进行分类，并查询每种分类所有人员的最大，最小，平均年龄, 查询结果按平均年龄排序并返回前3个查询结果
若需要按照分类总数进行排序时可以使用_count做为sort的field值
在聚合查询时通过size设置返回的TOP数量，默认为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

POST /test1/account/_search?pretty
{  "size" : 0,
  "aggs" : {    "group_by_age" : {      "range" : {        "field": "age",
        "ranges" : [{          "from" : 20,
          "to" : 30
        }, {          "from": 30,
          "to" : 40
        },{          "from": 40,
          "to": 50
        }]
      },
      "aggs":{        "group_by_gender" : {          "terms" : {"field": "gender"},
          "aggs" : {            "group_by_balance" :{              "range" : {                "field":"balance",
                "ranges" : [{                  "to" : 5000
                }, {                  "from" : 5000
                }
                ]
              }
            }
          }
        }
      }
    }
  }
}

输出:

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

{   "took": 1,
   "timed_out": false,
   "_shards": {      "total": 5,
      "successful": 5,
      "failed": 0
   },
   "hits": {      "total": 1000,
      "max_score": 0,
      "hits": []
   },
   "aggregations": {      "group_by_age": {         "buckets": [
            {               "key": "20.0-30.0",
               "from": 20,
               "from_as_string": "20.0",
               "to": 30,
               "to_as_string": "30.0",
               "doc_count": 451,
               "group_by_gender": {                  "doc_count_error_upper_bound": 0,
                  "sum_other_doc_count": 0,
                  "buckets": [
                     {                        "key": "m",
                        "doc_count": 232,
                        "group_by_balance": {                           "buckets": [
                              {                                 "key": "*-5000.0",
                                 "to": 5000,
                                 "to_as_string": "5000.0",
                                 "doc_count": 9
                              },
                              {                                 "key": "5000.0-*",
                                 "from": 5000,
                                 "from_as_string": "5000.0",
                                 "doc_count": 223
                              }
                           ]
                        }
                     },
                     {                        "key": "f",
                        "doc_count": 219,
                        "group_by_balance": {                           "buckets": [
                              {                                 "key": "*-5000.0",
                                 "to": 5000,
                                 "to_as_string": "5000.0",
                                 "doc_count": 20
                              },
                              {                                 "key": "5000.0-*",
                                 "from": 5000,
                                 "from_as_string": "5000.0",
                                 "doc_count": 199
                              }
                           ]
                        }
                     }
                  ]
               }
            },
            {               "key": "30.0-40.0",
               "from": 30,
               "from_as_string": "30.0",
               "to": 40,
               "to_as_string": "40.0",
               "doc_count": 504,
               "group_by_gender": {                  "doc_count_error_upper_bound": 0,
                  "sum_other_doc_count": 0,
                  "buckets": [
                     {                        "key": "f",
                        "doc_count": 253,
                        "group_by_balance": {                           "buckets": [
                              {                                 "key": "*-5000.0",
                                 "to": 5000,
                                 "to_as_string": "5000.0",
                                 "doc_count": 26
                              },
                              {                                 "key": "5000.0-*",
                                 "from": 5000,
                                 "from_as_string": "5000.0",
                                 "doc_count": 227
                              }
                           ]
                        }
                     },
                     {                        "key": "m",
                        "doc_count": 251,
                        "group_by_balance": {                           "buckets": [
                              {                                 "key": "*-5000.0",
                                 "to": 5000,
                                 "to_as_string": "5000.0",
                                 "doc_count": 21
                              },
                              {                                 "key": "5000.0-*",
                                 "from": 5000,
                                 "from_as_string": "5000.0",
                                 "doc_count": 230
                              }
                           ]
                        }
                     }
                  ]
               }
            },
            {               "key": "40.0-50.0",
               "from": 40,
               "from_as_string": "40.0",
               "to": 50,
               "to_as_string": "50.0",
               "doc_count": 45,
               "group_by_gender": {                  "doc_count_error_upper_bound": 0,
                  "sum_other_doc_count": 0,
                  "buckets": [
                     {                        "key": "m",
                        "doc_count": 24,
                        "group_by_balance": {                           "buckets": [
                              {                                 "key": "*-5000.0",
                                 "to": 5000,
                                 "to_as_string": "5000.0",
                                 "doc_count": 3
                              },
                              {                                 "key": "5000.0-*",
                                 "from": 5000,
                                 "from_as_string": "5000.0",
                                 "doc_count": 21
                              }
                           ]
                        }
                     },
                     {                        "key": "f",
                        "doc_count": 21,
                        "group_by_balance": {                           "buckets": [
                              {                                 "key": "*-5000.0",
                                 "to": 5000,
                                 "to_as_string": "5000.0",
                                 "doc_count": 0
                              },
                              {                                 "key": "5000.0-*",
                                 "from": 5000,
                                 "from_as_string": "5000.0",
                                 "doc_count": 21
                              }
                           ]
                        }
                     }
                  ]
               }
            }
         ]
      }
   }
}

使用head插件

  • 运行 cd "C:\Program Files\elasticsearch\bin" && plugin -install mobz/elasticsearch-head
  • 访问地址
from: http://imsilence.github.io/2015/09/14/elasticsearch/elasticsearch_01/

elasticsearch 第一篇(入门篇)相关推荐

  1. .NET Core实战项目之CMS 第一章 入门篇-开篇及总体规划

    写在前面 千呼万唤始出来,首先,请允许我长吸一口气!真没想到一份来自28岁老程序员的自白 这篇文章会这么火,更没想到的是张善友队长的公众号居然也转载了这篇文章,这就导致两天的时间就有两百多位读者朋友加 ...

  2. 最新版本elasticsearch本地搭建入门篇

    最新版本elasticsearch本地搭建入门篇 项目介绍 最近工作用到elasticsearch,主要是用于网站搜索,和应用搜索. 工欲善其事,必先利其器. 自己开始关注elasticsearch, ...

  3. 《网页制作与网站建设从入门到精通》第一部分 入门篇

    第一部分 入门篇 第1章■ 网页设计基础 第2章■ HTML入门 第3章■ 网站建设基础 第4章■ 网页中的色彩知识 第1章 网页设计基础 为了使网页初学者能够对网页设计有个总体的认识,本章首先介绍了 ...

  4. Elasticsearch 2.20入门篇：基本操作

    2019独角兽企业重金招聘Python工程师标准>>> 前面我们已经安装了Elasticsearch ,下一步我们要对Elasticsearch进行一些基本的操作.基本的操作主要有, ...

  5. 【弄nèng - Elasticsearch】DSL入门篇（四）—— 布尔查询Bool Query

    文章目录 1. 介绍 2. 测试 项目推荐 1. 介绍 Bool Query包括四种子句,must, should, must_not, filter. 格式: {"bool":{ ...

  6. 【弄nèng - Elasticsearch】DSL入门篇（十三）—— Index Template

    文章目录 1. 简介 2. 创建模板 3.查询模板 4.删除模板 项目推荐 索引模板 官网传送门 参考: https://www.cnblogs.com/shoufeng/p/10641560.htm ...

  7. 【弄nèng - Elasticsearch】DSL入门篇（五）—— 常用查询

    文章目录 1. term.terms查询 2. match查询 3. match_all查询 4. multi_match查询 5. match_phrase短语匹配 5.1 查询keyword 5. ...

  8. ElasticSearch-全文检索入门篇

    1.前置基础知识&学习用数据准备 ElasticSearch - 基础知识入门篇 官网 练习数据准备 2.初步检索 2.1._cat GET /_cat/nodes:查看所有节点 GET /_ ...

  9. envi 文件 生成mat_JVM 内存分析工具 MAT 的深度讲解与实践——入门篇

    1. MAT 工具简介 MAT(全名:Memory Analyzer Tool),是一款快速便捷且功能强大丰富的 JVM 堆内存离线分析工具.其通过展现 JVM 异常时所记录的运行时堆转储快照(Hea ...

最新文章

  1. 4、Eternal框架-持有者
  2. 1分钟10万字大法：量子波动速读、蒙眼翻书穿针，这是席卷15省的最新智商税...
  3. python seek tell_Python指针seektell详解
  4. Java中的锁原理、锁优化、CAS、AQS详解！
  5. CURL NDK 交叉编译
  6. docker查找镜像_5 款非常好用的开源 Docker 工具，get一波～
  7. hnu2021小学期程序设计 棋盘
  8. 今年的移动Pwn2own破解大赛：iPhone+安卓=50万美元
  9. OSPF在企业网络中的应用
  10. 计算机count是什么函数,计算机里COUNT是什么函数？怎么用的？好评！！
  11. 学生、课程、成绩三表sql查询
  12. 第三十五天：XSS跨站反射存储DOM盲打劫持
  13. 一文详解云原生DevOps(认识、熟悉、上手，DevOps，Docker，Jenkins，SonarQube，Harbor)
  14. 大数据系列 之 学习准备
  15. 家电售后服务外包维修模式，该如何管理
  16. 魔图互联：知识图谱推荐系统-给人们带来更个性化的推荐
  17. c语言用什么表示逻辑真,c语言中用什么表示逻辑量为真
  18. 全面解读 Java 现状及未来发展趋势
  19. 计算机时间戳转换时间在线,时间戳，Unix时间戳，时间戳转换
  20. java网站模版 Bootstrap HTML5 企业源码

热门文章

  1. Android Studio 分析器详解
  2. CCAI 2017 | 德国DFKI科技总监Hans Uszkoreit：如何用机器学习和知识图谱来实现商业智能化？ 原2017.07.25AI科技大本营 文/CSDN大琦 7 月22 - 2
  3. 聚焦互联网应用和深度学习
  4. Spring Cloud【Finchley】- 20使用@RefreshScope实现配置的刷新
  5. java图形界面猜字游戏,java程序，猜字游戏，希望大神帮忙
  6. 非此即彼的逻辑错误_MBA逻辑攻略逻辑知识大全，快来收藏吧！
  7. 计算机联锁仿真软件设计,一种基于LabVIEW的计算机联锁仿真系统的制作方法
  8. C语言——常见的字符串函数+内存操作函数的介绍及实现
  9. python 数组中第k个最大元素
  10. oracle定时服务器,服务器oracle数据库定时备份