Flutter中如何实现Firestore流的OR查询或合并多个流？

Firestore原生查询不支持直接的逻辑OR条件（链式where默认是AND关系），要实现isOpened = false 或 isPending = true的筛选，有两种可行方案：

方案一：客户端过滤流 #

先获取集合的完整流，再在客户端层面过滤符合条件的文档。这种方案适合数据量不大的场景，避免额外的Firestore读取开销：

late Stream<QuerySnapshot> requestsClosedOrPending = FirebaseFirestore.instance
    .collection(clients)
    .snapshots()
    .map((querySnapshot) {
  // 过滤出满足OR条件的文档
  final filteredDocs = querySnapshot.docs.where((doc) {
    final data = doc.data() as Map<String, dynamic>;
    return data['isOpened'] == false || data['isPending'] == true;
  }).toList();
  // 返回包含过滤后文档的QuerySnapshot副本
  return QuerySnapshot(
    docs: filteredDocs,
    query: querySnapshot.query,
    metadata: querySnapshot.metadata,
  );
});

直接将这个处理后的流传入StreamBuilder即可，无需修改Builder内部逻辑。

方案二：合并两个独立查询流 #

分别创建两个对应单一条件的流，再合并为一个流（需处理重复文档，避免同时满足两个条件的文档被重复返回）。这种方案适合数据量较大的场景，减少客户端过滤的计算量：

首先需要依赖rxdart包（在pubspec.yaml中添加rxdart: ^0.27.7），然后实现流合并：

import 'package:rxdart/rxdart.dart';

// 创建两个独立的查询流
Stream<QuerySnapshot> closedRequests = FirebaseFirestore.instance
    .collection(clients)
    .where('isOpened', isEqualTo: false)
    .snapshots();

Stream<QuerySnapshot> pendingRequests = FirebaseFirestore.instance
    .collection(clients)
    .where('isPending', isEqualTo: true)
    .snapshots();

// 合并流并去重
late Stream<QuerySnapshot> requestsClosedOrPending = MergeStream([closedRequests, pendingRequests])
    .scan((acc, snapshot, _) {
  // 用文档ID去重，维护唯一的文档集合
  final allDocs = <String, DocumentSnapshot>{...acc};
  for (var doc in snapshot.docs) {
    allDocs[doc.id] = doc;
  }
  return allDocs.values.toList();
}, <DocumentSnapshot>[])
    .map((docs) => QuerySnapshot(
          docs: docs,
          query: closedRequests.first.query, // 用任意一个查询的query即可
          metadata: closedRequests.first.metadata,
        ));

同样将合并后的流传入StreamBuilder使用。

在StreamBuilder中实现逻辑判断 #

如果不想修改上游流，也可以直接在StreamBuilder的builder方法里过滤数据：

StreamBuilder<QuerySnapshot> requestsStream(Future triggerAnalytics) {
  return StreamBuilder<QuerySnapshot>(
    stream: FirebaseFirestore.instance.collection(clients).snapshots(),
    builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
      if (snapshot.hasData) {
        // 在builder中过滤符合OR条件的文档
        final filteredDocs = snapshot.data!.docs.where((doc) {
          final data = doc.data() as Map<String, dynamic>;
          return data['isOpened'] == false || data['isPending'] == true;
        }).toList();
        // 基于filteredDocs构建UI
        return ListView.builder(
          itemCount: filteredDocs.length,
          itemBuilder: (context, index) {
            // 渲染每个文档的UI
            return ListTile(title: Text(filteredDocs[index]['title']));
          },
        );
      } else if (snapshot.hasError) {
        return Text('Error: ${snapshot.error}');
      }
      return CircularProgressIndicator();
    },
  );
}

这种方式简单直接，但每次快照更新都要在UI线程执行过滤逻辑，数据量大时可能影响性能。

内容的提问来源于stack exchange，提问作者leuji