elasticsearch 操作

返回说明

took —— Elasticsearch执行这个搜索的耗时，以毫秒为单位

timed_out —— 指明这个搜索是否超时

_shards —— 指出多少个分片被搜索了，同时也指出了成功/失败的被搜索的shards的数量

hits —— 搜索结果

hits.total —— 能够匹配我们查询标准的文档的总数目

hits.hits —— 真正的搜索结果数据（默认只显示前10个文档）

_score和max_score —— 现在先忽略这些字段

1：集群操作

1)集群健康指标(Cluster Health)

[code]curl 'localhost:9200/_cat/health?v'

2）获得节集群中的节点列表：

[code]  curl 'localhost:9200/_cat/nodes?v'

3) 看一下我们的索引：

[code]   curl 'localhost:9200/_cat/indices?v'

4)创建一个索引

[code]  curl -XPUT 'localhost:9200/customer?pretty'

5) 查询值

[code]  curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
        {
          "name": "John Doe"
        }'

  curl -XGET 'localhost:9200/customer/external/1?pretty'

6)删除一个索引

[code] curl -XDELETE 'localhost:9200/customer?pretty'

7) 修改数据

[code]curl -XPUT 'localhost:9200/customer/external/1?pretty' -d '
            {
              "name": "Jane Doe"
            }'

8)更新文档

[code]curl -XPOST 'localhost:9200/customer/external/1/_update?pretty' -d '
        {
          "doc": { "name": "Jane Doe", "age": 20 }
        }'

脚本

[code]curl -XPOST 'localhost:9200/customer/external/1/_update?pretty' -d '
        {
          "script" : "ctx._source.age += 5"
        }'

9）删除文档

[code]   curl -XDELETE 'localhost:9200/customer/external/_query?pretty' -d '
        {
          "query": { "match": { "name": "John" } }
        }'

10)批处理：

通过使用_bulk API实现的。这个功能之所以重要，在于它提供了非常高效的机制来尽可能快的完成多个操作，与此同时使用尽可能少的网络往返。

作为一个快速的例子，以下调用在一次bulk操作中索引了两个文档（ID 1 - John Doe and ID 2 - Jane Doe）:

[code]curl -XPOST 'localhost:9200/customer/external/_bulk?pretty' -d '
        {"index":{"_id":"1"}}
        {"name": "John Doe" }
        {"index":{"_id":"2"}}
        {"name": "Jane Doe" }
        '

[code]以下例子在一个bulk操作中，首先更新第一个文档（ID为1），然后删除第二个文档（ID为2）：

[code]curl -XPOST 'localhost:9200/customer/external/_bulk?pretty' -d '
        {"update":{"_id":"1"}}
        {"doc": { "name": "John Doe becomes Jane Doe" } }
        {"delete":{"_id":"2"}}
        '

注意上面的delete动作，由于删除动作只需要被删除文档的ID，所以并没有对应的源文档。

bulk API按顺序执行这些动作。如果其中一个动作因为某些原因失败了，将会继续处理它后面的动作。当bulk API返回时，它将提供每个动作的状态（按照同样的顺序），所以你能够看到某个动作成功与否。

2：默认情况下，索引会拥有5个主分片，但是为了演示，我们会让索引有3个主分片和1个副本分片(每个主分片都有1个副本分片)：

[code] PUT /blogs
{
   "settings" : {
      "number_of_shards" : 3,
      "number_of_replicas" : 1
   }
}

3：副本分片数量从1调整到2：

[code] PUT /blogs/_settings
    {
       "number_of_replicas" : 2
    }

4：查询

1）全匹配，从10 到20 按照bytes 排序

[code]curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
            {
              "query": { "match_all": {} },
                "from": 10,
                  "size": 10,
              "sort": { "bytes": { "order": "desc" } }
           }'

2）返回账户编号为20的文档：

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match": { "account_number": 20 } }
        }'

3）返回地址中包含“mill”的所有账户：

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match": { "address": "mill" } }
        }'

4）返回地址中包含“mill”或者包含“lane”的账户：

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match": { "address": "mill lane" } }
        }'

5）match的变体（match_phrase），它会去匹配短语“mill lane”：

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": { "match_phrase": { "address": "mill lane" } }
        }'

6）返回包含“mill”和“lane”的所有的账户

bool must语句指明了，对于一个文档，所有的查询都必须为真，这个文档才能够匹配成功。

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "must": [
                { "match": { "address": "mill" } },
                { "match": { "address": "lane" } }
              ]
            }
          }
        }'

7）返回的是地址中包含“mill”或者“lane”的所有的账户:

bool should语句指明，对于一个文档，查询列表中，只要有一个查询匹配，那么这个文档就被看成是匹配的。

[code]curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "should": [
                { "match": { "address": "mill" } },
                { "match": { "address": "lane" } }
              ]
            }
          }
        }'

8）返回地址中既不包含“mill”，同时也不包含“lane”的所有的账户信息：

bool must_not语句指明，对于一个文档，查询列表中的的所有查询都必须都不为真，这个文档才被认为是匹配的。

[code]curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "must_not": [
                { "match": { "address": "mill" } },
                { "match": { "address": "lane" } }
              ]
            }
          }
        }'

9）返回40岁以上并且不生活在ID（daho）的人的账户

在一个bool查询里一起使用must、should、must_not。此外，我们可以将bool查询放到这样的bool语句中来模拟复杂的、多等级的布尔逻辑。

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "bool": {
              "must": [
                { "match": { "age": "40" } }
              ],
              "must_not": [
                { "match": { "state": "ID" } }
              ]
            }
          }
        }'

5：过滤

1） 返回值是越在20000到30000之间（闭区间）的账户。换句话说，我们想要找到越大于等于20000并且小于等于30000的账户。

[code]curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "query": {
            "filtered": {
              "query": { "match_all": {} },
              "filter": {
                "range": {
                  "balance": {
                    "gte": 20000,
                    "lte": 30000
                  }
                }
              }
            }
          }
        }'

6：聚合

1）按照state分组，按照州名的计数倒序排序：

[code] curl -XPOST 'fuze246:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_state": {
              "terms": {
                "field": "state"
              }
            }
          }
        }'

2）计算了每个州的账户的平均余额（还是按照账户数量倒序排序的前10个州）：

注意，我们把average_balance聚合嵌套在了group_by_state聚合之中。这是所有聚合的一个常用模式。

[code]curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_state": {
              "terms": {
                "field": "state"
              },
              "aggs": {
                "average_balance": {
                  "avg": {
                    "field": "balance"
                  }
                }
              }
            }
          }
        }'

3）按照平均余额进行排序：

[code] curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "size": 0,
          "aggs": {
            "group_by_state": {
              "terms": {
                "field": "state",
                "order": {
                  "average_balance": "desc"
                }
              },
              "aggs": {
                "average_balance": {
                  "avg": {
                    "field": "balance"
                  }
                }
              }
            }
          }
        }'

4 ) 使用年龄段（20-29，30-39，40-49）分组，然后在用性别分组，然后为每一个年龄段的每一个性别计算平均账户余额

[code]curl -XPOST 'localhost:9200/bank/_search?pretty' -d '
        {
          "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": {
                    "average_balance": {
                      "avg": {
                        "field": "balance"
                      }
                    }
                  }
                }
              }
            }
          }
        }'

转：/article/3645394.html