Realiza consultas simples y compuestas en Cloud Firestore

Cloud Firestore proporciona una potente funcionalidad de consulta para especificar qué documentos desea recuperar de una colección o grupo de colecciones. Estas consultas también se pueden usar con get() o addSnapshotListener() , como se describe en Obtener datos y obtener actualizaciones en tiempo real .

Datos de ejemplo

Para comenzar, escriba algunos datos sobre las ciudades para que podamos ver diferentes formas de leerlos:

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"] });
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"] });
Nota: Este producto no está disponible en destinos watchOS y App Clip.
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"]
])
Nota: Este producto no está disponible en destinos watchOS y App Clip.
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"]
}];
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)
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);
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);
CollectionReference cities = db.collection("cities");
List<ApiFuture<WriteResult>> futures = new ArrayList<>();
futures
.add(
    cities
       
.document("SF")
       
.set(
           
new City(
               
"San Francisco",
               
"CA",
               
"USA",
               
false,
               
860000L,
               
Arrays.asList("west_coast", "norcal"))));
futures
.add(
    cities
       
.document("LA")
       
.set(
           
new City(
               
"Los Angeles",
               
"CA",
               
"USA",
               
false,
               
3900000L,
               
Arrays.asList("west_coast", "socal"))));
futures
.add(
    cities
       
.document("DC")
       
.set(
           
new City(
               
"Washington D.C.", null, "USA", true, 680000L, Arrays.asList("east_coast"))));
futures
.add(
    cities
       
.document("TOK")
       
.set(
           
new City(
               
"Tokyo", null, "Japan", true, 9000000L, Arrays.asList("kanto", "honshu"))));
futures
.add(
    cities
       
.document("BJ")
       
.set(
           
new City(
               
"Beijing",
               
null,
               
"China",
               
true,
               
21500000L,
               
Arrays.asList("jingjinji", "hebei"))));
// (optional) block on documents successfully added
ApiFutures.allAsList(futures).get();
class City:
   
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")
cities_ref
.document("BJ").set(
   
City("Beijing", None, "China", True, 21500000, ["hebei"]).to_dict()
)
cities_ref
.document("SF").set(
   
City(
       
"San Francisco", "CA", "USA", False, 860000, ["west_coast", "norcal"]
   
).to_dict()
)
cities_ref
.document("LA").set(
   
City(
       
"Los Angeles", "CA", "USA", False, 3900000, ["west_coast", "socal"]
   
).to_dict()
)
cities_ref
.document("DC").set(
   
City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()
)
cities_ref
.document("TOK").set(
   
City("Tokyo", None, "Japan", True, 9000000, ["kanto", "honshu"]).to_dict()
)
class City:
   
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()
)
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")})},
});
const citiesRef = db.collection('cities');

await citiesRef
.doc('SF').set({
  name
: 'San Francisco', state: 'CA', country: 'USA',
  capital
: false, population: 860000,
  regions
: ['west_coast', 'norcal']
});
await citiesRef
.doc('LA').set({
  name
: 'Los Angeles', state: 'CA', country: 'USA',
  capital
: false, population: 3900000,
  regions
: ['west_coast', 'socal']
});
await citiesRef
.doc('DC').set({
  name
: 'Washington, D.C.', state: null, country: 'USA',
  capital
: true, population: 680000,
  regions
: ['east_coast']
});
await citiesRef
.doc('TOK').set({
  name
: 'Tokyo', state: null, country: 'Japan',
  capital
: true, population: 9000000,
  regions
: ['kanto', 'honshu']
});
await citiesRef
.doc('BJ').set({
  name
: 'Beijing', state: null, country: 'China',
  capital
: true, population: 21500000,
  regions
: ['jingjinji', 'hebei']
});
cities := []struct {
        id
string
        c  
City
}{
       
{
                id
: "SF",
                c
: City{Name: "San Francisco", State: "CA", Country: "USA",
                       
Capital: false, Population: 860000,
                       
Regions: []string{"west_coast", "norcal"}},
       
},
       
{
                id
: "LA",
                c
: City{Name: "Los Angeles", State: "CA", Country: "USA",
                       
Capital: false, Population: 3900000,
                       
Regions: []string{"west_coast", "socal"}},
       
},
       
{
                id
: "DC",
                c
: City{Name: "Washington D.C.", Country: "USA",
                       
Capital: true, Population: 680000,
                       
Regions: []string{"east_coast"}},
       
},
       
{
                id
: "TOK",
                c
: City{Name: "Tokyo", Country: "Japan",
                       
Capital: true, Population: 9000000,
                       
Regions: []string{"kanto", "honshu"}},
       
},
       
{
                id
: "BJ",
                c
: City{Name: "Beijing", Country: "China",
                       
Capital: true, Population: 21500000,
                       
Regions: []string{"jingjinji", "hebei"}},
       
},
}
for _, c := range cities {
       
if _, err := client.Collection("cities").Doc(c.id).Set(ctx, c.c); err != nil {
               
return err
       
}
}
$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);
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"} }
});
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.");
cities_ref = firestore.col collection_path
cities_ref
.doc("SF").set(
 
{
    name
:       "San Francisco",
    state
:      "CA",
    country
:    "USA",
    capital
:    false,
    population
: 860_000,
    regions
:    ["west_coast", "norcal"]
 
}
)
cities_ref
.doc("LA").set(
 
{
    name
:       "Los Angeles",
    state
:      "CA",
    country
:    "USA",
    capital
:    false,
    population
: 3_900_000,
    regions
:    ["west_coast", "socal"]
 
}
)
cities_ref
.doc("DC").set(
 
{
    name
:       "Washington D.C.",
    state
:      nil,
    country
:    "USA",
    capital
:    true,
    population
: 680_000,
    regions
:    ["east_coast"]
 
}
)
cities_ref
.doc("TOK").set(
 
{
    name
:       "Tokyo",
    state
:      nil,
    country
:    "Japan",
    capital
:    true,
    population
: 9_000_000,
    regions
:    ["kanto", "honshu"]
 
}
)
cities_ref
.doc("BJ").set(
 
{
    name
:       "Beijing",
    state
:      nil,
    country
:    "China",
    capital
:    true,
    population
: 21_500_000,
    regions
:    ["jingjinji", "hebei"]
 
}
)

consultas simples

La siguiente consulta devuelve todas las ciudades con estado CA :

// 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"));
// Create a reference to the cities collection
var citiesRef = db.collection("cities");

// Create a query against the collection.
var query = citiesRef.where("state", "==", "CA");
Nota: Este producto no está disponible en destinos watchOS y App Clip.
// 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")
Nota: Este producto no está disponible en destinos watchOS y App Clip.
// 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"];
// Create a reference to the cities collection
val citiesRef = db.collection("cities")

// Create a query against the collection.
val query = citiesRef.whereEqualTo("state", "CA")
// Create a reference to the cities collection
CollectionReference citiesRef = db.collection("cities");

// Create a query against the collection.
Query query = citiesRef.whereEqualTo("state", "CA");
// 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");
// Create a reference to the cities collection
CollectionReference cities = db.collection("cities");
// Create a query against the collection.
Query query = cities.whereEqualTo("state", "CA");
// retrieve  query results asynchronously using query.get()
ApiFuture<QuerySnapshot> querySnapshot = query.get();

for (DocumentSnapshot document : querySnapshot.get().getDocuments()) {
 
System.out.println(document.getId());
}
# Create a reference to the cities collection
cities_ref
= db.collection("cities")

# Create a query against the collection
query_ref
= cities_ref.where(filter=FieldFilter("state", "==", "CA"))
# Create a reference to the cities collection
cities_ref
= db.collection("cities")

# Create a query against the collection
query_ref
= cities_ref.where(filter=FieldFilter("state", "==", "CA"))
CollectionReference cities_ref = db->Collection("cities");
// Create a query against the collection.
Query query_ca =
    cities_ref
.WhereEqualTo("state", FieldValue::String("CA"));
// Create a reference to the cities collection
const citiesRef = db.collection('cities');

// Create a query against the collection
const queryRef = citiesRef.where('state', '==', 'CA');
query := client.Collection("cities").Where("state", "==", "CA")
$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());
}
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));
   
}
});
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);
}
cities_ref = firestore.col collection_path

query
= cities_ref.where "state", "=", "CA"

query
.get do |city|
  puts
"Document #{city.document_id} returned by query state=CA."
end

La siguiente consulta devuelve todas las capitales:

import { collection, query, where } from "firebase/firestore";
const citiesRef = collection(db, "cities");

const q = query(citiesRef, where("capital", "==", true));
var citiesRef = db.collection("cities");

var query = citiesRef.where("capital", "==", true);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)
Nota: Este producto no está disponible en destinos watchOS y App Clip.
FIRQuery *capitalCities =
   
[[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@YES];
val capitalCities = db.collection("cities").whereEqualTo("capital", true)
Query capitalCities = db.collection("cities").whereEqualTo("capital", true);
final capitalcities =
    db
.collection("cities").where("capital", isEqualTo: true);
// Create a reference to the cities collection
CollectionReference cities = db.collection("cities");
// Create a query against the collection.
Query query = cities.whereEqualTo("capital", true);
// retrieve  query results asynchronously using query.get()
ApiFuture<QuerySnapshot> querySnapshot = query.get();

for (DocumentSnapshot document : querySnapshot.get().getDocuments()) {
 
System.out.println(document.getId());
}
cities_ref = db.collection("cities")

query
= cities_ref.where(filter=FieldFilter("capital", "==", True))
cities_ref = db.collection("cities")

query
= cities_ref.where(filter=FieldFilter("capital", "==", True))
Query capital_cities = db->Collection("cities").WhereEqualTo(
   
"capital", FieldValue::Boolean(true));
// Create a reference to the cities collection
const citiesRef = db.collection('cities');

// Create a query against the collection
const allCapitalsRes = citiesRef.where('capital', '==', true);
query := client.Collection("cities").Where("capital", "==", true)
$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());
}
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));
   
}
});
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);
}
cities_ref = firestore.col collection_path

query
= cities_ref.where "capital", "=", true

query
.get do |city|
  puts
"Document #{city.document_id} returned by query capital=true."
end

Ejecutar una consulta

Después de crear un objeto de consulta, use la función get() para recuperar los resultados:

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());
});
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);
   
});
Nota: Este producto no está disponible en destinos watchOS y App Clip.
do {
 
let querySnapshot = try await db.collection("cities").whereField("capital", isEqualTo: true)
   
.getDocuments()
 
for document in querySnapshot.documents {
    print
("\(document.documentID) => \(document.data())")
 
}
} catch {
  print
("Error getting documents: \(error)")
}
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[[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);
       
}
     
}
   
}];
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)
   
}
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());
               
}
           
}
       
});
db.collection("cities").where("capital", isEqualTo: true).get().then(
 
(querySnapshot) {
   
print("Successfully completed");
   
for (var docSnapshot in querySnapshot.docs) {
     
print('${docSnapshot.id} => ${docSnapshot.data()}');
   
}
 
},
  onError
: (e) => print("Error completing: $e"),
);
// asynchronously retrieve multiple documents
ApiFuture<QuerySnapshot> future = db.collection("cities").whereEqualTo("capital", true).get();
// future.get() blocks on response
List<QueryDocumentSnapshot> documents = future.get().getDocuments();
for (DocumentSnapshot document : documents) {
 
System.out.println(document.getId() + " => " + document.toObject(City.class));
}
# Note: Use of CollectionRef stream() is prefered to get()
docs
= (
    db
.collection("cities")
   
.where(filter=FieldFilter("capital", "==", True))
   
.stream()
)

for doc in docs:
   
print(f"{doc.id} => {doc.to_dict()}")
# Note: Use of CollectionRef stream() is prefered to get()
docs
= (
    db
.collection("cities")
   
.where(filter=FieldFilter("capital", "==", True))
   
.stream()
)

async
for doc in docs:
   
print(f"{doc.id} => {doc.to_dict()}")
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;
     
}
   
});
const citiesRef = db.collection('cities');
const snapshot = await citiesRef.where('capital', '==', true).get();
if (snapshot.empty) {
  console
.log('No matching documents.');
 
return;
}  

snapshot
.forEach(doc => {
  console
.log(doc.id, '=>', doc.data());
});

import (
       
"context"
       
"fmt"

       
"cloud.google.com/go/firestore"
       
"google.golang.org/api/iterator"
)

func multipleDocs
(ctx context.Context, client *firestore.Client) error {
        fmt
.Println("All capital cities:")
        iter
:= client.Collection("cities").Where("capital", "==", true).Documents(ctx)
       
for {
                doc
, err := iter.Next()
               
if err == iterator.Done {
                       
break
               
}
               
if err != nil {
                       
return err
               
}
                fmt
.Println(doc.Data())
       
}
       
return nil
}

PHP

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

$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());
   
}
}
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("");
 
};
});
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("");
}
cities_ref = firestore.col collection_path

query
= cities_ref.where "capital", "=", true

query
.get do |city|
  puts
"#{city.document_id} data: #{city.data}."
end

Consulte Obtener datos para obtener más información sobre cómo recuperar resultados de consultas. También puede agregar un oyente a una consulta para obtener los resultados actuales y escuchar actualizaciones futuras.

Operadores de consulta

El método where() toma tres parámetros: un campo para filtrar, un operador de comparación y un valor. Cloud Firestore admite los siguientes operadores de comparación:

Por ejemplo:

const stateQuery = query(citiesRef, where("state", "==", "CA"));
const populationQuery = query(citiesRef, where("population", "<", 100000));
const nameQuery = query(citiesRef, where("name", ">=", "San Francisco"));
const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Nota: Este producto no está disponible en destinos watchOS y App Clip.
let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")
let populationQuery = citiesRef.whereField("population", isLessThan: 100000)
let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")
Nota: Este producto no está disponible en destinos watchOS y App Clip.
FIRQuery *stateQuery = [citiesRef queryWhereField:@"state" isEqualTo:@"CA"];
FIRQuery *populationQuery = [citiesRef queryWhereField:@"population" isLessThan:@100000];
FIRQuery *nameQuery = [citiesRef queryWhereField:@"name" isGreaterThanOrEqualTo:@"San Francisco"];
val stateQuery = citiesRef.whereEqualTo("state", "CA")
val populationQuery = citiesRef.whereLessThan("population", 100000)
val nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco")
Query stateQuery = citiesRef.whereEqualTo("state", "CA");
Query populationQuery = citiesRef.whereLessThan("population", 100000);
Query nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco");
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");
Query stateQuery = cities.whereEqualTo("state", "CA");
Query populationQuery = cities.whereLessThan("population", 1000000L);
Query nameQuery = cities.whereGreaterThanOrEqualTo("name", "San Francisco");
cities_ref = db.collection("cities")

cities_ref
.where(filter=FieldFilter("state", "==", "CA"))
cities_ref
.where(filter=FieldFilter("population", "<", 1000000))
cities_ref
.where(filter=FieldFilter("name", ">=", "San Francisco"))
cities_ref = db.collection("cities")

cities_ref
.where(filter=FieldFilter("state", "==", "CA"))
cities_ref
.where(filter=FieldFilter("population", "<", 1000000))
cities_ref
.where(filter=FieldFilter("name", ">=", "San Francisco"))
cities_ref.WhereEqualTo("state", FieldValue::String("CA"));
cities_ref
.WhereLessThan("population", FieldValue::Integer(100000));
cities_ref
.WhereGreaterThanOrEqualTo("name",
                                     
FieldValue::String("San Francisco"));
const stateQueryRes = await citiesRef.where('state', '==', 'CA').get();
const populationQueryRes = await citiesRef.where('population', '<', 1000000).get();
const nameQueryRes = await citiesRef.where('name', '>=', 'San Francisco').get();
countryQuery := cities.Where("state", "==", "CA")
popQuery
:= cities.Where("population", "<", 1000000)
cityQuery
:= cities.Where("name", ">=", "San Francisco")
$stateQuery = $citiesRef->where('state', '=', 'CA');
$populationQuery
= $citiesRef->where('population', '>', 1000000);
$nameQuery
= $citiesRef->where('name', '>=', 'San Francisco');
Query stateQuery = citiesRef.WhereEqualTo("State", "CA");
Query populationQuery = citiesRef.WhereGreaterThan("Population", 1000000);
Query nameQuery = citiesRef.WhereGreaterThanOrEqualTo("Name", "San Francisco");
CollectionReference citiesRef = db.Collection("cities");
Query stateQuery = citiesRef.WhereEqualTo("State", "CA");
Query populationQuery = citiesRef.WhereGreaterThan("Population", 1000000);
Query nameQuery = citiesRef.WhereGreaterThanOrEqualTo("Name", "San Francisco");
state_query      = cities_ref.where "state", "=", "CA"
population_query
= cities_ref.where "population", ">", 1_000_000
name_query      
= cities_ref.where "name", ">=", "San Francisco"

No igual ( != )

Utilice el operador no igual ( != ) para devolver documentos donde el campo dado existe y no coincide con el valor de comparación. Por ejemplo:

const notCapitalQuery = query(citiesRef, where("capital", "!=", false));
citiesRef.where("capital", "!=", false);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)
Nota: Este producto no está disponible en destinos watchOS y App Clip.
query = [citiesRef queryWhereField:@"capital" isNotEqualTo:@NO];
val notCapitalQuery = citiesRef.whereNotEqualTo("capital", false)
Query notCapitalQuery = citiesRef.whereNotEqualTo("capital", false);
final citiesRef = db.collection("cities");
final notCapitals = citiesRef.where("capital", isNotEqualTo: true);
CollectionReference citiesRef = db.collection("cities");

Query query = citiesRef.whereNotEqualTo("capital", false);
// Snippet not yet available
const capitalNotFalseRes = await citiesRef.where('capital', '!=', false).get();
// Snippet not yet available
$stateQuery = $citiesRef->where('capital', '!=', false);
Query query = citiesRef.WhereNotEqualTo("capital", false);
Query query = citiesRef.WhereNotEqualTo("capital", false);
// Snippet not yet available
cities_ref = firestore.col collection_path
query
= cities_ref.where "capital", "!=", false

Esta consulta devuelve todos los documentos city donde existe el campo capital con un valor distinto de false o null . Esto incluye documentos city donde el valor del campo capital es igual a true o cualquier valor no booleano además de null .

Esta consulta no devuelve documentos city donde el campo capital no existe. Las consultas no iguales ( != ) y not-in excluyen documentos donde el campo dado no existe .

Un campo existe cuando se establece en cualquier valor, incluida una cadena vacía ( "" ), null y NaN (no un número). Tenga en cuenta que los valores de los campos null no coinciden con las cláusulas != , porque x != null se evalúa como undefined .

Limitaciones

Tenga en cuenta las siguientes limitaciones para consultas != :

  • Sólo los documentos donde existe el campo dado pueden coincidir con la consulta.
  • No puede combinar not-in y != en una consulta compuesta.
  • En una consulta compuesta, las comparaciones de rango ( < , <= , > , >= ) y no iguales ( != , not-in ) deben filtrarse en el mismo campo.

Membresía de matriz

Puede utilizar el operador array-contains para filtrar según los valores de la matriz. Por ejemplo:

import { query, where } from "firebase/firestore";  
const q = query(citiesRef, where("regions", "array-contains", "west_coast"));
citiesRef.where("regions", "array-contains", "west_coast");
Nota: Este producto no está disponible en destinos watchOS y App Clip.
citiesRef
 
.whereField("regions", arrayContains: "west_coast")
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[citiesRef queryWhereField:@"state" arrayContains:@"west_coast"];
val citiesRef = db.collection("cities")

citiesRef
.whereArrayContains("regions", "west_coast")
CollectionReference citiesRef = db.collection("cities");

citiesRef
.whereArrayContains("regions", "west_coast");
final citiesRef = db.collection("cities");
final westCoastcities =
    citiesRef
.where("regions", arrayContains: "west_coast");
CollectionReference citiesRef = db.collection("cities");
Query westCoastQuery = citiesRef.whereArrayContains("regions", "west_coast");
cities_ref = db.collection("cities")

query
= cities_ref.where(
    filter
=FieldFilter("regions", "array_contains", "west_coast")
)
cities_ref = db.collection("cities")

query
= cities_ref.where(
    filter
=FieldFilter("regions", "array_contains", "west_coast")
)
CollectionReference cities_ref = db->Collection("cities");

cities_ref
.WhereArrayContains("region", FieldValue::String("west_coast"));
const westCoastCities = citiesRef.where('regions', 'array-contains',
 
'west_coast').get();
query := cities.Where("regions", "array-contains", "west_coast").Documents(ctx)
$containsQuery = $citiesRef->where('regions', 'array-contains', 'west_coast');
CollectionReference citiesRef = db.Collection("cities");
Query arrayContainsQuery = citiesRef.WhereArrayContains("region", "west_coast");
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereArrayContains("Regions", "west_coast");
cities_ref = firestore.col collection_path
cities
= cities_ref.where "regions", "array-contains", "west_coast"

Esta consulta devuelve todos los documentos city donde el campo regions es una matriz que contiene west_coast . Si la matriz tiene varias instancias del valor que consulta, el documento se incluye en los resultados solo una vez.

Puede utilizar como máximo una array-contains matriz por disyunción ( or grupo). No puede combinar array-contains con array-contains-any en la misma disyunción.

in , not-in y array-contains-any

Utilice el operador in para combinar hasta 30 cláusulas de igualdad ( == ) en el mismo campo con un OR lógico. Una in devuelve documentos donde el campo dado coincide con cualquiera de los valores de comparación. Por ejemplo:

import { query, where } from "firebase/firestore";

const q = query(citiesRef, where('country', 'in', ['USA', 'Japan']));
citiesRef.where('country', 'in', ['USA', 'Japan']);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
let citiesRef = db.collection("cities")

citiesRef
.whereField("country", in: ["USA", "Japan"])
Nota: Este producto no está disponible en destinos watchOS y App Clip.
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];

[citiesRef queryWhereField:@"country" in:@[@"USA", @"Japan"]];
val citiesRef = db.collection("cities")

citiesRef
.whereIn("country", listOf("USA", "Japan"))
CollectionReference citiesRef = db.collection("cities");

citiesRef
.whereIn("country", Arrays.asList("USA", "Japan"));
final citiesRef = db.collection("cities");
final cities = citiesRef.where("country", whereIn: ["USA", "Japan"]);
CollectionReference citiesRef = db.collection("cities");

Query query = citiesRef.whereIn("country", Arrays.asList("USA", "Japan"));
cities_ref = db.collection("cities")

query
= cities_ref.where(filter=FieldFilter("country", "in", ["USA", "Japan"]))
return query
cities_ref = db.collection("cities")

query
= cities_ref.where(filter=FieldFilter("country", "in", ["USA", "Japan"]))
return query
CollectionReference cities_ref = db->Collection("cities");

cities_ref
.WhereIn("country", std::vector<FieldValue> {
 
FieldValue::String("USA"),
 
FieldValue::String("Japan")
});
const usaOrJapan = await citiesRef.where('country', 'in', ['USA', 'Japan']).get();
cities := client.Collection("cities")
query
:= cities.Where("country", "in", []string{"USA", "Japan"}).Documents(ctx)
$rangeQuery = $citiesRef->where('country', 'in', ['USA', 'Japan']);
CollectionReference citiesRef = db.Collection("cities");
List
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereIn("Country", new[] { "USA", "Japan" });
cities_ref = firestore.col collection_path
usr_or_japan
= cities_ref.where "country", "in", ["USA", "Japan"]

Esta consulta devuelve todos los documentos city donde el campo country está establecido en USA o Japan . Según los datos del ejemplo, esto incluye los documentos SF , LA , DC y TOK .

not-in

Utilice el operador not-in para combinar hasta 10 cláusulas no iguales ( != ) en el mismo campo con un AND lógico. Una consulta not-in devuelve documentos donde el campo dado existe, no es null y no coincide con ninguno de los valores de comparación. Por ejemplo:

import { query, where } from "firebase/firestore";

const q = query(citiesRef, where('country', 'not-in', ['USA', 'Japan']));
citiesRef.where('country', 'not-in', ['USA', 'Japan']);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
citiesRef.whereField("country", notIn: ["USA", "Japan"])
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[citiesRef queryWhereField:@"country" notIn:@[@"USA", @"Japan"]];
citiesRef.whereNotIn("country", listOf("USA", "Japan"))
citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));
final citiesRef = db.collection("cities");
final cities = citiesRef.where("country", whereNotIn: ["USA", "Japan"]);
CollectionReference citiesRef = db.collection("cities");

Query query = citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));
// Snippet not yet available
cities_ref.WhereNotIn("country", std::vector<FieldValue> {
 
FieldValue::String("USA"),
 
FieldValue::String("Japan")
});
const notUsaOrJapan = await citiesRef.where('country', 'not-in', ['USA', 'Japan']).get();
// Snippet not yet available
$stateQuery = $citiesRef->where(
   
'country',
   
\Google\Cloud\Firestore\V1\StructuredQuery\FieldFilter\Operator::NOT_IN,
   
['USA', 'Japan']
);
Query query = citiesRef.WhereNotIn(new FieldPath("country"), new List<string>{"USA", "Japan"});
Query query = citiesRef.WhereNotIn("country", new List<object>(){"USA", "Japan"});
// Snippet not yet available
cities_ref = firestore.col collection_path
usr_or_japan
= cities_ref.where "country", "not_in", ["USA", "Japan"]

Esta consulta devuelve todos los documentos city donde existe el campo country y no está establecido en USA , Japan o null . Según los datos del ejemplo, esto incluye los documentos London y Hong Kong .

Las consultas not-in excluyen documentos en los que el campo indicado no existe. Un campo existe cuando se establece en cualquier valor, incluida una cadena vacía ( "" ), null y NaN (no un número). Tenga en cuenta que x != null se evalúa como undefined . Una consulta not-in con null como uno de los valores de comparación no coincide con ningún documento.

array-contains-any

Utilice el operador array-contains-any para combinar hasta 30 cláusulas array-contains en el mismo campo con un OR lógico. Una array-contains-any devuelve documentos donde el campo dado es una matriz que contiene uno o más de los valores de comparación:

import { query, where } from "firebase/firestore";  

const q = query(citiesRef,
  where
('regions', 'array-contains-any', ['west_coast', 'east_coast']));
citiesRef.where('regions', 'array-contains-any',
   
['west_coast', 'east_coast']);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
let citiesRef = db.collection("cities")
citiesRef
.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])
Nota: Este producto no está disponible en destinos watchOS y App Clip.
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];

[citiesRef queryWhereField:@"regions" arrayContainsAny:@[@"west_coast", @"east_coast"]];
val citiesRef = db.collection("cities")

citiesRef
.whereArrayContainsAny("regions", listOf("west_coast", "east_coast"))
CollectionReference citiesRef = db.collection("cities");

citiesRef
.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));
final citiesRef = db.collection("cities");
final cities = citiesRef
   
.where("regions", arrayContainsAny: ["west_coast", "east_coast"]);
CollectionReference citiesRef = db.collection("cities");

Query query =
    citiesRef
.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));
cities_ref = db.collection("cities")

query
= cities_ref.where(
    filter
=FieldFilter(
       
"regions", "array_contains_any", ["west_coast", "east_coast"]
   
)
)
return query
cities_ref = db.collection("cities")

query
= cities_ref.where(
    filter
=FieldFilter(
       
"regions", "array_contains_any", ["west_coast", "east_coast"]
   
)
)
return query
CollectionReference cities_ref = db->Collection("cities");

cities_ref
.WhereArrayContainsAny("region", std::vector<FieldValue> {
 
FieldValue::String("west_coast"),
 
FieldValue::String("east_coast")
});
const coastalCities = await citiesRef.where('regions', 'array-contains-any',
   
['west_coast', 'east_coast']).get();
cities := client.Collection("cities")
query
:= cities.Where("regions", "array-contains-any", []string{"west_coast", "east_coast"}).Documents(ctx)
$containsQuery = $citiesRef->where('regions', 'array-contains-any', ['west_coast', 'east_coast']);
Query query = citiesRef.WhereArrayContainsAny(
                         
"regions",
                         
new List<object>()
                         
{
                           
new List<object>(){"west_coast"},
                           
new List<object>(){"east_coast"}});
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereArrayContainsAny("Regions", new[] { "west_coast", "east_coast" });
cities_ref = firestore.col collection_path
costal_cities
= cities_ref.where "regions", "array-contains-any", ["west_coast", "east_coast"]

Esta consulta devuelve todos los documentos de la ciudad donde el campo regions es una matriz que contiene west_coast o east_coast . A partir de los datos de ejemplo, esto incluye los documentos SF , LA y DC .

Los resultados de array-contains-any se eliminan de los duplicados. Incluso si el campo de matriz de un documento coincide con más de uno de los valores de comparación, el conjunto de resultados incluye ese documento solo una vez.

array-contains-any siempre filtra por el tipo de datos de la matriz. Por ejemplo, la consulta anterior no devolvería un documento de ciudad donde, en lugar de una matriz, el campo regions sea la cadena west_coast .

Puede utilizar un valor de matriz como valor de comparación para in , pero a diferencia de array-contains-any , la cláusula coincide exactamente con la longitud, el orden y los valores de la matriz. Por ejemplo:

import { query, where } from "firebase/firestore";  

const q = query(citiesRef, where('regions', 'in', [['west_coast'], ['east_coast']]));
citiesRef.where('regions', 'in',
   
[['west_coast'], ['east_coast']]);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
citiesRef.whereField("regions", in: [["west_coast"], ["east_coast"]])
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[citiesRef queryWhereField:@"regions" in:@[@[@"west_coast"], @[@"east_coast"]]];
citiesRef.whereIn("regions", listOf(arrayOf("west_coast"), arrayOf("east_coast")))
citiesRef.whereIn("regions", Arrays.asList(new String[]{"west_coast"}, new String[]{"east_coast"}));
final citiesRef = db.collection("cities");
final cities = citiesRef.where("regions", whereIn: [
 
["west_coast"],
 
["east_coast"]
]);
CollectionReference citiesRef = db.collection("cities");

Query query =
    citiesRef
.whereIn(
       
"regions", Arrays.asList(Arrays.asList("west_coast"), Arrays.asList("east_coast")));
cities_ref = db.collection("cities")

query
= cities_ref.where(
    filter
=FieldFilter("regions", "in", [["west_coast"], ["east_coast"]])
)
return query
cities_ref = db.collection("cities")

query
= cities_ref.where(
    filter
=FieldFilter("regions", "in", [["west_coast"], ["east_coast"]])
)
return query
cities_ref.WhereIn("region", std::vector<FieldValue> {
 
FieldValue::String("west_coast"),
 
FieldValue::String("east_coast")
});
const exactlyOneCoast = await citiesRef.where('regions', 'in',
   
[['west_coast', 'east_coast']]).get();
cities := client.Collection("cities")
query
:= cities.Where("regions", "in", [][]string{{"west_coast"}, {"east_coast"}}).Documents(ctx)
$rangeQuery = $citiesRef->where('regions', 'in', [['west_coast'], ['east_coast']]);
Query query = citiesRef.WhereIn(new FieldPath("regions"), new List<string>{"west_coast", "east_coast"});
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereIn("Regions",
   
new[] { new[] { "west_coast" }, new[] { "east_coast" } });
cities_ref = firestore.col collection_path
exactly_one_cost
= cities_ref.where "regions", "in", [["west_coast"], ["east_coast"]]

Esta consulta devuelve cada documento de ciudad donde el campo regions es una matriz que contiene exactamente un elemento de west_coast o east_coast . A partir de los datos del ejemplo, solo el documento DC califica con su campo regions de ["east_coast"] . El documento SF , sin embargo, no coincide porque su campo regions es ["west_coast", "norcal"] .

Limitaciones

Tenga en cuenta las siguientes limitaciones para in , not-in y array-contains-any :

  • Cloud Firestore brinda soporte para consultas OR lógicas a través de los operadores or , in y array-contains-any . Estas consultas están limitadas a 30 disyunciones basadas en la forma normal disyuntiva de la consulta .
  • Puede utilizar como máximo una array-contains matriz por disyunción ( or grupo). No puede combinar array-contains con array-contains-any en la misma disyunción.
  • ¡No puedes combinar not-in con no iguales != .
  • not-in admite hasta 10 valores de comparación.

Consultas compuestas ( AND )

Puede combinar restricciones con un AND lógico encadenando múltiples operadores de igualdad ( == o array-contains ). Sin embargo, debe crear un índice compuesto para combinar los operadores de igualdad con los operadores de desigualdad, < , <= , > y != .

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));
const q1 = citiesRef.where("state", "==", "CO").where("name", "==", "Denver");
const q2 = citiesRef.where("state", "==", "CA").where("population", "<", 1000000);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
citiesRef
 
.whereField("state", isEqualTo: "CO")
 
.whereField("name", isEqualTo: "Denver")
citiesRef
 
.whereField("state", isEqualTo: "CA")
 
.whereField("population", isLessThan: 1000000)
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[citiesRef queryWhereField:@"state" isEqualTo:@"CO"]
    queryWhereField
:@"name" isGreaterThanOrEqualTo:@"Denver"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
    queryWhereField
:@"population" isLessThan:@1000000];
citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver")
citiesRef
.whereEqualTo("state", "CA").whereLessThan("population", 1000000)
citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
citiesRef
.whereEqualTo("state", "CA").whereLessThan("population", 1000000);
final citiesRef = db.collection("cities");
citiesRef
   
.where("state", isEqualTo: "CO")
   
.where("name", isEqualTo: "Denver");
citiesRef
   
.where("state", isEqualTo: "CA")
   
.where("population", isLessThan: 1000000);
Query chainedQuery1 = cities.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
cities_ref = db.collection("cities")

denver_query
= cities_ref.where(filter=FieldFilter("state", "==", "CO")).where(
    filter
=FieldFilter("name", "==", "Denver")
)
large_us_cities_query
= cities_ref.where(
    filter
=FieldFilter("state", "==", "CA")
).where(filter=FieldFilter("population", ">", 1000000))
cities_ref = db.collection("cities")

denver_query
= cities_ref.where(filter=FieldFilter("state", "==", "CO")).where(
    filter
=FieldFilter("name", "==", "Denver")
)
large_us_cities_query
= cities_ref.where(
    filter
=FieldFilter("state", "==", "CA")
).where(filter=FieldFilter("population", ">", 1000000))
cities_ref.WhereEqualTo("state", FieldValue::String("CO"))
   
.WhereEqualTo("name", FieldValue::String("Denver"));
cities_ref
.WhereEqualTo("state", FieldValue::String("CA"))
   
.WhereLessThan("population", FieldValue::Integer(1000000));
citiesRef.where('state', '==', 'CO').where('name', '==', 'Denver');
citiesRef
.where('state', '==', 'CA').where('population', '<', 1000000);
denverQuery := cities.Where("name", "==", "Denver").Where("state", "==", "CO")
caliQuery
:= cities.Where("state", "==", "CA").Where("population", "<=", 1000000)
query
:= cities.Where("country", "==", "USA").Where("population", ">", 5000000)
$chainedQuery = $citiesRef
   
->where('state', '=', 'CA')
   
->where('name', '=', 'San Francisco');
Query chainedQuery = citiesRef
   
.WhereEqualTo("State", "CA")
   
.WhereEqualTo("Name", "San Francisco");
CollectionReference citiesRef = db.Collection("cities");
Query chainedQuery = citiesRef
   
.WhereEqualTo("State", "CA")
   
.WhereEqualTo("Name", "San Francisco");
chained_query = cities_ref.where("state", "=", "CA").where("name", "=", "San Francisco")

Puede realizar comparaciones de rango ( < , <= , > , >= ) o no es igual ( != ) solo en un solo campo, y puede incluir como máximo una cláusula array-contains o array-contains-any en una consulta compuesta :

Válido : filtros de rango en un solo campo

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));
const q1 = citiesRef.where("state", ">=", "CA").where("state", "<=", "IN");
const q2 = citiesRef.where("state", "==", "CA").where("population", ">", 1000000);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
citiesRef
 
.whereField("state", isGreaterThanOrEqualTo: "CA")
 
.whereField("state", isLessThanOrEqualTo: "IN")
citiesRef
 
.whereField("state", isEqualTo: "CA")
 
.whereField("population", isGreaterThan: 1000000)
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
    queryWhereField
:@"state" isLessThanOrEqualTo:@"IN"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
    queryWhereField
:@"population" isGreaterThan:@1000000];
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
   
.whereLessThanOrEqualTo("state", "IN")
citiesRef
.whereEqualTo("state", "CA")
   
.whereGreaterThan("population", 1000000)
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
       
.whereLessThanOrEqualTo("state", "IN");
citiesRef
.whereEqualTo("state", "CA")
       
.whereGreaterThan("population", 1000000);
final citiesRef = db.collection("cities");
citiesRef
   
.where("state", isGreaterThanOrEqualTo: "CA")
   
.where("state", isLessThanOrEqualTo: "IN");
citiesRef
   
.where("state", isEqualTo: "CA")
   
.where("population", isGreaterThan: 1000000);
Query validQuery1 =
    cities
.whereGreaterThanOrEqualTo("state", "CA").whereLessThanOrEqualTo("state", "IN");
Query validQuery2 = cities.whereEqualTo("state", "CA").whereGreaterThan("population", 1000000);
cities_ref = db.collection("cities")
cities_ref
.where(filter=FieldFilter("state", ">=", "CA")).where(
    filter
=FieldFilter("state", "<=", "IN")
)
cities_ref = db.collection("cities")
cities_ref
.where(filter=FieldFilter("state", ">=", "CA")).where(
    filter
=FieldFilter("state", "<=", "IN")
)
cities_ref.WhereGreaterThanOrEqualTo("state", FieldValue::String("CA"))
   
.WhereLessThanOrEqualTo("state", FieldValue::String("IN"));
cities_ref
.WhereEqualTo("state", FieldValue::String("CA"))
   
.WhereGreaterThan("population", FieldValue::Integer(1000000));
citiesRef.where('state', '>=', 'CA').where('state', '<=', 'IN');
citiesRef
.where('state', '==', 'CA').where('population', '>', 1000000);
stateQuery := cities.Where("state", ">=", "CA").Where("state", "<", "IN")
populationQuery
:= cities.Where("state", "==", "CA").Where("population", ">", 1000000)
$rangeQuery = $citiesRef
   
->where('state', '>=', 'CA')
   
->where('state', '<=', 'IN');
Query rangeQuery = citiesRef
   
.WhereGreaterThanOrEqualTo("State", "CA")
   
.WhereLessThanOrEqualTo("State", "IN");
CollectionReference citiesRef = db.Collection("cities");
Query rangeQuery = citiesRef
   
.WhereGreaterThanOrEqualTo("State", "CA")
   
.WhereLessThanOrEqualTo("State", "IN");
range_query = cities_ref.where("state", ">=", "CA").where("state", "<=", "IN")

No válido : filtros de rango en diferentes campos

import { query, where } from "firebase/firestore";  

const q = query(citiesRef, where("state", ">=", "CA"), where("population", ">", 100000));
citiesRef.where("state", ">=", "CA").where("population", ">", 100000);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
Nota: Este producto no está disponible en destinos watchOS y App Clip.
citiesRef
 
.whereField("state", isGreaterThanOrEqualTo: "CA")
 
.whereField("population", isGreaterThan: 1000000)
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
    queryWhereField
:@"population" isGreaterThan:@1000000];
citiesRef.whereGreaterThanOrEqualTo("state", "CA")
   
.whereGreaterThan("population", 100000)
citiesRef.whereGreaterThanOrEqualTo("state", "CA").whereGreaterThan("population", 100000);
final citiesRef = db.collection("cities");
citiesRef
   
.where("state", isGreaterThanOrEqualTo: "CA")
   
.where("population", isGreaterThan: 1000000);
Query invalidRangeQuery =
    cities
.whereGreaterThanOrEqualTo("state", "CA").whereGreaterThan("population", 100000);
cities_ref = db.collection("cities")
cities_ref
.where(filter=FieldFilter("state", ">=", "CA")).where(
    filter
=FieldFilter("population", ">=", 1000000)
)
cities_ref = db.collection("cities")
cities_ref
.where(filter=FieldFilter("state", ">=", "CA")).where(
    filter
=FieldFilter("population", ">=", 1000000)
)
// BAD EXAMPLE -- will crash the program:
cities_ref
.WhereGreaterThanOrEqualTo("state", FieldValue::String("CA"))
   
.WhereGreaterThan("population", FieldValue::Integer(100000));
citiesRef.where('state', '>=', 'CA').where('population', '>', 1000000);
query := cities.Where("state", ">=", "CA").Where("population", ">", 1000000)
$invalidRangeQuery = $citiesRef
   
->where('state', '>=', 'CA')
   
->where('population', '>', 1000000);
Query invalidRangeQuery = citiesRef
   
.WhereGreaterThanOrEqualTo("State", "CA")
   
.WhereGreaterThan("Population", 1000000);
CollectionReference citiesRef = db.Collection("cities");
Query invalidRangeQuery = citiesRef
   
.WhereGreaterThanOrEqualTo("State", "CA")
   
.WhereGreaterThan("Population", 1000000);
invalid_range_query = cities_ref.where("state", ">=", "CA").where("population", ">", 1_000_000)

OR consultas

Puede combinar restricciones con un OR lógico. Por ejemplo:

const q = query(citiesRef,  
 
or(where('capital', '==', true),
     
where('population', '>=', 1000000)
 
)
);
 

No disponible.

let query = db.collection("cities").whereFilter(Filter.orFilter([
               
Filter.whereField("capital", isEqualTo: true),
               
Filter.whereField("population", isGreaterThanOrEqualTo: 1000000);
           
]))
 
  FIRCollectionReference *collection = [self.db collectionWithPath:@"cities"];
 
FIRQuery *query = [collection queryWhereFilter:[FIRFilter orFilterWithFilters:@[
     
[FIRFilter filterWhereField:@"capital" isEqualTo:@YES],
     
[FIRFilter filterWhereField:@"population" isGreaterThanOrEqualTo:@1000000]
 
]]];
 
val query = collection.where(Filter.or(
       
Filter.equalTo("capital", true),
       
Filter.greaterThanOrEqualTo("population", 1000000)    
))
 
Query query = collection.where(Filter.or(
       
Filter.equalTo("capital", true),
       
Filter.greaterThanOrEqualTo("population", 1000000)
));
 
var query = db.collection("cities")
 
.where(
   
Filter.or(
     
Filter("capital", isEqualTo: true),
     
Filter("population", isGreaterThan: 1000000)
   
));

Fragmento no disponible.

from google.cloud import firestore
from google.cloud.firestore_v1.base_query import FieldFilter, Or


def query_or_composite_filter(project_id: str) -> None:
   
# Instantiate the Firestore client
    client
= firestore.Client(project=project_id)
    col_ref
= client.collection("users")

    filter_1
= FieldFilter("birthYear", "==", 1906)
    filter_2
= FieldFilter("birthYear", "==", 1912)

   
# Create the union filter of the two filters (queries)
    or_filter
= Or(filters=[filter_1, filter_2])

   
# Execute the query
    docs
= col_ref.where(filter=or_filter).stream()

   
print("Documents found:")
   
for doc in docs:
       
print(f"ID: {doc.id}")

Fragmento no disponible.

Fragmento no disponible.

const bigCities = await citiesRef
 
.where(
   
Filter.or(
     
Filter.where('capital', '==', true),
     
Filter.where('population', '>=', 1000000)
   
)
 
)
 
.get();
import (
       
"context"
       
"fmt"
       
"io"

        firestore
"cloud.google.com/go/firestore"
       
"google.golang.org/api/iterator"
)

func queryFilterOr
(w io.Writer, projectId string) error {
       
// Instantiate a client
        ctx
:= context.Background()
        client
, err := firestore.NewClient(ctx, projectId)
       
if err != nil {
               
return err
       
}
       
// always be sure to close the client to release resources
        defer client
.Close()

        q1
:= firestore.PropertyFilter{
               
Path:     "birthYear",
               
Operator: "==",
               
Value:    1906,
       
}

        q2
:= firestore.PropertyFilter{
               
Path:     "birthYear",
               
Operator: "==",
               
Value:    1815,
       
}

        orFilter
:= firestore.OrFilter{
               
Filters: []firestore.EntityFilter{q1, q2},
       
}

        orQuery
:= client.Collection("users").WhereEntity(orFilter)
        it
:= orQuery.Documents(ctx)
       
if err != nil {
               
return err
       
}

        fmt
.Fprint(w, "Individual documents:\n")
       
for {
                doc
, err := it.Next()
               
if err == iterator.Done {
                       
break
               
}
               
if err != nil {
                       
return fmt.Errorf("documents iterator: %w", err)
               
}
                fmt
.Fprintf(w, "%s: %s", doc.Ref.ID, doc.Data()["birthYear"])
       
}

       
return nil
}

Fragmento no disponible.

Query query = citiesRef.Where(Filter.Or(
       
Filter.EqualTo("State", "CA"),
       
Filter.GreaterThanOrEqualTo("population", 1000000)
));
query
.GetSnapshotAsync().ContinueWithOnMainThread((querySnapshotTask) =>
{
   
foreach (DocumentSnapshot documentSnapshot in querySnapshotTask.Result.Documents)
   
{
       
Debug.Log(String.Format("Document {0} returned by query State=CA or population >= {1}", documentSnapshot.Id, 1000000));
   
}
});

Fragmento no disponible.

Fragmento no disponible.

Cloud Firestore utiliza sus índices compuestos para atender consultas OR . Si sus índices no admiten la consulta, Cloud Firestore sugiere índices adicionales para su base de datos .

Puede combinar consultas OR con consultas compuestas para filtrar combinaciones de operaciones OR y AND . Por ejemplo:

const q = query(collection(db, "cities"), and(
  where
('state', '==', 'CA'),  
  or
(
    where
('capital', '==', true),
    where
('population', '>=', 1000000)
 
)
));

No disponible.

Nota: Este producto no está disponible en destinos watchOS y App Clip.
let query = db.collection("cities").whereFilter(Filter.andFilter([
   
Filter.whereField("state", isEqualTo: "CA"),
   
Filter.orFilter([
       
Filter.whereField("capital", isEqualTo: true),
       
Filter.whereField("population", isGreaterThanOrEqualTo: 1000000);
   
])
]))
Nota: Este producto no está disponible en destinos watchOS y App Clip.
FIRCollectionReference *collection = [self.db collectionWithPath:@"cities"];
FIRQuery *query = [collection queryWhereFilter:[FIRFilter andFilterWithFilters:@[
 
[FIRFilter filterWhereField:@"state" isEqualTo:@"CA"],
 
[FIRFilter orFilterWithFilters:@[
   
[FIRFilter filterWhereField:@"capital" isEqualTo:@YES],
   
[FIRFilter filterWhereField:@"population" isGreaterThanOrEqualTo:@1000000]
 
]]
]]];
val query = collection.where(Filter.and(
   
Filter.equalTo("state", "CA"),
   
Filter.or(
       
Filter.equalTo("capital", true),
       
Filter.greaterThanOrEqualTo("population", 1000000)
   
)
))
Query query = collection.where(Filter.and(
   
Filter.equalTo("state", "CA"),
   
Filter.or(
       
Filter.equalTo("capital", true),
       
Filter.greaterThanOrEqualTo("population", 1000000)
   
)
));
var query = db.collection("cities")
 
.where(
   
Filter.and(
     
Filter("state", isEqualTo: "CA"),
   
Filter.or(
     
Filter("capital", isEqualTo: true),
     
Filter("population", isGreaterThan: 1000000)
   
)));

Fragmento no disponible.

Fragmento no disponible.

Fragmento no disponible.

Fragmento no disponible.

const bigCitiesInCalifornia = await citiesRef
 
.where('state', '==', 'CA')
 
.where(
   
Filter.or(
     
Filter.where('capital', '==', true),
     
Filter.where('population', '>=', 1000000)
   
)
 
)
 
.get();

Fragmento no disponible.

Fragmento no disponible.

Query query = citiesRef.Where(Filter.And(
   
Filter.EqualTo("state", "CA"),
   
Filter.Or(
       
Filter.EqualTo("capital", true),
       
Filter.GreaterThanOrEqualTo("population", 1000000)
   
)
));

Fragmento no disponible.

Fragmento no disponible.

Limitaciones

Tenga en cuenta las siguientes limitaciones para consultas or :

Para obtener una descripción completa de las limitaciones, consulte Limitaciones de consultas .

Consultas de grupos de colección

Un grupo de colecciones consta de todas las colecciones con el mismo ID. De forma predeterminada, las consultas recuperan resultados de una única colección en su base de datos. Utilice una consulta de grupo de colecciones para recuperar documentos de un grupo de colecciones en lugar de de una única colección.

Por ejemplo, puedes crear un grupo de colección landmarks agregando una subcolección de puntos de referencia a cada ciudad:

import { collection, addDoc } from "firebase/firestore";  

const citiesRef = collection(db, 'cities');

await
Promise.all([
    addDoc
(collection(citiesRef, 'SF', 'landmarks'), {
        name
: 'Golden Gate Bridge',
        type
: 'bridge'
   
}),
    addDoc
(collection(citiesRef, 'SF', 'landmarks'), {
        name
: 'Legion of Honor',
        type
: 'museum'
   
}),
    addDoc
(collection(citiesRef, 'LA', 'landmarks'), {
        name
: 'Griffith Park',
        type
: 'park'
   
}),
    addDoc
(collection(citiesRef, 'LA', 'landmarks'), {
        name
: 'The Getty',
        type
: 'museum'
   
}),
    addDoc
(collection(citiesRef, 'DC', 'landmarks'), {
        name
: 'Lincoln Memorial',
        type
: 'memorial'
   
}),
    addDoc
(collection(citiesRef, 'DC', 'landmarks'), {
        name
: 'National Air and Space Museum',
        type
: 'museum'
   
}),
    addDoc
(collection(citiesRef, 'TOK', 'landmarks'), {
        name
: 'Ueno Park',
        type
: 'park'
   
}),
    addDoc
(collection(citiesRef, 'TOK', 'landmarks'), {
        name
: 'National Museum of Nature and Science',
        type
: 'museum'
   
}),
    addDoc
(collection(citiesRef, 'BJ', 'landmarks'), {
        name
: 'Jingshan Park',
        type
: 'park'
   
}),
    addDoc
(collection(citiesRef, 'BJ', 'landmarks'), {
        name
: 'Beijing Ancient Observatory',
        type
: 'museum'
   
})
]);
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'
   
})
]);
Nota: Este producto no está disponible en destinos watchOS y App Clip.
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)
Nota: Este producto no está disponible en destinos watchOS y App Clip.
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];
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)
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);
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);
CollectionReference cities = db.collection("cities");

final List<ApiFuture<WriteResult>> futures =
   
Arrays.asList(
        cities
           
.document("SF")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Golden Gate Bridge");
                    put
("type", "bridge");
                 
}
               
}),
        cities
           
.document("SF")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Legion of Honor");
                    put
("type", "museum");
                 
}
               
}),
        cities
           
.document("LA")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Griffith Park");
                    put
("type", "park");
                 
}
               
}),
        cities
           
.document("LA")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "The Getty");
                    put
("type", "museum");
                 
}
               
}),
        cities
           
.document("DC")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Lincoln Memorial");
                    put
("type", "memorial");
                 
}
               
}),
        cities
           
.document("DC")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "National Air and Space Museum");
                    put
("type", "museum");
                 
}
               
}),
        cities
           
.document("TOK")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Ueno Park");
                    put
("type", "park");
                 
}
               
}),
        cities
           
.document("TOK")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "National Museum of Nature and Science");
                    put
("type", "museum");
                 
}
               
}),
        cities
           
.document("BJ")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Jingshan Park");
                    put
("type", "park");
                 
}
               
}),
        cities
           
.document("BJ")
           
.collection("landmarks")
           
.document()
           
.set(
               
new HashMap<String, String>() {
                 
{
                    put
("name", "Beijing Ancient Observatory");
                    put
("type", "museum");
                 
}
               
}));
final List<WriteResult> landmarks = ApiFutures.allAsList(futures).get();
cities = db.collection("cities")

sf_landmarks
= cities.document("SF").collection("landmarks")
sf_landmarks
.document().set({"name": "Golden Gate Bridge", "type": "bridge"})
sf_landmarks
.document().set({"name": "Legion of Honor", "type": "museum"})
la_landmarks
= cities.document("LA").collection("landmarks")
la_landmarks
.document().set({"name": "Griffith Park", "type": "park"})
la_landmarks
.document().set({"name": "The Getty", "type": "museum"})
dc_landmarks
= cities.document("DC").collection("landmarks")
dc_landmarks
.document().set({"name": "Lincoln Memorial", "type": "memorial"})
dc_landmarks
.document().set(
   
{"name": "National Air and Space Museum", "type": "museum"}
)
tok_landmarks
= cities.document("TOK").collection("landmarks")
tok_landmarks
.document().set({"name": "Ueno Park", "type": "park"})
tok_landmarks
.document().set(
   
{"name": "National Museum of Nature and Science", "type": "museum"}
)
bj_landmarks
= cities.document("BJ").collection("landmarks")
bj_landmarks
.document().set({"name": "Jingshan Park", "type": "park"})
bj_landmarks
.document().set(
   
{"name": "Beijing Ancient Observatory", "type": "museum"}
)
cities = db.collection("cities")

sf_landmarks
= cities.document("SF").collection("landmarks")
await sf_landmarks
.document().set({"name": "Golden Gate Bridge", "type": "bridge"})
await sf_landmarks
.document().set({"name": "Legion of Honor", "type": "museum"})
la_landmarks
= cities.document("LA").collection("landmarks")
await la_landmarks
.document().set({"name": "Griffith Park", "type": "park"})
await la_landmarks
.document().set({"name": "The Getty", "type": "museum"})
dc_landmarks
= cities.document("DC").collection("landmarks")
await dc_landmarks
.document().set({"name": "Lincoln Memorial", "type": "memorial"})
await dc_landmarks
.document().set(
   
{"name": "National Air and Space Museum", "type": "museum"}
)
tok_landmarks
= cities.document("TOK").collection("landmarks")
await tok_landmarks
.document().set({"name": "Ueno Park", "type": "park"})
await tok_landmarks
.document().set(
   
{"name": "National Museum of Nature and Science", "type": "museum"}
)
bj_landmarks
= cities.document("BJ").collection("landmarks")
await bj_landmarks
.document().set({"name": "Jingshan Park", "type": "park"})
await bj_landmarks
.document().set(
   
{"name": "Beijing Ancient Observatory", "type": "museum"}
)
const citiesRef = db.collection('cities');

await citiesRef
.doc('SF').collection('landmarks').doc().set({
  name
: 'Golden Gate Bridge',
  type
: 'bridge'
});
await citiesRef
.doc('SF').collection('landmarks').doc().set({
  name
: 'Legion of Honor',
  type
: 'museum'
});
await citiesRef
.doc('LA').collection('landmarks').doc().set({
  name
: 'Griffith Park',
  type
: 'park'
});
await citiesRef
.doc('LA').collection('landmarks').doc().set({
  name
: 'The Getty',
  type
: 'museum'
});
await citiesRef
.doc('DC').collection('landmarks').doc().set({
  name
: 'Lincoln Memorial',
  type
: 'memorial'
});
await citiesRef
.doc('DC').collection('landmarks').doc().set({
  name
: 'National Air and Space Museum',
  type
: 'museum'
});
await citiesRef
.doc('TOK').collection('landmarks').doc().set({
  name
: 'Ueno Park',
  type
: 'park'
});
await citiesRef
.doc('TOK').collection('landmarks').doc().set({
  name
: 'National Museum of Nature and Science',
  type
: 'museum'
});
await citiesRef
.doc('BJ').collection('landmarks').doc().set({
  name
: 'Jingshan Park',
  type
: 'park'
});
await citiesRef
.doc('BJ').collection('landmarks').doc().set({
  name
: 'Beijing Ancient Observatory',
  type
: 'museum'
});
import (
       
"context"
       
"fmt"

       
"cloud.google.com/go/firestore"
)

// collectionGroupSetup sets up a collection group to query.
func collectionGroupSetup
(projectID, cityCollection string) error {
        ctx
:= context.Background()

        client
, err := firestore.NewClient(ctx, projectID)
       
if err != nil {
               
return fmt.Errorf("firestore.NewClient: %w", err)
       
}
        defer client
.Close()

        landmarks
:= []struct {
                city
, name, t string
       
}{
               
{"SF", "Golden Gate Bridge", "bridge"},
               
{"SF", "Legion of Honor", "museum"},
               
{"LA", "Griffith Park", "park"},
               
{"LA", "The Getty", "museum"},
               
{"DC", "Lincoln Memorial", "memorial"},
               
{"DC", "National Air and Space Museum", "museum"},
               
{"TOK", "Ueno Park", "park"},
               
{"TOK", "National Museum of Nature and Science", "museum"},
               
{"BJ", "Jingshan Park", "park"},
               
{"BJ", "Beijing Ancient Observatory", "museum"},
       
}

        cities
:= client.Collection(cityCollection)
       
for _, l := range landmarks {
               
if _, err := cities.Doc(l.city).Collection("landmarks").NewDoc().Set(ctx, map[string]string{
                       
"name": l.name,
                       
"type": l.t,
               
}); err != nil {
                       
return fmt.Errorf("Set: %w", err)
               
}
       
}

       
return nil
}
$citiesRef = $db->collection('samples/php/cities');
$citiesRef
->document('SF')->collection('landmarks')->newDocument()->set([
   
'name' => 'Golden Gate Bridge',
   
'type' => 'bridge'
]);
$citiesRef
->document('SF')->collection('landmarks')->newDocument()->set([
   
'name' => 'Legion of Honor',
   
'type' => 'museum'
]);
$citiesRef
->document('LA')->collection('landmarks')->newDocument()->set([
   
'name' => 'Griffith Park',
   
'type' => 'park'
]);
$citiesRef
->document('LA')->collection('landmarks')->newDocument()->set([
   
'name' => 'The Getty',
   
'type' => 'museum'
]);
$citiesRef
->document('DC')->collection('landmarks')->newDocument()->set([
   
'name' => 'Lincoln Memorial',
   
'type' => 'memorial'
]);
$citiesRef
->document('DC')->collection('landmarks')->newDocument()->set([
   
'name' => 'National Air and Space Museum',
   
'type' => 'museum'
]);
$citiesRef
->document('TOK')->collection('landmarks')->newDocument()->set([
   
'name' => 'Ueno Park',
   
'type' => 'park'
]);
$citiesRef
->document('TOK')->collection('landmarks')->newDocument()->set([
   
'name' => 'National Museum of Nature and Science',
   
'type' => 'museum'
]);
$citiesRef
->document('BJ')->collection('landmarks')->newDocument()->set([
   
'name' => 'Jingshan Park',
   
'type' => 'park'
]);
$citiesRef
->document('BJ')->collection('landmarks')->newDocument()->set([
   
'name' => 'Beijing Ancient Observatory',
   
'type' => 'museum'
]);
print('Added example landmarks collections to the cities collection.' . PHP_EOL);
List<Task<DocumentReference>> futures =
   
new List<Task<DocumentReference>>(){
        citiesRef
           
.Document("SF")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Golden Gate Bridge"},
                   
{"type", "bridge"},
               
}
               
),
        citiesRef
           
.Document("SF")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Legion of Honor"},
                   
{"type", "museum"},
               
}
               
),
        citiesRef
           
.Document("LA")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Griffith Park"},
                   
{"type", "park"},
               
}
               
),
        citiesRef
           
.Document("LA")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "The Getty"},
                   
{"type", "museum"},
               
}
               
),
        citiesRef
           
.Document("DC")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Lincoln Memorial"},
                   
{"type", "memorial"},
               
}
               
),
        citiesRef
           
.Document("DC")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "National Air and Space Museum"},
                   
{"type", "museum"},
               
}
               
),
        citiesRef
           
.Document("TOK")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Ueno Park"},
                   
{"type", "park"},
               
}
               
),
        citiesRef
           
.Document("TOK")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "National Museum of Nature and Science"},
                   
{"type", "museum"},
               
}
               
),
        citiesRef
           
.Document("BJ")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Jingshan Park"},
                   
{"type", "park"},
               
}
               
),
        citiesRef
           
.Document("BJ")
           
.Collection("landmarks")
           
.AddAsync(
               
new Dictionary<string, object>()
               
{
                   
{"name", "Beijing Ancient Observatory"},
                   
{"type", "museum"},
               
}
               
)};
DocumentReference[] landmarks = Task.WhenAll(futures).Result;
// Copyright(c) 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

using Google.Cloud.Firestore;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace GoogleCloudSamples
{
   
public class QueryData
   
{
       
public static string Usage = @"Usage:
C:\> dotnet run command YOUR_PROJECT_ID

Where command is one of
    query-create-examples
    create-query-state
    create-query-capital
    simple-queries
    array-contains-query
    array-contains-any-query
    in-query
    in-query-array
    collection-group-query
    chained-query
    composite-index-chained-query
    range-query
    invalid-range-query
"
;
       
private static async Task QueryCreateExamples(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
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.");
       
}

       
private static async Task CreateQueryState(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
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);
           
}
       
}

       
private static async Task CreateQueryCapital(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
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);
           
}
       
}

       
private static async Task SimpleQueries(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query stateQuery = citiesRef.WhereEqualTo("State", "CA");
           
Query populationQuery = citiesRef.WhereGreaterThan("Population", 1000000);
           
Query nameQuery = citiesRef.WhereGreaterThanOrEqualTo("Name", "San Francisco");
           
QuerySnapshot stateQuerySnapshot = await stateQuery.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in stateQuerySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query State=CA", documentSnapshot.Id);
           
}
           
QuerySnapshot populationQuerySnapshot = await populationQuery.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in populationQuerySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query Population>1000000", documentSnapshot.Id);
           
}
           
QuerySnapshot nameQuerySnapshot = await nameQuery.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in nameQuerySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query Name>=San Francisco", documentSnapshot.Id);
           
}
       
}

       
private static async Task ArrayContainsQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query query = citiesRef.WhereArrayContains("Regions", "west_coast");
           
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query 'Regions array_contains west_coast'", documentSnapshot.Id);
           
}
       
}

       
private static async Task ArrayContainsAnyQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query query = citiesRef.WhereArrayContainsAny("Regions", new[] { "west_coast", "east_coast" });
           
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query 'Regions array_contains_any {{west_coast, east_coast}}'", documentSnapshot.Id);
           
}
       
}

       
private static async Task InQueryWithoutArray(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query query = citiesRef.WhereIn("Country", new[] { "USA", "Japan" });
           
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query 'Country in {{USA, Japan}}'", documentSnapshot.Id);
           
}
       
}

       
private static async Task InQueryWithArray(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query query = citiesRef.WhereIn("Regions",
               
new[] { new[] { "west_coast" }, new[] { "east_coast" } });
           
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query 'Regions in {{west_coast}}, {{east_coast}}'", documentSnapshot.Id);
           
}
       
}

       
private static async Task CollectionGroupQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
            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" });

           
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")}");
           
}
       
}

       
private static async Task ChainedQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query chainedQuery = citiesRef
               
.WhereEqualTo("State", "CA")
               
.WhereEqualTo("Name", "San Francisco");
           
QuerySnapshot querySnapshot = await chainedQuery.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query State=CA and Name=San Francisco", documentSnapshot.Id);
           
}
       
}

       
private static async Task CompositeIndexChainedQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query chainedQuery = citiesRef
               
.WhereEqualTo("State", "CA")
               
.WhereLessThan("Population", 1000000);
           
QuerySnapshot querySnapshot = await chainedQuery.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query State=CA and Population<1000000", documentSnapshot.Id);
           
}
       
}

       
private static async Task RangeQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query rangeQuery = citiesRef
               
.WhereGreaterThanOrEqualTo("State", "CA")
               
.WhereLessThanOrEqualTo("State", "IN");
           
QuerySnapshot querySnapshot = await rangeQuery.GetSnapshotAsync();
           
foreach (DocumentSnapshot documentSnapshot in querySnapshot.Documents)
           
{
               
Console.WriteLine("Document {0} returned by query CA<=State<=IN", documentSnapshot.Id);
           
}
       
}

       
private static void InvalidRangeQuery(string project)
       
{
           
FirestoreDb db = FirestoreDb.Create(project);
           
CollectionReference citiesRef = db.Collection("cities");
           
Query invalidRangeQuery = citiesRef
               
.WhereGreaterThanOrEqualTo("State", "CA")
               
.WhereGreaterThan("Population", 1000000);
       
}

       
public static void Main(string[] args)
       
{
           
if (args.Length < 2)
           
{
               
Console.Write(Usage);
               
return;
           
}
           
string command = args[0].ToLower();
           
string project = string.Join(" ",
               
new ArraySegment<string>(args, 1, args.Length - 1));
           
switch (command)
           
{
               
case "query-create-examples":
                   
QueryCreateExamples(project).Wait();
                   
break;

               
case "create-query-state":
                   
CreateQueryState(project).Wait();
                   
break;

               
case "create-query-capital":
                   
CreateQueryCapital(project).Wait();
                   
break;

               
case "simple-queries":
                   
SimpleQueries(project).Wait();
                   
break;

               
case "array-contains-query":
                   
ArrayContainsQuery(project).Wait();
                   
break;

               
case "array-contains-any-query":
                   
ArrayContainsAnyQuery(project).Wait();
                   
break;

               
case "in-query":
                   
InQueryWithoutArray(project).Wait();
                   
break;

               
case "in-query-array":
                   
InQueryWithArray(project).Wait();
                   
break;

               
case "collection-group-query":
                   
CollectionGroupQuery(project).Wait();
                   
break;

               
case "chained-query":
                   
ChainedQuery(project).Wait();
                   
break;

               
case "composite-index-chained-query":
                   
CompositeIndexChainedQuery(project).Wait();
                   
break;

               
case "range-query":
                   
RangeQuery(project).Wait();
                   
break;

               
case "invalid-range-query":
                   
InvalidRangeQuery(project);
                   
break;

               
default:
                   
Console.Write(Usage);
                   
return;
           
}
       
}
   
}
}
cities_ref = firestore.col collection_path

sf_landmarks
= cities_ref.document("SF").collection("landmarks")
sf_landmarks
.document.set(
 
{
    name
: "Golden Gate Bridge",
    type
: "bridge"
 
}
)
sf_landmarks
.document.set(
 
{
    name
: "Legion of Honor",
    type
: "museum"
 
}
)

la_landmarks
= cities_ref.document("LA").collection("landmarks")
la_landmarks
.document.set(
 
{
    name
: "Griffith Park",
    type
: "park"
 
}
)
la_landmarks
.document.set(
 
{
    name
: "The Getty",
    type
: "museum"
 
}
)

dc_landmarks
= cities_ref.document("DC").collection("landmarks")
dc_landmarks
.document.set(
 
{
    name
: "Lincoln Memorial",
    type
: "memorial"
 
}
)
dc_landmarks
.document.set(
 
{
    name
: "National Air and Space Museum",
    type
: "museum"
 
}
)

tok_landmarks
= cities_ref.document("TOK").collection("landmarks")
tok_landmarks
.document.set(
 
{
    name
: "Ueno Park",
    type
: "park"
 
}
)
tok_landmarks
.document.set(
 
{
    name
: "National Museum of Nature and Science",
    type
: "museum"
 
}
)

bj_landmarks
= cities_ref.document("BJ").collection("landmarks")
bj_landmarks
.document.set(
 
{
    name
: "Jingshan Park",
    type
: "park"
 
}
)
bj_landmarks
.document.set(
 
{
    name
: "Beijing Ancient Observatory",
    type
: "museum"
 
}
)

Podemos utilizar la consulta simple y compuesta descrita anteriormente para consultar la subcolección landmarks de una sola ciudad, pero es posible que también desee recuperar los resultados de la subcolección de landmarks de cada ciudad a la vez.

El grupo de colección de landmarks consta de todas las colecciones con ID landmarks y puede consultarlo mediante una consulta de grupo de colección. Por ejemplo, esta consulta de grupo de colecciones recupera todos los puntos de interés museum en todas las ciudades:

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());
});
var museums = db.collectionGroup('landmarks').where('type', '==', 'museum');
museums
.get().then((querySnapshot) => {
    querySnapshot
.forEach((doc) => {
        console
.log(doc.id, ' => ', doc.data());
   
});
});
Nota: Este producto no está disponible en destinos watchOS y App Clip.
db.collectionGroup("landmarks").whereField("type", isEqualTo: "museum").getDocuments { (snapshot, error) in
 
// ...
}
Nota: Este producto no está disponible en destinos watchOS y App Clip.
[[[self.db collectionGroupWithID:@"landmarks"] queryWhereField:@"type" isEqualTo:@"museum"]
    getDocumentsWithCompletion
:^(FIRQuerySnapshot *snapshot, NSError *error) {
   
// ...
}];
db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
   
.addOnSuccessListener { queryDocumentSnapshots ->
       
// ...
   
}
db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
       
.addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
           
@Override
           
public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
               
// ...
           
}
       
});
db
   
.collectionGroup("landmarks")
   
.where("type", isEqualTo: "museum")
   
.get()
   
.then(
     
(res) => print("Successfully completed"),
      onError
: (e) => print("Error completing: $e"),
   
);
final Query museums = db.collectionGroup("landmarks").whereEqualTo("type", "museum");
final ApiFuture<QuerySnapshot> querySnapshot = museums.get();
for (DocumentSnapshot document : querySnapshot.get().getDocuments()) {
 
System.out.println(document.getId());
}
museums = db.collection_group("landmarks").where(
    filter
=FieldFilter("type", "==", "museum")
)
docs
= museums.stream()
for doc in docs:
   
print(f"{doc.id} => {doc.to_dict()}")
museums = db.collection_group("landmarks").where(
    filter
=FieldFilter("type", "==", "museum")
)
docs
= museums.stream()
async
for doc in docs:
   
print(f"{doc.id} => {doc.to_dict()}")
const querySnapshot = await db.collectionGroup('landmarks').where('type', '==', 'museum').get();
querySnapshot
.forEach((doc) => {
  console
.log(doc.id, ' => ', doc.data());
});
import (
       
"context"
       
"fmt"
       
"io"

       
"cloud.google.com/go/firestore"
       
"google.golang.org/api/iterator"
)

// collectionGroupQuery runs a collection group query over the data created by
// collectionGroupSetup.
func collectionGroupQuery
(w io.Writer, projectID string) error {
        ctx
:= context.Background()

        client
, err := firestore.NewClient(ctx, projectID)
       
if err != nil {
               
return fmt.Errorf("firestore.NewClient: %w", err)
       
}
        defer client
.Close()

        it
:= client.CollectionGroup("landmarks").Where("type", "==", "museum").Documents(ctx)
       
for {
                doc
, err := it.Next()
               
if err == iterator.Done {
                       
break
               
}
               
if err != nil {
                       
return fmt.Errorf("documents iterator: %w", err)
               
}
                fmt
.Fprintf(w, "%s: %s", doc.Ref.ID, doc.Data()["name"])
       
}

       
return nil
}
$museums = $db->collectionGroup('landmarks')->where('type', '==', 'museum');
foreach ($museums->documents() as $document) {
    printf
('%s => %s' . PHP_EOL, $document->id(), $document->data()['name']);
}
Query museums = db.CollectionGroup("landmarks").WhereEqualTo("type", "museum");
museums
.GetSnapshotAsync().ContinueWithOnMainThread((querySnapshotTask) =>
{
   
foreach (DocumentSnapshot documentSnapshot in querySnapshotTask.Result.Documents)
   
{
       
Debug.Log(String.Format("Document {0} returned by query State=CA", documentSnapshot.Id));
   
}
});
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")}");
}
museums = firestore.collection_group("landmarks").where("type", "==", "museum")
museums
.get do |museum|
  puts
"#{museum[:type]} name is #{museum[:name]}."
end

Antes de utilizar una consulta de grupo de colección, debe crear un índice que admita su consulta de grupo de colección. Puedes crear un índice a través de un mensaje de error, la consola o Firebase CLI .

Para los SDK web y móvil, también debe crear reglas que permitan las consultas del grupo de recopilación .

Limitaciones de consulta

La siguiente lista resume las limitaciones de las consultas de Cloud Firestore:

  • Cloud Firestore brinda soporte para consultas OR lógicas a través de los operadores or , in y array-contains-any . Estas consultas están limitadas a 30 disyunciones basadas en la forma normal disyuntiva de la consulta .
  • En una consulta compuesta, las comparaciones de rango ( < , <= , > , >= ) y no iguales ( != , not-in ) deben filtrarse en el mismo campo.
  • Puede utilizar como máximo una array-contains matriz por disyunción ( or grupo). No puede combinar array-contains con array-contains-any en la misma disyunción.
  • No puede combinar not-in con in , array-contains-any o or en la misma consulta.
  • Solo se permite un único not-in o != ` por consulta.
  • not-in admite hasta 10 valores de comparación.
  • La suma de filtros, criterios de clasificación y ruta del documento principal (1 para una subcolección, 0 para una colección raíz) en una consulta no puede exceder 100. Esto se calcula en función de la forma normal disyuntiva de la consulta .
  • Una consulta con un filtro de desigualdad en un campo implica ordenar por ese campo y filtrar por la existencia de ese campo .

Límites en consultas OR

Para evitar que una consulta se vuelva demasiado costosa desde el punto de vista computacional, Cloud Firestore limita la cantidad de cláusulas AND y OR que puedes combinar. Para aplicar este límite, Cloud Firestore convierte las consultas que realizan operaciones OR lógicas ( or , in y array-contains-any ) a la forma normal disyuntiva (también conocida como OR de AND ). Cloud Firestore limita una consulta a un máximo de 30 disyunciones en forma normal disyuntiva.

Forma normal disyuntiva

Cloud Firestore convierte las consultas a la forma normal disyuntiva aplicando dos reglas:

  • Aplanar

    Dadas las condiciones A , B y C :

    A and (B and C) => A and B and C

  • Ley distributiva

    Dadas las condiciones A , B , C y D :

    • A and (B or C) => (A and B) or (A and C)
    • (A or B) and (C or D) => (A and C) or (A and D) or (B and C) or (B and D)

Al aplicar estas reglas a consultas in y array-contains-any , recuerde que estos operadores son abreviaturas de OR . Por ejemplo, a in [1,2] es una abreviatura de a = 1 OR a = 2 .

Los siguientes ejemplos muestran el número de disyunciones para diferentes consultas:

Consulta Número de disyunciones
query(collectionRef, where("a", "==", 1))
     
1
query(collectionRef, or( where("a", "==", 1), where("b", "==", 2) ))
     
2
query(collectionRef,
       
or( and( where("a", "==", 1), where("c", "==", 3) ),
           
and( where("a", "==", 1), where("d", "==", 4) ),
           
and( where("b", "==", 2), where("c", "==", 3) ),
           
and( where("b", "==", 2), where("d", "==", 4) )
       
)
     
)
     
4
query(collectionRef,
       
and( or( where("a", "==", 1), where("b", "==", 2) ),
             
or( where("c", "==", 3), where("d", "==", 4) )
       
)
     
)
     

4

La forma normal disyuntiva de esta consulta es igual a la consulta anterior.

query(collectionRef, where("a", "in", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) )
     
10
query(collectionRef,
       
and( where("a", "in", [1, 2, 3, 4, 5]),
             
where("b", "in", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
       
)
     
)
     

50

Esta consulta devuelve un error porque supera el límite de 30 disyunciones.

query(collectionRef,
       
or( where("a", "in", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
           
where("b", "in", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
       
)
     
)
     
20
query(collectionRef,
       
and( where("a", "in", [1, 2, 3, 4, 5]),
             
or( where("b", "==", 2),
                 
where("c", "==", 3)
             
)
       
)
     
)
     
10

orderBy y existencia

Cuando ordena una consulta por un campo determinado, la consulta puede devolver solo los documentos donde existe el campo ordenar por.

Por ejemplo, la siguiente consulta no devolverá ningún documento donde el campo population no esté configurado, incluso si cumplen con los filtros de consulta.

Java
db.collection("cities").whereEqualTo("country", USA”).orderBy(“population”);

Un efecto relacionado se aplica a las desigualdades. Una consulta con un filtro de desigualdad en un campo también implica ordenar por ese campo. La siguiente consulta no devuelve documentos sin un campo population incluso si country = USA en ese documento. Como solución alternativa, puede ejecutar consultas separadas para cada pedido o puede asignar un valor para todos los campos por los que ordena.

Java
db.collection(“cities”).where(or(“country”, USA”), greaterThan(“population”, 250000));

La consulta anterior incluye un orden implícito en la desigualdad y es equivalente a lo siguiente:

Java
db.collection(“cities”).where(or(“country”, USA”), greaterThan(“population”, 250000)).orderBy(“population”);

Que sigue