目录
一、概述
1、MyCat是什么？
它是一个开源的分布式数据库系统，可以理解成 Mycat 就是MySQL Server，而Mycat 后面连接的MySQL Server，就好象是MySQL 的存储引擎,如InnoDB，MyISAM 等，因此，Mycat 本身并不存储数据，数据是在后端的MySQL 上存储的，因此数据可靠性以及事务等都是MySQL 保证的。
2、原理：
最重要的就是“拦截”，他拦截了用户发送过来的SQL语句，首先对sql语句做了一些分析：如分片、路由分析、读写分离分析、缓存分析等，然后再将此sql发往后端真实数据库，并将返回结果做适当处理，再返回给客户。
3、能干什么
1、读写分离
2、数据分片
垂直拆分（分库）、水平拆分（分表）、垂直+水平拆分（分库分表）
3、多数据源整合
4、Mycat监控
- 支持对Mycat、Mysql性能监控
- 支持对Mycat的JVM内存提供监控服务
- 支持对线程的监控
- 支持对操作系统的CPU、内存、磁盘、网络的监控
4、安装部署
1、环境准备
192.168.134.132
192.168.134.133
192.168.134.1342、安装
1、下载
http://dl.mycat.org.cn/1.6.7.5/2020-4-10/
2、上传解压到/usr/local/
[root@rabbitmq_1 local]# tar -zxvf Mycat-server-1.6.7.5-release-20200410174409-linux.tar.gz
[root@rabbitmq_1 mycat]# ls
bin catlet conf lib logs version.txt
bin 程序目录，存放了启动脚本
./mycat start 启动
./mycat stop 停止
./mycat restart 重启
./mycat status 查看mycat的启动状态
conf 目录下存放配置文件，修改配置文件，需要重启Mycat
schema.xml： 定义逻辑库，表、分片节点等内容
rule.xml： 定义分片规则
server.xml： 定义用户以及系统相关变量，如端口等
lib 目录下主要存放mycat 依赖的一些jar 文件
日志存放在logs/mycat.log 中，每天一个文件，日志的配置是在conf/log4j.xml 中
配置环境变量
vi /etc/profile
添加如下配置信息：
export MYCAT_HOME=/usr/local/mycat
export PATH=$MYCAT_HOME/bin:$PATH:$JAVA_HOME/bin
3、登录
目前mycat 有两个端口，8066 数据端口，9066 管理端口，命令行的登陆是通过9066 管理端口来操作，登录方式类似于mysql 的服务端登陆。
mysql -h127.0.0.1 -utest -ptest -P9066 [-dmycat]
4、常用管理命令
-h 后面是主机，即当前mycat 按照的主机地址，本地可用127.0.0.1 远程需要远程ip
-u Mycat server.xml 中配置的逻辑库用户
-p Mycat server.xml 中配置的逻辑库密码
-P 后面是端口默认9066，注意P 是大写
-d Mycat server.xml 中配置的逻辑库
show @@help：查看所有的命令
reload @@config;该命令用于更新配置文件，例如更新schema.xml 文件后在命令行窗口输入该命令，可不用重启即进行配置文件更新。
show @@database;该命令用于显示MyCAT 的数据库的列表，对应schema.xml 配置文件的schema 子节点
show @@datanode;该命令用于显示MyCAT 的数据节点的列表，对应schema.xml 配置文件的dataNode 节点，其中，“NAME”表示dataNode 的名称；“dataHost”表示对应dataHost 属性的值，即数据主机；“ACTIVE”表示活跃连接数；“IDLE”表示闲置连接数；“SIZE”对应总连接数量。
运行如下命令，可查找对应的schema 下面的dataNode 列表：
show @@datanode where schema = ?
show @@version该命令用于获取MyCAT 的版本
show @@connection该命令用于获取Mycat 的前端连接状态，即应用与mycat 的连接
kill @@connection id,id,id用于杀掉连接。
show @@backend查看后端连接状态。
show @@sql ; 用来记录用户通过本地8066 端口向Mycat-Server 发送的SQL 请求执行信息
show @@sql.slow ; 请求执行SQL 语句中超过慢SQL 时间阈值的（reload @@sqlslow=0 ; # 是的这条命令就是刚才提到的'如何设定慢SQL' 时间阈值的命令）
show @@sql.sum ; 执行的SQL 命令的统计信息数据
3、Mycat配置详解
1、server.xml
server.xml 几乎保存了所有mycat 需要的系统配置信息
user 标签
<user name="test" defaultAccount="true"> //对应的是mycat的用户名和密码
<property name="password">test</property>
<property name="schemas">TESTDB</property>
<property name="defaultSchema">TESTDB</property>
<!--No MyCAT Database selected 错误前会尝试使用该schema作为schema，不设置则为null,报错 -->
<!-- 表级 DML 权限设置 -->
<!--
<privileges check="false">
<schema name="TESTDB" dml="0110" >
<table name="tb01" dml="0000"></table>
<table name="tb02" dml="1111"></table>
</schema>
</privileges>
-->
</user>
详解：
用户相关配置：
name：设置用户的用户名，这里为 "root"。
defaultAccount：指定该用户是否为默认账户，这里设置为 "true"。
password：设置该用户的密码，这里密码为 "123456"。
schemas：指定该用户可访问的数据库（schema），这里用户具有访问 "TESTDB" 数据库的权限。
defaultSchema：指定用户默认使用的数据库（schema），这里设置为 "TESTDB"。
表级 DML 权限设置：
privileges 元素的 check 属性可以控制是否检查表级权限，这里设置为 "false"，表示不进行检查。
在 privileges 元素内部，通过 schema 元素来配置不同的数据库（schema）的权限。
schema 元素的 name 属性指定数据库的名称，这里为 "TESTDB"。
schema 元素的 dml 属性用于设置数据库级别的 DM权限，这里设置为 "0110"，表示该用户对数据库可以执行INSERT 和 UPDATE 操作。
在 schema 元素内部，通过 table 元素来配置不同表的权限。
table 元素的 name 属性指定表的名称，这里包括 "tb01" 和 "tb02"。
table 元素的 dml 属性用于设置表级别的 DML 权限，这里对于 "tb01" 表设置为 "0000"，表示该用户对该表没有任何 DML 权限；对于 "tb02" 表设置为 "1111"，表示该用户对该表具有 SELECT、INSERT、UPDATE 和 DELETE 的完全权限。
0和1 表示DML语句的权限，SELECT、INSERT、UPDATE、DELETE，0代表没有权限。1代表有权限。2、schema.xml
schema.xml 作为MyCat中重要的配置文件之一，管理着MyCat的逻辑库、表、分片规则、DataNode以及DataSource。搞懂这些配置是正确使用MyCat的前提。
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<!-->schema标签用于定义MyCat示例中的逻辑库<-->
<!-->name 虚拟库的名字，对应刚刚在server.xml中设置的TESTDB <-->
<!-->randomDataNode 虚拟库对应的真实database，值为dataNode标签的name<-->
<!-->checkSQLschema 是否检查自动删除 “虚拟库名”<-->
<!-->sqlMaxLimit 允许最大查询记录数<-->
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1"> //
<!-- 可以访问的表，只有设置在这里的表才会被MyCat管理访问 dataNode:虚拟库对应的真实database，对应<dataNode>标签。
如果做分片，则配置多个，用逗号分隔；或者使用db$0-99，代表db0到db99的database rule：分片规则，如果没有则删除
-->
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
<childTable name="customer_addr" primaryKey="id" joinKey="customer_id" parentKey="id"> </childTable>
</table>
</schema>
<!-- 真实的database信息，每一个dataNode就是一个数据库分片
name：虚拟名称
dataHost：真实库的主机信息，对应<dataHost>标签
database：真实MySQL中真实的物理数据库名称
-->
<dataNode name="dn1" dataHost="localhost1" database="db1" />
<dataNode name="dn2" dataHost="localhost1" database="db2" />
<dataNode name="dn3" dataHost="localhost1" database="db3" />
<!-- 真实库的主机信息
name：主机名,name属性值要与dataNode节点中的dataHost属性值对应
maxCon：最大连接， minCon：最小连接
balance：负载均衡方式：0~3四种选项。0，不开启读写分离。1~3都开启，区别是主是否参与读
writeType：写负载均衡。永远设置0
dbDriver：驱动类型，推荐native，可选jdbc
switchType：主从的自动切换
-->
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1" slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<!-- 这里设置写主机信息 -->
<writeHost host="hostM1" url="jdbc:mysql://localhost:3306" user="root"
password="123456">
<!-- 这里设置读主机信息 -->
<readHost host="hostS1" url="192.168.134.132:3306" user="root" password="123456" />
</writeHost>
</dataHost>
</mycat:schema>schema标签：
用于定义MyCat示例中的逻辑库，MyCat 可以有多个逻辑库，每个逻辑库都有自己的相关配置。可以使用schema 标签来划分这些不同的逻辑库。如果不配置schema 标签，所有的表配置，会属于同一个默认的逻辑库。
<schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
<!-->table 标签是定义需要分片的表<-->
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
<childTable name="customer_addr" primaryKey="id" joinKey="customer_id" parentKey="id"> </childTable>
</table>
</schema>相关属性：
| 属性名 | 值 | 数量限制 |
| checkSQLschema | Boolean | 1 |
| sqlMaxLimit | integer | 1 |
| randomDataNode | 任意string | （0...1） |
table标签：
定义了MyCat 中的逻辑表，所有需要拆分的表都需要在这个标签中定义。
相关属性：
| 属性名 | 值 | 说明 |
| name | string | 表名 |
| dataNode | string | 数据节点，该属性的值需要和dataNode 标签中name 属性的值相互对应 |
| rule | string | 分片规则名字，规则名字在rule.xml 中定义，必须与tableRule 标签中name 属性属性值一一对应。 |
| ruleRequired | Boolean | 该属性用于指定表是否绑定分片规则，如果配置为true，但没有配置具体rule 的话，程序会报错。 |
| primaryKey | string | 主键 |
| type | string | 属性：只有全局表（global）、普通表（不知道该值为global的所有表） |
| autoIncrement | Boolean | true。表示id字段将自动递增生成唯一的值 |
| subTables | string | |
| needAddLimit | Boolean | 是否添加limit限制，配置文件已经添加 |
| fetchStoreNodeByJdbc | Boolean |
<table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">childTable 标签：
<childTable name="customer_addr" primaryKey="id" joinKey="customer_id" parentKey="id"> </childTable>用于定义E-R 分片的子表。通过标签上的属性与父表进行关联。
相关属性：
| 属性名 | 值 | 说明 |
| name | string | 子表名 |
| primaryKey | string | 主键 |
| joinKey | string | 插入子表的时候会使用这个列的值查找父表存储的数据节点。 |
| parentKey | string | 一般为与父表建立关联关系的列名。程序首先获取joinkey 的值，再通过parentKey 属性指定的列名产生查询语句，通过执行该语句得到父表存储在哪个分片上。从而确定子表存储的位置。 |
dataNode标签：
<dataNode name="dn1" dataHost="localhost1" database="db1" />：定义了MyCat中的数据节点，也就是我们通常说所的数据分片。一个dataNode 标签就是一个独立的数据分片。
例子中所表述的意思为：使用名字为localhost1 数据库实例上的db1 物理数据库，这就组成一个数据分片，最后，我们使用名字dn1 标识这个分片。
dataNode属性：
| 属性名 | 值 | 说明 |
| name | string | 节点名称 唯一的，我们需要在table 标签上应用这个名字，来建立表与分片对应的关系。 |
| dataHost | string | 数据主机，属性值是引用dataHost 标签上定义的name 属性。 |
| database | string | 数据库名称 |
dataHost 标签：
作为Schema.xml 中最后的一个标签，该标签在mycat 逻辑库中也是作为最底层的标签存在，直接定义了具体的数据库实例、读写分离配置和心跳语句。
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1" slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<!-- can have multi write hosts -->
<writeHost host="hostM1" url="jdbc:mysql://localhost:3306" user="root"
password="root">
</writeHost>
<!-- <writeHost host="hostM2" url="localhost:3316" user="root" password="123456"/> -->
</dataHost>相关属性：
| 属性名 | 值 | 说明 |
| name | string | 唯一标识dataHost 标签，供上层的标签使用。 |
| maxCon | interger | 最大连接数 |
| minCon | interger | 最小连接数 |
| balance | interger | 负载均衡的方式， 0：不开启读写分离机制，所有读操作都发送到当前可用的writeHost 上。 1：简单的说，当双主双从模式(M1->S1，M2->S2，并且M1 与M2 互为主备)，正常情况下，M2,S1,S2 都参与select 语句的负载均衡。 2：所有读操作都随机的在writeHost、readhost 上分发。 3： |
| writeType | interger | 写入类型： 0：表示写入操作的类型，默认为同步写入。 |
| dbType | string | 数据库类型 |
| dbDriver | string | 数据库驱动 |
| switchType | interger | 切换方式： -1：表示不自动切换 1：默认值，自动切换 2：基于MySQL 主从同步的状态决定是否切换 心跳语句为show slave status 3：基于MySQL galary cluster 的切换机制（适合集群） 心跳语句为show status like ‘wsrep%’ |
| slaveThreshold | interger | Mycat 心跳机制通过检测show slave status 中的"Seconds_Behind_Master", "Slave_IO_Running","Slave_SQL_Running" 三个字段来确定当前主从同步的状态以及Seconds_Behind_Master 主从复制时延，当Seconds_Behind_Master>slaveThreshold 时，读写分离筛选器会过滤掉此Slave 机器，防止读到很久之前的旧数据。 |
heartbeat 标签：
这个标签内指明用于和后端数据库进行心跳检查的语句。例如,MYSQL 可以使用select user()
writeHost 标签、readHost 标签：
这两个标签都指定后端数据库的相关配置给mycat，用于实例化后端连接池。唯一不同的是，writeHost指定写的示例，readHost指定读实例，在一个dataHost 内可以定义多个writeHost 和readHost。但是，如果writeHost 指定的后端数据库宕机，那么这个writeHost 绑定的所有readHost 都将不可用。另一方面，由于这个writeHost 宕机系统会自动的检测到，并切换到备用的writeHost 上去。
两个标签的属性相同：
| 属性名 | 值 | 说明 |
| host | string | 用于表示不同实例，一般writeHost我们用M1，readHost我们用S1 |
| url | string | 连接点url |
| password | string | 密码 |
| user | string | 用户名 |
| weight | string | 权重配置在readhost 中作为读节点的权重 |
| usingDecrypt | string | 加密的，很少用 |
3、rule.xml
rule.xml 里面就定义了我们对表进行拆分所涉及到的规则定义。我们可以灵活的对表使用不同的分片算法，或者对表使用相同的算法但具体的参数不同。这个文件里面主要有tableRule 和function 这两个标签。在具体使用过程中可以按照需求添加tableRule 和function。
tableRule 标签：
<tableRule name="rule1">
<rule>
<columns>id</columns>
<algorithm>func1</algorithm>
</rule>
</tableRule>
name 属性指定唯一的名字，用于标识不同的表规则。
内嵌的rule 标签则指定对物理表中的哪一列进行拆分和使用什么路由算法。
columns 内指定要拆分的列名字。
algorithm 使用function 标签中的name 属性。连接表规则和具体路由算法。当然，多个表规则可以连接到同一个路由算法上。table 标签内使用。让逻辑表使用这个规则进行分片。function 标签：
<function name="func1" class="io.mycat.route.function.PartitionByLong">
<property name="partitionCount">8</property>
<property name="partitionLength">128</property>
</function>
function 元素的 name 属性值为 "func1"，表示这是一个名为 "func1" 的函数。
function 元素内部的 class 属性值为 "io.mycat.route.function.PartitionByLong"，表示这个函数使用了 io.mycat.route.function.PartitionByLong 类来进行计算。
function 元素内部有两个 property 子元素，分别为 partitionCount 和 partitionLength。
partitionCount 属性指定了分片的数量，这里设置为 8。
partitionLength 属性指定了分片的长度，这里设置为 128。
PartitionByLong 是 MyCAT (MySQL Cluster Auto-Management Tool) 中提供的一种数据分片策略，它将数据按照 long 类型进行分库分表。使用该策略时，可以通过设置 partitionCount 属性和 partitionLength 属性来控制分片的数量和长度，从而将数据分散存储在不同的数据库或表中，实现分布式存储。具体的分片规则百度就行，太多不做演示
4、使用 示例
启动mycat
[root@rabbitmq_1 mycat]# bin/mycat stop
Stopping Mycat-server...
Mycat-server was not running.
[root@rabbitmq_1 mycat]#
[root@rabbitmq_1 mycat]# bin/mycat start
Starting Mycat-server...
启动之后，mycat 默认会启动一个叫 8066 的端口，如果8066端口没起来，需要查看日志，分析问题
[root@rabbitmq_1 mycat]# netstat -ntl
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp6 0 0 :::8066 :::* LISTEN
今天就用test 数据库做示例 演示
(root@localhost) [(none)]> show databases;
+------------------------+
| Database |
+------------------------+
| test |
+------------------------+
连接mycat ，读取的是server.xml文件
如果报错就加上这个参数 --default_auth=mysql_native_password
[root@rabbitmq_1 mycat]# mysql -h192.168.134.132 -uroot -p123456 -P8066 --default_auth=mysql_native_password
(root@192.168.134.132) [(none)]> show databases;
+----------+
| DATABASE |
+----------+
| TESTDB |
+----------+
(root@192.168.134.132) [(none)]> use TESTDB
(root@192.168.134.132) [TESTDB]> show tables;
+------------------+
| Tables in TESTDB |
+------------------+
| customer |
| customer_addr |
+------------------+
示例：
1、垂直分库
分库分表和读写分离可以同时进行
server.xml
<user name="root">
<property name="password">123456</property>
<property name="schemas">USERDB1,USERDB2</property>
</user>
配置了USERDB1、USERDB2这两个逻辑库schema.xml
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="USERDB1" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1" />
<schema name="USERDB2" checkSQLschema="false" sqlMaxLimit="100"dataNode="dn2" />
<dataNode name="dn1" dataHost="node1" database="mytest1" />
<dataNode name="dn2" dataHost="node2" database="mytest2" />
<dataHost name="node1" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native">
<heartbeat>select user()</heartbeat>
<writeHost host="192.168.134.132" url="192.168.134.132:3306" user="root" password="123456" />
</dataHost>
<dataHost name="node2" maxCon="1000" minCon="10" balance="0"writeType="0" dbType="mysql" dbDriver="native">
<heartbeat>select user()</heartbeat>
<writeHost host="192.168.134.133" url="192.168.134.133:3306" user="root" password="123456" />
</dataHost>
</mycat:schema>两个逻辑库对应两个不同的数据节点，两个数据节点对应两个不同的物理机器
mytest1和mytest2分成了不同机器上的不同的库，各包含一部分表，它们原来是合在一块的，在一台机器上，现在做了垂直的拆分。
客户端就需要去连接不同的逻辑库了，根据业务操作不同的逻辑库
然后配置了两个写库，两台机器把库平分了，分担了原来单机的压力。分库伴随着分表，从业务上对表拆分
2、配置水平分表
server.xml
<user name="root" defaultAccount="true">
<property name="password">123456</property>
<property name="schemas">test</property>
<property name="defaultSchema">test</property>
</user>
<user name="user">
<property name="password">user</property>
<property name="schemas">test</property>
<property name="readOnly">true</property>
<property name="defaultSchema">test</property>
</user>schema.xml
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="test" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
<table name="user" dataNode="dn1" />
<table name="student" primaryKey="id" autoIncrement="true" dataNode="dn1,dn2" rule="mod-long"/>
</schema>
<dataNode name="dn1" dataHost="host1" database="test" />
<dataNode name="dn2" dataHost="host2" database="test" />
<dataHost name="host1" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<writeHost host="192.168.134.132" url="192.168.134.132:3306" user="root"
password="123456">
</writeHost>
</dataHost>
<dataHost name="host2" maxCon="1000" minCon="10" balance="0"
writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<writeHost host="192.168.134.133" url="192.168.134.133:3306" user="root"
password="123456">
</writeHost>
</dataHost>
</mycat:schema>此外还需要在rule.xml中配置以下拆分算法
找到算法mod-long，因为我们将逻辑表student分开映射到两台主机上，所以修改数据节点的数量为2
<tableRule name="mod-long">
<rule>
<columns>id</columns>
<algorithm>mod-long</algorithm>
</rule>
</tableRule>
<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
<property name="count">2</property>
</function>首先确保两个节点上都有test 数据库
在主库上创建 user 表和student表
(root@localhost) [test]> create table user(id int,name varchar(20));
Query OK, 0 rows affected (0.02 sec)
(root@localhost) [test]>
(root@localhost) [test]> create table student(id int primary key auto_increment,name varchar(20));
Query OK, 0 rows affected (0.01 sec)
登录到mycat的8066端口
[root@rabbitmq_1 mycat]# bin/mycat start
Starting Mycat-server...
[root@rabbitmq_1 mycat]# mysql -h192.168.134.132 -uroot -p123456 -P8066 --default_auth=mysql_native_password
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 1
Server version: 5.6.29-mycat-1.6.7.5-release-20200410174409 MyCat Server (OpenCloudDB)
Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
(root@192.168.134.132) [(none)]>
(root@192.168.134.132) [(none)]> show databases;
+----------+
| DATABASE |
+----------+
| test |
+----------+
1 row in set (0.00 sec)
(root@192.168.134.132) [(none)]> use test;
(root@192.168.134.132) [test]> show tables;
+----------------+
| Tables_in_test |
+----------------+
| student |
| user |
+----------------+
11 rows in set (0.00 sec)
(root@192.168.134.132) [test]> select * from user;
Empty set (0.24 sec)
通过mycat给user 表添加两条数据
(root@192.168.134.132) [test]> insert into user values(1,'aaa');
Query OK, 1 row affected (0.00 sec)
(root@192.168.134.132) [test]>
(root@192.168.134.132) [test]> insert into user values(2,'bbb');
Query OK, 1 row affected (0.00 sec)
由于schema.xml配置文件中，逻辑表user只在Linux主机的mytest1库中存在，mycat操作的逻辑表user会影响Linux主机上的物理表，
而不会影响另一台主机上的表。我们分别查看一下master和slave主机的user表：因为我搭建的主从，所以都会同步
2、我们再通过MyCat给student表插入两条数据
(root@192.168.134.132) [test]> insert into student(id,name) values(1,'aaa');
Query OK, 1 row affected (0.00 sec)
(root@192.168.134.132) [test]>
(root@192.168.134.132) [test]> insert into student(id,name) values(2,'aaa');
Query OK, 1 row affected (10.01 sec)
我们知道schema.xml配置文件中，逻辑表student对应两台主机上的1个 库 test 中的两张表，所以对逻辑表插入的两条数据，会实际影响到两张物理表（用
id%机器数，决定插入到哪张物理表）。我们分别查看一下 master 和 slave 机的student表：
(root@localhost) [test]> select * from student; //主
+----+------+
| id | name |
+----+------+
| 2 | aaa |
+----+------+
(root@localhost) [test]> select * from student; //从机
+----+------+
| id | name |
+----+------+
| 1 | aaa |
再通过MyCat插入id=3和id=4的数据，应该插入不同主机上的不同物理表
(root@192.168.134.132) [test]> insert into student(id,name) values(3,'bbb');
Query OK, 1 row affected (0.00 sec)
(root@192.168.134.132) [test]> insert into student(id,name) values(4,'ccc');
Query OK, 1 row affected (0.01 sec)
在查看
(root@localhost) [test]> select * from student; //主
+----+------+
| id | name |
+----+------+
| 2 | aaa |
| 4 | ccc |
+----+------+
(root@localhost) [test]> select * from student; //从
+----+------+
| id | name |
+----+------+
| 1 | aaa |
| 3 | bbb |
这就相当于把student表进行水平拆分了
通过MyCat查询的时候只需要正常输入就行，我们配置的是表拆分后放在这2个数据节点上，MyCat会根据配置在两个库上查询并进行数据合并
(root@192.168.134.132) [test]> select *from student;
+----+------+
| id | name |
+----+------+
| 2 | aaa |
| 4 | ccc |
| 1 | aaa |
| 3 | bbb |
+----+------+由于刚才在测试时候 把从库给关了。
测试完之后。把相应记录删除，在把从库起来，状态会报错。因为在主库删除表操作时，会记录到日志中，从库起来会报错。
此时需要跳过当前事务，主从状态就正常了
(root@localhost) [test]> STOP SLAVE;
Query OK, 0 rows affected (0.00 sec)
(root@localhost) [test]> SET GLOBAL sql_slave_skip_counter = 2;
Query OK, 0 rows affected (0.00 sec)
(root@localhost) [test]> START SLAVE;
Query OK, 0 rows affected (0.00 sec)
--或者
(root@localhost) [test]> STOP SLAVE SQL_THREAD;
//这个过滤是基于FTID 的 如果没开GTID 就是用下一个 REPLICATE_DO_DB（是同步哪些库）REPLICATE_IGNORE_DB（是不同步哪些库）
(root@localhost) [test]> CHANGE REPLICATION FILTER REPLICATE_WILD_IGNORE_TABLE = ('cjc.t2');
(root@localhost) [test]> CHANGE REPLICATION FILTER REPLICATE_DO_DB = (db1, db2),REPLICATE_IGNORE_DB = (db3);
(root@localhost) [test]> start SLAVE SQL_THREAD;
1081
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
