MongoDB集合操作 #

数据库（Database）
├── users (集合)
│   ├── { _id: 1, name: "John", age: 25 }
│   ├── { _id: 2, name: "Jane", age: 28 }
│   └── { _id: 3, name: "Bob", age: 30 }
├── orders (集合)
│   ├── { _id: 1, userId: 1, amount: 100 }
│   └── { _id: 2, userId: 2, amount: 200 }
└── products (集合)
    ├── { _id: 1, name: "Product A", price: 99.99 }
    └── { _id: 2, name: "Product B", price: 149.99 }

// 创建空集合
db.createCollection("users")

// 输出
// { "ok": 1 }

// 创建带选项的集合
db.createCollection("logs", {
    capped: true,        // 固定大小集合
    size: 5242880,       // 5MB
    max: 5000            // 最多5000个文档
})

// 创建带验证规则的集合
db.createCollection("users", {
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["name", "email"],
            properties: {
                name: {
                    bsonType: "string",
                    description: "必须为字符串"
                },
                email: {
                    bsonType: "string",
                    pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
                    description: "必须为有效邮箱"
                },
                age: {
                    bsonType: "int",
                    minimum: 0,
                    maximum: 150,
                    description: "必须为0-150之间的整数"
                }
            }
        }
    }
})

// 插入文档时自动创建集合
db.products.insertOne({
    name: "Product A",
    price: 99.99
})

// 集合products自动创建
show collections
// products

// 完整选项示例
db.createCollection("events", {
    capped: true,              // 固定大小
    size: 10485760,            // 10MB
    max: 10000,                // 最多10000个文档
    validator: { ... },        // 验证规则
    validationLevel: "strict", // 验证级别
    validationAction: "error", // 验证动作
    storageEngine: {
        wiredTiger: {
            configString: "block_compressor=snappy"
        }
    },
    indexOptionDefaults: {
        storageEngine: {
            wiredTiger: {}
        }
    },
    writeConcern: { w: "majority" }
})

// 显示所有集合
show collections
show tables

// 输出示例
// logs
// products
// users

// 查看集合统计
db.users.stats()

// 输出示例
{
    ns: 'mydb.users',
    count: 1000,
    size: 111000,
    avgObjSize: 111,
    storageSize: 69632,
    nindexes: 2,
    totalIndexSize: 131072,
    totalSize: 200704,
    ok: 1
}

// 以MB为单位显示
db.users.stats({ scale: 1024 * 1024 })

// 查看集合选项
db.users.getCollectionOptions()

// 输出示例
{
    capped: false,
    validator: { ... },
    validationLevel: 'strict',
    validationAction: 'error'
}

// 查看索引
db.users.getIndexes()

// 输出示例
[
    { v: 2, key: { _id: 1 }, name: '_id_' },
    { v: 2, key: { name: 1 }, name: 'name_1' },
    { v: 2, key: { email: 1 }, name: 'email_1', unique: true }
]

// 数据大小
db.users.dataSize()

// 存储大小
db.users.storageSize()

// 索引大小
db.users.totalIndexSize()

// 总大小
db.users.totalSize()

// 重命名集合
db.users.renameCollection("members")

// 重命名到其他数据库
db.users.renameCollection("mydb2.members")

// 强制重命名（如果目标集合存在则删除）
db.users.renameCollection("members", { dropTarget: true })

// 启用验证规则
db.runCommand({
    collMod: "users",
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["name", "email"],
            properties: {
                name: { bsonType: "string" },
                email: { bsonType: "string" }
            }
        }
    },
    validationLevel: "strict",
    validationAction: "error"
})

// 禁用验证规则
db.runCommand({
    collMod: "users",
    validator: {},
    validationLevel: "off"
})

// 修改固定集合大小
db.runCommand({
    collMod: "logs",
    capped: true,
    size: 10485760  // 10MB
})

// 添加文档过期时间（TTL索引）
db.logs.createIndex(
    { createdAt: 1 },
    { expireAfterSeconds: 3600 }  // 1小时后删除
)

// 修改TTL时间
db.runCommand({
    collMod: "logs",
    index: {
        keyPattern: { createdAt: 1 },
        expireAfterSeconds: 7200  // 改为2小时
    }
})

// 删除集合
db.users.drop()

// 输出
// true

// 验证删除
show collections

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

// 更高效的方式（删除索引）
db.users.drop()
db.createCollection("users")

// 删除前确认
show collections

// 删除
db.temp_collection.drop()

// 验证
show collections

// 创建固定大小集合
db.createCollection("logs", {
    capped: true,
    size: 5242880,    // 5MB
    max: 5000         // 最多5000个文档
})

// 创建固定大小集合（只限制大小）
db.createCollection("events", {
    capped: true,
    size: 10485760    // 10MB
})

// 检查是否为固定集合
db.logs.isCapped()

// 转换为固定集合
db.runCommand({
    convertToCapped: "users",
    size: 10485760
})

// 查询固定集合
db.logs.find().sort({ $natural: -1 }).limit(10)  // 最新10条

// 日志存储
db.createCollection("system_logs", {
    capped: true,
    size: 104857600  // 100MB
})

// 事件流
db.createCollection("events", {
    capped: true,
    size: 52428800,  // 50MB
    max: 100000
})

// 消息队列
db.createCollection("messages", {
    capped: true,
    size: 10485760  // 10MB
})

// 创建带验证规则的集合
db.createCollection("users", {
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["name", "email", "age"],
            properties: {
                name: {
                    bsonType: "string",
                    minLength: 2,
                    maxLength: 50,
                    description: "姓名，2-50字符"
                },
                email: {
                    bsonType: "string",
                    pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
                    description: "有效邮箱地址"
                },
                age: {
                    bsonType: "int",
                    minimum: 0,
                    maximum: 150,
                    description: "年龄，0-150"
                },
                status: {
                    enum: ["active", "inactive", "pending"],
                    description: "状态"
                },
                address: {
                    bsonType: "object",
                    properties: {
                        city: { bsonType: "string" },
                        street: { bsonType: "string" },
                        zipCode: { bsonType: "string" }
                    }
                },
                tags: {
                    bsonType: "array",
                    items: { bsonType: "string" },
                    description: "标签数组"
                }
            }
        }
    }
})

// 使用查询表达式验证
db.createCollection("orders", {
    validator: {
        $and: [
            { amount: { $gt: 0 } },
            { status: { $in: ["pending", "completed", "cancelled"] } },
            { userId: { $type: "objectId" } }
        ]
    }
})

// strict：所有插入和更新都验证（默认）
db.runCommand({
    collMod: "users",
    validationLevel: "strict"
})

// moderate：只验证现有文档的更新
db.runCommand({
    collMod: "users",
    validationLevel: "moderate"
})

// off：关闭验证
db.runCommand({
    collMod: "users",
    validationLevel: "off"
})

// error：验证失败返回错误（默认）
db.runCommand({
    collMod: "users",
    validationAction: "error"
})

// warn：验证失败记录警告
db.runCommand({
    collMod: "users",
    validationAction: "warn"
})

// 插入有效文档
db.users.insertOne({
    name: "John",
    email: "john@example.com",
    age: NumberInt(25),
    status: "active"
})
// 成功

// 插入无效文档
db.users.insertOne({
    name: "J",  // 太短
    email: "invalid-email",  // 无效邮箱
    age: NumberInt(200)  // 超出范围
})
// 报错：Document failed validation

// 创建视图
db.createView(
    "activeUsers",           // 视图名称
    "users",                 // 源集合
    [
        { $match: { status: "active" } },
        { $project: { name: 1, email: 1, age: 1 } }
    ]
)

// 使用聚合管道创建视图
db.createView(
    "orderSummary",
    "orders",
    [
        { $group: {
            _id: "$userId",
            totalOrders: { $sum: 1 },
            totalAmount: { $sum: "$amount" }
        }}
    ]
)

// 查看所有集合和视图
show collections

// 查看视图定义
db.getCollectionInfos({ name: "activeUsers" })

// 查询视图
db.activeUsers.find()

// 删除视图
db.activeUsers.drop()

// 压缩集合（回收空间）
db.runCommand({ compact: "users" })

// 带选项压缩
db.runCommand({
    compact: "users",
    force: true  // 强制执行
})

// 验证集合
db.users.validate()

// 完整验证
db.users.validate({ full: true })

// 输出示例
{
    ns: 'mydb.users',
    nrecords: 1000,
    nIndexes: 2,
    keysPerIndex: { _id_: 1000, name_1: 1000 },
    valid: true,
    errors: []
}

// 详细统计
db.users.aggregate([
    { $collStats: { latencyStats: { histograms: true } } }
])

// 输出示例
{
    ns: 'mydb.users',
    count: 1000,
    size: 111000,
    storageSize: 69632,
    totalIndexSize: 131072,
    latencyStats: {
        reads: { latency: 1234, ops: 100 },
        writes: { latency: 5678, ops: 50 },
        commands: { latency: 90, ops: 10 }
    }
}

// 查看查询执行计划
db.users.find({ name: "John" }).explain()

// 详细执行计划
db.users.find({ name: "John" }).explain("executionStats")

// 全部信息
db.users.find({ name: "John" }).explain("allPlansExecution")

// 查看索引使用情况
db.users.aggregate([
    { $indexStats: {} }
])

// 输出示例
{
    name: 'name_1',
    accesses: { ops: 1000, since: ISODate("...") },
    usage: { read: 800, write: 200 }
}

// 查看集合大小
db.users.stats()

// 压缩集合
db.runCommand({ compact: "users" })

// 重建索引
db.users.reIndex()

// 推荐
db.users              // 小写，复数形式
db.order_items        // 下划线分隔
db.log_2024_01        // 时间分区

// 不推荐
db.Users              // 大写
db.order-items        // 连字符
db.user               // 单数形式

集合设计原则

1. 相关数据放在一起
   ├── users (用户信息)
   ├── orders (订单信息)
   └── products (产品信息)

2. 避免过度嵌套
   ├── 推荐：2-3层嵌套
   └── 避免：5层以上嵌套

3. 考虑查询模式
   ├── 频繁查询的字段建立索引
   └── 大文档考虑拆分

// 使用JSON Schema验证
db.createCollection("users", {
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["name", "email"],
            properties: {
                name: { bsonType: "string" },
                email: { bsonType: "string" }
            }
        }
    },
    validationLevel: "strict",
    validationAction: "error"
})

// 原因：集合已存在
db.createCollection("users")
// 报错：Collection already exists

// 解决：先检查是否存在
if (db.getCollectionNames().includes("users")) {
    print("集合已存在")
} else {
    db.createCollection("users")
}

// 原因：权限不足
db.users.drop()
// 报错：not authorized

// 解决：使用有权限的用户
use admin
db.auth("admin", "password")
use mydb
db.users.drop()

// 固定集合不支持deleteOne/deleteMany
db.logs.deleteOne({ _id: 1 })
// 报错：cannot remove from a capped collection

// 解决：使用普通集合或重建集合
db.logs.drop()
db.createCollection("logs", { capped: true, size: 5242880 })