2021-08-08 Elasticsearch 1-3杂记

2024-04-07 09:34:50

文章目录

CURD操作
- PUT
index与Create不一样的地方是，如果文档不存在就索引新文档，否则现有文档会被删除，新的文档被索引。版本信息+1
使用POST 来create一个文档，自动生成ID
- 结果如下
- 把文档拿出来看看
PUT一个文档指定文档的ID
- 更新操作，对文档增加两个字段
BULK的API
- mget 批量读取操作
- msearch 指搜索
- - 批量查询
3.15节---倒排索引##############
3.16节--analysis，分词器
- 内置的分词器：
- 3.14节---Search API 概览
- 3.15节------URI Search
指定字段查询与泛查询
- 指定字段查询，以下指定从host.name字段进行查询
- - - - 结果如下：
  - 泛查询：所有字段都查询：
Term 与Phrase
分组与引号
布尔操作
范围查询
算数符号
通配符查询（通配符查询效率低，占用内存大，不建议使用，特别是在最前面）
正则表达式查询
模糊匹配与近似查询
Request Body的查询
- 一个简单的示例
- 脚本字段
Query String 与Simple Query
- Query String
- Simple Query
Mapping 与Dynamic Mapping
- Mapping：
- 字段类型
- Dynamic Mapping
- 能否更改Mapping的字段类型
3.19节显示Mapping设置与常见参数介绍
- 创建一个Mapping
- 自定义Mapping的一些建议
3.20 多字段特性及Mapping中配置自定义Analyzer
- tokenizer
- 为索引创建一个analyzer
3.21 Index Template 和 Dynamic Template
3.22 Elasticsearch 聚合分析简介
- Bucket 与 Metric
- - Metric

GET _search
{
  "query": {
    "match_all": {}
  }
}

GET securities-futures-2021.31/_doc/?
// 查看索引相关信息
GET securities-futures-2021.31

// 查看索引文档总数
GET securities-futures-2021.31/_count

//查看前10条文档，了解文档格式
POST securities-futures-2021.31/_search
{

}

//查看indices
GET /_cat/indices/securities-*?v&s=index

//查看状态为绿的索引
GET /_cat/indices?v&health=green

//按照文档个数排序
GET /_cat/indices?v&s=docs.count:desc

//查看具体的字段
GET /_cat/indices/securities*?pri&v&h=health,index.pri,rep,docs,count,mt

// 查看每个索引所占用的内存
GET /_cat/indices?v&h=i,tm&s=tm:desc

//
//查看集群的健康状态
GET _cluster/health
GET _cat/nodes
GET _cat/shards

查看索引的mapping的定义
GET indices/_mapping

CURD操作

//PUT文档的时候可以指定文档的ID，使用POST可以把ID去掉，会自动生成ID

PUT

//PUT方法文档的时候可以指定文档的ID，使用POST方法可以把ID去掉，会自动生成ID

PUT securities-futures-2021.31/_cereat/1
{
  
}
PUT securities-futures-2021.31/_doc/1
{
  
}

index与Create不一样的地方是，如果文档不存在就索引新文档，否则现有文档会被删除，新的文档被索引。版本信息+1

POST securities-futures-2021.31/_create
{
  
}

GET securities-futures-2021.31/_doc/1

//update一个文档，使用POST方法
POST securities-futures-2021.31/_update/1
{
 "doc":{
   
 } 
}

使用POST 来create一个文档，自动生成ID

//create document,自动生成_id，自动生成文档ID要用POST
POST securities-futures-2021.31/_doc
{
  "tags": ["Mike","is a person"],
  "@metadata":"2021-08-07T14:12:12",
  "message": "test kibana message"
}

结果如下

{
  "_index" : "securities-futures-2021.31",
  "_type" : "_doc",
  "_id" : "rRZBIHsBY4N9DGxpewtO",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "failed" : 0
  },
  "_seq_no" : 39501,
  "_primary_term" : 1
}

把文档拿出来看看

GET securities-futures-2021.31/_doc/rRZBIHsBY4N9DGxpewtO

GET securities-futures-2021.31/_doc/k7FDIHsBzlSCb0pCVpJs

PUT一个文档指定文档的ID

//PUT方法创建一个文档，指定文档ID为1,但是如果id已经存在，则报错：

PUT securities-futures-2021.31/_doc/1?op_type=create
{
  "tags": ["Jason","is a person"],
  "@metadata":"2021-08-07T14:12:12",
  "message": "test kibana message"
  
}

//以上是一个创建的操作op_type，所以如果存在id就会报错，但是如果不是创建的type，则默认是更新的操作，可以更新文档的版本号，如下，内容一样，但是每一次都会更新文档的版本号，这其实是一个index的操作，把旧文档删除，然后写入新文档，把版本号加1

PUT securities-futures-2021.31/_doc/1
{
    "tags": ["Jason","is a person"]
}

GET securities-futures-2021.31/_doc/1

更新操作，对文档增加两个字段

POST securities-futures-2021.31/_update/1
{
  "doc":{
    "@metadata": "2021-08-07T14:13:13",
    "message": "test kibana message2"
  }
}

BULK的API

#在一次REST的API中执行多种操作，还可以对不同的索引进行操作

POST _bulk
{"index":{"_index":"test","_id":1}}
{"field1":"value1"}
{"delete":{"_index":"test","_id":"2"}}
{"create":{"_index":"test2","_id":"3"}}
{"field1":"value3"}
{"update":{"_id":"1","_index":"test"}}
{"doc":{"field2":"value2"}}

GET test/_doc/1
GET test2/_doc/3

mget 批量读取操作

GET _mget
{
  "docs":[
    {
      "_index": "user",
      "_id":1
    },
    {
      "_index": "comment",
      "_id":1
    },
    {
      "_index": "test",
      "_id": 1
    }
    ]
}

msearch 指搜索

批量查询

GET securities-futures-2021.08.05
POST securities-futures-2021.31/_msearch
{}
{"query":{"match_all":{}},"size":1}
{"index":"securities-futures-2021.08.05"}
{"query":{"match_all":{}},"size":2}

POST /_msearch
{"index":"securities-futures-2021.31"}
{"query":{"match_all":{}},"size":1}
{"index":"securities-futures-2021.08.05"}
{"query":{"match_all":{}},"size":2}

3.15节—倒排索引##############

倒排索引按照word进行索引标明这个word在哪个文档中出现过。
拿图书来类比，图书中的目录页就是正排索引，而书最后的索引页，就是一种倒排索引的实现。
正排索引是文档ID到文档内容的单词的索引，
倒排索引是从单词来找文档的ID的索引。
所以在文档定入的时候要进行分词。

倒排索引项：
1，文档ID
2，词频TF，出现的次数
3，位置，position
4，偏移，Offset

Elasticsearch的JSON文档中的每个字段，都有自己的倒排索引，可以指定某些字段不用做索引，这样可以节省空间，但是该字段就无法进行搜索了。

3.16节–analysis，分词器

analysis是把文档分成单词的过程，也叫分词。是通过analyzer来实现的，elasticsearch内置了一些分词器，也可以按需求定制化一些分词器。
除了在写入时转换词条外，匹配query语句的时候也需要用相同的分词器对查询语句进行分析。

Analyzer分词器由3部分组成：
1，Chracter Filters:
对原始文本进行一些处理，例如去除html的标签。
2，Tokenizer:
按照一定的规则，将输入的字符串进行切分，例如按照空格进行切分
3，Token Filters:
对切分的单词进行加工，例如大小转小写，频用词去掉，增加一些近义词

内置的分词器：

1，standard analyzer:默认的分词器，按词切分，小写处理。
2，simple analyzer:按照非字母切分（符号被过滤），小写处理。
3，stop analyzer:小写处理，停用词过滤（the,a,is等）tokennizer是lowercase，Token Filter 是Stop
4，whitespace analyzer:按照空格进行切分，不转小写。
5，keyword analyzer:不分词，直接将输入当作输出。不不需要进行分词的时候就选这个。
6，patter analyzer: 正则表达式切分，默认\W+(非字符分割)，Tokenizer是pattern，而Token Filter是Lower case + Stop.
7，language ，提供了30多种常见语言的分词器。什么ing形式转成正式单词，复数转单数。
8，customer analyzer: 自定义分词器。

_analyze的api

直接指定analyzer进行测试

GET /_analyze
{
	"analyzer":"standard",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}
GET /_analyze
{
	"analyzer":"simple",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}
GET /_analyze
{
	"analyzer":"stop",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}
GET /_analyze
{
	"analyzer":"whitespace",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}

GET /_analyze
{
	"analyzer":"keyword",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}
GET /_analyze
{
	"analyzer":"pattern",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}

GET /_analyze
{
	"analyzer":"english",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}

指定的字段进行测试

POST books/_analyze
{
	"field": "title",
	"text":"Mastering Elasticsearch"
}

#自定义分词器进行测试
POST /_analyze
{
	"tokenizer":"standard",
	"filter":[“lowercase”],
	"test":"Mastering Elasticsearch"
}

中文分词

中文需要根据上下文进行分词。需要安装一个插件
elasticsearch-plugin install analysis-icu
提供了一个unicode的支持，更好的支持亚洲语言。

GET /_analyze
{
	"analyzer":"icu_analyzer",
	"text": "Mastering Elasticsearch,elasticsearch in Action"
}

还有更好的分词器：IK,THULAC(清华大学自然语言处理和社会人文计算实验室)

3.14节—Search API 概览

API 分两类
1，URIsearch，在URI中使用GET参数来查询
2，Request BODY方式，在BODY中使用JSON格式进行查询。
2.1,/_search
2.2,/index1/_search
2.3,/index1,index2/_search
2.4,/index*/_search

curl -XGET “http://localhost:9200/securities-futures-2021.31/_search?q=message:testmessage”
上述URL中，_search指明要查询
q指明查询的条件。

curl -XGET "http://localhost:9200/securities-futures-2021.31/_search"-H 'Content-Type:application/json' -d'
{
	"query":{
		"match_all":{}
	}
}

3.15节------URI Search

GET /securities-futures-2021.31/_search?q=2012&df=title&sort=year:desc&from=o&size=10&timeout=1s
{
	"prifile": true
}

q:指定查询语句，使用Query String Syntax
df:默认字段，不指定时，会对所有字段进行查询—default fields.不指定就是全文查找。所以指定字段会比较好。
sort:排序，/from和size用于分页
profile：可以可看查询是如何被执行的。

指定字段查询与泛查询

q=title:2012 q=2012

指定字段查询，以下指定从host.name字段进行查询

GET securities-futures-2021.31/_search?q=host.name:ELK-NODE-1&from=0&size=1
{
  "profile": true
}

结果如下：

{
  "took" : 8,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 10000,
      "relation" : "gte"
    },
    "max_score" : 0.0029382796,
    "hits" : [
      {
        "_index" : "securities-futures-2021.31",
        "_type" : "_doc",
        "_id" : "9aymFXsB-X2346SZyKCM",
        "_score" : 0.0029382796,
        "_source" : {
          "log" : {
            "file" : {
              "path" : "/var/log/messages"
            },
            "offset" : 2809904605
          },
          "ecs" : {
            "version" : "1.8.0"
          },
          "agent" : {
            "hostname" : "ELK-NODE-1",
            "version" : "7.13.4",
            "ephemeral_id" : "dcfa9937-6316-4684-a2dd-e9437cbe5c81",
            "id" : "3fa3c407-7491-4888-b338-d52ed73ddab3",
            "type" : "filebeat",
            "name" : "ELK-NODE-1"
          },
          "message" : "Aug  5 17:30:49 elk-node-1 logstash: [2021-08-05T17:30:49,416][INFO ][logstash.outputs.file    ][main][f88fdfac4ab33fa2abbfe198d5bf459f178520a5935bb820ace171000ecb342f] Closing file /tmp/futures/ELK-NODE-1-192.168.9.45-2021.08.05",
          "@timestamp" : "2021-08-05T09:30:55.909Z",
          "input" : {
            "type" : "log"
          },
          "tags" : [
            "标签",
            "可以随便写",
            "可以写中文",
            "kafka-tags",
            "from-filebeat-tag"
          ],
          "host" : {
            "name" : "ELK-NODE-1"
          },
          "fields" : {
            "applicationname" : "frontend",
            "address" : "dlfjdjfla kjfdlja flj asdljf ljd",
            "hostname" : "ELK-NODE-1",
            "systemname" : "futures",
            "ipaddress" : "192.168.9.45"
          },
          "@version" : "1"
        }
      }
    ]
  },
  "profile" : {
    "shards" : [
      {
        "id" : "[kicYTiloQ_ed57aZCXfjnA][securities-futures-2021.31][0]",
        "searches" : [
          {
            "query" : [
              {
                "type" : "TermQuery",
                "description" : "host.name:ELK-NODE-1",
                "time_in_nanos" : 3119640,
                "breakdown" : {
                  "set_min_competitive_score_count" : 10,
                  "match_count" : 0,
                  "shallow_advance_count" : 0,
                  "set_min_competitive_score" : 10988,
                  "next_doc" : 1423795,
                  "match" : 0,
                  "next_doc_count" : 10080,
                  "score_count" : 10080,
                  "compute_max_score_count" : 0,
                  "compute_max_score" : 0,
                  "advance" : 88104,
                  "advance_count" : 8,
                  "score" : 1082164,
                  "build_scorer_count" : 16,
                  "create_weight" : 233821,
                  "shallow_advance" : 0,
                  "create_weight_count" : 1,
                  "build_scorer" : 280768
                }
              }
            ],
            "rewrite_time" : 3678,
            "collector" : [
              {
                "name" : "SimpleTopScoreDocCollector",
                "reason" : "search_top_hits",
                "time_in_nanos" : 2026048
              }
            ]
          }
        ],
        "aggregations" : [ ]
      }
    ]
  }
}

泛查询：所有字段都查询：

GET securities-futures-2021.31/_search?q=ELK-NODE-1
  "profile": true
}

GET securities-futures-2021.31/_search?q=ELK-NODE-1&df=host.name&from=0&size=1
  "profile": true
}

Term 与Phrase

Beautiful Mind，等同于查Beautiful 或者 Mind 两个词。随便出现一个即匹配到查询
“Beautiful Mind” 有引号引起来表示2个必需同时出现，且顺序要保持一致

分组与引号

title:(Beautiful AND Mind)
title=“Beautiful Mind”

GET /indices/_search?q=title:Beautiful Mind
{
	"profile": true
}

如上，这样写就是查看Beautiful 或者Mind两个词的就可以

GET /indices/_search?q=title:(Beautiful Mind)
{
	"profile": true
}

如上，必需(Beautiful Mind) 在一起，而且前后顺序一致

布尔操作

AND / OR / NOT 或者 &&、|| ！
1、必需大写
2、title:(matrix NOT reloaded)
分组
1、+ 表示must
2、- 表示must_not
3、- title:(+matrix - reloaded)

GET /indices/_search?q=title:(Beautiful AND Mind)
{
	"profile":true
}

GET /indices/_search?q=title:(Beautiful NOT Mind)
{
	"profile":true
}

GET /indices/_search?q=title:(Beautiful NOT Mind)
{
	"profile":true
}

GET /indices/_search?q=title:(Beautiful @2BMind)
{
	"profile":true
}

%2B表示+号，表示must

范围查询

区间表示：“[]”表示闭区间，｛｝表示开区间
year:{2019 TO 2018}
year:[* TO 2018]

GET /indices/_search?q=year:>=2018
{
	“pfofile”:"true"
}

算数符号

year:>2010
year:(>2010 && <=2018)
year:(+>2010 +<2018)

通配符查询（通配符查询效率低，占用内存大，不建议使用，特别是在最前面）

？代表1个字符
- 代表0或多个字符
示例
title:mi?d
title:be*

正则表达式查询

title:[bt]oy

模糊匹配与近似查询

title:beautiful~1
title:“lord rings”~2

GET /indices/_search?q=title:beautifl~1
{
	"profile":"true"
}

模糊匹配，但是可以模糊匹配。U为故意写错的，查找与这个词近似的值。

Request Body的查询

URIsearch的查询语法有限，一些高阶的查询方法只能用Request Body的方法进行查询

一个简单的示例


POST /indices,404_idx/_search?ignore_unavailable=true
{
	"profile"：“true",
	"query":{
			"match_all":{}
	}
}


POST /indices,404_idx/_search?ignore_unavailable=true
{
	"profile"：“true",
	"sort"[{"order_date":"desc"}],
	"_source":["order_date","order_date","category.keyword"],
	"from": 10,
	"size": 5,
	"query":{
			"match_all":{}
	}
}

sort指明以哪个字段进行排序
_source:,指明从哪几个字段查询

排序最好在“数字型”与“日期型”字段上进行排序
如果不指定"_source",则从所有字段中进行查询，可以使用source写明指定字段进行查询。

脚本字段

“painless" 拼接

GET /index/_search
{
	"script_fields":{
		"new_field":{
			"script":{
				"lang":"painless",
				"source":"doc['order_date'].value+'_hello'"
			}
		}
	}
	"from":10,
	"size":5,
	"query":{
		"match_all":{}
	}
}

GET securities-futures-2021.31/_search
{
  "script_fields": {
    "test_field": {
      "script": {
        "lang": "painless",
        "source": "doc['agent.hostname'].value+doc['agent.id'].value"
      }
    }
  },
  "from":10,
  "size":5,
  "query":{
    "match_all":{}
  }
}

painless是elasticsearch的脚本去算出一个新的字段结果来。
订单中有不同的汇率，需要结合汇率对订单价格进行排序。

match 查询

GET /securities-futures-2021.31/_search
{
  "query":{
    "match": {
      "fields.hostname": "ELK-NODE-1"
    }
  },
  "size":10,
  "from":5
}

使用match匹配你要查询的字段的值。

GET /securities-futures-2021.31/_search
{
  "query":{
    "match": {
      "fields.hostname": "ELK-NODE-1 ELK-NODE-2"
    }
  },
  "size":1,
  "from":5
}

但是如果如上所示，如果填入两个词的话,则只查询后面的词，如果想两个都查，

GET /securities-futures-2021.31/_search
{
  "query":{
    "match": {
      "fields.hostname": {
      	"query":"ELK-NODE-1 ELK-NODE-2"
      	"operator":"AND"
      }
    }
  },
  "size":1,
  "from":5
}

指明需要一个AND的操作，两个字一起查。

match_phrase

GET /securities-futures-2021.31/_search
{
  "query":{
    "match_phrase": {
      "agent.hostname": {
        "query": "INFO monitoring",
        "slop": 1
      }
    }
  }
}

slop的值为1，表示中间可以有1个不同的值。

Query String 与Simple Query

Query String

GET securities-futures-2021.31/_search
{
  "query":{
    "query_string": {
      "default_field": "message",
      "query": "Non-zero AND metrics"
    }
  }
}

Simple Query

GET securities-futures-2021.31/_search
{
  "query":{
    "simple_query_string": {
      "query": "Non-zero AND metrics",
      "fields": ["message"],
      "default_operator": "AND"
    }
    }
  }
}

类似于query string，但是会忽略错误的语法，同时只支持部分查询语法
不支持AND OR NOT，会当作字符串处理
Term之间的默认关系是OR，可以指定Operator,
支持部分逻辑
“+” 表示AND
“|” 表示OR
“-” 表示NOT

Mapping 与Dynamic Mapping

Mapping：

与数据中中定义表的属性差不多，

定义字段的名称
定义字段的数据类型，字符串，数字，布尔。
字段，倒排索引相关的配置，（是否可以被索引，Analyzed or Not Analyzed）
Mapping会把json的文档映射成lucene所需要的扁平格式
一个Mapping属于一个索引的Type。
从7版本开始，一个索引只能有一个Type
所以一个mapping的定义呢只属于一个索引的一个Type。
因为一个索引只有一个Type，所以不需要在Mapping中定义指定的Type信息了。

字段类型

简单类型
- Text/Keyword
- Date
- integer/Floating
- Boolean
- IPv4 & IPv6
复杂类型
- object类型
- 嵌套类型
特殊类型
- geo_point
- geo_shape
- percolator
- 等等

Dynamic Mapping

如果写稿文档的时候，索引不存在，会自动创建索引
Dynamic Mapping的机制，使得我们无需手动定义Mappings。Elasticsearch 会自动根据文档信息推算出字段类型。
但是经常会推算不对。
类型不对时，会导致一些功能无法正常运行，例如Rangte查询。

能否更改Mapping的字段类型

两种情况
- 新增加字段
  - Dynamic 设为true时，一旦有新增字段的文档写入，Mapping也同时被更新。
  - Dynamic 设为false，Mapping不会被更新，新增字段的数据无法被索引。但是信息会出现在"_source"中。
  - Dynamic 设置成Strict，文档写入失败
- 已有字段，一旦已经有数据写入，就不再支持修改字段定义
  - Lucene实现的倒排索引，一旦生成后，就不允许修改。
- 如果希望改变字段类型，必需Reindex API,重建索引
原因
- 如果修改了字段的数据类型，会导致已被索引的属于无法被搜索
- 但是如果是增加新的字段，就不会有这样的影响。

3.19节显示Mapping设置与常见参数介绍

创建一个Mapping

PUT indices
{
	"mapping":{
	# define your mapping here.
	}
}

自定义Mapping的一些建议

可能参考API手册，纯手写
为了减少输入的工作量，减少出错率，可以按照以下步骤：
- 创建一个临时的index，写入一些样本数据。
- 通过访问Mapping API 获得该临时文件的动态Mapping定义。
- 修改后用，使用该配置创建你的索引
- 删除临时索引。

如果对一个字段设置好type的类型后，确定这个不需要索引的，可以“index":“false”

index Options：

根据不同的需要，可以设置不同的index Options。可以控制倒排索引记录的内容

docs - 记录doc id
freqs - 记录doc id 和term frequencies.
positions - 记录 doc id / term frequencies / term position
offsets - doc id / term frequencies / term posistion / character offects.

Text类型默认记录positions,其它默认为docs。
记录内容越多，占用存储空间越大。

"bio":{
	"type":"text",
	"index_options":"offsets"
}

null_value

如果需要对null这个值进行搜索，那么type需要设置为keyword类型，只有keyword类型支持设置null_value。

mobile:{
	"type": "keyword",
	"null_value":"NULL"
}

copy_to

_all 在7版本中被copy_to取代，
满足一些特定的搜索需求
copy_to将字段的数值拷贝到目标字段，实现类似_all的作用
copy_to的目标字段不出现在_source中。

举个例子：

PUT users
{
	"mapping":{
		"properties":{
			"firstname":{
				"type":"text",
				"copy_to" "fullname"
			}
			"lastname":{
				"type":"text",
				"copy_to":"fullname"
				}
		}
	}
}

如上，意思就是将fistname与lastname的值都拷贝到fullname，

数组类型

Elasticsearch 中不提供专门的数组类型。但是任何字段，都可以包含多个相同类类型的数值。

PUT users/_doc/1
{
	"name":"onebird",
	"interests":"reading"
}
PUT user/_doc/2
{
	"name":"twobirds",
	"interests": ["reading","music"]
}

3.20 多字段特性及Mapping中配置自定义Analyzer

多字段特性
- 厂商名字实现精确匹配
  - 增加一个keyword字段
- 使用不同的analyzer
  - 不同语言
  - pinyin字段的搜索
  - 还支持为搜索和索引指定不同的analyzer

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"
					}
				}
			}
		}
	}
}

Exact Values v.s Full Text

Exact values v.s Full Text
- Exact Value:包括数字/ 日期 / 具体一个字符串（例如“Apple Store”）
  - Elasticsearch中的keyword
  - 精确值的不需要被分词，为每一个字段创建一个倒排索引，也不需要做特殊的分词处理。
- 全文本，非结构化的文本数据
  - Elasticsearch 中text

自定义分词器

当Elasticsearch 自带的分词器无法满足时，可以自定义分词器，通过自组合不同的组件实现。
一些自带的Character Filters

HTML strip - 去除html的标签
Mapping - 字符串替换
Pattern replace - 正则匹配替换。

POST _analyze
{
	"tokenizer":"standard",
	"char_filter":[
		{
		"type":"mapping",
		"mappings":[":) => happy",":( => sad"]
		}
	],
	"text":["i am felling :)" , "Feeling :( today"]
}

{
  "tokens" : [
    {
      "token" : "i",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "am",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "<ALPHANUM>",
      "position" : 1
    },
    {
      "token" : "felling",
      "start_offset" : 5,
      "end_offset" : 12,
      "type" : "<ALPHANUM>",
      "position" : 2
    },
    {
      "token" : "happy",
      "start_offset" : 13,
      "end_offset" : 15,
      "type" : "<ALPHANUM>",
      "position" : 3
    },
    {
      "token" : "Feeling",
      "start_offset" : 16,
      "end_offset" : 23,
      "type" : "<ALPHANUM>",
      "position" : 104
    },
    {
      "token" : "sad",
      "start_offset" : 24,
      "end_offset" : 26,
      "type" : "<ALPHANUM>",
      "position" : 105
    },
    {
      "token" : "today",
      "start_offset" : 27,
      "end_offset" : 32,
      "type" : "<ALPHANUM>",
      "position" : 106
    }
  ]
}

正则表达式

GET _analyze
{
  "tokenizer": "standard",
  "char_filter": [
    {
    "type":"pattern_replace",
    "pattern":"http://(.*)",
    "replacement": "$1"
  }
  ],
  "text":"http://www.baidu.com"
}

结果：

{
  "tokens" : [
    {
      "token" : "www.baidu.com",
      "start_offset" : 0,
      "end_offset" : 20,
      "type" : "<ALPHANUM>",
      "position" : 0
    }
  ]
}

如上：该语法就把http://去掉了，只留一个纯网址。

tokenizer

POST _analyze
{
  "tokenizer": "path_hierarchy",
  "text":"/data/elasticsearch/log/server/err.log"
}

结果：

{
  "tokens" : [
    {
      "token" : "/data",
      "start_offset" : 0,
      "end_offset" : 5,
      "type" : "word",
      "position" : 0
    },
    {
      "token" : "/data/elasticsearch",
      "start_offset" : 0,
      "end_offset" : 19,
      "type" : "word",
      "position" : 0
    },
    {
      "token" : "/data/elasticsearch/log",
      "start_offset" : 0,
      "end_offset" : 23,
      "type" : "word",
      "position" : 0
    },
    {
      "token" : "/data/elasticsearch/log/server",
      "start_offset" : 0,
      "end_offset" : 30,
      "type" : "word",
      "position" : 0
    },
    {
      "token" : "/data/elasticsearch/log/server/err.log",
      "start_offset" : 0,
      "end_offset" : 38,
      "type" : "word",
      "position" : 0
    }
  ]
}

每一级目录都会被拆分出来

为索引创建一个analyzer

PUT my_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_custom_analyzer":{
          "type":"custome",
          "char_filter":["emotions"],
          "tokenizer":"punctuation",
          "filter":[
            "lowercase",
            "english_stop"
            ]
        }
      },
      "tokenizer": {
        "punctuation":{
          "type":"pattern",
          "pattern":"[.,!?]"
        }
      }
    }
  }
}

3.21 Index Template 和 Dynamic Template

Index Templates - 帮助你设定Mappings 和Settings，并按照一定的规则，自动匹配到新创建的索引之上
- 模板仅在一个索引被创建时，才会产生作用，修改模板不会影响已经创建的索引。
- 你可以设定多个索引模板，这些设置会被“merge”在一起。
- 你可以指定“order”的数值，控制"merging"的过程。
Dynamic Template
- 根据Elasticsearch识别数据类型，结合字段名称，来动态设定字段类型
- 所有的字符串类型都设定成keyword，或者关闭keyword字段。
- is开头的字段都设置成boolean
- long_ 开头的都设置成long类型。
- dynamic template是应用在具体的一个索引上的，而不是用于创建索引的。

3.22 Elasticsearch 聚合分析简介

集合的分类：

Bucket Aggregation - 一些列满足特定条件的文档的集合
Metric Aggregation - 一些数学运算，可以对文档字段进行统计分析
Pipeline Aggregation - 对其它的聚合结果进行二次聚合
Matrix Aggregration - 支持对多个字段的操作并提供一个结果矩阵

Bucket 与 Metric

Bucket 相当于sql里面的group，一组满足条件的文档
Metric 相当于一系列的统计算法。

Metric

Metric 会基于数据集计算结果，除了支持在字段上进行计算，同时也支持在脚本（painless script）产生结果之上进行计算
大多数Metric是数学计算，仅输出一个值（min/max/sum/avg/cardinality）
部分metric 支持输出多个数值（stats/percentiles/percentile_ranks）

码农公寓