MongoDB 与 NoSQL 数据库：文档数据库入门到实战

CP 系统（如 HBase、etcd）—— 牺牲可用性保证一致性
AP 系统（如 Cassandra、DynamoDB）—— 牺牲一致性保证可用性
CA 系统（单机 MySQL）—— 实际上无法在网络分区时工作

# 拉取 MongoDB 8.0 镜像
docker pull mongo:8.0

# 启动单节点 MongoDB
docker run -d \
  --name mongo-local \
  -p 27017:27017 \
  -v mongo-data:/data/db \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=admin123 \
  mongo:8.0

# 进入 mongosh 交互 Shell
docker exec -it mongo-local mongosh -u admin -p admin123

# 或者使用连接字符串直连
# mongodb://admin:admin123@localhost:27017

┌────────────────────────────────────────┐
│  Database (数据库)                     │
│  ┌──────────────────────────────────┐  │
│  │  Collection (集合)               │  │
│  │  ┌─────────────────────────────┐ │  │
│  │  │  Document (文档) — JSON 对象 │  │  │
│  │  │  {                          │  │  │
│  │  │    _id: ObjectId(...),      │  │  │
│  │  │    name: "Alice",           │  │  │
│  │  │    age: 30,                 │  │  │
│  │  │    tags: ["dev", "ops"]     │  │  │
│  │  │  }                          │  │  │
│  │  └─────────────────────────────┘ │  │
│  └──────────────────────────────────┘  │
└────────────────────────────────────────┘

// RDBMS：每张表需要 CREATE TABLE 定义 Schema
CREATE TABLE users (
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(100),
  age INT
);

// MongoDB：直接插入文档，无需预定义 Schema
db.users.insertOne({
  name: "Alice",
  age: 30,
  address: { city: "北京", district: "海淀" },  // 嵌套对象
  tags: ["开发者", "MongoDB"]                    // 数组
})

// 第二个文档可以和第一个字段不同！
db.users.insertOne({
  name: "Bob",
  phone: "13800138000",  // 新增字段
  meta: { lastLogin: ISODate() }
})

// 查看所有数据库
show dbs
// 或
db.adminCommand('listDatabases')

// 切换/创建数据库（use 后自动创建）
use myblog

// 查看所有集合
show collections

// 查看数据库信息
db.stats()

// 查看集合信息
db.articles.stats()

// 查看集合中所有文档
db.articles.find().pretty()

// 查看帮助
help
db.help()
db.articles.help()

// 列出所有可用的方法
db.articles.getDB()

// 在 mongosh 中测试 BSON 类型
db.types.insertOne({
  stringField: "文本",
  intField: NumberInt(42),
  longField: NumberLong(9999999999),
  decimalField: NumberDecimal("99.99"),
  doubleField: 3.14159,
  dateField: new Date(),
  isActive: true,
  nested: { key: "value" },
  arr: [1, "混合", true, { a: 1 }],
  nullField: null,
  objectIdField: new ObjectId(),
  binaryField: BinData(0, "AAAA"),
  timestampField: Timestamp(1726358400, 1)
})

use shop

db.products.insertOne({
  name: "无线蓝牙耳机",
  category: "电子产品",
  price: NumberDecimal("299.00"),
  stock: 150,
  specs: {
    brand: "SoundPro",
    color: "黑色",
    battery: "8小时"
  },
  tags: ["蓝牙", "无线", "降噪"],
  createdAt: new Date()
})

{
  acknowledged: true,
  insertedId: ObjectId("66e5a1b2c3d4e5f6a7b8c9d0")
}

db.products.insertMany([
  {
    name: "机械键盘",
    category: "电子产品",
    price: NumberDecimal("599.00"),
    stock: 80,
    specs: { brand: "KeyCraft", layout: "87键", switch: "青轴" },
    tags: ["键盘", "机械", "办公"]
  },
  {
    name: "瑜伽垫",
    category: "运动用品",
    price: NumberDecimal("129.00"),
    stock: 300,
    specs: { brand: "FitLife", thickness: "6mm", material: "TPE" },
    tags: ["瑜伽", "健身", "防滑"]
  },
  {
    name: "不锈钢保温杯",
    category: "厨具",
    price: NumberDecimal("89.00"),
    stock: 500,
    specs: { brand: "WarmHeld", capacity: "500ml", material: "304不锈钢" },
    tags: ["水杯", "保温", "户外"]
  }
])

// ordered: true — 遇到错误停止后续插入（默认）
db.products.insertMany([
  { _id: "a", name: "A" },
  { _id: "a", name: "B" },  // 重复 _id，报错，B 不插入
  { _id: "c", name: "C" }   // 因为有序，C 也不插入
], { ordered: true })

// ordered: false — 跳过错误继续插入
db.products.insertMany([
  { _id: "x", name: "X" },
  { _id: "x", name: "Y" },  // 重复 _id，跳过
  { _id: "z", name: "Z" }   // 继续插入成功
], { ordered: false })

// 查询所有文档
db.products.find()

// 美化输出
db.products.find().pretty()

// 查询一条
db.products.findOne({ name: "机械键盘" })

// 投影 — 只返回指定字段
db.products.find(
  { category: "电子产品" },
  { name: 1, price: 1, _id: 0 }  // 1=包含, 0=排除
)

// $eq — 等于
db.products.find({ price: NumberDecimal("299.00") })
// 或 $eq 显式写法
db.products.find({ price: { $eq: NumberDecimal("299.00") } })

// $ne — 不等于
db.products.find({ category: { $ne: "电子产品" } })

// $gt / $gte — 大于 / 大于等于
db.products.find({ price: { $gt: NumberDecimal("100.00") } })
db.products.find({ price: { $gte: NumberDecimal("100.00") } })

// $lt / $lte — 小于 / 小于等于
db.products.find({ stock: { $lt: 100 } })
db.products.find({ stock: { $lte: 150 } })

// $in — 在列表中
db.products.find({ category: { $in: ["电子产品", "运动用品"] } })

// $nin — 不在列表中
db.products.find({ category: { $nin: ["厨具"] } })

// $exists — 字段是否存在
db.products.find({ specs.color: { $exists: true } })

// $type — 按 BSON 类型查询
db.products.find({ price: { $type: "decimal" } })

// $regex — 正则匹配
db.products.find({ name: { $regex: /键盘/ } })
db.products.find({ name: { $regex: "^无", $options: "i" } })  // i 忽略大小写

// 数组查询
// 精确匹配数组
db.products.find({ tags: ["蓝牙", "无线", "降噪"] })

// 包含某个元素
db.products.find({ tags: "蓝牙" })

// $all — 包含所有指定元素
db.products.find({ tags: { $all: ["无线", "降噪"] } })

// $size — 数组长度
db.products.find({ tags: { $size: 3 } })

// $elemMatch — 数组内嵌文档匹配
db.products.find({ tags: { $elemMatch: { $eq: "蓝牙" } } })

// 点号访问嵌套字段（必须用引号）
db.products.find({ "specs.brand": "SoundPro" })

// 精确匹配嵌套文档
db.products.find({ specs: { brand: "SoundPro", color: "黑色", battery: "8小时" } })
// 注意：字段顺序和值必须完全一致！

// $set — 设置字段
db.products.updateOne(
  { name: "无线蓝牙耳机" },
  { $set: { price: NumberDecimal("279.00"), "specs.color": "白色" } }
)

// $unset — 删除字段
db.products.updateOne(
  { name: "无线蓝牙耳机" },
  { $unset: { "specs.battery": "" } }
)

// $inc — 自增/自减（原子操作）
db.products.updateOne(
  { name: "机械键盘" },
  { $inc: { stock: -1 } }  // 减1（下单扣库存）
)

// $mul — 相乘
db.products.updateOne(
  { name: "瑜伽垫" },
  { $mul: { price: NumberDecimal("0.9") } }  // 打九折
)

// $min / $max — 条件更新
db.products.updateOne(
  { name: "不锈钢保温杯" },
  { $min: { price: NumberDecimal("79.00") } }  // 如果当前 > 79 则更新
)

// 所有电子产品涨价 10%
db.products.updateMany(
  { category: "电子产品" },
  { $mul: { price: NumberDecimal("1.10") } }
)

// 所有库存不足 100 的商品标记为低库存
db.products.updateMany(
  { stock: { $lt: 100 } },
  { $set: { status: "low_stock" } }
)

// upsert: true — 文档不存在则创建
db.products.updateOne(
  { name: "智能手表" },
  {
    $setOnInsert: {
      category: "电子产品",
      price: NumberDecimal("1299.00"),
      stock: 60,
      created_at: new Date()
    },
    $set: { updated_at: new Date() }
  },
  { upsert: true }
)

// deleteOne — 删除单个文档
db.products.deleteOne({ name: "智能手表" })

// deleteMany — 删除多个
db.products.deleteMany({ stock: { $eq: 0 } })

// 删除所有文档（保留集合）
db.products.deleteMany({})

// 删除集合（整个集合及索引）
db.products.drop()

// 删除数据库
db.dropDatabase()

db.orders.insertMany([
  { _id: 1, customer: "Alice", items: ["鼠标", "键盘"], total: 898, status: "completed", date: ISODate("2024-01-15") },
  { _id: 2, customer: "Bob", items: ["显示器"], total: 2399, status: "completed", date: ISODate("2024-01-20") },
  { _id: 3, customer: "Alice", items: ["硬盘"], total: 599, status: "pending", date: ISODate("2024-02-10") },
  { _id: 4, customer: "Carol", items: ["耳机", "鼠标垫"], total: 199, status: "completed", date: ISODate("2024-02-15") },
  { _id: 5, customer: "Bob", items: ["键盘", "音箱"], total: 1298, status: "shipped", date: ISODate("2024-03-05") },
  { _id: 6, customer: "Alice", items: ["笔记本"], total: 5999, status: "completed", date: ISODate("2024-03-20") }
])

db.orders.aggregate([
  { $match: { status: "completed" } }
])

// 按客户分组，计算总消费和订单数
db.orders.aggregate([
  { $group: {
    _id: "$customer",
    totalSpent: { $sum: "$total" },
    orderCount: { $sum: 1 },
    avgAmount: { $avg: "$total" },
    minAmount: { $min: "$total" },
    maxAmount: { $max: "$total" }
  } }
])

db.orders.aggregate([
  { $group: {
    _id: "$customer",
    totalSpent: { $sum: "$total" }
  }},
  { $sort: { totalSpent: -1 } }   // -1 降序, 1 升序
])

db.orders.aggregate([
  { $project: {
    customer: 1,
    total: 1,
    date: { $dateToString: { format: "%Y-%m-%d", date: "$date" } },
    status: 1,
    itemsCount: { $size: "$items" },
    // 创建新计算字段
    totalCategory: {
      $cond: {
        if: { $gte: ["$total", 1000] },
        then: "大额订单",
        else: "普通订单"
      }
    },
    _id: 0
  } }
])

// 找出消费总额最高的客户及其订单统计
db.orders.aggregate([
  // 1. 筛选已完成订单
  { $match: { status: { $in: ["completed", "shipped"] } } },

  // 2. 按客户分组统计
  { $group: {
    _id: "$customer",
    totalSpent: { $sum: "$total" },
    orderCount: { $sum: 1 },
    avgOrderValue: { $avg: "$total" }
  }},

  // 3. 只保留总消费 >= 1000 的客户
  { $match: { totalSpent: { $gte: 1000 } } },

  // 4. 按总消费降序排列
  { $sort: { totalSpent: -1 } },

  // 5. 格式化输出
  { $project: {
    customer: "$_id",
    totalSpent: { $round: ["$totalSpent", 2] },
    orderCount: 1,
    avgOrderValue: { $round: ["$avgOrderValue", 2] },
    _id: 0
  }}
])

db.customers.insertMany([
  { _id: "Alice", email: "alice@example.com", city: "北京", vip: true },
  { _id: "Bob", email: "bob@example.com", city: "上海", vip: false },
  { _id: "Carol", email: "carol@example.com", city: "深圳", vip: true }
])

db.order_details.insertMany([
  { orderId: 1, product: "鼠标", qty: 1, price: 199 },
  { orderId: 1, product: "键盘", qty: 1, price: 699 },
  { orderId: 2, product: "显示器", qty: 1, price: 2399 },
  { orderId: 6, product: "笔记本", qty: 1, price: 5999 }
])

// 关联 orders 与 customers
db.orders.aggregate([
  { $lookup: {
    from: "customers",                     // 关联集合名
    localField: "customer",                // 本地字段
    foreignField: "_id",                   // 对方字段
    as: "customerInfo"                     // 输出数组字段名
  }},
  // $lookup 结果是一个数组，用 $unwind 展开
  { $unwind: {
    path: "$customerInfo",
    preserveNullAndEmptyArrays: true       // 保留没有客户信息的订单
  }},
  { $project: {
    orderId: "$_id",
    customer: 1,
    total: 1,
    city: "$customerInfo.city",
    isVip: "$customerInfo.vip",
    email: "$customerInfo.email",
    _id: 0
  }}
])

// 将每个订单按商品展开为多行
db.orders.aggregate([
  { $unwind: "$items" },
  { $project: {
    customer: 1,
    item: "$items",
    total: 1,
    _id: 0
  }}
])

// 结果：
// { customer: "Alice", item: "鼠标", total: 898 }
// { customer: "Alice", item: "键盘", total: 898 }
// { customer: "Bob",   item: "显示器", total: 2399 }
// ...

// 统计哪个商品被购买最多
db.orders.aggregate([
  { $unwind: "$items" },
  { $group: {
    _id: "$items",
    purchaseCount: { $sum: 1 }
  }},
  { $sort: { purchaseCount: -1 } }
])

// 将订单按金额分桶
db.orders.aggregate([
  { $bucket: {
    groupBy: "$total",
    boundaries: [0, 200, 500, 1000, 5000, 10000],
    default: "其他",
    output: {
      count: { $sum: 1 },
      orders: { $push: { id: "$_id", customer: "$customer" } },
      avgTotal: { $avg: "$total" }
    }
  }}
])

// 创建单字段升序索引
db.products.createIndex({ price: 1 })    // 1=升序, -1=降序

// 查看集合索引
db.products.getIndexes()

// 结果示例
[
  { v: 2, key: { _id: 1 }, name: "_id_" },
  { v: 2, key: { price: 1 }, name: "price_1" }
]

// 唯一索引
db.products.createIndex({ name: 1 }, { unique: true })

// 稀疏索引（只索引包含该字段的文档）
db.products.createIndex({ email: 1 }, { sparse: true })

// 复合索引：先按 category 排序，再按 price 排序
db.products.createIndex({ category: 1, price: -1 })

// 复合索引的"最左前缀"原则：
// 以下查询可以使用该索引：
db.products.find({ category: "电子产品" })
db.products.find({ category: "电子产品", price: { $gt: 100 } })

// 以下查询不能使用该索引（没有 category 条件）：
db.products.find({ price: { $gt: 100 } })

// 复合索引设计建议
// 1. 等值条件字段放前面
// 2. 排序字段放后面
// 3. 范围条件字段放最后

// 自动创建多键索引
db.products.createIndex({ tags: 1 })

// 多键索引对以下查询有效
db.products.find({ tags: "蓝牙" })
db.products.find({ tags: { $all: ["无线", "降噪"] } })

// 注意：一个复合索引中只能有一个数组字段
// 下面的创建会报错（两个数组字段）
// db.products.createIndex({ tags: 1, items: 1 })  // ❌

// 在 name 和 specs.brand 字段上创建文本索引
db.products.createIndex(
  { name: "text", "specs.brand": "text" },
  { weights: { name: 10, "specs.brand": 5 } }  // name 权重更高
)

// $text 查询
db.products.find({ $text: { $search: "蓝牙耳机" } })

// 按文本相关性排序
db.products.find(
  { $text: { $search: "键盘机械" } },
  { score: { $meta: "textScore" } }
).sort({ score: { $meta: "textScore" } })

// 中文分词 — 需要额外配置（mongosh 中需安装 ICU 或 Elasticsearch 配合）
// MongoDB 文本索引默认支持的语言不包括中文

// 创建会话集合，30分钟后自动删除
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 1800 }   // 1800秒 = 30分钟
)

// 插入数据（必须包含 createdAt 日期字段）
db.sessions.insertOne({
  sessionId: "abc123",
  userId: "user_001",
  createdAt: new Date()       // TTL 索引基于此字段
})

// 自定义过期时间（使用 expireAfterSeconds: 0）
// 文档中指定 expireAt 字段
db.coupons.createIndex(
  { expireAt: 1 },
  { expireAfterSeconds: 0 }
)

db.coupons.insertOne({
  code: "DISCOUNT50",
  discount: 50,
  expireAt: new Date("2024-12-31T23:59:59Z")   // 过期时间精确到秒
})

// 说明：TTL 索引每隔 60 秒运行一次后台清理任务

┌─────────────┐    选举      ┌─────────────┐
│  Primary    │◄────────────│  Secondary   │
│  (主节点)    │              │  (从节点1)   │
│  读写操作    │ ───────────►│  异步复制    │
└──────┬──────┘   oplog     └─────────────┘
       │                     ┌─────────────┐
       │                     │  Secondary   │
       └────────────────────►│  (从节点2)   │
           异步复制          │  异步复制    │
                             └─────────────┘

// 主节点写入，从节点读取（需要设置 readPreference）
// 在 mongosh 中：
rs.secondaryOk()  // 允许从从节点读取

// 在应用代码驱动中：
// readPreference=secondary         // 始终读从节点
// readPreference=primaryPreferred  // 优先读主节点，主节点不可用读从节点

// 写关注（Write Concern）
// w: "majority" — 等待大多数节点确认写入
db.orders.insertOne(
  { item: "商品", qty: 100 },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
)

// 读关注（Read Concern）
// "majority" — 只读取已被大多数节点确认的数据
db.orders.find().readConcern("majority")

// "local" — 默认，可能读到尚未复制到从节点的数据
db.orders.find().readConcern("local")

┌──────────────────────────────────────────────┐
│              mongos (路由层)                   │
│     应用程序通过 mongos 访问整个集群           │
└──────┬────────────────────────┬───────────────┘
       │                        │
┌──────▼──────┐      ┌─────────▼────────┐
│ Shard 1     │      │ Shard 2          │
│ (复制集 A)   │      │ (复制集 B)       │
│ 数据范围:    │      │ 数据范围:         │
│ 0 ~ 10000   │      │ 10001 ~ 20000    │
└─────────────┘      └──────────────────┘
        │                    │
        └────────┬───────────┘
                 │
    ┌────────────▼────────────┐
    │    Config Server        │
    │    (配置服务器，存储元数据) │
    │    必须为复制集          │
    └─────────────────────────┘

// ======== 启用分片 ========

// 1. 连接到 mongos
mongos> sh.enableSharding("shop")

// 2. 在集合上启用分片，选择分片键
// 方式一：基于 _id 的哈希分片（最常用，数据分布均匀）
mongos> sh.shardCollection("shop.orders", { _id: "hashed" })

// 方式二：基于范围分片
mongos> sh.shardCollection("shop.orders", { customer: 1 })

// 方式三：基于复合分片键（MongoDB 5.0+）
mongos> sh.shardCollection("shop.orders", { customer: 1, date: 1 })

// 1. 哈希分片（Ranged Hash）
// 优点：写入分布最均匀
// 缺点：范围查询会广播到所有分片
sh.shardCollection("shop.logs", { _id: "hashed" })

// 2. 范围分片
// 优点：范围查询高效（只需访问相关分片）
// 缺点：数据倾斜风险（如 hot 分片）
sh.shardCollection("shop.orders", { customer: 1 })

// 3. 区域分片（Zone Sharding，按地域）
// 适用于数据本地化场景
sh.addShardToZone("shard01", "华东")
sh.addShardToZone("shard02", "华北")
sh.updateZoneKeyRange(
  "shop.orders",
  { region: "华东" },
  { region: "华东" },
  "华东"
)

// 查看分片集群状态
sh.status()

// 查看数据分布
db.orders.getShardDistribution()

// 手动合并块（Chunk）
// 在分片间数据不均衡时手动触发
sh.mergeChunks(
  "shop.orders",
  { customer: "A" },
  { customer: "M" }
)

// 查看分片键范围
db.orders.getShardKey()

-- Cassandra 使用 CQL（Cassandra Query Language），类 SQL
CREATE KEYSPACE myapp
WITH replication = {
  'class': 'SimpleStrategy',
  'replication_factor': 3
};

CREATE TABLE myapp.users_by_email (
  email text PRIMARY KEY,
  name text,
  age int,
  city text
);

CREATE TABLE myapp.users_by_city (
  city text,
  email text,
  name text,
  age int,
  PRIMARY KEY (city, email)   -- 复合主键：分区键 + 聚类键
);

-- 插入
INSERT INTO myapp.users_by_email (email, name, age, city)
VALUES ('alice@example.com', 'Alice', 30, '北京');

-- 查询（必须带分区键）
SELECT * FROM myapp.users_by_city WHERE city = '北京';

(Alice) —[:FOLLOWS]→ (Bob) —[:LIKES]→ (Post1)
   │                                      │
   └────—[:COMMENTED]→ (Comment1) ←————─┘

// 创建节点和关系
CREATE (alice:User {name: 'Alice', age: 30})
CREATE (bob:User {name: 'Bob', age: 28})
CREATE (post:Post {title: 'MongoDB 入门教程', content: '...'})

CREATE (alice)-[:FOLLOWS]->(bob)
CREATE (bob)-[:LIKES]->(post)
CREATE (alice)-[:COMMENTED {text: '好文章！'}]->(post)

// 查询推荐的社交关系
// 找到 Bob 关注的人中 Alice 也认识的人
MATCH (alice:User {name: 'Alice'})-[:FOLLOWS]->(common:User)<-[:FOLLOWS]-(bob:User {name: 'Bob'})
RETURN common.name

// 找到 Alice 可能感兴趣的内容（好友喜欢的内容）
MATCH (alice:User {name: 'Alice'})-[:FOLLOWS]->(friend:User)
MATCH (friend)-[:LIKES]->(post:Post)
WHERE NOT (alice)-[:LIKES]->(post)
RETURN post.title, count(friend) AS recommendationScore
ORDER BY recommendationScore DESC

-- InfluxQL（类 SQL）
-- 插入时序数据
INSERT cpu_usage,host=server01,region=cn-beijing value=83.5,load=0.75 1726408800000000000

-- 查询
SELECT mean("value") AS avg_cpu
FROM "cpu_usage"
WHERE time > now() - 1h
  AND "region" = 'cn-beijing'
GROUP BY time(5m), "host"