mycat分表之ER表分片、范围分片、取模分片、日期分片、全局表等

最新推荐文章于 2024-08-23 14:22:39 发布
原创 最新推荐文章于 2024-08-23 14:22:39 发布 · 1.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#mysql #数据库 #mycat

博客介绍了数据库水平分表时Mycat的分片策略，分为连续分片和离散分片。连续分片如范围、日期分片，有节省资源等优点，但可能导致负载不均；离散分片如枚举、一致性哈希等，能增强并发，但扩容困难。还详细阐述了多种分片规则的配置与测试。
概述

数据库进行水平分表时，需要按照一定规则对数据进行分片。

Mycat的分片策略可以分为两种：
连续分片和离散分片。
在这里插入图片描述
连续分片常用的有分片规则有：

  • 范围分片。
  • 日期分片。

优点：如果进行范围查询，比如查询连续100条数据，mycat就不用到每个节点查询数据再汇总，只需在一个节点查询返回即可，比较节省资源，并且如果进行节点的扩展，也不用进行数据的重新分片。
缺点：如果某些数据是越新的数据是热点数据的话，比如id 0-100000分配到节点1，然后过了一段时间之后，这些数据变成了冷数据，不再经常访问，但是节点2的100001-200000数据在此时变成了热点数据，这就会导致热点数据分布不均匀，从而导致某个承载大量热点数据的节点负载过高，最后造成节点之间负载不均匀、

离散分片常用的分配规则有：

  • 枚举。
  • 一致性哈希。
  • 十进制取模。
  • 固定分配哈希。
  • 取模范围。
  • 范围取模。
  • 其他。

优点：

  • 并发访问能力增强（负载到不同的节点）。
  • 不会出现冷热数据分布不均匀的问题。
    缺点：
  • 数据扩容比较困难，涉及到数据迁移问题
  • 数据库连接消耗比较多，因为要经常汇总数据。
    三台数据库节点。
    表结构如下：
CREATE TABLE `customer` (
  `id` int(11) DEFAULT NULL,
  `name` varchar(255) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `order_info` (
  `order_id` int(11) NOT NULL COMMENT '订单ID',
  `uid` int(11) DEFAULT NULL COMMENT '用户ID',
  `nums` int(11) DEFAULT NULL COMMENT '商品数量',
  `state` int(2) DEFAULT NULL COMMENT '订单状态',
  `create_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `order_detail` (
  `order_id` int(11) NOT NULL COMMENT '订单号',
  `id` int(11) NOT NULL COMMENT '订单详情',
  `goods_id` int(11) DEFAULT NULL COMMENT '货品ID',
  `price` decimal(10,2) DEFAULT NULL COMMENT '价格',
  `is_pay` int(2) DEFAULT NULL COMMENT '支付状态',
  `is_ship` int(2) DEFAULT NULL COMMENT '是否发货',
  `status` int(2) DEFAULT NULL COMMENT '订单详情状态',
  PRIMARY KEY (`order_id`,`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


CREATE TABLE `student` (
  `sid` int(8) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `qq` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`sid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


CREATE TABLE `sharding_by_mod` (
  `id` int(11) NOT NULL,
  `db_nm` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


CREATE TABLE `sharding_by_month` (
`create_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
`db_nm` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `sharding_by_intfile` (
`age` int(11) NOT NULL,
`db_nm` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `sharding_by_murmur` (
`id` int(10) DEFAULT NULL,
`db_nm` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `sharding_by_long` (
  `id` int(10) DEFAULT NULL,
  `db_nm` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
范围分片

按照id进行水平分片，1-100000分在节点1,100001-200000分在节点2,200001-~分在节点3.

先修改schema，配置对应的逻辑表和物理数据库地址和对应的分片规则。

<!-- 配置逻辑数据库-->
<schema name="mycat-test" checkSQLschema="true" sqlMaxLimit="100" dataNode="dn1">
                <!--使用customer表来测试范围分片-->
                <!--dataNode数据节点，多个用逗号隔开-->
                <!--rule配置分片规则-->
                <!--primaryKey配置该表的主键-->
                <table name="customer" dataNode="dn1,dn2,dn3" rule="range-shard-by-id" primaryKey="id"/>
                <!-- auto sharding by id (long) -->
                <!--splitTableNames 启用<table name 属性使用逗号分割配置多个表,即多个表使用这个配置-->
                <!--<table name="travelrecord,address" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" splitTableNames ="true"/>-->
        </schema>
        <!--定义三个节点，dataHost由下面的dataHost标签配置，database配置物理数据库名称-->
        <dataNode name="dn1" dataHost="mycat_test1" database="mycat_test" />
        <dataNode name="dn2" dataHost="mycat_test2" database="mycat_test" />
        <dataNode name="dn3" dataHost="mycat_test3" database="mycat_test" />

       <!--配置真实数据库地址-->
        <dataHost name="mycat_test1" maxCon="1000" minCon="10" balance="3"
                          writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                <heartbeat>select user()</heartbeat>
                <!-- can have multi write hosts -->
                <writeHost host="MasterHost1" url="192.168.18.142:3306" user="root"
                                   password="123456">
                </writeHost>

        </dataHost>

         <dataHost name="mycat_test2" maxCon="1000" minCon="10" balance="3"
                          writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                <heartbeat>select user()</heartbeat>
                <!-- can have multi write hosts -->
                <writeHost host="MasterHost1" url="192.168.18.143:3306" user="root"
                                   password="123456">
                </writeHost> 
                </dataHost>

             
               <dataHost name="mycat_test3" maxCon="1000" minCon="10" balance="3"
                          writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
                <heartbeat>select user()</heartbeat>
                <!-- can have multi write hosts -->
                <writeHost host="MasterHost1" url="192.168.18.144:3306" user="root"
                                   password="123456">
                </writeHost>

        </dataHost>

配置分片规则：rule.xml

<!-- name就是配置规则名称，供上面印有 -->
<tableRule name="range-shard-by-id">
                <rule>
                		<!-- columns配置分片键，也就是进行分片规则的字段 -->
                        <columns>id</columns>
                        <!-- algorithm配置分片算法，在下面定义 -->
                        <algorithm>range-shard</algorithm>
                </rule>
        </tableRule>

<!-- name算法名称，用于上面引用 -->
<!-- class算法的类，这里使用mycat自带的AutoPartitionByLong -->
<!-- mapFile属性配置范围与节点指定的文件 -->
<function name="range-shard"
                          class="io.mycat.route.function.AutoPartitionByLong">
                <property name="mapFile">range-shard-long.txt</property><!-- 范围与节点对应指定文件 -->
                <!--默认节点，当路由不到节点就分到该节点上，如果不配置并且路由不到就会报错并新数据失败。-->
                <property name="defaultNode">2</property>

        </function>

配置range-shard-long.txt

#id为0-100000会分到第0个节点，下面类似。
0-100000=0
100001-200000=1

重启mycat，测试
连接mycat执行下面新增语句：

INSERT INTO `customer` (`id`, `name`) VALUES (66666, '赵先生');
INSERT INTO `customer` (`id`, `name`) VALUES (77777, '钱先生');
INSERT INTO `customer` (`id`, `name`) VALUES (166666, '孙先生');
INSERT INTO `customer` (`id`, `name`) VALUES (177777, '李先生');
INSERT INTO `customer` (`id`, `name`) VALUES (266666, '周先生');
INSERT INTO `customer` (`id`, `name`) VALUES (277777, '吴先生');

然后查看：
在这里插入图片描述
在mycat上面查询出了完整的数据，但是具体分在哪个节点还要看看。
节点0：
在这里插入图片描述
节点1：
在这里插入图片描述
节点2：因为266666和277777在范围外，所以会分片到默认节点。
在这里插入图片描述
可以看到跟range-shard-long.txt文件配置的范围规则是一致的。

ER分片

schema.xml文件的schema标签配置对应的表和分片规则（在上面基础上）：

<!--rule配置分片规则为mod-long-order，实际上就是一个取模的分配规则，关联字段取模，就能分片到相同的节点上 -->
 <table name="order_info" dataNode="dn1,dn2,dn3"  rule="mod-long-order" >
 <!-- joinKey是子表与父表关联的字段，这里是order_id -->
 <!-- parentKey是对应的是父表与子表关联的字段 -->
                        <childTable name="order_detail" joinKey="order_id" parentKey="order_id" primaryKey="id"/>
                </table>

配置分片规则

<tableRule name="mod-long-order">
                <rule>
                        <columns>order_id</columns>
                        <algorithm>mod-long-order</algorithm>
                </rule>
        </tableRule>



<function name="mod-long-order" class="io.mycat.route.function.PartitionByMod">
                <!-- 节点个数，用于取模 -->
                <property name="count">3</property>
        </function>

重启mycat并连接执行下面SQL。

INSERT INTO `order_info` (`order_id`, `uid`, `nums`, `state`, `create_time`, `update_time`) VALUES (1, 1000001, 1, 2, '2019-9-23 14:35:37', '2019-9-23 14:35:37');
INSERT INTO `order_info` (`order_id`, `uid`, `nums`, `state`, `create_time`, `update_time`) VALUES (2, 1000002, 1, 2, '2019-9-24 14:35:37', '2019-9-24 14:35:37');
INSERT INTO `order_info` (`order_id`, `uid`, `nums`, `state`, `create_time`, `update_time`) VALUES (3, 1000003, 3, 1, '2019-9-25 11:35:49', '2019-9-25 11:35:49');

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

INSERT INTO `order_detail` (`order_id`, `id`, `goods_id`, `price`, `is_pay`, `is_ship`, `status`) VALUES (3, 20180001, 85114752, 19.99, 1, 1, 1);
INSERT INTO `order_detail` (`order_id`, `id`, `goods_id`, `price`, `is_pay`, `is_ship`, `status`) VALUES (1, 20180002, 25411251, 1280.00, 1, 1, 0);
INSERT INTO `order_detail` (`order_id`, `id`, `goods_id`, `price`, `is_pay`, `is_ship`, `status`) VALUES (1, 20180003, 62145412, 288.00, 1, 1, 2);
INSERT INTO `order_detail` (`order_id`, `id`, `goods_id`, `price`, `is_pay`, `is_ship`, `status`) VALUES (2, 20180004, 21456985, 399.00, 1, 1, 2);
INSERT INTO `order_detail` (`order_id`, `id`, `goods_id`, `price`, `is_pay`, `is_ship`, `status`) VALUES (2, 20180005, 21457452, 1680.00, 1, 1, 2);
INSERT INTO `order_detail` (`order_id`, `id`, `goods_id`, `price`, `is_pay`, `is_ship`, `status`) VALUES (2, 20180006, 65214789, 9999.00, 1, 1, 3);

mycat查看两个表：
在这里插入图片描述
在这里插入图片描述
数据完整，然后查看每个节点。
节点1：
在这里插入图片描述
在这里插入图片描述
节点2：
在这里插入图片描述
在这里插入图片描述
节点3：
在这里插入图片描述
在这里插入图片描述
可以看到每个节点的两个表的order_id都是对应的，这样的绑定关系就避免了跨库的关联查询。

全局表

这个无需分配规则，只需加多个属性type="global"就行。

<table name="student" dataNode="dn1,dn2,dn3" primaryKey="sid" type="global"/>

重启mycat并连接执行下面语句

INSERT INTO `student` (`sid`, `name`, `qq`) VALUES (1, '黑白', '166669999');
INSERT INTO `student` (`sid`, `name`, `qq`) VALUES (2, 'AV哥', '466669999');
INSERT INTO `student` (`sid`, `name`, `qq`) VALUES (3, '地表最强菜鸟', '368828888');
INSERT INTO `student` (`sid`, `name`, `qq`) VALUES (4, '加载中', '655556666');
INSERT INTO `student` (`sid`, `name`, `qq`) VALUES (5, '猫老公', '265286999');
INSERT INTO `student` (`sid`, `name`, `qq`) VALUES (6, '一个人的精彩', '516895555');

然后查看mycat数据：
在这里插入图片描述
查看三个节点：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
可以看到所有节点都保存了全量数据。

取模分片

取模分片就不演示了，ER分片那里的实质就是取模分片。

日期分片

按自然月进行分片：
先修改schema.xml添加相关逻辑表信息。

<table name="sharding_by_month" dataNode="dn1,dn2,dn3" rule="qs-shard-by-month"/>

修改rule.xml，添加分片规则：


<tableRule name="qs-shard-by-month">
                <rule>
                        <columns>create_time</columns>
                        <algorithm>shardByMonth</algorithm>
                </rule>
        </tableRule>


<function name="shardByMonth"
                          class="io.mycat.route.function.PartitionByMonth">
                 <!-- 日期格式，数据表的对应字段的格式要与这里设置的一致 -->
                <property name="dateFormat">yyyy-MM-dd</property>
                <!-- 开始日期-->
                <property name="sBeginDate">2019-10-01</property>
                <!-- 结束日期-->
                <property name="sEndDate">2019-12-31</property>

        </function>

重启mycat并连接执行下面语句：

INSERT INTO sharding_by_month (create_time,db_nm) VALUES ('2019-10-16', database());
INSERT INTO sharding_by_month (create_time,db_nm) VALUES ('2019-10-27', database());
INSERT INTO sharding_by_month (create_time,db_nm) VALUES ('2019-11-04', database());
INSERT INTO sharding_by_month (create_time,db_nm) VALUES ('2019-11-11', database());
INSERT INTO sharding_by_month (create_time,db_nm) VALUES ('2019-12-25', database());
INSERT INTO sharding_by_month (create_time,db_nm) VALUES ('2019-12-31', database());

mycat查询：
在这里插入图片描述
插入成功。

查看各节点数据：
节点0：保存了10月的数据
在这里插入图片描述
节点1：保存了11月的数据
在这里插入图片描述
节点2：保存了12月的数据
在这里插入图片描述
如果添加一个在开始和结束日期之外的日期。
在这里插入图片描述
也会成功，但是分配到了最后一个节点那里，虽然也能成功，但是这个就不符合分配规则了，原本每个节点都保存一个月的数据。

所以节点数要与月份数一样或者大于月份数才能保证按月份分片。

枚举分片

就是用于分片的枚举字段的值是有限的，通过把它枚举出来分到特定的节点中。
在一些有限场景中适用，比如按地区分片，地区是有限的，可以枚举出来。

修改schema.xml添加表信息。

<table name="sharding_by_intfile" dataNode="dn1,dn2,dn3" rule="qs-shard-infile"/>

修改rule.xml，添加分片规则

<tableRule name="qs-shard-infile">
                <rule>
                        <columns>age</columns>
                        <algorithm>shardInFile</algorithm>
                </rule>
        </tableRule>


<function name="shardInFile" class="io.mycat.route.function.PartitionByFileMap">
                <!-- 枚举映射文件-->
                <property name="mapFile">shardInFile.txt</property>
                <!-- 类型 0位Integer型，非0位String型-->
                <property name="type">0</property>
                <!-- 默认节点，当存在枚举之外的值时，就分配到这个节点-->
                <property name="defaultNode">0</property>
        </function>

创建shardInFile.txt文件：

#这里仅仅枚举三个值，18就分到节点0,19就节点1,20就节点2
18=0
19=1
20=2

重启mycat并连接执行如下语句

INSERT INTO `sharding_by_intfile` (age,db_nm) VALUES (19, DATABASE());
INSERT INTO `sharding_by_intfile` (age,db_nm) VALUES (20, DATABASE());
INSERT INTO `sharding_by_intfile` (age,db_nm) VALUES (18, DATABASE());
INSERT INTO `sharding_by_intfile` (age,db_nm) VALUES (30, DATABASE());

mycat查询数据：
在这里插入图片描述
4条数据。

然后查看各节点数据。
节点0：
在这里插入图片描述
枚举18分到节点0,30在枚举之外，分到默认节点0，符合。

节点1：
在这里插入图片描述
节点2：
在这里插入图片描述

一致性哈希分片

一致性哈希的知识要另外自己了解，总的来说就是通过节点哈希在一个闭环里面表示一段范围，然后数据会落到相应的地方。分布比较均匀并且在扩容缩容时只需对圆环的下一个节点进行数据迁移即可，可以减少数据的迁移量。

先修改schema.xml，添加相应逻辑表信息。

 <table name="sharding_by_murmur" dataNode="dn1,dn2,dn3" rule="qs-shard-murmur" primaryKey="id"/>

修改rule.xml，定义分片规则：

<tableRule name="qs-shard-murmur">
                <rule>
                        <columns>id</columns>
                        <algorithm>shardMurMur</algorithm>
                </rule>
        </tableRule>


<function name="shardMurMur"
                          class="io.mycat.route.function.PartitionByMurmurHash">
                <property name="seed">0</property>
                <!-- 配置节点个数，要准确-->
                <property name="count">3</property>
                <!-- 虚拟节点个数，因为如果只有三个节点的话，会使得数据分布不均匀，需要配置虚拟节点来使得数据分布均匀，具体看一致性哈希相关知识就能理解了 -->
                <property name="virtualBucketTimes">160</property>
        </function>

重启mycat连接并执行下面语句：

INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (1, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (2, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (3, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (4, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (5, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (6, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (7, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (8, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (9, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (10, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (11, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (12, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (13, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (14, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (15, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (16, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (17, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (18, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (19, database());
INSERT INTO `sharding_by_murmur` (id,db_nm) VALUES (20, database());

mycat查询：
在这里插入图片描述
汇总了插入的20条数据。

查看各节点数据：
节点0：7条数据
在这里插入图片描述
节点1：8条数据
在这里插入图片描述
节点2：5条数据
在这里插入图片描述
也算比较均匀了。

固定分配哈希

跟redis集群的哈希槽类似，共1024个槽，然后每个节点会分到一定的哈希槽，数据对槽数进行哈希取模计算得到一个槽数。就分配到管理该哈希槽的节点上。

先修改schema.xml添加表信息：

<table name="sharding_by_long" dataNode="dn1,dn2,dn3" rule="qs-shard-long" primaryKey="id"/>

修改rule.xml定义分片规则

<tableRule name="qs-shard-long">
                <rule>
                        <columns>id</columns>
                        <algorithm>shardLong</algorithm>
                </rule>
        </tableRule>


<function name="shardLong"
                          class="io.mycat.route.function.PartitionByLong">
                 <!-- 三个节点，第一个节点分配256个槽，第二个节点分配256个槽，第三个节点分配512个槽，一一对应 -->
                <property name="partitionCount">1,1,1</property>
                <property name="partitionLength">256,256,512</property>
        </function>

在这里插入图片描述
重启mycat连接并执行下面语句：

INSERT INTO `sharding_by_long` (id,db_nm) VALUES (222, DATABASE());  
INSERT INTO `sharding_by_long` (id,db_nm) VALUES (333, DATABASE());  
INSERT INTO `sharding_by_long` (id,db_nm) VALUES (666, DATABASE());

mycat查询数据：数据已经插入成功。
在这里插入图片描述
查看各节点数据：
节点0：222%1024=222,222槽是归节点0管理，所以分配到了节点0中。
在这里插入图片描述
节点1：
在这里插入图片描述
节点2：
在这里插入图片描述
这种分片方式的优点是如果新增节点，给新增节点分配哈希槽，只需迁移哈希槽对应的数据即可。

Mycat分库分表生死战：垂直拆分×水平分片×行业血泪案例（实战篇二）
肖哥弹架构博客
06-22 1146
当订单表突破8000万行，你的数据库开始发出死亡呻吟：CPU飙升至98%，查询响应突破2秒，磁盘IO像垂死挣扎的心跳。这不是假设——这是某电商平台大促前夜的**真实噩梦**。他们选择的分库分表方案，在4.2秒内蒸发2400万订单，血淋淋地印证了分布式架构的残酷法则：**正确的分片让你涅槃重生，错误的设计让你坠入地狱**。 本文将撕开理论面纱，揭示分库分表的三重生死线： 1. **垂直拆分的铁血三律**：高内聚业务域集中如何避免跨库查询风暴，低耦合设计怎样阻止级联爆炸，事务闭环为何是资金安全的最后防线
初学者redis-cluster集群搭建
weixin_40322020的博客
07-28 479
目录 为什么要用redis-cluster 客户端分片 数据分布理论 搭建redis cluster 1、准备6套redis数据库，6套对应的启动配置文件,3主3从 2、分别启动6套redis数据库 3、安装ruby，一句命令分配redis集群的槽位 4、此时槽位已经分配好了，可以写入集群数据了 为什么要用redis-cluster 1.并发问题 redis官方生成可以达到 10万/每秒,每秒执行10万条命令，假如业务需要每秒100万的命令执行呢？ 2.数据量太大 一台..
查询mysql分区表其中一个分区的数据
weixin_42599558的博客
01-09 488
MySQL分区表的一个分区的数据可以使用如下的查询语句获取: SELECT * FROM table_name WHERE partition_column_name = partition_value;
MySQL查询特定分区中的数据
最新发布
学亮编程手记
08-23 2517
表很大并且有很多分区的话，可以显著提升查询性能，因为它不需要扫描其他无关的分区。关键字来明确指出你要查询哪一个分区。这里是一个具体的例子，假设你有一个名为。的表，并且这个表已经被按照某个字段分区，其中一个分区被命名为。如果你有更具体的查询需求或者想添加额外的过滤条件，可以在。需要替换为你实际使用的列名和值。这条 SQL 语句将会只从。分区中读取数据，这样如果。中的数据，你可以使用。如果你想查询特定分区。
高性能MySQL读书摘要（七）- MySQL高级特性
gonghaiyu的博客
09-14 326
MySQL高级特性7.1 分区表7.1.1 分区表的原理7.1.2分区表的类型 7.1 分区表 对用户来说，分区表是一个独立的逻辑表，但是底层由多个物理子表组成。实现分区的代码实际上是对一组底层表的句柄对象的封装。对分区表的请求，都会通过句柄对象转化为存储引擎的接口调用。所以分区对于SQL层来说是一个完全封装底层实现的黑盒子，对应用时透明的，但是从底层的文件系统来看就很容易发现，每一个分区表都有一个使用#分隔命名的表文件。 MySQL实现分区表的方式—对底层表的封装—意味着索引也是按照分区的子表定义的，.
sql 账号查询一个表查询权限_一个查询语句引发的问题以及巨型表相关操作探索与思考...
weixin_39860064的博客
12-04 148
背景：关于这个标题想了试了好几个总觉得欠那么点意思。大致情况是，在某服务支持中，1张大表4.5T左右，该表也是分区表。其中一个执行频繁的SQL写法有很大问题，导致巨表全量扫描，造成IO负载很大，业务收到严重影响。由于线上阶段基本上没有改SQL的可能， 只能通过其他途径优化。现场想到一种可行的方案，周末实在手痒，决定测试测试该方案理论上的可行性。基本情况：数据库：Oracle 11G表情...
利用Mycat进行分表分片
wqr111的博客
06-22 2360
分表 相对于垂直拆分，水平拆分不是将表做分类，而是按照某个字段的某种规则来分散到多个库之中，每个表中 包含一部分数据。简单来说，我们可以将数据的水平切分理解为是按照数据行的切分，就是将表中的某些行切分 到一个数据库，而另外的某些行又切分到其他的数据库中。 需求 在电信行业有电信计费系统(BOSS系统)，假设其中存储如下信息： 客户手机账户（手机号）信息 手机通话记录信息 字典表（如存储常用的码表信息，例如 通话类型，01：呼出，02：呼入等） 简单ER图如下： MySQL 单表存储数据条数
MyCat分库分表之逻辑库、逻辑表及分片规则
07-12 5243
1，逻辑库 对实际应用来说，并不需要知道中间件的存在，业务开发人员只需要知道数据库的概念，所以数据库中间件可以被看做是一个或多个数据库集群构成的逻辑库。 如图一中，在MYCAT服务区中的TESTDB库，只是逻辑上存在的数据库，真正的数据来源还是来源MYSQL服务区中的两台实际的Mysql db实例。 在Mycat中逻辑库在{MYCAT_HOME}/conf/schema.xml 用 标签定义。如图： 2，逻辑表 既然有逻辑库，肯定将会存在逻辑表，分布式数据库中，对应用来说，读写数据的表就是逻辑表。 逻辑表
mycat分库、分片、分表、读写分离、主从复制、性能监控-对mycat彻底掌握
王泽 的博客
03-14 1510
Mycat 分库分表、读写分离、主从复制
Mycat读写分离、主从切换、分库分表的操作记录- 线上操作手册
01-17
8. **全局表和分片策略**：通过全局表和ER关系实现高效多表JOIN查询。 9. **多租户支持**：允许在同一系统内维护多个独立的数据库环境。 10. **分布式事务处理**：支持弱XA分布式事务，确保数据一致性。 11. **全局...
oracle 分区_oracle自动按月分区
weixin_39830303的博客
12-06 788
分区表：当表中的数据量不断增大，查询数据的速度就会变慢，应用程序的性能就会下降，这时就应该考虑对表进行分区。表进行分区后，逻辑上表仍然是一张完整的表，只是将表中的数据在物理上存放到多个表空间(物理文件上)，这样查询数据时，不至于每次都扫描整张表。表分区的具体作用Oracle的表分区功能通过改善可管理性、性能和可用性，从而为各式应用程序带来了极大的好处。通常，分区可以使某些查询以及...
oracle查看某个分区的数据,查看oracle表的分区信息
weixin_28717431的博客
04-10 4898
显示分区表信息显示数据库所有分区表的信息：DBA_PART_TABLES显示当前用户可访问的所有分区表信息：ALL_PART_TABLES显示当前用户所有分区表的信息：USER_PART_TABLES显示表分区信息 显示数据库所有分区表的详细分区信息：DBA_TAB_PARTITIONS显示当前用户可访问的所有分区表的详细分区信息：ALL_TAB_PARTITIONS显示当前用户所有分区表的详细分...
mysql(39) : 查看表分区数据量
Lxinccode的博客
12-27 1844
【代码】mysql(39) : 查看表分区数据量。
oracle 分区表信息查询
峡谷胖猫的博客
01-16 2793
1,分区表信息 – （1）显示数据库所有分区表的信息 select * from DBA_PART_TABLES a where a.owner=upper(’’) and a.table_name=upper(’’); – （2）显示当前用户可访问的所有分区表信息 select * from ALL_PART_TABLES a where a.owner=upper(’’) and a.tab...
查看数据库表各分区数据数
weixin_45653314的博客
11-25 1486
SELECT PARTITION_NAME,TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = '表名';
spark的转换算子2
changshupx的博客
09-08 2010
1）coalesce def coalesce(numPartitions: Int, shuffle: Boolean = false)(implicit ord: Ordering[T] = null): RDD[T] 该函数用于将RDD进行重分区，使用HashPartitioner。 第一个参数为重分区的数目，第二个为是否进行shuffle，默认为false; 作用 缩减分区数，用于大数据集过滤后，提高小数据集的执行效率。 val ListRDD: RDD[Int] = context.makeRDD
mysql 查看表各分区数据总量
qq_42488996的博客
03-25 1726
SELECT PARTITION_NAME,TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = 'table_name';
MySQL的表分区
lehsyh的专栏
08-09 1306
一、什么是表分区通俗地讲表分区是将一大表，根据条件分割成若干个小表。mysql5.1开始支持数据表分区了。如：某用户表的记录超过了600万条，那么就可以根据入库日期将表分区，也可以根据所在地将表分区。当然也可根据其他的条件分区。   二、为什么要对表进行分区为了改善大型表以及具有各种访问模式的表的可伸缩性，可管理性和提高数据库效率。 分区的一些优点包括：      1）、与单个磁盘或文件系统...
指定分区表分区进行查询
wrh_csdn的博客
09-13 4623
select * from TBL_OPR_20_PERFORM_CNT partition(P201705);
Mycat数据库中间件分库分表技术详解
`rule.xml` 则用于配置分片规则，如按主键取模、范围分片、一致性哈希、枚举分片等，这些规则决定了某条记录应被写入哪个具体的数据库分片；`server.xml` 负责配置系统级参数，如用户权限、连接池设置、读写分离策略...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值