Bootstrap

mysql分区功能详细实例介

mysql分区功能详细介绍,以及实例

转载  2017年02月16日 18:14:41
  • 10573

一,什么是数据库分区

前段时间写过一篇关于mysql分表的的文章,下面来说一下什么是数据库分区,以mysql为例。mysql数据库中的数据是以文件的形势存在磁盘上的,默认放在/mysql/data下面(可以通过my.cnf中的datadir来查看),一张表主要对应着三个文件,一个是frm存放表结构的,一个是myd存放表数据的,一个是myi存表索引的。如果一张表的数据量太大的话,那么myd,myi就会变的很大,查找数据就会变的很慢,这个时候我们可以利用mysql的分区功能,在物理上将这一张表对应的三个文件,分割成许多个小块,这样呢,我们查找一条数据时,就不用全部查找了,只要知道这条数据在哪一块,然后在那一块找就行了。如果表的数据太大,可能一个磁盘放不下,这个时候,我们可以把数据分配到不同的磁盘里面去。
分区的二种方式

1,横向分区

什么是横向分区呢?就是横着来分区了,举例来说明一下,假如有100W条数据,分成十份,前10W条数据放到第一个分区,第二个10W条数据放到第二个分区,依此类推。也就是把表分成了十分,根用merge来分表,有点像哦。取出一条数据的时候,这条数据包含了表结构中的所有字段,也就是说横向分区,并没有改变表的结构。

2,纵向分区

什么是纵向分区呢?就是竖来分区了,举例来说明,在设计用户表的时候,开始的时候没有考虑好,而把个人的所有信息都放到了一张表里面去,这样这个表里面就会有比较大的字段,如个人简介,而这些简介呢,也许不会有好多人去看,所以等到有人要看的时候,在去查找,分表的时候,可以把这样的大字段,分开来。

感觉数据库的分区好像是切苹果,到底是横着切呢,还是竖着切,根据个人喜好了,mysql提供的分区属于第一种,横向分区,并且细分成很多种方式。下面将举例说明一下。

二,mysql的分区

我觉着吧,mysql的分区只有一种方式,只不过运用不同的算法,規则将数据分配到不同的区块中而已。

1,mysql5.1及以上支持分区功能

安装安装的时候,我们就可以查看一下

  1. [root@BlackGhost mysql-5.1.50]# ./configure --help |grep -A 3 Partition  
  2.  === Partition Support ===  
  3.  Plugin Name:      partition  
  4.  Description:      MySQL Partitioning Support  
  5.  Supports build:   static  
  6.  Configurations:   max, max-no-ndb  
[php]  view plain  copy
  1. [root@BlackGhost mysql-5.1.50]# ./configure --help |grep -A 3 Partition  
  2.  === Partition Support ===  
  3.  Plugin Name:      partition  
  4.  Description:      MySQL Partitioning Support  
  5.  Supports build:   static  
  6.  Configurations:   max, max-no-ndb  

查看一下,如果发现有上面这个东西,说明他是支持分区的,默认是打开的。如果你已经安装过了mysql的话

  1. mysql> show variables like "%part%";  
  2. +-------------------+-------+  
  3. | Variable_name     | Value |  
  4. +-------------------+-------+  
  5. | have_partitioning | YES   |  
  6. +-------------------+-------+  
  7. 1 row in set (0.00 sec)  
[php]  view plain  copy
  1. mysql> show variables like "%part%";  
  2. +-------------------+-------+  
  3. | Variable_name     | Value |  
  4. +-------------------+-------+  
  5. | have_partitioning | YES   |  
  6. +-------------------+-------+  
  7. 1 row in set (0.00 sec)  

查看一下变量,如果支持的话,会有上面的提示的。

2,range分区

按照RANGE分区的表是通过如下一种方式进行分区的,每个分区包含那些分区表达式的值位于一个给定的连续区间内的行

  1. //创建range分区表  
  2. mysql> CREATE TABLE IF NOT EXISTS `user` (  
  3.  ->   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',  
  4.  ->   `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',  
  5.  ->   `sex` int(1) NOT NULL DEFAULT '0' COMMENT '0为男,1为女',  
  6.  ->   PRIMARY KEY (`id`)  
  7.  -> ) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1  
  8.  -> PARTITION BY RANGE (id) (  
  9.  ->     PARTITION p0 VALUES LESS THAN (3),  
  10.  ->     PARTITION p1 VALUES LESS THAN (6),  
  11.  ->     PARTITION p2 VALUES LESS THAN (9),  
  12.  ->     PARTITION p3 VALUES LESS THAN (12),  
  13.  ->     PARTITION p4 VALUES LESS THAN MAXVALUE  
  14.  -> );  
  15. Query OK, 0 rows affected (0.13 sec)  
  16.   
  17. //插入一些数据  
  18. mysql> INSERT INTO `test`.`user` (`name` ,`sex`)VALUES ('tank''0')  
  19.  -> ,('zhang',1),('ying',1),('张',1),('映',0),('test1',1),('tank2',1)  
  20.  -> ,('tank1',1),('test2',1),('test3',1),('test4',1),('test5',1),('tank3',1)  
  21.  -> ,('tank4',1),('tank5',1),('tank6',1),('tank7',1),('tank8',1),('tank9',1)  
  22.  -> ,('tank10',1),('tank11',1),('tank12',1),('tank13',1),('tank21',1),('tank42',1);  
  23. Query OK, 25 rows affected (0.05 sec)  
  24. Records: 25  Duplicates: 0  Warnings: 0  
  25.   
  26. //到存放数据库表文件的地方看一下,my.cnf里面有配置,datadir后面就是  
  27. [root@BlackGhost test]# ls |grep user |xargs du -sh  
  28. 4.0K    user#P#p0.MYD  
  29. 4.0K    user#P#p0.MYI  
  30. 4.0K    user#P#p1.MYD  
  31. 4.0K    user#P#p1.MYI  
  32. 4.0K    user#P#p2.MYD  
  33. 4.0K    user#P#p2.MYI  
  34. 4.0K    user#P#p3.MYD  
  35. 4.0K    user#P#p3.MYI  
  36. 4.0K    user#P#p4.MYD  
  37. 4.0K    user#P#p4.MYI  
  38. 12K    user.frm  
  39. 4.0K    user.par  
  40.   
  41. //取出数据  
  42. mysql> select count(id) as count from user;  
  43. +-------+  
  44. count |  
  45. +-------+  
  46. |    25 |  
  47. +-------+  
  48. 1 row in set (0.00 sec)  
  49.   
  50. //删除第四个分区  
  51. mysql> alter table user drop partition p4;  
  52. Query OK, 0 rows affected (0.11 sec)  
  53. Records: 0  Duplicates: 0  Warnings: 0  
  54.   
  55. /**存放在分区里面的数据丢失了,第四个分区里面有14条数据,剩下的3个分区 
  56. 只有11条数据,但是统计出来的文件大小都是4.0K,从这儿我们可以看出分区的 
  57. 最小区块是4K 
  58. */  
  59. mysql> select count(id) as count from user;  
  60. +-------+  
  61. count |  
  62. +-------+  
  63. |    11 |  
  64. +-------+  
  65. 1 row in set (0.00 sec)  
  66.   
  67. //第四个区块已删除  
  68. [root@BlackGhost test]# ls |grep user |xargs du -sh  
  69. 4.0K    user#P#p0.MYD  
  70. 4.0K    user#P#p0.MYI  
  71. 4.0K    user#P#p1.MYD  
  72. 4.0K    user#P#p1.MYI  
  73. 4.0K    user#P#p2.MYD  
  74. 4.0K    user#P#p2.MYI  
  75. 4.0K    user#P#p3.MYD  
  76. 4.0K    user#P#p3.MYI  
  77. 12K    user.frm  
  78. 4.0K    user.par  
  79.   
  80. /*可以对现有表进行分区,并且会按規则自动的将表中的数据分配相应的分区 
  81. 中,这样就比较好了,可以省去很多事情,看下面的操作*/  
  82. mysql> alter table aa partition by RANGE(id)  
  83.  -> (PARTITION p1 VALUES less than (1),  
  84.  -> PARTITION p2 VALUES less than (5),  
  85.  -> PARTITION p3 VALUES less than MAXVALUE);  
  86. Query OK, 15 rows affected (0.21 sec)   //对15数据进行分区  
  87. Records: 15  Duplicates: 0  Warnings: 0  
  88.   
  89. //总共有15条  
  90. mysql> select count(*) from aa;  
  91. +----------+  
  92. count(*) |  
  93. +----------+  
  94. |       15 |  
  95. +----------+  
  96. 1 row in set (0.00 sec)  
  97.   
  98. //删除一个分区  
  99. mysql> alter table aa drop partition p2;  
  100. Query OK, 0 rows affected (0.30 sec)  
  101. Records: 0  Duplicates: 0  Warnings: 0  
  102.   
  103. //只有11条了,说明对现有的表分区成功了  
  104. mysql> select count(*) from aa;  
  105. +----------+  
  106. count(*) |  
  107. +----------+  
  108. |       11 |  
  109. +----------+  
  110. 1 row in set (0.00 sec)  
[php]  view plain  copy
  1. //创建range分区表  
  2. mysql> CREATE TABLE IF NOT EXISTS `user` (  
  3.  ->   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',  
  4.  ->   `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',  
  5.  ->   `sex` int(1) NOT NULL DEFAULT '0' COMMENT '0为男,1为女',  
  6.  ->   PRIMARY KEY (`id`)  
  7.  -> ) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1  
  8.  -> PARTITION BY RANGE (id) (  
  9.  ->     PARTITION p0 VALUES LESS THAN (3),  
  10.  ->     PARTITION p1 VALUES LESS THAN (6),  
  11.  ->     PARTITION p2 VALUES LESS THAN (9),  
  12.  ->     PARTITION p3 VALUES LESS THAN (12),  
  13.  ->     PARTITION p4 VALUES LESS THAN MAXVALUE  
  14.  -> );  
  15. Query OK, 0 rows affected (0.13 sec)  
  16.   
  17. //插入一些数据  
  18. mysql> INSERT INTO `test`.`user` (`name` ,`sex`)VALUES ('tank''0')  
  19.  -> ,('zhang',1),('ying',1),('张',1),('映',0),('test1',1),('tank2',1)  
  20.  -> ,('tank1',1),('test2',1),('test3',1),('test4',1),('test5',1),('tank3',1)  
  21.  -> ,('tank4',1),('tank5',1),('tank6',1),('tank7',1),('tank8',1),('tank9',1)  
  22.  -> ,('tank10',1),('tank11',1),('tank12',1),('tank13',1),('tank21',1),('tank42',1);  
  23. Query OK, 25 rows affected (0.05 sec)  
  24. Records: 25  Duplicates: 0  Warnings: 0  
  25.   
  26. //到存放数据库表文件的地方看一下,my.cnf里面有配置,datadir后面就是  
  27. [root@BlackGhost test]# ls |grep user |xargs du -sh  
  28. 4.0K    user#P#p0.MYD  
  29. 4.0K    user#P#p0.MYI  
  30. 4.0K    user#P#p1.MYD  
  31. 4.0K    user#P#p1.MYI  
  32. 4.0K    user#P#p2.MYD  
  33. 4.0K    user#P#p2.MYI  
  34. 4.0K    user#P#p3.MYD  
  35. 4.0K    user#P#p3.MYI  
  36. 4.0K    user#P#p4.MYD  
  37. 4.0K    user#P#p4.MYI  
  38. 12K    user.frm  
  39. 4.0K    user.par  
  40.   
  41. //取出数据  
  42. mysql> select count(id) as count from user;  
  43. +-------+  
  44. count |  
  45. +-------+  
  46. |    25 |  
  47. +-------+  
  48. 1 row in set (0.00 sec)  
  49.   
  50. //删除第四个分区  
  51. mysql> alter table user drop partition p4;  
  52. Query OK, 0 rows affected (0.11 sec)  
  53. Records: 0  Duplicates: 0  Warnings: 0  
  54.   
  55. /**存放在分区里面的数据丢失了,第四个分区里面有14条数据,剩下的3个分区 
  56. 只有11条数据,但是统计出来的文件大小都是4.0K,从这儿我们可以看出分区的 
  57. 最小区块是4K 
  58. */  
  59. mysql> select count(id) as count from user;  
  60. +-------+  
  61. count |  
  62. +-------+  
  63. |    11 |  
  64. +-------+  
  65. 1 row in set (0.00 sec)  
  66.   
  67. //第四个区块已删除  
  68. [root@BlackGhost test]# ls |grep user |xargs du -sh  
  69. 4.0K    user#P#p0.MYD  
  70. 4.0K    user#P#p0.MYI  
  71. 4.0K    user#P#p1.MYD  
  72. 4.0K    user#P#p1.MYI  
  73. 4.0K    user#P#p2.MYD  
  74. 4.0K    user#P#p2.MYI  
  75. 4.0K    user#P#p3.MYD  
  76. 4.0K    user#P#p3.MYI  
  77. 12K    user.frm  
  78. 4.0K    user.par  
  79.   
  80. /*可以对现有表进行分区,并且会按規则自动的将表中的数据分配相应的分区 
  81. 中,这样就比较好了,可以省去很多事情,看下面的操作*/  
  82. mysql> alter table aa partition by RANGE(id)  
  83.  -> (PARTITION p1 VALUES less than (1),  
  84.  -> PARTITION p2 VALUES less than (5),  
  85.  -> PARTITION p3 VALUES less than MAXVALUE);  
  86. Query OK, 15 rows affected (0.21 sec)   //对15数据进行分区  
  87. Records: 15  Duplicates: 0  Warnings: 0  
  88.   
  89. //总共有15条  
  90. mysql> select count(*) from aa;  
  91. +----------+  
  92. count(*) |  
  93. +----------+  
  94. |       15 |  
  95. +----------+  
  96. 1 row in set (0.00 sec)  
  97.   
  98. //删除一个分区  
  99. mysql> alter table aa drop partition p2;  
  100. Query OK, 0 rows affected (0.30 sec)  
  101. Records: 0  Duplicates: 0  Warnings: 0  
  102.   
  103. //只有11条了,说明对现有的表分区成功了  
  104. mysql> select count(*) from aa;  
  105. +----------+  
  106. count(*) |  
  107. +----------+  
  108. |       11 |  
  109. +----------+  
  110. 1 row in set (0.00 sec)  

3,list分区

LIST分区中每个分区的定义和选择是基于某列的值从属于一个值列表集中的一个值,而RANGE分 区是从属于一个连续区间值的集合。

  1. //这种方式失败  
  2. mysql> CREATE TABLE IF NOT EXISTS `list_part` (  
  3.  ->   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',  
  4.  ->   `province_id` int(2) NOT NULL DEFAULT 0 COMMENT '省',  
  5.  ->   `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',  
  6.  ->   `sex` int(1) NOT NULL DEFAULT '0' COMMENT '0为男,1为女',  
  7.  ->   PRIMARY KEY (`id`)  
  8.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1  
  9.  -> PARTITION BY LIST (province_id) (  
  10.  ->     PARTITION p0 VALUES IN (1,2,3,4,5,6,7,8),  
  11.  ->     PARTITION p1 VALUES IN (9,10,11,12,16,21),  
  12.  ->     PARTITION p2 VALUES IN (13,14,15,19),  
  13.  ->     PARTITION p3 VALUES IN (17,18,20,22,23,24)  
  14.  -> );  
  15. ERROR 1503 (HY000): A PRIMARY KEY must include all columns in the table's partitioning function 
  16.  
  17. //这种方式成功 
  18. mysql> CREATE TABLE IF NOT EXISTS `list_part` ( 
  19.  ->   `id` int(11) NOT NULL  COMMENT '用户ID', 
  20.  ->   `province_id` int(2) NOT NULL DEFAULT 0 COMMENT '', 
  21.  ->   `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称', 
  22.  ->   `sex` int(1) NOT NULL DEFAULT '0' COMMENT '0为男,1为女'  
  23.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8  
  24.  -> PARTITION BY LIST (province_id) (  
  25.  ->     PARTITION p0 VALUES IN (1,2,3,4,5,6,7,8),  
  26.  ->     PARTITION p1 VALUES IN (9,10,11,12,16,21),  
  27.  ->     PARTITION p2 VALUES IN (13,14,15,19),  
  28.  ->     PARTITION p3 VALUES IN (17,18,20,22,23,24)  
  29.  -> );  
  30. Query OK, 0 rows affected (0.33 sec)  
[javascript]  view plain  copy
  1. //这种方式失败  
  2. mysql> CREATE TABLE IF NOT EXISTS `list_part` (  
  3.  ->   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',  
  4.  ->   `province_id` int(2) NOT NULL DEFAULT 0 COMMENT '省',  
  5.  ->   `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',  
  6.  ->   `sex` int(1) NOT NULL DEFAULT '0' COMMENT '0为男,1为女',  
  7.  ->   PRIMARY KEY (`id`)  
  8.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1  
  9.  -> PARTITION BY LIST (province_id) (  
  10.  ->     PARTITION p0 VALUES IN (1,2,3,4,5,6,7,8),  
  11.  ->     PARTITION p1 VALUES IN (9,10,11,12,16,21),  
  12.  ->     PARTITION p2 VALUES IN (13,14,15,19),  
  13.  ->     PARTITION p3 VALUES IN (17,18,20,22,23,24)  
  14.  -> );  
  15. ERROR 1503 (HY000): A PRIMARY KEY must include all columns in the table's partitioning function  
  16.   
  17. //这种方式成功  
  18. mysql> CREATE TABLE IF NOT EXISTS `list_part` (  
  19.  ->   `id` int(11) NOT NULL  COMMENT '用户ID',  
  20.  ->   `province_id` int(2) NOT NULL DEFAULT 0 COMMENT '省',  
  21.  ->   `name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',  
  22.  ->   `sex` int(1) NOT NULL DEFAULT '0' COMMENT '0为男,1为女'  
  23.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8  
  24.  -> PARTITION BY LIST (province_id) (  
  25.  ->     PARTITION p0 VALUES IN (1,2,3,4,5,6,7,8),  
  26.  ->     PARTITION p1 VALUES IN (9,10,11,12,16,21),  
  27.  ->     PARTITION p2 VALUES IN (13,14,15,19),  
  28.  ->     PARTITION p3 VALUES IN (17,18,20,22,23,24)  
  29.  -> );  
  30. Query OK, 0 rows affected (0.33 sec)  

上面的这个创建list分区时,如果有主銉的话,分区时主键必须在其中,不然就会报错。如果我不用主键,分区就创建成功了,一般情况下,一个张表肯定会有一个主键,这算是一个分区的局限性吧。

如果对数据进行测试,请参考range分区的测试来操作

4,hash分区

HASH分区主要用来确保数据在预先确定数目的分区中平均分布,你所要做的只是基于将要被哈希的列值指定一个列值或表达式,以 及指定被分区的表将要被分割成的分区数量。

  1. mysql> CREATE TABLE IF NOT EXISTS `hash_part` (  
  2.  ->   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '评论ID',  
  3.  ->   `comment` varchar(1000) NOT NULL DEFAULT '' COMMENT '评论',  
  4.  ->   `ip` varchar(25) NOT NULL DEFAULT '' COMMENT '来源IP',  
  5.  ->   PRIMARY KEY (`id`)  
  6.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1  
  7.  -> PARTITION BY HASH(id)  
  8.  -> PARTITIONS 3;  
  9. Query OK, 0 rows affected (0.06 sec)  
[php]  view plain  copy
  1. mysql> CREATE TABLE IF NOT EXISTS `hash_part` (  
  2.  ->   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '评论ID',  
  3.  ->   `comment` varchar(1000) NOT NULL DEFAULT '' COMMENT '评论',  
  4.  ->   `ip` varchar(25) NOT NULL DEFAULT '' COMMENT '来源IP',  
  5.  ->   PRIMARY KEY (`id`)  
  6.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1  
  7.  -> PARTITION BY HASH(id)  
  8.  -> PARTITIONS 3;  
  9. Query OK, 0 rows affected (0.06 sec)  

测试请参考range分区的操作

5,key分区

按照KEY进行分区类似于按照HASH分区,除了HASH分区使用的用 户定义的表达式,而KEY分区的 哈希函数是由MySQL 服务器提供。

  1. mysql> CREATE TABLE IF NOT EXISTS `key_part` (  
  2.  ->   `news_id` int(11) NOT NULL  COMMENT '新闻ID',  
  3.  ->   `content` varchar(1000) NOT NULL DEFAULT '' COMMENT '新闻内容',  
  4.  ->   `u_id` varchar(25) NOT NULL DEFAULT '' COMMENT '来源IP',  
  5.  ->   `create_time` DATE NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '时间'  
  6.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8  
  7.  -> PARTITION BY LINEAR HASH(YEAR(create_time))  
  8.  -> PARTITIONS 3;  
  9. Query OK, 0 rows affected (0.07 sec)  
[php]  view plain  copy
  1. mysql> CREATE TABLE IF NOT EXISTS `key_part` (  
  2.  ->   `news_id` int(11) NOT NULL  COMMENT '新闻ID',  
  3.  ->   `content` varchar(1000) NOT NULL DEFAULT '' COMMENT '新闻内容',  
  4.  ->   `u_id` varchar(25) NOT NULL DEFAULT '' COMMENT '来源IP',  
  5.  ->   `create_time` DATE NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '时间'  
  6.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8  
  7.  -> PARTITION BY LINEAR HASH(YEAR(create_time))  
  8.  -> PARTITIONS 3;  
  9. Query OK, 0 rows affected (0.07 sec)  

测试请参考range分区的操作

6,子分区

子分区是分区表中每个分区的再次分割,子分区既可以使用HASH希分区,也可以使用KEY分区。这 也被称为复合分区(composite partitioning)。

1,如果一个分区中创建了子分区,其他分区也要有子分区

2,如果创建了了分区,每个分区中的子分区数必有相同

3,同一分区内的子分区,名字不相同,不同分区内的子分区名子可以相同(5.1.50不适用)

  1. mysql> CREATE TABLE IF NOT EXISTS `sub_part` (  
  2.  ->   `news_id` int(11) NOT NULL  COMMENT '新闻ID',  
  3.  ->   `content` varchar(1000) NOT NULL DEFAULT '' COMMENT '新闻内容',  
  4.  ->   `u_id`  int(11) NOT NULL DEFAULT 0s COMMENT '来源IP',  
  5.  ->   `create_time` DATE NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '时间'  
  6.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8  
  7.  -> PARTITION BY RANGE(YEAR(create_time))  
  8.  -> SUBPARTITION BY HASH(TO_DAYS(create_time))(  
  9.  -> PARTITION p0 VALUES LESS THAN (1990)(SUBPARTITION s0,SUBPARTITION s1,SUBPARTITION s2),  
  10.  -> PARTITION p1 VALUES LESS THAN (2000)(SUBPARTITION s3,SUBPARTITION s4,SUBPARTITION good),  
  11.  -> PARTITION p2 VALUES LESS THAN MAXVALUE(SUBPARTITION tank0,SUBPARTITION tank1,SUBPARTITION tank3)  
  12.  -> );  
  13. Query OK, 0 rows affected (0.07 sec)  
[php]  view plain  copy
  1. mysql> CREATE TABLE IF NOT EXISTS `sub_part` (  
  2.  ->   `news_id` int(11) NOT NULL  COMMENT '新闻ID',  
  3.  ->   `content` varchar(1000) NOT NULL DEFAULT '' COMMENT '新闻内容',  
  4.  ->   `u_id`  int(11) NOT NULL DEFAULT 0s COMMENT '来源IP',  
  5.  ->   `create_time` DATE NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '时间'  
  6.  -> ) ENGINE=INNODB  DEFAULT CHARSET=utf8  
  7.  -> PARTITION BY RANGE(YEAR(create_time))  
  8.  -> SUBPARTITION BY HASH(TO_DAYS(create_time))(  
  9.  -> PARTITION p0 VALUES LESS THAN (1990)(SUBPARTITION s0,SUBPARTITION s1,SUBPARTITION s2),  
  10.  -> PARTITION p1 VALUES LESS THAN (2000)(SUBPARTITION s3,SUBPARTITION s4,SUBPARTITION good),  
  11.  -> PARTITION p2 VALUES LESS THAN MAXVALUE(SUBPARTITION tank0,SUBPARTITION tank1,SUBPARTITION tank3)  
  12.  -> );  
  13. Query OK, 0 rows affected (0.07 sec)  

官方网站说不同分区内的子分区可以有相同的名字,但是mysql5.1.50却不行会提示以下错误

ERROR 1517 (HY000): Duplicate partition name s1

三,分区管理

1,删除分区

  1. mysql> alter table user drop partition p4;  
[php]  view plain  copy
  1. mysql> alter table user drop partition p4;  

2,新增分区

  1. //range添加新分区  
  2. mysql> alter table user add partition(partition p4 values less than MAXVALUE);  
  3. Query OK, 0 rows affected (0.06 sec)  
  4. Records: 0  Duplicates: 0  Warnings: 0  
  5.   
  6. //list添加新分区  
  7. mysql> alter table list_part add partition(partition p4 values in (25,26,28));  
  8. Query OK, 0 rows affected (0.01 sec)  
  9. Records: 0  Duplicates: 0  Warnings: 0  
  10.   
  11. //hash重新分区  
  12. mysql> alter table hash_part add partition partitions 4;  
  13. Query OK, 0 rows affected (0.12 sec)  
  14. Records: 0  Duplicates: 0  Warnings: 0  
  15.   
  16. //key重新分区  
  17. mysql> alter table key_part add partition partitions 4;  
  18. Query OK, 1 row affected (0.06 sec)    //有数据也会被重新分配  
  19. Records: 1  Duplicates: 0  Warnings: 0  
  20.   
  21. //子分区添加新分区,虽然我没有指定子分区,但是系统会给子分区命名的  
  22. mysql> alter table sub1_part add partition(partition p3 values less than MAXVALUE);  
  23. Query OK, 0 rows affected (0.02 sec)  
  24. Records: 0  Duplicates: 0  Warnings: 0  
  25.   
  26. mysql> show create table sub1_part\G;  
  27. *************************** 1. row ***************************  
  28.  Table: sub1_part  
  29. Create Table: CREATE TABLE `sub1_part` (  
  30.  `news_id` int(11) NOT NULL COMMENT '新闻ID',  
  31.  `content` varchar(1000) NOT NULL DEFAULT '' COMMENT '新闻内容',  
  32.  `u_id` varchar(25) NOT NULL DEFAULT '' COMMENT '来源IP',  
  33.  `create_time` date NOT NULL DEFAULT '0000-00-00' COMMENT '时间'  
  34. ) ENGINE=InnoDB DEFAULT CHARSET=utf8  
  35. !50100 PARTITION BY RANGE (YEAR(create_time))  
  36. SUBPARTITION BY HASH (TO_DAYS(create_time))  
  37. (PARTITION p0 VALUES LESS THAN (1990)  
  38.  (SUBPARTITION s0 ENGINE = InnoDB,  
  39.  SUBPARTITION s1 ENGINE = InnoDB,  
  40.  SUBPARTITION s2 ENGINE = InnoDB),  
  41.  PARTITION p1 VALUES LESS THAN (2000)  
  42.  (SUBPARTITION s3 ENGINE = InnoDB,  
  43.  SUBPARTITION s4 ENGINE = InnoDB,  
  44.  SUBPARTITION good ENGINE = InnoDB),  
  45.  PARTITION p2 VALUES LESS THAN (3000)  
  46.  (SUBPARTITION tank0 ENGINE = InnoDB,  
  47.  SUBPARTITION tank1 ENGINE = InnoDB,  
  48.  SUBPARTITION tank3 ENGINE = InnoDB),  
  49.  PARTITION p3 VALUES LESS THAN MAXVALUE  
  50.  (SUBPARTITION p3sp0 ENGINE = InnoDB,    //子分区的名子是自动生成的  
  51.  SUBPARTITION p3sp1 ENGINE = InnoDB,  
  52.  SUBPARTITION p3sp2 ENGINE = InnoDB))  
  53. 1 row in set (0.00 sec)  
[javascript]  view plain  copy
  1. //range添加新分区  
  2. mysql> alter table user add partition(partition p4 values less than MAXVALUE);  
  3. Query OK, 0 rows affected (0.06 sec)  
  4. Records: 0  Duplicates: 0  Warnings: 0  
  5.   
  6. //list添加新分区  
  7. mysql> alter table list_part add partition(partition p4 values in (25,26,28));  
  8. Query OK, 0 rows affected (0.01 sec)  
  9. Records: 0  Duplicates: 0  Warnings: 0  
  10.   
  11. //hash重新分区  
  12. mysql> alter table hash_part add partition partitions 4;  
  13. Query OK, 0 rows affected (0.12 sec)  
  14. Records: 0  Duplicates: 0  Warnings: 0  
  15.   
  16. //key重新分区  
  17. mysql> alter table key_part add partition partitions 4;  
  18. Query OK, 1 row affected (0.06 sec)    //有数据也会被重新分配  
  19. Records: 1  Duplicates: 0  Warnings: 0  
  20.   
  21. //子分区添加新分区,虽然我没有指定子分区,但是系统会给子分区命名的  
  22. mysql> alter table sub1_part add partition(partition p3 values less than MAXVALUE);  
  23. Query OK, 0 rows affected (0.02 sec)  
  24. Records: 0  Duplicates: 0  Warnings: 0  
  25.   
  26. mysql> show create table sub1_part\G;  
  27. *************************** 1. row ***************************  
  28.  Table: sub1_part  
  29. Create Table: CREATE TABLE `sub1_part` (  
  30.  `news_id` int(11) NOT NULL COMMENT '新闻ID',  
  31.  `content` varchar(1000) NOT NULL DEFAULT '' COMMENT '新闻内容',  
  32.  `u_id` varchar(25) NOT NULL DEFAULT '' COMMENT '来源IP',  
  33.  `create_time` date NOT NULL DEFAULT '0000-00-00' COMMENT '时间'  
  34. ) ENGINE=InnoDB DEFAULT CHARSET=utf8  
  35. !50100 PARTITION BY RANGE (YEAR(create_time))  
  36. SUBPARTITION BY HASH (TO_DAYS(create_time))  
  37. (PARTITION p0 VALUES LESS THAN (1990)  
  38.  (SUBPARTITION s0 ENGINE = InnoDB,  
  39.  SUBPARTITION s1 ENGINE = InnoDB,  
  40.  SUBPARTITION s2 ENGINE = InnoDB),  
  41.  PARTITION p1 VALUES LESS THAN (2000)  
  42.  (SUBPARTITION s3 ENGINE = InnoDB,  
  43.  SUBPARTITION s4 ENGINE = InnoDB,  
  44.  SUBPARTITION good ENGINE = InnoDB),  
  45.  PARTITION p2 VALUES LESS THAN (3000)  
  46.  (SUBPARTITION tank0 ENGINE = InnoDB,  
  47.  SUBPARTITION tank1 ENGINE = InnoDB,  
  48.  SUBPARTITION tank3 ENGINE = InnoDB),  
  49.  PARTITION p3 VALUES LESS THAN MAXVALUE  
  50.  (SUBPARTITION p3sp0 ENGINE = InnoDB,    //子分区的名子是自动生成的  
  51.  SUBPARTITION p3sp1 ENGINE = InnoDB,  
  52.  SUBPARTITION p3sp2 ENGINE = InnoDB))  
  53. 1 row in set (0.00 sec)  

3,重新分区

  1. //range重新分区  
  2. mysql> ALTER TABLE user REORGANIZE PARTITION p0,p1,p2,p3,p4 INTO (PARTITION p0 VALUES LESS THAN MAXVALUE);  
  3. Query OK, 11 rows affected (0.08 sec)  
  4. Records: 11  Duplicates: 0  Warnings: 0  
  5.   
  6. //list重新分区  
  7. mysql> ALTER TABLE list_part REORGANIZE PARTITION p0,p1,p2,p3,p4 INTO (PARTITION p0 VALUES in (1,2,3,4,5));  
  8. Query OK, 0 rows affected (0.28 sec)  
  9. Records: 0  Duplicates: 0  Warnings: 0  
  10.   
  11. //hash和key分区不能用REORGANIZE,官方网站说的很清楚  
  12. mysql> ALTER TABLE key_part REORGANIZE PARTITION COALESCE PARTITION 9;  
  13. ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'PARTITION 9' at line 1  
[php]  view plain  copy
  1. //range重新分区  
  2. mysql> ALTER TABLE user REORGANIZE PARTITION p0,p1,p2,p3,p4 INTO (PARTITION p0 VALUES LESS THAN MAXVALUE);  
  3. Query OK, 11 rows affected (0.08 sec)  
  4. Records: 11  Duplicates: 0  Warnings: 0  
  5.   
  6. //list重新分区  
  7. mysql> ALTER TABLE list_part REORGANIZE PARTITION p0,p1,p2,p3,p4 INTO (PARTITION p0 VALUES in (1,2,3,4,5));  
  8. Query OK, 0 rows affected (0.28 sec)  
  9. Records: 0  Duplicates: 0  Warnings: 0  
  10.   
  11. //hash和key分区不能用REORGANIZE,官方网站说的很清楚  
  12. mysql> ALTER TABLE key_part REORGANIZE PARTITION COALESCE PARTITION 9;  
  13. ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'PARTITION 9' at line 1  

四,分区优点

1,分区可以分在多个磁盘,存储更大一点

2,根据查找条件,也就是where后面的条件,查找只查找相应的分区不用全部查找了

3,进行大数据搜索时可以进行并行处理。

4,跨多个磁盘来分散数据查询,来获得更大的查询吞吐量

80


转载请注明
作者:海底苍鹰
地址:http://blog.51yip.com/mysql/1013.html



MySQL 分表、分区 详解

原创  2018年03月19日 11:32:21
  • 60
分表和分区的目的
大表是指存储百万级乃至千万级条记录的表,这样的表过于庞大,导致数据库在查询和插入的时候耗时太长,性能低下,如果涉及联合查询的情况,性能会更加糟糕。分表和表分区的目的就是减少数据库的负担,提高数据库的效率,通常点来讲就是提高表的增删改查效率

分表和分区不矛盾,可以相互配合的,对于那些大访问量,并且表数据比较多的表,可以采取分表和分区结合的方式 (如果 merge 这种分表方式,不能和分区配合的话,可以用其他的分表试),访问量不大,但是表数据很多的表可以采取分区的方式等


分表
分表是将一个大表按照一定的规则分解成多张具有独立存储空间的实体表,可以称为子表。分表是逻辑上将一个大数据量的表分成多个,可以是水平分也可以是垂直分

根据分表技术对海量数据的优化方式目前有 2种方法 :
     <1> 垂直分割 : 把一个数据量很大的表,根据某个字段的属性或使用频繁程度分类拆分为多个表,或者把一个业务系统的库分到不同的实例上
                   优点 : 拆分后业务清晰,拆分规则明确,系统之间整合或者拓展容易,数据库维护简单
                   缺点 : 部分业务无法使用 JOIN,只能通过接口方式解决,提供系统能够复杂度,受每种业务不同的限制存在性能瓶颈,不容易数据扩展跟性能提高。另外,事务处理复杂,垂直切分后按照业务的分类将表分散到不同的库,会导致有些业务表过于庞大,存在单库读写与存储瓶颈
     <2> 水平分割 : 根据一列或者多列的值把数据行放到多个独立的表里,水平分表方式可以通过多个低配置主机整合起来,实现高性能
                   优点 : 拆分规则抽象好,JION操作基本可以数据库做,不存在单表大数据、高并发的性能瓶颈,应用端改造较少,提高系统的稳定性和负载能力
                   缺点 : 分片事务一致性难以解决,在 MyCAT2.0之前 MySQL5.7之前,还是数据弱XA。数据多次扩展难度维护量大,夸库JOIN性能差
逻辑分表 : 用户自己定义规则,将数据分配到不同的表或数据库中
物理分表 : 由数据库决定,和分区中4中主要分配方式相似


分区
分区是将表的一个数据文件拆分成多个,不同的数据拆分到不同的文件中。这样对于一个数据量非常大的表,有多个数据文件来进行存储,这样就提
高了数据库的 IO 性能。分区后,表面上还是一张表,但数据散列到多个位置根据数据量的大小,分区方式主要有 4 中 :
1> range : 主要用于时间列分区、值范围,行数据基于一个给定连续分区的列值放入分区,如销售类的表,可以根据年来分区存放销售记录
2> list : 面向离散的值,分区要指定的值,当插入指定的数据到指定分区表去,如指定某些值在特定分区里
3> hash : 基于用户定义的表达式的返回值来进行选择的分区,该表达式使用将要插入到表中的这些行的列值进行计算。这个函数可以包含 MySQL 中有效的、产生非负整数值的任何表达式
3> key : 类似于按 HASH分区,区别在于 KEY分区 只支持计算一列或多列,且 MySQL服务器提供其自身的哈希函数,必须有一列或多列包含整数值

注 : 在用 INSERT 插入多行数据的过程中遇到分区为定义的值,MyISAM、InnoDB 存储引擎的处理完全不同,MyISAM 一条不成功 之前的成功值会进入表中,InnoDB 只要一条不成功所有都不成功

1> Range : 主要用于时间列分区,如销售类的表,可以根据年来分区存放销售记录
                   适用场景 : 1> 当需要删除 "旧的" 数据时。如果使用上面最近的那个例子给出的分区方案,只需简单地使用 "ALTER TABLE employees DROP PARTITION p0;" 来删除所有在 1991 年前就已经停止工作的雇员相对应的所有行。对于有大量行的表,这比运行一个如 "DELETE FROM employees WHERE YEAR(separated) <=1990;" 这样的一个 DELETE 查询要有效得多
                                    2> 使用一个包含有日期或时间值,或包含有从一些其他级数开始增长的值的列
                                    3> 经常运行直接依赖于用于分割表的列的查询。例如,当执行一个如 "SELECT COUNT(*) FROM employees WHERE YEAR(separated) = 2000 GROUP BY store_id;" 这样的查询时,MySQL 可以很迅速地确定只有分区 p2 需要扫描,这是因为余下的分区不可能包含有符合该 WHERE 子句的任何记录
# 创建表分区
mysql> CREATE TABLE t_range(id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(10)) PARTITION BY RANGE(id)(
     > partition p0 values less than (1000000),
     > partition p1 values less than (2000000),
     > partition p2 values less than (3000000),
     > partition p3 values less than (4000000),
     > partition p4 values less than maxvalue
     > );

# ll    ## 查看分区文件
总用量 294M
-rw-r-----. 1 mysql mysql 8.6K 3月  10 02:16 article2.frm
-rw-r-----. 1 mysql mysql  25M 3月  10 02:19 article2.ibd
-rw-r-----. 1 mysql mysql 8.6K 3月  10 01:32 article.frm
-rw-r-----. 1 mysql mysql  36M 3月  10 02:14 article.ibd
-rw-r-----. 1 mysql mysql   61 3月   8 21:42 db.opt
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:00 t_base.frm
-rw-r-----. 1 mysql mysql 232M 3月  18 05:02 t_base.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:02 t_range.frm
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p0.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p1.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p2.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p3.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p4.ibd


# 通过文件的大小来查看数据插入的位置
mysql> INSERT INTO t_range(name) VALUES('a');
mysql> INSERT INTO t_range(name) SELECT name FROM t_range;

mysql> SELECT * FROM t_range LIMIT 0,10;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | a    |
|  3 | a    |
|  4 | a    |
|  5 | a    |
|  6 | a    |
|  7 | a    |
|  8 | a    |
|  9 | a    |
| 10 | a    |
+----+------+
10 rows in set (0.01 sec)

# 删除第一个分区
mysql> ALTER TABLE t_range DROP PARTITION p0;
Query OK, 0 rows affected (0.06 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM t_range LIMIT 0,10;
+---------+------+
| id      | name |
+---------+------+
| 1000000 | a    |
| 1000001 | a    |
| 1000002 | a    |
| 1000003 | a    |
| 1000004 | a    |
| 1000005 | a    |
| 1000006 | a    |
| 1000007 | a    |
| 1000008 | a    |
| 1000009 | a    |
+---------+------+
10 rows in set (0.00 sec)
mysql> SHOW CREATE TABLE t_range;
...
| t_range | CREATE TABLE `t_range` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(10) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2097153 DEFAULT CHARSET=utf8
/*!50100 PARTITION BY RANGE (id)
(PARTITION p1 VALUES LESS THAN (2000000) ENGINE = InnoDB,
PARTITION p2 VALUES LESS THAN (3000000) ENGINE = InnoDB,
PARTITION p3 VALUES LESS THAN (4000000) ENGINE = InnoDB,
PARTITION p4 VALUES LESS THAN MAXVALUE ENGINE = InnoDB) */ |
...
1 row in set (0.01 sec)


# ll
总用量 341M
-rw-r-----. 1 mysql mysql 8.6K 3月  10 02:16 article2.frm
-rw-r-----. 1 mysql mysql  25M 3月  10 02:19 article2.ibd
-rw-r-----. 1 mysql mysql 8.6K 3月  10 01:32 article.frm
-rw-r-----. 1 mysql mysql  36M 3月  10 02:14 article.ibd
-rw-r-----. 1 mysql mysql   61 3月   8 21:42 db.opt
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:00 t_base.frm
-rw-r-----. 1 mysql mysql 232M 3月  18 05:02 t_base.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:09 t_range.frm
-rw-r-----. 1 mysql mysql  36M 3月  18 05:08 t_range#P#p1.ibd
-rw-r-----. 1 mysql mysql  11M 3月  18 05:08 t_range#P#p2.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p3.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p4.ibd

2> List : 面向离散的值,分区要指定的值,当插入指定的数据到指定分区表去,LIST() 所包含的列必须全部都是主键,和 Rang 区别在于 LIST 分区是基于列值匹配一个离散值集合中的某个值来进行选择
mysql> CREATE TABLE t_list(id INT AUTO_INCREMENT,province int,PRIMARY KEY(id,province)) PARTITION BY LIST(province)(
     > PARTITION p0 VALUES IN(1,2,3),
     > PARTITION p1 VALUES IN(4,5,6)
     > );

mysql> INSERT INTO t_list(province) VALUES(1),(2),(3),(4),(5),(6);
mysql> INSERT INTO t_list(province) SELECT province FROM t_list;

mysql> ll
总用量 341M
-rw-r-----. 1 mysql mysql 8.6K 3月  10 02:16 article2.frm
-rw-r-----. 1 mysql mysql  25M 3月  10 02:19 article2.ibd
-rw-r-----. 1 mysql mysql 8.6K 3月  10 01:32 article.frm
-rw-r-----. 1 mysql mysql  36M 3月  10 02:14 article.ibd
-rw-r-----. 1 mysql mysql   61 3月   8 21:42 db.opt
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:00 t_base.frm
-rw-r-----. 1 mysql mysql 232M 3月  18 05:02 t_base.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 06:09 t_list.frm
-rw-r-----. 1 mysql mysql  96K 3月  18 06:12 t_list#P#p0.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 06:12 t_list#P#p1.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:09 t_range.frm
-rw-r-----. 1 mysql mysql  36M 3月  18 05:08 t_range#P#p1.ibd
-rw-r-----. 1 mysql mysql  11M 3月  18 05:08 t_range#P#p2.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p3.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p4.ibd

mysql> ALTER TABLE t_list DROP PARTITION p0;
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> SHOW CREATE TABLE t_list;
...
| t_list | CREATE TABLE `t_list` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `province` int(11) NOT NULL,
  PRIMARY KEY (`id`,`province`)
) ENGINE=InnoDB AUTO_INCREMENT=97 DEFAULT CHARSET=utf8
/*!50100 PARTITION BY LIST (province)
(PARTITION p1 VALUES IN (4,5,6) ENGINE = InnoDB) */ |
...
1 row in set (0.00 sec)

mysql> ll
总用量 341M
-rw-r-----. 1 mysql mysql 8.6K 3月  10 02:16 article2.frm
-rw-r-----. 1 mysql mysql  25M 3月  10 02:19 article2.ibd
-rw-r-----. 1 mysql mysql 8.6K 3月  10 01:32 article.frm
-rw-r-----. 1 mysql mysql  36M 3月  10 02:14 article.ibd
-rw-r-----. 1 mysql mysql   61 3月   8 21:42 db.opt
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:00 t_base.frm
-rw-r-----. 1 mysql mysql 232M 3月  18 05:02 t_base.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 06:16 t_list.frm
-rw-r-----. 1 mysql mysql  96K 3月  18 06:12 t_list#P#p1.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:09 t_range.frm
-rw-r-----. 1 mysql mysql  36M 3月  18 05:08 t_range#P#p1.ibd
-rw-r-----. 1 mysql mysql  11M 3月  18 05:08 t_range#P#p2.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p3.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p4.ibd

3> Hash : 如果表中存在主键或是唯一索引时分区列必须是唯一索引的一个组成部分,如果没有主键或唯一索引可以指定任何一个列为分区列。Hash 分区主要用来确保数据在预先确定数目的分区中平均分布。在 RANGE 和 LIST 分区中,必须明确指定一个给定的列值或列值集合应该保存在哪个分区中;而在 Hash 分区中, MySQL 自动完成这些工作
mysql> CREATE TABLE t_hash(id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(10)) PARTITION BY HASH(id) PARTITIONS 4;
Query OK, 0 rows affected (0.02 sec)

mysql> ll
总用量 341M
-rw-r-----. 1 mysql mysql 8.6K 3月  10 02:16 article2.frm
-rw-r-----. 1 mysql mysql  25M 3月  10 02:19 article2.ibd
-rw-r-----. 1 mysql mysql 8.6K 3月  10 01:32 article.frm
-rw-r-----. 1 mysql mysql  36M 3月  10 02:14 article.ibd
-rw-r-----. 1 mysql mysql   61 3月   8 21:42 db.opt
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:00 t_base.frm
-rw-r-----. 1 mysql mysql 232M 3月  18 05:02 t_base.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 06:22 t_hash.frm
-rw-r-----. 1 mysql mysql  96K 3月  18 06:22 t_hash#P#p0.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 06:22 t_hash#P#p1.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 06:22 t_hash#P#p2.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 06:22 t_hash#P#p3.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 06:16 t_list.frm
-rw-r-----. 1 mysql mysql  96K 3月  18 06:12 t_list#P#p1.ibd
-rw-r-----. 1 mysql mysql 8.4K 3月  18 05:09 t_range.frm
-rw-r-----. 1 mysql mysql  36M 3月  18 05:08 t_range#P#p1.ibd
-rw-r-----. 1 mysql mysql  11M 3月  18 05:08 t_range#P#p2.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p3.ibd
-rw-r-----. 1 mysql mysql  96K 3月  18 05:03 t_range#P#p4.ibd

# 按年份进行 Hash 计算, partition by hash(expr)  expr 可以是列或表达式
mysql> create table t_hash2(col1 int not null,col2 date not null,col3 int not null,col4 int not null,unique key (col1,col2)) partition by hash(year(col2))  partitions 4;
4> Key (使用的比较少)

分区注意点 :
1> 重新分区时,如果原分区里面存在 maxvalue 则新的分区里面也必须包含 maxvalue 否则就错误
2> 分区删除时,数据也同样会被删除 alter table p_range drop partition p0;
3> 如果 range 分区列表里面没有 maxvalue 则如有新数据大于现在分区 range 数据值那么这个数据是无法写入到数据库表的
4> 修改表名不需要删除分区后在进行更改,修改表名后分区存储 myd myi 对应也会自动更改。如果希望从所有分区删除所有的数据,但是又保留表的定义和表的分区模式,使用 TRUNCATE TABLE 命令。如果希望改变表的分区而又不丢失数据,使用 "ALTER TABLE … REORGANIZE PARTITION" 语句
5> 对表进行分区时,不论采用哪种分区方式如果表中存在主键那么主键必须在分区列中,表分区的局限性
6> list 方式分区没有类似于 range 那种 less than maxvalue 的写法,也就是说 list 分区表的所有数据都必须在分区字段的值列表集合中
7> 在 MySQL 5.1 版中,同一个分区表的所有分区必须使用同一个存储引擎;例如,不能对一个分区使用 MyISAM,而对另一个使用 InnoDB
8> 分区的名字是不区分大小写的, myp1 与 MYp1 是相同的


版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/chenshun123/article/details/79609419




MySQL表的四种分区类型

一、什么是表分区

通俗地讲表分区是将一大表,根据条件分割成若干个小表。mysql5.1开始支持数据表分区了。 如:某用户表的记录超过了600万条,那么就可以根据入库日期将表分区,也可以根据所在地将表分区。当然也可根据其他的条件分区。

二、为什么要对表进行分区

为了改善大型表以及具有各种访问模式的表的可伸缩性,可管理性和提高数据库效率。

分区的一些优点包括:

  • 与单个磁盘或文件系统分区相比,可以存储更多的数据。
  • 对于那些已经失去保存意义的数据,通常可以通过删除与那些数据有关的分区,很容易地删除那些数据。相反地,在某些情况下,添加新数据的过程又可以通过为那些新数据专门增加一个新的分区,来很方便地实现。通常和分区有关的其他优点包括下面列出的这些。MySQL分区中的这些功能目前还没有实现,但是在我们的优先级列表中,具有高的优先级;我们希望在5.1的生产版本中,能包括这些功能。
  • 一些查询可以得到极大的优化,这主要是借助于满足一个给定WHERE语句的数据可以只保存在一个或多个分区内,这样在查找时就不用查找其他剩余的分区。因为分区可以在创建了分区表后进行修改,所以在第一次配置分区方案时还不曾这么做时,可以重新组织数据,来提高那些常用查询的效率。
  • 涉及到例如SUM()和COUNT()这样聚合函数的查询,可以很容易地进行并行处理。这种查询的一个简单例子如 “SELECT salesperson_id, COUNT (orders) as order_total FROM sales GROUP BY salesperson_id;”。通过“并行”,这意味着该查询可以在每个分区上同时进行,最终结果只需通过总计所有分区得到的结果。
  • 通过跨多个磁盘来分散数据查询,来获得更大的查询吞吐量。

三、分区类型

RANGE分区:基于属于一个给定连续区间的列值,把多行分配给分区。

LIST分区:类似于按RANGE分区,区别在于LIST分区是基于列值匹配一个离散值集合中的某个值来进行选择。

HASH分区:基于用户定义的表达式的返回值来进行选择的分区,该表达式使用将要插入到表中的这些行的列值进行计算。这个函数可以包含MySQL 中有效的、产生非负整数值的任何表达式。

KEY分区:类似于按HASH分区,区别在于KEY分区只支持计算一列或多列,且MySQL服务器提供其自身的哈希函数。必须有一列或多列包含整数值。

RANGE分区

基于属于一个给定连续区间的列值,把多行分配给分区。

这些区间要连续且不能相互重叠,使用VALUES LESS THAN操作符来进行定义。以下是实例。

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT NOT NULL,
    store_id INT NOT NULL
)

partition BY RANGE (store_id) (
    partition p0 VALUES LESS THAN (6),
    partition p1 VALUES LESS THAN (11),
    partition p2 VALUES LESS THAN (16),
    partition p3 VALUES LESS THAN (21)
);

按照这种分区方案,在商店1到5工作的雇员相对应的所有行被保存在分区P0中,商店6到10的雇员保存在P1中,依次类推。注意,每个分区都是按顺序进行定义,从最低到最高。这是PARTITION BY RANGE 语法的要求;在这点上,它类似于C或Java中的“switch … case”语句。对于包含数据(72, ‘Michael’, ‘Widenius’, ’1998-06-25′, NULL, 13)的一个新行,可以很容易地确定它将插入到p2分区中,但是如果增加了一个编号为第21的商店,将会发生什么呢?在这种方案下,由于没有规则把store_id大于20的商店包含在内,服务器将不知道把该行保存在何处,将会导致错误。 要避免这种错误,可以通过在CREATE TABLE语句中使用一个“catchall” VALUES LESS THAN子句,该子句提供给所有大于明确指定的最高值的值:

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT NOT NULL,
    store_id INT NOT NULL
)

PARTITION BY RANGE (store_id) (
    PARTITION p0 VALUES LESS THAN (6),
    PARTITION p1 VALUES LESS THAN (11),
    PARTITION p2 VALUES LESS THAN (16),
    PARTITION p3 VALUES LESS THAN MAXVALUE
);

MAXVALUE 表示最大的可能的整数值。现在,store_id 列值大于或等于16(定义了的最高值)的所有行都将保存在分区p3中。在将来的某个时候,当商店数已经增长到25, 30, 或更多 ,可以使用ALTER TABLE语句为商店21-25, 26-30,等等增加新的分区。在几乎一样的结构中,你还可以基于雇员的工作代码来分割表,也就是说,基于job_code 列值的连续区间。例如——假定2位数字的工作代码用来表示普通(店内的)工人,三个数字代码表示办公室和支持人员,四个数字代码表示管理层,你可以使用下面的语句创建该分区表:

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT NOT NULL,
    store_id INT NOT NULL
)

PARTITION BY RANGE (job_code) (
    PARTITION p0 VALUES LESS THAN (100),
    PARTITION p1 VALUES LESS THAN (1000),
    PARTITION p2 VALUES LESS THAN (10000)
);

在这个例子中, 店内工人相关的所有行将保存在分区p0中,办公室和支持人员相关的所有行保存在分区p1中,管理层相关的所有行保存在分区p2中。在VALUES LESS THAN 子句中使用一个表达式也是可能的。这里最值得注意的限制是MySQL 必须能够计算表达式的返回值作为LESS THAN (<)比较的一部分;因此,表达式的值不能为NULL 。由于这个原因,雇员表的hired, separated, job_code,和store_id列已经被定义为非空(NOT NULL)。除了可以根据商店编号分割表数据外,你还可以使用一个基于两个DATE (日期)中的一个的表达式来分割表数据。例如,假定你想基于每个雇员离开公司的年份来分割表,也就是说,YEAR(separated)的值。实现这种分区模式的CREATE TABLE 语句的一个例子如下所示:

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
)

PARTITION BY RANGE (YEAR(separated)) (
    PARTITION p0 VALUES LESS THAN (1991),
    PARTITION p1 VALUES LESS THAN (1996),
    PARTITION p2 VALUES LESS THAN (2001),
    PARTITION p3 VALUES LESS THAN MAXVALUE
);

在这个方案中,在1991年前雇佣的所有雇员的记录保存在分区p0中,1991年到1995年期间雇佣的所有雇员的记录保存在分区p1中, 1996年到2000年期间雇佣的所有雇员的记录保存在分区p2中,2000年后雇佣的所有工人的信息保存在p3中。

RANGE分区在如下场合特别有用:1)、当需要删除一个分区上的“旧的”数据时,只删除分区即可。如果你使用上面最近的那个例子给出的分区方案,你只需简单地使用”ALTER TABLE employees DROP PARTITION p0;”来删除所有在1991年前就已经停止工作的雇员相对应的所有行。对于有大量行的表,这比运行一个如”DELETE FROM employees WHERE YEAR (separated) <= 1990;”这样的一个DELETE查询要有效得多。 2)、想要使用一个包含有日期或时间值,或包含有从一些其他级数开始增长的值的列。3)、经常运行直接依赖于用于分割表的列的查询。例如,当执行一个如”SELECT COUNT(*) FROM employees WHERE YEAR(separated) = 2000 GROUP BY store_id;”这样的查询时,MySQL可以很迅速地确定只有分区p2需要扫描,这是因为余下的分区不可能包含有符合该WHERE子句的任何记录。

注释:这种优化还没有在MySQL 5.1源程序中启用,但是,有关工作正在进行中。

LIST分区

类似于按RANGE分区,区别在于LIST分区是基于列值匹配一个离散值集合中的某个值来进行选择。

LIST分区通过使用“PARTITION BY LIST(expr)”来实现,其中“expr”是某列值或一个基于某个列值、并返回一个整数值的表达式,然后通过“VALUES IN (value_list)”的方式来定义每个分区,其中“value_list”是一个通过逗号分隔的整数列表。 注释:在MySQL 5.1中,当使用LIST分区时,有可能只能匹配整数列表。

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
);

假定有20个音像店,分布在4个有经销权的地区,如下表所示:

====================

地区      商店ID 号

北区      3, 5, 6, 9, 17

东区      1, 2, 10, 11, 19, 20

西区      4, 12, 13, 14, 18

中心区   7, 8, 15, 16

====================

要按照属于同一个地区商店的行保存在同一个分区中的方式来分割表,可以使用下面的“CREATE TABLE”语句:

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
)

PARTITION BY LIST(store_id)
    PARTITION pNorth VALUES IN (3,5,6,9,17),
    PARTITION pEast VALUES IN (1,2,10,11,19,20),
    PARTITION pWest VALUES IN (4,12,13,14,18),
    PARTITION pCentral VALUES IN (7,8,15,16)
);

这使得在表中增加或删除指定地区的雇员记录变得容易起来。例如,假定西区的所有音像店都卖给了其他公司。那么与在西区音像店工作雇员相关的所有记录(行)可以使用查询“ALTER TABLE employees DROP PARTITION pWest;”来进行删除,它与具有同样作用的DELETE(删除)查询“DELETE query DELETE FROM employees WHERE store_id IN (4,12,13,14,18);”比起来,要有效得多。【要点】:如果试图插入列值(或分区表达式的返回值)不在分区值列表中的一行时,那么“INSERT”查询将失败并报错。例如,假定LIST分区的采用上面的方案,下面的查询将失败:

Sql代码:
INSERT INTO employees VALUES(224, 'Linus', 'Torvalds', '2002-05-01', '2004-10-12', 42, 21);
这是因为“store_id”列值21不能在用于定义分区pNorth, pEast, pWest,或pCentral的值列表中找到。要重点注意的是,LIST分区没有类似如“VALUES LESS THAN MAXVALUE”这样的包含其他值在内的定义。将要匹配的任何值都必须在值列表中找到。

LIST分区除了能和RANGE分区结合起来生成一个复合的子分区,与HASH和KEY分区结合起来生成复合的子分区也是可能的。

HASH分区

基于用户定义的表达式的返回值来进行选择的分区,该表达式使用将要插入到表中的这些行的列值进行计算。这个函数可以包含MySQL 中有效的、产生非负整数值的任何表达式。

要使用HASH分区来分割一个表,要在CREATE TABLE 语句上添加一个“PARTITION BY HASH (expr)”子句,其中“expr”是一个返回一个整数的表达式。它可以仅仅是字段类型为MySQL整型的一列的名字。此外,你很可能需要在后面再添加一个“PARTITIONS num”子句,其中num是一个非负的整数,它表示表将要被分割成分区的数量。

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
)
PARTITION BY HASH(store_id)
PARTITIONS 4;

如果没有包括一个PARTITIONS子句,那么分区的数量将默认为1。例外:对于NDB Cluster(簇)表,默认的分区数量将与簇数据节点的数量相同,这种修正可能是考虑任何MAX_ROWS设置,以便确保所有的行都能合适地插入到分区中。

LINER HASH

MySQL还支持线性哈希功能,它与常规哈希的区别在于,线性哈希功能使用的一个线性的2的幂(powers-of-two)运算法则,而常规哈希使用的是求哈希函数值的模数。线性哈希分区和常规哈希分区在语法上的唯一区别在于,在“PARTITION BY”子句中添加“LINEAR”关键字。

Sql代码:
CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
)
PARTITION BY LINEAR HASH(YEAR(hired))
PARTITIONS 4;

假设一个表达式expr,当使用线性哈希功能时,记录将要保存到的分区是num 个分区中的分区N,其中N是根据下面的算法得到: 1. 找到下一个大于num.的、2的幂,我们把这个值称为V ,它可以通过下面的公式得到: 2. V = POWER(2, CEILING(LOG(2, num))) (例如,假定num是13。那么LOG(2,13)就是3.7004397181411。 CEILING(3.7004397181411)就是4,则V = POWER(2,4), 即等于16)。 3. 设置 N = F(column_list) & (V – 1). 4.    当 N >= num: ·  设置 V = CEIL(V / 2) ·  设置 N = N & (V – 1) 例如,假设表t1,使用线性哈希分区且有4个分区,是通过下面的语句创建的: CREATE TABLE t1 (col1 INT, col2 CHAR(5), col3 DATE) PARTITION BY LINEAR HASH( YEAR(col3) ) PARTITIONS 6; 现在假设要插入两行记录到表t1中,其中一条记录col3列值为’2003-04-14′,另一条记录col3列值为’1998-10-19′。第一条记录将要保存到的分区确定如下: V = POWER(2, CEILING(LOG(2,7))) = 8 N = YEAR(’2003-04-14′) & (8 – 1)    = 2003 & 7    = 3 (3 >= 6 为假(FALSE): 记录将被保存到#3号分区中) 第二条记录将要保存到的分区序号计算如下: V = 8 N = YEAR(’1998-10-19′) & (8-1)   = 1998 & 7   = 6 (6 >= 4 为真(TRUE): 还需要附加的步骤) N = 6 & CEILING(5 / 2)   = 6 & 3   = 2   (2 >= 4 为假(FALSE): 记录将被保存到#2分区中) 按照线性哈希分区的优点在于增加、删除、合并和拆分分区将变得更加快捷,有利于处理含有极其大量(1000吉)数据的表。它的缺点在于,与使用常规HASH分区得到的数据分布相比,各个分区间数据的分布不大可能均衡。

KSY分区

类似于按HASH分区,区别在于KEY分区只支持计算一列或多列,且MySQL服务器提供其自身的哈希函数。必须有一列或多列包含整数值。

Sql代码:
CREATE TABLE tk (
    col1 INT NOT NULL,
    col2 CHAR(5),
    col3 DATE
)
PARTITION BY LINEAR KEY (col1)
PARTITIONS 3;

在KEY分区中使用关键字LINEAR和在HASH分区中使用具有同样的作用,分区的编号是通过2的幂(powers-of-two)算法得到,而不是通过模数算法。

源地址:http://www.xprogrammer.com/1653.html



 

Mysql分区/分片 精炼详解

标签: mysql分区 mysql表分区 mysql
4337人阅读  评论(1)  收藏  举报
  分类:
mysql(10) 
一 分区概念
mysql 5.1 以后支持分区, 有点类似MongoDB中的分片概念.
就是按照一定的规则, 将一个数据库表分解成很多细小的表, 这些细小的表可以是物理的分区, 就是在不同的位置. 但是站在应用的角度来看,分区又是透明的, 整体上看起来还是一个表,不影响使用.

二 分区优点
 1 可以存储更多的内容, 因为物理上可以放在不同的位置.
 2 提高查询效率, 如果分区的时候按照特定的规则, 将符合特定要求数据放在同一个分区内, 比如按照时间分区,查询的时候只要扫描某一个或几个分区即可.

三 查看你的mysql版本库是否支持mysql分区.
     使用命令 SHOW VARIABLES LIKE '%partition%' 查看
      
四 分区键及分区类型
     mysql的表要分区, 那么问题就来了, 到底按照什么分呢,怎么分呢?
     mysql分区有个分区键的概念, 根据分区键去分区的, 分区键要么是主键,或者唯一键, 要么这个表没有主键/ 唯一键.
     举个栗子:  如果你创建一张表, 想按照时间字段年或者月去分区的话,   这个表要么时间字段是主键, 要么没有主键.


  RANGE分区:范围分区, 基于一个给定的连续范围, 把数据分配到不同的分区, 如:时间范围, 或者id自增长的, 1-10万 ,10-20万条数据 
  LIST分区:     类似于按RANGE分区,区别在于LIST分区是基于列值匹配一个离散值集合中的某个值来进行选择。 比如: 表内10条数据, id 1-10 , 将 id等于 1,3,5,7,9 放第一个分区, 2,4,6,8,10 放第二个分区 , 分区键等于特定的某个值
· HASH分区:基于用户定义的表达式的返回值来进行选择的分区,该表达式使用将要插入到表中的这些行的列值进行计算。这个函数可以包含MySQL 中有效的、产生非负整数值的任何表达式。如: 将id为字符串类型的uuid 通过hash计算, 均匀的分配到 4个分区中
· KEY分区:类似于按HASH分区,区别在于KEY分区只支持计算一列或多列,且MySQL 服务器提供其自身的哈希函数。必须有一列或多列包含整数值。
Columns分区:  mysql5.5以后引入的分区,主要解决5.5以前 分区键只能是整形的问题, columns 细分为list columns 和 Range columns 分区, 支持 整型,字符串和时间类型.

   RANGE分区案例:
    按照日期的年分表, 通过Year函数获取分区键的具体年份, VALUES LESS  表示少于1991年的放入p0, 类推
     时间函数,TO_DAYS和  TO_SECONDS(我当前版本5.5支持) 可以让你更精确的分到天甚至秒.    
    PARTITION p3 VALUES LESS THAN MAXVALUE 是防止超过你设置的分区的话,都会存在最后一个分区内.

     CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1989-01-01',
    separated DATE NOT NULL DEFAULT '2016-12-14',
    job_code INT,
    store_id INT
 PARTITION BY RANGE (YEAR(separated)) (
    PARTITION p0 VALUES LESS THAN (1991),
    PARTITION p1 VALUES LESS THAN (1996),
    PARTITION p2 VALUES LESS THAN (2001),
    PARTITION p3 VALUES LESS THAN MAXVALUE
);
RANGE分区应用
     特别适用于有分区条件的查询和统计, 可以非常有效的避免全表扫描. 比如要查询时间范围在1991 年以前的数据, 只会扫描p0 ,可以用mysql explain命令查看.

LIST分区 案例:
按照分类的具体id分区, 如果插入的数据, 超出以下这几个固定值, 则会报错.
mysql 5.5 以后支持 非整数分区了, 下边的分类id 就可以换成具体的分类字符串了
CREATE TABLE employees2 (
    id INT NOT NULL,
    category INT
)PARTITION BY LIST(category)(
    PARTITION p0 VALUES IN (3,5),
    PARTITION p1 VALUES IN (1,2),
    PARTITION p2 VALUES IN (4),
    PARTITION p3 VALUES IN (7,8)
);
HASH分区案例:
主要是针对分区键进行一个散列函数计算, 来确定数据到底放到哪个分区,hash分区主要分为两种, 一种是常规的hash分区, 算法就是取模运算, 另外一种就是线性2的幂的运算.
创建的语法上后者比前者多了一个LINEAR  比如:   PARTITION BY LINEAR    HASH(store_id) PARTITIONS 4;

两者的优缺点: 取模运算的hash分区,在进行分区管理, 比如curd分区的时候, 处理工作会非常的浩大, 归根就是取模算法的问题.
线程运算的hash就没这个问题, 但是相对于取模运算, 这个算法导致数据的存储不是很均匀

CREATE TABLE employees3 (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1989-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
)
PARTITION BY HASH(store_id) PARTITIONS 4;



Key分区案例
跟范围分区很想, 区别是范围分区是通过一个表达式将分区键进行计算得到的一个具体的值来进行分区, 而key分区直接通过一个具体的值进行计算
CREATE TABLE tk (
    col1 INT NOT NULL,
    col2 CHAR(5),
    col3 DATE
)
PARTITION BY LINEAR KEY (col1)
PARTITIONS 3;

https://blog.csdn.net/liuyifeng1920/article/details/53673795



Mysql分表和分区的区别、分库分表介绍与区别

 

分表和分区的区别:

一,什么是mysql分表,分区 

什么是分表,从表面意思上看呢,就是把一张表分成N多个小表,具体请看:mysql分表的3种方法

什么是分区,分区呢就是把一张表的数据分成N多个区块,这些区块可以在同一个磁盘上,也可以在不同的磁盘上,具体请参考mysql分区功能详细介绍,以及实例 

二,mysql分表和分区有什么区别呢 

1,实现方式上 

a),mysql的分表是真正的分表,一张表分成很多表后,每一个小表都是完正的一张表,都对应三个文件,一个.MYD数据文件,.MYI索引文件,.frm表结构文件。 

Sql代码

复制代码
[root@BlackGhost test]# ls |grep user
alluser.MRG
alluser.frm
user1.MYD
user1.MYI
user1.frm
user2.MYD
user2.MYI
user2.frm  
复制代码


简 单说明一下,上面的分表呢是利用了merge存储引擎(分表的一种),alluser是总表,下面有二个分表,user1,user2。他们二个都是独立 的表,取数据的时候,我们可以通过总表来取。这里总表是没有.MYD,.MYI这二个文件的,也就是说,总表他不是一张表,没有数据,数据都放在分表里面。我们来看看.MRG到底是什么东西 

Sql代码
[root@BlackGhost test]# cat alluser.MRG |more
user1
user2
#INSERT_METHOD=LAST 


从上面我们可以看出,alluser.MRG里面就存了一些分表的关系,以及插入数据的方式。可以把总表理解成一个外壳,或者是联接池。 

b),分区不一样,一张大表进行分区后,他还是一张表,不会变成二张表,但是他存放数据的区块变多了。 

复制代码
Sql代码
[root@BlackGhost test]# ls |grep aa
aa#P#p1.MYD
aa#P#p1.MYI
aa#P#p3.MYD
aa#P#p3.MYI
aa.frm
aa.par 
复制代码


从 上面我们可以看出,aa这张表,分为二个区,p1和p3,本来是三个区,被我删了一个区。我们都知道一张表对应三个文件.MYD,.MYI,.frm。分 区呢根据一定的规则把数据文件和索引文件进行了分割,还多出了一个.par文件,打开.par文件后你可以看出他记录了,这张表的分区信息,根分表中 的.MRG有点像。分区后,还是一张,而不是多张表。 
如orderid,userid,ordertime,.....
ordertime<2015-01-01 #p0
ordertime<2015-04-01 #p1
ordertime<2015-07-01 #p2
ordertime<2015-10-01 #p3
ordertime<2016-01-01 #p4
按照时间分区。大部分只查询最近的订单数据,那么大部分只访问一个分区,比整个表小多了,数据库可以更加好的缓存,性能也提高了。这个是数据库分的,应用程序透明,无需修改。


2,数据处理上 

a),分表后,数据都是存放在分表里,总表只是一个外壳,存取数据发生在一个一个的分表里面。看下面的例子: 

select * from alluser where id='12'表面上看,是对表alluser进行操作的,其实不是的。是对alluser里面的分表进行了操作。 

b),分区呢,不存在分表的概念,分区只不过把存放数据的文件分成了许多小块,分区后的表呢,还是一张表。数据处理还是由自己来完成。 

3,提高性能上 

a), 分表后,单表的并发能力提高了,磁盘I/O性能也提高了。并发能力为什么提高了呢,因为查寻一次所花的时间变短了,如果出现高并发的话,总表可以根据不同 的查询,将并发压力分到不同的小表里面。磁盘I/O性能怎么搞高了呢,本来一个非常大的.MYD文件现在也分摊到各个小表的.MYD中去了。 

b),mysql提出了分区的概念,我觉得就想突破磁盘I/O瓶颈,想提高磁盘的读写能力,来增加mysql性能。 
在这一点上,分区和分表的测重点不同,分表重点是存取数据时,如何提高mysql并发能力上;而分区呢,如何突破磁盘的读写能力,从而达到提高mysql性能的目的。 

4),实现的难易度上 

a),分表的方法有很多,用merge来分表,是最简单的一种方式。这种方式根分区难易度差不多,并且对程序代码来说可以做到透明的。如果是用其他分表方式就比分区麻烦了。 

b),分区实现是比较简单的,建立分区表,根建平常的表没什么区别,并且对开代码端来说是透明的。 

三,mysql分表和分区有什么联系呢 

1,都能提高mysql的性高,在高并发状态下都有一个良好的表面。 

2,分表和分区不矛盾,可以相互配合的,对于那些大访问量,并且表数据比较多的表,我们可以采取分表和分区结合的方式(如果merge这种分表方式,不能和分区配合的话,可以用其他的分表试),访问量不大,但是表数据很多的表,我们可以采取分区的方式等。

 

分库分表区别:

1 基本思想之什么是分库分表?
从字面上简单理解,就是把原本存储于一个库的数据分块存储到多个库上,把原本存储于一个表的数据分块存储到多个表上。


2 基本思想之为什么要分库分表?
     数据库中的数据量不一定是可控的,在未进行分库分表的情况下,随着时间和业务的发展,库中的表会越来越多,表中的数据量也会越来越大,相应地,数据操作,增删改查的开销也会越来越大;另外,一台服务器的资源(CPU、磁盘、内存、IO等)是有限的,最终数据库所能承载的数据量、数据处理能力都将遭遇瓶颈,。


3 分库分表的实施策略。
     如果你的单机性能很低了,那可以尝试分库。分库,业务透明,在物理实现上分成多个服务器,不同的分库在不同服务器上。分区可以把表分到不同的硬盘上,但不能分配到不同服务器上。一台机器的性能是有限制的,用分库可以解决单台服务器性能不够,或者成本过高问题。
当分区之后,表还是很大,处理不过来,这时候可以用分库。
orderid,userid,ordertime,.....
userid%4=0,用分库1
userid%4=1,用分库2
userid%4=2, 用分库3
userid%4=3,用分库4
上面这个就是一个简单的分库路由,根据userid选择分库,即不同的服务器


分库分表有垂直切分和水平切分两种。
     3.1 何谓垂直切分,即将表按照功能模块、关系密切程度划分出来,部署到不同的库上。例如,我们会建立定义数据库workDB、商品数据库payDB、用户数据库userDB、日志数据库logDB等,分别用于存储项目数据定义表、商品定义表、用户数据表、日志数据表等。

   

如userid,name,addr一个表,为了防止表过大,分成2个表。
userid,name
userid,addr


       3.2 何谓水平切分,当一个表中的数据量过大时,我们可以把该表的数据按照某种规则,例如userID散列、按性别、按省,进行划分,然后存储到多个结构相同的表,和不同的库上。例如,我们的userDB中的用户数据表中,每一个表的数据量都很大,就可以把userDB切分为结构相同的多个userDB:part0DB、part1DB等,再将userDB上的用户数据表userTable,切分为很多userTable:userTable0、userTable1等,然后将这些表按照一定的规则存储到多个userDB上。


      3.3 应该使用哪一种方式来实施数据库分库分表,这要看数据库中数据量的瓶颈所在,并综合项目的业务类型进行考虑。
如果数据库是因为表太多而造成海量数据,并且项目的各项业务逻辑划分清晰、低耦合,那么规则简单明了、容易实施的垂直切分必是首选。
而如果数据库中的表并不多,但单表的数据量很大、或数据热度很高,这种情况之下就应该选择水平切分,水平切分比垂直切分要复杂一些,它将原本逻辑上属于一体的数据进行了物理分割,除了在分割时要对分割的粒度做好评估,考虑数据平均和负载平均,后期也将对项目人员及应用程序产生额外的数据管理负担。
在现实项目中,往往是这两种情况兼而有之,这就需要做出权衡,甚至既需要垂直切分,又需要水平切分。我们的游戏项目便综合使用了垂直与水平切分,我们首先对数据库进行垂直切分,然后,再针对一部分表,通常是用户数据表,进行水平切分。


4 分库分表存在的问题。

4.1 事务问题。
       在执行分库分表之后,由于数据存储到了不同的库上,数据库事务管理出现了困难。如果依赖数据库本身的分布式事务管理功能去执行事务,将付出高昂的性能代价;如果由应用程序去协助控制,形成程序逻辑上的事务,又会造成编程方面的负担。


4.2 跨库跨表的join问题。
    在执行了分库分表之后,难以避免会将原本逻辑关联性很强的数据划分到不同的表、不同的库上,这时,表的关联操作将受到限制,我们无法join位于不同分库的表,也无法join分表粒度不同的表,结果原本一次查询能够完成的业务,可能需要多次查询才能完成。


4.3 额外的数据管理负担和数据运算压力。
额外的数据管理负担,最显而易见的就是数据的定位问题和数据的增删改查的重复执行问题,这些都可以通过应用程序解决,但必然引起额外的逻辑运算,例如,对于一个记录用户成绩的用户数据表userTable,业务要求查出成绩最好的100位,在进行分表之前,只需一个order by语句就可以搞定,但是在进行分表之后,将需要n个order by语句,分别查出每一个分表的前100名用户数据,然后再对这些数据进行合并计算,才能得出结果。

 https://www.cnblogs.com/langtianya/p/4997768.html

相关:分库分表带来的完整性和一致性问题

Management of RANGE and LIST Partitions












;