adds test for type vs ftd and test for enums

Author: chalmerlowe

google/cloud/bigquery/enums.py

@@ -246,6 +246,11 @@ class KeyResultStatementKind:
 
 
 class StandardSqlTypeNames(str, enum.Enum):
+    """Enum of allowed SQL type names in schema.SchemaField.
+
+    Datatype used in GoogleSQL. 
+    """
+    
     def _generate_next_value_(name, start, count, last_values):
         return name
 
@@ -287,7 +292,10 @@ class EntityTypes(str, enum.Enum):
 # See also: https://cloud.google.com/bigquery/data-types#legacy_sql_data_types
 # and https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types
 class SqlTypeNames(str, enum.Enum):
-    """Enum of allowed SQL type names in schema.SchemaField."""
+    """Enum of allowed SQL type names in schema.SchemaField.
+
+    Datatype used in Legacy SQL.
+    """
 
     STRING = "STRING"
     BYTES = "BYTES"
@@ -309,7 +317,7 @@ class SqlTypeNames(str, enum.Enum):
     INTERVAL = "INTERVAL"  # NOTE: not available in legacy types
     RANGE = "RANGE"  # NOTE: not available in legacy types
     FOREIGN = "FOREIGN"  # NOTE: FOREIGN acts as a wrapper for data types
-                         # not natively understood by BigQuery unless translated
+                           # not natively understood by BigQuery unless translated
 
 
 class WriteDisposition(object):

google/cloud/bigquery/schema.py

@@ -32,8 +32,8 @@
 _STRUCT_TYPES = ("RECORD", "STRUCT")
 
 # SQL types reference:
-# https://cloud.google.com/bigquery/data-types#legacy_sql_data_types
-# https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types
+# LEGACY SQL: https://cloud.google.com/bigquery/data-types#legacy_sql_data_types
+# GoogleSQL: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types
 LEGACY_TO_STANDARD_TYPES = {
     "STRING": StandardSqlTypeNames.STRING,
     "BYTES": StandardSqlTypeNames.BYTES,
@@ -52,6 +52,7 @@
     "DATE": StandardSqlTypeNames.DATE,
     "TIME": StandardSqlTypeNames.TIME,
     "DATETIME": StandardSqlTypeNames.DATETIME,
+    "FOREIGN": StandardSqlTypeNames.FOREIGN,
     # no direct conversion from ARRAY, the latter is represented by mode="REPEATED"
 }
 """String names of the legacy SQL types to integer codes of Standard SQL standard_sql."""
@@ -170,6 +171,7 @@ class SchemaField(object):
             the type is RANGE, this field is required. Possible values for the
             field element type of a RANGE include `DATE`, `DATETIME` and
             `TIMESTAMP`.
+        TODO: add docstring here.
     """
 
     def __init__(
@@ -188,10 +190,9 @@ def __init__(
         rounding_mode: Union[RoundingMode, str, None] = None,
         foreign_type_definition: Optional[str] = None,
     ):
-        self._properties: Dict[str, Any] = {
-            "name": name,
-            "type": field_type,
-        }
+        self._properties: Dict[str, Any] = {}
+        
+        self._properties["name"] = name
         if mode is not None:
             self._properties["mode"] = mode.upper()
         if description is not _DEFAULT_VALUE:
@@ -218,7 +219,16 @@ def __init__(
             self._properties["roundingMode"] = rounding_mode
         if isinstance(foreign_type_definition, str):
             self._properties["foreignTypeDefinition"] = foreign_type_definition
-
+        
+        # The order of operations is important: 
+        # If field_type is FOREIGN, then foreign_type_definition must be set.
+        if field_type != "FOREIGN":
+            self._properties["type"] = field_type
+        else:
+            if self._properties.get("foreignTypeDefinition") is None:
+                raise ValueError("If the 'field_type' is 'FOREIGN', then 'foreign_type_definition' is required.")
+            self._properties["type"] = field_type
+        
         self._fields = tuple(fields)
 
     @staticmethod

tests/unit/test_schema.py

@@ -163,9 +163,9 @@ def test_to_api_repr(self):
             description="hello world",
             policy_tags=policy,
             rounding_mode=ROUNDINGMODE,
-            foreign_type_definition="INTEGER",
+            foreign_type_definition=None,
         )
-
+        print(f"DINOSAUR: {field}\n\n{field.to_api_repr()}")
         self.assertEqual(
             field.to_api_repr(),
             {
@@ -175,7 +175,6 @@ def test_to_api_repr(self):
                 "description": "hello world",
                 "policyTags": {"names": ["foo", "bar"]},
                 "roundingMode": "ROUNDING_MODE_UNSPECIFIED",
-                "foreignTypeDefinition": "INTEGER",
             },
         )
 
@@ -210,7 +209,6 @@ def test_from_api_repr(self):
                 "name": "foo",
                 "type": "record",
                 "roundingMode": "ROUNDING_MODE_UNSPECIFIED",
-                "foreignTypeDefinition": "INTEGER",
             }
         )
         self.assertEqual(field.name, "foo")
@@ -223,7 +221,6 @@ def test_from_api_repr(self):
         self.assertEqual(field.fields[0].mode, "NULLABLE")
         self.assertEqual(field.range_element_type, None)
         self.assertEqual(field.rounding_mode, "ROUNDING_MODE_UNSPECIFIED")
-        self.assertEqual(field.foreign_type_definition, "INTEGER")
 
     def test_from_api_repr_policy(self):
         field = self._get_target_class().from_api_repr(
@@ -329,7 +326,8 @@ def test_to_standard_sql_simple_type(self):
             ("GEOGRAPHY", bigquery.StandardSqlTypeNames.GEOGRAPHY),
         )
         for legacy_type, standard_type in examples:
-            field = self._make_one("some_field", legacy_type)
+            
+            field = self._make_one("some_field", legacy_type)            
             standard_field = field.to_standard_sql()
             self.assertEqual(standard_field.name, "some_field")
             self.assertEqual(standard_field.type.type_kind, standard_type)
@@ -489,6 +487,16 @@ def test_to_standard_sql_unknown_type(self):
             bigquery.StandardSqlTypeNames.TYPE_KIND_UNSPECIFIED,
         )
 
+    def test_to_standard_sql_foreign_type(self):
+        examples = (
+            ("FOREIGN", bigquery.StandardSqlTypeNames.FOREIGN, "INTEGER"),            
+        )
+        for legacy_type, standard_type, foreign_type_definition in examples:
+            field = self._make_one("some_field", legacy_type, foreign_type_definition=foreign_type_definition)            
+            standard_field = field.to_standard_sql()
+            self.assertEqual(standard_field.name, "some_field")
+            self.assertEqual(standard_field.type.type_kind, standard_type)
+
     def test___eq___wrong_type(self):
         field = self._make_one("test", "STRING")
         other = object()