perf(optimizer): skip redundant hash invalidation in simplify's pointer-reset loop (#7725)

_simplify's post-order pass re-anchors every child's parent/arg_key/index
pointers via set(), which also clears cached structural hashes up the
ancestor chain. The loop never changes values (it rewrites args[k] with
itself), and actual mutations already invalidate at mutation time through
set/replace/pop, so the only effect of the extra invalidation was forcing
while_changing to rehash entire condition subtrees after every (mostly
no-op) pass to detect the fix point.

Fix pointers directly with _set_parent, preserving set(k, None)'s
arg-removal semantics. Simplify step ~5-12% faster across condition and
TPC fixtures; output is byte-identical.

Author: tobymao

sqlglot/optimizer/simplify.py

@@ -699,9 +699,16 @@ def _simplify(
             root = original is expression
 
             # Resets parent, arg_key, index pointers– this is needed because some of the
-            # previous transformations mutate the AST, leading to an inconsistent state
+            # previous transformations mutate the AST, leading to an inconsistent state.
+            # We only fix pointers instead of calling `set` because the values are unchanged:
+            # actual mutations go through `set`/`replace`, which already invalidate cached
+            # hashes, so clearing them again here would force `while_changing` to rehash
+            # entire subtrees after every (mostly no-op) pass.
             for k, v in tuple(original.args.items()):
-                original.set(k, v)
+                if v is None:
+                    original.args.pop(k)
+                else:
+                    original._set_parent(k, v)
 
             # Post-order transformations
             node = self.simplify_not(original)