当先锋百科网

首页 1 2 3 4 5 6 7

ElasticSearch

ElasticSearch

一、字段的类型Field type的详解

下面就是所有的字段类型

字符串类型	text,keyword
整数类型	integer,long,short,byte
浮点类型	double,float,half_float,scaled_float
逻辑类型	boolean
日期类型	date
范围类型	range
二进制类型	binary
复合类型	数组类型	array
对象类型	object
嵌套类型	nested
地理类型	地理坐标类型	geo_point
地理地图	geo_shape
特殊类型	IP类型	ip
范围类型	completion
令牌计数类型	token_count
附件类型	attachment
抽取类型	percolator

1、字符串类型

1.1、text

会被分词器解析, 生成倒排索引, 支持模糊、精确查询, 不用于排序, 很少用于聚合,常用于全文检索.

1.2、keyword

不进行分词，直接索引, 支持模糊、精确查询, 支持聚合。如果需要为结构化内容, 比如 id、email、hostnames、状态码、标签等进行索引，则推荐使用 keyword 类型以进行完全匹配. 比如我们需要查询"已发货"的订单, 标记为"已发布"的文章等.

ES会对"数值(numeric)"类型的字段(比如, integer, long)进行优化以支持范围(range)查询. 但是, 不是所有的数值类型的数据都需要使用"数值"类型, 比如产品id, 会员id, ISDN(出版社编号), 这些很少会被进行范围查询, 通常都是精确匹配(term query).

keyword类型的查询通常比numeric的要快, 如果不需要范围查询, 则建议使用keyword类型.

如果不确定使用哪一种, 可以通过multi-field同时设置keyword和numeric类型.

2、数值类型(numeric)

类型说明取值范围
byte8位有符号整数-128 ~ 127
short16位有符号整数-32768 ~ 32767
integer32位有符号整数-2,147,483,648 ~ 2,147,483,647 即:-2^31 ~ 2^32 - 1
long64位有符号整数-2^63 ~ 2^63 - 1
float32位单精度IEEE 754浮点类型, 有限值, 24bits2^-149 ~ (2 - 2^-23) · 2^127
double64位双精度IEEE 754浮点类型, 有限值, 53bits2^-1074 ~ (2 - 2^-52) · 2^1023
half_float16位半精度IEEE 754浮点类型, 有限值, 11bits2^-24 ~ 65504
scaled_float带有缩放因子scaling_factor的浮点数, 可以当整型看待

2.1、整型

byte, short, integer, long

2.2、浮点型

float, half_float, scaled_float, double
对于上面展示的3种浮点类型（float, half_float, scaled_float）来说， -0.00和+0.00是不同的值，使用term查询-0.00时不会匹配+0.00, 反之亦然。对于范围查询(range query)来说也是如此：如果上边界是-0.00则无法匹配+0.00，如果下边界是+0.00则不会匹配-0.00

数值类型使用的注意事项:

  1. 在满足业务需求的情况下, 尽量选择范围小的类型, 这与mysql等关系型数据库的设计要求是一致的. 字段占用的空间越小, 搜索和索引的效率越高(这个有点废话, 数据量越小肯定越快了).

  2. 如果是浮点数, 则也要优先考虑使用scaled_float类型。对于scaled_float类型, 在索引时会乘以scaling_factor并四舍五入到最接近的一个long类型的值.

    如果我们存储商品价格只需要精确到分, 两位小数点, 把缩放因子设置为100, 那么浮点价格99.99存储的是9999.

    如果我们要存储的值是2.34, 而因子是10, 那么会存储为23, 在查询/聚合/排序时会表现为这个值是2.3. 如果设置更大的因子(比如100), 可以提高精度, 但是会增加空间需求.

3、Object类型

JSON文档天生具有层级关系: 文档可能包含内部对象, 而这个对象可能本身又包含对象, 就是可以包含嵌套的对象.

4、Date

JSON没有日期(date)类型, 在ES中date类型可以表现为:

  • 字符串格式的日期, 比如: “2015-01-01”, “2015/01/01 12:10:30”
  • long类型的自 epoch (1970-1-1) 以来的毫秒数
  • integer类型的自 epoch (1970-1-1) 以来的秒数(时间戳, timestamp)

在ES内部, 日期被转换为UTC格式(如果指定了时区), 并存储为long类型的自 epoch (1970-1-1) 以来的毫秒数.

查询时 , date类型会在内部转换为long类型的范围查询，聚合和存储字段的结果根据与字段关联的日期格式转换回字符串。

5、ip类型

ip类型的字段只能存储ipv4或ipv6地址.

二、属性的详解

1、fielddata字段数据

参考链接：https://www.cnblogs.com/rickie/p/11665168.html

默认情况下是false

作用：把不能聚合、排序、通过脚本访问的字段变为可以聚合、排序、通过脚本访问的字段

  • text类型是不支持doc_value。所以要想对text类型的字段拥有聚合等功能，只能设置属性的fielddata为true即可

缺点：构建和管理全部在内存，也就是在JVM的内存中。这意味着它本质上是不可扩展的。

fielddata可能会消耗大量的堆空间，尤其是在加载高基数（high cardinality）text字段时。一旦fielddata已加载到堆中，它将在该段的生命周期内保留。此外，加载fielddata是一个昂贵的过程，可能会导致用户遇到延迟命中。这就是默认情况下禁用fielddata的原因。

如果需要对 text 类型字段进行排序、聚合、或者从脚本中访问字段值，则会出现如下异常：

Fielddata is disabled on text fields by default. Set fielddata=true on [your_field_name] in order to load fielddata in memory by uninverting the inverted index. Note that this can however use significant memory.

但是，在启动fielddata 设置之前，需要考虑为什么针对text 类型字段进行排序、聚合、或脚本呢？通常情况下，这是不太合理的。

text字段在索引时，例如New York，这样的词会被分词，会被拆成new、york 2个词项，这样当搜索new 或 york时，可以被搜索到。在此字段上面来一个terms的聚合会返回一个new的bucket和一个york的bucket，但是你可能想要的是一个单一new york的bucket。

怎么解决这一问题呢？

你可以使用 text 字段来实现全文本查询，同时使用一个未分词的 keyword 字段，且启用doc_values，来处理聚合操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qlza4utS-1644556258944)(data:image/png;base64,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)]

(1) 使用my_field 字段用于查询；

(2) 使用my_field.keyword 字段用于聚合、排序、或脚本；
注意：但是我试了试，不行，我也不知道为啥

PUT /user3
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "fields": {
          "keyword":{
            "type":"keyword"
          }
        }
      }
    }
  }
}

POST /user3/_doc
{
  "name":"hello word 的数据结构 你真棒"
}

GET /user3/_search
{
  "query": {
    "match": {
      "name": "hello"
    }
  }, 
  "aggs":{
    "testq":{
      "terms":{
        "field":"name.keyword"
      }
    }
  }
}


结果输出：
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.2876821,
    "hits" : [
      {
        "_index" : "user3",
        "_type" : "_doc",
        "_id" : "N_X1n34BgddXgx4111ZC",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "hello word 的数据结构 你真棒"
        }
      }
    ]
  },
  "aggregations" : {
    "testq" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "hello word 的数据结构 你真棒",
          "doc_count" : 1
        }
      ]
    }
  }
}

也可以使用 PUT mapping API 在现有text 字段上启用 fielddata，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C0iFF2N6-1644556258949)(data:image/png;base64,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)]

2、doc_value

doc_values

默认情况下，大部分字段是索引的，这样让这些字段可被搜索。倒排索引（inverted index）允许查询请求在词项列表中查找搜索项（search term），并立即获得包含该词项的文档列表。

倒排索引（inverted index）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D0WU7j87-1644556258952)(data:image/png;base64,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)]

如果我们想要获得所有包含 brown 的文档的词的完整列表，我们会创建如下查询：

GET /my_index/_search
{
 "query" : {
  "match" : {
   "body" : "brown"
  }
 },

 "aggs" : {
  "popular_terms": {
   "terms" : {
   		"field" : "body"
   }
  }
 }
}

倒排索引是根据词项来排序的，所以我们首先在词项列表中找到 brown，然后扫描所有列，找到包含 brown 的文档。我们可以快速看到 Doc_1 和 Doc_2 包含 brown 这个 token。

然后，对于聚合部分，我们需要找到 Doc_1 和 Doc_2 里所有唯一的词项。用倒排索引做这件事情代价很高： 我们会迭代索引里的每个词项并收集 Doc_1 和 Doc_2 列里面 token。这很慢而且难以扩展：随着词项和文档的数量增加，执行时间也会增加。

Doc values 通过转置两者间的关系来解决这个问题。倒排索引将词项映射到包含它们的文档，doc values 将文档映射到它们包含的词项：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-deqcJ89G-1644556258957)(data:image/png;base64,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)]

当数据被转置之后，想要收集到 Doc_1 和 Doc_2 的唯一 token 会非常容易。获得每个文档行，获取所有的词项，然后求两个集合的并集。

Doc values 可以使聚合更快、更高效并且内存友好。Doc values 的存在是因为倒排索引只对某些操作是高效的。

倒排索引的优势：在于查找包含某个项的文档，而对于从另外一个方向的相反操作并不高效，即：确定哪些项是否存在单个文档里，聚合需要这种访问模式。

在 Elasticsearch 中，Doc Values 就是一种列式存储结构，默认情况下每个字段的 Doc Values 都是激活的，Doc Values 是在索引时创建的。当字段索引时，Elasticsearch 为了能够快速检索，会把字段的值加入倒排索引中，同时它也会存储该字段的 Doc Values。

Elasticsearch 中的 Doc Values 常被应用到以下场景：

  • 对一个字段进行排序
  • 对一个字段进行聚合
  • 某些过滤，比如地理位置过滤
  • 某些与字段相关的脚本计算

因为文档值（doc values）被序列化到磁盘，我们可以依靠操作系统的帮助来快速访问。当 working set 远小于节点的可用内存，系统会自动将所有的文档值保存在内存中，使得其读写十分高速；当其远大于可用内存，操作系统会自动把 Doc Values 加载到系统的页缓存中，从而避免了 jvm 堆内存溢出异常。

因此，搜索和聚合是相互紧密缠绕的。搜索使用倒排索引查找文档，聚合操作收集和聚合 doc values 里的数据。

doc values 支持大部分字段类型，但是text 字段类型不支持（因为analyzed）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LgoL0gRs-1644556258959)(data:image/png;base64,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)]

(1) status_code 字段默认启动 doc_values 属性；

(2) session_id 显式设置 doc_values = false，但是仍然可以被查询；

如果确信某字段不需要排序或者聚合，或者从脚本中访问字段值，那么我们可以设置 doc_values = false，这样可以节省磁盘空间。

3、executionHint

1、global ordinals

（1）what’s this?

当我们使用doc values或者fielddata存储时，在磁盘中存储的值不是真正的字段值，而是一个字典值(ordinal)。当我们进行聚合查询的时候，es会把这个字典值跟真正字段值的映射字典加载到内存中，并对结果集做映射，转化为真正的值。这份映射关系是shard级别的，为这个shard里面是所有segment服务，这也是global的体现。

（2）detail

  • 字典关系是lazy init的，只有第一次使用的时候才会加载到内存中。在es的内存表现中提现成fielddata，这也是全keyword的index为什么也会有fielddata使用的原因。只会加载命中的segment的字典不会加载全部。
  • 字典关系在shard被触发refresh以后就会失效。下次使用的时候需要再重新构建。所以可以提高refresh_interval的值，减少fresh频率提高字典的生存时间。

2、eager_global_ordinals

（1）what’s this？

当在global ordinals的时候，refresh以后下一次查询字典就需要重新构建，在追求查询的场景下很影响查询性能。可以使用eager_global_ordinals，即在每次refresh以后即可更新字典，字典常驻内存，减少了查询的时候构建字典的耗时。

（2）使用场景

因为这份字典需要常驻内存，并且每次refresh以后就会重构，所以增大了内存以及cpu的消耗。推荐在低写高查、数据量不大的index中使用。

（3）使用

PUT my_index/_mapping
{
  "properties": {
    "tags": {
      "type": "keyword",
      "eager_global_ordinals": true
    }
  }}

3、execution_hint

（1）what’ this?

上面介绍了global ordinal的使用场景，是doc_values以及fileddata的默认数据架构。除了这种模式，还可以选择map模式。即不再使用字典而是直接把值加载到内存中计算，减去了构建字典的耗时。当查询的结果集很小的情况下，可以使用map的模式不去构建字典。使用map还是global_ordinals的取决于构建字典的开销与加载原始字典的开销。当结果集大到一定程序，map的内存开销的代价可能抵消了构建字典的开销。

（2）how to use?

GET /_search{
    "aggs" : {
        "tags" : {
             "terms" : {
                 "field" : "tags",
                 "execution_hint": "map" 
             }
         }
    }}

4、Shard Size

为了提高该聚合的精确度，可以通过shard_size参数设置协调节点向各个分片请求的词根个数，然后在协调节点进行聚合，最后只返回size个词根给到客户端，shard_size >= size，如果shard_size设置小于size，ES会自动将其设置为size，默认情况下shard_size建议设置为(1.5 * size + 10)。

三、java实现对Es的curd

 //match查询age是20的条件
 QueryBuilders.matchQuery("age",20);
 
 //term查询age是20的条件
 QueryBuilders.termQuery("age",20);
 
 //terms查询age是20或者200，或者50的条件
 QueryBuilders.termsQuery("age",20,200,50);
 
 //query_string全文检索“xiumu”
 QueryBuilders.queryStringQuery("xiumu");
 
 //query_string检索username是“xiumu”
 QueryBuilders.queryStringQuery("xiumu").field("username");
 
 //multi_match查询字段username或者description的值是xiumu
 QueryBuilders.multiMatchQuery("xiumu","username","description");
 
 //range查询字段age的范围是在[18-200]之间
 QueryBuilders.rangeQuery("age").gte(18).lte(200);
 
 //exits查询字段age有值
 QueryBuilders.existsQuery("age");
 
 //wildcard查询字段description是以“男人”结尾的
 QueryBuilders.wildcardQuery("description","*男人");
 
 //bool查询
 BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
 //bool查询里添加must多个条件
 boolQueryBuilder.must(QueryBuilders.termQuery("age",20));
 boolQueryBuilder.must(QueryBuilders.existsQuery("age"));
 boolQueryBuilder.must(QueryBuilders.wildcardQuery("description","*男人"));
 



（1）统计某个字段的数量
  ValueCountBuilder vcb=  AggregationBuilders.count("count_uid").field("uid");
（2）去重统计某个字段的数量（有少量误差）
 CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
（3）聚合过滤
FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
（4）按某个字段分组
TermsBuilder tb=  AggregationBuilders.terms("group_name").field("name");
（5）求和
SumBuilder  sumBuilder=	AggregationBuilders.sum("sum_price").field("price");
（6）求平均
AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
（7）求最大值
MaxBuilder mb= AggregationBuilders.max("max_price").field("price"); 
（8）求最小值
MinBuilder min=	AggregationBuilders.min("min_price").field("price");
（9）按日期间隔分组
DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
（10）获取聚合里面的结果
TopHitsBuilder thb=  AggregationBuilders.topHits("top_result");
（11）嵌套的聚合
NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
（12）反转嵌套
AggregationBuilders.reverseNested("res_negsted").path("kps ");

package com.robin.elasticsearch;

import com.alibaba.fastjson.JSON;
import com.robin.elasticsearch.common.DataUtil;
import com.robin.elasticsearch.entity.User;
import com.robin.elasticsearch.entity.User2;
import com.robin.elasticsearch.entity.User3;
import com.robin.elasticsearch.reponsity.UserMapper;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.filter.Filters;
import org.elasticsearch.search.aggregations.bucket.filter.FiltersAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.filter.FiltersAggregator;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.elasticsearch.search.aggregations.bucket.histogram.Histogram;
import org.elasticsearch.search.aggregations.bucket.histogram.HistogramAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.range.DateRangeAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.range.IpRangeAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.range.Range;
import org.elasticsearch.search.aggregations.bucket.range.RangeAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.*;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.AggregationsContainer;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.clients.elasticsearch7.ElasticsearchAggregations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

@SpringBootTest
class ESTests {

    @Autowired
    UserMapper userMapper;

    @Autowired
    RestHighLevelClient restHighLevelClient;

    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;


    //创建索引
    @Test
    void createIndex() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("zkwz");
        CreateIndexResponse exists = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
    }

    //删除索引
    @Test
    void isExistIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest("zkwz");
        boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);

    }


    //删除索引
    @Test
    void deleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("user");
        AcknowledgedResponse delete = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());

    }


    //创建文档
    @Test
    void createDoc() throws IOException {
        IndexRequest request = new IndexRequest("user");
        User user = new User("111", "cwx", 23);

        IndexRequest source = request.id("123").source(JSON.toJSONString(user), XContentType.JSON);
        String id = source.id();
        IndexResponse index = restHighLevelClient.index(request, RequestOptions.DEFAULT);
        System.out.println(index);
    }

    //获取文档的信息
    @Test
    void getDocInfo() throws IOException {
        //创建获取文档的请求
        GetRequest request = new GetRequest("user", "123");
        boolean exists = restHighLevelClient.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
        GetResponse documentFields = restHighLevelClient.get(request, RequestOptions.DEFAULT);
        String source = documentFields.getSourceAsString();
        System.out.println(source);
    }

    //根据id更新文档
    @Test
    void updateDocById() throws IOException {
        UpdateRequest request = new UpdateRequest("user", "123");
        request.doc(JSON.toJSONString(new User("111", "cwx", 33)), XContentType.JSON);
        UpdateResponse update = restHighLevelClient.update(request, RequestOptions.DEFAULT);
        RestStatus status = update.status();
        System.out.println(status);
    }

    //根据id删除文档
    @Test
    void deleteDocById() throws IOException {
        DeleteRequest request = new DeleteRequest("user", "123");
        DeleteResponse delete = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
        RestStatus status = delete.status();
        System.out.println(status);
    }

    //批量创建文档
    @Test
    void createDocBulk() throws IOException {
        BulkRequest request = new BulkRequest();
        User user1 = new User("777", "thegoodmen", 30);
        User user2 = new User("888", "thegoodwomen", 50);
        User user3 = new User("999", "thewellboy", 23);
        User user4 = new User("100", "thewellgirl", 43);
        User user5 = new User("121", "thegirlmen", 12);
        ArrayList<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);

        for (User user : list) {
            request.add(new IndexRequest("user").source(JSON.toJSONString(user), XContentType.JSON));
        }

        BulkResponse bulk = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
        boolean status = bulk.hasFailures();
        System.out.println(status);
    }

    //基本查询
    @Test
    void selectByAge() throws IOException {
        SearchRequest request = new SearchRequest();

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //matchQuery是分词之后再查询的、termQuery是直接进行匹配(但是这个查询不到数据，换这个可以matchPhraseQuery)
        MatchQueryBuilder builder = QueryBuilders.matchQuery("name", "good");

        searchSourceBuilder.query(builder);

        request.source(searchSourceBuilder);
        SearchResponse search = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        Iterator<SearchHit> iterator = search.getHits().iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    //单条件查询
    @Test
    void select1() throws IOException {

        //左右模糊查询，相当于MySQL的%good%
        SearchHits<User> searchHits = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.queryStringQuery("good").field("name")),
                User.class,
                IndexCoordinates.of("user"));

        //精准匹配，相当于name="good"
        SearchHits<User> searchHits1 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.termQuery("name", "good")),
                User.class,
                IndexCoordinates.of("user"));

        //普通匹配，相当于name like "%good%"
        SearchHits<User> searchHits2 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.matchQuery("name", "good")),
                User.class,
                IndexCoordinates.of("user"));

        //模糊匹配
        SearchHits<User> searchHits3 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.fuzzyQuery("name", "good")),
                User.class,
                IndexCoordinates.of("user"));


        //前缀匹配
        SearchHits<User> searchHits6 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.prefixQuery("name", "men")),
                User.class,
                IndexCoordinates.of("user"));

        //多字段的模糊匹配
        SearchHits<User> searchHits7 = elasticsearchRestTemplate.search(
                    new NativeSearchQuery(QueryBuilders.multiMatchQuery("aaa", "name")),
                User.class,
                IndexCoordinates.of("user"));


        //前缀匹配
        SearchHits<User> searchHits8 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.wildcardQuery("name", "m*n")),
                User.class,
                IndexCoordinates.of("user"));

        //多内容多字段的模糊匹配
        String[] strings = {"good", "men"};
        SearchHits<User> searchHits9 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.moreLikeThisQuery(new String[]{"aaa"}, MoreLikeThisQueryBuilder.Item.EMPTY_ARRAY)),
                User.class,
                IndexCoordinates.of("user"));


        for (org.springframework.data.elasticsearch.core.SearchHit<User> e1 : searchHits9.getSearchHits()) {
            System.out.println(e1.getContent());
        }


    }


    //多条件查询
    @Test
    void select2() throws IOException {

        //数值型、日期、Ip的范围查询，相当于 between 80 and 90 ，80包含，90不包含
        SearchHits<User> searchHits1 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("age").from(80).to(90).includeLower(true).includeUpper(false))),
                User.class,
                IndexCoordinates.of("user"));

        //范围查询、大于50小于等于90
        SearchHits<User> searchHits2 = elasticsearchRestTemplate.search(
                new NativeSearchQuery(QueryBuilders.boolQuery().must(QueryBuilders.rangeQuery("age").gt(50).lte(90))),
                User.class,
                IndexCoordinates.of("user"));


        for (org.springframework.data.elasticsearch.core.SearchHit<User> e1 : searchHits1.getSearchHits()) {
            System.out.println(e1.getContent());
        }

    }


    //多条件查询
    @Test
    void select3() {

        // 排序
        FieldSortBuilder price = SortBuilders.fieldSort("age").order(SortOrder.DESC);
        // 高亮显示
        HighlightBuilder highlightBuilder = new HighlightBuilder().field("name");
        // 分页
        PageRequest pageRequest = PageRequest.of(0, 2);
        // 查询条件
        BoolQueryBuilder queryBuilder1 = new BoolQueryBuilder().must(new MatchQueryBuilder("name", "陈万祥"));
        BoolQueryBuilder queryBuilder2 = new BoolQueryBuilder().must(new MatchPhraseQueryBuilder("loc", "武威市"));
        BoolQueryBuilder queryBuilder3 = new BoolQueryBuilder().must(QueryBuilders.queryStringQuery("兰州市").field("name"));
        //求和
        SumAggregationBuilder field = AggregationBuilders.sum("sum").field("age");
        //求平均值
        AvgAggregationBuilder avgAggregationBuilder = AggregationBuilders.avg("avg").field("age");

        ValueCountAggregationBuilder countAggregationBuilder = AggregationBuilders.count("count").field("name");
        // 组装上述查询条件
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(queryBuilder1)
                .withSorts(price)
                .withHighlightBuilder(highlightBuilder)
                .withPageable(pageRequest)
                .build();

        NativeSearchQuery searchQuery2 = new NativeSearchQueryBuilder()
                .withAggregations(field)
                .withAggregations(avgAggregationBuilder)
                .withAggregations(countAggregationBuilder)
                .build();

        SearchHits<User2> user = elasticsearchRestTemplate.search(searchQuery, User2.class, IndexCoordinates.of("user"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User2> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
            Map<String, List<String>> highlightFields = hit.getHighlightFields();
            System.out.println(highlightFields.toString());
        }


        AggregationsContainer<?> aggregations = user.getAggregations();

        ElasticsearchAggregations aggregations1 = (ElasticsearchAggregations) aggregations;

        Aggregations aggregations2;
        if (aggregations1 != null) {
            aggregations2 = aggregations1.aggregations();
            Sum sum = aggregations2.get("sum");
            Avg avg = aggregations2.get("avg");
            ValueCount count = aggregations2.get("count");

            System.out.println(DataUtil.rmZeroSuper(sum.getValue()));
            System.out.println(DataUtil.rmZeroSuper(avg.getValue()));
            System.out.println(DataUtil.rmZeroSuper(count.getValue()));
        }


    }

    //最基础的聚合查询
    @Test
    void select4() throws IOException {

        SearchRequest request = new SearchRequest("user");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        sourceBuilder.query(QueryBuilders.matchQuery("name", "yyy"));

        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("ageAvg").field("age").size(10);

        sourceBuilder.aggregation(termsAggregationBuilder);


        AvgAggregationBuilder sumAggregationBuilder = AggregationBuilders.avg("avg").field("age");

        sourceBuilder.aggregation(sumAggregationBuilder);

        request.source(sourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(request, RequestOptions.DEFAULT);

        Aggregations aggregations = searchResponse.getAggregations();


        Avg ageAvg = aggregations.get("avg");

        System.out.println(ageAvg.getValue());


        Terms terms = aggregations.get("ageAvg");


        for (Terms.Bucket e1 : terms.getBuckets()) {
            System.out.println("年龄是" + e1.getKeyAsString() + "=====>" + "人数是" + e1.getDocCount());
        }

    }


    //先分组再得到不同分组的指标查询
    @Test
    void select5() {

        //先分组，并按指标排序
        TermsAggregationBuilder termsAggregationBuilder1 = AggregationBuilders.terms("team_count").field("team").order(BucketOrder.aggregation("max_age", true));
        termsAggregationBuilder1.subAggregation(AggregationBuilders.max("max_age").field("age"));
        termsAggregationBuilder1.subAggregation(AggregationBuilders.avg("avg_age").field("age"));
        termsAggregationBuilder1.subAggregation(AggregationBuilders.min("min_age").field("age"));
        termsAggregationBuilder1.subAggregation(AggregationBuilders.sum("sum_age").field("age"));


        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(termsAggregationBuilder1)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
        }

        AggregationsContainer<?> aggregations = user.getAggregations();

        ElasticsearchAggregations aggregations1 = (ElasticsearchAggregations) aggregations;

        Aggregations aggregations2;
        if (aggregations1 != null) {
            aggregations2 = aggregations1.aggregations();
            Terms terms = aggregations2.get("team_count");

            //获取聚合值的两种方法
            for (Terms.Bucket bucket : terms.getBuckets()) {
                Max max_age = bucket.getAggregations().get("max_age");
                Min min_age = bucket.getAggregations().get("min_age");
                Sum sum_age = bucket.getAggregations().get("sum_age");
                Avg avg_age = bucket.getAggregations().get("avg_age");

                System.out.println(bucket.getKeyAsString() + "的最大值是：" + max_age.getValue() + "的最小值是：" + min_age.getValue() + "的和是：" + sum_age.getValue() + "的平均值是：" + avg_age.getValue());
            }

            for (Terms.Bucket bucket : terms.getBuckets()) {
                Map<String, Aggregation> asMap = bucket.getAggregations().asMap();
                double max_age = ((ParsedMax) asMap.get("max_age")).getValue();
                double min_age = ((ParsedMin) asMap.get("min_age")).getValue();
                double sum_age = ((ParsedSum) asMap.get("sum_age")).getValue();
                double avg_age = ((ParsedAvg) asMap.get("avg_age")).getValue();

                System.out.println(bucket.getKeyAsString() + "的最大值是：" + max_age + "的最小值是：" + min_age + "的和是：" + sum_age + "的平均值是：" + avg_age);
            }
        }


    }


    //区间分组查询
    @Test
    void select6() {

        HistogramAggregationBuilder histogramAggregationBuilder = AggregationBuilders.histogram("his_age").field("age").interval(10);


        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(histogramAggregationBuilder)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
        }

        AggregationsContainer<?> aggregations = user.getAggregations();

        ElasticsearchAggregations aggregations1 = (ElasticsearchAggregations) aggregations;

        Aggregations aggregations2;
        if (aggregations1 != null) {
            aggregations2 = aggregations1.aggregations();
            Histogram terms = aggregations2.get("his_age");
            for (Histogram.Bucket bucket : terms.getBuckets()) {
                System.out.println(bucket.getKeyAsString() + "的数量是：" + bucket.getDocCount());
            }
        }
    }

    //时间区间分组查询
    @Test
    void select7() {


        /*
          calendarInterval表示时间间隔是类型、minDocCount设置最小值、format设置输出时间的格式化、
          missing当那个统计字段为null的时候，填充某个值，然后按照填充的值，统计计算
         */

        DateHistogramAggregationBuilder aggregationBuilder = AggregationBuilders.dateHistogram("his_birth")
                .field("birth")
                .calendarInterval(DateHistogramInterval.MONTH)
                .minDocCount(0)
                .format("yyyy-MM-dd")
                .missing("2021-07-27");

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(aggregationBuilder)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
        }

        ElasticsearchAggregations aggregations = (ElasticsearchAggregations) user.getAggregations();

        if (aggregations != null) {
            Histogram terms = aggregations.aggregations().get("his_birth");
            for (Histogram.Bucket bucket : terms.getBuckets()) {
                System.out.println(bucket.getKeyAsString() + "的数量是：" + bucket.getDocCount());
            }
        }
    }

    //指定范围区间分组查询
    @Test
    void select8() {


        /*
          calendarInterval表示时间间隔是类型、minDocCount设置最小值、format设置输出时间的格式化、
          missing当那个统计字段为null的时候，填充某个值，然后按照填充的值，统计计算
         */

        RangeAggregationBuilder aggregationBuilder = AggregationBuilders.range("range_age")
                .field("age")
                .addUnboundedTo(10)
                .addRange(11, 30)
                .addRange(31, 50)
                .addUnboundedFrom(100);

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(aggregationBuilder)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
        }

        ElasticsearchAggregations aggregations = (ElasticsearchAggregations) user.getAggregations();

        if (aggregations != null) {
            Range terms = aggregations.aggregations().get("range_age");
            for (Range.Bucket bucket : terms.getBuckets()) {
                System.out.println(bucket.getKeyAsString() + "的数量是：" + bucket.getDocCount());
                //起始范围值
                Object from = bucket.getFrom();
                //终止范围值
                Object to = bucket.getTo();
                System.out.println(from + "\t" + to);
            }
        }
    }

    //指定时间范围区间分组查询
    @Test
    void select9() {

        DateRangeAggregationBuilder aggregationBuilder = AggregationBuilders.dateRange("data_range_birth")
                .field("birth")
                .format("yyyy")
                .addUnboundedTo("2000")
                .addRange("2001", "2010")
                .addRange("2011", "2020")
                .addUnboundedFrom("2021");

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(aggregationBuilder)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
        }

        ElasticsearchAggregations aggregations = (ElasticsearchAggregations) user.getAggregations();

        if (aggregations != null) {
            Range terms = aggregations.aggregations().get("data_range_birth");
            for (Range.Bucket bucket : terms.getBuckets()) {
                System.out.println(bucket.getKeyAsString() + "的数量是：" + bucket.getDocCount());
            }
        }
    }


    //指定ip区间分组查询
    @Test
    void select10() {

        //TODO 这个地方的ip类型不能用来聚合，加上.keyword也不行，不知如何解决
        IpRangeAggregationBuilder aggregationBuilder = AggregationBuilders.ipRange("ip_range")
                .field("ip")
                .addUnboundedTo("192.168.0.0")
                .addRange("192.168.0.1", "192.168.0.122")
                .addRange("192.168.5.0", "192.168.7.134")
                .addUnboundedFrom("192.168.12.122");

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(aggregationBuilder)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            System.out.println(hit.getContent());
        }

        ElasticsearchAggregations aggregations = (ElasticsearchAggregations) user.getAggregations();

        if (aggregations != null) {
            Range terms = aggregations.aggregations().get("ip_range");
            for (Range.Bucket bucket : terms.getBuckets()) {
                System.out.println(bucket.getKeyAsString() + "的数量是：" + bucket.getDocCount());
            }
        }
    }

    //指定过滤条件分组查询
    @Test
    void select11() {
        FiltersAggregationBuilder aggregationBuilder = AggregationBuilders.filters("filter",
                new FiltersAggregator.KeyedFilter("men", QueryBuilders.termQuery("sex", "true")),
                new FiltersAggregator.KeyedFilter("women", QueryBuilders.termQuery("sex", "false")));

        // 高亮显示
        HighlightBuilder highlightBuilder = new HighlightBuilder().field("sex").preTags("<red>").postTags("</red>");

        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withAggregations(aggregationBuilder)
                .withHighlightBuilder(highlightBuilder)
                .build();

        SearchHits<User3> user = elasticsearchRestTemplate.search(searchQuery, User3.class, IndexCoordinates.of("user1"));
        for (org.springframework.data.elasticsearch.core.SearchHit<User3> hit : user.getSearchHits()) {
            Map<String, List<String>> highlightFields = hit.getHighlightFields();
            System.out.println(hit.getContent());
            System.out.println(highlightFields.toString());
        }

        ElasticsearchAggregations aggregations = (ElasticsearchAggregations) user.getAggregations();

        if (aggregations != null) {
            Filters terms = aggregations.aggregations().get("filter");
            for (Filters.Bucket bucket : terms.getBuckets()) {
                System.out.println(bucket.getKeyAsString() + "的数量是：" + bucket.getDocCount());
            }
        }

    }


}

四、命令的方式实现对Es的curd

DELETE /user3

PUT /user
{
  "settings": {
    "number_of_replicas": 2,
    "number_of_shards": 3
  }, 
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "sex":{
        "type": "boolean"
      },
      "age":{
        "type": "long"
      },
      "loc":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "team":{
        "type": "keyword"
      },
      "birth":{
        "type": "date"
      },
      "id":{
        "type": "ip"
      },
      "country":{
        "type": "keyword"
      },
      "habby":{
        "type": "text"
      },
      "balance":{
        "type": "float"
      }
    }
  }
}

POST /user/_doc/
{
  "name":"陈万祥",
  "age":12,
  "sex":true,
  "loc":"甘肃省武威市",
  "team":"red",
  "birth":"1998-01-10",
  "ip":"192.168.0.3",
  "country":"china",
  "habby":["basketball","sing","dance"],
  "balance":8700.12
}

POST /user/_doc/
{
  "name":"陈万祥",
  "age":122,
  "sex":true,
  "loc":"甘肃省武威市",
  "team":"blue",
  "birth":"1998-01-10",
  "ip":"192.168.0.",
  "country":"france",
  "habby":["basketball","sing"],
  "balance":82111
}

POST /user/_doc/
{
  "name":"劳霞明",
  "age":21,
  "sex":true,
  "loc":"广西钦州市",
  "team":"red",
  "birth":"1997-01-10",
  "ip":"192.168.3.11",
  "country":"china",
  "habby":["swming","dance"],
  "balance":800.12
}

POST /user/_doc/
{
  "name":"汪明",
  "age":24,
  "sex":false,
  "loc":"天津市",
  "team":"green",
  "birth":"1998-02-10",
  "ip":"192.165.0.3",
  "country":"china",
  "habby":["sing","read"],
  "balance":9000
}


POST /user/_doc/
{
  "name":"蔡徐坤",
  "age":12,
  "sex":true,
  "loc":"甘肃省兰州市",
  "team":"green",
  "birth":"1998-03-10",
  "ip":"192.167.0.0",
  "country":"france",
  "habby":["game","eat"],
  "balance":2300
}

POST /user/_doc/
{
  "name":"爱英斯坦",
  "age":45,
  "sex":true,
  "loc":"甘肃省张掖市",
  "team":"blue",
  "birth":"2003-06-10",
  "ip":"192.168.0.32",
  "country":"england",
  "habby":["basketball","sing","dance"],
  "balance":6900
}

POST /user/_doc/
{
  "name":"欧拉",
  "age":65,
  "sex":false,
  "loc":"甘肃省天水市",
  "team":"blue",
  "birth":"2021-08-10",
  "ip":"192.168.6.3",
  "country":"china",
  "habby":["basketball","dance"],
  "balance":4300
}
POST /user/_doc/
{
  "name":"上帝",
  "age":22,
  "sex":false,
  "loc":"西方世界",
  "team":"black",
  "ip":"192.168.3.3",
  "country":"england",
  "habby":["eat","game","sing"],
  "balance":12000.12
}

GET /user/_doc/_search

GET /user/_doc/_search
{
  "query":{
    "term":{
      "name":"陈万祥"
    }
  },
  "from":0,
  "size":10,
  "sort":[{
    "age":"desc"
  }],
  "highlight":{
    "fields":{
      "name":{}
    }
  }
}

#求出user索引的和
GET /user/_doc/_search
{
  "aggs":{
    "user1_sum":{
      "sum":{
        "field":"age"
      }
    }
  }
}

#求出user索引的最大值
GET /user/_doc/_search
{
  "size":0,
  "aggs":{
    "user1_max":{
      "max":{
        "field":"age"
      }
    }
  }
}

#根据team字段聚合分组、并得到每个分组的求和、最大值、最小值、平均值
GET /user/_doc/_search
{
  "size":0,
  "aggs":{
    "user1_term":{
      "terms":{
        "field":"team"
      },
      "aggs":{
        "term_sum":{
          "sum":{
          "field":"age"
        }
        },
        "term_max":{
          "max":{
          "field":"age"
        }},
        "term_min":{
          "min":{
          "field":"age"
        }},
        "term_avg":{
          "avg":{
          "field":"age"
        }}
      }
    }
  }
}

#查看工资范围的百分比
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "balance_a": {
      "percentile_ranks": {
        "field": "balance",
        "values": [2000,4000,6000,8000,10000]
      }
    }
  }
}

#查看一些计数、最小值、最大值、平均值、求和分别是多少
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "balance_a": {
      "stats": {
        "field": "balance"
      }
    }
  }
}

#查看一些其他的指标结果
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "balance_a": {
      "extended_stats": {
        "field": "age"
      }
    }
  }
}

#查看对字段sex的聚合
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "sex_a": {
      "terms": {
        "field": "sex"
      }
    }
  }
}

#聚合并排序
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "sex_a": {
      "terms": {
        "field": "team",
        "order": {
          "max_a": "desc"
        }
      },
        "aggs":{
          "max_a":{
            "max":{
              "field": "age"
            }
          }
        }
      
    }
  }
}

#聚合支持脚本
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "sex_a": {
      "terms": {
        "script": "doc['team'].value"
      }
    }
  }
}

#筛选出包含指定词语和不包含的
GET /user/_search
{
  "size": 0, 
  "aggs": {
    "term_a": {
      "terms": {
        "field": "age",
        "include": "*.市"
      }
    }
  }
}


#------------------------------------------------
DELETE user3


#多字段聚合的实现方式：
#1、通过脚本合并字段
#2、使用copy_to方法合并两个字段

PUT /user3
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "fielddata": true
        
      }
    }
  }
}

PUT /user3
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "fields": {
          "keyword":{
            "type":"keyword"
          }
        }
      }
    }
  }
}

POST /user3/_doc
{
  "name":"hello word"
}

GET /user3/_search
{
  "query": {
    "match": {
      "name": "hello"
    }
  }, 
  "aggs":{
    "testq":{
      "terms":{
        "field":"name.keyword"
      }
    }
  }
}


PUT test3

POST test3/stu
{
  "name":"cwx"
}

POST test3/tes
{
  "name":"lxm"
}

五、集群

六、优化

1、聚合为什么慢？

大多数时候对单个字段的聚合查询还是非常快的， 但是当需要同时聚合多个字段时，就可能会产生大量的分组，最终结果就是占用 es 大量内存，从而导致 OOM 的情况发生。
实践应用发现，以下情况都会比较慢：
1）待聚合文档数比较多（千万、亿、十亿甚至更多）；
2）聚合条件比较复杂（多重条件聚合）；
3）全量聚合（翻页的场景用）。

2、聚合优化方案探讨

参考链接：https://blog.csdn.net/laoyang360/article/details/79253294

优化方案一：默认深度优先聚合改为广度优先聚合。

"collect_mode" : "breadth_first"

depth_first 直接进行子聚合的计算
breadth_first 先计算出当前聚合的结果，针对这个结果在对子聚合进行计算。
优化方案二： 每一层terms aggregation内部加一个 “execution_hint”: “map”。

 "execution_hint": "map"

Map方式的结论可简要概括如下：
1）查询结果直接放入内存中构建map，在查询结果集小的场景下，速度极快；
2）但如果待结果集合很大的情况，map方式不一定也快。

3、运用 shard_size 来提高 term aggregation 的精度

参考链接：https://blog.csdn.net/UbuntuTouch/article/details/104141398

请求的大小（size）越大，结果将越准确，但计算最终结果的成本也将越高（这两者都是由于在分片级别上管理的优先级队列更大，并且节点和客户端之间的数据传输也更大）。

shard_size 参数可用于最大程度地减少请求的大小带来的额外工作。 定义后，它将确定协调节点将从每个分片请求多少个术语。 一旦所有分片都做出响应，协调节点便会将它们缩减为最终结果，该最终结果将基于size参数-这样一来，可以提高返回条款的准确性，并避免流回大量存储桶的开销给客户。

注意：shard_size 不能小于 size（因为意义不大）。 启用时，Elasticsearch 将覆盖它并将其重置为等于大小。

缺省 shard_size为（size* 1.5 + 10）。

Terms aggregation 对于大量数据来说通常是不精确的

我们先来看一下如下的一个图：

https://img-blog.csdnimg.cn/20200202090259391.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9lbGFzdGljc3RhY2suYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70

从上面的图中，在 shard_size 为3的情况下，我们想对 geoip.country_name 这个字段来进行 terms aggregation：

从 shard 0 中提取文档数靠前的前三个，它们分别是 USA，India 及 France。它们的文档数分别是5，4及4。
从 shard 1 中提取文档数靠前的前单个，它们分别是 USA，India 及 Japan。它们的文档数分别是4，5及3。
那么总的文档数是：

USA为：5 + 4 = 9
India为：4 + 5 = 9
France为：4 + 0 = 4
Japan为： 3 + 0 = 3

根据上面的计算，返回的结果将会是 USA，India 及 France。细心的开发者可能马上可以看出来，在上面的统计中国其实是不精确的，这是因为在 shard 0 中，我们可以看见 Japan 有3个文档没有被统计进去。这个统计是基于我们对 shard_size 为3的情况。假如我们把 shard_size 提供到4，情况马上就会不同，而且更加接近我们的实际的统计数据的结果。在这种情况下，Japan 将会有 3 + 6 共6很个文档，应该是排名第3。

我们可以修改我们的请求如下：

GET logs_server*/_search
{
  "size": 0,
  "aggs": {
    "top_10_urls": {
      "terms": {
        "field": "geoip.country_name.keyword",
        "size": 10,
        "shard_size": 100
      }
    }
  }
}

我们可以通过增加 shard_size 来提高数据的精确性，但是必须注意的是这样的代价是计算的成本增加，特别是针对大量数据而言。