introduce enum

Author: m-abulazm

src/databricks/labs/lakebridge/reconcile/design/expressions.py

@@ -2,7 +2,6 @@
 import typing as t
 
 import sqlglot.expressions as e
-import sqlglot.time as et
 from sqlglot.dialects import Dialect as SqlglotDialect
 
 DialectType = t.Union[str, SqlglotDialect, t.Type[SqlglotDialect], None]

src/databricks/labs/lakebridge/reconcile/design/normalizers.py

@@ -3,24 +3,9 @@
 
 import expressions as e
 from databricks.labs.lakebridge.reconcile.connectors.dialect_utils import DialectUtils
+from utypes import ExternalType, UType, DatabaseTypeName
 
 
-class Type:
-    name: str
-
-    def __eq__(self, other):
-        return isinstance(other, Type) and self.name.lower() == other.name.lower()
-    def __hash__(self):
-        return hash(self.name.lower())
-
-@dataclasses.dataclass(frozen=True)
-class UType(Type):
-    name: str
-
-@dataclasses.dataclass(frozen=True)
-class ExternalType(Type): # can be sybtyped if needed to override equal e.g. combining all oracle char columns in one
-    name: str
-
 @dataclasses.dataclass(frozen=True)
 class ExternalColumnDefinition:
     name: str
@@ -129,11 +114,11 @@ class UDatetimeTypeNormalizer(AbstractTypeNormalizer):
 
     @classmethod
     def registry_key(cls) -> str:
-        return cls.utype().name
+        return cls.utype().name.name
 
     @classmethod
     def utype(cls) -> UType:
-        return UType(cls.__name__.removesuffix("TypeNormalizer").upper())
+        return UType(DatabaseTypeName.DATETIME)
 
     def normalize_oracle(self, column: e.ExpressionBuilder, source_col: ExternalColumnDefinition) -> e.ExpressionBuilder:
         return column
@@ -150,7 +135,7 @@ class UStringTypeNormalizer(AbstractTypeNormalizer):
 
     @classmethod
     def registry_key(cls) -> str:
-        return cls.utype().name
+        return cls.utype().name.name
 
     @classmethod
     def utype(cls) -> UType:
@@ -180,27 +165,33 @@ def register_normalizer(self, normalizer: AbstractNormalizer): # also subclasses
             self.registry[normalizer.registry_key_family()] = {}
         self.registry[normalizer.registry_key_family()][normalizer.registry_key()] = normalizer
 
-    def get_type_normalizer(self, utype: UType) -> AbstractTypeNormalizer | None:
-        return self.registry.get(AbstractTypeNormalizer.registry_key_family()).get(utype.name)
+    def get_type_normalizer(self, name: DatabaseTypeName) -> AbstractTypeNormalizer | None:
+        return self.registry.get(AbstractTypeNormalizer.registry_key_family()).get(name.name)
 
 class DialectNormalizer(ABC):
-    type_normalizers: dict[ExternalType, UType] # do we need more info
+    DbTypeNormalizerType = dict[DatabaseTypeName, DatabaseTypeName]
+    # or ExternalType to UType. what about extra type information e.g scale, precision?
+
     dialect: e.DialectType
 
+    @classmethod
+    def type_normalizers(cls, overrides: DbTypeNormalizerType) -> DbTypeNormalizerType:
+        return {
+            DatabaseTypeName("DATE"): UDatetimeTypeNormalizer.utype().name,
+            **overrides
+        }
+
     @abstractmethod
     def normalize(self, column_def: ExternalColumnDefinition, registry: NormalizersRegistry) -> e.ExpressionBuilder:
         pass
 
 
 class OracleNormalizer(DialectNormalizer):
-    type_normalizers = {
-        ExternalType("DATE"): UDatetimeTypeNormalizer.utype()
-    }
     dialect = "oracle"
 
     def normalize(self, column_def: ExternalColumnDefinition, registry: NormalizersRegistry) -> e.ExpressionBuilder:
         start = e.ExpressionBuilder(column_def.name, self.dialect, None)
-        utype = self.type_normalizers.get(column_def.data_type)
+        utype = self.type_normalizers({}).get(column_def.data_type.name)
         if utype:
             normalizer = registry.get_type_normalizer(utype)
             if normalizer:
@@ -212,13 +203,9 @@ def normalize(self, column_def: ExternalColumnDefinition, registry: NormalizersR
     registry.register_normalizer(UDatetimeTypeNormalizer())
     oracle = OracleNormalizer()
 
-    column = ExternalColumnDefinition("student_id", ExternalType("NCHAR"))
+    column = ExternalColumnDefinition("student_id", ExternalType(DatabaseTypeName["NCHAR"]))
     column_builder = oracle.normalize(column, registry)
 
     sql = column_builder.build()
     print(sql)
     assert sql == "SELECT student_id"
-
-
-
-

src/databricks/labs/lakebridge/reconcile/design.py renamed to src/databricks/labs/lakebridge/reconcile/design/pipeline.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class AutoName(Enum):
+    """
+    This is used for creating Enum classes where `auto()` is the string form
+    of the corresponding enum's identifier (e.g. FOO.value results in "FOO").
+
+    Reference: https://docs.python.org/3/howto/enum.html#using-automatic-values
+    """
+
+    def _generate_next_value_(name, _start, _count, _last_values):
+        return name