Amazon DocumentDB 集合操作 #

DocumentDB集合：
├── 文档的逻辑分组容器
├── 类似关系数据库的表
├── 无固定模式（Schema-less）
├── 支持文档验证规则
└── 自动创建默认索引（_id）

命名规则：
├── 不能包含：$ 或 null字符
├── 不能以"system."开头
├── 不能包含点号（嵌套除外）
├── 长度限制：120字节
├── 区分大小写
└── 建议：使用复数形式、小写字母

// 基本创建
db.createCollection("users")

// 输出
{ "ok": 1 }

// 带选项创建
db.createCollection("logs", {
  capped: false,
  autoIndexId: true
})

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

// 集合自动创建
show collections
// 输出包含 products

// 使用JSON Schema验证
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之间的整数"
        },
        role: {
          enum: ["user", "admin", "guest"],
          description: "只能是user、admin或guest"
        }
      }
    }
  },
  validationLevel: "strict",
  validationAction: "error"
})

validationLevel：
├── strict：所有插入和更新都验证
├── moderate：仅验证符合现有规则的文档
└── off：禁用验证

validationAction：
├── error：拒绝无效文档
└── warn：允许但记录警告

// 显示所有集合
show collections

// 或使用函数
db.getCollectionNames()

// 输出示例
[
  "users",
  "products",
  "orders",
  "logs"
]

// 集合统计信息
db.users.stats()

// 输出
{
  "ns": "mydb.users",
  "count": 1000,
  "size": 128000,
  "avgObjSize": 128,
  "storageSize": 256000,
  "nindexes": 2,
  "totalIndexSize": 65536,
  "indexSizes": {
    "_id_": 32768,
    "email_1": 32768
  }
}

// 简化统计
db.users.stats({ scale: 1024 })  // 以KB为单位

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

// 输出
[
  {
    "name": "users",
    "type": "collection",
    "options": {
      "validator": { ... }
    },
    "info": {
      "readOnly": false
    }
  }
]

// 获取验证规则
db.getCollectionInfos({ name: "users" })[0].options.validator

// 为现有集合添加验证规则
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: {
    $or: [
      { phone: { $type: "string" } },
      { email: { $regex: /@/ } }
    ]
  }
})

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

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

// 跨数据库重命名（DocumentDB不支持）
// 需要手动导出导入

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

// 输出
true  // 删除成功
false // 集合不存在

// 删除前检查
if (db.users.countDocuments({}) === 0) {
  db.users.drop();
}

// 删除所有匹配的集合
db.getCollectionNames().forEach(function(name) {
  if (name.startsWith("temp_")) {
    db[name].drop();
    print("Dropped: " + name);
  }
});

删除前检查：
├── 确认集合名称
├── 检查是否有重要数据
├── 确认索引依赖
├── 检查应用引用
└── 确认权限

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

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

// 创建单字段索引
db.users.createIndex({ email: 1 })

// 创建复合索引
db.users.createIndex({ name: 1, age: -1 })

// 创建唯一索引
db.users.createIndex(
  { email: 1 },
  { unique: true }
)

// 创建稀疏索引
db.users.createIndex(
  { nickname: 1 },
  { sparse: true }
)

// 创建文本索引
db.articles.createIndex(
  { content: "text" }
)

// 删除指定索引
db.users.dropIndex("email_1")

// 删除所有索引（保留_id）
db.users.dropIndexes()

// 删除多个索引
db.users.dropIndexes(["email_1", "name_1"])

// 批量插入
db.users.insertMany([
  { name: "用户1", email: "user1@example.com" },
  { name: "用户2", email: "user2@example.com" },
  { name: "用户3", email: "user3@example.com" }
])

// 批量更新
db.users.updateMany(
  { status: "pending" },
  { $set: { status: "active" } }
)

// 批量删除
db.users.deleteMany({
  createdAt: { $lt: new Date("2023-01-01") }
})

// 使用explain分析查询
db.users.find({ email: "test@example.com" }).explain("executionStats")

// 输出关键信息
{
  "executionStats": {
    "totalDocsExamined": 1,
    "totalKeysExamined": 1,
    "executionTimeMillis": 0,
    "indexUsed": "email_1"
  }
}

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

// 输出
{
  "name": "email_1",
  "accesses": {
    "ops": 1000,
    "since": ISODate("2024-01-01T00:00:00Z")
  }
}

// 查看存储统计
db.users.stats()

// 整理集合（减少碎片）
db.runCommand({ compact: "users" })

// 完整的验证规则示例
db.createCollection("products", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "price", "category"],
      properties: {
        _id: {
          bsonType: "objectId"
        },
        name: {
          bsonType: "string",
          minLength: 1,
          maxLength: 100,
          description: "产品名称，1-100字符"
        },
        price: {
          bsonType: "decimal",
          minimum: 0,
          exclusiveMinimum: true,
          description: "价格必须大于0"
        },
        category: {
          enum: ["electronics", "clothing", "food", "other"],
          description: "产品类别"
        },
        tags: {
          bsonType: "array",
          items: {
            bsonType: "string"
          },
          minItems: 0,
          maxItems: 10,
          description: "标签数组，最多10个"
        },
        stock: {
          bsonType: "object",
          required: ["quantity", "warehouse"],
          properties: {
            quantity: {
              bsonType: "int",
              minimum: 0
            },
            warehouse: {
              bsonType: "string"
            }
          }
        },
        metadata: {
          bsonType: "object",
          additionalProperties: true
        }
      },
      additionalProperties: false
    }
  }
})

// 使用查询表达式验证
db.createCollection("orders", {
  validator: {
    $and: [
      { orderDate: { $type: "date" } },
      { totalAmount: { $gte: 0 } },
      {
        $or: [
          { status: "pending" },
          { status: "completed" },
          { status: "cancelled" }
        ]
      }
    ]
  }
})

// 验证失败示例
try {
  db.products.insertOne({
    name: "产品A",
    price: -10,  // 违反minimum规则
    category: "electronics"
  });
} catch (error) {
  print("验证失败: " + error.message);
}

// 使用warn模式
db.runCommand({
  collMod: "products",
  validationAction: "warn"
})

// 无效文档会被插入，但记录警告

命名建议：
├── 使用复数形式
├── 使用小写字母
├── 使用下划线分隔
├── 使用有意义的名称
└── 保持命名一致性

示例：
├── users（用户集合）
├── products（产品集合）
├── order_items（订单项集合）
└── user_sessions（用户会话集合）

设计原则：
├── 根据访问模式设计
├── 避免过度嵌套
├── 考虑查询性能
├── 平衡冗余和规范化
└── 考虑数据增长

索引建议：
├── 为常用查询字段创建索引
├── 复合索引注意字段顺序
├── 避免过多索引
├── 定期监控索引使用
└── 删除未使用的索引

// 问题：集合已存在
// 解决：先检查再创建
if (!db.getCollectionNames().includes("users")) {
  db.createCollection("users");
}

// 问题：现有数据不符合新规则
// 解决：使用moderate级别
db.runCommand({
  collMod: "users",
  validator: { ... },
  validationLevel: "moderate"
})

// 问题：大数据量索引创建超时
// 解决：后台创建
db.users.createIndex(
  { name: 1 },
  { background: true }
)

关键要点：
├── 合理命名集合
├── 使用验证规则保证数据质量
├── 优化索引策略
├── 监控集合性能
└── 定期维护