4 files changed, 77 insertions, 58 deletions
diff --git a/lib/sqlalchemy/sql/_py_util.py b/lib/sqlalchemy/sql/_py_util.py
new file mode 100644
index 000000000..ceb637609
--- /dev/null
+++ b/lib/sqlalchemy/sql/_py_util.py
@@ -0,0 +1,59 @@
+# sql/_py_util.py
+# Copyright (C) 2005-2021 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+
+
+class prefix_anon_map(dict):
+    """A map that creates new keys for missing key access.
+
+    Considers keys of the form "<ident> <name>" to produce
+    new symbols "<name>_<index>", where "index" is an incrementing integer
+    corresponding to <name>.
+
+    Inlines the approach taken by :class:`sqlalchemy.util.PopulateDict` which
+    is otherwise usually used for this type of operation.
+
+    """
+
+    def __missing__(self, key):
+        (ident, derived) = key.split(" ", 1)
+        anonymous_counter = self.get(derived, 1)
+        self[derived] = anonymous_counter + 1
+        value = f"{derived}_{anonymous_counter}"
+        self[key] = value
+        return value
+
+
+class cache_anon_map(dict):
+    """A map that creates new keys for missing key access.
+
+    Produces an incrementing sequence given a series of unique keys.
+
+    This is similar to the compiler prefix_anon_map class although simpler.
+
+    Inlines the approach taken by :class:`sqlalchemy.util.PopulateDict` which
+    is otherwise usually used for this type of operation.
+
+    """
+
+    _index = 0
+
+    def get_anon(self, object_):
+
+        idself = id(object_)
+        if idself in self:
+            return self[idself], True
+        else:
+            # inline of __missing__
+            self[idself] = id_ = str(self._index)
+            self._index += 1
+
+            return id_, False
+
+    def __missing__(self, key):
+        self[key] = val = str(self._index)
+        self._index += 1
+        return val
diff --git a/lib/sqlalchemy/sql/base.py b/lib/sqlalchemy/sql/base.py
index 4165751ca..b5a20830d 100644
--- a/lib/sqlalchemy/sql/base.py
+++ b/lib/sqlalchemy/sql/base.py
@@ -30,6 +30,12 @@ from .. import util
 from ..util import HasMemoized
 from ..util import hybridmethod
 
+try:
+    from sqlalchemy.cyextension.util import prefix_anon_map  # noqa
+except ImportError:
+    from ._py_util import prefix_anon_map  # noqa
+
+
 coercions = None
 elements = None
 type_api = None
@@ -1012,27 +1018,6 @@ class Executable(roles.StatementRole, Generative):
         return self._execution_options
 
 
-class prefix_anon_map(dict):
-    """A map that creates new keys for missing key access.
-
-    Considers keys of the form "<ident> <name>" to produce
-    new symbols "<name>_<index>", where "index" is an incrementing integer
-    corresponding to <name>.
-
-    Inlines the approach taken by :class:`sqlalchemy.util.PopulateDict` which
-    is otherwise usually used for this type of operation.
-
-    """
-
-    def __missing__(self, key):
-        (ident, derived) = key.split(" ", 1)
-        anonymous_counter = self.get(derived, 1)
-        self[derived] = anonymous_counter + 1
-        value = derived + "_" + str(anonymous_counter)
-        self[key] = value
-        return value
-
-
 class SchemaEventTarget:
     """Base class for elements that are the targets of :class:`.DDLEvents`
     events.
diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py
index 00270c9b5..08c993820 100644
--- a/lib/sqlalchemy/sql/elements.py
+++ b/lib/sqlalchemy/sql/elements.py
@@ -1659,14 +1659,9 @@ class BindParameter(roles.InElementRole, ColumnElement):
                 anon_map[NO_CACHE] = True
             return None
 
-        idself = id(self)
-        if idself in anon_map:
-            return (anon_map[idself], self.__class__)
-        else:
-            # inline of
-            # id_ = anon_map[idself]
-            anon_map[idself] = id_ = str(anon_map.index)
-            anon_map.index += 1
+        id_, found = anon_map.get_anon(self)
+        if found:
+            return (id_, self.__class__)
 
         if bindparams is not None:
             bindparams.append(self)
diff --git a/lib/sqlalchemy/sql/traversals.py b/lib/sqlalchemy/sql/traversals.py
index d58b5c2bb..22398e7c1 100644
--- a/lib/sqlalchemy/sql/traversals.py
+++ b/lib/sqlalchemy/sql/traversals.py
@@ -12,6 +12,12 @@ from .. import util
 from ..inspection import inspect
 from ..util import HasMemoized
 
+try:
+    from sqlalchemy.cyextension.util import cache_anon_map as anon_map  # noqa
+except ImportError:
+    from ._py_util import cache_anon_map as anon_map  # noqa
+
+
 SKIP_TRAVERSE = util.symbol("skip_traverse")
 COMPARE_FAILED = False
 COMPARE_SUCCEEDED = True
@@ -177,16 +183,11 @@ class HasCacheKey:
 
         """
 
-        idself = id(self)
         cls = self.__class__
 
-        if idself in anon_map:
-            return (anon_map[idself], cls)
-        else:
-            # inline of
-            # id_ = anon_map[idself]
-            anon_map[idself] = id_ = str(anon_map.index)
-            anon_map.index += 1
+        id_, found = anon_map.get_anon(self)
+        if found:
+            return (id_, cls)
 
         try:
             dispatcher = cls.__dict__["_generated_cache_key_traversal"]
@@ -1030,27 +1031,6 @@ def _resolve_name_for_compare(element, name, anon_map, **kw):
     return name
 
 
-class anon_map(dict):
-    """A map that creates new keys for missing key access.
-
-    Produces an incrementing sequence given a series of unique keys.
-
-    This is similar to the compiler prefix_anon_map class although simpler.
-
-    Inlines the approach taken by :class:`sqlalchemy.util.PopulateDict` which
-    is otherwise usually used for this type of operation.
-
-    """
-
-    def __init__(self):
-        self.index = 0
-
-    def __missing__(self, key):
-        self[key] = val = str(self.index)
-        self.index += 1
-        return val
-
-
 class TraversalComparatorStrategy(InternalTraversal, util.MemoizedSlots):
     __slots__ = "stack", "cache", "anon_map"