SQLAlchemy 2.0.43__py3-none-any.whl → 2.0.44__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.43"
+__version__ = "2.0.44"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/connectors/asyncio.py

@@ -19,11 +19,15 @@ from typing import Iterator
 from typing import NoReturn
 from typing import Optional
 from typing import Sequence
+from typing import Tuple
+from typing import Type
 from typing import TYPE_CHECKING
 
 from ..engine import AdaptedConnection
+from ..util import EMPTY_DICT
 from ..util.concurrency import await_fallback
 from ..util.concurrency import await_only
+from ..util.concurrency import in_greenlet
 from ..util.typing import Protocol
 
 if TYPE_CHECKING:
@@ -129,8 +133,11 @@ class AsyncAdapt_dbapi_cursor:
         "await_",
         "_cursor",
         "_rows",
+        "_soft_closed_memoized",
     )
 
+    _awaitable_cursor_close: bool = True
+
     _cursor: AsyncIODBAPICursor
     _adapt_connection: AsyncAdapt_dbapi_connection
     _connection: AsyncIODBAPIConnection
@@ -144,7 +151,7 @@ class AsyncAdapt_dbapi_cursor:
 
         cursor = self._make_new_cursor(self._connection)
         self._cursor = self._aenter_cursor(cursor)
-
+        self._soft_closed_memoized = EMPTY_DICT
         if not self.server_side:
             self._rows = collections.deque()
 
@@ -158,6 +165,8 @@ class AsyncAdapt_dbapi_cursor:
 
     @property
     def description(self) -> Optional[_DBAPICursorDescription]:
+        if "description" in self._soft_closed_memoized:
+            return self._soft_closed_memoized["description"]  # type: ignore[no-any-return]  # noqa: E501
         return self._cursor.description
 
     @property
@@ -176,11 +185,40 @@ class AsyncAdapt_dbapi_cursor:
     def lastrowid(self) -> int:
         return self._cursor.lastrowid
 
+    async def _async_soft_close(self) -> None:
+        """close the cursor but keep the results pending, and memoize the
+        description.
+
+        .. versionadded:: 2.0.44
+
+        """
+
+        if not self._awaitable_cursor_close or self.server_side:
+            return
+
+        self._soft_closed_memoized = self._soft_closed_memoized.union(
+            {
+                "description": self._cursor.description,
+            }
+        )
+        await self._cursor.close()
+
     def close(self) -> None:
-        # note we aren't actually closing the cursor here,
-        # we are just letting GC do it.  see notes in aiomysql dialect
         self._rows.clear()
 
+        # updated as of 2.0.44
+        # try to "close" the cursor based on what we know about the driver
+        # and if we are able to.  otherwise, hope that the asyncio
+        # extension called _async_soft_close() if the cursor is going into
+        # a sync context
+        if self._cursor is None or bool(self._soft_closed_memoized):
+            return
+
+        if not self._awaitable_cursor_close:
+            self._cursor.close()  # type: ignore[unused-coroutine]
+        elif in_greenlet():
+            self.await_(self._cursor.close())
+
     def execute(
         self,
         operation: Any,
@@ -349,3 +387,43 @@ class AsyncAdaptFallback_dbapi_connection(AsyncAdapt_dbapi_connection):
     __slots__ = ()
 
     await_ = staticmethod(await_fallback)
+
+
+class AsyncAdapt_terminate:
+    """Mixin for a AsyncAdapt_dbapi_connection to add terminate support."""
+
+    __slots__ = ()
+
+    def terminate(self) -> None:
+        if in_greenlet():
+            # in a greenlet; this is the connection was invalidated case.
+            try:
+                # try to gracefully close; see #10717
+                self.await_(asyncio.shield(self._terminate_graceful_close()))  # type: ignore[attr-defined] # noqa: E501
+            except self._terminate_handled_exceptions() as e:
+                # in the case where we are recycling an old connection
+                # that may have already been disconnected, close() will
+                # fail.  In this case, terminate
+                # the connection without any further waiting.
+                # see issue #8419
+                self._terminate_force_close()
+                if isinstance(e, asyncio.CancelledError):
+                    # re-raise CancelledError if we were cancelled
+                    raise
+        else:
+            # not in a greenlet; this is the gc cleanup case
+            self._terminate_force_close()
+
+    def _terminate_handled_exceptions(self) -> Tuple[Type[BaseException], ...]:
+        """Returns the exceptions that should be handled when
+        calling _graceful_close.
+        """
+        return (asyncio.TimeoutError, asyncio.CancelledError, OSError)
+
+    async def _terminate_graceful_close(self) -> None:
+        """Try to close connection gracefully"""
+        raise NotImplementedError
+
+    def _terminate_force_close(self) -> None:
+        """Terminate the connection"""
+        raise NotImplementedError

sqlalchemy/dialects/mssql/base.py

@@ -3503,6 +3503,9 @@ join sys.schemas as sch on
 where
     tab.name = :tabname
     and sch.name = :schname
+order by
+    ind_col.index_id,
+    ind_col.key_ordinal
             """
             )
             .bindparams(
@@ -3998,6 +4001,8 @@ index_info AS (
             index_info.index_schema = fk_info.unique_constraint_schema
             AND index_info.index_name = fk_info.unique_constraint_name
             AND index_info.ordinal_position = fk_info.ordinal_position
+            AND NOT (index_info.table_schema = fk_info.table_schema
+                     AND index_info.table_name = fk_info.table_name)
 
     ORDER BY fk_info.constraint_schema, fk_info.constraint_name,
         fk_info.ordinal_position

sqlalchemy/dialects/mysql/aiomysql.py

@@ -45,6 +45,7 @@ from ...connectors.asyncio import AsyncAdapt_dbapi_connection
 from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
 from ...connectors.asyncio import AsyncAdapt_dbapi_module
 from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
+from ...connectors.asyncio import AsyncAdapt_terminate
 from ...util.concurrency import await_fallback
 from ...util.concurrency import await_only
 
@@ -82,7 +83,9 @@ class AsyncAdapt_aiomysql_ss_cursor(
         )
 
 
-class AsyncAdapt_aiomysql_connection(AsyncAdapt_dbapi_connection):
+class AsyncAdapt_aiomysql_connection(
+    AsyncAdapt_terminate, AsyncAdapt_dbapi_connection
+):
     __slots__ = ()
 
     _cursor_cls = AsyncAdapt_aiomysql_cursor
@@ -101,13 +104,16 @@ class AsyncAdapt_aiomysql_connection(AsyncAdapt_dbapi_connection):
     def get_autocommit(self) -> bool:
         return self._connection.get_autocommit()  # type: ignore
 
-    def terminate(self) -> None:
-        # it's not awaitable.
-        self._connection.close()
-
     def close(self) -> None:
         self.await_(self._connection.ensure_closed())
 
+    async def _terminate_graceful_close(self) -> None:
+        await self._connection.ensure_closed()
+
+    def _terminate_force_close(self) -> None:
+        # it's not awaitable.
+        self._connection.close()
+
 
 class AsyncAdaptFallback_aiomysql_connection(AsyncAdapt_aiomysql_connection):
     __slots__ = ()

sqlalchemy/dialects/mysql/asyncmy.py

@@ -42,6 +42,7 @@ from ...connectors.asyncio import AsyncAdapt_dbapi_connection
 from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
 from ...connectors.asyncio import AsyncAdapt_dbapi_module
 from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
+from ...connectors.asyncio import AsyncAdapt_terminate
 from ...util.concurrency import await_fallback
 from ...util.concurrency import await_only
 
@@ -73,7 +74,9 @@ class AsyncAdapt_asyncmy_ss_cursor(
         )
 
 
-class AsyncAdapt_asyncmy_connection(AsyncAdapt_dbapi_connection):
+class AsyncAdapt_asyncmy_connection(
+    AsyncAdapt_terminate, AsyncAdapt_dbapi_connection
+):
     __slots__ = ()
 
     _cursor_cls = AsyncAdapt_asyncmy_cursor
@@ -107,13 +110,16 @@ class AsyncAdapt_asyncmy_connection(AsyncAdapt_dbapi_connection):
     def get_autocommit(self) -> bool:
         return self._connection.get_autocommit()  # type: ignore
 
-    def terminate(self) -> None:
-        # it's not awaitable.
-        self._connection.close()
-
     def close(self) -> None:
         self.await_(self._connection.ensure_closed())
 
+    async def _terminate_graceful_close(self) -> None:
+        await self._connection.ensure_closed()
+
+    def _terminate_force_close(self) -> None:
+        # it's not awaitable.
+        self._connection.close()
+
 
 class AsyncAdaptFallback_asyncmy_connection(AsyncAdapt_asyncmy_connection):
     __slots__ = ()

sqlalchemy/dialects/oracle/oracledb.py

@@ -736,6 +736,8 @@ class OracleDialect_oracledb(_cx_oracle.OracleDialect_cx_oracle):
 
 class AsyncAdapt_oracledb_cursor(AsyncAdapt_dbapi_cursor):
     _cursor: AsyncCursor
+    _awaitable_cursor_close: bool = False
+
     __slots__ = ()
 
     @property
@@ -749,10 +751,6 @@ class AsyncAdapt_oracledb_cursor(AsyncAdapt_dbapi_cursor):
     def var(self, *args, **kwargs):
         return self._cursor.var(*args, **kwargs)
 
-    def close(self):
-        self._rows.clear()
-        self._cursor.close()
-
     def setinputsizes(self, *args: Any, **kwargs: Any) -> Any:
         return self._cursor.setinputsizes(*args, **kwargs)
 

sqlalchemy/dialects/postgresql/array.py

@@ -44,6 +44,7 @@ if TYPE_CHECKING:
 
 
 _T = TypeVar("_T", bound=typing_Any)
+_CT = TypeVar("_CT", bound=typing_Any)
 
 
 def Any(
@@ -357,7 +358,7 @@ class ARRAY(sqltypes.ARRAY[_T]):
         self.dimensions = dimensions
         self.zero_indexes = zero_indexes
 
-    class Comparator(sqltypes.ARRAY.Comparator[_T]):
+    class Comparator(sqltypes.ARRAY.Comparator[_CT]):
         """Define comparison operations for :class:`_types.ARRAY`.
 
         Note that these operations are in addition to those provided
@@ -464,7 +465,7 @@ class ARRAY(sqltypes.ARRAY[_T]):
             super_rp = process
             pattern = re.compile(r"^{(.*)}$")
 
-            def handle_raw_string(value: str) -> list[str]:
+            def handle_raw_string(value: str) -> Sequence[Optional[str]]:
                 inner = pattern.match(value).group(1)  # type: ignore[union-attr]  # noqa: E501
                 return _split_enum_values(inner)
 
@@ -485,10 +486,13 @@ class ARRAY(sqltypes.ARRAY[_T]):
         return process
 
 
-def _split_enum_values(array_string: str) -> list[str]:
+def _split_enum_values(array_string: str) -> Sequence[Optional[str]]:
     if '"' not in array_string:
         # no escape char is present so it can just split on the comma
-        return array_string.split(",") if array_string else []
+        return [
+            r if r != "NULL" else None
+            for r in (array_string.split(",") if array_string else [])
+        ]
 
     # handles quoted strings from:
     # r'abc,"quoted","also\\\\quoted", "quoted, comma", "esc \" quot", qpr'
@@ -505,5 +509,11 @@ def _split_enum_values(array_string: str) -> list[str]:
         elif in_quotes:
             result.append(tok.replace("_$ESC_QUOTE$_", '"'))
         else:
-            result.extend(re.findall(r"([^\s,]+),?", tok))
+            # interpret NULL (without quotes!) as None
+            result.extend(
+                [
+                    r if r != "NULL" else None
+                    for r in re.findall(r"([^\s,]+),?", tok)
+                ]
+            )
     return result

sqlalchemy/dialects/postgresql/asyncpg.py

@@ -205,6 +205,7 @@ from .types import CITEXT
 from ... import exc
 from ... import pool
 from ... import util
+from ...connectors.asyncio import AsyncAdapt_terminate
 from ...engine import AdaptedConnection
 from ...engine import processors
 from ...sql import sqltypes
@@ -490,6 +491,7 @@ class AsyncAdapt_asyncpg_cursor:
     )
 
     server_side = False
+    _awaitable_cursor_close: bool = False
 
     def __init__(self, adapt_connection):
         self._adapt_connection = adapt_connection
@@ -501,6 +503,9 @@ class AsyncAdapt_asyncpg_cursor:
         self.rowcount = -1
         self._invalidate_schema_cache_asof = 0
 
+    async def _async_soft_close(self) -> None:
+        return
+
     def close(self):
         self._rows.clear()
 
@@ -691,7 +696,7 @@ class AsyncAdapt_asyncpg_ss_cursor(AsyncAdapt_asyncpg_cursor):
         )
 
 
-class AsyncAdapt_asyncpg_connection(AdaptedConnection):
+class AsyncAdapt_asyncpg_connection(AsyncAdapt_terminate, AdaptedConnection):
     __slots__ = (
         "dbapi",
         "isolation_level",
@@ -897,32 +902,18 @@ class AsyncAdapt_asyncpg_connection(AdaptedConnection):
 
         self.await_(self._connection.close())
 
-    def terminate(self):
-        if util.concurrency.in_greenlet():
-            # in a greenlet; this is the connection was invalidated
-            # case.
-            try:
-                # try to gracefully close; see #10717
-                # timeout added in asyncpg 0.14.0 December 2017
-                self.await_(asyncio.shield(self._connection.close(timeout=2)))
-            except (
-                asyncio.TimeoutError,
-                asyncio.CancelledError,
-                OSError,
-                self.dbapi.asyncpg.PostgresError,
-            ) as e:
-                # in the case where we are recycling an old connection
-                # that may have already been disconnected, close() will
-                # fail with the above timeout.  in this case, terminate
-                # the connection without any further waiting.
-                # see issue #8419
-                self._connection.terminate()
-                if isinstance(e, asyncio.CancelledError):
-                    # re-raise CancelledError if we were cancelled
-                    raise
-        else:
-            # not in a greenlet; this is the gc cleanup case
-            self._connection.terminate()
+    def _terminate_handled_exceptions(self):
+        return super()._terminate_handled_exceptions() + (
+            self.dbapi.asyncpg.PostgresError,
+        )
+
+    async def _terminate_graceful_close(self) -> None:
+        # timeout added in asyncpg 0.14.0 December 2017
+        await self._connection.close(timeout=2)
+        self._started = False
+
+    def _terminate_force_close(self) -> None:
+        self._connection.terminate()
         self._started = False
 
     @staticmethod

sqlalchemy/dialects/postgresql/json.py

@@ -279,6 +279,34 @@ class JSONB(JSON):
 
         :class:`_types.JSON`
 
+    .. warning::
+
+        **For applications that have indexes against JSONB subscript
+        expressions**
+
+        SQLAlchemy 2.0.42 made a change in how the subscript operation for
+        :class:`.JSONB` is rendered, from ``-> 'element'`` to ``['element']``,
+        for PostgreSQL versions greater than 14. This change caused an
+        unintended side effect for indexes that were created against
+        expressions that use subscript notation, e.g.
+        ``Index("ix_entity_json_ab_text", data["a"]["b"].astext)``. If these
+        indexes were generated with the older syntax e.g. ``((entity.data ->
+        'a') ->> 'b')``, they will not be used by the PostgreSQL query planner
+        when a query is made using SQLAlchemy 2.0.42 or higher on PostgreSQL
+        versions 14 or higher. This occurs because the new text will resemble
+        ``(entity.data['a'] ->> 'b')`` which will fail to produce the exact
+        textual syntax match required by the PostgreSQL query planner.
+        Therefore, for users upgrading to SQLAlchemy 2.0.42 or higher, existing
+        indexes that were created against :class:`.JSONB` expressions that use
+        subscripting would need to be dropped and re-created in order for them
+        to work with the new query syntax, e.g. an expression like
+        ``((entity.data -> 'a') ->> 'b')`` would become ``(entity.data['a'] ->>
+        'b')``.
+
+        .. seealso::
+
+            :ticket:`12868` - discussion of this issue
+
     """
 
     __visit_name__ = "JSONB"

sqlalchemy/dialects/postgresql/psycopg.py

@@ -585,6 +585,9 @@ class AsyncAdapt_psycopg_cursor:
     def arraysize(self, value):
         self._cursor.arraysize = value
 
+    async def _async_soft_close(self) -> None:
+        return
+
     def close(self):
         self._rows.clear()
         # Normal cursor just call _close() in a non-sync way.

sqlalchemy/dialects/sqlite/aiosqlite.py

@@ -141,6 +141,9 @@ class AsyncAdapt_aiosqlite_cursor:
         self.description: Optional[_DBAPICursorDescription] = None
         self._rows: Deque[Any] = deque()
 
+    async def _async_soft_close(self) -> None:
+        return
+
     def close(self) -> None:
         self._rows.clear()
 

sqlalchemy/dialects/sqlite/base.py

@@ -992,7 +992,10 @@ from __future__ import annotations
 import datetime
 import numbers
 import re
+from typing import Any
+from typing import Callable
 from typing import Optional
+from typing import TYPE_CHECKING
 
 from .json import JSON
 from .json import JSONIndexType
@@ -1025,6 +1028,13 @@ from ...types import TEXT  # noqa
 from ...types import TIMESTAMP  # noqa
 from ...types import VARCHAR  # noqa
 
+if TYPE_CHECKING:
+    from ...engine.interfaces import DBAPIConnection
+    from ...engine.interfaces import Dialect
+    from ...engine.interfaces import IsolationLevel
+    from ...sql.type_api import _BindProcessorType
+    from ...sql.type_api import _ResultProcessorType
+
 
 class _SQliteJson(JSON):
     def result_processor(self, dialect, coltype):
@@ -1163,7 +1173,9 @@ class DATETIME(_DateTimeMixin, sqltypes.DateTime):
                 "%(hour)02d:%(minute)02d:%(second)02d"
             )
 
-    def bind_processor(self, dialect):
+    def bind_processor(
+        self, dialect: Dialect
+    ) -> Optional[_BindProcessorType[Any]]:
         datetime_datetime = datetime.datetime
         datetime_date = datetime.date
         format_ = self._storage_format
@@ -1199,7 +1211,9 @@ class DATETIME(_DateTimeMixin, sqltypes.DateTime):
 
         return process
 
-    def result_processor(self, dialect, coltype):
+    def result_processor(
+        self, dialect: Dialect, coltype: object
+    ) -> Optional[_ResultProcessorType[Any]]:
         if self._reg:
             return processors.str_to_datetime_processor_factory(
                 self._reg, datetime.datetime
@@ -1254,7 +1268,9 @@ class DATE(_DateTimeMixin, sqltypes.Date):
 
     _storage_format = "%(year)04d-%(month)02d-%(day)02d"
 
-    def bind_processor(self, dialect):
+    def bind_processor(
+        self, dialect: Dialect
+    ) -> Optional[_BindProcessorType[Any]]:
         datetime_date = datetime.date
         format_ = self._storage_format
 
@@ -1275,7 +1291,9 @@ class DATE(_DateTimeMixin, sqltypes.Date):
 
         return process
 
-    def result_processor(self, dialect, coltype):
+    def result_processor(
+        self, dialect: Dialect, coltype: object
+    ) -> Optional[_ResultProcessorType[Any]]:
         if self._reg:
             return processors.str_to_datetime_processor_factory(
                 self._reg, datetime.date
@@ -2125,13 +2143,13 @@ class SQLiteDialect(default.DefaultDialect):
     )
     def __init__(
         self,
-        native_datetime=False,
-        json_serializer=None,
-        json_deserializer=None,
-        _json_serializer=None,
-        _json_deserializer=None,
-        **kwargs,
-    ):
+        native_datetime: bool = False,
+        json_serializer: Optional[Callable[..., Any]] = None,
+        json_deserializer: Optional[Callable[..., Any]] = None,
+        _json_serializer: Optional[Callable[..., Any]] = None,
+        _json_deserializer: Optional[Callable[..., Any]] = None,
+        **kwargs: Any,
+    ) -> None:
         default.DefaultDialect.__init__(self, **kwargs)
 
         if _json_serializer:
@@ -2199,7 +2217,9 @@ class SQLiteDialect(default.DefaultDialect):
     def get_isolation_level_values(self, dbapi_connection):
         return list(self._isolation_lookup)
 
-    def set_isolation_level(self, dbapi_connection, level):
+    def set_isolation_level(
+        self, dbapi_connection: DBAPIConnection, level: IsolationLevel
+    ) -> None:
         isolation_level = self._isolation_lookup[level]
 
         cursor = dbapi_connection.cursor()
@@ -2387,7 +2407,10 @@ class SQLiteDialect(default.DefaultDialect):
                 )
                 # remove create table
                 match = re.match(
-                    r"create table .*?\((.*)\)$",
+                    (
+                        r"create table .*?\((.*)\)"
+                        r"(?:\s*,?\s*(?:WITHOUT\s+ROWID|STRICT))*$"
+                    ),
                     tablesql.strip(),
                     re.DOTALL | re.IGNORECASE,
                 )