def build_updated_request(self): """Updates the given message request as per last scanned key""" r_kwargs = { "table_name": self.message.table_name, "filter": self.message.filter, } if self.message.rows_limit != 0: r_kwargs["rows_limit"] = max( 1, self.message.rows_limit - self.rows_read_so_far ) # if neither RowSet.row_keys nor RowSet.row_ranges currently exist, # add row_range that starts with last_scanned_key as start_key_open # to request only rows that have not been returned yet if "rows" not in self.message: row_range = data_v2_pb2.RowRange(start_key_open=self.last_scanned_key) r_kwargs["rows"] = data_v2_pb2.RowSet(row_ranges=[row_range]) else: row_keys = self._filter_rows_keys() row_ranges = self._filter_row_ranges() r_kwargs["rows"] = data_v2_pb2.RowSet( row_keys=row_keys, row_ranges=row_ranges ) return data_messages_v2_pb2.ReadRowsRequest(**r_kwargs)
def read_rows( self, request: bigtable.ReadRowsRequest = None, *, table_name: str = None, app_profile_id: str = None, retry: retries.Retry = gapic_v1.method.DEFAULT, timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> Iterable[bigtable.ReadRowsResponse]: r"""Streams back the contents of all requested rows in key order, optionally applying the same Reader filter to each. Depending on their size, rows and cells may be broken up across multiple responses, but atomicity of each row will still be preserved. See the ReadRowsResponse documentation for details. Args: request (google.cloud.bigtable_v2.types.ReadRowsRequest): The request object. Request message for Bigtable.ReadRows. table_name (str): Required. The unique name of the table from which to read. Values are of the form ``projects/<project>/instances/<instance>/tables/<table>``. This corresponds to the ``table_name`` field on the ``request`` instance; if ``request`` is provided, this should not be set. app_profile_id (str): This value specifies routing for replication. If not specified, the "default" application profile will be used. This corresponds to the ``app_profile_id`` field on the ``request`` instance; if ``request`` is provided, this should not be set. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. Returns: Iterable[google.cloud.bigtable_v2.types.ReadRowsResponse]: Response message for Bigtable.ReadRows. """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. has_flattened_params = any([table_name, app_profile_id]) if request is not None and has_flattened_params: raise ValueError("If the `request` argument is set, then none of " "the individual field arguments should be set.") # Minor optimization to avoid making a copy if the user passes # in a bigtable.ReadRowsRequest. # There's no risk of modifying the input as we've already verified # there are no flattened fields. if not isinstance(request, bigtable.ReadRowsRequest): request = bigtable.ReadRowsRequest(request) # If we have keyword arguments corresponding to fields on the # request, apply these. if table_name is not None: request.table_name = table_name if app_profile_id is not None: request.app_profile_id = app_profile_id # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.read_rows] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata) + (gapic_v1.routing_header.to_grpc_metadata( (("table_name", request.table_name), )), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, metadata=metadata, ) # Done; return the response. return response
def _ReadRowsRequestPB(*args, **kw): from google.cloud.bigtable_v2.types import bigtable as messages_v2_pb2 return messages_v2_pb2.ReadRowsRequest(*args, **kw)