Add a hashcode implementation to SchemaField

bigquery/google/cloud/bigquery/schema.py

@@ -26,27 +26,89 @@ class SchemaField(object):
                        'FLOAT', 'BOOLEAN', 'TIMESTAMP' or 'RECORD').
 
     :type mode: str
-    :param mode: the type of the field (one of 'NULLABLE', 'REQUIRED',
+    :param mode: the mode of the field (one of 'NULLABLE', 'REQUIRED',
                  or 'REPEATED').
 
     :type description: str
     :param description: optional description for the field.
 
-    :type fields: list of :class:`SchemaField`, or None
+    :type fields: tuple of :class:`SchemaField`
     :param fields: subfields (requires ``field_type`` of 'RECORD').
     """
-    def __init__(self, name, field_type, mode='NULLABLE', description=None,
-                 fields=None):
-        self.name = name
-        self.field_type = field_type
-        self.mode = mode
-        self.description = description
-        self.fields = fields
+    def __init__(self, name, field_type, mode='NULLABLE',
+                 description=None, fields=()):
+        self._name = name
+        self._field_type = field_type
+        self._mode = mode
+        self._description = description
+        self._fields = tuple(fields)
 
-    def __eq__(self, other):
+    @property
+    def name(self):
+        """str: The name of the field."""
+        return self._name
+
+    @property
+    def field_type(self):
+        """str: The type of the field.
+
+        Will be one of 'STRING', 'INTEGER', 'FLOAT', 'BOOLEAN',
+        'TIMESTAMP' or 'RECORD'.
+        """
+        return self._field_type
+
+    @property
+    def mode(self):
+        """str: The mode of the field.
+
+        Will be one of 'NULLABLE', 'REQUIRED', or 'REPEATED'.
+        """
+        return self._mode
+
+    @property
+    def description(self):
+        """Optional[str]: Description for the field."""
+        return self._description
+
+    @property
+    def fields(self):
+        """tuple: Subfields contained in this field.
+
+        If ``field_type`` is not 'RECORD', this property must be
+        empty / unset.
+        """
+        return self._fields
+
+    def _key(self):
+        """A tuple key that unique-ly describes this field.
+
+        Used to compute this instance's hashcode and evaluate equality.
+
+        Returns:
+            tuple: The contents of this :class:`SchemaField`.
+        """
         return (
-            self.name == other.name and
-            self.field_type.lower() == other.field_type.lower() and
-            self.mode == other.mode and
-            self.description == other.description and
-            self.fields == other.fields)
+            self._name,
+            self._field_type.lower(),
+            self._mode,
+            self._description,
+            self._fields,
+        )
+
+    def __eq__(self, other):
+        if isinstance(other, SchemaField):
+            return self._key() == other._key()
+        else:
+            return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, SchemaField):
+            return self._key() != other._key()
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash(self._key())
+
+    def __repr__(self):
+        return 'SchemaField{}'.format(self._key())

bigquery/google/cloud/bigquery/table.py

@@ -1079,7 +1079,7 @@ def _parse_schema_resource(info):
                 present in ``info``.
     """
     if 'fields' not in info:
-        return None
+        return ()
 
     schema = []
     for r_field in info['fields']:
@@ -1109,7 +1109,7 @@ def _build_schema_resource(fields):
                 'mode': field.mode}
         if field.description is not None:
             info['description'] = field.description
-        if field.fields is not None:
+        if field.fields:
             info['fields'] = _build_schema_resource(field.fields)
         infos.append(info)
     return infos

bigquery/tests/unit/test_query.py

@@ -88,9 +88,9 @@ def _verifySchema(self, query, resource):
                 self.assertEqual(found.mode, expected['mode'])
                 self.assertEqual(found.description,
                                  expected.get('description'))
-                self.assertEqual(found.fields, expected.get('fields'))
+                self.assertEqual(found.fields, expected.get('fields', ()))
         else:
-            self.assertIsNone(query.schema)
+            self.assertEqual(query.schema, ())
 
     def _verifyRows(self, query, resource):
         expected = resource.get('rows')
@@ -166,7 +166,7 @@ def test_ctor_defaults(self):
         self.assertIsNone(query.page_token)
         self.assertEqual(query.query_parameters, [])
         self.assertEqual(query.rows, [])
-        self.assertIsNone(query.schema)
+        self.assertEqual(query.schema, ())
         self.assertIsNone(query.total_rows)
         self.assertIsNone(query.total_bytes_processed)
         self.assertEqual(query.udf_resources, [])

bigquery/tests/unit/test_schema.py

@@ -26,43 +26,72 @@ def _get_target_class():
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
-    def test_ctor_defaults(self):
+    def test_constructor_defaults(self):
         field = self._make_one('test', 'STRING')
-        self.assertEqual(field.name, 'test')
-        self.assertEqual(field.field_type, 'STRING')
-        self.assertEqual(field.mode, 'NULLABLE')
-        self.assertIsNone(field.description)
-        self.assertIsNone(field.fields)
+        self.assertEqual(field._name, 'test')
+        self.assertEqual(field._field_type, 'STRING')
+        self.assertEqual(field._mode, 'NULLABLE')
+        self.assertIsNone(field._description)
+        self.assertEqual(field._fields, ())
 
-    def test_ctor_explicit(self):
+    def test_constructor_explicit(self):
         field = self._make_one('test', 'STRING', mode='REQUIRED',
                                description='Testing')
-        self.assertEqual(field.name, 'test')
-        self.assertEqual(field.field_type, 'STRING')
-        self.assertEqual(field.mode, 'REQUIRED')
-        self.assertEqual(field.description, 'Testing')
-        self.assertIsNone(field.fields)
-
-    def test_ctor_subfields(self):
+        self.assertEqual(field._name, 'test')
+        self.assertEqual(field._field_type, 'STRING')
+        self.assertEqual(field._mode, 'REQUIRED')
+        self.assertEqual(field._description, 'Testing')
+        self.assertEqual(field._fields, ())
+
+    def test_constructor_subfields(self):
+        sub_field1 = self._make_one('area_code', 'STRING')
+        sub_field2 = self._make_one('local_number', 'STRING')
         field = self._make_one(
-            'phone_number', 'RECORD',
-            fields=[self._make_one('area_code', 'STRING'),
-                    self._make_one('local_number', 'STRING')])
-        self.assertEqual(field.name, 'phone_number')
-        self.assertEqual(field.field_type, 'RECORD')
-        self.assertEqual(field.mode, 'NULLABLE')
-        self.assertIsNone(field.description)
-        self.assertEqual(len(field.fields), 2)
-        self.assertEqual(field.fields[0].name, 'area_code')
-        self.assertEqual(field.fields[0].field_type, 'STRING')
-        self.assertEqual(field.fields[0].mode, 'NULLABLE')
-        self.assertIsNone(field.fields[0].description)
-        self.assertIsNone(field.fields[0].fields)
-        self.assertEqual(field.fields[1].name, 'local_number')
-        self.assertEqual(field.fields[1].field_type, 'STRING')
-        self.assertEqual(field.fields[1].mode, 'NULLABLE')
-        self.assertIsNone(field.fields[1].description)
-        self.assertIsNone(field.fields[1].fields)
+            'phone_number',
+            'RECORD',
+            fields=[sub_field1, sub_field2],
+        )
+        self.assertEqual(field._name, 'phone_number')
+        self.assertEqual(field._field_type, 'RECORD')
+        self.assertEqual(field._mode, 'NULLABLE')
+        self.assertIsNone(field._description)
+        self.assertEqual(len(field._fields), 2)
+        self.assertIs(field._fields[0], sub_field1)
+        self.assertIs(field._fields[1], sub_field2)
+
+    def test_name_property(self):
+        name = 'lemon-ness'
+        schema_field = self._make_one(name, 'INTEGER')
+        self.assertIs(schema_field.name, name)
+
+    def test_field_type_property(self):
+        field_type = 'BOOLEAN'
+        schema_field = self._make_one('whether', field_type)
+        self.assertIs(schema_field.field_type, field_type)
+
+    def test_mode_property(self):
+        mode = 'REPEATED'
+        schema_field = self._make_one('again', 'FLOAT', mode=mode)
+        self.assertIs(schema_field.mode, mode)
+
+    def test_description_property(self):
+        description = 'It holds some data.'
+        schema_field = self._make_one(
+            'do', 'TIMESTAMP', description=description)
+        self.assertIs(schema_field.description, description)
+
+    def test_fields_property(self):
+        sub_field1 = self._make_one('one', 'STRING')
+        sub_field2 = self._make_one('fish', 'INTEGER')
+        fields = (sub_field1, sub_field2)
+        schema_field = self._make_one('boat', 'RECORD', fields=fields)
+        self.assertIs(schema_field.fields, fields)
+
+    def test___eq___wrong_type(self):
+        field = self._make_one('test', 'STRING')
+        other = object()
+        self.assertNotEqual(field, other)
+        self.assertIs(field.__eq__(other), NotImplemented)
 
     def test___eq___name_mismatch(self):
         field = self._make_one('test', 'STRING')
@@ -111,3 +140,46 @@ def test___eq___hit_w_fields(self):
         field = self._make_one('test', 'RECORD', fields=[sub1, sub2])
         other = self._make_one('test', 'RECORD', fields=[sub1, sub2])
         self.assertEqual(field, other)
+
+    def test___ne___wrong_type(self):
+        field = self._make_one('toast', 'INTEGER')
+        other = object()
+        self.assertNotEqual(field, other)
+        self.assertIs(field.__ne__(other), NotImplemented)
+
+    def test___ne___same_value(self):
+        field1 = self._make_one('test', 'TIMESTAMP', mode='REPEATED')
+        field2 = self._make_one('test', 'TIMESTAMP', mode='REPEATED')
+        # unittest ``assertEqual`` uses ``==`` not ``!=``.
+        comparison_val = (field1 != field2)
+        self.assertFalse(comparison_val)
+
+    def test___ne___different_values(self):
+        field1 = self._make_one(
+            'test1', 'FLOAT', mode='REPEATED', description='Not same')
+        field2 = self._make_one(
+            'test2', 'FLOAT', mode='NULLABLE', description='Knot saym')
+        self.assertNotEqual(field1, field2)
+
+    def test___hash__set_equality(self):
+        sub1 = self._make_one('sub1', 'STRING')
+        sub2 = self._make_one('sub2', 'STRING')
+        field1 = self._make_one('test', 'RECORD', fields=[sub1])
+        field2 = self._make_one('test', 'RECORD', fields=[sub2])
+        set_one = {field1, field2}
+        set_two = {field1, field2}
+        self.assertEqual(set_one, set_two)
+
+    def test___hash__not_equals(self):
+        sub1 = self._make_one('sub1', 'STRING')
+        sub2 = self._make_one('sub2', 'STRING')
+        field1 = self._make_one('test', 'RECORD', fields=[sub1])
+        field2 = self._make_one('test', 'RECORD', fields=[sub2])
+        set_one = {field1}
+        set_two = {field2}
+        self.assertNotEqual(set_one, set_two)
+
+    def test___repr__(self):
+        field1 = self._make_one('field1', 'STRING')
+        expected = "SchemaField('field1', 'string', 'NULLABLE', None, ())"
+        self.assertEqual(repr(field1), expected)