Hey there! Let's break down everything you need to know about using combined range queries as a replacement for Firestore's unsupported != clause. First off, the approach you mentioned—pairing where("age", "<", 30) and where("age", ">", 30) to get all users not aged 30—is completely valid and will give you the exact result set you're after. Below are answers to the most common technical questions about this setup:

• Wait, will this miss any edge cases?
  Nope! Combining the two range queries explicitly excludes any documents where age equals 30, so you'll end up with every user whose age is not 30—exactly what a != query would return (if it were supported).

• Do I need a composite index for this?
  Great question. If you're only filtering on the age field (no other where clauses), you don't need a custom composite index—Firestore automatically supports range queries on a single field. However, if you add another filter (like where("country", "==", "Canada") alongside the age ranges), you'll need to create a composite index that includes both age and country to make the query work.

• How do I actually implement this in code?
  Let's use JavaScript as an example. You'll run both queries, then merge the results (we'll use document IDs to avoid duplicates, since each Firestore document has a unique ID):

  const db = firebase.firestore();
  const usersRef = db.collection('users');
  
  // Set up the two range queries
  const under30Query = usersRef.where('age', '<', 30);
  const over30Query = usersRef.where('age', '>', 30);
  
  // Fetch both results in parallel
  const [under30Snapshot, over30Snapshot] = await Promise.all([
    under30Query.get(),
    over30Query.get()
  ]);
  
  // Combine and deduplicate results
  const uniqueUsers = [];
  const seenDocIds = new Set();
  
  [under30Snapshot, over30Snapshot].forEach(snapshot => {
    snapshot.forEach(doc => {
      if (!seenDocIds.has(doc.id)) {
        seenDocIds.add(doc.id);
        uniqueUsers.push(doc.data());
      }
    });
  });
  

  The logic translates directly to other languages like Swift, Java, or Python: run both queries, then merge and deduplicate the results.

• Will this hurt performance compared to a single query?
  The performance hit is minimal. You're making two network requests instead of one, but Firestore's query speed depends mostly on the number of results returned, not the number of queries. For small to medium result sets, you won't notice a difference. If you're dealing with huge datasets and want to optimize, you could add a boolean field like isAgeNot30 to your documents (and keep it updated when ages change) to allow a single where("isAgeNot30", "==", true) query—just note this requires extra maintenance for data updates.

• What if I need to exclude multiple values (like age !=30 AND age !=40)?
  You'll extend the same logic: split the range into segments that exclude all the values you don't want. For 30 and 40, that would mean three queries: age <30, 30 < age <40, and age>40. Merge those three result sets, and you're good to go. If you're excluding a ton of values, though, this gets cumbersome—consider rethinking your data model (like using an array of excluded ages and Firestore's array operations, or a different categorization field) to simplify things.

Quick side note: Firestore doesn't support != queries because its underlying indexes are ordered. A != condition can't be efficiently resolved with a single ordered index, but range queries can leverage those indexes to quickly find the right documents.

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