Query and filter data

import{collection,doc,setDoc}from"firebase/firestore";
constcitiesRef=collection(db,"cities");
awaitsetDoc(doc(citiesRef,"SF"),{
name:"San Francisco",state:"CA",country:"USA",
capital:false,population:860000,
regions:["west_coast","norcal"]});
awaitsetDoc(doc(citiesRef,"LA"),{
name:"Los Angeles",state:"CA",country:"USA",
capital:false,population:3900000,
regions:["west_coast","socal"]});
awaitsetDoc(doc(citiesRef,"DC"),{
name:"Washington, D.C.",state:null,country:"USA",
capital:true,population:680000,
regions:["east_coast"]});
awaitsetDoc(doc(citiesRef,"TOK"),{
name:"Tokyo",state:null,country:"Japan",
capital:true,population:9000000,
regions:["kanto","honshu"]});
awaitsetDoc(doc(citiesRef,"BJ"),{
name:"Beijing",state:null,country:"China",
capital:true,population:21500000,
regions:["jingjinji","hebei"]});
example_data.js 

varcitiesRef=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"]});
test.firestore.js 

letcitiesRef=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"]
])
ViewController.swift 

FIRCollectionReference*citiesRef=[self.dbcollectionWithPath:@"cities"];
[[citiesRefdocumentWithPath:@"SF"]setData:@{
@"name":@"San Francisco",
@"state":@"CA",
@"country":@"USA",
@"capital":@(NO),
@"population":@860000,
@"regions":@[@"west_coast",@"norcal"]
}];
[[citiesRefdocumentWithPath:@"LA"]setData:@{
@"name":@"Los Angeles",
@"state":@"CA",
@"country":@"USA",
@"capital":@(NO),
@"population":@3900000,
@"regions":@[@"west_coast",@"socal"]
}];
[[citiesRefdocumentWithPath:@"DC"]setData:@{
@"name":@"Washington D.C.",
@"country":@"USA",
@"capital":@(YES),
@"population":@680000,
@"regions":@[@"east_coast"]
}];
[[citiesRefdocumentWithPath:@"TOK"]setData:@{
@"name":@"Tokyo",
@"country":@"Japan",
@"capital":@(YES),
@"population":@9000000,
@"regions":@[@"kanto",@"honshu"]
}];
[[citiesRefdocumentWithPath:@"BJ"]setData:@{
@"name":@"Beijing",
@"country":@"China",
@"capital":@(YES),
@"population":@21500000,
@"regions":@[@"jingjinji",@"hebei"]
}];
ViewController.m 

valcities=db.collection("cities")
valdata1=hashMapOf(
"name"to"San Francisco",
"state"to"CA",
"country"to"USA",
"capital"tofalse,
"population"to860000,
"regions"tolistOf("west_coast","norcal"),
)
cities.document("SF").set(data1)
valdata2=hashMapOf(
"name"to"Los Angeles",
"state"to"CA",
"country"to"USA",
"capital"tofalse,
"population"to3900000,
"regions"tolistOf("west_coast","socal"),
)
cities.document("LA").set(data2)
valdata3=hashMapOf(
"name"to"Washington D.C.",
"state"tonull,
"country"to"USA",
"capital"totrue,
"population"to680000,
"regions"tolistOf("east_coast"),
)
cities.document("DC").set(data3)
valdata4=hashMapOf(
"name"to"Tokyo",
"state"tonull,
"country"to"Japan",
"capital"totrue,
"population"to9000000,
"regions"tolistOf("kanto","honshu"),
)
cities.document("TOK").set(data4)
valdata5=hashMapOf(
"name"to"Beijing",
"state"tonull,
"country"to"China",
"capital"totrue,
"population"to21500000,
"regions"tolistOf("jingjinji","hebei"),
)
cities.document("BJ").set(data5)
DocSnippets.kt 

CollectionReferencecities=db.collection("cities");
Map<String,Object>data1=newHashMap<>();
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=newHashMap<>();
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=newHashMap<>();
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=newHashMap<>();
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=newHashMap<>();
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);
DocSnippets.java 

finalcities=db.collection("cities");
finaldata1=<String,dynamic>{
"name":"San Francisco",
"state":"CA",
"country":"USA",
"capital":false,
"population":860000,
"regions":["west_coast","norcal"]
};
cities.doc("SF").set(data1);
finaldata2=<String,dynamic>{
"name":"Los Angeles",
"state":"CA",
"country":"USA",
"capital":false,
"population":3900000,
"regions":["west_coast","socal"],
};
cities.doc("LA").set(data2);
finaldata3=<String,dynamic>{
"name":"Washington D.C.",
"state":null,
"country":"USA",
"capital":true,
"population":680000,
"regions":["east_coast"]
};
cities.doc("DC").set(data3);
finaldata4=<String,dynamic>{
"name":"Tokyo",
"state":null,
"country":"Japan",
"capital":true,
"population":9000000,
"regions":["kanto","honshu"]
};
cities.doc("TOK").set(data4);
finaldata5=<String,dynamic>{
"name":"Beijing",
"state":null,
"country":"China",
"capital":true,
"population":21500000,
"regions":["jingjinji","hebei"],
};
cities.doc("BJ").set(data5);
firestore.dart 

classCity:
 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
 deffrom_dict(source):
 # ...
 defto_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")
cities_ref.document("BJ").set(
 City("Beijing", None, "China", True, 21500000, ["hebei"]).to_dict()
)
cities_ref.document("SF").set(
 City(
 "San Francisco", "CA", "USA", False, 860000, ["west_coast", "norcal"]
 ).to_dict()
)
cities_ref.document("LA").set(
 City(
 "Los Angeles", "CA", "USA", False, 3900000, ["west_coast", "socal"]
 ).to_dict()
)
cities_ref.document("DC").set(
 City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()
)
cities_ref.document("TOK").set(
 City("Tokyo", None, "Japan", True, 9000000, ["kanto", "honshu"]).to_dict()
)
snippets.py 

classCity:
 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
 deffrom_dict(source):
 # ...
 defto_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()
)
snippets.py 

CollectionReferencecities=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")})},
});
snippets.cpp 

CollectionReferencecitiesRef=db.Collection("cities");
citiesRef.Document("SF").SetAsync(newDictionary<string,object>(){
{"Name","San Francisco"},
{"State","CA"},
{"Country","USA"},
{"Capital",false},
{"Population",860000},
{"Regions",newArrayList{"west_coast","norcal"}}
});
citiesRef.Document("LA").SetAsync(newDictionary<string,object>(){
{"Name","Los Angeles"},
{"State","CA"},
{"Country","USA"},
{"Capital",false},
{"Population",3900000},
{"Regions",newArrayList{"west_coast","socal"}}
});
citiesRef.Document("DC").SetAsync(newDictionary<string,object>(){
{"Name","Washington D.C."},
{"State",null},
{"Country","USA"},
{"Capital",true},
{"Population",680000},
{"Regions",newArrayList{"east_coast"}}
});
citiesRef.Document("TOK").SetAsync(newDictionary<string,object>(){
{"Name","Tokyo"},
{"State",null},
{"Country","Japan"},
{"Capital",true},
{"Population",9000000},
{"Regions",newArrayList{"kanto","honshu"}}
});
citiesRef.Document("BJ").SetAsync(newDictionary<string,object>(){
{"Name","Beijing"},
{"State",null},
{"Country","China"},
{"Capital",true},
{"Population",21500000},
{"Regions",newArrayList{"jingjinji","hebei"}}
});

// Create a reference to the cities collection
import{collection,query,where}from"firebase/firestore";
constcitiesRef=collection(db,"cities");
// Create a query against the collection.
constq=query(citiesRef,where("state","==","CA"));
simple_queries.js 

// Create a reference to the cities collection
varcitiesRef=db.collection("cities");
// Create a query against the collection.
varquery=citiesRef.where("state","==","CA");
test.firestore.js 

// Create a reference to the cities collection
letcitiesRef=db.collection("cities")
// Create a query against the collection.
letquery=citiesRef.whereField("state",isEqualTo:"CA")
ViewController.swift 

// Create a reference to the cities collection
FIRCollectionReference*citiesRef=[self.dbcollectionWithPath:@"cities"];
// Create a query against the collection.
FIRQuery*query=[citiesRefqueryWhereField:@"state"isEqualTo:@"CA"];
ViewController.m 

// Create a reference to the cities collection
valcitiesRef=db.collection("cities")
// Create a query against the collection.
valquery=citiesRef.whereEqualTo("state","CA")
DocSnippets.kt 

// Create a reference to the cities collection
CollectionReferencecitiesRef=db.collection("cities");
// Create a query against the collection.
Queryquery=citiesRef.whereEqualTo("state","CA");
DocSnippets.java 

// Create a reference to the cities collection
finalcitiesRef=db.collection("cities");
// Create a query against the collection.
finalquery=citiesRef.where("state",isEqualTo:"CA");
firestore.dart 

CollectionReferencecities_ref=db->Collection("cities");
// Create a query against the collection.
Queryquery_ca=
cities_ref.WhereEqualTo("state",FieldValue::String("CA"));
snippets.cpp 

CollectionReferencecitiesRef=db.Collection("cities");
Queryquery=citiesRef.WhereEqualTo("State","CA");
query.GetSnapshotAsync().ContinueWithOnMainThread((querySnapshotTask)=>
{
foreach(DocumentSnapshotdocumentSnapshotinquerySnapshotTask.Result.Documents)
{
Debug.Log(String.Format("Document {0} returned by query State=CA",documentSnapshot.Id));
}
});

import{collection,query,where}from"firebase/firestore";
constcitiesRef=collection(db,"cities");
constq=query(citiesRef,where("capital","==",true));
simple_queries_again.js 

varcitiesRef=db.collection("cities");
varquery=citiesRef.where("capital","==",true);
test.firestore.js 

letcapitalCities=db.collection("cities").whereField("capital",isEqualTo:true)
ViewController.swift 

FIRQuery*capitalCities=
[[self.dbcollectionWithPath:@"cities"]queryWhereField:@"capital"isEqualTo:@YES];
ViewController.m 

valcapitalCities=db.collection("cities").whereEqualTo("capital",true)
DocSnippets.kt 

QuerycapitalCities=db.collection("cities").whereEqualTo("capital",true);
DocSnippets.java 

finalcapitalcities=
db.collection("cities").where("capital",isEqualTo:true);
firestore.dart 

Querycapital_cities=db->Collection("cities").WhereEqualTo(
"capital",FieldValue::Boolean(true));
snippets.cpp 

CollectionReferencecitiesRef=db.Collection("cities");
Queryquery=citiesRef.WhereEqualTo("Capital",true);
query.GetSnapshotAsync().ContinueWithOnMainThread((querySnapshotTask)=>
{
foreach(DocumentSnapshotdocumentSnapshotinquerySnapshotTask.Result.Documents)
{
Debug.Log(String.Format("Document {0} returned by query Capital=true",documentSnapshot.Id));
}
});

import{collection,query,where,getDocs}from"firebase/firestore";
constq=query(collection(db,"cities"),where("capital","==",true));
constquerySnapshot=awaitgetDocs(q);
querySnapshot.forEach((doc)=>{
// doc.data() is never undefined for query doc snapshots
console.log(doc.id," => ",doc.data());
});
get_multiple.js 

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);
});
test.firestore.js 

do{
letquerySnapshot=tryawaitdb.collection("cities").whereField("capital",isEqualTo:true)
.getDocuments()
fordocumentinquerySnapshot.documents{
print("\(document.documentID) => \(document.data())")
}
}catch{
print("Error getting documents: \(error)")
}
ViewController.swift 

[[[self.dbcollectionWithPath:@"cities"]queryWhereField:@"capital"isEqualTo:@(YES)]
getDocumentsWithCompletion:^(FIRQuerySnapshot*snapshot,NSError*error){
if(error!=nil){
NSLog(@"Error getting documents: %@",error);
}else{
for(FIRDocumentSnapshot*documentinsnapshot.documents){
NSLog(@"%@ => %@",document.documentID,document.data);
}
}
}];
ViewController.m 

db.collection("cities")
.whereEqualTo("capital",true)
.get()
.addOnSuccessListener{documents->
for(documentindocuments){
Log.d(TAG,"${document.id} => ${document.data}")
}
}
.addOnFailureListener{exception->
Log.w(TAG,"Error getting documents: ",exception)
}
DocSnippets.kt 

db.collection("cities")
.whereEqualTo("capital",true)
.get()
.addOnCompleteListener(newOnCompleteListener<QuerySnapshot>(){
@Override
publicvoidonComplete(@NonNullTask<QuerySnapshot>task){
if(task.isSuccessful()){
for(QueryDocumentSnapshotdocument:task.getResult()){
Log.d(TAG,document.getId()+" => "+document.getData());
}
}else{
Log.d(TAG,"Error getting documents: ",task.getException());
}
}
});
DocSnippets.java 

db.collection("cities").where("capital",isEqualTo:true).get().then(
(querySnapshot){
print("Successfully completed");
for(vardocSnapshotinquerySnapshot.docs){
print('${docSnapshot.id} => ${docSnapshot.data()}');
}
},
onError:(e)=>print("Error completing: $e"),
);
firestore.dart 

db->Collection("cities")
.WhereEqualTo("capital",FieldValue::Boolean(true))
.Get()
.OnCompletion([](constFuture<QuerySnapshot>&future){
if(future.error()==Error::kErrorOk){
for(constDocumentSnapshot&document:
future.result()->documents()){
std::cout << document << std::endl;
}
}else{
std::cout << "Error getting documents: " << future.error_message()
 << std::endl;
}
});
snippets.cpp 

QuerycapitalQuery=db.Collection("cities").WhereEqualTo("Capital",true);
capitalQuery.GetSnapshotAsync().ContinueWithOnMainThread(task=>{
QuerySnapshotcapitalQuerySnapshot=task.Result;
foreach(DocumentSnapshotdocumentSnapshotincapitalQuerySnapshot.Documents){
Debug.Log(String.Format("Document data for {0} document:",documentSnapshot.Id));
Dictionary<string,object>city=documentSnapshot.ToDictionary();
foreach(KeyValuePair<string,object>pairincity){
Debug.Log(String.Format("{0}: {1}",pair.Key,pair.Value));
}
// Newline to separate entries
Debug.Log("");
};
});

conststateQuery=query(citiesRef,where("state","==","CA"));
constpopulationQuery=query(citiesRef,where("population","<",100000));
constnameQuery=query(citiesRef,where("name",">=","San Francisco"));
example_filters.js 

conststateQuery=citiesRef.where("state","==","CA");
constpopulationQuery=citiesRef.where("population","<",100000);
constnameQuery=citiesRef.where("name",">=","San Francisco");
test.firestore.js 

letstateQuery=citiesRef.whereField("state",isEqualTo:"CA")
letpopulationQuery=citiesRef.whereField("population",isLessThan:100000)
letnameQuery=citiesRef.whereField("name",isGreaterThanOrEqualTo:"San Francisco")
ViewController.swift 

FIRQuery*stateQuery=[citiesRefqueryWhereField:@"state"isEqualTo:@"CA"];
FIRQuery*populationQuery=[citiesRefqueryWhereField:@"population"isLessThan:@100000];
FIRQuery*nameQuery=[citiesRefqueryWhereField:@"name"isGreaterThanOrEqualTo:@"San Francisco"];
ViewController.m 

valstateQuery=citiesRef.whereEqualTo("state","CA")
valpopulationQuery=citiesRef.whereLessThan("population",100000)
valnameQuery=citiesRef.whereGreaterThanOrEqualTo("name","San Francisco")
DocSnippets.kt 

QuerystateQuery=citiesRef.whereEqualTo("state","CA");
QuerypopulationQuery=citiesRef.whereLessThan("population",100000);
QuerynameQuery=citiesRef.whereGreaterThanOrEqualTo("name","San Francisco");
DocSnippets.java 

finalcitiesRef=db.collection("cities");
finalstateQuery=citiesRef.where("state",isEqualTo:"CA");
finalpopulationQuery=citiesRef.where("population",isLessThan:100000);
finalnameQuery=citiesRef.where("name",isEqualTo:"San Francisco");
firestore.dart 

cities_ref.WhereEqualTo("state",FieldValue::String("CA"));
cities_ref.WhereLessThan("population",FieldValue::Integer(100000));
cities_ref.WhereGreaterThanOrEqualTo("name",
FieldValue::String("San Francisco"));
snippets.cpp 

QuerystateQuery=citiesRef.WhereEqualTo("State","CA");
QuerypopulationQuery=citiesRef.WhereGreaterThan("Population",1000000);
QuerynameQuery=citiesRef.WhereGreaterThanOrEqualTo("Name","San Francisco");

constnotCapitalQuery=query(citiesRef,where("capital","!=",false));
simple_query_not_equal.js 

citiesRef.where("capital","!=",false);
test.firestore.js 

letnotEqualQuery=citiesRef.whereField("capital",isNotEqualTo:false)
ViewController.swift 

query=[citiesRefqueryWhereField:@"capital"isNotEqualTo:@NO];
ViewController.m 

valnotCapitalQuery=citiesRef.whereNotEqualTo("capital",false)
DocSnippets.kt 

QuerynotCapitalQuery=citiesRef.whereNotEqualTo("capital",false);
DocSnippets.java 

finalcitiesRef=db.collection("cities");
finalnotCapitals=citiesRef.where("capital",isNotEqualTo:true);
firestore.dart 

// Snippet not yet available

cities_ref.WhereNotEqualTo("capital",FieldValue::Boolean(false));

// Snippet not yet available

Queryquery=citiesRef.WhereNotEqualTo("capital",false);
Queryquery=citiesRef.WhereNotEqualTo("capital",false);

// Snippet not yet available

import{query,where}from"firebase/firestore";
constq=query(citiesRef,where("regions","array-contains","west_coast"));
array_contains_filter.js