MyCat学习笔记

Mycat数据库中间件

1、数据库中间件：

是一类连接软件组件和应用的计算机软件，以便于软件各部件之间的沟通。例子：Tomcat，web中间件。数据库中间件：连接java应用程序和数据库

2、为什么要用Mycat？

Java与数据库紧耦合
高访问量高并发对数据库的压力
读写请求数据不一致

mysql单表瓶颈1000w数据,单库瓶颈5000w数据

数据库中间件对比:

Mycat的官网: http://www.mycat.io/

Mycat能干什么:

读写分离
数据分片 垂直拆分（分库）、水平拆分（分表）、垂直+水平拆分（分库分表)
多数据源整合

原理:

Mycat 的原理中最重要的一个动词是“拦截”，它拦截了用户发送过来的 SQL 语句，首先对 SQL 语句做了一些特定的分析：如分片分析、路由分析、读写分离分析、缓存分析等，然后将此 SQL 发往后端的真实数据库，并将返回的结果做适当的处理，最终再返回给用户

安装启动

1、解压后即可使用 解压缩文件拷贝到 linux 下 /usr/local/ 2、三个配置文件

schema.xml：定义逻辑库，表、分片节点等内容
rule.xml：定义分片规则
server.xml：定义用户以及系统相关变量，如端口等

3、修改配置文件server.xml 修改用户信息，与MySQL区分

<user name="root">
<property name="password">123456</property> 
<property name="schemas">TESTDB</property> 
</user>

schemas:数据库名，这里会和schema.xml中的配置关联，多个用逗号分开，例如需要这个用户需要管理两个数据库db1,db2，则配置db1,db2

4.修改配置文件 schema.xml

删除<schema>标签间的表信息配置dataNode="dn1"， <dataNode>标签只留一个， <dataHost>标签只留一个， <writeHost>,<readHost>只留一对

<mycat:schema xmlns:mycat="http://io.mycat/">


<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">

</schema>


<dataNode name="dn1" dataHost="host1" database="testdb" />


<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="hostM1" url="192.168.107.132:3306" user="root"
password="000000">

<readHost host="hostS2" url="192.168.107.108:3306" user="hzy" password="000000"/>
</writeHost>

</dataHost>

</mycat:schema>

5.验证数据库访问情况

Mycat 作为数据库中间件要和数据库部署在不同机器上，所以要验证远程访问情况。

mysql -uhzy -p000000 -h 192.168.107.108 -P 3306
mysql -uroot -p000000 -h 192.168.107.132 -P 3306

如远程访问报错，请建对应用户

grant all privileges on . to root@'缺少的host' identified by '000000';

6.启动mycat

控制台启动：去 mycat/bin 目录下执行 ./mycat console
后台启动：去 mycat/bin 目录下 ./mycat start

为了能第一时间看到启动日志，方便定位问题，我们选择控制台启动。

7.登录mycat

登录后台管理窗口

此登录方式用于管理维护 Mycat

mysql -umycat -p123456 -P 9066 -h 192.168.140.128

常用命令如下：

show database;
show @@help;

登录数据窗口

此登录方式用于通过 Mycat 查询数据，我们选择这种方式访问Mycat

mysql -uroot -p123456 -P 8066 -h 192.168.107.132

读写分离

我们通过 Mycat 和 MySQL 的主从复制配合搭建数据库的读写分离，实现 MySQL 的高可用性。我们将搭建：一主一从、双主双从两种读写分离模式。

mysql主从复制原理:

与redis不同的是,redis从机会把主机的数据从头到尾复制,而mysql从机只会从接入点开始复制; 并且会发生多次IO有延时问题

主机配置

修改配置文件：
vim /etc/my.cnf

主服务器唯一ID

server-id=1

启用二进制日志

log-bin=mysql-bin

设置不要复制的数据库(可设置多个)

binlog-ignore-db=mysql
binlog-ignore-db=information_schema

设置需要复制的数据库

binlog-do-db=需要复制的主数据库名字

设置logbin格式

binlog_format=STATEMENT

binlog的三种模式:https://blog.csdn.net/vhomes/article/details/8082734

从机配置

vim /etc/my.cnf

从服务器唯一ID

server-id=2

启用中继日志

relay-log=mysql-relay

重启服务:systemctl restart mysqld
确认防火墙已关闭:systemctl status firewalld
在主机MySQL里执行授权命令: GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' IDENTIFIED BY '123123';

如果报错:Your password does not satisfy the current policy requirements,请执行:

set global validate_password_policy=0;
set global validate_password_length=4;

查看主机状态:

show master status;
File	Position	Binlog_Do_DB	Binlog_Ignore_DB	Executed_Gtid_Set
mysql-bin.000001	438	testdb	mysql,information_schema

1 row in set (0.01 sec)

记录下File和Position的值, 执行完此步骤后不要再操作主服务器MySQL，防止主服务器状态值变化

在从机上配置需要复制的主机

复制主机的命令

CHANGE MASTER TO MASTER_HOST='主机的IP地址',
MASTER_USER='slave',
MASTER_PASSWORD='123123',
MASTER_LOG_FILE='mysql-bin.具体数字',
MASTER_LOG_POS=具体值;

启动从服务器复制功能

start slave;

查看从服务器状态

show slave statusG

例子:

CHANGE MASTER TO MASTER_HOST='192.168.107.132',
MASTER_USER='slave',
MASTER_PASSWORD='123123',
MASTER_LOG_FILE='mysql-bin.000003',
MASTER_LOG_POS=154;

如果之前配置过主从复制,需要先重置stop slave;, reset master;

接着启动从服务器复制功能 start slave;

查看从服务器状态 show slave statusG(不要加分号)

这两项尾Yes即为成功

Slave_IO_Running: Yes
Slave_SQL_Running: Yes

如果失败可查看Error项

Last_Errno: 0
Last_Error:
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:

主机新建库(my.cnf中规定的库)、新建表、insert 记录，从机复制

一主一从

    <writeHost host="hostM1" url="192.168.107.132:3306" user="root"
               password="000000">

    <readHost host="hostS2" url="192.168.107.108:3306" user="hzy" password="000000"/>

启动mycat

在写主机数据库表mytbl中插入带系统变量数据，造成主从数据不一致 INSERT INTO mytbl VALUES(2,@@hostname);

使用mycat查询,可以看到mycat操作的是主机数据

原因是我们没有指定数据库访问的负载策略balance

balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。
balance="1"，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。
balance="2"，所有读操作都随机的在 writeHost、readhost 上分发。
balance="3"，所有读请求随机的分发到 readhost 执行，writerHost 不负担读压力

双主双从选1,单主单从或多从选3

修改schema.xml

<dataHost name="host1" maxCon="1000" minCon="10" balance="3"
          writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">

双主双从

一个主机 m1 用于处理所有写请求，它的从机 s1 和另一台主机 m2 还有它的从机 s2 负责所有读请求。当 m1 主机宕机后，m2 主机负责写请求，m1、m2 互为备机。

Master1配置

修改配置文件：vim /etc/my.cnf

主服务器唯一ID

server-id=1

启用二进制日志

log-bin=mysql-bin

设置不要复制的数据库(可设置多个)

binlog-ignore-db=mysql
binlog-ignore-db=information_schema

设置需要复制的数据库

binlog-do-db=需要复制的主数据库名字

设置logbin格式

binlog_format=STATEMENT

在作为从数据库的时候，有写入操作也要更新二进制日志文件

log-slave-updates

表示自增长字段每次递增的量，指字段一次递增多少，其默认值是1，取值范围是1 .. 65535

auto-increment-increment=2

表示自增长字段从哪个数开始，指自增字段的起始值，他的取值范围是1 .. 65535

auto-increment-offset=1

Master2配置

修改配置文件：vim /etc/my.cnf

主服务器唯一ID

server-id=3

启用二进制日志

log-bin=mysql-bin

设置不要复制的数据库(可设置多个)

binlog-ignore-db=mysql
binlog-ignore-db=information_schema

设置需要复制的数据库

binlog-do-db=需要复制的主数据库名字

设置logbin格式

binlog_format=STATEMENT

在作为从数据库的时候，有写入操作也要更新二进制日志文件

log-slave-updates

表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535

auto-increment-increment=2

表示自增长字段从哪个数开始，指自增字段的起始值，他的取值范围是1 .. 6553

65535 auto-increment-offset=2

注意:auto-increment-offset不可以是重复的

Slave1配置

从服务器唯一ID

server-id=2

启用中继日志

relay-log=mysql-relay

Slave2配置

从服务器唯一ID

server-id=4

启用中继日志

relay-log=mysql-relay

双主机、双从机重启 mysql 服务
主机从机都关闭防火墙
在两台主机上建立帐户并授权 slave

在主机MySQL里执行授权命令

GRANT REPLICATION SLAVE ON . TO 'slave'@'%' IDENTIFIED BY '123123';

查看两台主机的状态show master status;,记录binlogid和接入点
设置两台从机的主机,Slava1 复制 Master1，Slava2 复制 Master2
两台主机互备,Master2 复制 Master1，Master1 复制 Master2

stop slave;
reset master;

复制主机的命令

CHANGE MASTER TO MASTER_HOST='主机的IP地址',
MASTER_USER='slave',
MASTER_PASSWORD='123123',
MASTER_LOG_FILE='mysql-bin.具体数字',
MASTER_LOG_POS=具体值;

启动从服务器复制功能

start slave;

查看从服务器状态

show slave statusG

修改schema.xml

<heartbeat>select user()</heartbeat>                
<!-- can have multi write hosts -->                 
<writeHost host="hostM1" url="192.168.140.128:3306" user="root"                                    password="123123">                         
    <!-- can have multi read hosts -->                         
    <readHost host="hostS1" url="192.168.140.127:3306" user="root" password="123123"/>                 
</writeHost>    

<writeHost host="hostM2" url="192.168.140.126:3306" user="root"                                    password="123123">                         
    <!-- can have multi read hosts -->                         
    <readHost host="hostS2" url="192.168.140.125:3306" user="root" password="123123"/>                 
</writeHost>

</dataHost>

balance="1": 全部的readHost与stand by writeHost参与select语句的负载均衡。

writeType="0": 所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个

writeHost，重新启动后以切换后的为准，切换记录在配置文件中:dnindex.properties 。

switchType="1": 1 默认值，自动切换。

-1 表示不自动切换

2 基于 MySQL 主从同步的状态决定是否切换。

验证主从复制:Master1 主机新建库、新建表、insert 记录，Master2 和从机复制
验证读写分离:

在写主机Master1数据库表mytbl中插入带系统变量数据，造成主从数据不一致

INSERT INTO mytbl VALUES(3,@@hostname);,

在Mycat里查询mytbl表,可以看到查询语句在Master2（host81）、Slava1（host80）、Slava2（host82）主从三个主机间切换;

停止数据库Master1 在Mycat里插入数据依然成功，Master2自动切换为写主机

垂直拆分——分库

按照业务将表进行分类（或者 Schema）来切分到不同的数据库（主机）之上，这种切可以称之为数据的垂直（纵向）切分

分库的原则：有紧密关联关系的表应该在一个库里，相互没有关联关系的表可以分到不同的库里,因为分库的表不可以关联查询

客户表 rows:20万

CREATE TABLE customer(

id INT AUTO_INCREMENT, 
NAME VARCHAR(200), 
PRIMARY KEY(id)

);

订单表 rows:600万

CREATE TABLE orders(

id INT AUTO_INCREMENT, 
order_type INT, 
customer_id INT, 
amount DECIMAL(10,2),     
PRIMARY KEY(id)

);

订单详细表 rows:600万

CREATE TABLE orders_detail(

id INT AUTO_INCREMENT,     
detail VARCHAR(2000),     
order_id INT,     
PRIMARY KEY(id)

);

订单状态字典表 rows:20

CREATE TABLE dict_order_type(

id INT AUTO_INCREMENT,     
order_type VARCHAR(200),     
PRIMARY KEY(id)

);

客户表分在一个数据库，另外三张都需要关联查询，分在另外一个数据库。

1.修改 schema 配置文件

<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
    <!-- 配置customer表分配到dn2 -->
    <table name="customer" dataNode="dn2" ></table> 
</schema>

<!-- 数据节点 -->
<dataNode name="dn1" dataHost="host1" database="orders" />
<dataNode name="dn2" dataHost="host2" database="orders" />

<!-- host1 -->
<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="hostM1" url="192.168.107.132:3306" user="root"
               password="000000">
    </writeHost>
    
</dataHost>

<!-- host2 -->
<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="hostM1" url="192.168.107.108:3306" user="hzy"
               password="000000">
    </writeHost>
    
</dataHost>

通过mycat操作逻辑库默认执行到dataNode="dn1",我们指定了customer分配到dataNode="dn2"

balance="0"不设置读写分离

2.两台机器分别创建新的的数据库

CREATE DATABASE orders;

3.启动 Mycat

./mycat console

4.访问 Mycat 进行分库

mysql -umycat -p123456 -h 192.168.140.128 -P 8066

切换到 TESTDB

创建 4 张表

查看表信息，可以看到成功分库

水平拆分——分表

根据表中的数据的逻辑关系按照某个字段的某种规则，将同一个表中的数据按照某种条件拆分到多台数据库（主机）上面，这种切分称之为数据的水平（横向）切分

MySQL 单表存储数据条数是有瓶颈的，单表达到 1000 万条数据就达到了瓶颈，会影响查询效率，需要进行水平拆分（分表）进行优化。例如：例子中的 orders、orders_detail 都已经达到 600 万行数据，需要进行分表优化。

1.分表字段 ,以 orders 表为例，可以根据不同自字段进行分表

id主键或创建时间:查询订单注重时效，历史订单被查询的次数少，如此分片会造成一个节点访问多，一个访问少，不平均。
customer_id（客户 id）: 根据客户 id 去分，两个节点访问平均，一个客户的所有订单都在同一个节点

2.修改schema 配置文件

<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">
    <!-- 配置customer表分配到dn2 -->
    <table name="customer" dataNode="dn2" ></table>
    <table name="orders" dataNode="dn1,dn2"  rule="mod_rule" ></table> 
</schema>

orders表被划分到两个数据节点dn1,dn2,mod_rule分片规则名称

3.修改rule 配置文件

定义mod_rule分片规则,并指定规则适用字段为 customer_id，选择分片算法 mod-long（对字段求模运算），customer_id 对两个节点求模，根据结果分片

<tableRule name="mod_rule">
        <rule>
            <columns>customer_id</columns>
            <algorithm>mod-long</algorithm>
        </rule>
</tableRule>
<!--配置算法 mod-long 参数 count 为 2，两个节点-->
<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
        <!-- 多少个数据节点 -->
        <property name="count">2</property>
</function>

4.测试分表

在数据节点 dn2 上建 orders 表
重启 Mycat，让配置生效
访问 Mycat 实现分片
在 mycat 里向 orders 表插入数据，INSERT 字段不能省略 INSERT INTO
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(1,101,100,100100);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(2,101,100,100300);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(3,101,101,120000);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(4,101,101,103000);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(5,102,101,100400);
INSERT INTO orders(id,order_type,customer_id,amount) VALUES(6,102,100,100020);
在mycat、dn1、dn2中查看orders表数据，分表成功

Mycat 的分片 “join”

Orders 订单表已经进行分表操作了，和它关联的 orders_detail 订单详情表如何进行 join 查询。

orders_detail 也要进行分片操作。Join 的原理如下图：

ER 表

Mycat 借鉴了 NewSQL 领域的新秀 Foundation DB 的设计思路，Foundation DB 创新性的提出了 Table Group 的概念，其将子表的存储位置依赖于主表，并且物理上紧邻存放，因此彻底解决了 JION 的效率和性能问题，根据这一思路，提出了基于 E-R 关系的数据分片策略，子表的记录与所关联的父表记录存放在同一个数据分片上

修改 schema.xml 配置文件

配置orders的子表orders_detail,使用外键order_id进行分片,这样与orders表的数据分布紧密

在 dn2 创建 orders_detail 表 重启 Mycat 访问 Mycat 向 orders_detail 表插入数据

INSERT INTO orders_detail(id,detail,order_id) values(1,'detail1',1);
INSERT INTO orders_detail(id,detail,order_id) VALUES(2,'detail1',2);
INSERT INTO orders_detail(id,detail,order_id) VALUES(3,'detail1',3);
INSERT INTO orders_detail(id,detail,order_id) VALUES(4,'detail1',4);
INSERT INTO orders_detail(id,detail,order_id) VALUES(5,'detail1',5);
INSERT INTO orders_detail(id,detail,order_id) VALUES(6,'detail1',6);

在mycat、dn1、dn2中运行两个表join语句

Select o.*,od.detail from orders o
inner join orders_detail od on o.id=od.order_id;

全局表

在分片的情况下，当业务表因为规模而进行分片以后，业务表与这些附属的字典表之间的关联，就成了比较棘手的问题，考虑到字典表具有以下几个特性： ① 变动不频繁 ② 数据量总体变化不大 ③ 数据规模不大，很少有超过数十万条记录

鉴于此，Mycat 定义了一种特殊的表，称之为“全局表”，全局表具有以下特性：

全局表的插入、更新操作会实时在所有节点上执行，保持各个分片的数据一致性
全局表的查询操作，只从一个节点获取
全局表可以跟任何一个表进行 JOIN 操作

将字典表或者符合字典表特性的一些表定义为全局表，则从另外一个方面，很好的解决了数据 JOIN 的难题。通过全局表+基于 E-R 关系的分片策略，Mycat 可以满足 80%以上的企业应用开发

修改 schema.xml 配置文件

在 dn2 创建 dict_order_type 表 重启 Mycat 访问 Mycat 向 dict_order_type 表插入数据 INSERT INTO dict_order_type(id,order_type) VALUES(101,'type1'); INSERT INTO dict_order_type(id,order_type) VALUES(102,'type2'); 在Mycat、dn1、dn2中查询表数据

常用分片规则 ------ ### 取模此规则为对分片字段求摸运算。也是水平分表最常用规则。 ### 分片枚举 通过在配置文件中配置可能的枚举 id，自己配置分片，本规则适用于特定的场景，比如有些业务需要按照省份或区县来做保存，而全国省份区县固定的，这类业务使用本条规则。 * 修改schema.xml配置文件

* 修改rule.xml配置文件 <tableRule name="sharding_by_intfile"> <rule> <columns>areacode</columns> <algorithm>hash-int</algorithm> </rule> </tableRule> … <function name="hash-int" class="io.mycat.route.function.PartitionByFileMap"> <property name="mapFile">partition-hash-int.txt</property> <property name="type">1</property> <property name="defaultNode">0</property> </function> columns：分片字段，algorithm：分片函数 mapFile：标识配置文件名称，type：分片字段类型0为int型、非0为String defaultNode：默认节点:小于 0 表示不设置默认节点，大于等于 0 表示设置默认节点，设置默认节点如果碰到不识别的枚举值，就让它路由到默认节点，如不设置不识别就报错 * 修改partition-hash-int.txt配置文件 110=0 120=1 #110走dn1, 120走dn2 * 重启 Mycat * 访问Mycat创建表 #订单归属区域信息表 CREATE TABLE orders_ware_info ( id INT AUTO_INCREMENT comment '编号', order_id INT comment '订单编号', address VARCHAR(200) comment '地址', areacode VARCHAR(20) comment '区域编号', PRIMARY KEY(id) ); 插入数据 INSERT INTO orders_ware_info(id, order_id,address,areacode) VALUES (1,1,'北京','110'); INSERT INTO orders_ware_info(id, order_id,address,areacode) VALUES (2,2,'天津','120');

### 范围约定此分片适用于，提前规划好分片字段某个范围属于哪个分片。 * 修改schema.xml配置文件

* 修改rule.xml配置文件 <tableRule name="auto_sharding_long"> <rule> <columns>order_id</columns> <algorithm>rang-long</algorithm> </rule> </tableRule> … <function name="rang-long" class="io.mycat.route.function.AutoPartitionByLong"> <property name="mapFile">autopartition-long.txt</property> <property name="defaultNode">0</property> </function> columns：分片字段，algorithm：分片函数 mapFile：标识配置文件名称 defaultNode：默认节点:小于 0 表示不设置默认节点，大于等于 0 表示设置默认节点，设置默认节点如果碰到不识别的枚举值，就让它路由到默认节点，如不设置不识别就报错 * 修改autopartition-long.txt配置文件 0-102=0 103-200=1 * 重启 Mycat * 访问Mycat创建表 #支付信息表 CREATE TABLE payment_info ( id INT AUTO_INCREMENT comment '编号', order_id INT comment '订单编号', payment_status INT comment '支付状态', PRIMARY KEY(id) ); * 插入数据 INSERT INTO payment_info (id,order_id,payment_status) VALUES (1,101,0); INSERT INTO payment_info (id,order_id,payment_status) VALUES (2,102,1); INSERT INTO payment_info (id,order_id ,payment_status) VALUES (3,103,0); INSERT INTO payment_info (id,order_id,payment_status) VALUES (4,104,1); * 查询Mycat、dn1、dn2可以看到数据分片效果

### 日期(天)分片 * 修改schema.xml配置文件

* 修改rule.xml配置文件 <tableRule name="sharding_by_date"> <rule> <columns>login_date</columns> <algorithm>shardingByDate</algorithm> </rule> </tableRule> ... <function name="shardingByDate" class="io.mycat.route.function.PartitionByDate"> <property name="dateFormat">yyyy-MM-dd</property> <property name="sBeginDate">2019-01-01</property> <property name="sEndDate">2019-01-04</property> <property name="sPartionDay">2</property> </function> columns：分片字段，algorithm：分片函数 dateFormat ：日期格式 sBeginDate ：开始日期 sEndDate：结束日期,则代表数据达到了这个日期的分片后循环从开始分片插入 sPartionDay ：分区天数，即默认从开始日期算起，分隔 2 天一个分区 * 重启 Mycat * 访问Mycat创建表 * 用户信息表 CREATE TABLE login_info ( id INT AUTO_INCREMENT comment '编号', user_id INT comment '用户编号', login_date date comment '登录日期', PRIMARY KEY(id) ); INSERT INTO login_info(id,user_id,login_date) VALUES (1,101,'2019-01-01'); INSERT INTO login_info(id,user_id,login_date) VALUES (2,102,'2019-01-02'); INSERT INTO login_info(id,user_id,login_date) VALUES (3,103,'2019-01-03'); INSERT INTO login_info(id,user_id,login_date) VALUES (4,104,'2019-01-04'); INSERT INTO login_info(id,user_id,login_date) VALUES (5,103,'2019-01-05'); INSERT INTO login_info(id,user_id,login_date) VALUES (6,104,'2019-01-06'); * 查询Mycat、dn1、dn2可以看到数据分片效果

全局序列 ---- 在实现分库分表的情况下，数据库自增主键已无法保证自增主键的全局唯一。为此，Mycat 提供了全局 sequence，并且提供了包含本地配置和数据库配置等多种实现方式 1、本地文件 此方式 Mycat 将 sequence 配置到文件中，当使用到 sequence 中的配置后，Mycat 会更新 classpath 中的 sequence_conf.properties 文件中 sequence 当前的值。 * 优点：本地加载，读取速度较快 * 缺点：抗风险能力差，Mycat 所在主机宕机后，无法读取本地文件。 2、数据库方式 利用数据库一个表来进行计数累加。但是并不是每次生成序列都读写数据库，这样效率太低。 Mycat 会预加载一部分号段到 Mycat 的内存中，这样大部分读写序列都是在内存中完成的。如果内存中的号段用完了 Mycat 会再向数据库要一次。问：那如果 Mycat 崩溃了，那内存中的序列岂不是都没了？是的。如果是这样，那么 Mycat 启动后会向数据库申请新的号段，原有号段会弃用。也就是说如果 Mycat 重启，那么损失是当前的号段没用完的号码，但是不会因此出现主键重复 * 全局序列表 #在 dn1 上创建全局序列表 CREATE TABLE MYCAT_SEQUENCE ( NAME VARCHAR(50) NOT NULL, current_value INT NOT NULL, increment INT NOT NULL DEFAULT 100, PRIMARY KEY(NAME) ) ENGINE=INNODB; * 创建全局序列所需函数 DELIMITER $$ CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50)) RETURNS VARCHAR(64) DETERMINISTIC BEGIN DECLARE retval VARCHAR(64); SET retval="-999999999,null"; SELECT CONCAT(CAST(current_value AS CHAR),",",CAST(increment AS CHAR)) INTO retval FROM MYCAT_SEQUENCE WHERE NAME = seq_name; RETURN retval; END $$ DELIMITER ; DELIMITER $$ CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),VALUE INTEGER) RETURNS VARCHAR(64) DETERMINISTIC BEGIN UPDATE MYCAT_SEQUENCE SET current_value = VALUE WHERE NAME = seq_name; RETURN mycat_seq_currval(seq_name); END $$ D ELIMITER ; DELIMITER $$ CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS VARCHAR(64) DETERMINISTIC BEGIN UPDATE MYCAT_SEQUENCE SET current_value = current_value + increment WHERE NAME = seq_name; RETURN mycat_seq_currval(seq_name); END $$ DELIMITER ; * 初始化序列表记录 INSERT INTO MYCAT_SEQUENCE(NAME,current_value,increment) VALUES ('ORDERS', 400000, 100); * 修改 Mycat 配置修改sequence_db_conf.properties #sequence stored in datanode GLOBAL=dn1 COMPANY=dn1 CUSTOMER=dn1 ORDERS=dn1 意思是 ORDERS这个序列在dn1这个节点上，具体dn1节点是哪台机子，请参考schema.xml * 修改server.xml <property name="sequnceHandlerType">1</property> 全局序列类型：0-本地文件，1-数据库方式，2-时间戳方式。此处应该修改成1。 title: MyCat学习笔记 # 标题 date: 2019/10/26 16:23:46 # 时间 categories: # 分类 - 数据库 tags: # 标签 - 数据库中间件 - 分库分表 Mycat数据库中间件 =========== 1、数据库中间件：是一类连接软件组件和应用的计算机软件，以便于软件各部件之间的沟通。例子：Tomcat，web中间件。数据库中间件：连接java应用程序和数据库  2、为什么要用Mycat？ * Java与数据库紧耦合 * 高访问量高并发对数据库的压力 * 读写请求数据不一致 mysql单表瓶颈1000w数据,单库瓶颈5000w数据 数据库中间件对比:

Mycat的官网: http://www.mycat.io/ Mycat能干什么: * 读写分离

* 数据分片 垂直拆分（分库）、水平拆分（分表）、垂直+水平拆分（分库分表)

* 多数据源整合

原理: Mycat 的原理中最重要的一个动词是“拦截”，它拦截了用户发送过来的 SQL 语句，首先对 SQL 语句做了一些特定的分析：如分片分析、路由分析、读写分离分析、缓存分析等，然后将此 SQL 发往后端的真实数据库，并将返回的结果做适当的处理，最终再返回给用户安装启动 ---- 1、解压后即可使用 解压缩文件拷贝到 linux 下 /usr/local/ 2、三个配置文件 * schema.xml：定义逻辑库，表、分片节点等内容 * rule.xml：定义分片规则 * server.xml：定义用户以及系统相关变量，如端口等 3、修改配置文件server.xml 修改用户信息，与MySQL区分  <user name="root"> <property name="password">123456</property>  <property name="schemas">TESTDB</property>  </user> schemas:数据库名，这里会和schema.xml中的配置关联，多个用逗号分开，例如需要这个用户需要管理两个数据库db1,db2，则配置db1,db2 4.修改配置文件 schema.xml 删除<schema>标签间的表信息配置dataNode="dn1"， <dataNode>标签只留一个， <dataHost>标签只留一个， <writeHost>,<readHost>只留一对 <mycat:schema xmlns:mycat="http://io.mycat/">  <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">  </schema>  <dataNode name="dn1" dataHost="host1" database="testdb" />  <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="hostM1" url="192.168.107.132:3306" user="root" password="000000">  <readHost host="hostS2" url="192.168.107.108:3306" user="hzy" password="000000"/> </writeHost> </dataHost> </mycat:schema> 5.验证数据库访问情况 Mycat 作为数据库中间件要和数据库部署在不同机器上，所以要验证远程访问情况。 mysql -uhzy -p000000 -h 192.168.107.108 -P 3306 mysql -uroot -p000000 -h 192.168.107.132 -P 3306 #如远程访问报错，请建对应用户 grant all privileges on . to root@'缺少的host' identified by '000000'; 6.启动mycat * 控制台启动：去 mycat/bin 目录下执行 ./mycat console * 后台启动：去 mycat/bin 目录下 ./mycat start 为了能第一时间看到启动日志，方便定位问题，我们选择控制台启动。 7.登录mycat * 登录后台管理窗口此登录方式用于管理维护 Mycat mysql -umycat -p123456 -P 9066 -h 192.168.140.128 #常用命令如下： show database; show @@help; * 登录数据窗口此登录方式用于通过 Mycat 查询数据，我们选择这种方式访问Mycat mysql -uroot -p123456 -P 8066 -h 192.168.107.132 读写分离 ---- 我们通过 Mycat 和 MySQL 的主从复制配合搭建数据库的读写分离，实现 MySQL 的高可用性。我们将搭建：一主一从、双主双从两种读写分离模式。

mysql主从复制原理:

与redis不同的是,redis从机会把主机的数据从头到尾复制,而mysql从机只会从接入点开始复制; 并且会发生多次IO有延时问题 ### 主机配置修改配置文件： vim /etc/my.cnf #主服务器唯一ID server-id=1 #启用二进制日志 log-bin=mysql-bin # 设置不要复制的数据库(可设置多个) binlog-ignore-db=mysql binlog-ignore-db=information_schema #设置需要复制的数据库 binlog-do-db=需要复制的主数据库名字 #设置logbin格式 binlog_format=STATEMENT > binlog的三种模式:https://blog.csdn.net/vhomes/article/details/8082734 ### 从机配置 vim /etc/my.cnf #从服务器唯一ID server-id=2 #启用中继日志 relay-log=mysql-relay * 重启服务:systemctl restart mysqld * 确认防火墙已关闭:systemctl status firewalld * 在主机MySQL里执行授权命令: GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' IDENTIFIED BY '123123'; 如果报错:Your password does not satisfy the current policy requirements,请执行: set global validate_password_policy=0; set global validate_password_length=4; * 查看主机状态: show master status; +------------------+----------+--------------+--------------------------+-------------------+ | File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set | +------------------+----------+--------------+--------------------------+-------------------+ | mysql-bin.000001 | 438 | testdb | mysql,information_schema | | +------------------+----------+--------------+--------------------------+-------------------+ 1 row in set (0.01 sec) 记录下File和Position的值, 执行完此步骤后不要再操作主服务器MySQL，防止主服务器状态值变化 * 在从机上配置需要复制的主机 #复制主机的命令 CHANGE MASTER TO MASTER_HOST='主机的IP地址', MASTER_USER='slave', MASTER_PASSWORD='123123', MASTER_LOG_FILE='mysql-bin.具体数字', MASTER_LOG_POS=具体值; #启动从服务器复制功能 start slave; #查看从服务器状态 show slave statusG 例子: CHANGE MASTER TO MASTER_HOST='192.168.107.132', MASTER_USER='slave', MASTER_PASSWORD='123123', MASTER_LOG_FILE='mysql-bin.000003', MASTER_LOG_POS=154; 如果之前配置过主从复制,需要先重置stop slave;, reset master; 接着启动从服务器复制功能 start slave; 查看从服务器状态 show slave statusG(不要加分号) #这两项尾Yes即为成功 Slave_IO_Running: Yes Slave_SQL_Running: Yes #如果失败可查看Error项 Last_Errno: 0 Last_Error: Last_IO_Errno: 0 Last_IO_Error: Last_SQL_Errno: 0 Last_SQL_Error: 主机新建库(my.cnf中规定的库)、新建表、insert 记录，从机复制 ### 一主一从  <writeHost host="hostM1" url="192.168.107.132:3306" user="root" password="000000">  <readHost host="hostS2" url="192.168.107.108:3306" user="hzy" password="000000"/> 启动mycat 在写主机数据库表mytbl中插入带系统变量数据，造成主从数据不一致 INSERT INTO mytbl VALUES(2,@@hostname); 使用mycat查询,可以看到mycat操作的是主机数据 原因是我们没有指定数据库访问的负载策略balance * balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。 * balance="1"，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且 M1 与 M2 互为主备)，正常情况下，M2,S1,S2 都参与 select 语句的负载均衡。 * balance="2"，所有读操作都随机的在 writeHost、readhost 上分发。 * balance="3"，所有读请求随机的分发到 readhost 执行，writerHost 不负担读压力双主双从选1,单主单从或多从选3 修改schema.xml  <dataHost name="host1" maxCon="1000" minCon="10" balance="3" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100"> ### 双主双从一个主机 m1 用于处理所有写请求，它的从机 s1 和另一台主机 m2 还有它的从机 s2 负责所有读请求。当 m1 主机宕机后，m2 主机负责写请求，m1、m2 互为备机。

Master1配置 修改配置文件：vim /etc/my.cnf #主服务器唯一ID server-id=1 #启用二进制日志 log-bin=mysql-bin # 设置不要复制的数据库(可设置多个) binlog-ignore-db=mysql binlog-ignore-db=information_schema #设置需要复制的数据库 binlog-do-db=需要复制的主数据库名字 #设置logbin格式 binlog_format=STATEMENT # 在作为从数据库的时候，有写入操作也要更新二进制日志文件 log-slave-updates #表示自增长字段每次递增的量，指字段一次递增多少，其默认值是1，取值范围是1 .. 65535 auto-increment-increment=2 # 表示自增长字段从哪个数开始，指自增字段的起始值，他的取值范围是1 .. 65535 auto-increment-offset=1 Master2配置 修改配置文件：vim /etc/my.cnf #主服务器唯一ID server-id=3 #启用二进制日志 log-bin=mysql-bin #设置不要复制的数据库(可设置多个) binlog-ignore-db=mysql binlog-ignore-db=information_schema #设置需要复制的数据库 binlog-do-db=需要复制的主数据库名字 #设置logbin格式 binlog_format=STATEMENT # 在作为从数据库的时候，有写入操作也要更新二进制日志文件 log-slave-updates #表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535 auto-increment-increment=2 # 表示自增长字段从哪个数开始，指自增字段的起始值，他的取值范围是1 .. 6553 65535 auto-increment-offset=2 注意:auto-increment-offset不可以是重复的 Slave1配置 #从服务器唯一ID server-id=2 #启用中继日志 relay-log=mysql-relay Slave2配置 #从服务器唯一ID server-id=4 #启用中继日志 relay-log=mysql-relay * 双主机、双从机重启 mysql 服务 * 主机从机都关闭防火墙 * 在两台主机上建立帐户并授权 slave #在主机MySQL里执行授权命令 GRANT REPLICATION SLAVE ON . TO 'slave'@'%' IDENTIFIED BY '123123'; * 查看两台主机的状态show master status;,记录binlogid和接入点 * 设置两台从机的主机,Slava1 复制 Master1，Slava2 复制 Master2 * 两台主机互备,Master2 复制 Master1，Master1 复制 Master2 stop slave; reset master; #复制主机的命令 CHANGE MASTER TO MASTER_HOST='主机的IP地址', MASTER_USER='slave', MASTER_PASSWORD='123123', MASTER_LOG_FILE='mysql-bin.具体数字', MASTER_LOG_POS=具体值; #启动从服务器复制功能 start slave; #查看从服务器状态 show slave statusG * 修改schema.xml <dataNode name="dn1" dataHost="host1" database="testdb" /> <dataHost name="host1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100" > <heartbeat>select user()</heartbeat>  <writeHost host="hostM1" url="192.168.140.128:3306" user="root" password="123123">  <readHost host="hostS1" url="192.168.140.127:3306" user="root" password="123123"/> </writeHost> <writeHost host="hostM2" url="192.168.140.126:3306" user="root" password="123123">  <readHost host="hostS2" url="192.168.140.125:3306" user="root" password="123123"/> </writeHost> </dataHost> #balance="1": 全部的readHost与stand by writeHost参与select语句的负载均衡。 #writeType="0": 所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个 #writeHost，重新启动后以切换后的为准，切换记录在配置文件中:dnindex.properties 。 #switchType="1": 1 默认值，自动切换。 # -1 表示不自动切换 # 2 基于 MySQL 主从同步的状态决定是否切换。 * 验证主从复制:Master1 主机新建库、新建表、insert 记录，Master2 和从机复制 * 验证读写分离: 在写主机Master1数据库表mytbl中插入带系统变量数据，造成主从数据不一致 INSERT INTO mytbl VALUES(3,@@hostname);, 在Mycat里查询mytbl表,可以看到查询语句在Master2（host81）、Slava1（host80）、Slava2（host82）主从三个主机间切换; 停止数据库Master1 在Mycat里插入数据依然成功，Master2自动切换为写主机垂直拆分——分库 -------- 按照业务将表进行分类（或者 Schema）来切分到不同的数据库（主机）之上，这种切可以称之为数据的垂直（纵向）切分 分库的原则：有紧密关联关系的表应该在一个库里，相互没有关联关系的表可以分到不同的库里,因为分库的表不可以关联查询 #客户表 rows:20万 CREATE TABLE customer( id INT AUTO_INCREMENT, NAME VARCHAR(200), PRIMARY KEY(id) ); #订单表 rows:600万 CREATE TABLE orders( id INT AUTO_INCREMENT, order_type INT, customer_id INT, amount DECIMAL(10,2), PRIMARY KEY(id) ); #订单详细表 rows:600万 CREATE TABLE orders_detail( id INT AUTO_INCREMENT, detail VARCHAR(2000), order_id INT, PRIMARY KEY(id) ); #订单状态字典表 rows:20 CREATE TABLE dict_order_type( id INT AUTO_INCREMENT, order_type VARCHAR(200), PRIMARY KEY(id) ); 客户表分在一个数据库，另外三张都需要关联查询，分在另外一个数据库。 1.修改 schema 配置文件  <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">

</schema>  <dataNode name="dn1" dataHost="host1" database="orders" /> <dataNode name="dn2" dataHost="host2" database="orders" />  <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="hostM1" url="192.168.107.132:3306" user="root" password="000000"> </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="hostM1" url="192.168.107.108:3306" user="hzy" password="000000"> </writeHost> </dataHost> 通过mycat操作逻辑库默认执行到dataNode="dn1",我们指定了customer分配到dataNode="dn2" balance="0"不设置读写分离 2.两台机器分别创建新的的数据库 CREATE DATABASE orders; 3.启动 Mycat ./mycat console 4.访问 Mycat 进行分库 mysql -umycat -p123456 -h 192.168.140.128 -P 8066 #切换到 TESTDB #创建 4 张表 #查看表信息，可以看到成功分库

水平拆分——分表 -------- 根据表中的数据的逻辑关系按照某个字段的某种规则，将同一个表中的数据按照某种条件拆分到多台数据库（主机）上面，这种切分称之为数据的水平（横向）切分 MySQL 单表存储数据条数是有瓶颈的，单表达到 1000 万条数据就达到了瓶颈，会影响查询效率，需要进行水平拆分（分表）进行优化。例如：例子中的 orders、orders_detail 都已经达到 600 万行数据，需要进行分表优化。 1.分表字段 ,以 orders 表为例，可以根据不同自字段进行分表 * id主键或创建时间:查询订单注重时效，历史订单被查询的次数少，如此分片会造成一个节点访问多，一个访问少，不平均。 * customer_id（客户 id）: 根据客户 id 去分，两个节点访问平均，一个客户的所有订单都在同一个节点 2.修改schema 配置文件  <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1">

</schema> orders表被划分到两个数据节点dn1,dn2,mod_rule分片规则名称 3.修改rule 配置文件定义mod_rule分片规则,并指定规则适用字段为 customer_id，选择分片算法 mod-long（对字段求模运算），customer_id 对两个节点求模，根据结果分片 <tableRule name="mod_rule"> <rule> <columns>customer_id</columns> <algorithm>mod-long</algorithm> </rule> </tableRule>  <function name="mod-long" class="io.mycat.route.function.PartitionByMod">  <property name="count">2</property> </function> 4.测试分表 * 在数据节点 dn2 上建 orders 表 * 重启 Mycat，让配置生效 * 访问 Mycat 实现分片 * 在 mycat 里向 orders 表插入数据，INSERT 字段不能省略 INSERT INTO INSERT INTO orders(id,order_type,customer_id,amount) VALUES(1,101,100,100100); INSERT INTO orders(id,order_type,customer_id,amount) VALUES(2,101,100,100300); INSERT INTO orders(id,order_type,customer_id,amount) VALUES(3,101,101,120000); INSERT INTO orders(id,order_type,customer_id,amount) VALUES(4,101,101,103000); INSERT INTO orders(id,order_type,customer_id,amount) VALUES(5,102,101,100400); INSERT INTO orders(id,order_type,customer_id,amount) VALUES(6,102,100,100020); 在mycat、dn1、dn2中查看orders表数据，分表成功

Mycat 的分片 “join” ---------------- Orders 订单表已经进行分表操作了，和它关联的 orders_detail 订单详情表如何进行 join 查询。 orders_detail 也要进行分片操作。Join 的原理如下图：

### ER 表 Mycat 借鉴了 NewSQL 领域的新秀 Foundation DB 的设计思路，Foundation DB 创新性的提出了 Table Group 的概念，其将子表的存储位置依赖于主表，并且物理上紧邻存放，因此彻底解决了 JION 的效率和性能问题，根据这一思路，提出了基于 E-R 关系的数据分片策略，子表的记录与所关联的父表记录存放在同一个数据分片上 修改 schema.xml 配置文件 配置orders的子表orders_detail,使用外键order_id进行分片,这样与orders表的数据分布紧密 <childTable name="orders_detail" primaryKey="id" joinKey="order_id" parentKey="id" />

在 dn2 创建 orders_detail 表 重启 Mycat 访问 Mycat 向 orders_detail 表插入数据

在mycat、dn1、dn2中运行两个表join语句

Select o.*,od.detail from orders o
inner join orders_detail od on o.id=od.order_id;

全局表

鉴于此，Mycat 定义了一种特殊的表，称之为“全局表”，全局表具有以下特性：

全局表的插入、更新操作会实时在所有节点上执行，保持各个分片的数据一致性
全局表的查询操作，只从一个节点获取
全局表可以跟任何一个表进行 JOIN 操作

修改 schema.xml 配置文件

### 范围约定此分片适用于，提前规划好分片字段某个范围属于哪个分片。 * 修改schema.xml配置文件

### 日期(天)分片 * 修改schema.xml配置文件

全局序列 ---- 在实现分库分表的情况下，数据库自增主键已无法保证自增主键的全局唯一。为此，Mycat 提供了全局 sequence，并且提供了包含本地配置和数据库配置等多种实现方式 1、本地文件 此方式 Mycat 将 sequence 配置到文件中，当使用到 sequence 中的配置后，Mycat 会更新 classpath 中的 sequence_conf.properties 文件中 sequence 当前的值。 * 优点：本地加载，读取速度较快 * 缺点：抗风险能力差，Mycat 所在主机宕机后，无法读取本地文件。 2、数据库方式 利用数据库一个表来进行计数累加。但是并不是每次生成序列都读写数据库，这样效率太低。 Mycat 会预加载一部分号段到 Mycat 的内存中，这样大部分读写序列都是在内存中完成的。如果内存中的号段用完了 Mycat 会再向数据库要一次。问：那如果 Mycat 崩溃了，那内存中的序列岂不是都没了？是的。如果是这样，那么 Mycat 启动后会向数据库申请新的号段，原有号段会弃用。也就是说如果 Mycat 重启，那么损失是当前的号段没用完的号码，但是不会因此出现主键重复 * 全局序列表 #在 dn1 上创建全局序列表 CREATE TABLE MYCAT_SEQUENCE ( NAME VARCHAR(50) NOT NULL, current_value INT NOT NULL, increment INT NOT NULL DEFAULT 100, PRIMARY KEY(NAME) ) ENGINE=INNODB; * 创建全局序列所需函数 DELIMITER $$ CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50)) RETURNS VARCHAR(64) DETERMINISTIC BEGIN DECLARE retval VARCHAR(64); SET retval="-999999999,null"; SELECT CONCAT(CAST(current_value AS CHAR),",",CAST(increment AS CHAR)) INTO retval FROM MYCAT_SEQUENCE WHERE NAME = seq_name; RETURN retval; END $$ DELIMITER ; DELIMITER $$ CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),VALUE INTEGER) RETURNS VARCHAR(64) DETERMINISTIC BEGIN UPDATE MYCAT_SEQUENCE SET current_value = VALUE WHERE NAME = seq_name; RETURN mycat_seq_currval(seq_name); END $$ D ELIMITER ; DELIMITER $$ CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS VARCHAR(64) DETERMINISTIC BEGIN UPDATE MYCAT_SEQUENCE SET current_value = current_value + increment WHERE NAME = seq_name; RETURN mycat_seq_currval(seq_name); END $$ DELIMITER ; * 初始化序列表记录 INSERT INTO MYCAT_SEQUENCE(NAME,current_value,increment) VALUES ('ORDERS', 400000, 100); * 修改 Mycat 配置修改sequence_db_conf.properties #sequence stored in datanode GLOBAL=dn1 COMPANY=dn1 CUSTOMER=dn1 ORDERS=dn1 意思是 ORDERS这个序列在dn1这个节点上，具体dn1节点是哪台机子，请参考schema.xml * 修改server.xml <property name="sequnceHandlerType">1</property> 全局序列类型：0-本地文件，1-数据库方式，2-时间戳方式。此处应该修改成1。 * 重启Mycat * 验证全局序列登录 Mycat，插入数据,id使用MYCATSEQ_ORDERS全局序列表中的下一个值 insert into orders(id,amount,customer_id,order_type) values(next value for MYCATSEQ_ORDERS,1000,101,102);

* 重启Mycat后，再次插入数据，再查询

* 重启Mycat * 验证全局序列登录 Mycat，插入数据,id使用MYCATSEQ_ORDERS全局序列表中的下一个值 insert into orders(id,amount,customer_id,order_type) values(next value for MYCATSEQ_ORDERS,1000,101,102);

* 重启Mycat后，再次插入数据，再查询

MyCat学习笔记

Mycat数据库中间件

安装启动

如远程访问报错，请建对应用户

常用命令如下：

读写分离

主机配置

主服务器唯一ID

启用二进制日志

设置不要复制的数据库(可设置多个)

设置需要复制的数据库

设置logbin格式

从机配置

从服务器唯一ID

启用中继日志

复制主机的命令

启动从服务器复制功能

查看从服务器状态

这两项尾Yes即为成功

如果失败可查看Error项

一主一从

双主双从

主服务器唯一ID

启用二进制日志

设置不要复制的数据库(可设置多个)

设置需要复制的数据库

设置logbin格式

在作为从数据库的时候，有写入操作也要更新二进制日志文件

表示自增长字段每次递增的量，指字段一次递增多少，其默认值是1，取值范围是1 .. 65535

表示自增长字段从哪个数开始，指自增字段的起始值，他的取值范围是1 .. 65535

主服务器唯一ID

启用二进制日志

设置不要复制的数据库(可设置多个)

设置需要复制的数据库

设置logbin格式

在作为从数据库的时候，有写入操作也要更新二进制日志文件

表示自增长字段每次递增的量，指自增字段的起始值，其默认值是1，取值范围是1 .. 65535

表示自增长字段从哪个数开始，指自增字段的起始值，他的取值范围是1 .. 6553

从服务器唯一ID

启用中继日志

从服务器唯一ID

启用中继日志

在主机MySQL里执行授权命令

复制主机的命令

启动从服务器复制功能

查看从服务器状态

balance="1": 全部的readHost与stand by writeHost参与select语句的负载均衡。

writeType="0": 所有写操作发送到配置的第一个writeHost，第一个挂了切到还生存的第二个

writeHost，重新启动后以切换后的为准，切换记录在配置文件中:dnindex.properties 。

switchType="1": 1 默认值，自动切换。

-1 表示不自动切换

2 基于 MySQL 主从同步的状态决定是否切换。

垂直拆分——分库

客户表 rows:20万

订单表 rows:600万

订单详细表 rows:600万

订单状态字典表 rows:20

切换到 TESTDB

创建 4 张表

查看表信息，可以看到成功分库

水平拆分——分表

Mycat 的分片 “join”

ER 表

全局表

全局表

打了个冷颤

引用和评论

SparkSQL执行update操作修改mysql数据

在Java程序中监听mysql的binlog

Mysql数据库sql优化案例

数据集汇总｜18个电影/音乐数据集汇总，覆盖影片/歌曲推荐、电影评价、歌词识别、音乐流派······

使用 MongoDB 构建 AI：Gradient Accelerator Block 如何在几秒钟内让您从零开发 AI

MongoDB Atlas与YoMio.AI近乎完美适配:推理更快速、查询更灵活、场景更丰富

MongoDB 8.0已全面可用