Flutter中Firebase能否使用多个.where()语句实现复杂查询？

问题分析 #

你当前的代码存在几个关键问题：

1. 不必要的async/await：snapshots()直接返回Stream<QuerySnapshot>，不需要用await包裹，函数也无需标记为async
2. Firestore查询限制：whereIn的数组参数长度不能超过10，超过会直接触发报错
3. 逻辑可能不符合实际需求：当前代码是匹配displayName完全等于搜索词拆分后的某一项，而好友搜索场景通常需要的是包含关键词的模糊匹配

解决方案 #

场景1：严格匹配（displayName完全等于搜索词拆分项） #

修正代码，处理whereIn的长度限制，同时移除冗余的异步逻辑：

Stream<QuerySnapshot> searchFriend(
  String loggedInUserId,
  String searchString,
  List<dynamic> idOfFriends,
) {
  // 拆分搜索词并过滤空字符串
  final List<String> searchParse = searchString
      .split(' ')
      .where((term) => term.isNotEmpty)
      .toList();

  // 处理Firestore whereIn的10元素限制，截取前10个有效元素
  final validFriendIds = idOfFriends.take(10).toList();
  final validSearchTerms = searchParse.take(10).toList();

  return db
      .collection('Users')
      .where('id', whereIn: validFriendIds)
      .where('displayName', whereIn: validSearchTerms)
      .snapshots();
}

如果idOfFriends或searchParse长度超过10，需要拆分多个查询再合并结果并去重：

Stream<List<QueryDocumentSnapshot>> searchFriend(
  String loggedInUserId,
  String searchString,
  List<dynamic> idOfFriends,
) {
  final List<String> searchParse = searchString
      .split(' ')
      .where((term) => term.isNotEmpty)
      .toList();

  // 拆分id数组为多个10元素以内的子数组
  final List<List<dynamic>> friendIdChunks = [];
  for (int i = 0; i < idOfFriends.length; i += 10) {
    friendIdChunks.add(idOfFriends.sublist(
      i,
      i + 10 > idOfFriends.length ? idOfFriends.length : i + 10,
    ));
  }

  // 拆分搜索词为多个10元素以内的子数组
  final List<List<String>> searchTermChunks = [];
  for (int i = 0; i < searchParse.length; i += 10) {
    searchTermChunks.add(searchParse.sublist(
      i,
      i + 10 > searchParse.length ? searchParse.length : i + 10,
    ));
  }

  // 生成所有查询组合
  final List<Stream<QuerySnapshot>> queries = [];
  for (final idChunk in friendIdChunks) {
    for (final termChunk in searchTermChunks) {
      queries.add(
        db
            .collection('Users')
            .where('id', whereIn: idChunk)
            .where('displayName', whereIn: termChunk)
            .snapshots(),
      );
    }
  }

  // 合并所有查询结果并去重
  return Stream.merge(queries).map((snapshot) {
    final Set<String> uniqueDocIds = {};
    final List<QueryDocumentSnapshot> uniqueDocs = [];
    for (final doc in snapshot.docs) {
      if (!uniqueDocIds.contains(doc.id)) {
        uniqueDocIds.add(doc.id);
        uniqueDocs.add(doc);
      }
    }
    return uniqueDocs;
  });
}

场景2：模糊匹配（displayName包含搜索关键词） #

这是更符合好友搜索场景的需求，Firestore没有原生模糊查询API，推荐用**预存关键词数组+arrayContainsAny**实现：

步骤1：预存关键词数组

在用户文档中添加displayNameKeywords字段，存储displayName拆分后的小写关键词（创建或更新用户时维护该字段）：

Future<void> updateUserDisplayName(String userId, String newDisplayName) {
  // 拆分displayName为小写关键词数组
  final List<String> keywords = newDisplayName.toLowerCase().split(' ');
  return db.collection('Users').doc(userId).update({
    'displayName': newDisplayName,
    'displayNameKeywords': keywords,
  });
}

步骤2：编写查询代码

Stream<QuerySnapshot> searchFriend(
  String loggedInUserId,
  String searchString,
  List<dynamic> idOfFriends,
) {
  final List<String> searchParse = searchString
      .split(' ')
      .where((term) => term.isNotEmpty)
      .map((term) => term.toLowerCase())
      .toList();

  final validFriendIds = idOfFriends.take(10).toList();
  final validSearchTerms = searchParse.take(10).toList();

  return db
      .collection('Users')
      .where('id', whereIn: validFriendIds)
      .where('displayNameKeywords', arrayContainsAny: validSearchTerms)
      .snapshots();
}

关键注意事项 #

• Firestore的whereIn和arrayContainsAny都有10元素限制，超过需要拆分查询
• 确保为id和displayName（或displayNameKeywords）创建复合索引，否则查询会报错（Firestore控制台会自动提示创建索引的链接）

内容的提问来源于stack exchange，提问作者Vince Gelo Buala