时序数据合并场景加速分析和实现 - 复合索引，窗口分组查询加速，变态递归加速...

时序数据合并场景加速分析和实现 - 复合索引，窗口分组查询加速，变态递归加速

作者

digoal

日期

2016-11-28

标签

PostgreSQL , 数据合并 , 时序数据 , 复合索引 , 窗口查询

背景

在很多场景中，都会有数据合并的需求。

例如记录了表的变更明细(insert,update,delete)，需要合并明细，从明细中快速取到每个PK的最新值。

又比如有很多传感器，不断的在上报数据，要快速的取出每个传感器的最新状态。

对于这种需求，可以使用窗口查询，但是如何加速，如何快速的取出批量数据呢？

这个是有优化的门道的。

传感器例子

假设传感器数据不断的上报，用户需要查询当前最新的，每个传感器上报的值。

创建测试表如下，

create unlogged table sort_test(id serial8 primary key,  -- 主键c2 int,  -- 传感器IDc3 int  -- 传感器值
);  写入1000万传感器测试数据
postgres=# insert into sort_test (c2,c3) select random()*100000, random()*100 from generate_series(1,10000000);
INSERT 0 10000000

查询语句如下

postgres=# explain (analyze,verbose,timing,costs,buffers) select id,c2,c3 from (select id,c2,c3,row_number() over(partition by c2 order by id desc) rn from sort_test) t where rn=1;QUERY PLAN                                                                            
------------------------------------------------------------------------------------------------------------------------------------------------------------------Subquery Scan on t  (cost=10001512045.83..10001837045.83 rows=50000 width=16) (actual time=23865.363..44033.984 rows=100001 loops=1)Output: t.id, t.c2, t.c3Filter: (t.rn = 1)Rows Removed by Filter: 9899999Buffers: shared hit=54055, temp read=93801 written=93801->  WindowAgg  (cost=10001512045.83..10001712045.83 rows=10000000 width=24) (actual time=23865.351..41708.460 rows=10000000 loops=1)Output: sort_test.id, sort_test.c2, sort_test.c3, row_number() OVER (?)Buffers: shared hit=54055, temp read=93801 written=93801->  Sort  (cost=10001512045.83..10001537045.83 rows=10000000 width=16) (actual time=23865.335..31540.089 rows=10000000 loops=1)Output: sort_test.id, sort_test.c2, sort_test.c3Sort Key: sort_test.c2, sort_test.id DESCSort Method: external merge  Disk: 254208kBBuffers: shared hit=54055, temp read=93801 written=93801->  Seq Scan on public.sort_test  (cost=10000000000.00..10000154055.00 rows=10000000 width=16) (actual time=0.021..1829.135 rows=10000000 loops=1)Output: sort_test.id, sort_test.c2, sort_test.c3Buffers: shared hit=54055Planning time: 0.194 msExecution time: 44110.560 ms
(18 rows)

优化手段，新增复合索引，避免SORT，注意，id需要desc

postgres=# create index sort_test_1 on sort_test(c2,id desc); 
CREATE INDEX

优化后的SQL性能

postgres=# explain (analyze,verbose,timing,costs,buffers) select id,c2,c3 from (select id,c2,c3,row_number() over(partition by c2 order by id desc) rn from sort_test) t where rn=1;QUERY PLAN                                                                            
------------------------------------------------------------------------------------------------------------------------------------------------------------------Subquery Scan on t  (cost=0.43..542565.80 rows=50000 width=16) (actual time=0.048..33844.843 rows=100001 loops=1)Output: t.id, t.c2, t.c3Filter: (t.rn = 1)Rows Removed by Filter: 9899999Buffers: shared hit=10029020 read=1->  WindowAgg  (cost=0.43..417564.59 rows=10000097 width=24) (actual time=0.042..30490.662 rows=10000000 loops=1)Output: sort_test.id, sort_test.c2, sort_test.c3, row_number() OVER (?)Buffers: shared hit=10029020 read=1->  Index Scan using sort_test_1 on public.sort_test  (cost=0.43..242562.89 rows=10000097 width=16) (actual time=0.030..18347.482 rows=10000000 loops=1)Output: sort_test.id, sort_test.c2, sort_test.c3Buffers: shared hit=10029020 read=1Planning time: 0.216 msExecution time: 33865.321 ms
(13 rows)

如果被取出的数据需要后续的处理，可以使用游标，分批获取，因为不需要显示sort，所以分批获取速度很快，从而加快整个的处理速度。

\timing
begin;
declare c1 cursor for select id,c2,c3 from (select id,c2,c3,row_number() over(partition by c2 order by id desc) rn from sort_test) t where rn=1;
postgres=# fetch 100 from c1;id    | c2 | c3  
---------+----+-----9962439 |  0 |  939711199 |  1 |  529987709 |  2 |  659995611 |  3 |  349998766 |  4 |  129926693 |  5 |  81....9905064 | 98 |  449991592 | 99 |  99
(100 rows)
Time: 31.408 ms  -- 很快就返回

优化前，需要显示SORT，所以使用游标并不能加速，拿到第一条记录是在SORT后的。

drop index sort_test_1;begin;
declare c1 cursor for select id,c2,c3 from (select id,c2,c3,row_number() over(partition by c2 order by id desc) rn from sort_test) t where rn=1;postgres=# fetch 100 from c1;
....
Time: 22524.783 ms  -- sort结束后才开始返回，很慢

增量合并数据同步例子

类似Oracle的物化视图，apply时，对于同一条记录的update并不需要每次update的中间过程都需要执行，只需要执行最后一次的。

因此，也可以利用类似的操作手段，分组取最后一条，

create extension hstore;create unlogged table sort_test1(id serial8 primary key,  -- 主键c2 int,  -- 目标表PKc3 text,  -- insert or update or deletec4 hstore -- row
); create index idx_sort_test1_1 on sort_test1(c2,id desc);select c2,c3,c4 from (select c2,c3,c4,row_number() over(partition by c2 order by id desc) rn from sort_test1) t where rn=1;postgres=# explain select c2,c3,c4 from (select c2,c3,c4,row_number() over(partition by c2 order by id desc) rn from sort_test1) t where rn=1;QUERY PLAN                                             
---------------------------------------------------------------------------------------------------Subquery Scan on t  (cost=0.15..46.25 rows=4 width=68)Filter: (t.rn = 1)->  WindowAgg  (cost=0.15..36.50 rows=780 width=84)->  Index Scan using idx_sort_test1_1 on sort_test1  (cost=0.15..22.85 rows=780 width=76)
(4 rows)

稀疏列的变态优化方法

我们看到前面的优化手段，其实只是消除了SORT，并没有消除扫描的BLOCK数。

如果分组很少时，即稀疏列，还有一种更变态的优化方法，递归查询。

优化方法与这篇文档类似,

《distinct xx和count(distinct xx)的变态递归优化方法》

例子

create type r as (c2 int, c3 int);postgres=# explain (analyze,verbose,timing,costs,buffers) with recursive skip as (  (  select (c2,c3)::r as r from sort_test where id in (select id from sort_test where c2 is not null order by c2,id desc limit 1) )  union all  (  select (select (c2,c3)::r as r from sort_test where id in (select id from sort_test t where t.c2>(s.r).c2 and t.c2 is not null order by c2,id desc limit 1) ) from skip s where (s.r).c2 is not null)    -- 这里的where (s.r).c2 is not null 一定要加, 否则就死循环了. 
)   
select (t.r).c2, (t.r).c3 from skip t where t.* is not null; QUERY PLAN                                                                                           
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------CTE Scan on skip t  (cost=302.97..304.99 rows=100 width=8) (actual time=0.077..4184.770 rows=100001 loops=1)Output: (t.r).c2, (t.r).c3Filter: (t.* IS NOT NULL)Rows Removed by Filter: 1Buffers: shared hit=800947, temp written=476CTE skip->  Recursive Union  (cost=0.91..302.97 rows=101 width=32) (actual time=0.066..3970.580 rows=100002 loops=1)Buffers: shared hit=800947->  Nested Loop  (cost=0.91..2.95 rows=1 width=32) (actual time=0.064..0.066 rows=1 loops=1)Output: ROW(sort_test_1.c2, sort_test_1.c3)::rBuffers: shared hit=8->  HashAggregate  (cost=0.47..0.48 rows=1 width=8) (actual time=0.044..0.044 rows=1 loops=1)Output: sort_test_2.idGroup Key: sort_test_2.idBuffers: shared hit=4->  Limit  (cost=0.43..0.46 rows=1 width=12) (actual time=0.036..0.036 rows=1 loops=1)Output: sort_test_2.id, sort_test_2.c2Buffers: shared hit=4->  Index Only Scan using sort_test_1 on public.sort_test sort_test_2  (cost=0.43..267561.43 rows=10000000 width=12) (actual time=0.034..0.034 rows=1 loops=1)Output: sort_test_2.id, sort_test_2.c2Index Cond: (sort_test_2.c2 IS NOT NULL)Heap Fetches: 1Buffers: shared hit=4->  Index Scan using sort_test_pkey on public.sort_test sort_test_1  (cost=0.43..2.45 rows=1 width=16) (actual time=0.011..0.012 rows=1 loops=1)Output: sort_test_1.id, sort_test_1.c2, sort_test_1.c3Index Cond: (sort_test_1.id = sort_test_2.id)Buffers: shared hit=4->  WorkTable Scan on skip s  (cost=0.00..29.80 rows=10 width=32) (actual time=0.037..0.038 rows=1 loops=100002)Output: (SubPlan 1)Filter: ((s.r).c2 IS NOT NULL)Rows Removed by Filter: 0Buffers: shared hit=800939SubPlan 1->  Nested Loop  (cost=0.92..2.96 rows=1 width=32) (actual time=0.034..0.035 rows=1 loops=100001)Output: ROW(sort_test.c2, sort_test.c3)::rBuffers: shared hit=800939->  HashAggregate  (cost=0.49..0.50 rows=1 width=8) (actual time=0.023..0.023 rows=1 loops=100001)Output: t_1.idGroup Key: t_1.idBuffers: shared hit=400401->  Limit  (cost=0.43..0.48 rows=1 width=12) (actual time=0.021..0.021 rows=1 loops=100001)Output: t_1.id, t_1.c2Buffers: shared hit=400401->  Index Only Scan using sort_test_1 on public.sort_test t_1  (cost=0.43..133557.76 rows=3333333 width=12) (actual time=0.019..0.019 rows=1 loops=100001)Output: t_1.id, t_1.c2Index Cond: ((t_1.c2 > (s.r).c2) AND (t_1.c2 IS NOT NULL))Heap Fetches: 100000Buffers: shared hit=400401->  Index Scan using sort_test_pkey on public.sort_test  (cost=0.43..2.45 rows=1 width=16) (actual time=0.006..0.007 rows=1 loops=100000)Output: sort_test.id, sort_test.c2, sort_test.c3Index Cond: (sort_test.id = t_1.id)Buffers: shared hit=400538Planning time: 0.970 msExecution time: 4209.026 ms
(54 rows)

依旧支持快速的FETCH

postgres=# begin;
BEGIN
Time: 0.079 ms
postgres=# declare cur cursor for with recursive skip as (  (  select (c2,c3)::r as r from sort_test where id in (select id from sort_test where c2 is not null order by c2,id desc limit 1) )  union all  (  select (select (c2,c3)::r as r from sort_test where id in (select id from sort_test t where t.c2>(s.r).c2 and t.c2 is not null order by c2,id desc limit 1) ) from skip s where (s.r).c2 is not null)    -- 这里的where (s.r).c2 is not null 一定要加, 否则就死循环了. 
)   
select (t.r).c2, (t.r).c3 from skip t where t.* is not null; 
DECLARE CURSOR
Time: 1.240 ms
postgres=# fetch 100 from cur;r     
----------(0,93)(1,52)(2,65)
.....(97,78)(98,44)(99,99)
(100 rows)Time: 4.314 ms

使用变态的递归优化，性能提升了10倍，仅仅花了4秒，完成了1000万记录的筛选。

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

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

相关文章

navicat for mysql 数据库备份与还原

navicat for mysql 数据库备份与还原

一, 首先设置, 备份保存路径 工具 -> 选项 点开 其他 -> 日志文件保存路径 二. 开始备份 备份分两种, 一种是以sql保存, 一种是保存为备份 SQL保存 右键点击你要备份的数据库, -> 转储SQL文件 选择位置和文件名 开始转储 导入 建议 删除所有表 或 重新建数据库 同导出…
阅读更多...
DES的原理及python实现

DES的原理及python实现

DES加密算法原理及实现 DES是一种对称加密算法【即发送者与接收者持有相同的密钥】，它的基本原理是将要加密的数据划分为n个64位的块，然后使用一个56位的密钥逐个加密每一个64位的块，得到n个64位的密文块，最后将密文块拼接起来得…
阅读更多...
python按身高体重排队_LeetCode-python 406.根据身高重建队列

python按身高体重排队_LeetCode-python 406.根据身高重建队列

题目链接难度：中等 类型： 数组假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。 编写一个算法来重建这个队列。注意：总人数…
阅读更多...
远程连接mysql数据库，1130问题

远程连接mysql数据库，1130问题

远程或使用非127.0.0.1和localhost地址连接时，出现代号为1130问题， ERROR 1130: Host 192.168.2.159 is not allowed to connect to this MySQL server 猜想这是没有授权，将mysql数据库中user表中host列的localhost改为%，重新启动…
阅读更多...
华为手机充满有提醒吗_2020手机充电速度排名：最快21分钟充满，华为第15名

华为手机充满有提醒吗_2020手机充电速度排名：最快21分钟充满，华为第15名

5G手机扎堆出现，中国5G基站数量也是不断增多，中国移动曾经表态，2020年底将会在全国地级市覆盖5G网络，全民5G时代终于到来！从目前国内手机出货量数据来看，5G手机占比已经达到了六成以上，国产5G手…
阅读更多...
关于移动手机端富文本编辑器qeditor图片上传改造

关于移动手机端富文本编辑器qeditor图片上传改造

日前项目需要在移动端增加富文本编辑，上网找了下，大多数都是针对pc版的，不太兼容手机，当然由于手机屏幕小等原因也限制富文本编辑器的众多强大功能，所以要找的编辑器功能必须是精简的。 找了好久，发现qedit…
阅读更多...
【python】生成器

【python】生成器

生成器 直接总结 创建生成器的方法 生成器表达式：(i for i in [1, 2])yield: 函数中出现yield这个函数就是生成器，函数（生成器）执行到yield时会返回yield后面的值，并暂停，知道下次被唤醒后会从暂停处接着…
阅读更多...
python redis 性能测试台_Redis性能测试

python redis 性能测试台_Redis性能测试

Redis 性能测试Redis 性能测试是通过同时执行多个命令实现的。Redis性能测试主要是通过src文件夹下的redis-benchmark来实现(Linux系统下)语法redis 性能测试的基本命令如下：redis-benchmark [option] [option value]实例以下实例同时执行 10000 个请求来检测性能&a…
阅读更多...
Java IO 系统

Java IO 系统

Java IO系统 File类 用来处理文件目录，既可以代表一个特定文件的名称，也可以代表一组文件的名称，如果代表的是一个文件组，可以调用File.list()方法返回一个字符数组。 list()不传递任何参数时返回该目录下所有文件或文件名的字…
阅读更多...
Linux Crontab 任务管理工具命令以及示例

Linux Crontab 任务管理工具命令以及示例

Crontab 是 Linux 平台下的一款用于循环执行例行任务的工具,Linux 系统由 cron (crond) 这个系统服务来控制任务 , Linux系统本来就有很多的计划任务需要启动 , 所以这个系统服务是默认开机启动的 。 Linux 为使用者提供的计划任务的命令就是 Crontab Crontab 是 Linux 下用来周…
阅读更多...
Linux 网络编程详解一（IP套接字结构体、网络字节序，地址转换函数）

Linux 网络编程详解一（IP套接字结构体、网络字节序，地址转换函数）

IPv4套接字地址结构 struct sockaddr_in {uint8_t sinlen;（4个字节）sa_family_t sin_family;（4个字节）in_port_t sin_port;（2个字节）struct in_addr sin_addr;（4个字节）char sin_zer…
阅读更多...
地籍cad的lisp程序大集合_AutoCAD-LISP程序100例

地籍cad的lisp程序大集合_AutoCAD-LISP程序100例

{:soso_e179:}AutoCAD-LISP程序100例.JPG (143.82 KB, 下载次数: 28)2011-10-18 14:42 上传有说明很好！顶如果您使用 AutoCAD,下面的内容对您一定有帮助。在某些方面能大大提高您的工作效率。下面的程序均以源程序方式给出，您可以使用、参考、修改它。bg…
阅读更多...
javascript中数组的22种方法

javascript中数组的22种方法

前面的话数组总共有22种方法，本文将其分为对象继承方法、数组转换方法、栈和队列方法、数组排序方法、数组拼接方法、创建子数组方法、数组删改方法、数组位置方法、数组归并方法和数组迭代方法共10类来进行详细介绍对象继承方法数组是一种特殊的对象，继…
阅读更多...
javascript/jquery高度宽度详情解说分析

javascript/jquery高度宽度详情解说分析

为什么80%的码农都做不了架构师？>>> 一、window对象表示浏览器中打开的窗口 二、window对象可以省略 一、document对象是window对象的一部分 二、浏览器的HTML文档成为Document对象 window.location和document.location window对象的location属性引用的…
阅读更多...
农用地包括哪些地类_土地地类一览表

农用地包括哪些地类_土地地类一览表

一级类二级类三级类含义编号三大类名称编号名称编号名称1农用地指直接用于农业生产的土地，包括耕地，园地，林地，牧草地及其他的农业用地11耕地指种植农作物、土地，包括熟地、新开发复垦整理地，休闲地、轮歇地…
阅读更多...
红黑树插入时的自平衡

红黑树插入时的自平衡

红黑树插入时的自平衡 红黑树实质上是一棵自平衡的二叉查找树，引入带颜色的节点也是为了方便在进行插入或删除操作时，如果破坏了二叉查找树的平衡性能通过一系列变换保持平衡。 红黑树的性质 每个节点要么是红色，要么是黑色根节点必须是黑…
阅读更多...
说一下自己对于 Linux 哲学的理解

说一下自己对于 Linux 哲学的理解

查阅了一些资料，官方的哲学思想貌似是： 一切皆文件由众多单一目的的小程序，一个程序只实现一个功能，多个程序组合完成复杂任务文本文件保存配置信息尽量避免与用户交互什么，你问我的理解？哲学思想&#xff…
阅读更多...
UWP学习记录

UWP学习记录

微软{X:Bind}、{Binding}资料网站 &#xff1a; https://msdn.microsoft.com/windows/uwp/xaml-platform/x-bind-markup-extension在View的ItemTemplate中绑定ViewModel的方法&#xff1a;1 <ItemsControl Name"XX" ItemsSource"{x:Bind VM.XXModels,ModeOne…
阅读更多...
dw1000信标码_DW1000方案工牌型UWB标签，助力10厘米高精度室内定位！

dw1000信标码_DW1000方案工牌型UWB标签，助力10厘米高精度室内定位！

DW1000方案工牌型UWB标签&#xff0c;助力10厘米高精度室内定位&#xff01;发布日期&#xff1a;2019-04-01 浏览次数&#xff1a;244次微能信息(95power)推出一款工牌型UWB标签VDU1510 &#xff0c;广泛应用于超宽带UWB定位系统&#xff0c;最高可实现10cm高精度人员定位。工…
阅读更多...
【Java】HashMap源码（1.7）

【Java】HashMap源码（1.7）

Life is not a ridiculous number of life, the meaning of life lies in life itself HashMap源码 散列集 数组和链表可以保持元素插入的顺序&#xff0c;对数组来说&#xff0c;他的优点是拥有连续的存储空间&#xff0c;因此可以使用元素下标快速访问&#xff0c;但缺点在…
阅读更多...
最新文章

Copyright @ 2022~2023