<table&gt;</table&gt;

<table></table>

或

<table&gt;</table&gt;

<table></table>

catlet(人工智能)

解决跨分片的SQL JOIN的问题，远比想像的复杂，而且往往无法实现高效的处理，既然如此，就依靠人工智能去解决业务系统中特定的几个必须跨分片的SQL的JOIN逻辑。

select a.id,a.name,b.title from a,b where a.id=b.id

其中a在分片1，2，3上，b在4,5,6上，需要把数据全部拉到本地，执行join逻辑，具体过程如下：

EngineCtx ctx = new EngineCtx();//包含MyCat.SQLEngine
String sql=,"select a.id,a.name form a";
//在a表所在的所有分片上顺序执行下面的本地SQL
ctx.executeNativeSQLSequnceJob(allAnodes,new DirectDBJoinHandler());

DirectDBJoinHandler是一个回调类，负责处理SQL执行过程中返回的数据包，这里的这个类，主要目的是用a表返回的ID信息，去b表上查询对应的记录，做实时的关联

DirectDBJoinHandler{
    Private HashMap rows;//Key为id,value为一行记录的Column原始Byte数组，这里是a.id,b.title这三个要输出的字段
    Public Boolean onHeader(byte[] header){
        //保存Header信息，用于从Row中获取Field字段值
    }
    Public Boolean onRowData(byte[] rowData){
        String id = getColumnAsString("id");
        //放入结果集，b.title字段未知，所以先空着
        rows.put(getColumnRawBytes("id"),rowData);
        //满1000条，发送一个查询请求
        String sql = "select b.id,b.name from b where id in (...)";
        //此SQL在B的所有节点上并发执行，返回的结果直接输出到客户端
        ctx.executeNativeSQLParallJob(allBNodes,sql,new MyRowOutPutDataHandler(rows));
    }
    Public Boolean onRowFinished(){
    }
    Public void onJobFinished(){
        if(ctx.allJobFinished()){
            //used total time...
        }
    }
}

最后，增加一个JOB事件监听器，这里是所有JOB完成后，往客户端发送RowEnd包，结束整个流程。

ctx.setJobEventListener(new JobEventHandler(){
    public void onJobFinished(){
        client.writeRowEndPackage()
    }
});

以上提供一个SQL执行框架，完全是异步的模式执行，并且以后会提供更多高质量的API，简化分布式数据处理，比如内存结合文件的数据JOIN算法，分组算法和排序算法等。

Spack/Storm对join扩展

mycat后续的功能会引入spark和storm来做跨分片的join..

全局序列号

在实现分库分表的情况下,数据库自增主键已无法保证自增主键的全局唯一。为此,MyCat 提供了全局sequence,并且提供了 包含本地配置和数据库配置等多种实现方式。

本地文件方式

配置classpath中的sequence_conf.properties中sequence当前的值

配置方式

需server.xml配置sequnceHandlerType值为0，表示使用本地文件方式

配置sequence_conf.properties如下
GLOBAL_SEQ.HISIDS=
GLOBAL_SEQ.MINID=1001
GLOBAL_SEQ.MAXID=1000000000
GLOBAL_SEQ.CURID=1000

其中HISIDS表示使用过的历史分段(一般无特殊需要可不配置),MINID表示最小ID值，MAXID表示最大ID值，CURID表示当前ID值

使用示例

insert into table1(id,name) values(next value for MYCATSEQ_GLOBAL,'test');

优点：本地加载读取速度快，缺点：当MYCAT重新发布后，配置文件中的sequence会恢复初始值.

数据库方式

通过在数据库中建立一张表，存放sequence的名称(name)、当前值(current_value)、步长(increment int类型 每次读取多少个sequence)等信息。

Sequence获取步骤

1. 当初次使用该sequence时，根据传入的sequence名称，从数据库这张表中读取current_value和increment到mycat中，并将数据库中的current_value设置为原current_value值+increment值；

2. mycat将读取到current_value+increment作为本次要使用的sequence值，下次使用时，自动加1，当使用increment次后，执行步骤1相同的操作。

mycat负责维护这张表，用到哪些sequence,只需要在这张表中插入一条记录即可。

配置方式

需server.xml配置sequnceHandlerType值为1，表示使用本地文件方式

//1.创建数据表
– 创建存放sequence的表
DROP TABLE IF EXISTS MYCAT_SEQUENCE;
– name sequence名称
– current_value 当前value
– increment 增长步长! 可理解为mycat在数据库中一次读取多少个sequence. 当这些用完后,下次再从数据库中读取.
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;
– 插入一条sequence
INSERT INTO MYCAT_SEQUENCE(name,current_value,increment) VALUES (‘GLOBAL’,100000,100);
//2.创建相关function

– 获取当前sequence的值 (返回当前值,增量)

DROP FUNCTION IF EXISTS mycat_seq_currval;

DELIMITER

CREATE FUNCTION mycat_seq_currval(seq_name VARCHAR(50)) RETURNS varchar(64) CHARSET utf-8

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;

– 设置sequence值

DROP FUNCTION IF EXISTS mycat_seq_setval;

DELIMITER

CREATE FUNCTION mycat_seq_setval(seq_name VARCHAR(50),value INTEGER) RETURNS varchar(64) CHARSET utf-8 DETERMINISTIC

BEGIN

UPDATE MYCAT_SEQUENCE

SET current_value = value

WHERE name = seq_name;

RETURN mycat_seq_currval(seq_name);

END

DELIMITER;

– 获取下一个sequence值

DROP FUNCTION IF EXISTS mycat_seq_nextval;

DELIMITER

CREATE FUNCTION mycat_seq_nextval(seq_name VARCHAR(50)) RETURNS varchar(64) CHARSET utf-8 DETERMINISTIC

BEGIN

UPDATE MYCAT_SEQUENCE

SET current_value = current_value + increment WHERE name = seq_name;

RETURN mycat_seq_currval(seq_name);

END

DELIMITER;
//3.sequence_db_conf.properties相关配置，指定sequence相关配置在哪个节点上

例如:

USER_SEQ=test_dn1

注意:MYCAT_SEQUENCE表和以上的3个function,需要放在同一个节点上。function请直接在具体节点的数据库上执行,如 果执行的时候报:

you might want to use the less safe log_bin_trust_function_creators variable

需要对数据库做如下设置:

windows下my.ini[mysqld]加上log_bin_trust_function_creators=1 linux下/etc/my.cnf下my.ini[mysqld]加上log_bin_trust_function_creators=1
修改完后,即可在mysql数据库中执行上面的函数.

使用示例:

insert into table1(id,‘test’);

其他方式

• 使用catelet注解方式

/*!mycat:catlet=demo.catlets.BatchGetSequence */SELECT mycat_get_seq(‘GLOBAL’,100); 
注:此方法表示获取GLOBAL的100个sequence值,例如当前GLOBAL的最大sequence值为5000,则通过此方式返回的是 5001,同时更新数据库中的BLOBAL的最大sequence值为5100.

• 利用zookeeper方式实现

自增长主键

mycat自增长主键和返回生成主键ID的实现，mycat目前提供了自增长主键功能，但是如果对应的mysql节点上的数据表，没有定义auto_increment,那么mycat层调用last_insert_id()也是不会返回结果的。

• mysql本身对非自增长主键，使用last_insert_id()是不会返回结果的，只会返回0

• mysql只会对定义自增长主键，可以用last_insert_id()返回主键值

正确配置方式

1.mysql定义自增主键

CREATE TABLE table1(
‘id_’ INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,‘name_’ INT(10) UNSIGNED NOT NULL,PRIMARY KEY (‘id_’)
) ENGINE=MYISAM AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

2.mycat定义主键自增

schema.xml

        
        select user()
        
    

修改mycat对应sequence_db_conf.properties增加相应设置
TABLE1=dn1
继续在数据库中mycat_sequence表中增加TABLE1表的sequence记录
Mybatis新增记录后获取last_insert_id的示例


MyCAT分片规则
在数据切分处理中，特别是水平切分中，中间件最重要的两个处理过程就是数据的切分、数据的聚合。选择合适的切分规则，至关重要，因为它决定了后续数据聚合的难易程度，甚至可以避免跨库的数据聚合处理。
类似于数据字典表适合配置为全局表
    类似订单和订单明细适合配置为ER分片表
<table&gt;
    <childTable name="order_detail" primaryKey="id" joinKey="order_id" parentKey="order_id"/&gt;
</table&gt;
多对多关联
有一类业务场景是"主表A+关系表+主表B"，举例来说就是商户会员+订单+商户，对应这类业务，如何切分？
从会员的角度，如果需要查询会员购买的订单，那按照会员进行切分即可，但是如果要查询商户当前售出的订单，那又需要按照商户做切分，可是如果即要按会员又要按商户切分，几乎是无法实现，这类业务如何选择切分规则非常难。
目前还暂时无法很好支持这种模式下的三个表之间的关系，目前总的原则是需要从业务角度来看，关系表更偏向哪个表，即A的关系还是B的关系，来决定关系表跟从哪个方向存储。
未来Mycat版本将考虑将中间表进行双向复制，以实现A-关系以及B-关系表的双向关联查询。

主健分片 vs 非主键分片
当没有任何字段可以作为分片字段的时候，主键分片就是唯一选择，其优点是按照主键的查询最快，当采用自动增长的序列号作为主键时，还能比较均匀的将数据分片在不同的节点上。
若有某个合适的业务字段比较合适作为分片字段，则建议采用此业务字段分片，选择分片字段的条件如下

尽可能的比较均匀分布数据到各个节点上
该业务字段是最频繁或是最重要的查询条件

常见的除了主键之外的其他可能分片字段有订单创建时间、店铺类别或所有省等，当找到某个合适的业务字段作为分片字段以后，不必纠结于“牺牲了按主键查询记录的性能”，因为在这种情况下，mycat提供了主键到分片的内存缓存机制，热点数据按照主键查询，丝毫不损失性能。
本节主要讲了如何去分片，如何选择合适分片的规则，总之尽量规避跨库join是一条最重要的原则。
MyCat常用分片规则
分片枚举
通过在配置文件中配置可能的枚举id，自己配置分片，本规则适用于特定的场景，比如有些业务需要按照省或地区来做保存。

        user_id
        hash-int
    


    
    

partition-hash-int.txt配置

10000=0

10010=1

DEFAULT_NODE=1


上面columns标识将要分片的表字段，algorithm分片函数，其中分片函数配置中，mapFile标识配置文件名称，type默认值为0，0表示Integer，非零表示String。defaultNode指默认节点，小于0表示不设置默认节点，大于等于0表示设置默认节点。
默认节点的作：枚举分片时，如果碰到不识别的枚举值，就让它路由到默认节点，如果不配置，碰到不识别的枚举值就会报错。
固定分片hash算法
本规则类似于十进制的求模运算，区别在于是二进制的操作，是取ID的二进制低10位，即id二进制&2222222222。
此算法的优点在于如果按照10进制取模运算，在连接插入1-10时候，1-10会被分到1-10个分片，增大了插入的事务控制难度，而此算法根据二进制则可能会分到连续的分片，减少插入事务控制难度。

        user_id
        func1
    


    


配置说明：
partitionCount分片个数列表，partitionLength分片范围列表
分区长度：默认为最大2^n=1024,即最大支持1024分区
约束：count,length两个数组的长度必须是一致的
1024=sum((count[i]*length[i])) count和length两个向量的点积恒等于1024.
用法例子
本例的分区策略:希望将数据水平分成3份,前两份各占25%,第三份占50%。(故本例非均匀分区) // |<———————1024————————>|
// |<—-256—>|<—-256—>|<———-512———->|
// | partition0 | partition1 | partition2 |
// | 共2份,故count[0]=2 | 共1份,故count[1]=1 |
int[] count = new int[] { 2,1 };
int[] length = new int[] { 256,512 };
PartitionUtil pu = new PartitionUtil(count,length);

// 下面代码演示分别以offerId字段或memberId字段根据上述分区策略拆分的分配结果 int DEFAULT_STR_HEAD_LEN = 8; // cobar默认会配置为此值
long offerId = 12345;
String memberId = "qiushuo";
// 若根据offerId分配,partNo1将等于0,即按照上述分区策略,offerId为12345时将会被分配到partition0中 int partNo1 = pu.partition(offerId);
// 若根据memberId分配,partNo2将等于2,memberId为qiushuo时将会被分到partition2中 int partNo2 = pu.partition(memberId,DEFAULT_STR_HEAD_LEN);
如果需要平均分配设置：平均分为4分片 partitionCount*partitionLength=1024



范围约定
此分片适用于,提前规划好分片字段某个范围属于哪个分片
start <= range <= end
range start-end,data node index
K=1000,M=10000.

user_id
rang-long 


 

配置说明
rang-long 函数中mapFile代表配置文件路径
defaultNode 超过范围后的默认节点。 所有的节点配置都是从0开始,及0代表节点1,此配置非常简单,即预先制定可能的id范围到某个分片
0-500M=0 
500M-1000M=1 
1000M-1500M=2 
或
0-10000000=0 
10000001-20000000=1

求模
此规则为对分片字段求摸运算。

user_id
mod-long 

 


配置说明
此种配置非常明确即根据id进行十进制求模预算,相比固定分片hash,此种在批量插入时可能存在批量插入单事务插入多数据分 片,增大事务一致性难度。
按日期(天)分片

create_time
sharding-by-date 

 
 


配置说明:
columns :标识将要分片的表字段
 
algorithm :分片函数
dateFormat :日期格式
sBeginDate :开始日期
sBeginDate :结束日期
sPartionDay :分区天数,即默认从开始日期算起,分隔10天一个分区
Assert.assertEquals(true,0 == partition.calculate(“2014-01-01”)); Assert.assertEquals(true,0 == partition.calculate(“2014-01-10”)); Assert.assertEquals(true,1 == partition.calculate(“2014-01-11”)); Assert.assertEquals(true,12 == partition.calculate(“2014-05-01”));

取模范围约束
此种规则是取模运算与范围约束的结合，主要为了后续数据迁移做准备，即可以自主决定取模后数据的节点分布。

user_id
sharding-by-pattern 






partition-pattern.txt
//id partition range start-end,data node index 
//first host configuration
1-32=0
33-64=1
65-96=2
97-128=3
######## second host configuration 129-160=4
161-192=5
193-224=6
225-256=7
0-0=7

配置说明:
上面columns 标识将要分片的表字段,algorithm 分片函数,patternValue 即求模基数,defaoultNode 默认节点,如果配置 了默认,则不会按照求模运算
mapFile 配置文件路径
配置文件中,1-32 即代表id%256后分布的范围,如果在1-32则在分区1,其他类推,如果id非数据,则会分配在defaoultNode 默认节点
String idVal = “0”;
Assert.assertEquals(true,7 == autoPartition.calculate(idVal)); idVal = “45a”;
Assert.assertEquals(true,2 == autoPartition.calculate(idVal));
ASCII码求模范围约束
此种规则类似于取模范围约束，此规则支持数据符字母取模。

user_id
sharding-by-prefixpattern 






partition-pattern.txt
# range start-end,data node index # ASCII
# 8-57=0-9阿拉伯数字
# 64、65-90=@、A-Z
# 97-122=a-z
###### first host configuration 1-4=0
5-8=1
9-12=2
13-16=3
###### second host configuration 17-20=4
21-24=5
25-28=6
29-32=7
0-0=7
配置说明:
上面columns 标识将要分片的表字段,prefixLength ASCII 截取的位数
mapFile 配置文件路径
配置文件中,其他类推
此种方式类似方式6只不过采取的是将列种获取前prefixLength位列所有ASCII码的和进行求模sum%patternValue,获取的值,在范围内的分片数
String idVal=“gf89f9a”;
Assert.assertEquals(true,0==autoPartition.calculate(idVal));
idVal=“8df99a”;
Assert.assertEquals(true,4==autoPartition.calculate(idVal));
idVal=“8dhdf99a”;
Assert.assertEquals(true,3==autoPartition.calculate(idVal));

应用指定
此规则是在运行阶段有应用自主决定路由到哪个分片

user_id
sharding-by-substring 







配置说明:
上面columns 标识将要分片的表字段,algorithm 分片函数 此方法为直接根据字符子串(必须是数字)计算分区号(由应用传递参数,显式指定分区号)。
例如id=05-100000002 
在此配置中代表根据id中从startIndex=0,开始,截取siz=2位数字即05,05就是获取的分区,如果没传默认分配到 defaultPartition
字符串hash解析
此规则是截取字符串的int数值hash分片

user_id
sharding-by-stringhash 

512  



配置说明
上面columns 标识将要分片的表字段,algorithm 分片函数 
函数中length代表字符串hash求模基数,count分区数,hashSlice hash预算位 即根据子字符串中int值 hash运算
hashSlice : 0 means str.length(),-1 means str.length()-1 
/**
* “2” -> (0,2)
* “1:2” -> (1,2) * “1:” -> (1,0)
* “-1:” -> (-1,0) * “:-1” -> (0,-1) * “:” -> (0,0)
*/
例子:

String idVal=null; rule.setPartitionLength("512"); rule.setPartitionCount("2"); rule.init(); rule.setHashSlice("0:2");

// idVal = "0";

// Assert.assertEquals(true,0 == rule.calculate(idVal));

// idVal = "45a";

// Assert.assertEquals(true,1 == rule.calculate(idVal));

//last 4

rule = new PartitionByString(); rule.setPartitionLength("512"); rule.setPartitionCount("2");

rule.init();

//last 4 characters

rule.setHashSlice("-4:0");

idVal = "aaaabbb0000";

Assert.assertEquals(true,0 == rule.calculate(idVal)); idVal = "aaaabbb2359";

Assert.assertEquals(true,0 == rule.calculate(idVal));

一致性hash
一致性hash预算有效解决了分布式数据的扩容问题

user_id
murmur 



 
 
 

按单月小时拆分
此规则是单月内按照小时拆分，最小粒度是小时，可以一天最多24个分片，最少1个片，一个月完后下月从头开始循环，每个月月尾，需要手工清理数据。

create_time
sharding-by-hour 

 

配置说明
columns: 拆分字段,字符串类型(yyyymmddHH) 
splitOneDay : 一天切分的分片数
LatestMonthPartion partion = new LatestMonthPartion(); 
partion.setSplitOneDay(24);
Integer val = partion.calculate("2015020100"); 
assertTrue(val == 0);
val = partion.calculate("2015020216"); 
assertTrue(val == 40);
val = partion.calculate("2015022823"); 
assertTrue(val == 27 * 24 + 23);
Integer[] span = partion.calculateRange("2015020100","2015022823"); 
assertTrue(span.length == 27  24 + 23 + 1);

assertTrue(span[0] == 0 && span[span.length - 1] == 27  24 + 23);
span = partion.calculateRange("2015020100","2015020123");

assertTrue(span.length == 24);

assertTrue(span[0] == 0 && span[span.length - 1] == 23);

自然月分片
按月份列分区，每个自然月一个分片，格式between操作解析范例

create_time
sharding-by-month 


 

配置说明:
columns: 分片字段,字符串类型 
dateFormat : 日期字符串格式 
sBeginDate : 开始日期
PartitionByMonth partition = new PartitionByMonth();
partition.setDateFormat("yyyy-MM-dd"); 
partition.setsBeginDate("2014-01-01");
partition.init();

Assert.assertEquals(true,0 == partition.calculate("2014-01-01"));

Assert.assertEquals(true,0 == partition.calculate("2014-01-10"));

Assert.assertEquals(true,0 == partition.calculate("2014-01-31"));

Assert.assertEquals(true,1 == partition.calculate("2014-02-01"));

Assert.assertEquals(true,1 == partition.calculate("2014-02-28"));

Assert.assertEquals(true,2 == partition.calculate("2014-03-1"));

Assert.assertEquals(true,11 == partition.calculate("2014-12-31"));

Assert.assertEquals(true,12 == partition.calculate("2015-01-31"));

Assert.assertEquals(true,23 == partition.calculate("2015-12-31"));

权限控制
远程连接配置(读、写权限)
目前Mycat对于中间件的连接控制并没有做太复杂的控制，目前只做了中间件逻辑库级别的读写权限控制。
 
 
 


配置说明
name是应用连接中间件逻辑库的用户名
mycat 中password是应用连接中间件逻辑库的密码。
order 中是应用当前连接的逻辑库中所对应的逻辑表。schemas中可以配置一个或多个。
true 中readOnly是应用连接中间件逻辑库所具有的权限。true为只读,false为读写都有,默认为false。
多租户支持
单租户就是传统的给每个租户独立部署一套web + db 。由于租户越来越多,整个web部分的机器和运维成本都非常高,因此需 要改进到所有租户共享一套web的模式(db部分暂不改变)。
基于此需求,我们对单租户的程序做了简单的改造实现web多租户共享。具体改造如下:
1.web部分修改:
a.在用户登录时,在线程变量(ThreadLocal)中记录租户的id
b.修改jdbc的实现:在提交sql时,从ThreadLocal中获取租户id,添加sql 注释,把租户的schema 放到注释中。例如:/!mycat : schema = test_01 / sql ;
2.在db前面建立proxy层,代理所有web过来的数据库请求。proxy层是用mycat实现的,web提交的sql过来时在注释中指定 schema,proxy层根据指定的schema转发sql请求.
3.Mycat配置: mycat
partition.init();
Assert.assertEquals(true,23 == partition.calculate("2015-12-31"));
order,pay
./mycat start 启动
./mycat stop 停止
./mycat console 前台运行 
./mycat restart 重启服务 
./mycat pause 暂停
./mycat status 查看启动状态
Mycat性能测试
分片表的性能测试不同于普通单，因为它的数据是分布在几个Datahost上的，因此插入和查询，都需要特定的工具，才能做到多个节点同时负载请求，通过观察每个主机的负载，能够确定是否你的测试是合理和正确的。
                        
（编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!