Executar consultas simples e compostas no Cloud Firestore

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();
QueryDataSnippets.java

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

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
	}
}
query.go

$citiesRef = $db->collection('samples/php/cities');
$citiesRef->document('SF')->set([
    'name' => 'San Francisco',
    'state' => 'CA',
    'country' => 'USA',
    'capital' => false,
    'population' => 860000,
    'density' => 18000,
    'regions' => ['west_coast', 'norcal']
]);
$citiesRef->document('LA')->set([
    'name' => 'Los Angeles',
    'state' => 'CA',
    'country' => 'USA',
    'capital' => false,
    'population' => 3900000,
    'density' => 8000,
    'regions' => ['west_coast', 'socal']
]);
$citiesRef->document('DC')->set([
    'name' => 'Washington D.C.',
    'state' => null,
    'country' => 'USA',
    'capital' => true,
    'population' => 680000,
    'density' => 11000,
    'regions' => ['east_coast']
]);
$citiesRef->document('TOK')->set([
    'name' => 'Tokyo',
    'state' => null,
    'country' => 'Japan',
    'capital' => true,
    'population' => 9000000,
    'density' => 16000,
    'regions' => ['kanto', 'honshu']
]);
$citiesRef->document('BJ')->set([
    'name' => 'Beijing',
    'state' => null,
    'country' => 'China',
    'capital' => true,
    'population' => 21500000,
    'density' => 3500,
    'regions' => ['jingjinji', 'hebei']
]);
printf('Added example cities data to the cities collection.' . PHP_EOL);
query_filter_dataset.php

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 },
    { "Density", 18000 },
    { "Regions", new[] {"west_coast", "norcal"} }
});
await citiesRef.Document("LA").SetAsync(new Dictionary<string, object>
{
    { "Name", "Los Angeles" },
    { "State", "CA" },
    { "Country", "USA" },
    { "Capital", false },
    { "Population", 3900000 },
    { "Density", 8300 },
    { "Regions", new[] {"west_coast", "socal"} }
});
await citiesRef.Document("DC").SetAsync(new Dictionary<string, object>
{
    { "Name", "Washington D.C." },
    { "State", null },
    { "Country", "USA" },
    { "Capital", true },
    { "Population", 680000 },
    { "Density", 11300 },
    { "Regions", new[] {"east_coast"} }
});
await citiesRef.Document("TOK").SetAsync(new Dictionary<string, object>
{
    { "Name", "Tokyo" },
    { "State", null },
    { "Country", "Japan" },
    { "Capital", true },
    { "Population", 9000000 },
    { "Density", 16000 },
    { "Regions", new[] {"kanto", "honshu"} }
});
await citiesRef.Document("BJ").SetAsync(new Dictionary<string, object>
{
    { "Name", "Beijing" },
    { "State", null },
    { "Country", "China" },
    { "Capital", true },
    { "Population", 21500000 },
    { "Density", 3500 },
    { "Regions", new[] {"jingjinji", "hebei"} }
});
Console.WriteLine("Added example cities data to the cities collection.");
Program.cs

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"]
  }
)
query_data.rb

// 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());
}
QueryDataSnippets.java

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

# Create a query against the collection
query_ref = cities_ref.where(filter=FieldFilter("state", "==", "CA"))
snippets.py

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

# Create a query against the collection
query_ref = cities_ref.where(filter=FieldFilter("state", "==", "CA"))
snippets.py

// Create a reference to the cities collection
const citiesRef = db.collection('cities');

// Create a query against the collection
const queryRef = citiesRef.where('state', '==', 'CA');
index.js

query := client.Collection("cities").Where("state", "==", "CA")
query.go

$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());
}
query_filter_eq_string.php

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);
}
Program.cs

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
query_data.rb

// 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());
}
QueryDataSnippets.java

cities_ref = db.collection("cities")

query = cities_ref.where(filter=FieldFilter("capital", "==", True))
snippets.py

cities_ref = db.collection("cities")

query = cities_ref.where(filter=FieldFilter("capital", "==", True))
snippets.py

// Create a reference to the cities collection
const citiesRef = db.collection('cities');

// Create a query against the collection
const allCapitalsRes = citiesRef.where('capital', '==', true);
index.js

query := client.Collection("cities").Where("capital", "==", true)
query.go

$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());
}
query_filter_eq_boolean.php

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);
}
Program.cs

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
query_data.rb

// 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));
}
RetrieveDataSnippets.java

# Note: Use of CollectionRef stream() is prefered to get()
docs = (
    db.collection("cities")
    .where(filter=FieldFilter("capital", "==", True))
    .stream()
)

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

# Note: Use of CollectionRef stream() is prefered to get()
docs = (
    db.collection("cities")
    .where(filter=FieldFilter("capital", "==", True))
    .stream()
)

async for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
snippets.py

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());
});
index.js

import (
	"context"
	"fmt"

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

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

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("");
}
Program.cs

cities_ref = firestore.col collection_path

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

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

Query stateQuery = cities.whereEqualTo("state", "CA");
Query populationQuery = cities.whereLessThan("population", 1000000L);
Query nameQuery = cities.whereGreaterThanOrEqualTo("name", "San Francisco");
QueryDataSnippets.java

cities_ref = db.collection("cities")

cities_ref.where(filter=FieldFilter("state", "==", "CA"))
cities_ref.where(filter=FieldFilter("population", "<", 1000000))
cities_ref.where(filter=FieldFilter("name", ">=", "San Francisco"))
snippets.py

cities_ref = db.collection("cities")

cities_ref.where(filter=FieldFilter("state", "==", "CA"))
cities_ref.where(filter=FieldFilter("population", "<", 1000000))
cities_ref.where(filter=FieldFilter("name", ">=", "San Francisco"))
snippets.py

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();
index.js

countryQuery := cities.Where("state", "==", "CA")
popQuery := cities.Where("population", "<", 1000000)
cityQuery := cities.Where("name", ">=", "San Francisco")
query.go

$stateQuery = $citiesRef->where('state', '=', 'CA');
$populationQuery = $citiesRef->where('population', '>', 1000000);
$nameQuery = $citiesRef->where('name', '>=', 'San Francisco');
query_filter_single_examples.php

CollectionReference citiesRef = db.Collection("cities");
Query stateQuery = citiesRef.WhereEqualTo("State", "CA");
Query populationQuery = citiesRef.WhereGreaterThan("Population", 1000000);
Query nameQuery = citiesRef.WhereGreaterThanOrEqualTo("Name", "San Francisco");
Program.cs

state_query      = cities_ref.where "state", "=", "CA"
population_query = cities_ref.where "population", ">", 1_000_000
name_query       = cities_ref.where "name", ">=", "San Francisco"
query_data.rb

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

Query query = citiesRef.whereNotEqualTo("capital", false);
QueryDataSnippets.java

const capitalNotFalseRes = await citiesRef.where('capital', '!=', false).get();
index.js

$stateQuery = $citiesRef->where('capital', '!=', false);
query_filter_not_eq.php

cities_ref = firestore.col collection_path
query = cities_ref.where "capital", "!=", false
query_data.rb

CollectionReference citiesRef = db.collection("cities");
Query westCoastQuery = citiesRef.whereArrayContains("regions", "west_coast");
QueryDataSnippets.java

cities_ref = db.collection("cities")

query = cities_ref.where(
    filter=FieldFilter("regions", "array_contains", "west_coast")
)
snippets.py

cities_ref = db.collection("cities")

query = cities_ref.where(
    filter=FieldFilter("regions", "array_contains", "west_coast")
)
snippets.py

const westCoastCities = citiesRef.where('regions', 'array-contains',
  'west_coast').get();
index.js

query := cities.Where("regions", "array-contains", "west_coast").Documents(ctx)
query.go

$containsQuery = $citiesRef->where('regions', 'array-contains', 'west_coast');
query_filter_array_contains.php

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereArrayContains("Regions", "west_coast");
Program.cs

cities_ref = firestore.col collection_path
cities = cities_ref.where "regions", "array-contains", "west_coast"
query_data.rb

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

Query query = citiesRef.whereIn("country", Arrays.asList("USA", "Japan"));
QueryDataSnippets.java

cities_ref = db.collection("cities")

query = cities_ref.where(filter=FieldFilter("country", "in", ["USA", "Japan"]))
return query
snippets.py

cities_ref = db.collection("cities")

query = cities_ref.where(filter=FieldFilter("country", "in", ["USA", "Japan"]))
return query
snippets.py

const usaOrJapan = await citiesRef.where('country', 'in', ['USA', 'Japan']).get();
index.js

cities := client.Collection("cities")
query := cities.Where("country", "in", []string{"USA", "Japan"}).Documents(ctx)
query.go

$rangeQuery = $citiesRef->where('country', 'in', ['USA', 'Japan']);
query_filter_in.php

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereIn("Country", new[] { "USA", "Japan" });
Program.cs

cities_ref = firestore.col collection_path
usr_or_japan = cities_ref.where "country", "in", ["USA", "Japan"]
query_data.rb

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

Query query = citiesRef.whereNotIn("country", Arrays.asList("USA", "Japan"));
QueryDataSnippets.java

const notUsaOrJapan = await citiesRef.where('country', 'not-in', ['USA', 'Japan']).get();
index.js

$stateQuery = $citiesRef->where(
    'country',
    \Google\Cloud\Firestore\V1\StructuredQuery\FieldFilter\Operator::NOT_IN,
    ['USA', 'Japan']
);
query_filter_not_in.php

cities_ref = firestore.col collection_path
usr_or_japan = cities_ref.where "country", "not_in", ["USA", "Japan"]
query_data.rb

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

Query query =
    citiesRef.whereArrayContainsAny("regions", Arrays.asList("west_coast", "east_coast"));
QueryDataSnippets.java

cities_ref = db.collection("cities")

query = cities_ref.where(
    filter=FieldFilter(
        "regions", "array_contains_any", ["west_coast", "east_coast"]
    )
)
return query
snippets.py

cities_ref = db.collection("cities")

query = cities_ref.where(
    filter=FieldFilter(
        "regions", "array_contains_any", ["west_coast", "east_coast"]
    )
)
return query
snippets.py

const coastalCities = await citiesRef.where('regions', 'array-contains-any',
    ['west_coast', 'east_coast']).get();
index.js

cities := client.Collection("cities")
query := cities.Where("regions", "array-contains-any", []string{"west_coast", "east_coast"}).Documents(ctx)
query.go

$containsQuery = $citiesRef->where('regions', 'array-contains-any', ['west_coast', 'east_coast']);
query_filter_array_contains_any.php

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereArrayContainsAny("Regions", new[] { "west_coast", "east_coast" });
Program.cs

cities_ref = firestore.col collection_path
costal_cities = cities_ref.where "regions", "array-contains-any", ["west_coast", "east_coast"]
query_data.rb

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

Query query =
    citiesRef.whereIn(
        "regions", Arrays.asList(Arrays.asList("west_coast"), Arrays.asList("east_coast")));
QueryDataSnippets.java

cities_ref = db.collection("cities")

query = cities_ref.where(
    filter=FieldFilter("regions", "in", [["west_coast"], ["east_coast"]])
)
return query
snippets.py

cities_ref = db.collection("cities")

query = cities_ref.where(
    filter=FieldFilter("regions", "in", [["west_coast"], ["east_coast"]])
)
return query
snippets.py

const exactlyOneCoast = await citiesRef.where('regions', 'in',
    [['west_coast', 'east_coast']]).get();
index.js

cities := client.Collection("cities")
query := cities.Where("regions", "in", [][]string{{"west_coast"}, {"east_coast"}}).Documents(ctx)
query.go

$rangeQuery = $citiesRef->where('regions', 'in', [['west_coast'], ['east_coast']]);
query_filter_in_with_array.php

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereIn("Regions",
    new[] { new[] { "west_coast" }, new[] { "east_coast" } });
Program.cs

cities_ref = firestore.col collection_path
exactly_one_cost = cities_ref.where "regions", "in", [["west_coast"], ["east_coast"]]
query_data.rb

Query chainedQuery1 = cities.whereEqualTo("state", "CO").whereEqualTo("name", "Denver");
QueryDataSnippets.java

cities_ref = db.collection("cities")

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

cities_ref = db.collection("cities")

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

citiesRef.where('state', '==', 'CO').where('name', '==', 'Denver');
citiesRef.where('state', '==', 'CA').where('population', '<', 1000000);
index.js

denverQuery := cities.Where("name", "==", "Denver").Where("state", "==", "CO")
caliQuery := cities.Where("state", "==", "CA").Where("population", "<=", 1000000)
query := cities.Where("country", "==", "USA").Where("population", ">", 5000000)
query.go

$chainedQuery = $citiesRef
    ->where('state', '=', 'CA')
    ->where('name', '=', 'San Francisco');
query_filter_compound_multi_eq.php

CollectionReference citiesRef = db.Collection("cities");
Query chainedQuery = citiesRef
    .WhereEqualTo("State", "CA")
    .WhereEqualTo("Name", "San Francisco");
Program.cs

chained_query = cities_ref.where("state", "=", "CA").where("name", "=", "San Francisco")
query_data.rb

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

col_ref = client.collection("cities")
# Execute the query
query = col_ref.where(
    filter=Or(
        [
            FieldFilter("capital", "==", True),
            FieldFilter("population", ">", 1_000_000),
        ]
    )
)
docs = query.stream()
query_filter_or.py

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}
query_filter_or.go

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();
QueryDataSnippets.java

cities = db.collection("cities")

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

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"}
)
snippets.py

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'
});
index.js

import (
	"context"
	"fmt"

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

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

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

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

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

	return nil
}
collection_group_setup.go

$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);
query_collection_group_dataset.php

// Copyright(c) 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

using Google.Cloud.Firestore;
using Google.Cloud.Firestore.Admin.V1;
using Google.Protobuf.WellKnownTypes;
using Grpc.Core;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using static Google.Cloud.Firestore.Admin.V1.Index.Types;

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

Where command is one of
    query-create-examples
    create-query-state
    create-query-capital
    simple-queries
    array-contains-query
    array-contains-any-query
    in-query
    in-query-array
    collection-group-query
    subcollection-query
    chained-query
    composite-index-chained-query
    range-query
    invalid-range-query
    multiple-inequalities
";
        private static async Task QueryCreateExamples(string project)
        {
            FirestoreDb db = FirestoreDb.Create(project);
            // Note: the extra braces here are just to allow multiple citiesRef local variables.
            {
                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 },
                    { "Density", 18000 },
                    { "Regions", new[] {"west_coast", "norcal"} }
                });
                await citiesRef.Document("LA").SetAsync(new Dictionary<string, object>
                {
                    { "Name", "Los Angeles" },
                    { "State", "CA" },
                    { "Country", "USA" },
                    { "Capital", false },
                    { "Population", 3900000 },
                    { "Density", 8300 },
                    { "Regions", new[] {"west_coast", "socal"} }
                });
                await citiesRef.Document("DC").SetAsync(new Dictionary<string, object>
                {
                    { "Name", "Washington D.C." },
                    { "State", null },
                    { "Country", "USA" },
                    { "Capital", true },
                    { "Population", 680000 },
                    { "Density", 11300 },
                    { "Regions", new[] {"east_coast"} }
                });
                await citiesRef.Document("TOK").SetAsync(new Dictionary<string, object>
                {
                    { "Name", "Tokyo" },
                    { "State", null },
                    { "Country", "Japan" },
                    { "Capital", true },
                    { "Population", 9000000 },
                    { "Density", 16000 },
                    { "Regions", new[] {"kanto", "honshu"} }
                });
                await citiesRef.Document("BJ").SetAsync(new Dictionary<string, object>
                {
                    { "Name", "Beijing" },
                    { "State", null },
                    { "Country", "China" },
                    { "Capital", true },
                    { "Population", 21500000 },
                    { "Density", 3500 },
                    { "Regions", new[] {"jingjinji", "hebei"} }
                });
                Console.WriteLine("Added example cities data to the cities collection.");
            }

            {
                CollectionReference citiesRef = db.Collection("cities");
                await citiesRef.Document("SF").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Golden Gate Bridge", Type = "bridge" });
                await citiesRef.Document("SF").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Legion of Honor", Type = "museum" });
                await citiesRef.Document("LA").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Griffith Park", Type = "park" });
                await citiesRef.Document("DC").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Lincoln Memorial", Type = "memorial" });
                await citiesRef.Document("DC").Collection("landmarks").Document()
                    .SetAsync(new { Name = "National Air And Space Museum", Type = "museum" });
                await citiesRef.Document("TOK").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Ueno Park", Type = "park" });
                await citiesRef.Document("TOK").Collection("landmarks").Document()
                    .SetAsync(new { Name = "National Museum of Nature and Science", Type = "museum" });
                await citiesRef.Document("BJ").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Jingshan Park", Type = "park" });
                await citiesRef.Document("BJ").Collection("landmarks").Document()
                    .SetAsync(new { Name = "Beijing Ancient Observatory", Type = "museum" });
            }
        }

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

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

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

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

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

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

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

        private static async Task CollectionGroupQuery(string project)
        {
            FirestoreDb db = FirestoreDb.Create(project);
            Query museums = db.CollectionGroup("landmarks").WhereEqualTo("Type", "museum");
            QuerySnapshot querySnapshot = await museums.GetSnapshotAsync();
            foreach (DocumentSnapshot document in querySnapshot.Documents)
            {
                Console.WriteLine($"{document.Reference.Path}: {document.GetValue<string>("Name")}");
            }
        }

        private static async Task SubcollectionQuery(string project)
        {
            FirestoreDb db = FirestoreDb.Create(project);
            CollectionReference landmarks = db.Collection("cities").Document("SF").Collection("landmarks");
            QuerySnapshot querySnapshot = await landmarks.GetSnapshotAsync();
            foreach (DocumentSnapshot document in querySnapshot.Documents)
            {
                Console.WriteLine($"{document.Reference.Path}: {document.GetValue<string>("Name")}");
            }
        }

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

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

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

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

        private static async Task MultipleInequalitiesQuery(string project)
        {
            FirestoreDb db = FirestoreDb.Create(project);
            FirestoreAdminClient adminClient = FirestoreAdminClient.Create();
            var index = new Google.Cloud.Firestore.Admin.V1.Index
            {
                Fields =
                {
                    new IndexField { FieldPath = "Density", Order = IndexField.Types.Order.Ascending },
                    new IndexField { FieldPath = "Population", Order = IndexField.Types.Order.Ascending }
                },
                QueryScope = QueryScope.Collection
            };

            // We speculatively try to create the index, and just ignore an error of it already existing.
            try
            {
                var lro = await adminClient.CreateIndexAsync(new CollectionGroupName(db.ProjectId, db.DatabaseId, "cities"), index);
                await lro.PollUntilCompletedAsync();
            }
            catch (RpcException ex) when (ex.StatusCode == StatusCode.AlreadyExists)
            {
                // Assume the index is okay.
            }

            CollectionReference citiesRef = db.Collection("cities");
            Query query = citiesRef
                .WhereGreaterThan("Population", 1000000)
                .WhereLessThan("Density", 10000);
            QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
            foreach (DocumentSnapshot documentSnapshot in querySnapshot)
            {
                var name = documentSnapshot.GetValue<string>("Name");
                var population = documentSnapshot.GetValue<int>("Population");
                var density = documentSnapshot.GetValue<int>("Density");
                Console.WriteLine($"City '{name}' returned by query. Population={population}; Density={density}");
            }
        }

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

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

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

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

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

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

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

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

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

                case "subcollection-query":
                    SubcollectionQuery(project).Wait();
                    break;

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

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

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

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

                case "multiple-inequalities":
                    MultipleInequalitiesQuery(project).Wait();
                    break;

                default:
                    Console.Write(Usage);
                    return;
            }
        }
    }
}
Program.cs

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"
  }
)
query_data.rb

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());
}
QueryDataSnippets.java

museums = db.collection_group("landmarks").where(
    filter=FieldFilter("type", "==", "museum")
)
docs = museums.stream()
for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
snippets.py

museums = db.collection_group("landmarks").where(
    filter=FieldFilter("type", "==", "museum")
)
docs = museums.stream()
async for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
snippets.py

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

	return nil
}
collection_group_query.go

$museums = $db->collectionGroup('landmarks')->where('type', '==', 'museum');
foreach ($museums->documents() as $document) {
    printf('%s => %s' . PHP_EOL, $document->id(), $document->data()['name']);
}
query_collection_group_filter_eq.php

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

museums = firestore.collection_group("landmarks").where("type", "==", "museum")
museums.get do |museum|
  puts "#{museum[:type]} name is #{museum[:name]}."
end
query_data.rb