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)