ES学习笔记2

ES+Kibana+Beats+Logstash + APM

全部修改：

 PUT  /index/type/id

部分修改：

 POST /index/_update/id
 {
     "doc":{
     "name":"zhangsan"
     }
 }

查询

 get /index/type/_search?q=name:zhangsan
 ​
 get /index/type/_search
 {
     "query":{
         "match":{
             "name":"zhangsan"
         }
     }
 }
 ​
 get /index/type/_search
 {
     "query":{
         "bool":{
         "must":[
         {"match":{
             "name":"zhangsan"
         }}
         ]
         }
     }
 }
 ​
 get /index/type/_search
 {
     "query":{
         "match":{
             "name":"zhangsan"
         }
     },
     "from":10,
     "size":10,
     "_source":["name"]
 }
 ​
 ​
 get /index/type/_search
 {
     "query":{
         "match":{
             "name":"zhangsan"
         }
     },
     "from":10,
     "size":10,
     "_source":["name"],
     "sort":{
         "price":{
             "order":"desc/asc"
         }
     }
 }
 ​
 get /index/type/_search
 {
     "query":{
         "match":{
             "name":"zhangsan"
         }
     },
     "from":10,
     "size":10,
     "_source":["name"],
     "sort":{
         "price":{
             "order":"desc/asc"
         }
     }
 }
 ​
 get /index/type/_search
 {
     "query":{
         "bool":{
             "must":[
                 {
                     "match":{
                         "name":"zhangsan"
                     }
                 }
             ]
         }
     }
 }
 ​
 get /index/type/_search
 {
     "query":{
         "bool":{
             "should":[
                 {
                     "match":{
                         "name":"zhangsan"
                     }
                 },
                 {
                     "match":{
                         "name":"lisi"
                     }
                 }
             ]
         }
     }
 }
 ​
 get /index/type/_search
 {
     "query":{
         "bool":{
             "should":[
                 {
                     "match":{
                         "name":"zhangsan"
                     }
                 },
                 {
                     "match":{
                         "name":"lisi"
                     }
                 }
             ],
             "filter":{
                 "range":{
                     "price":{
                         "gt":300
                     }
                 }
             }
         }
     }
 }
 ​

 match 分词查询，有时候不是用户期望的。能查询到：小米、华为，华为手机
 {
     "query":{
      "match":{
         "name":"小华"
      }   
     }
 }
 ​
 使用match_phrase 进行精确匹配，查询到：华为，华为手机
 {
     "query":{
      "match_phrase":{
         "name":"华为"
      }   
     }
 }

1.查询所有文档

 {
  "query": {
  "match_all": {}
  }
 }
 ​

2.匹配查询， match 匹配操作，分词查询，多个词条直接是or关系。

 {
  "query": {
  "match": {
   "name":"zhangsan"
  }
  }
 }

3.字段匹配查询

 {
  "query": {
  "multi_match": {
  "query": "zhangsan",
  "fields": ["name","nickname"]
  }
  }
 }
 ​

4.关键字精确查询 ，term查询

 {
  "query": {
  "term": {
  "name": {
  "value": "zhangsan"
  }
  }
  }
 }
 ​

5.多关键字精确查询，terms查询，name="zhangsan" or name="lisi"。

{
 "query": {
 "terms": {
 "name": ["zhangsan","lisi"]
 }
 }
}

6.指定查询字段

{
 "_source": ["name","nickname"],
 "query": {
 "terms": {
 "nickname": ["zhangsan"]
 }
 }
}

7.过滤字段

includes：来指定想要显示的字段

 excludes：来指定不想要显示的字段

{
 "_source": {
 "excludes": ["name","nickname"]
 },
 "query": {
 "terms": {
 "nickname": ["zhangsan"]
 }
 }
}

8.组合查询

bool查询通过 must，must_not，should进行组合。

{
 "query": {
 "bool": {
 "must": [
 {
 "match": {
 "name": "zhangsan"
 }
 }
 ],
 "must_not": [
 {
 "match": {
 "age": "40"
 }
 }
 ],
 "should": [
 {
 "match": {
 "sex": "男"
 }
 }
 ]
 }
 }
}

9.范围查询 gt gte lt lte

{
 "query": {
 "range": {
 "age": {
 "gte": 30,
 "lte": 35
 }
 }
 }
}

10.模糊查询 fuzzy

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数

 更改字符（box → fox）

 删除字符（black → lack）

 插入字符（sic → sick）

 转置两个相邻字符（act → cat）

10.1默认编辑距离

GET /student/_search?
{
 "query": {
 "fuzzy": {
 "name": {
 "value": "zhangsan"
 }
 }
 }
}

10.2指定编辑距离

{
 "query": {
 "fuzzy": {
 "name": {
 "value": "zhangsan",
"fuzziness": 2
 }
 }
 }
}

11.单字段排序。 sort， desc 降序，asc 升序

{
 "query": {
 "match": {
 "name":"zhangsan"
 }
 },
 "sort": [{
 "age": {
 "order":"desc"
 }
 }]
}

12.多字段排序

使用 age 和 _score 进行查询，并且匹配的结果首先按照年龄排序，然后 按照相关性得分排序

{
 "query": {
 "match_all": {}
 },
 "sort": [
 {
 "age": {
 "order": "desc"
 }
 },
 {
 "_score":{
 "order": "desc"
 }
 }
 ]
}

13.高亮查询

 pre_tags：前置标签

 post_tags：后置标签

 fields：需要高亮的字段

 title：这里声明 title 字段需要高亮，后面可以为这个字段设置特有配置，也可以空

{
 "query": {
 "match": {
 "name": "zhangsan"
 }
 },
 "highlight": {
 "pre_tags": "",
 "post_tags": "",
 "fields": {
 "name": {}
 }
 }
}

14.分页查询

{
 "query": {
 "match_all": {}
 },
 "sort": [
 {
 "age": {
 "order": "desc"
 }
 }
 ],
 "from": 0,
 "size": 2
}

15聚合查询

对某个字段取最大值 max

{
 "aggs":{
 "max_age":{
 "max":{"field":"age"}
 }
 },
 "size":0
}

对某个字段取最小值 min

{
 "aggs":{
 "min_age":{
 "min":{"field":"age"}
 }
 },
 "size":0
}

对某个字段求和 sum

{
 "aggs":{
 "sum_age":{
 "sum":{"field":"age"}
 }
 },
 "size":0
}

对某个字段取平均值 avg

{
 "aggs":{
 "avg_age":{
 "avg":{"field":"age"}
 }
 },
 "size":0
}

对某个字段的值进行去重之后再取总个数。注意：是个数。

{
 "aggs":{
 "distinct_age":{
 "cardinality":{"field":"age"}
 }
 },
 "size":0
}

State 聚合 ，stats 聚合，对某个字段一次性返回 count，max，min，avg 和 sum 五个指标

{
 "aggs":{
 "stats_age":{
 "stats":{"field":"age"}
 }
 },
 "size":0
}

16)桶聚合查询

terms 聚合，分组统计

{
 "aggs":{
 "age_groupby":{
 "terms":{"field":"age", "size": 3000}
 }
 },
 "size":0
} 

在 terms 分组下再进行聚合

GET /student/_search?
{
    "aggs":{
        "age_groupby":{
            "terms":{
                "field":"age"
            },
            "aggs":{
                "sum_groupby":{
                    "sum":{
                        "field":"age"
                    }
                }
            }
        }
    },
    "size":0
}

1.入门

ES是面向文档的，存储整个文档或者对象。

全文搜索、实时搜索、搜索纠错、

索引、搜索、排序、过滤

2.ES命令

2.1

GET /_count?pretty
{
  "query": {
    "match_all": {}
  }
}

关键字约定：

index 索引
type 类型
token 表征
filter 过滤器
analyser 分析器

终端测试

curl 'http://localhost:9200/?pretty'

节点客户端

传输客户端

curl -X ':///?' -d ''

查询所有文档
curl -XGET 'http://localhost:9200/_count?pretty' -d '
{
"query": {
"match_all": {}
}
}

索引、搜索、聚合

存储数据的过程 叫做索引

索引 类型 文档 字段

索引（名词）

索引（动词）

倒排索引

检索文档：

GET /megacorp/employee/1
DELETe  方法删除文档
使用 HEAD  方法检查

GET /megacorp/employee/_search

轻量级查询

GET /megacorp/employee/_search?q=last_name:Smith

DSL语句查询

GET /megacorp/employee/_search
{
"query" : {
"match" : {
"last_name" : "Smith"
}
}
}

过滤器查询

使用过滤器
GET /megacorp/employee/_search
{
    "query":{
        "filtered":{
            "filter":{
                "range":{
                    "age":{
                        "gt":30
                    }
                }
            },
            "query":{
                "match":{
                    "last_name":"smith"
                }
            }
        }
    }
}

全文搜索（相关性）

GET /megacorp/employee/_search
{
"query" : {
"match" : {
"about" : "rock climbing"
}
}
}
返回结果 有相关性评分

短语搜索

GET /megacorp/employee/_search
{
    "query":{
        "match_phrase":{
            "about":"rock climbing"
        }
    }
}

高亮搜索

GET /megacorp/employee/_search
{
"query" : {
"match_phrase" : {
"about" : "rock climbing"
}
},
"highlight": {
"fields" : {
"about" : {}
}
}
}

聚合

获取员工共同爱好
GET /megacorp/employee/_search
{
"aggs": {
"all_interests": {
"terms": { "field": "interests" }
}
}
}

不显示原始信息，只显示汇聚结果
GET /megacorp/employee/_search
{
"size":0,
"aggs": {
"all_interests": {
"terms": { "field": "interests" }
}
}
}

先过滤，在汇聚。
GET /megacorp/employee/_search
{
"query": {
"match": {
"last_name": "smith"
}
},
"aggs": {
"all_interests": {
"terms": {
"field": "interests"
}
}
}
}

分级汇聚

每种兴趣下员工的平均年龄

GET /megacorp/employee/_search
{
"aggs" : {
"all_interests" : {
"terms" : { "field" : "interests" },
"aggs" : {
"avg_age" : {
"avg" : { "field" : "age" }
}
}
}
}
}

2.分布式集群

集群健康

GET /_cluster/health

主分区（primary shard) 和复制分区(replica shard)

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

修改复制分区个数

PUT /blogs/_settings
{
"number_of_replicas" : 2
}

3.结构概念

索引：名字全部为小写，不能下划线开头，不能包含逗号。

类型：可以大写或者小写，不能包含下划线或者逗号。

部分查询：

GET /website/_doc/123?_source=title,text

只想要source数据：

GET /website/blog/123/_source

文档是否存在：

curl -i -XHEAD http://localhost:9200/website/blog/123

创建文档，不是更新文档。

PUT /website/blog/123?op_type=create
{ ... }

PUT /website/blog/123/_create
{ ... }
成功201，已经存在返回409

删除文档

DELETE /website/blog/123
成功200，失败404

指定版本生效

PUT /website/blog/1?version=1
{
"title": "My first blog entry",
"text": "Starting to get the hang of this..."
}

更新

POST /website/blog/1/_update
{
"doc" : {
"tags" : [ "testing" ],
"views": 0
}
}

脚本

POST /website/blog/1/_update
{
"script" : "ctx._source.views+=1"
}

POST /website/blog/1/_update
{
"script" : "ctx._source.tags+=new_tag",
"params" : {
"new_tag" : "search"
}
}

通过设置 ctx.op  为 delete  我们可以根据内容删除文档
POST /website/blog/1/_update
{
"script" : "ctx.op = ctx._source.views == count ? 'delete' : 'none'",
"params" : {
"count": 1
}
}

可以使用 upsert  参数定义文档来使其不存在时被创建
POST /website/pageviews/1/_update
{
"script" : "ctx._source.views+=1",
"upsert": {
"views": 1
}
}

在错误发生前重试更新5次
POST /website/pageviews/1/_update?retry_on_conflict=5 <1>
{
"script" : "ctx._source.views+=1",
"upsert": {
"views": 0
}
}

检索多个文档

GET /_mget
{
"docs" : [
{
"_index" : "website",
"_type" : "blog",
"_id" : 2
},
{
"_index" : "website",
"_type" : "pageviews",
"_id" : 1,
"_source": "views"
}
]
}

如果你想检索的文档在同一个 index 中（甚至在同一个 _type 中），你就可以在URL中定义一个默认的 /index 或 者 /index/type

GET /website/blog/_mget
{
    "docs":[
        {
            "_id":2
        },
        {
            "_type":"pageviews",
            "_id":1
        }
    ]
}

如果所有文档具有相同 _index 和 _type ，你可以通过简单的 ids 数组来代替完整的 docs 数组

GET /website/blog/_mget
{
"ids" : [ "2", "1" ]
}

bulk 操作

行为(action)必须是以下几种：
行为   解释
create 当文档不存在时创建之。详见《创建文档》
index 创建新文档或替换已有文档。见《索引文档》和《更新文档》
update 局部更新文档。见《局部更新》
delete 删除一个文档。见《删除文档》

{ "delete": { "_index": "website", "_type": "blog", "_id": "123" }}

{ "create": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "title": "My first blog post" }


POST /_bulk
{ "delete": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "create": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "title": "My first blog post" }
{ "index": { "_index": "website", "_type": "blog" }}
{ "title": "My second blog post" }
{ "update": { "_index": "website", "_type": "blog", "_id": "123", "_retry_on_conflict" : 3} }
{ "doc" : {"title" : "My updated blog post"} }

url里面指定 索引或者类型

POST /website/_bulk
{ "index": { "_type": "log" }}
{ "event": "User logged in" }

可以覆盖
POST /website/log/_bulk
{ "index": {}}
{ "event": "User logged in" }
{ "index": { "_type": "blog" }}
{ "title": "Overriding the default type" }

#

3.搜索

概念 解释
映射(Mapping) 数据在每个字段中的解释说明
分析(Analysis) 全文是如何处理的可以被搜索的
领域特定语言查询(Query DSL) Elasticsearch使用的灵活的、强大的查询语言

空搜索

GET /_search

GET /_search?timeout=10ms 注意：结果先送出去，后台依旧执行查询。

多索引和多类型

/_search
/gb/_search
/gb,us/_search
/g*,u*/_search
/gb/user/_search
/gb,us/user,tweet/_search
/_all/user,tweet/_search

简易搜索

GET /_all/tweet/_search?q=tweet:elasticsearch

GET /_search?q=+name:john +tweet:mary 需要URL编码
GET /_search?q=%2Bname%3Ajohn+%2Btweet%3Amary

_all字段
GET /_search?q=mary

"+" 前缀表示语句匹配条件必须被满足。类似的 "-" 前缀表示条件必须不被满足。所有条件如果没有 + 或 - 表示是可选的 ——匹配越多，相关的文档就越多

+name:(mary john) +date:>2014-09-10 +(aggregations geo)
?q=%2Bname%3A(mary+john)+%2Bdate%3A%3E2014-09-10+%2B(aggregations+geo)
name 字段包含 "mary" 或 "john"
date 晚于 2014-09-10
_all 字段包含 "aggregations" 或 "geo"

结构化查询

空查询
GET /_search
{}

查询多个索引或者类型
GET /index_2014*/type1,type2/_search
{}

分页
GET /_search
{
"from": 30,
"size": 10
}

上面GET和POST效果一样！

结构化查询

空查询等同于
GET /_search
{
"query": {
"match_all": {}
}
}

查询子句

{
QUERY_NAME: {
ARGUMENT: VALUE,
ARGUMENT: VALUE,...
}
}

{
QUERY_NAME: {
FIELD_NAME: {
ARGUMENT: VALUE,
ARGUMENT: VALUE,...
}
}
}