Array-contains queries in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

Understanding array-contains query behavior

Given a Firestore collection 'users' where each document has a field 'roles' which is an array of strings, what will the following query return?

db.collection('users').where('roles', 'array-contains', 'admin').get()

Assuming documents:
- User A: roles = ['admin', 'editor']
- User B: roles = ['viewer']
- User C: roles = ['admin']

Which users will be returned by this query?

A Users A, B, and C

B Users B and C only

C User C only

D Users A and C only

💡 Hint

The 'array-contains' operator matches documents where the array field contains the specified value anywhere.

The query filters documents where the 'roles' array contains the string 'admin'. User A has 'admin' in roles, User C has 'admin', but User B does not. So only Users A and C are returned.

🧠 Conceptual

intermediate

Limitations of array-contains queries

Which of the following statements about Firestore's 'array-contains' queries is TRUE?

A 'array-contains' can be used to check if an array contains multiple values at once.

B 'array-contains' can be combined with 'array-contains-any' in the same query.

C 'array-contains' can only check for a single value inside an array field.

D 'array-contains' works on fields that are strings, not arrays.

💡 Hint

Think about what 'array-contains' means: it checks for one value inside an array.

'array-contains' only checks if a single value exists inside an array field. To check multiple values, 'array-contains-any' is used. It cannot be combined with 'array-contains' in the same query.

❓ Configuration

advanced

Correct Firestore query for multiple array values

You want to find documents in a 'products' collection where the 'tags' array contains either 'eco' or 'sale'. Which Firestore query code correctly achieves this?

A db.collection('products').where('tags', 'array-contains-any', ['eco', 'sale']).get()

B db.collection('products').where('tags', 'array-contains', ['eco', 'sale']).get()

C db.collection('products').where('tags', 'in', ['eco', 'sale']).get()

D db.collection('products').where('tags', 'array-contains-all', ['eco', 'sale']).get()

💡 Hint

'array-contains-any' checks if the array contains any of the listed values.

'array-contains-any' allows querying documents where the array field contains at least one of the specified values. 'array-contains' only accepts a single value, 'in' works on field values, not array contents, and 'array-contains-all' does not exist.

❓ security

advanced

Security rules impact on array-contains queries

Consider Firestore security rules that restrict read access to documents where the 'roles' array contains 'admin'. Which rule snippet correctly enforces this for read operations?

A allow read: if 'admin' in resource.data.roles;

B allow read: if resource.data.roles == 'admin';

C allow read: if request.auth.token.roles.array-contains('admin');

D allow read: if resource.data.roles.contains('admin');

💡 Hint

Firestore security rules use JavaScript-like syntax with 'in' to check array membership.

In Firestore security rules, to check if an array contains a value, use the 'in' operator: 'value in array'. Option A correctly uses 'admin' in resource.data.roles. Options A and D use invalid syntax, and B compares array to string.

❓ Architecture

expert

Designing Firestore indexes for array-contains queries

You have a Firestore collection 'orders' with a field 'items' which is an array of product IDs. You want to efficiently query orders containing a specific product ID using 'array-contains'. What is the best practice regarding indexes to support this query?

A Create a composite index on 'items' and 'orderDate' fields to support 'array-contains' queries.

B No index is needed; Firestore automatically indexes array fields for 'array-contains' queries.

C Manually create a single-field index on 'items' to enable 'array-contains' queries.

D Disable indexing on 'items' to improve write performance since 'array-contains' queries do not use indexes.

💡 Hint

Firestore automatically indexes array fields for 'array-contains' queries without extra setup.

Firestore automatically creates single-field indexes on array fields to support 'array-contains' queries. Composite indexes are needed only when combining multiple where clauses or ordering. Disabling indexing on 'items' would break queries.

Practice

1.

What does the array-contains query operator do in Firebase Firestore?

easy

A. Finds documents where an array field includes a specific value

B. Finds documents where a string field contains a substring

C. Finds documents where a number field is greater than a value

D. Finds documents where a field is missing

Solution

1. Step 1: Understand the purpose of array-contains

   This operator is designed to check if an array field in a document contains a specific value.

2. Step 2: Compare with other query types

   Other options describe different query operators, but only array-contains matches arrays including a value.

3. Final Answer:

   Finds documents where an array field includes a specific value -> Option A

4. Quick Check:

   array-contains = finds value in array [OK]

Hint: Remember: array-contains checks for one value inside an array [OK]

Common Mistakes:

• Confusing array-contains with substring search
• Using array-contains on non-array fields
• Thinking it works with multiple values at once

2.

Which of the following is the correct syntax to query documents where the tags array contains the value "urgent"?

const query = firestore.collection('tasks').where(____);

easy

A. "tags", "contains", "urgent"

B. "tags", "==", "urgent"

C. "tags", "array-contains-any", ["urgent"]

D. "tags", "array-contains", "urgent"

Solution

1. Step 1: Recall the correct operator for single value in array

   The operator is "array-contains" to check if an array includes a specific value.

2. Step 2: Check syntax format

   The syntax is .where("field", "array-contains", value). "tags", "array-contains", "urgent" matches this exactly.

3. Final Answer:

   "tags", "array-contains", "urgent" -> Option D

4. Quick Check:

   Correct syntax uses array-contains [OK]

Hint: Use "array-contains" for single value array queries [OK]

Common Mistakes:

• Using == instead of array-contains for arrays
• Confusing array-contains with array-contains-any
• Using non-existent operator "contains"

3.

Given the following documents in a Firestore collection projects:

[{ id: 1, members: ["alice", "bob"] }, { id: 2, members: ["carol"] }, { id: 3, members: ["bob", "dave"] }]

What will the query firestore.collection('projects').where('members', 'array-contains', 'bob').get() return?

medium

A. Documents with id 2 only

B. Documents with id 1 only

C. Documents with id 1 and 3

D. No documents

Solution

1. Step 1: Identify documents where 'members' array contains 'bob'

   Document 1 has members ["alice", "bob"] which includes "bob". Document 3 has ["bob", "dave"] which also includes "bob". Document 2 does not.

2. Step 2: Determine query result

   The query returns documents 1 and 3 because their 'members' arrays contain "bob".

3. Final Answer:

   Documents with id 1 and 3 -> Option C

4. Quick Check:

   array-contains 'bob' = docs 1 and 3 [OK]

Hint: Check which arrays include the value exactly [OK]

Common Mistakes:

• Including documents without the value
• Confusing array-contains with array-contains-any
• Assuming partial matches inside strings

4.

What is wrong with this Firestore query?

firestore.collection('orders').where('items', 'array-contains', ['apple', 'banana'])

The items field is an array of strings.

medium

A. You cannot use an array as the value with array-contains

B. The operator should be 'array-contains-any' instead

C. The field 'items' must be a string, not an array

D. The query syntax is correct

Solution

1. Step 1: Understand array-contains value type

   The 'array-contains' operator expects a single value, not an array, to check inside the array field.

2. Step 2: Identify correct usage

   Passing an array as the value causes an error. To check multiple values, 'array-contains-any' is used instead.

3. Final Answer:

   You cannot use an array as the value with array-contains -> Option A

4. Quick Check:

   array-contains needs single value, not array [OK]

Hint: array-contains accepts only one value, not arrays [OK]

Common Mistakes:

• Passing an array as the value to array-contains
• Confusing array-contains with array-contains-any
• Assuming array-contains works like 'in' operator

5.

You want to find all documents in the events collection where the attendees array contains both "john" and "jane". Which approach is correct?

hard

A. Use a single query with array-contains-any and pass both names

B. Use two queries with array-contains for each name and merge results client-side

C. Use a single query with array-contains and pass an array of both names

D. Use a query with where('attendees', '==', ['john', 'jane'])

Solution

1. Step 1: Understand limitations of array-contains and array-contains-any

   array-contains checks for one value in array; array-contains-any checks if array contains any of multiple values but not all.

2. Step 2: Find correct method to get documents containing both values

   Since Firestore does not support querying for multiple values all present in one array in a single query, you must run two queries with array-contains and combine results client-side.

3. Final Answer:

   Use two queries with array-contains for each name and merge results client-side -> Option B

4. Quick Check:

   Multiple array-contains queries combined client-side [OK]

Hint: Firestore can't query multiple array-contains in one query [OK]

Common Mistakes:

• Using array-contains-any expecting all values matched
• Passing array of values to array-contains
• Using equality check on arrays