fix new expression type

Author: georgesittas

sqlglot/optimizer/normalize.py

@@ -28,7 +28,7 @@ def normalize(expression: exp.Expression, dnf: bool = False, max_distance: int =
     Returns:
         sqlglot.Expression: normalized expression
     """
-    simplifier = Simplifier()
+    simplifier = Simplifier(annotate_new_expressions=False)
 
     for node in tuple(expression.walk(prune=lambda e: isinstance(e, exp.Connector))):
         if isinstance(node, exp.Connector):
@@ -173,7 +173,7 @@ def distributive_law(expression, dnf, max_distance, simplifier=None):
         from_func = exp.and_ if from_exp == exp.And else exp.or_
         to_func = exp.and_ if to_exp == exp.And else exp.or_
 
-        simplifier = simplifier or Simplifier()
+        simplifier = simplifier or Simplifier(annotate_new_expressions=False)
 
         if isinstance(a, to_exp) and isinstance(b, to_exp):
             if len(tuple(a.find_all(exp.Connector))) > len(tuple(b.find_all(exp.Connector))):

sqlglot/optimizer/simplify.py

@@ -85,11 +85,19 @@ def _func(self, expression: exp.Expression, *args, **kwargs) -> t.Optional[exp.E
         if new_expression is None:
             return new_expression
 
-        if new_expression != expression:
+        if self.annotate_new_expressions and expression != new_expression:
             self._annotator.clear()
+
+            # We annotate this to ensure new children nodes are also annotated
             new_expression = self._annotator.annotate(
-                expression=new_expression, annotate_scope=False
+                expression=new_expression,
+                annotate_scope=False,
             )
+
+            # Whatever expression the original expression is transformed into needs to preserve
+            # the original type, otherwise the simplification could result in a different schema
+            new_expression.type = expression.type
+
         return new_expression
 
     return _func
@@ -452,11 +460,9 @@ def boolean_literal(condition):
 
 
 class Simplifier:
-    def __init__(
-        self,
-        dialect: DialectType = None,
-    ):
+    def __init__(self, dialect: DialectType = None, annotate_new_expressions: bool = True):
         self.dialect = Dialect.get_or_raise(dialect)
+        self.annotate_new_expressions = annotate_new_expressions
 
         self._annotator: TypeAnnotator = TypeAnnotator(
             schema=ensure_schema(None, dialect=self.dialect), overwrite_types=False