async def order_multiple(): db = firestore.AsyncClient() # [START order_multiple_async] # [START firestore_query_order_multi_async] cities_ref = db.collection("cities") cities_ref.order_by("state").order_by("population", direction=firestore.Query.DESCENDING)
async def cursor_paginate(): db = firestore.AsyncClient() # [START cursor_paginate_async] # [START firestore_query_cursor_pagination_async] cities_ref = db.collection("cities") first_query = cities_ref.order_by("population").limit(3) # Get the last document from the results docs = [d async for d in first_query.stream()] last_doc = list(docs)[-1] # Construct a new query starting at this document # Note: this will not have the desired effect if # multiple cities have the exact same population value last_pop = last_doc.to_dict()["population"] next_query = (cities_ref.order_by("population").start_after({ "population": last_pop }).limit(3)) # Use the query for pagination # ... # [END firestore_query_cursor_pagination_async] # [END cursor_paginate_async] return next_query
async def update_create_if_missing(): db = firestore.AsyncClient() # [START update_create_if_missing_async] # [START firestore_data_set_doc_upsert_async] city_ref = db.collection("cities").document("BJ") await city_ref.set({"capital": True}, merge=True)
async def get_full_collection(): db = firestore.AsyncClient() # [START firestore_data_get_all_documents_async] docs = db.collection("cities").stream() async for doc in docs: print(f"{doc.id} => {doc.to_dict()}")
async def list_document_subcollections(): db = firestore.AsyncClient() # [START firestore_data_get_sub_collections_async] collections = db.collection("cities").document("SF").collections() async for collection in collections: async for doc in collection.stream(): print(f"{doc.id} => {doc.to_dict()}")
async def structure_doc_ref_alternate(): db = firestore.AsyncClient() # [START firestore_data_reference_document_path_async] a_lovelace_ref = db.document("users/alovelace") # [END firestore_data_reference_document_path_async] return a_lovelace_ref
async def add_from_dict(): db = firestore.AsyncClient() # [START firestore_data_set_from_map_async] data = {"name": "Los Angeles", "state": "CA", "country": "USA"} # Add a new doc in collection 'cities' with ID 'LA' await db.collection("cities").document("LA").set(data)
async def structure_subcollection_ref(): db = firestore.AsyncClient() # [START firestore_data_reference_subcollection_async] room_a_ref = db.collection("rooms").document("roomA") message_ref = room_a_ref.collection("messages").document("message1") # [END firestore_data_reference_subcollection_async] print(message_ref)
async def structure_doc_ref(): db = firestore.AsyncClient() # [START structure_doc_ref_async] # [START firestore_data_reference_document_async] a_lovelace_ref = db.collection("users").document("alovelace") # [END firestore_data_reference_document_async] # [END structure_doc_ref_async] print(a_lovelace_ref)
async def quickstart_get_collection(): db = firestore.AsyncClient() # [START firestore_quickstart_get_collection_async] users_ref = db.collection("users") docs = users_ref.stream() async for doc in docs: print(f"{doc.id} => {doc.to_dict()}")
async def order_limit_to_last(): db = firestore.AsyncClient() # [START firestore_query_order_limit_async] cities_ref = db.collection("cities") query = cities_ref.order_by("name").limit_to_last(2) results = await query.get() # [END firestore_query_order_limit_async] print(results)
async def compound_query_single_clause(): db = firestore.AsyncClient() # [START firestore_query_filter_single_examples_async] cities_ref = db.collection("cities") cities_ref.where("state", "==", "CA") cities_ref.where("population", "<", 1000000) cities_ref.where("name", ">=", "San Francisco")
async def order_where_valid(): db = firestore.AsyncClient() # [START firestore_query_order_with_filter_async] cities_ref = db.collection("cities") query = cities_ref.where("population", ">", 2500000).order_by("population") results = query.stream() # [END firestore_query_order_with_filter_async] print([d async for d in results])
async def structure_collection_ref(): db = firestore.AsyncClient() # [START structure_collection_ref_async] # [START firestore_data_reference_collection_async] users_ref = db.collection("users") # [END firestore_data_reference_collection_async] # [END structure_collection_ref_async] print(users_ref)
async def get_simple_query(): db = firestore.AsyncClient() # [START firestore_data_query_async] # 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()}")
async def get_custom_class(): db = firestore.AsyncClient() # [START firestore_data_get_as_custom_type_async] doc_ref = db.collection("cities").document("BJ") doc = await doc_ref.get() city = City.from_dict(doc.to_dict()) print(city)
async def order_where_invalid(): db = firestore.AsyncClient() # [START firestore_query_order_field_invalid_async] cities_ref = db.collection("cities") query = cities_ref.where("population", ">", 2500000).order_by("country") results = query.stream() # [END firestore_query_order_field_invalid_async] print(results)
async def compound_query_simple(): db = firestore.AsyncClient() # [START firestore_query_filter_eq_boolean_async] cities_ref = db.collection("cities") query = cities_ref.where("capital", "==", True) # [END firestore_query_filter_eq_boolean_async] print(query)
async def add_new_doc(): db = firestore.AsyncClient() # [START firestore_data_set_id_random_document_ref_async] new_city_ref = db.collection("cities").document() # later... await new_city_ref.set({ # ... })
async def add_new_doc(): db = firestore.AsyncClient() # [START add_new_doc_async] new_city_ref = db.collection("cities").document() # later... await new_city_ref.set({ # ... })
async def cursor_simple_start_at(): db = firestore.AsyncClient() # [START cursor_simple_start_at_async] cities_ref = db.collection("cities") query_start_at = cities_ref.order_by("population").start_at( {"population": 1000000}) # [END cursor_simple_start_at_async] return query_start_at
async def order_simple_limit_desc(): db = firestore.AsyncClient() # [START firestore_query_order_desc_limit_async] cities_ref = db.collection("cities") query = cities_ref.order_by("name", direction=firestore.Query.DESCENDING).limit(3) results = query.stream() # [END firestore_query_order_desc_limit_async] print(results)
async def quickstart_new_instance(): # [START quickstart_new_instance_async] from google.cloud import firestore # Project ID is determined by the GCLOUD_PROJECT environment variable db = firestore.AsyncClient() # [END quickstart_new_instance_async] return db
def fs_client(): yield firestore.AsyncClient() # clean up for shard in shards_list: shard.delete() if doc_ref: doc_ref.delete()
async def order_where_limit(): db = firestore.AsyncClient() # [START order_where_limit_async] cities_ref = db.collection("cities") query = cities_ref.where("population", ">", 2500000).order_by("population").limit(2) results = query.stream() # [END order_where_limit_async] print([d async for d in results])
async def cursor_simple_end_at(): db = firestore.AsyncClient() # [START firestore_query_cursor_end_at_field_value_single_async] cities_ref = db.collection("cities") query_end_at = cities_ref.order_by("population").end_at( {"population": 1000000}) # [END firestore_query_cursor_end_at_field_value_single_async] return query_end_at
async def quickstart_add_data_two(): db = firestore.AsyncClient() # [START firestore_setup_dataset_pt2_async] doc_ref = db.collection("users").document("aturing") await doc_ref.set({ "first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912 })
async def get_check_exists(): db = firestore.AsyncClient() # [START firestore_data_get_as_map_async] doc_ref = db.collection("cities").document("SF") doc = await doc_ref.get() if doc.exists: print(f"Document data: {doc.to_dict()}") else: print("No such document!")
async def array_contains_filter(): db = firestore.AsyncClient() # [START firestore_query_filter_array_contains_async] cities_ref = db.collection("cities") query = cities_ref.where("regions", "array_contains", "west_coast") # [END firestore_query_filter_array_contains_async] docs = query.stream() async for doc in docs: print(f"{doc.id} => {doc.to_dict()}")
async def update_doc(): db = firestore.AsyncClient() await db.collection("cities").document("DC").set( City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()) # [START firestore_data_set_field_async] city_ref = db.collection("cities").document("DC") # Set the capital field await city_ref.update({"capital": True})