MongoDB 视图与物化视图：虚拟集合与数据视图的完整指南

原创已于 2025-10-04 10:29:03 修改 · 1.2k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#mongodb #数据库

于 2025-10-04 10:28:31 首次发布

MongoDB 专栏收录该内容

7 篇文章

订阅专栏

想象一下，你需要为不同的业务部门提供定制化的数据视图，但又不希望重复存储数据。或者你需要定期生成复杂的统计报表，但每次都重新计算会消耗大量资源。MongoDB 的视图和物化视图功能正是为解决这些实际问题而设计的。

MongoDB 的视图（Views）提供了虚拟集合的能力，让你可以基于现有集合创建定制化的数据视图，而物化视图则通过预计算和缓存机制，大幅提升复杂查询的性能。从简单的数据过滤到复杂的统计分析，从实时视图到定期更新的报表，这些功能为数据管理提供了强大的工具。

今天，我们将深入探索 MongoDB 视图与物化视图的完整体系，通过丰富的实例和实际业务场景，让你掌握这些强大的数据管理工具，成为数据视图设计的专家。

为什么需要视图和物化视图？

视图解决的核心问题

在复杂的业务系统中，数据访问需求往往多样化：

数据安全：不同角色需要访问不同的数据子集
查询简化：复杂的聚合查询需要简化接口
数据整合：多个集合的数据需要统一视图
性能优化：频繁的复杂查询需要性能优化

视图 vs 物化视图对比

让我们看看两种视图方式的对比：

特性	视图（Views）	物化视图（Materialized Views）
数据存储	不存储数据，实时计算	预计算并存储结果
查询性能	每次查询都执行计算	查询预计算结果，性能极佳
存储空间	不占用额外空间	占用存储空间
数据实时性	实时数据	需要定期更新
适用场景	实时查询、权限控制	报表生成、复杂统计
维护成本	低	需要更新策略

视图的核心优势：

数据安全：基于权限的数据访问控制
查询简化：将复杂查询封装为简单接口
数据整合：统一多个数据源
实时性：始终反映最新数据

物化视图的核心优势：

性能优化：预计算结果，查询极快
资源节约：避免重复计算
报表生成：适合定期报表需求
复杂统计：支持复杂的聚合分析

MongoDB 视图基础

视图的基本概念

MongoDB 视图是基于聚合管道的虚拟集合，它不存储实际数据，而是在查询时动态执行聚合管道：

// MongoDB Shell / Node.js
// 视图的基本结构
db.createView(
  "view_name", // 视图名称
  "source_collection", // 源集合
  [
    // 聚合管道
    {
      $match: {
        /* 筛选条件 */
      },
    },
    {
      $project: {
        /* 字段投影 */
      },
    },
    {
      $group: {
        /* 分组统计 */
      },
    },
  ]
);

视图的工作原理

// MongoDB Shell / Node.js
// 1. 创建基础视图
db.createView("active_users", "users", [
  { $match: { status: "active" } },
  { $project: { username: 1, email: 1, createdAt: 1, _id: 0 } },
]);

// 2. 查询视图（就像查询普通集合一样）
db.active_users.find();
db.active_users.find({ username: /^张/ });

// 3. 视图支持所有查询操作
db.active_users.aggregate([
  { $group: { _id: "$username", count: { $sum: 1 } } },
]);

视图与集合的区别

// MongoDB Shell / Node.js
// 1. 普通集合查询
db.users.find({ status: "active" });

// 2. 视图查询（效果相同，但更灵活）
db.active_users.find();

// 3. 视图的优势：可以添加更多逻辑
db.createView("vip_users", "users", [
  { $match: { status: "active", level: { $gte: 3 } } },
  {
    $project: {
      username: 1,
      email: 1,
      level: 1,
      isVip: { $cond: [{ $gte: ["$level", 5] }, true, false] },
    },
  },
]);

视图创建与管理

基础视图创建

简单筛选视图：

// MongoDB Shell / Node.js
// 1. 创建用户筛选视图
db.createView("active_users", "users", [
  { $match: { status: "active" } },
  {
    $project: {
      username: 1,
      email: 1,
      createdAt: 1,
      _id: 0,
    },
  },
]);

// 2. 创建订单筛选视图
db.createView("recent_orders", "orders", [
  {
    $match: {
      createdAt: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) },
      status: { $in: ["completed", "processing"] },
    },
  },
  {
    $project: {
      orderId: 1,
      customerId: 1,
      totalAmount: 1,
      status: 1,
      createdAt: 1,
      _id: 0,
    },
  },
]);

// 3. 创建产品分类视图
db.createView("electronics", "products", [
  { $match: { category: "电子产品" } },
  {
    $project: {
      name: 1,
      price: 1,
      brand: 1,
      stock: 1,
      _id: 0,
    },
  },
]);

聚合视图创建

复杂统计视图：

// MongoDB Shell / Node.js
// 1. 用户统计视图
db.createView("user_statistics", "users", [
  {
    $group: {
      _id: "$department",
      totalUsers: { $sum: 1 },
      activeUsers: {
        $sum: { $cond: [{ $eq: ["$status", "active"] }, 1, 0] },
      },
      avgAge: { $avg: "$age" },
      maxAge: { $max: "$age" },
      minAge: { $min: "$age" },
    },
  },
  {
    $addFields: {
      activeRate: {
        $multiply: [{ $divide: ["$activeUsers", "$totalUsers"] }, 100],
      },
    },
  },
]);

// 2. 销售统计视图
db.createView("sales_summary", "orders", [
  { $match: { status: "completed" } },
  {
    $group: {
      _id: {
        year: { $year: "$createdAt" },
        month: { $month: "$createdAt" },
        category: "$category",
      },
      totalSales: { $sum: "$totalAmount" },
      orderCount: { $sum: 1 },
      avgOrderValue: { $avg: "$totalAmount" },
      maxOrderValue: { $max: "$totalAmount" },
      minOrderValue: { $min: "$totalAmount" },
    },
  },
  { $sort: { "_id.year": -1, "_id.month": -1 } },
]);

// 3. 客户分析视图
db.createView("customer_analysis", "orders", [
  { $match: { status: "completed" } },
  {
    $group: {
      _id: "$customerId",
      totalOrders: { $sum: 1 },
      totalSpent: { $sum: "$totalAmount" },
      avgOrderValue: { $avg: "$totalAmount" },
      firstOrderDate: { $min: "$createdAt" },
      lastOrderDate: { $max: "$createdAt" },
      orderHistory: {
        $push: {
          orderId: "$_id",
          amount: "$totalAmount",
          date: "$createdAt",
        },
      },
    },
  },
  {
    $addFields: {
      customerValue: {
        $switch: {
          branches: [
            { case: { $gte: ["$totalSpent", 10000] }, then: "VIP" },
            { case: { $gte: ["$totalSpent", 5000] }, then: "高级" },
            { case: { $gte: ["$totalSpent", 1000] }, then: "普通" },
          ],
          default: "新客户",
        },
      },
      daysSinceLastOrder: {
        $divide: [{ $subtract: [new Date(), "$lastOrderDate"] }, 86400000],
      },
    },
  },
  { $sort: { totalSpent: -1 } },
]);

视图管理操作

视图的增删改查：

// MongoDB Shell / Node.js
// 1. 查看所有视图
db.runCommand({ listCollections: 1, filter: { type: "view" } });

// 2. 查看特定视图信息
db.runCommand({ listCollections: 1, filter: { name: "active_users" } });

// 3. 查看视图定义
db.runCommand({ listCollections: 1, filter: { name: "active_users" } }).cursor
  .firstBatch[0].options.pipeline;

// 4. 删除视图
db.active_users.drop();

// 5. 重命名视图（通过删除和重建）
db.createView("new_view_name", "source_collection", pipeline);

// 6. 修改视图（删除后重建）
db.old_view.drop();
db.createView("old_view", "source_collection", new_pipeline);

高级视图功能

视图权限控制

基于角色的数据访问：

// MongoDB Shell / Node.js
// 1. 创建不同权限级别的视图
db.createView("public_products", "products", [
  { $match: { status: "active", visibility: "public" } },
  {
    $project: {
      name: 1,
      price: 1,
      category: 1,
      description: 1,
      _id: 0,
    },
  },
]);

db.createView("admin_products", "products", [
  {
    $project: {
      name: 1,
      price: 1,
      cost: 1,
      profit: { $subtract: ["$price", "$cost"] },
      stock: 1,
      status: 1,
      createdAt: 1,
      updatedAt: 1,
      _id: 1,
    },
  },
]);

// 2. 创建部门数据视图
db.createView("hr_employee_data", "employees", [
  {
    $project: {
      employeeId: 1,
      name: 1,
      department: 1,
      position: 1,
      salary: 1,
      hireDate: 1,
      status: 1,
      _id: 0,
    },
  },
]);

db.createView("finance_employee_data", "employees", [
  {
    $project: {
      employeeId: 1,
      name: 1,
      department: 1,
      salary: 1,
      benefits: 1,
      totalCompensation: { $add: ["$salary", "$benefits"] },
      _id: 0,
    },
  },
]);

视图性能优化

索引和查询优化：

// MongoDB Shell / Node.js
// 1. 为视图查询创建索引
db.users.createIndex({ status: 1, createdAt: -1 });
db.orders.createIndex({ status: 1, createdAt: -1, category: 1 });

// 2. 优化视图管道
db.createView("optimized_sales", "orders", [
  {
    $match: {
      status: "completed",
      createdAt: { $gte: new Date("2024-01-01") },
    },
  }, // 早期筛选
  {
    $project: {
      customerId: 1,
      totalAmount: 1,
      category: 1,
      createdAt: 1,
      _id: 0,
    },
  }, // 只选择必要字段
  {
    $group: {
      _id: "$customerId",
      totalSpent: { $sum: "$totalAmount" },
      orderCount: { $sum: 1 },
      categories: { $addToSet: "$category" },
    },
  },
  { $sort: { totalSpent: -1 } },
  { $limit: 1000 }, // 限制结果数量
]);

// 3. 使用复合索引优化
db.orders.createIndex({
  status: 1,
  createdAt: -1,
  customerId: 1,
});

视图监控与调试

性能监控和调试：

// MongoDB Shell / Node.js
// 1. 分析视图查询性能
db.sales_summary.find().explain("executionStats");

// 2. 监控视图使用情况
db.runCommand({
  collStats: "sales_summary",
  indexDetails: true,
});

// 3. 调试视图管道
db.createView("debug_view", "orders", [
  { $match: { status: "completed" } },
  { $addFields: { debugStage: "match_completed" } },
  {
    $group: {
      _id: "$customerId",
      count: { $sum: 1 },
      debugStage: { $first: "$debugStage" },
    },
  },
  { $addFields: { debugStage: "group_by_customer" } },
  { $sort: { count: -1 } },
  { $addFields: { debugStage: "sort_by_count" } },
]);

// 4. 视图查询统计
db.runCommand({
  collStats: "sales_summary",
  scale: 1024, // 以KB为单位
});

物化视图实现

$out 阶段实现物化视图

基础物化视图创建：

// MongoDB Shell / Node.js
// 1. 创建月度销售报表物化视图
db.orders.aggregate([
  {
    $match: {
      status: "completed",
      createdAt: { $gte: new Date("2024-01-01") },
    },
  },
  {
    $group: {
      _id: {
        year: { $year: "$createdAt" },
        month: { $month: "$createdAt" },
        category: "$category",
      },
      totalSales: { $sum: "$totalAmount" },
      orderCount: { $sum: 1 },
      avgOrderValue: { $avg: "$totalAmount" },
      maxOrderValue: { $max: "$totalAmount" },
      minOrderValue: { $min: "$totalAmount" },
      uniqueCustomers: { $addToSet: "$customerId" },
    },
  },
  {
    $addFields: {
      uniqueCustomerCount: { $size: "$uniqueCustomers" },
    },
  },
  { $project: { uniqueCustomers: 0 } }, // 移除数组字段
  { $sort: { "_id.year": -1, "_id.month": -1, totalSales: -1 } },
  { $out: "monthly_sales_materialized" }, // 输出到物化视图
]);

// 2. 创建客户价值分析物化视图
db.orders.aggregate([
  { $match: { status: "completed" } },
  {
    $group: {
      _id: "$customerId",
      totalOrders: { $sum: 1 },
      totalSpent: { $sum: "$totalAmount" },
      avgOrderValue: { $avg: "$totalAmount" },
      firstOrderDate: { $min: "$createdAt" },
      lastOrderDate: { $max: "$createdAt" },
      orderCategories: { $addToSet: "$category" },
    },
  },
  {
    $addFields: {
      customerValue: {
        $switch: {
          branches: [
            { case: { $gte: ["$totalSpent", 50000] }, then: "钻石客户" },
            { case: { $gte: ["$totalSpent", 20000] }, then: "金牌客户" },
            { case: { $gte: ["$totalSpent", 10000] }, then: "银牌客户" },
            { case: { $gte: ["$totalSpent", 5000] }, then: "铜牌客户" },
          ],
          default: "普通客户",
        },
      },
      daysSinceLastOrder: {
        $divide: [{ $subtract: [new Date(), "$lastOrderDate"] }, 86400000],
      },
      categoryCount: { $size: "$orderCategories" },
    },
  },
  { $project: { orderCategories: 0 } },
  { $sort: { totalSpent: -1 } },
  { $out: "customer_value_analysis" },
]);

$merge 阶段实现增量更新

增量更新物化视图：

// MongoDB Shell / Node.js
// 1. 增量更新销售统计
db.orders.aggregate([
  {
    $match: {
      status: "completed",
      updatedAt: { $gte: new Date("2024-01-01") }, // 只处理更新的数据
    },
  },
  {
    $group: {
      _id: {
        year: { $year: "$createdAt" },
        month: { $month: "$createdAt" },
        category: "$category",
      },
      totalSales: { $sum: "$totalAmount" },
      orderCount: { $sum: 1 },
      avgOrderValue: { $avg: "$totalAmount" },
    },
  },
  {
    $merge: {
      into: "monthly_sales_materialized",
      on: ["_id.year", "_id.month", "_id.category"],
      whenMatched: "merge",
      whenNotMatched: "insert",
    },
  },
]);

// 2. 增量更新客户分析
db.orders.aggregate([
  {
    $match: {
      status: "completed",
      createdAt: { $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }, // 最近7天
    },
  },
  {
    $group: {
      _id: "$customerId",
      recentOrders: { $sum: 1 },
      recentSpent: { $sum: "$totalAmount" },
      lastOrderDate: { $max: "$createdAt" },
    },
  },
  {
    $merge: {
      into: "customer_value_analysis",
      on: "_id",
      whenMatched: [
        {
          $set: {
            totalOrders: { $add: ["$totalOrders", "$$new.recentOrders"] },
            totalSpent: { $add: ["$totalSpent", "$$new.recentSpent"] },
            lastOrderDate: "$$new.lastOrderDate",
          },
        },
      ],
      whenNotMatched: "insert",
    },
  },
]);

物化视图管理策略

定期更新和维护：

// Node.js 示例 - 物化视图管理
class MaterializedViewManager {
  constructor(db) {
    this.db = db;
    this.updateSchedules = new Map();
  }

  // 创建物化视图
  async createMaterializedView(name, sourceCollection, pipeline, options = {}) {
    const {
      updateInterval = 3600000, // 1小时
      incremental = false,
      mergeKey = null,
    } = options;

    // 执行初始聚合
    await this.db
      .collection(sourceCollection)
      .aggregate([...pipeline, { $out: name }]);

    // 设置更新计划
    if (updateInterval > 0) {
      this.scheduleUpdate(name, sourceCollection, pipeline, {
        interval: updateInterval,
        incremental,
        mergeKey,
      });
    }

    return { success: true, viewName: name };
  }

  // 安排定期更新
  scheduleUpdate(name, sourceCollection, pipeline, options) {
    const { interval, incremental, mergeKey } = options;

    const updateFunction = async () => {
      try {
        if (incremental && mergeKey) {
          // 增量更新
          await this.incrementalUpdate(
            name,
            sourceCollection,
            pipeline,
            mergeKey
          );
        } else {
          // 全量更新
          await this.fullUpdate(name, sourceCollection, pipeline);
        }
        console.log(`物化视图 ${name} 更新完成`);
      } catch (error) {
        console.error(`物化视图 ${name} 更新失败:`, error);
      }
    };

    const scheduleId = setInterval(updateFunction, interval);
    this.updateSchedules.set(name, scheduleId);
  }

  // 全量更新
  async fullUpdate(viewName, sourceCollection, pipeline) {
    await this.db
      .collection(sourceCollection)
      .aggregate([...pipeline, { $out: viewName }]);
  }

  // 增量更新
  async incrementalUpdate(viewName, sourceCollection, pipeline, mergeKey) {
    const lastUpdate = await this.getLastUpdateTime(viewName);

    const incrementalPipeline = [
      { $match: { updatedAt: { $gte: lastUpdate } } },
      ...pipeline,
      {
        $merge: {
          into: viewName,
          on: mergeKey,
          whenMatched: "merge",
          whenNotMatched: "insert",
        },
      },
    ];

    await this.db.collection(sourceCollection).aggregate(incrementalPipeline);
    await this.updateLastUpdateTime(viewName);
  }

  // 手动触发更新
  async triggerUpdate(viewName) {
    const schedule = this.updateSchedules.get(viewName);
    if (schedule) {
      clearInterval(schedule);
      await this.fullUpdate(viewName, sourceCollection, pipeline);
      this.scheduleUpdate(viewName, sourceCollection, pipeline, options);
    }
  }

  // 停止更新
  stopUpdate(viewName) {
    const schedule = this.updateSchedules.get(viewName);
    if (schedule) {
      clearInterval(schedule);
      this.updateSchedules.delete(viewName);
    }
  }

  // 获取最后更新时间
  async getLastUpdateTime(viewName) {
    const metadata = await this.db
      .collection("view_metadata")
      .findOne({ viewName });
    return metadata ? metadata.lastUpdate : new Date(0);
  }

  // 更新最后更新时间
  async updateLastUpdateTime(viewName) {
    await this.db
      .collection("view_metadata")
      .updateOne(
        { viewName },
        { $set: { lastUpdate: new Date() } },
        { upsert: true }
      );
  }
}

// 使用示例
const viewManager = new MaterializedViewManager(db);

// 创建月度销售报表物化视图
await viewManager.createMaterializedView(
  "monthly_sales_materialized",
  "orders",
  [
    { $match: { status: "completed" } },
    {
      $group: {
        _id: {
          year: { $year: "$createdAt" },
          month: { $month: "$createdAt" },
          category: "$category",
        },
        totalSales: { $sum: "$totalAmount" },
        orderCount: { $sum: 1 },
      },
    },
  ],
  {
    updateInterval: 3600000, // 1小时更新一次
    incremental: true,
    mergeKey: ["_id.year", "_id.month", "_id.category"],
  }
);

实际应用场景

场景 1：多租户 SaaS 应用数据隔离

// Node.js 示例 - 多租户数据视图
class MultiTenantViewManager {
  constructor(db) {
    this.db = db;
  }

  // 为租户创建数据视图
  async createTenantView(tenantId, viewType) {
    const viewName = `tenant_${tenantId}_${viewType}`;

    switch (viewType) {
      case "users":
        return await this.createUserView(tenantId, viewName);
      case "orders":
        return await this.createOrderView(tenantId, viewName);
      case "analytics":
        return await this.createAnalyticsView(tenantId, viewName);
      default:
        throw new Error(`未知的视图类型: ${viewType}`);
    }
  }

  // 创建用户视图
  async createUserView(tenantId, viewName) {
    await this.db.createView(viewName, "users", [
      { $match: { tenantId: tenantId, status: "active" } },
      {
        $project: {
          username: 1,
          email: 1,
          role: 1,
          department: 1,
          createdAt: 1,
          _id: 0,
        },
      },
    ]);
    return viewName;
  }

  // 创建订单视图
  async createOrderView(tenantId, viewName) {
    await this.db.createView(viewName, "orders", [
      { $match: { tenantId: tenantId } },
      {
        $lookup: {
          from: "customers",
          localField: "customerId",
          foreignField: "_id",
          as: "customer",
        },
      },
      { $unwind: "$customer" },
      {
        $project: {
          orderId: 1,
          customerName: "$customer.name",
          totalAmount: 1,
          status: 1,
          createdAt: 1,
          _id: 0,
        },
      },
    ]);
    return viewName;
  }

  // 创建分析视图
  async createAnalyticsView(tenantId, viewName) {
    await this.db.createView(viewName, "orders", [
      { $match: { tenantId: tenantId, status: "completed" } },
      {
        $group: {
          _id: {
            year: { $year: "$createdAt" },
            month: { $month: "$createdAt" },
          },
          totalRevenue: { $sum: "$totalAmount" },
          orderCount: { $sum: 1 },
          uniqueCustomers: { $addToSet: "$customerId" },
        },
      },
      {
        $addFields: {
          uniqueCustomerCount: { $size: "$uniqueCustomers" },
          avgOrderValue: { $divide: ["$totalRevenue", "$orderCount"] },
        },
      },
      { $project: { uniqueCustomers: 0 } },
    ]);
    return viewName;
  }

  // 获取租户数据
  async getTenantData(tenantId, viewType, filters = {}) {
    const viewName = `tenant_${tenantId}_${viewType}`;
    return await this.db.collection(viewName).find(filters).toArray();
  }
}

场景 2：实时报表系统

// Node.js 示例 - 实时报表系统
class RealTimeReportSystem {
  constructor(db) {
    this.db = db;
    this.reportCache = new Map();
  }

  // 创建实时销售报表
  async createRealTimeSalesReport() {
    const reportName = "realtime_sales_report";

    // 创建物化视图
    await this.db.orders.aggregate([
      {
        $match: {
          status: "completed",
          createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) },
        },
      },
      {
        $group: {
          _id: {
            hour: { $hour: "$createdAt" },
            category: "$category",
          },
          totalSales: { $sum: "$totalAmount" },
          orderCount: { $sum: 1 },
          uniqueCustomers: { $addToSet: "$customerId" },
        },
      },
      {
        $addFields: {
          uniqueCustomerCount: { $size: "$uniqueCustomers" },
          avgOrderValue: { $divide: ["$totalSales", "$orderCount"] },
        },
      },
      { $project: { uniqueCustomers: 0 } },
      { $sort: { "_id.hour": 1 } },
      { $out: reportName },
    ]);

    // 设置自动更新
    setInterval(async () => {
      await this.updateRealTimeReport();
    }, 300000); // 5分钟更新一次

    return reportName;
  }

  // 更新实时报表
  async updateRealTimeReport() {
    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);

    await this.db.orders.aggregate([
      {
        $match: {
          status: "completed",
          createdAt: { $gte: oneHourAgo },
        },
      },
      {
        $group: {
          _id: {
            hour: { $hour: "$createdAt" },
            category: "$category",
          },
          totalSales: { $sum: "$totalAmount" },
          orderCount: { $sum: 1 },
        },
      },
      {
        $merge: {
          into: "realtime_sales_report",
          on: ["_id.hour", "_id.category"],
          whenMatched: [
            {
              $set: {
                totalSales: { $add: ["$totalSales", "$$new.totalSales"] },
                orderCount: { $add: ["$orderCount", "$$new.orderCount"] },
              },
            },
          ],
          whenNotMatched: "insert",
        },
      },
    ]);
  }

  // 获取实时报表数据
  async getRealTimeReport(filters = {}) {
    return await this.db
      .collection("realtime_sales_report")
      .find(filters)
      .toArray();
  }

  // 创建客户行为分析报表
  async createCustomerBehaviorReport() {
    await this.db.user_activities.aggregate([
      {
        $match: {
          timestamp: { $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) },
        },
      },
      {
        $group: {
          _id: {
            userId: "$userId",
            action: "$action",
          },
          count: { $sum: 1 },
          lastActivity: { $max: "$timestamp" },
        },
      },
      {
        $group: {
          _id: "$_id.userId",
          activities: {
            $push: {
              action: "$_id.action",
              count: "$count",
              lastActivity: "$lastActivity",
            },
          },
          totalActivities: { $sum: "$count" },
          lastActivity: { $max: "$lastActivity" },
        },
      },
      {
        $addFields: {
          activityScore: {
            $multiply: [
              { $divide: ["$totalActivities", 7] }, // 平均每天活动数
              100,
            ],
          },
        },
      },
      { $sort: { activityScore: -1 } },
      { $out: "customer_behavior_report" },
    ]);
  }
}

场景 3：数据仓库 ETL 流程

// Node.js 示例 - 数据仓库 ETL
class DataWarehouseETL {
  constructor(db) {
    this.db = db;
  }

  // 创建事实表物化视图
  async createFactTable() {
    await this.db.orders.aggregate([
      { $match: { status: "completed" } },
      {
        $lookup: {
          from: "customers",
          localField: "customerId",
          foreignField: "_id",
          as: "customer",
        },
      },
      {
        $lookup: {
          from: "products",
          localField: "items.productId",
          foreignField: "_id",
          as: "products",
        },
      },
      { $unwind: "$items" },
      { $unwind: "$products" },
      {
        $project: {
          orderId: 1,
          customerId: 1,
          productId: "$items.productId",
          quantity: "$items.quantity",
          unitPrice: "$items.price",
          totalAmount: { $multiply: ["$items.quantity", "$items.price"] },
          orderDate: "$createdAt",
          customerSegment: "$customer.segment",
          productCategory: "$products.category",
          region: "$customer.region",
        },
      },
      { $out: "fact_sales" },
    ]);
  }

  // 创建维度表物化视图
  async createDimensionTables() {
    // 客户维度表
    await this.db.customers.aggregate([
      {
        $project: {
          customerId: "$_id",
          name: 1,
          email: 1,
          segment: 1,
          region: 1,
          registrationDate: "$createdAt",
          totalOrders: { $size: "$orders" },
          totalSpent: { $sum: "$orders.totalAmount" },
        },
      },
      { $out: "dim_customers" },
    ]);

    // 产品维度表
    await this.db.products.aggregate([
      {
        $project: {
          productId: "$_id",
          name: 1,
          category: 1,
          brand: 1,
          price: 1,
          cost: 1,
          profit: { $subtract: ["$price", "$cost"] },
          profitMargin: {
            $multiply: [
              { $divide: [{ $subtract: ["$price", "$cost"] }, "$price"] },
              100,
            ],
          },
        },
      },
      { $out: "dim_products" },
    ]);

    // 时间维度表
    await this.db.orders.aggregate([
      {
        $project: {
          orderDate: "$createdAt",
          year: { $year: "$createdAt" },
          quarter: { $ceil: { $divide: [{ $month: "$createdAt" }, 3] } },
          month: { $month: "$createdAt" },
          week: { $week: "$createdAt" },
          dayOfWeek: { $dayOfWeek: "$createdAt" },
          isWeekend: {
            $in: [{ $dayOfWeek: "$createdAt" }, [1, 7]],
          },
        },
      },
      { $group: { _id: "$orderDate" } },
      {
        $project: {
          date: "$_id",
          year: { $year: "$_id" },
          quarter: { $ceil: { $divide: [{ $month: "$_id" }, 3] } },
          month: { $month: "$_id" },
          week: { $week: "$_id" },
          dayOfWeek: { $dayOfWeek: "$_id" },
          isWeekend: {
            $in: [{ $dayOfWeek: "$_id" }, [1, 7]],
          },
        },
      },
      { $out: "dim_dates" },
    ]);
  }

  // 创建聚合报表
  async createAggregatedReports() {
    // 销售趋势报表
    await this.db.collection("fact_sales").aggregate([
      {
        $group: {
          _id: {
            year: "$year",
            month: "$month",
            category: "$productCategory",
          },
          totalSales: { $sum: "$totalAmount" },
          totalQuantity: { $sum: "$quantity" },
          orderCount: { $sum: 1 },
          uniqueCustomers: { $addToSet: "$customerId" },
        },
      },
      {
        $addFields: {
          uniqueCustomerCount: { $size: "$uniqueCustomers" },
          avgOrderValue: { $divide: ["$totalSales", "$orderCount"] },
        },
      },
      { $project: { uniqueCustomers: 0 } },
      { $sort: { "_id.year": -1, "_id.month": -1 } },
      { $out: "rpt_sales_trend" },
    ]);

    // 客户价值分析报表
    await this.db.collection("fact_sales").aggregate([
      {
        $group: {
          _id: "$customerId",
          totalSpent: { $sum: "$totalAmount" },
          totalQuantity: { $sum: "$quantity" },
          orderCount: { $sum: 1 },
          categories: { $addToSet: "$productCategory" },
          regions: { $addToSet: "$region" },
        },
      },
      {
        $addFields: {
          customerValue: {
            $switch: {
              branches: [
                { case: { $gte: ["$totalSpent", 100000] }, then: "钻石" },
                { case: { $gte: ["$totalSpent", 50000] }, then: "金牌" },
                { case: { $gte: ["$totalSpent", 20000] }, then: "银牌" },
                { case: { $gte: ["$totalSpent", 10000] }, then: "铜牌" },
              ],
              default: "普通",
            },
          },
          categoryCount: { $size: "$categories" },
          avgOrderValue: { $divide: ["$totalSpent", "$orderCount"] },
        },
      },
      { $project: { categories: 0, regions: 0 } },
      { $sort: { totalSpent: -1 } },
      { $out: "rpt_customer_value" },
    ]);
  }
}

性能优化策略

视图性能优化

索引和查询优化：

// MongoDB Shell / Node.js
// 1. 为视图查询创建合适的索引
db.users.createIndex({ status: 1, createdAt: -1 });
db.orders.createIndex({ status: 1, createdAt: -1, category: 1 });
db.products.createIndex({ category: 1, status: 1 });

// 2. 优化视图管道
db.createView("optimized_sales_view", "orders", [
  {
    $match: {
      status: "completed",
      createdAt: { $gte: new Date("2024-01-01") },
    },
  }, // 早期筛选
  {
    $project: {
      customerId: 1,
      totalAmount: 1,
      category: 1,
      createdAt: 1,
      _id: 0,
    },
  }, // 只选择必要字段
  {
    $group: {
      _id: "$customerId",
      totalSpent: { $sum: "$totalAmount" },
      orderCount: { $sum: 1 },
      categories: { $addToSet: "$category" },
    },
  },
  { $sort: { totalSpent: -1 } },
  { $limit: 1000 }, // 限制结果数量
]);

// 3. 使用复合索引优化复杂查询
db.orders.createIndex({
  status: 1,
  createdAt: -1,
  customerId: 1,
  category: 1,
});

物化视图性能优化

更新策略和缓存管理：

// Node.js 示例 - 物化视图性能优化
class MaterializedViewOptimizer {
  constructor(db) {
    this.db = db;
    this.updateQueue = new Map();
    this.cacheManager = new Map();
  }

  // 智能更新策略
  async smartUpdate(viewName, updateStrategy = "incremental") {
    const viewInfo = await this.getViewInfo(viewName);

    switch (updateStrategy) {
      case "incremental":
        return await this.incrementalUpdate(viewName, viewInfo);
      case "full":
        return await this.fullUpdate(viewName, viewInfo);
      case "scheduled":
        return await this.scheduledUpdate(viewName, viewInfo);
      default:
        throw new Error(`未知的更新策略: ${updateStrategy}`);
    }
  }

  // 增量更新
  async incrementalUpdate(viewName, viewInfo) {
    const lastUpdate = await this.getLastUpdateTime(viewName);
    const changeThreshold = 0.1; // 10% 变化阈值

    // 检查数据变化量
    const changeRatio = await this.calculateChangeRatio(viewName, lastUpdate);

    if (changeRatio > changeThreshold) {
      // 变化较大，执行全量更新
      return await this.fullUpdate(viewName, viewInfo);
    } else {
      // 变化较小，执行增量更新
      return await this.performIncrementalUpdate(
        viewName,
        viewInfo,
        lastUpdate
      );
    }
  }

  // 计算数据变化比例
  async calculateChangeRatio(viewName, lastUpdate) {
    const totalCount = await this.db
      .collection(viewInfo.sourceCollection)
      .countDocuments();
    const changedCount = await this.db
      .collection(viewInfo.sourceCollection)
      .countDocuments({
        updatedAt: { $gte: lastUpdate },
      });

    return changedCount / totalCount;
  }

  // 批量更新优化
  async batchUpdate(views) {
    const updatePromises = views.map((view) =>
      this.smartUpdate(view.name, view.strategy)
    );

    const results = await Promise.allSettled(updatePromises);

    return results.map((result, index) => ({
      view: views[index].name,
      success: result.status === "fulfilled",
      error: result.status === "rejected" ? result.reason : null,
    }));
  }

  // 缓存管理
  async cacheViewResult(viewName, ttl = 3600000) {
    // 1小时TTL
    const cacheKey = `view_cache_${viewName}`;
    const cached = this.cacheManager.get(cacheKey);

    if (cached && Date.now() - cached.timestamp < ttl) {
      return cached.data;
    }

    const result = await this.db.collection(viewName).find().toArray();
    this.cacheManager.set(cacheKey, {
      data: result,
      timestamp: Date.now(),
    });

    return result;
  }

  // 清理过期缓存
  cleanupCache() {
    const now = Date.now();
    for (const [key, value] of this.cacheManager.entries()) {
      if (now - value.timestamp > 3600000) {
        // 1小时过期
        this.cacheManager.delete(key);
      }
    }
  }
}

内存管理

资源控制和优化：

// Node.js 示例 - 内存管理
class ViewMemoryManager {
  constructor(db) {
    this.db = db;
    this.memoryThreshold = 100 * 1024 * 1024; // 100MB
    this.activeViews = new Set();
  }

  // 监控视图内存使用
  async monitorViewMemory(viewName) {
  // 监控视图内存使用
  async monitorViewMemory(viewName) {
    const stats = await this.db.runCommand({
      collStats: viewName,
      indexDetails: true
    });


    const memoryUsage = stats.size + stats.totalIndexSize;

    if (memoryUsage > this.memoryThreshold) {
      console.warn(`视图 ${viewName} 内存使用过高: ${memoryUsage} bytes`);
      await this.optimizeViewMemory(viewName);
    }

    return {
      viewName,
      memoryUsage,
      isOptimized: memoryUsage <= this.memoryThreshold
    };
  }

  // 优化视图内存使用
  async optimizeViewMemory(viewName) {
    // 清理不必要的索引
    const indexes = await this.db.collection(viewName).listIndexes().toArray();
    for (const index of indexes) {
      if (index.name !== '_id_') {
        await this.db.collection(viewName).dropIndex(index.name);
      }
    }

    // 重建必要索引
    await this.db.collection(viewName).createIndex({ createdAt: -1 });

    console.log(`视图 ${viewName} 内存优化完成`);
  }

  // 批量内存优化
  async batchMemoryOptimization() {
    const views = await this.getAllViews();
    const optimizationPromises = views.map(view =>
      this.monitorViewMemory(view.name)
    );

    const results = await Promise.allSettled(optimizationPromises);
    return results.filter(result => result.status === 'fulfilled');
  }

  // 获取所有视图
  async getAllViews() {
    const collections = await this.db.listCollections().toArray();
    return collections.filter(col => col.type === 'view');
  }
}

企业级开发注意事项

视图安全实践

权限控制和数据安全：

// Node.js 示例 - 视图安全管理
class ViewSecurityManager {
  constructor(db) {
    this.db = db;
    this.userRoles = new Map();
  }

  // 创建安全视图
  async createSecureView(viewName, sourceCollection, pipeline, userRole) {
    // 验证用户权限
    if (!this.hasViewPermission(userRole, viewName)) {
      throw new Error(`用户角色 ${userRole} 无权创建视图 ${viewName}`);
    }

    // 添加安全过滤条件
    const securePipeline = this.addSecurityFilters(pipeline, userRole);

    await this.db.createView(viewName, sourceCollection, securePipeline);

    // 记录审计日志
    await this.logViewCreation(viewName, userRole);

    return viewName;
  }

  // 添加安全过滤条件
  addSecurityFilters(pipeline, userRole) {
    const securityFilters = this.getSecurityFilters(userRole);

    return [{ $match: securityFilters }, ...pipeline];
  }

  // 获取安全过滤条件
  getSecurityFilters(userRole) {
    const roleFilters = {
      admin: {}, // 管理员无限制
      manager: { department: { $in: this.getUserDepartments(userRole) } },
      user: { createdBy: this.getUserId(userRole) },
      guest: { status: "public" },
    };

    return roleFilters[userRole] || { status: "public" };
  }

  // 验证视图访问权限
  async validateViewAccess(viewName, userRole) {
    const viewInfo = await this.getViewInfo(viewName);
    const hasPermission = this.checkViewAccessPermission(viewName, userRole);

    if (!hasPermission) {
      throw new Error(`用户角色 ${userRole} 无权访问视图 ${viewName}`);
    }

    return true;
  }

  // 检查视图访问权限
  checkViewAccessPermission(viewName, userRole) {
    const viewPermissions = this.getViewPermissions(viewName);
    return viewPermissions.includes(userRole);
  }

  // 获取视图权限
  getViewPermissions(viewName) {
    const permissionMap = {
      admin_products: ["admin", "manager"],
      public_products: ["admin", "manager", "user", "guest"],
      hr_employee_data: ["admin", "hr_manager"],
      finance_employee_data: ["admin", "finance_manager"],
    };

    return permissionMap[viewName] || ["admin"];
  }

  // 记录审计日志
  async logViewCreation(viewName, userRole) {
    await this.db.collection("audit_logs").insertOne({
      action: "view_created",
      viewName,
      userRole,
      timestamp: new Date(),
      details: {
        sourceCollection: "users",
        pipeline: "secure_pipeline",
      },
    });
  }

  // 获取用户部门
  getUserDepartments(userRole) {
    const userDepartmentMap = {
      hr_manager: ["HR"],
      finance_manager: ["Finance"],
      sales_manager: ["Sales"],
    };

    return userDepartmentMap[userRole] || [];
  }

  // 获取用户ID
  getUserId(userRole) {
    // 实际应用中从认证系统获取
    return "user_" + userRole;
  }

  // 获取视图信息
  async getViewInfo(viewName) {
    const collections = await this.db.listCollections().toArray();
    return collections.find((col) => col.name === viewName);
  }
}

视图监控和告警

实时监控和性能告警：

// Node.js 示例 - 视图监控系统
class ViewMonitoringSystem {
  constructor(db) {
    this.db = db;
    this.metrics = new Map();
    this.alerts = new Map();
  }

  // 监控视图性能
  async monitorViewPerformance(viewName) {
    const startTime = Date.now();

    try {
      // 执行测试查询
      const result = await this.db
        .collection(viewName)
        .find()
        .limit(1)
        .toArray();
      const executionTime = Date.now() - startTime;

      // 记录性能指标
      this.recordPerformanceMetrics(viewName, executionTime, result.length);

      // 检查性能告警
      this.checkPerformanceAlerts(viewName, executionTime);

      return {
        viewName,
        executionTime,
        resultCount: result.length,
        status: "success",
      };
    } catch (error) {
      this.recordError(viewName, error);
      return {
        viewName,
        error: error.message,
        status: "error",
      };
    }
  }

  // 记录性能指标
  recordPerformanceMetrics(viewName, executionTime, resultCount) {
    const metrics = this.metrics.get(viewName) || {
      totalQueries: 0,
      totalExecutionTime: 0,
      averageExecutionTime: 0,
      maxExecutionTime: 0,
      errorCount: 0,
    };

    metrics.totalQueries++;
    metrics.totalExecutionTime += executionTime;
    metrics.averageExecutionTime =
      metrics.totalExecutionTime / metrics.totalQueries;
    metrics.maxExecutionTime = Math.max(
      metrics.maxExecutionTime,
      executionTime
    );

    this.metrics.set(viewName, metrics);
  }

  // 检查性能告警
  checkPerformanceAlerts(viewName, executionTime) {
    const alertThresholds = {
      slowQuery: 5000, // 5秒
      verySlowQuery: 10000, // 10秒
    };

    if (executionTime > alertThresholds.verySlowQuery) {
      this.triggerAlert(
        viewName,
        "CRITICAL",
        `视图 ${viewName} 执行时间过长: ${executionTime}ms`
      );
    } else if (executionTime > alertThresholds.slowQuery) {
      this.triggerAlert(
        viewName,
        "WARNING",
        `视图 ${viewName} 执行时间较慢: ${executionTime}ms`
      );
    }
  }

  // 触发告警
  triggerAlert(viewName, level, message) {
    const alert = {
      viewName,
      level,
      message,
      timestamp: new Date(),
    };

    this.alerts.set(`${viewName}_${Date.now()}`, alert);
    console.log(`[${level}] ${message}`);
  }

  // 记录错误
  recordError(viewName, error) {
    const metrics = this.metrics.get(viewName) || {
      totalQueries: 0,
      totalExecutionTime: 0,
      averageExecutionTime: 0,
      maxExecutionTime: 0,
      errorCount: 0,
    };

    metrics.errorCount++;
    this.metrics.set(viewName, metrics);

    this.triggerAlert(
      viewName,
      "ERROR",
      `视图 ${viewName} 执行错误: ${error.message}`
    );
  }

  // 获取性能报告
  getPerformanceReport() {
    const report = {};

    for (const [viewName, metrics] of this.metrics.entries()) {
      report[viewName] = {
        ...metrics,
        errorRate: metrics.errorCount / metrics.totalQueries,
        healthScore: this.calculateHealthScore(metrics),
      };
    }

    return report;
  }

  // 计算健康分数
  calculateHealthScore(metrics) {
    const errorRate = metrics.errorCount / metrics.totalQueries;
    const avgTime = metrics.averageExecutionTime;

    let score = 100;

    // 错误率影响
    score -= errorRate * 50;

    // 执行时间影响
    if (avgTime > 10000) score -= 30;
    else if (avgTime > 5000) score -= 20;
    else if (avgTime > 1000) score -= 10;

    return Math.max(0, Math.min(100, score));
  }

  // 获取告警列表
  getAlerts(level = null) {
    const alerts = Array.from(this.alerts.values());

    if (level) {
      return alerts.filter((alert) => alert.level === level);
    }

    return alerts.sort((a, b) => b.timestamp - a.timestamp);
  }

  // 清理过期告警
  cleanupAlerts(maxAge = 24 * 60 * 60 * 1000) {
    // 24小时
    const cutoffTime = Date.now() - maxAge;

    for (const [key, alert] of this.alerts.entries()) {
      if (alert.timestamp.getTime() < cutoffTime) {
        this.alerts.delete(key);
      }
    }
  }
}

物化视图更新策略

智能更新和版本管理：

// Node.js 示例 - 物化视图更新策略
class MaterializedViewUpdateStrategy {
  constructor(db) {
    this.db = db;
    this.updateStrategies = new Map();
    this.versionManager = new Map();
  }

  // 创建更新策略
  async createUpdateStrategy(viewName, strategy) {
    const strategies = {
      realtime: this.createRealtimeStrategy(viewName),
      scheduled: this.createScheduledStrategy(viewName, strategy.schedule),
      triggered: this.createTriggeredStrategy(viewName, strategy.triggers),
      hybrid: this.createHybridStrategy(viewName, strategy),
    };

    const updateStrategy = strategies[strategy.type];
    if (!updateStrategy) {
      throw new Error(`未知的更新策略: ${strategy.type}`);
    }

    this.updateStrategies.set(viewName, updateStrategy);
    return updateStrategy;
  }

  // 实时更新策略
  createRealtimeStrategy(viewName) {
    return {
      type: "realtime",
      update: async () => {
        // 实时更新逻辑
        await this.performRealtimeUpdate(viewName);
      },
      schedule: null,
    };
  }

  // 定时更新策略
  createScheduledStrategy(viewName, schedule) {
    const interval = this.parseSchedule(schedule);

    return {
      type: "scheduled",
      update: async () => {
        await this.performScheduledUpdate(viewName);
      },
      schedule: setInterval(async () => {
        await this.performScheduledUpdate(viewName);
      }, interval),
    };
  }

  // 触发更新策略
  createTriggeredStrategy(viewName, triggers) {
    return {
      type: "triggered",
      update: async (triggerData) => {
        await this.performTriggeredUpdate(viewName, triggerData);
      },
      triggers: triggers,
    };
  }

  // 混合更新策略
  createHybridStrategy(viewName, strategy) {
    return {
      type: "hybrid",
      update: async (context) => {
        if (context.type === "realtime") {
          await this.performRealtimeUpdate(viewName);
        } else if (context.type === "scheduled") {
          await this.performScheduledUpdate(viewName);
        } else if (context.type === "triggered") {
          await this.performTriggeredUpdate(viewName, context.data);
        }
      },
      schedule: strategy.schedule,
      triggers: strategy.triggers,
    };
  }

  // 执行实时更新
  async performRealtimeUpdate(viewName) {
    const viewInfo = await this.getViewInfo(viewName);
    const lastUpdate = await this.getLastUpdateTime(viewName);

    // 只更新变化的数据
    await this.db.collection(viewInfo.sourceCollection).aggregate([
      { $match: { updatedAt: { $gte: lastUpdate } } },
      ...viewInfo.pipeline,
      {
        $merge: {
          into: viewName,
          on: viewInfo.mergeKey,
          whenMatched: "merge",
          whenNotMatched: "insert",
        },
      },
    ]);

    await this.updateLastUpdateTime(viewName);
  }

  // 执行定时更新
  async performScheduledUpdate(viewName) {
    const viewInfo = await this.getViewInfo(viewName);

    // 全量更新
    await this.db
      .collection(viewInfo.sourceCollection)
      .aggregate([...viewInfo.pipeline, { $out: viewName }]);

    await this.updateLastUpdateTime(viewName);
  }

  // 执行触发更新
  async performTriggeredUpdate(viewName, triggerData) {
    const viewInfo = await this.getViewInfo(viewName);

    // 根据触发条件更新
    const updatePipeline = this.buildTriggeredPipeline(viewInfo, triggerData);

    await this.db.collection(viewInfo.sourceCollection).aggregate([
      ...updatePipeline,
      {
        $merge: {
          into: viewName,
          on: viewInfo.mergeKey,
          whenMatched: "merge",
          whenNotMatched: "insert",
        },
      },
    ]);

    await this.updateLastUpdateTime(viewName);
  }

  // 构建触发管道
  buildTriggeredPipeline(viewInfo, triggerData) {
    const basePipeline = viewInfo.pipeline;

    // 根据触发类型添加过滤条件
    if (triggerData.type === "data_change") {
      return [
        {
          $match: {
            _id: { $in: triggerData.affectedIds },
            updatedAt: { $gte: triggerData.timestamp },
          },
        },
        ...basePipeline,
      ];
    } else if (triggerData.type === "time_based") {
      return [
        {
          $match: {
            createdAt: {
              $gte: triggerData.startTime,
              $lte: triggerData.endTime,
            },
          },
        },
        ...basePipeline,
      ];
    }

    return basePipeline;
  }

  // 解析调度表达式
  parseSchedule(schedule) {
    const scheduleMap = {
      every_minute: 60 * 1000,
      every_5_minutes: 5 * 60 * 1000,
      every_hour: 60 * 60 * 1000,
      every_day: 24 * 60 * 60 * 1000,
      every_week: 7 * 24 * 60 * 60 * 1000,
    };

    return scheduleMap[schedule] || 60 * 60 * 1000; // 默认1小时
  }

  // 获取视图信息
  async getViewInfo(viewName) {
    const collections = await this.db.listCollections().toArray();
    const view = collections.find((col) => col.name === viewName);

    if (!view) {
      throw new Error(`视图 ${viewName} 不存在`);
    }

    return {
      sourceCollection: view.options.viewOn,
      pipeline: view.options.pipeline,
      mergeKey: ["_id"], // 默认合并键
    };
  }

  // 获取最后更新时间
  async getLastUpdateTime(viewName) {
    const metadata = await this.db
      .collection("view_metadata")
      .findOne({ viewName });
    return metadata ? metadata.lastUpdate : new Date(0);
  }

  // 更新最后更新时间
  async updateLastUpdateTime(viewName) {
    await this.db
      .collection("view_metadata")
      .updateOne(
        { viewName },
        { $set: { lastUpdate: new Date() } },
        { upsert: true }
      );
  }
}

常见问题与解决方案

视图性能问题

问题 1：视图查询缓慢

// 问题：视图查询执行时间过长
// 解决方案：优化索引和管道

// 1. 检查视图执行计划
db.sales_summary.find().explain("executionStats");

// 2. 为源集合创建合适索引
db.orders.createIndex({ status: 1, createdAt: -1, category: 1 });

// 3. 优化视图管道
db.createView("optimized_sales", "orders", [
  {
    $match: {
      status: "completed",
      createdAt: { $gte: new Date("2024-01-01") },
    },
  }, // 早期筛选
  {
    $project: {
      customerId: 1,
      totalAmount: 1,
      category: 1,
      _id: 0,
    },
  }, // 只选择必要字段
  {
    $group: {
      _id: "$customerId",
      totalSpent: { $sum: "$totalAmount" },
    },
  },
  { $sort: { totalSpent: -1 } },
  { $limit: 1000 }, // 限制结果数量
]);

问题 2：视图内存使用过高

// 问题：视图占用过多内存
// 解决方案：内存管理和优化

// 1. 监控内存使用
db.runCommand({
  collStats: "sales_summary",
  indexDetails: true,
});

// 2. 清理不必要索引
db.sales_summary.getIndexes().forEach((index) => {
  if (index.name !== "_id_") {
    db.sales_summary.dropIndex(index.name);
  }
});

// 3. 重建必要索引
db.sales_summary.createIndex({ totalSpent: -1 });

物化视图更新问题

问题 3：物化视图数据不一致

// 问题：物化视图数据与源数据不一致
// 解决方案：实现一致性检查

// 1. 实现数据一致性检查
async function checkDataConsistency(viewName, sourceCollection) {
  const viewCount = await db.collection(viewName).countDocuments();
  const sourceCount = await db.collection(sourceCollection).countDocuments();

  if (viewCount !== sourceCount) {
    console.warn(`数据不一致: 视图 ${viewCount} vs 源数据 ${sourceCount}`);
    await refreshMaterializedView(viewName, sourceCollection);
  }
}

// 2. 刷新物化视图
async function refreshMaterializedView(viewName, sourceCollection) {
  const pipeline = await getViewPipeline(viewName);

  await db
    .collection(sourceCollection)
    .aggregate([...pipeline, { $out: viewName }]);

  console.log(`物化视图 ${viewName} 已刷新`);
}

问题 4：增量更新失败

// 问题：增量更新时出现错误
// 解决方案：实现错误恢复机制

// 1. 实现增量更新错误恢复
async function incrementalUpdateWithRecovery(
  viewName,
  sourceCollection,
  pipeline
) {
  try {
    // 尝试增量更新
    await performIncrementalUpdate(viewName, sourceCollection, pipeline);
  } catch (error) {
    console.error(`增量更新失败: ${error.message}`);

    // 回退到全量更新
    console.log("回退到全量更新...");
    await performFullUpdate(viewName, sourceCollection, pipeline);
  }
}

// 2. 实现全量更新
async function performFullUpdate(viewName, sourceCollection, pipeline) {
  await db
    .collection(sourceCollection)
    .aggregate([...pipeline, { $out: viewName }]);
}

权限和安全问题

问题 5：视图权限控制失效

// 问题：用户能够访问不应该访问的数据
// 解决方案：加强权限验证

// 1. 实现严格的权限检查
function validateViewAccess(viewName, userRole, userId) {
  const viewPermissions = getViewPermissions(viewName);

  if (!viewPermissions.includes(userRole)) {
    throw new Error(`用户角色 ${userRole} 无权访问视图 ${viewName}`);
  }

  // 检查数据级权限
  const dataFilters = getDataLevelFilters(userRole, userId);
  return dataFilters;
}

// 2. 实现数据级权限过滤
function getDataLevelFilters(userRole, userId) {
  const roleFilters = {
    admin: {},
    manager: { department: getUserDepartment(userId) },
    user: { createdBy: userId },
    guest: { status: "public" },
  };

  return roleFilters[userRole] || { status: "public" };
}