⚖️ SQL vs NoSQL

📖 定义

SQL（关系型数据库）以表格形式存储结构化数据，并使用SQL语言操作。NoSQL（非关系型数据库）使用灵活schema存储各种形式的数据，有利于水平扩展。各有优缺点，需根据项目需求选择。

🎯 通过比喻理解

图书馆 vs 仓库

SQL (关系型DB) = 有序图书馆
├─ 所有书籍分类在固定位置
├─ 图书卡片上记录精确信息
├─ 严格的借还规则
└─ 容易找到但灵活性低

NoSQL (非关系型DB) = 灵活仓库
├─ 可存放各种形状的物品
├─ 快速添加/删除
├─ 空间扩展容易
└─ 灵活但组织可能困难

学校名册 vs 社交媒体

SQL = 学校出席簿
学生表：
┌────┬─────────┬─────┬────────┐
│ ID │  姓名   │年龄 │  班级   │
├────┼─────────┼─────┼────────┤
│ 1  │ 张三    │ 15  │ 1班    │
│ 2  │ 李四    │ 15  │ 2班    │
└────┴─────────┴─────┴────────┘
- 所有学生都有相同的信息字段

NoSQL = 社交媒体个人档案
用户1: { name: "张三", age: 15, hobbies: ["阅读", "游戏"] }
用户2: { name: "李四", city: "北京", job: "学生", pets: 2 }
- 每个用户可以有不同的信息

⚙️ 运作原理

1. 数据结构比较

-- SQL: 结构化表格
users 表
┌────┬─────────┬──────────────────┬─────┐
│ id │  name   │      email       │ age │
├────┼─────────┼──────────────────┼─────┤
│ 1  │ 张三    │ zhang@mail.com   │ 25  │
│ 2  │ 李四    │ li@mail.com      │ 30  │
└────┴─────────┴──────────────────┴─────┘

orders 表
┌────┬─────────┬─────────────┬───────┐
│ id │ user_id │   product   │ price │
├────┼─────────┼─────────────┼───────┤
│ 1  │   1     │ 笔记本电脑  │ 1500  │
│ 2  │   1     │ 鼠标        │  30   │
└────┴─────────┴─────────────┴───────┘

// NoSQL: 灵活文档
// MongoDB 示例
{
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "张三",
  email: "zhang@mail.com",
  age: 25,
  orders: [                              // 嵌套文档
    {
      product: "笔记本电脑",
      price: 1500,
      date: "2024-01-15"
    },
    {
      product: "鼠标",
      price: 30,
      date: "2024-01-20"
    }
  ],
  preferences: {                          // 各种结构
    theme: "dark",
    notifications: true
  }
}

2. NoSQL数据库类型

1. Document DB (文档型)
   └─ MongoDB, CouchDB
   └─ 存储JSON文档

2. Key-Value DB (键值型)
   └─ Redis, DynamoDB
   └─ 快速缓存、会话存储

3. Column-Family DB (列型)
   └─ Cassandra, HBase
   └─ 大规模数据分析

4. Graph DB (图型)
   └─ Neo4j, Amazon Neptune
   └─ 关系中心数据（社交网络）

💡 实际示例

SQL 示例 (MySQL)

-- 创建表格（严格schema）
CREATE TABLE users (
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(50) NOT NULL,
  email VARCHAR(100) UNIQUE NOT NULL,
  age INT,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE orders (
  id INT PRIMARY KEY AUTO_INCREMENT,
  user_id INT,
  product VARCHAR(100),
  price DECIMAL(10, 2),
  FOREIGN KEY (user_id) REFERENCES users(id)
);

-- 插入数据
INSERT INTO users (name, email, age)
VALUES ('张三', 'zhang@mail.com', 25);

-- 用JOIN获取关系
SELECT
  users.name,
  orders.product,
  orders.price
FROM users
INNER JOIN orders ON users.id = orders.user_id
WHERE users.name = '张三';

-- 事务（ACID保证）
BEGIN TRANSACTION;
  UPDATE accounts SET balance = balance - 100 WHERE id = 1;
  UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;

NoSQL 示例 (MongoDB)

// 无schema - 自由结构
db.users.insertOne({
  name: "张三",
  email: "zhang@mail.com",
  age: 25,
  orders: [
    { product: "笔记本电脑", price: 1500 },
    { product: "鼠标", price: 30 }
  ]
});

// 不同结构也可以！
db.users.insertOne({
  name: "李四",
  email: "li@mail.com",
  hobbies: ["阅读", "旅行"],    // 不同字段
  address: {                     // 嵌套对象
    city: "北京",
    zipcode: "100000"
  }
});

// 查询
db.users.find({ name: "张三" });

// 在嵌套文档中查询
db.users.find({
  "orders.product": "笔记本电脑"
});

// 更新
db.users.updateOne(
  { name: "张三" },
  {
    $set: { age: 26 },
    $push: {
      orders: { product: "键盘", price: 80 }
    }
  }
);

// 聚合
db.users.aggregate([
  { $unwind: "$orders" },
  { $group: {
      _id: "$name",
      totalSpent: { $sum: "$orders.price" }
    }
  }
]);

Node.js中的SQL vs NoSQL

// ============ SQL (MySQL) ============
const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'myapp'
});

// 获取用户与订单（需要JOIN）
async function getUserWithOrders(userId) {
  const [rows] = await pool.execute(`
    SELECT
      users.name,
      users.email,
      orders.product,
      orders.price
    FROM users
    LEFT JOIN orders ON users.id = orders.user_id
    WHERE users.id = ?
  `, [userId]);

  return rows;
}

// ============ NoSQL (MongoDB) ============
const { MongoClient } = require('mongodb');

const client = new MongoClient('mongodb://localhost:27017');
const db = client.db('myapp');
const users = db.collection('users');

// 获取用户与订单（不需JOIN - 已包含）
async function getUserWithOrders(userId) {
  const user = await users.findOne({ _id: userId });
  // 订单信息已在user.orders中！
  return user;
}

实务示例：博客系统

// ============ SQL方式 ============
// 规范化结构
/*
posts 表：
  id, title, content, author_id, created_at

comments 表：
  id, post_id, user_id, content, created_at

tags 表：
  id, name

post_tags 表：
  post_id, tag_id
*/

// 获取文章+评论+标签 → 需要多个JOIN
SELECT
  posts.*,
  comments.content as comment,
  tags.name as tag
FROM posts
LEFT JOIN comments ON posts.id = comments.post_id
LEFT JOIN post_tags ON posts.id = post_tags.post_id
LEFT JOIN tags ON post_tags.tag_id = tags.id
WHERE posts.id = 1;

// ============ NoSQL方式 ============
// 非规范化结构
{
  _id: ObjectId("..."),
  title: "MongoDB介绍",
  content: "MongoDB是...",
  author: {
    id: "user123",
    name: "张三"
  },
  comments: [
    {
      user: { id: "user456", name: "李四" },
      content: "很棒的文章！",
      createdAt: "2024-01-15"
    }
  ],
  tags: ["数据库", "NoSQL"],
  createdAt: "2024-01-10"
}

// 一次查询获取所有数据！
db.posts.findOne({ _id: ObjectId("...") });

🤔 常见问题

Q1. 应该选择哪个？

A: 根据项目特性选择：

✅ 选择SQL的情况：
├─ 数据结构明确且固定
├─ 复杂关系与多个JOIN
├─ ACID事务必须（金融、电商）
├─ 数据完整性重要
└─ 例：银行系统、会计软件、ERP

✅ 选择NoSQL的情况：
├─ 数据结构流动
├─ 快速读写重要
├─ 需要水平扩展（scale out）
├─ 大量数据处理
└─ 例：社交媒体、IoT、实时分析、日志

Q2. 主要差异是什么？

A:

特性	SQL	NoSQL
数据结构	表格（行、列）	文档、键值、图等
Schema	固定（严格）	灵活（动态）
扩展	垂直扩展（Scale Up）	水平扩展（Scale Out）
关系	用JOIN连接	嵌套或引用
事务	ACID保证	最终一致性（BASE）
查询	SQL语言	各DB不同
示例	MySQL, PostgreSQL	MongoDB, Redis

// SQL: ACID
Atomicity    (原子性): 全有或全无
Consistency  (一致性): 不违反规则
Isolation    (隔离性): 事务间独立
Durability   (持久性): 永久存储

// NoSQL: BASE
Basically Available    (基本可用)
Soft state            (柔性状态)
Eventually consistent (最终一致性)

Q3. 性能差异？

A: 取决于使用模式：

// SQL优势：复杂查询、JOIN
// 从多个表组合数据
SELECT u.name, p.title, c.content
FROM users u
JOIN posts p ON u.id = p.author_id
JOIN comments c ON p.id = c.post_id
WHERE u.age > 20
ORDER BY p.created_at DESC;
// → 强大且精确但可能慢

// NoSQL优势：快速读写
// 所有信息在一个文档中
db.posts.find({ author_age: { $gt: 20 } })
  .sort({ created_at: -1 });
// → 非常快但复杂JOIN困难

// 基准测试示例
SQL:    10,000 读取/秒  (复杂JOIN)
NoSQL: 100,000 读取/秒  (简单查询)

SQL:     5,000 写入/秒 (事务保证)
NoSQL:  50,000 写入/秒 (快速写入)

Q4. 可以一起使用吗？

A: 可以！称为多语言持久化（Polyglot Persistence）：

// 例：电商系统

// 1. SQL (MySQL) - 订单、付款
// → ACID事务必须
{
  orders: "MySQL",
  payments: "PostgreSQL",
  inventory: "MySQL"
}

// 2. NoSQL (MongoDB) - 产品目录
// → 灵活属性、快速搜索
{
  products: "MongoDB",
  reviews: "MongoDB"
}

// 3. NoSQL (Redis) - 缓存、会话
// → 超快速读写
{
  cache: "Redis",
  sessions: "Redis",
  realtime: "Redis"
}

// 4. Graph DB (Neo4j) - 推荐系统
// → 关系型查询
{
  recommendations: "Neo4j",
  socialGraph: "Neo4j"
}

Q5. 迁移困难吗？

A: 策略性方法即可：

// SQL → NoSQL 迁移策略

// 1. 混合方法
// - 新功能用NoSQL
// - 既有功能保持SQL

// 2. 渐进式迁移
// 步骤1: 从只读数据开始
// 步骤2: 较不重要功能
// 步骤3: 核心功能

// 3. 数据同步
// - 变动数据撷取 (CDC)
// - 事件串流 (Kafka)

// 例：双重写入
async function createUser(userData) {
  // 写入SQL
  const sqlUser = await mysqlDB.insert(userData);

  // 也写入NoSQL（异步）
  await mongooDB.insertOne({
    ...userData,
    _id: sqlUser.id
  }).catch(err => {
    // 失败时SQL仍保留
    console.error('MongoDB同步失败:', err);
  });

  return sqlUser;
}

🎓 下一步

了解SQL与NoSQL后，继续学习：

1. 什么是数据库？ - 基本概念
2. 什么是Node.js？ - 后端开发
3. 什么是Docker？（文档待编写） - 数据库容器化

实作练习

# ============ MySQL 实作 ============
# 安装
brew install mysql  # macOS

# 执行
mysql -u root -p

# 创建表格与查询
CREATE DATABASE testdb;
USE testdb;
CREATE TABLE users (id INT, name VARCHAR(50));
INSERT INTO users VALUES (1, '张三');
SELECT * FROM users;

# ============ MongoDB 实作 ============
# 安装
brew tap mongodb/brew
brew install mongodb-community

# 执行
mongod --config /usr/local/etc/mongod.conf

# MongoDB Shell
mongosh

# 插入与查询数据
use testdb
db.users.insertOne({ name: "张三", age: 25 })
db.users.find()

🎬 总结

SQL与NoSQL各有优缺点：

• SQL：结构化数据、ACID事务、复杂关系
• NoSQL：灵活schema、快速性能、水平扩展
• 选择标准：数据结构、扩展性、一致性需求
• 多语言：依需求组合使用多个DB

"没有银弹" - 为您的项目选择适合的数据库！ ⚖️✨