Cloud Firestore provides powerful query functionality for specifying which
documents you want to retrieve from a collection or collection group. These
queries can also be used with either get() or addSnapshotListener(), as
described in Get Data and Get Realtime Updates.
Example data
To get started, write some data about cities so we can look at different ways to read it back:
Web v8
var citiesRef = db.collection("cities");
citiesRef.doc("SF").set({
name: "San Francisco", state: "CA", country: "USA",
capital: false, population: 860000,
regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
name: "Los Angeles", state: "CA", country: "USA",
capital: false, population: 3900000,
regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
name: "Washington, D.C.", state: null, country: "USA",
capital: true, population: 680000,
regions: ["east_coast"] });
citiesRef.doc("TOK").set({
name: "Tokyo", state: null, country: "Japan",
capital: true, population: 9000000,
regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
name: "Beijing", state: null, country: "China",
capital: true, population: 21500000,
regions: ["jingjinji", "hebei"] });
Web v9
import { collection, doc, setDoc } from "firebase/firestore";
const citiesRef = collection(db, "cities");
await setDoc(doc(citiesRef, "SF"), {
name: "San Francisco", state: "CA", country: "USA",
capital: false, population: 860000,
regions: ["west_coast", "norcal"] });
await setDoc(doc(citiesRef, "LA"), {
name: "Los Angeles", state: "CA", country: "USA",
capital: false, population: 3900000,
regions: ["west_coast", "socal"] });
await setDoc(doc(citiesRef, "DC"), {
name: "Washington, D.C.", state: null, country: "USA",
capital: true, population: 680000,
regions: ["east_coast"] });
await setDoc(doc(citiesRef, "TOK"), {
name: "Tokyo", state: null, country: "Japan",
capital: true, population: 9000000,
regions: ["kanto", "honshu"] });
await setDoc(doc(citiesRef, "BJ"), {
name: "Beijing", state: null, country: "China",
capital: true, population: 21500000,
regions: ["jingjinji", "hebei"] });
Swift
let citiesRef = db.collection("cities")
citiesRef.document("SF").setData([
"name": "San Francisco",
"state": "CA",
"country": "USA",
"capital": false,
"population": 860000,
"regions": ["west_coast", "norcal"]
])
citiesRef.document("LA").setData([
"name": "Los Angeles",
"state": "CA",
"country": "USA",
"capital": false,
"population": 3900000,
"regions": ["west_coast", "socal"]
])
citiesRef.document("DC").setData([
"name": "Washington D.C.",
"country": "USA",
"capital": true,
"population": 680000,
"regions": ["east_coast"]
])
citiesRef.document("TOK").setData([
"name": "Tokyo",
"country": "Japan",
"capital": true,
"population": 9000000,
"regions": ["kanto", "honshu"]
])
citiesRef.document("BJ").setData([
"name": "Beijing",
"country": "China",
"capital": true,
"population": 21500000,
"regions": ["jingjinji", "hebei"]
])
Objective-C
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];
[[citiesRef documentWithPath:@"SF"] setData:@{
@"name": @"San Francisco",
@"state": @"CA",
@"country": @"USA",
@"capital": @(NO),
@"population": @860000,
@"regions": @[@"west_coast", @"norcal"]
}];
[[citiesRef documentWithPath:@"LA"] setData:@{
@"name": @"Los Angeles",
@"state": @"CA",
@"country": @"USA",
@"capital": @(NO),
@"population": @3900000,
@"regions": @[@"west_coast", @"socal"]
}];
[[citiesRef documentWithPath:@"DC"] setData:@{
@"name": @"Washington D.C.",
@"country": @"USA",
@"capital": @(YES),
@"population": @680000,
@"regions": @[@"east_coast"]
}];
[[citiesRef documentWithPath:@"TOK"] setData:@{
@"name": @"Tokyo",
@"country": @"Japan",
@"capital": @(YES),
@"population": @9000000,
@"regions": @[@"kanto", @"honshu"]
}];
[[citiesRef documentWithPath:@"BJ"] setData:@{
@"name": @"Beijing",
@"country": @"China",
@"capital": @(YES),
@"population": @21500000,
@"regions": @[@"jingjinji", @"hebei"]
}];
Java
CollectionReference cities = db.collection("cities");
Map<String, Object> data1 = new HashMap<>();
data1.put("name", "San Francisco");
data1.put("state", "CA");
data1.put("country", "USA");
data1.put("capital", false);
data1.put("population", 860000);
data1.put("regions", Arrays.asList("west_coast", "norcal"));
cities.document("SF").set(data1);
Map<String, Object> data2 = new HashMap<>();
data2.put("name", "Los Angeles");
data2.put("state", "CA");
data2.put("country", "USA");
data2.put("capital", false);
data2.put("population", 3900000);
data2.put("regions", Arrays.asList("west_coast", "socal"));
cities.document("LA").set(data2);
Map<String, Object> data3 = new HashMap<>();
data3.put("name", "Washington D.C.");
data3.put("state", null);
data3.put("country", "USA");
data3.put("capital", true);
data3.put("population", 680000);
data3.put("regions", Arrays.asList("east_coast"));
cities.document("DC").set(data3);
Map<String, Object> data4 = new HashMap<>();
data4.put("name", "Tokyo");
data4.put("state", null);
data4.put("country", "Japan");
data4.put("capital", true);
data4.put("population", 9000000);
data4.put("regions", Arrays.asList("kanto", "honshu"));
cities.document("TOK").set(data4);
Map<String, Object> data5 = new HashMap<>();
data5.put("name", "Beijing");
data5.put("state", null);
data5.put("country", "China");
data5.put("capital", true);
data5.put("population", 21500000);
data5.put("regions", Arrays.asList("jingjinji", "hebei"));
cities.document("BJ").set(data5);
Kotlin+KTX
val cities = db.collection("cities")
val data1 = hashMapOf(
"name" to "San Francisco",
"state" to "CA",
"country" to "USA",
"capital" to false,
"population" to 860000,
"regions" to listOf("west_coast", "norcal")
)
cities.document("SF").set(data1)
val data2 = hashMapOf(
"name" to "Los Angeles",
"state" to "CA",
"country" to "USA",
"capital" to false,
"population" to 3900000,
"regions" to listOf("west_coast", "socal")
)
cities.document("LA").set(data2)
val data3 = hashMapOf(
"name" to "Washington D.C.",
"state" to null,
"country" to "USA",
"capital" to true,
"population" to 680000,
"regions" to listOf("east_coast")
)
cities.document("DC").set(data3)
val data4 = hashMapOf(
"name" to "Tokyo",
"state" to null,
"country" to "Japan",
"capital" to true,
"population" to 9000000,
"regions" to listOf("kanto", "honshu")
)
cities.document("TOK").set(data4)
val data5 = hashMapOf(
"name" to "Beijing",
"state" to null,
"country" to "China",
"capital" to true,
"population" to 21500000,
"regions" to listOf("jingjinji", "hebei")
)
cities.document("BJ").set(data5)
Java
Python
class City(object):
def __init__(self, name, state, country, capital=False, population=0,
regions=[]):
self.name = name
self.state = state
self.country = country
self.capital = capital
self.population = population
self.regions = regions
@staticmethod
def from_dict(source):
# ...
def to_dict(self):
# ...
def __repr__(self):
return(
f'City(\
name={self.name}, \
country={self.country}, \
population={self.population}, \
capital={self.capital}, \
regions={self.regions}\
)'
)
cities_ref = db.collection(u'cities')
cities_ref.document(u'BJ').set(
City(u'Beijing', None, u'China', True, 21500000, [u'hebei']).to_dict())
cities_ref.document(u'SF').set(
City(u'San Francisco', u'CA', u'USA', False, 860000,
[u'west_coast', u'norcal']).to_dict())
cities_ref.document(u'LA').set(
City(u'Los Angeles', u'CA', u'USA', False, 3900000,
[u'west_coast', u'socal']).to_dict())
cities_ref.document(u'DC').set(
City(u'Washington D.C.', None, u'USA', True, 680000,
[u'east_coast']).to_dict())
cities_ref.document(u'TOK').set(
City(u'Tokyo', None, u'Japan', True, 9000000,
[u'kanto', u'honshu']).to_dict())
Python
class City(object):
def __init__(self, name, state, country, capital=False, population=0, regions=[]):
self.name = name
self.state = state
self.country = country
self.capital = capital
self.population = population
self.regions = regions
@staticmethod
def from_dict(source):
# ...
def to_dict(self):
# ...
def __repr__(self):
return f"City(\
name={self.name}, \
country={self.country}, \
population={self.population}, \
capital={self.capital}, \
regions={self.regions}\
)"
cities_ref = db.collection("cities")
await cities_ref.document("BJ").set(
City("Beijing", None, "China", True, 21500000, ["hebei"]).to_dict()
)
await cities_ref.document("SF").set(
City(
"San Francisco", "CA", "USA", False, 860000, ["west_coast", "norcal"]
).to_dict()
)
await cities_ref.document("LA").set(
City(
"Los Angeles", "CA", "USA", False, 3900000, ["west_coast", "socal"]
).to_dict()
)
await cities_ref.document("DC").set(
City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()
)
await cities_ref.document("TOK").set(
City("Tokyo", None, "Japan", True, 9000000, ["kanto", "honshu"]).to_dict()
)
C++
CollectionReference cities = db->Collection("cities");
cities.Document("SF").Set({
{"name", FieldValue::String("San Francisco")},
{"state", FieldValue::String("CA")},
{"country", FieldValue::String("USA")},
{"capital", FieldValue::Boolean(false)},
{"population", FieldValue::Integer(860000)},
{"regions", FieldValue::Array({FieldValue::String("west_coast"),
FieldValue::String("norcal")})},
});
cities.Document("LA").Set({
{"name", FieldValue::String("Los Angeles")},
{"state", FieldValue::String("CA")},
{"country", FieldValue::String("USA")},
{"capital", FieldValue::Boolean(false)},
{"population", FieldValue::Integer(3900000)},
{"regions", FieldValue::Array({FieldValue::String("west_coast"),
FieldValue::String("socal")})},
});
cities.Document("DC").Set({
{"name", FieldValue::String("Washington D.C.")},
{"state", FieldValue::Null()},
{"country", FieldValue::String("USA")},
{"capital", FieldValue::Boolean(true)},
{"population", FieldValue::Integer(680000)},
{"regions",
FieldValue::Array({FieldValue::String("east_coast")})},
});
cities.Document("TOK").Set({
{"name", FieldValue::String("Tokyo")},
{"state", FieldValue::Null()},
{"country", FieldValue::String("Japan")},
{"capital", FieldValue::Boolean(true)},
{"population", FieldValue::Integer(9000000)},
{"regions", FieldValue::Array({FieldValue::String("kanto"),
FieldValue::String("honshu")})},
});
cities.Document("BJ").Set({
{"name", FieldValue::String("Beijing")},
{"state", FieldValue::Null()},
{"country", FieldValue::String("China")},
{"capital", FieldValue::Boolean(true)},
{"population", FieldValue::Integer(21500000)},
{"regions", FieldValue::Array({FieldValue::String("jingjinji"),
FieldValue::String("hebei")})},
});
Node.js
Go
PHP
$citiesRef = $db->collection('samples/php/cities');
$citiesRef->document('SF')->set([
'name' => 'San Francisco',
'state' => 'CA',
'country' => 'USA',
'capital' => false,
'population' => 860000,
'regions' => ['west_coast', 'norcal']
]);
$citiesRef->document('LA')->set([
'name' => 'Los Angeles',
'state' => 'CA',
'country' => 'USA',
'capital' => false,
'population' => 3900000,
'regions' => ['west_coast', 'socal']
]);
$citiesRef->document('DC')->set([
'name' => 'Washington D.C.',
'state' => null,
'country' => 'USA',
'capital' => true,
'population' => 680000,
'regions' => ['east_coast']
]);
$citiesRef->document('TOK')->set([
'name' => 'Tokyo',
'state' => null,
'country' => 'Japan',
'capital' => true,
'population' => 9000000,
'regions' => ['kanto', 'honshu']
]);
$citiesRef->document('BJ')->set([
'name' => 'Beijing',
'state' => null,
'country' => 'China',
'capital' => true,
'population' => 21500000,
'regions' => ['jingjinji', 'hebei']
]);
printf('Added example cities data to the cities collection.' . PHP_EOL);
Unity
CollectionReference citiesRef = db.Collection("cities");
citiesRef.Document("SF").SetAsync(new Dictionary<string, object>(){
{ "Name", "San Francisco" },
{ "State", "CA" },
{ "Country", "USA" },
{ "Capital", false },
{ "Population", 860000 },
{ "Regions", new ArrayList{"west_coast", "norcal"} }
});
citiesRef.Document("LA").SetAsync(new Dictionary<string, object>(){
{ "Name", "Los Angeles" },
{ "State", "CA" },
{ "Country", "USA" },
{ "Capital", false },
{ "Population", 3900000 },
{ "Regions", new ArrayList{"west_coast", "socal"} }
});
citiesRef.Document("DC").SetAsync(new Dictionary<string, object>(){
{ "Name", "Washington D.C." },
{ "State", null },
{ "Country", "USA" },
{ "Capital", true },
{ "Population", 680000 },
{ "Regions", new ArrayList{"east_coast"} }
});
citiesRef.Document("TOK").SetAsync(new Dictionary<string, object>(){
{ "Name", "Tokyo" },
{ "State", null },
{ "Country", "Japan" },
{ "Capital", true },
{ "Population", 9000000 },
{ "Regions", new ArrayList{"kanto", "honshu"} }
});
citiesRef.Document("BJ").SetAsync(new Dictionary<string, object>(){
{ "Name", "Beijing" },
{ "State", null },
{ "Country", "China" },
{ "Capital", true },
{ "Population", 21500000 },
{ "Regions", new ArrayList{"jingjinji", "hebei"} }
});
C#
CollectionReference citiesRef = db.Collection("cities");
await citiesRef.Document("SF").SetAsync(new Dictionary<string, object>(){
{ "Name", "San Francisco" },
{ "State", "CA" },
{ "Country", "USA" },
{ "Capital", false },
{ "Population", 860000 },
{ "Regions", new ArrayList{"west_coast", "norcal"} }
});
await citiesRef.Document("LA").SetAsync(new Dictionary<string, object>(){
{ "Name", "Los Angeles" },
{ "State", "CA" },
{ "Country", "USA" },
{ "Capital", false },
{ "Population", 3900000 },
{ "Regions", new ArrayList{"west_coast", "socal"} }
});
await citiesRef.Document("DC").SetAsync(new Dictionary<string, object>(){
{ "Name", "Washington D.C." },
{ "State", null },
{ "Country", "USA" },
{ "Capital", true },
{ "Population", 680000 },
{ "Regions", new ArrayList{"east_coast"} }
});
await citiesRef.Document("TOK").SetAsync(new Dictionary<string, object>(){
{ "Name", "Tokyo" },
{ "State", null },
{ "Country", "Japan" },
{ "Capital", true },
{ "Population", 9000000 },
{ "Regions", new ArrayList{"kanto", "honshu"} }
});
await citiesRef.Document("BJ").SetAsync(new Dictionary<string, object>(){
{ "Name", "Beijing" },
{ "State", null },
{ "Country", "China" },
{ "Capital", true },
{ "Population", 21500000 },
{ "Regions", new ArrayList{"jingjinji", "hebei"} }
});
Console.WriteLine("Added example cities data to the cities collection.");
Ruby
Simple queries
The following query returns all cities with state CA:
Web v8
// Create a reference to the cities collection
var citiesRef = db.collection("cities");
// Create a query against the collection.
var query = citiesRef.where("state", "==", "CA");
Web v9
// Create a reference to the cities collection
import { collection, query, where } from "firebase/firestore";
const citiesRef = collection(db, "cities");
// Create a query against the collection.
const q = query(citiesRef, where("state", "==", "CA"));
Swift
// Create a reference to the cities collection
let citiesRef = db.collection("cities")
// Create a query against the collection.
let query = citiesRef.whereField("state", isEqualTo: "CA")
Objective-C
// Create a reference to the cities collection FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"]; // Create a query against the collection. FIRQuery *query = [citiesRef queryWhereField:@"state" isEqualTo:@"CA"];
Java
// Create a reference to the cities collection
CollectionReference citiesRef = db.collection("cities");
// Create a query against the collection.
Query query = citiesRef.whereEqualTo("state", "CA");
Kotlin+KTX
// Create a reference to the cities collection
val citiesRef = db.collection("cities")
// Create a query against the collection.
val query = citiesRef.whereEqualTo("state", "CA")
Java
Python
Python
C++
CollectionReference cities_ref = db->Collection("cities");
// Create a query against the collection.
Query query_ca =
cities_ref.WhereEqualTo("state", FieldValue::String("CA"));
Node.js
Go
PHP
$citiesRef = $db->collection('samples/php/cities');
$query = $citiesRef->where('state', '=', 'CA');
$snapshot = $query->documents();
foreach ($snapshot as $document) {
printf('Document %s returned by query state=CA' . PHP_EOL, $document->id());
}
Unity
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereEqualTo("State", "CA");
query.GetSnapshotAsync().ContinueWithOnMainThread((querySnapshotTask) =>
{
foreach (DocumentSnapshot documentSnapshot in querySnapshotTask.Result.Documents)
{
Debug.Log(String.Format("Document {0} returned by query State=CA", documentSnapshot.Id));
}
});
C#
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereEqualTo("State", "CA");
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
{
Console.WriteLine("Document {0} returned by query State=CA", documentSnapshot.Id);
}
Ruby
The following query returns all the capital cities:
Web v8
var citiesRef = db.collection("cities");
var query = citiesRef.where("capital", "==", true);
Web v9
import { collection, query, where } from "firebase/firestore";
const citiesRef = collection(db, "cities");
const q = query(citiesRef, where("capital", "==", true));
Swift
let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)
Objective-C
FIRQuery *capitalCities =
[[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@YES];
Java
Query capitalCities = db.collection("cities").whereEqualTo("capital", true);
Kotlin+KTX
val capitalCities = db.collection("cities").whereEqualTo("capital", true)
Java
Python
Python
C++
Query capital_cities = db->Collection("cities").WhereEqualTo(
"capital", FieldValue::Boolean(true));
Node.js
Go
PHP
$citiesRef = $db->collection('samples/php/cities');
$query = $citiesRef->where('capital', '=', true);
$snapshot = $query->documents();
foreach ($snapshot as $document) {
printf('Document %s returned by query capital=true' . PHP_EOL, $document->id());
}
Unity
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereEqualTo("Capital", true);
query.GetSnapshotAsync().ContinueWithOnMainThread((querySnapshotTask) =>
{
foreach (DocumentSnapshot documentSnapshot in querySnapshotTask.Result.Documents)
{
Debug.Log(String.Format("Document {0} returned by query Capital=true", documentSnapshot.Id));
}
});
C#
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereEqualTo("Capital", true);
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
{
Console.WriteLine("Document {0} returned by query Capital=true", documentSnapshot.Id);
}
Ruby
Execute a query
After creating a query object, use the get() function to retrieve the results:
Web v8
db.collection("cities").where("capital", "==", true)
.get()
.then((querySnapshot) => {
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
console.log(doc.id, " => ", doc.data());
});
})
.catch((error) => {
console.log("Error getting documents: ", error);
});
Web v9
import { collection, query, where, getDocs } from "firebase/firestore";
const q = query(collection(db, "cities"), where("capital", "==", true));
const querySnapshot = await getDocs(q);
querySnapshot.forEach((doc) => {
// doc.data() is never undefined for query doc snapshots
console.log(doc.id, " => ", doc.data());
});
Swift
db.collection("cities").whereField("capital", isEqualTo: true)
.getDocuments() { (querySnapshot, err) in
if let err = err {
print("Error getting documents: \(err)")
} else {
for document in querySnapshot!.documents {
print("\(document.documentID) => \(document.data())")
}
}
}
Objective-C
[[[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@(YES)]
getDocumentsWithCompletion:^(FIRQuerySnapshot *snapshot, NSError *error) {
if (error != nil) {
NSLog(@"Error getting documents: %@", error);
} else {
for (FIRDocumentSnapshot *document in snapshot.documents) {
NSLog(@"%@ => %@", document.documentID, document.data);
}
}
}];
Java
db.collection("cities")
.whereEqualTo("capital", true)
.get()
.addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
@Override
public void onComplete(@NonNull Task<QuerySnapshot> task) {
if (task.isSuccessful()) {
for (QueryDocumentSnapshot document : task.getResult()) {
Log.d(TAG, document.getId() + " => " + document.getData());
}
} else {
Log.d(TAG, "Error getting documents: ", task.getException());
}
}
});
Kotlin+KTX
db.collection("cities")
.whereEqualTo("capital", true)
.get()
.addOnSuccessListener { documents ->
for (document in documents) {
Log.d(TAG, "${document.id} => ${document.data}")
}
}
.addOnFailureListener { exception ->
Log.w(TAG, "Error getting documents: ", exception)
}
Java
Python
Python
C++
db->Collection("cities")
.WhereEqualTo("capital", FieldValue::Boolean(true))
.Get()
.OnCompletion([](const Future<QuerySnapshot>& future) {
if (future.error() == Error::kErrorOk) {
for (const DocumentSnapshot& document :
future.result()->documents()) {
std::cout << document << '\n';
}
} else {
std::cout << "Error getting documents: " << future.error_message()
<< '\n';
}
});
Node.js
Go
PHP
$citiesRef = $db->collection('samples/php/cities');
$query = $citiesRef->where('capital', '=', true);
$documents = $query->documents();
foreach ($documents as $document) {
if ($document->exists()) {
printf('Document data for document %s:' . PHP_EOL, $document->id());
print_r($document->data());
printf(PHP_EOL);
} else {
printf('Document %s does not exist!' . PHP_EOL, $document->id());
}
}
Unity
Query capitalQuery = db.Collection("cities").WhereEqualTo("Capital", true);
capitalQuery.GetSnapshotAsync().ContinueWithOnMainThread(task => {
QuerySnapshot capitalQuerySnapshot = task.Result;
foreach (DocumentSnapshot documentSnapshot in capitalQuerySnapshot.Documents) {
Debug.Log(String.Format("Document data for {0} document:", documentSnapshot.Id));
Dictionary<string, object> city = documentSnapshot.ToDictionary();
foreach (KeyValuePair<string, object> pair in city) {
Debug.Log(String.Format("{0}: {1}", pair.Key, pair.Value));
}
// Newline to separate entries
Debug.Log("");
};
});
C#
Query capitalQuery = db.Collection("cities").WhereEqualTo("Capital", true);
QuerySnapshot capitalQuerySnapshot = await capitalQuery.GetSnapshotAsync();
foreach (DocumentSnapshot documentSnapshot in capitalQuerySnapshot.Documents)
{
Console.WriteLine("Document data for {0} document:", documentSnapshot.Id);
Dictionary<string, object> city = documentSnapshot.ToDictionary();
foreach (KeyValuePair<string, object> pair in city)
{
Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
}
Console.WriteLine("");
}
Ruby
See Get Data for more information on retrieving query results. You can also add a listener to a query to get the current results and listen for future updates.
Query operators
The where() method takes three parameters: a field to filter on, a comparison
operator, and a value. Cloud Firestore supports the following comparison
operators:
<less than<=less than or equal to==equal to>greater than>=greater than or equal to!=not equal toarray-containsarray-contains-anyinnot-in
For example:
Web v8
const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Web v9
const stateQuery = query(citiesRef, where("state", "==", "CA"));
const populationQuery = query(citiesRef, where("population", "<", 100000));
const nameQuery = query(citiesRef, where("name", ">=", "San Francisco"));
Swift
let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")
let populationQuery = citiesRef.whereField("population", isLessThan: 100000)
let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")
Objective-C
FIRQuery *stateQuery = [citiesRef queryWhereField:@"state" isEqualTo:@"CA"]; FIRQuery *populationQuery = [citiesRef queryWhereField:@"population" isLessThan:@100000]; FIRQuery *nameQuery = [citiesRef queryWhereField:@"name" isGreaterThanOrEqualTo:@"San Francisco"];
Java
Query stateQuery = citiesRef.whereEqualTo("state", "CA");
Query populationQuery = citiesRef.whereLessThan("population", 100000);
Query nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco");
Kotlin+KTX
val stateQuery = citiesRef.whereEqualTo("state", "CA")
val populationQuery = citiesRef.whereLessThan("population", 100000)
val nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco")
Java
Python
Python
C++
cities_ref.WhereEqualTo("state", FieldValue::String("CA"));
cities_ref.WhereLessThan("population", FieldValue::Integer(100000));
cities_ref.WhereGreaterThanOrEqualTo("name",
FieldValue::String("San Francisco"));
Node.js
Go
PHP
$stateQuery = $citiesRef->where('state', '=', 'CA');
$populationQuery = $citiesRef->where('population', '>', 1000000);
$nameQuery = $citiesRef->where('name', '>=', 'San Francisco');
Unity
Query stateQuery = citiesRef.WhereEqualTo("State", "CA");
Query populationQuery = citiesRef.WhereGreaterThan("Population", 1000000);
Query nameQuery = citiesRef.WhereGreaterThanOrEqualTo("Name", "San Francisco");
C#
Query stateQuery = citiesRef.WhereEqualTo("State", "CA");
Query populationQuery = citiesRef.WhereGreaterThan("Population", 1000000);
Query nameQuery = citiesRef.WhereGreaterThanOrEqualTo("Name", "San Francisco");
Ruby
Not equal (!=)
Use the not equal (!=) operator to return documents where the given field
exists and does not match the comparison value. For example:
Web
citiesRef.where("capital", "!=", false);
Swift
let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)
Objective-C
query = [citiesRef queryWhereField:@"capital" isNotEqualTo:@NO];
Java
Query notCapitalQuery = citiesRef.whereNotEqualTo("capital", false);
Kotlin+KTX
val notCapitalQuery = citiesRef.whereNotEqualTo("capital", false)
Java
Python
// Snippet not yet available
C++
// Snippet not yet available
Node.js
Go
// Snippet not yet available
PHP
// Snippet not yet available
Unity
// Snippet not yet available
C#
// Snippet not yet available
Ruby
This query returns every city document where the capital field exists with a
value other than false or null. This includes city documents where the
capital field value equals true or any non-boolean value besides null.
This query does not return city documents where the capital field does not
exist. Not-equal (!=) and not-in queries exclude documents where the
given field does not exist.
A field exists when it's set to any value, including an empty string (""),
null, and NaN (not a number). Note that null field values do not
match != clauses, because x != null evaluates to undefined.
Limitations
Note the following limitations for != queries:
- Only documents where the given field exists can match the query.
- You can't combine
not-inand!=in a compound query. - In a compound query, range (
<,<=,>,>=) and not equals (!=,not-in) comparisons must all filter on the same field.
Array membership
You can use the array-contains operator to filter based on array
values. For example:
Web v8
citiesRef.where("regions", "array-contains", "west_coast");
Web v9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where("regions", "array-contains", "west_coast"));
Swift
citiesRef
.whereField("regions", arrayContains: "west_coast")
Objective-C
[citiesRef queryWhereField:@"state" arrayContains:@"west_coast"];
Java
CollectionReference citiesRef = db.collection("cities");
citiesRef.whereArrayContains("regions", "west_coast");
Kotlin+KTX
val citiesRef = db.collection("cities")
citiesRef.whereArrayContains("regions", "west_coast")
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
$containsQuery = $citiesRef->where('regions', 'array-contains', 'west_coast');
Unity
CollectionReference citiesRef = db.Collection("cities");
Query arrayContainsQuery = citiesRef.WhereArrayContains("region", "west_coast");
C#
Query query = citiesRef.WhereArrayContains("Regions", "west_coast");
Ruby
This query returns every city document where the regions field is an array that
contains west_coast. If the array has multiple instances of the value you
query on, the document is included in the results only once.
You can use at most one array-contains clause per query. You can't combine
array-contains with array-contains-any.
in, not-in, and array-contains-any
Use the in operator to combine up to 10 equality (==) clauses on
the same field with a logical OR. An in query returns documents
where the given field matches any of the comparison values. For example:
Web
citiesRef.where('country', 'in', ['USA', 'Japan']);
Swift
let citiesRef = db.collection("cities")
citiesRef.whereField("country", in: ["USA", "Japan"])
Objective-C
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"]; [citiesRef queryWhereField:@"country" in:@[@"USA", @"Japan"]];
Java
CollectionReference citiesRef = db.collection("cities");
citiesRef.whereIn("country", Arrays.asList("USA", "Japan"));
Kotlin+KTX
val citiesRef = db.collection("cities")
citiesRef.whereIn("country", listOf("USA", "Japan"))
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
// Snippet not yet available
Unity
CollectionReference citiesRef = db.Collection("cities");
List countriesList = new List<object>() {"USA", "Japan"};
Query whereInQuery = citiesRef.WhereIn("country", countriesList);
C#
Query query = citiesRef.WhereIn("Country", new[] { "USA", "Japan" });
Ruby
This query returns every city document where the country field is set
to USA or Japan. From the example data, this includes
the SF, LA, DC, and TOK documents.
not-in
Use the not-in operator to combine up to 10 not equal (!=) clauses on the
same field with a logical AND. A not-in query returns documents where the
given field exists, is not null, and does not match any of the
comparison values. For example:
Web
citiesRef.where('country', 'not-in', ['USA', 'Japan']);
Swift
citiesRef.whereField("country", notIn: ["USA", "Japan"])
Objective-C
[citiesRef queryWhereField:@"country" notIn:@[@"USA", @"Japan"]];
Java
citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));
Kotlin+KTX
citiesRef.whereNotIn("country", listOf("USA", "Japan"))
Java
Python
// Snippet not yet available
C++
// Snippet not yet available
Node.js
Go
// Snippet not yet available
PHP
// Snippet not yet available
Unity
// Snippet not yet available
C#
// Snippet not yet available
Ruby
This query returns every city document where the country field exists and is
not set to USA, Japan, or null. From the example data, this includes the
London and Hong Kong documents.
not-in queries exclude documents where the
given field does not exist. A field exists when it's set to any value,
including an empty string (""), null, and NaN (not a number). Note
that x != null evaluates to undefined. A not-in query with
null as one of the comparison values does not match any documents.
array-contains-any
Use the array-contains-any operator to combine up to 10
array-contains clauses on the same field with a logical OR. An
array-contains-any query returns documents where the given field is an array
that contains one or more of the comparison values:
Web
citiesRef.where('regions', 'array-contains-any',
['west_coast', 'east_coast']);
Swift
let citiesRef = db.collection("cities")
citiesRef.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])
Objective-C
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"]; [citiesRef queryWhereField:@"regions" arrayContainsAny:@[@"west_coast", @"east_coast"]];
Java
CollectionReference citiesRef = db.collection("cities");
citiesRef.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));
Kotlin+KTX
val citiesRef = db.collection("cities")
citiesRef.whereArrayContainsAny("regions", listOf("west_coast", "east_coast"))
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
// Snippet not yet available
Unity
CollectionReference citiesRef = db.Collection("cities");
List regionsList = new List<object>() {"west_coast", "east_coast"};
Query arrayContainsAnyQuery = citiesRef.WhereArrayContainsAny("regions", regionsList);
C#
Query query = citiesRef.WhereArrayContainsAny("Regions", new[] { "west_coast", "east_coast" });
Ruby
This query returns every city document where the region field is an array
that contains west_coast or east_coast. From the example data, this includes
the SF, LA, and DC documents.
Results from array-contains-any are de-duped. Even if a document's array field
matches more than one of the comparison values, the result set includes that
document only once.
array-contains-any always filters by the array data type. For example, the
query above would not return a city document where instead of an array, the
region field is the string west_coast.
You can use an array value as a comparison value for in, but unlike
array-contains-any, the clause matches for an exact match of array length,
order, and values. For example:
Web
citiesRef.where('region', 'in',
[['west_coast', 'east_coast']]);
Swift
citiesRef.whereField("regions", in: [["west_coast"], ["east_coast"]]);
Objective-C
[citiesRef queryWhereField:@"regions" in:@[@[@"west_coast"], @[@"east_coast"]]];
Java
citiesRef.whereIn("regions", Arrays.asList(new String[]{"west_coast"}, new String[]{"east_coast"}));
Kotlin+KTX
citiesRef.whereIn("regions", listOf(arrayOf("west_coast"), arrayOf("east_coast")))
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
// Snippet not yet available
Unity
// Not yet supported in the Unity SDK
C#
Query query = citiesRef.WhereIn("Regions",
new[] { new[] { "west_coast" }, new[] { "east_coast" } });
Ruby
This query returns every city document where the region field is an array
that contains exactly one element of either west_coast or east_coast.
From the example data, only the DC document qualifies with its region field
of ["east_coast"]. The SF document, however, does
not match because its region field is ["west_coast", "norcal"].
Limitations
Note the following limitations for in, not-in, and array-contains-any:
in,not-in, andarray-contains-anysupport up to 10 comparison values.- You can use at most one
array-containsclause per query. You can't combinearray-containswitharray-contains-any. - You can use at most one
in,not-in, orarray-contains-anyclause per query. You can't combine these operators in the same query. - You can't combine
not-inwith not equals!=. - You can't order your query by a field included in an equality (
==) orinclause.
Compound queries
You can chain multiple equality operators (== or array-contains) methods to
create more specific queries (logical AND). However, you must create a
composite index to combine equality operators with the inequality
operators, <, <=, >, and !=.
Web v8
const q1 = citiesRef.where("state", "==", "CO").where("name", "==", "Denver");
const q2 = citiesRef.where("state", "==", "CA").where("population", "<", 1000000);
Web v9
import { query, where } from "firebase/firestore";
const q1 = query(citiesRef, where("state", "==", "CO"), where("name", "==", "Denver"));
const q2 = query(citiesRef, where("state", "==", "CA"), where("population", "<", 1000000));
Swift
citiesRef
.whereField("state", isEqualTo: "CO")
.whereField("name", isEqualTo: "Denver")
citiesRef
.whereField("state", isEqualTo: "CA")
.whereField("population", isLessThan: 1000000)
Objective-C
[[citiesRef queryWhereField:@"state" isEqualTo:@"CO"]
queryWhereField:@"name" isGreaterThanOrEqualTo:@"Denver"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
queryWhereField:@"population" isLessThan:@1000000];
Java
citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000);
Kotlin+KTX
citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver")
citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000)
Java
Python
Python
C++
cities_ref.WhereEqualTo("state", FieldValue::String("CO"))
.WhereEqualTo("name", FieldValue::String("Denver"));
cities_ref.WhereEqualTo("state", FieldValue::String("CA"))
.WhereLessThan("population", FieldValue::Integer(1000000));
Node.js
Go
PHP
$chainedQuery = $citiesRef
->where('state', '=', 'CA')
->where('name', '=', 'San Francisco');
Unity
Query chainedQuery = citiesRef
.WhereEqualTo("State", "CA")
.WhereEqualTo("Name", "San Francisco");
C#
Query chainedQuery = citiesRef
.WhereEqualTo("State", "CA")
.WhereEqualTo("Name", "San Francisco");
Ruby
You can perform range (<, <=, >, >=) or not equals (!=)
comparisons only on a single field, and you can include at most one
array-contains or array-contains-any clause in a
compound query:
Valid: Range filters on only one field
Web v8
const q1 = citiesRef.where("state", ">=", "CA").where("state", "<=", "IN");
const q2 = citiesRef.where("state", "==", "CA").where("population", ">", 1000000);
Web v9
import { query, where } from "firebase/firestore";
const q1 = query(citiesRef, where("state", ">=", "CA"), where("state", "<=", "IN"));
const q2 = query(citiesRef, where("state", "==", "CA"), where("population", ">", 1000000));
Swift
citiesRef
.whereField("state", isGreaterThanOrEqualTo: "CA")
.whereField("state", isLessThanOrEqualTo: "IN")
citiesRef
.whereField("state", isEqualTo: "CA")
.whereField("population", isGreaterThan: 1000000)
Objective-C
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
queryWhereField:@"state" isLessThanOrEqualTo:@"IN"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
queryWhereField:@"population" isGreaterThan:@1000000];
Java
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
.whereLessThanOrEqualTo("state", "IN");
citiesRef.whereEqualTo("state", "CA")
.whereGreaterThan("population", 1000000);
Kotlin+KTX
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
.whereLessThanOrEqualTo("state", "IN")
citiesRef.whereEqualTo("state", "CA")
.whereGreaterThan("population", 1000000)
Java
Python
Python
C++
cities_ref.WhereGreaterThanOrEqualTo("state", FieldValue::String("CA"))
.WhereLessThanOrEqualTo("state", FieldValue::String("IN"));
cities_ref.WhereEqualTo("state", FieldValue::String("CA"))
.WhereGreaterThan("population", FieldValue::Integer(1000000));
Node.js
Go
PHP
$rangeQuery = $citiesRef
->where('state', '>=', 'CA')
->where('state', '<=', 'IN');
Unity
Query rangeQuery = citiesRef
.WhereGreaterThanOrEqualTo("State", "CA")
.WhereLessThanOrEqualTo("State", "IN");
C#
Query rangeQuery = citiesRef
.WhereGreaterThanOrEqualTo("State", "CA")
.WhereLessThanOrEqualTo("State", "IN");
Ruby
Invalid: Range filters on different fields
Web v8
citiesRef.where("state", ">=", "CA").where("population", ">", 100000);
Web v9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where("state", ">=", "CA"), where("population", ">", 100000));
Swift
citiesRef
.whereField("state", isGreaterThanOrEqualTo: "CA")
.whereField("population", isGreaterThan: 1000000)
Objective-C
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
queryWhereField:@"population" isGreaterThan:@1000000];
Java
citiesRef.whereGreaterThanOrEqualTo("state", "CA").whereGreaterThan("population", 100000);
Kotlin+KTX
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
.whereGreaterThan("population", 100000)
Java
Python
Python
C++
// BAD EXAMPLE -- will crash the program:
cities_ref.WhereGreaterThanOrEqualTo("state", FieldValue::String("CA"))
.WhereGreaterThan("population", FieldValue::Integer(100000));
Node.js
Go
PHP
$invalidRangeQuery = $citiesRef
->where('state', '>=', 'CA')
->where('population', '>', 1000000);
Unity
Query invalidRangeQuery = citiesRef
.WhereGreaterThanOrEqualTo("State", "CA")
.WhereGreaterThan("Population", 1000000);
C#
Query invalidRangeQuery = citiesRef
.WhereGreaterThanOrEqualTo("State", "CA")
.WhereGreaterThan("Population", 1000000);
Ruby
Collection group queries
A collection group consists of all collections with the same ID. By default, queries retrieve results from a single collection in your database. Use a collection group query to retrieve documents from a collection group instead of from a single collection.
For example, you can create a landmarks collection group by adding a landmarks
subcollection to each city:
Web
var citiesRef = db.collection('cities');
var landmarks = Promise.all([
citiesRef.doc('SF').collection('landmarks').doc().set({
name: 'Golden Gate Bridge',
type: 'bridge'
}),
citiesRef.doc('SF').collection('landmarks').doc().set({
name: 'Legion of Honor',
type: 'museum'
}),
citiesRef.doc('LA').collection('landmarks').doc().set({
name: 'Griffith Park',
type: 'park'
}),
citiesRef.doc('LA').collection('landmarks').doc().set({
name: 'The Getty',
type: 'museum'
}),
citiesRef.doc('DC').collection('landmarks').doc().set({
name: 'Lincoln Memorial',
type: 'memorial'
}),
citiesRef.doc('DC').collection('landmarks').doc().set({
name: 'National Air and Space Museum',
type: 'museum'
}),
citiesRef.doc('TOK').collection('landmarks').doc().set({
name: 'Ueno Park',
type: 'park'
}),
citiesRef.doc('TOK').collection('landmarks').doc().set({
name: 'National Museum of Nature and Science',
type: 'museum'
}),
citiesRef.doc('BJ').collection('landmarks').doc().set({
name: 'Jingshan Park',
type: 'park'
}),
citiesRef.doc('BJ').collection('landmarks').doc().set({
name: 'Beijing Ancient Observatory',
type: 'museum'
})
]);
Swift
let citiesRef = db.collection("cities")
var data = ["name": "Golden Gate Bridge", "type": "bridge"]
citiesRef.document("SF").collection("landmarks").addDocument(data: data)
data = ["name": "Legion of Honor", "type": "museum"]
citiesRef.document("SF").collection("landmarks").addDocument(data: data)
data = ["name": "Griffith Park", "type": "park"]
citiesRef.document("LA").collection("landmarks").addDocument(data: data)
data = ["name": "The Getty", "type": "museum"]
citiesRef.document("LA").collection("landmarks").addDocument(data: data)
data = ["name": "Lincoln Memorial", "type": "memorial"]
citiesRef.document("DC").collection("landmarks").addDocument(data: data)
data = ["name": "National Air and Space Museum", "type": "museum"]
citiesRef.document("DC").collection("landmarks").addDocument(data: data)
data = ["name": "Ueno Park", "type": "park"]
citiesRef.document("TOK").collection("landmarks").addDocument(data: data)
data = ["name": "National Museum of Nature and Science", "type": "museum"]
citiesRef.document("TOK").collection("landmarks").addDocument(data: data)
data = ["name": "Jingshan Park", "type": "park"]
citiesRef.document("BJ").collection("landmarks").addDocument(data: data)
data = ["name": "Beijing Ancient Observatory", "type": "museum"]
citiesRef.document("BJ").collection("landmarks").addDocument(data: data)
Objective-C
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];
NSDictionary *data = @{@"name": @"Golden Gate Bridge", @"type": @"bridge"};
[[[citiesRef documentWithPath:@"SF"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"Legion of Honor", @"type": @"museum"};
[[[citiesRef documentWithPath:@"SF"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"Griffith Park", @"type": @"park"};
[[[citiesRef documentWithPath:@"LA"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"The Getty", @"type": @"museum"};
[[[citiesRef documentWithPath:@"LA"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"Lincoln Memorial", @"type": @"memorial"};
[[[citiesRef documentWithPath:@"DC"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"National Air and Space Museum", @"type": @"museum"};
[[[citiesRef documentWithPath:@"DC"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"Ueno Park", @"type": @"park"};
[[[citiesRef documentWithPath:@"TOK"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"National Museum of Nature and Science", @"type": @"museum"};
[[[citiesRef documentWithPath:@"TOK"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"Jingshan Park", @"type": @"park"};
[[[citiesRef documentWithPath:@"BJ"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
data = @{@"name": @"Beijing Ancient Observatory", @"type": @"museum"};
[[[citiesRef documentWithPath:@"BJ"] collectionWithPath:@"landmarks"] addDocumentWithData:data];
Java
CollectionReference citiesRef = db.collection("cities");
Map<String, Object> ggbData = new HashMap<>();
ggbData.put("name", "Golden Gate Bridge");
ggbData.put("type", "bridge");
citiesRef.document("SF").collection("landmarks").add(ggbData);
Map<String, Object> lohData = new HashMap<>();
lohData.put("name", "Legion of Honor");
lohData.put("type", "museum");
citiesRef.document("SF").collection("landmarks").add(lohData);
Map<String, Object> gpData = new HashMap<>();
gpData.put("name", "Griffith Park");
gpData.put("type", "park");
citiesRef.document("LA").collection("landmarks").add(gpData);
Map<String, Object> tgData = new HashMap<>();
tgData.put("name", "The Getty");
tgData.put("type", "museum");
citiesRef.document("LA").collection("landmarks").add(tgData);
Map<String, Object> lmData = new HashMap<>();
lmData.put("name", "Lincoln Memorial");
lmData.put("type", "memorial");
citiesRef.document("DC").collection("landmarks").add(lmData);
Map<String, Object> nasaData = new HashMap<>();
nasaData.put("name", "National Air and Space Museum");
nasaData.put("type", "museum");
citiesRef.document("DC").collection("landmarks").add(nasaData);
Map<String, Object> upData = new HashMap<>();
upData.put("name", "Ueno Park");
upData.put("type", "park");
citiesRef.document("TOK").collection("landmarks").add(upData);
Map<String, Object> nmData = new HashMap<>();
nmData.put("name", "National Museum of Nature and Science");
nmData.put("type", "museum");
citiesRef.document("TOK").collection("landmarks").add(nmData);
Map<String, Object> jpData = new HashMap<>();
jpData.put("name", "Jingshan Park");
jpData.put("type", "park");
citiesRef.document("BJ").collection("landmarks").add(jpData);
Map<String, Object> baoData = new HashMap<>();
baoData.put("name", "Beijing Ancient Observatory");
baoData.put("type", "museum");
citiesRef.document("BJ").collection("landmarks").add(baoData);
Kotlin+KTX
val citiesRef = db.collection("cities")
val ggbData = mapOf(
"name" to "Golden Gate Bridge",
"type" to "bridge"
)
citiesRef.document("SF").collection("landmarks").add(ggbData)
val lohData = mapOf(
"name" to "Legion of Honor",
"type" to "museum"
)
citiesRef.document("SF").collection("landmarks").add(lohData)
val gpData = mapOf(
"name" to "Griffth Park",
"type" to "park"
)
citiesRef.document("LA").collection("landmarks").add(gpData)
val tgData = mapOf(
"name" to "The Getty",
"type" to "museum"
)
citiesRef.document("LA").collection("landmarks").add(tgData)
val lmData = mapOf(
"name" to "Lincoln Memorial",
"type" to "memorial"
)
citiesRef.document("DC").collection("landmarks").add(lmData)
val nasaData = mapOf(
"name" to "National Air and Space Museum",
"type" to "museum"
)
citiesRef.document("DC").collection("landmarks").add(nasaData)
val upData = mapOf(
"name" to "Ueno Park",
"type" to "park"
)
citiesRef.document("TOK").collection("landmarks").add(upData)
val nmData = mapOf(
"name" to "National Musuem of Nature and Science",
"type" to "museum"
)
citiesRef.document("TOK").collection("landmarks").add(nmData)
val jpData = mapOf(
"name" to "Jingshan Park",
"type" to "park"
)
citiesRef.document("BJ").collection("landmarks").add(jpData)
val baoData = mapOf(
"name" to "Beijing Ancient Observatory",
"type" to "musuem"
)
citiesRef.document("BJ").collection("landmarks").add(baoData)
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
// Snippet not yet available
Unity
// Not yet supported in the Unity SDK
C#
await citiesRef.Document("SF").Collection("landmarks").Document()
.CreateAsync(new { Name = "Golden Gate Bridge", Type = "bridge" });
await citiesRef.Document("SF").Collection("landmarks").Document()
.CreateAsync(new { Name = "Legion of Honor", Type = "museum" });
await citiesRef.Document("LA").Collection("landmarks").Document()
.CreateAsync(new { Name = "Griffith Park", Type = "park" });
await citiesRef.Document("DC").Collection("landmarks").Document()
.CreateAsync(new { Name = "Lincoln Memorial", Type = "memorial" });
await citiesRef.Document("DC").Collection("landmarks").Document()
.CreateAsync(new { Name = "National Air And Space Museum", Type = "museum" });
await citiesRef.Document("TOK").Collection("landmarks").Document()
.CreateAsync(new { Name = "Ueno Park", Type = "park" });
await citiesRef.Document("TOK").Collection("landmarks").Document()
.CreateAsync(new { Name = "National Museum of Nature and Science", Type = "museum" });
await citiesRef.Document("BJ").Collection("landmarks").Document()
.CreateAsync(new { Name = "Jingshan Park", Type = "park" });
await citiesRef.Document("BJ").Collection("landmarks").Document()
.CreateAsync(new { Name = "Beijing Ancient Observatory", Type = "museum" });
Ruby
We can use the simple and compound query described earlier to query a single
city's landmarks subcollection, but you might also want to retrieve
results from every city's landmarks subcollection at once.
The landmarks collection group consists of all collections with the ID
landmarks, and you can query it using a collection group query. For example,
this collection group query retrieves all museum landmarks across all cities:
Web
->var museums = db.collectionGroup('landmarks').where('type', '==', 'museum');
museums.get().then((querySnapshot) => {
querySnapshot.forEach((doc) => {
console.log(doc.id, ' => ', doc.data());
});
});
Swift
db.collectionGroup("landmarks").whereField("type", isEqualTo: "museum").getDocuments { (snapshot, error) in
// ...
}
Objective-C
[[[self.db collectionGroupWithID:@"landmarks"] queryWhereField:@"type" isEqualTo:@"museum"]
getDocumentsWithCompletion:^(FIRQuerySnapshot *snapshot, NSError *error) {
// ...
}];
Java
db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
.addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
@Override
public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
// ...
}
});
Kotlin+KTX
db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
.addOnSuccessListener { queryDocumentSnapshots ->
// ...
}
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
// Snippet not yet available
Unity
// Not yet supported in the Unity SDK
C#
Query museums = db.CollectionGroup("landmarks").WhereEqualTo("Type", "museum");
QuerySnapshot querySnapshot = await museums.GetSnapshotAsync();
foreach (DocumentSnapshot document in querySnapshot.Documents)
{
Console.WriteLine($"{document.Reference.Path}: {document.GetValue<string>("Name")}");
}
Ruby
Before using a collection group query, you must create an index that supports your collection group query. You can create an index through an error message, the console, or the Firebase CLI.
For the web and mobile SDKs, you must also create rules that allow your collection group queries.
Query limitations
The following list summarizes Cloud Firestore query limitations:
- Cloud Firestore provides limited support for logical
ORqueries. Thein, andarray-contains-anyoperators support a logicalORof up to 10 equality (==) orarray-containsconditions on a single field. For other cases, create a separate query for eachORcondition and merge the query results in your app. - In a compound query, range (
<,<=,>,>=) and not equals (!=,not-in) comparisons must all filter on the same field. - You can use at most one
array-containsclause per query. You can't combinearray-containswitharray-contains-any. - You can use at most one
in,not-in, orarray-contains-anyclause per query. You can't combinein,not-in, andarray-contains-anyin the same query. - You can't order your query by a field included in an equality (
==) orinclause. - The sum of filters, sort orders, and parent document path (1 for a subcollection, 0 for a root collection) in a query cannot exceed 100.