google-cloud-bigquery 3.43.0__tar.gz → 3.45.0__tar.gz

{google_cloud_bigquery-3.43.0/google_cloud_bigquery.egg-info → google_cloud_bigquery-3.45.0}/PKG-INFO

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

{google_cloud_bigquery-3.43.0 → google_cloud_bigquery-3.45.0}/google/cloud/bigquery/__init__.py

@@ -30,6 +30,8 @@ The main concepts with this API are:
 import sys
 import warnings
 
+import google.api_core as api_core
+
 from google.cloud.bigquery import version as bigquery_version
 
 __version__ = bigquery_version.__version__
@@ -57,6 +59,8 @@ from google.cloud.bigquery.external_config import ExternalSourceFormat
 from google.cloud.bigquery.external_config import HivePartitioningOptions
 from google.cloud.bigquery.format_options import AvroOptions
 from google.cloud.bigquery.format_options import ParquetOptions
+from google.cloud.bigquery.enums import QueryResultsCompressionCodec
+from google.cloud.bigquery.enums import QueryResultsFormat
 from google.cloud.bigquery.job.base import SessionInfo
 from google.cloud.bigquery.job import Compression
 from google.cloud.bigquery.job import CopyJob
@@ -132,6 +136,9 @@ if sys.version_info < (3, 10):  # pragma: NO COVER
         FutureWarning,
     )
 
+api_core.check_python_version(__name__)
+api_core.check_dependency_versions(__name__)
+
 __all__ = [
     "__version__",
     "Client",
@@ -216,6 +223,8 @@ __all__ = [
     "KeyResultStatementKind",
     "OperationType",
     "QueryPriority",
+    "QueryResultsCompressionCodec",
+    "QueryResultsFormat",
     "RoutineType",
     "SchemaUpdateOption",
     "SourceFormat",

{google_cloud_bigquery-3.43.0 → google_cloud_bigquery-3.45.0}/google/cloud/bigquery/_job_helpers.py

@@ -430,6 +430,8 @@ def query_and_wait(
     job_retry: Optional[retries.Retry],
     page_size: Optional[int] = None,
     max_results: Optional[int] = None,
+    query_results_format: Optional[str] = None,
+    compression_codec: Optional[str] = None,
     callback: Callable = lambda _: None,
 ) -> table.RowIterator:
     """Run the query, wait for it to finish, and return the results.
@@ -475,6 +477,10 @@ def query_and_wait(
             request. Non-positive values are ignored.
         max_results (Optional[int]):
             The maximum total number of rows from this request.
+        query_results_format (Optional[Union[str, google.cloud.bigquery.enums.QueryResultsFormat]]):
+            [Beta] The format for query results (e.g. "ARROW" or :class:`~google.cloud.bigquery.enums.QueryResultsFormat.ARROW`).
+        compression_codec (Optional[Union[str, google.cloud.bigquery.enums.QueryResultsCompressionCodec]]):
+            [Beta] Compression codec for Arrow serialization (e.g. "LZ4_FRAME" or :class:`~google.cloud.bigquery.enums.QueryResultsCompressionCodec.LZ4_FRAME`).
         callback (Callable):
             A callback function used by bigframes to report query progress.
 
@@ -499,6 +505,13 @@ def query_and_wait(
     request_body = _to_query_request(
         query=query, job_config=job_config, location=location, timeout=api_timeout
     )
+    if query_results_format is not None:
+        request_body["queryResultsFormat"] = query_results_format
+    if compression_codec is not None:
+        request_body.setdefault("formatOptions", {})
+        request_body["formatOptions"]["arrowSerializationOptions"] = {
+            "bufferCompression": compression_codec
+        }
 
     # Some API parameters aren't supported by the jobs.query API. In these
     # cases, fallback to a jobs.insert call.
@@ -522,6 +535,7 @@ def query_and_wait(
             retry=retry,
             page_size=page_size,
             max_results=max_results,
+            query_results_format=query_results_format,
             callback=callback,
         )
 
@@ -594,6 +608,7 @@ def query_and_wait(
                 retry=retry,
                 page_size=page_size,
                 max_results=max_results,
+                query_results_format=query_results_format,
                 callback=callback,
             )
 
@@ -633,6 +648,7 @@ def query_and_wait(
             created=query_results.created,
             started=query_results.started,
             ended=query_results.ended,
+            query_results_format=query_results_format,
         )
 
     if job_retry is not None:
@@ -673,6 +689,7 @@ def _supported_by_jobs_query(request_body: Dict[str, Any]) -> bool:
         "jobTimeoutMs",
         "reservation",
         "maxSlots",
+        "queryResultsFormat",
     }
 
     unsupported_keys = request_keys - keys_allowlist
@@ -687,6 +704,7 @@ def _wait_or_cancel(
     page_size: Optional[int],
     max_results: Optional[int],
     *,
+    query_results_format: Optional[str] = None,
     callback: Callable = lambda _: None,
 ) -> table.RowIterator:
     """Wait for a job to complete and return the results.
@@ -731,6 +749,7 @@ def _wait_or_cancel(
                     ended=job.ended,
                 )
             )
+        query_results._query_results_format = query_results_format
         return query_results
     except Exception:
         # Attempt to cancel the job since we can't return the results.

{google_cloud_bigquery-3.43.0 → google_cloud_bigquery-3.45.0}/google/cloud/bigquery/client.py

@@ -163,6 +163,16 @@ _LIST_ROWS_FROM_QUERY_RESULTS_FIELDS = "jobReference,totalRows,pageToken,rows"
 # https://github.com/googleapis/python-bigquery/issues/438
 _MIN_GET_QUERY_RESULTS_TIMEOUT = 120
 
+_LOAD_TABLE_FROM_DATAFRAME_DEPRECATED = (
+    "Loading DataFrames via google-cloud-bigquery is deprecated. "
+    "For direct, optimized loading, please call 'pandas_gbq.to_gbq()' directly."
+)
+
+_INSERT_ROWS_FROM_DATAFRAME_DEPRECATED = (
+    "Inserting rows from DataFrames via google-cloud-bigquery is deprecated. "
+    "For direct, optimized access, please call 'pandas_gbq.to_gbq()' directly."
+)
+
 TIMEOUT_HEADER = "X-Server-Timeout"
 
 
@@ -2830,6 +2840,12 @@ class Client(ClientWithProject):
                 If ``job_config`` is not an instance of
                 :class:`~google.cloud.bigquery.job.LoadJobConfig` class.
         """
+        warnings.warn(
+            _LOAD_TABLE_FROM_DATAFRAME_DEPRECATED,
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+
         job_id = _make_job_id(job_id, job_id_prefix)
 
         if job_config is not None:
@@ -3649,6 +3665,8 @@ class Client(ClientWithProject):
         job_retry: retries.Retry = DEFAULT_JOB_RETRY,
         page_size: Optional[int] = None,
         max_results: Optional[int] = None,
+        query_results_format: Optional[str] = None,
+        compression_codec: Optional[str] = None,
     ) -> RowIterator:
         """Run the query, wait for it to finish, and return the results.
 
@@ -3696,6 +3714,10 @@ class Client(ClientWithProject):
                 by this parameter.
             max_results (Optional[int]):
                 The maximum total number of rows from this request.
+            query_results_format (Optional[Union[str, google.cloud.bigquery.enums.QueryResultsFormat]]):
+                [Beta] The format for query results (e.g. "ARROW" or :class:`~google.cloud.bigquery.enums.QueryResultsFormat.ARROW`).
+            compression_codec (Optional[Union[str, google.cloud.bigquery.enums.QueryResultsCompressionCodec]]):
+                [Beta] Compression codec for Arrow serialization (e.g. "LZ4_FRAME" or :class:`~google.cloud.bigquery.enums.QueryResultsCompressionCodec.LZ4_FRAME`).
 
         Returns:
             google.cloud.bigquery.table.RowIterator:
@@ -3726,6 +3748,8 @@ class Client(ClientWithProject):
             job_retry=job_retry,
             page_size=page_size,
             max_results=max_results,
+            query_results_format=query_results_format,
+            compression_codec=compression_codec,
         )
 
     def _query_and_wait_bigframes(
@@ -3741,6 +3765,8 @@ class Client(ClientWithProject):
         job_retry: retries.Retry = DEFAULT_JOB_RETRY,
         page_size: Optional[int] = None,
         max_results: Optional[int] = None,
+        query_results_format: Optional[str] = None,
+        compression_codec: Optional[str] = None,
         callback: Callable = lambda _: None,
     ) -> RowIterator:
         """See query_and_wait.
@@ -3773,6 +3799,8 @@ class Client(ClientWithProject):
             job_retry=job_retry,
             page_size=page_size,
             max_results=max_results,
+            query_results_format=query_results_format,
+            compression_codec=compression_codec,
             callback=callback,
         )
 
@@ -3900,6 +3928,12 @@ class Client(ClientWithProject):
         Raises:
             ValueError: if table's schema is not set
         """
+        warnings.warn(
+            _INSERT_ROWS_FROM_DATAFRAME_DEPRECATED,
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+
         insert_results = []
 
         chunk_count = int(math.ceil(len(dataframe) / chunk_size))

{google_cloud_bigquery-3.43.0 → google_cloud_bigquery-3.45.0}/google/cloud/bigquery/enums.py

@@ -495,3 +495,20 @@ class TimestampPrecision(enum.Enum):
     """
     For TIMESTAMP type with picosecond precision.
     """
+
+
+class QueryResultsFormat(str, enum.Enum):
+    """[Beta] Format for query results response."""
+
+    ARROW = "ARROW"
+    """Specifies Apache Arrow format for query results."""
+
+
+class QueryResultsCompressionCodec(str, enum.Enum):
+    """[Beta] Compression codec for Arrow query results serialization."""
+
+    LZ4_FRAME = "LZ4_FRAME"
+    """Specifies LZ4_FRAME compression codec."""
+
+    ZSTD = "ZSTD"
+    """Specifies ZSTD compression codec."""

{google_cloud_bigquery-3.43.0 → google_cloud_bigquery-3.45.0}/google/cloud/bigquery/table.py

@@ -16,14 +16,15 @@
 
 from __future__ import absolute_import
 
+import base64
 import copy
 import datetime
 import functools
+import logging
 import operator
 import typing
-from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Union, Sequence
-
 import warnings
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Sequence, Tuple, Union
 
 try:
     import pandas  # type: ignore
@@ -56,33 +57,37 @@ else:
     _read_wkt = wkt.loads
 
 import google.api_core.exceptions
-from google.api_core.page_iterator import HTTPIterator
-
 import google.cloud._helpers  # type: ignore
-from google.cloud.bigquery import _helpers
-from google.cloud.bigquery import _pandas_helpers
-from google.cloud.bigquery import _versions_helpers
+from google.api_core.page_iterator import HTTPIterator
+from google.cloud.bigquery import (
+    _helpers,
+    _pandas_helpers,
+    _string_references,
+    _versions_helpers,
+    external_config,
+)
 from google.cloud.bigquery import exceptions as bq_exceptions
+from google.cloud.bigquery import schema as _schema
 from google.cloud.bigquery._tqdm_helpers import get_progress_bar
 from google.cloud.bigquery.encryption_configuration import EncryptionConfiguration
-from google.cloud.bigquery.enums import DefaultPandasDTypes
+from google.cloud.bigquery.enums import DefaultPandasDTypes, QueryResultsFormat
 from google.cloud.bigquery.external_config import ExternalConfig
-from google.cloud.bigquery import schema as _schema
-from google.cloud.bigquery.schema import _build_schema_resource
-from google.cloud.bigquery.schema import _parse_schema_resource
-from google.cloud.bigquery.schema import _to_schema_fields
-from google.cloud.bigquery import external_config
-from google.cloud.bigquery import _string_references
+from google.cloud.bigquery.schema import (
+    _build_schema_resource,
+    _parse_schema_resource,
+    _to_schema_fields,
+)
 
 if typing.TYPE_CHECKING:  # pragma: NO COVER
     # Unconditionally import optional dependencies again to tell pytype that
     # they are not None, avoiding false "no attribute" errors.
+    import geopandas  # type: ignore
     import pandas
     import pyarrow
-    import geopandas  # type: ignore
     from google.cloud import bigquery_storage  # type: ignore
     from google.cloud.bigquery.dataset import DatasetReference
 
+_LOGGER = logging.getLogger(__name__)
 
 _NO_GEOPANDAS_ERROR = (
     "The geopandas library is not installed, please install "
@@ -110,6 +115,22 @@ _RANGE_PYARROW_WARNING = (
     "pyarrow >= 10.0.1."
 )
 
+_TO_DATAFRAME_DEPRECATED = (
+    "Retrieving DataFrames via google-cloud-bigquery is 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."
+)
+
 # How many of the total rows need to be downloaded already for us to skip
 # calling the BQ Storage API?
 #
@@ -164,6 +185,18 @@ def _view_use_legacy_sql_getter(
     return None  # explicit return statement to appease mypy
 
 
+def _disallow_when_arrow(func):
+    """Decorator that disallows iteration/access when queryResultsFormat is ARROW."""
+
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        if self._query_results_format == QueryResultsFormat.ARROW.value:
+            raise ValueError(_CANNOT_ITERATE_ARROW_ERROR)
+        return func(self, *args, **kwargs)
+
+    return wrapper
+
+
 class _TableBase:
     """Base class for Table-related classes with common functionality."""
 
@@ -1912,6 +1945,7 @@ class RowIterator(HTTPIterator):
         created: Optional[datetime.datetime] = None,
         started: Optional[datetime.datetime] = None,
         ended: Optional[datetime.datetime] = None,
+        query_results_format: Optional[str] = None,
     ):
         super(RowIterator, self).__init__(
             client,
@@ -1945,6 +1979,20 @@ class RowIterator(HTTPIterator):
         self._job_created = created
         self._job_started = started
         self._job_ended = ended
+        self._query_results_format = query_results_format
+
+    @property
+    @_disallow_when_arrow
+    def pages(self):
+        return super().pages
+
+    @_disallow_when_arrow
+    def __iter__(self):
+        return super().__iter__()
+
+    @_disallow_when_arrow
+    def __next__(self):
+        return super().__next__()
 
     @property
     def _billing_project(self) -> Optional[str]:
@@ -2226,6 +2274,12 @@ class RowIterator(HTTPIterator):
 
         .. versionadded:: 2.31.0
         """
+        if self._query_results_format == QueryResultsFormat.ARROW.value:
+            return self._download_arrow_from_job_id(
+                bqstorage_client=bqstorage_client,
+                timeout=timeout,
+            )
+
         self._maybe_warn_max_results(bqstorage_client)
 
         bqstorage_download = functools.partial(
@@ -2251,6 +2305,106 @@ class RowIterator(HTTPIterator):
             bqstorage_client=bqstorage_client,
         )
 
+    def _download_arrow_from_job_id(
+        self,
+        bqstorage_client: Optional["bigquery_storage.BigQueryReadClient"] = None,
+        timeout: Optional[float] = None,
+    ) -> Iterator["pyarrow.RecordBatch"]:
+        """Yield Arrow record batches for query results formatted as ARROW.
+
+        First processes inline Arrow data in the initial page response (if present),
+        updating row offset and total row counts. If more rows remain, streams
+        remaining batches using the BigQuery Read API default job stream
+        (``projects/.../locations/.../jobs/.../streams/_default``).
+
+        Args:
+            bqstorage_client (Optional[bigquery_storage.BigQueryReadClient]):
+                Client for BigQuery Storage Read API. If None, one will be created.
+            timeout (Optional[float]):
+                Timeout in seconds for read operations.
+
+        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
+
     # If changing the signature of this method, make sure to apply the same
     # changes to job.QueryJob.to_arrow()
     def to_arrow(
@@ -2316,6 +2470,12 @@ class RowIterator(HTTPIterator):
 
         .. versionadded:: 1.17.0
         """
+        warnings.warn(
+            _TO_ARROW_DEPRECATED,
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+
         if pyarrow is None:
             raise ValueError(_NO_PYARROW_ERROR)
 
@@ -2357,7 +2517,10 @@ class RowIterator(HTTPIterator):
                 # but mypy cannot infer this correlation. We ignore the union-attr error here.
                 bqstorage_client._transport.close()  # type: ignore[union-attr]
 
-        if record_batches and bqstorage_client is not None:
+        if record_batches and (
+            bqstorage_client is not None
+            or self._query_results_format == QueryResultsFormat.ARROW.value
+        ):
             return pyarrow.Table.from_batches(record_batches)
         else:
             # No records (not record_batches), use schema based on BigQuery schema
@@ -2438,6 +2601,24 @@ class RowIterator(HTTPIterator):
         if dtypes is None:
             dtypes = {}
 
+        if self._query_results_format == QueryResultsFormat.ARROW.value:
+
+            def _batch_to_dataframe(batch):
+                df = batch.to_pandas()
+                if dtypes:
+                    for col, dtype in dtypes.items():
+                        if col in df.columns:
+                            df[col] = df[col].astype(dtype)
+                return df
+
+            return (
+                _batch_to_dataframe(batch)
+                for batch in self.to_arrow_iterable(
+                    bqstorage_client=bqstorage_client,
+                    timeout=timeout,
+                )
+            )
+
         self._maybe_warn_max_results(bqstorage_client)
 
         column_names = [field.name for field in self._schema]
@@ -2709,6 +2890,12 @@ class RowIterator(HTTPIterator):
                 is not supported dtype.
 
         """
+        warnings.warn(
+            _TO_DATAFRAME_DEPRECATED,
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+
         _pandas_helpers.verify_pandas_imports()
 
         if geography_as_object and shapely is None:
@@ -2797,16 +2984,42 @@ class RowIterator(HTTPIterator):
 
         self._maybe_warn_max_results(bqstorage_client)
 
-        if not self._should_use_bqstorage(bqstorage_client, create_bqstorage_client):
+        if (
+            self._query_results_format != QueryResultsFormat.ARROW.value
+            and not self._should_use_bqstorage(
+                bqstorage_client, create_bqstorage_client
+            )
+        ):
             create_bqstorage_client = False
             bqstorage_client = None
 
-        record_batch = self.to_arrow(
-            progress_bar_type=progress_bar_type,
-            bqstorage_client=bqstorage_client,
-            create_bqstorage_client=create_bqstorage_client,
-            timeout=timeout,
-        )
+        if _versions_helpers.PANDAS_GBQ_VERSIONS.is_delegation_supported:
+            try:
+                client_info = getattr(
+                    getattr(self.client, "_connection", None), "_client_info", None
+                )
+                if client_info:
+                    ua = getattr(client_info, "user_agent", None) or ""
+                    if "pandas-gbq" not in ua:
+                        version = (
+                            _versions_helpers.PANDAS_GBQ_VERSIONS.installed_version
+                        )
+                        client_info.user_agent = f"{ua} pandas-gbq/{version}".strip()
+            except Exception as exc:
+                _LOGGER.debug("Failed to update telemetry user-agent: %s", exc)
+
+        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,
+            )
 
         # 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
@@ -3009,18 +3222,24 @@ class RowIterator(HTTPIterator):
                 "one to use to create a GeoDataFrame"
             )
 
-        df = self.to_dataframe(
-            bqstorage_client,
-            dtypes,
-            progress_bar_type,
-            create_bqstorage_client,
-            geography_as_object=True,
-            bool_dtype=bool_dtype,
-            int_dtype=int_dtype,
-            float_dtype=float_dtype,
-            string_dtype=string_dtype,
-            timeout=timeout,
-        )
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=PendingDeprecationWarning,
+                message="Retrieving DataFrames via google-cloud-bigquery is deprecated.*",
+            )
+            df = self.to_dataframe(
+                bqstorage_client,
+                dtypes,
+                progress_bar_type,
+                create_bqstorage_client,
+                geography_as_object=True,
+                bool_dtype=bool_dtype,
+                int_dtype=int_dtype,
+                float_dtype=float_dtype,
+                string_dtype=string_dtype,
+                timeout=timeout,
+            )
 
         return geopandas.GeoDataFrame(
             df, crs=_COORDINATE_REFERENCE_SYSTEM, geometry=geography_column
@@ -3048,6 +3267,14 @@ class _EmptyRowIterator(RowIterator):
         )
         self._total_rows = 0
 
+    @_disallow_when_arrow
+    def __iter__(self):
+        return iter(())
+
+    @_disallow_when_arrow
+    def __next__(self):
+        raise StopIteration
+
     def to_arrow(
         self,
         progress_bar_type=None,
@@ -3068,6 +3295,11 @@ 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(
@@ -3114,6 +3346,11 @@ class _EmptyRowIterator(RowIterator):
         Returns:
             pandas.DataFrame: An empty :class:`~pandas.DataFrame`.
         """
+        warnings.warn(
+            _TO_DATAFRAME_DEPRECATED,
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
         _pandas_helpers.verify_pandas_imports()
         return pandas.DataFrame()
 
@@ -3219,11 +3456,10 @@ class _EmptyRowIterator(RowIterator):
         Returns:
             An iterator yielding a single empty :class:`~pyarrow.RecordBatch`.
         """
+        if pyarrow is None:
+            raise ValueError(_NO_PYARROW_ERROR)
         return iter((pyarrow.record_batch([]),))
 
-    def __iter__(self):
-        return iter(())
-
 
 class PartitionRange(object):
     """Definition of the ranges for range partitioning.