Compound queries (multiple where) in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

Understanding compound queries with multiple where clauses

Consider a Firestore collection named products with documents having fields category (string) and price (number). You want to query products where category is 'electronics' and price is less than 500.

Which query will correctly return the matching documents?

A db.collection('products').where('category', '==', 'electronics').where('price', '>', 500).get()

B db.collection('products').where('category', '==', 'electronics' && 'price', '<', 500).get()

C db.collection('products').where('category', '==', 'electronics').where('price', '<=', 500).get()

D db.collection('products').where('category', '==', 'electronics').where('price', '<', 500).get()

💡 Hint

Remember that Firestore supports chaining multiple where clauses for compound queries.

Option D correctly chains two where clauses: one for category equality and one for price less than 500. Option D is invalid syntax. Option D uses '<=' which includes 500, not strictly less. Option D queries for price greater than 500, which is incorrect.

❓ Architecture

intermediate

Firestore index requirements for compound queries

You have a Firestore query with two where clauses on fields status and priority. What must you ensure for this query to work without errors?

A No index is needed because Firestore automatically indexes all fields

B A composite index on <code>status</code> and <code>priority</code> fields must exist

C Only single-field indexes on <code>status</code> and <code>priority</code> are required

D An index on <code>status</code> only is sufficient

💡 Hint

Firestore requires composite indexes for queries with multiple where clauses on different fields.

Firestore automatically creates single-field indexes but requires a composite index for compound queries involving multiple fields. Without it, the query will fail with an error prompting index creation.

❓ security

advanced

Security rules impact on compound queries

You have Firestore security rules that allow reading documents only if userId field matches the authenticated user's ID. You run a compound query with where('userId', '==', auth.uid) and where('status', '==', 'active'). What will happen if the rules do not explicitly allow filtering by status?

A The query will succeed but only return documents with <code>status</code> 'active' and matching <code>userId</code>

B The query will return documents ignoring the <code>status</code> filter

C The query will fail because Firestore security rules require all queried fields to be allowed

D The query will succeed because <code>userId</code> matches the authenticated user

💡 Hint

Firestore applies security rules to each document returned by the query after server-side filtering.

Option A is correct. The query succeeds and returns only documents matching both conditions because Firestore executes the query server-side, and all returned documents satisfy the security rule (userId matches). Security rules do not need to explicitly reference all query filter fields; they are checked per returned document.

✅ Best Practice

advanced

Optimizing compound queries for performance

You have a Firestore collection with millions of documents. You want to query documents with category == 'books' and rating >= 4. Which approach is best to optimize query performance?

A Create a composite index on <code>category</code> and <code>rating</code> fields and use a compound query with both filters

B Query all documents with <code>category == 'books'</code> and filter <code>rating >= 4</code> in client code

C Use two separate queries for each filter and merge results in client code

D Create single-field indexes on <code>category</code> and <code>rating</code> and query only by <code>category</code>

💡 Hint

Firestore performs best with proper composite indexes for compound queries.

Option A uses a composite index allowing Firestore to efficiently execute the compound query server-side. Options B and C cause large data transfers and client-side filtering, which is inefficient. Option A does not filter by rating server-side.

🧠 Conceptual

expert

Limitations of compound queries in Firestore

Which of the following statements about Firestore compound queries with multiple where clauses is FALSE?

A All fields used in compound queries must be indexed appropriately

B You can combine multiple <code>where</code> clauses on different fields using logical AND

C Firestore supports OR queries natively with multiple <code>where</code> clauses

D Inequality filters (<, <=, >, >=) can only be applied on a single field in a compound query

💡 Hint

Think about how Firestore handles logical operators in queries.

Firestore compound queries combine multiple where clauses with logical AND. It does not support OR queries natively with multiple where clauses. OR queries require different approaches like in or array-contains-any or multiple queries client-side.

Practice

1. What does a compound query with multiple .where() filters do in Firebase Firestore?

easy

A. It deletes documents that match the conditions.

B. It finds documents that match any one of the specified conditions.

C. It finds documents that match all the specified conditions.

D. It updates documents that match the conditions.

Solution

1. Step 1: Understand the purpose of .where() filters

   Each .where() filter narrows down the documents by a condition.

2. Step 2: Combine multiple filters in a compound query

   Multiple .where() filters together find documents matching all conditions (AND logic).

3. Final Answer:

   It finds documents that match all the specified conditions. -> Option C

4. Quick Check:

   Compound query = all conditions matched [OK]

Hint: Multiple .where() means all conditions must be true [OK]

Common Mistakes:

• Thinking it matches any condition (OR logic)
• Confusing query with update or delete
• Assuming it returns all documents

2. Which of the following is the correct syntax to create a compound query with two .where() filters in Firebase Firestore?

easy

A. db.collection('users').where(['age', '>=', 18], ['status', '==', 'active'])

B. db.collection('users').where('age', '>=', 18, 'status', '==', 'active')

C. db.collection('users').filter('age', '>=', 18).filter('status', '==', 'active')

D. db.collection('users').where('status', '==', 'active').where('age', '>=', 18)

Solution

1. Step 1: Review Firestore query chaining syntax

   Each .where() is chained separately with three arguments: field, operator, value.

2. Step 2: Identify correct chaining of two .where() calls

   db.collection('users').where('status', '==', 'active').where('age', '>=', 18) correctly chains two .where() calls with proper arguments.

3. Final Answer:

   db.collection('users').where('status', '==', 'active').where('age', '>=', 18) -> Option D

4. Quick Check:

   Separate .where() calls chained = correct syntax [OK]

Hint: Chain separate .where() calls with 3 arguments each [OK]

Common Mistakes:

• Passing multiple conditions in one .where() call
• Using .filter() instead of .where()
• Incorrect argument grouping inside .where()

3. Given the following Firestore query:

db.collection('orders')
  .where('status', '==', 'shipped')
  .where('total', '>', 100)

What documents will this query return?

medium

A. Orders with status 'shipped' only.

B. Orders with status 'shipped' and total greater than 100.

C. Orders with total greater than 100 only.

D. Orders with status 'shipped' or total greater than 100.

Solution

1. Step 1: Analyze the two .where() filters

   First filter: status must be 'shipped'. Second filter: total must be greater than 100.

2. Step 2: Understand compound query logic

   Both conditions must be true for a document to be returned.

3. Final Answer:

   Orders with status 'shipped' and total greater than 100. -> Option B

4. Quick Check:

   Multiple .where() = AND logic [OK]

Hint: Multiple .where() means all conditions must match [OK]

Common Mistakes:

• Thinking it uses OR logic
• Ignoring one of the filters
• Confusing field names or operators

4. You wrote this Firestore query:

db.collection('products')
  .where('category', '==', 'books')
  .where('price', '<', 20)
  .where('price', '>', 5)
  .orderBy('price')

But Firestore returns an error about missing index. What is the best way to fix this?

medium

A. Create a composite index for 'category' and 'price' fields as requested by Firestore.

B. Remove one of the .where() filters to avoid multiple conditions.

C. Change the query to use only one .where() filter.

D. Rewrite the query using .orderBy() instead of .where().

Solution

1. Step 1: Understand Firestore index requirements for compound queries

   Firestore requires composite indexes for queries with multiple .where() filters on different fields or range filters.

2. Step 2: Follow Firestore error message instructions

   Firestore error usually provides a link to create the needed composite index.

3. Final Answer:

   Create a composite index for 'category' and 'price' fields as requested by Firestore. -> Option A

4. Quick Check:

   Missing index error = create composite index [OK]

Hint: Create composite index when Firestore asks [OK]

Common Mistakes:

• Removing filters instead of creating index
• Ignoring Firestore error message
• Trying to replace .where() with .orderBy() incorrectly

5. You want to query a Firestore collection 'events' for documents where type is 'conference', attendees is greater than 100, and location is 'NYC'. Which of the following is the best approach to write this compound query and ensure it works efficiently?

hard

A. Chain three .where() filters for each condition and create a composite index for these fields.

B. Use a single .where() with an array of conditions for all fields.

C. Query only by type and filter the rest in client code.

D. Use .orderBy() on all fields instead of .where().

Solution

1. Step 1: Write the compound query with multiple .where() filters

   Use .where('type', '==', 'conference'), .where('location', '==', 'NYC'), and .where('attendees', '>', 100) chained together.

2. Step 2: Ensure Firestore has a composite index for these fields

   Because multiple filters on different fields are used, create a composite index to optimize query performance and avoid errors.

3. Final Answer:

   Chain three .where() filters and create a composite index for these fields. -> Option A

4. Quick Check:

   Multiple filters + composite index = efficient query [OK]

Hint: Chain .where() and create composite index for multiple fields [OK]

Common Mistakes:

• Trying to put all conditions in one .where() call
• Filtering on client side instead of query
• Using .orderBy() instead of .where() for filtering