MySQL数据库多表操作与高级查询实践技巧整理实用指南

-- 添加字段的三种方式
ALTER TABLE employees ADD COLUMN email VARCHAR(100); -- 默认末尾
ALTER TABLE employees ADD COLUMN id INT FIRST; -- 添加到第一列
ALTER TABLE employees ADD COLUMN age INT AFTER name; -- 指定位置

-- 修改字段的注意事项
ALTER TABLE employees MODIFY COLUMN email VARCHAR(150); -- 扩展长度
ALTER TABLE employees CHANGE COLUMN email work_email VARCHAR(150); -- 重命名

-- 特别提醒：大表结构变更要谨慎
-- 生产环境建议：
-- 1. 先在测试环境验证
-- 2. 选择业务低峰期执行
-- 3. 对于超大表考虑使用pt-online-schema-change工具

-- 多维度聚合分析
SELECT 
    product_category,
    COUNT(*) AS order_count,
    SUM(amount) AS total_sales,
    AVG(amount) AS avg_order_value,
    MAX(amount) AS max_order,
    MIN(amount) AS min_order
FROM orders
WHERE order_date BETWEEN '2023-01-01' AND '2023-12-31'
GROUP BY product_category
HAVING total_sales > 10000
ORDER BY total_sales DESC;

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(100) UNIQUE,
    age INT CHECK (age >= 18),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    is_active BOOLEAN DEFAULT TRUE
);

-- 复合唯一约束
ALTER TABLE user_roles ADD CONSTRAINT uk_user_role 
UNIQUE (user_id, role_id);

-- 基础分页（小数据量适用）
SELECT * FROM products ORDER BY id LIMIT 20 OFFSET 40;

-- 大数据量优化方案（记住上一页最后ID）
SELECT * FROM products 
WHERE id > 1000  -- 上一页最后一条记录的ID
ORDER BY id 
LIMIT 20;

-- 带条件的分页优化
SELECT p.* FROM products p
JOIN (
    SELECT id FROM products
    WHERE category = 'electronics'
    ORDER BY price DESC
    LIMIT 20 OFFSET 40
) AS tmp USING(id);

-- 单维度ROLLUP
SELECT 
    department,
    COUNT(*) AS emp_count,
    SUM(salary) AS total_salary
FROM employees
GROUP BY department WITH ROLLUP;

-- 多维度CUBE（MySQL 8.0+）
SELECT 
    department,
    job_title,
    COUNT(*) AS emp_count
FROM employees
GROUP BY department, job_title WITH CUBE;

-- 替代方案：使用UNION ALL模拟CUBE
SELECT department, job_title, COUNT(*) 
FROM employees GROUP BY department, job_title
UNION ALL
SELECT department, NULL, COUNT(*) 
FROM employees GROUP BY department
UNION ALL
SELECT NULL, job_title, COUNT(*) 
FROM employees GROUP BY job_title
UNION ALL
SELECT NULL, NULL, COUNT(*) FROM employees;

-- 低效的IN子查询
SELECT * FROM orders 
WHERE customer_id IN (
    SELECT id FROM customers WHERE vip = 1
);

-- 优化为JOIN
SELECT o.* FROM orders o
JOIN customers c ON o.customer_id = c.id
WHERE c.vip = 1;

-- EXISTS更适合判断存在性
SELECT * FROM products p
WHERE EXISTS (
    SELECT 1 FROM inventory 
    WHERE product_id = p.id AND quantity > 0
);

-- 派生表优化
SELECT t.* FROM (
    SELECT product_id, SUM(amount) AS total 
    FROM sales 
    GROUP BY product_id
) AS t
WHERE t.total > 1000;

-- 用户基础表
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL
);

-- 用户详情表（一对一）
CREATE TABLE user_profiles (
    user_id INT PRIMARY KEY,
    full_name VARCHAR(100),
    birth_date DATE,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- 查询示例
SELECT u.username, p.full_name 
FROM users u
LEFT JOIN user_profiles p ON u.id = p.user_id;

-- 部门表
CREATE TABLE departments (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    location VARCHAR(100)
);

-- 员工表
CREATE TABLE employees (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    department_id INT,
    FOREIGN KEY (department_id) REFERENCES departments(id)
);

-- 索引建议
CREATE INDEX idx_emp_dept ON employees(department_id);

-- 学生表
CREATE TABLE students (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL
);

-- 课程表
CREATE TABLE courses (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(100) NOT NULL,
    credit INT
);

-- 关联表
CREATE TABLE student_courses (
    student_id INT,
    course_id INT,
    enrollment_date DATE,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES students(id),
    FOREIGN KEY (course_id) REFERENCES courses(id)
);

-- 查询学生选课情况
SELECT s.name, c.title 
FROM students s
JOIN student_courses sc ON s.id = sc.student_id
JOIN courses c ON sc.course_id = c.id;

-- 内连接：只返回匹配记录
SELECT o.order_id, c.customer_name
FROM orders o
INNER JOIN customers c ON o.customer_id = c.id;

-- 左连接：返回左表所有记录
SELECT d.dept_name, e.emp_name
FROM departments d
LEFT JOIN employees e ON d.id = e.dept_id;

-- 右连接：返回右表所有记录
SELECT e.emp_name, p.project_name
FROM employees e
RIGHT JOIN projects p ON e.id = p.lead_id;

-- 全外连接模拟（MySQL不支持FULL OUTER JOIN）
SELECT * FROM t1 LEFT JOIN t2 ON t1.id = t2.id
UNION
SELECT * FROM t1 RIGHT JOIN t2 ON t1.id = t2.id WHERE t1.id IS NULL;

-- 确保连接字段有索引
EXPLAIN SELECT * FROM orders o JOIN customers c ON o.customer_id = c.id;

-- 减少连接的数据量
SELECT o.*, c.name 
FROM (SELECT * FROM orders WHERE status = 'completed') o
JOIN customers c ON o.customer_id = c.id;

-- 使用STRAIGHT_JOIN控制连接顺序
SELECT STRAIGHT_JOIN o.*, c.* 
FROM orders o JOIN customers c ON o.customer_id = c.id
WHERE o.amount > 1000;

-- 错误：Cannot add or update a child row: a foreign key constraint fails
-- 解决方案：
-- 1. 检查被引用表是否存在对应主键
-- 2. 检查数据类型是否匹配
-- 3. 临时禁用外键检查（慎用）
SET FOREIGN_KEY_CHECKS = 0;
-- 执行操作
SET FOREIGN_KEY_CHECKS = 1;

-- 错误：Expression #2 of SELECT list is not in GROUP BY clause
-- 解决方案：
-- 方法1：修改SQL模式
SET SESSION sql_mode=(SELECT REPLACE(@@sql_mode,'ONLY_FULL_GROUP_BY',''));
-- 方法2：确保SELECT字段都在GROUP BY中或使用聚合函数

-- 多列索引最左前缀原则
CREATE INDEX idx_name ON users(last_name, first_name);
-- 能使用索引的情况
SELECT * FROM users WHERE last_name = 'Smith';
SELECT * FROM users WHERE last_name = 'Smith' AND first_name = 'John';
-- 不能使用索引的情况
SELECT * FROM users WHERE first_name = 'John';

-- 覆盖索引优化
CREATE INDEX idx_cover ON orders(customer_id, status, amount);
-- 直接使用索引数据，避免回表
SELECT customer_id, status FROM orders WHERE customer_id = 100;

-- 原查询（使用OR效率低）
SELECT * FROM products 
WHERE category = 'electronics' OR price > 1000;

-- 优化为UNION
SELECT * FROM products WHERE category = 'electronics'
UNION
SELECT * FROM products WHERE price > 1000;

-- 使用派生表优化复杂查询
SELECT * FROM (
    SELECT * FROM orders 
    WHERE order_date > '2023-01-01'
) AS recent_orders
JOIN customers ON recent_orders.customer_id = customers.id;

# my.cnf关键参数
[mysqld]
innodb_buffer_pool_size = 4G  # 通常设为物理内存的70-80%
innodb_log_file_size = 256M
innodb_flush_log_at_trx_commit = 2  # 平衡性能与持久性
query_cache_size = 0  # MySQL 8.0已移除查询缓存

-- 多表关联的复杂报表
SELECT 
    o.order_id,
    DATE(o.order_date) AS order_day,
    c.customer_name,
    p.product_name,
    oi.quantity,
    oi.unit_price,
    (oi.quantity * oi.unit_price) AS item_total,
    o.total_amount,
    pm.payment_method,
    s.shipping_status
FROM orders o
JOIN customers c ON o.customer_id = c.id
JOIN order_items oi ON o.id = oi.order_id
JOIN products p ON oi.product_id = p.id
LEFT JOIN payment_methods pm ON o.payment_method_id = pm.id
LEFT JOIN shipping s ON o.id = s.order_id
WHERE o.order_date BETWEEN '2023-01-01' AND '2023-12-31'
ORDER BY o.order_date DESC
LIMIT 1000;

-- 使用子查询和连接
SELECT 
    p.id,
    p.product_name,
    p.reorder_level,
    COALESCE(SUM(i.quantity), 0) AS current_stock,
    CASE 
        WHEN COALESCE(SUM(i.quantity), 0) < p.reorder_level THEN '需要补货'
        ELSE '库存充足'
    END AS status
FROM products p
LEFT JOIN inventory i ON p.id = i.product_id
GROUP BY p.id
HAVING status = '需要补货';

-- 使用窗口函数（MySQL 8.0+）
SELECT 
    user_id,
    page_url,
    view_time,
    COUNT(*) OVER (PARTITION BY user_id) AS total_views,
    RANK() OVER (PARTITION BY user_id ORDER BY view_time DESC) AS recency_rank,
    LAG(page_url, 1) OVER (PARTITION BY user_id ORDER BY view_time) AS previous_page
FROM user_page_views
WHERE view_date = CURRENT_DATE()
ORDER BY user_id, view_time DESC;

-- 销售排名分析
SELECT 
    salesperson_id,
    sale_date,
    amount,
    SUM(amount) OVER (PARTITION BY salesperson_id) AS total_sales,
    RANK() OVER (ORDER BY amount DESC) AS sales_rank,
    AVG(amount) OVER (ORDER BY sale_date 
        RANGE BETWEEN INTERVAL 7 DAY PRECEDING AND CURRENT ROW) AS weekly_avg
FROM sales
WHERE sale_date BETWEEN '2023-01-01' AND '2023-12-31';

-- 递归CTE处理层级数据
WITH RECURSIVE org_hierarchy AS (
    -- 基础查询：顶级部门
    SELECT id, name, parent_id, 1 AS level
    FROM departments
    WHERE parent_id IS NULL
    
    UNION ALL
    
    -- 递归查询：子部门
    SELECT d.id, d.name, d.parent_id, h.level + 1
    FROM departments d
    JOIN org_hierarchy h ON d.parent_id = h.id
)
SELECT * FROM org_hierarchy
ORDER BY level, id;

-- 多级CTE简化复杂查询
WITH 
customer_orders AS (
    SELECT customer_id, COUNT(*) AS order_count
    FROM orders
    GROUP BY customer_id
),
high_value_customers AS (
    SELECT customer_id, SUM(amount) AS total_spent
    FROM orders
    GROUP BY customer_id
    HAVING total_spent > 10000
)
SELECT 
    c.id,
    c.name,
    co.order_count,
    hvc.total_spent
FROM customers c
LEFT JOIN customer_orders co ON c.id = co.customer_id
LEFT JOIN high_value_customers hvc ON c.id = hvc.customer_id
ORDER BY hvc.total_spent DESC;

-- 设置事务隔离级别
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;

-- 典型事务模式
START TRANSACTION;
-- 操作1：扣减库存
UPDATE inventory SET quantity = quantity - 1 
WHERE product_id = 100 AND quantity >= 1;
-- 操作2：创建订单
INSERT INTO orders (customer_id, product_id, quantity) 
VALUES (1, 100, 1);
-- 根据影响行数判断是否提交
IF ROW_COUNT() > 0 THEN
    COMMIT;
ELSE
    ROLLBACK;
END IF;

-- SELECT FOR UPDATE锁定关键资源
START TRANSACTION;
SELECT * FROM inventory 
WHERE product_id = 100 
FOR UPDATE;
-- 执行库存扣减
UPDATE inventory SET quantity = quantity - 1 
WHERE product_id = 100;
COMMIT;

-- 死锁预防策略：
-- 1. 按固定顺序访问表
-- 2. 减少事务持有锁的时间
-- 3. 使用较低的隔离级别
-- 4. 添加合理的索引减少锁定范围

-- 星型模型示例（数据仓库）
CREATE TABLE fact_sales (
    id INT PRIMARY KEY,
    date_id INT,
    product_id INT,
    customer_id INT,
    amount DECIMAL(10,2),
    quantity INT,
    FOREIGN KEY (date_id) REFERENCES dim_date(id),
    FOREIGN KEY (product_id) REFERENCES dim_products(id),
    FOREIGN KEY (customer_id) REFERENCES dim_customers(id)
);

-- 雪花模型示例
CREATE TABLE dim_products (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    category_id INT,
    FOREIGN KEY (category_id) REFERENCES dim_categories(id)
);

CREATE TABLE dim_categories (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    department_id INT,
    FOREIGN KEY (department_id) REFERENCES dim_departments(id)
);

-- 软删除实现
ALTER TABLE employees ADD COLUMN is_deleted BOOLEAN DEFAULT FALSE;
ALTER TABLE employees ADD COLUMN deleted_at TIMESTAMP NULL;

-- 查询时排除已删除记录
SELECT * FROM employees WHERE is_deleted = FALSE;

-- 历史数据追踪设计
CREATE TABLE employee_history (
    id INT PRIMARY KEY AUTO_INCREMENT,
    employee_id INT NOT NULL,
    field_name VARCHAR(50) NOT NULL,
    old_value TEXT,
    new_value TEXT,
    changed_by INT,
    change_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (employee_id) REFERENCES employees(id)
);

-- 使用触发器自动记录变更
CREATE TRIGGER track_employee_changes
AFTER UPDATE ON employees
FOR EACH ROW
BEGIN
    IF NEW.salary <> OLD.salary THEN
        INSERT INTO employee_history 
        (employee_id, field_name, old_value, new_value)
        VALUES (NEW.id, 'salary', OLD.salary, NEW.salary);
    END IF;
    -- 其他字段检查...
END;

-- 启用慢查询日志
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1; -- 超过1秒的查询
SET GLOBAL slow_query_log_file = '/var/log/mysql/mysql-slow.log';

-- 分析慢查询日志
mysqldumpslow -s t /var/log/mysql/mysql-slow.log

-- 使用performance_schema监控
SELECT * FROM performance_schema.events_statements_summary_by_digest
ORDER BY sum_timer_wait DESC LIMIT 10;

-- 查找缺失索引
SELECT * FROM sys.schema_unused_indexes;

-- 索引使用情况分析
SELECT * FROM sys.schema_index_statistics
WHERE table_schema = 'your_database';

-- 优化索引策略
-- 1. 为高频查询条件创建索引
-- 2. 考虑复合索引顺序（高选择性字段在前）
-- 3. 避免过度索引（每个索引增加写操作开销）
-- 4. 定期分析并删除未使用的索引

-- 按用户ID范围分片
CREATE TABLE orders_0 (
    id BIGINT PRIMARY KEY,
    user_id BIGINT,
    -- 其他字段
    CHECK (user_id % 4 = 0)
);

CREATE TABLE orders_1 (
    id BIGINT PRIMARY KEY,
    user_id BIGINT,
    -- 其他字段
    CHECK (user_id % 4 = 1)
);
-- 类似创建orders_2和orders_3

-- 路由查询示例
SET @shard_id = MOD(123456, 4);
SET @sql = CONCAT('SELECT * FROM orders_', @shard_id, ' WHERE user_id = 123456');
PREPARE stmt FROM @sql;
EXECUTE stmt;

-- 使用MySQL Router自动路由
-- 写操作发送到主库
INSERT INTO orders (...) VALUES (...);

-- 读操作发送到从库
-- 在代码中配置不同的数据源
-- 或使用中间件自动识别SELECT查询

# 逻辑备份（mysqldump）
mysqldump -u root -p --single-transaction --routines --triggers \
--all-databases > full_backup.sql

# 物理备份（Percona XtraBackup）
xtrabackup --backup --target-dir=/data/backups/
xtrabackup --prepare --target-dir=/data/backups/

# 启用二进制日志
[mysqld]
log-bin=mysql-bin
binlog_format=ROW

# 执行时间点恢复
mysqlbinlog --start-datetime="2023-01-01 00:00:00" \
--stop-datetime="2023-01-01 12:00:00" \
mysql-bin.000123 | mysql -u root -p

-- 使用AWS RDS参数组优化
-- 关键参数：
-- innodb_buffer_pool_size
-- innodb_io_capacity
-- innodb_read_io_threads

-- 监控性能指标
SELECT * FROM sys.metrics
WHERE variable_name LIKE 'innodb%'
ORDER BY variable_name;

# 使用连接池管理云数据库连接
import pymysql
from sqlalchemy import create_engine
# 创建连接池
engine = create_engine(
    'mysql+pymysql://user:pass@rds-instance:3306/db',
    pool_size=5,
    max_overflow=10,
    pool_recycle=3600
)
# 获取连接
conn = engine.connect()
try:
    result = conn.execute("SELECT * FROM users LIMIT 10")
    for row in result:
        print(row)
finally:
    conn.close()

-- 公用表表达式(CTE)
WITH regional_sales AS (
    SELECT region, SUM(amount) AS total_sales
    FROM orders
    GROUP BY region
)
SELECT region, total_sales
FROM regional_sales
WHERE total_sales > 100000;

-- 窗口函数
SELECT 
    product_id,
    sale_date,
    amount,
    SUM(amount) OVER (PARTITION BY product_id ORDER BY sale_date) AS running_total
FROM sales;

-- 不可见索引
CREATE INDEX idx_invisible ON customers(email) INVISIBLE;
ALTER INDEX idx_invisible ON customers VISIBLE;

-- 使用Vitess分片集群
-- 分片查询示例
SELECT * FROM orders WHERE user_id = 123 AND product_id = 456;
-- Vitess自动路由到正确的分片

-- 使用ProxySQL实现读写分离
-- 配置规则将SELECT查询路由到从库
INSERT INTO mysql_query_rules (rule_id,active,match_pattern,destination_hostgroup,apply)
VALUES (1,1,'^SELECT',2,1);