Cloud Firestore में सरल और मिश्रित क्वेरी निष्पादित करें

क्लाउड फायरस्टोर यह निर्दिष्ट करने के लिए शक्तिशाली क्वेरी कार्यक्षमता प्रदान करता है कि आप संग्रह या संग्रह समूह से कौन से दस्तावेज़ पुनर्प्राप्त करना चाहते हैं। इन प्रश्नों का उपयोग get() या addSnapshotListener() के साथ भी किया जा सकता है, जैसा कि Get Data और Get Realtime Updates में वर्णित है।

उदाहरण डेटा

आरंभ करने के लिए, शहरों के बारे में कुछ डेटा लिखें ताकि हम इसे वापस पढ़ने के विभिन्न तरीकों को देख सकें:

Web version 9

import { collection, doc, setDoc } from "firebase/firestore"; 

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

await setDoc(doc(citiesRef, "SF"), {
    name: "San Francisco", state: "CA", country: "USA",
    capital: false, population: 860000,
    regions: ["west_coast", "norcal"] });
await setDoc(doc(citiesRef, "LA"), {
    name: "Los Angeles", state: "CA", country: "USA",
    capital: false, population: 3900000,
    regions: ["west_coast", "socal"] });
await setDoc(doc(citiesRef, "DC"), {
    name: "Washington, D.C.", state: null, country: "USA",
    capital: true, population: 680000,
    regions: ["east_coast"] });
await setDoc(doc(citiesRef, "TOK"), {
    name: "Tokyo", state: null, country: "Japan",
    capital: true, population: 9000000,
    regions: ["kanto", "honshu"] });
await setDoc(doc(citiesRef, "BJ"), {
    name: "Beijing", state: null, country: "China",
    capital: true, population: 21500000,
    regions: ["jingjinji", "hebei"] });

Web version 8

var citiesRef = db.collection("cities");

citiesRef.doc("SF").set({
    name: "San Francisco", state: "CA", country: "USA",
    capital: false, population: 860000,
    regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
    name: "Los Angeles", state: "CA", country: "USA",
    capital: false, population: 3900000,
    regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
    name: "Washington, D.C.", state: null, country: "USA",
    capital: true, population: 680000,
    regions: ["east_coast"] });
citiesRef.doc("TOK").set({
    name: "Tokyo", state: null, country: "Japan",
    capital: true, population: 9000000,
    regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
    name: "Beijing", state: null, country: "China",
    capital: true, population: 21500000,
    regions: ["jingjinji", "hebei"] });
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
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"]
    ])
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];
[[citiesRef documentWithPath:@"SF"] setData:@{
  @"name": @"San Francisco",
  @"state": @"CA",
  @"country": @"USA",
  @"capital": @(NO),
  @"population": @860000,
  @"regions": @[@"west_coast", @"norcal"]
}];
[[citiesRef documentWithPath:@"LA"] setData:@{
  @"name": @"Los Angeles",
  @"state": @"CA",
  @"country": @"USA",
  @"capital": @(NO),
  @"population": @3900000,
  @"regions": @[@"west_coast", @"socal"]
}];
[[citiesRef documentWithPath:@"DC"] setData:@{
  @"name": @"Washington D.C.",
  @"country": @"USA",
  @"capital": @(YES),
  @"population": @680000,
  @"regions": @[@"east_coast"]
}];
[[citiesRef documentWithPath:@"TOK"] setData:@{
  @"name": @"Tokyo",
  @"country": @"Japan",
  @"capital": @(YES),
  @"population": @9000000,
  @"regions": @[@"kanto", @"honshu"]
}];
[[citiesRef documentWithPath:@"BJ"] setData:@{
  @"name": @"Beijing",
  @"country": @"China",
  @"capital": @(YES),
  @"population": @21500000,
  @"regions": @[@"jingjinji", @"hebei"]
}];

Java

CollectionReference cities = db.collection("cities");

Map<String, Object> data1 = new HashMap<>();
data1.put("name", "San Francisco");
data1.put("state", "CA");
data1.put("country", "USA");
data1.put("capital", false);
data1.put("population", 860000);
data1.put("regions", Arrays.asList("west_coast", "norcal"));
cities.document("SF").set(data1);

Map<String, Object> data2 = new HashMap<>();
data2.put("name", "Los Angeles");
data2.put("state", "CA");
data2.put("country", "USA");
data2.put("capital", false);
data2.put("population", 3900000);
data2.put("regions", Arrays.asList("west_coast", "socal"));
cities.document("LA").set(data2);

Map<String, Object> data3 = new HashMap<>();
data3.put("name", "Washington D.C.");
data3.put("state", null);
data3.put("country", "USA");
data3.put("capital", true);
data3.put("population", 680000);
data3.put("regions", Arrays.asList("east_coast"));
cities.document("DC").set(data3);

Map<String, Object> data4 = new HashMap<>();
data4.put("name", "Tokyo");
data4.put("state", null);
data4.put("country", "Japan");
data4.put("capital", true);
data4.put("population", 9000000);
data4.put("regions", Arrays.asList("kanto", "honshu"));
cities.document("TOK").set(data4);

Map<String, Object> data5 = new HashMap<>();
data5.put("name", "Beijing");
data5.put("state", null);
data5.put("country", "China");
data5.put("capital", true);
data5.put("population", 21500000);
data5.put("regions", Arrays.asList("jingjinji", "hebei"));
cities.document("BJ").set(data5);

Kotlin+KTX

val cities = db.collection("cities")

val data1 = hashMapOf(
        "name" to "San Francisco",
        "state" to "CA",
        "country" to "USA",
        "capital" to false,
        "population" to 860000,
        "regions" to listOf("west_coast", "norcal")
)
cities.document("SF").set(data1)

val data2 = hashMapOf(
        "name" to "Los Angeles",
        "state" to "CA",
        "country" to "USA",
        "capital" to false,
        "population" to 3900000,
        "regions" to listOf("west_coast", "socal")
)
cities.document("LA").set(data2)

val data3 = hashMapOf(
        "name" to "Washington D.C.",
        "state" to null,
        "country" to "USA",
        "capital" to true,
        "population" to 680000,
        "regions" to listOf("east_coast")
)
cities.document("DC").set(data3)

val data4 = hashMapOf(
        "name" to "Tokyo",
        "state" to null,
        "country" to "Japan",
        "capital" to true,
        "population" to 9000000,
        "regions" to listOf("kanto", "honshu")
)
cities.document("TOK").set(data4)

val data5 = hashMapOf(
        "name" to "Beijing",
        "state" to null,
        "country" to "China",
        "capital" to true,
        "population" to 21500000,
        "regions" to listOf("jingjinji", "hebei")
)
cities.document("BJ").set(data5)

Dart

final cities = db.collection("cities");
final data1 = <String, dynamic>{
  "name": "San Francisco",
  "state": "CA",
  "country": "USA",
  "capital": false,
  "population": 860000,
  "regions": ["west_coast", "norcal"]
};
cities.doc("SF").set(data1);

final data2 = <String, dynamic>{
  "name": "Los Angeles",
  "state": "CA",
  "country": "USA",
  "capital": false,
  "population": 3900000,
  "regions": ["west_coast", "socal"],
};
cities.doc("LA").set(data2);

final data3 = <String, dynamic>{
  "name": "Washington D.C.",
  "state": null,
  "country": "USA",
  "capital": true,
  "population": 680000,
  "regions": ["east_coast"]
};
cities.doc("DC").set(data3);

final data4 = <String, dynamic>{
  "name": "Tokyo",
  "state": null,
  "country": "Japan",
  "capital": true,
  "population": 9000000,
  "regions": ["kanto", "honshu"]
};
cities.doc("TOK").set(data4);

final data5 = <String, dynamic>{
  "name": "Beijing",
  "state": null,
  "country": "China",
  "capital": true,
  "population": 21500000,
  "regions": ["jingjinji", "hebei"],
};
cities.doc("BJ").set(data5);
जावा
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(object):
    def __init__(self, name, state, country, capital=False, population=0,
                 regions=[]):
        self.name = name
        self.state = state
        self.country = country
        self.capital = capital
        self.population = population
        self.regions = regions

    @staticmethod
    def from_dict(source):
        # ...

    def to_dict(self):
        # ...

    def __repr__(self):
        return (
            f'City(\
                name={self.name}, \
                country={self.country}, \
                population={self.population}, \
                capital={self.capital}, \
                regions={self.regions}\
            )'
        )
cities_ref = db.collection(u'cities')
cities_ref.document(u'BJ').set(
    City(u'Beijing', None, u'China', True, 21500000, [u'hebei']).to_dict())
cities_ref.document(u'SF').set(
    City(u'San Francisco', u'CA', u'USA', False, 860000,
         [u'west_coast', u'norcal']).to_dict())
cities_ref.document(u'LA').set(
    City(u'Los Angeles', u'CA', u'USA', False, 3900000,
         [u'west_coast', u'socal']).to_dict())
cities_ref.document(u'DC').set(
    City(u'Washington D.C.', None, u'USA', True, 680000,
         [u'east_coast']).to_dict())
cities_ref.document(u'TOK').set(
    City(u'Tokyo', None, u'Japan', True, 9000000,
         [u'kanto', u'honshu']).to_dict())

Python

class City(object):
    def __init__(self, name, state, country, capital=False, population=0, regions=[]):
        self.name = name
        self.state = state
        self.country = country
        self.capital = capital
        self.population = population
        self.regions = regions

    @staticmethod
    def from_dict(source):
        # ...

    def to_dict(self):
        # ...

    def __repr__(self):
        return f"City(\
                name={self.name}, \
                country={self.country}, \
                population={self.population}, \
                capital={self.capital}, \
                regions={self.regions}\
            )"
cities_ref = db.collection("cities")
await cities_ref.document("BJ").set(
    City("Beijing", None, "China", True, 21500000, ["hebei"]).to_dict()
)
await cities_ref.document("SF").set(
    City(
        "San Francisco", "CA", "USA", False, 860000, ["west_coast", "norcal"]
    ).to_dict()
)
await cities_ref.document("LA").set(
    City(
        "Los Angeles", "CA", "USA", False, 3900000, ["west_coast", "socal"]
    ).to_dict()
)
await cities_ref.document("DC").set(
    City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()
)
await cities_ref.document("TOK").set(
    City("Tokyo", None, "Japan", True, 9000000, ["kanto", "honshu"]).to_dict()
)
सी++
CollectionReference cities = db->Collection("cities");

cities.Document("SF").Set({
    {"name", FieldValue::String("San Francisco")},
    {"state", FieldValue::String("CA")},
    {"country", FieldValue::String("USA")},
    {"capital", FieldValue::Boolean(false)},
    {"population", FieldValue::Integer(860000)},
    {"regions", FieldValue::Array({FieldValue::String("west_coast"),
                                   FieldValue::String("norcal")})},
});

cities.Document("LA").Set({
    {"name", FieldValue::String("Los Angeles")},
    {"state", FieldValue::String("CA")},
    {"country", FieldValue::String("USA")},
    {"capital", FieldValue::Boolean(false)},
    {"population", FieldValue::Integer(3900000)},
    {"regions", FieldValue::Array({FieldValue::String("west_coast"),
                                   FieldValue::String("socal")})},
});

cities.Document("DC").Set({
    {"name", FieldValue::String("Washington D.C.")},
    {"state", FieldValue::Null()},
    {"country", FieldValue::String("USA")},
    {"capital", FieldValue::Boolean(true)},
    {"population", FieldValue::Integer(680000)},
    {"regions",
     FieldValue::Array({FieldValue::String("east_coast")})},
});

cities.Document("TOK").Set({
    {"name", FieldValue::String("Tokyo")},
    {"state", FieldValue::Null()},
    {"country", FieldValue::String("Japan")},
    {"capital", FieldValue::Boolean(true)},
    {"population", FieldValue::Integer(9000000)},
    {"regions", FieldValue::Array({FieldValue::String("kanto"),
                                   FieldValue::String("honshu")})},
});

cities.Document("BJ").Set({
    {"name", FieldValue::String("Beijing")},
    {"state", FieldValue::Null()},
    {"country", FieldValue::String("China")},
    {"capital", FieldValue::Boolean(true)},
    {"population", FieldValue::Integer(21500000)},
    {"regions", FieldValue::Array({FieldValue::String("jingjinji"),
                                   FieldValue::String("hebei")})},
});
Node.js
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"]
  }
)

सरल प्रश्न

निम्नलिखित क्वेरी राज्य CA वाले सभी शहरों को लौटाती है:

Web version 9

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

// Create a query against the collection.
const q = query(citiesRef, where("state", "==", "CA"));

Web version 8

// Create a reference to the cities collection
var citiesRef = db.collection("cities");

// Create a query against the collection.
var query = citiesRef.where("state", "==", "CA");
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
// 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")
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
// Create a reference to the cities collection
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];
// Create a query against the collection.
FIRQuery *query = [citiesRef queryWhereField:@"state" isEqualTo:@"CA"];

Java

// Create a reference to the cities collection
CollectionReference citiesRef = db.collection("cities");

// Create a query against the collection.
Query query = citiesRef.whereEqualTo("state", "CA");

Kotlin+KTX

// Create a reference to the cities collection
val citiesRef = db.collection("cities")

// Create a query against the collection.
val query = citiesRef.whereEqualTo("state", "CA")

Dart

// Create a reference to the cities collection
final citiesRef = db.collection("cities");

// Create a query against the collection.
final query = citiesRef.where("state", isEqualTo: "CA");
जावा
// 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(u'cities')

# Create a query against the collection
query_ref = cities_ref.where(u'state', u'==', u'CA')

Python

# Create a reference to the cities collection
cities_ref = db.collection("cities")

# Create a query against the collection
query_ref = cities_ref.where("state", "==", "CA")
सी++
CollectionReference cities_ref = db->Collection("cities");
// Create a query against the collection.
Query query_ca =
    cities_ref.WhereEqualTo("state", FieldValue::String("CA"));
Node.js
// 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

निम्नलिखित क्वेरी सभी राजधानी शहरों को लौटाती है:

Web version 9

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

const q = query(citiesRef, where("capital", "==", true));

Web version 8

var citiesRef = db.collection("cities");

var query = citiesRef.where("capital", "==", true);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
FIRQuery *capitalCities =
    [[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@YES];

Java

Query capitalCities = db.collection("cities").whereEqualTo("capital", true);

Kotlin+KTX

val capitalCities = db.collection("cities").whereEqualTo("capital", true)

Dart

final capitalcities =
    db.collection("cities").where("capital", isEqualTo: true);
जावा
// 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(u'cities')

query = cities_ref.where(u'capital', u'==', True)

Python

cities_ref = db.collection("cities")

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

// Create a query against the collection
const allCapitalsRes = await citiesRef.where('capital', '==', true).get();
जाओ
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

एक क्वेरी निष्पादित करें

क्वेरी ऑब्जेक्ट बनाने के बाद, परिणाम प्राप्त करने के लिए get() फ़ंक्शन का उपयोग करें:

Web version 9

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

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

const querySnapshot = await getDocs(q);
querySnapshot.forEach((doc) => {
  // doc.data() is never undefined for query doc snapshots
  console.log(doc.id, " => ", doc.data());
});

Web version 8

db.collection("cities").where("capital", "==", true)
    .get()
    .then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            // doc.data() is never undefined for query doc snapshots
            console.log(doc.id, " => ", doc.data());
        });
    })
    .catch((error) => {
        console.log("Error getting documents: ", error);
    });
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
db.collection("cities").whereField("capital", isEqualTo: true)
    .getDocuments() { (querySnapshot, err) in
        if let err = err {
            print("Error getting documents: \(err)")
        } else {
            for document in querySnapshot!.documents {
                print("\(document.documentID) => \(document.data())")
            }
        }
}
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[[[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@(YES)]
    getDocumentsWithCompletion:^(FIRQuerySnapshot *snapshot, NSError *error) {
      if (error != nil) {
        NSLog(@"Error getting documents: %@", error);
      } else {
        for (FIRDocumentSnapshot *document in snapshot.documents) {
          NSLog(@"%@ => %@", document.documentID, document.data);
        }
      }
    }];

Java

db.collection("cities")
        .whereEqualTo("capital", true)
        .get()
        .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
            @Override
            public void onComplete(@NonNull Task<QuerySnapshot> task) {
                if (task.isSuccessful()) {
                    for (QueryDocumentSnapshot document : task.getResult()) {
                        Log.d(TAG, document.getId() + " => " + document.getData());
                    }
                } else {
                    Log.d(TAG, "Error getting documents: ", task.getException());
                }
            }
        });

Kotlin+KTX

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

Dart

db.collection("cities").where("capital", isEqualTo: true).get().then(
      (res) => print("Successfully completed"),
      onError: (e) => print("Error completing: $e"),
    );
जावा
// 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(u'cities').where(u'capital', u'==', True).stream()

for doc in docs:
    print(f'{doc.id} => {doc.to_dict()}')

Python

# Note: Use of CollectionRef stream() is prefered to get()
docs = db.collection("cities").where("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;
      }
    });
Node.js
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());
});
जाओ
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())
}
पीएचपी
$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

क्वेरी परिणाम प्राप्त करने के बारे में अधिक जानकारी के लिए डेटा प्राप्त करें देखें। वर्तमान परिणाम प्राप्त करने और भविष्य के अपडेट सुनने के लिए आप एक श्रोता को एक क्वेरी में जोड़ सकते हैं।

क्वेरी ऑपरेटर

where() विधि तीन पैरामीटर लेती है: फ़िल्टर करने के लिए एक फ़ील्ड, एक तुलना ऑपरेटर, और एक मान। क्लाउड फायरस्टोर निम्नलिखित तुलना ऑपरेटरों का समर्थन करता है:

उदाहरण के लिए:

Web version 9

const stateQuery = query(citiesRef, where("state", "==", "CA"));
const populationQuery = query(citiesRef, where("population", "<", 100000));
const nameQuery = query(citiesRef, where("name", ">=", "San Francisco"));

Web version 8

const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")
let populationQuery = citiesRef.whereField("population", isLessThan: 100000)
let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
FIRQuery *stateQuery = [citiesRef queryWhereField:@"state" isEqualTo:@"CA"];
FIRQuery *populationQuery = [citiesRef queryWhereField:@"population" isLessThan:@100000];
FIRQuery *nameQuery = [citiesRef queryWhereField:@"name" isGreaterThanOrEqualTo:@"San Francisco"];

Java

Query stateQuery = citiesRef.whereEqualTo("state", "CA");
Query populationQuery = citiesRef.whereLessThan("population", 100000);
Query nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco");

Kotlin+KTX

val stateQuery = citiesRef.whereEqualTo("state", "CA")
val populationQuery = citiesRef.whereLessThan("population", 100000)
val nameQuery = citiesRef.whereGreaterThanOrEqualTo("name", "San Francisco")

Dart

final citiesRef = db.collection("cities");
final stateQuery = citiesRef.where("state", isEqualTo: "CA");
final populationQuery = citiesRef.where("population", isLessThan: 100000);
final nameQuery = citiesRef.where("name", isEqualTo: "San Francisco");
जावा
Query stateQuery = cities.whereEqualTo("state", "CA");
Query populationQuery = cities.whereLessThan("population", 1000000L);
Query nameQuery = cities.whereGreaterThanOrEqualTo("name", "San Francisco");
अजगर
cities_ref = db.collection(u'cities')

cities_ref.where(u'state', u'==', u'CA')
cities_ref.where(u'population', u'<', 1000000)
cities_ref.where(u'name', u'>=', u'San Francisco')

Python

cities_ref = db.collection("cities")

cities_ref.where("state", "==", "CA")
cities_ref.where("population", "<", 1000000)
cities_ref.where("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"));
Node.js
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");
सी#
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"

बराबर नहीं ( != )

दस्तावेज़ों को वापस करने के लिए बराबर नहीं ( != ) ऑपरेटर का उपयोग करें जहां दिया गया फ़ील्ड मौजूद है और तुलना मूल्य से मेल नहीं खाता है। उदाहरण के लिए:

Web version 9

const notCapitalQuery = query(citiesRef, where("capital", "!=", false));

Web version 8

citiesRef.where("capital", "!=", false);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
query = [citiesRef queryWhereField:@"capital" isNotEqualTo:@NO];

Java

Query notCapitalQuery = citiesRef.whereNotEqualTo("capital", false);

Kotlin+KTX

val notCapitalQuery = citiesRef.whereNotEqualTo("capital", false)

Dart

final citiesRef = db.collection("cities");
final notCapitals = citiesRef.where("capital", isNotEqualTo: true);
जावा
CollectionReference citiesRef = db.collection("cities");

Query query = citiesRef.whereNotEqualTo("capital", false);
अजगर
// Snippet not yet available
सी++
// Snippet not yet available
Node.js
const capitalNotFalseRes = await citiesRef.where('capital', '!=', false).get();
जाओ
// Snippet not yet available
पीएचपी
$stateQuery = $citiesRef->where('capital', '!=', false);
एकता
// Snippet not yet available
सी#
// Snippet not yet available
माणिक
cities_ref = firestore.col collection_path
query = cities_ref.where "capital", "!=", false

यह क्वेरी हर city के दस्तावेज़ को लौटाती है जहाँ capital फ़ील्ड false या null के अलावा किसी अन्य मान के साथ मौजूद है। इसमें city के दस्तावेज़ शामिल हैं जहां capital फ़ील्ड मान true के बराबर है या null के अलावा कोई गैर-बूलियन मान है।

यह क्वेरी city के दस्तावेज़ नहीं लौटाती है जहाँ capital फ़ील्ड मौजूद नहीं है। नॉट-इक्वल ( != ) और नॉट- not-in क्वेश्चन उन दस्तावेजों को बाहर करते हैं जहां दिया गया फ़ील्ड मौजूद नहीं है

एक फ़ील्ड तब मौजूद होती है जब वह किसी भी मान पर सेट होती है, जिसमें एक खाली स्ट्रिंग ( "" ), null , और NaN (संख्या नहीं) शामिल है। ध्यान दें कि null फ़ील्ड मान != क्लॉज़ से मेल नहीं खाते, क्योंकि x != null undefined का मूल्यांकन करता है।

सीमाओं

!= प्रश्नों के लिए निम्नलिखित सीमाओं पर ध्यान दें:

  • केवल वे दस्तावेज़ जिनमें दी गई फ़ील्ड मौजूद है, क्वेरी से मेल खा सकते हैं।
  • आप कंपाउंड क्वेरी में नॉट not-in और != को संयोजित नहीं कर सकते।
  • एक मिश्रित क्वेरी में, श्रेणी ( < , <= , > , >= ) और बराबर नहीं ( != , not-in ) तुलनाओं को सभी एक ही फ़ील्ड पर फ़िल्टर करना चाहिए।

सरणी सदस्यता

आप सरणी मानों के आधार पर फ़िल्टर करने के लिए array-contains ऑपरेटर का उपयोग कर सकते हैं। उदाहरण के लिए:

Web version 9

import { query, where } from "firebase/firestore";  
const q = query(citiesRef, where("regions", "array-contains", "west_coast"));

Web version 8

citiesRef.where("regions", "array-contains", "west_coast");
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
citiesRef
  .whereField("regions", arrayContains: "west_coast")
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[citiesRef queryWhereField:@"state" arrayContains:@"west_coast"];

Java

CollectionReference citiesRef = db.collection("cities");

citiesRef.whereArrayContains("regions", "west_coast");

Kotlin+KTX

val citiesRef = db.collection("cities")

citiesRef.whereArrayContains("regions", "west_coast")

Dart

final citiesRef = db.collection("cities");
final westCoastcities =
    citiesRef.where("regions", arrayContains: "west_coast");
जावा
CollectionReference citiesRef = db.collection("cities");
Query westCoastQuery = citiesRef.whereArrayContains("regions", "west_coast");
अजगर
cities_ref = db.collection(u'cities')

query = cities_ref.where(u'regions', u'array_contains', u'west_coast')

Python

cities_ref = db.collection("cities")

query = cities_ref.where("regions", "array_contains", "west_coast")
सी++
CollectionReference cities_ref = db->Collection("cities");

cities_ref.WhereArrayContains("region", FieldValue::String("west_coast"));
Node.js
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");
सी#
Query query = citiesRef.WhereArrayContains("Regions", "west_coast");
माणिक
cities_ref = firestore.col collection_path
cities = cities_ref.where "regions", "array-contains", "west_coast"

यह क्वेरी हर city के दस्तावेज़ को लौटाती है जहाँ regions फ़ील्ड एक सरणी है जिसमें west_coast होता है। यदि सरणी में आपके द्वारा क्वेरी किए गए मान के कई उदाहरण हैं, तो दस्तावेज़ को केवल एक बार परिणामों में शामिल किया जाता है।

आप प्रति क्वेरी अधिकतम एक array-contains खंड का उपयोग कर सकते हैं। आप array-contains को array-contains-any साथ जोड़ नहीं सकते।

in , not-in , और array-contains-any

एक ही फ़ील्ड पर लॉजिकल OR के साथ 10 समानता ( == ) क्लॉज को संयोजित करने के लिए in ऑपरेटर का उपयोग करें। एक क्वेरी in दस्तावेज़ लौटाता है जहां दिया गया फ़ील्ड किसी भी तुलना मान से मेल खाता है। उदाहरण के लिए:

Web version 9

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

const q = query(citiesRef, where('country', 'in', ['USA', 'Japan']));

Web version 8

citiesRef.where('country', 'in', ['USA', 'Japan']);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
let citiesRef = db.collection("cities")

citiesRef.whereField("country", in: ["USA", "Japan"])
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];

[citiesRef queryWhereField:@"country" in:@[@"USA", @"Japan"]];

Java

CollectionReference citiesRef = db.collection("cities");

citiesRef.whereIn("country", Arrays.asList("USA", "Japan"));

Kotlin+KTX

val citiesRef = db.collection("cities")

citiesRef.whereIn("country", listOf("USA", "Japan"))

Dart

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

Query query = citiesRef.whereIn("country", Arrays.asList("USA", "Japan"));
अजगर
cities_ref = db.collection(u'cities')

query = cities_ref.where(u'country', u'in', [u'USA', u'Japan'])
return query

Python

cities_ref = db.collection("cities")

query = cities_ref.where("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")
});
Node.js
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 countriesList = new List<object>() {"USA", "Japan"};

Query whereInQuery = citiesRef.WhereIn("country", countriesList);
सी#
Query query = citiesRef.WhereIn("Country", new[] { "USA", "Japan" });
माणिक
cities_ref = firestore.col collection_path
usr_or_japan = cities_ref.where "country", "in", ["USA", "Japan"]

यह क्वेरी हर city के दस्तावेज़ को लौटाती है जहाँ country फ़ील्ड USA या Japan पर सेट है। उदाहरण डेटा से, इसमें SF , LA , DC , और TOK दस्तावेज़ शामिल हैं।

not-in

नॉट not-in ऑपरेटर का उपयोग लॉजिकल AND के साथ एक ही फील्ड पर 10 नॉट इक्वल ( != ) क्लॉज को संयोजित करने के लिए करें। एक not-in क्वेरी उन दस्तावेज़ों को लौटाती है जहां दिया गया फ़ील्ड मौजूद है, null नहीं है, और किसी भी तुलना मान से मेल नहीं खाता है। उदाहरण के लिए:

Web version 9

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

const q = query(citiesRef, where('country', 'not-in', ['USA', 'Japan']));

Web version 8

citiesRef.where('country', 'not-in', ['USA', 'Japan']);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
citiesRef.whereField("country", notIn: ["USA", "Japan"])
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[citiesRef queryWhereField:@"country" notIn:@[@"USA", @"Japan"]];

Java

citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));

Kotlin+KTX

citiesRef.whereNotIn("country", listOf("USA", "Japan"))

Dart

final citiesRef = db.collection("cities");
final cities = citiesRef.where("country", whereNotIn: ["USA", "Japan"]);
जावा
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")
});
Node.js
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']
);
एकता
// Snippet not yet available
सी#
// Snippet not yet available
माणिक
cities_ref = firestore.col collection_path
usr_or_japan = cities_ref.where "country", "not_in", ["USA", "Japan"]

यह क्वेरी हर city के दस्तावेज़ को लौटाती है जहाँ country फ़ील्ड मौजूद है और USA , Japan या null पर सेट नहीं है। उदाहरण डेटा से, इसमें London और Hong Kong दस्तावेज़ शामिल हैं।

not-in क्वेश्चन उन दस्तावेज़ों को बाहर करते हैं जहाँ दिया गया फ़ील्ड मौजूद नहीं है। एक फ़ील्ड तब मौजूद होती है जब वह किसी भी मान पर सेट होती है, जिसमें एक खाली स्ट्रिंग ( "" ), null , और NaN (संख्या नहीं) शामिल है। ध्यान दें कि x != null undefined का मूल्यांकन करता है। तुलना मूल्यों में से एक के रूप में null के साथ एक not-in क्वेरी किसी भी दस्तावेज़ से मेल नहीं खाती है।

array-contains-any

array-contains-any ऑपरेटर का उपयोग लॉजिकल OR के साथ एक ही फ़ील्ड पर 10 array-contains खंडों को संयोजित करने के लिए करें। एक array-contains-any क्वेरी दस्तावेज़ लौटाती है जहां दिया गया फ़ील्ड एक सरणी है जिसमें एक या अधिक तुलना मान होते हैं:

Web version 9

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

const q = query(citiesRef, 
  where('regions', 'array-contains-any', ['west_coast', 'east_coast']));

Web version 8

citiesRef.where('regions', 'array-contains-any',
    ['west_coast', 'east_coast']);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
let citiesRef = db.collection("cities")
citiesRef.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];

[citiesRef queryWhereField:@"regions" arrayContainsAny:@[@"west_coast", @"east_coast"]];

Java

CollectionReference citiesRef = db.collection("cities");

citiesRef.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));

Kotlin+KTX

val citiesRef = db.collection("cities")

citiesRef.whereArrayContainsAny("regions", listOf("west_coast", "east_coast"))

Dart

final citiesRef = db.collection("cities");
final cities = citiesRef
    .where("regions", arrayContainsAny: ["west_coast", "east_coast"]);
जावा
CollectionReference citiesRef = db.collection("cities");

Query query =
    citiesRef.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));
अजगर
cities_ref = db.collection(u'cities')

query = cities_ref.where(
    u'regions', u'array_contains_any', [u'west_coast', u'east_coast']
)
return query

Python

cities_ref = db.collection("cities")

query = cities_ref.where(
    "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")
});
Node.js
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']);
एकता
CollectionReference citiesRef = db.Collection("cities");
List regionsList = new List<object>() {"west_coast", "east_coast"};

Query arrayContainsAnyQuery = citiesRef.WhereArrayContainsAny("regions", regionsList);
सी#
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"]

यह क्वेरी हर शहर के दस्तावेज़ को लौटाती है जहाँ regions फ़ील्ड एक सरणी है जिसमें west_coast या east_coast शामिल है। उदाहरण डेटा से, इसमें SF , LA , और DC दस्तावेज़ शामिल हैं।

array-contains-any से परिणाम डी-डुप्लिकेट हैं। भले ही किसी दस्तावेज़ का सरणी फ़ील्ड एक से अधिक तुलना मानों से मेल खाता हो, परिणाम सेट में वह दस्तावेज़ केवल एक बार शामिल होता है।

array-contains-any हमेशा सरणी डेटा प्रकार द्वारा फ़िल्टर करता है। उदाहरण के लिए, ऊपर दी गई क्वेरी शहर का दस्तावेज़ नहीं लौटाएगी, जहां एक सरणी के बजाय, regions फ़ील्ड स्ट्रिंग west_coast है।

आप के लिए तुलना मान के रूप in सरणी मान का उपयोग कर सकते हैं, लेकिन array-contains-any विपरीत, खंड सरणी लंबाई, क्रम और मानों के सटीक मिलान के लिए मेल खाता है। उदाहरण के लिए:

Web version 9

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

const q = query(citiesRef, where('regions', 'in', [['west_coast', 'east_coast']]));

Web version 8

citiesRef.where('regions', 'in',
    [['west_coast', 'east_coast']]);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
citiesRef.whereField("regions", in: [["west_coast"], ["east_coast"]]);
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[citiesRef queryWhereField:@"regions" in:@[@[@"west_coast"], @[@"east_coast"]]];

Java

citiesRef.whereIn("regions", Arrays.asList(new String[]{"west_coast"}, new String[]{"east_coast"}));

Kotlin+KTX

citiesRef.whereIn("regions", listOf(arrayOf("west_coast"), arrayOf("east_coast")))

Dart

final citiesRef = db.collection("cities");
final cities = citiesRef.where("regions", whereIn: [
  ["west_coast"],
  ["east_coast"]
]);
जावा
CollectionReference citiesRef = db.collection("cities");

Query query =
    citiesRef.whereIn(
        "regions", Arrays.asList(Arrays.asList("west_coast"), Arrays.asList("east_coast")));
अजगर
cities_ref = db.collection(u'cities')

query = cities_ref.where(
    u'regions', u'in', [[u'west_coast'], [u'east_coast']]
)
return query

Python

cities_ref = db.collection("cities")

query = cities_ref.where("regions", "in", [["west_coast"], ["east_coast"]])
return query
सी++
cities_ref.WhereIn("region", std::vector<FieldValue> {
  FieldValue::String("west_coast"),
  FieldValue::String("east_coast")
});
Node.js
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']]);
एकता
// Not yet supported in the Unity SDK
सी#
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"]]

यह क्वेरी हर शहर के दस्तावेज़ को लौटाती है जहाँ regions फ़ील्ड एक सरणी है जिसमें या तो west_coast या east_coast का ठीक एक तत्व होता है। उदाहरण डेटा से, केवल DC दस्तावेज़ ["east_coast"] के अपने regions फ़ील्ड के साथ उत्तीर्ण होता है। हालांकि, SF दस्तावेज़ मेल नहीं खाता क्योंकि इसका regions फ़ील्ड ["west_coast", "norcal"] है।

सीमाओं

in , not-in , और array-contains-any के लिए निम्नलिखित सीमाओं पर ध्यान दें:

  • in , not-in , और array-contains-any समर्थन 10 तुलना मानों तक।
  • आप प्रति क्वेरी अधिकतम एक array-contains खंड का उपयोग कर सकते हैं। आप array-contains को array-contains-any साथ जोड़ नहीं सकते।
  • आप प्रति क्वेरी in , not-in , या array-contains-any क्लॉज में से अधिकतम एक का उपयोग कर सकते हैं। आप इन ऑपरेटरों को एक ही क्वेरी में संयोजित नहीं कर सकते।
  • आप नॉट not-in को नॉट इक्वल्स != के साथ नहीं जोड़ सकते।
  • आप समानता ( == ) या खंड in शामिल फ़ील्ड द्वारा अपनी क्वेरी का आदेश नहीं दे सकते।

यौगिक प्रश्न

अधिक विशिष्ट प्रश्न (तार्किक AND ) बनाने के लिए आप कई समानता ऑपरेटरों ( == या array-contains ) विधियों को श्रृंखलाबद्ध कर सकते हैं। हालांकि, आपको समानता ऑपरेटरों को असमानता ऑपरेटरों, < , <= , > , और != के साथ संयोजित करने के लिए एक समग्र सूचकांक बनाना होगा।

Web version 9

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

const q1 = query(citiesRef, where("state", "==", "CO"), where("name", "==", "Denver"));
const q2 = query(citiesRef, where("state", "==", "CA"), where("population", "<", 1000000));

Web version 8

const q1 = citiesRef.where("state", "==", "CO").where("name", "==", "Denver");
const q2 = citiesRef.where("state", "==", "CA").where("population", "<", 1000000);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
citiesRef
    .whereField("state", isEqualTo: "CO")
    .whereField("name", isEqualTo: "Denver")
citiesRef
    .whereField("state", isEqualTo: "CA")
    .whereField("population", isLessThan: 1000000)
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[[citiesRef queryWhereField:@"state" isEqualTo:@"CO"]
    queryWhereField:@"name" isGreaterThanOrEqualTo:@"Denver"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
    queryWhereField:@"population" isLessThan:@1000000];

Java

citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000);

Kotlin+KTX

citiesRef.whereEqualTo("state", "CO").whereEqualTo("name", "Denver")
citiesRef.whereEqualTo("state", "CA").whereLessThan("population", 1000000)

Dart

final citiesRef = db.collection("cities");
citiesRef
    .where("state", isEqualTo: "CO")
    .where("name", isEqualTo: "Denver");
citiesRef
    .where("state", isEqualTo: "CA")
    .where("population", isLessThan: 1000000);
जावा
Query chainedQuery1 = cities.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
अजगर
cities_ref = db.collection(u'cities')

denver_query = cities_ref.where(
    u'state', u'==', u'CO').where(u'name', u'==', u'Denver')
large_us_cities_query = cities_ref.where(
    u'state', u'==', u'CA').where(u'population', u'>', 1000000)

Python

cities_ref = db.collection("cities")

denver_query = cities_ref.where("state", "==", "CO").where("name", "==", "Denver")
large_us_cities_query = cities_ref.where("state", "==", "CA").where(
    "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));
Node.js
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");
सी#
Query chainedQuery = citiesRef
    .WhereEqualTo("State", "CA")
    .WhereEqualTo("Name", "San Francisco");
माणिक
chained_query = cities_ref.where("state", "=", "CA").where("name", "=", "San Francisco")

आप केवल एक फ़ील्ड पर श्रेणी ( < , <= , > , >= ) या बराबर नहीं ( != ) तुलना कर सकते हैं, और आप एक कंपाउंड क्वेरी में अधिकतम एक array-contains या array-contains-any खंड शामिल कर सकते हैं :

मान्य : केवल एक फ़ील्ड पर रेंज फ़िल्टर

Web version 9

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

const q1 = query(citiesRef, where("state", ">=", "CA"), where("state", "<=", "IN"));
const q2 = query(citiesRef, where("state", "==", "CA"), where("population", ">", 1000000));

Web version 8

const q1 = citiesRef.where("state", ">=", "CA").where("state", "<=", "IN");
const q2 = citiesRef.where("state", "==", "CA").where("population", ">", 1000000);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
citiesRef
    .whereField("state", isGreaterThanOrEqualTo: "CA")
    .whereField("state", isLessThanOrEqualTo: "IN")
citiesRef
    .whereField("state", isEqualTo: "CA")
    .whereField("population", isGreaterThan: 1000000)
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
    queryWhereField:@"state" isLessThanOrEqualTo:@"IN"];
[[citiesRef queryWhereField:@"state" isEqualTo:@"CA"]
    queryWhereField:@"population" isGreaterThan:@1000000];

Java

citiesRef.whereGreaterThanOrEqualTo("state", "CA")
        .whereLessThanOrEqualTo("state", "IN");
citiesRef.whereEqualTo("state", "CA")
        .whereGreaterThan("population", 1000000);

Kotlin+KTX

citiesRef.whereGreaterThanOrEqualTo("state", "CA")
        .whereLessThanOrEqualTo("state", "IN")
citiesRef.whereEqualTo("state", "CA")
        .whereGreaterThan("population", 1000000)

Dart

final citiesRef = db.collection("cities");
citiesRef
    .where("state", isGreaterThanOrEqualTo: "CA")
    .where("state", isLessThanOrEqualTo: "IN");
citiesRef
    .where("state", isEqualTo: "CA")
    .where("population", isGreaterThan: 1000000);
जावा
Query validQuery1 =
    cities.whereGreaterThanOrEqualTo("state", "CA").whereLessThanOrEqualTo("state", "IN");
Query validQuery2 = cities.whereEqualTo("state", "CA").whereGreaterThan("population", 1000000);
अजगर
cities_ref = db.collection(u'cities')
cities_ref.where(u'state', u'>=', u'CA').where(u'state', u'<=', u'IN')

Python

cities_ref = db.collection("cities")
cities_ref.where("state", ">=", "CA").where("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));
Node.js
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");
सी#
Query rangeQuery = citiesRef
    .WhereGreaterThanOrEqualTo("State", "CA")
    .WhereLessThanOrEqualTo("State", "IN");
माणिक
range_query = cities_ref.where("state", ">=", "CA").where("state", "<=", "IN")

अमान्य : विभिन्न क्षेत्रों पर श्रेणी फ़िल्टर

Web version 9

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

const q = query(citiesRef, where("state", ">=", "CA"), where("population", ">", 100000));

Web version 8

citiesRef.where("state", ">=", "CA").where("population", ">", 100000);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
citiesRef
    .whereField("state", isGreaterThanOrEqualTo: "CA")
    .whereField("population", isGreaterThan: 1000000)
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[[citiesRef queryWhereField:@"state" isGreaterThanOrEqualTo:@"CA"]
    queryWhereField:@"population" isGreaterThan:@1000000];

Java

citiesRef.whereGreaterThanOrEqualTo("state", "CA").whereGreaterThan("population", 100000);

Kotlin+KTX

citiesRef.whereGreaterThanOrEqualTo("state", "CA")
        .whereGreaterThan("population", 100000)

Dart

final citiesRef = db.collection("cities");
citiesRef
    .where("state", isGreaterThanOrEqualTo: "CA")
    .where("population", isGreaterThan: 1000000);
जावा
Query invalidRangeQuery =
    cities.whereGreaterThanOrEqualTo("state", "CA").whereGreaterThan("population", 100000);
अजगर
cities_ref = db.collection(u'cities')
cities_ref.where(
    u'state', u'>=', u'CA').where(u'population', u'>=', 1000000)

Python

cities_ref = db.collection("cities")
cities_ref.where("state", ">=", "CA").where("population", ">=", 1000000)
सी++
// BAD EXAMPLE -- will crash the program:
cities_ref.WhereGreaterThanOrEqualTo("state", FieldValue::String("CA"))
    .WhereGreaterThan("population", FieldValue::Integer(100000));
Node.js
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);
सी#
Query invalidRangeQuery = citiesRef
    .WhereGreaterThanOrEqualTo("State", "CA")
    .WhereGreaterThan("Population", 1000000);
माणिक
invalid_range_query = cities_ref.where("state", ">=", "CA").where("population", ">", 1_000_000)

संग्रह समूह प्रश्न

एक संग्रह समूह में एक ही आईडी वाले सभी संग्रह होते हैं। डिफ़ॉल्ट रूप से, क्वेरीज़ आपके डेटाबेस में एकल संग्रह से परिणाम प्राप्त करती हैं। एकल संग्रह के बजाय संग्रह समूह से दस्तावेज़ पुनर्प्राप्त करने के लिए संग्रह समूह क्वेरी का उपयोग करें।

उदाहरण के लिए, आप प्रत्येक शहर में एक लैंडमार्क उपसंग्रह जोड़कर एक landmarks संग्रह समूह बना सकते हैं:

Web version 9

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'
    })
]);

Web version 8

var citiesRef = db.collection('cities');

var landmarks = Promise.all([
    citiesRef.doc('SF').collection('landmarks').doc().set({
        name: 'Golden Gate Bridge',
        type: 'bridge'
    }),
    citiesRef.doc('SF').collection('landmarks').doc().set({
        name: 'Legion of Honor',
        type: 'museum'
    }),
    citiesRef.doc('LA').collection('landmarks').doc().set({
        name: 'Griffith Park',
        type: 'park'
    }),
    citiesRef.doc('LA').collection('landmarks').doc().set({
        name: 'The Getty',
        type: 'museum'
    }),
    citiesRef.doc('DC').collection('landmarks').doc().set({
        name: 'Lincoln Memorial',
        type: 'memorial'
    }),
    citiesRef.doc('DC').collection('landmarks').doc().set({
        name: 'National Air and Space Museum',
        type: 'museum'
    }),
    citiesRef.doc('TOK').collection('landmarks').doc().set({
        name: 'Ueno Park',
        type: 'park'
    }),
    citiesRef.doc('TOK').collection('landmarks').doc().set({
        name: 'National Museum of Nature and Science',
        type: 'museum'
    }),
    citiesRef.doc('BJ').collection('landmarks').doc().set({
        name: 'Jingshan Park',
        type: 'park'
    }),
    citiesRef.doc('BJ').collection('landmarks').doc().set({
        name: 'Beijing Ancient Observatory',
        type: 'museum'
    })
]);
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
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)
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];

NSDictionary *data = @{@"name": @"Golden Gate Bridge", @"type": @"bridge"};
[[[citiesRef documentWithPath:@"SF"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"Legion of Honor", @"type": @"museum"};
[[[citiesRef documentWithPath:@"SF"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"Griffith Park", @"type": @"park"};
[[[citiesRef documentWithPath:@"LA"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"The Getty", @"type": @"museum"};
[[[citiesRef documentWithPath:@"LA"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"Lincoln Memorial", @"type": @"memorial"};
[[[citiesRef documentWithPath:@"DC"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"National Air and Space Museum", @"type": @"museum"};
[[[citiesRef documentWithPath:@"DC"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"Ueno Park", @"type": @"park"};
[[[citiesRef documentWithPath:@"TOK"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"National Museum of Nature and Science", @"type": @"museum"};
[[[citiesRef documentWithPath:@"TOK"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"Jingshan Park", @"type": @"park"};
[[[citiesRef documentWithPath:@"BJ"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

data = @{@"name": @"Beijing Ancient Observatory", @"type": @"museum"};
[[[citiesRef documentWithPath:@"BJ"] collectionWithPath:@"landmarks"] addDocumentWithData:data];

Java

CollectionReference citiesRef = db.collection("cities");

Map<String, Object> ggbData = new HashMap<>();
ggbData.put("name", "Golden Gate Bridge");
ggbData.put("type", "bridge");
citiesRef.document("SF").collection("landmarks").add(ggbData);

Map<String, Object> lohData = new HashMap<>();
lohData.put("name", "Legion of Honor");
lohData.put("type", "museum");
citiesRef.document("SF").collection("landmarks").add(lohData);

Map<String, Object> gpData = new HashMap<>();
gpData.put("name", "Griffith Park");
gpData.put("type", "park");
citiesRef.document("LA").collection("landmarks").add(gpData);

Map<String, Object> tgData = new HashMap<>();
tgData.put("name", "The Getty");
tgData.put("type", "museum");
citiesRef.document("LA").collection("landmarks").add(tgData);

Map<String, Object> lmData = new HashMap<>();
lmData.put("name", "Lincoln Memorial");
lmData.put("type", "memorial");
citiesRef.document("DC").collection("landmarks").add(lmData);

Map<String, Object> nasaData = new HashMap<>();
nasaData.put("name", "National Air and Space Museum");
nasaData.put("type", "museum");
citiesRef.document("DC").collection("landmarks").add(nasaData);

Map<String, Object> upData = new HashMap<>();
upData.put("name", "Ueno Park");
upData.put("type", "park");
citiesRef.document("TOK").collection("landmarks").add(upData);

Map<String, Object> nmData = new HashMap<>();
nmData.put("name", "National Museum of Nature and Science");
nmData.put("type", "museum");
citiesRef.document("TOK").collection("landmarks").add(nmData);

Map<String, Object> jpData = new HashMap<>();
jpData.put("name", "Jingshan Park");
jpData.put("type", "park");
citiesRef.document("BJ").collection("landmarks").add(jpData);

Map<String, Object> baoData = new HashMap<>();
baoData.put("name", "Beijing Ancient Observatory");
baoData.put("type", "museum");
citiesRef.document("BJ").collection("landmarks").add(baoData);

Kotlin+KTX

val citiesRef = db.collection("cities")

val ggbData = mapOf(
        "name" to "Golden Gate Bridge",
        "type" to "bridge"
)
citiesRef.document("SF").collection("landmarks").add(ggbData)

val lohData = mapOf(
        "name" to "Legion of Honor",
        "type" to "museum"
)
citiesRef.document("SF").collection("landmarks").add(lohData)

val gpData = mapOf(
        "name" to "Griffth Park",
        "type" to "park"
)
citiesRef.document("LA").collection("landmarks").add(gpData)

val tgData = mapOf(
        "name" to "The Getty",
        "type" to "museum"
)
citiesRef.document("LA").collection("landmarks").add(tgData)

val lmData = mapOf(
        "name" to "Lincoln Memorial",
        "type" to "memorial"
)
citiesRef.document("DC").collection("landmarks").add(lmData)

val nasaData = mapOf(
        "name" to "National Air and Space Museum",
        "type" to "museum"
)
citiesRef.document("DC").collection("landmarks").add(nasaData)

val upData = mapOf(
        "name" to "Ueno Park",
        "type" to "park"
)
citiesRef.document("TOK").collection("landmarks").add(upData)

val nmData = mapOf(
        "name" to "National Musuem of Nature and Science",
        "type" to "museum"
)
citiesRef.document("TOK").collection("landmarks").add(nmData)

val jpData = mapOf(
        "name" to "Jingshan Park",
        "type" to "park"
)
citiesRef.document("BJ").collection("landmarks").add(jpData)

val baoData = mapOf(
        "name" to "Beijing Ancient Observatory",
        "type" to "musuem"
)
citiesRef.document("BJ").collection("landmarks").add(baoData)

Dart

final citiesRef = db.collection("cities");

final ggbData = {"name": "Golden Gate Bridge", "type": "bridge"};
citiesRef.doc("SF").collection("landmarks").add(ggbData);

final lohData = {"name": "Legion of Honor", "type": "museum"};
citiesRef.doc("SF").collection("landmarks").add(lohData);

final gpData = {"name": "Griffth Park", "type": "park"};
citiesRef.doc("LA").collection("landmarks").add(gpData);

final tgData = {"name": "The Getty", "type": "museum"};
citiesRef.doc("LA").collection("landmarks").add(tgData);

final lmData = {"name": "Lincoln Memorial", "type": "memorial"};
citiesRef.doc("DC").collection("landmarks").add(lmData);

final nasaData = {
  "name": "National Air and Space Museum",
  "type": "museum"
};
citiesRef.doc("DC").collection("landmarks").add(nasaData);

final upData = {"name": "Ueno Park", "type": "park"};
citiesRef.doc("TOK").collection("landmarks").add(upData);

final nmData = {
  "name": "National Musuem of Nature and Science",
  "type": "museum"
};
citiesRef.doc("TOK").collection("landmarks").add(nmData);

final jpData = {"name": "Jingshan Park", "type": "park"};
citiesRef.doc("BJ").collection("landmarks").add(jpData);

final baoData = {"name": "Beijing Ancient Observatory", "type": "musuem"};
citiesRef.doc("BJ").collection("landmarks").add(baoData);
जावा
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(u'cities')

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

Python

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"}
)
सी++
// This is not yet supported.
Node.js
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: %v", 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: %v", 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);
एकता
// Not yet supported in the Unity SDK
सी#
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" });
माणिक
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"
  }
)

हम किसी एक शहर के landmarks उप-संग्रह को क्वेरी करने के लिए पहले वर्णित सरल और मिश्रित क्वेरी का उपयोग कर सकते हैं, लेकिन हो सकता है कि आप प्रत्येक शहर के landmarks उप-संग्रह से एक ही बार में परिणाम प्राप्त करना चाहें।

landmarks संग्रह समूह में आईडी landmarks वाले सभी संग्रह होते हैं, और आप संग्रह समूह क्वेरी का उपयोग करके इसे क्वेरी कर सकते हैं। उदाहरण के लिए, यह संग्रह समूह क्वेरी सभी शहरों में सभी museum स्थलों को पुनः प्राप्त करती है:

Web version 9

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

const museums = query(collectionGroup(db, 'landmarks'), where('type', '==', 'museum'));
const querySnapshot = await getDocs(museums);
querySnapshot.forEach((doc) => {
    console.log(doc.id, ' => ', doc.data());
});

Web version 8

var museums = db.collectionGroup('landmarks').where('type', '==', 'museum');
museums.get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(doc.id, ' => ', doc.data());
    });
});
तीव्र
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
db.collectionGroup("landmarks").whereField("type", isEqualTo: "museum").getDocuments { (snapshot, error) in
    // ...
}
उद्देश्य सी
नोट: यह उत्पाद watchOS और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
[[[self.db collectionGroupWithID:@"landmarks"] queryWhereField:@"type" isEqualTo:@"museum"]
    getDocumentsWithCompletion:^(FIRQuerySnapshot *snapshot, NSError *error) {
    // ...
}];

Java

db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
        .addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
            @Override
            public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
                // ...
            }
        });

Kotlin+KTX

db.collectionGroup("landmarks").whereEqualTo("type", "museum").get()
        .addOnSuccessListener { queryDocumentSnapshots ->
            // ...
        }

Dart

db
    .collectionGroup("landmarks")
    .where("type", isEqualTo: "museum")
    .get()
    .then(
      (res) => print("Successfully completed"),
      onError: (e) => print("Error completing: $e"),
    );
जावा
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(u'landmarks')\
    .where(u'type', u'==', u'museum')
docs = museums.stream()
for doc in docs:
    print(f'{doc.id} => {doc.to_dict()}')

Python

museums = db.collection_group("landmarks").where("type", "==", "museum")
docs = museums.stream()
async for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
सी++
// This is not yet supported.
Node.js
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: %v", 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: %v", 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']);
}
एकता
// Not yet supported in the Unity SDK
सी#
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

संग्रह समूह क्वेरी का उपयोग करने से पहले, आपको एक इंडेक्स बनाना होगा जो आपके संग्रह समूह क्वेरी का समर्थन करता हो। आप एक त्रुटि संदेश, कंसोल, या Firebase CLI के माध्यम से एक अनुक्रमणिका बना सकते हैं

वेब और मोबाइल SDK के लिए, आपको ऐसे नियम भी बनाने होंगे जो आपके संग्रह समूह प्रश्नों की अनुमति दें .

क्वेरी सीमाएं

निम्न सूची Cloud Firestore क्वेरी सीमाओं को सारांशित करती है:

  • क्लाउड फायरस्टोर तार्किक OR प्रश्नों के लिए सीमित समर्थन प्रदान करता है। in , और array-contains-any ऑपरेटर तार्किक OR अधिकतम 10 समानता ( == ) का समर्थन करता है या किसी एकल फ़ील्ड पर array-contains स्थितियां हैं। अन्य मामलों के लिए, प्रत्येक OR शर्त के लिए एक अलग क्वेरी बनाएं और क्वेरी परिणामों को अपने ऐप में मर्ज करें।
  • एक मिश्रित क्वेरी में, श्रेणी ( < , <= , > , >= ) और बराबर नहीं ( != , not-in ) तुलनाओं को सभी एक ही फ़ील्ड पर फ़िल्टर करना चाहिए।
  • आप प्रति क्वेरी अधिकतम एक array-contains खंड का उपयोग कर सकते हैं। आप array-contains को array-contains-any साथ जोड़ नहीं सकते।
  • आप प्रति क्वेरी in , not-in , या array-contains-any क्लॉज में से अधिकतम एक का उपयोग कर सकते हैं। आप एक ही क्वेरी में in , not-in , और array-contains-any को संयोजित नहीं कर सकते।
  • आप समानता ( == ) या खंड in शामिल फ़ील्ड द्वारा अपनी क्वेरी का आदेश नहीं दे सकते।
  • किसी क्वेरी में फ़िल्टर, सॉर्ट ऑर्डर और पैरेंट दस्तावेज़ पथ (उपसंग्रह के लिए 1, रूट संग्रह के लिए 0) का योग 100 से अधिक नहीं हो सकता।