个人的观点，这种大表的优化，不一定上来就要分库分表，因为表一旦被拆分，开发、运维的复杂度会直线上升，而大多数公司是欠缺这种能力的。所以MySQL中几百万甚至小几千万的表，先考虑做单表的优化。

单表优化

单表优化可以从这几个角度出发：

• 表分区：MySQL在5.1之后才有的，可以看做是水平拆分，分区表需要在建表的需要加上分区参数，用户需要在建表的时候加上分区参数；分区表底层由多个物理子表组成，但是对于代码来说，分区表是透明的；SQL中的条件中最好能带上分区条件的列，这样可以定位到少量的分区上，否则就会扫描全部分区。
  

MySQL数据库是在国内各大公司最常用的数据库之一，MySQL是一种开源的关系型数据库。而对于数据库的优化我认为可以从以下几个方面进行：

1.数据库配置优化在安装MySQL数据库时，可以对于数据库进行优化，增加数据库的连接数，增加访问量，访问量的增加可以提高查询速度。增加缓存等优化数据库，在查询时，可以直接在缓存中查询数据；

2.表结构优化在创建表结构时，一张数据表中不要创建过多的字段，如果一个功能的数据表结构中字段较多，可以尝试将字段分离出来，分别建成两个或多个表。而且对于字段的长度够用即可，不要设置的过长；

3.索引优化可以在数据库中，对于经常使用的表建立索引，索引可以增加查询的速度。但是索引不是越多越好，过多的索引反而会减慢查询的速度。针对性地建立索引会加速查询，但是对新增、修改、删除会造成一定的影响；

4.SQL查询优化在SQL查询时可以通过优化SQL的查询进行优化，通过增加查询的条件优化SQL，在多表关联的查询中，尽量不要使用自关联和全关联的方式进行，而是使用左右关联的方式进行查询。查询语句将字段写出来，不要使用select * from t(表名)的方式进行。

一、Mysql分库分表方案

当一张表的数据达到几千万时，你查询一次所花的时间会变多，如果有联合查询的话，我想有可能会死在那儿了。分表的目的就在于此，减小数据库的负担，缩短查询时间。

mysql中有一种机制是表锁定和行锁定，是为了保证数据的完整性。表锁定表示你们都不能对这张表进行操作，必须等我对表操作完才行。行锁定也一样，别的sql必须等我对这条数据操作完了，才能对这条数据进行操作。

做mysql集群,利用amoeba。

从上层的java程序来讲，不需要知道主服务器和从服务器的来源，即主从数据库服务器对于上层来讲是透明的。可以通过amoeba来配置。

MySQL 一直以来都支持正则匹配，不过对于正则替换则一直到MySQL 8.0 才支持。对于这类场景，以前要么在MySQL端处理，要么把数据拿出来在应用端处理。

比如我想把表y1的列str1的出现第3个action的子 串替换成dble，怎么实现？

1. 自己写SQL层的存储函数。代码如下写死了3个，没有优化，仅仅作为演示，MySQL 里非常不建议写这样的函数。

• mysql
• DELIMITER $$
• USE `ytt`$$
• DROP FUNCTION IF EXISTS `func_instr_simple_ytt`$$
• CREATE DEFINER=`root`@`localhost` FUNCTION `func_instr_simple_ytt`(
• f_str VARCHAR(1000), -- Parameter 1
• f_substr VARCHAR(100), -- Parameter 2
• f_replace_str varchar(100),
• f_times int -- times counter.only support 3.
• ) RETURNS varchar(1000)
• BEGIN
• declare v_result varchar(1000) default 'ytt'; -- result.
• declare v_substr_len int default 0; -- search string length.
• 
  
  
• set f_times = 3; -- only support 3.
• set v_substr_len = length(f_substr);
• select instr(f_str,f_substr) into @p1; -- First real position .
• select instr(substr(f_str,@p1+v_substr_len),f_substr) into @p2; Secondary virtual position.
• select instr(substr(f_str,@p2+ @p1 +2*v_substr_len - 1),f_substr) into @p3; -- Third virtual position.
• if @p1 > 0 && @p2 > 0 && @p3 > 0 then -- Fine.
• select
• concat(substr(f_str,1,@p1 + @p2 + @p3 + (f_times - 1) * v_substr_len - f_times)
• ,f_replace_str,
• substr(f_str,@p1 + @p2 + @p3 + f_times * v_substr_len-2)) into v_result;
• else
• set v_result = f_str; -- Never changed.
• end if;
• -- Purge all session variables.
• set @p1 = null;
• set @p2 = null;
• set @p3 = null;
• return v_result;
• 
  
  
• end;
• $$
• DELIMITER ;
• 
  
  
• -- 调用函数来更新：
• mysql> update y1 set str1 = func_instr_simple_ytt(str1,'action','dble',3);
• Query OK, 20 rows affected (0.12 sec)
• Rows matched: 20 Changed: 20 Warnings: 0
• 2. 导出来用sed之类的工具替换掉在导入，步骤如下：（推荐使用）1）导出表y1的记录。
• mysqlmysql> select * from y1 into outfile '/var/lib/mysql-files/y1.csv';Query OK, 20 rows affected (0.00 sec)
• 
  2）用sed替换导出来的数据。
• shellroot@ytt-Aspire-V5-471G:/var/lib/mysql-files# sed -i 's/action/dble/3' y1.csv
• 
  3）再次导入处理好的数据，完成。
• mysql
• mysql> truncate y1;
• Query OK, 0 rows affected (0.99 sec)
• 
  
  
• mysql> load data infile '/var/lib/mysql-files/y1.csv' into table y1;
• Query OK, 20 rows affected (0.14 sec)
• Records: 20 Deleted: 0 Skipped: 0 Warnings: 0
• 以上两种还是推荐导出来处理好了再重新导入，性能来的高些，而且还不用自己费劲写函数代码。那MySQL 8.0 对于以上的场景实现就非常简单了，一个函数就搞定了。
• mysqlmysql> update y1 set str1 = regexp_replace(str1,'action','dble',1,3) ;Query OK, 20 rows affected (0.13 sec)Rows matched: 20 Changed: 20 Warnings: 0
• 
  还有一个regexp_instr 也非常有用，特别是这种特指出现第几次的场景。比如定义 SESSION 变量@a。
• mysqlmysql> set @a = 'aa bb cc ee fi lucy 1 1 1 b s 2 3 4 5 2 3 5 561 19 10 10 20 30 10 40';Query OK, 0 rows affected (0.04 sec)
• 
  拿到至少两次的数字出现的第二次子串的位置。
• mysqlmysql> select regexp_instr(@a,'[:digit:]',1,2);+--------------------------------------+| regexp_instr(@a,'[:digit:]',1,2) |+--------------------------------------+| 50 |+--------------------------------------+1 row in set (0.00 sec)
• 
  那我们在看看对多字节字符支持如何。
• mysql
• mysql> set @a = '中国 美国 俄罗斯 日本 中国 北京 上海 深圳 广州 北京 上海 武汉 东莞 北京 青岛 北京';
• Query OK, 0 rows affected (0.00 sec)
• 
  
  
• mysql> select regexp_instr(@a,'北京',1,1);
• +-------------------------------+
• | regexp_instr(@a,'北京',1,1) |
• +-------------------------------+
• | 17 |
• +-------------------------------+
• 1 row in set (0.00 sec)
• 
  
  
• mysql> select regexp_instr(@a,'北京',1,2);
• +-------------------------------+
• | regexp_instr(@a,'北京',1,2) |
• +-------------------------------+
• | 29 |
• +-------------------------------+
• 1 row in set (0.00 sec)
• 
  
  
• mysql> select regexp_instr(@a,'北京',1,3);
• +-------------------------------+
• | regexp_instr(@a,'北京',1,3) |
• +-------------------------------+
• | 41 |
• +-------------------------------+
• 1 row in set (0.00 sec)
• 那总结下，这里我提到了 MySQL 8.0 的两个最有用的正则匹配函数 regexp_replace 和 regexp_instr。针对以前类似的场景算是有一个完美的解决方案。

我也最近在看千万级数据怎么解决数据量大的问题，其中我找到2个比较好的解决方案，一个是mycat一个是sharing jdbc，mycat的官方文档刚看完，提供了分库分表和分片的概念，如果一个表的数据量太大，可以根据表中的字段区分为好几个分片，比如5千万的数据量分为10个分片，每个500万，当你查询的的时候他会移动根据路由规则查询哪几个分片然后聚合数据，具体的需要你根据自己的业务拆分，sharing jdbc我只是在看书的时候看到的，具体没怎么研究过。

首先分析数据量是否真的太大，分析表的使用方式，统计表的插入查询性能，可以查看mysql的slowlog，再把耗时长的语句拿出来分析，看能否通过优化sql来达到性能提升的目的。

以上的努力都尝试过还是存在性能问题的话，就得做下一步了。

单表数据量发的情况一般建议做分表，一是开发成本低，大多数框架都支持分表配置，其次是数据还在一个库里，对查询的影响比较小。

我是小七，一个平凡简单而不甘于平庸的程序员，欢迎大家关注我，一起交流学习！