Compound queries (multiple where) in Firebase - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a compound query in Firebase?

A compound query in Firebase is a query that uses more than one 'where' condition to filter documents based on multiple criteria.

beginner

Can you use multiple 'where' clauses on different fields in a single Firebase query?

Yes, Firebase allows multiple 'where' clauses on different fields to create compound queries, as long as the fields are indexed properly.

intermediate

Why do you need indexes for compound queries in Firebase?

Indexes help Firebase quickly find documents that match multiple conditions. Without indexes, compound queries may fail or be slow.

beginner

Example: How to query documents where 'status' is 'active' and 'age' is greater than 25?

Use: collection.where('status', '==', 'active').where('age', '>', 25)

intermediate

What happens if you try a compound query without the required index in Firebase?

Firebase will return an error with a link to create the needed index automatically in the Firebase console.

Which of these is a valid compound query in Firebase?

A collection.where('type', '==', 'book').where('price', '<', 20)

B collection.where('type', '==', 'book').orderBy('type').where('price', '<', 20)

C collection.where('type', '==', 'book').where('price')

D collection.where('type', '==', 'book').where('price', 'between', 10, 20)

Option A uses two valid 'where' clauses with supported operators. Option B mixes orderBy and where incorrectly. Option C is incomplete. Option D uses an unsupported operator.

What must you do before running a compound query on multiple fields in Firebase?

A Enable multi-field queries in settings

B Create a composite index for those fields

C Use only one 'where' clause

D Nothing special, it works by default

Firebase requires a composite index for compound queries on multiple fields to work efficiently.

Which operator is NOT supported in Firebase compound queries?

A ==

B <=

C >

D between

'between' is not a supported operator in Firebase queries; use two conditions instead.

If Firebase returns an error about missing index, what should you do?

A Create the index using the provided link

B Ignore it and retry

C Remove one 'where' clause

D Switch to a different database

Firebase provides a direct link to create the required index in the console to fix the error.

Can you use multiple 'where' clauses on the same field in Firebase?

A Yes, but only with '==' operator

B No, only one 'where' per field

C Yes, with different operators

D Only if the field is indexed twice

You can use multiple 'where' clauses on the same field with different operators, like '>=' and '<='.

Explain how to build a compound query in Firebase and what you need to consider about indexes.

Think about filtering by more than one condition and how Firebase handles that.

Describe what happens if you run a compound query without the necessary index in Firebase.

Consider Firebase's way of guiding you to fix missing indexes.

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