# 语法：mysql -h 主机 -P 端口 -u 用户名 -p
# -p 后面不加密码，回车后交互式输入（更安全，密码不会留在历史记录）
mysql -h 10.0.1.100 -P 3306 -u root -p

# 快速登录本地 Socket（比 TCP 更快）
mysql -u root -p -S /tmp/mysql.sock

Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
mysql>

-- 查看当前所有活跃连接（排查连接池爆满时必用）
SHOW FULL PROCESSLIST;

-- 只看非 Sleep 的活跃查询
SELECT id, user, host, db, command, time, state, info
FROM information_schema.PROCESSLIST
WHERE command != 'Sleep';

+----+------+-------------+------+---------+------+-----------+------------------+
| id | user | host        | db   | command | time | state     | info             |
+----+------+-------------+------+---------+------+-----------+------------------+
| 10 | root | 10.0.1.1:22 | test | Query   |    0 | executing | SELECT * FROM t  |
| 11 | app  | 10.0.1.2:33 | test | Sleep   |  120 |           | NULL             |
+----+------+-------------+------+---------+------+-----------+------------------+

-- 查看所有数据库
SHOW DATABASES;

-- 选择数据库
USE mydb;

-- 查看当前库所有表
SHOW TABLES;

-- 查看表结构（字段、类型、主键等）
DESC mytable;
-- 或
SHOW CREATE TABLE mytable\G

+-------+--------------+------+-----+---------+----------------+
| Field | Type         | Null | Key | Default | Extra          |
+-------+--------------+------+-----+---------+----------------+
| id    | int(11)      | NO   | PRI | NULL    | auto_increment |
| name  | varchar(100) | YES  |     | NULL    |                |
+-------+--------------+------+-----+---------+----------------+

-- 创建数据库（指定字符集，避免乱码）
CREATE DATABASE IF NOT EXISTS mydb
  DEFAULT CHARACTER SET utf8mb4
  DEFAULT COLLATE utf8mb4_unicode_ci;

-- 创建表
CREATE TABLE IF NOT EXISTS users (
    id       INT UNSIGNED AUTO_INCREMENT PRIMARY KEY COMMENT '用户ID',
    name     VARCHAR(100) NOT NULL COMMENT '用户名',
    email    VARCHAR(200) NOT NULL COMMENT '邮箱',
    age      TINYINT UNSIGNED DEFAULT 0 COMMENT '年龄',
    status   TINYINT DEFAULT 1 COMMENT '状态 1=正常 0=禁用',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    INDEX idx_email (email),
    INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

-- ⚠️ 大表加字段可能导致锁表，生产环境用 pt-online-schema-change

-- 添加字段
ALTER TABLE users ADD COLUMN phone VARCHAR(20) AFTER email;

-- 修改字段类型
ALTER TABLE users MODIFY COLUMN phone VARCHAR(30);

-- 重命名字段
ALTER TABLE users CHANGE COLUMN phone mobile VARCHAR(20);

-- 删除字段（谨慎！）
ALTER TABLE users DROP COLUMN mobile;

-- 添加索引
ALTER TABLE users ADD INDEX idx_name (name);

-- 查看表大小（排查磁盘空间）
SELECT
    table_name,
    ROUND(((data_length + index_length) / 1024 / 1024), 2) AS 'size_mb'
FROM information_schema.tables
WHERE table_schema = 'mydb'
ORDER BY size_mb DESC;

-- operation_logs：记录每一次 API 请求的日志
-- 就像：每次有人访问你的网站，MySQL 都会记一条——是谁、什么时候、调了什么接口、花了多久、报错了没有
CREATE TABLE operation_logs (
    id          BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    trace_id    VARCHAR(32)     NOT NULL COMMENT '链路追踪ID（一个请求的唯一身份证号）',
    app_name    VARCHAR(50)     NOT NULL COMMENT '哪个应用产生的日志？如 order-api（订单服务）',
    log_level   ENUM('DEBUG','INFO','WARN','ERROR','FATAL') NOT NULL DEFAULT 'INFO',
    message     TEXT            NOT NULL COMMENT '日志的具体内容（报错信息/描述）',
    req_ip      VARCHAR(45)     NOT NULL COMMENT '请求来源的 IP 地址',
    user_id     INT UNSIGNED    DEFAULT NULL COMMENT '操作用户ID（没登录就是 NULL）',
    api_path    VARCHAR(200)    DEFAULT NULL COMMENT '请求的接口路径，如 /api/order/create',
    status_code SMALLINT        DEFAULT NULL COMMENT 'HTTP 状态码（200=成功, 404=找不到, 500=服务器错误）',
    cost_ms     INT UNSIGNED    DEFAULT 0 COMMENT '这个请求花了多少毫秒',
    created_at  DATETIME(3)     NOT NULL COMMENT '日志产生的时间（精确到毫秒）',
    INDEX idx_app_level (app_name, log_level),
    INDEX idx_created (created_at),
    INDEX idx_user (user_id),
    INDEX idx_api_status (api_path(100), status_code)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='操作日志表';

-- users：用户基本信息
CREATE TABLE users (
    id         INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name       VARCHAR(100) NOT NULL,
    role       ENUM('admin','ops','dev','viewer') NOT NULL DEFAULT 'dev',
    status     TINYINT DEFAULT 1 COMMENT '1=正常 0=禁用',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

FROM         → 第一步：从哪张表拿数据？
    ↓
WHERE        → 第二步：筛选哪些行留下？
    ↓
GROUP BY     → 第三步：要不要分组统计？
    ↓
HAVING       → 第四步：分组后还要不要过滤（很少用）？
    ↓
SELECT       → 第五步：我要看哪些列？
    ↓
ORDER BY     → 第六步：按什么排序？
    ↓
LIMIT        → 第七步：只要前 N 条

-- 需求：查某段时间内、某应用的 ERROR 日志
SELECT trace_id, created_at, message, api_path, cost_ms, req_ip   ← 第⑤步：我只想看这 6 列
FROM   operation_logs                                               ← 第①步：从日志表里找
WHERE  app_name   = 'order-api'                                     ← 第②步：只留 order-api 的记录
  AND  log_level  = 'ERROR'                                         ← 第②步：只留 ERROR 级别的
  AND  created_at >= '2026-06-23 09:50:00'                          ← 第②步：只要 9:50 之后的
  AND  created_at <  '2026-06-23 10:00:00'                          ← 第②步：只要 10:00 之前的
ORDER BY created_at DESC;                                           ← 第⑥步：最新的排最上面

Q：为什么用 >= 和 <，而不是 BETWEEN？
A：BETWEEN 包含两边，BETWEEN '09:50' AND '10:00' 会包含 10:00:00 整。
   用 >= AND < 叫"左闭右开区间"，是时间范围查询的标准写法，不会多出下一秒的数据。

Q：为什么 ORDER BY created_at DESC 而不是 ASC？
A：DESC = 倒序（最新的在前）。排障时永远先看最近的——10:00 的 ERROR 比 09:50 的更有参考价值。

+----------------------------------+-------------------------+--------------------------------------+-------------------+--------+-------------+
| trace_id                         | created_at              | message                              | api_path          | cost_ms| req_ip      |
+----------------------------------+-------------------------+--------------------------------------+-------------------+--------+-------------+
| a1b2c3d4-e5f6-7890-abcd-ef123456 | 2026-06-23 09:59:58.123 | [Timeout] Redis read timeout after 3s| /api/order/create |   3210 | 10.0.1.50   |
| a1b2c3d4-e5f6-7890-abcd-ef789012 | 2026-06-23 09:55:32.456 | [DBError] Deadlock found when trying.| /api/order/pay    |   5432 | 10.0.1.88   |
+----------------------------------+-------------------------+--------------------------------------+-------------------+--------+-------------+

SELECT COUNT(*) AS error_count, api_path
FROM   operation_logs
WHERE  app_name   = 'order-api'
  AND  log_level  = 'ERROR'
  AND  created_at >= NOW() - INTERVAL 5 MINUTE    -- NOW() 是"当前时间"，减 5 分钟
GROUP BY api_path
ORDER BY error_count DESC;

SELECT created_at, log_level, api_path, message, cost_ms
FROM   operation_logs
WHERE  trace_id = 'a1b2c3d4-e5f6-7890-abcd-ef123456'   -- 限定是这个请求
ORDER BY created_at ASC;                                   -- ASC = 正序（最早的在前）

Q：为什么这里用 ASC（正序）？
A：你要看的是"一个请求从开始到结束的全过程"——正序排列就像看录像带从头播到尾。
   刚才场景 1 用 DESC 是因为"哪个错误最新"。

Q：trace_id 是什么？
A：每个请求进系统时就分配一个唯一 ID。这个 ID 会传递到所有下游服务。
   拿着这个 ID，你就能把同一个请求在前端、网关、后端、数据库的日志全部串起来。

SELECT                                                                         ← 第⑤步
    DATE_FORMAT(created_at, '%Y-%m-%d %H:00') AS time_bucket,                -- 把时间切成"小时块"
    COUNT(*)                                   AS total_reqs,                 -- 这个小时总共有多少次请求
    SUM(IF(status_code >= 500, 1, 0))          AS error_5xx,                  -- 其中 500 以上的有多少次
    ROUND(AVG(cost_ms), 1)                     AS avg_cost_ms,                -- 平均耗时
    ROUND(MAX(cost_ms), 0)                     AS max_cost_ms,                -- 最大耗时（最慢的那次）
    CONCAT(ROUND(SUM(IF(status_code >= 500, 1, 0)) * 100.0 / COUNT(*), 2), '%') AS error_rate  -- 错误率
FROM   operation_logs                                                           ← 第①步
WHERE  app_name = 'order-api'                                                  ← 第②步
  AND  created_at >= NOW() - INTERVAL 24 HOUR                                  ← 第②步：过去 24 小时
GROUP BY DATE_FORMAT(created_at, '%Y-%m-%d %H:00')                             ← 第③步：按"小时"分组
ORDER BY time_bucket ASC;                                                      ← 第⑥步

错误的请求数 × 100 ÷ 总请求数 = 错误率%

举例（10:00~10:59 这小时）：
  总请求 4210 次，其中 380 次返回 500
  错误率 = 380 × 100 ÷ 4210 = 9.03%

+------------------+-----------+----------+-------------+------------+------------+
| time_bucket      | total_reqs| error_5xx| avg_cost_ms | max_cost_ms| error_rate |
+------------------+-----------+----------+-------------+------------+------------+
| 2026-06-22 09:00 |      3520 |       12 |         45.2 |       2100 | 0.34%      |
| 2026-06-22 10:00 |      4210 |      380 |        320.5 |       8910 | 9.03%      | ← 拐点！
| 2026-06-22 11:00 |      1080 |      420 |        980.0 |      15000 | 38.89%     | ← 扩大
+------------------+-----------+----------+-------------+------------+------------+

SELECT
    DATE(created_at)         AS day,         -- DATE() 只取年月日
    COUNT(*)                 AS total,
    SUM(IF(log_level='ERROR', 1, 0)) AS errors,
    ROUND(AVG(cost_ms), 0)   AS avg_latency
FROM   operation_logs
WHERE  app_name = 'order-api'
  AND  created_at >= CURDATE() - INTERVAL 14 DAY
GROUP BY DATE(created_at)
ORDER BY day DESC;

SELECT trace_id, created_at, log_level, message, api_path, cost_ms
FROM   operation_logs
WHERE  app_name = 'order-api'
  AND  created_at >= '2026-06-23 00:00:00'
  AND  message LIKE '%Redis timeout%'    -- 包含这个关键词（不管在哪）
ORDER BY created_at DESC
LIMIT 50;

情况 1：MySQL 数据不多（几百万行）+ 时间范围小 → 可以 LIKE
情况 2：MySQL 数据多 + 经常搜关键词 → 上 Elasticsearch（ELK）
情况 3：临时查一下 → 缩小时间窗口，加更多 WHERE 条件

SELECT trace_id, message, api_path
FROM   operation_logs
WHERE  app_name = 'order-api'
  AND  created_at >= '2026-06-23 09:50:00'          -- ✅ 只搜 10 分钟
  AND  created_at <  '2026-06-23 10:00:00'
  AND  (message LIKE '%Redis%' OR message LIKE '%timeout%')   -- 多关键词
  AND  log_level IN ('ERROR', 'WARN')                 -- ✅ 只看 WARN 以上
ORDER BY created_at DESC;

SELECT api_path,
       COUNT(*)                AS call_count,
       ROUND(AVG(cost_ms), 0) AS avg_ms,
       ROUND(MAX(cost_ms), 0) AS max_ms
FROM   operation_logs
WHERE  app_name = 'order-api'
  AND  created_at >= CURDATE() - INTERVAL 1 DAY
GROUP BY api_path
HAVING call_count > 100                              -- 冷门接口不具统计意义，排除
ORDER BY avg_ms DESC
LIMIT 10;

日志表（左）              用户表（右）
+--------+--------+     +--------+--------+--------+
| log_id | user_id|     | id     | name   | role   |
+--------+--------+     +--------+--------+--------+
| L01    | 12345  |     | 12345  | 张三   | admin  |
| L02    | 12346  |     | 12346  | 李四   | dev    |
+--------+--------+     +--------+--------+--------+

JOIN 的意思："把 user_id 对上 id，两边拼在一起"

结果：
+--------+--------+--------+--------+--------+
| log_id | user_id| id     | name   | role   |
+--------+--------+--------+--------+--------+
| L01    | 12345  | 12345  | 张三   | admin  |
| L02    | 12346  | 12346  | 李四   | dev    |
+--------+--------+--------+--------+--------+

SELECT
    l.created_at, l.log_level, l.api_path, l.message,          -- 来自日志表（l）
    u.name AS user_name, u.role AS user_role, u.status AS user_status  -- 来自用户表（u）
FROM   operation_logs l       -- l 是简称
JOIN   users u ON l.user_id = u.id   -- 🔑 关键：把 l.user_id 和 u.id 对上
WHERE  l.user_id = 12345
  AND  l.log_level IN ('ERROR', 'WARN')
  AND  l.created_at >= '2026-06-01'
ORDER BY l.created_at DESC
LIMIT 20;

JOIN（INNER JOIN）：两边都有的才保留
  日志的 user_id=12345，用户表有 → 保留
  日志的 user_id=NULL        → 丢掉这条日志

LEFT JOIN：左边表全部保留，右边有就拼上，没有就 NULL
  日志的 user_id=NULL        → 保留，但 user_name 显示 NULL

SELECT l.created_at, l.api_path, l.status_code, l.message, u.name, u.role
FROM   operation_logs l
LEFT JOIN users u ON l.user_id = u.id      -- 用 LEFT JOIN！
WHERE  l.req_ip = '10.0.1.50'
  AND  l.created_at >= '2026-06-23 09:30:00'
  AND  l.created_at <  '2026-06-23 10:00:00'
ORDER BY l.created_at ASC;

SELECT api_path, total, errors,
       ROUND(errors * 100.0 / total, 2) AS error_rate
FROM (
    -- 里面先算每个接口的总数和错误数
    SELECT api_path,
           COUNT(*) AS total,
           SUM(IF(status_code >= 500, 1, 0)) AS errors
    FROM operation_logs
    WHERE app_name = 'order-api'
      AND created_at >= CURDATE() - INTERVAL 1 DAY
    GROUP BY api_path
) AS stats                            -- 临时表，起名叫 stats
WHERE errors * 100.0 / total > 5       -- 在外面过滤
ORDER BY errors DESC;

第①步（先执行括号里的）：
  FROM operation_logs → WHERE → GROUP BY → 算出临时表 stats
  +---------------------+-------+--------+
  | api_path            | total | errors |
  +---------------------+-------+--------+
  | /api/order/create   | 35210 |   2850 |
  | /api/payment/pay    | 18200 |   1200 |
  | /api/user/login     | 88000 |    400 |
  +---------------------+-------+--------+

第②步（执行外层的）：
  FROM stats → WHERE errors/total > 5% → SELECT 并计算 error_rate
  +---------------------+-------+--------+------------+
  | /api/order/create   | 35210 |   2850 |      8.09% |
  | /api/payment/pay    | 18200 |   1200 |      6.59% |
  +---------------------+-------+--------+------------+
  /api/user/login 调了 88000 次但只错 400 次（0.45%），被过滤掉

WITH api_stats AS (                           -- 先定义一个"临时视图"
    SELECT api_path,
           COUNT(*) AS total,
           SUM(IF(status_code >= 500, 1, 0)) AS errors
    FROM operation_logs
    WHERE app_name = 'order-api'
      AND created_at >= CURDATE() - INTERVAL 1 DAY
    GROUP BY api_path
)
SELECT api_path, total, errors,
       ROUND(errors * 100.0 / total, 2) AS error_rate
FROM   api_stats
WHERE  errors * 100.0 / total > 5
ORDER BY errors DESC;

WITH api_stats AS (...)
SELECT * FROM api_stats
WHERE errors * 100.0 / total > 5      -- 条件 1：错误率高
   OR avg_ms > 1000                    -- 条件 2：平均耗时 > 1 秒

SELECT
    CASE                                                          -- "如果...就..."
        WHEN log_level IN ('FATAL', 'ERROR') THEN '严重'             -- FATAL 或 ERROR → 严重
        WHEN log_level = 'WARN'               THEN '警告'             -- WARN → 警告
        ELSE                                                  '正常'  -- 剩下的 → 正常
    END AS severity,                                                -- 结果起名叫 severity
    COUNT(*) AS cnt
FROM   operation_logs
WHERE  app_name = 'order-api'
  AND  created_at >= NOW() - INTERVAL 7 DAY
GROUP BY severity
ORDER BY cnt DESC;

MySQL 逐行读日志，对每一行：
  第 1 行：log_level = 'INFO'
    → 检查 WHEN IN ('FATAL','ERROR') → 不是
    → 检查 WHEN = 'WARN' → 不是
    → ELSE → '正常'

  第 2 行：log_level = 'FATAL'
    → 检查 WHEN IN ('FATAL','ERROR') → 是！→ '严重'（跳过后面）

  第 3 行：log_level = 'WARN'
    → 检查 WHEN IN ('FATAL','ERROR') → 不是
    → 检查 WHEN = 'WARN' → 是！→ '警告'

然后 GROUP BY severity 把相同标签的归一堆，COUNT(*) 数每堆多少条。

+----------+-------+
| severity | cnt   |
+----------+-------+
| 正常     | 285000|
| 警告     |   3200|
| 严重     |    480|
+----------+-------+

SELECT
    CASE
        WHEN status_code >= 200 AND status_code < 300 THEN '2xx 成功'
        WHEN status_code >= 400 AND status_code < 500 THEN '4xx 客户端错误'  -- 用户的问题
        WHEN status_code >= 500 THEN '5xx 服务端错误'                          -- 我们的问题
        ELSE '其他'
    END AS status_category,
    COUNT(*) AS cnt,
    CONCAT(ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER(), 1), '%') AS pct
FROM   operation_logs
WHERE  app_name = 'order-api'
  AND  created_at >= CURDATE()
GROUP BY status_category
ORDER BY cnt DESC;

9:00 组 → /api/order/create  45次
9:00 组 → /api/order/pay     30次
9:00 组 → /api/user/login     8次

9:00 组 → /api/order/create  45次  排名 1
9:00 组 → /api/order/pay     30次  排名 2
9:00 组 → /api/user/login     8次  排名 3

ROW_NUMBER() OVER (
    PARTITION BY 分组依据     ← "在每个组内"
    ORDER BY 排序依据         ← "按什么排序来排名"
) AS 排名

WITH hourly_errors AS (
    SELECT
        DATE_FORMAT(created_at, '%Y-%m-%d %H:00') AS hour_bucket,
        api_path,
        COUNT(*) AS error_count,
        ROW_NUMBER() OVER (                                          -- 🆕 窗口函数
            PARTITION BY DATE_FORMAT(created_at, '%Y-%m-%d %H:00')  -- 按"小时"分组
            ORDER BY COUNT(*) DESC                                  -- 错误数多的排前面
        ) AS rn                                                      -- 排名结果叫 rn
    FROM operation_logs
    WHERE app_name = 'order-api'
      AND log_level IN ('ERROR', 'FATAL')
      AND created_at >= CURDATE() - INTERVAL 1 DAY
    GROUP BY hour_bucket, api_path
)
SELECT hour_bucket, api_path, error_count
FROM   hourly_errors
WHERE  rn <= 3                                                      -- 只要前 3 名
ORDER BY hour_bucket DESC, rn ASC;

第①步：GROUP BY 算出每小时每个接口的错误数
第②步：ROW_NUMBER() 在每个小时组内排名
  → 9:00 组：create=1, pay=2, login=3, refund=4
  → 8:00 组：create=1, refund=2
第③步：WHERE rn <= 3 → 过滤掉排名 4 以后的

+------------------+---------------------+-------------+
| hour_bucket      | api_path            | error_count |
+------------------+---------------------+-------------+
| 2026-06-22 09:00 | /api/order/create   |          45 |
| 2026-06-22 09:00 | /api/order/pay      |          30 |
| 2026-06-22 09:00 | /api/user/login     |           8 |
| 2026-06-22 08:00 | /api/order/create   |          12 |
| 2026-06-22 08:00 | /api/order/refund   |           5 |
+------------------+---------------------+-------------+

-- ❌ 不要这样写！OFFSET 越大越慢
SELECT * FROM operation_logs WHERE log_level = 'ERROR'
ORDER BY id LIMIT 100 OFFSET 100000;

-- ✅ 方案一：游标分页（用 id 定位）
-- 第 1 页：
SELECT * FROM operation_logs WHERE log_level = 'ERROR'
ORDER BY id LIMIT 100;                    -- 最后一条 id = 100100

-- 第 2 页（记住上次的位置）：
SELECT * FROM operation_logs
WHERE log_level = 'ERROR'
  AND id > 100100                        -- 🔑 直接从 100100 之后查
ORDER BY id LIMIT 100;

-- ✅ 方案二：按时间分批（导出数据最实用）
SELECT * FROM operation_logs
WHERE created_at >= '2026-06-01'
  AND created_at <  '2026-06-02'          -- 每次拿 1 天
ORDER BY id ASC;

-- 单条插入：一次加一行
INSERT INTO operation_logs
    (trace_id, app_name, log_level, message, req_ip, api_path, cost_ms, created_at)
VALUES
    ('manual-001', 'order-api', 'INFO', '手动回放请求确认修复', '127.0.0.1', '/api/check', 0, NOW());

-- 批量插入：一次加多条（比逐条快 50 倍）
INSERT INTO operation_logs (trace_id, app_name, log_level, message, req_ip, api_path, cost_ms, created_at)
VALUES
    ('batch-001', 'order-api', 'ERROR', 'DB connection timeout', '10.0.1.1', '/api/order', 3210, NOW()),
    ('batch-002', 'order-api', 'WARN',  'Slow query detected',  '10.0.1.2', '/api/user', 2100, NOW()),
    ('batch-003', 'order-api', 'INFO',  'Request completed',    '10.0.1.3', '/api/ok',     45, NOW());

-- ❌ 错误：忘写 WHERE → 全表更新！没有后悔药
-- UPDATE operation_logs SET log_level = 'ERROR';

-- ✅ 正确：
-- 第①步：先 SELECT 确认
SELECT id, log_level FROM operation_logs WHERE id = 12345;
-- 第②步：确认无误再 UPDATE
UPDATE operation_logs SET log_level = 'ERROR' WHERE id = 12345;

-- 批量更新（记得加时间范围）
UPDATE operation_logs
SET log_level = 'DEBUG'
WHERE req_ip = '10.0.1.100'
  AND created_at >= '2026-06-01';   -- ✅ 加时间范围，避免全表锁

-- 每次只删 1 万行，跑完等 1 秒再下一批
DELETE FROM operation_logs
WHERE created_at < '2026-01-01'
LIMIT 10000;

-- Shell 循环脚本：
-- while true; do
--   mysql -e "DELETE FROM operation_logs WHERE created_at < '2026-01-01' LIMIT 10000;"
--   sleep 1
-- done

-- 建分区表（按月）
CREATE TABLE operation_logs_partitioned (
    id BIGINT UNSIGNED AUTO_INCREMENT,
    -- ...
    created_at DATETIME(3) NOT NULL,
    PRIMARY KEY (id, created_at)    -- 分区键必须包含在主键中！
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
PARTITION BY RANGE (TO_DAYS(created_at)) (
    PARTITION p202606 VALUES LESS THAN (TO_DAYS('2026-07-01')),
    PARTITION p202607 VALUES LESS THAN (TO_DAYS('2026-08-01')),
    PARTITION p202608 VALUES LESS THAN (TO_DAYS('2026-09-01')),
    PARTITION p_future VALUES LESS THAN MAXVALUE
);

-- 清理旧分区：秒级！
ALTER TABLE operation_logs_partitioned DROP PARTITION p202606;

-- 查看表的索引
SHOW INDEX FROM users;

-- 找出没有主键的表（运维巡检用）
SELECT table_schema, table_name
FROM information_schema.tables
WHERE engine = 'InnoDB'
  AND table_schema NOT IN ('mysql', 'sys', 'performance_schema', 'information_schema')
  AND (SELECT COUNT(*) FROM information_schema.statistics
       WHERE table_schema = information_schema.tables.table_schema
         AND table_name = information_schema.tables.table_name
         AND index_name = 'PRIMARY') = 0;

-- 添加普通索引
CREATE INDEX idx_email ON users(email);

-- 添加唯一索引
CREATE UNIQUE INDEX idx_email_unique ON users(email);

-- 添加复合索引（最左前缀原则）
-- 场景：经常按 status + created_at 查询
CREATE INDEX idx_status_created ON users(status, created_at);

-- 删除索引
DROP INDEX idx_email ON users;

-- 查看索引使用情况（排查慢查询）
SELECT * FROM sys.schema_unused_indexes;

EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';
-- 看 type 列：const > ref > range > index > ALL（ALL 就是全表扫描）

-- 创建用户（密码用强密码）
CREATE USER 'app_user'@'10.0.1.%' IDENTIFIED BY 'StrongP@ss123';

-- 查看所有用户
SELECT user, host, account_locked FROM mysql.user;

-- 授予库级权限（最小权限原则）
GRANT SELECT, INSERT, UPDATE, DELETE ON mydb.* TO 'app_user'@'10.0.1.%';

-- 授予只读账号（报表查询专用）
GRANT SELECT ON mydb.* TO 'readonly'@'10.0.1.%';

-- 授予 DBA 权限（仅限个人账号）
GRANT ALL PRIVILEGES ON *.* TO 'dba_zhangsan'@'10.0.1.%' WITH GRANT OPTION;

-- 刷新权限（修改权限后必须执行）
FLUSH PRIVILEGES;

-- 查看用户权限
SHOW GRANTS FOR 'app_user'@'10.0.1.%';

-- 撤销权限
REVOKE DELETE ON mydb.* FROM 'app_user'@'10.0.1.%';

-- 删除用户
DROP USER 'old_user'@'10.0.1.%';

# 备份单个库
mysqldump -h 10.0.1.100 -u root -p --single-transaction --routines --triggers --events mydb > mydb_20260623.sql

# 备份多个库
mysqldump -h 10.0.1.100 -u root -p --single-transaction --databases db1 db2 db3 > multi_db.sql

# 备份全部库
mysqldump -h 10.0.1.100 -u root -p --single-transaction --all-databases --routines > all_dbs.sql

# 只导结构（不要数据）
mysqldump -h 10.0.1.100 -u root -p --no-data mydb > mydb_schema.sql

# 恢复单个库
mysql -h 10.0.1.100 -u root -p mydb < mydb_20260623.sql

# 或者在 MySQL 内执行
mysql> source /backup/mydb_20260623.sql;

# 只看备份中的建表语句，不看数据
grep "^CREATE TABLE" mydb_20260623.sql | head -10

# 查看备份文件大小
ls -lh mydb_20260623.sql

-- 开启慢查询日志（临时，当前会话有效）
SET GLOBAL slow_query_log = ON;
SET GLOBAL long_query_time = 2;  -- 超过 2 秒的记录
SET GLOBAL slow_query_log_file = '/var/log/mysql/slow.log';

-- 查看当前正在执行的查询（排查"卡住"的情况）
SELECT * FROM sys.session
WHERE command != 'Sleep' AND time > 10;

-- 查看最近 10 条慢查询（需要 performance_schema）
SELECT * FROM sys.statement_analysis
WHERE avg_latency > 100000000000  -- 大于 100 秒
ORDER BY avg_latency DESC
LIMIT 10;

-- 1. 找到慢查询的 SQL（从慢查询日志）
-- 2. 用 EXPLAIN 分析执行计划
EXPLAIN SELECT * FROM orders WHERE user_id = 123 ORDER BY created_at DESC;

-- 3. 看 type 和 rows 字段
--    type=ALL → 全表扫描，需要加索引
--    rows=100000 → MySQL 扫描了 10 万行，很大

-- 4. 看是否有文件排序
--    Extra: "Using filesort" → 排序字段没索引
--    加复合索引：CREATE INDEX idx_user_created ON orders(user_id, created_at);

-- 查看各库磁盘占用
SELECT
    table_schema AS '数据库',
    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS '总大小(MB)',
    ROUND(SUM(data_length) / 1024 / 1024, 2) AS '数据(MB)',
    ROUND(SUM(index_length) / 1024 / 1024, 2) AS '索引(MB)'
FROM information_schema.tables
GROUP BY table_schema
ORDER BY SUM(data_length + index_length) DESC;

-- 查看碎片率（碎片率 > 30% 考虑 OPTIMIZE）
SELECT
    table_name,
    ROUND(data_free / 1024 / 1024, 2) AS '碎片大小(MB)',
    ROUND(data_free * 100 / (data_length + index_length), 2) AS '碎片率(%)'
FROM information_schema.tables
WHERE table_schema = 'mydb' AND data_free > 0
ORDER BY data_free DESC;

-- 查看当前事务（排查事务未提交导致的锁）
SELECT * FROM information_schema.INNODB_TRX\G

-- 查看当前锁等待（排查死锁）
SELECT * FROM sys.innodb_lock_waits;

-- 强制结束长时间未提交的事务（最后手段）
-- KILL 查询线程 ID（从 PROCESSLIST 查到的 id）
KILL 12345;

-- 开启事务
START TRANSACTION;

-- 执行操作
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;

-- 提交（成功）
COMMIT;

-- 或回滚（失败）
ROLLBACK;

-- 查看当前隔离级别（默认 REPEATABLE-READ）
SELECT @@transaction_isolation;

-- 修改隔离级别（当前会话）
SET SESSION transaction_isolation = 'READ-COMMITTED';

-- 查看最近一次死锁日志
SHOW ENGINE INNODB STATUS\G

-- 查看当前锁等待信息
SELECT * FROM sys.innodb_lock_waits;

------------------------
LATEST DETECTED DEADLOCK
------------------------
*** (1) TRANSACTION:  // 事务1：等待 A 锁
*** (2) TRANSACTION:  // 事务2：等待 B 锁，持有 A 锁
*** WE ROLL BACK TRANSACTION (2)  // 自动回滚事务2

# 一键检查 MySQL 健康状态（返回关键指标，适合写入监控脚本）
mysqladmin -h 10.0.1.100 -u root -p ping
mysqladmin -h 10.0.1.100 -u root -p status
mysqladmin -h 10.0.1.100 -u root -p extended-status

# 或者 Shell 脚本方式
mysql -h 10.0.1.100 -u root -p -e "
SELECT 'Uptime' as k, VARIABLE_VALUE as v FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Uptime'
UNION ALL
SELECT 'Connections', VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Threads_connected'
UNION ALL
SELECT 'Slow_queries', VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Slow_queries';
"

-- 1. 用 root 账号登录
mysql -u root -p

-- 2. 查看当前连接分布
SELECT user, COUNT(*) AS cnt FROM information_schema.PROCESSLIST GROUP BY user;

-- 3. 临时加大连接数
SET GLOBAL max_connections = 500;

-- 4. 杀掉空闲连接（注意：不要 kill 重要业务连接）
-- 杀掉 Sleep 超过 300 秒的连接
SELECT CONCAT('KILL ', id, ';') AS kill_cmd
FROM information_schema.PROCESSLIST
WHERE command = 'Sleep' AND time > 300;
-- 把输出的 KILL 语句复制执行

# 1. 清理慢查询日志 / 错误日志
truncate -s 0 /var/log/mysql/slow.log
truncate -s 0 /var/log/mysql/error.log

# 2. 清理 binlog（确认从库已同步后）
mysql -u root -p -e "PURGE BINARY LOGS BEFORE NOW() - INTERVAL 7 DAY;"

# 3. 如果还不行，清理大表历史数据
# 见 DELETE 分批删除章节

-- 1. 查看延迟
SHOW SLAVE STATUS\G
-- 看 Seconds_Behind_Master 字段

-- 2. 常见原因：
--    - 从库写入慢 → 升级从库配置或优化慢查询
--    - 大事务 → 避免长事务，大操作分批执行
--    - 从库在做备份 → 错开备份时间

-- 3. 临时跳过错误（不推荐，仅紧急恢复用）
STOP SLAVE;
SET GLOBAL sql_slave_skip_counter = 1;
START SLAVE;