2.0.44

Released: October 10, 2025

platform

• [platform] [bug] Unblocked automatic greenlet installation for Python 3.14 now that there are greenlet wheels on pypi for python 3.14.

orm

• [orm] [usecase] The way ORM Annotated Declarative interprets Python PEP 695 type aliases in Mapped[] annotations has been refined to expand the lookup scheme. A PEP 695 type can now be resolved based on either its direct presence in _orm.registry.type_annotation_map or its immediate resolved value, as long as a recursive lookup across multiple PEP 695 types is not required for it to resolve. This change reverses part of the restrictions introduced in 2.0.37 as part of #11955, which deprecated (and disallowed in 2.1) the ability to resolve any PEP 695 type that was not explicitly present in _orm.registry.type_annotation_map. Recursive lookups of PEP 695 types remains deprecated in 2.0 and disallowed in version 2.1, as do implicit lookups of NewType types without an entry in _orm.registry.type_annotation_map.

  Additionally, new support has been added for generic PEP 695 aliases that refer to PEP 593 Annotated constructs containing _orm.mapped_column() configurations. See the sections below for examples.

  References: #12829

• [orm] [bug] Fixed a caching issue where _orm.with_loader_criteria() would incorrectly reuse cached bound parameter values when used with _sql.CompoundSelect constructs such as _sql.union(). The issue was caused by the cache key for compound selects not including the execution options that are part of the _sql.Executable base class, which _orm.with_loader_criteria() uses to apply its criteria dynamically. The fix ensures that compound selects and other executable constructs properly include execution options in their cache key traversal.

  References: #12905

engine

• [engine] [bug] Implemented initial support for free-threaded Python by adding new tests and reworking the test harness to include Python 3.13t and Python 3.14t in test runs. Two concurrency issues have been identified and fixed: the first involves initialization of the .c collection on a FromClause, a continuation of #12302, where an optional mutex under free-threading is added; the second involves synchronization of the pool "first_connect" event, which first received thread synchronization in #2964, however under free-threading the creation of the mutex itself runs under the same free-threading mutex. Support for free-threaded wheels on Pypi is implemented as well within the 2.1 series only. Initial pull request and test suite courtesy Lysandros Nikolaou.

  References: #12881

sql

• [sql] [bug] Improved the implementation of UpdateBase.returning() to use more robust logic in setting up the .c collection of a derived statement such as a CTE. This fixes issues related to RETURNING clauses that feature expressions based on returned columns with or without qualifying labels.

  References: #12271

schema

• [schema] [bug] Fixed issue where _schema.MetaData.reflect() did not forward dialect-specific keyword arguments to the _engine.Inspector methods, causing options like oracle_resolve_synonyms to be ignored during reflection. The method now ensures that all extra kwargs passed to _schema.MetaData.reflect() are forwarded to _engine.Inspector.get_table_names() and related reflection methods. Pull request courtesy Lukáš Kožušník.

  References: #12884

typing

• [typing] [bug] Fixed typing bug where the Session.execute() method advertised that it would return a CursorResult if given an insert/update/delete statement. This is not the general case as several flavors of ORM insert/update do not actually yield a CursorResult which cannot be differentiated at the typing overload level, so the method now yields Result in all cases. For those cases where CursorResult is known to be returned and the .rowcount attribute is required, please use typing.cast().

  References: #12813

• [typing] [bug] Added new decorator _orm.mapped_as_dataclass(), which is a function based form of _orm.registry.mapped_as_dataclass(); the method form _orm.registry.mapped_as_dataclass() does not seem to be correctly recognized within the scope of PEP 681 in recent mypy versions.

  References: #12855

asyncio

• [asyncio] [usecase] Generalize the terminate logic employed by the asyncpg dialect to reuse it in the aiomysql and asyncmy dialect implementation.

  References: #12273

postgresql

• [postgresql] [bug] Fixed issue where selecting an enum array column containing NULL values would fail to parse properly in the PostgreSQL dialect. The _split_enum_values() function now correctly handles NULL entries by converting them to Python None values.

  References: #12847

• [postgresql] [bug] Fixed issue where the _sql.any_() and _sql.all_() aggregation operators would not correctly coerce the datatype of the compared value, in those cases where the compared value were not a simple int/str etc., such as a Python Enum or other custom value. This would lead to execution time errors for these values. This issue is essentially the same as #6515 which was for the now-legacy ARRAY.any() and ARRAY.all() methods.

  References: #12874

sqlite

• [sqlite] [bug] Fixed issue where SQLite table reflection would fail for tables using WITHOUT ROWID and/or STRICT table options when the table contained generated columns. The regular expression used to parse CREATE TABLE statements for generated column detection has been updated to properly handle these SQLite table options that appear after the column definitions. Pull request courtesy Tip ten Brink.

  References: #12864

mssql

• [mssql] [bug] Improved the base implementation of the asyncio cursor such that it includes the option for the underlying driver's cursor to be actively closed in those cases where it requires await in order to complete the close sequence, rather than relying on garbage collection to "close" it, when a plain Result is returned that does not use await for any of its methods. The previous approach of relying on gc was fine for MySQL and SQLite dialects but has caused problems with the aioodbc implementation on top of SQL Server. The new option is enabled for those dialects which have an "awaitable" cursor.close(), which includes the aioodbc, aiomysql, and asyncmy dialects (aiosqlite is also modified for 2.1 only).

  References: #12798

• [mssql] [bug] Fixed issue where the index reflection for SQL Server would not correctly return the order of the column inside an index when the order of the columns in the index did not match the order of the columns in the table. Pull request courtesy of Allen Chen.

  References: #12894

• [mssql] [bug] [reflection] Fixed issue in the MSSQL dialect's foreign key reflection query where duplicate rows could be returned when a foreign key column and its referenced primary key column have the same name, and both the referencing and referenced tables have indexes with the same name. This resulted in an "ForeignKeyConstraint with duplicate source column references are not supported" error when attempting to reflect such tables. The query has been corrected to exclude indexes on the child table when looking for unique indexes referenced by foreign keys.

  References: #12907

misc

• [bug] [ext] Fixed issue caused by an unwanted functional change while typing the MutableList class. This change also reverts all other functional changes done in the same change.

  References: #12802