google-cloud-bigquery 3.46.0__tar.gz → 3.46.2__tar.gz

{google_cloud_bigquery-3.46.0/google_cloud_bigquery.egg-info → google_cloud_bigquery-3.46.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigquery
-Version: 3.46.0
+Version: 3.46.2
 Summary: Google BigQuery API client library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0

google_cloud_bigquery-3.46.2/google/cloud/bigquery/_arrow_query.py

@@ -0,0 +1,125 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Read query results returned in Apache Arrow format."""
+
+from __future__ import annotations
+
+import base64
+from typing import Iterator, Optional, TYPE_CHECKING
+
+try:
+    import pyarrow  # type: ignore
+except ImportError:
+    pyarrow = None  # type: ignore[assignment]
+
+if TYPE_CHECKING:  # pragma: NO COVER
+    from google.cloud import bigquery_storage
+    from google.cloud.bigquery.table import RowIterator
+
+_NO_PYARROW_ERROR = (
+    "The pyarrow library is not installed, please install "
+    "pyarrow to use the to_arrow() function."
+)
+
+
+def download_arrow_from_job(
+    row_iterator: "RowIterator",
+    bqstorage_client: Optional["bigquery_storage.BigQueryReadClient"] = None,
+    timeout: Optional[float] = None,
+) -> Iterator["pyarrow.RecordBatch"]:
+    """Yield Arrow record batches for ``row_iterator``'s ARROW query results.
+
+    See :meth:`google.cloud.bigquery.table.RowIterator._download_arrow_from_job_id`.
+    """
+    if pyarrow is None:
+        raise ValueError(_NO_PYARROW_ERROR)
+
+    # Step 1: Ensure BigQuery Read API client is available upfront.
+    if bqstorage_client is None:
+        if row_iterator.client is None:
+            raise ValueError("RowIterator client is None.")
+        bqstorage_client = row_iterator.client._ensure_bqstorage_client()
+        if bqstorage_client is None:
+            raise ValueError(
+                "The google-cloud-bigquery-storage library is required to read Arrow results."
+            )
+
+    offset = 0
+    pa_schema = None
+    total_rows = row_iterator.total_rows
+    job_complete = False
+
+    # Step 2: Process initial inline Arrow response from jobs.query if available.
+    if row_iterator._first_page_response:
+        first_page = row_iterator._first_page_response
+        row_iterator._first_page_response = None
+
+        job_complete = bool(first_page.get("jobComplete", False))
+        if job_complete:
+            total_rows = int(first_page.get("totalRows", 0))
+
+        arrow_schema_json = first_page.get("arrowSchema")
+        if isinstance(arrow_schema_json, dict):
+            schema_bytes = arrow_schema_json.get("serializedSchema")
+            if schema_bytes:
+                if isinstance(schema_bytes, str):
+                    schema_bytes = base64.b64decode(schema_bytes)
+                pa_schema = pyarrow.ipc.read_schema(pyarrow.py_buffer(schema_bytes))
+
+        arrow_batch_json = first_page.get("arrowRecordBatch")
+        if isinstance(arrow_batch_json, dict) and pa_schema is not None:
+            batch_bytes = arrow_batch_json.get("serializedRecordBatch")
+            if batch_bytes:
+                if isinstance(batch_bytes, str):
+                    batch_bytes = base64.b64decode(batch_bytes)
+                batch = pyarrow.ipc.read_record_batch(
+                    pyarrow.py_buffer(batch_bytes),
+                    pa_schema,
+                )
+                offset += batch.num_rows
+                yield batch
+
+    # Step 3: Return early if all results were delivered in the first page response.
+    if job_complete and offset >= total_rows:
+        return
+
+    # Step 4: Stream remaining Arrow record batches from the job default stream.
+    project = row_iterator._project or (
+        row_iterator.client.project if row_iterator.client else None
+    )
+    location = row_iterator._location or (
+        row_iterator.client.location if row_iterator.client else None
+    )
+    stream_name = f"projects/{project}/locations/{location}/jobs/{row_iterator._job_id}/streams/_default"
+    reader = bqstorage_client.read_rows(stream_name, offset=offset, timeout=timeout)
+    for response in reader:
+        if (
+            response.arrow_schema
+            and response.arrow_schema.serialized_schema
+            and pa_schema is None
+        ):
+            pa_schema = pyarrow.ipc.read_schema(
+                pyarrow.py_buffer(response.arrow_schema.serialized_schema)
+            )
+        if (
+            response.arrow_record_batch
+            and response.arrow_record_batch.serialized_record_batch
+            and pa_schema is not None
+        ):
+            batch = pyarrow.ipc.read_record_batch(
+                pyarrow.py_buffer(response.arrow_record_batch.serialized_record_batch),
+                pa_schema,
+            )
+            yield batch

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/google/cloud/bigquery/external_config.py

@@ -729,14 +729,14 @@ class ExternalConfig(object):
         self._properties = {"sourceFormat": source_format}
 
     @property
-    def source_format(self):
-        """:class:`~.external_config.ExternalSourceFormat`:
+    def source_format(self) -> Optional[str]:
+        """Optional[:class:`~.external_config.ExternalSourceFormat`]:
         Format of external source.
 
         See
         https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ExternalDataConfiguration.FIELDS.source_format
         """
-        return self._properties["sourceFormat"]
+        return self._properties.get("sourceFormat")
 
     @property
     def options(self) -> Optional[OptionsType]:
@@ -1120,7 +1120,7 @@ class ExternalConfig(object):
         Returns:
             ExternalConfig: Configuration parsed from ``resource``.
         """
-        config = cls(resource["sourceFormat"])
+        config = cls(resource.get("sourceFormat"))
         config._properties = copy.deepcopy(resource)
         return config
 

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/google/cloud/bigquery/schema.py

@@ -15,16 +15,14 @@
 """Schemas for BigQuery tables / queries."""
 
 from __future__ import annotations
+
 import enum
 import typing
-from typing import Any, cast, Dict, Iterable, Optional, Union, Sequence
+from typing import Any, Dict, Iterable, Optional, Sequence, Union, cast
 
-from google.cloud.bigquery import _helpers
-from google.cloud.bigquery import standard_sql
-from google.cloud.bigquery import enums
+from google.cloud.bigquery import _helpers, enums, standard_sql
 from google.cloud.bigquery.enums import StandardSqlTypeNames
 
-
 _STRUCT_TYPES = ("RECORD", "STRUCT")
 
 # SQL types reference:
@@ -109,6 +107,43 @@ class FieldElementType(object):
         """
         return self._properties
 
+    def _key(self):
+        """A tuple key that uniquely describes this FieldElementType.
+
+        Used to compute this instance's hashcode and evaluate equality.
+
+        Returns:
+            Tuple: The contents of this :class:`~google.cloud.bigquery.schema.FieldElementType`.
+        """
+        return (self.element_type,)
+
+    def __eq__(self, other):
+        if not isinstance(other, FieldElementType):
+            return NotImplemented
+        return self._key() == other._key()
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash(self._key())
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(element_type={self.element_type!r})"
+
+
+class _SchemaFieldKey(typing.NamedTuple):
+    name: str
+    field_type: str
+    mode: str
+    default_value_expression: Optional[str]
+    description: Optional[str]
+    fields: tuple
+    policy_tags: Optional[tuple[str, ...]]
+    timestamp_precision: Optional[int]
+    rounding_mode: Optional[str]
+    foreign_type_definition: Optional[str]
+
 
 class SchemaField(object):
     """Describe a single field within a table schema.
@@ -436,6 +471,9 @@ class SchemaField(object):
                     field_type = f"{field_type}({self.precision}, {self.scale})"
                 else:
                     field_type = f"{field_type}({self.precision})"
+        elif field_type == "RANGE":
+            if self.range_element_type is not None:
+                field_type = f"{field_type}<{self.range_element_type.element_type}>"
 
         policy_tags = (
             None if self.policy_tags is None else tuple(sorted(self.policy_tags.names))
@@ -443,16 +481,24 @@ class SchemaField(object):
 
         timestamp_precision = self._properties.get("timestampPrecision")
 
-        return (
-            self.name,
-            field_type,
+        rounding_mode = (
+            self.rounding_mode.value
+            if isinstance(self.rounding_mode, enums.RoundingMode)
+            else self.rounding_mode
+        )
+
+        return _SchemaFieldKey(
+            name=self.name,
+            field_type=field_type,
             # Mode is always str, if not given it defaults to a str value
-            self.mode.upper(),  # pytype: disable=attribute-error
-            self.default_value_expression,
-            self.description,
-            self.fields,
-            policy_tags,
-            timestamp_precision,
+            mode=self.mode.upper(),  # pytype: disable=attribute-error
+            default_value_expression=self.default_value_expression,
+            description=self.description,
+            fields=self.fields,
+            policy_tags=policy_tags,
+            timestamp_precision=timestamp_precision,
+            rounding_mode=rounding_mode,
+            foreign_type_definition=self.foreign_type_definition,
         )
 
     def to_standard_sql(self) -> standard_sql.StandardSqlField:
@@ -503,9 +549,11 @@ class SchemaField(object):
         return hash(self._key())
 
     def __repr__(self):
-        *initial_tags, policy_tags, timestamp_precision_tag = self._key()
-        policy_tags_inst = None if policy_tags is None else PolicyTagList(policy_tags)
-        adjusted_key = (*initial_tags, policy_tags_inst, timestamp_precision_tag)
+        key = self._key()
+        policy_tags_inst = (
+            None if key.policy_tags is None else PolicyTagList(key.policy_tags)
+        )
+        adjusted_key = tuple(key._replace(policy_tags=policy_tags_inst))
         return f"{self.__class__.__name__}{adjusted_key}"
 
 

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/google/cloud/bigquery/table.py

@@ -16,7 +16,6 @@
 
 from __future__ import absolute_import
 
-import base64
 import copy
 import datetime
 import functools
@@ -59,6 +58,7 @@ import google.api_core.exceptions
 import google.cloud._helpers  # type: ignore
 from google.api_core.page_iterator import HTTPIterator
 from google.cloud.bigquery import (
+    _arrow_query,
     _helpers,
     _pandas_helpers,
     _string_references,
@@ -118,12 +118,6 @@ _TO_DATAFRAME_DEPRECATED = (
     "For direct, optimized access, please call 'pandas_gbq.read_gbq()' directly."
 )
 
-_TO_ARROW_DEPRECATED = (
-    "Retrieving PyArrow Tables via google-cloud-bigquery is deprecated. "
-    "For direct, optimized access, please call 'pandas_gbq.arrow.read_bigquery_table()' "
-    "or 'pandas_gbq.arrow.read_bigquery_query()' directly."
-)
-
 _CANNOT_ITERATE_ARROW_ERROR = (
     "Cannot iterate over non-arrow results when queryResultsFormat is ARROW. "
     "Use to_arrow_iterable() or to_arrow() instead."
@@ -2158,15 +2152,16 @@ class RowIterator(HTTPIterator):
 
         params = self._get_query_params()
 
-        # If the user has provided page_size and start_index, we need to pass
-        # start_index for the first page, but for all subsequent pages, we
-        # should not pass start_index. We make a shallow copy of params and do
-        # not alter the original, so if the user iterates the results again,
-        # start_index is preserved.
+        # If the user has provided start_index, we need to pass it for the
+        # first page, but once the server hands back a page token we should
+        # not pass start_index, because the server only allows one of them.
+        # This applies whether the pages come from page_size or from the
+        # server splitting a large result. We make a shallow copy of params
+        # and do not alter the original, so if the user iterates the results
+        # again, start_index is preserved.
         params_copy = copy.copy(params)
-        if self._page_size is not None:
-            if self.page_number and "startIndex" in params:
-                del params_copy["startIndex"]
+        if self.next_page_token is not None and "startIndex" in params:
+            del params_copy["startIndex"]
 
         return self.api_request(
             method=self._HTTP_METHOD, path=self.path, query_params=params_copy
@@ -2324,84 +2319,9 @@ class RowIterator(HTTPIterator):
         Yields:
             pyarrow.RecordBatch: Record batches generated from the query result.
         """
-        if pyarrow is None:
-            raise ValueError(_NO_PYARROW_ERROR)
-
-        # Step 1: Ensure BigQuery Read API client is available upfront.
-        if bqstorage_client is None:
-            if self.client is None:
-                raise ValueError("RowIterator client is None.")
-            bqstorage_client = self.client._ensure_bqstorage_client()
-            if bqstorage_client is None:
-                raise ValueError(
-                    "The google-cloud-bigquery-storage library is required to read Arrow results."
-                )
-
-        offset = 0
-        pa_schema = None
-        total_rows = self.total_rows
-        job_complete = False
-
-        # Step 2: Process initial inline Arrow response from jobs.query if available.
-        if self._first_page_response:
-            first_page = self._first_page_response
-            self._first_page_response = None
-
-            job_complete = bool(first_page.get("jobComplete", False))
-            if job_complete:
-                total_rows = int(first_page.get("totalRows", 0))
-
-            arrow_schema_json = first_page.get("arrowSchema")
-            if isinstance(arrow_schema_json, dict):
-                schema_bytes = arrow_schema_json.get("serializedSchema")
-                if schema_bytes:
-                    if isinstance(schema_bytes, str):
-                        schema_bytes = base64.b64decode(schema_bytes)
-                    pa_schema = pyarrow.ipc.read_schema(pyarrow.py_buffer(schema_bytes))
-
-            arrow_batch_json = first_page.get("arrowRecordBatch")
-            if isinstance(arrow_batch_json, dict) and pa_schema is not None:
-                batch_bytes = arrow_batch_json.get("serializedRecordBatch")
-                if batch_bytes:
-                    if isinstance(batch_bytes, str):
-                        batch_bytes = base64.b64decode(batch_bytes)
-                    batch = pyarrow.ipc.read_record_batch(
-                        pyarrow.py_buffer(batch_bytes),
-                        pa_schema,
-                    )
-                    offset += batch.num_rows
-                    yield batch
-
-        # Step 3: Return early if all results were delivered in the first page response.
-        if job_complete and offset >= total_rows:
-            return
-
-        # Step 4: Stream remaining Arrow record batches from the job default stream.
-        project = self._project or (self.client.project if self.client else None)
-        location = self._location or (self.client.location if self.client else None)
-        stream_name = f"projects/{project}/locations/{location}/jobs/{self._job_id}/streams/_default"
-        reader = bqstorage_client.read_rows(stream_name, offset=offset, timeout=timeout)
-        for response in reader:
-            if (
-                response.arrow_schema
-                and response.arrow_schema.serialized_schema
-                and pa_schema is None
-            ):
-                pa_schema = pyarrow.ipc.read_schema(
-                    pyarrow.py_buffer(response.arrow_schema.serialized_schema)
-                )
-            if (
-                response.arrow_record_batch
-                and response.arrow_record_batch.serialized_record_batch
-                and pa_schema is not None
-            ):
-                batch = pyarrow.ipc.read_record_batch(
-                    pyarrow.py_buffer(
-                        response.arrow_record_batch.serialized_record_batch
-                    ),
-                    pa_schema,
-                )
-                yield batch
+        return _arrow_query.download_arrow_from_job(
+            self, bqstorage_client=bqstorage_client, timeout=timeout
+        )
 
     # If changing the signature of this method, make sure to apply the same
     # changes to job.QueryJob.to_arrow()
@@ -2468,12 +2388,6 @@ class RowIterator(HTTPIterator):
 
         .. versionadded:: 1.17.0
         """
-        warnings.warn(
-            _TO_ARROW_DEPRECATED,
-            PendingDeprecationWarning,
-            stacklevel=2,
-        )
-
         if pyarrow is None:
             raise ValueError(_NO_PYARROW_ERROR)
 
@@ -2991,18 +2905,12 @@ class RowIterator(HTTPIterator):
             create_bqstorage_client = False
             bqstorage_client = None
 
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                category=PendingDeprecationWarning,
-                message="Retrieving PyArrow Tables.*",
-            )
-            record_batch = self.to_arrow(
-                progress_bar_type=progress_bar_type,
-                bqstorage_client=bqstorage_client,
-                create_bqstorage_client=create_bqstorage_client,
-                timeout=timeout,
-            )
+        record_batch = self.to_arrow(
+            progress_bar_type=progress_bar_type,
+            bqstorage_client=bqstorage_client,
+            create_bqstorage_client=create_bqstorage_client,
+            timeout=timeout,
+        )
 
         # Default date dtype is `db_dtypes.DateDtype()` that could cause out of bounds error,
         # when pyarrow converts date values to nanosecond precision. To avoid the error, we
@@ -3278,11 +3186,6 @@ class _EmptyRowIterator(RowIterator):
         """
         if pyarrow is None:
             raise ValueError(_NO_PYARROW_ERROR)
-        warnings.warn(
-            _TO_ARROW_DEPRECATED,
-            PendingDeprecationWarning,
-            stacklevel=2,
-        )
         return pyarrow.Table.from_arrays(())
 
     def to_dataframe(

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/google/cloud/bigquery/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "3.46.0"
+__version__ = "3.46.2"

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2/google_cloud_bigquery.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigquery
-Version: 3.46.0
+Version: 3.46.2
 Summary: Google BigQuery API client library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/google_cloud_bigquery.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 setup.cfg
 setup.py
 google/cloud/bigquery/__init__.py
+google/cloud/bigquery/_arrow_query.py
 google/cloud/bigquery/_helpers.py
 google/cloud/bigquery/_http.py
 google/cloud/bigquery/_job_helpers.py

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/tests/unit/job/test_query.py

@@ -1632,6 +1632,59 @@ class TestQueryJob(_Base):
             tabledata_list_request_2[1]["query_params"]["maxResults"], page_size
         )
 
+    def test_result_with_start_index_and_max_results_multi_page(self):
+        # When only max_results and start_index are set, the server may still
+        # split the result into several pages (e.g. when a page would exceed
+        # the response size limit). The follow-up requests carry a page token,
+        # so they must not carry start_index as well, because the server only
+        # allows one of them.
+        query_resource = {
+            "jobComplete": True,
+            "jobReference": {"projectId": self.PROJECT, "jobId": self.JOB_ID},
+            "schema": {"fields": [{"name": "col1", "type": "STRING"}]},
+            "totalRows": "7",
+        }
+        tabledata_resource_1 = {
+            "totalRows": "7",
+            "pageToken": "page_token_1",
+            "rows": [
+                {"f": [{"v": "abc"}]},
+                {"f": [{"v": "def"}]},
+            ],
+        }
+        tabledata_resource_2 = {
+            "totalRows": "7",
+            "rows": [
+                {"f": [{"v": "ghi"}]},
+                {"f": [{"v": "jkl"}]},
+            ],
+        }
+
+        connection = make_connection(
+            query_resource, tabledata_resource_1, tabledata_resource_2
+        )
+        client = _make_client(self.PROJECT, connection=connection)
+        resource = self._make_resource(ended=True)
+        job = self._get_target_class().from_api_repr(resource, client)
+
+        start_index = 1
+        max_results = 4
+
+        rows = list(job.result(max_results=max_results, start_index=start_index))
+
+        self.assertEqual([row.col1 for row in rows], ["abc", "def", "ghi", "jkl"])
+        self.assertEqual(len(connection.api_request.call_args_list), 3)
+
+        tabledata_list_request_1 = connection.api_request.call_args_list[1]
+        self.assertEqual(
+            tabledata_list_request_1[1]["query_params"]["startIndex"], start_index
+        )
+
+        tabledata_list_request_2 = connection.api_request.call_args_list[2]
+        query_params_2 = tabledata_list_request_2[1]["query_params"]
+        self.assertEqual(query_params_2["pageToken"], "page_token_1")
+        self.assertNotIn("startIndex", query_params_2)
+
     def test_result_error(self):
         from google.cloud import exceptions
 

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/tests/unit/test_external_config.py

@@ -81,6 +81,23 @@ class TestExternalConfig(unittest.TestCase):
         got_resource = ec.to_api_repr()
         self.assertEqual(got_resource, resource)
 
+    def test_from_api_repr_missing_source_format(self):
+        resource = copy.deepcopy(self.BASE_RESOURCE)
+        del resource["sourceFormat"]
+
+        ec = external_config.ExternalConfig.from_api_repr(resource)
+        self._verify_base(ec)
+        self.assertIsNone(ec.source_format)
+        self.assertIsNone(ec.options)
+        self.assertIsNone(ec.avro_options)
+        self.assertIsNone(ec.bigtable_options)
+        self.assertIsNone(ec.csv_options)
+        self.assertIsNone(ec.google_sheets_options)
+        self.assertIsNone(ec.parquet_options)
+
+        got_resource = ec.to_api_repr()
+        self.assertEqual(got_resource, resource)
+
     def test_to_api_repr_base(self):
         ec = external_config.ExternalConfig("")
         ec.source_uris = self.SOURCE_URIS

{google_cloud_bigquery-3.46.0 → google_cloud_bigquery-3.46.2}/tests/unit/test_query_results_format_arrow.py

@@ -193,7 +193,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
         mock_response.arrow_record_batch = None
         mock_bqstorage.read_rows.return_value = [mock_response]
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow") as mock_pyarrow:
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow") as mock_pyarrow:
             mock_pyarrow.py_buffer = lambda x: x
             batches = list(iterator._download_arrow_from_job_id(timeout=5.0))
             self.assertEqual(batches, [])
@@ -247,7 +247,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
 
         mock_bqstorage.read_rows.return_value = [mock_response]
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow") as mock_pyarrow:
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow") as mock_pyarrow:
             mock_pyarrow.py_buffer = lambda x: x
             mock_pyarrow.ipc.read_schema.return_value = "deserialized_schema"
             mock_pyarrow.ipc.read_record_batch.side_effect = [
@@ -306,7 +306,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
 
         mock_bqstorage.read_rows.return_value = [mock_response]
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow") as mock_pyarrow:
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow") as mock_pyarrow:
             mock_pyarrow.py_buffer = lambda x: x
             mock_pyarrow.ipc.read_schema.return_value = "deserialized_schema"
             mock_pyarrow.ipc.read_record_batch.return_value = mock_stream_batch
@@ -339,7 +339,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
             query_results_format="ARROW",
         )
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow"):
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow"):
             with self.assertRaises(ValueError) as ctx:
                 list(iterator._download_arrow_from_job_id())
             self.assertIn(
@@ -374,7 +374,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
 
         mock_bqstorage.read_rows.return_value = [mock_response]
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow") as mock_pyarrow:
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow") as mock_pyarrow:
             mock_pyarrow.py_buffer = lambda x: x
             mock_pyarrow.ipc.read_schema.return_value = "fake_schema"
             mock_pyarrow.ipc.read_record_batch.return_value = "fake_batch"
@@ -422,7 +422,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
         mock_first_batch = mock.MagicMock()
         mock_first_batch.num_rows = 10
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow") as mock_pyarrow:
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow") as mock_pyarrow:
             mock_pyarrow.py_buffer = lambda x: x
             mock_pyarrow.ipc.read_schema.return_value = "deserialized_schema"
             mock_pyarrow.ipc.read_record_batch.return_value = mock_first_batch
@@ -464,7 +464,7 @@ class TestQueryResultsFormatOption1(unittest.TestCase):
         mock_first_batch.num_rows = 10
         mock_bqstorage.read_rows.return_value = []
 
-        with mock.patch("google.cloud.bigquery.table.pyarrow") as mock_pyarrow:
+        with mock.patch("google.cloud.bigquery._arrow_query.pyarrow") as mock_pyarrow:
             mock_pyarrow.py_buffer = lambda x: x
             mock_pyarrow.ipc.read_schema.return_value = "deserialized_schema"
             mock_pyarrow.ipc.read_record_batch.return_value = mock_first_batch