Java各类技能知识点学习链接大全：四、数据库Sql，Mysql相关

「爱情、让人受尽委屈。」 2022-11-16 10:55 148阅读 0赞

以下内容大多是学习链接，他人整理，个人收藏以便复习，同时归纳分享出来（如有不妥，原作者可随时联系本人删除，感谢！）

## 四、数据库Sql，Mysql相关 ##

1、[MySQL中锁详解（行锁、表锁、页锁、悲观锁、乐观锁等）][MySQL]

[https://blog.csdn.net/mysteryhaohao/article/details/51669741][https_blog.csdn.net_mysteryhaohao_article_details_51669741]

2、[一张图彻底搞懂MySQL的 explain][MySQL_ explain]

[https://segmentfault.com/a/1190000021458117][MySQL_ explain]

3、select for update使用详解

[https://zhuanlan.zhihu.com/p/143866444][https_zhuanlan.zhihu.com_p_143866444]

4、mysql for update 死锁问题：

[https://www.jianshu.com/p/2b258bfe00e5][https_www.jianshu.com_p_2b258bfe00e5]（gap锁和排它锁发生的死锁）

【

我们已经知道，这种情况出现的原因是：两个session同时通过select for update，并且未命中任何记录的情况下，是有可能得到相同gap的锁的（要看where筛选条件是否落在同一个区间。如果上面的案例如果一个session准备插入'6'另一个准备插入'11'

（上面文章没有这个值，假设表里面有 id =12的值，插入11，就在10~12直接有一个gap锁，不会跟6的gap锁产生冲突                   了）则不会出现冲突，因为不是同一个gap）。

此时再进行并发插入，其中一个会进入锁等待，待第二个session进行插入时，会出现死锁。MySQL会根据事务权重选择一个事务进行回滚。

那么如何避免这个情况呢？  
一种解决办法是将事务隔离级别降低到Read Committed，这时不会有gap锁，对于上述场景，如果where中条件不同即最终要插入的键不同，则不会有问题。如果业务代码中可能不同线程会尝试对相同键进行select for update，则可在业务代码中捕获索引冲突异常进行重试。  
此外，上面代码示例中的代码还有一处值得注意的地方是事务注解@Transactional的传播机制，对于这类与主流程事务关系不大的方法，应当将事务传播行为改为REQUIRES\_NEW。  
原因有两点:

因为这里的解决方案是对隔离级别降级，如果传播行为仍然是默认的话，在外层事务隔离级别不是RC的情况下，会抛出IllegalTransactionStateException异常(在你的TransactionManager开启了validateExistingTransaction校验的情况下)。  
如果加入外层事务的话，某个线程在执行获取流水号的时候可能会因为另一个线程的与流水号不相关的事务代码还没执行完毕而阻塞。

】

5、剖析6个MySQL死锁案例的原因以及死锁预防策略

[https://juejin.cn/post/6950979697400348686][https_juejin.cn_post_6950979697400348686]

6、[MySQL的四种事务隔离级别][MySQL 1]

**不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表**

[https://www.cnblogs.com/huanongying/p/7021555.html][MySQL 1]

[https://developer.aliyun.com/article/743691][https_developer.aliyun.com_article_743691]

7、查询使用limit的优化：在MySQL中如何使用覆盖索引优化limit分页查询

如果索引包含所有满足查询需要的数据的索引成为覆盖索引(Covering Index)，也就是平时所说的不需要回表操作。

简单的说，覆盖索引覆盖所有需要查询的字段（即，大于或等于所查询的字段）。MySQL可以通过索引获取查询数据，因而不需要读取数据行。

（1）索引大小远小于数据行大小。因而，如果只读取索引，则能极大减少对数据访问量。  
（2）索引按顺序储存。对于IO密集型的范围查询会比随机从磁盘读取每一行数据的IO要少。  
（3）避免对主键索引的二次查询。二级索引的叶子节点包含了主键的值，如果二级索引包含所要查询的值，则能避免二次查询主键索引（聚簇索引，聚簇索引既存储了索引，也储存了值）。

[https://www.jianshu.com/p/c6290e65d8b5][https_www.jianshu.com_p_c6290e65d8b5]

8、[MySQL索引背后的数据结构及算法原理][MySQL 2]

[http://blog.codinglabs.org/articles/theory-of-mysql-index.html][MySQL 2]

9、[Innodb中的事务隔离级别和锁的关系][Innodb]（美团技术博客）

[https://tech.meituan.com/2014/08/20/innodb-lock.html][Innodb]

10、[MySQL索引原理及慢查询优化][MySQL 3]（美团技术博客）

[https://tech.meituan.com/2014/06/30/mysql-index.html][MySQL 3]

11、[MyBatis 如何实现流式查询][MyBatis]

[https://segmentfault.com/a/1190000022478915][MyBatis]

12、DB主从一致性架构优化4种方法

[https://mp.weixin.qq.com/s?\_\_biz=MjM5ODYxMDA5OQ==&mid=2651959442&idx=1&sn=feb8ff75385d8031386e120ef3535329&scene=21\#wechat\_redirect][https_mp.weixin.qq.com_s_biz_MjM5ODYxMDA5OQ_mid_2651959442_idx_1_sn_feb8ff75385d8031386e120ef3535329_scene_21_wechat_redirect]

13、数据库读写分离，主从同步实现方法：

[https://blog.csdn.net/starlh35/article/details/78735510][https_blog.csdn.net_starlh35_article_details_78735510]

[https://blog.csdn.net/helloxiaozhe/article/details/79548186][https_blog.csdn.net_helloxiaozhe_article_details_79548186]

[https://blog.csdn.net/qq\_15092079/article/details/81672920][https_blog.csdn.net_qq_15092079_article_details_81672920]

14、mysql 的binlog介绍：

[https://www.cnblogs.com/dadonggg/p/8617826.html][https_www.cnblogs.com_dadonggg_p_8617826.html]

15、分库分表技术演进：

[https://mp.weixin.qq.com/s/3ZxGq9ZpgdjQFeD2BIJ1MA][https_mp.weixin.qq.com_s_3ZxGq9ZpgdjQFeD2BIJ1MA]

16、分布式事务以及解决方案的详解：（本地硬盘资料）

https://www.bilibili.com/video/BV1FJ411A7mV?p=6（哔哩哔哩视频）

三种方案：2PC/XA方案、TCC强一致性方案、可靠消息最终一致性方案：

Mysql，通过XA事务可以来支持分布式事务的实现，在使用分布式事务时，InnoDB存储引擎必须使用SERIALIZABLE的隔离级别，查看是否启用了XA事务支持（默认开启）

mysql> show variables like 'innodb_support_xa';
    +-------------------+-------+
    | Variable_name     | Value |
    +-------------------+-------+
    | innodb_support_xa | ON    |
    +-------------------+-------+

XA规范的基础是两阶段提交协议（2PC）。TCC事务处理流程和 2PC二阶段提交类似，不过2PC通常都是在跨库的DB层面，而TCC本质就是一个应用层面的2PC

前两种方案链接：参考链接：[https://www.jianshu.com/p/ee4071d0c951][https_www.jianshu.com_p_ee4071d0c951]

可靠消息最终一致性方案：  
基于 MQ 来实现事务。比如阿里的 RocketMQ 就支持消息事务。大概的意思就是：

A 系统先发送一个 prepared 消息到 MQ，如果这个 prepared 消息发送失败那么就直接取消操作别执行了；  
如果这个消息发送成功过了，那么接着执行本地事务，如果成功就告诉 MQ 发送确认消息，如果失败就告诉 MQ 回滚消息；  
如果发送了确认消息，那么此时 B 系统会接收到确认消息，然后执行本地的事务；  
mq 会自动定时轮询所有 prepared 消息回调你的接口，问你，这个消息是不是本地事务处理失败了，所有没发送确认的消息，是继续重试还是回滚？一般来说这里你就可以查下数据库看之前本地事务是否执行，如果回滚了，那么这里也回滚吧。这个就是避免可能本地事务执行成功了，而确认消息却发送失败了。  
这个方案里，要是系统 B 的事务失败了咋办？重试咯，自动不断重试直到成功，如果实在是不行，要么就是针对重要的资金类业务进行回滚，比如 B 系统本地回滚后，想办法通知系统 A 也回滚；或者是发送报警由人工来手工回滚和补偿。  
这个还是比较合适的，目前国内互联网公司大都是这么玩儿的，要不你举用 RocketMQ 支持的，要不你就自己基于类似 ActiveMQ？RabbitMQ？自己封装一套类似的逻辑出来，总之思路就是这样子的。

最大努力通知方案  
这个方案的大致意思就是：

系统 A 本地事务执行完之后，发送个消息到 MQ；  
这里会有个专门消费 MQ 的最大努力通知服务，这个服务会消费 MQ 然后写入数据库中记录下来，或者是放入个内存队列也可以，接着调用系统 B 的接口；  
要是系统 B 执行成功就 ok 了；要是系统 B 执行失败了，那么最大努力通知服务就定时尝试重新调用系统 B，反复 N 次，最后还是不行就放弃。

seata分布式事务的坑：[https://juejin.cn/post/6844903878098436103][https_juejin.cn_post_6844903878098436103]

SpringCloud +Seata 实现分布式事务，Nacos 为配置中心：[https://blog.csdn.net/u014087208/article/details/108511340][https_blog.csdn.net_u014087208_article_details_108511340]

Seata实战-分布式事务简介及demo上手： [https://blog.csdn.net/hosaos/article/details/89136666][https_blog.csdn.net_hosaos_article_details_89136666]

17、分库分表介绍：

[https://blog.csdn.net/weixin\_43314519/article/details/109823130][https_blog.csdn.net_weixin_43314519_article_details_109823130]

18、sharding-jdbc介绍：

[https://zhuanlan.zhihu.com/p/301031380][https_zhuanlan.zhihu.com_p_301031380]

[https://shardingsphere.apache.org/document/current/cn/overview/][https_shardingsphere.apache.org_document_current_cn_overview]

19、[大众点评订单系统分库分表实践][Link 1]（美团技术博客）

[https://tech.meituan.com/2016/11/18/dianping-order-db-sharding.html][Link 1]

20、理解MYSQL MVCC 实现机制

快照读，是使用MVCC实现的；

当前读，使用next-key-lock，行锁间隙锁实现；

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 2][]![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

视频理解：[https://www.bilibili.com/video/BV1hL411479T?from=search&seid=6172954146791149151][https_www.bilibili.com_video_BV1hL411479T_from_search_seid_6172954146791149151]

[https://blog.csdn.net/SnailMann/article/details/94724197][https_blog.csdn.net_SnailMann_article_details_94724197]

[https://cloud.tencent.com/developer/article/1863151][https_cloud.tencent.com_developer_article_1863151]

[https://www.php.cn/mysql-tutorials-460111.html][https_www.php.cn_mysql-tutorials-460111.html]

21、由于MySQL的行锁是针对索引加的锁，不是针对记录加的锁，所以虽然是访问不同行的记录，但是如果是使用相同的索引键，是会出现锁冲突的：

InnoDB行锁是通过给索引上的索引项加锁来实现的，这一点MySQL与Oracle不同，后者是通过在数据块中对相应数据行加锁来实现的。InnoDB这种行锁实现特点意味着：只有通过索引条件检索数据，InnoDB才使用行级锁，否则，InnoDB将使用表锁！

在如下表所示的例子中，表tab\_with\_index的 **id字段有索引，name字段没有索引**：  
mysql> alter table tab\_with\_index drop index name;  
Query OK, 4 rows affected (0.22 sec)  
Records: 4  Duplicates: 0  Warnings: 0  
mysql> insert into tab\_with\_index  values(1,'4');  
Query OK, 1 row affected (0.00 sec)  
mysql> select \* from tab\_with\_index where id = 1;  
\+------+------+  
| id   | name |  
\+------+------+  
| 1    | 1    |  
| 1    | 4    |  
\+------+------+  
2 rows in set (0.00 sec)  
   InnoDB存储引擎使用相同索引键的阻塞例子

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70][]  
  
（3）当表有多个索引的时候，不同的事务可以使用不同的索引锁定不同的行，另外，不论是使用主键索引、唯一索引或普通索引，InnoDB都会使用行锁来对数据加锁。  
在如下表所示的例子中，表tab\_with\_index的 **id字段有主键索引，name字段有普通索引**：  
mysql> alter table tab\_with\_index add index name(name);  
Query OK, 5 rows affected (0.23 sec)  
Records: 5  Duplicates: 0  Warnings: 0  
 ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 2][]

即便在条件中使用了索引字段，但是否使用索引来检索数据是由MySQL通过判断不同执行计划的代价来决定的，如果MySQL认为全表扫描效率更高，比如对一些很小的表，它就不会使用索引，这种情况下InnoDB将使用表锁，而不是行锁。因此，在分析锁冲突时，别忘了检查SQL的执行计划，以确认是否真正使用了索引。

原文链接：https://blog.csdn.net/mysteryhaohao/article/details/51669741

22、Mysql索引总结：

[https://zhuanlan.zhihu.com/p/29118331][https_zhuanlan.zhihu.com_p_29118331]

23、Mysql的覆盖索引与回表：

[https://zhuanlan.zhihu.com/p/107125866][https_zhuanlan.zhihu.com_p_107125866]

[https://www.jianshu.com/p/d0d3de6832b9][https_www.jianshu.com_p_d0d3de6832b9]

24、聚簇索引与非聚簇索引（也叫二级索引）

[https://www.jianshu.com/p/fa8192853184][https_www.jianshu.com_p_fa8192853184]

25、mysql索引面试题

[https://zhuanlan.zhihu.com/p/277567026][https_zhuanlan.zhihu.com_p_277567026]

[https://zhuanlan.zhihu.com/p/340593296][https_zhuanlan.zhihu.com_p_340593296]

26、Mysql order by与limit混用陷阱

原因：当order by中的列具有相同的值时，每次查询到的顺序存在不一致的现象；

当使用explain执行计划的时候：

Using temporary表示由于排序没有走索引，因此创建了一个内部临时表。注意这里的临时表可能是内存上的临时表，也有可能是硬盘上的临时表。  
Using filesort表示没有使用索引排序，它并不意味着在硬盘上排序，filesort与文件无关。消除Using filesort的方法就是让查询sql的排序走索引。

数据库order by排序不唯一，会导致最终的数据排序是不是稳定的 ，  
建议在 order by 最后，增加 PK 列或 ROWID，rowid还能增加查询效率！

[https://blog.csdn.net/qiubabin/article/details/70135556][https_blog.csdn.net_qiubabin_article_details_70135556]

[https://blog.csdn.net/grant167/article/details/102883507][https_blog.csdn.net_grant167_article_details_102883507]

[https://www.jianshu.com/p/8c2154872f83][https_www.jianshu.com_p_8c2154872f83]

27、mysql查询的时候默认排序

[https://blog.csdn.net/a7442358/article/details/89138558][https_blog.csdn.net_a7442358_article_details_89138558]

[https://blog.csdn.net/changerzhuo\_319/article/details/85555526][https_blog.csdn.net_changerzhuo_319_article_details_85555526]

28、mysql索引失效场景：

[https://blog.csdn.net/wuseyukui/article/details/72312574][https_blog.csdn.net_wuseyukui_article_details_72312574]

29、mysql优化小建议：

[https://blog.csdn.net/u014421556/article/details/52063904][https_blog.csdn.net_u014421556_article_details_52063904]

30、一次mysql千万级数据量优化：

[https://blog.csdn.net/Tim\_phper/article/details/78344444][https_blog.csdn.net_Tim_phper_article_details_78344444]

31、B-tree和B+tree的理解：

[https://blog.csdn.net/v\_JULY\_v/article/details/6530142][https_blog.csdn.net_v_JULY_v_article_details_6530142]

[https://zhuanlan.zhihu.com/p/27700617][https_zhuanlan.zhihu.com_p_27700617]

[https://zhuanlan.zhihu.com/p/54102723][https_zhuanlan.zhihu.com_p_54102723]

32、sql执行解析顺序：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 3][]

[https://blog.csdn.net/u014044812/article/details/51004754][https_blog.csdn.net_u014044812_article_details_51004754]

33、mysql索引最左匹配原则的理解

[https://blog.csdn.net/u013164931/article/details/82386555][https_blog.csdn.net_u013164931_article_details_82386555]

34、【数据库基础】联合索引是什么？为什么要用它？用它时要注意什么？

[https://blog.csdn.net/nakiri\_arisu/article/details/79702461][https_blog.csdn.net_nakiri_arisu_article_details_79702461]

35、[开源数据同步神器——canal][canal]

[https://www.cnblogs.com/joylee/p/10248106.html][canal]

[https://zhuanlan.zhihu.com/p/96628405][https_zhuanlan.zhihu.com_p_96628405]

36、[Mysql-Limit 优化][Mysql-Limit]   百万级，千万级

[https://www.cnblogs.com/weixiaotao/p/10646666.html][Mysql-Limit]

37、Mysql 分页语句 Limit原理

[https://blog.csdn.net/helloxiaozhe/article/details/78106709][https_blog.csdn.net_helloxiaozhe_article_details_78106709]

38、LEFT JOIN关联表中ON,WHERE后面跟条件的区别

[https://blog.csdn.net/wqc19920906/article/details/79785424][https_blog.csdn.net_wqc19920906_article_details_79785424]

[https://www.runoob.com/w3cnote/sql-join-the-different-of-on-and-where.html][https_www.runoob.com_w3cnote_sql-join-the-different-of-on-and-where.html]

39、为什么mysql数据库字段要定义为NOT NULL

[https://blog.csdn.net/weixin\_42442847/article/details/81207505][https_blog.csdn.net_weixin_42442847_article_details_81207505]

[https://blog.csdn.net/g6U8W7p06dCO99fQ3/article/details/115586952][https_blog.csdn.net_g6U8W7p06dCO99fQ3_article_details_115586952]

40、数据库分库分表策略和分库分表后数据的查询

[https://blog.csdn.net/majunzhu/article/details/100163523][https_blog.csdn.net_majunzhu_article_details_100163523]

[https://blog.csdn.net/ahjxhy2010/article/details/50540500][https_blog.csdn.net_ahjxhy2010_article_details_50540500]

41、数据库连接池学习笔记（一）：原理介绍+常用连接池介绍：

[https://blog.csdn.net/CrankZ/article/details/82874158][https_blog.csdn.net_CrankZ_article_details_82874158]

42、mysql int 类型的长度值问题

[https://www.jianshu.com/p/febf5bd2bd37][https_www.jianshu.com_p_febf5bd2bd37]

[https://blog.csdn.net/allenjay11/article/details/76549503][https_blog.csdn.net_allenjay11_article_details_76549503]

43、【MySQL】20个经典面试题

[https://blog.csdn.net/u013252072/article/details/52912385][https_blog.csdn.net_u013252072_article_details_52912385]

44、mysql面试题整理（ThinkWon博客）

[https://blog.csdn.net/ThinkWon/article/details/104778621][https_blog.csdn.net_ThinkWon_article_details_104778621]

45、mysql  null 字段查询问题

[https://zhuanlan.zhihu.com/p/347002120][https_zhuanlan.zhihu.com_p_347002120]

[https://database.51cto.com/art/202012/638170.htm][https_database.51cto.com_art_202012_638170.htm]（同上）

46、MySQL字段 不推荐使用 Null 的理由

Mysql官方文档对于null字段的一个说明。

NULL columns require additional space in the rowto record whether their values are NULL. For MyISAM tables, each NULL columntakes one bit extra, rounded up to the nearest byte.

《高性能mysql第二版》中也提到，Mysql难以优化引用可空列查询，它会使索引、索引统计和值更加复杂。可空列需要更多的存储空间，还需要mysql内部进行特殊处理。可空列被索引后，每条记录都需要一个额外的字节，还能导致MYISAM中固定大小的索引变成可变大小的索引。

[https://blog.csdn.net/sinat\_14913533/article/details/104880869][https_blog.csdn.net_sinat_14913533_article_details_104880869]

47、MySQL如何有效的存储IP地址及字符串IP和数值之间如何转换

通常，在保存IPv4地址时，一个IPv4最小需要7个字符，最大需要15个字符，所以，使用VARCHAR(15)即可。MySQL在保存变长的字符串时，还需要额外的一个字节来保存此字符串的长度。而如果使用无符号整数来存储，只需要4个字节即可。另外还可以使用4个字段分别存储IPv4中的各部分，但是通常这不管是存储空间和查询效率应该都不是很高（可能有的场景适合使用这种方式存储）。

[https://blog.csdn.net/mhmyqn/article/details/48653157][https_blog.csdn.net_mhmyqn_article_details_48653157]

48、为什么MySQL设计主键时key不能过长？

[https://www.jianshu.com/p/31bfd4ac3e61][https_www.jianshu.com_p_31bfd4ac3e61]

49、MySQL的复制原理以及流程

[https://www.jianshu.com/p/63c1a1babfd1][https_www.jianshu.com_p_63c1a1babfd1]

50、MySQL中myisam与innodb的区别

[https://www.jianshu.com/p/beea4f812b59][https_www.jianshu.com_p_beea4f812b59]

51、innodb的事务与日志的实现方式

redo log  undo log  binlog

[https://zhuanlan.zhihu.com/p/190886874][https_zhuanlan.zhihu.com_p_190886874]

[https://cloud.tencent.com/developer/article/1801920][https_cloud.tencent.com_developer_article_1801920]

52、MySQL数据库cpu飙升到500%的话他怎么处理？

[https://blog.csdn.net/lxw1844912514/article/details/105298019][https_blog.csdn.net_lxw1844912514_article_details_105298019]

[https://www.jianshu.com/p/b5356317beaf][https_www.jianshu.com_p_b5356317beaf]

53、sql中的or，哪些场景会导致全表扫描

建议 用  union  all   替代  or

[https://blog.csdn.net/Knight\_hf/article/details/52629758][https_blog.csdn.net_Knight_hf_article_details_52629758]

[https://cloud.tencent.com/developer/article/1082236][https_cloud.tencent.com_developer_article_1082236]

[https://www.cnblogs.com/shipengzhi/archive/2012/09/20/2695825.html][https_www.cnblogs.com_shipengzhi_archive_2012_09_20_2695825.html]（这个有另外说法）

[MySQL]: https://www.cnblogs.com/jpfss/p/8890250.html
[https_blog.csdn.net_mysteryhaohao_article_details_51669741]: https://blog.csdn.net/mysteryhaohao/article/details/51669741
[MySQL_ explain]: https://segmentfault.com/a/1190000021458117
[https_zhuanlan.zhihu.com_p_143866444]: https://zhuanlan.zhihu.com/p/143866444
[https_www.jianshu.com_p_2b258bfe00e5]: https://www.jianshu.com/p/2b258bfe00e5
[https_juejin.cn_post_6950979697400348686]: https://juejin.cn/post/6950979697400348686
[MySQL 1]: https://www.cnblogs.com/huanongying/p/7021555.html
[https_developer.aliyun.com_article_743691]: https://developer.aliyun.com/article/743691
[https_www.jianshu.com_p_c6290e65d8b5]: https://www.jianshu.com/p/c6290e65d8b5
[MySQL 2]: http://blog.codinglabs.org/articles/theory-of-mysql-index.html
[Innodb]: https://tech.meituan.com/2014/08/20/innodb-lock.html
[MySQL 3]: https://tech.meituan.com/2014/06/30/mysql-index.html
[MyBatis]: https://segmentfault.com/a/1190000022478915
[https_mp.weixin.qq.com_s_biz_MjM5ODYxMDA5OQ_mid_2651959442_idx_1_sn_feb8ff75385d8031386e120ef3535329_scene_21_wechat_redirect]: https://mp.weixin.qq.com/s?__biz=MjM5ODYxMDA5OQ==&mid=2651959442&idx=1&sn=feb8ff75385d8031386e120ef3535329&scene=21#wechat_redirect
[https_blog.csdn.net_starlh35_article_details_78735510]: https://blog.csdn.net/starlh35/article/details/78735510
[https_blog.csdn.net_helloxiaozhe_article_details_79548186]: https://blog.csdn.net/helloxiaozhe/article/details/79548186
[https_blog.csdn.net_qq_15092079_article_details_81672920]: https://blog.csdn.net/qq_15092079/article/details/81672920
[https_www.cnblogs.com_dadonggg_p_8617826.html]: https://www.cnblogs.com/dadonggg/p/8617826.html
[https_mp.weixin.qq.com_s_3ZxGq9ZpgdjQFeD2BIJ1MA]: https://mp.weixin.qq.com/s/3ZxGq9ZpgdjQFeD2BIJ1MA
[https_www.jianshu.com_p_ee4071d0c951]: https://www.jianshu.com/p/ee4071d0c951
[https_juejin.cn_post_6844903878098436103]: https://juejin.cn/post/6844903878098436103
[https_blog.csdn.net_u014087208_article_details_108511340]: https://blog.csdn.net/u014087208/article/details/108511340
[https_blog.csdn.net_hosaos_article_details_89136666]: https://blog.csdn.net/hosaos/article/details/89136666
[https_blog.csdn.net_weixin_43314519_article_details_109823130]: https://blog.csdn.net/weixin_43314519/article/details/109823130
[https_zhuanlan.zhihu.com_p_301031380]: https://zhuanlan.zhihu.com/p/301031380
[https_shardingsphere.apache.org_document_current_cn_overview]: https://shardingsphere.apache.org/document/current/cn/overview/
[Link 1]: https://tech.meituan.com/2016/11/18/dianping-order-db-sharding.html
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/ac5097175e304f40a11acbea4f7be5f1.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20221022/6db13b63bc9044eca115562fe384ca16.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/20210830205042575.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20221022/9e73a03371a44cc2b5dc2d9c8242aad4.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20221022/7523f459ace74a0294190536b4b4d9d8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20221022/1eec2b1169ec450eb893c5035630a11c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20221022/9c614e47a6fd4f7290bc4e8ff3b3fd87.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5bCP5ZOl6aqR5Y2V6L2m_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20221022/9e31bff9cc294b28bf1b1a7389a817aa.png
[https_www.bilibili.com_video_BV1hL411479T_from_search_seid_6172954146791149151]: https://www.bilibili.com/video/BV1hL411479T?from=search&seid=6172954146791149151
[https_blog.csdn.net_SnailMann_article_details_94724197]: https://blog.csdn.net/SnailMann/article/details/94724197
[https_cloud.tencent.com_developer_article_1863151]: https://cloud.tencent.com/developer/article/1863151
[https_www.php.cn_mysql-tutorials-460111.html]: https://www.php.cn/mysql-tutorials-460111.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70]: /images/20221022/33fc0eeba08847a3859c743c6855dd48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 1]: /images/20221022/c40ba5c0f5074936924b436943858620.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 2]: /images/20221022/960ae4429b7e4726a82736b754a12dc3.png
[https_zhuanlan.zhihu.com_p_29118331]: https://zhuanlan.zhihu.com/p/29118331
[https_zhuanlan.zhihu.com_p_107125866]: https://zhuanlan.zhihu.com/p/107125866
[https_www.jianshu.com_p_d0d3de6832b9]: https://www.jianshu.com/p/d0d3de6832b9
[https_www.jianshu.com_p_fa8192853184]: https://www.jianshu.com/p/fa8192853184
[https_zhuanlan.zhihu.com_p_277567026]: https://zhuanlan.zhihu.com/p/277567026
[https_zhuanlan.zhihu.com_p_340593296]: https://zhuanlan.zhihu.com/p/340593296
[https_blog.csdn.net_qiubabin_article_details_70135556]: https://blog.csdn.net/qiubabin/article/details/70135556
[https_blog.csdn.net_grant167_article_details_102883507]: https://blog.csdn.net/grant167/article/details/102883507
[https_www.jianshu.com_p_8c2154872f83]: https://www.jianshu.com/p/8c2154872f83
[https_blog.csdn.net_a7442358_article_details_89138558]: https://blog.csdn.net/a7442358/article/details/89138558
[https_blog.csdn.net_changerzhuo_319_article_details_85555526]: https://blog.csdn.net/changerzhuo_319/article/details/85555526
[https_blog.csdn.net_wuseyukui_article_details_72312574]: https://blog.csdn.net/wuseyukui/article/details/72312574
[https_blog.csdn.net_u014421556_article_details_52063904]: https://blog.csdn.net/u014421556/article/details/52063904
[https_blog.csdn.net_Tim_phper_article_details_78344444]: https://blog.csdn.net/Tim_phper/article/details/78344444
[https_blog.csdn.net_v_JULY_v_article_details_6530142]: https://blog.csdn.net/v_JULY_v/article/details/6530142
[https_zhuanlan.zhihu.com_p_27700617]: https://zhuanlan.zhihu.com/p/27700617
[https_zhuanlan.zhihu.com_p_54102723]: https://zhuanlan.zhihu.com/p/54102723
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 3]: /images/20221022/f745c4e9ae0443549e00dc49f8ab121e.png
[https_blog.csdn.net_u014044812_article_details_51004754]: https://blog.csdn.net/u014044812/article/details/51004754
[https_blog.csdn.net_u013164931_article_details_82386555]: https://blog.csdn.net/u013164931/article/details/82386555
[https_blog.csdn.net_nakiri_arisu_article_details_79702461]: https://blog.csdn.net/nakiri_arisu/article/details/79702461
[canal]: https://www.cnblogs.com/joylee/p/10248106.html
[https_zhuanlan.zhihu.com_p_96628405]: https://zhuanlan.zhihu.com/p/96628405
[Mysql-Limit]: https://www.cnblogs.com/weixiaotao/p/10646666.html
[https_blog.csdn.net_helloxiaozhe_article_details_78106709]: https://blog.csdn.net/helloxiaozhe/article/details/78106709
[https_blog.csdn.net_wqc19920906_article_details_79785424]: https://blog.csdn.net/wqc19920906/article/details/79785424
[https_www.runoob.com_w3cnote_sql-join-the-different-of-on-and-where.html]: https://www.runoob.com/w3cnote/sql-join-the-different-of-on-and-where.html
[https_blog.csdn.net_weixin_42442847_article_details_81207505]: https://blog.csdn.net/weixin_42442847/article/details/81207505
[https_blog.csdn.net_g6U8W7p06dCO99fQ3_article_details_115586952]: https://blog.csdn.net/g6U8W7p06dCO99fQ3/article/details/115586952
[https_blog.csdn.net_majunzhu_article_details_100163523]: https://blog.csdn.net/majunzhu/article/details/100163523
[https_blog.csdn.net_ahjxhy2010_article_details_50540500]: https://blog.csdn.net/ahjxhy2010/article/details/50540500
[https_blog.csdn.net_CrankZ_article_details_82874158]: https://blog.csdn.net/CrankZ/article/details/82874158
[https_www.jianshu.com_p_febf5bd2bd37]: https://www.jianshu.com/p/febf5bd2bd37
[https_blog.csdn.net_allenjay11_article_details_76549503]: https://blog.csdn.net/allenjay11/article/details/76549503
[https_blog.csdn.net_u013252072_article_details_52912385]: https://blog.csdn.net/u013252072/article/details/52912385
[https_blog.csdn.net_ThinkWon_article_details_104778621]: https://blog.csdn.net/ThinkWon/article/details/104778621
[https_zhuanlan.zhihu.com_p_347002120]: https://zhuanlan.zhihu.com/p/347002120
[https_database.51cto.com_art_202012_638170.htm]: https://database.51cto.com/art/202012/638170.htm
[https_blog.csdn.net_sinat_14913533_article_details_104880869]: https://blog.csdn.net/sinat_14913533/article/details/104880869
[https_blog.csdn.net_mhmyqn_article_details_48653157]: https://blog.csdn.net/mhmyqn/article/details/48653157
[https_www.jianshu.com_p_31bfd4ac3e61]: https://www.jianshu.com/p/31bfd4ac3e61
[https_www.jianshu.com_p_63c1a1babfd1]: https://www.jianshu.com/p/63c1a1babfd1
[https_www.jianshu.com_p_beea4f812b59]: https://www.jianshu.com/p/beea4f812b59
[https_zhuanlan.zhihu.com_p_190886874]: https://zhuanlan.zhihu.com/p/190886874
[https_cloud.tencent.com_developer_article_1801920]: https://cloud.tencent.com/developer/article/1801920
[https_blog.csdn.net_lxw1844912514_article_details_105298019]: https://blog.csdn.net/lxw1844912514/article/details/105298019
[https_www.jianshu.com_p_b5356317beaf]: https://www.jianshu.com/p/b5356317beaf
[https_blog.csdn.net_Knight_hf_article_details_52629758]: https://blog.csdn.net/Knight_hf/article/details/52629758
[https_cloud.tencent.com_developer_article_1082236]: https://cloud.tencent.com/developer/article/1082236
[https_www.cnblogs.com_shipengzhi_archive_2012_09_20_2695825.html]: https://www.cnblogs.com/shipengzhi/archive/2012/09/20/2695825.html