ES基础--常用知识梳理

发表于 | 分类于

索引操作

PUT 和 POST 的区别：

相对来说PUT偏向于创建，POST 偏向于更新，其实使用场景不同。在索引（indexing）数据时，PUT 需要指定 id ，POST 可以自动生成。

CRUD的API使用示例及区别：

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
#查看索引
GET _cat/indices

#索引文档，已有id的会删除重建，版本号+1
PUT index_name/_doc/1 
{
    "user":"elasticsearch",
    "comment":"you know,for search"
}

#创建文档，已有id会报错。
PUT index_name/_create/1
{
    "user":"elasticsearch",
    "comment":"you know,for search"
}

#创建文档，不指定id，自动生成
POST index_name/_doc
{
    "user":"elasticsearch",
    "comment":"you know,for search"
}

#查询
GET index_name/_doc/1

#更新，不会删除旧文档，真正的更新
POST index_name/_update/1
{
    "user":"elasticsearch",
    "comment":"document update"
}

#删除
DELETE index_name/_doc/1

节点类型

  • Master eligible 节点和 Master 节点。eligible 标识该节点是否参与选举。通过设置node.master=false禁止。第一个节点在启动时，会将自己设置为 master 。每个节点都保存了集群的状态（state），但只有 master 可以进行更改（确保数据的一致性）。
  • DataNode，存放数据的节点，负责保存分片数据。

  • Coordinating 节点，负责接收 client 的请求，将请求分发给合适的节点。最终汇聚结果，每个节点默认都起到了Coordinating Node的职责。

  • Hot&Warm 节点，不同硬件的 DataNode。Hot&Warm 架构用于降低部署成本

  • MachineLearning 节点，机器学习节点。
  • TribeNode，5.3后开始加入的，用于连接到不同集群，且支持当做新的集群来处理。
节点类型 配置参数 默认值
Master eligible node.master true
Data node.data true
Ingest node.ingest true
Coordinating 无 每个节点都是coordinating。设置其他类型全为false
MachineLearning node.ml true(需enable-xpack)

经常提到的 reIndex 和 alias 到底是什么？

reIndex 也称为索引重建。很多时候会遇到诸如：分片数设置错误、mapping 设置错误等。此时就只能选择 reindex，因为这些属性在创建后就不能进行修改。只能进行索引重建

集群颜色体现了什么

查看集群状态

1
GET _cluster/health

  • Green 代表所有主副分片均正常，
  • Yellow 代表主分片正常，有副本未能正常分配，
  • Red 代表有主分片为正常分配，如磁盘不足时，新建了一个索引

分片和副本

分片是将一份数据分成多个，水平扩展存储到不同机器，提高存储量。

副本是将一份数据复制为两份或更多，避免数据丢失。

搜索类型

  • match、term、terms、constant score等.....
  • match_phrase
  • match_phrase_prefix
  • query_string ,相对来说更智能，可以识别 and 和 or
  • simple_query_string，更笨重一些，无法识别 and 和 or，但可以通过 default_oparator 进行控制。
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
// 假设数据有三条，elasticsearch函数、kibana函数、logstash函数。
//query_string返回前两个
GET search_jw_words/_search
{
  "query": {
    "query_string": {
      "default_field": "content",
      "query": "(elasticsearch AND 函数) OR (kibana AND 函数)"
    }
  }
}
//simple——query_string三条全部返回
GET search_jw_words/_search
{
  "query": {
    "simple_query_string": {
      "query": "elasticsearch AND 函数",
      "fields": ["content"]
    }
  }
}
//修改默认连接参数，此时则只返回elasticsearch函数
GET search_jw_words/_search
{
  "query": {
    "simple_query_string": {
      "query": "elasticsearch AND 函数",
      "fields": ["content"],
      "default_operator": "AND"
    }
  }
}

数据类型

  • text/keyword
  • Date,建立 mapping 时，需要指定 format
  • Integer/Floating
  • boolean
  • IPv4/IPv6
  • 复杂类型，对象和嵌套对象。
  • 特殊类型， geo_point,geo_shape,percolator

mapping 和 DynamicMapping

mapping 指的是字段的映射信息，即每个字段的数据类型，分词配置等等。mapping 创建后，可以新加字段，但不能修改已有字段的 mapping，要修改已有字段只能进行 reindex 操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
PUT search_jw_words
{
  "mappings" : {
    "properties" : {
      "content" : {
        "type" : "text",
        "analyzer": "ik_smart",
        "fielddata": true,
        "fields": {
          "keyword":{
            "type":"keyword"
          }
        }
      },
      "searchtime" : {
        "type" : "date",
        "format": "yyyy-MM-dd||yyyy-MM-dd HH:mm:ss||yyyy-MM-dd HH:mm:ss.SSS||strict_date_optional_time||epoch_millis"
      }
    }
  }
}

在写入文档时，如果索引不存在，es 会自动创建索引。此时，使用到的 mapping 映射就叫做 DynamicMapping。但默认的 DynamicMaapping会出现识别错误的情况。例如地理位置类型推断错误,分词器选择错误等等。所以就需要人为定义好DynamicMapping，减少识别错误的问题，实际使用中，其实用的不多，还是人工定义 mapping 更适合。

1
2
3
4
5
6
7
8
9
//查看某索引的mapping
GET indexName/_mapping

//控制dynamic映射的参数有三个、true、false以及strict，
//默认值为true，false可以写入数据但不会被索引。strict会报错，禁止字段与mapping不一致。
PUT search_jw_words/_mapping
{
    "dynamic":"strict"
}

null_value

对于插入的字段值为 “NULL” 且需要对其进行检索时，可以使用 null_value （只有 keyword 类型支持设定 null_value）

1
2
3
4
5
6
7
8
9
PUT movies
{
  "mappings" : {
    "properties" : {
      "type":"keyword",
      "null_value":"NULL"
    }
  }
}

copy_to

拷贝字段到额外的新字段上，用于满足特性的搜索需求，由于老版本的 “_all” 已经去掉，copy_to 可以用于实现类型的功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PUT users
{
    "mappoing":{
        "properties":{
            "firstName":{
                "type":"text",
                "copy_to":"fullName"
            },
            "lastName":{
                "type":"text",
                "copy_to":"fullName"
            },
        }
    }
}

数组类型

es 不提供专门的数组类型，任何类型都可以存储多个值，即每种类型都可以存储数组。

1
2
3
4
5
PUT users/_doc/1
{
    "user":["张三","李四"],
    "age":[30,20]
}

多字段类型

基于不同需求情况下，可能会遇到同样的内容需要被中文检索到，也要被英文检索到。那次此时就可以使用到多字段类型：

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
PUT products
{
    "mapping":{
        "properties":{
            "company":{
                "type":"text",
                "fields":{
                    "keyword":{
                        "type":"keyword",
                        "ignore_above":256
                    }
                }
            },
            "comment":{
                "type":"text",
                "fields":{
                    "english_comment":{
                        "type":"text",
                        "analyzer":"english",
                        "search_analyzer":"english"
                    }
                }
            }
        }
    }
}

自定义分词器

自定义分词器分为以下三个部分：

  • charfilter，增加、替换或删除字符串
  • tokenizer，分词
  • filter，过滤
  • 组合成 analyzer
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
自定义分析器标准格式是：
PUT /my_index
{
    "settings": {
        "analysis": {
            "char_filter": { ... custom character filters ... },//字符过滤器
            "tokenizer": { ... custom tokenizers ... },//分词器
            "filter": { ... custom token filters ... }, //词单元过滤器
            "analyzer": { ... custom analyzers ... }
        }
    }
}
============================实例===========================
PUT /my_index
{
    "settings": {
        "analysis": {
            "char_filter": {
                "&_to_and": {
                    "type": "mapping",
                    "mappings": [ "&=> and "]
            }},
            "filter": {
                "my_stopwords": {
                    "type": "stop",
                    "stopwords": [ "the", "a" ]
            }},
            "analyzer": {
                "my_analyzer": {
                    "type": "custom",
                    "char_filter": [ "html_strip", "&_to_and" ],
                    "tokenizer": "standard",
                    "filter": [ "lowercase", "my_stopwords" ]
            }}
}}}


============================实例===========================
比如自定义好的analyzer名字是my_analyzer,在此索引下的某个新增字段应用此分析器
PUT /my_index/_mapping
{
   "properties":{
        "username":{
             "type":"text",
              "analyzer" : "my_analyzer"
         },
        "password" : {
          "type" : "text"
        }
    
  }
}
=================插入数据====================
PUT /my_index/_doc/1
{
  "username":"The quick & brown fox ",
   "password":"The quick & brown fox "


}
====username采用自定义分析器my_analyzer,password采用默认的standard分析器==
===验证
GET /my_index/_analyze
{
  "field":"username",
  "text":"The quick & brown fox"
}

GET /my_index/_analyze
{
  "field":"password",
  "text":"The quick & brown fox"
}

indexTemplate和DynamicTemplate

当一个索引被创建时，会按照以下步骤顺序进行：

  • 应用 es 默认的 settings 和 mappings
  • 应用 order 数值更低的 indexTemplate 的设定
  • 应用 order 更高的 indexTemplate 的设定，会覆盖之前相同的属性
  • 应用创建索引时，用户手动指定的 settings 和 mappings，覆盖之前相同的属性
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
PUT _template/template_default
{
    "index_patterns":["*"],
    "order":0,
    "version":1,
    "settings":{
        "number_of_shards":1,
        "number_of_replicas":1
    }
}

PUT _template/template_test
{
    "index_patterns":["test*"],
    "order":1,
    "settings":{
        "number_of_shards":1,
        "number_of_replicas":2
    },
    "mappings":{
    //日期推断关闭，数字推断打开
        "date_detection":false,
        "numeric_detection":true
    }
}

//查看template信息
GET _template/template_default
GET _template/temp*

PUT testtemplate/_doc/1
{
    "someNumber":"1",
    "someDate":"2020/01/01"
}
GET testtemplate/_mapping

PUT testmy
{
    "settings":{
        "number_of_replicas":5
    }
}
GET testmy/_settings
PUT testmy/_doc/1
{
    "key":"value"
}
DELETE testmy
DELETE _template/template_default
DELETE _template/template_test
//或
DELETE _template/temp*

DynamicTemplate 用于对新字段进行模板映射，当 dynamicTemplates 匹配到该字段时，就会应用已经设置好的 mapping。

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
PUT my_index
{
    "mappings":{
        "dynamic_templates":[
        {
            "string_as_boolean":{
                "match_mapping_type":"string",
                "match":"is*",
                "mapping":{
                    "type":"boolean"
                }
            }
        },
        {
            "string_as_keywords":{
                "match_mapping_type":"string",
                "mapping":{
                    "type":"keyword"
                }
            }
        }
        ]
    }
}
//测试
PUT my_index/_doc/1
{
    "firstName":"zhang"
    "isMan":"true"
}
GET my_index/_mapping
DELETE my_index

PUT my_index
{
    "mappings":{
        "dynamic_templates":[
        {
            "full_name":{
                "path_match":"name.*",
                "path_unmatch":"*.middle",
                "mapping":{
                    "type":"text",
                    "copy_to":"full_name"
                }
            }
        }
        ]
    }
}

PUT my_index/_doc/1
{
    "name":{
        "first":"张",
        "middle":"尼古拉斯",
        "last":"三"
    }
}
//测试
GET my_index/_search
{
  "query": {
    "match": {
      "full_name": "张三"
    }
  }
}

聚合

聚合总体可以分为一下几个大类别：

  • bucket aggregation，满足特定条件的某些聚合
  • metric aggregation，一些数学运算，可以对文档字段进行统计分析
  • pipeline aggregation，对其它的聚合结果进行二次聚合
  • Matrix aggregation，支持对多个字段的操作，并提供一个结果矩阵。

bucket 可以简单理解为 sql 语句的 group by 操作，metric 可以理解为 sql 的 count 函数。

0%