ElasticSearch - 深入解析 Elasticsearch Composite Aggregation 的分页与去重机制

文章目录

  • Pre
  • 概述
  • 什么是 `composite aggregation`？
  • 基本结构
  • `after` 参数的作用
    • 问题背景：传统分页的重复问题
    • `after` 的设计理念
    • 响应示例
  • `after` 如何确保数据不重复
    • 核心机制
    • Example
      • 步骤 1: 创建测试数据
        • 创建索引
        • 插入测试数据
      • 步骤 2: 查询第一页结果
        • 查询第一页
        • 返回结果
      • 步骤 3: 查询第二页结果
        • 查询第二页
        • 返回结果
      • 步骤 4: 查询第三页结果
        • 查询第三页
        • 返回结果
      • 步骤 5: 查询第四页结果
        • 查询第四页
        • 返回结果
      • 验证
      • 小结
  • 总结

在这里插入图片描述

Pre

ElasticSearch - 使用 Composite Aggregation 实现桶的分页查询

概述

在 Elasticsearch 中，composite aggregation 提供了一种高效的分页聚合方式，尤其适用于数据量较大的场景。为了避免传统分页中常见的重复数据问题，composite aggregation 引入了 after 参数。本文将详细探讨 after 参数的机制，以及它如何确保数据不重复。

什么是 composite aggregation？

composite aggregation 是一种支持多字段分组的聚合类型，其独特之处在于可以实现分页功能。这种分页能力通过 size 参数控制每次返回的桶数量，并通过 after 参数获取下一页的结果。

基本结构

一个典型的 composite aggregation 查询：

GET /your_index_name/_search
{"size": 0,"aggs": {"my_composite_agg": {"composite": {"size": 10,"sources": [{"field1": {"terms": {"field": "your_field_name1"}}},{"field2": {"terms": {"field": "your_field_name2"}}}]}}}
}

在以上查询中：

  • sources 定义了按哪些字段分组，字段顺序决定了分组键（bucket key）的生成顺序。
  • size 定义每页的桶数量。
  • 响应结果中的 after_key 用于获取下一页数据。

after 参数的作用

问题背景：传统分页的重复问题

在使用基于偏移量的分页（如 from 和 size 参数）时，数据更新可能导致页码错乱或重复。例如：

  • 如果在分页过程中有新文档插入或更新，数据偏移可能导致某些文档重复出现在多页结果中。

after 的设计理念

after 参数是 composite aggregation 特有的，它记录了上一页最后一个桶的键值（after_key），并以此为起点获取下一页数据。这种方式基于排序键，确保分页过程始终连续、无重复。

响应示例

以下是一个分页查询的响应：

{"aggregations": {"my_composite_agg": {"buckets": [{ "key": { "field1": "value1", "field2": "value2" }, "doc_count": 10 },{ "key": { "field1": "value3", "field2": "value4" }, "doc_count": 8 }],"after_key": { "field1": "value3", "field2": "value4" }}}
}

在下一页查询中，可以使用 after_key 作为起点：

GET /your_index_name/_search
{"size": 0,"aggs": {"my_composite_agg": {"composite": {"size": 10,"after": { "field1": "value3", "field2": "value4" },"sources": [{"field1": {"terms": {"field": "your_field_name1"}}},{"field2": {"terms": {"field": "your_field_name2"}}}]}}}
}

after 如何确保数据不重复

核心机制

  1. 排序保证一致性

    • composite aggregation 内部按照 sources 中定义的字段顺序生成桶键，并进行字典序排序。
    • 每次查询的结果顺序是固定的，即使数据发生变动，也不会影响之前已返回的桶键。

  2. 分页起点记录

    • 每次查询都会返回 after_key，表示当前页最后一个桶的键值。
    • 在下一页查询中，Elasticsearch 从该键值开始，获取后续的桶。

  3. 跳过已处理的桶

    • Elasticsearch 在执行查询时，会严格按照 after_key 跳过已处理的桶，确保每个桶仅返回一次。

  4. 游标精准定位

    • after_key 明确表示从上次分页结果的最后一个桶之后开始读取，而不会重新读取已经返回的桶。
    • 查询总是基于 key 的排序位置，按顺序依次获取后续的桶。

  5. 无偏移计算

    • 不使用 from 和 size 等偏移量参数，避免了由于数据插入或删除导致的分页偏移问题。

  6. 全局一致性排序

    • 所有桶的排序是全局确定的，即使数据分布在多个分片中，也能按照统一的顺序返回。
    • Elasticsearch 会在多个分片中进行合并排序，从而确保每次分页的桶是唯一且无重复的。

Example

步骤 1: 创建测试数据

我们创建一个名为 test_index 的索引，并插入一些测试数据。数据包含一个字段 category，我们将根据这个字段进行聚合分页。

创建索引
PUT /test_index
{"mappings": {"properties": {"category": {"type": "keyword"},"value": {"type": "integer"}}}
}
插入测试数据
POST /test_index/_bulk
{ "index": {} }
{ "category": "A", "value": 10 }
{ "index": {} }
{ "category": "A", "value": 20 }
{ "index": {} }
{ "category": "A", "value": 30 }
{ "index": {} }
{ "category": "B", "value": 40 }
{ "index": {} }
{ "category": "B", "value": 50 }
{ "index": {} }
{ "category": "B", "value": 60 }
{ "index": {} }
{ "category": "C", "value": 70 }
{ "index": {} }
{ "category": "C", "value": 80 }
{ "index": {} }
{ "category": "C", "value": 90 }
{ "index": {} }
{ "category": "D", "value": 100 }
{ "index": {} }
{ "category": "D", "value": 110 }
{ "index": {} }
{ "category": "D", "value": 120 }
{ "index": {} }
{ "category": "E", "value": 130 }
{ "index": {} }
{ "category": "E", "value": 140 }
{ "index": {} }
{ "category": "E", "value": 150 }
{ "index": {} }
{ "category": "F", "value": 160 }
{ "index": {} }
{ "category": "F", "value": 170 }
{ "index": {} }
{ "category": "F", "value": 180 }
{ "index": {} }
{ "category": "G", "value": 190 }
{ "index": {} }
{ "category": "G", "value": 200 }
{ "index": {} }
{ "category": "G", "value": 210 }
{ "index": {} }
{ "category": "H", "value": 220 }
{ "index": {} }
{ "category": "H", "value": 230 }
{ "index": {} }
{ "category": "H", "value": 240 }
{ "index": {} }
{ "category": "I", "value": 250 }
{ "index": {} }
{ "category": "I", "value": 260 }
{ "index": {} }
{ "category": "I", "value": 270 }
{ "index": {} }
{ "category": "J", "value": 280 }
{ "index": {} }
{ "category": "J", "value": 290 }
{ "index": {} }
{ "category": "J", "value": 300 }
{ "index": {} }
{ "category": "K", "value": 310 }
{ "index": {} }
{ "category": "K", "value": 320 }
{ "index": {} }
{ "category": "K", "value": 330 }
{ "index": {} }
{ "category": "L", "value": 340 }
{ "index": {} }
{ "category": "L", "value": 350 }
{ "index": {} }
{ "category": "L", "value": 360 }
{ "index": {} }
{ "category": "M", "value": 370 }
{ "index": {} }
{ "category": "M", "value": 380 }
{ "index": {} }
{ "category": "M", "value": 390 }
{ "index": {} }
{ "category": "N", "value": 400 }
{ "index": {} }
{ "category": "N", "value": 410 }
{ "index": {} }
{ "category": "N", "value": 420 }
{ "index": {} }
{ "category": "O", "value": 430 }
{ "index": {} }
{ "category": "O", "value": 440 }
{ "index": {} }
{ "category": "O", "value": 450 }
{ "index": {} }
{ "category": "P", "value": 460 }
{ "index": {} }
{ "category": "P", "value": 470 }
{ "index": {} }
{ "category": "P", "value": 480 }
{ "index": {} }
{ "category": "Q", "value": 490 }
{ "index": {} }
{ "category": "Q", "value": 500 }
{ "index": {} }
{ "category": "Q", "value": 510 }
{ "index": {} }
{ "category": "R", "value": 520 }
{ "index": {} }
{ "category": "R", "value": 530 }
{ "index": {} }
{ "category": "R", "value": 540 }
{ "index": {} }
{ "category": "S", "value": 550 }
{ "index": {} }
{ "category": "S", "value": 560 }
{ "index": {} }
{ "category": "S", "value": 570 }
{ "index": {} }
{ "category": "T", "value": 580 }
{ "index": {} }
{ "category": "T", "value": 590 }
{ "index": {} }
{ "category": "T", "value": 600 }
{ "index": {} }
{ "category": "U", "value": 610 }
{ "index": {} }
{ "category": "U", "value": 620 }
{ "index": {} }
{ "category": "U", "value": 630 }
{ "index": {} }
{ "category": "V", "value": 640 }
{ "index": {} }
{ "category": "V", "value": 650 }
{ "index": {} }
{ "category": "V", "value": 660 }
{ "index": {} }
{ "category": "W", "value": 670 }
{ "index": {} }
{ "category": "W", "value": 680 }
{ "index": {} }
{ "category": "W", "value": 690 }
{ "index": {} }
{ "category": "X", "value": 700 }
{ "index": {} }
{ "category": "X", "value": 710 }
{ "index": {} }
{ "category": "X", "value": 720 }
{ "index": {} }
{ "category": "Y", "value": 730 }
{ "index": {} }
{ "category": "Y", "value": 740 }
{ "index": {} }
{ "category": "Y", "value": 750 }
{ "index": {} }
{ "category": "Z", "value": 760 }
{ "index": {} }
{ "category": "Z", "value": 770 }
{ "index": {} }
{ "category": "Z", "value": 780 }

步骤 2: 查询第一页结果

我们使用 composite aggregation 查询第一页，设置每页返回 3 个桶。

查询第一页
GET /test_index/_search
{"size": 0,"aggs": {"composite_agg": {"composite": {"size": 10,"sources": [{ "category": { "terms": { "field": "category" } } }]}}}
}
返回结果
 {"took" : 11,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 78,"relation" : "eq"},"max_score" : null,"hits" : [ ]},"aggregations" : {"composite_agg" : {"after_key" : {"category" : "J"},"buckets" : [{"key" : {"category" : "A"},"doc_count" : 3},{"key" : {"category" : "B"},"doc_count" : 3},{"key" : {"category" : "C"},"doc_count" : 3},{"key" : {"category" : "D"},"doc_count" : 3},{"key" : {"category" : "E"},"doc_count" : 3},{"key" : {"category" : "F"},"doc_count" : 3},{"key" : {"category" : "G"},"doc_count" : 3},{"key" : {"category" : "H"},"doc_count" : 3},{"key" : {"category" : "I"},"doc_count" : 3},{"key" : {"category" : "J"},"doc_count" : 3}]}}
}

步骤 3: 查询第二页结果

我们使用第一页返回的 after_key 值 { "category": "J" } 来查询第二页。

查询第二页
GET /test_index/_search
{"size": 0,"aggs": {"composite_agg": {"composite": {"size": 10,"after": { "category": "J" },"sources": [{ "category": { "terms": { "field": "category" } } }]}}}
}
返回结果

在这里插入图片描述

步骤 4: 查询第三页结果

使用第二页返回的 after_key 值 { "category": "T" } 查询第三页。

查询第三页
GET /test_index/_search
{"size": 0,"aggs": {"composite_agg": {"composite": {"size": 10,"after": { "category": "T" },"sources": [{ "category": { "terms": { "field": "category" } } }]}}}
}
返回结果

在这里插入图片描述

步骤 5: 查询第四页结果

使用第三页返回的 after_key 值 { "category": "Z" } 查询第三页。

查询第四页
GET /test_index/_search
{"size": 0,"aggs": {"composite_agg": {"composite": {"size": 10,"after": { "category": "Z" },"sources": [{ "category": { "terms": { "field": "category" } } }]}}}
}
返回结果

在这里插入图片描述

验证

通过四次分页查询，我们验证以下几点：

  1. 结果无重复：

    • 每页的结果是唯一的，没有重复桶。例如：
      • 第 1 页返回桶：A, B, C…J
      • 第 2 页返回桶：K, L, M…T
      • 第 3 页返回桶：U, V…Z
      • 第 4 页返回桶：已到最后

  2. 顺序一致：

    • 所有结果按照 category 字段值排序，顺序为 A, B, C, …, Z。

  3. after_key 确保正确游标定位：

    • 使用 after_key 明确标识分页起点，每次从上页的最后一个桶的 key 开始查询，没有遗漏或重复。

小结

  • composite aggregation 使用基于 after_key 的游标机制，可以确保分页查询中数据无重复、无遗漏。
  • composite aggregation 的设计特别适合大规模数据的聚合和分页，是传统 from + size 分页方法的高效替代方案。

通过 after_key 的分页，可以看到每页数据互不重叠，且严格按照 category 字段排序。

总结

传统分页 (from + size)Composite Aggregation (游标)
基于偏移计算，容易因数据变动重复基于游标，桶的顺序和定位稳定无重复
数据量大时性能下降明显高效处理大数据，避免偏移的性能开销
不支持跨分片排序跨分片排序一致性，返回结果无重复或遗漏
  • composite aggregation 使用基于 after_key 的游标机制，可以确保分页查询中数据无重复、无遗漏。
  • composite aggregation 的设计特别适合大规模数据的聚合和分页，是传统 from + size 分页方法的高效替代方案。

composite aggregation 的设计通过排序和 after_key 机制，确保分页查询的每页数据互不重复，且顺序一致。这种特性使其在大数据量的分页聚合中表现出色。如果应用场景需要可靠的分页聚合，可以尝试 composite aggregation

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/65283.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用 Scrapy 抓取网页数据

使用 Scrapy 抓取网页数据

1. Scrapy 简介 Scrapy 是一个流行的 Python 爬虫框架，提供了强大的工具和灵活的扩展机制，用于高效抓取和处理网页数据。它支持异步 I/O，速度快且资源消耗低，非常适合大规模爬取任务。 2. 安装 Scrapy 确保你的 Python 环境版本…
阅读更多...
如何训练Stable Diffusion 模型

如何训练Stable Diffusion 模型

训练Stable Diffusion模型是一个复杂且资源密集的过程，通常需要大量的计算资源（如GPU或TPU）和时间。Stable Diffusion是一种基于扩散模型的生成式AI，能够根据文本提示生成高质量的图像。它的训练过程涉及多个步骤，包括…
阅读更多...
Kafka常用集群配置参数

Kafka常用集群配置参数

Broker log.dirs 这是非常重要的参数，指定了 Broker 需要使用的若干个文件目录路径。比如/home/kafka1,/home/kafka2,/home/kafka3这样 log.dirs /home/kafka1,/home/kafka2,/home/kafka3如果有条件的话你最好保证这些目录挂载到不同的物理磁盘上。 1、可以提升…
阅读更多...
两分钟掌握 TDengine 全部写入方式

两分钟掌握 TDengine 全部写入方式

1. 背景 TDengine 写入过程会涉及很多概念，这些概念目前你是不是还一团乱，参数绑定写入、无模式写入、websocket 写入、RESTFUL 写入 、各种连接器写入等等一堆的写入，都是做什么的，不明白，这里花两分钟时间给你彻底整…
阅读更多...
使用 Docker 在 Ubuntu 下部署 Cloudflared Tunnel 服务器

使用 Docker 在 Ubuntu 下部署 Cloudflared Tunnel 服务器

在现代互联网中，安全和隐私是至关重要的。Cloudflared Tunnel 是 Cloudflare 提供的一种安全隧道解决方案，可以帮助你安全地将本地服务暴露到互联网，而无需暴露你的服务器 IP 地址。通过 Docker 部署 Cloudflared Tunnel，不仅简化…
阅读更多...
快速理解24种设计模式

快速理解24种设计模式

简单工厂模式 建立产品接口类，规定好要实现方法。 建立工厂类，根据传入的参数，实例化所需的类，实例化的类必须实现指定的产品类接口 创建型 单例模式Singleton 保证一个类只有一个实例，并提供一个访问他它的全局…
阅读更多...
数据可视化echarts学习笔记

数据可视化echarts学习笔记

目录，介绍 知识储备 一端操作，多端联动的效果（开启了多个网页，操作一端，多个网页的效果会跟着改变） cmd命令控制面板返回上一级或上上级 在当前目录打开文件： cd 文件名 在Windows命令提示符&am…
阅读更多...
OpenCV相机标定与3D重建(30)过滤二值图像中的小斑点函数filterSpeckles()的使用

OpenCV相机标定与3D重建(30)过滤二值图像中的小斑点函数filterSpeckles()的使用

操作系统：ubuntu22.04 OpenCV版本：OpenCV4.9 IDE:Visual Studio Code 编程语言：C11 算法描述 在视差图中过滤掉小的噪声斑点（speckles）。 cv::filterSpeckles 是 OpenCV 库中的一个函数，用于过滤图像或视…
阅读更多...
C语言期末复习笔记（中）

C语言期末复习笔记（中）

目录 五、选择控制结构 1.算法中的概念及描述方法 2.关系运算符和逻辑表达式 3.条件运算符和条件表达式 4.两种多分支if 5.switch语句 6.逻辑运算符和逻辑表达式 六、循环控制结构 1.控制循环的方式 2.控制非法输入 3.选择三种循环的一般原则 4.猜数游戏 5.嵌套循环…
阅读更多...
android jetpack compose Model对象更新变量 UI不更新、不刷新问题

android jetpack compose Model对象更新变量 UI不更新、不刷新问题

以前是搞老本行Android原生开发的，因为工作原因，一直在用vue小程序；因为一些工作需要，又需要用到Android原生开发，建了个项目，打开源码一看，天塌了！！！我以前的…
阅读更多...
Python的Pandas--Series的创建和实现

Python的Pandas--Series的创建和实现

1.Series函数的格式： pandas.Series(data,index,dtype,name,copy) data：一组数据（ndarray类型、list、dict等类）或标量值 index：数据索引标签。如果不指定，默认为整数，从0开始 dtype&#x…
阅读更多...
python通过正则匹配SQL

python通过正则匹配SQL

pattern r"(?:[^;]|(?:\\.|[^])*);" sql_list [match.group().strip() for match in re.finditer(pattern, execute_sql) if match.group().strip()]for sql in sql_list:print(sql)(?:[^;]|(?:\\.|[^])*); 匹配 连续的非分号内容 或 单引号包裹的字符串&#…
阅读更多...
利用Gurobi追溯模型不可行原因的四种方案及详细案例

利用Gurobi追溯模型不可行原因的四种方案及详细案例

文章目录 1. 引言2. 追溯不可行集的四种方法2.1 通过约束增减进行判断2.2 通过computeIIS函数获得冲突集2.3 利用 feasRelaxS() 或 feasRelax() 函数辅助排查2.4 利用 IIS Force 属性1. 引言 模型不可行是一个让工程师头疼的问题，对于复杂模型而言，导致模型不可行的原因可能…
阅读更多...
算法工程化工程师

算法工程化工程师

算法工程化工程师是一种结合算法研究与工程开发能力的技术职位，主要职责是将算法从理论研究到实际落地，应用到各种工业或商业场景中。以下是关于这个职位的一些核心内容： 核心职责： 算法实现与优化： 将数学模型或算法…
阅读更多...
MySQL和HBase的对比

MySQL和HBase的对比

Mysql ：关系型数据库，主要面向 OLTP ，支持事务，支持二级索引，支持 sql ，支持主从、 Group Replication 架构模型（此处以 Innodb 为例，不涉及别的存储引擎）。 HBase &am…
阅读更多...
mybatis-plus自动填充时间的配置类实现

mybatis-plus自动填充时间的配置类实现

mybatis-plus自动填充时间的配置类实现 在实际操作过程中，我们并不希望创建时间、修改时间这些来手动进行，而是希望通过自动化来完成，而mybatis-plus则也提供了自动填充功能来实现这一操作，接下来，就来了解一下mybatis…
阅读更多...
【软件工程】十万字知识点梳理 | 期末复习专用

【软件工程】十万字知识点梳理 | 期末复习专用

原创文章，禁止转载。 文章目录 图CRC卡片用例图类图状态图活动图泳道图软件质量因素自顶向下集成自底向上集成人员与工作量之间的关系时序图关键路径软件结构基本路径测试判定表数据流图（DFD）体系结构设计问题数据字典挣值分析等价划分程序流程图PAD | N-S燃尽图甘特图对象模…
阅读更多...
STM32完全学习——FLASH上FATFS文件管理系统

STM32完全学习——FLASH上FATFS文件管理系统

一、需要移植的接口 我们通过看官网的手册，可以看到我们只要完成下面函数的实现，就可以完成移植。我们这里只移植前5个函数，获取时间的函数我们不在这里移植。 二、移植接口函数 DSTATUS disk_status (BYTE pdrv /* Physical drive nmuber…
阅读更多...
安卓帧率获取

安卓帧率获取

背景 性能优化，经常用到一些指标，诸如帧率、功耗等。对于普通app来讲， 之前一直使用gfxinfo指令获取丢帧率。但是这个指令无法获取游戏的帧率，查阅资料，发现SurfaceFlinger可以获取游戏帧率。 帧率获取原理 获取当前f…
阅读更多...
Redis - Token JWT 概念解析及双token实现分布式session存储实战

Redis - Token JWT 概念解析及双token实现分布式session存储实战

Token 定义：令牌，访问资源接口（API）时所需要的资源凭证 一、Access Token 定义：访问资源接口（API）时所需要的资源凭证，存储在客户端 组成 组成部分说明uid用户唯一的身份标识time…
阅读更多...
最新文章

Copyright @ 2022~2023