SQLAlchemy 2.0.51__py3-none-any.whl → 2.0.52__py3-none-any.whl

sqlalchemy/__init__.py

@@ -269,7 +269,7 @@ from .types import Uuid as Uuid
 from .types import VARBINARY as VARBINARY
 from .types import VARCHAR as VARCHAR
 
-__version__ = "2.0.51"
+__version__ = "2.0.52"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/connectors/pyodbc.py

@@ -77,10 +77,16 @@ class PyODBCConnector(Connector):
         else:
 
             def check_quote(token: str) -> str:
-                if ";" in str(token) or str(token).startswith("{"):
+                if (
+                    ";" in str(token)
+                    or "}" in str(token)
+                    or str(token).startswith("{")
+                ):
                     token = "{%s}" % token.replace("}", "}}")
                 return token
 
+            driver = keys.pop("driver", self.pyodbc_driver_name)
+
             keys = {k: check_quote(v) for k, v in keys.items()}
 
             dsn_connection = "dsn" in keys or (
@@ -96,7 +102,6 @@ class PyODBCConnector(Connector):
                     port = ",%d" % int(keys.pop("port"))
 
                 connectors = []
-                driver = keys.pop("driver", self.pyodbc_driver_name)
                 if driver is None and keys:
                     # note if keys is empty, this is a totally blank URL
                     util.warn(
@@ -105,7 +110,9 @@ class PyODBCConnector(Connector):
                         "DSN-less connections"
                     )
                 else:
-                    connectors.append("DRIVER={%s}" % driver)
+                    connectors.append(
+                        "DRIVER={%s}" % str(driver).replace("}", "}}")
+                    )
 
                 connectors.extend(
                     [
@@ -136,7 +143,9 @@ class PyODBCConnector(Connector):
                     "AutoTranslate=%s" % keys.pop("odbc_autotranslate")
                 )
 
-            connectors.extend(["%s=%s" % (k, v) for k, v in keys.items()])
+            connectors.extend(
+                ["%s=%s" % (check_quote(k), v) for k, v in keys.items()]
+            )
 
         return ((";".join(connectors),), connect_args)
 

sqlalchemy/dialects/mssql/base.py

@@ -1585,7 +1585,7 @@ class MSUUid(sqltypes.Uuid):
         if self.native_uuid:
 
             def process(value):
-                return f"""'{str(value).replace("''", "'")}'"""
+                return f"""'{str(value).replace("'", "''")}'"""
 
             return process
         else:

sqlalchemy/dialects/postgresql/base.py

@@ -1213,6 +1213,33 @@ identifier::
         ),
     )
 
+SQLAlchemy does not automatically copy the columns from the inherited tables
+mentioned in the ``postgresql_inherits`` argument into the new
+:class:`_schema.Table`. To populate the new table columns reflection may be
+used, or a function similar to the following one::
+
+    def get_parent_columns(tbl: sa.Table) -> list[sa.Column]:
+        return [
+            sa.Column(
+                c.name,
+                c.type,
+                key=c.key,
+                nullable=c.nullable,
+                # Set system=true to omit from the CREATE TABLE statement
+                system=True,
+            )
+            for c in tbl.columns
+        ]
+
+
+    documents = Table(
+        "some_table",
+        metadata,
+        *get_parent_columns(some_supertable),
+        # ... # add other columns here normally if needed
+        postgresql_inherits="some_supertable",
+    )
+
 ``ON COMMIT``
 ^^^^^^^^^^^^^
 
@@ -2135,7 +2162,9 @@ class PGCompiler(compiler.SQLCompiler):
         return "string_agg%s" % self.function_argspec(fn)
 
     def visit_sequence(self, seq, **kw):
-        return "nextval('%s')" % self.preparer.format_sequence(seq)
+        return "nextval(%s)" % self.preparer._format_sequence_string_literal(
+            seq
+        )
 
     def limit_clause(self, select, **kw):
         text = ""
@@ -2968,9 +2997,43 @@ class PGTypeCompiler(compiler.GenericTypeCompiler):
         return "JSONPATH"
 
 
+class _CompilerSequence:
+    """Minimal stand-in for :class:`.Sequence`.
+
+    Used for the implicit sequence behind a SERIAL column, where no
+    :class:`.Sequence` object exists but a name still has to be rendered
+    through :meth:`.IdentifierPreparer.format_sequence`.
+
+    """
+
+    __slots__ = ("name", "schema")
+
+    # the schema handed to us has already been resolved against the
+    # schema translate map, so don't let format_sequence() translate it
+    # a second time
+    _use_schema_map = False
+
+    def __init__(self, name, schema=None):
+        self.name = name
+        self.schema = schema
+
+
 class PGIdentifierPreparer(compiler.IdentifierPreparer):
     reserved_words = RESERVED_WORDS
 
+    def _format_sequence_string_literal(self, sequence):
+        """Render a sequence name as a SQL string literal.
+
+        ``nextval()`` and friends take the sequence as a string rather than
+        as an identifier, so the quoted identifier produced by
+        :meth:`.format_sequence` has to be escaped a second time for the
+        enclosing literal.
+
+        """
+        return "'%s'" % self.format_sequence(
+            sequence, use_schema=True
+        ).replace("'", "''")
+
     def _unquote_identifier(self, value):
         if value[0] == self.initial_quote:
             value = value[1:-1].replace(
@@ -3156,8 +3219,8 @@ class PGExecutionContext(default.DefaultExecutionContext):
     def fire_sequence(self, seq, type_):
         return self._execute_scalar(
             (
-                "select nextval('%s')"
-                % self.identifier_preparer.format_sequence(seq)
+                "select nextval(%s)"
+                % self.identifier_preparer._format_sequence_string_literal(seq)
             ),
             type_,
         )
@@ -3194,13 +3257,12 @@ class PGExecutionContext(default.DefaultExecutionContext):
                 else:
                     effective_schema = None
 
-                if effective_schema is not None:
-                    exc = 'select nextval(\'"%s"."%s"\')' % (
-                        effective_schema,
-                        seq_name,
+                exc = (
+                    "select nextval(%s)"
+                    % self.identifier_preparer._format_sequence_string_literal(
+                        _CompilerSequence(seq_name, effective_schema)
                     )
-                else:
-                    exc = "select nextval('\"%s\"')" % (seq_name,)
+                )
 
                 return self._execute_scalar(exc, column.type)
 
@@ -5229,9 +5291,7 @@ class PGDialect(default.DefaultDialect):
                 util.warn("Could not parse CHECK constraint text: %r" % src)
                 sqltext = ""
             else:
-                sqltext = re.compile(
-                    r"^[\s\n]*\((.+)\)[\s\n]*$", flags=re.DOTALL
-                ).sub(r"\1", m.group(1))
+                sqltext = util.strip_outer_parens(m.group(1))
             entry = {
                 "name": check_name,
                 "sqltext": sqltext,

sqlalchemy/dialects/postgresql/json.py

@@ -49,6 +49,9 @@ class JSONPathType(sqltypes.JSON.JSONPathType):
             if isinstance(value, str):
                 # If it's already a string assume that it's in json path
                 # format. This allows using cast with json paths literals
+                # Still need to process through super_proc for proper escaping
+                if super_proc:
+                    value = super_proc(value)
                 return value
             elif value:
                 # If it's already a string assume that it's in json path

sqlalchemy/dialects/sqlite/aiosqlite.py

@@ -76,6 +76,36 @@ based on the kind of SQLite database that's requested:
     may be used by specifying it via the
     :paramref:`_sa.create_engine.poolclass` parameter.
 
+.. _aiosqlite_memory:
+
+Using a Memory Database with Multiple Coroutines
+-------------------------------------------------
+
+The default :class:`.StaticPool` used for ``:memory:`` databases forces all
+coroutines to share a single DBAPI connection.  Because SQLite maintains only
+one transaction state per connection, concurrent coroutines can interfere
+with each other — a ``ROLLBACK`` in one coroutine will also discard
+uncommitted work from any other coroutine using the same engine.
+
+For async workloads where multiple :class:`.AsyncSession` or
+:class:`.AsyncConnection` objects may be active simultaneously, use SQLite's
+shared-cache URI mode instead.  This gives each checkout its own DBAPI
+connection with independent transaction state while still sharing one
+in-memory database::
+
+    engine = create_async_engine(
+        "sqlite+aiosqlite:///file::memory:?cache=shared&uri=true"
+    )
+
+Because this URL form is treated as a file-based database by the dialect,
+:class:`.AsyncAdaptedQueuePool` is used automatically and no additional
+configuration is needed.
+
+See the pysqlite documentation at
+:ref:`pysqlite_uri_shared_cache` for full details on shared-cache memory
+databases, including how to use named databases to maintain multiple
+independent in-memory databases within the same process.
+
 """  # noqa
 
 from __future__ import annotations

sqlalchemy/dialects/sqlite/base.py

@@ -1128,7 +1128,7 @@ class DATETIME(_DateTimeMixin, sqltypes.DateTime):
             storage_format=(
                 "%(year)04d/%(month)02d/%(day)02d %(hour)02d:%(minute)02d:%(second)02d"
             ),
-            regexp=r"(\d+)/(\d+)/(\d+) (\d+)-(\d+)-(\d+)",
+            regexp=r"(\d+)/(\d+)/(\d+) (\d+):(\d+):(\d+)",
         )
 
     :param truncate_microseconds: when ``True`` microseconds will be truncated
@@ -2774,7 +2774,7 @@ class SQLiteDialect(default.DefaultDialect):
             )
             INLINE_UNIQUE_PATTERN = (
                 r'(?:(".+?")|(?:[\[`])?([a-z0-9_]+)(?:[\]`])?)[\t ]'
-                r"+[a-z0-9_ ]+?[\t ]+UNIQUE"
+                r"+[a-z0-9_]+(?:[\t ]+[a-z0-9_]+)*?[\t ]+UNIQUE"
             )
 
             for match in re.finditer(UNIQUE_PATTERN, table_data, re.I):
@@ -2865,32 +2865,14 @@ class SQLiteDialect(default.DefaultDialect):
                     flags=re.DOTALL,
                 )
 
-            # Find the matching closing parenthesis by counting balanced parens
-            # Must track string context to ignore parens inside string literals
-            start = match.end()  # Position after 'CHECK ('
-            paren_count = 1
-            in_single_quote = False
-            in_double_quote = False
-
-            for pos, char in enumerate(table_data[start:], start):
-                # Track string literal context
-                if char == "'" and not in_double_quote:
-                    in_single_quote = not in_single_quote
-                elif char == '"' and not in_single_quote:
-                    in_double_quote = not in_double_quote
-                # Only count parens when not inside a string literal
-                elif not in_single_quote and not in_double_quote:
-                    if char == "(":
-                        paren_count += 1
-                    elif char == ")":
-                        paren_count -= 1
-                        if paren_count == 0:
-                            # Successfully found matching closing parenthesis
-                            sqltext = table_data[start:pos].strip()
-                            cks.append(
-                                {"sqltext": sqltext, "name": constraint_name}
-                            )
-                            break
+            # Find the matching closing parenthesis with quote-aware paren
+            # counting. ``match.end() - 1`` is the position of the ``(``
+            # that opened the CHECK clause; ``match.end()`` is the first
+            # character of the constraint body.
+            close = util.find_matching_paren(table_data, match.end() - 1)
+            if close is not None:
+                sqltext = table_data[match.end() : close].strip()
+                cks.append({"sqltext": sqltext, "name": constraint_name})
 
         cks.sort(key=lambda d: d["name"] or "~")  # sort None as last
         if cks:

sqlalchemy/dialects/sqlite/pysqlite.py

@@ -209,8 +209,8 @@ processing.
 
 .. _pysqlite_threading_pooling:
 
-Threading/Pooling Behavior
----------------------------
+Concurrency/Threading/Pooling Behavior
+--------------------------------------
 
 The ``sqlite3`` DBAPI by default prohibits the use of a particular connection
 in a thread which is not the one in which it was created.  As SQLite has
@@ -261,15 +261,82 @@ connection reuse implemented by :class:`.QueuePool`.  However, it still
 may be beneficial to use this class if the application is experiencing
 issues with files being locked.
 
-Using a Memory Database in Multiple Threads
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Using a Memory Database in Multiple Threads or Coroutines
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A ``:memory:`` SQLite database exists only within the scope of a single
+DBAPI connection.  It is not possible for two separate ``sqlite3``
+connection objects to access the same ``:memory:`` database unless SQLite's
+shared-cache feature is enabled.  Without shared cache, each connection
+creates its own independent in-memory database.
+
+This means a ``:memory:`` database is **not suitable** for use with
+multiple concurrent threads or coroutines unless either:
+
+* All workers are fully serialized (mutexed) against each other
+  such that only one is using the database at a time, or
+* SQLite's shared-cache URI feature is used to allow multiple
+  independent connections to access the same in-memory database.
+
+The same considerations apply when using the :ref:`aiosqlite <aiosqlite>`
+dialect, which wraps ``pysqlite`` connections in an async interface —
+without shared cache, each connection still creates its own independent
+in-memory database.
+
+The recommended approach for multithreaded or async in-memory
+use is the shared-cache URI feature, described below.
+
+.. _pysqlite_uri_shared_cache:
+
+Using a Shared-Cache Memory Database
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SQLite's
+`URI shared-cache <https://www.sqlite.org/sharedcache.html>`_
+mode allows multiple independent DBAPI connections, each with
+their own transaction state, to access the same in-memory
+database.  This is enabled by using a ``file:`` URI with
+``cache=shared`` and passing ``uri=true`` in the query
+string::
+
+    engine = create_engine("sqlite:///file::memory:?cache=shared&uri=true")
+
+For async use with aiosqlite, use
+:func:`_asyncio.create_async_engine`::
+
+    engine = create_async_engine(
+        "sqlite+aiosqlite:///file::memory:?cache=shared&uri=true"
+    )
+
+Because this URL form is treated as a file-based database by the
+dialect, :class:`.QueuePool` is used automatically and
+``check_same_thread`` defaults to ``False``, so no additional pool
+or connect_args configuration is needed.  Each checkout from the
+pool is a distinct DBAPI connection with its own transaction state,
+and the in-memory database persists as long as at least one
+connection remains open.
+
+The shared-cache database is scoped by the filename component of
+the URI.  ``file::memory:`` (empty name) is process-global — all
+engines in the process that use this URI share the same database.
+To maintain multiple independent in-memory databases within the
+same process, supply a distinct name for each::
+
+    engine_a = create_engine(
+        "sqlite:///file:db_a?mode=memory&cache=shared&uri=true"
+    )
+    engine_b = create_engine(
+        "sqlite:///file:db_b?mode=memory&cache=shared&uri=true"
+    )
+
+Using StaticPool for Single-Connection Memory Databases
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-To use a ``:memory:`` database in a multithreaded scenario, the same
-connection object must be shared among threads, since the database exists
-only within the scope of that connection.   The
-:class:`.StaticPool` implementation will maintain a single connection
-globally, and the ``check_same_thread`` flag can be passed to Pysqlite
-as ``False``::
+An older approach for sharing a ``:memory:`` database among threads
+is to force all checkouts to return the same DBAPI connection using
+:class:`.StaticPool`.  **This approach does not support any form of
+concurrency** and is only useful when all access to the engine is
+fully serialized, such as in single-threaded test suites::
 
     from sqlalchemy.pool import StaticPool
 
@@ -279,8 +346,18 @@ as ``False``::
         poolclass=StaticPool,
     )
 
-Note that using a ``:memory:`` database in multiple threads requires a recent
-version of SQLite.
+.. warning::
+
+    Because :class:`.StaticPool` maintains a single DBAPI connection,
+    all :class:`.Session` or :class:`.Connection` objects that use
+    this engine share that one underlying connection and its single
+    SQLite transaction state.  A ``ROLLBACK`` issued by one session
+    (e.g. during error handling) will also roll back uncommitted work
+    from any other session, and concurrent ``COMMIT`` / ``ROLLBACK``
+    calls can interfere with each other unpredictably.  This approach
+    is only appropriate when access to the engine is fully serialized,
+    such as in single-threaded test suites.  For concurrent workloads,
+    use the shared-cache URI approach described above.
 
 Using Temporary Tables with SQLite
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

sqlalchemy/orm/bulk_persistence.py

@@ -785,6 +785,22 @@ class BulkUDCompileState(ORMDMLState):
                 }
             )
 
+            # disable result-level adapt_to_context.  ORM UPDATE/DELETE with
+            # RETURNING uses a "two level" statement: the invoked ORM statement
+            # holds the user's returning() columns while the cached Core
+            # statement returns primary key + supplemental columns, so the two
+            # are not positionally aligned.  adapt_to_context() would remap
+            # result keys positionally between them and mislabel columns on a
+            # cache hit; the ORM instead interprets rows via its own
+            # from_statement context, so the Core adaptation would interfere
+            # here.
+            if not execution_options:
+                execution_options = context._orm_load_exec_options
+            else:
+                execution_options = execution_options.union(
+                    context._orm_load_exec_options
+                )
+
         return (
             statement,
             util.immutabledict(execution_options).union(

sqlalchemy/orm/decl_base.py

@@ -1240,6 +1240,20 @@ class _ClassScanMapperConfig(_MapperConfig):
                 "documentation for additional information.",
                 code="dcte",
             ) from ex
+        else:
+            # as of Python 3.15, dataclasses no longer renders the
+            # auto-generated class docstring immediately; it instead installs
+            # a descriptor that renders the ``__init__`` signature the first
+            # time ``__doc__`` is accessed (see
+            # ``dataclasses._AutoDocstring``).  As the ``finally:`` block
+            # below puts the class' original annotations back, that deferred
+            # render would no longer see the dataclass-oriented annotations
+            # applied above, and would omit them from the docstring entirely.
+            # Read the attribute now, while those annotations are still in
+            # place, so the docstring we generate is the same on every Python
+            # version.
+            klass.__doc__
+
         finally:
             # restore original annotations outside of the dataclasses
             # process; for mixins and __abstract__ superclasses, SQLAlchemy

sqlalchemy/orm/path_registry.py

@@ -17,6 +17,7 @@ from typing import cast
 from typing import Dict
 from typing import Iterator
 from typing import List
+from typing import Mapping
 from typing import Optional
 from typing import overload
 from typing import Sequence
@@ -30,6 +31,8 @@ from .. import exc
 from .. import util
 from ..sql import visitors
 from ..sql.cache_key import HasCacheKey
+from ..util.typing import Final
+from ..util.typing import Literal
 
 if TYPE_CHECKING:
     from ._typing import _InternalEntityType
@@ -82,6 +85,40 @@ def _unreduce_path(path: _SerializedPath) -> PathRegistry:
 _WILDCARD_TOKEN: _LiteralStar = "*"
 _DEFAULT_TOKEN = "_sa_default"
 
+_RELATIONSHIP_TOKEN: Final[Literal["relationship"]] = "relationship"
+_COLUMN_TOKEN: Final[Literal["column"]] = "column"
+
+_UNPREFIXED_TOKENS = frozenset([_WILDCARD_TOKEN, _DEFAULT_TOKEN])
+"""the wildcard strings accepted from the user in a loader option.
+
+these are prefixed with the target property's ``strategy_wildcard_key`` to
+form the tokens in :data:`._PATH_TOKENS`, and are not themselves valid as an
+element of a path.
+
+"""
+
+_PATH_TOKENS = frozenset(
+    f"{wildcard_key}:{suffix}"
+    for wildcard_key in (_RELATIONSHIP_TOKEN, _COLUMN_TOKEN)
+    for suffix in (_WILDCARD_TOKEN, _DEFAULT_TOKEN)
+)
+"""the complete set of tokens which may appear within a path.
+
+:attr:`.PathToken._intern` is populated from this collection at module import
+time, so that a token is present in every process, including one which has
+not yet run any query.
+
+"""
+
+_ACCEPTED_TOKENS = _UNPREFIXED_TOKENS | _PATH_TOKENS
+"""every string a loader option may accept in place of an attribute name.
+
+this is the union of the bare wildcards the user writes and the prefixed
+tokens which the loader option internals hand back to themselves; only the
+latter may appear in a path.
+
+"""
+
 
 class PathRegistry(HasCacheKey):
     """Represent query load paths and registry functions.
@@ -356,12 +393,12 @@ class CreatesToken(PathRegistry):
     is_root: bool
 
     def token(self, token: _StrPathToken) -> TokenRegistry:
-        if token.endswith(f":{_WILDCARD_TOKEN}"):
+        if token not in PathToken._intern:
+            raise exc.ArgumentError(f"invalid token: {token}")
+        elif token.endswith(f":{_WILDCARD_TOKEN}"):
             return TokenRegistry(self, token)
-        elif token.endswith(f":{_DEFAULT_TOKEN}"):
-            return TokenRegistry(self.root, token)
         else:
-            raise exc.ArgumentError(f"invalid token: {token}")
+            return TokenRegistry(self.root, token)
 
 
 class RootRegistry(CreatesToken):
@@ -408,7 +445,17 @@ PathRegistry.root = RootRegistry()
 class PathToken(orm_base.InspectionAttr, HasCacheKey, str):
     """cacheable string token"""
 
-    _intern: Dict[str, PathToken] = {}
+    _intern: Mapping[str, PathToken]
+    """the :class:`.PathToken` for each of :data:`._PATH_TOKENS`.
+
+    this collection is fully populated below at module import time and is
+    never added to afterwards; it's typed as :class:`.Mapping` so that a
+    mutation is flagged by type checkers.
+    :meth:`.PathRegistry._deserialize_path` relies on it being complete,
+    distinguishing a token from a mapped attribute key by testing
+    membership here.
+
+    """
 
     def _gen_cache_key(
         self, anon_map: anon_map, bindparams: List[BindParameter[Any]]
@@ -419,13 +466,8 @@ class PathToken(orm_base.InspectionAttr, HasCacheKey, str):
     def _path_for_compare(self) -> Optional[_PathRepresentation]:
         return None
 
-    @classmethod
-    def intern(cls, strvalue: str) -> PathToken:
-        if strvalue in cls._intern:
-            return cls._intern[strvalue]
-        else:
-            cls._intern[strvalue] = result = PathToken(strvalue)
-            return result
+
+PathToken._intern = {token: PathToken(token) for token in _PATH_TOKENS}
 
 
 class TokenRegistry(PathRegistry):
@@ -437,7 +479,7 @@ class TokenRegistry(PathRegistry):
     parent: CreatesToken
 
     def __init__(self, parent: CreatesToken, token: _StrPathToken):
-        token = PathToken.intern(token)
+        token = PathToken._intern[token]
 
         self.token = token
         self.parent = parent

sqlalchemy/orm/properties.py

@@ -29,7 +29,6 @@ from typing import Union
 
 from . import attributes
 from . import exc as orm_exc
-from . import strategy_options
 from .base import _DeclarativeMapped
 from .base import class_mapper
 from .descriptor_props import CompositeProperty
@@ -42,6 +41,7 @@ from .interfaces import _MapsColumns
 from .interfaces import MapperProperty
 from .interfaces import PropComparator
 from .interfaces import StrategizedProperty
+from .path_registry import _COLUMN_TOKEN
 from .relationships import RelationshipProperty
 from .util import de_stringify_annotation
 from .. import exc as sa_exc
@@ -108,7 +108,7 @@ class ColumnProperty(
 
     """
 
-    strategy_wildcard_key = strategy_options._COLUMN_TOKEN
+    strategy_wildcard_key = _COLUMN_TOKEN
     inherit_cache = True
     """:meta private:"""
 

sqlalchemy/orm/relationships.py

@@ -45,7 +45,6 @@ from typing import Union
 import weakref
 
 from . import attributes
-from . import strategy_options
 from ._typing import insp_is_aliased_class
 from ._typing import is_has_collection_adapter
 from .base import _DeclarativeMapped
@@ -64,6 +63,7 @@ from .interfaces import ONETOMANY
 from .interfaces import PropComparator
 from .interfaces import RelationshipDirection
 from .interfaces import StrategizedProperty
+from .path_registry import _RELATIONSHIP_TOKEN
 from .util import _orm_annotate
 from .util import _orm_deannotate
 from .util import CascadeOptions
@@ -322,7 +322,7 @@ class RelationshipProperty(
 
     """
 
-    strategy_wildcard_key = strategy_options._RELATIONSHIP_TOKEN
+    strategy_wildcard_key = _RELATIONSHIP_TOKEN
     inherit_cache = True
     """:meta private:"""