Firestore子字段查询优化技巧分享

在Firestore中，针对动态子字段（如文章的`genres.Action`或`studios.Studio A`）进行灵活查询时，常面临索引爆炸的难题。本文提出一种巧妙的“关键字组合”策略，通过预处理文档数据，将动态子字段信息整合为`keywords`数组，并利用`array-contains`查询，规避了传统复合索引的限制。文章详细阐述了如何改造文档结构，在数据写入时生成关键词，以及如何修改查询函数，以实现高效的流派、工作室等组合过滤。此方法不仅解决了动态子字段查询的索引问题，还提供了可扩展、易维护的解决方案，并探讨了数据冗余、数组大小限制等注意事项，助力开发者构建更强大的Firestore应用。

本文旨在解决 Firestore 中对动态子字段（如 `genres.Action`、`studios.Studio A`）进行查询时遇到的索引问题。通过引入一种“关键字组合”策略，将文档中的动态子字段信息预处理并存储为一个 `keywords` 数组，结合 `array-contains` 查询操作，有效规避了传统复合索引在面对无限组合模式时的局限性，从而实现高效且灵活的过滤功能。

理解 Firestore 动态子字段查询的挑战

在使用 Firestore 构建具有多维度过滤功能的应用程序时，经常会遇到需要根据文档中的子字段进行查询的场景。例如，一个文章集合可能包含 genres 和 studios 字段，它们是映射类型，键代表具体的流派或工作室名称，值通常为 true，表示该文章属于该流派或由该工作室制作。

{
  "title": "Example Article",
  "year": 2023,
  "season": "Fall",
  "genres": {
    "Action": true,
    "Comedy": true,
    "Drama": true
  },
  "studios": {
    "Studio A": true,
    "Studio B": true
  },
  "id": "article-123"
}

当尝试对这些动态子字段进行查询时，例如 where("genres.Action", "==", true) 或 where("studios.Studio A", "==", true)，如果查询条件涉及多个子字段的组合，或者子字段名称本身是动态的（即键值并非固定），Firestore 可能会提示需要创建索引。对于 genres.Action 这样的查询，虽然可以创建单个字段索引，但当流派和工作室的组合数量非常庞大时，手动创建所有可能的复合索引变得不切实际且难以维护。

原始的查询函数示例如下，它尝试直接查询 genres.${filters.genre} 和 studios.${filters.studio}：

import { collection, query, where, orderBy, limit, Query, DocumentData } from "firebase/firestore";
import { firestore } from "./firebaseConfig"; // 假设 firestore 实例已初始化

export function generateSearchQuery(
  searchTerms: string,
  filters: {
    year: number | "";
    season: string;
    genre: string;
    studio: string;
  }
): Query<DocumentData> {
  const docRef = collection(firestore, "example");
  let q = query(docRef);

  if (searchTerms) q = query(q, where("title", "==", searchTerms));
  if (filters.year) q = query(q, where("year", "==", filters.year));
  if (filters.season) q = query(q, where("season", "==", filters.season));
  // 问题所在：直接查询动态子字段
  if (filters.genre) q = query(q, where(`genres.${filters.genre}`, "==", true));
  if (filters.studio)
    q = query(q, where(`studios.${filters.studio}`, "==", true));

  q = query(q, orderBy("id", "desc"), limit(20));

  return q;
}

当 filters.genre 和 filters.studio 同时存在时，Firestore 会要求为 genres.${genre} 和 studios.${studio} 的组合创建复合索引，而这种组合模式是无限的。

解决方案：关键字组合与 array-contains 查询

为了解决上述挑战，一种有效的策略是预处理文档数据，将所有相关的、可用于查询的关键字组合存储在一个新的数组字段中（例如命名为 keywords）。然后，查询时使用 array-contains 操作符来匹配这个 keywords 数组中的元素。

1. 改造文档结构

首先，我们需要修改文档的数据模型，为每个文档添加一个 keywords 字段。这个字段将是一个字符串数组，包含所有可能的流派、工作室以及流派与工作室的组合。

{
  "title": "Example Article",
  "year": 2023,
  "season": "Fall",
  "genres": {
    "Action": true,
    "Comedy": true,
    "Drama": true
  },
  "studios": {
    "Studio A": true,
    "Studio B": true
  },
  "id": "article-123",
  "keywords": [
    "Action",
    "Comedy",
    "Drama",
    "Studio A",
    "Studio B",
    "Action, Studio A",
    "Action, Studio B",
    "Comedy, Studio A",
    "Comedy, Studio B",
    "Drama, Studio A",
    "Drama, Studio B"
  ]
}

2. 生成文档关键字 (数据写入/更新时)

在将数据写入 Firestore 或更新现有文档时，我们需要一个函数来根据 genres 和 studios 字段生成 keywords 数组。

/**
 * 根据文章的流派和工作室信息生成用于查询的关键字数组。
 * 这个函数应在文档创建或更新时调用，并将生成的关键字存储在文档的 'keywords' 字段中。
 * @param genresMap 包含流派名称作为键的映射 (e.g., { "Action": true, "Comedy": true })
 * @param studiosMap 包含工作室名称作为键的映射 (e.g., { "Studio A": true, "Studio B": true })
 * @returns 包含所有流派、工作室及其组合的字符串数组。
 */
function generateDocumentKeywords(
  genresMap: { [key: string]: boolean },
  studiosMap: { [key: string]: boolean }
): string[] {
  const keywords = new Set<string>();
  const documentGenres = Object.keys(genresMap);
  const documentStudios = Object.keys(studiosMap);

  // 添加单个流派作为关键字
  documentGenres.forEach(genre => keywords.add(genre));
  // 添加单个工作室作为关键字
  documentStudios.forEach(studio => keywords.add(studio));

  // 添加流派与工作室的组合作为关键字
  for (const genre of documentGenres) {
    for (const studio of documentStudios) {
      keywords.add(`${genre}, ${studio}`);
    }
  }

  return Array.from(keywords);
}

// 示例：在保存或更新文档时如何使用
// const articleData = {
//   title: "Example Article",
//   // ... 其他字段
//   genres: { "Action": true, "Comedy": true },
//   studios: { "Studio A": true }
// };
// const articleKeywords = generateDocumentKeywords(articleData.genres, articleData.studios);
// await setDoc(docRef, { ...articleData, keywords: articleKeywords }, { merge: true });

3. 修改查询函数

接下来，我们需要修改 generateSearchQuery 函数，使其不再直接查询 genres.${filters.genre} 和 studios.${filters.studio}，而是构建一个目标关键字，并使用 where("keywords", "array-contains", targetKeyword) 进行查询。

/**
 * 根据用户选择的流派和工作室筛选条件，生成用于 array-contains 查询的目标关键字。
 * @param selectedGenre 用户选择的流派
 * @param selectedStudio 用户选择的工作室
 * @returns 组合后的关键字字符串，或空字符串如果两者都未选择。
 */
function generateSearchTarget(selectedGenre: string, selectedStudio: string): string {
  let target = "";

  if (selectedGenre) {
    target += selectedGenre;
  }

  if (selectedGenre && selectedStudio) {
    target += ", "; // 仅当两者都存在时添加分隔符
  }

  if (selectedStudio) {
    target += selectedStudio;
  }

  return target;
}

// 修改后的查询函数
export function generateSearchQuery(
  searchTerms: string,
  filters: {
    year: number | "";
    season: string;
    genre: string;
    studio: string;
  }
): Query<DocumentData> {
  const docRef = collection(firestore, "example");
  let q = query(docRef);

  if (searchTerms) q = query(q, where("title", "==", searchTerms));
  if (filters.year) q = query(q, where("year", "==", filters.year));
  if (filters.season) q = query(q, where("season", "==", filters.season));

  // 使用关键字组合进行查询
  const targetKeyword = generateSearchTarget(filters.genre, filters.studio);
  if (targetKeyword) {
    q = query(q, where("keywords", "array-contains", targetKeyword));
  } else if (filters.genre) { // 如果只选择了流派
    q = query(q, where("keywords", "array-contains", filters.genre));
  } else if (filters.studio) { // 如果只选择了工作室
    q = query(q, where("keywords", "array-contains", filters.studio));
  }
  // 注意：上述 else if 逻辑是可选的，如果 generateSearchTarget 已经能处理单个字段的情况，可以简化。
  // 实际上，generateSearchTarget 已经能够正确生成单个字段的 target。
  // 所以，简化的逻辑如下：
  // const targetKeyword = generateSearchTarget(filters.genre, filters.studio);
  // if (targetKeyword) {
  //   q = query(q, where("keywords", "array-contains", targetKeyword));
  // }


  q = query(q, orderBy("id", "desc"), limit(20));

  return q;
}

4. 索引要求

对于 where("keywords", "array-contains", targetKeyword) 这样的查询，Firestore 会自动提示或要求为 keywords 字段创建一个单字段索引。通常，Firestore 会在您首次运行此类查询时，在控制台中提供一个链接来自动创建所需的索引。

注意事项与总结

1. 数据冗余与一致性：keywords 字段引入了数据冗余。当 genres 或 studios 字段发生变化时，必须确保 keywords 字段也同步更新，以保持数据一致性。这通常通过后端函数（如 Cloud Functions）在文档更新时触发来自动完成。
2. 数组大小限制：Firestore 数组字段有大小限制（最大 1MB），并且每个文档的 keywords 数组中的元素数量也应适度。如果流派和工作室的数量非常庞大，导致组合爆炸，可能需要重新评估此策略或考虑更复杂的搜索方案（如与 Algolia 或 Elasticsearch 集成）。
3. 查询灵活性：此方法能够灵活处理单个流派、单个工作室或流派与工作室的组合查询，而无需为每种组合手动创建复合索引。
4. 性能考量：array-contains 查询通常性能良好，但如果 keywords 数组非常大，或者查询条件非常复杂，仍需进行性能测试。
5. 其他过滤条件：此方案可以与其他 where 条件（如 year、season、title）结合使用。Firestore 将根据所有 where 子句自动优化索引使用。

通过上述“关键字组合”策略，我们成功地解决了 Firestore 在动态子字段上进行复杂查询时的索引挑战，提供了一个可扩展且易于管理的解决方案。

终于介绍完啦！小伙伴们，这篇关于《Firestore子字段查询优化技巧分享》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！