精华内容
下载资源
问答
  • Elasticsearch聚合后分页深入详解

    万次阅读 2018-01-20 11:18:58
    1、Elasticsearch支持聚合后分页吗,为什么? 不支持,看看Elasticsearch员工如何解读。 这个问题,2014年在github上有很长的讨论。究其为什么ES不支持聚合后分页?可概括如下: 1)性能角度——聚合分页会在...

    Elasticsearch 最少必要知识实战教程直播回放

    1、Elasticsearch支持聚合后分页吗,为什么?

    不支持,看看Elasticsearch员工如何解读。
    这里写图片描述
    这里写图片描述
    这个问题,2014年在github上有很长的讨论。究其为什么ES不支持聚合后分页?可概括如下:
    1)性能角度——聚合分页会在大量的记录中产生性能问题。
    2)正确性角度——聚合的文档计数不准确。
    所以奇怪的事情可能会发生,如第二页的第一项具有比第一页的最后一个元素更高的计数。

    具体为什么会不正确?
    这是因为每个分片都提供了自己对有序列表应该是什么的看法,并将这些列表结合起来给出最终的结果值。
    举例如下:
    对于如下的聚合:聚合出产品数据量的前5名

    GET /_search
    {
       "aggs" : {
           "products" : {
               "terms" : {
                   "field" : "product",
                   "size" : 5
               }
           }
       }
    }
    

    步骤1: 三个分片的统计计数如下:
    这里写图片描述
    步骤2:各分片取前5名。
    这里写图片描述
    步骤3:依据各分片前5名,聚合得出总前5名。
    这里写图片描述
    仅以产品C的排名作为举例,产品C(50个)的数据来自分片A(6个)和分片C(44个)之和。
    所以,排名第三。
    实际产品C在分片B中还存在4个,只不过这四个按照排名处于第10位,取前5的时候,显然取不到。
    所以,导致聚合结果不准确。
    官网有详细举例解读。

    2、Elasticsearch要实现聚合后分页,该怎么办?

    方案:需要展示满足条件的全部数据条数,即需要全量聚合,且按照某规则排序。
    记住,如果数据基数大(十万、百万甚至千万级),这必然会很慢。

    **步骤1:**全量聚合,size设置为: 2147483647。
    ES5.X/6.X版本设置为2147483647 ,它等于2^31-1,
    是32位操作系统中最大的符号型整型常量;ES1.X 2.X版本设置为0。

    **步骤2:**将聚合结果存入内存中,可以考虑list或map存储。
    这里存入list的_id是基于某种规则排序过的,如:基于插入时间。

    **步骤3:**内存内分页,基于list中存储值结合偏移值进行筛选。
    如每页10条数据,取第一页就是:取list中第0到第9个元素,以此类推。

    **步骤4:**基于筛选出的值进行二次查询获取详情。
    此处的筛选条件已经能唯一确定一篇document。

    3、“聚合后不能分页,但能分区来取",是什么鬼?

    这里写图片描述
    貌似,没有起到分页的作用。此处没有深入研究。

    4、聚合后分页实战

    步骤1:建立索引

    PUT book_index
    {
      "mappings": {
      "book_type": {
      "properties": {
      "_key": {
      "type": "keyword",
      "ignore_above": 256
      },
    
      "pt": {
      "type": "date"
      },
    
      "url": {
      "type": "keyword",
      "ignore_above": 256
      },
      "title": {
      "type": "text",
      "term_vector": "with_positions_offsets",
      "fields": {
      "keyword": {
      "type": "keyword",
      "ignore_above": 256
      }
      },
      "analyzer": "ik_smart"
      },
      "abstr": {
      "type": "text",
      "term_vector": "with_positions_offsets",
      "fields": {
      "keyword": {
      "type": "keyword",
      "ignore_above": 256
      }
      },
      "analyzer": "ik_smart"
      },
      "rplyinfo": {
      "type": "text",
      "term_vector": "with_positions_offsets",
      "fields": {
      "keyword": {
      "type": "keyword",
      "ignore_above": 256
      }
      },
      "analyzer": "ik_smart"
      },
      "author": {
      "type": "keyword",
      "ignore_above": 256
      },
      "booktype": {
      "type": "keyword",
      "ignore_above": 256
      },
      "price": {
      "type": "long"
      }
      }
      }
      }
    }
    

    步骤2:导入数据

    举例原因,假设后来导入百万甚至千万级别数据。

    	POST book_index/book_type/1
    	{
    	 "title":"《Elasticsearch深入理解》",
    	 "author":"ERicif",
    	 "abstr":"Elasticsearch实战书籍",
    	 "relyinfo":"不错,值得推荐",
    	 "booktype":"技术",
    	 "price":79,
    	 "pt":1543611840000
    	}
    POST book_index/book_type/2
    {
      "title":"《大数据之路》",
      "author":"阿里巴巴",
      "abstr":"大数据实现",
      "relyinfo":"不错,值得推荐2",
      "booktype":"技术",
      "price":89,
      "pt":1543011840000
    }
    
    POST book_index/book_type/3
    {
      "title":"《人性的弱点》",
      "author":"卡耐基",
      "abstr":"直击人性",
      "relyinfo":"不错,值得推荐2",
      "booktype":"励志",
      "price":59,
      "pt":1543101840000
    }
    
    POST book_index/book_type/4
    {
      "title":"《Flow案例精编》",
      "author":"ERicif",
      "abstr":"Flow案例",
      "relyinfo":"还可以",
      "booktype":"技术",
      "price":57,
      "pt":1543201840000
    }
    
    POST book_index/book_type/5
    {
      "title":"《kibana案例精编》",
      "author":"ERicif",
      "abstr":"kibana干货",
      "relyinfo":"还可以,不孬",
      "booktype":"技术",
      "price":53,
      "pt":1480539840000
    }
    

    步骤3:聚合

    要求:按照以下条件聚合
    1)相同作者出书量;(聚合)
    2)相同作者的书,取时间最大的返回。(聚合后排序)

    		POST book_index/_search
    		{
    		  "sort": [
    		  {
    		  "pt": "desc"
    		  }
    		  ],
    		  "aggs": {
    		  "count_over_sim": {
    		  "terms": {
    		  "field": "author",
    		  "size": 2147483647,
    		  "order": {
    		  "pt_order": "desc"
    		  }
    		  },
    		  "aggs": {
    		  "pt_order": {
    		  "max": {
    		  "field": "pt"
    		  }
    		  }
    		  }
    		  }
    		  },
    		  "query": {
    		  "bool": {
    		  "must": [
    		  {
    		  "bool": {
    		  "should": [
    		  {
    		  "match": {
    		  "booktype": "技术"
    		  }
    		  }
    		  ]
    		  }
    		  },
    		  {
    		  "range": {
    		  "pt": {
    		  "gte": 1451595840000,
    		  "lte": 1603201840000
    		  }
    		  }
    		  }
    		  ]
    		  }
    		  },
    		  "_source": {
    		  "includes": [
    		  "title",
    		  "abstr",
    		  "pt",
    		  "booktype",
    		  "author"
    		  ]
    		  },
    		  "from": 0,
    		  "size": 10,
    		  "highlight": {
    		  "pre_tags": [
    		  "<span style=\"color:red\">"
    		  ],
    		  "post_tags": [
    		  "</span>"
    		  ],
    		  "fields": {
    		  "title": {}
    		  }
    		  }
    		}
    

    步骤4:获取关键信息存入list。

    步骤5:二次遍历+偏移截取分页实现。

    #5、Elasticsearch聚合+分页速度慢,该如何优化?
    优化方案:改为广度搜索方式。
    “collect_mode” : “breadth_first”,
    [ES官网]如果数据量越大,那么默认的使用深度优先的聚合模式生成的总分组数就会非常多,但是预估二级的聚合字段分组后的数据量相比总的分组数会小很多所以这种情况下使用广度优先的模式能大大节省内存,从而通过优化聚合模式来大大提高了在某些特定场景下聚合查询的成功率。

    6、小结

    待聚合的大小size取值越大,结果就越精确,而且计算最终结果的代价也越高;
    耗时主要体现在:
    第一:分片级别巨大的优先级队列的管理成本;
    第二:集群节点和客户端之间的数据传输成本。

    7、认知升级

    思路优化:
    1、聚合后分页的实现通过topHits Agg方式,而非term Agg。
    好处:
    1)支持自定义返回字段:_source 方式定义。
    2)聚合后返回结果,而非二次再检索。

    具体实现:

    步骤1:结合原来query实现topHits聚合;并指定待返回字段。

    步骤2:考虑分页实现,采取from+size的实现方式。

    假定每页限定10条数据,可自定义。
    1)取第1-10条,page=1, size=10;top_hits聚合传入的参数是10(10=page*size);

    2)取第11—20条,page=2,size=10; top_hits聚合传入的参数是20(20=page*size);
    此时,注意:会聚合生成top20的数据,返回给前端的时候,返回最后size条数据;

    3)取最后一页,最后几条数据,不一定是10(<=10)条。
    举例:假定共187条数据,共应该分成18+1=19页。
    最后一页,请求:page=19,size=187-(page-1)size=7页。
    top_hits聚合传入的参数是:190(190=page
    size)。

    步骤3:组合数据json串,返回给前端。

    参考:

    [1]Git解读:http://t.cn/RQpTzSH
    [2]广度优先遍历:http://t.cn/RHndSgY
    [3]分区聚合:http://t.cn/RQpTbdO

    ——————————————————————————————————
    更多ES相关实战干货经验分享,请扫描下方【铭毅天下】微信公众号二维码关注。
    (每周至少更新一篇!)

    这里写图片描述
    和你一起,死磕Elasticsearch
    ——————————————————————————————————

    2018-1-20
    作者:铭毅天下
    转载请标明出处,原文地址:
    http://blog.csdn.net/laoyang360/article/details/79112946
    如果感觉本文对您有帮助,请点击‘顶’支持一下,您的支持是我坚持写作最大的动力,谢谢!

    展开全文
  • 一、聚合分析简介  1. ES聚合分析是什么? 聚合分析是数据库中重要的功能特性,完成对一个查询的数据集中数据的聚合计算,如:找出某字段(或计算表达式的结果)的最大值、最小值,计算和、平均值等。ES作为搜索...

    一、聚合分析简介

     1. ES聚合分析是什么?

    聚合分析是数据库中重要的功能特性,完成对一个查询的数据集中数据的聚合计算,如:找出某字段(或计算表达式的结果)的最大值、最小值,计算和、平均值等。ES作为搜索引擎兼数据库,同样提供了强大的聚合分析能力。

    对一个数据集求最大、最小、和、平均值等指标的聚合,在ES中称为指标聚合   metric

    而关系型数据库中除了有聚合函数外,还可以对查询出的数据进行分组group by,再在组上进行指标聚合。在 ES 中group by 称为分桶桶聚合 bucketing

    ES中还提供了矩阵聚合(matrix)、管道聚合(pipleline),但还在完善中。 

     2. ES聚合分析查询的写法

     在查询请求体中以aggregations节点按如下语法定义聚合分析:

    复制代码

    "aggregations" : {
        "<aggregation_name>" : { <!--聚合的名字 -->
            "<aggregation_type>" : { <!--聚合的类型 -->
                <aggregation_body> <!--聚合体:对哪些字段进行聚合 -->
            }
            [,"meta" : {  [<meta_data_body>] } ]? <!--元 -->
            [,"aggregations" : { [<sub_aggregation>]+ } ]? <!--在聚合里面在定义子聚合 -->
        }
        [,"<aggregation_name_2>" : { ... } ]*<!--聚合的名字 -->
    }

    复制代码

     说明:

    aggregations 也可简写为 aggs

     3. 聚合分析的值来源

    聚合计算的值可以取字段的值,也可是脚本计算的结果

    二、指标聚合

    1. max min sum avg

    示例1:查询所有客户中余额的最大值

    复制代码

    POST /bank/_search?
    {
      "size": 0, 
      "aggs": {
        "masssbalance": {
          "max": {
            "field": "balance"
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 2080,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "masssbalance": {
          "value": 49989
        }
      }
    }

    复制代码

    示例2:查询年龄为24岁的客户中的余额最大值

    复制代码

    POST /bank/_search?
    {
      "size": 2, 
      "query": {
        "match": {
          "age": 24
        }
      },
      "sort": [
        {
          "balance": {
            "order": "desc"
          }
        }
      ],
      "aggs": {
        "max_balance": {
          "max": {
            "field": "balance"
          }
        }
      }
    }

    复制代码

     结果2:

    复制代码

    {
      "took": 5,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 42,
        "max_score": null,
        "hits": [
          {
            "_index": "bank",
            "_type": "_doc",
            "_id": "697",
            "_score": null,
            "_source": {
              "account_number": 697,
              "balance": 48745,
              "firstname": "Mallory",
              "lastname": "Emerson",
              "age": 24,
              "gender": "F",
              "address": "318 Dunne Court",
              "employer": "Exoplode",
              "email": "malloryemerson@exoplode.com",
              "city": "Montura",
              "state": "LA"
            },
            "sort": [
              48745
            ]
          },
          {
            "_index": "bank",
            "_type": "_doc",
            "_id": "917",
            "_score": null,
            "_source": {
              "account_number": 917,
              "balance": 47782,
              "firstname": "Parks",
              "lastname": "Hurst",
              "age": 24,
              "gender": "M",
              "address": "933 Cozine Avenue",
              "employer": "Pyramis",
              "email": "parkshurst@pyramis.com",
              "city": "Lindcove",
              "state": "GA"
            },
            "sort": [
              47782
            ]
          }
        ]
      },
      "aggregations": {
        "max_balance": {
          "value": 48745
        }
      }
    }

    复制代码

     示例3:值来源于脚本,查询所有客户的平均年龄是多少,并对平均年龄加10

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "avg_age": {
          "avg": {
            "script": {
              "source": "doc.age.value"
            }
          }
        },
        "avg_age10": {
          "avg": {
            "script": {
              "source": "doc.age.value + 10"
            }
          }
        }
      }
    }

    复制代码

     结果3:

    复制代码

    {
      "took": 86,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "avg_age": {
          "value": 30.171
        },
        "avg_age10": {
          "value": 40.171
        }
      }
    }

    复制代码

     示例4:指定field,在脚本中用_value 取字段的值

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "sum_balance": {
          "sum": {
            "field": "balance",
            "script": {
                "source": "_value * 1.03"
            }
          }
        }
      }
    }

    复制代码

     结果4:

    复制代码

    {
      "took": 165,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "sum_balance": {
          "value": 26486282.11
        }
      }
    }

    复制代码

     示例5:为没有值字段指定值。如未指定,缺失该字段值的文档将被忽略。

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "avg_age": {
          "avg": {
            "field": "age",
            "missing": 18
          }
        }
      }
    }

    复制代码

     2. 文档计数 count

     示例1:统计银行索引bank下年龄为24的文档数量

    复制代码

    POST /bank/_doc/_count
    {
      "query": {
        "match": {
          "age" : 24
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "count": 42,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      }
    }

    复制代码

     3. Value count 统计某字段有值的文档数

    示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_count": {
          "value_count": {
            "field": "age"
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 2022,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_count": {
          "value": 1000
        }
      }
    }

    复制代码

     4. cardinality  值去重计数

    示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_count": {
          "cardinality": {
            "field": "age"
          }
        },
        "state_count": {
          "cardinality": {
            "field": "state.keyword"
          }
        }
      }
    }

    复制代码

     说明:state的使用它的keyword版

     结果1:

    复制代码

    {
      "took": 2074,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "state_count": {
          "value": 51
        },
        "age_count": {
          "value": 21
        }
      }
    }

    复制代码

     5. stats 统计 count max min avg sum 5个值

     示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_stats": {
          "stats": {
            "field": "age"
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 7,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_stats": {
          "count": 1000,
          "min": 20,
          "max": 40,
          "avg": 30.171,
          "sum": 30171
        }
      }
    }

    复制代码

     6. Extended stats

    高级统计,比stats多4个统计结果: 平方和、方差、标准差、平均值加/减两个标准差的区间

     示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_stats": {
          "extended_stats": {
            "field": "age"
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 7,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_stats": {
          "count": 1000,
          "min": 20,
          "max": 40,
          "avg": 30.171,
          "sum": 30171,
          "sum_of_squares": 946393,
          "variance": 36.10375899999996,
          "std_deviation": 6.008640362012022,
          "std_deviation_bounds": {
            "upper": 42.18828072402404,
            "lower": 18.153719275975956
          }
        }
      }
    }

    复制代码

     7. Percentiles 占比百分位对应的值统计

    对指定字段(脚本)的值按从小到大累计每个值对应的文档数的占比(占所有命中文档数的百分比),返回指定占比比例对应的值。默认返回[ 1, 5, 25, 50, 75, 95, 99 ]分位上的值。如下中间的结果,可以理解为:占比为50%的文档的age值 <= 31,或反过来:age<=31的文档数占总命中文档数的50%

     示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_percents": {
          "percentiles": {
            "field": "age"
          }
        }
      }
    }

    复制代码

    结果1:

    复制代码

    {
      "took": 87,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_percents": {
          "values": {
            "1.0": 20,
            "5.0": 21,
            "25.0": 25,
            "50.0": 31,
            "75.0": 35.00000000000001,
            "95.0": 39,
            "99.0": 40
          }
        }
      }
    }

    复制代码

     结果说明:

    占比为50%的文档的age值 <= 31,或反过来:age<=31的文档数占总命中文档数的50%

     示例2:指定分位值

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_percents": {
          "percentiles": {
            "field": "age",
            "percents" : [95, 99, 99.9] 
          }
        }
      }
    }

    复制代码

     结果2:

    复制代码

    {
      "took": 8,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_percents": {
          "values": {
            "95.0": 39,
            "99.0": 40,
            "99.9": 40
          }
        }
      }
    }

    复制代码

     8. Percentiles rank 统计值小于等于指定值的文档占比

     示例1:统计年龄小于25和30的文档的占比,和第7项相反

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "gge_perc_rank": {
          "percentile_ranks": {
            "field": "age",
            "values": [
              25,
              30
            ]
          }
        }
      }
    }

    复制代码

    结果2:

    复制代码

    {
      "took": 8,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "gge_perc_rank": {
          "values": {
            "25.0": 26.1,
            "30.0": 49.2
          }
        }
      }
    }

    复制代码

     结果说明:年龄小于25的文档占比为26.1%,年龄小于30的文档占比为49.2%,

     9. Geo Bounds aggregation 求文档集中的地理位置坐标点的范围

    参考官网链接:

    https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-geobounds-aggregation.html

    10. Geo Centroid aggregation  求地理位置中心点坐标值

    参考官网链接:

    https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-geocentroid-aggregation.html

    三、桶聚合

     

    1. Terms Aggregation  根据字段值项分组聚合 

     示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age"
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 2000,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_terms": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 463,
          "buckets": [
            {
              "key": 31,
              "doc_count": 61
            },
            {
              "key": 39,
              "doc_count": 60
            },
            {
              "key": 26,
              "doc_count": 59
            },
            {
              "key": 32,
              "doc_count": 52
            },
            {
              "key": 35,
              "doc_count": 52
            },
            {
              "key": 36,
              "doc_count": 52
            },
            {
              "key": 22,
              "doc_count": 51
            },
            {
              "key": 28,
              "doc_count": 51
            },
            {
              "key": 33,
              "doc_count": 50
            },
            {
              "key": 34,
              "doc_count": 49
            }
          ]
        }
      }
    }

    复制代码

     结果说明:

    "doc_count_error_upper_bound": 0:文档计数的最大偏差值

    "sum_other_doc_count": 463:未返回的其他项的文档数

    默认情况下返回按文档计数从高到低的前10个分组:

    复制代码

     "buckets": [
            {
              "key": 31,
              "doc_count": 61
            },
            {
              "key": 39,
              "doc_count": 60
            },
        .............
    ]

    复制代码

     年龄为31的文档有61个,年龄为39的文档有60个

     size 指定返回多少个分组:

    示例2:指定返回20个分组

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age",
            "size": 20
          }
        }
      }
    }

    复制代码

     结果2:

     View Code

     示例3:每个分组上显示偏差值

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age",
            "size": 5,
            "shard_size": 20,
            "show_term_doc_count_error": true
          }
        }
      }
    }

    复制代码

     结果3:

    复制代码

    {
      "took": 8,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_terms": {
          "doc_count_error_upper_bound": 25,
          "sum_other_doc_count": 716,
          "buckets": [
            {
              "key": 31,
              "doc_count": 61,
              "doc_count_error_upper_bound": 0
            },
            {
              "key": 39,
              "doc_count": 60,
              "doc_count_error_upper_bound": 0
            },
            {
              "key": 26,
              "doc_count": 59,
              "doc_count_error_upper_bound": 0
            },
            {
              "key": 32,
              "doc_count": 52,
              "doc_count_error_upper_bound": 0
            },
            {
              "key": 36,
              "doc_count": 52,
              "doc_count_error_upper_bound": 0
            }
          ]
        }
      }
    }

    复制代码

     示例4:shard_size 指定每个分片上返回多少个分组

    shard_size 的默认值为:
    索引只有一个分片:= size
    多分片:= size * 1.5 + 10

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age",
            "size": 5,
            "shard_size": 20
          }
        }
      }
    }

    复制代码

     结果4:

    复制代码

    {
      "took": 8,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_terms": {
          "doc_count_error_upper_bound": 25,
          "sum_other_doc_count": 716,
          "buckets": [
            {
              "key": 31,
              "doc_count": 61
            },
            {
              "key": 39,
              "doc_count": 60
            },
            {
              "key": 26,
              "doc_count": 59
            },
            {
              "key": 32,
              "doc_count": 52
            },
            {
              "key": 36,
              "doc_count": 52
            }
          ]
        }
      }
    }

    复制代码

     order  指定分组的排序

     示例5:根据文档计数排序

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age",
            "order" : { "_count" : "asc" }
          }
        }
      }
    }

    复制代码

     结果5:

    复制代码

    {
      "took": 3,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_terms": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 584,
          "buckets": [
            {
              "key": 29,
              "doc_count": 35
            },
            {
              "key": 27,
              "doc_count": 39
            },
            {
              "key": 38,
              "doc_count": 39
            },
            {
              "key": 23,
              "doc_count": 42
            },
            {
              "key": 24,
              "doc_count": 42
            },
            {
              "key": 25,
              "doc_count": 42
            },
            {
              "key": 37,
              "doc_count": 42
            },
            {
              "key": 20,
              "doc_count": 44
            },
            {
              "key": 40,
              "doc_count": 45
            },
            {
              "key": 21,
              "doc_count": 46
            }
          ]
        }
      }
    }

    复制代码

     示例6:根据分组值排序

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age",
            "order" : { "_key" : "asc" }
          }
        }
      }
    }

    复制代码

     结果6:

    复制代码

    {
      "took": 10,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_terms": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 549,
          "buckets": [
            {
              "key": 20,
              "doc_count": 44
            },
            {
              "key": 21,
              "doc_count": 46
            },
            {
              "key": 22,
              "doc_count": 51
            },
            {
              "key": 23,
              "doc_count": 42
            },
            {
              "key": 24,
              "doc_count": 42
            },
            {
              "key": 25,
              "doc_count": 42
            },
            {
              "key": 26,
              "doc_count": 59
            },
            {
              "key": 27,
              "doc_count": 39
            },
            {
              "key": 28,
              "doc_count": 51
            },
            {
              "key": 29,
              "doc_count": 35
            }
          ]
        }
      }
    }

    复制代码

    示例7:取分组指标值排序

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "terms": {
            "field": "age",
            "order": {
              "max_balance": "asc"
            }
          },
          "aggs": {
            "max_balance": {
              "max": {
                "field": "balance"
              }
            },
            "min_balance": {
              "min": {
                "field": "balance"
              }
            }
          }
        }
      }
    }

    复制代码

     结果7:

     View Code

     示例8:筛选分组-正则表达式匹配值

    复制代码

    GET /_search
    {
        "aggs" : {
            "tags" : {
                "terms" : {
                    "field" : "tags",
                    "include" : ".*sport.*",
                    "exclude" : "water_.*"
                }
            }
        }
    }

    复制代码

     示例9:筛选分组-指定值列表

    复制代码

    GET /_search
    {
        "aggs" : {
            "JapaneseCars" : {
                 "terms" : {
                     "field" : "make",
                     "include" : ["mazda", "honda"]
                 }
             },
            "ActiveCarManufacturers" : {
                 "terms" : {
                     "field" : "make",
                     "exclude" : ["rover", "jensen"]
                 }
             }
        }
    }

    复制代码

     示例10:根据脚本计算值分组

    复制代码

    GET /_search
    {
        "aggs" : {
            "genres" : {
                "terms" : {
                    "script" : {
                        "source": "doc['genre'].value",
                        "lang": "painless"
                    }
                }
            }
        }
    }

    复制代码

     示例1:缺失值处理

    复制代码

    GET /_search
    {
        "aggs" : {
            "tags" : {
                 "terms" : {
                     "field" : "tags",
                     "missing": "N/A" 
                 }
             }
        }
    }

    复制代码

     结果10:

     View Code

    2.  filter Aggregation  对满足过滤查询的文档进行聚合计算

     在查询命中的文档中选取符合过滤条件的文档进行聚合,先过滤再聚合

    示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_terms": {
          "filter": {"match":{"gender":"F"}},
          "aggs": {
            "avg_age": {
              "avg": {
                "field": "age"
              }
            }
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 163,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_terms": {
          "doc_count": 493,
          "avg_age": {
            "value": 30.3184584178499
          }
        }
      }
    }

    复制代码

     3. Filters Aggregation  多个过滤组聚合计算

    示例1:

     准备数据:

    复制代码

    PUT /logs/_doc/_bulk?refresh
    {"index":{"_id":1}}
    {"body":"warning: page could not be rendered"}
    {"index":{"_id":2}}
    {"body":"authentication error"}
    {"index":{"_id":3}}
    {"body":"warning: connection timed out"}

    复制代码

    获取组合过滤后聚合的结果:

    复制代码

    GET logs/_search
    {
      "size": 0,
      "aggs": {
        "messages": {
          "filters": {
            "filters": {
              "errors": {
                "match": {
                  "body": "error"
                }
              },
              "warnings": {
                "match": {
                  "body": "warning"
                }
              }
            }
          }
        }
      }
    }

    复制代码

     上面的结果:

    复制代码

    {
      "took": 18,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 3,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "messages": {
          "buckets": {
            "errors": {
              "doc_count": 1
            },
            "warnings": {
              "doc_count": 2
            }
          }
        }
      }
    }

    复制代码

     示例2:为其他值组指定key

    复制代码

    GET logs/_search
    {
      "size": 0,
      "aggs": {
        "messages": {
          "filters": {
            "other_bucket_key": "other_messages",
            "filters": {
              "errors": {
                "match": {
                  "body": "error"
                }
              },
              "warnings": {
                "match": {
                  "body": "warning"
                }
              }
            }
          }
        }
      }
    }

    复制代码

     结果2:

    复制代码

    {
      "took": 5,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 3,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "messages": {
          "buckets": {
            "errors": {
              "doc_count": 1
            },
            "warnings": {
              "doc_count": 2
            },
            "other_messages": {
              "doc_count": 0
            }
          }
        }
      }
    }

    复制代码

     4. Range Aggregation 范围分组聚合

     示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_range": {
          "range": {
            "field": "age",
            "ranges": [
              {
                "to": 25
              },
              {
                "from": 25,
                "to": 35
              },
              {
                "from": 35
              }
            ]
          },
          "aggs": {
            "bmax": {
              "max": {
                "field": "balance"
              }
            }
          }
        }
      }
    }

    复制代码

     结果1:

    复制代码

    {
      "took": 7,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_range": {
          "buckets": [
            {
              "key": "*-25.0",
              "to": 25,
              "doc_count": 225,
              "bmax": {
                "value": 49587
              }
            },
            {
              "key": "25.0-35.0",
              "from": 25,
              "to": 35,
              "doc_count": 485,
              "bmax": {
                "value": 49795
              }
            },
            {
              "key": "35.0-*",
              "from": 35,
              "doc_count": 290,
              "bmax": {
                "value": 49989
              }
            }
          ]
        }
      }
    }

    复制代码

    示例2:为组指定key

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "age_range": {
          "range": {
            "field": "age",
            "keyed": true,
            "ranges": [
              {
                "to": 25,
                "key": "Ld"
              },
              {
                "from": 25,
                "to": 35,
                "key": "Md"
              },
              {
                "from": 35,
                "key": "Od"
              }
            ]
          }
        }
      }
    }

    复制代码

    结果2:

    复制代码

    {
      "took": 2,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "age_range": {
          "buckets": {
            "Ld": {
              "to": 25,
              "doc_count": 225
            },
            "Md": {
              "from": 25,
              "to": 35,
              "doc_count": 485
            },
            "Od": {
              "from": 35,
              "doc_count": 290
            }
          }
        }
      }
    }

    复制代码

    5. Date Range Aggregation  时间范围分组聚合

    示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "range": {
          "date_range": {
            "field": "date",
            "format": "MM-yyy",
            "ranges": [
              {
                "to": "now-10M/M"
              },
              {
                "from": "now-10M/M"
              }
            ]
          }
        }
      }
    }

    复制代码

    结果1:

    复制代码

    {
      "took": 115,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "range": {
          "buckets": [
            {
              "key": "*-2017-08-01T00:00:00.000Z",
              "to": 1501545600000,
              "to_as_string": "2017-08-01T00:00:00.000Z",
              "doc_count": 0
            },
            {
              "key": "2017-08-01T00:00:00.000Z-*",
              "from": 1501545600000,
              "from_as_string": "2017-08-01T00:00:00.000Z",
              "doc_count": 0
            }
          ]
        }
      }
    }

    复制代码

    6. Date Histogram Aggregation  时间直方图(柱状)聚合

    就是按天、月、年等进行聚合统计。可按 year (1y), quarter (1q), month (1M), week (1w), day (1d), hour (1h), minute (1m), second (1s) 间隔聚合或指定的时间间隔聚合。

    示例1:

    复制代码

    POST /bank/_search?size=0
    {
      "aggs": {
        "sales_over_time": {
          "date_histogram": {
            "field": "date",
            "interval": "month"
          }
        }
      }
    }

    复制代码

    结果1:

    复制代码

    {
      "took": 9,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1000,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "sales_over_time": {
          "buckets": []
        }
      }
    }

    复制代码

    7. Missing Aggregation  缺失值的桶聚合

    复制代码

    POST /bank/_search?size=0
    {
        "aggs" : {
            "account_without_a_age" : {
                "missing" : { "field" : "age" }
            }
        }
    }

    复制代码

    8. Geo Distance Aggregation  地理距离分区聚合

    展开全文
  • 本篇将开始介绍Elasticsearch Bucket聚合(桶聚合)。 Buket Aggregations(桶聚合)不像metrics Aggregations(度量聚合)那样计算字段上的度量,而是创建文档桶,每个文件桶有效地定义一个文档集。除了bucket本身之外,...

    本篇将开始介绍Elasticsearch Bucket聚合(桶聚合)。

    Buket Aggregations(桶聚合)不像metrics Aggregations(度量聚合)那样计算字段上的度量,而是创建文档桶,每个文件桶有效地定义一个文档集。除了bucket本身之外,bucket聚合还计算并返回“落入”每个bucket的文档的数量。

    与度量聚合相反,桶聚合可以嵌套子聚合。这些子聚合将为它们的“父”桶聚合创建的桶进行聚合。

    ES Bucket Aggregations对标关系型数据库的(group by)。

    首先我们来介绍桶聚合两个常用参数intervals、time_zone的含义。

    1、Intervals
    定义桶的间隔,其可选值如下:

    • seconds
      1, 5, 10, 30的倍数。
    • minutes
      1, 5, 10, 30的倍数。
    • hours
      1, 3, 12的倍数。
    • days
      1,7的倍数。
    • months
      1, 3的倍数。
    • years
      1, 5, 10, 20, 50, 100的倍数。

    2、Time Zone
    对于日期类型,可以使用time_zone来指定时区,可选值可以是相对ISO 8601 utc的相对值,例如+01:00或-08:00,也可以是时区ID,例如America/Los_Angeles。

    3、Histogram Aggregation
    直方图聚合,Date Histogram Aggregation是其特例。

    动态将文档中的值按照特定的间隔构建桶,并计算落在该桶的数量,文档中的值根据如下函数进行近似匹配:

    bucket_key = Math.floor((value - offset) / interval) * interval + offset,
    其中interval必须是正小数(包含正整数),offset为[0,interval)。

    主要支持的参数如下:

    • keyed
      响应结果返回组织方式(数组或对象),具体示例请参考日期类直方图聚合。
    • doc_count
      匹配的文档数量。
    • offset 偏移量
      更改每个bucket(桶)的开始时间,例如将offset设置为"10",则上例中返回的一个桶的key为:[10,30),如果offset设置为5,则第一个桶的key为[15,30)。
    • order
      默认按照key的升序进行排序,可以通过order字段来指定排序,其值为BucketOrder。
      其取值:
    1. BucketOrder.count(boolean asc)
      按匹配文档格式升序/降序排序。
    2. BucketOrder.key(boolean asc)
      按key的升序或降序排序。
    3. BucketOrder.aggregation
      通过定义一个子聚合进行排序。
    4. BucketOrder.compound(List< BucketOrder> orders)
      创建一个桶排序策略,该策略根据多个条件对桶进行排序。
    • min_doc_count
      表示只显示匹配的文档大于等于min_doc_count的桶。

    具体JAVA的示例将在Date Histogram Aggregation中详细介绍。

    4、Date Histogram Aggregation
    日期字段直方图聚合。

    4.1 interval 取值

    • milliseconds (ms)
      毫秒,固定长度,支持倍数,通常使用1000的倍数。
    • seconds (s)
    • minutes (m)
      分钟。所有的分钟从00秒开始
      1m,表示在指定时区的第一分钟00s到下一分钟00s之间的时间段。
      {n}m,表示时间间隔,等于n * 60 * 1000 毫秒。
    • hours (h)
      小时,其分钟与秒都从00开始。
    1. 1小时(1h)是指定时区内第一个小时的00:00分钟到下一个小时的00:00分钟之间的时间间隔,用来补偿其间的任何闰秒,从而使经过该小时的分钟数和秒数在开始和结束时相同。
    2. {n}h,表示时间间隔,等于 n * 60 * 60 * 1000 毫秒的时间间隔。
    • days (d)
    1. 一天(1d)是在指定的时区内,从一天的开始到第二天的开始的时间间隔。
    2. {n}d,表示时间间隔,等于n * 24 * 60 * 60 * 1000毫秒。
    • weeks (w)
    1. 1周(1w)为开始日:of_week:hour:minute:second与一周的同一天及下一周的时间在指定时区的间隔。
    2. 不支持 {n}w。
    • months (M)
    1. 一个月(1M)是本月开始之间的时间间隔的一天与次月的同一天。
    2. 不支持{n}M
    • quarters (q)
      季度,不支持{n}q。
    • years (y)
      年, 不支持{n}y。

    4.2 示例

    {
        "aggs" : {
            "sales_over_time" : {
                "date_histogram" : {
                    "field" : "date",
                    "interval" : "month"
                }
            }
        }
    }
    

    对应的JAVA示例如下:

    /**
    	 * 日期直方图聚合
    	 */
    	public static void test_Date_Histogram_Aggregation() {
    		RestHighLevelClient client = EsClient.getClient();
    		try {
    			
    			//构建日期直方图聚合  时间间隔,示例中按月统计
    			DateHistogramInterval interval = new DateHistogramInterval("1M"); 
    			SearchRequest searchRequest = new SearchRequest();
    			searchRequest.indices("aggregations_index02");
    			SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    			AggregationBuilder aggregationBuild = AggregationBuilders.dateHistogram("createTime_histogram")
    																		.field("createTime")
    																		.dateHistogramInterval(interval)
    																	//	.format("yyyy-MM-dd") // 对key的格式化
    					                              ;
    			sourceBuilder.aggregation(aggregationBuild);
    			sourceBuilder.size(0);
    			sourceBuilder.query(
    					QueryBuilders.termQuery("sellerId", 24)
    			);
    			searchRequest.source(sourceBuilder);
    			SearchResponse result = client.search(searchRequest, RequestOptions.DEFAULT);
    			System.out.println(result);
    		} catch (Throwable e) {
    			e.printStackTrace();
    		} finally {
    			EsClient.close(client);
    		}
    	}
    

    对应的返回值:

    {
        ... //省略常规响应
        "aggregations":{
            "date_histogram#createTime_histogram":{
                "buckets":[
                        "key_as_string":"2015-12-01 00:00:00",
                        "key":1448928000000,
                        "doc_count":6
                    },
                    {
                        "key_as_string":"2016-01-01 00:00:00",  
                        "key":1451606400000,
                        "doc_count":4
                    }
                ]
            }
        }
    }
    

    其相应的参数已在上面详述,在此不重复介绍。

    4.3 Date Histogram聚合支持的常用参数

    除Histogram Aggregation罗列的参数后,还额外支持如下参数:

    • timeZone 时区指定。
    • offset 偏移量
      更改每个bucket(桶)的开始时间,例如将offset设置为"1h",则上例中返回的一个桶的开始时间:“2015-12-01 00:00:00”,则更改为"2015-12-01 01:00:00"
    • format
      key格式化,将key使用format格式化后的值设置为key_as_string字段。
    • keyed
      返回结果格式化,默认为false,则buckets返回值为数组,如果keyed=true,则对应的返回结果如下:
    "aggregations":{
            "date_histogram#createTime_histogram":{
                "buckets":{
                    "2015-12-01 00:00:00":{
                        "key_as_string":"2015-12-01 00:00:00",
                        "key":1448928000000,
                        "doc_count":6
                    },
                    "2016-01-01 00:00:00":{
                        "key_as_string":"2016-01-01 00:00:00",
                        "key":1451606400000,
                        "doc_count":4
                    }
    			}
    		}
    	}
    }
    

    5、Date Range Aggregation
    日期范围聚合,每个范围定义[from,to),from,to可支持date mesh格式。
    其使用示例如下,其他与 Date Histogram类似。

    /**
    	 * 日期范围聚合
    	 */
    	public static void test_Date_range_Aggregation() {
    		RestHighLevelClient client = EsClient.getClient();
    		try {
    			//构建日期直方图聚合  时间间隔,示例中按月统计
    			SearchRequest searchRequest = new SearchRequest();
    			searchRequest.indices("aggregations_index02");
    			SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    			AggregationBuilder aggregationBuild = AggregationBuilders.dateRange("createTime_date_range")
    																		.field("createTime")
    																		.format("yyyy-MM-dd")
    																		.addRange("quarter_01", "2016-01", "2016-03")
    																		.addRange("quarter_02", "2016-03", "2016-06")
    																		.addRange("quarter_03", "2016-06", "2016-09")
    																		.addRange("quarter_04", "2016-09", "2016-12")
    																	
    																	//	.format("yyyy-MM-dd") // 对key的格式化
    					                              ;
    			sourceBuilder.aggregation(aggregationBuild);
    			sourceBuilder.size(0);
    			sourceBuilder.query(
    					QueryBuilders.termQuery("sellerId", 24)
    			);
    			searchRequest.source(sourceBuilder);
    			SearchResponse result = client.search(searchRequest, RequestOptions.DEFAULT);
    			System.out.println(result);
    		} catch (Throwable e) {
    			e.printStackTrace();
    		} finally {
    			EsClient.close(client);
    		}
    	}
    

    6、Filter Aggregation
    聚合中支持首先根据过滤上下文对所有文档进行刷选,然后再进行聚合计算,例如:

    POST /sales/_search?size=0
    {
        "aggs" : {
            "t_shirts" : {
                "filter" : { "term": { "type": "t-shirt" } },
                "aggs" : {
                    "avg_price" : { "avg" : { "field" : "price" } }
                }
            }
        }
    }
    

    其对应的JAVA代码如下:

    /**
    	 * 日期范围聚合
    	 */
    	public static void test_filter_Aggregation() {
    		RestHighLevelClient client = EsClient.getClient();
    		try {
    			//构建日期直方图聚合  时间间隔,示例中按月统计
    			SearchRequest searchRequest = new SearchRequest();
    			searchRequest.indices("aggregations_index02");
    			SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    			AggregationBuilder aggregationBuild = AggregationBuilders.filter("t_shirts", QueryBuilders.termQuery("status", "1"))
    													.subAggregation(AggregationBuilders.avg("avg").field("num"))
    					                              ;
    			sourceBuilder.aggregation(aggregationBuild);
    			sourceBuilder.size(0);
    			sourceBuilder.query(
    					QueryBuilders.termQuery("sellerId", 24)
    			);
    			searchRequest.source(sourceBuilder);
    			SearchResponse result = client.search(searchRequest, RequestOptions.DEFAULT);
    			System.out.println(result);
    		} catch (Throwable e) {
    			e.printStackTrace();
    		} finally {
    			EsClient.close(client);
    		}
    	}
    

    其返回结果如下:

    {
        ... //省略
        "aggregations":{
            "filter#t_shirts":{
                "doc_count":2,
                "avg#avg":{
                    "value":1
                }
            }
        }
    }
    

    {
    … //省略
    “aggregations”:{
    “filter#t_shirts”:{
    “doc_count”:2,
    “avg#avg”:{
    “value”:1
    }
    }
    }
    }

    7、Filters Aggregation
    定义一个多桶聚合,其中每个桶与一个过滤器相关联。每个bucket将收集与其关联过滤器匹配的所有文档。

    public static void test_filters_aggregation() {
    		RestHighLevelClient client = EsClient.getClient();
    		try {
    			//构建日期直方图聚合  时间间隔,示例中按月统计
    			SearchRequest searchRequest = new SearchRequest();
    			searchRequest.indices("aggregations_index02");
    			SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    			AggregationBuilder aggregationBuild = AggregationBuilders.filters("create_filters", 
    														QueryBuilders.termQuery("status", 1),
    														QueryBuilders.termQuery("buyerId", 1))
    													.subAggregation(AggregationBuilders.avg("avg").field("num"))
    					                              ;
    			sourceBuilder.aggregation(aggregationBuild);
    			sourceBuilder.size(0);
    			sourceBuilder.query(
    					QueryBuilders.termQuery("sellerId", 24)
    			);
    			searchRequest.source(sourceBuilder);
    			SearchResponse result = client.search(searchRequest, RequestOptions.DEFAULT);
    			System.out.println(result);
    		} catch (Throwable e) {
    			e.printStackTrace();
    		} finally {
    			EsClient.close(client);
    		}
    
    	}
    

    其返回结果:

    {
        ... // 省略
        "aggregations":{
            "filters#create_filters":{
                "buckets":[
                    {
                        "doc_count":2,
                        "avg#avg":{
                            "value":1
                        }
                    },
                    {
                        "doc_count":0,
                        "avg#avg":{
                            "value":null
                        }
                    }
                ]
            }
        }
    }
    

    温馨提示,每一个filter代表一个桶(聚合)。

    8、Global Aggregation
    全局聚合,会忽略所有的查询条件,具体从下述例子进行说明:

    POST /sales/_search?size=0
    {
        "query" : {
            "match" : { "type" : "t-shirt" }
        },
        "aggs" : {
            "all_products" : {
                "global" : {}, 
                "aggs" : { 
                    "avg_price" : { "avg" : { "field" : "price" } }
                }
            },
            "t_shirts": { "avg" : { "field" : "price" } }
        }
    }
    

    其聚合的文档集不是匹配该查询的文档"query" : {“match” : { “type” : “t-shirt” } },而是针对所有的文档进行聚合。

    对应的JAVA实例如下:

    public static void test_global_aggregation() {
    		RestHighLevelClient client = EsClient.getClient();
    		try {
    			//构建日期直方图聚合  时间间隔,示例中按月统计
    			SearchRequest searchRequest = new SearchRequest();
    			searchRequest.indices("aggregations_index02");
    			SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    			AggregationBuilder aggregationBuild = AggregationBuilders.global("all_producers")
    															.subAggregation(AggregationBuilders
    																	.avg("num_avg_aggregation")
    																	.field("num"))
    					                              ;
    			sourceBuilder.aggregation(aggregationBuild);
    			sourceBuilder.size(0);
    			sourceBuilder.query(
    					QueryBuilders.termQuery("sellerId", 24)
    			);
    			searchRequest.source(sourceBuilder);
    			SearchResponse result = client.search(searchRequest, RequestOptions.DEFAULT);
    			System.out.println(result);
    		} catch (Throwable e) {
    			e.printStackTrace();
    		} finally {
    			EsClient.close(client);
    		}
    
    	}
    

    对应的返回值如下:

    {
        "took":151,
        "timed_out":false,
        "_shards":{
            "total":5,
            "successful":5,
            "skipped":0,
            "failed":0
        },
        "hits":{
            "total":39,                       // @1
            "max_score":0,
            "hits":[
    
            ]
        },
        "aggregations":{
            "global#all_producers":{
                "doc_count":1286,      // @2
                "avg#num_avg_aggregation":{
                    "value":1.3157076205287714
                }
            }
        }
    }
    

    结果@1:表示符合查询条件的总个数。
    结构@2:表示参与聚合的文档数量,等于当前库中文档总数。

    9、IP Range Aggregation
    ip类型特有的范围聚合,与其他聚合使用类似,就不重复介绍了。

    10、Missing Aggregation
    统计缺少某个字段的文档个数。
    JAVA示例如下:

    AggregationBuilder aggregationBuild = AggregationBuilders.missing("missing_num_count")
    														.field("num");
    

    11、Range Aggregation
    基于多桶值源的聚合,允许用户定义一组范围——每个范围表示一个桶。在聚合过程中,将根据每个bucket范围和相关/匹配文档的“bucket”检查从每个文档中提取的值。注意,此聚合包含from值,并排除每个范围的to值。

    GET /_search
    {
        "aggs" : {
            "price_ranges" : {
                "range" : {
                    "field" : "price",
                    "ranges" : [
                        { "to" : 100.0 },
                        { "from" : 100.0, "to" : 200.0 },
                        { "from" : 200.0 }
                    ]
                }
            }
        }
    }
    

    对应的JAVA示例如下:

    public static void test_range_aggregation() {
    		RestHighLevelClient client = EsClient.getClient();
    		try {
    			//构建日期直方图聚合  时间间隔,示例中按月统计
    			SearchRequest searchRequest = new SearchRequest();
    			searchRequest.indices("aggregations_index02");
    			SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    			AggregationBuilder aggregationBuild = AggregationBuilders.range("num_range_aggregation")
    																	.field("num")
    																	.addRange(0, 5)
    																	.addRange(5,10)
    																	.addUnboundedFrom(10)
    					                              ;
    			sourceBuilder.aggregation(aggregationBuild);
    			sourceBuilder.size(0);
    			sourceBuilder.query(
    					QueryBuilders.termQuery("sellerId", 24)
    			);
    			searchRequest.source(sourceBuilder);
    			SearchResponse result = client.search(searchRequest, RequestOptions.DEFAULT);
    			System.out.println(result);
    		} catch (Throwable e) {
    			e.printStackTrace();
    		} finally {
    			EsClient.close(client);
    		}
    
    	}
    

    其返回结果如下:

    {
        // 省略
        "aggregations":{
            "range#num_range_aggregation":{
                "buckets":[
                    {
                        "key":"0.0-5.0",
                        "from":0,
                        "to":5,
                        "doc_count":38
                    },
                    {
                        "key":"5.0-10.0",
                        "from":5,
                        "to":10,
                        "doc_count":0
                    },
                    {
                        "key":"10.0-*",
                        "from":10,
                        "doc_count":1
                    }
                ]
            }
        }
    }
    

    Range Aggregations支持嵌套聚合,使用subAggregations来支持嵌套聚合,根据官网示例如下:

    GET /_search
    {
        "aggs" : {
            "price_ranges" : {
                "range" : {                                    // @1
                    "field" : "price",
                    "ranges" : [
                        { "to" : 100 },
                        { "from" : 100, "to" : 200 },
                        { "from" : 200 }
                    ]
                },
                "aggs" : {                                  // @2
                    "price_stats" : {
                        "stats" : { "field" : "price" }
                    }
                }
            }
        }
    }
    

    首先通过@1定义范围聚合,然后对每个桶中 的文档再执行子聚合@2,其返回结果如下:

    {
      ...
      "aggregations": {
        "price_ranges": {
          "buckets": [
            {
              "key": "*-100.0",
              "to": 100.0,
              "doc_count": 2,
              "price_stats": {
                "count": 2,
                "min": 10.0,
                "max": 50.0,
                "avg": 30.0,
                "sum": 60.0
              }
            },
            {
              "key": "100.0-200.0",
              "from": 100.0,
              "to": 200.0,
              "doc_count": 2,
              "price_stats": {
                "count": 2,
                "min": 150.0,
                "max": 175.0,
                "avg": 162.5,
                "sum": 325.0
              }
            },
            {
              "key": "200.0-*",
              "from": 200.0,
              "doc_count": 3,
              "price_stats": {
                "count": 3,
                "min": 200.0,
                "max": 200.0,
                "avg": 200.0,
                "sum": 600.0
              }
            }
          ]
        }
      }
    }
    

    本文详细介绍了ES 桶聚合,并给出JAVA示例,下一篇将重点关注ES桶聚合之term聚合。


    见文如面,我是威哥,热衷于成体系剖析JAVA主流中间件,关注公众号『中间件兴趣圈』,回复专栏可获取成体系专栏导航,回复资料可以获取笔者的学习思维导图。
    在这里插入图片描述

    展开全文
  • 华为 BGP路由聚合

    千次阅读 多人点赞 2020-07-01 11:03:17
    BGP的聚合相对其他协议的聚合差异较大,且重要性较高,关于手动聚合的属性及策略运用要熟练掌握。 BGP路由聚合的作用和聚合的方式 1、减少路由表的明细路由(减少空间占用和维护每条明细路由带来压力) 2、减少因为...

    业精于勤,荒于嬉;行成于思,毁于随。

    BGP的聚合相对其他协议的聚合差异较大,且重要性较高,关于手动聚合的属性及策略运用要熟练掌握。

    一、BGP聚合

    在中型或大型BGP网络中,BGP路由表会变得十分庞大,存储路由表占用大量的交换机内存资源,传输和处理路由信息需要占用大量的网络资源。使用路由聚合(Routes Aggregation)可以大大减小路由表的规模;另外通过对路由进行聚合,隐藏一些具体的路由,可以减少路由震荡对网络带来的影响。

    BGP路由聚合结合灵活的路由策略,使BGP更有效的传递和控制路由。

    1、减少路由表项网络设备的硬件资源的占用
    2、提高网络的稳定性

    BGP支持两种聚合方式:自动聚合和手动聚合。自动聚合的路由优先级低于手动聚合的路由优先级(宣告聚合路由–配合静态来实现)。

    1.1 BGP路由聚合的作用

    (1)减少路由表的明细路由(减少空间占用和维护每条明细路由带来压力)
    (2)减少因为某些明细路由的频繁更新导致网络波动

    1.2 BGP路由聚合的方式

    (1)summary automatic 自动聚合
    (2)Aggregation 手动聚合
    (3)静态宣告 宣告时宣告手动汇总后的路由(需要再ip路由表静态部署一条指向null 0的手动聚合后的路由)

    二、拓扑

    在这里插入图片描述

    三、基础配置

    1、AS-200运行OSPF协议属于区域0

    2、如图构建BGP邻居,全部建立EBGP邻居(AR-4不运行BGP),开启团体属性通告功能

    3、在AR-4将静态路由及Loopback 1直连路由引入进OSPF,引入后的路由开销为150,类型值为2

    [AR-4]acl 2000                                           //创建基本acl 2000 来匹配192.168.1.4/32的主机路由
    [AR-4-acl-basic-2000]rule permit source 192.168.1.4 0 
    [AR-4-acl-basic-2000]quit 
    [AR-4]route-policy ospf_cost permit node 10              //创建名称为ospf_cost的路由策略节点10	
    [AR-4-route-policy]if-match acl 2000                     //此节点匹配acl 2000抓取的路由
    [AR-4-route-policy]apply cost 150                        //此节点匹配到路由修改开销为150
    [AR-4-route-policy]quit 
    
    [AR-4]ospf 1                                             //进入OSPF进程
    [AR-4-ospf-1]import-route direct route-policy ospf_cost  //引入直连路由时挂接名称为ospf_cost的路由策略进行路由过滤与开销修改
    [AR-4-ospf-1]import-route static cost 150                //引入此设备的静态路由并修改开销为150
    [AR-4-ospf-1]quit 
    

    3.1 自动聚合

    (1)只对引入的BGP路由会自动聚合,network宣告进BGP的路由无法执行自动聚合。
    (2)只对始发与本地的BGP路由聚合会生效,对于通过其他BGP设备传递而来的外部路由聚合不会生效。
    (3)只将聚合后的路由发布出去
    (4)聚合后自动在本地生成一条指向聚合的Null路由来防止可能出现的环路
    (5)默认情况BGP设备的自动聚合是关闭的

    1、在AR-3将Loopback 1接口地址引入进BGP协议并开启自动聚合

    [AR-3]bgp 300	
    [AR-3-bgp]net 192.168.1.3 32 
    [AR-3-bgp]ipv4-family unicast 
    [AR-3-bgp-af-ipv4]summary automatic  //开启本BGP设备的自动汇总,自动汇总只对引入(重分发)进本BGP的路由有效,会将路由汇总为主类路由
    

    四、策略与观察

    1、查看AR-2 BGP路由表中192.168.1.0/24路由的MED值,AS-patch值判断AR-2对于此路由的最优来源选择

    dis bgp routing-table
    在这里插入图片描述
    MED值为0;AS-patch值为300;
    主要是该路由到达目的地的路由是唯一的,所以直接优选。

    2、在AR-2将OSPF路由引入进BGP协议,查看AR-2 BGP路由表中192.168.1.0/24路由的MED值,AS-path值判断AR-2对于此路由的最优来源选择

    [AR-2]bgp 200
    [AR-2-bgp]import-route ospf 
    

    dis bgp routing-table
    在这里插入图片描述
    MED值为150,AS-path值为空(本地产生);为本地始发
    Origin i>e>?
    主要是该路由到达目的地的路由是唯一的,所以直接优选,对到达同一目的地的路由不存在多条。

    3、在AR-2开启自动聚合,查看AR-2 BGP路由表中192.168.1.0/24路由的MED值,AS-path值判断AR-2对于此路由的最优来源选择

    [AR-2]bgp 200
    [AR-2-bgp]summary automatic 
    

    dis bgp routing-table
    在这里插入图片描述
    4、在AR-2通过手动聚合产生192.168.1.0/24的BGP路由,查看AR-2 BGP路由表针对192.168.1.0/24路由的MED值,AS-patch值判断AR-2对于此路由的最优来源选择
    (通告查看192.168.1.0的bgp详细路由信息来区分路由是自动聚合或是手动聚合产生)

    起源属性为“?”是自动聚合产生;
    起源属性为“i”可能是自动聚合产生,也可能是动聚合产生。

    [AR-2-bgp]aggregate 192.168.1.0 24
    

    dis bgp routing-table
    在这里插入图片描述

    [AR-2-bgp]undo summary automatic 
    

    dis bgp routing-table
    在这里插入图片描述
    5、当完成上述内容后,在AR-2的BGP路由表存在几条192.168.1.0/24的路由,同时存在这些路由时优选哪个起源属性的路由,并得出BGP本地起源属性的规则

    BGP本地起源属性:

    BGP的第四条选路原则只有当BGP设备针对同一条路由有多个获取源时,使用第四条选路原则
    手动聚合>自动聚合>IGP>BGP的规则来原则最佳路由

    五、TS排错

    1、现要求AS-100的路由器可以正常接收聚合路由192.168.2.0/24

    [AR-2-bgp]aggregate 192.168.2.0 255.255.255.0 detail-suppressed
    

    dis bgp routing-table
    在这里插入图片描述
    2、此路由需要最好的放环属性

    [AR-2-acl-basic-2000]acl 2020
    [AR-2-acl-basic-2020]rule 20 permit source 192.168.2.0 0.0.0.255
    [AR-2-acl-basic-2020]quit
    [AR-2]route-policy no-ad permit node 10
    [AR-2-route-policy]if-match acl 2020
    [AR-2-route-policy]apply community no-advertise
    [AR-2-route-policy]quit
    [AR-2]route-policy no-ad  permit node 20
    [AR-2-route-policy]quit
    [AR-2]bgp 200
    [AR-2-bgp]peer 12.1.1.1 route-policy no-ad  export 
    

    3、同时只接收192.168.2.0/24内的明细路由192.168.2.3/32

    请在AR-2进行故障排查,修改缺失或者错误配置及策略,满足以上题目需求
    (注意:可做修改与增加配置,不要删除任何配置)

    我这里用的是“反向操作”!!但是最好所有的问题和需求都在聚合策略下完成

    [AR-2]acl 2030
    [AR-2-acl-basic-2030]rule 30 permit source 192.168.2.2 0
    [AR-2-acl-basic-2030]rule 40 permit source 192.168.2.4 0
    [AR-2-acl-basic-2030]quit
    [AR-2]route-policy aa permit node 10
    [AR-2-route-policy]if-match acl 2030
    [AR-2-bgp]undo  peer 12.1.1.1 route-policy no-ad export
    [AR-2-bgp]aggregate 192.168.2.0 255.255.255.0 as-set suppress-policy aa 
    

    dis bgp routing-table
    在这里插入图片描述

    5.1 手动聚合

    1、聚合后明细和聚合路由都发布出去

    (1)对宣告;引入;始发;以及通过BGP学到的路由都会生效
    (2)汇总后将明细和汇总路由都传递出去
    (3)汇总后的路由不再携带明细路由的AS号,只携带汇总设备的AS号,此路由以汇总设备作为始发。
    (4)聚合后自动在本地生成一条指向聚合的Null路由来防止可能出现的环路

      [AR-2-bgp]aggregate 192.168.2.0 24 ?
              as-set              //发出聚合路由时携带明细路由的AS号
              attribute-policy    //为聚合路由添加属性值
              detail-suppressed   //抑制所有的明细路由,只发出聚合路由
              origin-policy       //只有命中指定路由后才会产生此聚合路由(被route-policy命中的的明细)
              suppress-policy     //选择性抑制明细路由(被suppress-policy命中的路由会被抑制)
    

    2、聚合后的路由携带明细AS发布出去

    (1)默认情况下聚合后的路由不再携带原明细路由的AS号,只有本聚合设备的AS然后开始传递,这样聚合路由回传存在环路的风险
    (2)对聚合路由赋予as-set属性,此聚合路由将保留原明细路由的AS属性

    [AR-2-bgp]aggregate 192.168.0.0 22 as-set                  //手动聚合的这条路由将携带明细路由的AS-Path属性发布出去。
    
    [AR-2-bgp]aggregate 40.1.0.0 22 detail-suppressed as-set   //只将聚合后的路由发送给邻居,并携带明细路由的AS-Path属性。
    

    3、只将聚合后的路由发布出去

    (1)对宣告;引入;始发;以及通过BGP学到的路由都会生效
    (2)汇总后只将汇总路由传递出去 ,参与汇总的明细路由将在本地BGP路由表打上“S”被抑制
    (3)汇总后的路由不再携带明细路由的AS号,只携带汇总设备的AS号,此路由以汇总设备作为始发。

     [AR-2-bgp]aggregate 192.168.2.0 24 detail-suppressed        //手动聚合后只将聚合路由传递下去
    
     [AR-2-bgp]aggregate 192.168.2.0 24 suppress-policy aa      //手动聚合后的路由和经过路由策略AAA过滤完的明细路由传递下去
    

    六、策略

    suppress-policy 抑制策略

    作用:抑制BGP对的路由(被抑制的路由不会被邻居通告)
    匹配:Route-policy

    attribute-policy 聚合路由路径属性策略

    作用:修改聚合路由属性
    匹配:Route- policy

    origin- policy 起源策略

    作用:限制聚合路由的条件(只有被origin- policy命中的路由才可以产生聚合路由)
    匹配:route policy

    route policy 路由策略

    作用:过滤路由修改路由属性,匹配路由(抓取路由–基于cost路由匹配)
    匹配:ACL,匹配所以路由

    在这里插入图片描述

    本人所有文章都受版权保护,著作权归艺博东所有!未经授权,转载必究或附上其原创链接。

    展开全文
  • 浅谈UML中的聚合与组合

    万次阅读 多人点赞 2011-11-21 23:46:03
    大家都知道UML的类图中一般包含五种关系即 关联聚合组合泛化 依赖 有些人可能会感觉组合跟聚合有点难区分 说难其实是相对其他几种关系而言 实际上想分清这两种关系一点也不难 聚合跟组合其实都属于关联 只不过它们...
  • 聚合

    2019-06-29 01:01:38
    聚合体,简称聚合,其中包括:实体对象(聚合根、聚合项)、值对象。 聚合内部: 1、聚合根是聚合项的一个特例。实体对象都可以作为聚合项。 2、聚合必须包含唯一的聚合根,以该聚合根代表一个聚合。 3、聚合中...
  • 聚合路由器

    2020-08-05 09:16:20
    乾元通聚合路由器火了,凭什么? 说起路由器,大家都不陌生,几乎家家户户都有,很多人接触的路由器只是普通型的家庭或企业型路由器。但最近有一款聚合路由器火了,它虽然也叫路由器,由于专业性较强,却跟我们平时...
  • VLAN聚合

    千次阅读 2018-05-21 13:13:42
    VLAN聚合简介: VLAN聚合(VLAN Aggregation,也称Super VLAN)指在一个物理网络内,用多个VLAN(称为Sub-VLAN)隔离广播域,并将这些Sub-VLAN聚合成一个逻辑的VLAN(称为Super-VLAN),这些Sub-VLAN使用同一个IP...
  • Maven 聚合

    千次阅读 2019-06-30 10:31:22
    Maven之聚合1简介2聚合是什么3如何用在Maven POM表示聚合3.1聚合项目的POM3.1聚合的表示语法3.2聚合的两种形式3.2.1父子目录3.2.2平行目录3.3相对路径理解4聚合的主要作用 1简介 在使用Java开发项目时,一种常见的...
  • MongoDB 聚合

    千次阅读 2020-06-05 14:40:03
    MongoDB 聚合 MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等),并返回计算后的数据结果。有点类似sql语句中的 count(*)。 aggregate() 方法 MongoDB中聚合的方法使用aggregate()。 语法 ...
  • DDD之4聚合聚合

    千次阅读 2020-06-07 17:14:37
    聚合就是归类的意思,把同类事物统一处理; 聚合根也就是最抽象,最普遍的特性; 背景 领域建模的过程回顾: 那么问题来了? 为什么要在限界上下文和实体之间增加聚合聚合根的概念,即作用是什么? 如何设计聚合?...
  • Elasticsearch聚合优化 | 聚合速度提升5倍

    万次阅读 多人点赞 2018-02-04 16:27:01
    1、聚合为什么慢? 大多数时候对单个字段的聚合查询还是非常快的, 但是当需要同时聚合多个字段时,就可能会产生大量的分组,最终结果就是占用 es 大量内存,从而导致 OOM 的情况发生。 实践应用发现,以下情况...
  • 链路聚合

    千次阅读 2019-05-16 18:45:13
    1.链路聚合 以太网链路聚合简称链路聚合,它通过将多条以太网物理链路捆绑在一起成为一条逻辑链路,从而实现增加链路带宽的目的。同时,这些捆绑在一起的链路通过相互间的动态备份,可以有效的提高链路的可靠性。 ...
  • ES聚合分析是什么 聚合分析是数据库中重要的功能特性,完成对⼀个查询的数据集中数据的聚合计算,如:找出某字段(或计算表达式的结果)的最⼤值、最⼩值,计算和、平均值等。ES作为搜索引擎兼数据库,同样提供...
  • Elasticsearch聚合学习之二:区间聚合

    千次阅读 2019-05-03 01:13:35
    本文是《Elasticsearch聚合学习》系列的第二篇,上一篇是我们熟悉了聚合的基本操作,本篇的内容是按照区间聚合的实战操作;
  • Java聚合

    千次阅读 2018-12-03 12:35:55
    Java聚合聚合 聚合 如果一个类有一个类的实体引用(类中的类),则它称为聚合聚合表示HAS-A关系。 考虑有一种情况,Employee对象包含许多信息,例如:id,name,emailId等。它包含另一个类对象:address,其包含它...
  • 链路聚合和端口聚合

    千次阅读 2017-11-29 11:02:00
    全文转载 我在百度上查了一下定义: 链路聚合是将两个或更多数据信道结合成一个单个的信道,该信道以一个单个的更高带宽的逻辑链路出现。链路聚合一般用来连接一个或多个带宽需求大的设备,例如连接骨干网络的服务器...
  • 华三H3C端口聚合与链路聚合

    万次阅读 2018-03-14 20:56:44
    端口聚合是思科的叫法,链路聚合是华为与华三的叫法,网上也有不同解释,自己查资料理解区别吧 端口聚合 把端口加入端口组(group),链路聚合 把链路聚合在一起 华三配置 静态聚合模式 <H3C>system-view ...
  • sum聚合 sum是一个求累加值的聚合,其作用与关系型数据库中相同。 GET /lib4/items/_search { &amp;quot;size&amp;quot;: 0, //表示查询多少条文档,聚合只需就和结果,输出文档可以设置为0条 &...
  • 载波聚合

    千次阅读 2019-09-15 20:37:38
    为什么要进行载波聚合? lte中最大带宽是20M(100个PRB),该小区下ue能获得速率是有限的(LTE_FDD上行理想状态下75Mbps左右,而下行理想状态在175Mbps(注:后面我会专门一篇文章计算LTE_TDD,LTE_FDD理想状态下的...
  • 链路聚合 一、链路聚合技术介绍 以太网链路聚合简称链路聚合,它通过将多条以太网物理链路捆绑在一起成为一条逻辑链路,从而实现增加链路带宽的目的。同时,这些捆绑在一起的链路通过相互间的动态备份,可以有效地...
  • 聚合运算

    千次阅读 2018-03-20 13:51:37
    一、聚合 聚合运算就是从一组值中计算出一个值。Aggregate扩展方法允许实现自定义的聚合运算。【示例】合并、求平均值、最大值、最小值using System; using System.Collections.Generic; using System.Linq; ...
  • 聚合支付

    千次阅读 2017-02-08 15:12:58
    聚合支付平台
  • 链路聚合或端口聚合,将多条物理链路聚合成一条逻辑上的链路(这条逻辑链路带宽相当于物理链路带宽之各),不单独配置物理口,这些物理链路作为这个逻辑通道的成员,配置时只配置这个逻辑通道。这些物理口同时都在...
  • 网卡聚合

    万次阅读 2020-11-25 15:31:23
    一、基本命令: ​ 1、ifconfig 查看新设备 ​ 2、cd /etc/sysconfig/network-scripts 网卡配置文件所在目录 ...​ 6、teamdctl (虚拟网卡连接名) state 查看聚合网卡的状态 ​ 7、nmcli connection delete
  • max聚合查询 最大值聚合查询使用 public class EsAgg throws UnknownHostException{ public void maxAgg(TransportClient client){ //最大值聚合查询(max) AggregationBuilder agg = ...
  • VLAN特性 聚合、MUX VLAN、QinQ、映射

    万次阅读 多人点赞 2020-07-24 13:37:56
    文章目录一、VLAN聚合二、MUX VLAN三、QinQ四、VLAN Mapping五、拓扑六、基本配置与分析七、设备完整配置 VLAN特性 映射、聚合、MUX VLAN、QinQ;DHCP,DHCP中继,NAT,ACL。 一、VLAN聚合 聚合VLAN产生的背景: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,704
精华内容 42,281
关键字:

聚合