数据切分——MySql表分区

最新推荐文章于 2021-03-18 20:41:06 发布
最新推荐文章于 2021-03-18 20:41:06 发布
阅读量537 收藏
点赞数
分类专栏： 数据库

MySql表分区概述

定义：

       表的分区指根据可以设置为任意大小的规则，跨文件系统分配单个表的多个部分。实际上，表的不同部分在不同的位置被存储为单独的表。用户所选择的、实现数据分割的规则被称为分区函数，这在MySQL中它可以是模数，或者是简单的匹配一个连续的数值区间或数值列表，或者是一个内部HASH函数，或一个线性HASH函数。


         使用场景:

        1.某张表的数据量非常大，通过索引已经不能很好的解决查询性能的问题

     2.表的数据可以按照某种条件进行分类，以致于在查询的时候性能得到很大的提升

          

      优点:

       1）、对于那些已经失去保存意义的数据，通常可以通过删除与那些数据有关的分区，很容易地删除那些数据。相反地，在某些情况下，添加新数据的过程又可以通过为那些新数据专门增加一个新的分区，来很方便地实现。

     2）、一些查询可以得到极大的优化，这主要是借助于满足一个给定WHERE语句的数据可以只保存在一个或多个分区内，这样在查找时就不用查找其他剩余的分区。因为分区可以在创建了分区表后进行修改，所以在第一次配置分区方案时还不曾这么做时，可以重新组织数据，来提高那些常用查询的效率。

     3）、涉及到例如SUM()和COUNT()这样聚合函数的查询，可以很容易地进行并行处理。这意味着查询可以在每个分区上同时进行，最终结果只需通过总计所有分区得到的结果。

     4）、通过跨多个磁盘来分散数据查询，来获得更大的查询吞吐量。


    分类：

   
     

Mysql分区表的建立及性能分析

1.检查你的Mysql是否支持分区

        mysql> SHOW VARIABLES LIKE '%partition%';


       若结果如下，表示你的Mysql支持表分区:

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

       | Variable_name         | Value |
       +-----------------------+-------+
       | have_partition_engine | YES   |
       +-----------------------+-------+
       1 row in set (0.00 sec)
               RANGE分区表创建方式：
[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. DROP TABLE IF EXISTS `my_orders`;  
  2. CREATE TABLE `my_orders` (  
  3.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '表主键',  
  4.   `pid` int(10) unsigned NOT NULL COMMENT '产品ID',  
  5.   `price` decimal(15,2) NOT NULL COMMENT '单价',  
  6.   `num` int(11) NOT NULL COMMENT '购买数量',  
  7.   `uid` int(10) unsigned NOT NULL COMMENT '客户ID',  
  8.   `atime` datetime NOT NULL COMMENT '下单时间',  
  9.   `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT '修改时间',  
  10.   `isdel` tinyint(4) NOT NULL DEFAULT '0' COMMENT '软删除标识',  
  11.   PRIMARY KEY (`id`,`atime`)  
  12. ) ENGINE=InnoDB DEFAULT CHARSET=utf8  
  13.   
  14. /*********分区信息**************/  
  15. PARTITION BY RANGE (YEAR(atime))  
  16. (  
  17.    PARTITION p0 VALUES LESS THAN (2016),  
  18.    PARTITION p1 VALUES LESS THAN (2017),  
  19.    PARTITION p2 VALUES LESS THAN MAXVALUE  
  20. );  
         以上是一个简单的订单表，分区字段是atime,根据RANGE分区，这样当你向该表中插入数据的时候，Mysql会根据YEAR(atime)的值进行分区存储。


        检查分区是否创建成功，执行查询语句：

         EXPLAIN PARTITIONS SELECT * FROM `my_orders`

         若成功，结果如下：

       

        

        性能分析：

        1）.创建同样表结构，但没有进行分区的表     

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. DROP TABLE IF EXISTS `my_order`;  
  2. CREATE TABLE `my_order` (  
  3.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '表主键',  
  4.   `pid` int(10) unsigned NOT NULL COMMENT '产品ID',  
  5.   `price` decimal(15,2) NOT NULL COMMENT '单价',  
  6.   `num` int(11) NOT NULL COMMENT '购买数量',  
  7.   `uid` int(10) unsigned NOT NULL COMMENT '客户ID',  
  8.   `atime` datetime NOT NULL COMMENT '下单时间',  
  9.   `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT '修改时间',  
  10.   `isdel` tinyint(4) NOT NULL DEFAULT '0' COMMENT '软删除标识',  
  11.   PRIMARY KEY (`id`,`atime`)  
  12. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;  

        2）.向两张表中插入相同的数据

      

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /**************************向分区表插入数据****************************/  
  2. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP());  
  3. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2016-05-01 00:00:00');  
  4. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2017-05-01 00:00:00');  
  5. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2018-05-01 00:00:00');  
  6. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2015-05-01 00:00:00');  
  7. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2016-05-01 00:00:00');  
  8. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2017-05-01 00:00:00');  
  9. INSERT INTO my_orders(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2018-05-01 00:00:00');  
  10.   
  11. /**************************向未分区表插入数据****************************/  
  12. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP());  
  13. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2016-05-01 00:00:00');  
  14. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2017-05-01 00:00:00');  
  15. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2018-05-01 00:00:00');  
  16. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2015-05-01 00:00:00');  
  17. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2016-05-01 00:00:00');  
  18. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2017-05-01 00:00:00');  
  19. INSERT INTO my_order(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2018-05-01 00:00:00');  

         3）.主从复制，大约20万条左右（主从复制的数据和真实环境有差距，但是能体现出表分区查询的性能优劣）

        

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /**********************************主从复制大量数据******************************/  
  2. INSERT INTO `my_orders`(`pid`,`price`,`num`,`uid`,`atime`) SELECT `pid`,`price`,`num`,`uid`,`atime` FROM `my_orders`;  
  3. INSERT INTO `my_order`(`pid`,`price`,`num`,`uid`,`atime`) SELECT `pid`,`price`,`num`,`uid`,`atime` FROM `my_order`;  
    

       4）.查询测试

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /***************************查询性能分析**************************************/  
  2. SELECT * FROM `my_orders` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP();  
  3. /****用时0.084s****/  
  4.   
  5. SELECT * FROM `my_order` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP();  
  6. /****用时0.284s****/  

      通过以上查询可以明显看出进行表分区的查询性能更好，查询所花费的时间更短。

      分析查询过程：

      EXPLAIN PARTITIONS SELECT * FROM `my_orders` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP();

           


      EXPLAIN PARTITIONS SELECT * FROM `my_order` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP();

             

      

       通过以上结果可以看出，my_orders表查询直接经过p0分区，只扫描了49386行，而my_order表没有进行分区，扫描了196983行，这也是性能得到提升的关键所在。


       当然，表的分区并不是分的越多越好，当表的分区太多时找分区又是一个性能的瓶颈了，建议在200个分区以内。


      LIST分区表创建方式：

      

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /*****************创建分区表*********************/  
  2. CREATE TABLE `products` (  
  3. `id`  bigint UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '表主键' ,  
  4. `name`  varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '产品名称' ,  
  5. `metrial`  tinyint UNSIGNED NOT NULL COMMENT '材质' ,  
  6. `weight`  double UNSIGNED NOT NULL DEFAULT 0 COMMENT '重量' ,  
  7. `vol`  double UNSIGNED NOT NULL DEFAULT 0 COMMENT '容积' ,  
  8. `c_id`  tinyint UNSIGNED NOT NULL COMMENT '供货公司ID' ,  
  9. PRIMARY KEY (`id`,`c_id`)  
  10. )ENGINE=InnoDB DEFAULT CHARSET=utf8  
  11.   
  12. /*********分区信息**************/  
  13. PARTITION BY LIST(c_id)  
  14. (  
  15.     PARTITION pA VALUES IN (1,3,11,13),  
  16.     PARTITION pB VALUES IN (2,4,12,14),  
  17.     PARTITION pC VALUES IN (5,7,15,17),  
  18.     PARTITION pD VALUES IN (6,8,16,18),  
  19.     PARTITION pE VALUES IN (9,10,19,20)  
  20. );  

       可以看出，LIST分区和RANGE分区很类似，这里就不做性能分析了，和RANGE很类似。


       HASH分区表的创建方式：

      

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /*****************分区表*****************/  
  2. CREATE TABLE `msgs` (  
  3.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '表主键',  
  4.   `sender` int(10) unsigned NOT NULL COMMENT '发送者ID',  
  5.   `reciver` int(10) unsigned NOT NULL COMMENT '接收者ID',  
  6.   `msg_type` tinyint(3) unsigned NOT NULL COMMENT '消息类型',  
  7.   `msg` varchar(225) NOT NULL COMMENT '消息内容',  
  8.   `atime` int(10) unsigned NOT NULL COMMENT '发送时间',  
  9.   `sub_id` tinyint(3) unsigned NOT NULL COMMENT '部门ID',  
  10.   PRIMARY KEY (`id`,`sub_id`)  
  11. ) ENGINE=InnoDB DEFAULT CHARSET=utf8  
  12. /*********分区信息**************/  
  13. PARTITION BY HASH(sub_id)  
  14. PARTITIONS 10;  

          以上语句代表，msgs表按照sub_id进行HASH分区，一共分了十个区。


       Key分区和HASH分区很类似，不再介绍，若想了解可以参考Mysql官方文档进行详细了解。


       子分区的创建方式:

      

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. CREATE TABLE `msgss` (  
  2.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '表主键',  
  3.   `sender` int(10) unsigned NOT NULL COMMENT '发送者ID',  
  4.   `reciver` int(10) unsigned NOT NULL COMMENT '接收者ID',  
  5.   `msg_type` tinyint(3) unsigned NOT NULL COMMENT '消息类型',  
  6.   `msg` varchar(225) NOT NULL COMMENT '消息内容',  
  7.   `atime` int(10) unsigned NOT NULL COMMENT '发送时间',  
  8.   `sub_id` tinyint(3) unsigned NOT NULL COMMENT '部门ID',  
  9.   PRIMARY KEY (`id`,`atime`,`sub_id`)  
  10. ) ENGINE=InnoDB DEFAULT CHARSET=utf8  
  11. /*********分区信息**************/  
  12. PARTITION BY RANGE (atime) SUBPARTITION BY HASH (sub_id)   
  13. (  
  14.         PARTITION t0 VALUES LESS THAN(1451577600)  
  15.         (  
  16.             SUBPARTITION s0,  
  17.             SUBPARTITION s1,  
  18.             SUBPARTITION s2,  
  19.             SUBPARTITION s3,  
  20.             SUBPARTITION s4,  
  21.             SUBPARTITION s5  
  22.         ),  
  23.         PARTITION t1 VALUES LESS THAN(1483200000)  
  24.         (  
  25.             SUBPARTITION s6,  
  26.             SUBPARTITION s7,  
  27.             SUBPARTITION s8,  
  28.             SUBPARTITION s9,  
  29.             SUBPARTITION s10,  
  30.             SUBPARTITION s11  
  31.         ),  
  32.         PARTITION t2 VALUES LESS THAN MAXVALUE  
  33.         (  
  34.             SUBPARTITION s12,  
  35.             SUBPARTITION s13,  
  36.             SUBPARTITION s14,  
  37.             SUBPARTITION s15,  
  38.             SUBPARTITION s16,  
  39.             SUBPARTITION s17  
  40.         )  
  41. );  

         检查子分区是否创建成功：

        EXPLAIN PARTITIONS SELECT * FROM msgss;

        结果如下图：

         


Mysql分区表的管理与维护

       前面已经提过，Mysql支持4种表的分区，即RANGE与LIST、HASH与KEY，其中RANGE和LIST类似，按一种区间进行分区，HASH与KEY类似，是按照某种算法对字段进行分区。


       RANGE与LIST分区管理：

       案例：有一个聊天记录表，用户几千左右，已经对表按照用户进行一定粒度的水平分割，现仍然有部分表存储的记录比较多，于是按照下列方式有对表进行了分区，分区的好处是，可以动态改变分区，删除分区后，数据也一同被删除，如聊天记录只保存两年，那么你就可以按照时间进行分区，定期删除两年前的分区，动态创建新的的分区就能做到很好的数据维护。

  

       分区表创建的语句如下：

        

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. DROP TABLE IF EXISTS `msgss`;  
  2. CREATE TABLE `msgss` (  
  3.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '表主键',  
  4.   `sender` int(10) unsigned NOT NULL COMMENT '发送者ID',  
  5.   `reciver` int(10) unsigned NOT NULL COMMENT '接收者ID',  
  6.   `msg_type` tinyint(3) unsigned NOT NULL COMMENT '消息类型',  
  7.   `msg` varchar(225) NOT NULL COMMENT '消息内容',  
  8.   `atime` int(10) unsigned NOT NULL COMMENT '发送时间',  
  9.   `sub_id` tinyint(3) unsigned NOT NULL COMMENT '部门ID',  
  10.   PRIMARY KEY (`id`,`atime`,`sub_id`)  
  11. ) ENGINE=InnoDB DEFAULT CHARSET=utf8  
  12. /*********分区信息**************/  
  13. PARTITION BY RANGE (atime) SUBPARTITION BY HASH (sub_id)   
  14. (  
  15.         PARTITION t0 VALUES LESS THAN(1451577600)  
  16.         (  
  17.             SUBPARTITION s0,  
  18.             SUBPARTITION s1,  
  19.             SUBPARTITION s2,  
  20.             SUBPARTITION s3,  
  21.             SUBPARTITION s4,  
  22.             SUBPARTITION s5  
  23.         ),  
  24.         PARTITION t1 VALUES LESS THAN(1483200000)  
  25.         (  
  26.             SUBPARTITION s6,  
  27.             SUBPARTITION s7,  
  28.             SUBPARTITION s8,  
  29.             SUBPARTITION s9,  
  30.             SUBPARTITION s10,  
  31.             SUBPARTITION s11  
  32.         ),  
  33.         PARTITION t2 VALUES LESS THAN MAXVALUE  
  34.         (  
  35.             SUBPARTITION s12,  
  36.             SUBPARTITION s13,  
  37.             SUBPARTITION s14,  
  38.             SUBPARTITION s15,  
  39.             SUBPARTITION s16,  
  40.             SUBPARTITION s17  
  41.         )  
  42. );  


        上述语句创建了三个按照RANGE划分的主分区，每个主分区下面有六个按照HASH划分的子分区。


        插入测试数据：

       

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH',UNIX_TIMESTAMP(NOW()),1);  
  2. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 2',UNIX_TIMESTAMP(NOW()),2);  
  3. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 3',UNIX_TIMESTAMP(NOW()),3);  
  4. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 10',UNIX_TIMESTAMP(NOW()),10);  
  5. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 7',UNIX_TIMESTAMP(NOW()),7);  
  6. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 5',UNIX_TIMESTAMP(NOW()),5);  
  7.   
  8. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH',1451577607,1);  
  9. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 2',1451577609,2);  
  10. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 3',1451577623,3);  
  11. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 10',1451577654,10);  
  12. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 7',1451577687,7);  
  13. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 5',1451577699,5);  
  14.   
  15. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH',1514736056,1);  
  16. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 2',1514736066,2);  
  17. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 3',1514736076,3);  
  18. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 10',1514736086,10);  
  19. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 7',1514736089,7);  
  20. INSERT INTO `msgss`(`sender`,`reciver`,`msg_type`,`msg`,`atime`,`sub_id`) VALUES(1,2,0,'Hello HASH 5',1514736098,5);  

                  进行分区分析：

        EXPLAIN PARTITIONS SELECT * FROM msgss;

        可以检测到分区信息如下：

         


         检测分区数据分布：

         

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. EXPLAIN PARTITIONS SELECT * FROM msgss WHERE `atime`<1451577600;  
  2.   
  3. EXPLAIN PARTITIONS SELECT * FROM msgss WHERE `atime`>1451577600 AND `atime`<1483200000;  
  4.   
  5. EXPLAIN PARTITIONS SELECT * FROM msgss WHERE `atime`>1483200000 AND `atime`<1514736000;  
  6.   
  7. EXPLAIN PARTITIONS SELECT * FROM msgss WHERE `atime`>1514736000;  

                    结果：第一条语句只扫描了t0的所有子分区，第二条语句只扫描了t1的所有子分区，第三四条分别只扫描了t2的所有子分区，证明表的分区和数据分布成功。


         需求：目前已经是2017年，需要将2015年所有的聊天记录删除，但是保留2016年的聊天记录，并且2017年的数据也能正常按照分区进行存储。


        实现以上需求，需要两步，第一步删除t0分区，第二步按照新规则重建分区。

        删除分区语句：

        ALTER TABLE `msgss` DROP PARTITION t0;

        重建分区语句：

       

[sql] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. ALTER TABLE `msgss` PARTITION BY RANGE (atime) SUBPARTITION BY HASH (sub_id)   
  2. (  
  3.         PARTITION t0 VALUES LESS THAN(1483200000)  
  4.         (  
  5.             SUBPARTITION s0,  
  6.             SUBPARTITION s1,  
  7.             SUBPARTITION s2,  
  8.             SUBPARTITION s3,  
  9.             SUBPARTITION s4,  
  10.             SUBPARTITION s5  
  11.         ),  
  12.         PARTITION t1 VALUES LESS THAN(1514736000)  
  13.         (  
  14.             SUBPARTITION s6,  
  15.             SUBPARTITION s7,  
  16.             SUBPARTITION s8,  
  17.             SUBPARTITION s9,  
  18.             SUBPARTITION s10,  
  19.             SUBPARTITION s11  
  20.         ),  
  21.         PARTITION t2 VALUES LESS THAN MAXVALUE  
  22.         (  
  23.             SUBPARTITION s12,  
  24.             SUBPARTITION s13,  
  25.             SUBPARTITION s14,  
  26.             SUBPARTITION s15,  
  27.             SUBPARTITION s16,  
  28.             SUBPARTITION s17  
  29.         )  
  30. );  

                    查询发现，15年的数据全部被删除，剩余的数据被重新分区并分布。          未完。。。。


转自：http://blog.csdn.net/jhq0113/article/category/2897729

dragonpeng2008
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
总结MySQL的分区
01-19
相对于没有分区的当个表而言分区的表有很多的优势包括： 并发统计查询、快速归档删除分区数据、分散存储、查询性能更佳。 mysql5.7以后查询语句支持指定分区例如：“ SELECT * FROM t PARTITION (p0,p1) WHERE c &lt...
数据切分——MySql表分区概述
姜海强
03-24 6462
定义：        表的分区指根据可以设置为任意大小的规则，跨文件系统分配单个表的多个部分。实际上，表的不同部分在不同的位置被存储为单独的表。用户所选择的、实现数据分割的规则被称为分区函数，这在MySQL中它可以是模数，或者是简单的匹配一个连续的数值区间或数值列表，或者是一个内部HASH函数，或一个线性HASH函数。          使用场景:       
mysql 数据表格切分_MySQL分库分表和切分策略
weixin_32019219的博客
12-31 160
随着业务和数据量的增长，单库的IO压力越来越大，数据库切分是分散数据库访问压力的基本方法。Sharding的基本思想就是把一个数据库切分成多个部分放到不同的DB server上，从而解决单一数据库的性能问题。1、垂直切分一个复杂的业务系统，可以先根据业务子系统，模块把数据库表切分到不同的server上，关系紧密的表自然划分到一个server上。2、水平切分按业务模块垂直切分后，可能有些单表数据还是...
水平分割 垂直分割 和 库表散列 概念 说明
热门推荐
David Dai -- Focus on Oracle
06-18 1万+
一．水平分割 根据一列或多列数据的值把数据行放到两个独立的表中。即按记录进分分割，不同的记录可以分开保存，每个子表的列数相同。   水平分区将表分为多个表。每个表包含的列数相同，但是行更少。例如，可以将一个包含十亿行的表水平分区成 12 个表，每个小表表示特定年份内一个月的数据。任何需要特定月份数据的查询只需引用相应月份的表。 水平分割通常在下面的情况下使用：（1）    表很大，分割后可以降低在
数据切分——Mysql分区表的建立及性能分析
slqgenius的博客
11-01 271
MySQL的安装方法可以参考：         http://blog.csdn.net/jhq0113/article/details/43812895                  Mysql分区表的介绍可以参考：         http://blog.csdn.net/jhq0113/article/details/44592865        
数据切分——Mysql分区表的管理与维护
茶爸爸(微信：benyzhous) 的专栏
04-12 585
关于Mysql分区表的介绍可以参考:         http://blog.csdn.net/jhq0113/article/details/44592865        关于Mysql分区表的创建可以参考：        http://blog.csdn.net/jhq0113/article/details/44593511        前面已经提过，
Linux——MySQL分表分区
weixin_45191791的博客
01-25 314
本文概括了在MySQL5.7.32版本中如何创建分表和分区操作！！！ 分表和分区 一、分表 1.什么是分表 ​ 数据库数据越来越大，随之而来的是单个表中数据太多。以至于查询速度慢，而且由于表的锁机制导致应用操作也受到影响，出现了数据库性能瓶颈。 MySQL中有一种机制是表锁定和行锁定，是为了保证数据的完整性。 表锁定：表示你们都不能对这张表进行操作，必须等我对表操作完成之后才可以进行操作； 行锁定：所表锁定差不多，别的sql语句必须等我这条数据操作完了，才能对这条数据进行操作； 当出现这种情况，我们就
Mysql数据分片技术(一)——初识表分区
jack_wang001的专栏
09-18 729
1. 为什么需要数据分片技术 2. 3种数据分片方式简述 3. 分片技术原理概述 4. 对单表分区的时机 1为什么需要数据分片技术 数据库产品的市场 在互联网行业内，绝大部分开发人员都会遇到数据表的性能问题，特别是当单表数据量特别大的时候，就算是添加索引，性能也都差强人意。对于亿级别的数据，有些大的企业会选择性能非常好的Oracle，Oracle属于中大型数据库，能在数据量大的情况下有好的数据处理性能。但是绝大部分小型企业是不会选择昂贵的oracle...
MySQL——分表分区
lin小将的博客
03-18 301
为什么要分表和分区？ 随着数据库数据越来越大，随之而来的是单个表中数据太多。以至于查询速度变慢，而且由于表的锁机制导致应用操作也受到严重影响，出现了数据库性能瓶颈。 mysql中有一种机制是表锁定和行锁定，是为了保证数据的完整性。表锁定表示你们都不能对这张表进行操作，必须等我对表操作完才行。行锁定也一样，别的sql必须等我对这条数据操作完了，才能对这条数据进行操作。当出现这种情况时，可以考虑分表或分区。 1、分表 什么是分表？ 分表是将一个大表按照一定的规则分解成多张具有独立存储空间的实体表，每个表都对应三
MySQL切分查询用法分析
09-10
主要介绍了MySQL切分查询用法,结合实例形式分析了通过do while语句进行切分查询的具体实现技巧,需要的朋友可以参考下
数据切分整合？有章法！
03-02
《MySQL性能调优与架构设计》第14.5节“数据切分及整合方案”14.5 数据切分及整合方案通过前面的章节，已经清楚了通过数据库的数据切分可以极大地提高系统的扩展性。但是，数据库中的数据经过垂直和（或）水平切分...
Python数据集切分实例
09-19
今天小编就为大家分享一篇Python数据集切分实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java swing + socket + mysql 五子棋网络对战游戏FiveChess.zip
05-12
五子棋游戏想必大家都非常熟悉，游戏规则十分简单。游戏开始后,玩家在游戏设置中选择人机对战，则系统执黑棋，玩家自己执白棋。双方轮流下一棋，先将横、竖或斜线的5个或5个以上同色棋子连成不间断的一排者为胜。 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【技术】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
纯C语言实现的控制台有禁手五子棋(带AI）Five-to-five-Renju.zip
05-12
五子棋游戏想必大家都非常熟悉，游戏规则十分简单。游戏开始后,玩家在游戏设置中选择人机对战，则系统执黑棋，玩家自己执白棋。双方轮流下一棋，先将横、竖或斜线的5个或5个以上同色棋子连成不间断的一排者为胜。 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【技术】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
setuptools-57.1.0.tar.gz
05-12
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
setuptools-59.1.1.tar.gz
最新发布
05-12
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
空载损耗计算软件.zip
05-12
空载损耗计算软件
贪吃蛇.cpp
05-12
贪吃蛇.cpp
matlab数据切分
08-30
在Matlab中，可以使用函数来对数据进行切分。首先，需要指定待切分的文件路径，例如'C:/Users/Louise喵/Desktop/dataFOV20.txt'。然后调用splitFile函数，并将文件路径作为输入参数传递给该函数。调用splitFile函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值