🖥️ 后端技术 - DATABASE

What is a database? What are the differences between relational and non-relational databases?

考察点：数据库基础概念。

答案：

数据库是一个有组织的数据集合，用于存储、管理和检索数据。它提供了数据的持久化存储、高效访问和数据完整性保证。数据库管理系统(DBMS)是操作和管理数据库的软件系统。

核心区别：

1. 关系型数据库(RDBMS)：

   -- MySQL示例
   CREATE TABLE users (
     id INT PRIMARY KEY,
     name VARCHAR(100),
     email VARCHAR(100)
   );
   
   SELECT * FROM users WHERE age > 18;
   

2. 非关系型数据库(NoSQL)：

   // MongoDB示例
   db.users.insertOne({
     name: "张三",
     email: "[email protected]",
     profile: {
       age: 25,
       skills: ["JavaScript", "Python"]
     }
   });
   

主要差异：

• 数据结构：关系型使用表格结构，非关系型使用文档、键值对、图形等
• 数据完整性：关系型强调ACID特性，非关系型更注重性能和可扩展性
• 扩展方式：关系型主要垂直扩展，非关系型支持水平扩展
• 查询语言：关系型使用SQL，非关系型各有专门的查询语法

适用场景：

• 关系型：金融系统、ERP、需要强一致性的应用
• 非关系型：大数据分析、实时系统、需要快速迭代的Web应用

What is MongoDB? What are its main features and advantages?

考察点：MongoDB基础概念。

答案：

MongoDB是一个开源的NoSQL文档数据库，采用类似JSON的BSON格式存储数据。它是目前最流行的文档型数据库之一，设计目标是提供可扩展、高性能的数据存储解决方案。

主要特点：

1. 文档存储：

   // 灵活的文档结构
   {
     _id: ObjectId("..."),
     name: "张三",
     age: 25,
     address: {
       city: "北京",
       district: "朝阳区"
     },
     hobbies: ["读书", "运动", "旅行"]
   }
   

2. 动态模式：无需预定义表结构，支持字段动态添加

3. 高可用性：内置复制集(Replica Set)机制

4. 水平扩展：原生支持分片(Sharding)

5. 丰富查询：支持复杂查询、索引和聚合操作

核心优势：

• 开发效率高：文档结构接近编程语言的对象模型
• 扩展性强：支持自动分片和负载均衡
• 性能优越：内存映射文件和高效索引机制
• 灵活性好：无严格的表结构约束，适合敏捷开发

适用场景：

• 内容管理系统、实时分析、物联网应用
• 需要快速迭代和原型开发的项目
• 大数据量且结构变化频繁的应用

What are documents, collections, and databases in MongoDB?

考察点：MongoDB数据模型。

答案：

MongoDB采用层次化的数据组织结构，由文档、集合、数据库三个层级组成，类似于关系型数据库中的行、表、数据库概念。

层级结构说明：

1. 文档 (Document)：

   // 一个用户文档示例
   {
     _id: ObjectId("507f1f77bcf86cd799439011"),
     username: "john_doe",
     email: "[email protected]",
     profile: {
       firstName: "John",
       lastName: "Doe",
       age: 30
     },
     tags: ["developer", "javascript"]
   }
   

2. 集合 (Collection)：

   // users集合包含多个用户文档
   db.users.find()  // 查询users集合中的所有文档
   db.products.insertOne({...})  // 向products集合插入文档
   

3. 数据库 (Database)：

   // 切换到指定数据库
   use ecommerce
   
   // 显示当前数据库的所有集合
   show collections
   

对应关系：

• 文档 ≈ 关系型数据库的行(Row)
• 集合 ≈ 关系型数据库的表(Table)
• 数据库 ≈ 关系型数据库的数据库(Database)

特点说明：

• 文档：BSON格式，支持嵌套结构和数组
• 集合：动态创建，无需预定义结构
• 数据库：逻辑分组，物理隔离存储

How to connect to MongoDB database in Node.js?

考察点：数据库连接。

答案：

在Node.js中连接MongoDB主要有两种方式：使用官方驱动程序或使用Mongoose ODM。两种方式都需要先安装相应的依赖包。

连接方式：

1. 使用官方MongoDB驱动：

   // 安装：npm install mongodb
   const { MongoClient } = require('mongodb');
   
   async function connectDB() {
     const uri = 'mongodb://localhost:27017';
     const client = new MongoClient(uri);
     
     try {
       await client.connect();
       console.log('连接MongoDB成功');
       const db = client.db('myapp');
       return db;
     } catch (error) {
       console.error('连接失败:', error);
     }
   }
   

2. 使用Mongoose ODM：

   // 安装：npm install mongoose
   const mongoose = require('mongoose');
   
   async function connectDB() {
     try {
       await mongoose.connect('mongodb://localhost:27017/myapp', {
         useNewUrlParser: true,
         useUnifiedTopology: true
       });
       console.log('Mongoose连接成功');
     } catch (error) {
       console.error('连接失败:', error);
     }
   }
   
   connectDB();
   

连接配置选项：

• useNewUrlParser: 使用新的URL解析器
• useUnifiedTopology: 使用新的服务器发现和监控引擎
• maxPoolSize: 连接池最大连接数
• serverSelectionTimeoutMS: 服务器选择超时时间

最佳实践：

• 使用环境变量存储连接字符串
• 实现连接重试机制
• 正确处理连接错误和断开事件
• 在应用关闭时优雅地关闭数据库连接

How to perform basic CRUD operations in MongoDB?

考察点：基础数据操作。

答案：

MongoDB的CRUD操作包括Create(创建)、Read(读取)、Update(更新)、Delete(删除)四种基本数据操作，每种操作都有对应的方法。

基本操作方法：

1. Create(创建)：

   // 插入单个文档
   db.users.insertOne({
     name: "张三",
     email: "[email protected]",
     age: 25
   });
   
   // 插入多个文档
   db.users.insertMany([
     { name: "李四", email: "[email protected]" },
     { name: "王五", email: "[email protected]" }
   ]);
   

2. Read(读取)：

   // 查询所有文档
   db.users.find();
   
   // 条件查询
   db.users.find({ age: { $gt: 18 } });
   
   // 查询单个文档
   db.users.findOne({ name: "张三" });
   
   // 限制和排序
   db.users.find().limit(10).sort({ age: -1 });
   

3. Update(更新)：

   // 更新单个文档
   db.users.updateOne(
     { name: "张三" },
     { $set: { age: 26 } }
   );
   
   // 更新多个文档
   db.users.updateMany(
     { age: { $lt: 18 } },
     { $set: { status: "minor" } }
   );
   
   // 替换整个文档
   db.users.replaceOne({ _id: ObjectId("...") }, newDoc);
   

4. Delete(删除)：

   // 删除单个文档
   db.users.deleteOne({ name: "张三" });
   
   // 删除多个文档
   db.users.deleteMany({ age: { $lt: 18 } });
   

常用查询操作符：

• $gt/$lt: 大于/小于
• $in/$nin: 在数组中/不在数组中
• $regex: 正则表达式匹配
• $and/$or: 逻辑与/或操作

What is SQL? What are the commonly used SQL statements?

考察点：SQL基础语法。

答案：

SQL(Structured Query Language)是结构化查询语言，是用于管理关系型数据库的标准语言。它提供了定义、查询、更新和管理关系数据库的完整功能。

SQL语句分类：

1. DDL(数据定义语言)：

   -- 创建表
   CREATE TABLE users (
     id INT PRIMARY KEY AUTO_INCREMENT,
     name VARCHAR(100) NOT NULL,
     email VARCHAR(100) UNIQUE,
     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
   );
   
   -- 修改表结构
   ALTER TABLE users ADD COLUMN phone VARCHAR(20);
   
   -- 删除表
   DROP TABLE users;
   

2. DML(数据操作语言)：

   -- 插入数据
   INSERT INTO users (name, email) VALUES ('张三', '[email protected]');
   
   -- 查询数据
   SELECT * FROM users WHERE age > 18 ORDER BY created_at DESC;
   
   -- 更新数据
   UPDATE users SET age = 26 WHERE name = '张三';
   
   -- 删除数据
   DELETE FROM users WHERE age < 18;
   

3. DQL(数据查询语言)：

   -- 基本查询
   SELECT name, email FROM users;
   
   -- 条件查询
   SELECT * FROM users WHERE age BETWEEN 18 AND 65;
   
   -- 聚合查询
   SELECT COUNT(*) as total, AVG(age) as avg_age FROM users;
   
   -- 连接查询
   SELECT u.name, p.title 
   FROM users u 
   JOIN posts p ON u.id = p.user_id;
   

4. DCL(数据控制语言)：

   -- 授权
   GRANT SELECT, INSERT ON users TO 'developer'@'localhost';
   
   -- 撤销权限
   REVOKE DELETE ON users FROM 'developer'@'localhost';
   

常用SQL函数：

• 聚合函数: COUNT(), SUM(), AVG(), MAX(), MIN()
• 字符串函数: CONCAT(), SUBSTRING(), UPPER(), LOWER()
• 日期函数: NOW(), DATE_FORMAT(), DATEDIFF()
• 条件函数: IF(), CASE WHEN … THEN … END

What are primary keys, foreign keys, and indexes in databases?

考察点：数据库设计基础。

答案：

主键、外键和索引是关系型数据库设计的核心概念，用于保证数据完整性、建立表间关系和提升查询性能。

概念说明：

1. 主键 (Primary Key)：

   CREATE TABLE users (
     id INT PRIMARY KEY AUTO_INCREMENT,  -- 主键
     username VARCHAR(50) UNIQUE NOT NULL,
     email VARCHAR(100) UNIQUE NOT NULL
   );
   
   -- 复合主键示例
   CREATE TABLE order_items (
     order_id INT,
     product_id INT,
     quantity INT,
     PRIMARY KEY (order_id, product_id)
   );
   

2. 外键 (Foreign Key)：

   CREATE TABLE posts (
     id INT PRIMARY KEY AUTO_INCREMENT,
     title VARCHAR(200),
     content TEXT,
     user_id INT,
     FOREIGN KEY (user_id) REFERENCES users(id)
       ON DELETE CASCADE 
       ON UPDATE CASCADE
   );
   

3. 索引 (Index)：

   -- 创建单列索引
   CREATE INDEX idx_username ON users(username);
   
   -- 创建复合索引
   CREATE INDEX idx_name_email ON users(name, email);
   
   -- 唯一索引
   CREATE UNIQUE INDEX idx_email ON users(email);
   
   -- 查看索引
   SHOW INDEX FROM users;
   

主要特点：

• 主键: 唯一标识表中每一行，不能为NULL，一个表只能有一个主键
• 外键: 建立表间关联关系，维护参照完整性约束
• 索引: 加速数据检索，但会增加存储空间和维护成本

性能影响：

• 主键: 自动创建聚集索引，查询性能最优
• 外键: 查询时可能需要连接操作，影响性能
• 索引: 显著提升查询速度，但降低插入/更新性能

设计原则：

• 选择合适的主键策略(自增ID vs UUID)
• 合理设计外键约束和级联操作
• 根据查询模式创建必要的索引

What are database transactions? What are ACID properties?

考察点：事务基础概念。

答案：

数据库事务是作为一个逻辑工作单元执行的一系列数据库操作，这些操作要么全部成功执行，要么全部回滚。事务确保数据库在并发环境下保持一致性和完整性。

ACID特性详解：

1. 原子性 (Atomicity)：

   BEGIN TRANSACTION;
   
   UPDATE accounts SET balance = balance - 100 WHERE id = 1;  -- 转出
   UPDATE accounts SET balance = balance + 100 WHERE id = 2;  -- 转入
   
   -- 如果任一操作失败，整个事务回滚
   COMMIT;  -- 或 ROLLBACK;
   

2. 一致性 (Consistency)：

   -- 事务执行前后，数据必须满足完整性约束
   -- 例如：转账前后总金额保持不变
   SELECT SUM(balance) FROM accounts;  -- 转账前后结果相同
   

3. 隔离性 (Isolation)：

   -- 设置事务隔离级别
   SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
   
   BEGIN TRANSACTION;
   SELECT * FROM accounts WHERE id = 1;
   -- 其他事务的修改在当前事务提交前不可见
   COMMIT;
   

4. 持久性 (Durability)：

   -- 事务一旦提交，数据改变永久保存
   COMMIT;  -- 数据写入磁盘，即使系统崩溃也不会丢失
   

事务隔离级别：

• READ UNCOMMITTED: 读取未提交数据，可能出现脏读
• READ COMMITTED: 只读取已提交数据，避免脏读
• REPEATABLE READ: 可重复读，避免不可重复读
• SERIALIZABLE: 串行化，避免幻读，隔离级别最高

实际应用场景：

• 银行转账系统
• 订单处理流程
• 库存管理操作
• 用户注册流程

注意事项：

• 事务应尽可能短小，减少锁定时间
• 避免在事务中执行耗时操作
• 正确处理事务异常和回滚

How to perform database backup and recovery?

考察点：数据安全基础。

答案：

数据库备份和恢复是确保数据安全的重要措施，通过定期备份可以在数据丢失或损坏时快速恢复业务。不同数据库系统有各自的备份恢复工具和策略。

MySQL备份恢复：

1. 逻辑备份 (mysqldump)：

   # 备份单个数据库
   mysqldump -u root -p database_name > backup.sql
   
   # 备份所有数据库
   mysqldump -u root -p --all-databases > all_backup.sql
   
   # 备份特定表
   mysqldump -u root -p database_name table1 table2 > tables_backup.sql
   
   # 恢复数据库
   mysql -u root -p database_name < backup.sql
   

2. 物理备份 (热备份)：

   # 使用xtrabackup
   xtrabackup --backup --target-dir=/backup/mysql/
   
   # 恢复备份
   xtrabackup --prepare --target-dir=/backup/mysql/
   xtrabackup --copy-back --target-dir=/backup/mysql/
   

MongoDB备份恢复：

# 使用mongodump备份
mongodump --host localhost:27017 --db myapp --out /backup/mongodb/

# 备份单个集合
mongodump --db myapp --collection users --out /backup/

# 使用mongorestore恢复
mongorestore --host localhost:27017 --db myapp /backup/mongodb/myapp/

# 恢复到不同数据库
mongorestore --host localhost:27017 --db newapp /backup/mongodb/myapp/

备份策略类型：

1. 完全备份: 备份整个数据库
2. 增量备份: 只备份自上次备份后的变化
3. 差异备份: 备份自上次完全备份后的所有变化

自动化备份脚本：

#!/bin/bash
# MySQL自动备份脚本
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/backups/mysql"
DB_NAME="myapp"

mysqldump -u backup_user -p$DB_PASSWORD $DB_NAME > $BACKUP_DIR/${DB_NAME}_${DATE}.sql

# 删除7天前的备份
find $BACKUP_DIR -name "*.sql" -mtime +7 -delete

最佳实践：

• 定期测试备份文件的完整性
• 采用3-2-1备份策略(3份副本，2种媒介，1份异地)
• 建立监控和告警机制
• 记录备份和恢复操作日志

What is ORM? What are the commonly used Node.js ORM frameworks?

考察点：ORM概念理解。

答案：

ORM(Object-Relational Mapping)是对象关系映射，是一种程序设计技术，用于在面向对象编程语言中实现不同类型系统的数据之间的转换。它将数据库表映射为编程语言中的对象，使开发者可以用面向对象的方式操作数据库。

ORM核心概念：

// 传统SQL操作
const sql = "SELECT * FROM users WHERE age > ? ORDER BY name";
const users = await db.query(sql, [18]);

// ORM操作
const users = await User.findAll({
  where: { age: { [Op.gt]: 18 } },
  order: [['name', 'ASC']]
});

常用Node.js ORM框架：

1. Sequelize (关系型数据库)：

   // 模型定义
   const User = sequelize.define('User', {
     firstName: DataTypes.STRING,
     lastName: DataTypes.STRING,
     email: {
       type: DataTypes.STRING,
       unique: true,
       validate: { isEmail: true }
     }
   });
   
   // 查询操作
   const users = await User.findAll({
     where: { age: { [Op.gte]: 18 } },
     include: [{ model: Profile }]
   });
   

2. Prisma (现代化ORM)：

   // schema.prisma
   model User {
     id    Int    @id @default(autoincrement())
     email String @unique
     posts Post[]
   }
   
   // 使用
   const user = await prisma.user.create({
     data: {
       email: "[email protected]",
       posts: {
         create: [
           { title: "第一篇文章" }
         ]
       }
     }
   });
   

3. TypeORM (TypeScript支持)：

   @Entity()
   export class User {
     @PrimaryGeneratedColumn()
     id: number;
   
     @Column({ unique: true })
     email: string;
   
     @OneToMany(() => Post, post => post.user)
     posts: Post[];
   }
   

4. Mongoose (MongoDB ODM)：

   const userSchema = new mongoose.Schema({
     name: { type: String, required: true },
     email: { type: String, unique: true },
     posts: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Post' }]
   });
   
   const User = mongoose.model('User', userSchema);
   

ORM优缺点：

优势：

• 提高开发效率，减少SQL编写
• 提供类型安全和IDE支持
• 自动处理数据库连接和事务管理
• 支持数据库迁移和版本控制

劣势：

• 性能开销，复杂查询效率可能不如原生SQL
• 学习成本，需要掌握ORM特定语法
• 灵活性限制，某些高级SQL特性难以表达

What is MongoDB’s sharding mechanism? How to implement horizontal scaling?

考察点：分布式架构理解。

答案：

MongoDB分片(Sharding)是一种水平扩展策略，通过将数据分布在多个服务器(分片)上来处理大数据量和高吞吐量的场景。它将大型数据集拆分成较小的、可管理的部分，每个部分存储在不同的分片服务器上。

分片架构组件：

1. Shard (分片)：

   // 每个分片是一个独立的MongoDB实例或复制集
   // 存储数据集的一个子集
   rs0:PRIMARY> db.users.find().count()  // 分片1的数据量
   rs1:PRIMARY> db.users.find().count()  // 分片2的数据量
   

2. Config Servers (配置服务器)：

   // 存储集群元数据和配置信息
   // 必须是复制集架构，通常3个节点
   configReplSet:PRIMARY> use config
   configReplSet:PRIMARY> db.chunks.find().pretty()
   

3. Mongos (路由器)：

   // 客户端连接入口，负责查询路由
   mongos> sh.status()  // 查看分片集群状态
   mongos> db.users.find({userId: 12345})  // 自动路由到正确分片
   

分片配置步骤：

1. 启用分片：

   // 连接到mongos
   mongos> sh.enableSharding("myapp")
   
   // 为集合创建分片键
   mongos> sh.shardCollection("myapp.users", { "userId": 1 })
   

2. 选择分片键：

   // 范围分片 - 基于分片键值范围
   sh.shardCollection("myapp.users", { "userId": 1 })
   
   // 哈希分片 - 基于分片键哈希值
   sh.shardCollection("myapp.logs", { "timestamp": "hashed" })
   
   // 复合分片键
   sh.shardCollection("myapp.orders", { "customerId": 1, "orderDate": 1 })
   

水平扩展策略：

// 查看数据分布
mongos> db.users.getShardDistribution()

// 添加新分片
mongos> sh.addShard("rs2/shard2-1:27017,shard2-2:27017,shard2-3:27017")

// 移动数据块
mongos> sh.moveChunk("myapp.users", { userId: 1000 }, "rs2")

分片键选择原则：

• 高基数: 分片键值应该有足够的变化范围
• 均匀分布: 避免数据倾斜到某个分片
• 查询模式匹配: 常用查询应包含分片键
• 避免单调递增: 如ObjectId、时间戳等

性能优化考虑：

• 合理设计分片策略，避免跨分片查询
• 监控分片间的数据平衡
• 使用复合分片键提高查询效率
• 定期分析和调整分片配置

How to design efficient MongoDB data models? Embedded vs Referenced?

考察点：数据建模策略。

答案：

MongoDB数据建模的核心在于理解应用的查询模式和数据关系，选择合适的嵌入式或引用式设计。与关系型数据库的范式化不同，MongoDB更注重查询性能和数据访问模式。

设计模式对比：

1. 嵌入式设计 (Embedded)：

   // 用户文档包含地址信息
   {
     _id: ObjectId("..."),
     name: "张三",
     email: "[email protected]",
     addresses: [
       {
         type: "home",
         street: "北京市朝阳区xxx街道",
         city: "北京",
         zipCode: "100000"
       },
       {
         type: "work", 
         street: "上海市浦东新区xxx路",
         city: "上海",
         zipCode: "200000"
       }
     ]
   }
   

2. 引用式设计 (Referenced)：

   // 用户文档
   {
     _id: ObjectId("user123"),
     name: "张三",
     email: "[email protected]"
   }
   
   // 独立的地址文档
   {
     _id: ObjectId("addr1"),
     userId: ObjectId("user123"),
     type: "home",
     street: "北京市朝阳区xxx街道",
     city: "北京",
     zipCode: "100000"
   }
   

选择策略指南：

使用嵌入式的场景：

• 一对一关系: 用户和个人资料
• 一对少量: 博客文章和评论(少于100条)
• 数据不经常更新: 产品和规格信息
• 经常一起查询: 订单和订单项

// 博客文章嵌入评论
{
  _id: ObjectId("..."),
  title: "MongoDB数据建模",
  content: "文章内容...",
  author: "张三",
  comments: [
    {
      author: "李四",
      content: "很好的文章",
      createdAt: ISODate("2024-01-01")
    }
  ]
}

使用引用式的场景：

• 多对多关系: 用户和角色
• 一对很多: 用户和订单(可能数千个)
• 数据经常更新: 库存信息
• 数据需要独立查询: 产品目录

// 用户角色多对多关系
// 用户文档
{
  _id: ObjectId("user1"),
  name: "张三",
  roleIds: [ObjectId("role1"), ObjectId("role2")]
}

// 角色文档  
{
  _id: ObjectId("role1"),
  name: "管理员",
  permissions: ["read", "write", "delete"]
}

混合设计模式：

// 电商订单 - 混合模式
{
  _id: ObjectId("order1"),
  userId: ObjectId("user123"),  // 引用用户
  status: "pending",
  items: [  // 嵌入订单项
    {
      productId: ObjectId("prod1"),  // 引用商品
      productName: "iPhone 15",      // 冗余商品名称
      price: 8999,
      quantity: 1
    }
  ],
  shipping: {  // 嵌入配送信息
    address: "北京市朝阳区...",
    method: "快递",
    fee: 15
  }
}

设计最佳实践：

1. 遵循查询模式: 根据应用的读写比例设计模式
2. 控制文档大小: MongoDB文档限制16MB，嵌入数据不宜过大
3. 考虑更新频率: 频繁更新的数据适合独立存储
4. 平衡冗余和一致性: 适度冗余可提升查询性能
5. 使用索引优化: 为常用查询字段创建合适的索引

What is the aggregation pipeline in MongoDB? How to use it?

考察点：数据聚合分析。

答案：

MongoDB聚合管道(Aggregation Pipeline)是一个数据处理框架，允许对集合中的文档进行复杂的数据转换和分析操作。它采用管道概念，将多个处理阶段串联起来，每个阶段对数据进行特定的操作。

管道工作原理：

// 基本语法
db.collection.aggregate([
  { $stage1: { ... } },
  { $stage2: { ... } },
  { $stage3: { ... } }
])

// 数据流向：输入文档 -> 阶段1 -> 阶段2 -> 阶段3 -> 输出结果

常用管道阶段：

1. $match - 筛选文档：

   // 筛选年龄大于18的用户
   db.users.aggregate([
     { $match: { age: { $gt: 18 } } }
   ])
   

2. $group - 分组聚合：

   // 按城市分组统计用户数量
   db.users.aggregate([
     {
       $group: {
         _id: "$city",
         userCount: { $sum: 1 },
         avgAge: { $avg: "$age" },
         maxAge: { $max: "$age" }
       }
     }
   ])
   

3. $project - 字段投影：

   // 选择特定字段，计算新字段
   db.users.aggregate([
     {
       $project: {
         name: 1,
         email: 1,
         isAdult: { $gte: ["$age", 18] },
         fullName: { $concat: ["$firstName", " ", "$lastName"] }
       }
     }
   ])
   

4. $sort - 排序：

   // 按年龄降序排序
   db.users.aggregate([
     { $sort: { age: -1 } }
   ])
   

5. $limit 和 $skip - 分页：

   // 跳过前10条，返回5条记录
   db.users.aggregate([
     { $skip: 10 },
     { $limit: 5 }
   ])
   

复杂聚合示例：

// 电商数据分析 - 统计每个用户的订单统计
db.orders.aggregate([
  // 1. 筛选已完成订单
  { $match: { status: "completed" } },
  
  // 2. 展开订单项数组
  { $unwind: "$items" },
  
  // 3. 按用户ID分组统计
  {
    $group: {
      _id: "$userId",
      totalOrders: { $addToSet: "$_id" },  // 去重订单ID
      totalAmount: { $sum: "$items.price" },
      avgOrderValue: { $avg: "$items.price" },
      topCategory: { $first: "$items.category" }
    }
  },
  
  // 4. 计算订单数量
  {
    $project: {
      userId: "$_id",
      orderCount: { $size: "$totalOrders" },
      totalAmount: 1,
      avgOrderValue: { $round: ["$avgOrderValue", 2] }
    }
  },
  
  // 5. 关联用户信息
  {
    $lookup: {
      from: "users",
      localField: "userId", 
      foreignField: "_id",
      as: "userInfo"
    }
  },
  
  // 6. 展开用户信息
  { $unwind: "$userInfo" },
  
  // 7. 最终输出格式
  {
    $project: {
      userName: "$userInfo.name",
      orderCount: 1,
      totalAmount: 1,
      avgOrderValue: 1
    }
  },
  
  // 8. 按总金额降序排序
  { $sort: { totalAmount: -1 } },
  
  // 9. 只返回前10名
  { $limit: 10 }
])

高级操作符：

// 时间处理
{
  $group: {
    _id: {
      year: { $year: "$createdAt" },
      month: { $month: "$createdAt" }
    },
    count: { $sum: 1 }
  }
}

// 条件表达式
{
  $project: {
    grade: {
      $switch: {
        branches: [
          { case: { $gte: ["$score", 90] }, then: "A" },
          { case: { $gte: ["$score", 80] }, then: "B" },
          { case: { $gte: ["$score", 70] }, then: "C" }
        ],
        default: "D"
      }
    }
  }
}

性能优化技巧：

• 尽早使用$match筛选数据，减少后续处理量
• 合理使用索引支持$match和$sort操作
• 避免在$group前使用$project移除需要的字段
• 大数据量时考虑使用$sample进行采样分析

How to optimize MongoDB query performance?

考察点：性能优化策略。

答案：

MongoDB查询性能优化涉及索引设计、查询模式、数据建模等多个方面。通过合理的优化策略可以显著提升查询效率和系统吞吐量。

索引优化策略：

1. 创建合适的索引：

   // 单字段索引
   db.users.createIndex({ email: 1 })
   
   // 复合索引 - 注意字段顺序
   db.users.createIndex({ city: 1, age: -1, name: 1 })
   
   // 部分索引 - 只为特定条件创建索引
   db.users.createIndex(
     { email: 1 },
     { partialFilterExpression: { status: "active" } }
   )
   
   // 稀疏索引 - 跳过null值
   db.users.createIndex({ phone: 1 }, { sparse: true })
   

2. 索引使用分析：

   // 查看查询执行计划
   db.users.find({ city: "北京", age: { $gt: 25 } }).explain("executionStats")
   
   // 检查索引使用情况
   db.users.getIndexes()
   db.users.totalIndexSize()
   
   // 分析慢查询
   db.setProfilingLevel(2, { slowms: 100 })
   db.system.profile.find().sort({ ts: -1 }).limit(5)
   

查询优化技巧：

1. 高效查询模式：

   // 使用投影减少数据传输
   db.users.find({ city: "北京" }, { name: 1, email: 1, _id: 0 })
   
   // 使用limit控制返回数量
   db.users.find({ age: { $gt: 18 } }).limit(100)
   
   // 避免正则表达式开头的通配符
   // 低效
   db.users.find({ name: /.*john.*/ })
   // 高效  
   db.users.find({ name: /^john/ })
   

2. 批量操作优化：

   // 使用bulkWrite进行批量操作
   db.users.bulkWrite([
     { insertOne: { document: { name: "user1" } } },
     { updateOne: { filter: { _id: 1 }, update: { $set: { status: "active" } } } },
     { deleteOne: { filter: { _id: 2 } } }
   ], { ordered: false })
   
   // 批量插入
   db.users.insertMany(documents, { ordered: false })
   

数据模型优化：

// 反范式化设计 - 适度冗余提升查询性能
{
  _id: ObjectId("..."),
  orderId: "ORD-001",
  customerId: ObjectId("..."),
  customerName: "张三",  // 冗余客户姓名，避免关联查询
  customerEmail: "[email protected]",  // 冗余邮箱
  items: [
    {
      productId: ObjectId("..."),
      productName: "iPhone 15",  // 冗余产品名称
      price: 8999,
      quantity: 1
    }
  ]
}

内存和存储优化：

1. 工作集优化：

   // 监控内存使用
   db.serverStatus().mem
   db.serverStatus().wiredTiger.cache
   
   // 调整缓存大小 (mongod配置)
   storage.wiredTiger.engineConfig.cacheSizeGB: 8
   

2. 文档大小控制：

   // 避免文档过大，控制在16MB以内
   // 大数据使用GridFS存储
   const bucket = new GridFSBucket(db, { bucketName: 'files' });
   

连接池优化：

// MongoDB连接配置优化
const client = new MongoClient(uri, {
  maxPoolSize: 100,        // 最大连接数
  minPoolSize: 5,          // 最小连接数  
  maxIdleTimeMS: 30000,    // 连接空闲时间
  serverSelectionTimeoutMS: 5000,  // 服务器选择超时
  socketTimeoutMS: 45000,  // socket超时时间
});

分片集群优化：

// 选择合适的分片键
sh.shardCollection("myapp.users", { "userId": "hashed" })

// 避免跨分片查询
db.users.find({ userId: 12345 })  // 包含分片键，路由到单个分片

// 监控分片平衡
sh.status()
db.stats()

性能监控工具：

• MongoDB Compass: 可视化性能监控
• mongostat: 实时统计信息
• mongotop: 按集合统计读写时间
• Profiler: 慢查询分析
• 第三方工具: PMM、Datadog等

What is a database connection pool? Why do we need connection pooling?

考察点：连接管理机制。

答案：

数据库连接池是一种资源管理技术，它维护一个数据库连接的缓存池，应用程序可以重复使用这些连接，而不是为每次数据库操作创建和销毁新连接。连接池通过复用连接显著提升应用性能和资源利用率。

连接池工作原理：

// 传统连接方式（每次创建新连接）
async function queryWithoutPool() {
  const connection = await createConnection();  // 耗时操作
  const result = await connection.query('SELECT * FROM users');
  await connection.close();  // 销毁连接
  return result;
}

// 连接池方式（复用连接）
const pool = createConnectionPool({
  host: 'localhost',
  port: 3306,
  database: 'myapp',
  min: 5,      // 最小连接数
  max: 20,     // 最大连接数
  idle: 10000  // 空闲超时时间
});

async function queryWithPool() {
  const connection = await pool.getConnection();  // 从池中获取
  const result = await connection.query('SELECT * FROM users');
  pool.releaseConnection(connection);  // 归还到池中
  return result;
}

为什么需要连接池：

1. 性能提升：

   // 避免连接建立的开销
   // TCP握手 + 身份验证 + 资源分配 ≈ 几十毫秒
   
   // 无连接池：每次请求都要建立连接
   请求1: 建立连接(50ms) + 查询(5ms) + 关闭连接(10ms) = 65ms
   请求2: 建立连接(50ms) + 查询(5ms) + 关闭连接(10ms) = 65ms
   
   // 有连接池：复用已建立的连接
   请求1: 获取连接(1ms) + 查询(5ms) + 归还连接(1ms) = 7ms
   请求2: 获取连接(1ms) + 查询(5ms) + 归还连接(1ms) = 7ms
   

2. 资源控制：

   // 限制数据库连接数，防止资源耗尽
   const pool = new Pool({
     max: 20,  // 最多20个连接，控制数据库负载
     min: 2,   // 保持2个连接，快速响应
     acquireTimeoutMillis: 60000,  // 获取连接超时
     createTimeoutMillis: 3000,    // 创建连接超时
     destroyTimeoutMillis: 5000,   // 销毁连接超时
     idleTimeoutMillis: 30000,     // 空闲连接超时
     reapIntervalMillis: 1000,     // 清理检查间隔
   });
   

不同数据库的连接池实现：

1. MySQL (mysql2/promise)：

   const mysql = require('mysql2/promise');
   
   const pool = mysql.createPool({
     host: 'localhost',
     user: 'root',
     password: 'password',
     database: 'myapp',
     connectionLimit: 10,
     queueLimit: 0
   });
   
   // 使用连接池
   async function getUsers() {
     const [rows] = await pool.execute('SELECT * FROM users WHERE age > ?', [18]);
     return rows;
   }
   

2. PostgreSQL (pg)：

   const { Pool } = require('pg');
   
   const pool = new Pool({
     user: 'postgres',
     host: 'localhost',
     database: 'myapp',
     password: 'password',
     port: 5432,
     max: 20,        // 最大连接数
     idleTimeoutMillis: 30000,
     connectionTimeoutMillis: 2000,
   });
   
   async function getUsers() {
     const client = await pool.connect();
     try {
       const result = await client.query('SELECT * FROM users');
       return result.rows;
     } finally {
       client.release();  // 重要：归还连接到池中
     }
   }
   

3. MongoDB (mongoose)：

   // Mongoose内置连接池
   const mongoose = require('mongoose');
   
   await mongoose.connect('mongodb://localhost:27017/myapp', {
     maxPoolSize: 10,     // 最大连接数
     minPoolSize: 2,      // 最小连接数  
     serverSelectionTimeoutMS: 5000,
     socketTimeoutMS: 45000,
     bufferMaxEntries: 0
   });
   

连接池最佳实践：

1. 合理配置参数：

   // 根据应用负载调整连接数
   const poolConfig = {
     // 基础配置
     min: Math.max(2, process.env.NODE_ENV === 'production' ? 5 : 2),
     max: process.env.NODE_ENV === 'production' ? 50 : 10,
     
     // 超时配置
     acquireTimeoutMillis: 60000,
     createTimeoutMillis: 3000,
     destroyTimeoutMillis: 5000,
     idleTimeoutMillis: 30000,
     
     // 监控配置
     log: (message, logLevel) => {
       console.log(`Pool ${logLevel}: ${message}`);
     }
   };
   

2. 错误处理和监控：

   pool.on('connect', () => {
     console.log('新连接已建立');
   });
   
   pool.on('error', (err) => {
     console.error('连接池错误:', err);
   });
   
   // 定期检查连接池状态
   setInterval(() => {
     console.log('连接池状态:', {
       total: pool.totalCount,
       idle: pool.idleCount,
       waiting: pool.waitingCount
     });
   }, 30000);
   

性能对比：

• 无连接池: 1000次查询 ≈ 65秒
• 有连接池: 1000次查询 ≈ 7秒
• 性能提升: 约9倍提升

How to handle concurrent access and locking mechanisms in databases?

考察点：并发控制理解。

答案：

数据库并发访问和锁机制是确保数据一致性和完整性的核心技术。在多用户环境下，合理的并发控制策略可以最大化系统性能，同时避免数据竞争和不一致问题。

并发问题类型：

1. 丢失更新 (Lost Update)：

   -- 事务A和B同时读取account余额为1000
   -- 事务A: UPDATE accounts SET balance = 900 WHERE id = 1; -- -100
   -- 事务B: UPDATE accounts SET balance = 800 WHERE id = 1; -- -200  
   -- 结果：最终余额800，丢失了事务A的更新
   

2. 脏读 (Dirty Read)：

   -- 事务A: UPDATE accounts SET balance = 500 WHERE id = 1;
   -- 事务B: SELECT balance FROM accounts WHERE id = 1; -- 读到500
   -- 事务A: ROLLBACK; -- 回滚，余额实际还是1000
   -- 事务B读到了未提交的"脏"数据
   

3. 不可重复读 (Non-Repeatable Read)：

   -- 事务A: SELECT balance FROM accounts WHERE id = 1; -- 读到1000
   -- 事务B: UPDATE accounts SET balance = 500 WHERE id = 1; COMMIT;
   -- 事务A: SELECT balance FROM accounts WHERE id = 1; -- 读到500
   -- 同一事务中两次读取结果不同
   

锁机制类型：

1. 悲观锁 (Pessimistic Locking)：

   -- MySQL示例
   BEGIN;
   SELECT balance FROM accounts WHERE id = 1 FOR UPDATE; -- 加排他锁
   UPDATE accounts SET balance = balance - 100 WHERE id = 1;
   COMMIT;
   
   -- PostgreSQL示例  
   BEGIN;
   SELECT * FROM accounts WHERE id = 1 FOR UPDATE NOWAIT; -- 立即返回，不等待
   -- 处理业务逻辑
   COMMIT;
   

2. 乐观锁 (Optimistic Locking)：

   -- 使用版本号实现乐观锁
   CREATE TABLE accounts (
     id INT PRIMARY KEY,
     balance DECIMAL(10,2),
     version INT DEFAULT 0
   );
   
   -- 读取数据时获取版本号
   SELECT id, balance, version FROM accounts WHERE id = 1;
   
   -- 更新时检查版本号
   UPDATE accounts 
   SET balance = balance - 100, version = version + 1 
   WHERE id = 1 AND version = ?; -- 原版本号
   
   -- 如果affected_rows = 0，说明数据被其他事务修改，需要重试
   

MongoDB并发控制：

1. 文档级锁：

   // MongoDB使用乐观并发控制
   // 使用findOneAndUpdate进行原子更新
   const result = await db.accounts.findOneAndUpdate(
     { _id: accountId, balance: { $gte: amount } },
     { $inc: { balance: -amount } },
     { returnDocument: 'after' }
   );
   
   if (!result.value) {
     throw new Error('余额不足或账户不存在');
   }
   

2. 事务支持（4.0+）：

   const session = client.startSession();
   
   try {
     await session.withTransaction(async () => {
       // 转账操作
       await accounts.updateOne(
         { _id: fromAccount },
         { $inc: { balance: -amount } },
         { session }
       );
       
       await accounts.updateOne(
         { _id: toAccount },
         { $inc: { balance: amount } },
         { session }
       );
     });
   } finally {
     await session.endSession();
   }
   

应用层并发处理：

1. 重试机制：

   async function transferWithRetry(fromId, toId, amount, maxRetries = 3) {
     for (let i = 0; i < maxRetries; i++) {
       try {
         const account = await Account.findById(fromId);
         if (account.balance < amount) {
           throw new Error('余额不足');
         }
         
         const result = await Account.updateOne(
           { _id: fromId, version: account.version, balance: { $gte: amount } },
           { 
             $inc: { balance: -amount, version: 1 }
           }
         );
         
         if (result.modifiedCount === 0) {
           // 版本冲突，重试
           if (i === maxRetries - 1) throw new Error('操作失败，请重试');
           await new Promise(resolve => setTimeout(resolve, Math.random() * 100));
           continue;
         }
         
         // 成功，处理目标账户
         await Account.updateOne(
           { _id: toId },
           { $inc: { balance: amount } }
         );
         
         return { success: true };
       } catch (error) {
         if (i === maxRetries - 1) throw error;
       }
     }
   }
   

2. 分布式锁：

   // 使用Redis实现分布式锁
   async function withDistributedLock(key, ttl, callback) {
     const lockKey = `lock:${key}`;
     const lockValue = Math.random().toString(36);
     
     // 获取锁
     const acquired = await redis.set(lockKey, lockValue, 'PX', ttl, 'NX');
     if (!acquired) {
       throw new Error('获取锁失败');
     }
     
     try {
       return await callback();
     } finally {
       // 释放锁（使用Lua脚本确保原子性）
       const script = `
         if redis.call("get", KEYS[1]) == ARGV[1] then
           return redis.call("del", KEYS[1])
         else
           return 0
         end
       `;
       await redis.eval(script, 1, lockKey, lockValue);
     }
   }
   

性能优化策略：

• 减少锁持有时间: 尽快完成事务操作
• 选择合适的隔离级别: 平衡一致性和性能需求
• 使用索引: 减少锁定的数据量
• 分库分表: 减少锁竞争
• 读写分离: 分离查询和更新操作

What are the normalization design principles for databases?

考察点：数据库设计理论。

答案：

数据库范式化是一套系统性的设计原则，用于消除数据冗余、避免更新异常，确保数据的一致性和完整性。通过逐步应用范式化规则，可以设计出结构清晰、维护简单的数据库。

范式化级别：

1. 第一范式 (1NF) - 原子性：

   -- 违反1NF：字段包含多个值
   CREATE TABLE students_bad (
     id INT,
     name VARCHAR(50),
     subjects VARCHAR(200)  -- "数学,英语,物理" 包含多个值
   );
   
   -- 符合1NF：每个字段都是原子值
   CREATE TABLE students (
     id INT,
     name VARCHAR(50),
     subject VARCHAR(50)    -- 单个学科
   );
   

2. 第二范式 (2NF) - 完全依赖：

   -- 违反2NF：存在部分依赖
   CREATE TABLE order_items_bad (
     order_id INT,
     product_id INT,
     product_name VARCHAR(100),  -- 只依赖product_id
     product_price DECIMAL(10,2), -- 只依赖product_id  
     quantity INT,               -- 完全依赖复合主键
     PRIMARY KEY (order_id, product_id)
   );
   
   -- 符合2NF：分离表结构
   CREATE TABLE order_items (
     order_id INT,
     product_id INT,
     quantity INT,
     PRIMARY KEY (order_id, product_id)
   );
   
   CREATE TABLE products (
     product_id INT PRIMARY KEY,
     product_name VARCHAR(100),
     product_price DECIMAL(10,2)
   );
   

3. 第三范式 (3NF) - 消除传递依赖：

   -- 违反3NF：存在传递依赖
   CREATE TABLE employees_bad (
     emp_id INT PRIMARY KEY,
     emp_name VARCHAR(50),
     dept_id INT,
     dept_name VARCHAR(50),    -- 依赖于dept_id，而不是emp_id
     dept_location VARCHAR(50) -- 依赖于dept_id，而不是emp_id
   );
   
   -- 符合3NF：消除传递依赖
   CREATE TABLE employees (
     emp_id INT PRIMARY KEY,
     emp_name VARCHAR(50),
     dept_id INT,
     FOREIGN KEY (dept_id) REFERENCES departments(dept_id)
   );
   
   CREATE TABLE departments (
     dept_id INT PRIMARY KEY,
     dept_name VARCHAR(50),
     dept_location VARCHAR(50)
   );
   

BCNF范式 (Boyce-Codd Normal Form)：

-- 违反BCNF的例子
CREATE TABLE course_instructor (
  student_id INT,
  course VARCHAR(50),
  instructor VARCHAR(50),
  -- 假设：每门课程只有一个讲师，但一个讲师可以教多门课
  -- 存在 course -> instructor 的依赖
  PRIMARY KEY (student_id, course)
);

-- 符合BCNF：分解表结构
CREATE TABLE student_course (
  student_id INT,
  course VARCHAR(50),
  PRIMARY KEY (student_id, course)
);

CREATE TABLE course_instructor (
  course VARCHAR(50) PRIMARY KEY,
  instructor VARCHAR(50)
);

反范式化策略：

在某些情况下，为了提升查询性能，可以适当进行反范式化：

-- 范式化设计（多表联查）
SELECT o.order_id, o.order_date, c.customer_name, c.customer_email
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id;

-- 反范式化设计（冗余数据）
CREATE TABLE orders_denormalized (
  order_id INT PRIMARY KEY,
  customer_id INT,
  customer_name VARCHAR(100),    -- 冗余客户姓名
  customer_email VARCHAR(100),   -- 冗余客户邮箱
  order_date DATE
);

-- 查询性能更好，但需要维护数据一致性
SELECT order_id, order_date, customer_name, customer_email 
FROM orders_denormalized;

范式化的优缺点：

优势：

• 减少数据冗余，节省存储空间
• 避免更新异常和数据不一致
• 提升数据插入和更新性能
• 简化数据维护

劣势：

• 查询需要多表连接，可能影响性能
• 设计复杂度增加
• 某些业务查询变得复杂

设计决策指南：

1. OLTP系统: 通常采用高度范式化设计
2. OLAP系统: 可以适当反范式化提升查询性能
3. 混合场景: 在范式化基础上进行选择性反范式化

实践建议：

• 先进行完全范式化设计
• 根据查询模式和性能要求进行调整
• 使用视图或中间表处理复杂查询
• 建立合适的索引支持连接查询

How to implement read-write separation for databases?

考察点：架构设计策略。

答案：

读写分离是一种数据库架构模式，将读操作和写操作分配到不同的数据库实例上。通过主库处理写操作，从库处理读操作，可以有效提升系统性能和可用性。

基本架构：

应用程序
    ↓
路由层（读写分离中间件）
    ↓           ↓
主库(Master)    从库(Slave)
  写操作        读操作

MySQL读写分离实现：

1. 主从复制配置：

   -- 主库配置 (my.cnf)
   [mysqld]
   server-id=1
   log-bin=mysql-bin
   binlog-do-db=myapp
   
   -- 从库配置 (my.cnf)  
   [mysqld]
   server-id=2
   relay-log=mysql-relay-log
   
   -- 在主库创建复制用户
   CREATE USER 'replicator'@'%' IDENTIFIED BY 'password';
   GRANT REPLICATION SLAVE ON *.* TO 'replicator'@'%';
   
   -- 在从库配置复制
   CHANGE MASTER TO
     MASTER_HOST='master_host',
     MASTER_USER='replicator', 
     MASTER_PASSWORD='password',
     MASTER_LOG_FILE='mysql-bin.000001',
     MASTER_LOG_POS=0;
   START SLAVE;
   

2. 应用层实现：

   const mysql = require('mysql2/promise');
   
   class DatabaseRouter {
     constructor() {
       // 主库连接池（写操作）
       this.masterPool = mysql.createPool({
         host: 'master.db.com',
         user: 'app_user',
         password: 'password',
         database: 'myapp',
         connectionLimit: 10
       });
       
       // 从库连接池（读操作）
       this.slavePool = mysql.createPool({
         host: 'slave.db.com',
         user: 'app_user', 
         password: 'password',
         database: 'myapp',
         connectionLimit: 20
       });
     }
     
     async query(sql, params, forceWrite = false) {
       const isWriteOperation = this.isWriteQuery(sql) || forceWrite;
       const pool = isWriteOperation ? this.masterPool : this.slavePool;
       
       try {
         const [rows] = await pool.execute(sql, params);
         return rows;
       } catch (error) {
         // 从库故障时fallback到主库
         if (!isWriteOperation && this.isConnectionError(error)) {
           console.warn('从库连接失败，切换到主库');
           const [rows] = await this.masterPool.execute(sql, params);
           return rows;
         }
         throw error;
       }
     }
     
     isWriteQuery(sql) {
       const writeKeywords = /^\s*(INSERT|UPDATE|DELETE|REPLACE|CREATE|DROP|ALTER)/i;
       return writeKeywords.test(sql);
     }
   }
   

What is MongoDB replica set? How to configure it?

考察点：高可用架构。

答案：

MongoDB复制集(Replica Set)是一组维护相同数据集的MongoDB服务器。它提供冗余和高可用性，是生产环境部署MongoDB的基础。

复制集架构：

Primary (主节点)
    ↓ 复制
Secondary (从节点1)
Secondary (从节点2)  
Arbiter (仲裁节点，可选)

配置步骤：

1. 启动MongoDB实例：

   # 节点1 (Primary)
   mongod --replSet myReplicaSet --dbpath /data/db1 --port 27017
   
   # 节点2 (Secondary)  
   mongod --replSet myReplicaSet --dbpath /data/db2 --port 27018
   
   # 节点3 (Secondary)
   mongod --replSet myReplicaSet --dbpath /data/db3 --port 27019
   

2. 初始化复制集：

   // 连接到其中一个节点
   mongo --port 27017
   
   // 初始化复制集
   rs.initiate({
     _id: "myReplicaSet",
     members: [
       { _id: 0, host: "localhost:27017" },
       { _id: 1, host: "localhost:27018" },
       { _id: 2, host: "localhost:27019" }
     ]
   });
   
   // 查看状态
   rs.status();
   

3. 应用程序连接：

   const mongoose = require('mongoose');
   
   // 连接复制集
   await mongoose.connect('mongodb://localhost:27017,localhost:27018,localhost:27019/myapp?replicaSet=myReplicaSet', {
     readPreference: 'secondaryPreferred'  // 优先从Secondary读取
   });
   

How to perform database performance monitoring and tuning?

考察点：监控调优能力。

答案：

数据库性能监控和调优是确保系统稳定运行的关键环节。通过建立完善的监控体系和优化策略，可以及时发现问题并持续改进性能。

关键监控指标：

1. 系统资源监控：

   # CPU使用率
   top -p $(pgrep mysqld)
   
   # 内存使用情况
   free -m
   cat /proc/$(pgrep mysqld)/status | grep Vm
   
   # 磁盘I/O
   iostat -x 1
   iotop -p $(pgrep mysqld)
   
   # 网络连接
   netstat -an | grep 3306
   

2. MySQL性能监控：

   -- 查看当前连接数
   SHOW GLOBAL STATUS LIKE 'Threads_connected';
   
   -- 查看慢查询
   SHOW GLOBAL STATUS LIKE 'Slow_queries';
   
   -- 查看缓冲池状态
   SHOW ENGINE INNODB STATUS;
   
   -- 查看当前运行的查询
   SHOW PROCESSLIST;
   
   -- 查看表锁状态
   SHOW GLOBAL STATUS LIKE 'Table_locks%';
   

3. MongoDB性能监控：

   // 服务器状态
   db.serverStatus()
   
   // 数据库统计
   db.stats()
   
   // 慢操作分析
   db.setProfilingLevel(2, { slowms: 100 })
   db.system.profile.find().sort({ ts: -1 }).limit(5)
   
   // 连接状态
   db.serverStatus().connections
   
   // 内存使用
   db.serverStatus().mem
   

性能优化策略：

• 索引优化: 创建合适的索引，避免全表扫描
• 查询优化: 优化SQL语句，使用EXPLAIN分析执行计划
• 配置调优: 调整缓冲池大小、连接数等参数
• 硬件升级: 增加内存、使用SSD存储
• 架构优化: 读写分离、分库分表、缓存层

How to design a highly available and high-performance database architecture?

考察点：架构设计能力。

答案：

设计高可用、高性能的数据库架构需要综合考虑可靠性、扩展性、性能和成本等多个因素。通过多层次的架构设计和技术组合，可以构建能够支撑大规模业务的数据库系统。

架构设计原则：

• 无单点故障: 消除所有单点故障
• 水平可扩展: 支持按需扩展
• 故障自恢复: 自动检测和恢复故障
• 性能可预测: 稳定的响应时间

多层架构设计：

负载均衡层 (HAProxy/Nginx)
        ↓
应用服务层 (多实例)
        ↓
数据库代理层 (ProxySQL/MaxScale)
        ↓
数据库集群层 (主从/分片)
        ↓
存储层 (SSD RAID/分布式存储)

具体实现方案：

1. MySQL高可用架构：

   -- 主从复制 + 哨兵模式
   -- 主库 (Master)
   CREATE USER 'repl'@'%' IDENTIFIED BY 'password';
   GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';
   
   -- 从库 (Slave) 
   CHANGE MASTER TO
     MASTER_HOST='master_ip',
     MASTER_USER='repl',
     MASTER_PASSWORD='password';
   START SLAVE;
   
   -- 使用ProxySQL实现读写分离和故障转移
   

2. MongoDB分片集群：

   // 配置服务器集群 (3节点)
   configReplSet: {
     config1: "config1.example.com:27019",
     config2: "config2.example.com:27019", 
     config3: "config3.example.com:27019"
   }
   
   // 分片服务器 (每个分片3节点复制集)
   shard1ReplSet: {
     shard1a: "shard1a.example.com:27018",
     shard1b: "shard1b.example.com:27018",
     shard1c: "shard1c.example.com:27018"
   }
   
   // 路由服务器 (多个mongos实例)
   mongos: [
     "mongos1.example.com:27017",
     "mongos2.example.com:27017"
   ]
   

How to implement distributed transactions in databases? Application of CAP theorem?

考察点：分布式系统设计。

答案：

分布式事务处理是分布式系统中的核心挑战之一。CAP理论指出在一致性(Consistency)、可用性(Availability)、分区容错性(Partition tolerance)中只能同时满足两个。

CAP理论应用：

1. CP系统 (一致性 + 分区容错)：

   // 银行系统 - 强一致性优先
   // 使用两阶段提交(2PC)确保数据一致性
   class BankTransfer {
     async transfer(fromAccount, toAccount, amount) {
       const transaction = await this.beginDistributedTransaction();
       
       try {
         // 阶段1: 准备阶段
         await transaction.prepare([
           { db: 'bank_a', account: fromAccount, amount: -amount },
           { db: 'bank_b', account: toAccount, amount: +amount }
         ]);
         
         // 阶段2: 提交阶段  
         await transaction.commit();
       } catch (error) {
         await transaction.rollback();
         throw error;
       }
     }
   }
   

2. AP系统 (可用性 + 分区容错)：

   // 社交媒体 - 可用性优先，最终一致性
   class SocialFeed {
     async publishPost(userId, content) {
       // 主库写入
       const post = await this.masterDB.posts.create({
         userId, content, timestamp: new Date()
       });
       
       // 异步复制到从库，允许短暂不一致
       this.replicationQueue.add({
         operation: 'insert',
         table: 'posts',
         data: post
       });
       
       return post;
     }
   }
   

分布式事务实现模式：

1. Saga模式：

   // 订单处理Saga
   class OrderSaga {
     async processOrder(orderData) {
       const saga = new Saga();
       
       saga.addStep(
         // 正向操作
         () => this.inventory.reserve(orderData.items),
         // 补偿操作
         () => this.inventory.release(orderData.items)
       );
       
       saga.addStep(
         () => this.payment.charge(orderData.payment),
         () => this.payment.refund(orderData.payment)
       );
       
       saga.addStep(
         () => this.shipping.create(orderData.shipping),
         () => this.shipping.cancel(orderData.shipping)
       );
       
       return await saga.execute();
     }
   }
   

How to implement automatic failover and disaster recovery for databases?

考察点：容灾机制设计。

答案：

自动故障转移和灾备是确保业务连续性的关键机制。通过自动化的监控、检测和切换流程，可以最小化系统宕机时间。

故障转移架构：

// MySQL MHA (Master High Availability) 配置
const mhaConfig = {
  manager: {
    host: 'mha-manager',
    workdir: '/var/log/masterha/app1',
    user: 'mha',
    password: 'password',
    repl_user: 'repl',
    repl_password: 'repl_pass'
  },
  
  nodes: [
    { hostname: 'mysql1', port: 3306, role: 'master' },
    { hostname: 'mysql2', port: 3306, role: 'candidate_master' },
    { hostname: 'mysql3', port: 3306, role: 'slave' }
  ],
  
  // 故障检测间隔
  ping_interval: 3,
  
  // 自动故障转移
  master_ip_failover_script: '/scripts/master_ip_failover',
  
  // 应用层故障转移脚本
  master_ip_online_change_script: '/scripts/master_ip_online_change'
};

灾备策略：

1. 同城双活：

   // 双机房部署
   const primaryDataCenter = {
     mysql: {
       master: 'mysql-master-dc1',
       slaves: ['mysql-slave1-dc1', 'mysql-slave2-dc1']
     },
     redis: {
       master: 'redis-master-dc1',
       slaves: ['redis-slave-dc1']
     }
   };
   
   const secondaryDataCenter = {
     mysql: {
       master: 'mysql-master-dc2',  // 备用主库
       slaves: ['mysql-slave1-dc2']
     },
     redis: {
       master: 'redis-master-dc2'
     }
   };
   

What are the database selection and architecture design strategies for big data scenarios?

考察点：大数据架构能力。

答案：

大数据场景下的数据库选型需要考虑数据量、访问模式、一致性要求、成本等多个维度。不同的业务场景适合不同的数据库技术栈。

数据库选型矩阵：

Lambda架构实现：

// 批处理层 (Batch Layer)
const batchLayer = {
  storage: 'HDFS',
  processing: 'Spark',
  
  async processBatch(startTime, endTime) {
    const data = await hdfs.read(`/data/${startTime}-${endTime}`);
    const result = await spark.sql(`
      SELECT user_id, COUNT(*) as page_views
      FROM user_events 
      WHERE timestamp BETWEEN '${startTime}' AND '${endTime}'
      GROUP BY user_id
    `);
    await hbase.put('batch_views', result);
  }
};

// 流处理层 (Speed Layer)  
const speedLayer = {
  streaming: 'Kafka + Flink',
  
  async processStream() {
    kafka.consume('user_events')
      .map(event => JSON.parse(event.value))
      .keyBy('user_id')
      .timeWindow(Time.minutes(5))
      .reduce((acc, event) => acc + 1)
      .addSink(redis.set);
  }
};

// 服务层 (Serving Layer)
const servingLayer = {
  async getUserPageViews(userId) {
    // 合并批处理和实时结果
    const batchViews = await hbase.get('batch_views', userId);
    const realtimeViews = await redis.get(`views:${userId}`);
    
    return batchViews + (realtimeViews || 0);
  }
};

How to implement data consistency across databases?

考察点：一致性保证机制。

答案：

跨数据库的数据一致性是微服务架构中的核心挑战。通过事件溯源、Saga模式、最终一致性等技术可以在保证业务正确性的同时维持系统的可用性和性能。

一致性保证策略：

1. 事件溯源 + CQRS：

   // 事件存储
   class EventStore {
     async append(streamId, events, expectedVersion) {
       const currentVersion = await this.getStreamVersion(streamId);
       if (currentVersion !== expectedVersion) {
         throw new ConcurrencyError('版本冲突');
       }
       
       await this.db.events.insertMany(
         events.map((event, index) => ({
           streamId,
           version: expectedVersion + index + 1,
           eventType: event.constructor.name,
           eventData: event,
           timestamp: new Date()
         }))
       );
       
       // 发布事件到消息队列
       events.forEach(event => this.eventBus.publish(event));
     }
   }
   
   // 投影更新
   class UserProjectionHandler {
     async handle(userCreatedEvent) {
       await this.readModel.users.create({
         id: userCreatedEvent.userId,
         name: userCreatedEvent.name,
         email: userCreatedEvent.email
       });
     }
   }
   

2. 分布式事务协调：

   // TCC模式实现
   class DistributedTransaction {
     constructor() {
       this.participants = [];
       this.status = 'PREPARING';
     }
     
     addParticipant(service, tryMethod, confirmMethod, cancelMethod) {
       this.participants.push({
         service, tryMethod, confirmMethod, cancelMethod
       });
     }
     
     async execute() {
       // Try阶段
       for (const participant of this.participants) {
         try {
           await participant.service[participant.tryMethod]();
         } catch (error) {
           await this.cancel();
           throw error;
         }
       }
       
       // Confirm阶段
       this.status = 'CONFIRMING';
       for (const participant of this.participants) {
         await participant.service[participant.confirmMethod]();
       }
       
       this.status = 'CONFIRMED';
     }
     
     async cancel() {
       this.status = 'CANCELLING';
       for (const participant of this.participants) {
         await participant.service[participant.cancelMethod]();
       }
       this.status = 'CANCELLED';
     }
   }
   

What are the security protection strategies for databases?

考察点：安全防护体系。

答案：

数据库安全防护是一个多层次的综合体系，需要从网络、主机、数据库、应用等多个层面构建完整的安全防线，确保数据的机密性、完整性和可用性。

安全防护体系：

1. 访问控制和身份认证：

   -- 最小权限原则
   CREATE USER 'app_read'@'%' IDENTIFIED BY 'strong_password';
   GRANT SELECT ON myapp.* TO 'app_read'@'%';
   
   CREATE USER 'app_write'@'%' IDENTIFIED BY 'strong_password';
   GRANT SELECT, INSERT, UPDATE ON myapp.* TO 'app_write'@'%';
   
   -- 禁用不必要的账户
   DROP USER 'test'@'localhost';
   UPDATE mysql.user SET authentication_string='' WHERE User='';
   DELETE FROM mysql.user WHERE User='';
   

2. 数据加密：

   -- 传输加密 (SSL/TLS)
   CREATE USER 'secure_user'@'%' IDENTIFIED BY 'password' REQUIRE SSL;
   
   -- 存储加密 (透明数据加密)
   ALTER TABLE sensitive_data ENCRYPTION='Y';
   
   -- 应用层字段加密
   CREATE TABLE users (
     id INT PRIMARY KEY,
     username VARCHAR(50),
     encrypted_email VARBINARY(256),  -- AES加密的邮箱
     password_hash VARCHAR(255)       -- bcrypt哈希
   );
   

3. SQL注入防护：

   // 使用参数化查询
   // 错误方式 - 存在SQL注入风险
   const sql = `SELECT * FROM users WHERE id = ${userId}`;
   
   // 正确方式 - 使用预处理语句
   const sql = 'SELECT * FROM users WHERE id = ?';
   const result = await db.execute(sql, [userId]);
   
   // ORM层面的保护
   const user = await User.findOne({
     where: { id: userId }  // Sequelize自动处理参数化
   });
   

How to design and implement database partitioning strategies?

考察点：分区设计能力。

答案：

数据库分区是将大型表或索引分解成更小、更易管理的片段的技术。合理的分区策略可以显著提升查询性能、简化维护操作并支持并行处理。

分区类型和策略：

1. 水平分区 (按行分区)：

   -- 范围分区 - 按时间分区
   CREATE TABLE orders (
     order_id BIGINT,
     order_date DATE,
     customer_id INT,
     amount DECIMAL(10,2)
   )
   PARTITION BY RANGE (YEAR(order_date)) (
     PARTITION p2023 VALUES LESS THAN (2024),
     PARTITION p2024 VALUES LESS THAN (2025),
     PARTITION p2025 VALUES LESS THAN (2026),
     PARTITION pmax VALUES LESS THAN MAXVALUE
   );
   
   -- 哈希分区 - 均匀分布
   CREATE TABLE user_sessions (
     session_id VARCHAR(64),
     user_id BIGINT,
     created_at TIMESTAMP
   )
   PARTITION BY HASH(user_id) PARTITIONS 8;
   
   -- 列表分区 - 按地区分区
   CREATE TABLE sales (
     id INT,
     region VARCHAR(10),
     amount DECIMAL(10,2)
   )
   PARTITION BY LIST (region) (
     PARTITION north VALUES IN ('北京','天津','河北'),
     PARTITION south VALUES IN ('广东','广西','海南'),
     PARTITION west VALUES IN ('四川','重庆','云南')
   );
   

2. 垂直分区 (按列分区)：

   -- 将大表拆分为多个相关表
   -- 主表 - 常用字段
   CREATE TABLE users_basic (
     user_id BIGINT PRIMARY KEY,
     username VARCHAR(50),
     email VARCHAR(100),
     status TINYINT,
     created_at TIMESTAMP
   );
   
   -- 扩展表 - 不常用字段
   CREATE TABLE users_profile (
     user_id BIGINT PRIMARY KEY,
     full_name VARCHAR(100),
     bio TEXT,
     avatar_url VARCHAR(255),
     FOREIGN KEY (user_id) REFERENCES users_basic(user_id)
   );
   

What are the best practices for databases in microservices architecture?

考察点：微服务数据管理。

答案：

微服务架构中的数据库设计遵循"每个服务一个数据库"的原则，通过数据隔离来实现服务的独立性和自治性。

核心原则：

1. 数据库per服务：

   // 用户服务
   const userService = {
     database: 'users_db',
     tables: ['users', 'profiles', 'preferences']
   };
   
   // 订单服务
   const orderService = {
     database: 'orders_db', 
     tables: ['orders', 'order_items', 'payments']
   };
   
   // 库存服务
   const inventoryService = {
     database: 'inventory_db',
     tables: ['products', 'stock', 'reservations']
   };
   

2. 事件驱动的数据同步：

   // 用户服务发布事件
   class UserService {
     async updateUser(userId, userData) {
       await this.db.users.update(userData, { where: { id: userId } });
       
       // 发布用户更新事件
       await this.eventBus.publish('user.updated', {
         userId,
         name: userData.name,
         email: userData.email,
         timestamp: new Date()
       });
     }
   }
   
   // 订单服务监听事件
   class OrderService {
     async onUserUpdated(event) {
       // 更新订单中的冗余用户信息
       await this.db.orders.update(
         { customerName: event.name },
         { where: { customerId: event.userId } }
       );
     }
   }
   

How to handle real-time analysis and OLAP for massive data?

考察点：数据分析架构。

答案：

海量数据的实时分析需要构建高效的数据处理管道，结合流处理、列式存储、预聚合等技术来实现秒级的查询响应。

实时OLAP架构：

// Kappa架构 - 统一流处理
const realTimeOLAP = {
  // 数据摄取层
  ingestion: {
    kafka: {
      topics: ['user_events', 'transaction_events', 'system_metrics'],
      partitions: 32,
      replication: 3
    }
  },
  
  // 流处理层
  processing: {
    flink: {
      // 实时ETL
      etl: `
        CREATE TABLE user_events (
          user_id BIGINT,
          event_type STRING,
          timestamp TIMESTAMP(3),
          properties MAP<STRING, STRING>
        ) WITH (
          'connector' = 'kafka',
          'topic' = 'user_events'
        );
        
        CREATE TABLE aggregated_metrics (
          window_start TIMESTAMP(3),
          window_end TIMESTAMP(3), 
          event_type STRING,
          user_count BIGINT,
          event_count BIGINT
        ) WITH (
          'connector' = 'clickhouse'
        );
        
        INSERT INTO aggregated_metrics
        SELECT 
          TUMBLE_START(timestamp, INTERVAL '1' MINUTE) as window_start,
          TUMBLE_END(timestamp, INTERVAL '1' MINUTE) as window_end,
          event_type,
          COUNT(DISTINCT user_id) as user_count,
          COUNT(*) as event_count
        FROM user_events
        GROUP BY 
          TUMBLE(timestamp, INTERVAL '1' MINUTE),
          event_type;
      `
    }
  },
  
  // 存储层
  storage: {
    clickhouse: {
      // 列式存储，支持高并发查询
      schema: `
        CREATE TABLE metrics_realtime (
          timestamp DateTime,
          dimension1 String,
          dimension2 String, 
          metric1 UInt64,
          metric2 Float64
        ) ENGINE = MergeTree()
        PARTITION BY toYYYYMM(timestamp)
        ORDER BY (dimension1, dimension2, timestamp);
      `
    }
  }
};

What are the cloud-native architecture and containerized deployment strategies for databases?

考察点：云原生架构设计。

答案：

云原生数据库架构利用容器、微服务、自动化等技术实现弹性伸缩、高可用和自动化运维。通过Kubernetes等平台可以实现数据库的云原生部署。

容器化部署策略：

1. StatefulSet部署：

   # MongoDB集群部署
   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: mongodb
   spec:
     replicas: 3
     serviceName: mongodb-service
     selector:
       matchLabels:
         app: mongodb
     template:
       metadata:
         labels:
           app: mongodb
       spec:
         containers:
         - name: mongodb
           image: mongo:5.0
           ports:
           - containerPort: 27017
           env:
           - name: MONGO_INITDB_ROOT_USERNAME
             valueFrom:
               secretKeyRef:
                 name: mongodb-secret
                 key: username
           volumeMounts:
           - name: mongodb-data
             mountPath: /data/db
     volumeClaimTemplates:
     - metadata:
         name: mongodb-data
       spec:
         accessModes: ["ReadWriteOnce"]
         resources:
           requests:
             storage: 100Gi
   

2. Operator模式：

   # MySQL Operator部署
   apiVersion: mysql.oracle.com/v2
   kind: InnoDBCluster
   metadata:
     name: mysql-cluster
   spec:
     secretName: mysql-credentials
     instances: 3
     router:
       instances: 2
     datadirVolumeClaimTemplate:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: 200Gi
     mycnf: |
       [mysqld]
       innodb_buffer_pool_size=2G
       max_connections=200
   

云原生特性：

• 自动扩缩容: 根据负载自动调整实例数量
• 故障自恢复: Pod失败自动重启和重新调度
• 滚动更新: 零停机升级数据库版本
• 备份恢复: 自动化的备份和恢复流程
• 监控告警: 集成Prometheus等监控系统
• 服务网格: 通过Istio等实现流量管理