Firestore bietet leistungsstarke Abfragefunktionen, mit denen sich Dokumente aus einer Sammlung oder Sammlungsgruppe abrufen lassen. Diese Abfragen können Sie auch mit den Methoden get() und addSnapshotListener() verwenden, wie unter Daten abrufen und Echtzeitdaten abrufen erläutert.
Beispieldaten
Schreiben zuerst einige Daten über Städte, damit wir verschiedene Arten betrachten können, wie sie gelesen werden können:
Webversion 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"] });
Webversion 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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
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
Android
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
Android
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
(Async)
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
Einfache Abfragen
Die folgende Abfrage gibt alle Städte mit dem Bundesstaat CA zurück:
Webversion 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"));
Webversion 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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
// 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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
// 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
Android
// 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
Android
// 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
(Async)
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
Die folgende Abfrage gibt alle Hauptstädte zurück:
Webversion 9
import { collection, query, where } from "firebase/firestore";
const citiesRef = collection(db, "cities");
const q = query(citiesRef, where("capital", "==", true));
Webversion 8
var citiesRef = db.collection("cities");
var query = citiesRef.where("capital", "==", true);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
FIRQuery *capitalCities =
[[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@YES];
Java
Android
Query capitalCities = db.collection("cities").whereEqualTo("capital", true);
Kotlin+KTX
Android
val capitalCities = db.collection("cities").whereEqualTo("capital", true)
Java
Python
Python
(Async)
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
Abfrage ausführen
Nach dem Erstellen eines Abfrageobjekts rufen Sie die Ergebnisse mithilfe der Funktion get() ab:
Webversion 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());
});
Webversion 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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[[[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
Android
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
Android
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
(Async)
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
Weitere Informationen zum Abrufen von Abfrageergebnissen finden Sie unter Daten abrufen. Sie können einer Abfrage auch einen Listener hinzufügen, um die aktuellen Ergebnisse abzurufen und auf zukünftige Aktualisierungen zu überwachen.
Abfrageoperatoren
Die Methode where() benötigt drei Parameter: ein Feld zum Filtern, einen Vergleichs-Operator und einen Wert. Firestore unterstützt die folgenden Vergleichsoperatoren:
<kleiner als<=kleiner als oder gleich==gleich>größer als>=größer als oder gleich!=nicht gleicharray-containsarray-contains-anyinnot-in
Beispiel:
Webversion 9
const stateQuery = query(citiesRef, where("state", "==", "CA"));
const populationQuery = query(citiesRef, where("population", "<", 100000));
const nameQuery = query(citiesRef, where("name", ">=", "San Francisco"));
Webversion 8
const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")
let populationQuery = citiesRef.whereField("population", isLessThan: 100000)
let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
FIRQuery *stateQuery = [citiesRef queryWhereField:@"state" isEqualTo:@"CA"]; FIRQuery *populationQuery = [citiesRef queryWhereField:@"population" isLessThan:@100000]; FIRQuery *nameQuery = [citiesRef queryWhereField:@"name" isGreaterThanOrEqualTo:@"San Francisco"];
Java
Android
Query stateQuery = citiesRef.whereEqualTo("state", "CA");
Query populationQuery = citiesRef.whereLessThan("population", 100000);
Query nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco");
Kotlin+KTX
Android
val stateQuery = citiesRef.whereEqualTo("state", "CA")
val populationQuery = citiesRef.whereLessThan("population", 100000)
val nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco")
Java
Python
Python
(Async)
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
Ungleich (!=)
Mit dem Operator „ungleich“ (!=) werden Dokumente zurückgegeben, in denen das angegebene Feld vorhanden ist und es nicht mit dem Vergleichswert übereinstimmt. Beispiel:
Webversion 9
const notCapitalQuery = query(citiesRef, where("capital", "!=", false));
Webversion 8
citiesRef.where("capital", "!=", false);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
query = [citiesRef queryWhereField:@"capital" isNotEqualTo:@NO];
Java
Android
Query notCapitalQuery = citiesRef.whereNotEqualTo("capital", false);
Kotlin+KTX
Android
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
Unity
// Snippet not yet available
C#
// Snippet not yet available
Ruby
Diese Abfrage gibt alle city-Dokumente zurück, in denen das Feld capital mit einem anderen Wert als false oder null vorhanden ist. Dazu gehören city-Dokumente, deren capital-Feldwert gleich true oder einem beliebigen nicht-boolesche Wert außer null ist.
Diese Abfrage gibt keine city-Dokumente zurück, in denen das Feld capital nicht vorhanden ist. Ungleiche (!=)- und not-in-Abfragen schließen Dokumente aus, bei denen das angegebene Feld nicht vorhanden ist.
Ein Feld ist vorhanden, wenn es auf einen beliebigen Wert gesetzt ist, einschließlich einer leeren Zeichenfolge (""), null und NaN (keine Zahl). Die null-Feldwerte stimmen nicht mit den !=-Klauseln überein, da x != null als undefined ausgewertet wird.
Beschränkungen
Beachten Sie folgende Einschränkungen für !=-Abfragen:
- Nur Dokumente, in denen das angegebene Feld vorhanden ist, können mit der Abfrage übereinstimmen.
not-inund!=können nicht in zusammengesetzten Abfragen kombiniert werden.- In zusammengesetzten Abfragen müssen alle Bereichs- (
<,<=,>,>=) und Ungleich-Vergleiche (!=,not-in) in demselben Feld filtern.
Arraymitgliedschaft
Mit dem Operator array-contains können Sie auf Basis von Arraywerten filtern. Beispiel:
Webversion 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where("regions", "array-contains", "west_coast"));
Webversion 8
citiesRef.where("regions", "array-contains", "west_coast");
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
citiesRef
.whereField("regions", arrayContains: "west_coast")
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[citiesRef queryWhereField:@"state" arrayContains:@"west_coast"];
Java
Android
CollectionReference citiesRef = db.collection("cities");
citiesRef.whereArrayContains("regions", "west_coast");
Kotlin+KTX
Android
val citiesRef = db.collection("cities")
citiesRef.whereArrayContains("regions", "west_coast")
Java
Python
Python
(Async)
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
Diese Abfrage gibt jedes city-Dokument zurück, in dem das Feld regions ein Array ist, das west_coast enthält. Wenn das Array mehrere Instanzen des abgefragten Werts enthält, wird das Dokument nur einmal in die Ergebnisse aufgenommen.
Sie können maximal eine array-contains-Klausel pro Abfrage verwenden. Sie können array-contains nicht mit array-contains-any kombinieren.
in, not-in und array-contains-any
Mit dem Operator in können Sie bis zu 10 Gleichheitsklauseln (==) für dasselbe Feld mit einem logischen OR kombinieren. Eine in-Abfrage gibt Dokumente zurück, bei denen das angegebene Feld mit einem der Vergleichswerte übereinstimmt. Beispiel:
Webversion 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where('country', 'in', ['USA', 'Japan']));
Webversion 8
citiesRef.where('country', 'in', ['USA', 'Japan']);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
let citiesRef = db.collection("cities")
citiesRef.whereField("country", in: ["USA", "Japan"])
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"]; [citiesRef queryWhereField:@"country" in:@[@"USA", @"Japan"]];
Java
Android
CollectionReference citiesRef = db.collection("cities");
citiesRef.whereIn("country", Arrays.asList("USA", "Japan"));
Kotlin+KTX
Android
val citiesRef = db.collection("cities")
citiesRef.whereIn("country", listOf("USA", "Japan"))
Java
Python
Python
(Async)
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
Diese Abfrage gibt alle city-Dokumente zurück, bei denen das Feld country auf USA oder Japan gesetzt ist. Aus den Beispieldaten gehören die Dokumente SF, LA, DC und TOK dazu.
not-in
Mit dem Operator not-in können Sie bis zu 10 Nicht-Gleichheitsklauseln (!=) für dasselbe Feld mit einem logischen AND kombinieren. Eine not-in-Abfrage gibt Dokumente zurück, in denen das angegebene Feld vorhanden ist, nicht null ist und keinem der Vergleichswerte entspricht. Beispiel:
Webversion 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where('country', 'not-in', ['USA', 'Japan']));
Webversion 8
citiesRef.where('country', 'not-in', ['USA', 'Japan']);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
citiesRef.whereField("country", notIn: ["USA", "Japan"])
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[citiesRef queryWhereField:@"country" notIn:@[@"USA", @"Japan"]];
Java
Android
citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));
Kotlin+KTX
Android
citiesRef.whereNotIn("country", listOf("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
Diese Abfrage gibt alle city-Dokumente zurück, in denen das Feld country vorhanden und nicht auf USA, Japan oder null festgelegt ist. Aus den Beispieldaten gehören die Dokumente London, Hong Kong und dazu.
not-in-Abfragen schließen Dokumente aus, in denen das angegebene Feld nicht vorhanden ist. Ein Feld ist vorhanden, wenn es auf einen beliebigen Wert gesetzt ist, einschließlich einer leeren Zeichenfolge (""), null und NaN (keine Zahl). x != null ergibt undefined. Eine not-in-Abfrage mit null als einer der Vergleichswerte stimmt mit keinem Dokument überein.
array-contains-any
Mit dem Operator array-contains-any können Sie bis zu 10 array-contains-Klauseln für dasselbe Feld mit einem logischen OR kombinieren. Eine Abfrage wie array-contains-any gibt Dokumente zurück, bei denen das angegebene Feld ein Array ist, das mindestens einen der Vergleichswerte enthält:
Webversion 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef,
where('regions', 'array-contains-any', ['west_coast', 'east_coast']));
Webversion 8
citiesRef.where('regions', 'array-contains-any',
['west_coast', 'east_coast']);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
let citiesRef = db.collection("cities")
citiesRef.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"]; [citiesRef queryWhereField:@"regions" arrayContainsAny:@[@"west_coast", @"east_coast"]];
Java
Android
CollectionReference citiesRef = db.collection("cities");
citiesRef.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));
Kotlin+KTX
Android
val citiesRef = db.collection("cities")
citiesRef.whereArrayContainsAny("regions", listOf("west_coast", "east_coast"))
Java
Python
Python
(Async)
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
Diese Abfrage gibt jedes "city"-Dokument zurück, in dem das Feld region ein Array mit west_coast oder east_coast ist. Aus den Beispieldaten gehören die Dokumente SF, LA und DC dazu.
Ergebnisse aus array-contains-any werden entfernt. Auch wenn das Arrayfeld eines Dokuments mit mehreren der Vergleichswerte übereinstimmt, enthält die Ergebnismenge dieses Dokument nur einmal.
array-contains-any filtert immer nach dem Arraydatentyp. Die obige Abfrage würde beispielsweise kein "city"-Dokument zurückgeben, in dem anstelle eines Arrays das Feld region der String west_coast ist.
Sie können einen Arraywert als Vergleichswert für in verwenden. Im Gegensatz zu array-contains-any stimmt die Klausel aber mit einer genauen Übereinstimmung von Arraylänge, -reihenfolge und -werten überein. Beispiel:
Webversion 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where('regions', 'in', [['west_coast', 'east_coast']]));
Webversion 8
citiesRef.where('regions', 'in',
[['west_coast', 'east_coast']]);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
citiesRef.whereField("regions", in: [["west_coast"], ["east_coast"]]);
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[citiesRef queryWhereField:@"regions" in:@[@[@"west_coast"], @[@"east_coast"]]];
Java
Android
citiesRef.whereIn("regions", Arrays.asList(new String[]{"west_coast"}, new String[]{"east_coast"}));
Kotlin+KTX
Android
citiesRef.whereIn("regions", listOf(arrayOf("west_coast"), arrayOf("east_coast")))
Java
Python
Python
(Async)
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
Diese Abfrage gibt jedes "city"-Dokument zurück, in dem das Feld region ein Array ist, das genau ein Element von entweder west_coast oder east_coast enthält.
Aus den Beispieldaten entspricht nur das Dokument DC mit dem Feld region von ["east_coast"] diesen Angaben. Das SF-Dokument stimmt jedoch nicht überein, da das Feld region den Wert ["west_coast", "norcal"] enthält.
Beschränkungen
Beachten Sie die folgenden Einschränkungen für in, not-in und array-contains-any:
in,not-inundarray-contains-anyunterstützen bis zu zehn Vergleichswerte.- Sie können maximal eine
array-contains-Klausel pro Abfrage verwenden. Sie könnenarray-containsnicht mitarray-contains-anykombinieren. - Sie können maximal eine
in-,not-in- oderarray-contains-any-Klausel pro Abfrage verwenden. Diese Operatoren können nicht in derselben Abfrage kombiniert werden. - Sie können
not-innicht mit ungleich!=kombinieren. - Sie können Ihre Abfrage nicht nach einem Feld sortieren, das in einer Gleichheitsklausel (
==) oder einerin-Klausel enthalten ist.
Kumulierende Abfragen
Sie können mehrere Gleichheitsoperatoren (== oder array-contains) verketten, um spezifischere Abfragen zu erstellen (logisches AND). Sie müssen jedoch einen zusammengesetzten Index erstellen, um Gleichheitsoperatoren mit den Ungleichheitsfiltern <, <=, > und != zu kombinieren.
Webversion 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));
Webversion 8
const q1 = citiesRef.where("state", "==", "CO").where("name", "==", "Denver");
const q2 = citiesRef.where("state", "==", "CA").where("population", "<", 1000000);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
citiesRef
.whereField("state", isEqualTo: "CO")
.whereField("name", isEqualTo: "Denver")
citiesRef
.whereField("state", isEqualTo: "CA")
.whereField("population", isLessThan: 1000000)
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[[citiesRef queryWhereField:@"state" isEqualTo:@"CO"]
queryWhereField:@"name" isGreaterThanOrEqualTo:@"Denver"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
queryWhereField:@"population" isLessThan:@1000000];
Java
Android
citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000);
Kotlin+KTX
Android
citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver")
citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000)
Java
Python
Python
(Async)
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
Sie können einen Bereichs- (<, <=, >, >=) oder Nicht-Gleichheitsvergleich (!=) nur auf einem einzelnen Feld ausführen. Es können maximal eine array-contains- oder array-contains-any-Klausel in einer zusammengesetzten Abfrage sein:
Gültig: Bereichsfilter für nur ein Feld
Webversion 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));
Webversion 8
const q1 = citiesRef.where("state", ">=", "CA").where("state", "<=", "IN");
const q2 = citiesRef.where("state", "==", "CA").where("population", ">", 1000000);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
citiesRef
.whereField("state", isGreaterThanOrEqualTo: "CA")
.whereField("state", isLessThanOrEqualTo: "IN")
citiesRef
.whereField("state", isEqualTo: "CA")
.whereField("population", isGreaterThan: 1000000)
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
queryWhereField:@"state" isLessThanOrEqualTo:@"IN"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
queryWhereField:@"population" isGreaterThan:@1000000];
Java
Android
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
.whereLessThanOrEqualTo("state", "IN");
citiesRef.whereEqualTo("state", "CA")
.whereGreaterThan("population", 1000000);
Kotlin+KTX
Android
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
.whereLessThanOrEqualTo("state", "IN")
citiesRef.whereEqualTo("state", "CA")
.whereGreaterThan("population", 1000000)
Java
Python
Python
(Async)
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
Ungültig: Bereichsfilter für verschiedene Felder
Webversion 9
import { query, where } from "firebase/firestore";
const q = query(citiesRef, where("state", ">=", "CA"), where("population", ">", 100000));
Webversion 8
citiesRef.where("state", ">=", "CA").where("population", ">", 100000);
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
citiesRef
.whereField("state", isGreaterThanOrEqualTo: "CA")
.whereField("population", isGreaterThan: 1000000)
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
queryWhereField:@"population" isGreaterThan:@1000000];
Java
Android
citiesRef.whereGreaterThanOrEqualTo("state", "CA").whereGreaterThan("population", 100000);
Kotlin+KTX
Android
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
.whereGreaterThan("population", 100000)
Java
Python
Python
(Async)
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
Sammlungsgruppenabfragen
Eine Sammlungsgruppe umfasst alle Sammlungen mit derselben ID. Standardmäßig rufen Abfragen Ergebnisse aus einer einzelnen Sammlung in einer Datenbank ab. Mit einer Sammlungsgruppenabfrage können Sie Dokumente aus einer Sammlungsgruppe statt aus einer einzelnen Sammlung abrufen.
So haben Sie beispielsweise die Möglichkeit, eine landmarks-Sammlungsgruppe zu erstellen, indem Sie jeder Stadt eine Untersammlung für Sehenswürdigkeiten hinzufügen:
Webversion 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'
})
]);
Webversion 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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
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
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
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
Android
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
Android
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
(Async)
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
Mithilfe der oben beschriebenen einfachen und zusammengesetzten Abfrage können Sie die Untersammlung landmarks einer bestimmten Stadt abfragen. Sie können jedoch auch Ergebnisse aus der Untersammlung landmarks einer Stadt auf einmal abrufen.
Die Sammlungsgruppe landmarks besteht aus allen Sammlungen mit der ID landmarks. Sie können sie mit einer Sammlungsgruppenabfrage abfragen. Bei dieser Sammlungsgruppenabfrage werden beispielsweise alle museum-Sehenswürdigkeiten in allen Städten abgerufen:
Webversion 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());
});
Webversion 8
var museums = db.collectionGroup('landmarks').where('type', '==', 'museum');
museums.get().then((querySnapshot) => {
querySnapshot.forEach((doc) => {
console.log(doc.id, ' => ', doc.data());
});
});
Swift
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
db.collectionGroup("landmarks").whereField("type", isEqualTo: "museum").getDocuments { (snapshot, error) in
// ...
}
Objective-C
Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.
[[[self.db collectionGroupWithID:@"landmarks"] queryWhereField:@"type" isEqualTo:@"museum"]
getDocumentsWithCompletion:^(FIRQuerySnapshot *snapshot, NSError *error) {
// ...
}];
Java
Android
db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
.addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
@Override
public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
// ...
}
});
Kotlin+KTX
Android
db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
.addOnSuccessListener { queryDocumentSnapshots ->
// ...
}
Java
Python
Python
(Async)
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
Um eine Sammlungsgruppenabfrage verwenden zu können, müssen Sie einen Index erstellen, der Ihre Sammlungsgruppenabfrage unterstützt. Sie können einen Index über eine Fehlermeldung, die Konsole oder die Firebase CLI erstellen.
Für die Web- und mobilen SDKs müssen Sie außerdem Regeln erstellen, die die Sammlungsgruppenabfragen zulassen.
Abfragebeschränkungen
Folgende Liste fasst die Einschränkungen für Firestore-Abfragen zusammen:
- Firestore bietet eingeschränkte Unterstützung für logische
OR-Abfragen. Die Operatoreninundarray-contains-anyunterstützen ein logischesORfür bis zu 10 Gleichheitsbedingungen (==) oderarray-contains-Bedingungen für ein einzelnes Feld. Erstellen Sie in anderen Fällen für jedeOR-Bedingung eine separate Abfrage und führen Sie die Abfrageergebnisse in der App zusammen. - In zusammengesetzten Abfragen müssen alle Bereichs- (
<,<=,>,>=) und Ungleich-Vergleiche (!=,not-in) in demselben Feld filtern. - Sie können maximal eine
array-contains-Klausel pro Abfrage verwenden. Sie könnenarray-containsnicht mitarray-contains-anykombinieren. - Sie können höchstens eine
in-,not-in- oderarray-contains-any-Klausel pro Abfrage verwenden. Sie könnenin,not-inundarray-contains-anynicht in derselben Abfrage kombinieren. - Sie können Ihre Abfrage nicht nach einem Feld sortieren, das in einer Gleichheitsklausel (
==) oder einerin-Klausel enthalten ist. - Die Summe der Filter, der Sortierreihenfolgen und des übergeordneten Dokumentpfads (1 für eine untergeordnete Sammlung, 0 für eine Stammsammlung) in einer Abfrage darf 100 nicht überschreiten.