PostgreSQL还是MongoDB？选错数据库，你的Node.js应用可能快不了

npm install pg

// db.js
const { Client } = require('pg');

const client = new Client({
user: 'your_username',
host: 'localhost',
database: 'testdb',
password: 'your_password',
port: 5432,
});

client.connect()
  .then(() =>console.log('已连接到 PostgreSQL'))
  .catch(err =>console.error('连接出错:', err.stack));

module.exports = client;

你的应用     TCP连接     PostgreSQL 服务器
    |--------建立------->|
    |--------认证------->|
    |<-------响应--------|
    |   准备好发送SQL    |

// db.js - 使用连接池（推荐）
const { Pool } = require('pg');

const pool = new Pool({
user: 'your_username',
host: 'localhost',
database: 'testdb',
password: 'your_password',
port: 5432,
max: 20,                    // 最大连接数
idleTimeoutMillis: 30000,   // 空闲连接30秒后关闭
connectionTimeoutMillis: 2000, // 获取连接超时2秒
});

// 使用 pool.query() 代替 client.query()
module.exports = pool;

请求 1 ——\
请求 2 ——|-> 连接池(max: 20) ——-> PostgreSQL (20个处理线程)
请求 N ——/

// 错误示范 ❌ - SQL注入的噩梦
const insertUser = async (user) => {
  const query = `INSERT INTO users(name, age) VALUES('${user.name}', ${user.age})`;
  try {
    const res = await pool.query(query);
    console.log('插入成功:', res.rows[0]);
  } catch (err) {
    console.error('插入失败:', err);
  }
};

// 如果用户输入了：user.name = "Robert'); DROP TABLE users; --"
// 你的整个 users 表就没了。这不是危言耸听，是真实的灾难。

const insertUser = async (user) => {
const query = {
    text: 'INSERT INTO users(name, age) VALUES($1, $2) RETURNING *',
    values: [user.name, user.age],
  };

try {
    const res = await pool.query(query);
    console.log('插入成功:', res.rows[0]);
    return res.rows[0];
  } catch (err) {
    console.error('插入失败:', err.stack);
  }
};

await insertUser({ name: '张三', age: 28 });

1. 你发送 SQL 模板：INSERT INTO users(name, age) VALUES($1, $2)
2. PostgreSQL 预先编译这个模板，检查语法和权限
3. 你分别发送数据：['张三', 28]
4. PostgreSQL 把数据当作数据，绝对不会作为 SQL 命令执行

// 获取所有用户
const getUsers = async () => {
try {
    const res = await pool.query('SELECT * FROM users');
    return res.rows;
  } catch (err) {
    console.error('查询失败:', err);
  }
};

// 获取特定用户（带条件）
const getUserById = async (id) => {
try {
    const res = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
    return res.rows[0];
  } catch (err) {
    console.error('查询失败:', err);
  }
};

// 带复杂条件的查询
const searchUsers = async (ageMin, ageMax) => {
try {
    const res = await pool.query(
      'SELECT id, name, age FROM users WHERE age BETWEEN $1 AND $2 ORDER BY age DESC',
      [ageMin, ageMax]
    );
    return res.rows;
  } catch (err) {
    console.error('查询失败:', err);
  }
};

const updateUser = async (id, updates) => {
const { name, age } = updates;
try {
    const res = await pool.query(
      'UPDATE users SET name = $1, age = $2 WHERE id = $3 RETURNING *',
      [name, age, id]
    );
    return res.rows[0];
  } catch (err) {
    console.error('更新失败:', err);
  }
};

const deleteUser = async (id) => {
try {
    const res = await pool.query(
      'DELETE FROM users WHERE id = $1 RETURNING *',
      [id]
    );
    return res.rows[0];
  } catch (err) {
    console.error('删除失败:', err);
  }
};

npm install mongoose

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/testdb', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})
  .then(() => console.log('已连接到 MongoDB'))
  .catch(err => console.error('连接出错:', err));

你的应用代码
    |
Mongoose（定义Schema、验证、钩子）
    |
MongoDB 驱动（实际的网络通信）
    |
MongoDB 服务器

// user.model.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
name: {
    type: String,
    required: true,        // 必填
    trim: true,            // 自动去除前后空格
    maxlength: 50,         // 最大长度
  },
age: {
    type: Number,
    min: 0,               // 最小值
    max: 120,             // 最大值
  },
email: {
    type: String,
    unique: true,         // 唯一性约束
    lowercase: true,
  },
createdAt: {
    type: Date,
    default: Date.now,    // 默认值
  },
role: {
    type: String,
    enum: ['user', 'admin'], // 枚举值
    default: 'user',
  },
});

// 创建索引（加快查询速度）
userSchema.index({ email: 1 });
userSchema.index({ name: 1, age: -1 });

const User = mongoose.model('User', userSchema);
module.exports = User;

// 错误示范 ❌
const insertUser = async (userData) => {
try {
    const user = new User(userData);
    await user.save();
    console.log('插入成功:', user);
    return user;
  } catch (err) {
    // 会捕捉到各种验证错误、唯一性冲突等
    console.error('插入失败:', err.message);
  }
};

// 问题：如果字段不合法，会抛异常。没有错误处理很容易让应用崩溃。

// 正确的做法 ✅
const insertUser = async (userData) => {
try {
    const user = new User(userData);
    const savedUser = await user.save();
    return { success: true, data: savedUser };
  } catch (err) {
    if (err.code === 11000) {
      // 唯一性冲突
      return { success: false, error: '该邮箱已被注册' };
    } elseif (err.name === 'ValidationError') {
      // 验证失败
      return { success: false, error: err.message };
    }
    return { success: false, error: '未知错误' };
  }
};

// 获取所有用户
const getUsers = async () => {
try {
    const users = await User.find();
    return users;
  } catch (err) {
    console.error('查询失败:', err);
  }
};

// 查询特定用户
const getUserById = async (id) => {
try {
    const user = await User.findById(id);
    return user;
  } catch (err) {
    console.error('查询失败:', err);
  }
};

// 带条件的查询（Mongoose Query API 很强大）
const searchUsers = async (minAge, maxAge) => {
try {
    const users = await User.find({
      age: { $gte: minAge, $lte: maxAge }
    }).sort({ age: -1 });
    return users;
  } catch (err) {
    console.error('查询失败:', err);
  }
};

// 查询并投影（只返回特定字段）
const getUserEmails = async () => {
try {
    const users = await User.find({}, 'email name'); // 只返回 email 和 name
    return users;
  } catch (err) {
    console.error('查询失败:', err);
  }
};

// 复杂查询：aggregation pipeline（聚合管道）
const getAgeStatistics = async () => {
try {
    const stats = await User.aggregate([
      {
        $group: {
          _id: '$role',
          avgAge: { $avg: '$age' },
          count: { $sum: 1 },
        }
      },
      { $sort: { count: -1 } }
    ]);
    return stats;
  } catch (err) {
    console.error('聚合失败:', err);
  }
};

// 更新一个文档
const updateUser = async (id, updates) => {
try {
    const user = await User.findByIdAndUpdate(
      id,
      updates,
      { 
        new: true,           // 返回更新后的文档
        runValidators: true// 更新时也要运行验证
      }
    );
    return user;
  } catch (err) {
    console.error('更新失败:', err);
  }
};

// 更新多个文档
const updateMultipleUsers = async (filter, updates) => {
try {
    const result = await User.updateMany(filter, updates);
    return { modifiedCount: result.modifiedCount };
  } catch (err) {
    console.error('批量更新失败:', err);
  }
};

// 删除单个
const deleteUser = async (id) => {
try {
    const user = await User.findByIdAndDelete(id);
    return user;
  } catch (err) {
    console.error('删除失败:', err);
  }
};

// 删除多个
const deleteMultipleUsers = async (filter) => {
try {
    const result = await User.deleteMany(filter);
    return { deletedCount: result.deletedCount };
  } catch (err) {
    console.error('批量删除失败:', err);
  }
};

用户(1) -----(N) 文章
            |
            -----(N) 评论 -----(N) 用户

// 创建表（SQL 层面）
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(50) UNIQUE NOT NULL,
  email VARCHAR(100) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE articles (
  id SERIAL PRIMARY KEY,
  title VARCHAR(200) NOT NULL,
  content TEXT,
  author_id INTEGER REFERENCES users(id),
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE comments (
  id SERIAL PRIMARY KEY,
  content TEXT NOT NULL,
  article_id INTEGER REFERENCES articles(id) ON DELETE CASCADE,
  author_id INTEGER REFERENCES users(id),
  created_at TIMESTAMP DEFAULT NOW()
);

// 查询文章及其所有评论
SELECT 
  a.*,
  json_agg(
    json_build_object(
      'id', c.id,
      'content', c.content,
      'author', u.username,
      'created_at', c.created_at
    )
  ) as comments
FROM articles a
LEFT JOIN comments c ON a.id = c.article_id
LEFT JOIN users u ON c.author_id = u.id
WHERE a.id = $1
GROUP BY a.id;

// 定义 Schema
const articleSchema = new mongoose.Schema({
title: String,
content: String,
author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  },
comments: [
    {
      content: String,
      author: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
      },
      createdAt: { type: Date, default: Date.now }
    }
  ],
createdAt: { type: Date, default: Date.now }
});

// 查询文章及其评论
const article = await Article.findById(articleId)
  .populate('author', 'username')
  .populate('comments.author', 'username');

好的 SQL ──┐
          ├─→ 查询优化器 ──→ 执行计划 ──→ 结果
烂的 SQL ──┤    (PG)        (可能还不错)
          │
          └─→ 仍然能跑

// ❌ 错误示范：N+1 查询
const articles = await pool.query('SELECT * FROM articles');
for (const article of articles.rows) {
  const comments = await pool.query(
    'SELECT * FROM comments WHERE article_id = $1',
    [article.id]
  );
  article.comments = comments.rows;
}
// 结果：1次获取所有文章 + N次获取评论 = N+1 次查询

// ✅ 正确做法：使用 JOIN 一次性获取
const result = await pool.query(`
  SELECT 
    a.id, a.title, a.content,
    json_agg(json_build_object('id', c.id, 'content', c.content)) as comments
  FROM articles a
  LEFT JOIN comments c ON a.id = c.article_id
  GROUP BY a.id
`);

// ❌ 没有索引，百万级数据扫描会很慢
SELECT * FROM users WHERE email = 'user@example.com';

// ✅ 建索引
CREATE INDEX idx_users_email ON users(email);

// ❌ 坏主意：在文档中冗余存储用户信息
const article = {
title: 'xxx',
author: {
    id: 123,
    name: '张三',
    email: 'zhangsan@xxx.com'// 冗余！
  }
};

// 当用户改名了，你得更新所有包含这个用户信息的文章
// 如果有百万篇文章，这个操作会很慢，还可能更新不完整

// ✅ 正确做法：只存储 ID，查询时 populate
const article = {
title: 'xxx',
author: ObjectId('...')
};

// 查询时
const article = await Article.findById(id).populate('author');

// ❌ 把本应分表的东西硬塞到一个文档里
const order = {
orderId: '...',
orderDate: '...',
items: [
    { productId: '...', price: 100, ... },
    // 可能有几百个
  ],
shippingAddress: { ... },
billingAddress: { ... },
// ... 还有很多很多字段
};

// 问题：这个文档可能大到 16MB 的 MongoDB 限制
// 而且每次查询都得加载整个文档

// ✅ 分散数据
const order = {
orderId: '...',
orderDate: '...',
// 只存必要的字段
};

const orderItems = {
orderId: '...',
items: [...]
};

// 需要时分别查询

应用层
  |
  ├─→ PostgreSQL（订单、库存、用户账户 - 需要事务）
  ├─→ MongoDB（日志、用户行为追踪 - 灵活Schema）
  ├─→ Redis（缓存、会话 - 高速读写）
  └─→ Elasticsearch（日志搜索 - 全文检索）