fix: make DataType.type return self instead of a clone (#7708)

annotate_types stored a deep clone of each DataType node in the node's
own _type slot via `self._set_type(e, e.copy())`. The .copy() existed
to avoid a self-cycle that would break recursive consumers of _type
(serde.dump, etc). But Expr.__deepcopy__ also recursively walked _type,
so every later e.copy() of an ancestor dragged the shadow type along.
The work compounded across nested STRUCT levels and turned annotate
into a >100s operation on wide, deeply nested STRUCT casts.

Conceptually, asking "what type is this DataType?" should answer "itself".
Special-case DataType in Expression.type the same way Cast already is,
via an is_data_type ClassVar:

- Expression.type returns self when self.is_data_type is True.
- DataType (and all its subclasses) set is_data_type = True.
- The DataType annotator becomes a no-op (no copy needed; no _type to set).
- serde.dump skips the TYPE field when node.type is node, since storing
  a self-reference is meaningless and was the original reason the
  annotator needed the .copy().
- _to_s uses node.is_data_type so DataType subclasses (IntervalSpan,
  PseudoType, ObjectIdentifier) are skipped uniformly during repr.

Behavior change to call out: on a DataType `dt`, `dt.type is dt` is now
true (previously it returned a clone, equal but not identical). Equality
semantics are unchanged.

Author: VaggelisD

sqlglot/expressions/core.py

@@ -88,6 +88,7 @@ class Expr:
     _hash_raw_args: t.ClassVar[bool] = False
     is_subquery: t.ClassVar[bool] = False
     is_cast: t.ClassVar[bool] = False
+    is_data_type: t.ClassVar[bool] = False
 
     args: dict[str, t.Any]
     parent: Expr | None
@@ -962,6 +963,8 @@ def output_name(self) -> str:
 
     @property
     def type(self) -> DataType | None:
+        if self.is_data_type:
+            return self  # type: ignore[return-value]
         if self.is_cast:
             return self._type or self.to  # type: ignore[attr-defined]
         return self._type
@@ -2552,7 +2555,7 @@ def _to_s(node: t.Any, verbose: bool = False, level: int = 0, repr_str: bool = F
     if isinstance(node, Expr):
         args = {k: v for k, v in node.args.items() if (v is not None and v != []) or verbose}
 
-        if (node.type or verbose) and type(node).__name__ != "DataType":
+        if (node.type or verbose) and not node.is_data_type:
             args["_type"] = node.type
         if node.comments or verbose:
             args["_comments"] = node.comments

sqlglot/expressions/datatypes.py

@@ -187,6 +187,8 @@ class DataType(Expression):
         "collate": False,
     }
 
+    is_data_type: t.ClassVar[bool] = True
+
     Type: t.ClassVar[Type[DType]] = DType
 
     STRUCT_TYPES: t.ClassVar[set[DType]] = {

sqlglot/serde.py

@@ -50,7 +50,7 @@ def dump(expression: exp.Expr) -> list[dict[str, t.Any]]:
 
             payload[CLASS] = klass
 
-            if node.type:
+            if node.type and node.type is not node:
                 payload[TYPE] = dump(node.type)
             if node.comments:
                 payload[COMMENTS] = node.comments

sqlglot/typing/__init__.py

@@ -332,7 +332,7 @@
             e, exp.DType.BIGINT if e.args.get("big_int") else exp.DType.INT
         )
     },
-    exp.DataType: {"annotator": lambda self, e: self._set_type(e, e.copy())},
+    exp.DataType: {"annotator": lambda _, e: e},
     exp.Div: {"annotator": lambda self, e: self._annotate_div(e)},
     exp.Distinct: {"annotator": lambda self, e: self._annotate_by_args(e, "expressions")},
     exp.Dot: {"annotator": lambda self, e: self._annotate_dot(e)},