def test_split_read_stream(self):
# Setup Expected Response
expected_response = {}
expected_response = storage_pb2.SplitReadStreamResponse(**expected_response)
# Mock the API response
channel = ChannelStub(responses=[expected_response])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = big_query_storage_client.BigQueryStorageClient()
# Setup Request
original_stream = {}
response = client.split_read_stream(original_stream)
assert expected_response == response
assert len(channel.requests) == 1
expected_request = storage_pb2.SplitReadStreamRequest(
original_stream=original_stream
)
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def split_read_stream(
self,
original_stream,
fraction=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
"""
Splits a given read stream into two Streams. These streams are referred
to as the primary and the residual of the split. The original stream can
still be read from in the same manner as before. Both of the returned
streams can also be read from, and the total rows return by both child
streams will be the same as the rows read from the original stream.
Moreover, the two child streams will be allocated back to back in the
original Stream. Concretely, it is guaranteed that for streams Original,
Primary, and Residual, that Original[0-j] = Primary[0-j] and
Original[j-n] = Residual[0-m] once the streams have been read to
completion.
This method is guaranteed to be idempotent.
Example:
>>> from google.cloud import bigquery_storage_v1beta1
>>>
>>> client = bigquery_storage_v1beta1.BigQueryStorageClient()
>>>
>>> # TODO: Initialize `original_stream`:
>>> original_stream = {}
>>>
>>> response = client.split_read_stream(original_stream)
Args:
original_stream (Union[dict, ~google.cloud.bigquery_storage_v1beta1.types.Stream]): Stream to split.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.bigquery_storage_v1beta1.types.Stream`
fraction (float): A value in the range (0.0, 1.0) that specifies the fractional point at
which the original stream should be split. The actual split point is
evaluated on pre-filtered rows, so if a filter is provided, then there is
no guarantee that the division of the rows between the new child streams
will be proportional to this fractional value. Additionally, because the
server-side unit for assigning data is collections of rows, this fraction
will always map to to a data storage boundary on the server side.
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will
be retried using a default configuration.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.cloud.bigquery_storage_v1beta1.types.SplitReadStreamResponse` instance.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
if "split_read_stream" not in self._inner_api_calls:
self._inner_api_calls[
"split_read_stream"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.split_read_stream,
default_retry=self._method_configs["SplitReadStream"].retry,
default_timeout=self._method_configs["SplitReadStream"].timeout,
client_info=self._client_info,
)
request = storage_pb2.SplitReadStreamRequest(
original_stream=original_stream, fraction=fraction
)
if metadata is None:
metadata = []
metadata = list(metadata)
try:
routing_header = [("original_stream.name", original_stream.name)]
except AttributeError:
pass
else:
routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata(
routing_header
)
metadata.append(routing_metadata) # pragma: no cover
return self._inner_api_calls["split_read_stream"](
request, retry=retry, timeout=timeout, metadata=metadata
)
