starred/sandman2-jeffknupp
1
0
Fork 0
mirror of https://github.com/jeffknupp/sandman2.git synced 2026-04-30 10:55:51 +03:00
Code Issues 45 Projects Releases Packages Wiki Activity

[PR #212] [CLOSED] Scheduled weekly dependency update for week 16 #232

New issue
Closed
opened 2026-02-26 01:33:41 +03:00 by kerem · 0 comments
kerem commented 2026-02-26 01:33:41 +03:00
Owner
Copy link

📋 Pull Request Information

Original PR: https://github.com/jeffknupp/sandman2/pull/212
Author: @pyup-bot
Created: 4/19/2021
Status: ❌ Closed

Base: master ← Head: pyup-scheduled-update-2021-04-19

📝 Commits (9)

  • c83c953 Update flask-admin from 1.5.7 to 1.5.8
  • ad59678 Update flask-sqlalchemy from 2.4.4 to 2.5.1
  • 43bd40e Update sqlalchemy from 1.3.20 to 1.4.9
  • 6cc8175 Update coverage from 5.3 to 5.5
  • 8df0d6a Update pytest from 6.2.0 to 6.2.3
  • 5909b9b Update flask-cors from 3.0.9 to 3.0.10
  • d2dfb2b Update pytest-cov from 2.10.1 to 2.11.1
  • d497577 Update pytest-flask from 1.1.0 to 1.2.0
  • 9d66d5c Update zipp from 3.4.0 to 3.4.1

📊 Changes

1 file changed (+9 additions, -9 deletions)

View changed files

📝 requirements.txt (+9 -9)

📄 Description

Update Flask-Admin from 1.5.7 to 1.5.8.

Changelog

1.5.8

-----

* SQLAlchemy 1.4.5+ compatibility fixes
* Redis CLI fixes
Links

Update Flask-SQLAlchemy from 2.4.4 to 2.5.1.

Changelog

2.5.1

-------------

Released 2021-03-18

-   Fix compatibility with Python 2.7.

2.5.0

-------------

Released 2021-03-18

-   Update to support SQLAlchemy 1.4.
-   SQLAlchemy ``URL`` objects are immutable. Some internal methods have
 changed to return a new URL instead of ``None``. :issue:`885`
Links

Update SQLAlchemy from 1.3.20 to 1.4.9.

Changelog

1.4.9

:released: April 17, 2021

 .. change::
     :tags: bug, sql, regression
     :tickets: 6290

     Fixed regression where an empty in statement on a tuple would result
     in an error when compiled with the option ``literal_binds=True``.

 .. change::
     :tags: bug, regression, orm, performance, sql
     :tickets: 6304

     Fixed a critical performance issue where the traversal of a
     :func:`_sql.select` construct would traverse a repetitive product of the
     represented FROM clauses as they were each referred towards by columns in
     the columns clause; for a series of nested subqueries with lots of columns
     this could cause a large delay and significant memory growth. This
     traversal is used by a wide variety of SQL and ORM functions, including by
     the ORM :class:`_orm.Session` when it's configured to have
     "table-per-bind", which while this is not a common use case, it seems to be
     what Flask-SQLAlchemy is hardcoded as using, so the issue impacts
     Flask-SQLAlchemy users. The traversal has been repaired to uniqify on FROM
     clauses which was effectively what would happen implicitly with the pre-1.4
     architecture.

 .. change::
     :tags: bug, postgresql, sql, regression
     :tickets: 6303

     Fixed an argument error in the default and PostgreSQL compilers that
     would interfere with an UPDATE..FROM or DELETE..FROM..USING statement
     that was then SELECTed from as a CTE.

 .. change::
     :tags: bug, orm, regression
     :tickets: 6272

     Fixed regression where an attribute that is mapped to a
     :func:`_orm.synonym` could not be used in column loader options such as
     :func:`_orm.load_only`.

 .. change::
     :tags: usecase, orm
     :tickets: 6267

     Established support for :func:`_orm.synoynm` in conjunction with
     hybrid property, assocaitionproxy is set up completely, including that
     synonyms can be established linking to these constructs which work
     fully.   This is a behavior that was semi-explicitly disallowed previously,
     however since it did not fail in every scenario, explicit support
     for assoc proxy and hybrids has been added.


.. changelog::

1.4.8

:released: April 15, 2021

 .. change::
     :tags: change, mypy

     Updated Mypy plugin to only use the public plugin interface of the
     semantic analyzer.

 .. change::
     :tags: bug, mssql, regression
     :tickets: 6265

     Fixed an additional regression in the same area as that of :ticket:`6173`,
     :ticket:`6184`, where using a value of 0 for OFFSET in conjunction with
     LIMIT with SQL Server would create a statement using "TOP", as was the
     behavior in 1.3, however due to caching would then fail to respond
     accordingly to other values of OFFSET. If the "0" wasn't first, then it
     would be fine. For the fix, the "TOP" syntax is now only emitted if the
     OFFSET value is omitted entirely, that is, :meth:`_sql.Select.offset` is
     not used. Note that this change now requires that if the "with_ties" or
     "percent" modifiers are used, the statement can't specify an OFFSET of
     zero, it now needs to be omitted entirely.

 .. change::
     :tags: bug, engine

     The :meth:`_engine.Dialect.has_table` method now raises an informative
     exception if a non-Connection is passed to it, as this incorrect behavior
     seems to be common.  This method is not intended for external use outside
     of a dialect.  Please use the :meth:`.Inspector.has_table` method
     or for cross-compatibility with older SQLAlchemy versions, the
     :meth:`_engine.Engine.has_table` method.


 .. change::
     :tags: bug, regression, sql
     :tickets: 6249

     Fixed regression where the :class:`_sql.BindParameter` object would not
     properly render for an IN expression (i.e. using the "post compile" feature
     in 1.4) if the object were copied from either an internal cloning
     operation, or from a pickle operation, and the parameter name contained
     spaces or other special characters.

 .. change::
     :tags: bug, mypy
     :tickets: 6205

     Revised the fix for ``OrderingList`` from version 1.4.7 which was testing
     against the incorrect API.

 .. change::
     :tags: bug, asyncio
     :tickets: 6220

     Fix typo that prevented setting the ``bind`` attribute of an
     :class:`_asyncio.AsyncSession` to the correct value.

 .. change::
     :tags: feature, sql
     :tickets: 3314

     The tuple returned by :attr:`.CursorResult.inserted_primary_key` is now a
     :class:`_result.Row` object with a named tuple interface on top of the
     existing tuple interface.




 .. change::
     :tags: bug, regression, sql, sqlite
     :tickets: 6254

     Fixed regression where the introduction of the INSERT syntax "INSERT...
     VALUES (DEFAULT)" was not supported on some backends that do however
     support "INSERT..DEFAULT VALUES", including SQLite. The two syntaxes are
     now each individually supported or non-supported for each dialect, for
     example MySQL supports "VALUES (DEFAULT)" but not "DEFAULT VALUES".
     Support for Oracle has also been enabled.

 .. change::
     :tags: bug, regression, orm
     :tickets: 6259

     Fixed a cache leak involving the :func:`_orm.with_expression` loader
     option, where the given SQL expression would not be correctly considered as
     part of the cache key.

     Additionally, fixed regression involving the corresponding
     :func:`_orm.query_expression` feature. While the bug technically exists in
     1.3 as well, it was not exposed until 1.4. The "default expr" value of
     ``null()`` would be rendered when not needed, and additionally was also not
     adapted correctly when the ORM rewrites statements such as when using
     joined eager loading. The fix ensures "singleton" expressions like ``NULL``
     and ``true`` aren't "adapted" to refer to columns in ORM statements, and
     additionally ensures that a :func:`_orm.query_expression` with no default
     expression doesn't render in the statement if a
     :func:`_orm.with_expression` isn't used.

 .. change::
     :tags: bug, orm
     :tickets: 6252

     Fixed issue in the new feature of :meth:`_orm.Session.refresh` introduced
     by :ticket:`1763` where eagerly loaded relationships are also refreshed,
     where the ``lazy="raise"`` and ``lazy="raise_on_sql"`` loader strategies
     would interfere with the :func:`_orm.immediateload` loader strategy, thus
     breaking the feature for relationships that were loaded with
     :func:`_orm.selectinload`, :func:`_orm.subqueryload` as well.

.. changelog::

1.4.7

:released: April 9, 2021

 .. change::
     :tags: bug, sql, regression
     :tickets: 6222

     Enhanced the "expanding" feature used for :meth:`_sql.ColumnOperators.in_`
     operations to infer the type of expression from the right hand list of
     elements, if the left hand side does not have any explicit type set up.
     This allows the expression to support stringification among other things.
     In 1.3, "expanding" was not automatically used for
     :meth:`_sql.ColumnOperators.in_` expressions, so in that sense this change
     fixes a behavioral regression.


 .. change::
     :tags: bug, mypy

     Fixed issue in Mypy plugin where the plugin wasn’t inferring the correct
     type for columns of subclasses that don’t directly descend from
     ``TypeEngine``, in particular that of  ``TypeDecorator`` and
     ``UserDefinedType``.

 .. change::
     :tags: bug, orm, regression
     :tickets: 6221

     Fixed regression where the :func:`_orm.subqueryload` loader strategy would
     fail to correctly accommodate sub-options, such as a :func:`_orm.defer`
     option on a column, if the "path" of the subqueryload were more than one
     level deep.


 .. change::
     :tags: bug, sql

     Fixed the "stringify" compiler to support a basic stringification
     of a "multirow" INSERT statement, i.e. one with multiple tuples
     following the VALUES keyword.


 .. change::
     :tags: bug, orm, regression
     :tickets: 6211

     Fixed regression where the :func:`_orm.merge_frozen_result` function relied
     upon by the dogpile.caching example was not included in tests and began
     failing due to incorrect internal arguments.

 .. change::
     :tags: bug, engine, regression
     :tickets: 6218

     Fixed up the behavior of the :class:`_result.Row` object when dictionary
     access is used upon it, meaning converting to a dict via ``dict(row)`` or
     accessing members using strings or other objects i.e. ``row["some_key"]``
     works as it would with a dictionary, rather than raising ``TypeError`` as
     would be the case with a tuple, whether or not the C extensions are in
     place. This was originally supposed to emit a 2.0 deprecation warning for
     the "non-future" case using :class:`_result.LegacyRow`, and was to raise
     ``TypeError`` for the "future" :class:`_result.Row` class. However, the C
     version of :class:`_result.Row` was failing to raise this ``TypeError``,
     and to complicate matters, the :meth:`_orm.Session.execute` method now
     returns :class:`_result.Row` in all cases to maintain consistency with the
     ORM result case, so users who didn't have C extensions installed would
     see different behavior in this one case for existing pre-1.4 style
     code.

     Therefore, in order to soften the overall upgrade scheme as most users have
     not been exposed to the more strict behavior of :class:`_result.Row` up
     through 1.4.6, :class:`_result.LegacyRow` and :class:`_result.Row` both
     provide for string-key access as well as support for ``dict(row)``, in all
     cases emitting the 2.0 deprecation warning when ``SQLALCHEMY_WARN_20`` is
     enabled. The :class:`_result.Row` object still uses tuple-like behavior for
     ``__contains__``, which is probably the only noticeable behavioral change
     compared to :class:`_result.LegacyRow`, other than the removal of
     dictionary-style methods ``values()`` and ``items()``.

 .. change::
     :tags: bug, regression, orm
     :tickets: 6233

     Fixed critical regression where the :class:`_orm.Session` could fail to
     "autobegin" a new transaction when a flush occurred without an existing
     transaction in place, implicitly placing the :class:`_orm.Session` into
     legacy autocommit mode which commit the transaction. The
     :class:`_orm.Session` now has a check that will prevent this condition from
     occurring, in addition to repairing the flush issue.

     Additionally, scaled back part of the change made as part of :ticket:`5226`
     which can run autoflush during an unexpire operation, to not actually
     do this in the case of a :class:`_orm.Session` using legacy
     :paramref:`_orm.Session.autocommit` mode, as this incurs a commit within
     a refresh operation.

 .. change::
     :tags: change, tests

     Added a new flag to :class:`.DefaultDialect` called ``supports_schemas``;
     third party dialects may set this flag to ``False`` to disable SQLAlchemy's
     schema-level tests when running the test suite for a third party dialect.

 .. change::
     :tags: bug, regression, schema
     :tickets: 6216

     Fixed regression where usage of a token in the
     :paramref:`_engine.Connection.execution_options.schema_translate_map`
     dictionary which contained special characters such as braces would fail to
     be substituted properly. Use of square bracket characters ``[]`` is now
     explicitly disallowed as these are used as a delimiter character in the
     current implementation.

 .. change::
     :tags: bug, regression, orm
     :tickets: 6215

     Fixed regression where the ORM compilation scheme would assume the function
     name of a hybrid property would be the same as the attribute name in such a
     way that an ``AttributeError`` would be raised, when it would attempt to
     determine the correct name for each element in a result tuple. A similar
     issue exists in 1.3 but only impacts the names of tuple rows. The fix here
     adds a check that the hybrid's function name is actually present in the
     ``__dict__`` of the class or its superclasses before assigning this name;
     otherwise, the hybrid is considered to be "unnamed" and ORM result tuples
     will use the naming scheme of the underlying expression.

 .. change::
     :tags: bug, orm, regression
     :tickets: 6232

     Fixed critical regression caused by the new feature added as part of
     :ticket:`1763`, eager loaders are invoked on unexpire operations. The new
     feature makes use of the "immediateload" eager loader strategy as a
     substitute for a collection loading strategy, which unlike the other
     "post-load" strategies was not accommodating for recursive invocations
     between mutually-dependent relationships, leading to recursion overflow
     errors.


.. changelog::

1.4.6

:released: April 6, 2021

 .. change::
     :tags: bug, sql, regression, oracle, mssql
     :tickets: 6202

     Fixed further regressions in the same area as that of :ticket:`6173` released in
     1.4.5, where a "postcompile" parameter, again most typically those used for
     LIMIT/OFFSET rendering in Oracle and SQL Server, would fail to be processed
     correctly if the same parameter rendered in multiple places in the
     statement.



 .. change::
     :tags: bug, orm, regression
     :tickets: 6203

     Fixed regression where a deprecated form of :meth:`_orm.Query.join` were
     used, passing a series of entities to join from without any ON clause in a
     single :meth:`_orm.Query.join` call, would fail to function correctly.

 .. change::
     :tags: bug, mypy
     :tickets: 6147

     Applied a series of refactorings and fixes to accommodate for Mypy
     "incremental" mode across multiple files, which previously was not taken
     into account. In this mode the Mypy plugin has to accommodate Python
     datatypes expressed in other files coming in with less information than
     they have on a direct run.

     Additionally, a new decorator :func:`_orm.declarative_mixin` is added,
     which is necessary for the Mypy plugin to be able to definifitely identify
     a Declarative mixin class that is otherwise not used inside a particular
     Python file.

     .. seealso::

         :ref:`mypy_declarative_mixins`


 .. change::
     :tags: bug, mypy
     :tickets: 6205

     Fixed issue where the Mypy plugin would fail to interpret the
     "collection_class" of a relationship if it were a callable and not a class.
     Also improved type matching and error reporting for collection-oriented
     relationships.


 .. change::
     :tags: bug, sql
     :tickets: 6204

     Executing a :class:`_sql.Subquery` using :meth:`_engine.Connection.execute`
     is deprecated and will emit a deprecation warning; this use case was an
     oversight that should have been removed from 1.4. The operation will now
     execute the underlying :class:`_sql.Select` object directly for backwards
     compatibility. Similarly, the :class:`_sql.CTE` class is also not
     appropriate for execution. In 1.3, attempting to execute a CTE would result
     in an invalid "blank" SQL statement being executed; since this use case was
     not working it now raises :class:`_exc.ObjectNotExecutableError`.
     Previously, 1.4 was attempting to execute the CTE as a statement however it
     was working only erratically.

 .. change::
     :tags: bug, regression, orm
     :tickets: 6206

     Fixed critical regression where the :meth:`_orm.Query.yield_per` method in
     the ORM would set up the internal :class:`_engine.Result` to yield chunks
     at a time, however made use of the new :meth:`_engine.Result.unique` method
     which uniques across the entire result. This would lead to lost rows since
     the ORM is using ``id(obj)`` as the uniquing function, which leads to
     repeated identifiers for new objects as already-seen objects are garbage
     collected. 1.3's behavior here was to "unique" across each chunk, which
     does not actually produce "uniqued" results when results are yielded in
     chunks. As the :meth:`_orm.Query.yield_per` method is already explicitly
     disallowed when joined eager loading is in place, which is the primary
     rationale for the "uniquing" feature, the "uniquing" feature is now turned
     off entirely when :meth:`_orm.Query.yield_per` is used.

     This regression only applies to the legacy :class:`_orm.Query` object; when
     using :term:`2.0 style` execution, "uniquing" is not automatically applied.
     To prevent the issue from arising from explicit use of
     :meth:`_engine.Result.unique`, an error is now raised if rows are fetched
     from a "uniqued" ORM-level :class:`_engine.Result` if any
     :ref:`yield per <orm_queryguide_yield_per>` API is also in use, as the
     purpose of ``yield_per`` is to allow for arbitrarily large numbers of rows,
     which cannot be uniqued in memory without growing the number of entries to
     fit the complete result size.


 .. change::
     :tags: usecase, asyncio, postgresql
     :tickets: 6199

     Added accessors ``.sqlstate`` and synonym ``.pgcode`` to the ``.orig``
     attribute of the SQLAlchemy exception class raised by the asyncpg DBAPI
     adapter, that is, the intermediary exception object that wraps on top of
     that raised by the asyncpg library itself, but below the level of the
     SQLAlchemy dialect.

.. changelog::

1.4.5

:released: April 2, 2021

 .. change::
     :tags: bug, sql, postgresql
     :tickets: 6183

     Fixed bug in new :meth:`_functions.FunctionElement.render_derived` feature
     where column names rendered out explicitly in the alias SQL would not have
     proper quoting applied for case sensitive names and other non-alphanumeric
     names.

 .. change::
     :tags: bug, regression, orm
     :tickets: 6172

     Fixed regression where the :func:`_orm.joinedload` loader strategy would
     not successfully joinedload to a mapper that is mapper against a
     :class:`.CTE` construct.

 .. change::
     :tags: bug, regression, sql
     :tickets: 6181

     Fixed regression where use of the :meth:`.Operators.in_` method with a
     :class:`_sql.Select` object against a non-table-bound column would produce
     an ``AttributeError``, or more generally using a :class:`_sql.ScalarSelect`
     that has no datatype in a binary expression would produce invalid state.


 .. change::
     :tags: bug, mypy
     :tickets: sqlalchemy/sqlalchemy2-stubs/14

     Fixed issue in mypy plugin where newly added support for
     :func:`_orm.as_declarative` needed to more fully add the
     ``DeclarativeMeta`` class to the mypy interpreter's state so that it does
     not result in a name not found error; additionally improves how global
     names are setup for the plugin including the ``Mapped`` name.


 .. change::
     :tags: bug, mysql, regression
     :tickets: 6163

     Fixed regression in the MySQL dialect where the reflection query used to
     detect if a table exists would fail on very old MySQL 5.0 and 5.1 versions.

 .. change::
     :tags: bug, sql
     :tickets: 6184

     Added a new flag to the :class:`_engine.Dialect` class called
     :attr:`_engine.Dialect.supports_statement_cache`. This flag now needs to be present
     directly on a dialect class in order for SQLAlchemy's
     :ref:`query cache <sql_caching>` to take effect for that dialect. The
     rationale is based on discovered issues such as :ticket:`6173` revealing
     that dialects which hardcode literal values from the compiled statement,
     often the numerical parameters used for LIMIT / OFFSET, will not be
     compatible with caching until these dialects are revised to use the
     parameters present in the statement only. For third party dialects where
     this flag is not applied, the SQL logging will show the message "dialect
     does not support caching", indicating the dialect should seek to apply this
     flag once they have verified that no per-statement literal values are being
     rendered within the compilation phase.

     .. seealso::

       :ref:`engine_thirdparty_caching`

 .. change::
     :tags: bug, postgresql
     :tickets: 6099

     Fixed typo in the fix for :ticket:`6099` released in 1.4.4 that completely
     prevented this change from working correctly, i.e. the error message did not match
     what was actually emitted by pg8000.

 .. change::
     :tags: bug, orm, regression
     :tickets: 6171

     Scaled back the warning message added in :ticket:`5171` to not warn for
     overlapping columns in an inheritance scenario where a particular
     relationship is local to a subclass and therefore does not represent an
     overlap.

 .. change::
     :tags: bug, regression, oracle
     :tickets: 6173

     Fixed critical regression where the Oracle compiler would not maintain the
     correct parameter values in the LIMIT/OFFSET for a select due to a caching
     issue.


 .. change::
     :tags: bug, postgresql
     :tickets: 6170

     Fixed issue where the PostgreSQL :class:`.PGInspector`, when generated
     against an :class:`_engine.Engine`, would fail for ``.get_enums()``,
     ``.get_view_names()``, ``.get_foreign_table_names()`` and
     ``.get_table_oid()`` when used against a "future" style engine and not the
     connection directly.

 .. change::
     :tags: bug, schema
     :tickets: 6146

     Introduce a new parameter :paramref:`_types.Enum.omit_aliases` in
     :class:`_types.Enum` type allow filtering aliases when using a pep435 Enum.
     Previous versions of SQLAlchemy kept aliases in all cases, creating
     database enum type with additional states, meaning that they were treated
     as different values in the db. For backward compatibility this flag
     defaults to ``False`` in the 1.4 series, but will be switched to ``True``
     in a future version. A deprecation warning is raise if this flag is not
     specified and the passed enum contains aliases.

 .. change::
     :tags: bug, mssql
     :tickets: 6163

     Fixed a regression in MSSQL 2012+ that prevented the order by clause
     to be rendered when ``offset=0`` is used in a subquery.

 .. change::
     :tags: bug, asyncio
     :tickets: 6166


     Fixed issue where the asyncio extension could not be loaded
     if running Python 3.6 with the backport library of
     ``contextvars`` installed.

.. changelog::

1.4.4

:released: March 30, 2021

 .. change::
     :tags: bug, misc

     Adjusted the usage of the ``importlib_metadata`` library for loading
     setuptools entrypoints in order to accommodate for some deprecation
     changes.


 .. change::
     :tags: bug, postgresql
     :tickets: 6099

     Modified the ``is_disconnect()`` handler for the pg8000 dialect, which now
     accommodates for a new ``InterfaceError`` emitted by pg8000 1.19.0. Pull
     request courtesy Hamdi Burak Usul.


 .. change::
     :tags: bug, orm
     :tickets: 6139

     Fixed critical issue in the new :meth:`_orm.PropComparator.and_` feature
     where loader strategies that emit secondary SELECT statements such as
     :func:`_orm.selectinload` and :func:`_orm.lazyload` would fail to
     accommodate for bound parameters in the user-defined criteria in terms of
     the current statement being executed, as opposed to the cached statement,
     causing stale bound values to be used.

     This also adds a warning for the case where an object that uses
     :func:`_orm.lazyload` in conjunction with :meth:`_orm.PropComparator.and_`
     is attempted to be serialized; the loader criteria cannot reliably
     be serialized and deserialized and eager loading should be used for this
     case.


 .. change::
     :tags: bug, engine
     :tickets: 6138

     Repair wrong arguments to exception handling method
     in CursorResult.

 .. change::
     :tags: bug, regression, orm
     :tickets: 6144

     Fixed missing method :meth:`_orm.Session.get` from the
     :class:`_orm.ScopedSession` interface.


 .. change::
     :tags: usecase, engine
     :tickets: 6155

     Modified the context manager used by :class:`_engine.Transaction` so that
     an "already detached" warning is not emitted by the ending of the context
     manager itself, if the transaction were already manually rolled back inside
     the block. This applies to regular transactions, savepoint transactions,
     and legacy "marker" transactions. A warning is still emitted if the
     ``.rollback()`` method is called explicitly more than once.

.. changelog::

1.4.3

:released: March 25, 2021

 .. change::
     :tags: bug, orm
     :tickets: 6069

     Fixed a bug where python 2.7.5 (default on CentOS 7) wasn't able to import
     sqlalchemy, because on this version of Python ``exec "statement"`` and
     ``exec("statement")`` do not behave the same way.  The compatibility
     ``exec_()`` function was used instead.

 .. change::
     :tags: sqlite, feature, asyncio
     :tickets: 5920

     Added support for the aiosqlite database driver for use with the
     SQLAlchemy asyncio extension.

     .. seealso::

       :ref:`aiosqlite`

 .. change::
     :tags: bug, regression, orm, declarative
     :tickets: 6128

     Fixed regression where the ``.metadata`` attribute on a per class level
     would not be honored, breaking the use case of per-class-hierarchy
     :class:`.schema.MetaData` for abstract declarative classes and mixins.


     .. seealso::

       :ref:`declarative_metadata`

 .. change::
     :tags: bug, mypy

     Added support for the Mypy extension to correctly interpret a declarative
     base class that's generated using the :func:`_orm.as_declarative` function
     as well as the :meth:`_orm.registry.as_declarative_base` method.

 .. change::
     :tags: bug, mypy
     :tickets: 6109

     Fixed bug in Mypy plugin where the Python type detection
     for the :class:`_types.Boolean` column type would produce
     an exception; additionally implemented support for :class:`_types.Enum`,
     including detection of a string-based enum vs. use of Python ``enum.Enum``.

 .. change::
     :tags: bug, reflection, postgresql
     :tickets: 6129

     Fixed reflection of identity columns in tables with mixed case names
     in PostgreSQL.

 .. change::
     :tags: bug, sqlite, regression
     :tickets: 5848

     Repaired the ``pysqlcipher`` dialect to connect correctly which had
     regressed in 1.4, and added test + CI support to maintain the driver
     in working condition.  The dialect now imports the ``sqlcipher3`` module
     for Python 3 by default before falling back to ``pysqlcipher3`` which
     is documented as now being unmaintained.

     .. seealso::

       :ref:`pysqlcipher`


 .. change::
     :tags: bug, orm
     :tickets: 6060

     Fixed bug where ORM queries using a correlated subquery in conjunction with
     :func:`_orm.column_property` would fail to correlate correctly to an
     enclosing subquery or to a CTE when :meth:`_sql.Select.correlate_except`
     were used in the property to control correlation, in cases where the
     subquery contained the same selectables as ones within the correlated
     subquery that were intended to not be correlated.

 .. change::
     :tags: bug, orm
     :tickets: 6131

     Fixed bug where combinations of the new "relationship with criteria"
     feature could fail in conjunction with features that make use of the new
     "lambda SQL" feature, including loader strategies such as selectinload and
     lazyload, for more complicated scenarios such as polymorphic loading.

 .. change::
     :tags: bug, orm
     :tickets: 6124

     Repaired support so that the :meth:`_sql.ClauseElement.params` method can
     work correctly with a :class:`_sql.Select` object that includes joins
     across ORM relationship structures, which is a new feature in 1.4.


 .. change::
     :tags: bug, engine, regression
     :tickets: 6119

     Restored the :class:`_engine.ResultProxy` name back to the
     ``sqlalchemy.engine`` namespace. This name refers to the
     :class:`_engine.LegacyCursorResult` object.

 .. change::
     :tags: bug, orm
     :tickets: 6115

     Fixed issue where a "removed in 2.0" warning were generated internally by
     the relationship loader mechanics.


.. changelog::

1.4.2

:released: March 19, 2021

 .. change::
     :tags: bug, orm, dataclasses
     :tickets: 6093

     Fixed issue in new ORM dataclasses functionality where dataclass fields on
     an abstract base or mixin that contained column or other mapping constructs
     would not be mapped if they also included a "default" key within the
     dataclasses.field() object.


 .. change::
     :tags: bug, regression, orm
     :tickets: 6088

     Fixed regression where the :attr:`_orm.Query.selectable` accessor, which is
     a synonym for :meth:`_orm.Query.__clause_element__`, got removed, it's now
     restored.

 .. change::
     :tags: bug, engine, regression

     Restored top level import for ``sqlalchemy.engine.reflection``. This
     ensures that the base :class:`_reflection.Inspector` class is properly
     registered so that :func:`_sa.inspect` works for third party dialects that
     don't otherwise import this package.


 .. change::
     :tags: bug, regression, orm
     :tickets: 6086

     Fixed regression where use of an unnamed SQL expression such as a SQL
     function would raise a column targeting error if the query itself were
     using joinedload for an entity and was also being wrapped in a subquery by
     the joinedload eager loading process.


 .. change::
     :tags: bug, orm, regression
     :tickets: 6092

     Fixed regression where the :meth:`_orm.Query.filter_by` method would fail
     to locate the correct source entity if the :meth:`_orm.Query.join` method
     had been used targeting an entity without any kind of ON clause.


 .. change::
     :tags: postgresql, usecase
     :tickets: 6982

     Rename the column name used by a reflection query that used
     a reserved word in some postgresql compatible databases.

 .. change::
     :tags: usecase, orm, dataclasses
     :tickets: 6100

     Added support for the :class:`_orm.declared_attr` object to work in the
     context of dataclass fields.

     .. seealso::

         :ref:`orm_declarative_dataclasses_mixin`

 .. change::
     :tags: bug, sql, regression
     :tickets: 6101

     Fixed issue where using a ``func`` that includes dotted packagenames would
     fail to be cacheable by the SQL caching system due to a Python list of
     names that needed to be a tuple.


 .. change::
     :tags: bug, regression, orm
     :tickets: 6095

     Fixed regression where the SQL compilation of a :class:`.Function` would
     not work correctly if the object had been "annotated", which is an internal
     memoization process used mostly by the ORM. In particular it could affect
     ORM lazy loads which make greater use of this feature in 1.4.

 .. change::
     :tags: bug, sql, regression
     :tickets: 6097

     Fixed regression in the :func:`_sql.case` construct, where the "dictionary"
     form of argument specification failed to work correctly if it were passed
     positionally, rather than as a "whens" keyword argument.

 .. change::
     :tags: bug, orm
     :tickets: 6090

     Fixed regression where the :class:`.ConcreteBase` would fail to map at all
     when a mapped column name overlapped with the discriminator column name,
     producing an assertion error. The use case here did not function correctly
     in 1.3 as the polymorphic union would produce a query that ignored the
     discriminator column entirely, while emitting duplicate column warnings. As
     1.4's architecture cannot easily reproduce this essentially broken behavior
     of 1.3 at the ``select()`` level right now, the use case now raises an
     informative error message instructing the user to use the
     ``.ConcreteBase._concrete_discriminator_name`` attribute to resolve the
     conflict. To assist with this configuration,
     ``.ConcreteBase._concrete_discriminator_name`` may be placed on the base
     class only where it will be automatically used by subclasses; previously
     this was not the case.


 .. change::
     :tags: bug, mypy
     :tickets: sqlalchemy/sqlalchemy2-stubs/2

     Fixed issue in MyPy extension which crashed on detecting the type of a
     :class:`.Column` if the type were given with a module prefix like
     ``sa.Integer()``.


.. changelog::

1.4.1

:released: March 17, 2021

 .. change::
     :tags: bug, orm, regression
     :tickets: 6066

     Fixed regression where producing a Core expression construct such as
     :func:`_sql.select` using ORM entities would eagerly configure the mappers,
     in an effort to maintain compatibility with the :class:`_orm.Query` object
     which necessarily does this to support many backref-related legacy cases.
     However, core :func:`_sql.select` constructs are also used in mapper
     configurations and such, and to that degree this eager configuration is
     more of an inconvenience, so eager configure has been disabled for the
     :func:`_sql.select` and other Core constructs in the absence of ORM loading
     types of functions such as :class:`_orm.Load`.

     The change maintains the behavior of :class:`_orm.Query` so that backwards
     compatibility is maintained. However, when using a :func:`_sql.select` in
     conjunction with ORM entities, a "backref" that isn't explicitly placed on
     one of the classes until mapper configure time won't be available unless
     :func:`_orm.configure_mappers` or the newer :func:`_orm.registry.configure`
     has been called elsewhere. Prefer using
     :paramref:`_orm.relationship.back_populates` for more explicit relationship
     configuration which does not have the eager configure requirement.


 .. change::
     :tags: bug, mssql, regression
     :tickets: 6058

     Fixed regression where a new setinputsizes() API that's available for
     pyodbc was enabled, which is apparently incompatible with pyodbc's
     fast_executemany() mode in the absence of more accurate typing information,
     which as of yet is not fully implemented or tested. The pyodbc dialect and
     connector has been modified so that setinputsizes() is not used at all
     unless the parameter ``use_setinputsizes`` is passed to the dialect, e.g.
     via :func:`_sa.create_engine`, at which point its behavior can be
     customized using the :meth:`.DialectEvents.do_setinputsizes` hook.

     .. seealso::

       :ref:`mssql_pyodbc_setinputsizes`

 .. change::
     :tags: bug, orm, regression
     :tickets: 6055

     Fixed a critical regression in the relationship lazy loader where the SQL
     criteria used to fetch a related many-to-one object could go stale in
     relation to other memoized structures within the loader if the mapper had
     configuration changes, such as can occur when mappers are late configured
     or configured on demand, producing a comparison to None and returning no
     object. Huge thanks to Alan Hamlett for their help tracking this down late
     into the night.



 .. change::
     :tags: bug, regression
     :tickets: 6068

     Added back ``items`` and ``values`` to ``ColumnCollection`` class.
     The regression was introduced while adding support for duplicate
     columns in from clauses and selectable in ticket 4753.


 .. change::
     :tags: bug, engine, regression
     :tickets: 6074

     The Python ``namedtuple()`` has the behavior such that the names ``count``
     and ``index`` will be served as tuple values if the named tuple includes
     those names; if they are absent, then their behavior as methods of
     ``collections.abc.Sequence`` is maintained. Therefore the
     :class:`_result.Row` and :class:`_result.LegacyRow` classes have been fixed
     so that they work in this same way, maintaining the expected behavior for
     database rows that have columns named "index" or "count".

 .. change::
     :tags: bug, orm, regression
     :tickets: 6076

     Fixed regression where the :meth:`_orm.Query.exists` method would fail to
     create an expression if the entity list of the :class:`_orm.Query` were
     an arbitrary SQL column expression.


 .. change::
     :tags: bug, orm, regression
     :tickets: 6052

     Fixed regression where calling upon :meth:`_orm.Query.count` in conjunction
     with a loader option such as :func:`_orm.joinedload` would fail to ignore
     the loader option. This is a behavior that has always been very specific to
     the :meth:`_orm.Query.count` method; an error is normally raised if a given
     :class:`_orm.Query` has options that don't apply to what it is returning.

 .. change::
     :tags: bug, orm, declarative, regression
     :tickets: 6054

     Fixed bug where user-mapped classes that contained an attribute named
     "registry" would cause conflicts with the new registry-based mapping system
     when using :class:`.DeclarativeMeta`. While the attribute remains
     something that can be set explicitly on a declarative base to be
     consumed by the metaclass, once located it is placed under a private
     class variable so it does not conflict with future subclasses that use
     the same name for other purposes.



 .. change::
     :tags: bug, orm, regression
     :tickets: 6067

     Fixed regression in :meth:`_orm.Session.identity_key`, including that the
     method and related methods were not covered by any unit test as well as
     that the method contained a typo preventing it from functioning correctly.


.. changelog::

1.4.0

:released: March 15, 2021

 .. change::
     :tags: bug, mssql
     :tickets: 5919

     Fix a reflection error for MSSQL 2005 introduced by the reflection of
     filtered indexes.

 .. change::
     :tags: feature, mypy
     :tickets: 4609

     Rudimentary and experimental support for Mypy has been added in the form of
     a new plugin, which itself depends on new typing stubs for SQLAlchemy. The
     plugin allows declarative mappings in their standard form to both be
     compatible with Mypy as well as to provide typing support for mapped
     classes and instances.

     .. seealso::

         :ref:`mypy_toplevel`

 .. change::
     :tags: bug, sql
     :tickets: 6016

     Fixed bug where the "percent escaping" feature that occurs with dialects
     that use the "format" or "pyformat" bound parameter styles was not enabled
     for the :meth:`_sql.Operators.op` and :class:`_sql.custom_op` constructs,
     for custom operators that use percent signs. The percent sign will now be
     automatically doubled based on the paramstyle as necessary.



 .. change::
     :tags: bug, regression, sql
     :tickets: 5979

     Fixed regression where the "unsupported compilation error" for unknown
     datatypes would fail to raise correctly.

 .. change::
     :tags: ext, usecase
     :tickets: 5942

     Add new parameter
     :paramref:`_automap.AutomapBase.prepare.reflection_options`
     to allow passing of :meth:`_schema.MetaData.reflect` options like ``only``
     or dialect-specific reflection options like ``oracle_resolve_synonyms``.

 .. change::
     :tags: change, sql

     Altered the compilation for the :class:`.CTE` construct so that a string is
     returned representing the inner SELECT statement if the :class:`.CTE` is
     stringified directly, outside of the context of an enclosing SELECT; This
     is the same behavior of :meth:`_sql.FromClause.alias` and
     :meth:`_sql.Select.subquery`. Previously, a blank string would be
     returned as the CTE is normally placed above a SELECT after that SELECT has
     been generated, which is generally misleading when debugging.


 .. change::
     :tags: bug, orm
     :tickets: 5981

     Fixed regression where the :paramref:`_orm.relationship.query_class`
     parameter stopped being functional for "dynamic" relationships.  The
     ``AppenderQuery`` remains dependent on the legacy :class:`_orm.Query`
     class; users are encouraged to migrate from the use of "dynamic"
     relationships to using :func:`_orm.with_parent` instead.


 .. change::
     :tags: bug, orm, regression
     :tickets: 6003

     Fixed regression where :meth:`_orm.Query.join` would produce no effect if
     the query itself as well as the join target were against a
     :class:`_schema.Table` object, rather than a mapped class. This was part of
     a more systemic issue where the legacy ORM query compiler would not be
     correctly used from a :class:`_orm.Query` if the statement produced had not
     ORM entities present within it.


 .. change::
     :tags: bug, regression, sql
     :tickets: 6008

     Fixed regression where usage of the standalone :func:`_sql.distinct()` used
     in the form of being directly SELECTed would fail to be locatable in the
     result set by column identity, which is how the ORM locates columns. While
     standalone :func:`_sql.distinct()` is not oriented towards being directly
     SELECTed (use :meth:`_sql.select.distinct` for a regular
     ``SELECT DISTINCT..``) , it was usable to a limited extent in this way
     previously (but wouldn't work in subqueries, for example). The column
     targeting for unary expressions such as "DISTINCT <col>" has been improved
     so that this case works again, and an additional improvement has been made
     so that usage of this form in a subquery at least generates valid SQL which
     was not the case previously.

     The change additionally enhances the ability to target elements in
     ``row._mapping`` based on SQL expression objects in ORM-enabled
     SELECT statements, including whether the statement was invoked by
     ``connection.execute()`` or ``session.execute()``.

 .. change::
     :tags: bug, orm, asyncio
     :tickets: 5998

     The API for :meth:`_asyncio.AsyncSession.delete` is now an awaitable;
     this method cascades along relationships which must be loaded in a
     similar manner as the :meth:`_asyncio.AsyncSession.merge` method.


 .. change::
     :tags: usecase, postgresql, mysql, asyncio
     :tickets: 5967

     Added an ``asyncio.Lock()`` within SQLAlchemy's emulated DBAPI cursor,
     local to the connection, for the asyncpg and aiomysql dialects for the
     scope of the ``cursor.execute()`` and ``cursor.executemany()`` methods. The
     rationale is to prevent failures and corruption for the case where the
     connection is used in multiple awaitables at once.

     While this use case can also occur with threaded code and non-asyncio
     dialects, we anticipate this kind of use will be more common under asyncio,
     as the asyncio API is encouraging of such use. It's definitely better to
     use a distinct connection per concurrent awaitable however as concurrency
     will not be achieved otherwise.

     For the asyncpg dialect, this is so that the space between
     the call to ``prepare()`` and ``fetch()`` is prevented from allowing
     concurrent executions on the connection from causing interface error
     exceptions, as well as preventing race conditions when starting a new
     transaction. Other PostgreSQL DBAPIs are threadsafe at the connection level
     so this intends to provide a similar behavior, outside the realm of server
     side cursors.

     For the aiomysql dialect, the mutex will provide safety such that
     the statement execution and the result set fetch, which are two distinct
     steps at the connection level, won't get corrupted by concurrent
     executions on the same connection.


 .. change::
     :tags: bug, engine
     :tickets: 6002

     Improved engine logging to note ROLLBACK and COMMIT which is logged while
     the DBAPI driver is in AUTOCOMMIT mode. These ROLLBACK/COMMIT are library
     level and do not have any effect when AUTOCOMMIT is in effect, however it's
     still worthwhile to log as these indicate where SQLAlchemy sees the
     "transaction" demarcation.

 .. change::
     :tags: bug, regression, engine
     :tickets: 6004

     Fixed a regression where the "reset agent" of the connection pool wasn't
     really being utilized by the :class:`_engine.Connection` when it were
     closed, and also leading to a double-rollback scenario that was somewhat
     wasteful.   The newer architecture of the engine has been updated so that
     the connection pool "reset-on-return" logic will be skipped when the
     :class:`_engine.Connection` explicitly closes out the transaction before
     returning the pool to the connection.

 .. change::
     :tags: bug, schema
     :tickets: 5953

     Deprecated all schema-level ``.copy()`` methods and renamed to
     ``_copy()``.  These are not standard Python "copy()" methods as they
     typically rely upon being instantiated within particular contexts
     which are passed to the method as optional keyword arguments.   The
     :meth:`_schema.Table.tometadata` method is the public API that provides
     copying for :class:`_schema.Table` objects.

 .. change::
     :tags: bug, ext
     :tickets: 6020

     The ``sqlalchemy.ext.mutable`` extension now tracks the "parents"
     collection using the :class:`.InstanceState` associated with objects,
     rather than the object itself. The latter approach required that the object
     be hashable so that it can be inside of a ``WeakKeyDictionary``, which goes
     against the behavioral contract of the ORM overall which is that ORM mapped
     objects do not need to provide any particular kind of ``__hash__()`` method
     and that unhashable objects are supported.

 .. change::
     :tags: bug, orm
     :tickets: 5984

     The unit of work process now turns off all "lazy='raise'" behavior
     altogether when a flush is proceeding.  While there are areas where the UOW
     is sometimes loading things that aren't ultimately needed, the lazy="raise"
     strategy is not helpful here as the user often does not have much control
     or visibility into the flush process.


.. changelog::

1.4.0b3

:released: March 15, 2021
 :released: February 15, 2021

 .. change::
     :tags: bug, orm
     :tickets: 5933

     Fixed issue in new 1.4/2.0 style ORM queries where a statement-level label
     style would not be preserved in the keys used by result rows; this has been
     applied to all combinations of Core/ORM columns / session vs. connection
     etc. so that the linkage from statement to result row is the same in all
     cases.   As part of this change, the labeling of column expressions
     in rows has been improved to retain the original name of the ORM
     attribute even if used in a subquery.




 .. change::
     :tags: bug, sql
     :tickets: 5924

     Fixed bug where the "cartesian product" assertion was not correctly
     accommodating for joins between tables that relied upon the use of LATERAL
     to connect from a subquery to another subquery in the enclosing context.

 .. change::
     :tags: bug, sql
     :tickets: 5934

     Fixed 1.4 regression where the :meth:`_functions.Function.in_` method was
     not covered by tests and failed to function properly in all cases.

 .. change::
     :tags: bug, engine, postgresql
     :tickets: 5941

     Continued with the improvement made as part of :ticket:`5653` to further
     support bound parameter names, including those generated against column
     names, for names that include colons, parenthesis, and question marks, as
     well as improved test support, so that bound parameter names even if they
     are auto-derived from column names should have no problem including for
     parenthesis in psycopg2's "pyformat" style.

     As part of this change, the format used by the asyncpg DBAPI adapter (which
     is local to SQLAlchemy's asyncpg dialect) has been changed from using
     "qmark" paramstyle to "format", as there is a standard and internally
     supported SQL string escaping style for names that use percent signs with
     "format" style (i.e. to double percent signs), as opposed to names that use
     question marks with "qmark" style (where an escaping system is not defined
     by pep-249 or Python).

     .. seealso::

       :ref:`change_5941`

 .. change::
     :tags: sql, usecase, postgresql, sqlite
     :tickets: 5939

     Enhance ``set_`` keyword of :class:`.OnConflictDoUpdate` to accept a
     :class:`.ColumnCollection`, such as the ``.c.`` collection from a
     :class:`Selectable`, or the ``.excluded`` contextual object.

 .. change::
     :tags: feature, orm

     The ORM used in :term:`2.0 style` can now return ORM objects from the rows
     returned by an UPDATE..RETURNING or INSERT..RETURNING statement, by
     supplying the construct to :meth:`_sql.Select.from_statement` in an ORM
     context.

     .. seealso::

       :ref:`orm_dml_returning_objects`



 .. change::
     :tags: bug, sql
     :tickets: 5935

     Fixed regression where use of an arbitrary iterable with the
     :func:`_sql.select` function was not working, outside of plain lists. The
     forwards/backwards compatibility logic here now checks for a wider range of
     incoming "iterable" types including that a ``.c`` collection from a
     selectable can be passed directly. Pull request compliments of Oliver Rice.

.. changelog::

1.4.0b2

:released: March 15, 2021
 :released: February 3, 2021

 .. change::
     :tags: usecase, sql
     :tickets: 5695

     Multiple calls to "returning", e.g. :meth:`_sql.Insert.returning`,
     may now be chained to add new columns to the RETURNING clause.


 .. change::
   :tags: bug, asyncio
   :tickets: 5615

   Adjusted the greenlet integration, which provides support for Python asyncio
   in SQLAlchemy, to accommodate for the handling of Python ``contextvars``
   (introduced in Python 3.7) for ``greenlet`` versions greater than 0.4.17.
   Greenlet version 0.4.17 added automatic handling of contextvars in a
   backwards-incompatible way; we've coordinated with the greenlet authors to
   add a preferred API for this in versions subsequent to 0.4.17 which is now
   supported by SQLAlchemy's greenlet integration.  For greenlet versions prior
   to 0.4.17 no behavioral change is needed, version 0.4.17 itself is blocked
   from the dependencies.

 .. change::
     :tags: bug, engine, sqlite
     :tickets: 5845

     Fixed bug in the 2.0 "future" version of :class:`.Engine` where emitting
     SQL during the :meth:`.EngineEvents.begin` event hook would cause a
     re-entrant (recursive) condition due to autobegin, affecting among other
     things the recipe documented for SQLite to allow for savepoints and
     serializable isolation support.


 .. change::
     :tags: bug, orm, regression
     :tickets: 5845

     Fixed issue in new :class:`_orm.Session` similar to that of the
     :class:`_engine.Connection` where the new "autobegin" logic could be
     tripped into a re-entrant (recursive) state if SQL were executed within the
     :meth:`.SessionEvents.after_transaction_create` event hook.

 .. change::
     :tags: sql
     :tickets: 4757

     Replace :meth:`_orm.Query.with_labels` and
     :meth:`_sql.GenerativeSelect.apply_labels` with explicit getters and
     setters :meth:`_sql.GenerativeSelect.get_label_style` and
     :meth:`_sql.GenerativeSelect.set_label_style` to accommodate the three
     supported label styles: :data:`_sql.LABEL_STYLE_DISAMBIGUATE_ONLY`,
     :data:`_sql.LABEL_STYLE_TABLENAME_PLUS_COL`, and
     :data:`_sql.LABEL_STYLE_NONE`.

     In addition, for Core and "future style" ORM queries,
     ``LABEL_STYLE_DISAMBIGUATE_ONLY`` is now the default label style. This
     style differs from the existing "no labels" style in that labeling is
     applied in the case of column name conflicts; with ``LABEL_STYLE_NONE``, a
     duplicate column name is not accessible via name in any case.

     For cases where labeling is significant, namely that the ``.c`` collection
     of a subquery is able to refer to all columns unambiguously, the behavior
     of ``LABEL_STYLE_DISAMBIGUATE_ONLY`` is now sufficient for all
     SQLAlchemy features across Core and ORM which involve this behavior.
     Result set rows since SQLAlchemy 1.0 are usually aligned with column
     constructs positionally.

     For legacy ORM queries using :class:`_query.Query`, the table-plus-column
     names labeling style applied by ``LABEL_STYLE_TABLENAME_PLUS_COL``
     continues to be used so that existing test suites and logging facilities
     see no change in behavior by default.

 .. change::
     :tags: bug, orm, unitofwork
     :tickets: 5735

     Improved the unit of work topological sorting system such that the
     toplogical sort is now deterministic based on the sorting of the input set,
     which itself is now sorted at the level of mappers, so that the same inputs
     of affected mappers should produce the same output every time, among
     mappers / tables that don't have any dependency on each other. This further
     reduces the chance of deadlocks as can be observed in a flush that UPDATEs
     among multiple, unrelated tables such that row locks are generated.


 .. change::
     :tags: changed, orm
     :tickets: 5897

     Mapper "configuration", which occurs within the
     :func:`_orm.configure_mappers` function, is now organized to be on a
     per-registry basis. This allows for example the mappers within a certain
     declarative base to be configured, but not those of another base that is
     also present in memory. The goal is to provide a means of reducing
     application startup time by only running the "configure" process for sets
     of mappers that are needed. This also adds the
     :meth:`_orm.registry.configure` method that will run configure for the
     mappers local in a particular registry only.

 .. change::
     :tags: bug, orm
     :tickets: 5702

     Fixed regression where the :paramref:`.Bundle.single_entity` flag would
     take effect for a :class:`.Bundle` even though it were not set.
     Additionally, this flag is legacy as it only makes sense for the
     :class:`_orm.Query` object and not 2.0 style execution.  a deprecation
     warning is emitted when used with new-style execution.

 .. change::
     :tags: bug, sql
     :tickets: 5858

     Fixed issue in new :meth:`_sql.Select.join` method where chaining from the
     current JOIN wasn't looking at the right state, causing an expression like
     "FROM a JOIN b <onclause>, b JOIN c <onclause>" rather than
     "FROM a JOIN b <onclause> JOIN c <onclause>".

 .. change::
     :tags: usecase, sql

     Added :meth:`_sql.Select.outerjoin_from` method to complement
     :meth:`_sql.Select.join_from`.

 .. change::
     :tags: usecase, sql
     :tickets: 5888

     Adjusted the "literal_binds" feature of :class:`_sql.Compiler` to render
     NULL for a bound parameter that has ``None`` as the value, either
     explicitly passed or omitted. The previous error message "bind parameter
     without a renderable value" is removed, and a missing or ``None`` value
     will now render NULL in all cases. Previously, rendering of NULL was
     starting to happen for DML statements due to internal refactorings, but was
     not explicitly part of test coverage, which it now is.

     While no error is raised, when the context is within that of a column
     comparison, and the operator is not "IS"/"IS NOT", a warning is emitted
     that this is not generally useful from a SQL perspective.


 .. change::
     :tags: bug, orm
     :tickets: 5750

     Fixed regression where creating an :class:`_orm.aliased` construct against
     a plain selectable and including a name would raise an assertionerror.


 .. change::
     :tags: bug, mssql, mysql, datatypes
     :tickets: 5788
     :versions: 1.4.0b2

     Decimal accuracy and behavior has been improved when extracting floating
     point and/or decimal values from JSON strings using the
     :meth:`_sql.sqltypes.JSON.Comparator.as_float` method, when the numeric
     value inside of the JSON string has many significant digits; previously,
     MySQL backends would truncate values with many significant digits and SQL
     Server backends would raise an exception due to a DECIMAL cast with
     insufficient significant digits.   Both backends now use a FLOAT-compatible
     approach that does not hardcode significant digits for floating point
     values. For precision numerics, a new method
     :meth:`_sql.sqltypes.JSON.Comparator.as_numeric` has been added which
     accepts arguments for precision and scale, and will return values as Python
     ``Decimal`` objects with no floating point conversion assuming the DBAPI
     supports it (all but pysqlite).

 .. change::
     :tags: feature, orm, declarative
     :tickets: 5745

     Added an alternate resolution scheme to Declarative that will extract the
     SQLAlchemy column or mapped property from the "metadata" dictionary of a
     dataclasses.Field object.  This allows full declarative mappings to be
     combined with dataclass fields.

     .. seealso::

         :ref:`orm_declarative_dataclasses_declarative_table`

 .. change::
     :tags: bug, sql
     :tickets: 5754

     Deprecation warnings are emitted under "SQLALCHEMY_WARN_20" mode when
     passing a plain string to :meth:`_orm.Session.execute`.


 .. change::
     :tags: bug, sql, orm
     :tickets: 5760, 5763, 5765, 5768, 5770

     A wide variety of fixes to the "lambda SQL" feature introduced at
     :ref:`engine_lambda_caching` have been implemented based on user feedback,
     with an emphasis on its use within the :func:`_orm.with_loader_criteria`
     feature where it is most prominently used [ticket:5760]:

     * fixed issue where boolean True/False values referred towards in the
       closure variables of the lambda would cause failures [ticket:5763]

     * Repaired a non-working detection for Python functions embedded in the
       lambda that produce bound values; this case is likely not supportable
       so raises an informative error, where the function should be invoked
       outside the lambda itself.  New documentation has been added to
       further detail this behavior. [ticket:5770]

     * The lambda system by default now rejects the use of non-SQL elements
       within the closure variables of the lambda entirely, where the error
       suggests the two options of either explicitly ignoring closure variables
       that are not SQL parameters, or specifying a specific set of values to be
       considered as part of the cache key based on hash value.   This critically
       prevents the lambda system from assuming that arbitrary objects within
       the lambda's closure are appropriate for caching while also refusing to
       ignore them by default, preventing the case where their state might
       not be constant and have an impact on the SQL construct produced.
       The error message is comprehensive and new documentation has been
       added to further detail this behavior. [ticket:5

---

<sub>🔄 This issue represents a GitHub Pull Request. It cannot be merged through Gitea due to API limitations.</sub>
## 📋 Pull Request Information **Original PR:** https://github.com/jeffknupp/sandman2/pull/212 **Author:** [@pyup-bot](https://github.com/pyup-bot) **Created:** 4/19/2021 **Status:** ❌ Closed **Base:** `master` ← **Head:** `pyup-scheduled-update-2021-04-19` --- ### 📝 Commits (9) - [`c83c953`](https://github.com/jeffknupp/sandman2/commit/c83c953797e973ae57b4e363e0a2801b38135ec0) Update flask-admin from 1.5.7 to 1.5.8 - [`ad59678`](https://github.com/jeffknupp/sandman2/commit/ad59678de879670c6c87e96d6d50d6e062332d67) Update flask-sqlalchemy from 2.4.4 to 2.5.1 - [`43bd40e`](https://github.com/jeffknupp/sandman2/commit/43bd40ee9e90c101659bff374ed17388476a3034) Update sqlalchemy from 1.3.20 to 1.4.9 - [`6cc8175`](https://github.com/jeffknupp/sandman2/commit/6cc817566cbeabfdf450ae67ead272856cd3acef) Update coverage from 5.3 to 5.5 - [`8df0d6a`](https://github.com/jeffknupp/sandman2/commit/8df0d6a64fe3a8246b5018c3a1386f8dff61706e) Update pytest from 6.2.0 to 6.2.3 - [`5909b9b`](https://github.com/jeffknupp/sandman2/commit/5909b9b04cc7ec9a3b8488044aab9c0574313dc4) Update flask-cors from 3.0.9 to 3.0.10 - [`d2dfb2b`](https://github.com/jeffknupp/sandman2/commit/d2dfb2b1f1b7d372d95de429a8774fc0ebf9a651) Update pytest-cov from 2.10.1 to 2.11.1 - [`d497577`](https://github.com/jeffknupp/sandman2/commit/d49757792d15e6eb1c2af24626a250fa92753e19) Update pytest-flask from 1.1.0 to 1.2.0 - [`9d66d5c`](https://github.com/jeffknupp/sandman2/commit/9d66d5cf9be68a718b5040434f3c9b504ea9f411) Update zipp from 3.4.0 to 3.4.1 ### 📊 Changes **1 file changed** (+9 additions, -9 deletions) <details> <summary>View changed files</summary> 📝 `requirements.txt` (+9 -9) </details> ### 📄 Description ### Update [Flask-Admin](https://pypi.org/project/Flask-Admin) from **1.5.7** to **1.5.8**. <details> <summary>Changelog</summary> ### 1.5.8 ``` ----- * SQLAlchemy 1.4.5+ compatibility fixes * Redis CLI fixes ``` </details> <details> <summary>Links</summary> - PyPI: https://pypi.org/project/flask-admin - Changelog: https://pyup.io/changelogs/flask-admin/ - Repo: https://github.com/flask-admin/flask-admin/ - Docs: https://pythonhosted.org/Flask-Admin/ </details> ### Update [Flask-SQLAlchemy](https://pypi.org/project/Flask-SQLAlchemy) from **2.4.4** to **2.5.1**. <details> <summary>Changelog</summary> ### 2.5.1 ``` ------------- Released 2021-03-18 - Fix compatibility with Python 2.7. ``` ### 2.5.0 ``` ------------- Released 2021-03-18 - Update to support SQLAlchemy 1.4. - SQLAlchemy ``URL`` objects are immutable. Some internal methods have changed to return a new URL instead of ``None``. :issue:`885` ``` </details> <details> <summary>Links</summary> - PyPI: https://pypi.org/project/flask-sqlalchemy - Changelog: https://pyup.io/changelogs/flask-sqlalchemy/ - Repo: https://github.com/pallets/flask-sqlalchemy - Docs: https://pythonhosted.org/Flask-SQLAlchemy/ </details> ### Update [SQLAlchemy](https://pypi.org/project/SQLAlchemy) from **1.3.20** to **1.4.9**. <details> <summary>Changelog</summary> ### 1.4.9 ``` :released: April 17, 2021 .. change:: :tags: bug, sql, regression :tickets: 6290 Fixed regression where an empty in statement on a tuple would result in an error when compiled with the option ``literal_binds=True``. .. change:: :tags: bug, regression, orm, performance, sql :tickets: 6304 Fixed a critical performance issue where the traversal of a :func:`_sql.select` construct would traverse a repetitive product of the represented FROM clauses as they were each referred towards by columns in the columns clause; for a series of nested subqueries with lots of columns this could cause a large delay and significant memory growth. This traversal is used by a wide variety of SQL and ORM functions, including by the ORM :class:`_orm.Session` when it&#39;s configured to have &quot;table-per-bind&quot;, which while this is not a common use case, it seems to be what Flask-SQLAlchemy is hardcoded as using, so the issue impacts Flask-SQLAlchemy users. The traversal has been repaired to uniqify on FROM clauses which was effectively what would happen implicitly with the pre-1.4 architecture. .. change:: :tags: bug, postgresql, sql, regression :tickets: 6303 Fixed an argument error in the default and PostgreSQL compilers that would interfere with an UPDATE..FROM or DELETE..FROM..USING statement that was then SELECTed from as a CTE. .. change:: :tags: bug, orm, regression :tickets: 6272 Fixed regression where an attribute that is mapped to a :func:`_orm.synonym` could not be used in column loader options such as :func:`_orm.load_only`. .. change:: :tags: usecase, orm :tickets: 6267 Established support for :func:`_orm.synoynm` in conjunction with hybrid property, assocaitionproxy is set up completely, including that synonyms can be established linking to these constructs which work fully. This is a behavior that was semi-explicitly disallowed previously, however since it did not fail in every scenario, explicit support for assoc proxy and hybrids has been added. .. changelog:: ``` ### 1.4.8 ``` :released: April 15, 2021 .. change:: :tags: change, mypy Updated Mypy plugin to only use the public plugin interface of the semantic analyzer. .. change:: :tags: bug, mssql, regression :tickets: 6265 Fixed an additional regression in the same area as that of :ticket:`6173`, :ticket:`6184`, where using a value of 0 for OFFSET in conjunction with LIMIT with SQL Server would create a statement using &quot;TOP&quot;, as was the behavior in 1.3, however due to caching would then fail to respond accordingly to other values of OFFSET. If the &quot;0&quot; wasn&#39;t first, then it would be fine. For the fix, the &quot;TOP&quot; syntax is now only emitted if the OFFSET value is omitted entirely, that is, :meth:`_sql.Select.offset` is not used. Note that this change now requires that if the &quot;with_ties&quot; or &quot;percent&quot; modifiers are used, the statement can&#39;t specify an OFFSET of zero, it now needs to be omitted entirely. .. change:: :tags: bug, engine The :meth:`_engine.Dialect.has_table` method now raises an informative exception if a non-Connection is passed to it, as this incorrect behavior seems to be common. This method is not intended for external use outside of a dialect. Please use the :meth:`.Inspector.has_table` method or for cross-compatibility with older SQLAlchemy versions, the :meth:`_engine.Engine.has_table` method. .. change:: :tags: bug, regression, sql :tickets: 6249 Fixed regression where the :class:`_sql.BindParameter` object would not properly render for an IN expression (i.e. using the &quot;post compile&quot; feature in 1.4) if the object were copied from either an internal cloning operation, or from a pickle operation, and the parameter name contained spaces or other special characters. .. change:: :tags: bug, mypy :tickets: 6205 Revised the fix for ``OrderingList`` from version 1.4.7 which was testing against the incorrect API. .. change:: :tags: bug, asyncio :tickets: 6220 Fix typo that prevented setting the ``bind`` attribute of an :class:`_asyncio.AsyncSession` to the correct value. .. change:: :tags: feature, sql :tickets: 3314 The tuple returned by :attr:`.CursorResult.inserted_primary_key` is now a :class:`_result.Row` object with a named tuple interface on top of the existing tuple interface. .. change:: :tags: bug, regression, sql, sqlite :tickets: 6254 Fixed regression where the introduction of the INSERT syntax &quot;INSERT... VALUES (DEFAULT)&quot; was not supported on some backends that do however support &quot;INSERT..DEFAULT VALUES&quot;, including SQLite. The two syntaxes are now each individually supported or non-supported for each dialect, for example MySQL supports &quot;VALUES (DEFAULT)&quot; but not &quot;DEFAULT VALUES&quot;. Support for Oracle has also been enabled. .. change:: :tags: bug, regression, orm :tickets: 6259 Fixed a cache leak involving the :func:`_orm.with_expression` loader option, where the given SQL expression would not be correctly considered as part of the cache key. Additionally, fixed regression involving the corresponding :func:`_orm.query_expression` feature. While the bug technically exists in 1.3 as well, it was not exposed until 1.4. The &quot;default expr&quot; value of ``null()`` would be rendered when not needed, and additionally was also not adapted correctly when the ORM rewrites statements such as when using joined eager loading. The fix ensures &quot;singleton&quot; expressions like ``NULL`` and ``true`` aren&#39;t &quot;adapted&quot; to refer to columns in ORM statements, and additionally ensures that a :func:`_orm.query_expression` with no default expression doesn&#39;t render in the statement if a :func:`_orm.with_expression` isn&#39;t used. .. change:: :tags: bug, orm :tickets: 6252 Fixed issue in the new feature of :meth:`_orm.Session.refresh` introduced by :ticket:`1763` where eagerly loaded relationships are also refreshed, where the ``lazy=&quot;raise&quot;`` and ``lazy=&quot;raise_on_sql&quot;`` loader strategies would interfere with the :func:`_orm.immediateload` loader strategy, thus breaking the feature for relationships that were loaded with :func:`_orm.selectinload`, :func:`_orm.subqueryload` as well. .. changelog:: ``` ### 1.4.7 ``` :released: April 9, 2021 .. change:: :tags: bug, sql, regression :tickets: 6222 Enhanced the &quot;expanding&quot; feature used for :meth:`_sql.ColumnOperators.in_` operations to infer the type of expression from the right hand list of elements, if the left hand side does not have any explicit type set up. This allows the expression to support stringification among other things. In 1.3, &quot;expanding&quot; was not automatically used for :meth:`_sql.ColumnOperators.in_` expressions, so in that sense this change fixes a behavioral regression. .. change:: :tags: bug, mypy Fixed issue in Mypy plugin where the plugin wasn’t inferring the correct type for columns of subclasses that don’t directly descend from ``TypeEngine``, in particular that of ``TypeDecorator`` and ``UserDefinedType``. .. change:: :tags: bug, orm, regression :tickets: 6221 Fixed regression where the :func:`_orm.subqueryload` loader strategy would fail to correctly accommodate sub-options, such as a :func:`_orm.defer` option on a column, if the &quot;path&quot; of the subqueryload were more than one level deep. .. change:: :tags: bug, sql Fixed the &quot;stringify&quot; compiler to support a basic stringification of a &quot;multirow&quot; INSERT statement, i.e. one with multiple tuples following the VALUES keyword. .. change:: :tags: bug, orm, regression :tickets: 6211 Fixed regression where the :func:`_orm.merge_frozen_result` function relied upon by the dogpile.caching example was not included in tests and began failing due to incorrect internal arguments. .. change:: :tags: bug, engine, regression :tickets: 6218 Fixed up the behavior of the :class:`_result.Row` object when dictionary access is used upon it, meaning converting to a dict via ``dict(row)`` or accessing members using strings or other objects i.e. ``row[&quot;some_key&quot;]`` works as it would with a dictionary, rather than raising ``TypeError`` as would be the case with a tuple, whether or not the C extensions are in place. This was originally supposed to emit a 2.0 deprecation warning for the &quot;non-future&quot; case using :class:`_result.LegacyRow`, and was to raise ``TypeError`` for the &quot;future&quot; :class:`_result.Row` class. However, the C version of :class:`_result.Row` was failing to raise this ``TypeError``, and to complicate matters, the :meth:`_orm.Session.execute` method now returns :class:`_result.Row` in all cases to maintain consistency with the ORM result case, so users who didn&#39;t have C extensions installed would see different behavior in this one case for existing pre-1.4 style code. Therefore, in order to soften the overall upgrade scheme as most users have not been exposed to the more strict behavior of :class:`_result.Row` up through 1.4.6, :class:`_result.LegacyRow` and :class:`_result.Row` both provide for string-key access as well as support for ``dict(row)``, in all cases emitting the 2.0 deprecation warning when ``SQLALCHEMY_WARN_20`` is enabled. The :class:`_result.Row` object still uses tuple-like behavior for ``__contains__``, which is probably the only noticeable behavioral change compared to :class:`_result.LegacyRow`, other than the removal of dictionary-style methods ``values()`` and ``items()``. .. change:: :tags: bug, regression, orm :tickets: 6233 Fixed critical regression where the :class:`_orm.Session` could fail to &quot;autobegin&quot; a new transaction when a flush occurred without an existing transaction in place, implicitly placing the :class:`_orm.Session` into legacy autocommit mode which commit the transaction. The :class:`_orm.Session` now has a check that will prevent this condition from occurring, in addition to repairing the flush issue. Additionally, scaled back part of the change made as part of :ticket:`5226` which can run autoflush during an unexpire operation, to not actually do this in the case of a :class:`_orm.Session` using legacy :paramref:`_orm.Session.autocommit` mode, as this incurs a commit within a refresh operation. .. change:: :tags: change, tests Added a new flag to :class:`.DefaultDialect` called ``supports_schemas``; third party dialects may set this flag to ``False`` to disable SQLAlchemy&#39;s schema-level tests when running the test suite for a third party dialect. .. change:: :tags: bug, regression, schema :tickets: 6216 Fixed regression where usage of a token in the :paramref:`_engine.Connection.execution_options.schema_translate_map` dictionary which contained special characters such as braces would fail to be substituted properly. Use of square bracket characters ``[]`` is now explicitly disallowed as these are used as a delimiter character in the current implementation. .. change:: :tags: bug, regression, orm :tickets: 6215 Fixed regression where the ORM compilation scheme would assume the function name of a hybrid property would be the same as the attribute name in such a way that an ``AttributeError`` would be raised, when it would attempt to determine the correct name for each element in a result tuple. A similar issue exists in 1.3 but only impacts the names of tuple rows. The fix here adds a check that the hybrid&#39;s function name is actually present in the ``__dict__`` of the class or its superclasses before assigning this name; otherwise, the hybrid is considered to be &quot;unnamed&quot; and ORM result tuples will use the naming scheme of the underlying expression. .. change:: :tags: bug, orm, regression :tickets: 6232 Fixed critical regression caused by the new feature added as part of :ticket:`1763`, eager loaders are invoked on unexpire operations. The new feature makes use of the &quot;immediateload&quot; eager loader strategy as a substitute for a collection loading strategy, which unlike the other &quot;post-load&quot; strategies was not accommodating for recursive invocations between mutually-dependent relationships, leading to recursion overflow errors. .. changelog:: ``` ### 1.4.6 ``` :released: April 6, 2021 .. change:: :tags: bug, sql, regression, oracle, mssql :tickets: 6202 Fixed further regressions in the same area as that of :ticket:`6173` released in 1.4.5, where a &quot;postcompile&quot; parameter, again most typically those used for LIMIT/OFFSET rendering in Oracle and SQL Server, would fail to be processed correctly if the same parameter rendered in multiple places in the statement. .. change:: :tags: bug, orm, regression :tickets: 6203 Fixed regression where a deprecated form of :meth:`_orm.Query.join` were used, passing a series of entities to join from without any ON clause in a single :meth:`_orm.Query.join` call, would fail to function correctly. .. change:: :tags: bug, mypy :tickets: 6147 Applied a series of refactorings and fixes to accommodate for Mypy &quot;incremental&quot; mode across multiple files, which previously was not taken into account. In this mode the Mypy plugin has to accommodate Python datatypes expressed in other files coming in with less information than they have on a direct run. Additionally, a new decorator :func:`_orm.declarative_mixin` is added, which is necessary for the Mypy plugin to be able to definifitely identify a Declarative mixin class that is otherwise not used inside a particular Python file. .. seealso:: :ref:`mypy_declarative_mixins` .. change:: :tags: bug, mypy :tickets: 6205 Fixed issue where the Mypy plugin would fail to interpret the &quot;collection_class&quot; of a relationship if it were a callable and not a class. Also improved type matching and error reporting for collection-oriented relationships. .. change:: :tags: bug, sql :tickets: 6204 Executing a :class:`_sql.Subquery` using :meth:`_engine.Connection.execute` is deprecated and will emit a deprecation warning; this use case was an oversight that should have been removed from 1.4. The operation will now execute the underlying :class:`_sql.Select` object directly for backwards compatibility. Similarly, the :class:`_sql.CTE` class is also not appropriate for execution. In 1.3, attempting to execute a CTE would result in an invalid &quot;blank&quot; SQL statement being executed; since this use case was not working it now raises :class:`_exc.ObjectNotExecutableError`. Previously, 1.4 was attempting to execute the CTE as a statement however it was working only erratically. .. change:: :tags: bug, regression, orm :tickets: 6206 Fixed critical regression where the :meth:`_orm.Query.yield_per` method in the ORM would set up the internal :class:`_engine.Result` to yield chunks at a time, however made use of the new :meth:`_engine.Result.unique` method which uniques across the entire result. This would lead to lost rows since the ORM is using ``id(obj)`` as the uniquing function, which leads to repeated identifiers for new objects as already-seen objects are garbage collected. 1.3&#39;s behavior here was to &quot;unique&quot; across each chunk, which does not actually produce &quot;uniqued&quot; results when results are yielded in chunks. As the :meth:`_orm.Query.yield_per` method is already explicitly disallowed when joined eager loading is in place, which is the primary rationale for the &quot;uniquing&quot; feature, the &quot;uniquing&quot; feature is now turned off entirely when :meth:`_orm.Query.yield_per` is used. This regression only applies to the legacy :class:`_orm.Query` object; when using :term:`2.0 style` execution, &quot;uniquing&quot; is not automatically applied. To prevent the issue from arising from explicit use of :meth:`_engine.Result.unique`, an error is now raised if rows are fetched from a &quot;uniqued&quot; ORM-level :class:`_engine.Result` if any :ref:`yield per &lt;orm_queryguide_yield_per&gt;` API is also in use, as the purpose of ``yield_per`` is to allow for arbitrarily large numbers of rows, which cannot be uniqued in memory without growing the number of entries to fit the complete result size. .. change:: :tags: usecase, asyncio, postgresql :tickets: 6199 Added accessors ``.sqlstate`` and synonym ``.pgcode`` to the ``.orig`` attribute of the SQLAlchemy exception class raised by the asyncpg DBAPI adapter, that is, the intermediary exception object that wraps on top of that raised by the asyncpg library itself, but below the level of the SQLAlchemy dialect. .. changelog:: ``` ### 1.4.5 ``` :released: April 2, 2021 .. change:: :tags: bug, sql, postgresql :tickets: 6183 Fixed bug in new :meth:`_functions.FunctionElement.render_derived` feature where column names rendered out explicitly in the alias SQL would not have proper quoting applied for case sensitive names and other non-alphanumeric names. .. change:: :tags: bug, regression, orm :tickets: 6172 Fixed regression where the :func:`_orm.joinedload` loader strategy would not successfully joinedload to a mapper that is mapper against a :class:`.CTE` construct. .. change:: :tags: bug, regression, sql :tickets: 6181 Fixed regression where use of the :meth:`.Operators.in_` method with a :class:`_sql.Select` object against a non-table-bound column would produce an ``AttributeError``, or more generally using a :class:`_sql.ScalarSelect` that has no datatype in a binary expression would produce invalid state. .. change:: :tags: bug, mypy :tickets: sqlalchemy/sqlalchemy2-stubs/14 Fixed issue in mypy plugin where newly added support for :func:`_orm.as_declarative` needed to more fully add the ``DeclarativeMeta`` class to the mypy interpreter&#39;s state so that it does not result in a name not found error; additionally improves how global names are setup for the plugin including the ``Mapped`` name. .. change:: :tags: bug, mysql, regression :tickets: 6163 Fixed regression in the MySQL dialect where the reflection query used to detect if a table exists would fail on very old MySQL 5.0 and 5.1 versions. .. change:: :tags: bug, sql :tickets: 6184 Added a new flag to the :class:`_engine.Dialect` class called :attr:`_engine.Dialect.supports_statement_cache`. This flag now needs to be present directly on a dialect class in order for SQLAlchemy&#39;s :ref:`query cache &lt;sql_caching&gt;` to take effect for that dialect. The rationale is based on discovered issues such as :ticket:`6173` revealing that dialects which hardcode literal values from the compiled statement, often the numerical parameters used for LIMIT / OFFSET, will not be compatible with caching until these dialects are revised to use the parameters present in the statement only. For third party dialects where this flag is not applied, the SQL logging will show the message &quot;dialect does not support caching&quot;, indicating the dialect should seek to apply this flag once they have verified that no per-statement literal values are being rendered within the compilation phase. .. seealso:: :ref:`engine_thirdparty_caching` .. change:: :tags: bug, postgresql :tickets: 6099 Fixed typo in the fix for :ticket:`6099` released in 1.4.4 that completely prevented this change from working correctly, i.e. the error message did not match what was actually emitted by pg8000. .. change:: :tags: bug, orm, regression :tickets: 6171 Scaled back the warning message added in :ticket:`5171` to not warn for overlapping columns in an inheritance scenario where a particular relationship is local to a subclass and therefore does not represent an overlap. .. change:: :tags: bug, regression, oracle :tickets: 6173 Fixed critical regression where the Oracle compiler would not maintain the correct parameter values in the LIMIT/OFFSET for a select due to a caching issue. .. change:: :tags: bug, postgresql :tickets: 6170 Fixed issue where the PostgreSQL :class:`.PGInspector`, when generated against an :class:`_engine.Engine`, would fail for ``.get_enums()``, ``.get_view_names()``, ``.get_foreign_table_names()`` and ``.get_table_oid()`` when used against a &quot;future&quot; style engine and not the connection directly. .. change:: :tags: bug, schema :tickets: 6146 Introduce a new parameter :paramref:`_types.Enum.omit_aliases` in :class:`_types.Enum` type allow filtering aliases when using a pep435 Enum. Previous versions of SQLAlchemy kept aliases in all cases, creating database enum type with additional states, meaning that they were treated as different values in the db. For backward compatibility this flag defaults to ``False`` in the 1.4 series, but will be switched to ``True`` in a future version. A deprecation warning is raise if this flag is not specified and the passed enum contains aliases. .. change:: :tags: bug, mssql :tickets: 6163 Fixed a regression in MSSQL 2012+ that prevented the order by clause to be rendered when ``offset=0`` is used in a subquery. .. change:: :tags: bug, asyncio :tickets: 6166 Fixed issue where the asyncio extension could not be loaded if running Python 3.6 with the backport library of ``contextvars`` installed. .. changelog:: ``` ### 1.4.4 ``` :released: March 30, 2021 .. change:: :tags: bug, misc Adjusted the usage of the ``importlib_metadata`` library for loading setuptools entrypoints in order to accommodate for some deprecation changes. .. change:: :tags: bug, postgresql :tickets: 6099 Modified the ``is_disconnect()`` handler for the pg8000 dialect, which now accommodates for a new ``InterfaceError`` emitted by pg8000 1.19.0. Pull request courtesy Hamdi Burak Usul. .. change:: :tags: bug, orm :tickets: 6139 Fixed critical issue in the new :meth:`_orm.PropComparator.and_` feature where loader strategies that emit secondary SELECT statements such as :func:`_orm.selectinload` and :func:`_orm.lazyload` would fail to accommodate for bound parameters in the user-defined criteria in terms of the current statement being executed, as opposed to the cached statement, causing stale bound values to be used. This also adds a warning for the case where an object that uses :func:`_orm.lazyload` in conjunction with :meth:`_orm.PropComparator.and_` is attempted to be serialized; the loader criteria cannot reliably be serialized and deserialized and eager loading should be used for this case. .. change:: :tags: bug, engine :tickets: 6138 Repair wrong arguments to exception handling method in CursorResult. .. change:: :tags: bug, regression, orm :tickets: 6144 Fixed missing method :meth:`_orm.Session.get` from the :class:`_orm.ScopedSession` interface. .. change:: :tags: usecase, engine :tickets: 6155 Modified the context manager used by :class:`_engine.Transaction` so that an &quot;already detached&quot; warning is not emitted by the ending of the context manager itself, if the transaction were already manually rolled back inside the block. This applies to regular transactions, savepoint transactions, and legacy &quot;marker&quot; transactions. A warning is still emitted if the ``.rollback()`` method is called explicitly more than once. .. changelog:: ``` ### 1.4.3 ``` :released: March 25, 2021 .. change:: :tags: bug, orm :tickets: 6069 Fixed a bug where python 2.7.5 (default on CentOS 7) wasn&#39;t able to import sqlalchemy, because on this version of Python ``exec &quot;statement&quot;`` and ``exec(&quot;statement&quot;)`` do not behave the same way. The compatibility ``exec_()`` function was used instead. .. change:: :tags: sqlite, feature, asyncio :tickets: 5920 Added support for the aiosqlite database driver for use with the SQLAlchemy asyncio extension. .. seealso:: :ref:`aiosqlite` .. change:: :tags: bug, regression, orm, declarative :tickets: 6128 Fixed regression where the ``.metadata`` attribute on a per class level would not be honored, breaking the use case of per-class-hierarchy :class:`.schema.MetaData` for abstract declarative classes and mixins. .. seealso:: :ref:`declarative_metadata` .. change:: :tags: bug, mypy Added support for the Mypy extension to correctly interpret a declarative base class that&#39;s generated using the :func:`_orm.as_declarative` function as well as the :meth:`_orm.registry.as_declarative_base` method. .. change:: :tags: bug, mypy :tickets: 6109 Fixed bug in Mypy plugin where the Python type detection for the :class:`_types.Boolean` column type would produce an exception; additionally implemented support for :class:`_types.Enum`, including detection of a string-based enum vs. use of Python ``enum.Enum``. .. change:: :tags: bug, reflection, postgresql :tickets: 6129 Fixed reflection of identity columns in tables with mixed case names in PostgreSQL. .. change:: :tags: bug, sqlite, regression :tickets: 5848 Repaired the ``pysqlcipher`` dialect to connect correctly which had regressed in 1.4, and added test + CI support to maintain the driver in working condition. The dialect now imports the ``sqlcipher3`` module for Python 3 by default before falling back to ``pysqlcipher3`` which is documented as now being unmaintained. .. seealso:: :ref:`pysqlcipher` .. change:: :tags: bug, orm :tickets: 6060 Fixed bug where ORM queries using a correlated subquery in conjunction with :func:`_orm.column_property` would fail to correlate correctly to an enclosing subquery or to a CTE when :meth:`_sql.Select.correlate_except` were used in the property to control correlation, in cases where the subquery contained the same selectables as ones within the correlated subquery that were intended to not be correlated. .. change:: :tags: bug, orm :tickets: 6131 Fixed bug where combinations of the new &quot;relationship with criteria&quot; feature could fail in conjunction with features that make use of the new &quot;lambda SQL&quot; feature, including loader strategies such as selectinload and lazyload, for more complicated scenarios such as polymorphic loading. .. change:: :tags: bug, orm :tickets: 6124 Repaired support so that the :meth:`_sql.ClauseElement.params` method can work correctly with a :class:`_sql.Select` object that includes joins across ORM relationship structures, which is a new feature in 1.4. .. change:: :tags: bug, engine, regression :tickets: 6119 Restored the :class:`_engine.ResultProxy` name back to the ``sqlalchemy.engine`` namespace. This name refers to the :class:`_engine.LegacyCursorResult` object. .. change:: :tags: bug, orm :tickets: 6115 Fixed issue where a &quot;removed in 2.0&quot; warning were generated internally by the relationship loader mechanics. .. changelog:: ``` ### 1.4.2 ``` :released: March 19, 2021 .. change:: :tags: bug, orm, dataclasses :tickets: 6093 Fixed issue in new ORM dataclasses functionality where dataclass fields on an abstract base or mixin that contained column or other mapping constructs would not be mapped if they also included a &quot;default&quot; key within the dataclasses.field() object. .. change:: :tags: bug, regression, orm :tickets: 6088 Fixed regression where the :attr:`_orm.Query.selectable` accessor, which is a synonym for :meth:`_orm.Query.__clause_element__`, got removed, it&#39;s now restored. .. change:: :tags: bug, engine, regression Restored top level import for ``sqlalchemy.engine.reflection``. This ensures that the base :class:`_reflection.Inspector` class is properly registered so that :func:`_sa.inspect` works for third party dialects that don&#39;t otherwise import this package. .. change:: :tags: bug, regression, orm :tickets: 6086 Fixed regression where use of an unnamed SQL expression such as a SQL function would raise a column targeting error if the query itself were using joinedload for an entity and was also being wrapped in a subquery by the joinedload eager loading process. .. change:: :tags: bug, orm, regression :tickets: 6092 Fixed regression where the :meth:`_orm.Query.filter_by` method would fail to locate the correct source entity if the :meth:`_orm.Query.join` method had been used targeting an entity without any kind of ON clause. .. change:: :tags: postgresql, usecase :tickets: 6982 Rename the column name used by a reflection query that used a reserved word in some postgresql compatible databases. .. change:: :tags: usecase, orm, dataclasses :tickets: 6100 Added support for the :class:`_orm.declared_attr` object to work in the context of dataclass fields. .. seealso:: :ref:`orm_declarative_dataclasses_mixin` .. change:: :tags: bug, sql, regression :tickets: 6101 Fixed issue where using a ``func`` that includes dotted packagenames would fail to be cacheable by the SQL caching system due to a Python list of names that needed to be a tuple. .. change:: :tags: bug, regression, orm :tickets: 6095 Fixed regression where the SQL compilation of a :class:`.Function` would not work correctly if the object had been &quot;annotated&quot;, which is an internal memoization process used mostly by the ORM. In particular it could affect ORM lazy loads which make greater use of this feature in 1.4. .. change:: :tags: bug, sql, regression :tickets: 6097 Fixed regression in the :func:`_sql.case` construct, where the &quot;dictionary&quot; form of argument specification failed to work correctly if it were passed positionally, rather than as a &quot;whens&quot; keyword argument. .. change:: :tags: bug, orm :tickets: 6090 Fixed regression where the :class:`.ConcreteBase` would fail to map at all when a mapped column name overlapped with the discriminator column name, producing an assertion error. The use case here did not function correctly in 1.3 as the polymorphic union would produce a query that ignored the discriminator column entirely, while emitting duplicate column warnings. As 1.4&#39;s architecture cannot easily reproduce this essentially broken behavior of 1.3 at the ``select()`` level right now, the use case now raises an informative error message instructing the user to use the ``.ConcreteBase._concrete_discriminator_name`` attribute to resolve the conflict. To assist with this configuration, ``.ConcreteBase._concrete_discriminator_name`` may be placed on the base class only where it will be automatically used by subclasses; previously this was not the case. .. change:: :tags: bug, mypy :tickets: sqlalchemy/sqlalchemy2-stubs/2 Fixed issue in MyPy extension which crashed on detecting the type of a :class:`.Column` if the type were given with a module prefix like ``sa.Integer()``. .. changelog:: ``` ### 1.4.1 ``` :released: March 17, 2021 .. change:: :tags: bug, orm, regression :tickets: 6066 Fixed regression where producing a Core expression construct such as :func:`_sql.select` using ORM entities would eagerly configure the mappers, in an effort to maintain compatibility with the :class:`_orm.Query` object which necessarily does this to support many backref-related legacy cases. However, core :func:`_sql.select` constructs are also used in mapper configurations and such, and to that degree this eager configuration is more of an inconvenience, so eager configure has been disabled for the :func:`_sql.select` and other Core constructs in the absence of ORM loading types of functions such as :class:`_orm.Load`. The change maintains the behavior of :class:`_orm.Query` so that backwards compatibility is maintained. However, when using a :func:`_sql.select` in conjunction with ORM entities, a &quot;backref&quot; that isn&#39;t explicitly placed on one of the classes until mapper configure time won&#39;t be available unless :func:`_orm.configure_mappers` or the newer :func:`_orm.registry.configure` has been called elsewhere. Prefer using :paramref:`_orm.relationship.back_populates` for more explicit relationship configuration which does not have the eager configure requirement. .. change:: :tags: bug, mssql, regression :tickets: 6058 Fixed regression where a new setinputsizes() API that&#39;s available for pyodbc was enabled, which is apparently incompatible with pyodbc&#39;s fast_executemany() mode in the absence of more accurate typing information, which as of yet is not fully implemented or tested. The pyodbc dialect and connector has been modified so that setinputsizes() is not used at all unless the parameter ``use_setinputsizes`` is passed to the dialect, e.g. via :func:`_sa.create_engine`, at which point its behavior can be customized using the :meth:`.DialectEvents.do_setinputsizes` hook. .. seealso:: :ref:`mssql_pyodbc_setinputsizes` .. change:: :tags: bug, orm, regression :tickets: 6055 Fixed a critical regression in the relationship lazy loader where the SQL criteria used to fetch a related many-to-one object could go stale in relation to other memoized structures within the loader if the mapper had configuration changes, such as can occur when mappers are late configured or configured on demand, producing a comparison to None and returning no object. Huge thanks to Alan Hamlett for their help tracking this down late into the night. .. change:: :tags: bug, regression :tickets: 6068 Added back ``items`` and ``values`` to ``ColumnCollection`` class. The regression was introduced while adding support for duplicate columns in from clauses and selectable in ticket 4753. .. change:: :tags: bug, engine, regression :tickets: 6074 The Python ``namedtuple()`` has the behavior such that the names ``count`` and ``index`` will be served as tuple values if the named tuple includes those names; if they are absent, then their behavior as methods of ``collections.abc.Sequence`` is maintained. Therefore the :class:`_result.Row` and :class:`_result.LegacyRow` classes have been fixed so that they work in this same way, maintaining the expected behavior for database rows that have columns named &quot;index&quot; or &quot;count&quot;. .. change:: :tags: bug, orm, regression :tickets: 6076 Fixed regression where the :meth:`_orm.Query.exists` method would fail to create an expression if the entity list of the :class:`_orm.Query` were an arbitrary SQL column expression. .. change:: :tags: bug, orm, regression :tickets: 6052 Fixed regression where calling upon :meth:`_orm.Query.count` in conjunction with a loader option such as :func:`_orm.joinedload` would fail to ignore the loader option. This is a behavior that has always been very specific to the :meth:`_orm.Query.count` method; an error is normally raised if a given :class:`_orm.Query` has options that don&#39;t apply to what it is returning. .. change:: :tags: bug, orm, declarative, regression :tickets: 6054 Fixed bug where user-mapped classes that contained an attribute named &quot;registry&quot; would cause conflicts with the new registry-based mapping system when using :class:`.DeclarativeMeta`. While the attribute remains something that can be set explicitly on a declarative base to be consumed by the metaclass, once located it is placed under a private class variable so it does not conflict with future subclasses that use the same name for other purposes. .. change:: :tags: bug, orm, regression :tickets: 6067 Fixed regression in :meth:`_orm.Session.identity_key`, including that the method and related methods were not covered by any unit test as well as that the method contained a typo preventing it from functioning correctly. .. changelog:: ``` ### 1.4.0 ``` :released: March 15, 2021 .. change:: :tags: bug, mssql :tickets: 5919 Fix a reflection error for MSSQL 2005 introduced by the reflection of filtered indexes. .. change:: :tags: feature, mypy :tickets: 4609 Rudimentary and experimental support for Mypy has been added in the form of a new plugin, which itself depends on new typing stubs for SQLAlchemy. The plugin allows declarative mappings in their standard form to both be compatible with Mypy as well as to provide typing support for mapped classes and instances. .. seealso:: :ref:`mypy_toplevel` .. change:: :tags: bug, sql :tickets: 6016 Fixed bug where the &quot;percent escaping&quot; feature that occurs with dialects that use the &quot;format&quot; or &quot;pyformat&quot; bound parameter styles was not enabled for the :meth:`_sql.Operators.op` and :class:`_sql.custom_op` constructs, for custom operators that use percent signs. The percent sign will now be automatically doubled based on the paramstyle as necessary. .. change:: :tags: bug, regression, sql :tickets: 5979 Fixed regression where the &quot;unsupported compilation error&quot; for unknown datatypes would fail to raise correctly. .. change:: :tags: ext, usecase :tickets: 5942 Add new parameter :paramref:`_automap.AutomapBase.prepare.reflection_options` to allow passing of :meth:`_schema.MetaData.reflect` options like ``only`` or dialect-specific reflection options like ``oracle_resolve_synonyms``. .. change:: :tags: change, sql Altered the compilation for the :class:`.CTE` construct so that a string is returned representing the inner SELECT statement if the :class:`.CTE` is stringified directly, outside of the context of an enclosing SELECT; This is the same behavior of :meth:`_sql.FromClause.alias` and :meth:`_sql.Select.subquery`. Previously, a blank string would be returned as the CTE is normally placed above a SELECT after that SELECT has been generated, which is generally misleading when debugging. .. change:: :tags: bug, orm :tickets: 5981 Fixed regression where the :paramref:`_orm.relationship.query_class` parameter stopped being functional for &quot;dynamic&quot; relationships. The ``AppenderQuery`` remains dependent on the legacy :class:`_orm.Query` class; users are encouraged to migrate from the use of &quot;dynamic&quot; relationships to using :func:`_orm.with_parent` instead. .. change:: :tags: bug, orm, regression :tickets: 6003 Fixed regression where :meth:`_orm.Query.join` would produce no effect if the query itself as well as the join target were against a :class:`_schema.Table` object, rather than a mapped class. This was part of a more systemic issue where the legacy ORM query compiler would not be correctly used from a :class:`_orm.Query` if the statement produced had not ORM entities present within it. .. change:: :tags: bug, regression, sql :tickets: 6008 Fixed regression where usage of the standalone :func:`_sql.distinct()` used in the form of being directly SELECTed would fail to be locatable in the result set by column identity, which is how the ORM locates columns. While standalone :func:`_sql.distinct()` is not oriented towards being directly SELECTed (use :meth:`_sql.select.distinct` for a regular ``SELECT DISTINCT..``) , it was usable to a limited extent in this way previously (but wouldn&#39;t work in subqueries, for example). The column targeting for unary expressions such as &quot;DISTINCT &lt;col&gt;&quot; has been improved so that this case works again, and an additional improvement has been made so that usage of this form in a subquery at least generates valid SQL which was not the case previously. The change additionally enhances the ability to target elements in ``row._mapping`` based on SQL expression objects in ORM-enabled SELECT statements, including whether the statement was invoked by ``connection.execute()`` or ``session.execute()``. .. change:: :tags: bug, orm, asyncio :tickets: 5998 The API for :meth:`_asyncio.AsyncSession.delete` is now an awaitable; this method cascades along relationships which must be loaded in a similar manner as the :meth:`_asyncio.AsyncSession.merge` method. .. change:: :tags: usecase, postgresql, mysql, asyncio :tickets: 5967 Added an ``asyncio.Lock()`` within SQLAlchemy&#39;s emulated DBAPI cursor, local to the connection, for the asyncpg and aiomysql dialects for the scope of the ``cursor.execute()`` and ``cursor.executemany()`` methods. The rationale is to prevent failures and corruption for the case where the connection is used in multiple awaitables at once. While this use case can also occur with threaded code and non-asyncio dialects, we anticipate this kind of use will be more common under asyncio, as the asyncio API is encouraging of such use. It&#39;s definitely better to use a distinct connection per concurrent awaitable however as concurrency will not be achieved otherwise. For the asyncpg dialect, this is so that the space between the call to ``prepare()`` and ``fetch()`` is prevented from allowing concurrent executions on the connection from causing interface error exceptions, as well as preventing race conditions when starting a new transaction. Other PostgreSQL DBAPIs are threadsafe at the connection level so this intends to provide a similar behavior, outside the realm of server side cursors. For the aiomysql dialect, the mutex will provide safety such that the statement execution and the result set fetch, which are two distinct steps at the connection level, won&#39;t get corrupted by concurrent executions on the same connection. .. change:: :tags: bug, engine :tickets: 6002 Improved engine logging to note ROLLBACK and COMMIT which is logged while the DBAPI driver is in AUTOCOMMIT mode. These ROLLBACK/COMMIT are library level and do not have any effect when AUTOCOMMIT is in effect, however it&#39;s still worthwhile to log as these indicate where SQLAlchemy sees the &quot;transaction&quot; demarcation. .. change:: :tags: bug, regression, engine :tickets: 6004 Fixed a regression where the &quot;reset agent&quot; of the connection pool wasn&#39;t really being utilized by the :class:`_engine.Connection` when it were closed, and also leading to a double-rollback scenario that was somewhat wasteful. The newer architecture of the engine has been updated so that the connection pool &quot;reset-on-return&quot; logic will be skipped when the :class:`_engine.Connection` explicitly closes out the transaction before returning the pool to the connection. .. change:: :tags: bug, schema :tickets: 5953 Deprecated all schema-level ``.copy()`` methods and renamed to ``_copy()``. These are not standard Python &quot;copy()&quot; methods as they typically rely upon being instantiated within particular contexts which are passed to the method as optional keyword arguments. The :meth:`_schema.Table.tometadata` method is the public API that provides copying for :class:`_schema.Table` objects. .. change:: :tags: bug, ext :tickets: 6020 The ``sqlalchemy.ext.mutable`` extension now tracks the &quot;parents&quot; collection using the :class:`.InstanceState` associated with objects, rather than the object itself. The latter approach required that the object be hashable so that it can be inside of a ``WeakKeyDictionary``, which goes against the behavioral contract of the ORM overall which is that ORM mapped objects do not need to provide any particular kind of ``__hash__()`` method and that unhashable objects are supported. .. change:: :tags: bug, orm :tickets: 5984 The unit of work process now turns off all &quot;lazy=&#39;raise&#39;&quot; behavior altogether when a flush is proceeding. While there are areas where the UOW is sometimes loading things that aren&#39;t ultimately needed, the lazy=&quot;raise&quot; strategy is not helpful here as the user often does not have much control or visibility into the flush process. .. changelog:: ``` ### 1.4.0b3 ``` :released: March 15, 2021 :released: February 15, 2021 .. change:: :tags: bug, orm :tickets: 5933 Fixed issue in new 1.4/2.0 style ORM queries where a statement-level label style would not be preserved in the keys used by result rows; this has been applied to all combinations of Core/ORM columns / session vs. connection etc. so that the linkage from statement to result row is the same in all cases. As part of this change, the labeling of column expressions in rows has been improved to retain the original name of the ORM attribute even if used in a subquery. .. change:: :tags: bug, sql :tickets: 5924 Fixed bug where the &quot;cartesian product&quot; assertion was not correctly accommodating for joins between tables that relied upon the use of LATERAL to connect from a subquery to another subquery in the enclosing context. .. change:: :tags: bug, sql :tickets: 5934 Fixed 1.4 regression where the :meth:`_functions.Function.in_` method was not covered by tests and failed to function properly in all cases. .. change:: :tags: bug, engine, postgresql :tickets: 5941 Continued with the improvement made as part of :ticket:`5653` to further support bound parameter names, including those generated against column names, for names that include colons, parenthesis, and question marks, as well as improved test support, so that bound parameter names even if they are auto-derived from column names should have no problem including for parenthesis in psycopg2&#39;s &quot;pyformat&quot; style. As part of this change, the format used by the asyncpg DBAPI adapter (which is local to SQLAlchemy&#39;s asyncpg dialect) has been changed from using &quot;qmark&quot; paramstyle to &quot;format&quot;, as there is a standard and internally supported SQL string escaping style for names that use percent signs with &quot;format&quot; style (i.e. to double percent signs), as opposed to names that use question marks with &quot;qmark&quot; style (where an escaping system is not defined by pep-249 or Python). .. seealso:: :ref:`change_5941` .. change:: :tags: sql, usecase, postgresql, sqlite :tickets: 5939 Enhance ``set_`` keyword of :class:`.OnConflictDoUpdate` to accept a :class:`.ColumnCollection`, such as the ``.c.`` collection from a :class:`Selectable`, or the ``.excluded`` contextual object. .. change:: :tags: feature, orm The ORM used in :term:`2.0 style` can now return ORM objects from the rows returned by an UPDATE..RETURNING or INSERT..RETURNING statement, by supplying the construct to :meth:`_sql.Select.from_statement` in an ORM context. .. seealso:: :ref:`orm_dml_returning_objects` .. change:: :tags: bug, sql :tickets: 5935 Fixed regression where use of an arbitrary iterable with the :func:`_sql.select` function was not working, outside of plain lists. The forwards/backwards compatibility logic here now checks for a wider range of incoming &quot;iterable&quot; types including that a ``.c`` collection from a selectable can be passed directly. Pull request compliments of Oliver Rice. .. changelog:: ``` ### 1.4.0b2 ``` :released: March 15, 2021 :released: February 3, 2021 .. change:: :tags: usecase, sql :tickets: 5695 Multiple calls to &quot;returning&quot;, e.g. :meth:`_sql.Insert.returning`, may now be chained to add new columns to the RETURNING clause. .. change:: :tags: bug, asyncio :tickets: 5615 Adjusted the greenlet integration, which provides support for Python asyncio in SQLAlchemy, to accommodate for the handling of Python ``contextvars`` (introduced in Python 3.7) for ``greenlet`` versions greater than 0.4.17. Greenlet version 0.4.17 added automatic handling of contextvars in a backwards-incompatible way; we&#39;ve coordinated with the greenlet authors to add a preferred API for this in versions subsequent to 0.4.17 which is now supported by SQLAlchemy&#39;s greenlet integration. For greenlet versions prior to 0.4.17 no behavioral change is needed, version 0.4.17 itself is blocked from the dependencies. .. change:: :tags: bug, engine, sqlite :tickets: 5845 Fixed bug in the 2.0 &quot;future&quot; version of :class:`.Engine` where emitting SQL during the :meth:`.EngineEvents.begin` event hook would cause a re-entrant (recursive) condition due to autobegin, affecting among other things the recipe documented for SQLite to allow for savepoints and serializable isolation support. .. change:: :tags: bug, orm, regression :tickets: 5845 Fixed issue in new :class:`_orm.Session` similar to that of the :class:`_engine.Connection` where the new &quot;autobegin&quot; logic could be tripped into a re-entrant (recursive) state if SQL were executed within the :meth:`.SessionEvents.after_transaction_create` event hook. .. change:: :tags: sql :tickets: 4757 Replace :meth:`_orm.Query.with_labels` and :meth:`_sql.GenerativeSelect.apply_labels` with explicit getters and setters :meth:`_sql.GenerativeSelect.get_label_style` and :meth:`_sql.GenerativeSelect.set_label_style` to accommodate the three supported label styles: :data:`_sql.LABEL_STYLE_DISAMBIGUATE_ONLY`, :data:`_sql.LABEL_STYLE_TABLENAME_PLUS_COL`, and :data:`_sql.LABEL_STYLE_NONE`. In addition, for Core and &quot;future style&quot; ORM queries, ``LABEL_STYLE_DISAMBIGUATE_ONLY`` is now the default label style. This style differs from the existing &quot;no labels&quot; style in that labeling is applied in the case of column name conflicts; with ``LABEL_STYLE_NONE``, a duplicate column name is not accessible via name in any case. For cases where labeling is significant, namely that the ``.c`` collection of a subquery is able to refer to all columns unambiguously, the behavior of ``LABEL_STYLE_DISAMBIGUATE_ONLY`` is now sufficient for all SQLAlchemy features across Core and ORM which involve this behavior. Result set rows since SQLAlchemy 1.0 are usually aligned with column constructs positionally. For legacy ORM queries using :class:`_query.Query`, the table-plus-column names labeling style applied by ``LABEL_STYLE_TABLENAME_PLUS_COL`` continues to be used so that existing test suites and logging facilities see no change in behavior by default. .. change:: :tags: bug, orm, unitofwork :tickets: 5735 Improved the unit of work topological sorting system such that the toplogical sort is now deterministic based on the sorting of the input set, which itself is now sorted at the level of mappers, so that the same inputs of affected mappers should produce the same output every time, among mappers / tables that don&#39;t have any dependency on each other. This further reduces the chance of deadlocks as can be observed in a flush that UPDATEs among multiple, unrelated tables such that row locks are generated. .. change:: :tags: changed, orm :tickets: 5897 Mapper &quot;configuration&quot;, which occurs within the :func:`_orm.configure_mappers` function, is now organized to be on a per-registry basis. This allows for example the mappers within a certain declarative base to be configured, but not those of another base that is also present in memory. The goal is to provide a means of reducing application startup time by only running the &quot;configure&quot; process for sets of mappers that are needed. This also adds the :meth:`_orm.registry.configure` method that will run configure for the mappers local in a particular registry only. .. change:: :tags: bug, orm :tickets: 5702 Fixed regression where the :paramref:`.Bundle.single_entity` flag would take effect for a :class:`.Bundle` even though it were not set. Additionally, this flag is legacy as it only makes sense for the :class:`_orm.Query` object and not 2.0 style execution. a deprecation warning is emitted when used with new-style execution. .. change:: :tags: bug, sql :tickets: 5858 Fixed issue in new :meth:`_sql.Select.join` method where chaining from the current JOIN wasn&#39;t looking at the right state, causing an expression like &quot;FROM a JOIN b &lt;onclause&gt;, b JOIN c &lt;onclause&gt;&quot; rather than &quot;FROM a JOIN b &lt;onclause&gt; JOIN c &lt;onclause&gt;&quot;. .. change:: :tags: usecase, sql Added :meth:`_sql.Select.outerjoin_from` method to complement :meth:`_sql.Select.join_from`. .. change:: :tags: usecase, sql :tickets: 5888 Adjusted the &quot;literal_binds&quot; feature of :class:`_sql.Compiler` to render NULL for a bound parameter that has ``None`` as the value, either explicitly passed or omitted. The previous error message &quot;bind parameter without a renderable value&quot; is removed, and a missing or ``None`` value will now render NULL in all cases. Previously, rendering of NULL was starting to happen for DML statements due to internal refactorings, but was not explicitly part of test coverage, which it now is. While no error is raised, when the context is within that of a column comparison, and the operator is not &quot;IS&quot;/&quot;IS NOT&quot;, a warning is emitted that this is not generally useful from a SQL perspective. .. change:: :tags: bug, orm :tickets: 5750 Fixed regression where creating an :class:`_orm.aliased` construct against a plain selectable and including a name would raise an assertionerror. .. change:: :tags: bug, mssql, mysql, datatypes :tickets: 5788 :versions: 1.4.0b2 Decimal accuracy and behavior has been improved when extracting floating point and/or decimal values from JSON strings using the :meth:`_sql.sqltypes.JSON.Comparator.as_float` method, when the numeric value inside of the JSON string has many significant digits; previously, MySQL backends would truncate values with many significant digits and SQL Server backends would raise an exception due to a DECIMAL cast with insufficient significant digits. Both backends now use a FLOAT-compatible approach that does not hardcode significant digits for floating point values. For precision numerics, a new method :meth:`_sql.sqltypes.JSON.Comparator.as_numeric` has been added which accepts arguments for precision and scale, and will return values as Python ``Decimal`` objects with no floating point conversion assuming the DBAPI supports it (all but pysqlite). .. change:: :tags: feature, orm, declarative :tickets: 5745 Added an alternate resolution scheme to Declarative that will extract the SQLAlchemy column or mapped property from the &quot;metadata&quot; dictionary of a dataclasses.Field object. This allows full declarative mappings to be combined with dataclass fields. .. seealso:: :ref:`orm_declarative_dataclasses_declarative_table` .. change:: :tags: bug, sql :tickets: 5754 Deprecation warnings are emitted under &quot;SQLALCHEMY_WARN_20&quot; mode when passing a plain string to :meth:`_orm.Session.execute`. .. change:: :tags: bug, sql, orm :tickets: 5760, 5763, 5765, 5768, 5770 A wide variety of fixes to the &quot;lambda SQL&quot; feature introduced at :ref:`engine_lambda_caching` have been implemented based on user feedback, with an emphasis on its use within the :func:`_orm.with_loader_criteria` feature where it is most prominently used [ticket:5760]: * fixed issue where boolean True/False values referred towards in the closure variables of the lambda would cause failures [ticket:5763] * Repaired a non-working detection for Python functions embedded in the lambda that produce bound values; this case is likely not supportable so raises an informative error, where the function should be invoked outside the lambda itself. New documentation has been added to further detail this behavior. [ticket:5770] * The lambda system by default now rejects the use of non-SQL elements within the closure variables of the lambda entirely, where the error suggests the two options of either explicitly ignoring closure variables that are not SQL parameters, or specifying a specific set of values to be considered as part of the cache key based on hash value. This critically prevents the lambda system from assuming that arbitrary objects within the lambda&#39;s closure are appropriate for caching while also refusing to ignore them by default, preventing the case where their state might not be constant and have an impact on the SQL construct produced. The error message is comprehensive and new documentation has been added to further detail this behavior. [ticket:5 --- <sub>🔄 This issue represents a GitHub Pull Request. It cannot be merged through Gitea due to API limitations.</sub>
kerem 2026-02-26 01:33:41 +03:00
Sign in to join this conversation.
No Branch/Tag specified
Branches Tags
master
pyup-scheduled-update-2026-04-27
pyup-scheduled-update-2026-04-20
pyup-scheduled-update-2024-09-16
pyup-scheduled-update-2023-07-24
pyup-scheduled-update-2023-06-19
pyup-scheduled-update-2023-05-22
pyup-scheduled-update-2023-05-15
pyup-scheduled-update-2023-05-08
dependabot/pip/flask-2.3.2
pyup-scheduled-update-2023-05-01
pyup-scheduled-update-2023-04-03
dependabot/pip/werkzeug-2.2.3
pyup-scheduled-update-2022-11-14
pyup-scheduled-update-2022-10-03
pyup-scheduled-update-2022-08-01
pyup-scheduled-update-2022-06-13
pyup-scheduled-update-2022-05-30
pyup-scheduled-update-2022-03-07
pyup-scheduled-update-2022-01-10
pyup-scheduled-update-2021-11-01
pyup-scheduled-update-2020-10-05
pyup-scheduled-update-2019-09-30
pyup-scheduled-update-2019-07-29
pyup-scheduled-update-2019-07-22
pyup-scheduled-update-2019-05-27
pyup-scheduled-update-2019-03-11
marshmallow
pyup-scheduled-update-2019-02-25
pyup-scheduled-update-2019-02-18
pyup-scheduled-update-2019-01-28
pyup-scheduled-update-2019-01-14
docker
name-map-stupid
swagger
fix-pagination
doc-expansion
specify-schema
No results found.
Labels
Clear labels   
bug

   
duplicate

   
enhancement

   
help wanted

   
invalid

   
pull-request

Mirrored from GitHub Pull Request

  
question

   
refactoring

   
research

   
wontfix
No labels
bug
duplicate
enhancement
help wanted
invalid
pull-request
question
refactoring
research
wontfix
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
starred/sandman2-jeffknupp#232
No description provided.