o ˷e@sjUdZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z ddlm Z dd lmZdd lmZdd lmZdd lmZdd lmZddlmZmZmZmZmZmZmZmZmZddlm Z e!e"d<e!e"d<e!e"d<ee!efe"d<e!e"d<e!e"d<e!e"d<e!e"d<e!e"d<e!e"d<ee"d<dZ#ej$j%Z&de&j'de&j(e#e&j)de&j*de&j+d e&j,d!e&j-d"e&j.d#e&j/d$e&j0i Z1d%Z2d&Z3d'Z4d(Z5d)Z6d*Z7d+Z8d,Z9e:Z;Gd-d.d.e:Zd0e?fd3d4Z@d5e!d0e=fd6d7ZAd0ejBfd8d9ZCd:eeDe?fd0eefd;d<ZEd=ed>e!d0ee j fd?d@ZFd=ed0ee j fdAdBZGGdCdDdDe<ZHGdEdFdFZIdS)Ga+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. N)retry) wrappers_pb2)_helpers)document field_path) transforms)StructuredQuery)query)Cursor)RunQueryResponse)Order) AnyDict GeneratorIterableNoReturnOptionalTupleTypeUnion)DocumentSnapshot_BAD_DIR_STRING_BAD_OP_NAN_NULL_BAD_OP_STRING_COMPARISON_OPERATORS_EQ_OP_INVALID_CURSOR_TRANSFORM_INVALID_WHERE_TRANSFORM_MISMATCH_CURSOR_W_ORDER_BY_MISSING_ORDER_BY_NO_ORDERS_FOR_CURSOR_operator_enumz===>array_containsinznot-inarray_contains_anyz7Operator string {!r} is invalid. Valid choices are: {}.zBOnly an equality filter ("==") can be used with None or NaN valuesz*Transforms cannot be used as where values.z4Invalid direction {!r}. Must be one of {!r} or {!r}.z+Transforms cannot be used as cursor values.zThe "order by" field path {!r} is not present in the cursor data {!r}. All fields sent to ``order_by()`` must be present in the fields if passed to one of ``start_at()`` / ``start_after()`` / ``end_before()`` / ``end_at()`` to define a cursor.zAttempting to create a cursor with no fields to order on. When defining a cursor with one of ``start_at()`` / ``start_after()`` / ``end_before()`` / ``end_at()``, all fields in the cursor must come from fields set in ``order_by()``.z5The cursor {!r} does not match the order fields {!r}.c@s<eZdZdZdZ dZ          d\ d]dd Zd d Zed d Z de e ddfddZ e e e e e e e e e e d deejjdeeejjdeeejjdeedeedeedeeeefdeeeefdeedeeddfddZddZd e d!e ddfd"d#Zedejfd$d%Zefd e d&e ddfd'd(Zd)eddfd*d+Zd)eddfd,d-Zd.ed/edefd0d1Z d2eddfd3d4Z!d]d5d6Z"d7e#e$ee%e&fd8ed9eddfd:d;Z'd7e#e$ee%e&fddfdd?Z)d7e#e$ee%e&fddfd@dAZ*d7e#e$ee%e&fddfdBdCZ+dej,fdDdEZ-edejfdFdGZ.de%fdHdIZ/deee0e0ffdJdKZ1defdLdMZ2   d^dNe3j4dOe5de e$fdPdQZ6   d^dNe3j4dOe5deee effdRdSZ7   d^dNe3j4dOe5de8e9j$e0dffdTdUZ:de;fdVdWZdS)` BaseQuerya 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. limit_to_last (Optional[bool]): Denotes whether a provided limit is applied to the end of the result set. 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. recursive (Optional[bool]): When true, returns all documents and all documents in any subcollections below them. Defaults to false. ASCENDING DESCENDINGNFreturnc CsF||_||_||_||_||_||_||_||_| |_| |_ | |_ dSN) _parent _projection_field_filters_orders_limit_limit_to_last_offset _start_at_end_at_all_descendants _recursive selfparent projection field_filtersorderslimit limit_to_lastoffsetstart_atend_atall_descendants recursiver+r+[/var/www/ideatree/venv/lib/python3.10/site-packages/google/cloud/firestore_v1/base_query.py__init__s zBaseQuery.__init__cCst||jstS|j|jkoC|j|jkoC|j|jkoC|j|jkoC|j|jkoC|j|jkoC|j |j koC|j |j koC|j |j koC|j |j kSr-) isinstance __class__NotImplementedr.r/r0r1r2r3r4r5r6r7)r:otherr+r+rF__eq__s*           zBaseQuery.__eq__cCs|jjS)zThe client of the parent collection. Returns: :class:`~google.cloud.firestore_v1.client.Client`: The client that owns this query. )r._clientr:r+r+rFrMszBaseQuery._client field_pathscCs@t|}|D]}t|qtjjdd|Dd}|j|dS)afProject documents matching query to a limited set of fields. See :meth:`~google.cloud.firestore_v1.client.Client.field_path` for more information on **field paths**. If the current query already has a projection set (i.e. has already called :meth:`~google.cloud.firestore_v1.query.Query.select`), this will overwrite it. Args: field_paths (Iterable[str, ...]): An iterable of field paths (``.``-delimited list of field names) to use as a projection of document fields in the query results. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A "projected" query. Acts as a copy of the current query, modified with the newly added projection. Raises: ValueError: If any ``field_path`` is invalid. cSsg|] }tjj|dqS)r)r r FieldReference).0rr+r+rF s z$BaseQuery.select..fields)r<)listfield_path_modulesplit_field_pathr r Projection_copy)r:rOrnew_projectionr+r+rFselects  zBaseQuery.select r<r=r>r?r@rArBrCrDrEr<r=r>r?r@rArBrCrDrEc Cs|j|j|||j|||j|||j|||j|||j|||j|||j |||j || |j || |j d S)Nr\) rIr._evaluate_paramr/r0r1r2r3r4r5r6r7r8) r:r<r=r>r?r@rArBrCrDrEr+r+rFrYs         zBaseQuery._copycCs|tur|S|S)zHelper which allows `None` to be passed into `copy` and be set on the copy instead of being misinterpreted as an unpassed parameter.) _not_passed)r:valuefallback_valuer+r+rFr]szBaseQuery._evaluate_paramr op_stringcCst||dur"|tkrtttjjtjj|dtjj j d}n=t |r?|tkr.tttjjtjj|dtjj j d}n t |tjtjfrLtttjjtjj|dt|t|d}|j|f}|j|dS)aMFilter the query on a field. See :meth:`~google.cloud.firestore_v1.client.Client.field_path` for more information on **field paths**. Returns a new :class:`~google.cloud.firestore_v1.query.Query` that filters on a specific field path, according to an operation (e.g. ``==`` or "equals") and a particular value to be paired with that operation. Args: field_path (str): A field path (``.``-delimited list of field names) for the field to filter on. op_string (str): A comparison operation in the form of a string. Acceptable values are ``<``, ``<=``, ``==``, ``!=``, ``>=``, ``>``, ``in``, ``not-in``, ``array_contains`` and ``array_contains_any``. value (Any): The value to compare the field against in the filter. If ``value`` is :data:`None` or a NaN, then ``==`` is the only allowed operation. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A filtered query. Acts as a copy of the current query, modified with the newly added filter. Raises: ValueError: If ``field_path`` is invalid. ValueError: If ``value`` is a NaN or :data:`None` and ``op_string`` is not ``==``. Nr)fieldop)rbrcr_)r=)rVrWr ValueErrorrr r UnaryFilterrPOperatorIS_NULL_isnanIS_NANrHrSentinel _ValueListr FieldFilter_enum_from_op_stringr encode_valuer0rY)r:rrar_ filter_pb new_filtersr+r+rFwhere s0      zBaseQuery.wherecCstjjtjj|dt|dS)zHelper for :meth:`order_by`.rrb direction)r r r rP_enum_from_direction)rrsr+r+rF _make_order[s zBaseQuery._make_orderrscCs.t||||}|j|f}|j|dS)a|Modify the query to add an order clause on a specific field. See :meth:`~google.cloud.firestore_v1.client.Client.field_path` for more information on **field paths**. Successive :meth:`~google.cloud.firestore_v1.query.Query.order_by` calls will further refine the ordering of results returned by the query (i.e. the new "order by" fields will be added to existing ones). Args: field_path (str): A field path (``.``-delimited list of field names) on which to order the query results. direction (Optional[str]): The direction to order by. Must be one of :attr:`ASCENDING` or :attr:`DESCENDING`, defaults to :attr:`ASCENDING`. Returns: :class:`~google.cloud.firestore_v1.query.Query`: An ordered query. Acts as a copy of the current query, modified with the newly added "order by" constraint. Raises: ValueError: If ``field_path`` is invalid. ValueError: If ``direction`` is not one of :attr:`ASCENDING` or :attr:`DESCENDING`. )r>)rVrWrur1rY)r:rrsorder_pb new_ordersr+r+rForder_bycs    zBaseQuery.order_bycountcC|j|ddS)agLimit a query to return at most `count` matching results. If the current query already has a `limit` set, this will override it. .. note:: `limit` and `limit_to_last` are mutually exclusive. Setting `limit` will drop previously set `limit_to_last`. Args: count (int): Maximum number of documents to return that match the query. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A limited query. Acts as a copy of the current query, modified with the newly added "limit" filter. Fr?r@rYr:ryr+r+rFr?zBaseQuery.limitcCrz)awLimit a query to return the last `count` matching results. If the current query already has a `limit_to_last` set, this will override it. .. note:: `limit` and `limit_to_last` are mutually exclusive. Setting `limit_to_last` will drop previously set `limit`. Args: count (int): Maximum number of documents to return that match the query. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A limited query. Acts as a copy of the current query, modified with the newly added "limit" filter. Tr{r|r}r+r+rFr@r~zBaseQuery.limit_to_last num_loaded chunk_sizecCs,|jdur|||jkrt|j|dS|S)zUtility function for chunkify.Nr)r2max)r:rrr+r+rF_resolve_chunk_sizeszBaseQuery._resolve_chunk_size num_to_skipcCs |j|dS)aSkip to an offset in a query. If the current query already has specified an offset, this will overwrite it. Args: num_to_skip (int): The number of results to skip at the beginning of query results. (Must be non-negative.) Returns: :class:`~google.cloud.firestore_v1.query.Query`: An offset query. Acts as a copy of the current query, modified with the newly added "offset" field. )rAr|)r:rr+r+rFrAs zBaseQuery.offsetcCs.|jrdS|jjdd|jjkrtddS)zValidate local snapshots for non-collection-group queries. Raises: ValueError: for non-collection-group queries, if the snapshot is from a different collection. Nz8Cannot use snapshot from another collection as a cursor.)r7 reference_pathr.rd)r:document_snapshotr+r+rF_check_snapshots zBaseQuery._check_snapshotdocument_fields_or_snapshotbeforestartcCst|tr t|}nt|tjr||nt|}||f}|j|j |j |j |j |j d}|r:||d<|j|d<n |j|d<||d<|jdi|S)aSet values to be used for a ``start_at`` or ``end_at`` cursor. The values will later be used in a query protobuf. When the query is sent to the server, the ``document_fields_or_snapshot`` will be used in the order given by fields set by :meth:`~google.cloud.firestore_v1.query.Query.order_by`. Args: document_fields_or_snapshot (Union[:class:`~google.cloud.firestore_v1.document.DocumentSnapshot`, dict, list, tuple]): a document snapshot or a dictionary/list/tuple of fields representing a query results cursor. A cursor is a collection of values that represent a position in a query result set. before (bool): Flag indicating if the document in ``document_fields_or_snapshot`` should (:data:`False`) or shouldn't (:data:`True`) be included in the result set. start (Optional[bool]): determines if the cursor is a ``start_at`` cursor (:data:`True`) or an ``end_at`` cursor (:data:`False`). Returns: :class:`~google.cloud.firestore_v1.query.Query`: A query with cursor. Acts as a copy of the current query, modified with the newly added "start at" cursor. )r<r=r>r?rArDrBrCNr+)rHtuplerUrrrcopydeepcopyr/r0r1r2r4r7r6r5rY)r:rrr cursor_pair query_kwargsr+r+rF_cursor_helpers&       zBaseQuery._cursor_helpercC|j|dddS)aStart query results at a particular document value. The result set will **include** the document specified by ``document_fields_or_snapshot``. If the current query already has specified a start cursor -- either via this method or :meth:`~google.cloud.firestore_v1.query.Query.start_after` -- this will overwrite it. When the query is sent to the server, the ``document_fields`` will be used in the order given by fields set by :meth:`~google.cloud.firestore_v1.query.Query.order_by`. Args: document_fields_or_snapshot (Union[:class:`~google.cloud.firestore_v1.document.DocumentSnapshot`, dict, list, tuple]): a document snapshot or a dictionary/list/tuple of fields representing a query results cursor. A cursor is a collection of values that represent a position in a query result set. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A query with cursor. Acts as a copy of the current query, modified with the newly added "start at" cursor. Trrrr:rr+r+rFrBszBaseQuery.start_atcC|j|dddS)aStart query results after a particular document value. The result set will **exclude** the document specified by ``document_fields_or_snapshot``. If the current query already has specified a start cursor -- either via this method or :meth:`~google.cloud.firestore_v1.query.Query.start_at` -- this will overwrite it. When the query is sent to the server, the ``document_fields_or_snapshot`` will be used in the order given by fields set by :meth:`~google.cloud.firestore_v1.query.Query.order_by`. Args: document_fields_or_snapshot (Union[:class:`~google.cloud.firestore_v1.document.DocumentSnapshot`, dict, list, tuple]): a document snapshot or a dictionary/list/tuple of fields representing a query results cursor. A cursor is a collection of values that represent a position in a query result set. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A query with cursor. Acts as a copy of the current query, modified with the newly added "start after" cursor. FTrrrr+r+rF start_after(zBaseQuery.start_aftercCr)aEnd query results before a particular document value. The result set will **exclude** the document specified by ``document_fields_or_snapshot``. If the current query already has specified an end cursor -- either via this method or :meth:`~google.cloud.firestore_v1.query.Query.end_at` -- this will overwrite it. When the query is sent to the server, the ``document_fields_or_snapshot`` will be used in the order given by fields set by :meth:`~google.cloud.firestore_v1.query.Query.order_by`. Args: document_fields_or_snapshot (Union[:class:`~google.cloud.firestore_v1.document.DocumentSnapshot`, dict, list, tuple]): a document snapshot or a dictionary/list/tuple of fields representing a query results cursor. A cursor is a collection of values that represent a position in a query result set. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A query with cursor. Acts as a copy of the current query, modified with the newly added "end before" cursor. TFrrrr+r+rF end_beforeIrzBaseQuery.end_beforecCr)aEnd query results at a particular document value. The result set will **include** the document specified by ``document_fields_or_snapshot``. If the current query already has specified an end cursor -- either via this method or :meth:`~google.cloud.firestore_v1.query.Query.end_before` -- this will overwrite it. When the query is sent to the server, the ``document_fields_or_snapshot`` will be used in the order given by fields set by :meth:`~google.cloud.firestore_v1.query.Query.order_by`. Args: document_fields_or_snapshot (Union[:class:`~google.cloud.firestore_v1.document.DocumentSnapshot`, dict, list, tuple]): a document snapshot or a dictionary/list/tuple of fields representing a query results cursor. A cursor is a collection of values that represent a position in a query result set. Returns: :class:`~google.cloud.firestore_v1.query.Query`: A query with cursor. Acts as a copy of the current query, modified with the newly added "end at" cursor. Frrrr+r+rFrCjrzBaseQuery.end_atcCs\t|j}|dkr dS|dkrt|jdStjjtjjjdd|jDd}tjj|dS)acConvert all the filters into a single generic Filter protobuf. This may be a lone field filter or unary filter, may be a composite filter or may be :data:`None`. Returns: :class:`google.cloud.firestore_v1.types.StructuredQuery.Filter`: A "generic" filter representing the current query's filters. rNcSsg|]}t|qSr+) _filter_pb)rQfilter_r+r+rFrRz)BaseQuery._filters_pb..)rcfilters)composite_filter) lenr0rr r CompositeFilterrfANDFilter)r: num_filtersrr+r+rF _filters_pbs zBaseQuery._filters_pbcCs8|durt|j}|stjjdd}tjj|gdS|S)z(Helper: convert field paths to message.N__name__rrS)rUrTr r rPrX)r<rT field_refr+r+rF_normalize_projections  zBaseQuery._normalize_projectioncCst|j}d}|jrt|jdtjrd}|jr#t|jdtjr#d}|r}ddtD}dd|D}|jD] }t|j t j j rV|j j}|j |vrV||vrV|||dq6|sd||dd|Sd d|D}d|vr}|d j}||d||S) z7Helper: adjust orders based on cursors, where clauses.FrTcSs g|] }|tdfvrt|qS)r%)rrm)rQkeyr+r+rFrRs  z/BaseQuery._normalize_orders..cSg|]}|jjqSr+rbrrQorderr+r+rFrRrr)rcSrr+rrr+r+rFrRrr)rUr1r5rHrrr6rr0rcr rlrfrbrappendrurs)r:r>_has_snapshot_cursor should_order order_keysrrbrsr+r+rF_normalize_orderss6   zBaseQuery._normalize_ordersc Cs`|durdS|s tt|\}}dd|D}t|tjr(|}|}|j|d<t|trfg}|}|dt|D]*} z| |vrH| || n | t | |Wq9t yct | |} t| w|}|rzt|t|krzt||} t| tjtjf} tt||D]$\} } | \}}t|| rt} t| |dkrt|tr|j||| <q||fS)z;Helper: convert cursor to a list of values based on orders.NcSrr+rrr+r+rFrRrz/BaseQuery._normalize_cursor..r)rdr!rHrrto_dictrdictrrrVget_nested_valueKeyErrorr formatrrrjrk enumerateziprstrr.)r:cursorr>document_fieldsrrsnapshotvaluesdata order_keymsg_transform_basesindex key_fieldrrbr+r+rF_normalize_cursorsN         zBaseQuery._normalize_cursorcCs||j}|}||j|}||j|}|tjj|j j |j dg| |t |t |d}|jdur;|j|d<|jdurItj|jd|d<tjdi|S)zConvert the current query into the equivalent protobuf. Returns: :class:`google.cloud.firestore_v1.types.StructuredQuery`: The query protobuf. ) collection_idrD)r[from_rqrxrBrCNrAr_r?r+)rr/rrr5r6r r CollectionSelectorr.idr7r _cursor_pbr4r2r Int32Value)r:r<r>rBrCrr+r+rF _to_protobuf s&    zBaseQuery._to_protobufrtimeoutcCtr-NotImplementedErrorr: transactionrrr+r+rFget)z BaseQuery.getcCsH|jrtd|j\}}||t|d}t||}|||fS)z,Shared setup for async / sync :meth:`stream`zoQuery results for queries that include limit_to_last() constraints cannot be streamed. Use Query.get() instead.)r;structured_queryr)r3rdr. _parent_inforrget_transaction_idmake_retry_timeout_kwargs)r:rrr parent_pathexpected_prefixrequestkwargsr+r+rF _prep_stream1s  zBaseQuery._prep_streamcCrr-rrr+r+rFstreamHrzBaseQuery.streamcCrr-r)r:callbackr+r+rF on_snapshotPzBaseQuery.on_snapshotcCs|jddd}|jrN|jjrNd|jj}|d|_|jj|j_d}|d|}d}||d|}|tj  tj |i tj |i}|S)aReturns a copy of this query whose iterator will yield all matching documents as well as each of their descendent subcollections and documents. This differs from the `all_descendents` flag, which only returns descendents whose subcollection names match the parent collection's name. To return all descendents, regardless of their subcollection name, use this. T)rErD/z__id-9223372036854775808__) rYr.rjoinr_get_collection_reference_classrMrxrV FieldPath document_idrBrC)r:copiedoriginal_collection_idREFERENCE_NAME_MIN_IDrBnullCharrCr+r+rFrESs zBaseQuery.recursivec Cs|j}t|dkr tj}n|djdkrtj}ntj}t|}tjj tjj ddt |d}| ||D]P}|j jdkrIt |jj|jj}n1|j j|jvsW|j j|jvr[td|j|j j} |j|j j} t| } t| } t | | }|dkr|j|Sq5dS)NrrrrrrrzCan only compare fields that exist in the DocumentSnapshot. Please include the fields you are ordering on in your select() call.)r1rr(r)rsr*rUr r r rPrtrrbr _compare_torr_datardrrncompare) r:doc1doc2r1 lastDirectionorderBysrvorderBycompv1v2 encoded_v1 encoded_v2r+r+rF _comparator{s:      zBaseQuery._comparator) Nr+r+NFNNNFFr,N)NNN)r,r()?r __module__ __qualname____doc__r)r*rGrLpropertyrMrrr[r^rr r rXrrlr intboolrrYr]rq staticmethodrurxr?r@rrArrrrUrrrBrrrCrrrrrrrretriesRetryfloatrrrrrrrrErr+r+r+rFr(es <   %      ;"   9   ! ! ! %8       (r(rar,cCs@zt|WStydtt}t||}t|w)aConvert a string representation of a binary operator to an enum. These enums come from the protobuf message definition ``StructuredQuery.FieldFilter.Operator``. Args: op_string (str): A comparison operation in the form of a string. Acceptable values are ``<``, ``<=``, ``==``, ``!=``, ``>=`` and ``>``. Returns: int: The enum corresponding to ``op_string``. Raises: ValueError: If ``op_string`` is not a valid operator. z, )rrrsortedkeysrrrd)rachoicesrr+r+rFrms   rmcCst|tr t|SdS)zCheck if a value is NaN. This differs from ``math.isnan`` in that **any** input type is allowed. Args: value (Any): A value to check for NaN-ness. Returns: bool: Indicates if the value is the NaN float. F)rHrmathisnanrr+r+rFrhs rhrscCsLt|tr|S|tjkrtjjS|tjkrtjjSt|tjtj}t |)aConvert a string representation of a direction to an enum. Args: direction (str): A direction to order by. Must be one of :attr:`~google.cloud.firestore.BaseQuery.ASCENDING` or :attr:`~google.cloud.firestore.BaseQuery.DESCENDING`. Returns: int: The enum corresponding to ``direction``. Raises: ValueError: If ``direction`` is not a valid direction. ) rHrr(r)r Directionr*rrrd)rsrr+r+rFrts    rtcCsHt|tjjrtjj|dSt|tjjrtjj|dStdt||)aConvert a specific protobuf filter to the generic filter type. Args: field_or_unary (Union[google.cloud.proto.firestore.v1. query.StructuredQuery.FieldFilter, google.cloud.proto. firestore.v1.query.StructuredQuery.FieldFilter]): A field or unary filter to convert to a generic filter. Returns: google.cloud.firestore_v1.types. StructuredQuery.Filter: A "generic" filter. Raises: ValueError: If ``field_or_unary`` is not a field or unary filter. ) field_filter) unary_filterzUnexpected filter type)rHr r rlrrerdtype)field_or_unaryr+r+rFrs rrcCs0|dur|\}}dd|D}tj||dSdS)a~Convert a cursor pair to a protobuf. If ``cursor_pair`` is :data:`None`, just returns :data:`None`. Args: cursor_pair (Optional[Tuple[list, bool]]): Two-tuple of * a list of field values. * a ``before`` flag Returns: Optional[google.cloud.firestore_v1.types.Cursor]: A protobuf cursor corresponding to the values. NcSsg|]}t|qSr+)rrn)rQr_r+r+rFrRsz_cursor_pb..)rr)r r )rrr value_pbsr+r+rFr s r response_pbrcCs^|jdsdSt|j|}||}t|jj|j}tj||d|j |jj |jj d}|S)aParse a query response protobuf to a document snapshot. Args: response_pb (google.cloud.proto.firestore.v1. firestore.RunQueryResponse): A collection (:class:`~google.cloud.firestore_v1.collection.CollectionReference`): A reference to the collection that initiated the query. expected_prefix (str): The expected prefix for fully-qualified document names returned in the query results. This can be computed directly from ``collection`` via :meth:`_parent_info`. Returns: Optional[:class:`~google.cloud.firestore.document.DocumentSnapshot`]: A snapshot of the data returned in the query. If ``response_pb.document`` is not set, the snapshot will be :data:`None`. rNTexists read_time create_time update_time) _pbHasFieldr get_doc_idr decode_dictrTrMrrrr)r collectionrrrrrr+r+rF_query_response_to_snapshots  rcCs\|jdsdS|j|jj}t|jj|j}tj||d|jj |jjj |jjj d}|S)a)Parse a query response protobuf to a document snapshot. Args: response_pb (google.cloud.proto.firestore.v1. firestore.RunQueryResponse): A collection (:class:`~google.cloud.firestore_v1.collection.CollectionReference`): A reference to the collection that initiated the query. Returns: Optional[:class:`~google.cloud.firestore.document.DocumentSnapshot`]: A snapshot of the data returned in the query. If ``response_pb.document`` is not set, the snapshot will be :data:`None`. rNTr) rrrMrnamerrrTrrrr)rrrrrr+r+rF,_collection_group_query_response_to_snapshotBs rc seZdZdZeejej fZ          d dfdd Z d d Z d d Z  dd ejdedeeeffddZ  dd ejdedefddZededfddZZS)BaseCollectionGroupa}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. Nr+FTr,c s6| stdtt|j||||||||| | | d dS)Nz8all_descendants must be True for collection group query.) r;r<r=r>r?r@rArBrCrDrE)rdsuperr rGr9rIr+rFrGts  zBaseCollectionGroup.__init__cCs<|jrtd|jrtd|jrtd|jrtddS)Nz#Can't partition query with filters.z&Can't partition query with projection.z!Can't partition query with limit.z"Can't partition query with offset.)r0rdr/r2r4rNr+r+rF_validate_partition_querysz-BaseCollectionGroup._validate_partition_querycCrr-rrNr+r+rF_get_query_classrz$BaseCollectionGroup._get_query_classrrc Cs^||j\}}|}||j|j|j|j|jd}|||d}t ||} || fS)N)r>rBrCrD)r;rpartition_count) r#r.rr$_PARTITION_QUERY_ORDERr5r6r7rrr) r:r%rrrrklassr rrr+r+rF_prep_get_partitionss  z(BaseCollectionGroup._prep_get_partitionscCrr-r)r:r%rrr+r+rFget_partitionsrz"BaseCollectionGroup.get_partitionscCrr-rr+r+r+rFrsz3BaseCollectionGroup._get_collection_reference_class) Nr+r+NFNNNTFr)NN)rrrrr(rurVrrr)r&rGr#r$rrrrrr(rr)rrr __classcell__r+r+r"rFr asT       r c@s8eZdZdZddZeddZeddZdd Zd S) QueryPartitionaMRepresents a bounded partition of a collection group query. Contains cursors that can be used in a query as a starting and/or end point for the collection group query. The cursors may only be used in a query that matches the constraints of the query that produced this partition. Args: query (BaseQuery): The original query that this is a partition of. start_at (Optional[~google.cloud.firestore_v1.document.DocumentSnapshot]): Cursor for first query result to include. If `None`, the partition starts at the beginning of the result set. end_at (Optional[~google.cloud.firestore_v1.document.DocumentSnapshot]): Cursor for first query result after the last result included in the partition. If `None`, the partition runs to the end of the result set. cCs||_||_||_dSr-)_queryr5r6r:r rBrCr+r+rFrGs zQueryPartition.__init__cC|jSr-)r5rNr+r+rFrBzQueryPartition.start_atcCr.r-)r6rNr+r+rFrCr/zQueryPartition.end_atcCsN|j}|jr |jgdfnd}|jr|jgdfnd}t||j|j|j||dS)zGenerate a new query using this partition's bounds. Returns: BaseQuery: Copy of the original query with start and end bounds set by the cursors from this partition. TN)rDr>rBrC)r,rBrCrr.r7r&r-r+r+rFr szQueryPartition.queryN) rrrrrGrrBrCr r+r+r+rFr+s   r+)Jrrr google.api_corerrgoogle.protobufrgoogle.cloud.firestore_v1rrrrVrgoogle.cloud.firestore_v1.typesr r r r google.cloud.firestore_v1.orderr typingrrrrrrrrr'google.cloud.firestore_v1.base_documentrr__annotations__rrlrfr" LESS_THANLESS_THAN_OR_EQUALEQUAL NOT_EQUALGREATER_THAN_OR_EQUAL GREATER_THANARRAY_CONTAINSINNOT_INARRAY_CONTAINS_ANYrrrrrrr r!robjectr^r(rrmrrhrtrrrUrrrr r+r+r+r+rFs           ,  K $ h