Database on Leanku 的博客

MySQL 中主要的日志类型

Mon, 13 Oct 2025 20:30:01 +0800

MySQL 中主要的日志类型

MySQL 提供了多种日志类型，每种都有其特定的目的和格式。理解这些日志对于数据库管理、性能调优、数据恢复和故障排查至关重要。

下面我将详细介绍 MySQL 中主要的日志类型及其格式

总结概览

日志类型	主要目的	格式	是否默认开启
错误日志	记录 MySQL 启动、运行、停止时的错误、警告和提示信息。	文本格式	是
二进制日志	记录所有更改数据的语句，用于主从复制和数据恢复。	`STATEMENT`, `ROW`, `MIXED`	否 (8.0默认开启)
通用查询日志	记录所有到达 MySQL 的客户端连接和执行的语句。	文本格式 / CSV 格式	否
慢查询日志	记录执行时间超过指定阈值的查询，用于性能优化。	文本格式 / CSV 格式	否
重做日志	InnoDB 特有的，用于保证事务的持久性和崩溃恢复。	物理格式（二进制）	是
回滚日志	InnoDB 特有的，用于保证事务的原子性和 MVCC。	逻辑格式	是

详细解析

1. 错误日志

这是 DBA 首先需要查看的日志，当数据库出现任何异常时，它通常是排查问题的起点。

内容：启动/关闭信息、错误信息、警告信息、在复制环境中从服务器线程的启动信息等。
格式：纯文本格式，易于阅读。
配置参数：
- log_error：指定错误日志文件的位置。

示例内容：

12023-10-27T08:00:00.000000Z 0 \[Note\] Server started.
22023-10-27T08:01:23.456789Z 5 \[Warning\] Aborted connection 5 to db: 'test' user: 'root' host: 'localhost'

2. 二进制日志

这是最重要的日志之一，它记录了所有对数据库进行更改的 DDL 和 DML 语句（如 CREATE, ALTER, INSERT, UPDATE, DELETE），但不包括 SELECT 和 SHOW 这类不修改数据的操作。

Mysql窗口函数

Thu, 20 Feb 2025 20:46:01 +0800

Mysql窗口函数

一、什么是窗口函数？

窗口函数是一种在查询结果的"窗口"上执行计算的函数，它不会像常规聚合函数那样将多行合并为一行，而是为每一行返回一个值，同时保持原始行数不变。

基本语法

1<窗口函数>(<参数>) OVER (
2[PARTITION BY <分区表达式>]
3[ORDER BY <排序表达式> [ASC | DESC]]
4[ROWS/RANGE <窗口范围>]
5)

‌<窗口函数>‌：可以是聚合函数（如SUM、AVG）或专用函数（如ROW_NUMBER、RANK）。‌‌
‌OVER()‌：必需子句，定义窗口框架。‌‌
‌PARTITION BY‌：可选，用于分组数据；若省略，窗口覆盖整个结果集。
‌ORDER BY‌：可选，指定窗口内行的排序顺序。‌‌
‌窗口范围‌：可选，默认ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。‌‌

二、准备测试数据

 1-- 创建销售数据表
 2CREATE TABLE sales (
 3 sale_id INT PRIMARY KEY,
 4 salesperson VARCHAR(50),
 5 region VARCHAR(50),
 6 sale_date DATE,
 7 amount DECIMAL(10,2)
 8);
 9
10INSERT INTO sales VALUES
11(1, '张三', '北京', '2023-01-15', 5000),
12(2, '李四', '上海', '2023-01-16', 8000),
13(3, '王五', '北京', '2023-01-17', 6000),
14(4, '张三', '北京', '2023-02-01', 7000),
15(5, '李四', '上海', '2023-02-02', 9000),
16(6, '赵六', '广州', '2023-02-03', 4000),
17(7, '王五', '北京', '2023-02-04', 5500),
18(8, '张三', '北京', '2023-03-01', 8500);
19
20-- 创建员工薪资表
21CREATE TABLE employee_salary (
22 emp_id INT,
23 name VARCHAR(50),
24 department VARCHAR(50),
25 salary DECIMAL(10,2),
26 hire_date DATE
27);
28
29INSERT INTO employee_salary VALUES
30(1, '张三', '技术部', 15000, '2020-01-15'),
31(2, '李四', '技术部', 12000, '2021-03-20'),
32(3, '王五', '销售部', 8000, '2022-06-10'),
33(4, '赵六', '销售部', 7500, '2022-08-05'),
34(5, '钱七', '技术部', 13000, '2020-11-30'),
35(6, '孙八', '人事部', 9000, '2021-09-15'),
36(7, '周九', '技术部', 16000, '2019-05-20');

1. 排名函数

ROW_NUMBER()

1SELECT 
2 salesperson,
3 region,
4 amount,
5 ROW_NUMBER() OVER (PARTITION BY region ORDER BY amount DESC) as row_num
6FROM sales;

结果：为每个地区的销售按金额降序分配唯一序号

MyCat实现Mysql分库分表

Tue, 18 Feb 2025 20:33:45 +0800

Mysql分库分表和主从复制

MyCat 实现分库分表

MySQL 的分库分表解决方案通常依赖于中间件来实现水平扩展。常见的中间件有以下几种

MyCat
ShardingSphere
TDDL (Taobao Distributed Data Layer)
Cobar
Vitess

MyCat 是一款开源的数据库中间件，支持 MySQL 数据库的分库分表功能。

使用 MyCat 实现分库分表的过程包括多个步骤，涉及配置 MyCat 和数据库的分片策略，路由规则等。下面通过一个实际案例来详细解释 MyCat 的实现原理、方式和步骤。

案例背景

假设你有一个电商系统，包含一个 orders 表，记录用户的订单信息。随着数据量的增长，单一数据库难以满足性能需求，因此需要进行分库分表。

实现原理

MyCat 是一种数据库中间件，支持分库分表。它的原理是通过代理 MySQL 连接，将 SQL 请求转发到实际的数据库实例上。MyCat 会根据预定义的路由规则（如分片策略）来决定将查询请求路由到哪个数据库或表。

MyCat 的 分库分表原理如下：

分库：将数据按照某种规则分配到多个数据库实例中。例如，按用户的 ID 来分库。

分表：将一个大表拆分成多个小表，避免单表的数据过大导致查询性能下降。例如，可以按时间范围或数据量来分表。

实现方式

MyCat 的实现方式主要通过配置分片规则来实现分库分表。配置内容包括：

数据源配置：定义数据库实例。
分片规则配置：指定哪些字段用于分片，如何分片（按范围、按哈希等）。
路由规则配置：根据 SQL 查询的条件来路由请求到不同的数据库或表。

实现步骤

安装并启动 MyCat
1. 下载 MyCat 安装包并解压。
2. 配置 MyCat 启动脚本，启动 MyCat。
```
1cd MyCat
2./bin/start.sh
```
配置数据源在 MyCat 的配置文件 conf/context.xml 中，定义数据源。假设我们有两个 MySQL 实例 db1 和 db2，分别存储不同的 orders 表。

Mysql 简易安装

Sat, 11 May 2024 13:46:01 +0800

Mysql 简易安装

安装Mysql8.0(centos8为例)，可参考 MySQL官方文档

 1# CentOS el8下载 MySQL YUM 仓库（替换为最新版本）
 2wget https://dev.mysql.com/get/mysql80-community-release-el8-6.noarch.rpm 
 3# el9 使用sudo yum install mysql84-community-release-el9-x86_64.noarch.rpm
 4sudo rpm -Uvh mysql80-community-release-el*.rpm
 5sudo yum makecache
 6# 安装 MySQL 社区版服务器
 7# el9 的话sudo yum install mysql84-community-release-el9-x86_64.noarch.rpm
 8
 9sudo yum install -y mysql-community-server
10# 可以通过手动编辑/etc/yum.repos.d/mysql-community.repo文件来选择发布系列。
11# **install时如果出现GPG 密钥问题**
12# sudo curl -o /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql-2023 https://repo.mysql.com/RPM-GPG-KEY-mysql-2023
13# sudo chmod 644 /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql-2023
14# sudo rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql-2023
15# 重新执行 yum install -y mysql-community-server
16
17# 启动 MySQL 服务
18sudo systemctl start mysqld
19sudo systemctl enable mysqld
20sudo systemctl status mysqld
21
22#MySQL 首次启动会生成一个临时 root 密码：
23sudo grep 'temporary password' /var/log/mysqld.log
24
25# 运行安全配置向导：
26#按提示操作：1.输入临时密码。2.置新密码（需符合复杂度要求）。3.移除匿名用户、禁止远程 root 登录、删除测试数据库等。
27sudo mysql_secure_installation
28mysql -u root -p

简单配置

MySQL分库分表（无中间件）

Tue, 23 Apr 2024 20:46:01 +0800

MySQL分库分表（无中间件）

一、分库分表方案设计

1. 垂直拆分 (按业务模块)

 1-- 原始单体数据库
 2CREATE DATABASE ecommerce;
 3USE ecommerce;
 4
 5-- 垂直拆分后的数据库
 6-- 用户库
 7CREATE DATABASE user_center;
 8USE user_center;
 9
10CREATE TABLE users (
11 user_id BIGINT PRIMARY KEY,
12 username VARCHAR(50) UNIQUE,
13 email VARCHAR(100) UNIQUE,
14 password VARCHAR(100),
15 mobile VARCHAR(20),
16 status TINYINT DEFAULT 1,
17 created_at DATETIME,
18 updated_at DATETIME
19);
20
21CREATE TABLE user_profiles (
22 user_id BIGINT PRIMARY KEY,
23 real_name VARCHAR(50),
24 avatar VARCHAR(200),
25 gender TINYINT,
26 birthday DATE,
27 bio TEXT
28);
29
30CREATE TABLE user_address (
31 address_id BIGINT PRIMARY KEY,
32 user_id BIGINT,
33 province VARCHAR(50),
34 city VARCHAR(50),
35 district VARCHAR(50),
36 detail VARCHAR(200),
37 is_default TINYINT DEFAULT 0,
38 INDEX idx_user_id (user_id)
39);
40
41-- 订单库
42CREATE DATABASE order_center;
43USE order_center;
44
45CREATE TABLE orders (
46 order_id BIGINT PRIMARY KEY,
47 user_id BIGINT,
48 total_amount DECIMAL(10,2),
49 status TINYINT,
50 payment_status TINYINT,
51 created_at DATETIME,
52 paid_at DATETIME
53);
54
55CREATE TABLE order_items (
56 item_id BIGINT PRIMARY KEY,
57 order_id BIGINT,
58 product_id BIGINT,
59 product_name VARCHAR(100),
60 price DECIMAL(10,2),
61 quantity INT,
62 INDEX idx_order_id (order_id)
63);
64
65-- 商品库
66CREATE DATABASE product_center;
67USE product_center;
68
69CREATE TABLE products (
70 product_id BIGINT PRIMARY KEY,
71 name VARCHAR(100),
72 category_id INT,
73 price DECIMAL(10,2),
74 stock INT,
75 status TINYINT,
76 created_at DATETIME
77);
78
79CREATE TABLE categories (
80 category_id INT PRIMARY KEY,
81 name VARCHAR(50),
82 parent_id INT
83);

2. 水平拆分（按数据量）

用户表水平分表（10个分表）

 1-- 在 user_center 数据库中创建分表
 2USE user_center;
 3
 4-- 下面语句中的//为分隔符
 5DELIMITER //
 6CREATE PROCEDURE CreateUserShards()
 7BEGIN
 8 DECLARE i INT DEFAULT 0;
 9 WHILE i < 10 DO
10 SET @sql = CONCAT('
11 CREATE TABLE users_', i, ' (
12 user_id BIGINT PRIMARY KEY,
13 username VARCHAR(50) NOT NULL,
14 email VARCHAR(100),
15 password VARCHAR(100),
16 mobile VARCHAR(20),
17 status TINYINT DEFAULT 1,
18 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
19 updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
20 UNIQUE KEY uk_username_', i, ' (username),
21 UNIQUE KEY uk_email_', i, ' (email),
22 INDEX idx_mobile_', i, ' (mobile),
23 INDEX idx_created_', i, ' (created_at)
24 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
25 ');
26 PREPARE stmt FROM @sql;
27 EXECUTE stmt;
28 DEALLOCATE PREPARE stmt;
29 SET i = i + 1;
30 END WHILE;
31END//
32DELIMITER ;
33
34CALL CreateUserShards();

订单表水平分表（按用户ID分表）

 1USE order_center;
 2
 3DELIMITER //
 4CREATE PROCEDURE CreateOrderShards()
 5BEGIN
 6 DECLARE i INT DEFAULT 0;
 7 WHILE i < 10 DO
 8 SET @sql = CONCAT('
 9 CREATE TABLE orders_', i, ' (
10 order_id BIGINT PRIMARY KEY,
11 user_id BIGINT NOT NULL,
12 total_amount DECIMAL(10,2),
13 status TINYINT DEFAULT 1,
14 payment_status TINYINT DEFAULT 0,
15 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
16 paid_at DATETIME,
17 INDEX idx_user_id_', i, ' (user_id),
18 INDEX idx_created_', i, ' (created_at),
19 INDEX idx_status_', i, ' (status)
20 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
21 ');
22 PREPARE stmt FROM @sql;
23 EXECUTE stmt;
24 DEALLOCATE PREPARE stmt;
25 
26 -- 创建对应的订单项分表
27 SET @sql = CONCAT('
28 CREATE TABLE order_items_', i, ' (
29 item_id BIGINT PRIMARY KEY,
30 order_id BIGINT NOT NULL,
31 product_id BIGINT,
32 product_name VARCHAR(100),
33 price DECIMAL(10,2),
34 quantity INT,
35 INDEX idx_order_id_', i, ' (order_id),
36 INDEX idx_product_id_', i, ' (product_id)
37 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
38 ');
39 PREPARE stmt FROM @sql;
40 EXECUTE stmt;
41 DEALLOCATE PREPARE stmt;
42 
43 SET i = i + 1;
44 END WHILE;
45END//
46DELIMITER ;
47
48CALL CreateOrderShards();

二、程序中处理（PHP）

1. 基础配置类

 1<?php
 2// Config.php
 3class Config {
 4 private static $instance;
 5 private $config;
 6 
 7 private function __construct() {
 8 $this->config = [
 9 'databases' => [
10 'user_center' => [
11 'host' => 'localhost',
12 'port' => 3306,
13 'username' => 'root',
14 'password' => 'password',
15 'dbname' => 'user_center'
16 ],
17 'order_center' => [
18 'host' => 'localhost',
19 'port' => 3306,
20 'username' => 'root',
21 'password' => 'password',
22 'dbname' => 'order_center'
23 ],
24 'product_center' => [
25 'host' => 'localhost',
26 'port' => 3306,
27 'username' => 'root',
28 'password' => 'password',
29 'dbname' => 'product_center'
30 ]
31 ],
32 'shard' => [
33 'user' => 10, // 用户表10个分片
34 'order' => 10 // 订单表10个分片
35 ]
36 ];
37 }
38 
39 public static function getInstance() {
40 if (!self::$instance) {
41 self::$instance = new self();
42 }
43 return self::$instance;
44 }
45 
46 public function get($key) {
47 $keys = explode('.', $key);
48 $value = $this->config;
49 
50 foreach ($keys as $k) {
51 if (!isset($value[$k])) {
52 return null;
53 }
54 $value = $value[$k];
55 }
56 
57 return $value;
58 }
59}

2. 分片路由类

 1<?php
 2// ShardRouter.php
 3class ShardRouter {
 4 private $shardConfig;
 5 
 6 public function __construct() {
 7 $config = Config::getInstance();
 8 $this->shardConfig = $config->get('shard');
 9 }
10 
11 /**
12 * 根据用户ID计算分片
13 */
14 public function getUserShard($userId) {
15 return $userId % $this->shardConfig['user'];
16 }
17 
18 /**
19 * 根据订单ID计算分片（订单按用户ID分片）
20 */
21 public function getOrderShard($orderId) {
22 // 假设订单ID包含用户ID信息
23 $userId = $this->extractUserIdFromOrderId($orderId);
24 return $userId % $this->shardConfig['order'];
25 }
26 
27 /**
28 * 根据用户名计算分片（用于登录查询）
29 */
30 public function getShardByString($str, $type = 'user') {
31 $shardCount = $this->shardConfig[$type];
32 return crc32($str) % $shardCount;
33 }
34 
35 /**
36 * 生成分布式ID（雪花算法）
37 */
38 public function generateId($shardId = 0, $timestamp = null) {
39 $timestamp = $timestamp ?? (int)(microtime(true) * 1000);
40 $workerId = $shardId % 1024;
41 $sequence = mt_rand(0, 4095);
42 
43 return (($timestamp - 1577836800000) << 22) 
44 | ($workerId << 12) 
45 | $sequence;
46 }
47 
48 /**
49 * 从订单ID提取用户ID（根据业务规则）
50 */
51 private function extractUserIdFromOrderId($orderId) {
52 // 实际业务中需要根据ID生成规则来解析
53 // 这里简单返回订单ID的低位部分作为用户ID
54 return $orderId & 0x3FFFFFFF;
55 }
56 
57 /**
58 * 获取表名
59 */
60 public function getTableName($baseTable, $shardId) {
61 return $baseTable . '_' . $shardId;
62 }
63}

3. 数据库连接管理

 1<?php
 2// DatabaseManager.php
 3class DatabaseManager {
 4 private static $instance;
 5 private $connections = [];
 6 private $config;
 7 
 8 private function __construct() {
 9 $this->config = Config::getInstance();
10 }
11 
12 public static function getInstance() {
13 if (!self::$instance) {
14 self::$instance = new self();
15 }
16 return self::$instance;
17 }
18 
19 /**
20 * 获取数据库连接
21 */
22 public function getConnection($database, $shardId = null) {
23 $key = $database . ($shardId !== null ? '_' . $shardId : '');
24 
25 if (!isset($this->connections[$key])) {
26 $dbConfig = $this->config->get("databases.{$database}");
27 
28 if (!$dbConfig) {
29 throw new Exception("Database config not found: {$database}");
30 }
31 
32 try {
33 $dsn = "mysql:host={$dbConfig['host']};port={$dbConfig['port']};dbname={$dbConfig['dbname']};charset=utf8mb4";
34 
35 $this->connections[$key] = new PDO(
36 $dsn,
37 $dbConfig['username'],
38 $dbConfig['password'],
39 [
40 PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
41 PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
42 PDO::ATTR_EMULATE_PREPARES => false,
43 PDO::ATTR_PERSISTENT => false
44 ]
45 );
46 } catch (PDOException $e) {
47 throw new Exception("Database connection failed: " . $e->getMessage());
48 }
49 }
50 
51 return $this->connections[$key];
52 }
53 
54 /**
55 * 开始事务（单分片事务）
56 */
57 public function beginTransaction($database, $shardId = null) {
58 $connection = $this->getConnection($database, $shardId);
59 return $connection->beginTransaction();
60 }
61 
62 /**
63 * 提交事务
64 */
65 public function commit($database, $shardId = null) {
66 $connection = $this->getConnection($database, $shardId);
67 return $connection->commit();
68 }
69 
70 /**
71 * 回滚事务
72 */
73 public function rollback($database, $shardId = null) {
74 $connection = $this->getConnection($database, $shardId);
75 return $connection->rollback();
76 }
77}

4. 用户服务类示例（完整CRUD）

 1<?php
 2// UserService.php
 3class UserService {
 4 private $db;
 5 private $router;
 6 
 7 public function __construct() {
 8 $this->db = DatabaseManager::getInstance();
 9 $this->router = new ShardRouter();
 10 }
 11 
 12 /**
 13 * 创建用户（写入操作）
 14 */
 15 public function createUser($userData) {
 16 // 生成用户ID
 17 $userId = $this->router->generateId();
 18 $shardId = $this->router->getUserShard($userId);
 19 
 20 $tableName = $this->router->getTableName('users', $shardId);
 21 $connection = $this->db->getConnection('user_center', $shardId);
 22 
 23 try {
 24 // 开始事务
 25 $this->db->beginTransaction('user_center', $shardId);
 26 
 27 // 插入用户基础信息
 28 $sql = "INSERT INTO {$tableName} 
 29 (user_id, username, email, password, mobile, created_at) 
 30 VALUES (?, ?, ?, ?, ?, NOW())";
 31 
 32 $stmt = $connection->prepare($sql);
 33 $stmt->execute([
 34 $userId,
 35 $userData['username'],
 36 $userData['email'],
 37 password_hash($userData['password'], PASSWORD_DEFAULT),
 38 $userData['mobile'] ?? null
 39 ]);
 40 
 41 // 插入用户档案（垂直分库，但在同一个事务中）
 42 $this->createUserProfile($userId, $userData);
 43 
 44 // 提交事务
 45 $this->db->commit('user_center', $shardId);
 46 
 47 return $userId;
 48 
 49 } catch (Exception $e) {
 50 $this->db->rollback('user_center', $shardId);
 51 throw new Exception("创建用户失败: " . $e->getMessage());
 52 }
 53 }
 54 
 55 /**
 56 * 更新用户信息
 57 */
 58 public function updateUser($userId, $updateData) {
 59 $shardId = $this->router->getUserShard($userId);
 60 $tableName = $this->router->getTableName('users', $shardId);
 61 $connection = $this->db->getConnection('user_center', $shardId);
 62 
 63 $allowedFields = ['email', 'mobile', 'password'];
 64 $setParts = [];
 65 $params = [];
 66 
 67 foreach ($updateData as $field => $value) {
 68 if (in_array($field, $allowedFields)) {
 69 if ($field === 'password') {
 70 $value = password_hash($value, PASSWORD_DEFAULT);
 71 }
 72 $setParts[] = "{$field} = ?";
 73 $params[] = $value;
 74 }
 75 }
 76 
 77 if (empty($setParts)) {
 78 throw new Exception("没有有效的更新字段");
 79 }
 80 
 81 $params[] = $userId;
 82 
 83 $sql = "UPDATE {$tableName} SET " . implode(', ', $setParts) . " WHERE user_id = ?";
 84 $stmt = $connection->prepare($sql);
 85 
 86 return $stmt->execute($params);
 87 }
 88 
 89 /**
 90 * 根据用户ID查询（精确查询）
 91 */
 92 public function getUserById($userId) {
 93 $shardId = $this->router->getUserShard($userId);
 94 $tableName = $this->router->getTableName('users', $shardId);
 95 $connection = $this->db->getConnection('user_center', $shardId);
 96 
 97 $sql = "SELECT * FROM {$tableName} WHERE user_id = ?";
 98 $stmt = $connection->prepare($sql);
 99 $stmt->execute([$userId]);
100 
101 $user = $stmt->fetch();
102 if ($user) {
103 $user['profile'] = $this->getUserProfile($userId);
104 $user['addresses'] = $this->getUserAddresses($userId);
105 }
106 
107 return $user;
108 }
109 
110 /**
111 * 根据用户名查询（需要计算分片）
112 */
113 public function getUserByUsername($username) {
114 $shardId = $this->router->getShardByString($username, 'user');
115 $tableName = $this->router->getTableName('users', $shardId);
116 $connection = $this->db->getConnection('user_center', $shardId);
117 
118 $sql = "SELECT * FROM {$tableName} WHERE username = ?";
119 $stmt = $connection->prepare($sql);
120 $stmt->execute([$username]);
121 
122 return $stmt->fetch();
123 }
124 
125 /**
126 * 批量查询用户信息
127 */
128 public function getUsersByIds($userIds) {
129 $usersByShard = [];
130 
131 // 按分片分组用户ID
132 foreach ($userIds as $userId) {
133 $shardId = $this->router->getUserShard($userId);
134 $usersByShard[$shardId][] = $userId;
135 }
136 
137 $results = [];
138 foreach ($usersByShard as $shardId => $shardUserIds) {
139 $tableName = $this->router->getTableName('users', $shardId);
140 $connection = $this->db->getConnection('user_center', $shardId);
141 
142 $placeholders = str_repeat('?,', count($shardUserIds) - 1) . '?';
143 $sql = "SELECT * FROM {$tableName} WHERE user_id IN ({$placeholders})";
144 
145 $stmt = $connection->prepare($sql);
146 $stmt->execute($shardUserIds);
147 
148 $results = array_merge($results, $stmt->fetchAll());
149 }
150 
151 return $results;
152 }
153 
154 /**
155 * 复杂查询：按条件搜索用户（需要遍历分片）
156 */
157 public function searchUsers($conditions, $page = 1, $pageSize = 20) {
158 $allUsers = [];
159 $shardCount = Config::getInstance()->get('shard.user');
160 
161 for ($shardId = 0; $shardId < $shardCount; $shardId++) {
162 $tableName = $this->router->getTableName('users', $shardId);
163 $connection = $this->db->getConnection('user_center', $shardId);
164 
165 $where = [];
166 $params = [];
167 
168 if (!empty($conditions['username'])) {
169 $where[] = "username LIKE ?";
170 $params[] = $conditions['username'] . '%';
171 }
172 
173 if (!empty($conditions['email'])) {
174 $where[] = "email LIKE ?";
175 $params[] = $conditions['email'] . '%';
176 }
177 
178 if (!empty($conditions['mobile'])) {
179 $where[] = "mobile LIKE ?";
180 $params[] = $conditions['mobile'] . '%';
181 }
182 
183 $whereClause = $where ? "WHERE " . implode(' AND ', $where) : "";
184 $offset = ($page - 1) * $pageSize;
185 
186 $sql = "SELECT * FROM {$tableName} {$whereClause} LIMIT ? OFFSET ?";
187 $params[] = $pageSize;
188 $params[] = $offset;
189 
190 $stmt = $connection->prepare($sql);
191 $stmt->execute($params);
192 
193 $shardUsers = $stmt->fetchAll();
194 $allUsers = array_merge($allUsers, $shardUsers);
195 }
196 
197 // 在PHP中进行排序和分页
198 usort($allUsers, function($a, $b) {
199 return strcmp($b['created_at'], $a['created_at']);
200 });
201 
202 return array_slice($allUsers, 0, $pageSize);
203 }
204 
205 /**
206 * 删除用户
207 */
208 public function deleteUser($userId) {
209 $shardId = $this->router->getUserShard($userId);
210 $tableName = $this->router->getTableName('users', $shardId);
211 $connection = $this->db->getConnection('user_center', $shardId);
212 
213 try {
214 $this->db->beginTransaction('user_center', $shardId);
215 
216 // 删除用户基础信息
217 $sql = "DELETE FROM {$tableName} WHERE user_id = ?";
218 $stmt = $connection->prepare($sql);
219 $stmt->execute([$userId]);
220 
221 // 删除关联数据
222 $this->deleteUserProfile($userId);
223 $this->deleteUserAddresses($userId);
224 
225 $this->db->commit('user_center', $shardId);
226 return true;
227 
228 } catch (Exception $e) {
229 $this->db->rollback('user_center', $shardId);
230 throw new Exception("删除用户失败: " . $e->getMessage());
231 }
232 }
233 
234 // 用户档案相关方法
235 private function createUserProfile($userId, $userData) {
236 $connection = $this->db->getConnection('user_center');
237 
238 $sql = "INSERT INTO user_profiles 
239 (user_id, real_name, avatar, gender, birthday, bio) 
240 VALUES (?, ?, ?, ?, ?, ?)";
241 
242 $stmt = $connection->prepare($sql);
243 return $stmt->execute([
244 $userId,
245 $userData['real_name'] ?? '',
246 $userData['avatar'] ?? '',
247 $userData['gender'] ?? 0,
248 $userData['birthday'] ?? null,
249 $userData['bio'] ?? ''
250 ]);
251 }
252 
253 private function getUserProfile($userId) {
254 $connection = $this->db->getConnection('user_center');
255 
256 $sql = "SELECT * FROM user_profiles WHERE user_id = ?";
257 $stmt = $connection->prepare($sql);
258 $stmt->execute([$userId]);
259 
260 return $stmt->fetch();
261 }
262 
263 private function getUserAddresses($userId) {
264 $connection = $this->db->getConnection('user_center');
265 
266 $sql = "SELECT * FROM user_address WHERE user_id = ? ORDER BY is_default DESC";
267 $stmt = $connection->prepare($sql);
268 $stmt->execute([$userId]);
269 
270 return $stmt->fetchAll();
271 }
272 
273 private function deleteUserProfile($userId) {
274 $connection = $this->db->getConnection('user_center');
275 
276 $sql = "DELETE FROM user_profiles WHERE user_id = ?";
277 $stmt = $connection->prepare($sql);
278 return $stmt->execute([$userId]);
279 }
280 
281 private function deleteUserAddresses($userId) {
282 $connection = $this->db->getConnection('user_center');
283 
284 $sql = "DELETE FROM user_address WHERE user_id = ?";
285 $stmt = $connection->prepare($sql);
286 return $stmt->execute([$userId]);
287 }
288}

5. 订单服务类示例

 1<?php
 2// OrderService.php
 3class OrderService {
 4 private $db;
 5 private $router;
 6 
 7 public function __construct() {
 8 $this->db = DatabaseManager::getInstance();
 9 $this->router = new ShardRouter();
 10 }
 11 
 12 /**
 13 * 创建订单
 14 */
 15 public function createOrder($orderData) {
 16 $userId = $orderData['user_id'];
 17 $shardId = $this->router->getUserShard($userId);
 18 
 19 $orderId = $this->router->generateId($shardId);
 20 $orderTable = $this->router->getTableName('orders', $shardId);
 21 $itemTable = $this->router->getTableName('order_items', $shardId);
 22 $connection = $this->db->getConnection('order_center', $shardId);
 23 
 24 try {
 25 $this->db->beginTransaction('order_center', $shardId);
 26 
 27 // 插入订单主表
 28 $sql = "INSERT INTO {$orderTable} 
 29 (order_id, user_id, total_amount, status, payment_status, created_at) 
 30 VALUES (?, ?, ?, 1, 0, NOW())";
 31 
 32 $stmt = $connection->prepare($sql);
 33 $stmt->execute([
 34 $orderId,
 35 $userId,
 36 $orderData['total_amount']
 37 ]);
 38 
 39 // 插入订单项
 40 foreach ($orderData['items'] as $item) {
 41 $itemId = $this->router->generateId($shardId);
 42 
 43 $sql = "INSERT INTO {$itemTable} 
 44 (item_id, order_id, product_id, product_name, price, quantity) 
 45 VALUES (?, ?, ?, ?, ?, ?)";
 46 
 47 $stmt = $connection->prepare($sql);
 48 $stmt->execute([
 49 $itemId,
 50 $orderId,
 51 $item['product_id'],
 52 $item['product_name'],
 53 $item['price'],
 54 $item['quantity']
 55 ]);
 56 }
 57 
 58 $this->db->commit('order_center', $shardId);
 59 return $orderId;
 60 
 61 } catch (Exception $e) {
 62 $this->db->rollback('order_center', $shardId);
 63 throw new Exception("创建订单失败: " . $e->getMessage());
 64 }
 65 }
 66 
 67 /**
 68 * 更新订单状态
 69 */
 70 public function updateOrderStatus($orderId, $status) {
 71 $shardId = $this->router->getOrderShard($orderId);
 72 $tableName = $this->router->getTableName('orders', $shardId);
 73 $connection = $this->db->getConnection('order_center', $shardId);
 74 
 75 $sql = "UPDATE {$tableName} SET status = ?, updated_at = NOW() WHERE order_id = ?";
 76 $stmt = $connection->prepare($sql);
 77 
 78 return $stmt->execute([$status, $orderId]);
 79 }
 80 
 81 /**
 82 * 根据订单ID查询
 83 */
 84 public function getOrderById($orderId) {
 85 $shardId = $this->router->getOrderShard($orderId);
 86 $orderTable = $this->router->getTableName('orders', $shardId);
 87 $itemTable = $this->router->getTableName('order_items', $shardId);
 88 $connection = $this->db->getConnection('order_center', $shardId);
 89 
 90 // 查询订单基本信息
 91 $sql = "SELECT * FROM {$orderTable} WHERE order_id = ?";
 92 $stmt = $connection->prepare($sql);
 93 $stmt->execute([$orderId]);
 94 
 95 $order = $stmt->fetch();
 96 if ($order) {
 97 // 查询订单项
 98 $sql = "SELECT * FROM {$itemTable} WHERE order_id = ?";
 99 $stmt = $connection->prepare($sql);
100 $stmt->execute([$orderId]);
101 $order['items'] = $stmt->fetchAll();
102 }
103 
104 return $order;
105 }
106 
107 /**
108 * 查询用户订单列表
109 */
110 public function getUserOrders($userId, $page = 1, $pageSize = 20) {
111 $shardId = $this->router->getUserShard($userId);
112 $tableName = $this->router->getTableName('orders', $shardId);
113 $connection = $this->db->getConnection('order_center', $shardId);
114 
115 $offset = ($page - 1) * $pageSize;
116 
117 $sql = "SELECT * FROM {$tableName} 
118 WHERE user_id = ? 
119 ORDER BY created_at DESC 
120 LIMIT ? OFFSET ?";
121 
122 $stmt = $connection->prepare($sql);
123 $stmt->execute([$userId, $pageSize, $offset]);
124 
125 return $stmt->fetchAll();
126 }
127}

6. 使用示例

6.1 用户注册和订单创建

 1<?php
 2// register_and_order.php
 3require_once 'Config.php';
 4require_once 'ShardRouter.php';
 5require_once 'DatabaseManager.php';
 6require_once 'UserService.php';
 7require_once 'OrderService.php';
 8
 9try {
10 // 初始化服务
11 $userService = new UserService();
12 $orderService = new OrderService();
13 
14 // 1. 创建用户
15 $userData = [
16 'username' => 'zhangsan',
17 'email' => 'zhangsan@example.com',
18 'password' => '123456',
19 'mobile' => '13800138000',
20 'real_name' => '张三',
21 'avatar' => 'avatar.jpg'
22 ];
23 
24 $userId = $userService->createUser($userData);
25 echo "用户创建成功，ID: {$userId}\n";
26 
27 // 2. 为用户创建订单
28 $orderData = [
29 'user_id' => $userId,
30 'total_amount' => 299.00,
31 'items' => [
32 [
33 'product_id' => 1001,
34 'product_name' => 'iPhone 14',
35 'price' => 299.00,
36 'quantity' => 1
37 ]
38 ]
39 ];
40 
41 $orderId = $orderService->createOrder($orderData);
42 echo "订单创建成功，ID: {$orderId}\n";
43 
44 // 3. 查询用户信息
45 $user = $userService->getUserById($userId);
46 echo "用户信息: " . json_encode($user, JSON_UNESCAPED_UNICODE) . "\n";
47 
48 // 4. 查询订单信息
49 $order = $orderService->getOrderById($orderId);
50 echo "订单信息: " . json_encode($order, JSON_UNESCAPED_UNICODE) . "\n";
51 
52 // 5. 查询用户订单列表
53 $orders = $orderService->getUserOrders($userId);
54 echo "用户订单数量: " . count($orders) . "\n";
55 
56} catch (Exception $e) {
57 echo "操作失败: " . $e->getMessage() . "\n";
58}

6.2 批量操作示例

 1<?php
 2// batch_operations.php
 3require_once 'UserService.php';
 4
 5$userService = new UserService();
 6
 7// 批量查询用户信息
 8$userIds = [123456, 234567, 345678, 456789];
 9$users = $userService->getUsersByIds($userIds);
10echo "批量查询到 " . count($users) . " 个用户\n";
11
12// 复杂搜索
13$conditions = [
14 'username' => 'zhang',
15 'mobile' => '138'
16];
17$users = $userService->searchUsers($conditions, 1, 10);
18echo "搜索到 " . count($users) . " 个用户\n";
19
20// 更新用户信息
21$updateResult = $userService->updateUser(123456, [
22 'email' => 'new_email@example.com',
23 'mobile' => '13900139000'
24]);
25echo "更新结果: " . ($updateResult ? '成功' : '失败') . "\n";

三、总结

写入操作：

先计算分片：根据分片键（如用户ID）计算目标分片

MySQL索引类型

Tue, 23 Apr 2024 20:46:01 +0800

MySQL索引类型

索引是帮助MySQL高效获取数据的数据结构，类似于书籍的目录，可以大大加快查询速度。

一、索引类型

1. B-Tree 索引（最常用）

特点

默认的索引类型
适用于全键值、键值范围或键值前缀查找
支持排序和分组

创建语法

 1-- 单列索引
 2CREATE INDEX idx_name ON table_name(column_name);
 3
 4-- 多列复合索引
 5CREATE INDEX idx_name ON table_name(col1, col2, col3);
 6
 7-- 创建表时指定
 8CREATE TABLE users (
 9 id INT PRIMARY KEY,
10 name VARCHAR(50),
11 email VARCHAR(100),
12 age INT,
13 INDEX idx_name (name),
14 INDEX idx_email_age (email, age)
15);

适用查询类型

 1-- 全值匹配
 2SELECT * FROM users WHERE name = 'John';
 3
 4-- 前缀匹配（最左前缀）
 5SELECT * FROM users WHERE name LIKE 'Joh%';
 6
 7-- 范围查询
 8SELECT * FROM users WHERE age BETWEEN 20 AND 30;
 9
10-- 精确匹配左列 + 范围匹配右列
11SELECT * FROM users WHERE email = 'john@example.com' AND age > 25;
12
13-- 排序
14SELECT * FROM users ORDER BY name;
15
16-- 分组
17SELECT COUNT(*), age FROM users GROUP BY age;

最左前缀原则示例

 1-- 复合索引: (last_name, first_name, age)
 2
 3-- 使用索引的情况
 4SELECT * FROM users WHERE last_name = 'Smith';
 5SELECT * FROM users WHERE last_name = 'Smith' AND first_name = 'John';
 6SELECT * FROM users WHERE last_name = 'Smith' AND first_name = 'John' AND age = 30;
 7SELECT * FROM users WHERE last_name = 'Smith' AND age > 25; -- 只使用last_name部分
 8
 9-- 不能使用索引的情况
10SELECT * FROM users WHERE first_name = 'John'; -- 跳过了last_name
11SELECT * FROM users WHERE age = 30; -- 跳过了前两列

2. 哈希索引

特点

基于哈希表实现
只能用于等值比较（=, IN）
不支持范围查询和排序
Memory存储引擎默认索引类型

创建语法

1-- 只能在MEMORY表上创建哈希索引
2CREATE TABLE memory_table (
3 id INT,
4 data VARCHAR(100),
5 INDEX USING HASH (id)
6) ENGINE=MEMORY;
7
8-- 或者
9CREATE INDEX idx_hash ON memory_table(id) USING HASH;

适用场景

1-- 等值查询（快速）
2SELECT * FROM memory_table WHERE id = 100;
3
4-- 不支持范围查询
5SELECT * FROM memory_table WHERE id > 100; -- 不会使用哈希索引

自适应哈希索引（InnoDB）

InnoDB会自动在内存中为频繁访问的索引页创建哈希索引，这是自动的，无需手动创建。

Mysql中的回表

Tue, 23 Apr 2024 20:46:01 +0800

MYSQL中的回（Back to Table）表说明

一、基本概念

回表是指当使用非聚簇索引（二级索引）进行查询时，首先在索引中查找到所需数据的主键值，然后再根据这个主键值回到主键索引（聚簇索引）中查找完整数据行的过程。

二、核心原理

聚簇索引 vs 非聚簇索引

 1-- 创建测试表
 2CREATE TABLE user_info (
 3 id INT PRIMARY KEY, -- 主键，聚簇索引
 4 name VARCHAR(50), 
 5 email VARCHAR(100),
 6 age INT,
 7 created_at DATETIME,
 8 INDEX idx_email (email), -- 非聚簇索引（二级索引）
 9 INDEX idx_name_age (name, age) -- 复合非聚簇索引
10);

索引结构对比

聚簇索引（主键索引）结构：

1索引节点 -> 叶子节点包含完整数据行
2[id:1] -> [id:1, name:'张三', email:'zhang@xx.com', age:25, ...]
3[id:2] -> [id:2, name:'李四', email:'li@xx.com', age:30, ...]

非聚簇索引（二级索引）结构：

1索引节点 -> 叶子节点只包含索引列 + 主键值
2[email:'li@xx.com'] -> [主键id:2]
3[email:'zhang@xx.com'] -> [主键id:1]

三、回表现象详解

示例1：基本的回表查询

1-- 这个查询会发生回表
2EXPLAIN SELECT * FROM user_info WHERE email = 'zhang@xx.com';

查询过程：

在 idx_email 索引中查找 email = ‘zhang@xx.com’
找到对应的主键值 id = 1
使用 id = 1 回到聚簇索引中查找完整数据行
返回所有列的数据

EXPLAIN 结果：

1type: ref
2key: idx_email
3Extra: Using index condition

示例2：覆盖索引避免回表

1-- 这个查询不会回表（覆盖索引）
2EXPLAIN SELECT id, email FROM user_info WHERE email = 'zhang@xx.com';

查询过程：

在 idx_email 索引中查找 email = ‘zhang@xx.com’
索引中已经包含所需的 id 和 email 列
直接返回结果，无需回表

EXPLAIN 结果：

1type: ref
2key: idx_email
3Extra: Using index ← 这个表示使用了覆盖索引

四、实际案例演示

准备测试数据

 1-- 创建详细的测试表
 2CREATE TABLE employee (
 3 emp_id INT PRIMARY KEY AUTO_INCREMENT,
 4 emp_name VARCHAR(50) NOT NULL,
 5 department VARCHAR(50),
 6 salary DECIMAL(10,2),
 7 hire_date DATE,
 8 email VARCHAR(100),
 9 phone VARCHAR(20),
10 INDEX idx_department (department),
11 INDEX idx_email (email),
12 INDEX idx_hire_date (hire_date),
13 INDEX idx_department_salary (department, salary)
14);
15
16-- 插入测试数据
17INSERT INTO employee (emp_name, department, salary, hire_date, email, phone) VALUES
18('张三', '技术部', 15000, '2020-01-15', 'zhang@company.com', '13800138001'),
19('李四', '技术部', 12000, '2021-03-20', 'li@company.com', '13800138002'),
20('王五', '销售部', 8000, '2022-06-10', 'wang@company.com', '13800138003'),
21('赵六', '销售部', 7500, '2022-08-05', 'zhao@company.com', '13800138004'),
22('钱七', '人事部', 9000, '2021-09-15', 'qian@company.com', '13800138005');

案例1：明显的回表查询

1-- 查询1：会发生回表
2EXPLAIN SELECT * FROM employee WHERE department = '技术部';

执行过程分析：

使用 idx_department 索引找到所有 department = ‘技术部’ 的记录
获取对应的主键值 emp_id
用这些 emp_id 回表到聚簇索引查询完整数据
返回所有字段

案例2：避免回表的覆盖索引

1-- 查询2：覆盖索引，避免回表
2EXPLAIN SELECT emp_id, department FROM employee WHERE department = '技术部';

执行过程分析：

使用 idx_department 索引找到所有 department = ‘技术部’ 的记录
索引中已经包含 emp_id 和 department 字段
直接返回，无需回表

案例3：复合索引的回表情况

1-- 查询3：复合索引，但需要回表
2EXPLAIN SELECT emp_id, emp_name, department, salary 
3FROM employee 
4WHERE department = '技术部' AND salary > 10000;

执行过程分析：

使用 idx_department_salary 索引找到符合条件的记录
索引中包含 department, salary, emp_id
但是 emp_name 字段不在索引中，需要回表查询

五、如何识别回表

使用 EXPLAIN 分析

1-- 查看执行计划判断是否回表
2EXPLAIN SELECT * FROM employee WHERE email = 'zhang@company.com';
3
4-- 重点关注 Extra 字段：
5-- "Using index": 覆盖索引，无回表 ✓
6-- "Using index condition": 使用索引，但需要回表
7-- "Using where": 可能回表

实际测试对比

 1-- 测试1：需要回表的查询
 2EXPLAIN 
 3SELECT emp_name, department, salary, email, phone 
 4FROM employee 
 5WHERE department = '技术部';
 6
 7-- 测试2：覆盖索引查询（无回表）
 8EXPLAIN 
 9SELECT emp_id, department 
10FROM employee 
11WHERE department = '技术部';
12
13-- 测试3：部分回表
14EXPLAIN 
15SELECT emp_id, department, emp_name 
16FROM employee 
17WHERE department = '技术部';

六、回表的性能影响

性能测试对比

 1-- 创建大数据量表进行测试
 2CREATE TABLE large_table (
 3 id INT PRIMARY KEY AUTO_INCREMENT,
 4 data1 VARCHAR(100),
 5 data2 VARCHAR(100),
 6 data3 VARCHAR(100),
 7 index_col INT,
 8 INDEX idx_index_col (index_col)
 9);
10
11-- 插入10万条测试数据
12DELIMITER //
13CREATE PROCEDURE InsertTestData()
14BEGIN
15 DECLARE i INT DEFAULT 0;
16 WHILE i < 100000 DO
17 INSERT INTO large_table (data1, data2, data3, index_col) 
18 VALUES (CONCAT('data1_', i), CONCAT('data2_', i), CONCAT('data3_', i), i);
19 SET i = i + 1;
20 END WHILE;
21END//
22DELIMITER ;
23
24CALL InsertTestData();

性能对比查询

1-- 需要回表的查询（慢）
2SELECT * FROM large_table WHERE index_col BETWEEN 1000 AND 2000;
3
4-- 覆盖索引查询（快）
5SELECT id, index_col FROM large_table WHERE index_col BETWEEN 1000 AND 2000;

七、如何避免回表

方法1：使用覆盖索引

1-- 创建覆盖索引
2CREATE INDEX idx_covering ON employee(department, salary, emp_name);
3
4-- 现在这个查询不会回表
5EXPLAIN 
6SELECT emp_id, department, salary, emp_name 
7FROM employee 
8WHERE department = '技术部' AND salary > 10000;

方法2：只查询需要的列

1-- 不好的写法：查询所有列
2SELECT * FROM employee WHERE email = 'zhang@company.com';
3
4-- 好的写法：只查询需要的列
5SELECT emp_id, emp_name, email FROM employee WHERE email = 'zhang@company.com';
6
7-- 更好的写法：创建覆盖索引
8CREATE INDEX idx_covering_email ON employee(email, emp_name);
9SELECT emp_name, email FROM employee WHERE email = 'zhang@company.com';

方法3：优化复合索引设计

1-- 根据查询需求设计覆盖索引
2-- 常见查询：按部门查询员工信息和薪资
3CREATE INDEX idx_dept_covering ON employee(department, salary, emp_name, hire_date);
4
5-- 现在这些查询都可以使用覆盖索引：
6SELECT emp_name, salary FROM employee WHERE department = '技术部';
7SELECT department, AVG(salary) FROM employee GROUP BY department;
8SELECT emp_name, hire_date FROM employee WHERE department = '销售部' ORDER BY hire_date;

八、实际业务场景优化

场景1：用户查询优化

 1-- 原始表结构
 2CREATE TABLE users (
 3 user_id INT PRIMARY KEY,
 4 username VARCHAR(50),
 5 email VARCHAR(100),
 6 phone VARCHAR(20),
 7 real_name VARCHAR(50),
 8 avatar_url VARCHAR(200),
 9 created_time DATETIME,
10 INDEX idx_email (email)
11);
12
13-- 问题：根据email查询用户信息需要回表
14SELECT * FROM users WHERE email = 'user@example.com';
15
16-- 优化：创建覆盖索引
17CREATE INDEX idx_email_covering ON users(email, username, avatar_url);
18
19-- 优化后的查询（页面展示常用字段）
20SELECT user_id, username, email, avatar_url 
21FROM users 
22WHERE email = 'user@example.com';

场景2：订单查询优化

 1-- 订单表
 2CREATE TABLE orders (
 3 order_id BIGINT PRIMARY KEY,
 4 user_id INT,
 5 amount DECIMAL(10,2),
 6 status VARCHAR(20),
 7 create_time DATETIME,
 8 update_time DATETIME,
 9 INDEX idx_user_status (user_id, status)
10);
11
12-- 常见查询：用户订单列表
13-- 需要回表的查询
14SELECT * FROM orders WHERE user_id = 123 AND status = 'completed';
15
16-- 优化为覆盖索引
17CREATE INDEX idx_user_status_covering ON orders(user_id, status, order_id, amount, create_time);
18
19-- 优化后的查询（列表页面需要的字段）
20SELECT order_id, amount, create_time 
21FROM orders 
22WHERE user_id = 123 AND status = 'completed';

总结

回表的关键点：

触发条件：使用二级索引且查询字段不全部在索引中
性能影响：额外的磁盘I/O，降低查询性能
识别方法：EXPLAIN查看执行计划，关注"Using index"
避免方法：
- 使用覆盖索引

Mysql中的事务及隔离级别

Tue, 23 Apr 2024 20:46:01 +0800

MySQL事务与隔离级别深度解析

一、事务基础概念

1. 什么是事务

事务(Transaction)是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作。事务具有以下四个关键特性(ACID)：

原子性(Atomicity)：事务中的所有操作要么全部完成，要么全部不完成
一致性(Consistency)：事务执行前后，数据库从一个一致状态变到另一个一致状态
隔离性(Isolation)：多个事务并发执行时，一个事务的执行不应影响其他事务
持久性(Durability)：事务一旦提交，其结果就是永久性的

2. MySQL中的事务控制语句

1START TRANSACTION; -- 或 BEGIN
2-- 执行SQL操作
3COMMIT; -- 提交事务
4ROLLBACK; -- 回滚事务

二、事务隔离级别详解

1. 四种标准隔离级别

MySQL支持四种事务隔离级别，控制不同事务之间的可见性：

隔离级别	脏读	不可重复读	幻读	说明
READ UNCOMMITTED（读未提交）	可能	可能	可能	最低隔离级别
READ COMMITTED（读已提交）	不可能	可能	可能	大多数数据库默认级别
REPEATABLE READ（可重复读）	不可能	不可能	可能	MySQL默认级别
SERIALIZABLE（序列化）	不可能	不可能	不可能	最高隔离级别

2. 并发问题说明

脏读(Dirty Read)：读取到其他事务未提交的数据
不可重复读(Non-repeatable Read)：同一事务内多次读取同一数据结果不同
幻读(Phantom Read)：同一事务内多次查询返回不同的行集合

3. 隔离级别设置与查看

1-- 设置当前会话隔离级别
2SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
3
4-- 设置全局隔离级别
5SET GLOBAL TRANSACTION ISOLATION LEVEL REPEATABLE READ;
6
7-- 查看当前隔离级别
8SELECT @@transaction_isolation;

三、各隔离级别实现机制

1. READ UNCOMMITTED

实现方式：不加锁，直接读取最新数据（包括其他事务未提交的）

Mysql中的锁

Tue, 23 Apr 2024 20:46:01 +0800

MYSQL中的锁

一、 MySQL锁概述

MySQL锁机制是数据库管理系统实现并发控制的核心技术，它通过在共享资源上实施访问限制，确保数据的一致性和完整性。作为PHP高级开发者，深入理解MySQL锁机制对于构建高性能、高并发的Web应用至关重要。

二、 MySQL锁分类体系

1. 按锁的粒度划分

1. 表级锁

特点

开销小，加锁快
锁定整个表
并发度低 使用场景

1-- 显式加表锁
2LOCK TABLES users READ; -- 共享锁
3LOCK TABLES users WRITE; -- 排他锁
4
5-- 操作完成后释放
6UNLOCK TABLES;

注意事项：

MyISAM引擎默认使用表锁
在InnoDB上应谨慎使用，会严重影响并发

2. 行级锁

特点

开销大，加锁慢
只锁定需要的行
并发度高 使用场景

1-- 共享锁(S锁)
2SELECT * FROM accounts WHERE id = 1 LOCK IN SHARE MODE;
3-- MySQL 8.0+推荐语法
4SELECT * FROM accounts WHERE id = 1 FOR SHARE;
5
6-- 排他锁(X锁)
7SELECT * FROM accounts WHERE id = 1 FOR UPDATE;

注意事项：

MySQL优化常用方法

Sun, 17 Mar 2024 13:46:01 +0800

MySQL优化常用方法

1. EXPLAIN

EXPLAIN 查看SQL执行计划

主要字段说明：

type列，连接类型。一个好的SQL语句至少要达到range级别。杜绝出现all级别。
key列，使用到的索引名。如果没有选择索引，值是NULL。可以采取强制索引方式。
key_len列，索引长度。
rows列，扫描行数。该值是个预估值。
extra列，详细说明。注意，常见的不太友好的值，如下：Using filesort，Using temporary。

2. SQL语句中IN包含的值不应过多

MySQL对于IN做了相应的优化，即将IN中的常量全部存储在一个数组里面，而且这个数组是排好序的。但是如果数值较多，产生的消耗也是比较大的。再例如：select id from t where num in(1,2,3) 对于连续的数值，能用between就不要用in了；再或者使用连接来替换。

3. SELECT语句务必指明字段名称

SELECT*增加很多不必要的消耗（CPU、IO、内存、网络带宽）；增加了使用覆盖索引的可能性；当表结构发生改变时，前断也需要更新。所以要求直接在select后面接上字段名。

4. 当只需要一条数据的时候，使用limit 1

这是为了使EXPLAIN中type列达到const类型

5. 如果排序字段没有用到索引，就尽量少排序

6. 如果限制条件中其他字段没有索引，尽量少用or

or两边的字段中，如果有一个不是索引字段，而其他条件也不是索引字段，会造成该查询不走索引的情况。很多时候使用union all或者是union（必要的时候）的方式来代替“or”会得到更好的效果。

7. 尽量用union all代替union

nion和union all的差异主要是前者需要将结果集合并后再进行唯一性过滤操作，这就会涉及到排序，增加大量的CPU运算，加大资源消耗及延迟。当然，union all的前提条件是两个结果集没有重复数据。

8. 不使用ORDER BY RAND()

select id from dynamic order by rand() limit 1000;

上面的SQL语句，可优化为：

select id from dynamic t1 join (select rand() * (select max(id) from dynamic) as nid) t2 on t1.id > t2.nidlimit 1000;

Mysql主从复制原理及保证数据一致性

Tue, 12 Mar 2024 13:46:01 +0800

Mysql主从复制原理及保证数据一致性

提升数据库的并发能力

提在实际工作中，我们常常将Redis作为缓存与MySQL来配合使用，当有请求的时候，首先会从缓存中进行查找，如果存在就直接取出，如果不存在再访问数据库。这样就提升了读取的效率，也减少了对后端数据库的访问压力。

此外，对于一般数据库应用而言，都是读多写少的，当数据库读取数据压力较大时，我们可以从成本较小的方案开始优化，可以首先考虑优化SQL和索引，其次就是缓存策略，最后才是主从架构。

主从复制的作用

读写分离。在读多写少的情况下，可以采用读写分离，主库当做写库，然后根据实际需要，选择使用多个读库，分散读的压力，提高并发性。
数据备份。主从复制其实就相当于一种热备份的机制。
实现高可用。数据备份其实就是一种冗余机制，当主服务器出现故障是时，可以切换到从服务器上，提高服务器可用性。

主从复制原理

实际上主从同步的原理就是基于binlog进行数据同步的。在主从复制过程中，会基于3个线程来操作，一个主库线程，两个从库线程。
二进制日志转储线程是一个主库线程。当从库线程连接的时候，主库可以将二进制日志发送给从库，当主库读取事件的时候，会在Binlog上加锁，读取完成之后，再将锁释放掉。
从库I/O线程会连接到主库，向主库发送请求更新Binlog。这时从库的I/O线程就可以读取到主库的二进制日志转储线程发送的Binlog更新部分，并且拷贝到本地的中继日志。
从库SQL线程会读取从库中的中继日志，并且执行日志中的事件，将从库中的数据与主库保持同步。

总结起来就是三步：

步骤1：Master将写操作记录到二进制日志（binlog），这些记录叫做二进制日志事件（binary log events）；

步骤2：Slave 将 Master 的 binary log events拷贝到它的中继日志（relay log）；

步骤3：Slave重做中继日志中的事件，将改变应用到自己的数据库中。

搭建

TODO 此处省略，待补充

如何解决数据一致性问题

进行主从同步的内容是二进制日志，它是一个文件，在进行网络传输的过程中就一定会存在主从延迟，这样就可能造成用户在从库上读取的数据不是最新的数据，也就是主从同步中的数据不一致性问题。

方案一、异步复制

异步模式就是客户端提交COMMIT之后不需要等从库返回任何结果，而是直接将结果返回给客户端，这样做的好处是不会影响主库写的效率。
但这样可能会存在主库宕机，而Binlog还没有同步到从库的情况，也就是此时的主库和从库数据不一致。
这时候从从库中选择一个作为新主，那么新主则可能缺少原来主服务器中已提交的事务。所以，这种复制模式下的数据一致性是最弱的。

方案二、半同步复制

半同步复制的原理是在客户端提交COMMIT之后不直接将结果返回给客户端，而是等待至少有一个从库接收到了Binlog，并且写入到中继日志中，再返回给客户端。
这样做的好处是提高了数据的一致性，当然相比于异步复制来说，至少多增加了一个网络连接的延迟，降低了主库写的效率。
在MySQL5.7版本中还增加了一个参数，可以对应答的从库数量进行设置，默认为1，也就是说只要有1个从库进行了响应，就可以返回给客户端。如果将这个参数调大，可以提升数据一致性的强度，但也会增加主库等待从库响应的时间。

方案三、组复制

异步复制和半同步复制都无法最终保证数据的一致性问题，半同步复制是通过判断从库响应的个数来决定是否返回给客户端，虽然数据一致性相比于异步复制有提升，但仍然无法满足对数据一致性要求高的场景。组复制技术MGR很好地弥补了这两种复制模式的不足，它是MySQL在5.7.17版本中推出的一种新的数据复制技术，是基于Paxos协议的状态机复制。

原文链接：

Mysql的一些常见题

Tue, 20 Feb 2024 20:46:01 +0800

Mysql的一些常见题

请写出数据类型(int char varchar datetime text)的意思；请问 varchar 和 char有什么区别？

Int 整数char 定长字符 Varchar 变长字符 Datetime 日期时间型Text 文本型 Varchar与char的区别 char是固定长度的字符类型，分配多少空间，就占用多长空间。Varchar是可变长度的字符类型，内容有多大就占用多大的空间，能有效节省空间。由于varchar类型是可变的，所以在数据长度改变的时，服务器要进行额外的操作，所以效率比char类型低。
MyISAM和 InnoDB 的基本区别？索引结构如何实现？

A、MyISAM类型不支持事务，表锁，易产生碎片，要经常优化，读写速度较快，适合用于频繁查询的应用；
B、InnoDB类型支持事务，行锁，有崩溃恢复能力，读写速度比MyISAM慢，适合于插入和更新操作比较多的应用，空间占用大，不支持全文索引等。创建索引：alert table tablename add index 索引名 (字段名)
什么是事务？及其特性？

答：事务：是一系列的数据库操作，是数据库应用的基本逻辑单位。

事务特性：A、原子性：即不可分割性，事务要么全部被执行，要么就全部不被执行。B、一致性或可串性。事务的执行使得数据库从一种正确状态转换成另一种正确状态C、隔离性。在事务正确提交之前，不允许把该事务对数据的任何改变提供给任何其他事务，D、持久性。事务正确提交后，其结果将永久保存在数据库中，即使在事务提交后有了其他故障，事务的处理结果也会得到保存。

或者这样理解：事务就是被绑定在一起作为一个逻辑工作单元的SQL语句分组，如果任何一个语句操作失败那么整个操作就被失败，以后操作就会回滚到操作前状态，或者是上有个节点。为了确保要么执行，要么不执行，就可以使用事务。要将有组语句作为事务考虑，就需要通过ACID测试，即原子性，一致性，隔离性和持久性。
什么是锁？

答：数据库是一个多用户使用的共享资源。当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的情况。若对并发操作不加控制就可能会读取和存储不正确的数据，破坏数据库的一致性。

加锁是实现数据库并发控制的一个非常重要的技术。当事务在对某个数据对象进行操作前，先向系统发出请求，对其加锁。加锁后事务就对该数据对象有了一定的控制，在该事务释放锁之前，其他的事务不能对此数据对象进行更新操作。

基本锁类型：锁包括行级锁和表级锁
索引的作用？和它的优点缺点是什么？

索引就一种特殊的查询表，数据库的搜索引擎可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。
怎么防止sql注入？

1）过滤掉一些常见的数据库操作关键字：select,insert,update,delete,and,*等，或者通过系统函数：addslashes(需要被过滤的内容)来进行过滤。

2）在PHP配置文件中

Register_globals=off;设置为关闭状态 //作用将注册全局变量关闭。

比如：接收POST表单的值使用$_POST[‘user’],如果将register_globals=on;直接使用$user可以接收表单的值。

3）SQL语句书写的时候尽量不要省略小引号(tab键上面那个)和单引号

4）提高数据库命名技巧，对于一些重要的字段根据程序的特点命名，取不易被猜到的

5）对于常用的方法加以封装，避免直接暴漏SQL语句

6）开启PHP安全模式

Safe_mode=on;

7）打开magic_quotes_gpc来防止SQL注入

Magic_quotes_gpc=off;默认是关闭的，它打开后将自动把用户提交的sql语句的查询进行转换，把’转为'，这对防止sql注入有重大作用。

因此开启：magic_quotes_gpc=on;

8）控制错误信息

关闭错误提示信息，将错误信息写到系统日志。

9）使用mysqli或pdo预处理。
数据库优化策略？
1. 合理的表设计。
  1. 依据三范式，设计表.
  三范式：1.原子性，每个字段都是不可在分的。
  1. 在1方式的基础上，表中每一列必须有唯一性，其他字段依赖主键。
  2. 在2方式的基础上，表中的每一列只与主键直接相关，而不是间接相关。
  3. 选择合适的字段。 I.尽量使用TYPEINT、SMALLINT、MEDIUM_INT代替INT的使用，一般索引，并且是字段递增，可以考虑设置为UNSIGNED.
  II.使用枚举代替字符串类型。
  
  III.将少null的使用，null很难优化，并且还占用额外的空间。

MySQL主从复制

Tue, 20 Feb 2024 20:46:01 +0800

MySQL 分库分表 + 主从复制

一、主从复制

1. 环境说明

1个master节点，2个slave节点

mysql-master
mysql-slave1
mysql-slave2

此处使用docker启动多个 MySQL 容器,为每个容器挂载配置文件

1docker run -d --name mysql-master -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 mysql:8.0
2docker run -d --name mysql-slave1 -e MYSQL_ROOT_PASSWORD=root -p 3307:3306 mysql:8.0
3docker run -d --name mysql-slave2 -e MYSQL_ROOT_PASSWORD=root -p 3308:3306 mysql:8.0

创建配置文件目录

1mkdir -p ~/mysql/master ~/mysql/slave1 ~/mysql/slave2

2. 修改配置

master的 my.cnf （~/mysql/master/my.cnf）

1[mysqld]
2server-id=1
3log_bin=mysql-bin
4binlog_format=ROW
5gtid_mode=ON
6enforce_gtid_consistency=ON
7log_slave_updates=ON

slave1 的 my.cnf（~/mysql/slave1/my.cnf）

1[mysqld]
2server-id=2
3relay_log_recovery=ON
4read_only=ON
5super_read_only=ON
6gtid_mode=ON
7enforce_gtid_consistency=ON
8log_slave_updates=ON

slave2 的 my.cnf（~/mysql/slave2/my.cnf）

ShardingSphere 使用指南

Tue, 20 Feb 2024 20:46:01 +0800

ShardingSphere 使用指南

一、介绍

Apache ShardingSphere 是一个开源的分布式数据库中间件生态，支持分库分表、读写分离、数据加密、影子库等功能。它的定位是数据库增强计算层，让你在不修改（或少量修改）应用代码的情况下，实现复杂的数据分片与治理。

核心组件：

ShardingSphere-JDBC：客户端 SDK，直接在应用中引入。
ShardingSphere-Proxy：中间件代理层，应用通过 MySQL 协议访问，无需修改业务代码。
ShardingSphere-Sidecar：面向 K8s 的云原生数据库 Mesh。

二、适用场景

分库分表：数据量过大，单表行数超过 1千万～1亿，单库容量超限时。
读写分离：主库写、从库读，提升查询性能。
柔性事务：分布式场景下保证一致性（支持 Seata、XA）。
数据加密：对敏感字段（手机号、身份证号）自动加密存储，解密查询。
影子库：A/B 测试或灰度发布。

三、配置方式

以 ShardingSphere-Proxy 为例（最常用于 PHP 项目）。

3.1 部署 Proxy

1wget https://downloads.apache.org/shardingsphere/5.4.2/apache-shardingsphere-5.4.2-shardingsphere-proxy-bin.tar.gz
2tar -zxvf apache-shardingsphere-5.4.2-shardingsphere-proxy-bin.tar.gz
3cd apache-shardingsphere-5.4.2-shardingsphere-proxy-bin

配置文件路径：

1conf/server.yaml # 全局配置（身份认证、元数据）
2conf/config-sharding.yaml # 分库分表配置

3.2 示例配置（分库分表 + 读写分离）

server.yaml （全局配置）

1authentication:
2 users:
3 root:
4 password: root123  # 设置登录 ShardingSphere-Proxy 的账号和密码
5 authorizedSchemas: ds_sharding # 指定该用户可访问的逻辑库（schema）
6
7props:
8 sql-show: true # 开启 SQL 打印，方便调试时查看 Proxy 最终路由后的真实 SQL

config-sharding.yaml （分库分表 + 读写分离配置）

 1schemaName: ds_sharding  # 定义逻辑库名称，PHP / Java / MySQL 客户端连接时用这个库名
 2
 3# -----------------------------
 4# 数据源配置（物理数据库连接）
 5# -----------------------------
 6dataSources:
 7 ds0: # 数据源1（对应一个物理数据库）
 8 url: jdbc:mysql://127.0.0.1:3306/order_db0?serverTimezone=UTC&useSSL=false
 9 username: root
10 password: root
11 ds1: # 数据源2（对应另一个物理数据库）
12 url: jdbc:mysql://127.0.0.1:3306/order_db1?serverTimezone=UTC&useSSL=false
13 username: root
14 password: root
15
16# -----------------------------
17# 分片规则配置
18# -----------------------------
19rules:
20- !SHARDING
21 tables:
22 t_order: # 定义逻辑表名：t_order
23 actualDataNodes: ds$->{0..1}.t_order_$->{0..3} 
24 # 表示实际的数据节点： 
25 # - 数据库范围是 ds0、ds1（0..1）
26 # - 每个库里有 4 个分表（t_order_0, t_order_1, t_order_2, t_order_3）
27 # 最终生成的物理表结构：
28 # ds0.t_order_0 ~ ds0.t_order_3
29 # ds1.t_order_0 ~ ds1.t_order_3
30
31 tableStrategy: # 表级分片策略
32 standard: # 标准分片（根据单一分片键）
33 shardingColumn: order_id  # 分片字段（根据 order_id 来决定落在哪个分表）
34 shardingAlgorithmName: t_order_inline  # 使用下面定义的分片算法
35
36 shardingAlgorithms: # 定义分片算法
37 t_order_inline: # 算法名（和上面引用的保持一致）
38 type: INLINE  # 类型为 INLINE（内联表达式分片）
39 props:
40 algorithm-expression: t_order_$->{order_id % 4}
41 # 分片规则：根据 order_id 取模 4
42 # 比如 order_id=10001 → 10001%4=1 → 路由到 t_order_1
43
44# -----------------------------
45# （可选）读写分离配置
46# -----------------------------
47- !READWRITE_SPLITTING
48 dataSources:
49 pr_ds: # 定义一个逻辑数据源 pr_ds（Proxy 会将它当成读写分离的数据源）
50 staticStrategy:
51 writeDataSourceName: ds0  # 指定主库（写库），这里用 ds0
52 readDataSourceNames: [ds1]  # 指定从库（读库），这里用 ds1
53 loadBalancerName: round_robin  # 多个从库时的负载均衡策略（这里用轮询）
54
55 loadBalancers:
56 round_robin: # 定义负载均衡器
57 type: ROUND_ROBIN  # 类型：轮询

配置说明：

SQL语法速成

Fri, 01 Sep 2023 20:46:01 +0800

SQL语法速成

SQL 语法结构

子句 - 是语句和查询的组成成分。（在某些情况下，这些都是可选的。）
表达式 - 可以产生任何标量值，或由列和行的数据库表
谓词 - 给需要评估的 SQL 三值逻辑（3VL）（true/false/unknown）或布尔真值指定条件，并限制语句和查询的效果，或改变程序流程。
查询 - 基于特定条件检索数据。这是 SQL 的一个重要组成部分。
语句 - 可以持久地影响纲要和数据，也可以控制数据库事务、程序流程、连接、会话或诊断。

SQL 语法要点

SQL 语句不区分大小写，但是数据库表名、列名和值是否区分，依赖于具体的 DBMS 以及配置。例如：SELECT 与 select 、Select 是相同的。
多条 SQL 语句必须以分号 ; 分隔。
处理 SQL 语句时，所有空格都被忽略。SQL 语句可以写成一行，也可以分写为多行。
SQL 支持三种注释
```
1## 注释1
2-- 注释2
3/* 注释3 */
```

增删改查，又称为 CRUD，数据库基本操作中的基本操作。

插入数据

INSERT INTO 语句用于向表中插入新记录。

插入完整的行

1INSERT INTO user VALUES (10, 'root', 'root', 'xxxx@163.com');

插入行的一部分

1INSERT INTO user(username, password, email)VALUES ('admin', 'admin', 'xxxx@163.com');

插入查询出来的数据

MySQL 运维常用脚本

Fri, 03 Feb 2023 00:00:00 +0000

MySQL 运维常用脚本

1.导出整个数据库

1
2#mysqldump -u 用户名 -p –default-character-set=latin1 数据库名 > 导出的文件名(数据库默认编码是latin1)   
3
4mysql dump -u wcnc -p smgp_apps_wcnc > wcnc.sql

2.导出一个表

1#mysqldump -u 用户名 -p 数据库名 表名> 导出的文件名 
2
3mysql dump -u wcnc -p smgp_apps_wcnc users> wcnc_users.sql

3.导出一个数据库结构

1mysql dump -u wcnc -p -d –add-drop-table smgp_apps_wcnc >d:wcnc_db.sql
2
3#-d 没有数据 –add-drop-table 在每个create语句之前增加一个drop table

4.导入数据库

 1#A:常用source 命令   
 2#进入mysql数据库控制台，   如
 3mysql -u root -p   
 4mysql>use databasename
 5#然后使用source命令，后面参数为脚本文件(如这里用到的.sql)
 6mysql>source wcnc_db.sql
 7#B:使用mysqldump命令
 8mysqldump -u username -p dbname < filename.sql
 9#C:使用mysql命令
10mysql -u username -p -D dbname < filename.sql

启动与退出

Database on Leanku 的博客

MySQL 中主要的日志类型

MySQL 中主要的日志类型

总结概览

详细解析

1. 错误日志

2. 二进制日志

Mysql窗口函数

Mysql窗口函数

一、什么是窗口函数？

基本语法

二、 准备测试数据

1. 排名函数

ROW_NUMBER()

MyCat实现Mysql分库分表

Mysql分库分表和主从复制

MyCat 实现分库分表

案例背景

实现原理

实现方式

实现步骤

Mysql 简易安装

Mysql 简易安装

安装Mysql8.0(centos8为例)， 可参考 MySQL官方文档

MySQL分库分表（无中间件）

MySQL分库分表（无中间件）

一、 分库分表方案设计

1. 垂直拆分 (按业务模块)

2. 水平拆分 （按数据量）

用户表水平分表（10个分表）

订单表水平分表（按用户ID分表）

二、程序中处理（PHP）

1. 基础配置类

2. 分片路由类

3. 数据库连接管理

4. 用户服务类示例（完整CRUD）

5. 订单服务类示例

6. 使用示例

6.1 用户注册和订单创建

6.2 批量操作示例

三、 总结

写入操作：

MySQL索引类型

MySQL索引类型

一、索引类型

1. B-Tree 索引（最常用）

特点

创建语法

适用查询类型

最左前缀原则示例

2. 哈希索引

特点

创建语法

适用场景

自适应哈希索引（InnoDB）

Mysql中的回表

MYSQL中的回（Back to Table）表说明

一、 基本概念

二、核心原理

聚簇索引 vs 非聚簇索引

索引结构对比

聚簇索引（主键索引）结构：

非聚簇索引（二级索引）结构：

三、 回表现象详解

示例1：基本的回表查询

查询过程：

EXPLAIN 结果：

示例2：覆盖索引避免回表

查询过程：

EXPLAIN 结果：

四、 实际案例演示

准备测试数据

案例1：明显的回表查询

执行过程分析：

案例2：避免回表的覆盖索引

执行过程分析：

案例3：复合索引的回表情况

执行过程分析：

五、 如何识别回表

使用 EXPLAIN 分析

二、准备测试数据

安装Mysql8.0(centos8为例)，可参考 MySQL官方文档

一、分库分表方案设计

2. 水平拆分（按数据量）

三、总结

一、基本概念

三、回表现象详解

四、实际案例演示

五、如何识别回表

六、回表的性能影响

七、如何避免回表

一、事务基础概念

MySQL优化常用方法

MySQL优化常用方法

三、配置方式