a !f;@@sdZddlmZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z mZmZmZmZmZdd lmZdd lmZdd lmZdd lmZmZmZmZmZmZGd ddeZGdddee Z dS)a+Classes for representing queries for the Google Cloud Firestore API. A :class:`~google.cloud.firestore_v1.query.Query` can be created directly from a :class:`~google.cloud.firestore_v1.collection.Collection` and that can be a more common way to create a query than direct usage of the constructor. ) annotations) firestore_v1)DocumentSnapshot) exceptions)gapic_v1)retry)BaseCollectionGroup BaseQueryQueryPartition_query_response_to_snapshot,_collection_group_query_response_to_snapshot_enum_from_direction) aggregation)document)Watch)AnyCallable GeneratorListOptionalTypec seZdZdZd(ddfdd Zdejjdfd d d d d dZdddddZ ddZ ddZ d)dddddZ dejjdfd d dd ddZ d d!d"d#d$Zed%dd&d'ZZS)*Querya Represents a query to the Firestore API. Instances of this class are considered immutable: all methods that would modify an instance instead return a new instance. Args: parent (:class:`~google.cloud.firestore_v1.collection.CollectionReference`): The collection that this query applies to. projection (Optional[:class:`google.cloud.proto.firestore.v1. query.StructuredQuery.Projection`]): A projection of document fields to limit the query results to. field_filters (Optional[Tuple[:class:`google.cloud.proto.firestore.v1. query.StructuredQuery.FieldFilter`, ...]]): The filters to be applied in the query. orders (Optional[Tuple[:class:`google.cloud.proto.firestore.v1. query.StructuredQuery.Order`, ...]]): The "order by" entries to use in the query. limit (Optional[int]): The maximum number of documents the query is allowed to return. offset (Optional[int]): The number of results to skip. start_at (Optional[Tuple[dict, bool]]): Two-tuple of : * a mapping of fields. Any field that is present in this mapping must also be present in ``orders`` * an ``after`` flag The fields and the flag combine to form a cursor used as a starting point in a query result set. If the ``after`` flag is :data:`True`, the results will start just after any documents which have fields matching the cursor, otherwise any matching documents will be included in the result set. When the query is formed, the document values will be used in the order given by ``orders``. end_at (Optional[Tuple[dict, bool]]): Two-tuple of: * a mapping of fields. Any field that is present in this mapping must also be present in ``orders`` * a ``before`` flag The fields and the flag combine to form a cursor used as an ending point in a query result set. If the ``before`` flag is :data:`True`, the results will end just before any documents which have fields matching the cursor, otherwise any matching documents will be included in the result set. When the query is formed, the document values will be used in the order given by ``orders``. all_descendants (Optional[bool]): When false, selects only collections that are immediate children of the `parent` specified in the containing `RunQueryRequest`. When true, selects all descendant collections. NFNonereturnc s*tt|j||||||||| | | d dSN) parent projection field_filtersorderslimit limit_to_lastoffsetstart_atend_atall_descendants recursive)superr__init__ selfrrrr r!r"r#r$r%r&r' __class__r`/var/www/html/python-backend/venv/lib/python3.9/site-packages/google/cloud/firestore_v1/query.pyr)ds zQuery.__init__ retries.RetryfloatzList[DocumentSnapshot]rtimeoutrcCsf|j}|jr>|jD]$}t|jj|jkr,|jn|j|_qd|_|j|||d}|r^tt |}t |S)aRead the documents in the collection that match this query. This sends a ``RunQuery`` RPC and returns a list of documents returned in the stream of ``RunQueryResponse`` messages. Args: transaction (Optional[:class:`~google.cloud.firestore_v1.transaction.Transaction`]): An existing transaction that this query will run in. If a ``transaction`` is used and it already has write operations added, this method cannot be used (i.e. read-after-write is not allowed). retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. Defaults to a system-specified policy. timeout (float): The timeout for this request. Defaults to a system-specified value. Returns: list: The documents in the collection that match this query. F) transactionrr2) Z_limit_to_lastZ_ordersr directionnameZ ASCENDINGZ DESCENDINGstreamreversedlist)r+r3rr2Zis_limited_to_lastorderresultrrr.gets   z Query.getintz-Generator[List[DocumentSnapshot], None, None]) chunk_sizerc cs|j}d}|}d}|||}||}|r:||}|}|rN|d}|t|7}|Vt||ksx|r||krdSqdS)Nr)_limitZ_copyZ_resolve_chunk_sizer! start_afterr;len) r+r=Z max_to_returnZ num_returnedoriginalZ last_document _chunk_sizeZ_qZ snapshotsrrr. _chunkifys&     zQuery._chunkifycCs:||||\}}}|jjjf||jjd|}||fS)!Helper method for :meth:`stream`.requestmetadata)Z _prep_stream_client_firestore_api run_query _rpc_metadata)r+r3rr2rGexpected_prefixkwargsresponse_iteratorrrr._get_stream_iterators  zQuery._get_stream_iteratorcCs8|dur4|tjjur*|jjj}|j}|j}||SdS)rENF) rmethodDEFAULTrIrJ _transportrKZ_retryZ _predicate)r+excrr3 transportZgapic_callablerrr._retry_query_after_exceptions   z"Query._retry_query_after_exceptionz str | Nonez1Type['firestore_v1.aggregation.AggregationQuery'])aliasrcCst|j|dS)z Adds a count over the query. :type alias: str :param alias: (Optional) The alias for the count )rW)rZAggregationQuerycount)r+rWrrr.rXs z Query.countz/Generator[document.DocumentSnapshot, Any, None]c cs||||\}}d}zt|d}Wn`tjy}zF||||rn||} | |||\}} WYd}~qnWYd}~n d}~00|durq|jrt||j} nt ||j|} | dur| }| VqdS)a"Read the documents in the collection that match this query. This sends a ``RunQuery`` RPC and then returns an iterator which consumes each document returned in the stream of ``RunQueryResponse`` messages. .. note:: The underlying stream of responses will time out after the ``max_rpc_timeout_millis`` value set in the GAPIC client configuration for the ``RunQuery`` API. Snapshots not consumed from the iterator before that point will be lost. If a ``transaction`` is used and it already has write operations added, this method cannot be used (i.e. read-after-write is not allowed). Args: transaction (Optional[:class:`~google.cloud.firestore_v1.transaction.Transaction`]): An existing transaction that this query will run in. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. Defaults to a system-specified policy. timeout (float): The timeout for this request. Defaults to a system-specified value. Yields: :class:`~google.cloud.firestore_v1.document.DocumentSnapshot`: The next document that fulfills the query. N) rPnextrZGoogleAPICallErrorrVr@Z_all_descendantsr _parentr ) r+r3rr2rOrMZ last_snapshotresponserTZ new_query_Zsnapshotrrr.r6s<$ z Query.streamrr)callbackrcCst||tjS)aMonitor the documents in this collection that match this query. This starts a watch on this query using a background thread. The provided callback is run on the snapshot of the documents. Args: callback(Callable[[:class:`~google.cloud.firestore.query.QuerySnapshot`], NoneType]): a callback to run when a change occurs. Example: .. code-block:: python from google.cloud import firestore_v1 db = firestore_v1.Client() query_ref = db.collection(u'users').where("user", "==", u'Ada') def on_snapshot(docs, changes, read_time): for doc in docs: print(u'{} => {}'.format(doc.id, doc.to_dict())) # Watch this query query_watch = query_ref.on_snapshot(on_snapshot) # Terminate this watch query_watch.unsubscribe() )rZ for_queryrr)r+r]rrr. on_snapshotEszQuery.on_snapshotz3Type['firestore_v1.collection.CollectionReference']cCsddlm}|S)NrCollectionReference)Z$google.cloud.firestore_v1.collectionr`r_rrr._get_collection_reference_classds z%Query._get_collection_reference_class) NrrNFNNNFF)N)__name__ __module__ __qualname____doc__r)rrQrRr;rDrPrVrXr6r^ staticmethodra __classcell__rrr,r.r,s8:.'  Jrc sPeZdZdZdddfdd Zed d Zejj dfd d ddddZ Z S)CollectionGroupa}Represents a Collection Group in the Firestore API. This is a specialization of :class:`.Query` that includes all documents in the database that are contained in a collection or subcollection of the given parent. Args: parent (:class:`~google.cloud.firestore_v1.collection.CollectionReference`): The collection that this query applies to. NrFTrrc s*tt|j||||||||| | | d dSr)r(rhr)r*r,rr.r)ys zCollectionGroup.__init__cCstS)N)rrrrr._get_query_classsz CollectionGroup._get_query_classr/r0z%Generator[QueryPartition, None, None]r1c csv||||\}}|jjjf||jjd|}d}|D]*}|j|jdj} t||| V| }q8t||dVdS)a Partition a query for parallelization. Partitions a query by returning partition cursors that can be used to run the query in parallel. The returned partition cursors are split points that can be used as starting/end points for the query results. Args: partition_count (int): The desired maximum number of partition points. The number must be strictly positive. The actual number of partitions returned may be fewer. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. Defaults to a system-specified policy. timeout (float): The timeout for this request. Defaults to a system-specified value. rFNr) Z_prep_get_partitionsrIrJZpartition_queryrLrvaluesZreference_valuer ) r+Zpartition_countrr2rGrNpagerr$Z cursor_pbcursorrrr.get_partitionss zCollectionGroup.get_partitions) NrrNFNNNTF) rbrcrdrer)rfrirrQrRrmrgrrr,r.rhms" rhN)!re __future__rZ google.cloudrZ'google.cloud.firestore_v1.base_documentrZgoogle.api_corerrrretriesZ$google.cloud.firestore_v1.base_queryrr r r r r Zgoogle.cloud.firestore_v1rrZgoogle.cloud.firestore_v1.watchrtypingrrrrrrrrhrrrr.s           C