PostgreSQL分区使用传统方法

分区的概念是把大型表逻辑分解为小块的更好的性能数据库。

内置的PostgreSQL分区技术的方法

范围分区
表分区
散列分区

何时使用分区

批量数据加载和删除操作可以执行使用附加的分区特征和有效分离。
确切的点表将受益于分区取决于应用程序。然而,经验法则是,表的大小应该超过数据库服务器的物理内存。
数据增长,可以创建子分区,这提高了性能,也可以删除旧的分区通过使他们独立的或完全放弃他们。

分区的好处

可以提高查询性能DDL和DML操作在某些情况下,特别是当最严重的被访问的行表的单个分区或少量的分区如下解释。
当查询或更新访问一个大比例的一个分区,可以提高性能通过使用顺序扫描的分区,而不是使用一个索引,这将要求随机访问读取分散在整个表。
将分区表或删除分区表可以通过使用DROP table和截断表,分别通过删除操作减少负载。

范围分区

数据库分区是基于一个特定范围的列与数据日期和数值。

在这里,作为一个例子,我创建了一个表范围分区和分区表为每个季度日期列。

创建表的员工(INT id NOt NULL、帧VARCHAR (20), lname VARCHAR(20),捐赠日期不是NULL,加入日期NOt NULL)分区的范围(加入);

1 2	创建表员工 ( id INT 不零 , 帧 VARCHAR ( 20. ) , lname VARCHAR ( 20. ) , 强加于人日期不零 , 加入日期不零 ) 分区通过范围 ( 加入 ) ;

创建员工表employees_q1分区值(2022-01-01)(2022-04-01);创建员工表employees_q2分区值(2022-04-01)(2022-07-01);创建员工表employees_q3分区值(2022-07-01)(2022-10-01);创建员工表employees_q4分区值(2022-10-01)(2023-01-01);

创建表 employees_q1 分区的员工为值从 ( “2022-01-01” ) 来 ( “2022-04-01” ) ;

创建表 employees_q2 分区的员工为值从 ( “2022-04-01” ) 来 ( “2022-07-01” ) ;

创建表 employees_q3 分区的员工为值从 ( “2022-07-01” ) 来 ( “2022-10-01” ) ;

创建表 employees_q4 分区的员工为值从 ( “2022-10-01” ) 来 ( “2023-01-01” ) ;

范围分区表中所示的结构。

d +员工分区表”。员工" Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description --------+-----------------------+-----------+----------+---------+----------+-------------+--------------+------------- id | integer | | not null | | plain | | | fname | character varying(20) | | | | extended | | | lname | character varying(20) | | | | extended | | | dob | date | | not null | | plain | | | joined | date | | not null | | plain | | | Partition key: RANGE (joined) Partitions: employees_q1 FOR VALUES FROM ('2022-01-01') TO ('2022-04-01'), employees_q2 FOR VALUES FROM ('2022-04-01') TO ('2022-07-01'), employees_q3 FOR VALUES FROM ('2022-07-01') TO ('2022-10-01'), employees_q4 FOR VALUES FROM ('2022-10-01') TO ('2023-01-01')

d + 员工

分区表 “public.employees”

列 | 类型 | 排序 | 可以为空 | 默认的 | 存储 | 压缩 | 统计数据目标 | 描述

- - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - -

id | 整数 | | 不零 | | 平原 | | |

帧 | 字符不同 ( 20. ) | | | | 扩展 | | |

强加于人 | 日期 | | 不零 | | 平原 | | |

加入 | 日期 | | 不零 | | 平原 | | |

分区关键 : 范围 ( 加入 )

分区 : employees_q1 为值从 ( “2022-01-01” ) 来 ( “2022-04-01” ) ,

employees_q2 为值从 ( “2022-04-01” ) 来 ( “2022-07-01” ) ,

employees_q3 为值从 ( “2022-07-01” ) 来 ( “2022-10-01” ) ,

employees_q4 为值从 ( “2022-10-01” ) 来 ( “2023-01-01” )

插入一些随机的数据条目,一年365天。

插入雇员(id、帧lname,强加于人,加入)值(generate_series(365),(数组(“奥斯瓦尔德”,“亨利”,“鲍勃”,' Vennie '])[地板(随机()* 4 + 1)),(数组(‘狮子’,‘杰克’,‘窝’,“黛西”,'伍迪'])[地板(随机()* 5 + 1],“1995-01-01”::日期+ trunc(随机()* 366 * 3)::int, generate_series(“1/1/2022”:日期、“12/31/2022”::日期,1天));

插入成员工 ( id , 帧 , lname , 强加于人 , 加入 ) 值 ( generate_series ( 1 , 365年 ) , ( 数组 ( 奥斯瓦尔德的 , “亨利。” , “鲍勃” , “Vennie” ] ) ( 地板上 ( 随机 ( ) * 4 + 1 ) ] ,

( 数组 ( “狮子座” , “杰克” , “窝” , “黛西” , “木质” ] ) ( 地板上 ( 随机 ( ) * 5 + 1 ) ] , “1995-01-01” :: 日期 + trunc ( 随机 ( ) * 366年 * 3 ) :: int ,

generate_series ( “1/1/2022” :: 日期 , “12/31/2022” :: 日期 , “一天” ) ) ;

范围分区数据被视为低于分布在其分区。

选择employees_q1、employees_q2 employees_q3、employees_q4 employees_totalcnt从(SELECT COUNT(*)从employees_q1) employees_q1,(从employees_q2 SELECT COUNT(*))作为employees_q2,(从employees_q3 SELECT COUNT(*))作为employees_q3,(从employees_q3 SELECT COUNT(*))作为employees_q4,(从员工选择COUNT (*)) employees_totalcnt;employees_q1 | employees_q2 | employees_q3 | employees_q4 | employees_totalcnt - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -(90) |(91) |(92) |(92) |(365)(1行)

选择员工 _第一季度 , 员工 _第二季 , 员工 _第三季 , 员工 _第四季度 , employees_totalcnt 从

( 选择数 ( * ) 从员工 _第一季度 ) 作为 employees_q1 ,

( 选择数 ( * ) 从员工 _第二季 ) 作为 employees_q2 ,

( 选择数 ( * ) 从员工 _第三季 ) 作为 employees_q3 ,

( 选择数 ( * ) 从员工 _第三季 ) 作为员工 _第四季度 ,

( 选择数 ( * ) 从员工 ) 作为员工 _totalcnt ;

employees_q1 | employees_q2 | employees_q3 | employees_q4 | employees_totalcnt

- - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

( 90年 ) | ( 91年 ) | ( 92年 ) | ( 92年 ) | ( 365年 )

( 1 行 )

DDL操作的性能

这里,我创建了一个表没有一个分区和插入相同的数据,类似于分区表。

查询计划被认为更适合当执行DDL操作数据与单个分区或更少的分区。

创建表employees_nopartition (INT id NOt NULL、帧VARCHAR (20), lname VARCHAR(20),捐赠日期不是NULL,加入日期NOt NULL);

1	创建表 employees_nopartition ( id INT 不零 , 帧 VARCHAR ( 20. ) , lname VARCHAR ( 20. ) , 强加于人日期不零 , 加入日期不零 ) ;

插入employees_nopartition (id、帧、lname强加于人,加入)值(generate_series(365),(数组(“奥斯瓦尔德”,“亨利”,“鲍勃”,' Vennie '])[地板(随机()* 4 + 1)),(数组(‘狮子’,‘杰克’,‘窝’,“黛西”,'伍迪'])[地板(随机()* 5 + 1],“1995-01-01”::日期+ trunc(随机()* 366 * 3)::int, generate_series(“1/1/2022”:日期、“12/31/2022”::日期,1天));

插入成 employees_nopartition ( id , 帧 , lname , 强加于人 , 加入 ) 值 ( generate_series ( 1 , 365年 ) , ( 数组 ( 奥斯瓦尔德的 , “亨利。” , “鲍勃” , “Vennie” ] ) ( 地板上 ( 随机 ( ) * 4 + 1 ) ] ,

( 数组 ( “狮子座” , “杰克” , “窝” , “黛西” , “木质” ] ) ( 地板上 ( 随机 ( ) * 5 + 1 ) ] , “1995-01-01” :: 日期 + trunc ( 随机 ( ) * 366年 * 3 ) :: int ,

generate_series ( “1/1/2022” :: 日期 , “12/31/2022” :: 日期 , “一天” ) ) ;

解释select *从employees_nopartition在哪里加入>=“2022-05-12”和 joined < '2022-06-10'; QUERY PLAN ------------------------------------------------------------------------------ Seq Scan on employees_nopartition (cost=0.00..8.47 rows=29 width=22) Filter: ((joined >= '2022-05-12'::date) AND (joined < '2022-06-10'::date)) (2 rows)

解释 select * 从 employees_nopartition 在哪里加入 & gt ; = “2022-05-12” 和加入 & lt ; “2022-06-10” ;

查询计划

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Seq 扫描在 employees_nopartition ( 成本 = 0.00,8.47 行 = 29日宽度 = 22 )

过滤器 : ( ( 加入 & gt ; = “2022-05-12” :: 日期 ) 和 ( 加入 & lt ; “2022-06-10” :: 日期 ) )

( 2 行 )

在这里,我们可以看到一个更好的查询计划时数据都是从比数据获取的非分区表的分区表。

解释select *从员工加入祝辞= ' 2022-05-12 ',加入& lt;“2022-06-10”;查询计划- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Seq扫描employees_q2(成本= 0.00,2.37行= 29宽度= 22)过滤器:((加入祝辞=“2022-05-12”::日期)和(加入& lt;“2022-06-10”::日期))(2行)

解释 select * 从员工在哪里加入 & gt ; = “2022-05-12” 和加入 & lt ; “2022-06-10” ;

查询计划

Seq 扫描在 employees_q2 ( 成本 = 0.00,2.37 行 = 29日宽度 = 22 )

过滤器 : ( ( 加入 & gt ; = “2022-05-12” :: 日期 ) 和 ( 加入 & lt ; “2022-06-10” :: 日期 ) )

( 2 行 )

表分区

数据库分区基于键值(s)或离散值和分区也可以用列的表达式(表达式)列表(范围),这是解释如下:

例如,我创建了一个表分区列表和一些list-partitioned表,并插入一些随机数据与1000行。

创建表的销售(INT id NOT NULL,分支VARCHAR(3),文本类型,INT)分区的列表(分支机构);

1	创建表销售 ( id INT 不零 , 分支 VARCHAR ( 3 ) , 类型文本 , 量 int ) 分区通过列表 ( 分支 ) ;

创建表HYD_sales分区的销售价值(海德拉巴的);创建表BLR_sales分区的销售价值(“BLR”);创建表DEL_sales分区的销售价值(DEL);创建表TPT_sales分区的销售价值(TPT);

创建表 HYD_sales 分区的销售为值在 ( 海德拉巴的 ) ;

创建表 BLR_sales 分区的销售为值在 ( “BLR” ) ;

创建表 DEL_sales 分区的销售为值在 ( “▽” ) ;

创建表 TPT_sales 分区的销售为值在 ( “课程” ) ;

插入销售(id、分支类型、数量)值(generate_series(1000),(数组(海德拉巴,“BLR”,“▽”,“课程”))(地板(随机()* 4 + 1)),(数组(“笔记本电脑”,“打印机”,“Hardisks”、“桌面”、“监控”))(地板(随机()* 5 + 1)),(随机()* 200000)::int);raybet雷竞技竞猜在线官网

1 2	插入成销售 ( id , 分支 , 类型 , 量 ) 值 ( generate_series ( 1 , 1000年 ) , ( 数组 ( 海德拉巴的 , “BLR” , “▽” , “课程” ] ) ( 地板上 ( 随机 ( ) * 4 + 1 ) ] , ( 数组 ( “笔记本电脑” , “打印机” , “Hardisks” , “桌面” , “raybet雷竞技竞猜在线官网监控” ] ) ( 地板上 ( 随机 ( ) * 5 + 1 ) ] , ( 随机 ( ) * 200000年 ) :: int ) ;

列表分区的表定义如下:

d +销售分区表”。销售" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------+----------------------+-----------+----------+---------+----------+--------------+------------- id | integer | | not null | | plain | | branch | character varying(3) | | | | extended | | type | text | | | | extended | | amount | integer | | | | plain | | Partition key: LIST (branch) Partitions: blr_sales FOR VALUES IN ('BLR'), del_sales FOR VALUES IN ('DEL'), hyd_sales FOR VALUES IN ('HYD'), tpt_sales FOR VALUES IN ('TPT')

d + 销售

分区表 “public.sales”

列 | 类型 | 排序 | 可以为空 | 默认的 | 存储 | 统计数据目标 | 描述

- - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - -

id | 整数 | | 不零 | | 平原 | |

分支 | 字符不同 ( 3 ) | | | | 扩展 | |

类型 | 文本 | | | | 扩展 | |

量 | 整数 | | | | 平原 | |

分区关键 : 列表 ( 分支 )

分区 : blr_sales 为值在 ( “BLR” ) ,

del_sales 为值在 ( “▽” ) ,

hyd_sales 为值在 ( 海德拉巴的 ) ,

tpt_sales 为值在 ( “课程” )

分区数据分布在其分区如下所示:

选择blr_sales、del_sales hyd_sales、tpt_sales total_cnt从(SELECT COUNT(*)从blr_sales) blr_sales,(从del_sales SELECT COUNT(*))作为del_sales,(从hyd_sales SELECT COUNT(*))作为hyd_sales,(从tpt_sales SELECT COUNT(*))作为tpt_sales, (SELECT COUNT(*)从销售)total_cnt;blr_sales | del_sales | hyd_sales | tpt_sales | total_cnt - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - -(262) |(258) |(228) |(252) |(1001)(1行)

选择 blr _销售 , ▽ _销售 , hyd_sales , tpt_sales , total_cnt 从

( 选择数 ( * ) 从 blr _销售 ) 作为 blr_sales , ( 选择数 ( * ) 从 ▽ _销售 ) 作为 del_sales ,

( 选择数 ( * ) 从海德拉巴 _销售 ) 作为 hyd_sales , ( 选择数 ( * ) 从课程的 _销售 ) 作为课程的 _销售 ,

( 选择数 ( * ) 从销售 ) 作为 total_cnt ;

blr_sales | del_sales | hyd_sales | tpt_sales | total_cnt

- - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - -

( 262年 ) | ( 258年 ) | ( 228年 ) | ( 252年 ) | ( 1001年 )

( 1 行 )

使用表达式列表分区

例如,我创建了一个表列表分区使用的表达式列。

创建表捐助者(INT id NOt NULL,名字VARCHAR (20), bloodgroup VARCHAR (15), last_donated日期、contact_num VARCHAR(10))分区的列表(左(上层(bloodgroup), 3));

1 2	创建表捐助者 ( id INT 不零 , 的名字 VARCHAR ( 20. ) , bloodgroup VARCHAR ( 15 ) , last_donated 日期 , contact_num VARCHAR ( 10 ) ) 分区通过列表 ( 左 ( 上 ( bloodgroup ) , 3 ) ) ;

创建表A_positive分区值的捐助者(“+”);创建表A_negative分区值的捐助者(“-”);创建表B_positive分区值的捐助者(“B +”);创建表B_negative分区值的捐助者(B -);创建表AB_positive分区值的捐助者(AB +);创建表AB_negative分区值的捐助者(AB -);创建表O_positive分区值的捐助者(' O + ');创建表O_negative分区值的捐助者(' O - ');

创建表 A_positive 分区的捐助者为值在 ( “+” ) ;

创建表 A_negative 分区的捐助者为值在 ( “- - -” ) ;

创建表 B_positive 分区的捐助者为值在 ( “B +” ) ;

创建表 B_negative 分区的捐助者为值在 ( “B -” ) ;

创建表 AB_positive 分区的捐助者为值在 ( “AB +” ) ;

创建表 AB_negative 分区的捐助者为值在 ( “AB - - - - - -” ) ;

创建表 O_positive 分区的捐助者为值在 ( “O +” ) ;

创建表 O_negative 分区的捐助者为值在 ( “啊——” ) ;

列表分区的表定义如下:

d +捐助者分区表“公共。捐助者" Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description --------------+-----------------------+-----------+----------+---------+----------+-------------+--------------+------------- id | integer | | not null | | plain | | | name | character varying(20) | | | | extended | | | bloodgroup | character varying(15) | | | | extended | | | last_donated | date | | | | plain | | | contact_num | character varying(10) | | | | extended | | | Partition key: LIST ("left"(upper((bloodgroup)::text), 3)) Partitions: a_negative FOR VALUES IN ('A- '), a_positive FOR VALUES IN ('A+ '), ab_negative FOR VALUES IN ('AB-'), ab_positive FOR VALUES IN ('AB+'), b_negative FOR VALUES IN ('B- '), b_positive FOR VALUES IN ('B+ '), o_negative FOR VALUES IN ('O- '), o_positive FOR VALUES IN ('O+ ')

d + 捐助者

分区表 “public.donors”

列 | 类型 | 排序 | 可以为空 | 默认的 | 存储 | 压缩 | 统计数据目标 | 描述

- - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - -

id | 整数 | | 不零 | | 平原 | | |

的名字 | 字符不同 ( 20. ) | | | | 扩展 | | |

last_donated | 日期 | | | | 平原 | | |

分区关键 : 列表 ( “左” ( 上 ( ( bloodgroup ) :: 文本 ) , 3 ) )

分区 : a_negative 为值在 ( “- - -” ) ,

a_positive 为值在 ( “+” ) ,

ab_negative 为值在 ( “AB - - - - - -” ) ,

ab_positive 为值在 ( “AB +” ) ,

b_negative 为值在 ( “B -” ) ,

b_positive 为值在 ( “B +” ) ,

o_negative 为值在 ( “啊——” ) ,

o_positive 为值在 ( “O +” )

在这里,我一些随机插入100行。

插入捐助者(id、名称、bloodgroup last_donated, contact_num)值(generate_series (100),“user_”| | trunc(随机()* 100),(数组(“A +集团”,“A -集团”,“O -集团”,“O +集团”,“AB +集团”,“AB -集团”,“B +集团”,“B -集团”))(地板(随机()* 8 + 1)),“2022-01-01”::日期+ trunc(随机()* 366 * 1)::int,演员(1000000000 +地板(随机()* 9000000000)为bigint));

插入成捐助者 ( id , 的名字 , bloodgroup , 去年 _捐赠 , contact_num ) 值 ( generate_series ( 1 , One hundred. ) , “user_” | | trunc ( 随机 ( ) * One hundred. ) ,

( 数组 ( “一群+” , ——组织的 , “啊——集团” , “O +集团” , “AB +集团” , “AB集团” , “B +集团” , “B -集团” ] ) ( 地板上 ( 随机 ( ) * 8 + 1 ) ] , “2022-01-01” :: 日期 + trunc ( 随机 ( ) * 366年 * 1 ) :: int ,

投 ( 1000000000 + 地板上 ( 随机 ( ) * 9000000000 ) 作为长整型数字 ) ) ;

与表达分布在它的分区是分区数据列表所示:

选择a_negative、a_positive ab_negative、ab_positive b_negative, b_positive, o_negative, o_positive, total_cnt从(SELECT COUNT(*)从a_negative) a_negative,(从a_positive SELECT COUNT(*))作为a_positive,(从ab_negative SELECT COUNT(*))作为ab_negative,(从ab_positive SELECT COUNT(*))作为ab_positive,(从b_negative SELECT COUNT(*))作为b_negative,(从b_positive SELECT COUNT(*))作为b_positive,(从o_positive SELECT COUNT(*))作为o_positive,(从o_negative SELECT COUNT(*))作为o_negative,(从捐赠者选择COUNT (*)) total_cnt;a_negative | a_positive | ab_negative | ab_positive | b_negative | b_positive | o_negative | o_positive | total_cnt - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - -(9) |(19) |(10) |(12) |(12) |(10) |(18) |(10) |(100)(1行)

选择一个 _负 , 一个 _积极的 , ab _负 , ab _积极的 , b _负 , b _积极的 , o _负 , o _积极的 , total_cnt 从

( 选择数 ( * ) 从一个 _负 ) 作为 a_negative , ( 选择数 ( * ) 从一个 _积极的 ) 作为 a_positive ,

( 选择数 ( * ) 从 ab _负 ) 作为 ab_negative , ( 选择数 ( * ) 从 ab _积极的 ) 作为 ab _积极的 ,

( 选择数 ( * ) 从 b _负 ) 作为 b_negative , ( 选择数 ( * ) 从 b _积极的 ) 作为 b _积极的 ,

( 选择数 ( * ) 从 o _积极的 ) 作为 o _积极的 , ( 选择数 ( * ) 从 o _负 ) 作为 o_negative ,

( 选择数 ( * ) 从捐助者 ) 作为 total_cnt ;

- - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - -

( 9 ) | ( 19 ) | ( 10 ) | ( 12 ) | ( 12 ) | ( 10 ) | ( 18 ) | ( 10 ) | ( One hundred. )

( 1 行 )

DML操作的性能

这里有一个例子所示的表,没有创建分区和插入相同的数据类似的分区表。

下面我创建了一个表没有分区并与1000行显示插入一些随机数据查询性能。

创建表sales_nopartition (INT id NOT NULL,分支VARCHAR(3),文本类型,INT);

1	创建表 sales_nopartition ( id INT 不零 , 分支 VARCHAR ( 3 ) , 类型文本 , 量 int ) ;

插入sales_nopartition (id、分支类型、数量)值(generate_series(1000),(数组(海德拉巴,“BLR”、“▽”,“课程”))(地板(随机()* 4 + 1)),(数组(“笔记本电脑”,“打印机”,“Hardisks”、“桌面”、“监控”))(地板(随机()* 5 + 1)),(随机()* 200000)::int);raybet雷竞技竞猜在线官网

插入成 sales_nopartition ( id , 分支 , 类型 , 量 ) 值 ( generate_series ( 1 , 1000年 ) ,

( 数组 ( 海德拉巴的 , “BLR” , “▽” , “课程” ] ) ( 地板上 ( 随机 ( ) * 4 + 1 ) ] ,

( 数组 ( “笔记本电脑” , “打印机” , “Hardisks” , “桌面” , “raybet雷竞技竞猜在线官网监控” ] ) ( 地板上 ( 随机 ( ) * 5 + 1 ) ] , ( 随机 ( ) * 200000年 ) :: int ) ;

更新查询性能

解释更新sales_nopartition设置类型=“智能手表”,分支=“海德拉巴”;查询计划- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -更新sales_nopartition(成本= 0.00 . . 19.50行= 229宽度= 50)→Seq扫描sales_nopartition(成本= 0.00 . . 19.50行= 229宽度= 50)过滤器:((分支)::文本=“海德拉巴”::文本)(3行)

解释更新 sales_nopartition 集类型 = “智能手表” 在哪里分支 = 海德拉巴的 ;

查询计划

更新在 sales_nopartition ( 成本 = 0.00,19.50 行 = 229年宽度 = 50 )

- - - - - - & gt ; Seq 扫描在 sales_nopartition ( 成本 = 0.00,19.50 行 = 229年宽度 = 50 )

过滤器 : ( ( 分支 ) :: 文本 = 海德拉巴的 :: 文本 )

( 3 行 )

解释更新销售组类型=“智能手表'在分支=“海德拉巴”;查询计划- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -更新销售(成本= 0.00 = 248 . . 5.10行宽度= 50)更新hyd_sales→Seq扫描hyd_sales(成本= 0.00 . . 5.10行= 248宽度= 50)过滤器:((分支)::文本=“海德拉巴”::文本)(4行)

解释更新销售集类型 = “智能手表” 在哪里分支 = 海德拉巴的 ;

查询计划

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

更新在销售 ( 成本 = 0.00,5.10 行 = 248年宽度 = 50 )

更新在 hyd_sales

- - - - - - & gt ; Seq 扫描在 hyd_sales ( 成本 = 0.00,5.10 行 = 248年宽度 = 50 )

过滤器 : ( ( 分支 ) :: 文本 = 海德拉巴的 :: 文本 )

( 4 行 )

删除查询性能

解释从sales_nopartition删除分支=“海德拉巴”;查询计划- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - ------------------------------------------------------ Delete on sales_nopartition (cost=0.00..19.50 rows=229 width=6) -> Seq Scan on sales_nopartition (cost=0.00..19.50 rows=229 width=6) Filter: ((branch)::text = 'HYD'::text) (3 rows)

解释删除从 sales_nopartition 在哪里分支 = 海德拉巴的 ;

查询计划

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

删除在 sales_nopartition ( 成本 = 0.00,19.50 行 = 229年宽度 = 6 )

- - - - - - & gt ; Seq 扫描在 sales_nopartition ( 成本 = 0.00,19.50 行 = 229年宽度 = 6 )

过滤器 : ( ( 分支 ) :: 文本 = 海德拉巴的 :: 文本 )

( 3 行 )

解释删除从销售部门=“海德拉巴”;查询计划- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - -- - -- - - - - --------------------------------------------- Delete on sales (cost=0.00..5.10 rows=248 width=6) Delete on hyd_sales -> Seq Scan on hyd_sales (cost=0.00..5.10 rows=248 width=6) Filter: ((branch)::text = 'HYD'::text) (4 rows)

解释删除从销售在哪里分支 = 海德拉巴的 ;

查询计划

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

删除在销售 ( 成本 = 0.00,5.10 行 = 248年宽度 = 6 )

删除在 hyd_sales

- - - - - - & gt ; Seq 扫描在 hyd_sales ( 成本 = 0.00,5.10 行 = 248年宽度 = 6 )

过滤器 : ( ( 分支 ) :: 文本 = 海德拉巴的 :: 文本 )

( 4 行 )

上面的示例显示删除和更新操作的性能与数据获取从单个分区表有更好的查询计划比没有分区。

散列分区

散列分区表被定义为表分区通过指定模量和每个分区的剩余部分。

每个分区将持有的散列值的行指定的分区键除以模量将产生指定的剩余部分。
散列分区时最好使用每个分区是在不同的表空间驻留在单独的物理磁盘,所以IO同样除以更多的设备。

例如,我创建了一个表与散列分区和分区表5模量。

创建表的学生(int id NOT NULL,名字varchar(30)不是NULL,当然varchar(100),加入日期)由散列(id)分区;

1	创建表学生 ( id int 不零 , 的名字 varchar ( 30. ) 不零 , 课程 varchar ( One hundred. ) , 加入日期 ) 分区通过哈希 ( id ) ;

创建学生值表student_0分区(模量5,剩余0);创建学生值表student_1分区(模量5,剩余1);创建学生值表student_2分区(模量5,剩余2);创建学生值表student_3分区(模量5,剩余3);创建学生值表student_4分区(模量5,其余4);

创建表 student_0 分区的学生为值与 ( 模量 5 , 剩余部分 0 ) ;

创建表 student_1 分区的学生为值与 ( 模量 5 , 剩余部分 1 ) ;

创建表 student_2 分区的学生为值与 ( 模量 5 , 剩余部分 2 ) ;

创建表 student_3 分区的学生为值与 ( 模量 5 , 剩余部分 3 ) ;

创建表 student_4 分区的学生为值与 ( 模量 5 , 剩余部分 4 ) ;

下面的表结构看起来像一个有五个创建分区:

d +学生分区表”。学生" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------+------------------------+-----------+----------+---------+----------+--------------+------------- id | integer | | not null | | plain | | name | character varying(30) | | not null | | extended | | course | character varying(100) | | | | extended | | joined | date | | | | plain | | Partition key: HASH (id) Partitions: student_0 FOR VALUES WITH (modulus 5, remainder 0), student_1 FOR VALUES WITH (modulus 5, remainder 1), student_2 FOR VALUES WITH (modulus 5, remainder 2), student_3 FOR VALUES WITH (modulus 5, remainder 3), student_4 FOR VALUES WITH (modulus 5, remainder 4)

d + 学生

分区表 “public.students”

列 | 类型 | 排序 | 可以为空 | 默认的 | 存储 | 统计数据目标 | 描述

- - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - -

id | 整数 | | 不零 | | 平原 | |

的名字 | 字符不同 ( 30. ) | | 不零 | | 扩展 | |

课程 | 字符不同 ( One hundred. ) | | | | 扩展 | |

加入 | 日期 | | | | 平原 | |

分区关键 : 哈希 ( id )

分区 : student_0 为值与 ( 模量 5 , 剩余部分 0 ) ,

student_1 为值与 ( 模量 5 , 剩余部分 1 ) ,

student_2 为值与 ( 模量 5 , 剩余部分 2 ) ,

student_3 为值与 ( 模量 5 , 剩余部分 3 ) ,

student_4 为值与 ( 模量 5 , 剩余部分 4 )

在这里,我与100000行插入一些随机数据。

插入成学生(id,的名字,课程,joined ) VALUES (generate_series(1, 100000) , 'student_' || trunc(random()*1000) , (array['Finance & Accounts', 'Business Statistics', 'Environmental Science'])[floor(random() * 3 + 1)],'2019-01-01'::date + trunc(random() * 366 * 3)::int);

1 2	插入成学生 ( id , 的名字 , 课程 , 加入 ) 值 ( generate_series ( 1 , 100000年 ) , “student_” \| \| trunc ( 随机 ( ) * 1000年 ) , ( 数组 ( “金融,账户的 , 业务统计的 , “环境科学” ] ) ( 地板上 ( 随机 ( ) * 3 + 1 ) ] , “2019-01-01” :: 日期 + trunc ( 随机 ( ) * 366年 * 3 ) :: int ) ;

我们看到下面的散列分区数据分区表。

选择relname reltuples行从pg_class relname在(‘student_0’,‘student_1’,‘student_2’,‘student_3’,‘student_4’)由relname秩序;relname |行- - - - - - - - - - - - + - - - - - - - student_0 student_1 | 19851 | 20223年student_2 | 19969年student_3 student_4 | 19952 | 20005(5行)

选择 relname , reltuples 作为行从 pg_class 在哪里 relname 在 ( “student_0” , “student_1” , “student_2” , “student_3” , “student_4” ) 订单通过 relname ;

relname | 行

- - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - -

student_0 | 19851年

student_1 | 20223年

student_2 | 19969年

student_3 | 19952年

student_4 | 20005年

( 5 行 )

散列分区的好处

的主要好处是确保数据均匀分布在一个预先确定的数量的分区。
使用散列键有效且高效地在范围不适用的情况下,员工编号,产品编号,等。

如果是范围或列表的数据吗?

为此,我们使用默认分区范围和分区表列表。

范围和列表分区,数据可以存储暂时超出范围,通过创建一个默认分区之后创建一个适当的分区。

哈希分区的表可能没有一个默认的分区,作为散列分区创建一个默认的分区没有任何意义,不需要。

我们看到当我试着插入数据的分区不存在,在这种情况下默认分区如何帮助。

插入销售值(1001年,“岬”,“扫描仪”,190000年);错误:没有分区的关系“销售”发现行细节:行包含失败的分区键(分支)=(岬)。

插入成销售值 ( 1001年 , “岬” , “扫描仪” , 190000年 ) ;

错误 : 没有分区的关系 “销售” 发现为行

细节 : 分区关键的的失败行包含 ( 分支 ) = ( 岬 ) 。

创建销售表sales_default分区默认;创建表插入销售值(1001年,“岬”,“扫描仪”,190000年);插入0 1

创建表 sales_default 分区的销售默认的 ;

创建表

插入成销售值 ( 1001年 , “岬” , “扫描仪” , 190000年 ) ;

插入 0 1

从sales_default select *;id | |分支类型|数量- - - - - - + - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - 1001 | MYS |扫描仪| 190000(1行)

select * 从销售 _默认的 ;

id | 分支 | 类型 | 量

- - - - - - - - - + - - - - - - - - - - - - + - - - - - - - - - - - - - - - + - - - - - - - - - - - -

1001年 | 岬 | 扫描仪 | 190000年

( 1 行 )

所以我们插入的数据发送到默认的分区,分区可以创建后基于默认表中的数据和可用分区。

结论

这里我们讨论了默认分区技术在PostgreSQL使用单一的列,我们还可以创建多列分区。PostgreSQL分区管理器(pg_partman)也可以用于创建和管理有效的分区。进一步的细节将会在即将到来的博客解释道。

另外,请查收以下相关博客供参考:

PostgreSQL分片:概述和MongoDB的比较

执行ETL在PostgreSQL使用继承

雷竞技下载官网Percona分布PostgreSQL提供最好的和最关键的企业组件从开源社区在一个分布,设计和测试一起工作。

raybet52

雷竞技下载官网
raybet雷竞技竞猜在线官网监测和
管理

MySQL 5.7
生命的结束

软件
下载

产品
文档

资源中心

金融
服务

雷竞技下载官网Percona博客

雷竞技下载官网Percona社区中心

雷竞技下载官网Percona活动中心

关于Perc雷竞技下载官网ona

雷竞技下载官网Percona新闻

我们的客户

我们的合作伙伴

职业生涯

联系我们

内置的PostgreSQL分区技术的方法

何时使用分区

分区的好处

范围分区

DDL操作的性能

表分区

使用表达式列表分区

DML操作的性能

散列分区

散列分区的好处

如果是范围或列表的数据吗?

结论

相关的

相关的博客文章

推荐的文章

十对运行MongoDB环境的建议

快20倍备份准备与Percona XtraBackup 8.0.33-雷竞技下载官网28 !

快流备份——引入Percona XtraBackup FIFO平行流雷竞技下载官网

最受欢迎文章

上部署Django Kubernetes PostgreSQL P雷竞技下载官网ercona运营商

自动化Kubernetes MongoDB的物理备份

雷竞技下载官网Percona XtraBackup现在支持我实例配置文件

雷竞技下载官网raybet雷竞技竞猜在线官网监测和管理

MySQL 5.7生命的结束

软件下载

产品文档

资源中心

金融服务

雷竞技下载官网Percona博客

雷竞技下载官网Percona社区中心

雷竞技下载官网Percona活动中心

关于Perc雷竞技下载官网ona

雷竞技下载官网Percona新闻

我们的客户

我们的合作伙伴

职业生涯

联系我们

PostgreSQL分区使用传统方法

内置的PostgreSQL分区技术的方法

何时使用分区

分区的好处

范围分区

DDL操作的性能

表分区

使用表达式列表分区

DML操作的性能

散列分区

散列分区的好处

如果是范围或列表的数据吗?

结论

相关的

分享这篇文章!

想要每周更新清单的最新博客文章?

相关的博客文章

推荐的文章

十对运行MongoDB环境的建议

快20倍备份准备与Percona XtraBackup 8.0.33-雷竞技下载官网28 !

快流备份——引入Percona XtraBackup FIFO平行流雷竞技下载官网

最受欢迎文章

上部署Django Kubernetes PostgreSQL P雷竞技下载官网ercona运营商

自动化Kubernetes MongoDB的物理备份

雷竞技下载官网Percona XtraBackup现在支持我实例配置文件

雷竞技下载官网
raybet雷竞技竞猜在线官网监测和
管理

MySQL 5.7
生命的结束

软件
下载

产品
文档

金融
服务