From cea6e0357f04ddc63abe4ec1ff9c2f27145bf86e Mon Sep 17 00:00:00 2001 From: Dmytro Karacheban Date: Wed, 13 Dec 2023 01:01:54 +0200 Subject: [PATCH 01/26] feat: add `table_constraints` field to Table model --- google/cloud/bigquery/table.py | 128 +++++++++++++++++++++++++++++++++ tests/unit/test_table.py | 112 +++++++++++++++++++++++++++++ 2 files changed, 240 insertions(+) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index 70e601714..c00c29be9 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -390,6 +390,7 @@ class Table(_TableBase): "view_use_legacy_sql": "view", "view_query": "view", "require_partition_filter": "requirePartitionFilter", + "table_constraints": "tableConstraints", } def __init__(self, table_ref, schema=None) -> None: @@ -973,6 +974,16 @@ def clone_definition(self) -> Optional["CloneDefinition"]: clone_info = CloneDefinition(clone_info) return clone_info + @property + def table_constraints(self) -> Optional["TableConstraints"]: + """Tables Primary Key and Foreign Key information.""" + table_constraints = self._properties.get( + self._PROPERTY_TO_API_FIELD["table_constraints"] + ) + if table_constraints is not None: + table_constraints = TableConstraints.from_api_repr(table_constraints) + return table_constraints + @classmethod def from_string(cls, full_table_id: str) -> "Table": """Construct a table from fully-qualified table ID. @@ -2942,6 +2953,123 @@ def __repr__(self): return "TimePartitioning({})".format(",".join(key_vals)) +class PrimaryKey: + """Represents the primary key constraint on a table's columns. + + Args: + columns: The columns that are composed of the primary key constraint. + """ + + def __init__(self, columns: List[str]): + self.columns = columns + + def __eq__(self, other): + if not isinstance(other, PrimaryKey): + raise NotImplementedError + return self.columns == other.columns + + +class ColumnReference: + """The pair of the foreign key column and primary key column. + + Args: + referencing_column: The column that composes the foreign key. + referenced_column: The column in the primary key that are referenced by the referencingColumn. + """ + + def __init__(self, referencing_column: str, referenced_column: str): + self.referencing_column = referencing_column + self.referenced_column = referenced_column + + def __eq__(self, other): + if not isinstance(other, ColumnReference): + raise NotImplementedError + return ( + self.referenced_column == other.referencing_column + and self.referenced_column == other.referenced_column + ) + + @classmethod + def from_api_repr(cls, api_repr: Dict[str, Any]) -> "ColumnReference": + """Create an instance from API representation.""" + return cls(api_repr["referencingColumn"], api_repr["referencedColumn"]) + + +class ForeignKey: + """Represents a foreign key constraint on a table's columns. + + Args: + name: Set only if the foreign key constraint is named. + referenced_table: The table that holds the primary key and is referenced by this foreign key. + column_references: The columns that compose the foreign key. + """ + + def __init__( + self, + name: str, + referenced_table: TableReference, + column_references: List[ColumnReference], + ): + self.name = name + self.referenced_table = referenced_table + self.column_references = column_references + + def __eq__(self, other): + if not isinstance(other, ForeignKey): + raise NotImplementedError + return ( + self.name == other.name and self.referenced_table == other.referenced_table + ) + + @classmethod + def from_api_repr(cls, api_repr: Dict[str, Any]) -> "ForeignKey": + """Create an instance from API representation.""" + return cls( + name=api_repr["name"], + referenced_table=TableReference.from_api_repr(api_repr["referencedTable"]), + column_references=[ + ColumnReference.from_api_repr(column_reference_resource) + for column_reference_resource in api_repr["columnReferences"] + ], + ) + + +class TableConstraints: + """The TableConstraints defines the primary key and foreign key. + + Args: + primary_key: + Represents a primary key constraint on a table's columns. Present only if the table + has a primary key. The primary key is not enforced. + foreign_keys: + Present only if the table has a foreign key. The foreign key is not enforced. + + """ + + def __init__( + self, + primary_key: Optional[PrimaryKey], + foreign_keys: Optional[List[ForeignKey]], + ): + self.primary_key = primary_key + self.foreign_keys = foreign_keys + + @classmethod + def from_api_repr(cls, resource: Dict[str, Any]) -> "TableConstraints": + """Create an instance from API representation.""" + primary_key = None + if "primaryKey" in resource: + primary_key = PrimaryKey(resource["primaryKey"]["columns"]) + + foreign_keys = None + if "foreignKeys" in resource: + foreign_keys = [ + ForeignKey.from_api_repr(foreign_key_resource) + for foreign_key_resource in resource["foreignKeys"] + ] + return cls(primary_key, foreign_keys) + + def _item_to_row(iterator, resource): """Convert a JSON row to the native object. diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 9b3d4fe84..5e0821aef 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -603,6 +603,7 @@ def test_ctor(self): self.assertIsNone(table.encryption_configuration) self.assertIsNone(table.time_partitioning) self.assertIsNone(table.clustering_fields) + self.assertIsNone(table.table_constraints) def test_ctor_w_schema(self): from google.cloud.bigquery.schema import SchemaField @@ -901,6 +902,21 @@ def test_clone_definition_set(self): 2010, 9, 28, 10, 20, 30, 123000, tzinfo=UTC ) + def test_table_constraints_property_getter(self): + from google.cloud.bigquery.table import PrimaryKey, TableConstraints + + dataset = DatasetReference(self.PROJECT, self.DS_ID) + table_ref = dataset.table(self.TABLE_NAME) + table = self._make_one(table_ref) + table._properties["tableConstraints"] = { + "primaryKey": {"columns": ["id"]}, + } + + table_constraints = table.table_constraints + + assert isinstance(table_constraints, TableConstraints) + assert table_constraints.primary_key == PrimaryKey(columns=["id"]) + def test_description_setter_bad_value(self): dataset = DatasetReference(self.PROJECT, self.DS_ID) table_ref = dataset.table(self.TABLE_NAME) @@ -5385,6 +5401,102 @@ def test_set_expiration_w_none(self): assert time_partitioning._properties["expirationMs"] is None +class TestTableConstraint(unittest.TestCase): + @staticmethod + def _get_target_class(): + from google.cloud.bigquery.table import TableConstraints + + return TableConstraints + + @classmethod + def _make_one(cls, *args, **kwargs): + return cls._get_target_class()(*args, **kwargs) + + def test_constructor_defaults(self): + instance = self._make_one(primary_key=None, foreign_keys=None) + self.assertIsNone(instance.primary_key) + self.assertIsNone(instance.foreign_keys) + + def test_from_api_repr_full_resource(self): + from google.cloud.bigquery.table import ( + ColumnReference, + ForeignKey, + TableReference, + ) + + resource = { + "primaryKey": { + "columns": ["id", "product_id"], + }, + "foreignKeys": [ + { + "name": "my_fk_name", + "referencedTable": { + "projectId": "my-project", + "datasetId": "your-dataset", + "tableId": "products", + }, + "columnReferences": [ + {"referencingColumn": "product_id", "referencedColumn": "id"}, + ], + } + ], + } + instance = self._get_target_class().from_api_repr(resource) + + self.assertIsNotNone(instance.primary_key) + self.assertEqual(instance.primary_key.columns, ["id", "product_id"]) + self.assertEqual( + instance.foreign_keys, + [ + ForeignKey( + name="my_fk_name", + referenced_table=TableReference.from_string( + "my-project.your-dataset.products" + ), + column_references=[ + ColumnReference( + referencing_column="product_id", referenced_column="id" + ), + ], + ), + ], + ) + + def test_from_api_repr_only_primary_key_resource(self): + resource = { + "primaryKey": { + "columns": ["id"], + }, + } + instance = self._get_target_class().from_api_repr(resource) + + self.assertIsNotNone(instance.primary_key) + self.assertEqual(instance.primary_key.columns, ["id"]) + self.assertIsNone(instance.foreign_keys) + + def test_from_api_repr_only_foreign_keys_resource(self): + resource = { + "foreignKeys": [ + { + "name": "my_fk_name", + "referencedTable": { + "projectId": "my-project", + "datasetId": "your-dataset", + "tableId": "products", + }, + "columnReferences": [ + {"referencingColumn": "product_id", "referencedColumn": "id"}, + ], + } + ] + } + instance = self._get_target_class().from_api_repr(resource) + + self.assertIsNone(instance.primary_key) + self.assertIsNotNone(instance.foreign_keys) + + @pytest.mark.skipif( bigquery_storage is None, reason="Requires `google-cloud-bigquery-storage`" ) From 9e3481042cedb9fa497f6968d6002f8591221150 Mon Sep 17 00:00:00 2001 From: Dmytro Karacheban Date: Sat, 16 Dec 2023 22:23:20 +0200 Subject: [PATCH 02/26] Change `raise` to `return` in __eq__ methods --- google/cloud/bigquery/table.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index c00c29be9..e776bee9f 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2965,7 +2965,7 @@ def __init__(self, columns: List[str]): def __eq__(self, other): if not isinstance(other, PrimaryKey): - raise NotImplementedError + return NotImplemented return self.columns == other.columns @@ -2983,7 +2983,7 @@ def __init__(self, referencing_column: str, referenced_column: str): def __eq__(self, other): if not isinstance(other, ColumnReference): - raise NotImplementedError + return NotImplemented return ( self.referenced_column == other.referencing_column and self.referenced_column == other.referenced_column @@ -3016,7 +3016,7 @@ def __init__( def __eq__(self, other): if not isinstance(other, ForeignKey): - raise NotImplementedError + return NotImplemented return ( self.name == other.name and self.referenced_table == other.referenced_table ) From 5d034f4c10297a1ba81cc92226a59cb88137fbf1 Mon Sep 17 00:00:00 2001 From: Dmytro Karacheban Date: Sat, 16 Dec 2023 23:19:57 +0200 Subject: [PATCH 03/26] Fix __eq__ for ColumnReference --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index e776bee9f..480da9095 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2985,7 +2985,7 @@ def __eq__(self, other): if not isinstance(other, ColumnReference): return NotImplemented return ( - self.referenced_column == other.referencing_column + self.referencing_column == other.referencing_column and self.referenced_column == other.referenced_column ) From da663b2a61615bb43bea737088b5bc90efc13e1d Mon Sep 17 00:00:00 2001 From: Dmytro Karacheban Date: Sat, 16 Dec 2023 23:34:04 +0200 Subject: [PATCH 04/26] Add column_references to ForeignKey __eq__ --- google/cloud/bigquery/table.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index 480da9095..a8568bf4c 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -3018,7 +3018,9 @@ def __eq__(self, other): if not isinstance(other, ForeignKey): return NotImplemented return ( - self.name == other.name and self.referenced_table == other.referenced_table + self.name == other.name + and self.referenced_table == other.referenced_table + and self.column_references == other.column_references ) @classmethod From 29d123809ea60835c028eea27e4f3f005538d083 Mon Sep 17 00:00:00 2001 From: Dmytro Karacheban Date: Sat, 16 Dec 2023 23:35:07 +0200 Subject: [PATCH 05/26] Add missing coverage --- google/cloud/bigquery/table.py | 10 +- tests/unit/test_table.py | 168 +++++++++++++++++++++++++++++++++ 2 files changed, 172 insertions(+), 6 deletions(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index a8568bf4c..ad3300d53 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2989,11 +2989,6 @@ def __eq__(self, other): and self.referenced_column == other.referenced_column ) - @classmethod - def from_api_repr(cls, api_repr: Dict[str, Any]) -> "ColumnReference": - """Create an instance from API representation.""" - return cls(api_repr["referencingColumn"], api_repr["referencedColumn"]) - class ForeignKey: """Represents a foreign key constraint on a table's columns. @@ -3030,7 +3025,10 @@ def from_api_repr(cls, api_repr: Dict[str, Any]) -> "ForeignKey": name=api_repr["name"], referenced_table=TableReference.from_api_repr(api_repr["referencedTable"]), column_references=[ - ColumnReference.from_api_repr(column_reference_resource) + ColumnReference( + column_reference_resource["referencingColumn"], + column_reference_resource["referencedColumn"], + ) for column_reference_resource in api_repr["columnReferences"] ], ) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 5e0821aef..51e177a0a 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5401,6 +5401,174 @@ def test_set_expiration_w_none(self): assert time_partitioning._properties["expirationMs"] is None +class TestPrimaryKey(unittest.TestCase): + @staticmethod + def _get_target_class(): + from google.cloud.bigquery.table import PrimaryKey + + return PrimaryKey + + @classmethod + def _make_one(cls, *args, **kwargs): + return cls._get_target_class()(*args, **kwargs) + + def test_constructor_explicit(self): + columns = ["id", "product_id"] + primary_key = self._make_one(columns) + + self.assertEqual(primary_key.columns, columns) + + def test__eq__columns_mismatch(self): + primary_key = self._make_one(columns=["id", "product_id"]) + other_primary_key = self._make_one(columns=["id"]) + + self.assertNotEqual(primary_key, other_primary_key) + + def test__eq__other_type(self): + primary_key = self._make_one(columns=["id", "product_id"]) + + self.assertNotEqual(primary_key, object()) + + +class TestColumnReference(unittest.TestCase): + @staticmethod + def _get_target_class(): + from google.cloud.bigquery.table import ColumnReference + + return ColumnReference + + @classmethod + def _make_one(cls, *args, **kwargs): + return cls._get_target_class()(*args, **kwargs) + + def test_constructor_explicit(self): + referencing_column = "product_id" + referenced_column = "id" + column_reference = self._make_one(referencing_column, referenced_column) + + self.assertEqual(column_reference.referencing_column, referencing_column) + self.assertEqual(column_reference.referenced_column, referenced_column) + + def test__eq__referencing_column_mismatch(self): + column_reference = self._make_one( + referencing_column="product_id", + referenced_column="id", + ) + other_column_reference = self._make_one( + referencing_column="item_id", + referenced_column="id", + ) + + self.assertNotEqual(column_reference, other_column_reference) + + def test__eq__referenced_column_mismatch(self): + column_reference = self._make_one( + referencing_column="product_id", + referenced_column="id", + ) + other_column_reference = self._make_one( + referencing_column="product_id", + referenced_column="id_1", + ) + + self.assertNotEqual(column_reference, other_column_reference) + + def test__eq__other_type(self): + column_reference = self._make_one( + referencing_column="product_id", + referenced_column="id", + ) + + self.assertNotEqual(column_reference, object()) + + +class TestForeignKey(unittest.TestCase): + @staticmethod + def _get_target_class(): + from google.cloud.bigquery.table import ForeignKey + + return ForeignKey + + @classmethod + def _make_one(cls, *args, **kwargs): + return cls._get_target_class()(*args, **kwargs) + + def test_constructor_explicit(self): + name = "my_fk" + referenced_table = TableReference.from_string("my-project.mydataset.mytable") + column_references = [] + foreign_key = self._make_one(name, referenced_table, column_references) + + self.assertEqual(foreign_key.name, name) + self.assertEqual(foreign_key.referenced_table, referenced_table) + self.assertEqual(foreign_key.column_references, column_references) + + def test__eq__name_mismatch(self): + referenced_table = TableReference.from_string("my-project.mydataset.mytable") + column_references = [] + foreign_key = self._make_one( + name="my_fk", + referenced_table=referenced_table, + column_references=column_references, + ) + other_foreign_key = self._make_one( + name="my_other_fk", + referenced_table=referenced_table, + column_references=column_references, + ) + + self.assertNotEqual(foreign_key, other_foreign_key) + + def test__eq__referenced_table_mismatch(self): + name = "my_fk" + column_references = [] + foreign_key = self._make_one( + name=name, + referenced_table=TableReference.from_string("my-project.mydataset.mytable"), + column_references=column_references, + ) + other_foreign_key = self._make_one( + name=name, + referenced_table=TableReference.from_string( + "my-project.mydataset.my-other-table" + ), + column_references=column_references, + ) + + self.assertNotEqual(foreign_key, other_foreign_key) + + def test__eq__column_references_mismatch(self): + from google.cloud.bigquery.table import ColumnReference + + name = "my_fk" + referenced_table = TableReference.from_string("my-project.mydataset.mytable") + foreign_key = self._make_one( + name=name, + referenced_table=referenced_table, + column_references=[], + ) + other_foreign_key = self._make_one( + name=name, + referenced_table=referenced_table, + column_references=[ + ColumnReference( + referencing_column="product_id", referenced_column="id" + ), + ], + ) + + self.assertNotEqual(foreign_key, other_foreign_key) + + def test__eq__other_type(self): + foreign_key = self._make_one( + name="my_fk", + referenced_table=TableReference.from_string("my-project.mydataset.mytable"), + column_references=[], + ) + + self.assertNotEqual(foreign_key, object()) + + class TestTableConstraint(unittest.TestCase): @staticmethod def _get_target_class(): From c69d717f540808de00baf3093e3d3dce5e822c68 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Wed, 3 Jan 2024 07:08:06 -0500 Subject: [PATCH 06/26] Update google/cloud/bigquery/table.py --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index d5672b789..41dc63583 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2981,7 +2981,7 @@ def __init__(self, columns: List[str]): def __eq__(self, other): if not isinstance(other, PrimaryKey): - return NotImplemented + return TypeError("The value provided is not a BigQuery PrimaryKey.") return self.columns == other.columns From 8cdbc04a3938d11e6eb6bd60a0f0c0d67ae15d5e Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Wed, 3 Jan 2024 07:08:13 -0500 Subject: [PATCH 07/26] Update google/cloud/bigquery/table.py --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index 41dc63583..8db427c45 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2999,7 +2999,7 @@ def __init__(self, referencing_column: str, referenced_column: str): def __eq__(self, other): if not isinstance(other, ColumnReference): - return NotImplemented + return TypeError("The value provided is not a BigQuery ColumnReference.") return ( self.referencing_column == other.referencing_column and self.referenced_column == other.referenced_column From 55054bb9477d393573412964acbf68de18453b24 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Wed, 3 Jan 2024 07:08:26 -0500 Subject: [PATCH 08/26] Update google/cloud/bigquery/table.py --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index 8db427c45..fd96baf51 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -3027,7 +3027,7 @@ def __init__( def __eq__(self, other): if not isinstance(other, ForeignKey): - return NotImplemented + return TypeError("The value provided is not a BigQuery ForeignKey.") return ( self.name == other.name and self.referenced_table == other.referenced_table From 9d49e508c97ed12c3722b25ee5168c46f553f684 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Thu, 4 Jan 2024 09:13:32 -0500 Subject: [PATCH 09/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 21c202bea..51e9d3bb4 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5435,7 +5435,7 @@ def test__eq__columns_mismatch(self): def test__eq__other_type(self): primary_key = self._make_one(columns=["id", "product_id"]) - self.assertNotEqual(primary_key, object()) + self.assertNotEqual(primary_key, list) class TestColumnReference(unittest.TestCase): From 7bdfad95ffecdfa0b903b9791d5cb8691d72fff2 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Thu, 4 Jan 2024 09:13:45 -0500 Subject: [PATCH 10/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 51e9d3bb4..cb6bcca88 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5487,7 +5487,7 @@ def test__eq__other_type(self): referenced_column="id", ) - self.assertNotEqual(column_reference, object()) + self.assertNotEqual(column_reference, list) class TestForeignKey(unittest.TestCase): From 5145eb9770e8b7e3a38bbe0e90e87236185dc5c5 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Thu, 4 Jan 2024 09:44:20 -0500 Subject: [PATCH 11/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index cb6bcca88..22d905656 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5574,7 +5574,7 @@ def test__eq__other_type(self): column_references=[], ) - self.assertNotEqual(foreign_key, object()) + self.assertNotEqual(foreign_key, list) class TestTableConstraint(unittest.TestCase): From cd1ee016cb15b9ea660f4984067dfdb517945e68 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Fri, 5 Jan 2024 06:57:46 -0500 Subject: [PATCH 12/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 22d905656..dcc66992f 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5574,7 +5574,7 @@ def test__eq__other_type(self): column_references=[], ) - self.assertNotEqual(foreign_key, list) + self.assertNotEqual(foreign_key.column_references, None) class TestTableConstraint(unittest.TestCase): From dd8a16ba61f1f23491062a297bd471f3d5703a3d Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Fri, 5 Jan 2024 07:00:36 -0500 Subject: [PATCH 13/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index dcc66992f..9e4dd9618 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5435,7 +5435,7 @@ def test__eq__columns_mismatch(self): def test__eq__other_type(self): primary_key = self._make_one(columns=["id", "product_id"]) - self.assertNotEqual(primary_key, list) + self.assertNotEqual(primary_key.columns, None) class TestColumnReference(unittest.TestCase): From 1fa1cfd74bee2817e5521e693c78d6db202c0ede Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Fri, 5 Jan 2024 07:48:40 -0500 Subject: [PATCH 14/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 9e4dd9618..4cd87294d 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5435,7 +5435,7 @@ def test__eq__columns_mismatch(self): def test__eq__other_type(self): primary_key = self._make_one(columns=["id", "product_id"]) - self.assertNotEqual(primary_key.columns, None) + self.assertIsNot(primary_key, None) class TestColumnReference(unittest.TestCase): From 43ec13409b2f724748b2bcf4872c722078163824 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Fri, 5 Jan 2024 07:49:10 -0500 Subject: [PATCH 15/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 4cd87294d..6279a778a 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5487,7 +5487,7 @@ def test__eq__other_type(self): referenced_column="id", ) - self.assertNotEqual(column_reference, list) + self.assertIsNot(column_reference, None) class TestForeignKey(unittest.TestCase): From 3b566b80da00c9cf31bc0d88fafff8790e0d8db6 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Fri, 5 Jan 2024 07:49:44 -0500 Subject: [PATCH 16/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 6279a778a..7da00fe3e 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5574,7 +5574,7 @@ def test__eq__other_type(self): column_references=[], ) - self.assertNotEqual(foreign_key.column_references, None) + self.assertIsNot(foreign_key, None) class TestTableConstraint(unittest.TestCase): From eec92da07adb7c8e4d8c5a176fabd111b78f6b6e Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:24:28 -0500 Subject: [PATCH 17/26] Update google/cloud/bigquery/table.py --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index fd96baf51..ace5d69d0 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2981,7 +2981,7 @@ def __init__(self, columns: List[str]): def __eq__(self, other): if not isinstance(other, PrimaryKey): - return TypeError("The value provided is not a BigQuery PrimaryKey.") + raise TypeError("The value provided is not a BigQuery PrimaryKey.") return self.columns == other.columns From a84edc42aab1c5398328dcffce3ebb24aefc960d Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:24:35 -0500 Subject: [PATCH 18/26] Update google/cloud/bigquery/table.py --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index ace5d69d0..408f7022d 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -2999,7 +2999,7 @@ def __init__(self, referencing_column: str, referenced_column: str): def __eq__(self, other): if not isinstance(other, ColumnReference): - return TypeError("The value provided is not a BigQuery ColumnReference.") + raise TypeError("The value provided is not a BigQuery ColumnReference.") return ( self.referencing_column == other.referencing_column and self.referenced_column == other.referenced_column From bec1b4aaeacd344805bb01dd7610404bd9ac951e Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:24:42 -0500 Subject: [PATCH 19/26] Update google/cloud/bigquery/table.py --- google/cloud/bigquery/table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/bigquery/table.py b/google/cloud/bigquery/table.py index 408f7022d..b3be4ff90 100644 --- a/google/cloud/bigquery/table.py +++ b/google/cloud/bigquery/table.py @@ -3027,7 +3027,7 @@ def __init__( def __eq__(self, other): if not isinstance(other, ForeignKey): - return TypeError("The value provided is not a BigQuery ForeignKey.") + raise TypeError("The value provided is not a BigQuery ForeignKey.") return ( self.name == other.name and self.referenced_table == other.referenced_table From 8e07232fa20a05a77e79d7e27790de4553cdc726 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:24:52 -0500 Subject: [PATCH 20/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 7da00fe3e..415fe5807 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5434,8 +5434,8 @@ def test__eq__columns_mismatch(self): def test__eq__other_type(self): primary_key = self._make_one(columns=["id", "product_id"]) - - self.assertIsNot(primary_key, None) + with self.assertRaises(TypeError): + primary_key == 'This is not a Primary Key' class TestColumnReference(unittest.TestCase): From 60ba10c220121ac3f2ec4d6bfe8c08a5faad6e3e Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:25:12 -0500 Subject: [PATCH 21/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 415fe5807..ff9d9d176 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5573,8 +5573,8 @@ def test__eq__other_type(self): referenced_table=TableReference.from_string("my-project.mydataset.mytable"), column_references=[], ) - - self.assertIsNot(foreign_key, None) + with self.assertRaises(TypeError): + foreign_key == 'This is not a Foreign Key'``` class TestTableConstraint(unittest.TestCase): From 75f3482d9b9055851894817336f70c11f5bcdb19 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:25:20 -0500 Subject: [PATCH 22/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index ff9d9d176..a45f9bc20 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5486,8 +5486,8 @@ def test__eq__other_type(self): referencing_column="product_id", referenced_column="id", ) - - self.assertIsNot(column_reference, None) + with self.assertRaises(TypeError): + column_reference == 'This is not a Column Reference' class TestForeignKey(unittest.TestCase): From 21cac593b29c7b8f8183c479df865318767f7dd6 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 11:35:19 -0500 Subject: [PATCH 23/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index a45f9bc20..41be03858 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5574,7 +5574,7 @@ def test__eq__other_type(self): column_references=[], ) with self.assertRaises(TypeError): - foreign_key == 'This is not a Foreign Key'``` + foreign_key == 'This is not a Foreign Key' class TestTableConstraint(unittest.TestCase): From 69a72353f302206ecd50cf1c9e9793f23f0694a4 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 13:14:30 -0500 Subject: [PATCH 24/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index 41be03858..ade90b23e 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5574,7 +5574,7 @@ def test__eq__other_type(self): column_references=[], ) with self.assertRaises(TypeError): - foreign_key == 'This is not a Foreign Key' + foreign_key == "This is not a Foreign Key" class TestTableConstraint(unittest.TestCase): From c6ac02319d427b93d9b2975403ec313a84ec4205 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 13:14:37 -0500 Subject: [PATCH 25/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index ade90b23e..c4c80c947 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5487,7 +5487,7 @@ def test__eq__other_type(self): referenced_column="id", ) with self.assertRaises(TypeError): - column_reference == 'This is not a Column Reference' + column_reference == "This is not a Column Reference" class TestForeignKey(unittest.TestCase): From 7f40eab9a3c930fb797e10c49169e10097dfb761 Mon Sep 17 00:00:00 2001 From: Chalmer Lowe Date: Mon, 8 Jan 2024 13:14:43 -0500 Subject: [PATCH 26/26] Update tests/unit/test_table.py --- tests/unit/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_table.py b/tests/unit/test_table.py index c4c80c947..e4d0c66ab 100644 --- a/tests/unit/test_table.py +++ b/tests/unit/test_table.py @@ -5435,7 +5435,7 @@ def test__eq__columns_mismatch(self): def test__eq__other_type(self): primary_key = self._make_one(columns=["id", "product_id"]) with self.assertRaises(TypeError): - primary_key == 'This is not a Primary Key' + primary_key == "This is not a Primary Key" class TestColumnReference(unittest.TestCase):