Firestore添加了管道操作，提供了超过100个新的查询功能

谷歌已经彻底改革了 Firestore 企业版的查询引擎，增加了管道（Pipeline）操作，这让开发者可以将多个查询阶段串联起来，用于复杂的聚合、数组操作和正则表达式匹配。这次更新消除了 Firestore 长期以来的查询限制，并使得索引成为可选的，使数据库与其他主要 NoSQL 平台持平。

一、Firestore 查询引擎的演变

1.1 Firestore 的起源和设计理念

Firestore（前身为 Firebase 实时数据库）是谷歌推出的NoSQL文档数据库，最初设计用于移动和Web应用的实时数据同步。

核心特点

1. 文档-数据模型 { "users": { "user123": { "name": "张三", "email": "zhangsan@example.com", "age": 28, "tags": ["developer", "frontend", "react"], "address": { "city": "北京", "district": "朝阳区" } } } }
2. 实时监听 // 实时监听数据变化 db.collection('users') .doc('user123') .onSnapshot((doc) => { console.log('当前数据：', doc.data()); });
3. 自动扩展 无需管理服务器 按使用付费 全球分布
4. 离线支持 本地缓存 离线操作队列 自动同步

1.2 早期查询引擎的局限性

查询限制

在管道操作之前，Firestore 查询存在重大限制：

1. 单字段排序和过滤 // ❌ 不支持：多个范围查询 db.collection('users') .where('age', '>=', 18) .where('age', '<=', 30) .where('name', '==', '张三') // 错误：只能在单个字段上使用范围查询
2. 索引要求 复合查询必须创建索引 耗时的索引管理 查询失败时需要创建索引
3. 无聚合功能 // ❌ 无法直接统计 db.collection('users') .where('age', '>=', 18) .count() // 不支持 .sum('age') // 不支持 .average('salary') // 不支持
4. 数组操作限制 // ❌ 无法查询数组长度 db.collection('users') .where('tags.length', '>', 2) // 不支持 // ❌ 无法操作数组元素 db.collection('users') .update({ tags: admin.firestore.FieldValue.arrayUnion('new_tag') // 受限 })
5. 正则表达式查询缺失 // ❌ 不支持正则表达式 db.collection('users') .where('email', 'matches', /^.*@gmail.com$/) // 不支持
6. 联表查询复杂 // ❌ 无法直接JOIN // 需要多次查询或在客户端处理

实际影响

开发者面临的问题：

1.3 业界对比

与其他NoSQL数据库的对比

市场份额影响

由于查询限制，许多开发者选择了其他数据库：

• MongoDB：强大的聚合管道
• PostgreSQL：SQL的灵活性
• Redis：高性能键值存储

二、管道操作（Pipeline）详解

2.1 什么是管道操作？

管道操作是一种数据处理范式，允许将多个操作串联起来形成数据处理流水线。每个阶段的输出成为下一个阶段的输入。

概念图

输入数据
    │
    ▼
┌─────────────────┐
│  Stage 1: Match │  ← 过滤数据
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Stage 2: Group │  ← 分组聚合
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Stage 3: Sort │  ← 排序
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Stage 4: Limit│  ← 限制结果
└────────┬────────┘
         │
         ▼
    输出数据

2.2 Firestore管道操作语法

基本结构

const query = db.collection('users')
  .pipe([
    { $match: { age: { $gte: 18 } } },
    { $group: { _id: '$city', count: { $sum: 1 } } },
    { $sort: { count: -1 } }
  ]);

完整的管道阶段

Firestore管道支持以下100+个操作符：

1. 匹配阶段（$match）

// 基本匹配
{ $match: { age: { $gte: 18 } } }

// 多条件匹配
{ $match: {
  age: { $gte: 18, $lte: 30 },
  city: '北京'
}}

// 数组匹配
{ $match: { tags: 'developer' } }

// 嵌套字段匹配
{ $match: { 'address.city': '北京' } }

// 正则表达式匹配（新增！）
{ $match: { email: /^.*@gmail.com$/ } }

// 多种匹配操作符
{ $match: {
  age: { $in: [18, 25, 30] },           // in
  name: { $ne: null },                   // 不等于
  createdAt: { $exists: true }            // 字段存在
}}

2. 分组阶段（$group）

// 按字段分组计数
{ $group: {
  _id: '$city',
  userCount: { $sum: 1 }
}}

// 多级分组
{ $group: {
  _id: {
    city: '$city',
    district: '$address.district'
  },
  count: { $sum: 1 },
  avgAge: { $avg: '$age' },
  maxAge: { $max: '$age' },
  minAge: { $min: '$age' }
}}

// 数组操作
{ $group: {
  _id: null,
  allTags: { $push: '$tags' },
  uniqueTags: { $addToSet: '$tags' }
}}

3. 投影阶段（$project）

// 包含字段
{ $project: {
  name: 1,
  email: 1,
  _id: 0
}}

// 排除字段
{ $project: {
  password: 0,
  secret: 0
}}

// 重命名字段
{ $project: {
  userName: '$name',
  userEmail: '$email',
  userAge: '$age'
}}

// 计算字段
{ $project: {
  name: 1,
  age: 1,
  ageGroup: {
    $cond: [
      { $lt: ['$age', 18] },
      '未成年',
      { $cond: [
        { $lt: ['$age', 60] },
        '成年',
        '老年'
      ]}
    ]
  }
}}

// 数组元素投影
{ $project: {
  name: 1,
  firstTag: { $arrayElemAt: ['$tags', 0] },
  lastTag: { $arrayElemAt: ['$tags', -1] }
}}

4. 展开阶段（$unwind）

// 展开数组
{ $unwind: '$tags' }

// 展开嵌套数组
{ $unwind: { path: '$address.phones' } }

// 保留空数组
{ $unwind: {
  path: '$tags',
  preserveNullAndEmptyArrays: true
}}

// 展开后分组
pipeline = [
  { $unwind: '$tags' },
  { $group: {
    _id: '$tags',
    count: { $sum: 1 }
  }},
  { $sort: { count: -1 } }
]

5. 查找阶段（$lookup）

// 联表查询
{ $lookup: {
  from: 'orders',
  localField: 'userId',
  foreignField: 'userId',
  as: 'userOrders'
}}

// 多级联表
pipeline = [
  { $lookup: {
    from: 'orders',
    localField: 'userId',
    foreignField: 'userId',
    as: 'orders'
  }},
  { $unwind: '$orders' },
  { $lookup: {
    from: 'products',
    localField: 'orders.productId',
    foreignField: 'productId',
    as: 'orders.product'
  }}
]

6. 排序阶段（$sort）

// 单字段排序
{ $sort: { age: 1 } }  // 升序
{ $sort: { age: -1 } } // 降序

// 多字段排序
{ $sort: {
  city: 1,
  age: -1
}}

// 文本字段排序
{ $sort: { name: 1 } }

7. 限制和跳过

// 限制结果数量
{ $limit: 10 }

// 跳过前N条
{ $skip: 20 }

// 分页查询
pipeline = [
  { $match: { age: { $gte: 18 } } },
  { $sort: { createdAt: -1 } },
  { $skip: 20 },
  { $limit: 10 }
]

8. 数组操作符

// 数组长度（新增！）
{ $project: {
  name: 1,
  tagCount: { $size: '$tags' }
}}

// 数组过滤
{ $project: {
  name: 1,
  longTags: {
    $filter: {
      input: '$tags',
      cond: { $gt: [{ $strLenCP: '$$this' }, 5] }
    }
  }
}}

// 数组切片
{ $project: {
  name: 1,
  firstThreeTags: { $slice: ['$tags', 3] }
}}

// 数组元素匹配
{ $match: {
  tags: { $all: ['developer', 'frontend'] }
}}

// 数组位置查询
{ $match: {
  'tags.0': 'developer'  // 第一个元素
}}

9. 条件操作符

// 条件表达式
{ $project: {
  name: 1,
  status: {
    $cond: [
      { $eq: ['$age', 18] },
      '刚成年',
      { $cond: [
        { $lt: ['$age', 30] },
        '青年',
        { $cond: [
          { $lt: ['$age', 60] },
          '中年',
          '老年'
        ]}
      ]}
    ]
  }
}}

// 多条件分支
{ $project: {
  name: 1,
  level: {
    $switch: {
      branches: [
        { case: { $lt: ['$score', 60] }, then: '不及格' },
        { case: { $lt: ['$score', 80] }, then: '及格' },
        { case: { $lt: ['$score', 90] }, then: '良好' }
      ],
      default: '优秀'
    }
  }
}}

// IFNULL
{ $project: {
  name: 1,
  nickname: { $ifNull: ['$nickname', '匿名'] }
}}

10. 字符串操作符（新增！）

// 字符串拼接
{ $project: {
  fullName: { $concat: ['$firstName', ' ', '$lastName'] }
}}

// 字符串长度
{ $project: {
  nameLength: { $strLenCP: '$name' }
}}

// 子字符串
{ $project: {
  namePrefix: { $substr: ['$name', 0, 3] }
}}

// 大小写转换
{ $project: {
  upperName: { $toUpper: '$name' },
  lowerEmail: { $toLower: '$email' }
}}

// 字符串分割
{ $project: {
  tagsArray: { $split: ['$tagsString', ','] }
}}

// 字符串替换
{ $project: {
  cleanName: { $replaceAll: { input: '$name', find: '-', replacement: ' ' } }
}}

// 字符串裁剪
{ $project: {
  trimmedName: { $trim: { input: '$name' } }
}}

11. 日期操作符

// 日期提取
{ $project: {
  year: { $year: '$createdAt' },
  month: { $month: '$createdAt' },
  day: { $dayOfMonth: '$createdAt' },
  hour: { $hour: '$createdAt' },
  weekday: { $dayOfWeek: '$createdAt' }
}}

// 日期运算
{ $project: {
  daysSinceCreated: {
    $divide: [
      { $subtract: [new Date(), '$createdAt'] },
      1000 * 60 * 60 * 24
    ]
  }
}}

// 日期格式化
{ $project: {
  formattedDate: {
    $dateToString: {
      format: '%Y-%m-%d',
      date: '$createdAt'
    }
  }
}}

12. 数学操作符

// 基本运算
{ $project: {
  totalPrice: { $multiply: ['$price', '$quantity'] },
  discountPrice: {
    $subtract: ['$price', { $multiply: ['$price', 0.1] }]
  }
}}

// 取模
{ $project: {
  remainder: { $mod: ['$number', 3] }
}}

// 幂运算
{ $project: {
  square: { $pow: ['$number', 2] }
}}

// 对数
{ $project: {
  logValue: { $log: ['$number', 10] }
}}

// 平方根
{ $project: {
  sqrtValue: { $sqrt: ['$number'] }
}}

// 绝对值
{ $project: {
  absValue: { $abs: ['$number'] }
}}

2.3 实际应用示例

示例1：用户统计仪表板

async function getUserDashboard() {
  const pipeline = [
    // 1. 过滤活跃用户
    {
      $match: {
        status: 'active',
        lastLoginAt: {
          $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
        }
      }
    },
    // 2. 按城市分组统计
    {
      $group: {
        _id: '$city',
        userCount: { $sum: 1 },
        avgAge: { $avg: '$age' },
        totalPurchases: { $sum: '$purchaseCount' },
        totalSpent: { $sum: '$totalSpent' },
        tags: { $push: '$tags' }
      }
    },
    // 3. 展开标签数组
    { $unwind: '$tags' },
    // 4. 按标签再分组
    {
      $group: {
        _id: {
          city: '$_id',
          tag: '$tags'
        },
        city: { $first: '$_id' },
        userCount: { $first: '$userCount' },
        tagCount: { $sum: 1 },
        avgAge: { $first: '$avgAge' },
        totalSpent: { $first: '$totalSpent' }
      }
    },
    // 5. 按城市和标签排序
    {
      $sort: {
        city: 1,
        tagCount: -1
      }
    }
  ];

  const result = await db.collection('users')
    .aggregate(pipeline)
    .get();

  return result.docs;
}

示例2：销售分析报表

async function getSalesReport(startDate, endDate) {
  const pipeline = [
    // 1. 日期范围过滤
    {
      $match: {
        createdAt: {
          $gte: startDate,
          $lte: endDate
        },
        status: 'completed'
      }
    },
    // 2. 展开订单商品
    {
      $unwind: '$items'
    },
    // 3. 联表查询商品信息
    {
      $lookup: {
        from: 'products',
        localField: 'items.productId',
        foreignField: 'productId',
        as: 'product'
      }
    },
    // 4. 展开商品数组
    { $unwind: '$product' },
    // 5. 按商品分类统计
    {
      $group: {
        _id: '$product.category',
        totalRevenue: {
          $sum: {
            $multiply: ['$items.price', '$items.quantity']
          }
        },
        totalQuantity: { $sum: '$items.quantity' },
        avgPrice: { $avg: '$product.price' },
        orderCount: { $sum: 1 },
        products: {
          $addToSet: {
            productId: '$product.productId',
            productName: '$product.name'
          }
        }
      }
    },
    // 6. 计算利润率
    {
      $project: {
        category: '$_id',
        totalRevenue: 1,
        totalQuantity: 1,
        avgPrice: 1,
        orderCount: 1,
        productCount: { $size: '$products' },
        profitMargin: {
          $subtract: [
            1,
            { $divide: ['$totalRevenue', { $multiply: ['$totalQuantity', 100] }] }
          ]
        }
      }
    },
    // 7. 按收入排序
    {
      $sort: { totalRevenue: -1 }
    }
  ];

  const result = await db.collection('orders')
    .aggregate(pipeline)
    .get();

  return result.docs;
}

示例3：用户推荐系统

async function getRecommendations(userId) {
  const pipeline = [
    // 1. 查找用户信息和订单
    {
      $match: { userId: userId }
    },
    // 2. 联表查询订单
    {
      $lookup: {
        from: 'orders',
        localField: 'userId',
        foreignField: 'userId',
        as: 'orders'
      }
    },
    // 3. 展开订单
    { $unwind: '$orders' },
    // 4. 展开订单商品
    { $unwind: '$orders.items' },
    // 5. 获取购买的商品ID
    {
      $group: {
        _id: '$userId',
        purchasedProductIds: {
          $addToSet: '$orders.items.productId'
        },
        userTags: { $first: '$tags' },
        userCity: { $first: '$city' }
      }
    },
    // 6. 联表查询其他用户的购买历史
    {
      $lookup: {
        from: 'user_purchases',
        let: { purchasedIds: '$purchasedProductIds' },
        pipeline: [
          {
            $match: {
              $expr: {
                $in: ['$productId', '$$purchasedIds']
              }
            }
          },
          {
            $group: {
              _id: '$userId',
              similarProductCount: { $sum: 1 },
              recommendedProducts: {
                $addToSet: '$productId'
              }
            }
          }
        ],
        as: 'similarUsers'
      }
    },
    // 7. 获取推荐商品的详细信息
    {
      $lookup: {
        from: 'products',
        let: { recommendedIds: '$similarUsers.recommendedProducts' },
        pipeline: [
          {
            $match: {
              $expr: {
                $and: [
                  { $in: ['$productId', '$$recommendedIds'] },
                  { $not: { $in: ['$productId', '$$purchasedIds'] } }
                ]
              }
            }
          },
          {
            $project: {
              productId: 1,
              name: 1,
              price: 1,
              rating: 1,
              tags: 1
            }
          }
        ],
        as: 'recommendedProducts'
      }
    },
    // 8. 计算推荐分数
    {
      $project: {
        userId: '$_id',
        recommendedProducts: {
          $map: {
            input: '$recommendedProducts',
            as: 'product',
            in: {
              productId: '$$product.productId',
              name: '$$product.name',
              price: '$$product.price',
              rating: '$$product.rating',
              score: {
                $add: [
                  { $multiply: ['$$product.rating', 10] },
                  { $size: { $setIntersection: ['$$product.tags', '$userTags'] } },
                  { $cond: [
                    { $eq: ['$$product.city', '$userCity'] },
                    5,
                    0
                  ]}
                ]
              }
            }
          }
        }
      }
    },
    // 9. 展开推荐商品
    { $unwind: '$recommendedProducts' },
    // 10. 按分数排序
    {
      $sort: { 'recommendedProducts.score': -1 }
    },
    // 11. 限制推荐数量
    { $limit: 10 },
    // 12. 重新组织输出
    {
      $project: {
        productId: '$recommendedProducts.productId',
        name: '$recommendedProducts.name',
        price: '$recommendedProducts.price',
        score: '$recommendedProducts.score'
      }
    }
  ];

  const result = await db.collection('users')
    .aggregate(pipeline)
    .get();

  return result.docs;
}

三、新特性详解

3.1 索引不再是必需的

旧版本的索引依赖

// 旧版本：必须创建复合索引
db.collection('users')
  .where('age', '>=', 18)
  .where('age', '<=', 30)
  .where('city', '==', '北京')

// 错误信息：需要创建索引
// "The query requires an index..."

新版本的智能查询

// 新版本：自动查询优化，无需索引
db.collection('users')
  .pipe([
    { $match: {
      age: { $gte: 18, $lte: 30 },
      city: '北京'
    }}
  ])
  .get()

// Firestore自动优化查询路径
// 对于小数据集：全表扫描更快
// 对于大数据集：自动使用现有索引

查询优化策略

// Firestore的查询优化器会分析：
const optimizationMetrics = {
  dataSize: '评估数据集大小',
  queryComplexity: '查询复杂度',
  indexAvailability: '现有索引',
  cacheHitRate: '缓存命中率',
  networkLatency: '网络延迟'
};

// 自动选择最优执行计划
const executionPlan = optimizer.choosePlan({
  options: ['full-scan', 'index-scan', 'hybrid'],
  metrics: optimizationMetrics
});

3.2 正则表达式支持

基本正则匹配

// 邮箱验证
db.collection('users')
  .pipe([
    {
      $match: {
        email: /^.*@gmail.com$/
      }
    }
  ])

// 手机号匹配
db.collection('users')
  .pipe([
    {
      $match: {
        phone: /^1[3-9]d{9}$/
      }
    }
  ])

// 用户名匹配（包含特定字符）
db.collection('users')
  .pipe([
    {
      $match: {
        username: /.*dev.*/
      }
    }
  ])

高级正则表达式

// 复杂模式匹配
db.collection('logs')
  .pipe([
    {
      $match: {
        // 匹配错误日志
        message: /^(ERROR|WARN)s+[.*?]s+.*$/,
        // 特定格式的日志
        timestamp: /^d{4}-d{2}-d{2}Td{2}:d{2}:d{2}.d{3}Z$/
      }
    }
  ])

// 多条件正则
db.collection('products')
  .pipe([
    {
      $match: {
        $or: [
          { name: /.*iPhone.*/ },
          { name: /.*MacBook.*/ },
          { name: /.*iPad.*/ }
        ]
      }
    }
  ])

正则表达式优化

// 前缀匹配优化
// ✅ 好：有前缀，可以利用索引
{ name: /^Apple iPhone/ }

// ❌ 差：没有前缀，无法利用索引
{ name: /iPhone/ }

// 大小写不敏感
{ email: /^.*@GMAIL.COM$/i }

// 使用管道优化复杂正则
db.collection('users')
  .pipe([
    // 先用简单条件过滤
    { $match: { city: '北京' } },
    // 再用正则匹配
    { $match: { email: /^.*@gmail.com$/ } }
  ])

3.3 数组操作增强

数组查询

// 数组长度查询
db.collection('users')
  .pipe([
    {
      $match: {
        $expr: { $gt: [{ $size: '$tags' }, 3] }
      }
    }
  ])

// 数组元素位置
db.collection('comments')
  .pipe([
    {
      $match: {
        'tags.0': 'hot'  // 第一个标签是'hot'
      }
    }
  ])

// 数组包含所有元素
db.collection('products')
  .pipe([
    {
      $match: {
        tags: { $all: ['electronics', 'new', 'sale'] }
      }
    }
  ])

数组修改

// 添加元素
db.collection('users')
  .doc(userId)
  .update({
    tags: admin.firestore.FieldValue.arrayUnion('new-tag')
  })

// 删除元素
db.collection('users')
  .doc(userId)
  .update({
    tags: admin.firestore.FieldValue.arrayRemove('old-tag')
  })

// 批量更新数组
db.collection('users')
  .pipe([
    { $match: { status: 'active' } }
  ])
  .forEach(doc => {
    db.collection('users')
      .doc(doc.id)
      .update({
        tags: admin.firestore.FieldValue.arrayUnion('verified')
      })
  })

数组聚合

// 数组去重统计
db.collection('users')
  .pipe([
    { $unwind: '$tags' },
    {
      $group: {
        _id: '$tags',
        userCount: { $sum: 1 }
      }
    },
    { $sort: { userCount: -1 } }
  ])

// 数组元素聚合
db.collection('orders')
  .pipe([
    { $unwind: '$items' },
    {
      $group: {
        _id: '$items.productId',
        totalSold: { $sum: '$items.quantity' },
        totalRevenue: {
          $sum: {
            $multiply: ['$items.price', '$items.quantity']
          }
        }
      }
    }
  ])

3.4 地理空间查询

地理空间索引

// 创建地理位置索引
db.collection('stores')
  .doc('store1')
  .set({
    name: '北京店',
    location: new admin.firestore.GeoPoint(39.9042, 116.4074)
  })

地理查询

// 查找附近门店
const center = new admin.firestore.GeoPoint(39.9042, 116.4074);
const radiusInMeters = 1000;

db.collection('stores')
  .pipe([
    {
      $match: {
        location: {
          $near: {
            $geometry: center,
            $maxDistance: radiusInMeters
          }
        }
      }
    }
  ])

// 范围查询
const sw = new admin.firestore.GeoPoint(39.8, 116.3);
const ne = new admin.firestore.GeoPoint(40.0, 116.5);

db.collection('stores')
  .pipe([
    {
      $match: {
        location: {
          $geoWithin: {
            $box: [sw, ne]
          }
        }
      }
    }
  ])

四、性能优化

4.1 查询性能对比

聚合性能

响应时间

// 旧版本：多轮查询
async function oldVersion() {
  const users = await db.collection('users').get();
  const stats = {};

  for (const user of users.docs) {
    const orders = await db.collection('orders')
      .where('userId', '==', user.id)
      .get();

    stats[user.id] = {
      user: user.data(),
      orderCount: orders.size,
      // ... 更多聚合
    };
  }

  return stats;
}
// 耗时：2-5秒

// 新版本：单次管道查询
async function newVersion() {
  const pipeline = [
    { $lookup: {
      from: 'orders',
      localField: 'userId',
      foreignField: 'userId',
      as: 'orders'
    }},
    {
      $project: {
        user: '$$ROOT',
        orderCount: { $size: '$orders' }
      }
    }
  ];

  return await db.collection('users')
    .aggregate(pipeline)
    .get();
}
// 耗时：200-500毫秒

4.2 索引策略

何时使用索引

// ✅ 使用索引：大数据集 + 过滤条件
db.collection('users')
  .pipe([
    { $match: { city: '北京' } }
  ])
  // 数据量：1亿条
  // 使用索引：city（1/20）
  // 性能：~100ms

// ❌ 不需要索引：小数据集
db.collection('users')
  .pipe([
    { $match: { city: '北京' } }
  ])
  // 数据量：1000条
  // 全表扫描更快：~10ms

复合索引策略

// 创建复合索引
db.collection('orders')
  .createIndex({
    userId: 1,
    createdAt: -1,
    status: 1
  })

// 查询优化
db.collection('orders')
  .pipe([
    {
      $match: {
        userId: userId,
        createdAt: {
          $gte: startDate,
          $lte: endDate
        },
        status: 'completed'
      }
    },
    { $sort: { createdAt: -1 } }
  ])

4.3 查询缓存

Firestore查询缓存

// 启用缓存
const db = firebase.firestore();
db.settings({
  cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED
});

// 缓存优先策略
db.collection('users')
  .where('city', '==', '北京')
  .get({ source: 'cache' })
  .then(snapshot => {
    if (snapshot.empty) {
      // 缓存未命中，从服务器获取
      return db.collection('users')
        .where('city', '==', '北京')
        .get({ source: 'server' });
    }
    return snapshot;
  });

五、迁移指南

5.1 从旧查询迁移到管道

案例1：多条件查询

// 旧版本
const query = db.collection('users')
  .where('age', '>=', 18)
  .where('city', '==', '北京')
  .orderBy('createdAt')
  .limit(10);

// 新版本
const pipeline = [
  { $match: {
    age: { $gte: 18 },
    city: '北京'
  }},
  { $sort: { createdAt: -1 } },
  { $limit: 10 }
];

案例2：聚合统计

// 旧版本：客户端聚合
async function getOldStats() {
  const snapshot = await db.collection('users')
    .where('status', '==', 'active')
    .get();

  let total = 0;
  let avgAge = 0;

  snapshot.forEach(doc => {
    total++;
    avgAge += doc.data().age;
  });

  return { total, avgAge: avgAge / total };
}

// 新版本：管道聚合
async function getNewStats() {
  const pipeline = [
    { $match: { status: 'active' } },
    {
      $group: {
        _id: null,
        total: { $sum: 1 },
        avgAge: { $avg: '$age' }
      }
    }
  ];

  const result = await db.collection('users')
    .aggregate(pipeline)
    .get();

  return result.docs[0].data();
}

5.2 最佳实践

1. 查询设计原则

// ✅ 好的查询设计
const goodPipeline = [
  // 早期过滤
  { $match: { status: 'active' } },
  // 早期投影
  { $project: { name: 1, email: 1, _id: 0 } },
  // 后期排序
  { $sort: { name: 1 } },
  // 后期限制
  { $limit: 10 }
];

// ❌ 不好的查询设计
const badPipeline = [
  // 先排序（性能差）
  { $sort: { name: 1 } },
  // 后过滤（数据量大）
  { $match: { status: 'active' } },
  // 后投影（传输数据多）
  { $project: { name: 1, email: 1, _id: 0 } }
];

2. 分阶段优化

// 分阶段执行，逐步优化
const pipeline = [
  // 阶段1：数据收集
  { $match: { /* 条件 */ } },
  // 阶段2：数据转换
  { $project: { /* 投影 */ } },
  // 阶段3：数据聚合
  { $group: { /* 分组 */ } },
  // 阶段4：结果处理
  { $sort: { /* 排序 */ } }
];

// 可以单独测试每个阶段
for (let i = 0; i < pipeline.length; i++) {
  const result = await db.collection('users')
    .aggregate(pipeline.slice(0, i + 1))
    .get();
  console.log(`阶段${i + 1}结果：`, result.docs.length);
}

3. 错误处理

try {
  const result = await db.collection('users')
    .aggregate(pipeline)
    .get();

  // 处理结果
  result.forEach(doc => {
    console.log(doc.data());
  });
} catch (error) {
  // 错误处理
  if (error.code === 'permission-denied') {
    console.error('权限不足');
  } else if (error.code === 'invalid-argument') {
    console.error('查询参数错误');
  } else {
    console.error('未知错误：', error);
  }
}

六、结论

Firestore的管道操作是一个重大的升级，解决了长期以来开发者的痛点：

主要优势

1. 功能完备：100+个操作符，覆盖大多数查询需求
2. 性能提升：减少往返次数，降低网络延迟
3. 开发效率：无需创建复杂索引，简化查询逻辑
4. 竞争力增强：与MongoDB等NoSQL数据库功能持平

建议

• 立即迁移：将现有复杂查询迁移到管道操作
• 学习曲线：团队需要时间学习和适应新语法
• 性能测试：在生产环境部署前进行充分测试
• 监控优化：持续监控查询性能，优化管道

未来展望

• 更多操作符和功能
• 更好的查询优化器
• 与其他Google服务集成
• 边缘查询支持

Firestore正在成为更强大、更灵活的NoSQL数据库，开发者应该充分利用这些新特性来构建更好的应用。

发布日期：2025年2月25日来源：InfoQ技术精选