google-cloud-bigquery 3.42.0__tar.gz → 3.42.2__tar.gz

{google_cloud_bigquery-3.42.0/google_cloud_bigquery.egg-info → google_cloud_bigquery-3.42.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigquery
-Version: 3.42.0
+Version: 3.42.2
 Summary: Google BigQuery API client library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0
@@ -19,7 +19,7 @@ Classifier: Topic :: Internet
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: google-api-core[grpc]<3.0.0,>=2.11.1
+Requires-Dist: google-api-core[grpc]<3.0.0,>=2.25.0
 Requires-Dist: google-auth[pyopenssl]<3.0.0,>=2.14.1
 Requires-Dist: google-cloud-core<3.0.0,>=2.4.1
 Requires-Dist: google-resumable-media<3.0.0,>=2.0.0

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google/cloud/bigquery/__init__.py

@@ -123,7 +123,7 @@ try:
 except ImportError:
     bigquery_magics = None
 
-if sys.version_info < (3, 10):
+if sys.version_info < (3, 10):  # pragma: NO COVER
     warnings.warn(
         "The python-bigquery library no longer supports Python <= 3.9. "
         f"Your Python version is {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}. We "

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google/cloud/bigquery/client.py

@@ -14,11 +14,8 @@
 
 """Client for interacting with the Google BigQuery API."""
 
-from __future__ import absolute_import
-from __future__ import annotations
-from __future__ import division
+from __future__ import absolute_import, annotations, division
 
-from collections import abc as collections_abc
 import copy
 import datetime
 import functools
@@ -30,36 +27,39 @@ import math
 import os
 import tempfile
 import typing
+import uuid
+import warnings
+from collections import abc as collections_abc
 from typing import (
+    IO,
     Any,
     Callable,
     Dict,
-    IO,
     Iterable,
-    Mapping,
     List,
+    Mapping,
     Optional,
     Sequence,
     Tuple,
     Union,
 )
-import uuid
-import warnings
-
-import requests
-
-from google import resumable_media  # type: ignore
-from google.resumable_media.requests import MultipartUpload  # type: ignore
-from google.resumable_media.requests import ResumableUpload
 
 import google.api_core.client_options
 import google.api_core.exceptions as core_exceptions
-from google.api_core.iam import Policy
+import google.cloud._helpers  # type: ignore
+import requests
+from google import resumable_media  # type: ignore
 from google.api_core import page_iterator
 from google.api_core import retry as retries
-import google.cloud._helpers  # type: ignore
+from google.api_core.iam import Policy
 from google.cloud import exceptions  # pytype: disable=import-error
-from google.cloud.client import ClientWithProject  # type: ignore  # pytype: disable=import-error
+from google.cloud.client import (
+    ClientWithProject,  # type: ignore  # pytype: disable=import-error
+)
+from google.resumable_media.requests import (
+    MultipartUpload,  # type: ignore
+    ResumableUpload,
+)
 
 try:
     from google.cloud.bigquery_storage_v1.services.big_query_read.client import (
@@ -70,29 +70,30 @@ except ImportError:
 
 
 from google.auth.credentials import Credentials
-from google.cloud.bigquery._http import Connection
-from google.cloud.bigquery import _job_helpers
-from google.cloud.bigquery import _pandas_helpers
-from google.cloud.bigquery import _versions_helpers
-from google.cloud.bigquery import enums
+from google.cloud.bigquery import (
+    _job_helpers,
+    _pandas_helpers,
+    _versions_helpers,
+    enums,
+    job,
+)
 from google.cloud.bigquery import exceptions as bq_exceptions
-from google.cloud.bigquery import job
-from google.cloud.bigquery._helpers import _get_sub_prop
-from google.cloud.bigquery._helpers import _record_field_to_json
-from google.cloud.bigquery._helpers import _str_or_none
-from google.cloud.bigquery._helpers import _verify_job_config_type
-from google.cloud.bigquery._helpers import _get_bigquery_host
-from google.cloud.bigquery._helpers import _DEFAULT_HOST
-from google.cloud.bigquery._helpers import _DEFAULT_HOST_TEMPLATE
-from google.cloud.bigquery._helpers import _DEFAULT_UNIVERSE
-from google.cloud.bigquery._helpers import _validate_universe
-from google.cloud.bigquery._helpers import _get_client_universe
-from google.cloud.bigquery._helpers import TimeoutType
+from google.cloud.bigquery._helpers import (
+    _DEFAULT_HOST,
+    _DEFAULT_HOST_TEMPLATE,
+    _DEFAULT_UNIVERSE,
+    TimeoutType,
+    _get_bigquery_host,
+    _get_client_universe,
+    _get_sub_prop,
+    _record_field_to_json,
+    _str_or_none,
+    _validate_universe,
+    _verify_job_config_type,
+)
+from google.cloud.bigquery._http import Connection
 from google.cloud.bigquery._job_helpers import make_job_id as _make_job_id
-from google.cloud.bigquery.dataset import Dataset
-from google.cloud.bigquery.dataset import DatasetListItem
-from google.cloud.bigquery.dataset import DatasetReference
-
+from google.cloud.bigquery.dataset import Dataset, DatasetListItem, DatasetReference
 from google.cloud.bigquery.enums import AutoRowIDs, DatasetView, UpdateMode
 from google.cloud.bigquery.format_options import ParquetOptions
 from google.cloud.bigquery.job import (
@@ -105,27 +106,26 @@ from google.cloud.bigquery.job import (
     QueryJob,
     QueryJobConfig,
 )
-from google.cloud.bigquery.model import Model
-from google.cloud.bigquery.model import ModelReference
-from google.cloud.bigquery.model import _model_arg_to_model_ref
+from google.cloud.bigquery.model import Model, ModelReference, _model_arg_to_model_ref
 from google.cloud.bigquery.opentelemetry_tracing import create_span
 from google.cloud.bigquery.query import _QueryResults
 from google.cloud.bigquery.retry import (
+    DEFAULT_GET_JOB_TIMEOUT,
     DEFAULT_JOB_RETRY,
     DEFAULT_RETRY,
     DEFAULT_TIMEOUT,
-    DEFAULT_GET_JOB_TIMEOUT,
     POLLING_DEFAULT_VALUE,
 )
-from google.cloud.bigquery.routine import Routine
-from google.cloud.bigquery.routine import RoutineReference
+from google.cloud.bigquery.routine import Routine, RoutineReference
 from google.cloud.bigquery.schema import SchemaField
-from google.cloud.bigquery.table import _table_arg_to_table
-from google.cloud.bigquery.table import _table_arg_to_table_ref
-from google.cloud.bigquery.table import Table
-from google.cloud.bigquery.table import TableListItem
-from google.cloud.bigquery.table import TableReference
-from google.cloud.bigquery.table import RowIterator
+from google.cloud.bigquery.table import (
+    RowIterator,
+    Table,
+    TableListItem,
+    TableReference,
+    _table_arg_to_table,
+    _table_arg_to_table_ref,
+)
 
 pyarrow = _versions_helpers.PYARROW_VERSIONS.try_import()
 pandas = (
@@ -621,11 +621,45 @@ class Client(ClientWithProject):
             )
             return None
 
-        if bqstorage_client is None:  # pragma: NO COVER
+        # Import here since it should be installed if the BQ Storage client is
+        # also installed.
+        import google.api_core.gapic_v1.client_info
+
+        try:
+            import pandas_gbq  # type: ignore
+        except ImportError:
+            pandas_gbq = None  # type: ignore
+
+        if pandas_gbq is None:
+            user_agent = "pandas-gbq/0.0.0"
+        else:
+            user_agent = f"pandas-gbq/{pandas_gbq.__version__}"
+
+        if client_info is None:
+            amended_client_info = google.api_core.gapic_v1.client_info.ClientInfo(
+                user_agent=user_agent,
+            )
+        else:
+            if client_info.user_agent is None:
+                amended_user_agent = user_agent
+            else:
+                amended_user_agent = client_info.user_agent + " " + user_agent
+
+            amended_client_info = google.api_core.gapic_v1.client_info.ClientInfo(
+                python_version=client_info.python_version,
+                grpc_version=client_info.grpc_version,
+                api_core_version=client_info.api_core_version,
+                gapic_version=client_info.gapic_version,
+                user_agent=amended_user_agent,
+                rest_version=client_info.rest_version,
+                protobuf_runtime_version=client_info.protobuf_runtime_version,
+            )
+
+        if bqstorage_client is None:
             bqstorage_client = bigquery_storage.BigQueryReadClient(
                 credentials=self._credentials,
                 client_options=client_options,
-                client_info=client_info,  # type: ignore  # (None is also accepted)
+                client_info=amended_client_info,
             )
 
         return bqstorage_client
@@ -4012,15 +4046,22 @@ class Client(ClientWithProject):
         path = "%s/insertAll" % table.path
         # We can always retry, because every row has an insert ID.
         span_attributes = {"path": path}
-        response = self._call_api(
-            retry,
-            span_name="BigQuery.insertRowsJson",
-            span_attributes=span_attributes,
-            method="POST",
-            path=path,
-            data=data,
-            timeout=timeout,
-        )
+        try:
+            response = self._call_api(
+                retry,
+                span_name="BigQuery.insertRowsJson",
+                span_attributes=span_attributes,
+                method="POST",
+                path=path,
+                data=data,
+                timeout=timeout,
+            )
+        except requests.exceptions.SSLError as exc:
+            msg = (
+                "An SSL/Connection error occurred while streaming rows. This "
+                "could be due to an invalid request (e.g., invalid table schema)."
+            )
+            raise requests.exceptions.SSLError(msg) from exc
         errors = []
 
         for error in response.get("insertErrors", ()):

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google/cloud/bigquery/dbapi/connection.py

@@ -84,7 +84,7 @@ class Connection(object):
 
         if self._owns_bqstorage_client:
             # There is no close() on the BQ Storage client itself.
-            self._bqstorage_client._transport.grpc_channel.close()
+            self._bqstorage_client._transport.close()
 
         for cursor_ in self._cursors_created:
             if not cursor_._closed:

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google/cloud/bigquery/magics/magics.py

@@ -773,4 +773,4 @@ def _close_transports(client, bqstorage_client):
     """
     client.close()
     if bqstorage_client is not None:
-        bqstorage_client._transport.grpc_channel.close()
+        bqstorage_client._transport.close()

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google/cloud/bigquery/retry.py

@@ -40,6 +40,11 @@ _UNSTRUCTURED_RETRYABLE_TYPES = (
 
 _DEFAULT_RETRY_DEADLINE = 10.0 * 60.0  # 10 minutes
 
+# Exceptions that are subclasses of types in _UNSTRUCTURED_RETRYABLE_TYPES
+# but should not be retried because they typically indicate persistent
+# configuration or security issues.
+_UNSTRUCTURED_NON_RETRYABLE_TYPES = (requests.exceptions.SSLError,)
+
 # Ambiguous errors (e.g. internalError, backendError, rateLimitExceeded) retry
 # until the full `_DEFAULT_RETRY_DEADLINE`. This is because the
 # `jobs.getQueryResults` REST API translates a job failure into an HTTP error.
@@ -64,9 +69,13 @@ _DEFAULT_JOB_DEADLINE = 2.0 * (2.0 * _DEFAULT_RETRY_DEADLINE)
 def _should_retry(exc):
     """Predicate for determining when to retry.
 
-    We retry if and only if the 'reason' is in _RETRYABLE_REASONS or is
-    in _UNSTRUCTURED_RETRYABLE_TYPES.
+    We retry if the 'reason' is in _RETRYABLE_REASONS or if the exception
+    is an instance of one of the _UNSTRUCTURED_RETRYABLE_TYPES, unless it
+    is explicitly excluded by being in _UNSTRUCTURED_NON_RETRYABLE_TYPES.
     """
+    if isinstance(exc, _UNSTRUCTURED_NON_RETRYABLE_TYPES):
+        return False
+
     try:
         reason = exc.errors[0]["reason"]
     except (AttributeError, IndexError, TypeError, KeyError):

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google/cloud/bigquery/table.py

@@ -2353,7 +2353,9 @@ class RowIterator(HTTPIterator):
                 progress_bar.close()
         finally:
             if owns_bqstorage_client:
-                bqstorage_client._transport.grpc_channel.close()  # type: ignore
+                # mypy: bqstorage_client is guaranteed to be not None when owns_bqstorage_client is True,
+                # 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:
             return pyarrow.Table.from_batches(record_batches)

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.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.42.0"
+__version__ = "3.42.2"

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2/google_cloud_bigquery.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigquery
-Version: 3.42.0
+Version: 3.42.2
 Summary: Google BigQuery API client library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0
@@ -19,7 +19,7 @@ Classifier: Topic :: Internet
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: google-api-core[grpc]<3.0.0,>=2.11.1
+Requires-Dist: google-api-core[grpc]<3.0.0,>=2.25.0
 Requires-Dist: google-auth[pyopenssl]<3.0.0,>=2.14.1
 Requires-Dist: google-cloud-core<3.0.0,>=2.4.1
 Requires-Dist: google-resumable-media<3.0.0,>=2.0.0

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google_cloud_bigquery.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ tests/system/test_list_rows.py
 tests/system/test_magics.py
 tests/system/test_pandas.py
 tests/system/test_query.py
+tests/system/test_ssl_retry.py
 tests/system/test_structs.py
 tests/unit/__init__.py
 tests/unit/conftest.py

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/google_cloud_bigquery.egg-info/requires.txt

@@ -1,4 +1,4 @@
-google-api-core[grpc]<3.0.0,>=2.11.1
+google-api-core[grpc]<3.0.0,>=2.25.0
 google-auth[pyopenssl]<3.0.0,>=2.14.1
 google-cloud-core<3.0.0,>=2.4.1
 google-resumable-media<3.0.0,>=2.0.0

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/pyproject.toml

@@ -41,7 +41,7 @@ classifiers = [
   "Topic :: Internet",
 ]
 dependencies = [
-  "google-api-core[grpc] >= 2.11.1, < 3.0.0",
+  "google-api-core[grpc] >= 2.25.0, < 3.0.0",
   "google-auth[pyopenssl] >= 2.14.1, < 3.0.0",
   "google-cloud-core >= 2.4.1, < 3.0.0",
   "google-resumable-media >= 2.0.0, < 3.0.0",

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/tests/system/helpers.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import contextlib
 import datetime
 import decimal
 import uuid
@@ -21,7 +22,6 @@ import test_utils.retry
 
 from google.cloud._helpers import UTC
 
-
 _naive = datetime.datetime(2016, 12, 5, 12, 41, 9)
 _naive_microseconds = datetime.datetime(2016, 12, 5, 12, 41, 9, 250000)
 _stamp = "%s %s" % (_naive.date().isoformat(), _naive.time().isoformat())
@@ -104,3 +104,29 @@ retry_403 = test_utils.retry.RetryErrors(
     google.api_core.exceptions.Forbidden,
     error_predicate=_rate_limit_exceeded,
 )
+
+
+@contextlib.contextmanager
+def patch_tracked_requests():
+    """Context manager to patch google-auth requests and track/close their HTTP sessions.
+
+    This prevents socket leaks in system tests that use Workload Identity or metadata server auth.
+    """
+    import google.auth.transport.requests
+
+    original_init = google.auth.transport.requests.Request.__init__
+    tracked_requests = []
+
+    def patched_init(self, session=None):
+        original_init(self, session=session)
+        if session is None:
+            tracked_requests.append(self)
+
+    google.auth.transport.requests.Request.__init__ = patched_init
+    try:
+        yield tracked_requests
+    finally:
+        google.auth.transport.requests.Request.__init__ = original_init
+        for req in tracked_requests:
+            if hasattr(req, "session") and req.session is not None:
+                req.session.close()

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/tests/system/test_client.py

@@ -58,7 +58,6 @@ from test_utils.system import unique_resource_id
 
 from . import helpers
 
-
 JOB_TIMEOUT = 120  # 2 minutes
 DATA_PATH = pathlib.Path(__file__).parent.parent / "data"
 
@@ -234,23 +233,29 @@ class TestBigQuery(unittest.TestCase):
 
     def test_close_releases_open_sockets(self):
         current_process = psutil.Process()
-        conn_count_start = len(current_process.net_connections())
+        conn_start = current_process.net_connections()
+        conn_count_start = len(conn_start)
+
+        with helpers.patch_tracked_requests():
+            client = Config.CLIENT
+            client.query(
+                """
+                SELECT
+                    source_year AS year, COUNT(is_male) AS birth_count
+                FROM `bigquery-public-data.samples.natality`
+                GROUP BY year
+                ORDER BY year DESC
+                LIMIT 15
+                """
+            )
 
-        client = Config.CLIENT
-        client.query(
-            """
-            SELECT
-                source_year AS year, COUNT(is_male) AS birth_count
-            FROM `bigquery-public-data.samples.natality`
-            GROUP BY year
-            ORDER BY year DESC
-            LIMIT 15
-            """
-        )
+            client.close()
 
-        client.close()
+        import gc
 
-        conn_count_end = len(current_process.net_connections())
+        gc.collect()
+        conn_end = current_process.net_connections()
+        conn_count_end = len(conn_end)
         self.assertLessEqual(conn_count_end, conn_count_start)
 
     def test_create_dataset(self):
@@ -2174,25 +2179,31 @@ class TestBigQuery(unittest.TestCase):
     def test_dbapi_connection_does_not_leak_sockets(self):
         pytest.importorskip("google.cloud.bigquery_storage")
         current_process = psutil.Process()
-        conn_count_start = len(current_process.net_connections())
-
-        # Provide no explicit clients, so that the connection will create and own them.
-        connection = dbapi.connect()
-        cursor = connection.cursor()
-
-        cursor.execute(
+        conn_start = current_process.net_connections()
+        conn_count_start = len(conn_start)
+
+        with helpers.patch_tracked_requests():
+            # Provide no explicit clients, so that the connection will create and own them.
+            connection = dbapi.connect()
+            cursor = connection.cursor()
+
+            cursor.execute(
+                """
+                SELECT id, `by`, timestamp
+                FROM `bigquery-public-data.hacker_news.full`
+                ORDER BY `id` ASC
+                LIMIT 100000
             """
-            SELECT id, `by`, timestamp
-            FROM `bigquery-public-data.hacker_news.full`
-            ORDER BY `id` ASC
-            LIMIT 100000
-        """
-        )
-        rows = cursor.fetchall()
-        self.assertEqual(len(rows), 100000)
+            )
+            rows = cursor.fetchall()
+            self.assertEqual(len(rows), 100000)
+
+            connection.close()
+        import gc
 
-        connection.close()
-        conn_count_end = len(current_process.net_connections())
+        gc.collect()
+        conn_end = current_process.net_connections()
+        conn_count_end = len(conn_end)
         self.assertLessEqual(conn_count_end, conn_count_start)
 
     def _load_table_for_dml(self, rows, dataset_id, table_id):

{google_cloud_bigquery-3.42.0 → google_cloud_bigquery-3.42.2}/tests/system/test_magics.py

@@ -19,6 +19,7 @@ import re
 import pytest
 import psutil
 
+from . import helpers
 
 IPython = pytest.importorskip("IPython")
 io = pytest.importorskip("IPython.utils.io")
@@ -48,27 +49,30 @@ def ipython_interactive(ipython):
 def test_bigquery_magic(ipython_interactive):
     ip = IPython.get_ipython()
     current_process = psutil.Process()
-    conn_count_start = len(current_process.net_connections())
-
-    # Deprecated, but should still work in google-cloud-bigquery 3.x.
-    with pytest.warns(FutureWarning, match="bigquery_magics"):
-        ip.extension_manager.load_extension("google.cloud.bigquery")
-
-    sql = """
-        SELECT
-            CONCAT(
-            'https://stackoverflow.com/questions/',
-            CAST(id as STRING)) as url,
-            view_count
-        FROM `bigquery-public-data.stackoverflow.posts_questions`
-        WHERE tags like '%google-bigquery%'
-        ORDER BY view_count DESC
-        LIMIT 10
-    """
-    with io.capture_output() as captured:
-        result = ip.run_cell_magic("bigquery", "--use_rest_api", sql)
-
-    conn_count_end = len(current_process.net_connections())
+    conn_start = current_process.net_connections()
+    conn_count_start = len(conn_start)
+
+    with helpers.patch_tracked_requests():
+        # Deprecated, but should still work in google-cloud-bigquery 3.x.
+        with pytest.warns(FutureWarning, match="bigquery_magics"):
+            ip.extension_manager.load_extension("google.cloud.bigquery")
+
+        sql = """
+            SELECT
+                CONCAT(
+                'https://stackoverflow.com/questions/',
+                CAST(id as STRING)) as url,
+                view_count
+            FROM `bigquery-public-data.stackoverflow.posts_questions`
+            WHERE tags like '%google-bigquery%'
+            ORDER BY view_count DESC
+            LIMIT 10
+        """
+        with io.capture_output() as captured:
+            result = ip.run_cell_magic("bigquery", "--use_rest_api", sql)
+
+    conn_end = current_process.net_connections()
+    conn_count_end = len(conn_end)
 
     lines = re.split("\n|\r", captured.stdout)
     # Removes blanks & terminal code (result of display clearing)

google_cloud_bigquery-3.42.2/tests/system/test_ssl_retry.py

@@ -0,0 +1,66 @@
+# 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
+#
+#     https://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.
+
+import time
+from unittest import mock
+
+import pytest
+import requests.exceptions
+from google.cloud import bigquery
+
+
+def test_insert_rows_json_ssl_error_no_retry(bigquery_client, dataset_id, project_id):
+    """
+    Verify that SSLError during insert_rows_json is NOT retried and
+    propagates a descriptive error message immediately.
+    """
+    table_id = f"{project_id}.{dataset_id}.test_ssl_retry_{int(time.time())}"
+    schema = [bigquery.SchemaField("name", "STRING")]
+    table = bigquery.Table(table_id, schema=schema)
+    bigquery_client.create_table(table)
+    try:
+        # We mock the api_request to simulate the GFE abruptly closing the connection
+        # which manifests as a requests.exceptions.SSLError.
+        bigquery_client._connection.api_request
+        call_count = 0
+
+        def mock_api_request(*args, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            raise requests.exceptions.SSLError("EOF occurred in violation of protocol")
+
+        with mock.patch.object(
+            bigquery_client._connection, "api_request", side_effect=mock_api_request
+        ):
+            # Use a reasonably short deadline for the test, although it should fail on the first attempt anyway.
+            retry = bigquery.DEFAULT_RETRY.with_deadline(5.0)
+
+            start_time = time.time()
+            with pytest.raises(requests.exceptions.SSLError) as excinfo:
+                bigquery_client.insert_rows_json(table, [{"name": "test"}], retry=retry)
+            duration = time.time() - start_time
+
+        # Verification:
+        # 1. It should NOT have retried (total calls should be 1)
+        assert call_count == 1
+
+        # 2. It should have failed quickly (much less than the 5s deadline)
+        assert duration < 2.0
+
+        # 3. The error message should contain our descriptive wrapping
+        assert "invalid table schema" in str(excinfo.value)
+        assert "SSL/Connection error occurred" in str(excinfo.value)
+    finally:
+        # Cleanup
+        bigquery_client.delete_table(table_id)