Mycat安装与配置详解

Dear 丶 2022-03-11 12:40 706阅读 0赞

## 需要提前准备两个数据库以便于测试 ##

## 由于github限制，所以以后新版本从以下地址下载 ##

去这里下载 [http://dl.mycat.io][http_dl.mycat.io] （GitHub的mycat： [https://github.com/MyCATApache/Mycat-download）][https_github.com_MyCATApache_Mycat-download]  
可以看到最新的稳定版是1.6.7.1  
之后的都是测试和开发版，所以我们下载稳定版的1.6.7.1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70]

根据不同这里下载不同的版本（这里没有显示全，补过可以通过把鼠标移上去看左下角显示的链接信息）  
因为我要下linux版本的。所以我下载第一个Mycat-server-1.6.7.1-release-20190213150257-lin的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 1]  
下载后上传到Linux上，我的是centos6.5

#### 解压安装包 ####

tar -xvf Mycat-server-1.6.7.1-release-20190213150257-linux.tar.gz  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 2]  
可以看到解压出来的内容都放到mycat文件夹中了。  
删除安装包，进入mycat文件夹

![在这里插入图片描述][20190307211233100.png]  
bin:命令文件  
catlet:空的,扩展  
conf:配置文件(server.xml,schema.xml,rule.xml等)  
lib:依赖的jar包  
![在这里插入图片描述][20190307211430332.png]  
进入conf文件夹配置文件

在mycat根目录创建logs文件夹，会把日志自动记录到这里。  
如果启动报错可以到此目录查看日志  
我在安装的时候发现一个错误  
本地主机名未知，我的linux主机名称为test1，所以报错，需要在hosts文件中加上我的主机名字  
![在这里插入图片描述][20190308010346276.png]  
编辑hosts文件：vim /etc/hosts

![在这里插入图片描述][20190308010638305.png]  
把我的主机名test1加上即可.  
![在这里插入图片描述][20190308010711293.png]

通过命令：ps -ef | grep mycat 查看服务是否已经确认启动成功

### 确认成功之后开始配置conf文件夹下的schema.xml、server.xml、rule.xml ###

#### 配置schema.xml ####

在后面的测试环节有对此配置的说明内容，很详细。

<?xml version="1.0"?>
    <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
    <mycat:schema xmlns:mycat="http://io.mycat/">
    
    
    	
    	<schema name="mydatabase" checkSQLschema="true" sqlMaxLimit="100">
    		
    		<table name="t_user" dataNode="dn1,dn2,dn3" primaryKey="id" rule="auto-sharding-long">
    					
    			<childTable name="t_loginlog" primaryKey="id" joinKey="user_id" parentKey="id"></childTable>
    		</table>
    		<table name="t_student" dataNode="dn1,dn3" primaryKey="id" rule="student_id" />
    		<table name="t_dictionaries" dataNode="dn1,dn2,dn3" type="global" />
    		<table name="t_teacher" dataNode="dn1" />
        </schema>
    		
    		
    		<dataNode name="dn1" dataHost="dtHost1" database="db1" />
    		<dataNode name="dn2" dataHost="dtHost1" database="db2" />
    		<dataNode name="dn3" dataHost="dtHost2" database="db3" />
    		
    	
    	<dataHost name="dtHost1" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
    		
    		<heartbeat>select user()</heartbeat>
    		
    		<writeHost host="127.0.0.1" url="192.168.199.11:3306" user="root" password="123456">
    			<readHost host="127.0.0.1" url="192.168.199.12:3306" user="root" password="123456" />
    		</writeHost>
    	
    	</dataHost>
    	<dataHost name="dtHost2" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
    		
    		<heartbeat>select user()</heartbeat>
    		
    		<writeHost host="127.0.0.1" url="192.168.199.13:3306" user="root" password="123456">
    			<readHost host="127.0.0.1" url="192.168.199.13:3306" user="root" password="123456" />
    		</writeHost>
    	
    	</dataHost>
    </mycat:schema>

#### 配置server.xml ####

<?xml version="1.0" encoding="UTF-8"?>
    
    <!DOCTYPE mycat:server SYSTEM "server.dtd">
    <mycat:server xmlns:mycat="http://io.mycat/">
    	<system>
    	
        <property name="serverPort">8066</property>
    	<property name="nonePasswordLogin">0</property> 
    	<property name="useHandshakeV10">1</property>
    	<property name="useSqlStat">0</property>  
    	<property name="useGlobleTableCheck">0</property>  
    
    		<property name="sequnceHandlerType">2</property>
    	<property name="subqueryRelationshipCheck">false</property> 
           
             
    	
    	
            
    		<property name="processorBufferPoolType">0</property>
    		
    		
    		
    		
    		
    		
    		
    		
    		<property name="handleDistributedTransactions">0</property>
    		
    			
    		<property name="useOffHeapForMerge">1</property>
    
    		
            <property name="memoryPageSize">64k</property>
    
    		
    		<property name="spillsFileBufferSize">1k</property>
    
    		<property name="useStreamOutput">0</property>
    
    		
    		<property name="systemReserveMemorySize">384m</property>
    
    
    		
    		<property name="useZKSwitch">false</property>
    
    		
    		
    
    		
    		
    		
    		<property name="strictTxIsolation">false</property>
    		
    		<property name="useZKSwitch">true</property>
    		
    	</system>
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	<firewall>
    	   <whitehost>
    	      <host host="192.*" user="root"/>
    		  <host host="127.*" user="root"/>
    	   </whitehost>
           <blacklist check="false">
           </blacklist>
    	</firewall>
    	
    	
    	<user name="root" defaultAccount="true">
    		<property name="password">123456</property>
    		<property name="schemas">mydatabase</property>
    		
    		
    		
    	</user>
    
    	
    
    </mycat:server>

#### 配置rule.xml ####

<?xml version="1.0" encoding="UTF-8"?>
    
    <!DOCTYPE mycat:rule SYSTEM "rule.dtd">
    <mycat:rule xmlns:mycat="http://io.mycat/">
    
    	<tableRule name="student_id">
            <rule>
                <columns>id</columns>
                <algorithm>student_text</algorithm>
            </rule>
        </tableRule>
    	
    	
    	<tableRule name="rule1">
    		<rule>
    			<columns>id</columns>
    			<algorithm>func1</algorithm>
    		</rule>
    	</tableRule>
    
    	<tableRule name="rule2">
    		<rule>
    			<columns>user_id</columns>
    			<algorithm>func1</algorithm>
    		</rule>
    	</tableRule>
    
    	<tableRule name="sharding-by-intfile">
    		<rule>
    			<columns>sharding_id</columns>
    			<algorithm>hash-int</algorithm>
    		</rule>
    	</tableRule>
    	<tableRule name="auto-sharding-long">
    		<rule>
    			<columns>id</columns>
    			<algorithm>rang-long</algorithm>
    		</rule>
    	</tableRule>
    	<tableRule name="mod-long">
    		<rule>
    			<columns>id</columns>
    			<algorithm>mod-long</algorithm>
    		</rule>
    	</tableRule>
    	<tableRule name="sharding-by-murmur">
    		<rule>
    			<columns>id</columns>
    			<algorithm>murmur</algorithm>
    		</rule>
    	</tableRule>
    	<tableRule name="crc32slot">
    		<rule>
    			<columns>id</columns>
    			<algorithm>crc32slot</algorithm>
    		</rule>
    	</tableRule>
    	<tableRule name="sharding-by-month">
    		<rule>
    			<columns>create_time</columns>
    			<algorithm>partbymonth</algorithm>
    		</rule>
    	</tableRule>
    	<tableRule name="latest-month-calldate">
    		<rule>
    			<columns>calldate</columns>
    			<algorithm>latestMonth</algorithm>
    		</rule>
    	</tableRule>
    	
    	<tableRule name="auto-sharding-rang-mod">
    		<rule>
    			<columns>id</columns>
    			<algorithm>rang-mod</algorithm>
    		</rule>
    	</tableRule>
    	
    	<tableRule name="jch">
    		<rule>
    			<columns>id</columns>
    			<algorithm>jump-consistent-hash</algorithm>
    		</rule>
    	</tableRule>
    
    
    
    
    
     <function name="student_text" class="io.mycat.route.function.AutoPartitionByLong">
            <property name="mapFile">student_text.txt</property>
        </function>
    	
    	
    	
    	
    	
    	
    	
    	
    	<function name="murmur" class="io.mycat.route.function.PartitionByMurmurHash">
    		<property name="seed">0</property>
    		<property name="count">2</property>
    		<property name="virtualBucketTimes">160</property>
    		
    		
    	</function>
    
    	<function name="crc32slot" class="io.mycat.route.function.PartitionByCRC32PreSlot">
    	</function>
    	<function name="hash-int" class="io.mycat.route.function.PartitionByFileMap">
    		<property name="mapFile">partition-hash-int.txt</property>
    	</function>
    	<function name="rang-long" class="io.mycat.route.function.AutoPartitionByLong">
    		<property name="mapFile">autopartition-long.txt</property>
    	</function>
    	<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
    		
    		<property name="count">3</property>
    	</function>
    
    	<function name="func1" class="io.mycat.route.function.PartitionByLong">
    		<property name="partitionCount">8</property>
    		<property name="partitionLength">128</property>
    	</function>
    	<function name="latestMonth" class="io.mycat.route.function.LatestMonthPartion">
    		<property name="splitOneDay">24</property>
    	</function>
    	<function name="partbymonth" class="io.mycat.route.function.PartitionByMonth">
    		<property name="dateFormat">yyyy-MM-dd</property>
    		<property name="sBeginDate">2015-01-01</property>
    	</function>
    	
    	<function name="rang-mod" class="io.mycat.route.function.PartitionByRangeMod">
            	<property name="mapFile">partition-range-mod.txt</property>
    	</function>
    	
    	<function name="jump-consistent-hash" class="io.mycat.route.function.PartitionByJumpConsistentHash">
    		<property name="totalBuckets">3</property>
    	</function>
    </mycat:rule>

### 在conf文件夹创建student\_text.txt文件 ###

vim student\_text.txt  
![在这里插入图片描述][20190308032719793.png]  
内容如下，需要注意的是  
0-1M ，为0<=id<=10000,  
1M-2M，为10000<id<=20000，因为只定义了两个范围。如果超过20000例如20001会报错  
说明一下：1k=1000 ， 1M=10000

0-1M=0
    1M-2M=1

#### schema.xml中t\_student的 table标签值对应了两个dataNode节点，所以此处只有两个规则，不能多，也不能少 ####

#### 配置完成后就可以启动mycat进行测试了 ####

在bin文件夹下执行./mycat start  
然后通过navicat进行连接，注意端口为之前配置的8066，用户名和密码也是之前配置的root/123456,连接地址为mycat安装主机地址  
192.168.199.11和192.168.199.12为双机热备的物理库，  
192.168.199.13为单机库，  
mycat为逻辑库，通过逻辑库做增删改查、建表、删除表等表操作都会同步在其他物理库上执行。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 3]

### 手动在物理库上创建好已经定义的库 ###

然后在**mycat**中执行sql创建表，并自动同步到物理库中，注意是mycat执行建表sql

DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user` (
      `id` int(11) NOT NULL,
      `name` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    
    
    DROP TABLE IF EXISTS `t_student`;
    
    CREATE TABLE `t_student` (
      `id` int(11) NOT NULL,
      `s_name` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    
    
    
    DROP TABLE IF EXISTS `t_teacher`;
    CREATE TABLE `t_teacher` (
      `id` int(11) NOT NULL,
      `t_name` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    DROP TABLE IF EXISTS `t_loginlog`;
    
    CREATE TABLE `t_loginlog` (
      `id` int(11) NOT NULL,
      `user_id` int(11) NOT NULL,
      `create_time` date DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    
    DROP TABLE IF EXISTS `t_dictionaries`;
    
    CREATE TABLE `t_dictionaries` (
      `id` int(11) NOT NULL,
      `name` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

### 在mycat中执行插入数据sql ###

INSERT INTO `t_student` VALUES ('0', '00');
    INSERT INTO `t_student` VALUES ('1', '111');
    INSERT INTO `t_student` VALUES ('10000', '10000');
    INSERT INTO `t_student` VALUES ('10001', '10001');
    INSERT INTO `t_student` VALUES ('20000', '20000');
    
    INSERT INTO `t_user` VALUES ('1', '111');
    INSERT INTO `t_user` VALUES ('10000001', '10000001');
    INSERT INTO `t_user` VALUES ('5000001', '5000001');
    
    INSERT INTO `t_loginlog` VALUES ('1', '1', '2019-03-08');
    INSERT INTO `t_loginlog` VALUES ('3', '10000001', '2019-03-06');
    INSERT INTO `t_loginlog` VALUES ('2', '5000001', '2019-03-07');
    
    INSERT INTO `t_dictionaries` VALUES ('1', '1');

打开mycat查看刚刚插入的数据，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 4]  
首先确认t\_student的数据，分片节点为dn1和dn3对应db1和db3的物理库，并分别存储在dtHost1和dtHost2两台mysql上  
分片规则为  
0-1M=0  
1M-2M=1  
确认物理库确实根据ID分开进行存储  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 5]

##### 确认t\_user是否进行了分片，t\_loginlog是否根据和t\_user的主外键规则进行分片 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 6]  
确认t\_user确实按照ID进行了分片，t\_loginlog确实根据t\_user的外键关联进行了分片，因为我的SQL并没有写主外键的约束，所以我手动往t\_loginlog也是可以插入数据的

##### t\_dictionaries表为全局表，所以他的数据操作是同步在所有的数据节点上， #####

配置了3个数据节点，所以3个数据节点中的数据是一致的  
此处就不截图了。

##### t\_teacher 并没有进行分片配置，也只定义了一个节点所以是单表，确认只有一个物理库中存在即可。 #####

![在这里插入图片描述][20190308225248813.png]

# 至此已经搭建完毕 #

### rule规则详解 ###

常用的分片规则：总共十个（基本够用）
     
    一、枚举法
    <tableRule name="sharding-by-intfile">
        <rule>
          <columns>user_id</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">0</property>
        <property name="defaultNode">0</property>
      </function>
     
    partition-hash-int.txt 配置：
    10000=0
    10010=1
    上面columns 标识将要分片的表字段，algorithm 分片函数，
    其中分片函数配置中，mapFile标识配置文件名称，type默认值为0，0表示Integer，非零表示String，
    所有的节点配置都是从0开始，及0代表节点1
    /**
    *  defaultNode 默认节点:小于0表示不设置默认节点，大于等于0表示设置默认节点,结点为指定的值
    * 
    默认节点的作用：枚举分片时，如果碰到不识别的枚举值，就让它路由到默认节点
    *                如果不配置默认节点（defaultNode值小于0表示不配置默认节点），碰到
    *                不识别的枚举值就会报错，
    *                like this：can't find datanode for sharding column:column_name val:ffffffff    
    */
     
    二、固定分片hash算法
    <tableRule name="rule1">
        <rule>
          <columns>user_id</columns>
          <algorithm>func1</algorithm>
        </rule>
    </tableRule>
     
      <function name="func1" class="io.mycat.route.function.PartitionByLong">
        <property name="partitionCount">2,1</property>
        <property name="partitionLength">256,512</property>
      </function>
    配置说明：
    上面columns 标识将要分片的表字段，algorithm 分片函数，
    partitionCount 分片个数列表，partitionLength 分片范围列表
    分区长度:默认为最大2^n=1024 ,即最大支持1024分区
    约束 :
    count,length两个数组的长度必须是一致的。
    1024 = sum((count[i]*length[i])). count和length两个向量的点积恒等于1024
    用法例子：
    @Test
    public void testPartition() {
    // 本例的分区策略：希望将数据水平分成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, 0, DEFAULT_STR_HEAD_LEN);
    
    Assert.assertEquals(0, partNo1);
    Assert.assertEquals(2, partNo2);
    }
     
    如果需要平均分配设置：平均分为4分片，partitionCount*partitionLength=1024
    <function name="func1" class="org.opencloudb.route.function.PartitionByLong">
        <property name="partitionCount">4</property>
        <property name="partitionLength">256</property>
      </function>
     
    三、范围约定
    <tableRule name="auto-sharding-long">
        <rule>
          <columns>user_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>
      </function>
    # range start-end ,data node index
    # K=1000,M=10000.
    0-500M=0
    500M-1000M=1
    1000M-1500M=2
    或
    0-10000000=0
    10000001-20000000=1
     
     
    配置说明：
    上面columns 标识将要分片的表字段，algorithm 分片函数，
    rang-long 函数中mapFile代表配置文件路径
    所有的节点配置都是从0开始，及0代表节点1，此配置非常简单，即预先制定可能的id范围到某个分片
     
    四、求模法
    <tableRule name="mod-long">
        <rule>
          <columns>user_id</columns>
          <algorithm>mod-long</algorithm>
        </rule>
      </tableRule>
      <function name="mod-long" class="io.mycat.route.function.PartitionByMod">
       
        <property name="count">3</property>
      </function>
     
    配置说明：
    上面columns 标识将要分片的表字段，algorithm 分片函数，
    此种配置非常明确即根据id与count（你的结点数）进行求模预算，相比方式1，此种在批量插入时需要切换数据源，id不连续
     
    五、日期列分区法
    <tableRule name="sharding-by-date">
          <rule>
            <columns>create_time</columns>
            <algorithm>sharding-by-date</algorithm>
          </rule>
       </tableRule> 
    <function name="sharding-by-date" class="io.mycat.route.function..PartitionByDate">
       <property name="dateFormat">yyyy-MM-dd</property>
        <property name="sBeginDate">2014-01-01</property>
        <property name="sPartionDay">10</property>
      </function>
    配置说明：
    上面columns 标识将要分片的表字段，algorithm 分片函数，
    配置中配置了开始日期，分区天数，即默认从开始日期算起，分隔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"));
     
     
     
    六、通配取模
    <tableRule name="sharding-by-pattern">
          <rule>
            <columns>user_id</columns>
            <algorithm>sharding-by-pattern</algorithm>
          </rule>
       </tableRule>
    <function name="sharding-by-pattern" class="io.mycat.route.function.PartitionByPattern">
        <property name="patternValue">256</property>
        <property name="defaultNode">2</property>
        <property name="mapFile">partition-pattern.txt</property>
     
      </function>
    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 默认节点，如果不配置了默认，则默认是0即第一个结点
    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码求模通配
    <tableRule name="sharding-by-prefixpattern">
          <rule>
            <columns>user_id</columns>
            <algorithm>sharding-by-prefixpattern</algorithm>
          </rule>
       </tableRule>
    <function name="sharding-by-pattern" class="io.mycat.route.function.PartitionByPrefixPattern">
        <property name="patternValue">256</property>
        <property name="prefixLength">5</property>
        <property name="mapFile">partition-pattern.txt</property>
     
      </function>
     
    partition-pattern.txt
     
    # range start-end ,data node index
    # ASCII
    # 48-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 标识将要分片的表字段，algorithm 分片函数，patternValue 即求模基数，prefixLength ASCII 截取的位数
    mapFile 配置文件路径
    配置文件中，1-32 即代表id%256后分布的范围，如果在1-32则在分区1，其他类推 
     
    此种方式类似方式6只不过采取的是将列种获取前prefixLength位列所有ASCII码的和进行求模sum%patternValue ,获取的值，在通配范围内的
    即 分片数，
    /**
    * ASCII编码：
    * 48-57=0-9阿拉伯数字
    * 64、65-90=@、A-Z
    * 97-122=a-z
    *
    */
    如 
     
    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));
     
    八、编程指定
    <tableRule name="sharding-by-substring">
          <rule>
            <columns>user_id</columns>
            <algorithm>sharding-by-substring</algorithm>
          </rule>
       </tableRule>
    <function name="sharding-by-substring" class="io.mycat.route.function.PartitionDirectBySubString">
        <property name="startIndex">0</property> 
        <property name="size">2</property>
        <property name="partitionCount">8</property>
        <property name="defaultPartition">0</property>
      </function>
    配置说明：
    上面columns 标识将要分片的表字段，algorithm 分片函数 
    此方法为直接根据字符子串（必须是数字）计算分区号（由应用传递参数，显式指定分区号）。
    例如id=05-100000002
    在此配置中代表根据id中从startIndex=0，开始，截取siz=2位数字即05，05就是获取的分区，如果没传默认分配到defaultPartition
     
    九、字符串拆分hash解析
    <tableRule name="sharding-by-stringhash">
          <rule>
            <columns>user_id</columns>
            <algorithm>sharding-by-stringhash</algorithm>
          </rule>
       </tableRule>
    <function name="sharding-by-substring" class="io.mycat.route.function.PartitionByString">
        <property name=length>512</property> 
        <property name="count">2</property>
        <property name="hashSlice">0:2</property>
      </function>
    配置说明：
    上面columns 标识将要分片的表字段，algorithm 分片函数 
    函数中length代表字符串hash求模基数，count分区数，hashSlice hash预算位
    即根据子字符串 hash运算
     
    hashSlice ： 0 means str.length(), -1 means str.length()-1
     
    /**
         * "2" -> (0,2)<br/>
         * "1:2" -> (1,2)<br/>
         * "1:" -> (1,0)<br/>
         * "-1:" -> (-1,0)<br/>
         * ":-1" -> (0,-1)<br/>
         * ":" -> (0,0)<br/>
         */
    public class PartitionByStringTest {
    
    @Test
    public void test() {
    PartitionByString rule = new PartitionByString();
    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
    <tableRule name="sharding-by-murmur">
          <rule>
            <columns>user_id</columns>
            <algorithm>murmur</algorithm>
          </rule>
       </tableRule>
    <function name="murmur" class="io.mycat.route.function.PartitionByMurmurHash">
          <property name="seed">0</property>
          <property name="count">2</property>
          
          
      </function>

[http_dl.mycat.io]: http://dl.mycat.io
[https_github.com_MyCATApache_Mycat-download]: https://github.com/MyCATApache/Mycat-download%EF%BC%89
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70]: /images/20220311/4d43af045d7f48ea9a39cf809cc5c42f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 1]: /images/20220311/fb855bbbc6f14cb2b53b382fa4e23c6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 2]: /images/20220311/2c8ec7003842456b9e4fb4c35dfe860f.png
[20190307211233100.png]: /images/20220311/6c4a436fb7504f86b8792fa4a444df76.png
[20190307211430332.png]: /images/20220311/1657737c725744a1bc09270f9e46b23c.png
[20190308010346276.png]: /images/20220311/e0ca2839d4074bc983711c0ca274e542.png
[20190308010638305.png]: /images/20220311/3da879d5bcbc4056919798e8268b4261.png
[20190308010711293.png]: /images/20220311/07b241dedcff4d90855fbe99b4e1ddba.png
[20190308032719793.png]: /images/20220311/2760125e4f98420db2323a76b97c024b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 3]: /images/20220311/1c188f60e0bb4bdab0657b1ab6aaa853.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 4]: /images/20220311/6d791c540f804142ab871453fdef629a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 5]: /images/20220311/05be87629c6042bc8abc6df65695edb5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1MzQyMTA3MDU2_size_16_color_FFFFFF_t_70 6]: /images/20220311/1a62ef94ba0343ba852ab007bcc4b4a5.png
[20190308225248813.png]: /images/20220311/366baa88e9ac4664bb840eb4d24d8c6a.png