那个几乎搞崩我们数据库的巨大错误，你可能正在犯……

• “我们加了索引”

• “我们换了个数据库”

• “我们加了缓存”

• “我们实现了读副本”

async function getRevenueDashboard(filters) {  // Fetch all orders from the last year  const orders = await db.query(`    SELECT       id,       amount,       created_at,       product_id,       region,      customer_id    FROM orders    WHERE created_at > NOW() - INTERVAL '1 year'  `);  // Fetch all products  const products = await db.query(`    SELECT id, name, category    FROM products  `);  // Create product lookup map  const productMap = products.reduce((acc, p) => {    acc[p.id] = p;    return acc;  }, {});  // Process in JavaScript  const result = {    totalRevenue: 0,    byCategory: {},    byRegion: {},    byMonth: {}  };  orders.forEach(order => {    const product = productMap[order.product_id];    const category = product?.category || 'Unknown';    const month = order.created_at.toISOString().substring(0, 7);    // Total revenue    result.totalRevenue += order.amount;    // By category    result.byCategory[category] = (result.byCategory[category] || 0) + order.amount;    // By region    result.byRegion[order.region] = (result.byRegion[order.region] || 0) + order.amount;    // By month    result.byMonth[month] = (result.byMonth[month] || 0) + order.amount;  });  return result;}

• 第一个月：5000个订单。响应时间：200毫秒。大家都很开心。

• 第三个月：50000个订单。响应时间：800毫秒。开始感觉慢，但可以接受。

• 第六个月：180000个订单。响应时间：3.2秒。业务团队开始抱怨。

• 第九个月：350000个订单。响应时间：7.8秒。CEO发了条Slack消息：“为什么仪表板这么慢？”

• 在 created_at 和 product_id 上添加了索引（有点帮助）

• 实现了Redis缓存（有帮助，但缓存巨大且失效是个噩梦）

• 优化了JavaScript处理（也许节省了200毫秒）

WITH monthly_revenue AS (  SELECT     DATE_TRUNC('month', o.created_at) as month,    p.category,    o.region,    SUM(o.amount) as revenue  FROM orders o  JOIN products p ON o.product_id = p.id  WHERE o.created_at > NOW() - INTERVAL '1 year'  GROUP BY DATE_TRUNC('month', o.created_at), p.category, o.region)SELECT   -- Total revenue  (SELECT SUM(revenue) FROM monthly_revenue) as total_revenue,  -- By category  (    SELECT json_object_agg(category, category_revenue)    FROM (      SELECT category, SUM(revenue) as category_revenue      FROM monthly_revenue      GROUP BY category    ) cat  ) as by_category,  -- By region  (    SELECT json_object_agg(region, region_revenue)    FROM (      SELECT region, SUM(revenue) as region_revenue      FROM monthly_revenue      GROUP BY region    ) reg  ) as by_region,  -- By month  (    SELECT json_object_agg(month, month_revenue)    FROM (      SELECT month, SUM(revenue) as month_revenue      FROM monthly_revenue      GROUP BY month      ORDER BY month    ) mon  ) as by_month;

async function getRevenueDashboard(filters) {  const result = await db.query(`    -- That whole SQL query above  `);  return result.rows[0];}

• 数据库 = 存储层

• 应用程序 = 逻辑层

• 从数据库获取数据

• 在应用程序中处理数据

• 返回结果

• 高效地连接表

• 聚合数据

• 用复杂条件过滤

• 进行数学运算

• 转换数据

• 执行业务逻辑

• 返回JSON、XML或你需要的任何格式

• 通过网络传输大量数据

• 解析和反序列化这些数据

• 将其加载到内存中

• 用更慢、优化程度更低的代码处理它

• 序列化结果

• 通过网络发送回去

// Bad: N+1 queriesconst users = await db.query('SELECT * FROM users');for (const user of users) {  const orders = await db.query(    'SELECT * FROM orders WHERE user_id = ?',    [user.id]  );  user.orderCount = orders.length;  user.totalSpent = orders.reduce((sum, o) => sum + o.amount, 0);}

// Good: One queryconst users = await db.query(`  SELECT     u.*,    COUNT(o.id) as order_count,    COALESCE(SUM(o.amount), 0) as total_spent  FROM users u  LEFT JOIN orders o ON u.id = o.user_id  GROUP BY u.id`);

// Bad: Fetch everything, filter in codeconst products = await db.query('SELECT * FROM products');const available = products.filter(p =>   p.stock > 0 &&   p.price < 100 &&   p.category === 'electronics' &&  !p.discontinued);

-- Good: Let the database filterSELECT * FROM productsWHERE stock > 0  AND price < 100  AND category = 'electronics'  AND discontinued = false;

// Bad: Compute in applicationconst orders = await db.query(`  SELECT amount, tax_rate FROM orders`);orders.forEach(order => {  order.taxAmount = order.amount * order.tax_rate;  order.total = order.amount + order.taxAmount;});-- Good: Compute in databaseSELECT   amount,  tax_rate,  amount * tax_rate as tax_amount,  amount + (amount * tax_rate) as totalFROM orders;

• 当你的数据增长10倍时会发生什么？

• 当你有并发用户时呢？

• 当你的API在高峰时段被猛烈访问时呢？

-- This query processes millions of rows-- but returns only a small summarySELECT   product_id,  COUNT(*) as order_count,  SUM(quantity) as total_quantity,  AVG(price) as avg_price,  PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY price) as median_priceFROM order_itemsWHERE created_at > NOW() - INTERVAL '30 days'GROUP BY product_idHAVING COUNT(*) > 10ORDER BY total_quantity DESCLIMIT 100;

// Bad: Fetch everything, sort in app, paginate in appconst allUsers = await db.query('SELECT * FROM users');const sorted = allUsers.sort((a, b) => b.created_at - a.created_at);const page = sorted.slice(offset, offset + limit);

-- Good: Database handles itSELECT * FROM usersORDER BY created_at DESCLIMIT 20 OFFSET 0;

-- Calculate customer lifetime value with complex rulesWITH customer_orders AS (  SELECT     customer_id,    SUM(total_amount) as total_spent,    COUNT(*) as order_count,    MAX(created_at) as last_order_date  FROM orders  WHERE status = 'completed'  GROUP BY customer_id),customer_segments AS (  SELECT     c.id,    c.email,    co.total_spent,    co.order_count,    co.last_order_date,    CASE       WHEN co.total_spent > 10000 THEN 'vip'      WHEN co.total_spent > 5000 THEN 'premium'      WHEN co.total_spent > 1000 THEN 'regular'      ELSE 'new'    END as segment,    CASE      WHEN co.last_order_date > NOW() - INTERVAL '30 days' THEN 'active'      WHEN co.last_order_date > NOW() - INTERVAL '90 days' THEN 'at_risk'      ELSE 'churned'    END as status  FROM customers c  LEFT JOIN customer_orders co ON c.id = co.customer_id)SELECT * FROM customer_segmentsWHERE segment = 'vip' AND status = 'at_risk';

// Typical ORM approachconst users = await User.findAll({  include: [{    model: Order,    required: false  }]});// Now you have users with orders nested// But you still need to process this in JS to get totals

• 聚合

• 复杂连接

• 子查询

• 窗口函数

• 任何返回汇总数据的操作

// Use ORM for thisconst user = await User.findByPk(userId);user.email = newEmail;await user.save();// Use raw SQL for thisconst stats = await db.query(`  SELECT     COUNT(*) as total_users,    COUNT(*) FILTER (WHERE last_login > NOW() - INTERVAL '7 days') as active_users,    AVG(order_count) as avg_orders_per_user  FROM users`);

-- Running total and ranking in one querySELECT   date,  revenue,  SUM(revenue) OVER (ORDER BY date) as running_total,  RANK() OVER (ORDER BY revenue DESC) as revenue_rankFROM daily_revenue;

WITH high_value_customers AS (  SELECT customer_id, SUM(amount) as total  FROM orders  GROUP BY customer_id  HAVING SUM(amount) > 10000),recent_orders AS (  SELECT *  FROM orders  WHERE created_at > NOW() - INTERVAL '30 days')SELECT   c.name,  hvc.total as lifetime_value,  COUNT(ro.id) as recent_ordersFROM customers cJOIN high_value_customers hvc ON c.id = hvc.customer_idLEFT JOIN recent_orders ro ON c.id = ro.customer_idGROUP BY c.id, c.name, hvc.total;

-- Query JSON fields efficientlySELECT   id,  metadata->>'name' as name,  metadata->'preferences'->>'theme' as themeFROM usersWHERE metadata @> '{"status": "active"}';

CREATE TABLE products (  id SERIAL PRIMARY KEY,  price DECIMAL(10,2),  tax_rate DECIMAL(3,2),  price_with_tax DECIMAL(10,2) GENERATED ALWAYS AS (price * (1 + tax_rate)) STORED);

CREATE TABLE orders (  id SERIAL PRIMARY KEY,  quantity INTEGER CHECK (quantity > 0),  status VARCHAR(20) CHECK (status IN ('pending', 'processing', 'completed', 'cancelled')),  completed_at TIMESTAMP,  CONSTRAINT completed_orders_must_have_date     CHECK (status != 'completed' OR completed_at IS NOT NULL));

“数据库存储我的数据。我的应用程序处理它。”

“数据库是一个强大的处理器。我的应用程序协调它。”

• 处理HTTP请求

• 验证用户身份

• 验证输入

• 用设计良好的查询调用数据库

• 返回结果

• 处理错误

• 存储数据

• 处理数据

• 聚合数据

• 过滤数据

• 连接数据

• 强制约束

• 返回正好需要的内容

• 把所有逻辑都放进数据库

• 永远不在你的应用程序中处理数据

• 所有东西都用存储过程

• 完全放弃ORM

• 用数据库做它擅长的事

• 不要传输和处理你不需要的数据

• 当有意义时编写SQL

• 让数据库执行基于集合的操作

• 复杂的业务工作流

• 与外部服务的集成

• 任何需要分支到多个系统的操作

• 用户特定的格式化和呈现

• 仪表板加载时间： 7.8秒 → 47毫秒（快166倍）

• API响应时间： p95从3.2秒降至180毫秒

• 数据库CPU使用率： 下降了40%（数据传输减少）

• 应用程序内存使用： 下降了60%（不再持有巨大数据集）

• Redis成本： 下降了70%（所需缓存减少）

• 开发者幸福感： 大幅提升（更快的反馈循环）