目录

mycat实现分库分表

垂直分库

垂直分库介绍

http://img.cana.space/picStore/20201121194909.png

单个数据库负载是有限的,在应对高并发时候,达到极限时候,容易崩掉,以及当某个表数据量很大的时候,执行速度缓慢,影响应用用户体验;

这时候,mycat提供了对数据库表垂直的库拆分,不同的业务模块的表,可以放不同的数据库,通过mycat,能屏蔽拆分细节,也就是连接mycat操作,我们依然可以看做是一个库;

同时mycat支持了把单个数据量巨大的表依据某个字段规则拆分成多个表分散存到多个数据库当中去,来减少单表压力;

垂直分库最佳实践

垂直分库如何根据表来分库呢?

这里一种情况,比如订单表,商品表。 订单表的一个商品外检关联商品表主键;多对一的关系;

如果我们把 订单表 商品表拆分到两个数据库中,那这里就会有一个很头疼的问题,这两个表Join关联查询的话,如何来搞呢。

这里传统的话,有四种解决方案:

  1. mycat新版本,提供了跨库2表join,但是假如数据量大的话,会有性能问题;
  2. 全局表,后面会讲到,每个数据库都有搞个商品表,有点浪费资源;
  3. 不join查询,业务代码里通过API方式另外再查询,看具情况使用;
  4. 采用冗余数据方式,订单表里面把商品id,商品名称,价格等数据库也搞进自己的表里,这样就不用join查询,也是有点浪费资源;

mycat官方就说明了,支持单库内任意Join,所以我们设计的时候,把同一个业务模块的表放同一个库,依据业务模块来垂直分库;

所以我们的最终分库原则以下三点:

1. 根据业务模块来划分库,不搞跨库join操作,避坑;

2. 公共表,比如数据字典表,系统属性表等,采用全局表;

3. 有些核心表,比如用户表,部门表,权限表等,业务模块偶尔用到的时候,可以通过API方式查询,无需划分到具体业务模块里去;

http://img.cana.space/picStore/20201121195054.png

垂直分库案例实现

我们抽象电商系统四个表:用户表,商品表,订单表,数据字典表

用户表t_user

1
2
3
4
5
6
CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `userName` varchar(20) DEFAULT NULL COMMENT '用户名',
  `password` varchar(20) DEFAULT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

商品表t_product

1
2
3
4
5
6
7
8
CREATE TABLE `t_product` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `name` varchar(50) DEFAULT NULL COMMENT '商品名称',
  `price` decimal(10,0) DEFAULT NULL COMMENT '价格',
  `description` text COMMENT '描述',
  `stock` int(11) DEFAULT NULL COMMENT '库存量',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

订单表t_order

1
2
3
4
5
6
7
8
CREATE TABLE `t_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `pId` int(11) DEFAULT NULL COMMENT '商品编号',
  `num` int(11) DEFAULT NULL COMMENT '购买数量',
  `uId` int(11) DEFAULT NULL COMMENT '用户编号',
  `orderDate` datetime DEFAULT NULL COMMENT '下单时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

我们分两个库,t_user一个库 t_product和t_order搞一个库,因为有join关联;

  • t_user 放 db_mall_user库;
  • t_product和t_order放db_mall_order库;

环境

编号 角色 分配IP
1 db_mall_user库; 182.30.0.7
2 db_mall_order库; 182.30.0.8
3 mycat 182.30.0.9

mycat-vertical.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
version: '2'
services: 
    db_mall_user: 
        image: mysql:5.7
        container_name: db_mall_user
        volumes: 
            - ./db_mall_user/log:/var/log/mysql
            - ./db_mall_user/data:/var/lib/mysql
            - ./db_mall_user/conf:/etc/mysql/mysql.conf.d
        restart: always
        environment:
            - MYSQL_ROOT_PASSWORD=333
        ports: 
            - 3306:3306
        networks: 
            mysql: 
                ipv4_address: 182.30.0.2 # 设置静态ipv4地址
    db_mall_order: 
        image: mysql:5.7
        container_name: db_mall_order
        volumes: 
            - ./db_mall_order/log:/var/log/mysql
            - ./db_mall_order/data:/var/lib/mysql
            - ./db_mall_order/conf:/etc/mysql/mysql.conf.d
        restart: always
        environment:
            - MYSQL_ROOT_PASSWORD=333
        ports: 
            - 3307:3306
        networks: 
            mysql: 
                ipv4_address: 182.30.0.3 # 设置静态ipv4地址
networks: # 使用自定义网络
    mysql:
        # ipam插件只在compose version 2中好使,
        # issue:https://github.com/docker/docker.github.io/pull/1636
        ipam: # 要使用静态ip必须使用ipam插件
            config:
            - subnet: 182.30.0.0/16 # 网段/16位掩码
              gateway: 182.30.0.1 # 网关地址

执行:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
$ dcp -f mysql-2m-2s.yml down
$ dcp -f mycat-vertical.yml up -d
Creating db_mall_user  ... done
Creating db_mall_order ... done

# david @ Davids-Macbook-Pro in ~/docker/compose-config/mysql [20:49:05]
$ docker_ip
/db_mall_order - 182.30.0.3
/db_mall_user - 182.30.0.2
/mycat01 - 182.30.0.9

测试使用,mysql配置使用原始配置即可,分别脸上mysql服务器,建db_mall_user和db_mall_order数据库

配置schemat.xml,这里我们要配置2个数据主机 以及两个数据节点,以及逻辑表;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

	<!-- 将randomDataNode改成dataNode -->
	<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100">
		<table name="t_user" primaryKey="id" dataNode="dn1" />
     	<table name="t_order" primaryKey="id" dataNode="dn2" />
     	<table name="t_product" primaryKey="id" dataNode="dn2" />
	</schema>

	<!--配置成自己的数据库-->
	<dataNode name="dn1" dataHost="localhost1" database="db_mall_user" />
	<dataNode name="dn2" dataHost="localhost2" database="db_mall_order" />


	<dataHost name="localhost1" maxCon="1000" minCon="10" balance="3"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<heartbeat>select user()</heartbeat>
		<writeHost host="hostM1" url="182.30.0.2:3306" user="root" password="333" />
	</dataHost>
	<dataHost name="localhost2" maxCon="1000" minCon="10" balance="3"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<heartbeat>select user()</heartbeat>
		<writeHost host="hostM2" url="182.30.0.3:3306" user="root" password="333" />
	</dataHost>
</mycat:schema>

重启mycat $ docker restart 9b

连接TESTDB,进来后能看到3张逻辑表,

http://img.cana.space/picStore/20201121211028.png

但此时还没有物理表,我们在TESTDB里执行前面的三条建表语句,执行完后分别切到两个物理库上查看,发现表确实创建了,接着我们在逻辑库上执行下面的数据插入:

注意linux区分大小写,我们使用逻辑库建表,物理库上表明都是大写,所以再使用逻辑库插入时表明也得大写

1
2
3
4
5
insert  into `T_USER`(`id`,`userName`,`password`) values (1,'java1234','123456'),(2,'jack','123'),(3,'marry','456');

insert  into `T_PRODUCT`(`id`,`name`,`price`,`description`,`stock`) values (1,'耐克鞋2020款001A','998','dfs',50),(2,'阿迪达斯休闲衣服2020Add','388','dfs',20);

insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values (1,1,1,2,'2020-03-16 22:10:25'),(2,2,3,3,'2020-03-16 22:10:34');

查看物理库,发现数据也都插入成功。

测试join

1
select * from T_ORDER o left join T_PRODUCT p on o.pId=p.id

http://img.cana.space/picStore/20201121212021.png

垂直分库优缺点

优点:

  1. 拆分简单明了,拆分规则明确
  2. 应用程序模块清晰明确,整合容易
  3. 数据维护方便易行,容易定位
  4. 减轻了单个库的负载

缺点:

  1. 部分表关联无法在数据库级别完成,需要在程序中完成
  2. 对于访问机器频繁且数据量超大的表任然存在性能瓶颈
  3. 切分达到一定程度之后,扩展性会遇到限制,单表性能依然存在瓶颈

水平分表

水平分表介绍

http://img.cana.space/picStore/20201121194909.png

我们可以根据业务来垂直划分库,来减少服务器负载,但是假如单个表的数据量很大的时候,比如订单表,上了千万数据量,就查询性能就很低,

这时候我们需要进行水平分表,把单个表的数据根据分表策略分到多个数据库,来减少单表压力,这就是水平分表;

水平分表原则

具体怎么个水平分表法,我们最终目标是要根据具体业务把单表的请求负载均衡的分散到多库中。

不能出现大量的请求集中1,2个分表;

比如订单表,我们划分的时候,不能根据id来划分,因为平时请求查询的时候一般是根据某个用户id去查询用户的订单信息的。

所以我们这个订单表的划分原则是根据用户id 取模划分,这样的话,请求能均衡的分布到多个分表,以及 查询的时候 大部分情况都是一个分表查询,效率会高一些;

MYCAT常用的分片规则如下:

  1. 分片枚举: sharding-by-intfile
  2. 主键范围约定: auto-sharding-long 此分片适用于,提前规划好分片字段某个范围属于哪个分片
  3. 一致性hash: sharding-by-murmur
  4. 字符串hash解析: sharding-by-stringhash
  5. 按日期(天)分片:sharding-by-date
  6. 按单月小时拆分: sharding-by-hour
  7. 自然月分片: sharding-by-month
  8. 取模:  mod-long 此规则为对分片字段求摸运算
  9. 取模范围约束: sharding-by-pattern 此种规则是取模运算与范围约束的结合,主要为了后续数据迁移做准备,即可以自主决定取模后数据的节点分布

水平分表取模分片实现

结合垂直分库一起演示,建3个库,db_mall_user和db_mall_order_1、db_mall_order_2,后面两个库做水平分表

老规矩,mycat-horizontal.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
version: '2'
services: 
    db_mall_user: 
        image: mysql:5.7
        container_name: db_mall_user
        volumes: 
            - ./db_mall_user/log:/var/log/mysql
            - ./db_mall_user/data:/var/lib/mysql
            - ./db_mall_user/conf:/etc/mysql/mysql.conf.d
        restart: always
        environment:
            - MYSQL_ROOT_PASSWORD=333
            - MYSQL_ROOT_HOST=%
        ports: 
            - 3306:3306
        networks: 
            mysql: 
                ipv4_address: 182.30.0.2 # 设置静态ipv4地址
    db_mall_order_1: 
        image: mysql:5.7
        container_name: db_mall_order_1
        volumes: 
            - ./db_mall_order_1/log:/var/log/mysql
            - ./db_mall_order_1/data:/var/lib/mysql
            - ./db_mall_order_1/conf:/etc/mysql/mysql.conf.d
        restart: always
        environment:
            - MYSQL_ROOT_PASSWORD=333
            - MYSQL_ROOT_HOST=%
        ports: 
            - 3307:3306
        networks: 
            mysql: 
                ipv4_address: 182.30.0.3 # 设置静态ipv4地址
    db_mall_order_2: 
        image: mysql:5.7
        container_name: db_mall_order_2
        volumes: 
            - ./db_mall_order_2/log:/var/log/mysql
            - ./db_mall_order_2/data:/var/lib/mysql
            - ./db_mall_order_2/conf:/etc/mysql/mysql.conf.d
        restart: always
        environment:
            - MYSQL_ROOT_PASSWORD=333
            - MYSQL_ROOT_HOST=%
        ports: 
            - 3308:3306
        networks: 
            mysql: 
                ipv4_address: 182.30.0.4 # 设置静态ipv4地址
networks: # 使用自定义网络
    mysql:
        # ipam插件只在compose version 2中好使,
        # issue:https://github.com/docker/docker.github.io/pull/1636
        ipam: # 要使用静态ip必须使用ipam插件
            config:
            - subnet: 182.30.0.0/16 # 网段/16位掩码
              gateway: 182.30.0.1 # 网关地址

执行:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
$ dcp -f mycat-vertical.yml down
$ dcp -f mycat-horizontal.yml up -d
Creating db_mall_order_2 ... done
Creating db_mall_user    ... done
Creating db_mall_order_1 ... done
$ docker_ip
/db_mall_order_1 - 182.30.0.3
/db_mall_user - 182.30.0.2
/db_mall_order_2 - 182.30.0.4
/mycat01 - 182.30.0.9

连上数据库服务器,分别创建db_mall_user数据库和db_mall_order数据库

http://img.cana.space/picStore/20201121215853.png

mycat配置水平分库

先配置分片规则,打开rule.xml,增加一个规则

1
2
3
4
5
6
7
8
9
<!-- 订单表水平分片规则,使用mod-long取模分片,需要设置mod-long的count参数 -->
	<tableRule name="order-rule">
       <rule>
       	  <!-- columns是规则字段 根据这个字段来实现分表 -->
          <columns>uId</columns>
          <!-- algorithm是分表算法 我们用 mod-long 取模分片 -->
          <algorithm>mod-long</algorithm>
       </rule>
  </tableRule>

修改mod-long方法

1
2
3
4
5
<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
		<!-- how many data nodes -->
		<!-- 我们要把 count改成2 因为我们就搞了2个分片 -->
		<property name="count">2</property>
	</function>

再来配置水平分片,修改schema.xml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">

	<!-- 将randomDataNode改成dataNode -->
	<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100">
		<table name="t_user" primaryKey="id" dataNode="dn1" />
		<!-- 我们搞了两个数据节点dn2和dn3 作为t_order表的两个分片 规则是 order-rule -->
     	<table name="t_order" primaryKey="id" dataNode="dn2,dn3" rule="order-rule" />
	</schema>

	<!--配置成自己的数据库-->
	<dataNode name="dn1" dataHost="localhost1" database="db_mall_user" />
	<dataNode name="dn2" dataHost="localhost2" database="db_mall_order" />
	<dataNode name="dn3" dataHost="localhost3" database="db_mall_order" />


	<dataHost name="localhost1" maxCon="1000" minCon="10" balance="3"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<heartbeat>select user()</heartbeat>
		<writeHost host="hostM1" url="182.30.0.2:3306" user="root" password="333" />
	</dataHost>

	<dataHost name="localhost2" maxCon="1000" minCon="10" balance="3"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<heartbeat>select user()</heartbeat>
		<writeHost host="hostM2" url="182.30.0.3:3306" user="root" password="333" />
	</dataHost>

	<dataHost name="localhost3" maxCon="1000" minCon="10" balance="3"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<heartbeat>select user()</heartbeat>
		<writeHost host="hostM3" url="182.30.0.4:3306" user="root" password="333" />
	</dataHost>

</mycat:schema>

ok,现在启动mycat:$ docker start 9b

使用navicat连接TESTDB,分别创建T_USER表和T_ORDER表,并执行插入语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `userName` varchar(20) DEFAULT NULL COMMENT '用户名',
  `password` varchar(20) DEFAULT NULL COMMENT '密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

CREATE TABLE `t_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `pId` int(11) DEFAULT NULL COMMENT '商品编号',
  `num` int(11) DEFAULT NULL COMMENT '购买数量',
  `uId` int(11) DEFAULT NULL COMMENT '用户编号',
  `orderDate` datetime DEFAULT NULL COMMENT '下单时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

insert  into `T_ORDER`(`pId`,`num`,`uId`,`orderDate`) values (1,1,1,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`pId`,`num`,`uId`,`orderDate`) values (1,1,2,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`pId`,`num`,`uId`,`orderDate`) values (1,1,2,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`pId`,`num`,`uId`,`orderDate`) values (1,1,4,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`pId`,`num`,`uId`,`orderDate`) values (1,1,5,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`pId`,`num`,`uId`,`orderDate`) values (1,1,5,'2020-03-16 22:10:25');

查看数据分布情况:

http://img.cana.space/picStore/20201121232739.png

http://img.cana.space/picStore/20201121232812.png

可以看到数据成功按照我们的规则进行了分片,查询数据,结果是mycat拼接后的结果

http://img.cana.space/picStore/20201121232837.png

全局自增ID

水平分表后,会产生一个问题,就是自增ID问题;

我们以前单表的时候,直接 mysql自增很好搞。单是分表后,就不行了,会有冲突;参照上面水平分表的示例

所以解决方案可以不用自增,在应用层搞唯一id,比如redis单线程incr 生成自增id;或者 uuid,基于雪花算法的 UidGenerator等;我们这里用mycat提供的支持来生成全局自增ID;

一、我们首先在分片的第一节点 建立表和相关函数;

mycat都给我们提供了,在mysql的conf目录下,dbseq.sql文件;

我们在第一个分片节点dn2 的db_mall_order数据库里导入sql脚本执行即可;

http://img.cana.space/picStore/20201121233321.png

二、修改sequence_db_conf.properties文件

1
2
3
4
5
#sequence stored in datanode
GLOBAL=dn2
COMPANY=dn2
CUSTOMER=dn2
ORDERS=dn2

三、修改server.xml配置文件的 sequnceHandlerType配置;改成1,默认已经是1,check一下

1
2
3
4
5
<property name="useGlobleTableCheck">0</property>  <!-- 1为开启全加班一致性检测、0为关闭 -->
		<property name="sqlExecuteTimeout">300</property>  <!-- SQL 执行超时 单位:秒-->
		<property name="sequnceHandlerType">1</property>
		<property name="sequnceHandlerPattern">(?:(\s*next\s+value\s+for\s*MYCATSEQ_(\w+))(,|\)|\s)*)+</property>
	<property name="subqueryRelationshipCheck">false</property>

sequnceHandlerType配置

  • 0 本地方式
  • 1 数据库方式
  • 2 时间戳方式

四、重启mycat;

1
$ docker restart 9b

五、测试;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
drop table T_ORDER;
CREATE TABLE `t_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `pId` int(11) DEFAULT NULL COMMENT '商品编号',
  `num` int(11) DEFAULT NULL COMMENT '购买数量',
  `uId` int(11) DEFAULT NULL COMMENT '用户编号',
  `orderDate` datetime DEFAULT NULL COMMENT '下单时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values ('next value for MYCATSEQ_GLOBAL',1,1,1,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values ('next value for MYCATSEQ_GLOBAL',1,1,2,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values ('next value for MYCATSEQ_GLOBAL',1,1,2,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values ('next value for MYCATSEQ_GLOBAL',1,1,4,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values ('next value for MYCATSEQ_GLOBAL',1,1,5,'2020-03-16 22:10:25');
insert  into `T_ORDER`(`id`,`pId`,`num`,`uId`,`orderDate`) values ('next value for MYCATSEQ_GLOBAL',1,1,5,'2020-03-16 22:10:25');
select * from T_ORDER;

http://img.cana.space/picStore/20201121234246.png

可以看到id全局自增,注意在插入的时候id要写成'next value for MYCATSEQ_GLOBAL',mycat解析到这个字符串会去触发之前生成的函数进行处理。

全局表

前面讲过,当两个或者多个表有join关联时候,跨分片查询会有瓶颈问题,我们其中有一个解决方案是通过全局表,

全局表的话,每个分片节点都有这个表,并且mycat会实时同步数据;

适合数据量不大,不频繁变动数据的表,比如 数据字典表,或者一些类别表;

在schema.xml 配置逻辑表参数中指定 type=“global” 即可;

1
2
3
4
5
6
<!-- 将randomDataNode改成dataNode -->
	<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100">
			...
     	<!-- 配置全局表 -->
     	<table name="t_datadic" primaryKey="id" dataNode="dn1,dn2,dn3" type="global" />
	</schema>

重启mycat

1
$ docker restart 9b

在逻辑库中执行如下sql

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
-- 数据字典表t_datadic
CREATE TABLE `t_datadic` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `name` varchar(20) DEFAULT NULL COMMENT '数据字典名称',
  `value` varchar(20) DEFAULT NULL COMMENT '数据字典值',
  `remark` varchar(100) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

insert  into `T_DATADIC`(`id`,`name`,`value`,`remark`) values (1,'性别','男',NULL),(2,'性别','女',NULL),(3,'性别','男变女',NULL),(4,'性别','女变男',NULL),(5,'政治面貌','共产党',NULL),(6,'政治面貌','共青团员',NULL),(7,'政治面貌','无党派人士',NULL);

查看其它3个库,都已经创建这个数据字典表并且插入数据了。

注意
表名在mycat配置文件以及创建表的时候小写,等在逻辑库中创建好后物理库中就变成大写了,感兴趣的可以自行研究怎么设置。