Remove unnecessary Simplifier() instantiations in simplify.py

Author: georgesittas

sqlglot/optimizer/annotate_types.py

@@ -56,6 +56,7 @@ def annotate_types(
         expression_metadata: Maps expression type to corresponding annotation function.
         coerces_to: Maps expression type to set of types that it can be coerced into.
         overwrite_types: Re-annotate the existing AST types.
+
     Returns:
         The expression annotated with types.
     """

sqlglot/optimizer/normalize.py

@@ -6,7 +6,7 @@
 from sqlglot.errors import OptimizeError
 from sqlglot.helper import while_changing
 from sqlglot.optimizer.scope import find_all_in_scope
-from sqlglot.optimizer.simplify import flatten, rewrite_between, uniq_sort
+from sqlglot.optimizer.simplify import Simplifier, flatten
 
 logger = logging.getLogger("sqlglot")
 
@@ -28,14 +28,16 @@ def normalize(expression: exp.Expression, dnf: bool = False, max_distance: int =
     Returns:
         sqlglot.Expression: normalized expression
     """
+    simplifier = Simplifier()
+
     for node in tuple(expression.walk(prune=lambda e: isinstance(e, exp.Connector))):
         if isinstance(node, exp.Connector):
             if normalized(node, dnf=dnf):
                 continue
             root = node is expression
             original = node.copy()
 
-            node.transform(rewrite_between, copy=False)
+            node.transform(simplifier.rewrite_between, copy=False)
             distance = normalization_distance(node, dnf=dnf, max_=max_distance)
 
             if distance > max_distance:
@@ -46,7 +48,10 @@ def normalize(expression: exp.Expression, dnf: bool = False, max_distance: int =
 
             try:
                 node = node.replace(
-                    while_changing(node, lambda e: distributive_law(e, dnf, max_distance))
+                    while_changing(
+                        node,
+                        lambda e: distributive_law(e, dnf, max_distance, simplifier=simplifier),
+                    )
                 )
             except OptimizeError as e:
                 logger.info(e)
@@ -146,7 +151,7 @@ def _predicate_lengths(expression, dnf, max_=float("inf"), depth=0):
         yield from _predicate_lengths(right, dnf, max_, depth)
 
 
-def distributive_law(expression, dnf, max_distance):
+def distributive_law(expression, dnf, max_distance, simplifier=None):
     """
     x OR (y AND z) -> (x OR y) AND (x OR z)
     (x AND y) OR (y AND z) -> (x OR y) AND (x OR z) AND (y OR y) AND (y OR z)
@@ -168,32 +173,34 @@ def distributive_law(expression, dnf, max_distance):
         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()
+
         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))):
-                return _distribute(a, b, from_func, to_func)
-            return _distribute(b, a, from_func, to_func)
+                return _distribute(a, b, from_func, to_func, simplifier)
+            return _distribute(b, a, from_func, to_func, simplifier)
         if isinstance(a, to_exp):
-            return _distribute(b, a, from_func, to_func)
+            return _distribute(b, a, from_func, to_func, simplifier)
         if isinstance(b, to_exp):
-            return _distribute(a, b, from_func, to_func)
+            return _distribute(a, b, from_func, to_func, simplifier)
 
     return expression
 
 
-def _distribute(a, b, from_func, to_func):
+def _distribute(a, b, from_func, to_func, simplifier):
     if isinstance(a, exp.Connector):
         exp.replace_children(
             a,
             lambda c: to_func(
-                uniq_sort(flatten(from_func(c, b.left))),
-                uniq_sort(flatten(from_func(c, b.right))),
+                simplifier.uniq_sort(flatten(from_func(c, b.left))),
+                simplifier.uniq_sort(flatten(from_func(c, b.right))),
                 copy=False,
             ),
         )
     else:
         a = to_func(
-            uniq_sort(flatten(from_func(a, b.left))),
-            uniq_sort(flatten(from_func(a, b.right))),
+            simplifier.uniq_sort(flatten(from_func(a, b.left))),
+            simplifier.uniq_sort(flatten(from_func(a, b.right))),
             copy=False,
         )
 

sqlglot/optimizer/simplify.py

@@ -108,17 +108,47 @@ def flatten(expression):
     return expression
 
 
-# Backward compatibility wrappers for functions used by other modules
-def rewrite_between(expression: exp.Expression) -> exp.Expression:
-    return Simplifier().rewrite_between(expression)
+def simplify_parens(expression: exp.Expression, dialect: DialectType) -> exp.Expression:
+    if not isinstance(expression, exp.Paren):
+        return expression
 
+    this = expression.this
+    parent = expression.parent
+    parent_is_predicate = isinstance(parent, exp.Predicate)
 
-def uniq_sort(expression: exp.Expression, root: bool = True) -> exp.Expression:
-    return Simplifier().uniq_sort(expression, root)
+    if isinstance(this, exp.Select):
+        return expression
 
+    if isinstance(parent, (exp.SubqueryPredicate, exp.Bracket)):
+        return expression
 
-def simplify_parens(expression: exp.Expression, dialect: DialectType) -> exp.Expression:
-    return Simplifier(dialect=dialect).simplify_parens(expression, dialect)
+    # Handle risingwave struct columns
+    # see https://docs.risingwave.com/sql/data-types/struct#retrieve-data-in-a-struct
+    if (
+        dialect == "risingwave"
+        and isinstance(parent, exp.Dot)
+        and (isinstance(parent.right, (exp.Identifier, exp.Star)))
+    ):
+        return expression
+
+    if (
+        not isinstance(parent, (exp.Condition, exp.Binary))
+        or isinstance(parent, exp.Paren)
+        or (
+            not isinstance(this, exp.Binary)
+            and not (isinstance(this, (exp.Not, exp.Is)) and parent_is_predicate)
+        )
+        or (
+            isinstance(this, exp.Predicate)
+            and not (parent_is_predicate or isinstance(parent, exp.Neg))
+        )
+        or (isinstance(this, exp.Add) and isinstance(parent, exp.Add))
+        or (isinstance(this, exp.Mul) and isinstance(parent, exp.Mul))
+        or (isinstance(this, exp.Mul) and isinstance(parent, (exp.Add, exp.Sub)))
+    ):
+        return this
+
+    return expression
 
 
 def propagate_constants(expression, root=True):
@@ -594,7 +624,7 @@ def _simplify(expression):
 
                 new_node = self.simplify_literals(new_node, root)
                 new_node = self.simplify_equality(new_node)
-                new_node = self.simplify_parens(new_node, dialect=self.dialect)
+                new_node = simplify_parens(new_node, dialect=self.dialect)
                 new_node = self.simplify_datetrunc(new_node)
                 new_node = self.sort_comparison(new_node)
                 new_node = self.simplify_startswith(new_node)
@@ -1067,48 +1097,6 @@ def _simplify_binary(self, expression, a, b):
 
         return None
 
-    def simplify_parens(self, expression: exp.Expression, dialect: DialectType) -> exp.Expression:
-        if not isinstance(expression, exp.Paren):
-            return expression
-
-        this = expression.this
-        parent = expression.parent
-        parent_is_predicate = isinstance(parent, exp.Predicate)
-
-        if isinstance(this, exp.Select):
-            return expression
-
-        if isinstance(parent, (exp.SubqueryPredicate, exp.Bracket)):
-            return expression
-
-        # Handle risingwave struct columns
-        # see https://docs.risingwave.com/sql/data-types/struct#retrieve-data-in-a-struct
-        if (
-            dialect == "risingwave"
-            and isinstance(parent, exp.Dot)
-            and (isinstance(parent.right, (exp.Identifier, exp.Star)))
-        ):
-            return expression
-
-        if (
-            not isinstance(parent, (exp.Condition, exp.Binary))
-            or isinstance(parent, exp.Paren)
-            or (
-                not isinstance(this, exp.Binary)
-                and not (isinstance(this, (exp.Not, exp.Is)) and parent_is_predicate)
-            )
-            or (
-                isinstance(this, exp.Predicate)
-                and not (parent_is_predicate or isinstance(parent, exp.Neg))
-            )
-            or (isinstance(this, exp.Add) and isinstance(parent, exp.Add))
-            or (isinstance(this, exp.Mul) and isinstance(parent, exp.Mul))
-            or (isinstance(this, exp.Mul) and isinstance(parent, (exp.Add, exp.Sub)))
-        ):
-            return this
-
-        return expression
-
     @annotate_types_on_change
     def simplify_coalesce(self, expression: exp.Expression) -> exp.Expression:
         # COALESCE(x) -> x