google-cloud-bigquery 3.36.0__tar.gz → 3.37.0__tar.gz

{google_cloud_bigquery-3.36.0/google_cloud_bigquery.egg-info → google_cloud_bigquery-3.37.0}/PKG-INFO

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

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/google/cloud/bigquery/_job_helpers.py

@@ -658,6 +658,9 @@ def _supported_by_jobs_query(request_body: Dict[str, Any]) -> bool:
         "requestId",
         "createSession",
         "writeIncrementalResults",
+        "jobTimeoutMs",
+        "reservation",
+        "maxSlots",
     }
 
     unsupported_keys = request_keys - keys_allowlist

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/google/cloud/bigquery/client.py

@@ -3519,7 +3519,8 @@ class Client(ClientWithProject):
                 specified here becomes the default ``job_retry`` for
                 ``result()``, where it can also be specified.
             api_method (Union[str, enums.QueryApiMethod]):
-                Method with which to start the query job.
+                Method with which to start the query job.  By default,
+                the jobs.insert API is used for starting a query.
 
                 See :class:`google.cloud.bigquery.enums.QueryApiMethod` for
                 details on the difference between the query start methods.

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/google/cloud/bigquery/job/base.py

@@ -224,6 +224,37 @@ class _JobConfig(object):
         else:
             self._properties.pop("jobTimeoutMs", None)
 
+    @property
+    def max_slots(self) -> Optional[int]:
+        """The maximum rate of slot consumption to allow for this job.
+
+        If set, the number of slots used to execute the job will be throttled
+        to try and keep its slot consumption below the requested rate.
+        This feature is not generally available.
+        """
+
+        max_slots = self._properties.get("maxSlots")
+        if max_slots is not None:
+            if isinstance(max_slots, str):
+                return int(max_slots)
+            if isinstance(max_slots, int):
+                return max_slots
+        return None
+
+    @max_slots.setter
+    def max_slots(self, value):
+        try:
+            value = _int_or_none(value)
+        except ValueError as err:
+            raise ValueError("Pass an int for max slots, e.g. 100").with_traceback(
+                err.__traceback__
+            )
+
+        if value is not None:
+            self._properties["maxSlots"] = str(value)
+        else:
+            self._properties.pop("maxSlots", None)
+
     @property
     def reservation(self):
         """str: Optional. The reservation that job would use.
@@ -662,7 +693,12 @@ class _AsyncJob(google.api_core.future.polling.PollingFuture):
 
     @property
     def error_result(self):
-        """Error information about the job as a whole.
+        """Output only. Final error result of the job.
+
+        If present, indicates that the job has completed and was unsuccessful.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatus.FIELDS.error_result
 
         Returns:
             Optional[Mapping]: the error information (None until set from the server).
@@ -673,7 +709,13 @@ class _AsyncJob(google.api_core.future.polling.PollingFuture):
 
     @property
     def errors(self):
-        """Information about individual errors generated by the job.
+        """Output only. The first errors encountered during the running of the job.
+
+        The final message includes the number of errors that caused the process to stop.
+        Errors here do not necessarily mean that the job has not completed or was unsuccessful.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatus.FIELDS.errors
 
         Returns:
             Optional[List[Mapping]]:
@@ -685,7 +727,12 @@ class _AsyncJob(google.api_core.future.polling.PollingFuture):
 
     @property
     def state(self):
-        """Status of the job.
+        """Output only. Running state of the job.
+
+        Valid states include 'PENDING', 'RUNNING', and 'DONE'.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatus.FIELDS.state
 
         Returns:
             Optional[str]:

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/google/cloud/bigquery/query.py

@@ -1400,7 +1400,7 @@ class _QueryResults(object):
             api_response (Dict): Response returned from an API call
         """
         self._properties.clear()
-        self._properties.update(copy.deepcopy(api_response))
+        self._properties.update(api_response)
 
 
 def _query_param_from_api_repr(resource):

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/google/cloud/bigquery/table.py

@@ -3574,9 +3574,9 @@ class TableConstraints:
     def __eq__(self, other):
         if not isinstance(other, TableConstraints) and other is not None:
             raise TypeError("The value provided is not a BigQuery TableConstraints.")
-        return (
-            self.primary_key == other.primary_key if other.primary_key else None
-        ) and (self.foreign_keys == other.foreign_keys if other.foreign_keys else None)
+        return self.primary_key == (
+            other.primary_key if other.primary_key else None
+        ) and self.foreign_keys == (other.foreign_keys if other.foreign_keys else None)
 
     @classmethod
     def from_api_repr(cls, resource: Dict[str, Any]) -> "TableConstraints":

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/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.36.0"
+__version__ = "3.37.0"

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0/google_cloud_bigquery.egg-info}/PKG-INFO

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

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/tests/unit/job/test_base.py

@@ -1276,3 +1276,44 @@ class Test_JobConfig(unittest.TestCase):
         job_config = self._make_one()
         job_config.reservation = "foo"
         self.assertEqual(job_config._properties["reservation"], "foo")
+
+    def test_max_slots_miss(self):
+        job_config = self._make_one()
+        self.assertEqual(job_config.max_slots, None)
+
+    def test_max_slots_set_and_clear(self):
+        job_config = self._make_one()
+        job_config.max_slots = 14
+        self.assertEqual(job_config.max_slots, 14)
+        job_config.max_slots = None
+        self.assertEqual(job_config.max_slots, None)
+
+    def test_max_slots_hit_str(self):
+        job_config = self._make_one()
+        job_config._properties["maxSlots"] = "4"
+        self.assertEqual(job_config.max_slots, 4)
+
+    def test_max_slots_hit_int(self):
+        job_config = self._make_one()
+        job_config._properties["maxSlots"] = int(3)
+        self.assertEqual(job_config.max_slots, 3)
+
+    def test_max_slots_hit_invalid(self):
+        job_config = self._make_one()
+        job_config._properties["maxSlots"] = object()
+        self.assertEqual(job_config.max_slots, None)
+
+    def test_max_slots_update_in_place(self):
+        job_config = self._make_one()
+        job_config.max_slots = 45  # update in place
+        self.assertEqual(job_config.max_slots, 45)
+
+    def test_max_slots_setter_invalid(self):
+        job_config = self._make_one()
+        with self.assertRaises(ValueError):
+            job_config.max_slots = "foo"
+
+    def test_max_slots_setter(self):
+        job_config = self._make_one()
+        job_config.max_slots = 123
+        self.assertEqual(job_config._properties["maxSlots"], "123")

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/tests/unit/job/test_query_config.py

@@ -172,6 +172,11 @@ class TestQueryJobConfig(_Base):
         config.write_incremental_results = True
         self.assertEqual(config.write_incremental_results, True)
 
+    def test_max_slots(self):
+        config = self._get_target_class()()
+        config.max_slots = 99
+        self.assertEqual(config.max_slots, 99)
+
     def test_create_session(self):
         config = self._get_target_class()()
         self.assertIsNone(config.create_session)

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/tests/unit/test__job_helpers.py

@@ -200,6 +200,19 @@ def make_query_response(
             make_query_request({"writeIncrementalResults": True}),
             id="job_config-with-incremental-results",
         ),
+        pytest.param(
+            job_query.QueryJobConfig(
+                reservation="foo",
+                max_slots=100,
+            ),
+            make_query_request(
+                {
+                    "maxSlots": "100",
+                    "reservation": "foo",
+                }
+            ),
+            id="job_config-with-reservation-and-slots",
+        ),
     ),
 )
 def test__to_query_request(job_config, expected):
@@ -1048,6 +1061,21 @@ def test_make_job_id_w_job_id_overrides_prefix():
             True,
             id="write_incremental_results",
         ),
+        pytest.param(
+            job_query.QueryJobConfig(job_timeout_ms=1000),
+            True,
+            id="job_timeout_ms",
+        ),
+        pytest.param(
+            job_query.QueryJobConfig(reservation="foo"),
+            True,
+            id="reservation",
+        ),
+        pytest.param(
+            job_query.QueryJobConfig(max_slots=20),
+            True,
+            id="max_slots",
+        ),
     ),
 )
 def test_supported_by_jobs_query_from_queryjobconfig(

{google_cloud_bigquery-3.36.0 → google_cloud_bigquery-3.37.0}/tests/unit/test_table.py

@@ -6322,82 +6322,6 @@ class TestTableConstraint(unittest.TestCase):
         self.assertIsNone(table_constraint.primary_key)
         self.assertIsNone(table_constraint.foreign_keys)
 
-    def test__eq__primary_key_mismatch(self):
-        from google.cloud.bigquery.table import (
-            PrimaryKey,
-            ForeignKey,
-            TableReference,
-            ColumnReference,
-        )
-
-        foriegn_keys = [
-            ForeignKey(
-                name="my_fk_id",
-                referenced_table=TableReference.from_string(
-                    "my-project.my-dataset.my-table"
-                ),
-                column_references=[
-                    ColumnReference(referencing_column="id", referenced_column="id"),
-                ],
-            ),
-        ]
-
-        table_constraint = self._make_one(
-            primary_key=PrimaryKey(columns=["my_pk_id"]),
-            foreign_keys=foriegn_keys,
-        )
-        other_table_constraint = self._make_one(
-            primary_key=PrimaryKey(columns=["my_other_pk_id"]),
-            foreign_keys=foriegn_keys,
-        )
-
-        self.assertNotEqual(table_constraint, other_table_constraint)
-
-    def test__eq__foreign_keys_mismatch(self):
-        from google.cloud.bigquery.table import (
-            PrimaryKey,
-            ForeignKey,
-            TableReference,
-            ColumnReference,
-        )
-
-        primary_key = PrimaryKey(columns=["my_pk_id"])
-
-        table_constraint = self._make_one(
-            primary_key=primary_key,
-            foreign_keys=[
-                ForeignKey(
-                    name="my_fk_id",
-                    referenced_table=TableReference.from_string(
-                        "my-project.my-dataset.my-table"
-                    ),
-                    column_references=[
-                        ColumnReference(
-                            referencing_column="id", referenced_column="id"
-                        ),
-                    ],
-                ),
-            ],
-        )
-        other_table_constraint = self._make_one(
-            primary_key=primary_key,
-            foreign_keys=[
-                ForeignKey(
-                    name="my_other_fk_id",
-                    referenced_table=TableReference.from_string(
-                        "my-project.my-dataset.my-other-table"
-                    ),
-                    column_references=[
-                        ColumnReference(
-                            referencing_column="other_id", referenced_column="other_id"
-                        ),
-                    ],
-                ),
-            ],
-        )
-
-        self.assertNotEqual(table_constraint, other_table_constraint)
-
     def test__eq__other_type(self):
         from google.cloud.bigquery.table import (
             PrimaryKey,
@@ -6615,6 +6539,74 @@ class TestTableConstraint(unittest.TestCase):
         self.assertEqual(instance.to_api_repr(), expected)
 
 
+@pytest.mark.parametrize(
+    "self_pk_name,self_fk_name,other_pk_name,other_fk_name,expected_equal",
+    [
+        (None, None, None, None, True),
+        ("pkey", None, "pkey", None, True),
+        ("pkey", "fkey", "pkey", "fkey", True),
+        (None, "fkey", None, "fkey", True),
+        ("pkey", None, "pkey_no_match", None, False),
+        ("pkey", "fkey", "pkey_no_match", "fkey_no_match", False),
+        (None, "fkey", None, "fkey_no_match", False),
+        ("pkey", "fkey", "pkey_no_match", "fkey", False),
+        ("pkey", "fkey", "pkey", "fkey_no_match", False),
+    ],
+)
+def test_table_constraint_eq_parametrized(
+    self_pk_name, self_fk_name, other_pk_name, other_fk_name, expected_equal
+):
+    # Imports are placed here to ensure they are self-contained for this example.
+    # In a real test file, they would likely be at the top of the file.
+    from google.cloud.bigquery.table import (
+        ColumnReference,
+        ForeignKey,
+        PrimaryKey,
+        TableReference,
+        TableConstraints,
+    )
+
+    # Helper function to create a PrimaryKey object or None
+    def _create_primary_key(name):
+        if name is None:
+            return None
+        return PrimaryKey(columns=[name])
+
+    # Helper function to create a list of ForeignKey objects or None
+    def _create_foreign_keys(name):
+        if name is None:
+            return None
+        # Using a generic referenced_table and column_references for simplicity
+        # The 'name' parameter ensures different ForeignKey objects for different names
+        return [
+            ForeignKey(
+                name=name,
+                referenced_table=TableReference.from_string(
+                    f"my-project.my-dataset.{name}_referenced_table"
+                ),
+                column_references=[
+                    ColumnReference(
+                        referencing_column=f"{name}_ref_col",
+                        referenced_column=f"{name}_pk_col",
+                    )
+                ],
+            )
+        ]
+
+    # Create the two TableConstraints instances for comparison
+    tc1 = TableConstraints(
+        primary_key=_create_primary_key(self_pk_name),
+        foreign_keys=_create_foreign_keys(self_fk_name),
+    )
+    tc2 = TableConstraints(
+        primary_key=_create_primary_key(other_pk_name),
+        foreign_keys=_create_foreign_keys(other_fk_name),
+    )
+
+    # Assert the equality based on the expected outcome
+    assert (tc1 == tc2) == expected_equal
+
+
 class TestExternalCatalogTableOptions:
     PROJECT = "test-project"
     DATASET_ID = "test_dataset"