Com o Cloud Firestore, você tem um recurso de consulta eficiente para especificar os
documentos que pretende recuperar de uma coleção ou grupo de coleções. Essas
consultas também podem ser usadas com get() ou addSnapshotListener(), conforme
descrito em Retornar dados e Receber atualizações em tempo real.
Dados de exemplo
Para começar, escreva alguns dados sobre cidades para demonstrarmos diversas formas de leitura:
Web version 9
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"] });
Web version 8
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"] });
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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)
Dart
final cities = db.collection("cities");
final data1 = <String, dynamic>{
"name": "San Francisco",
"state": "CA",
"country": "USA",
"capital": false,
"population": 860000,
"regions": ["west_coast", "norcal"]
};
cities.doc("SF").set(data1);
final data2 = <String, dynamic>{
"name": "Los Angeles",
"state": "CA",
"country": "USA",
"capital": false,
"population": 3900000,
"regions": ["west_coast", "socal"],
};
cities.doc("LA").set(data2);
final data3 = <String, dynamic>{
"name": "Washington D.C.",
"state": null,
"country": "USA",
"capital": true,
"population": 680000,
"regions": ["east_coast"]
};
cities.doc("DC").set(data3);
final data4 = <String, dynamic>{
"name": "Tokyo",
"state": null,
"country": "Japan",
"capital": true,
"population": 9000000,
"regions": ["kanto", "honshu"]
};
cities.doc("TOK").set(data4);
final data5 = <String, dynamic>{
"name": "Beijing",
"state": null,
"country": "China",
"capital": true,
"population": 21500000,
"regions": ["jingjinji", "hebei"],
};
cities.doc("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
Consultas simples
A seguinte consulta mostra todas as cidades do estado CA:
Web version 9
// 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"));
Web version 8
// Create a reference to the cities collection
var citiesRef = db.collection("cities");
// Create a query against the collection.
var query = citiesRef.where("state", "==", "CA");
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
// 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
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
// 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")
Dart
// Create a reference to the cities collection
final citiesRef = db.collection("cities");
// Create a query against the collection.
final query = citiesRef.where("state", isEqualTo: "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
A consulta a seguir retorna todas as capitais:
Web version 9
import { collection, query, where } from "firebase/firestore";
const citiesRef = collection(db, "cities");
const q = query(citiesRef, where("capital", "==", true));
Web version 8
var citiesRef = db.collection("cities");
var query = citiesRef.where("capital", "==", true);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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)
Dart
final capitalcities =
db.collection("cities").where("capital", isEqualTo: 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
Executar uma consulta
Depois de criar um objeto de consulta, use a função get() para conseguir os resultados:
Web version 9
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());
});
Web version 8
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);
});
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[[[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)
}
Dart
db.collection("cities").where("capital", isEqualTo: true).get().then(
(res) => print("Successfully completed"),
onError: (e) => print("Error completing: $e"),
);
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 << std::endl;
}
} else {
std::cout << "Error getting documents: " << future.error_message()
<< std::endl;
}
});
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
Consulte Retornar dados para conseguir mais informações sobre como recuperar os resultados da consulta. Também é possível adicionar um listener a uma consulta para receber os resultados atuais e detectar futuras atualizações.
Operadores de consulta
O método where() usa três parâmetros: um campo para filtrar, um operador de comparação e um valor. O Cloud Firestore oferece suporte aos seguintes operadores de comparação:
<menor que<=menor que ou igual a==igual a>maior que>=maior que ou igual a!=diferente dearray-containsarray-contains-anyinnot-in
Exemplo:
Web version 9
const stateQuery = query(citiesRef, where("state", "==", "CA"));
const populationQuery = query(citiesRef, where("population", "<", 100000));
const nameQuery = query(citiesRef, where("name", ">=", "San Francisco"));
Web version 8
const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")
let populationQuery = citiesRef.whereField("population", isLessThan: 100000)
let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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")
Dart
final citiesRef = db.collection("cities");
final stateQuery = citiesRef.where("state", isEqualTo: "CA");
final populationQuery = citiesRef.where("population", isLessThan: 100000);
final nameQuery = citiesRef.where("name", isEqualTo: "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
Diferente de (!=)
Use o operador "diferente de" (!=) para retornar os documentos em que o campo especificado
existe e não corresponde ao valor da comparação. Exemplo:
Web version 9
const notCapitalQuery = query(citiesRef, where("capital", "!=", false));
Web version 8
citiesRef.where("capital", "!=", false);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
query = [citiesRef queryWhereField:@"capital" isNotEqualTo:@NO];
Java
Query notCapitalQuery = citiesRef.whereNotEqualTo("capital", false);
Kotlin+KTX
val notCapitalQuery = citiesRef.whereNotEqualTo("capital", false)
Dart
final citiesRef = db.collection("cities");
final notCapitals = citiesRef.where("capital", isNotEqualTo: true);
Java
Python
// Snippet not yet available
C++
// Snippet not yet available
Node.js
Go
// Snippet not yet available
PHP
Unity
// Snippet not yet available
C#
// Snippet not yet available
Ruby
Essa consulta retorna todos os documentos city em que o campo capital existe com um
valor diferente de false ou null. Isso inclui os documentos city em que o
valor do campo capital é igual a true ou a qualquer valor não booleano além de null.
Essa consulta não retorna os documentos city em que o campo capital não
existe. As consultas "diferente de" (!=) e not-in não selecionam os documentos em que o campo especificado não existe.
Haverá um campo quando ele estiver definido como qualquer valor, incluindo uma string vazia (""),
null e NaN (não numérico). Observe que os valores de campos com null não
correspondem a cláusulas !=, porque x != null é considerado como undefined.
Limitações
Observe as seguintes limitações para as consultas !=:
- Apenas os documentos nos quais o campo determinado existe podem corresponder à consulta.
- Não é possível combinar
not-ine!=em uma consulta composta. - Em uma consulta composta, as comparações de intervalos (
<,<=,>e>=) e de valores diferentes (!=enot-in) precisam filtrar no mesmo campo.
Associação de matriz
Use o operador array-contains para filtrar com base nos valores
da matriz. Exemplo:
Web version 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where("regions", "array-contains", "west_coast"));
Web version 8
citiesRef.where("regions", "array-contains", "west_coast");
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
citiesRef
.whereField("regions", arrayContains: "west_coast")
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[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")
Dart
final citiesRef = db.collection("cities");
final westCoastcities =
citiesRef.where("regions", arrayContains: "west_coast");
Java
Python
Python
C++
CollectionReference cities_ref = db->Collection("cities");
cities_ref.WhereArrayContains("region", FieldValue::String("west_coast"));
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
Essa consulta retorna todos os documentos city em que o campo regions é uma matriz
contendo west_coast. Se a matriz tiver várias instâncias do valor
consultado, o documento será incluído nos resultados apenas uma vez.
É possível usar no máximo uma cláusula array-contains por consulta. Não é possível combinar
array-contains com array-contains-any.
in, not-in e array-contains-any
Use o operador in para combinar até 10 cláusulas de igualdade (==) no
mesmo campo utilizando um OR lógico. Uma consulta in retorna documentos em que o campo especificado corresponde a qualquer um dos valores de comparação. Exemplo:
Web version 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where('country', 'in', ['USA', 'Japan']));
Web version 8
citiesRef.where('country', 'in', ['USA', 'Japan']);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
let citiesRef = db.collection("cities")
citiesRef.whereField("country", in: ["USA", "Japan"])
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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"))
Dart
final citiesRef = db.collection("cities");
final cities = citiesRef.where("country", whereIn: ["USA", "Japan"]);
Java
Python
Python
C++
CollectionReference cities_ref = db->Collection("cities");
cities_ref.WhereIn("country", std::vector<FieldValue> {
FieldValue::String("USA"),
FieldValue::String("Japan")
});
Node.js
Go
PHP
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
Essa consulta retorna todos os documentos city em que o campo country está definido
como USA ou Japan. Considerando os dados de exemplo, isso inclui
os documentos SF, LA, DC e TOK.
not-in
Use o operador not-in para combinar até 10 cláusulas "diferente de" (!=) no
mesmo campo utilizando um AND lógico. Uma consulta not-in retorna documentos em que o campo especificado existe, não é null e não corresponde a nenhum dos valores de comparação. Exemplo:
Web version 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where('country', 'not-in', ['USA', 'Japan']));
Web version 8
citiesRef.where('country', 'not-in', ['USA', 'Japan']);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
citiesRef.whereField("country", notIn: ["USA", "Japan"])
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[citiesRef queryWhereField:@"country" notIn:@[@"USA", @"Japan"]];
Java
citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));
Kotlin+KTX
citiesRef.whereNotIn("country", listOf("USA", "Japan"))
Dart
final citiesRef = db.collection("cities");
final cities = citiesRef.where("country", whereNotIn: ["USA", "Japan"]);
Java
Python
// Snippet not yet available
C++
cities_ref.WhereNotIn("country", std::vector<FieldValue> {
FieldValue::String("USA"),
FieldValue::String("Japan")
});
Node.js
Go
// Snippet not yet available
PHP
Unity
// Snippet not yet available
C#
// Snippet not yet available
Ruby
Essa consulta retorna todos os documentos city em que o campo country existe e
não está definido como USA, Japan ou null. Considerando os dados de exemplo, isso inclui os
documentos London e Hong Kong.
As consultas not-in não selecionam os documentos em que
o campo especificado não existe. Haverá um campo quando ele estiver definido como qualquer valor,
incluindo uma string vazia (""), null e NaN (não numérico). Observe
que x != null é considerado como undefined. Uma consulta not-in com
null como um dos valores de comparação não corresponderá a nenhum documento.
array-contains-any
Use o operador array-contains-any para combinar até 10
cláusulas array-contains no mesmo campo utilizando um OR lógico. Uma
consulta array-contains-any retorna documentos em que o campo especificado é uma matriz
que contém um ou mais valores de comparação:
Web version 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef,
where('regions', 'array-contains-any', ['west_coast', 'east_coast']));
Web version 8
citiesRef.where('regions', 'array-contains-any',
['west_coast', 'east_coast']);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
let citiesRef = db.collection("cities")
citiesRef.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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"))
Dart
final citiesRef = db.collection("cities");
final cities = citiesRef
.where("regions", arrayContainsAny: ["west_coast", "east_coast"]);
Java
Python
Python
C++
CollectionReference cities_ref = db->Collection("cities");
cities_ref.WhereArrayContainsAny("region", std::vector<FieldValue> {
FieldValue::String("west_coast"),
FieldValue::String("east_coast")
});
Node.js
Go
PHP
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
Essa consulta retorna todos os documentos de cidades em que o campo regions é uma matriz
que contém west_coast ou east_coast. Considerando os dados de exemplo, isso inclui
os documentos SF, LA e DC.
Os resultados de array-contains-any são eliminados. Mesmo que o campo da matriz de um documento
corresponda a mais de um dos valores de comparação, o conjunto de resultados incluirá
esse documento apenas uma vez.
array-contains-any sempre filtra pelo tipo de dado da matriz. Por exemplo, a
consulta acima não retornaria um documento de cidade em que, em vez de uma matriz, o
campo regions fosse a string west_coast.
É possível usar um valor de matriz como um valor de comparação para in, mas, diferentemente de
array-contains-any, a cláusula corresponderá a uma correspondência exata de comprimento, ordem e valores de matriz. Exemplo:
Web version 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where('regions', 'in', [['west_coast', 'east_coast']]));
Web version 8
citiesRef.where('regions', 'in',
[['west_coast', 'east_coast']]);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
citiesRef.whereField("regions", in: [["west_coast"], ["east_coast"]]);
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[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")))
Dart
final citiesRef = db.collection("cities");
final cities = citiesRef.where("regions", whereIn: [
["west_coast"],
["east_coast"]
]);
Java
Python
Python
C++
cities_ref.WhereIn("region", std::vector<FieldValue> {
FieldValue::String("west_coast"),
FieldValue::String("east_coast")
});
Node.js
Go
PHP
Unity
// Not yet supported in the Unity SDK
C#
Query query = citiesRef.WhereIn("Regions",
new[] { new[] { "west_coast" }, new[] { "east_coast" } });
Ruby
Essa consulta retorna todos os documentos de cidades em que o campo regions é uma matriz que contém exatamente um elemento de west_coast ou east_coast.
Considerando os dados de exemplo, apenas o documento DC se qualifica com seu campo regions de ["east_coast"]. No entanto, o documento SF não corresponde, porque seu campo regions é ["west_coast", "norcal"].
Limitações
Veja abaixo as limitações de in, not-in e array-contains-any:
in,not-inearray-contains-anyaceitam até 10 valores de comparação.- É possível usar no máximo uma cláusula
array-containspor consulta. Não é possível combinararray-containscomarray-contains-any. - É possível usar no máximo uma cláusula
in,not-inouarray-contains-anypor consulta. Não é possível combinar esses operadores na mesma consulta. - Não é possível combinar
not-incom!=. - Não é possível ordenar sua consulta por um campo incluído em uma cláusula
inou de igualdade (==).
Consultas compostas
É possível encadear diversos métodos de operadores de igualdade (== ou array-contains) para
criar consultas mais específicas (AND lógico). No entanto, é necessário criar um
índice composto para combinar os operadores de igualdade com os operadores
de desigualdade <, <=, > e !=.
Web version 9
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));
Web version 8
const q1 = citiesRef.where("state", "==", "CO").where("name", "==", "Denver");
const q2 = citiesRef.where("state", "==", "CA").where("population", "<", 1000000);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
citiesRef
.whereField("state", isEqualTo: "CO")
.whereField("name", isEqualTo: "Denver")
citiesRef
.whereField("state", isEqualTo: "CA")
.whereField("population", isLessThan: 1000000)
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[[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)
Dart
final citiesRef = db.collection("cities");
citiesRef
.where("state", isEqualTo: "CO")
.where("name", isEqualTo: "Denver");
citiesRef
.where("state", isEqualTo: "CA")
.where("population", isLessThan: 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
É possível fazer comparações de intervalos (<, <=, >, >=) ou de valores diferentes (!=)
apenas em um único campo e incluir no máximo uma
cláusula array-contains ou array-contains-any em uma
consulta composta:
Válido: filtros de intervalo em apenas um campo
Web version 9
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));
Web version 8
const q1 = citiesRef.where("state", ">=", "CA").where("state", "<=", "IN");
const q2 = citiesRef.where("state", "==", "CA").where("population", ">", 1000000);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
citiesRef
.whereField("state", isGreaterThanOrEqualTo: "CA")
.whereField("state", isLessThanOrEqualTo: "IN")
citiesRef
.whereField("state", isEqualTo: "CA")
.whereField("population", isGreaterThan: 1000000)
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[[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)
Dart
final citiesRef = db.collection("cities");
citiesRef
.where("state", isGreaterThanOrEqualTo: "CA")
.where("state", isLessThanOrEqualTo: "IN");
citiesRef
.where("state", isEqualTo: "CA")
.where("population", isGreaterThan: 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
Inválido: filtros de intervalo em campos diferentes
Web version 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where("state", ">=", "CA"), where("population", ">", 100000));
Web version 8
citiesRef.where("state", ">=", "CA").where("population", ">", 100000);
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
citiesRef
.whereField("state", isGreaterThanOrEqualTo: "CA")
.whereField("population", isGreaterThan: 1000000)
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[[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)
Dart
final citiesRef = db.collection("cities");
citiesRef
.where("state", isGreaterThanOrEqualTo: "CA")
.where("population", isGreaterThan: 1000000);
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
Consultas do grupo de coleções
Um grupo de coleções é composto de todas as coleções com o mesmo ID. Por padrão, por meio das consultas são recuperados resultados de uma única coleção no seu banco de dados. Use uma consulta de grupo de coleções para recuperar documentos de um grupo em vez de uma única coleção.
Por exemplo, é possível criar um grupo de coleções de landmarks com a adição de uma subcoleção
de pontos de referência a cada cidade:
Web version 9
import { collection, doc, setDoc } from "firebase/firestore";
const citiesRef = collection(db, 'cities');
await Promise.all([
setDoc(doc(citiesRef, 'SF', 'landmarks'), {
name: 'Golden Gate Bridge',
type: 'bridge'
}),
setDoc(doc(citiesRef, 'SF', 'landmarks'), {
name: 'Legion of Honor',
type: 'museum'
}),
setDoc(doc(citiesRef, 'LA', 'landmarks'), {
name: 'Griffith Park',
type: 'park'
}),
setDoc(doc(citiesRef, 'LA', 'landmarks'), {
name: 'The Getty',
type: 'museum'
}),
setDoc(doc(citiesRef, 'DC', 'landmarks'), {
name: 'Lincoln Memorial',
type: 'memorial'
}),
setDoc(doc(citiesRef, 'DC', 'landmarks'), {
name: 'National Air and Space Museum',
type: 'museum'
}),
setDoc(doc(citiesRef, 'TOK', 'landmarks'), {
name: 'Ueno Park',
type: 'park'
}),
setDoc(doc(citiesRef, 'TOK', 'landmarks'), {
name: 'National Museum of Nature and Science',
type: 'museum'
}),
setDoc(doc(citiesRef, 'BJ', 'landmarks'), {
name: 'Jingshan Park',
type: 'park'
}),
setDoc(doc(citiesRef, 'BJ', 'landmarks'), {
name: 'Beijing Ancient Observatory',
type: 'museum'
})
]);
Web version 8
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
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
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)
Dart
final citiesRef = db.collection("cities");
final ggbData = {"name": "Golden Gate Bridge", "type": "bridge"};
citiesRef.doc("SF").collection("landmarks").add(ggbData);
final lohData = {"name": "Legion of Honor", "type": "museum"};
citiesRef.doc("SF").collection("landmarks").add(lohData);
final gpData = {"name": "Griffth Park", "type": "park"};
citiesRef.doc("LA").collection("landmarks").add(gpData);
final tgData = {"name": "The Getty", "type": "museum"};
citiesRef.doc("LA").collection("landmarks").add(tgData);
final lmData = {"name": "Lincoln Memorial", "type": "memorial"};
citiesRef.doc("DC").collection("landmarks").add(lmData);
final nasaData = {
"name": "National Air and Space Museum",
"type": "museum"
};
citiesRef.doc("DC").collection("landmarks").add(nasaData);
final upData = {"name": "Ueno Park", "type": "park"};
citiesRef.doc("TOK").collection("landmarks").add(upData);
final nmData = {
"name": "National Musuem of Nature and Science",
"type": "museum"
};
citiesRef.doc("TOK").collection("landmarks").add(nmData);
final jpData = {"name": "Jingshan Park", "type": "park"};
citiesRef.doc("BJ").collection("landmarks").add(jpData);
final baoData = {"name": "Beijing Ancient Observatory", "type": "musuem"};
citiesRef.doc("BJ").collection("landmarks").add(baoData);
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
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
Podemos usar a consulta simples e a composta descritas anteriormente para consultar a subcoleção landmarks de uma cidade, mas também é possível recuperar os resultados da subcoleção landmarks de cada cidade ao mesmo tempo.
No grupo de coleções landmarks estão todos os conjuntos com o ID landmarks. Para consultá-lo, basta fazer uma consulta de grupo de coleções. Por exemplo,
com esta consulta de grupo de coleções são recuperados todos os pontos de referência museum em todas as cidades:
Web version 9
import { collectionGroup, query, where, getDocs } from "firebase/firestore";
const museums = query(collectionGroup(db, 'landmarks'), where('type', '==', 'museum'));
const querySnapshot = await getDocs(museums);
querySnapshot.forEach((doc) => {
console.log(doc.id, ' => ', doc.data());
});
Web version 8
var museums = db.collectionGroup('landmarks').where('type', '==', 'museum');
museums.get().then((querySnapshot) => {
querySnapshot.forEach((doc) => {
console.log(doc.id, ' => ', doc.data());
});
});
Swift
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
db.collectionGroup("landmarks").whereField("type", isEqualTo: "museum").getDocuments { (snapshot, error) in
// ...
}
Objective-C
Observação: este produto não está disponível para watchOS e destinos de clipes de apps.
[[[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 ->
// ...
}
Dart
db
.collectionGroup("landmarks")
.where("type", isEqualTo: "museum")
.get()
.then(
(res) => print("Successfully completed"),
onError: (e) => print("Error completing: $e"),
);
Java
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
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
Antes de usar uma consulta de grupo de coleções, é preciso criar um índice compatível com ela. Faça isso por meio de uma mensagem de erro, do console ou da CLI do Firebase.
No caso de SDKs da Web e para dispositivos móveis, você também precisa criar regras que permitam consultas de grupos de coleções.
Limitações de consulta
Na lista a seguir, resumimos as limitações de consultas do Cloud Firestore:
- O Cloud Firestore oferece compatibilidade limitada para consultas com um
ORlógico. Os operadoresinearray-contains-anysão compatíveis com umORlógico de até 10 condições de igualdade (==) ou dearray-containsem um único campo. Para outros casos, crie uma consulta separada para cada condiçãoORe combine os resultados da consulta no seu aplicativo. - Em uma consulta composta, as comparações de intervalos (
<,<=,>e>=) e de valores diferentes (!=enot-in) precisam filtrar no mesmo campo. - É possível usar no máximo uma cláusula
array-containspor consulta. Não é possível combinararray-containscomarray-contains-any. - É possível usar no máximo uma cláusula
in,not-inouarray-contains-anypor consulta. Você não pode combinarin,not-inearray-contains-anyna mesma consulta. - Não é possível ordenar sua consulta por um campo incluído em uma cláusula
inou de igualdade (==). - A soma de filtros, ordens de classificação e caminho do documento pai (1 para uma subcoleção, 0 para uma coleção raiz) em uma consulta não pode exceder 100.