[orm] [feature] An aliased()
construct can now be passed to the
Query.select_entity_from()
method. Entities will be pulled
from the selectable represented by the aliased()
construct.
This allows special options for aliased()
such as
aliased.adapt_on_names
to be used in conjunction with
Query.select_entity_from()
.¶
This change is also backported to: 1.1.7
References: #3933
[orm] [feature] Added .autocommit
attribute to scoped_session
, proxying
the .autocommit
attribute of the underling Session
currently assigned to the thread. Pull request courtesy
Ben Fagin.¶
[orm] [feature] Added a new feature orm.with_expression()
that allows an ad-hoc
SQL expression to be added to a specific entity in a query at result
time. This is an alternative to the SQL expression being delivered as
a separate element in the result tuple.
References: #3058
[orm] [feature] Added a new style of mapper-level inheritance loading “polymorphic selectin”. This style of loading emits queries for each subclass in an inheritance hierarchy subsequent to the load of the base object type, using IN to specify the desired primary key values.
¶References: #3948
[orm] [feature] Added a new kind of eager loading called “selectin” loading. This
style of loading is very similar to “subquery” eager loading,
except that it uses an IN expression given a list of primary key
values from the loaded parent objects, rather than re-stating the
original query. This produces a more efficient query that is
“baked” (e.g. the SQL string is cached) and also works in the
context of Query.yield_per()
.
References: #3944
[orm] [feature] The lazy="select"
loader strategy now makes used of the
BakedQuery
query caching system in all cases. This
removes most overhead of generating a Query
object and
running it into a select()
and then string SQL statement from
the process of lazy-loading related collections and objects. The
“baked” lazy loader has also been improved such that it can now
cache in most cases where query load options are used.
References: #3954
[orm] [feature] [ext] The Query.update()
method can now accommodate both
hybrid attributes as well as composite attributes as a source
of the key to be placed in the SET clause. For hybrids, an
additional decorator hybrid_property.update_expression()
is supplied for which the user supplies a tuple-returning function.
References: #3229
[orm] [feature] Added new attribute event AttributeEvents.bulk_replace()
.
This event is triggered when a collection is assigned to a
relationship, before the incoming collection is compared with the
existing one. This early event allows for conversion of incoming
non-ORM objects as well. The event is integrated with the
@validates
decorator.
See also
References: #3896
[orm] [feature] Added new event handler AttributeEvents.modified()
which is
triggered when the func:.attributes.flag_modified function is
invoked, which is common when using the sqlalchemy.ext.mutable
extension module.
References: #3303
[orm] [bug] Fixed issue with subquery eagerloading which continues on from the series of issues fixed in #2699, #3106, #3893 involving that the “subquery” contains the correct FROM clause when beginning from a joined inheritance subclass and then subquery eager loading onto a relationship from the base class, while the query also includes criteria against the subclass. The fix in the previous tickets did not accommodate for additional subqueryload operations loading more deeply from the first level, so the fix has been further generalized.¶
This change is also backported to: 1.1.11
References: #4011
[orm] [bug] Fixed bug where a cascade such as “delete-orphan” (but others as well) would fail to locate an object linked to a relationship that itself is local to a subclass in an inheritance relationship, thus causing the operation to not take place.¶
This change is also backported to: 1.1.10
References: #3986
[orm] [bug] Fixed a race condition which could occur under threaded environments
as a result of the caching added via #3915. An internal
collection of Column
objects could be regenerated on an alias
object inappropriately, confusing a joined eager loader when it
attempts to render SQL and collect results and resulting in an
attribute error. The collection is now generated up front before
the alias object is cached and shared among threads.¶
This change is also backported to: 1.1.7
References: #3947
[orm] [bug] An UPDATE emitted as a result of the
relationship.post_update
feature will now integrate with
the versioning feature to both bump the version id of the row as well
as assert that the existing version number was matched.
References: #3496
[orm] [bug] Repaired several use cases involving the
relationship.post_update
feature when used in conjunction
with a column that has an “onupdate” value. When the UPDATE emits,
the corresponding object attribute is now expired or refreshed so that
the newly generated “onupdate” value can populate on the object;
previously the stale value would remain. Additionally, if the target
attribute is set in Python for the INSERT of the object, the value is
now re-sent during the UPDATE so that the “onupdate” does not overwrite
it (note this works just as well for server-generated onupdates).
Finally, the SessionEvents.refresh_flush()
event is now emitted
for these attributes when refreshed within the flush.
[orm] [bug] Fixed bug where programmatic version_id counter in conjunction with joined table inheritance would fail if the version_id counter were not actually incremented and no other values on the base table were modified, as the UPDATE would have an empty SET clause. Since programmatic version_id where version counter is not incremented is a documented use case, this specific condition is now detected and the UPDATE now sets the version_id value to itself, so that concurrency checks still take place.¶
References: #3996
[orm] [bug] The versioning feature does not support NULL for the version counter. An exception is now raised if the version id is programmatic and was set to NULL for an UPDATE. Pull request courtesy Diana Clarke.¶
References: #3673
[orm] [bug] Removed a very old keyword argument from scoped_session
called scope
. This keyword was never documented and was an
early attempt at allowing for variable scopes.
References: #3796
[orm] [bug] Fixed bug where combining a “with_polymorphic” load in conjunction with subclass-linked relationships that specify joinedload with innerjoin=True, would fail to demote those “innerjoins” to “outerjoins” to suit the other polymorphic classes that don’t support that relationship. This applies to both a single and a joined inheritance polymorphic load.¶
References: #3988
[orm] [bug] Added new argument with_for_update
to the
Session.refresh()
method. When the Query.with_lockmode()
method were deprecated in favor of Query.with_for_update()
,
the Session.refresh()
method was never updated to reflect
the new option.
References: #3991
[orm] [bug] Fixed bug where a column_property()
that is also marked as
“deferred” would be marked as “expired” during a flush, causing it
to be loaded along with the unexpiry of regular attributes even
though this attribute was never accessed.¶
References: #3984
[orm] [bug] Fixed bug in subquery eager loading where the “join_depth” parameter for self-referential relationships would not be correctly honored, loading all available levels deep rather than correctly counting the specified number of levels for eager loading.¶
References: #3967
[orm] [bug] Added warnings to the LRU “compiled cache” used by the Mapper
(and ultimately will be for other ORM-based LRU caches) such that
when the cache starts hitting its size limits, the application will
emit a warning that this is a performance-degrading situation that
may require attention. The LRU caches can reach their size limits
primarily if an application is making use of an unbounded number
of Engine
objects, which is an antipattern. Otherwise,
this may suggest an issue that should be brought to the SQLAlchemy
developer’s attention.¶
[orm] [bug] Fixed bug to improve upon the specificity of loader options that take effect subsequent to the lazy load of a related entity, so that the loader options will match to an aliased or non-aliased entity more specifically if those options include entity information.¶
References: #3963
[orm] [bug] The attributes.flag_modified()
function now raises
InvalidRequestError
if the named attribute key is not
present within the object, as this is assumed to be present
in the flush process. To mark an object “dirty” for a flush
without referring to any specific attribute, the
attributes.flag_dirty()
function may be used.
References: #3753
[orm] [bug] The “evaluate” strategy used by Query.update()
and
Query.delete()
can now accommodate a simple
object comparison from a many-to-one relationship to an instance,
when the attribute names of the primary key / foreign key columns
don’t match the actual names of the columns. Previously this would
do a simple name-based match and fail with an AttributeError.¶
References: #3366
[orm] [bug] The @validates
decorator now allows the decorated method to receive
objects from a “bulk collection set” operation that have not yet
been compared to the existing collection. This allows incoming values
to be converted to compatible ORM objects as is already allowed
from an “append” event. Note that this means that the
@validates
method is called for all values during a collection
assignment, rather than just the ones that are new.
References: #3896
[orm] [bug] Fixed bug in single-table inheritance where the select_from() argument would not be taken into account when limiting rows to a subclass. Previously, only expressions in the columns requested would be taken into account.
¶References: #3891
[orm] [bug] When assigning a collection to an attribute mapped by a relationship, the previous collection is no longer mutated. Previously, the old collection would be emptied out in conjunction with the “item remove” events that fire off; the events now fire off without affecting the old collection.
¶References: #3913
[orm] [bug] The state of the Session
is now present when the
SessionEvents.after_rollback()
event is emitted, that is, the
attribute state of objects prior to their being expired. This is now
consistent with the behavior of the
SessionEvents.after_commit()
event which also emits before the
attribute state of objects is expired.
References: #3934
[orm] [bug] Fixed bug where Query.with_parent()
would not work if the
Query
were against an aliased()
construct rather than
a regular mapped class. Also adds a new parameter
util.with_parent.from_entity
to the standalone
util.with_parent()
function as well as
Query.with_parent()
.¶
References: #3607
[bug] [orm] [declarative] Fixed bug where using declared_attr
on an
AbstractConcreteBase
where a particular return value were some
non-mapped symbol, including None
, would cause the attribute
to hard-evaluate just once and store the value to the object
dictionary, not allowing it to invoke for subclasses. This behavior
is normal when declared_attr
is on a mapped class, and
does not occur on a mixin or abstract class. Since
AbstractConcreteBase
is both “abstract” and actually
“mapped”, a special exception case is made here so that the
“abstract” behavior takes precedence for declared_attr
.¶
References: #3848
[engine] [feature] Added native “pessimistic disconnection” handling to the Pool
object. The new parameter Pool.pre_ping
, available from
the engine as create_engine.pool_pre_ping
, applies an
efficient form of the “pre-ping” recipe featured in the pooling
documentation, which upon each connection check out, emits a simple
statement, typically “SELECT 1”, to test the connection for liveness.
If the existing connection is no longer able to respond to commands,
the connection is transparently recycled, and all other connections
made prior to the current timestamp are invalidated.
See also
Disconnect Handling - Pessimistic
Pessimistic disconnection detection added to the connection pool
References: #3919
[engine] [bug] Added an exception handler that will warn for the “cause” exception on
Py2K when the “autorollback” feature of Connection
itself
raises an exception. In Py3K, the two exceptions are naturally reported
by the interpreter as one occurring during the handling of the other.
This is continuing with the series of changes for rollback failure
handling that were last visited as part of #2696 in 1.0.12.¶
This change is also backported to: 1.1.7
References: #3946
[engine] [bug] Fixed bug where in the unusual case of passing a
Compiled
object directly to Connection.execute()
,
the dialect with which the Compiled
object were generated
was not consulted for the paramstyle of the string statement, instead
assuming it would match the dialect-level paramstyle, causing
mismatches to occur.¶
References: #3938
[sql] [feature] Added a new kind of bindparam()
called “expanding”. This is
for use in IN
expressions where the list of elements is rendered
into individual bound parameters at statement execution time, rather
than at statement compilation time. This allows both a single bound
parameter name to be linked to an IN expression of multiple elements,
as well as allows query caching to be used with IN expressions. The
new feature allows the related features of “select in” loading and
“polymorphic in” loading to make use of the baked query extension
to reduce call overhead. This feature should be considered to be
experimental for 1.2.
References: #3953
[sql] [feature] [postgresql] [mysql] [oracle] Added support for SQL comments on Table
and Column
objects, via the new Table.comment
and
Column.comment
arguments. The comments are included
as part of DDL on table creation, either inline or via an appropriate
ALTER statement, and are also reflected back within table reflection,
as well as via the Inspector
. Supported backends currently
include MySQL, Postgresql, and Oracle. Many thanks to Frazer McLean
for a large amount of effort on this.
References: #1546
[sql] [feature] The longstanding behavior of the ColumnOperators.in_()
and
ColumnOperators.notin_()
operators emitting a warning when
the right-hand condition is an empty sequence has been revised;
a simple “static” expression of “1 != 1” or “1 = 1” is now rendered
by default, rather than pulling in the original left-hand
expression. This causes the result for a NULL column comparison
against an empty set to change from NULL to true/false. The
behavior is configurable, and the old behavior can be enabled
using the create_engine.empty_in_strategy
parameter
to create_engine()
.
References: #3907
[sql] [feature] Added a new option autoescape
to the “startswith” and
“endswith” classes of comparators; this supplies an escape character
also applies it to all occurrences of the wildcard characters “%”
and “_” automatically. Pull request courtesy Diana Clarke.
References: #2694
[sql] [bug] Fixed AttributeError which would occur in WithinGroup
construct during an iteration of the structure.¶
This change is also backported to: 1.1.11
References: #4012
[sql] [bug] Fixed regression released in 1.1.5 due to #3859 where
adjustments to the “right-hand-side” evaluation of an expression
based on Variant
to honor the underlying type’s
“right-hand-side” rules caused the Variant
type
to be inappropriately lost, in those cases when we do want the
left-hand side type to be transferred directly to the right hand side
so that bind-level rules can be applied to the expression’s argument.¶
This change is also backported to: 1.1.9
References: #3952
[sql] [bug] [postgresql] Changed the mechanics of ResultProxy
to unconditionally
delay the “autoclose” step until the Connection
is done
with the object; in the case where Postgresql ON CONFLICT with
RETURNING returns no rows, autoclose was occurring in this previously
non-existent use case, causing the usual autocommit behavior that
occurs unconditionally upon INSERT/UPDATE/DELETE to fail.¶
This change is also backported to: 1.1.9
References: #3955
[sql] [bug] The rules for type coercion between Numeric
, Integer
,
and date-related types now include additional logic that will attempt
to preserve the settings of the incoming type on the “resolved” type.
Currently the target for this is the asdecimal
flag, so that
a math operation between Numeric
or Float
and
Integer
will preserve the “asdecimal” flag as well as
if the type should be the Float
subclass.
References: #4018
[sql] [bug] [mysql] The result processor for the Float
type now unconditionally
runs values through the float()
processor if the dialect
specifies that it also supports “native decimal” mode. While most
backends will deliver Python float
objects for a floating point
datatype, the MySQL backends in some cases lack the typing information
in order to provide this and return Decimal
unless the float
conversion is done.
References: #4020
[sql] [bug] Added some extra strictness to the handling of Python “float” values
passed to SQL statements. A “float” value will be associated with the
Float
datatype and not the Decimal-coercing Numeric
datatype as was the case before, eliminating a confusing warning
emitted on SQLite as well as unecessary coercion to Decimal.
References: #4017
[sql] [bug] The operator precedence for all comparison operators such as LIKE, IS, IN, MATCH, equals, greater than, less than, etc. has all been merged into one level, so that expressions which make use of these against each other will produce parentheses between them. This suits the stated operator precedence of databases like Oracle, MySQL and others which place all of these operators as equal precedence, as well as Postgresql as of 9.5 which has also flattened its operator precendence.
¶References: #3999
[sql] [bug] Repaired issue where the type of an expression that used
ColumnOperators.is_()
or similar would not be a “boolean” type,
instead the type would be “nulltype”, as well as when using custom
comparison operators against an untyped expression. This typing can
impact how the expression behaves in larger contexts as well as
in result-row-handling.¶
References: #3873
[sql] [bug] Fixed the negation of a Label
construct so that the
inner element is negated correctly, when the not_()
modifier
is applied to the labeled expression.¶
References: #3969
[sql] [bug] The system by which percent signs in SQL statements are “doubled”
for escaping purposes has been refined. The “doubling” of percent
signs mostly associated with the literal_column
construct
as well as operators like ColumnOperators.contains()
now
occurs based on the stated paramstyle of the DBAPI in use; for
percent-sensitive paramstyles as are common with the Postgresql
and MySQL drivers the doubling will occur, for others like that
of SQLite it will not. This allows more database-agnostic use
of the literal_column
construct to be possible.
References: #3740
[sql] [bug] Fixed bug where a column-level CheckConstraint
would fail
to compile the SQL expression using the underlying dialect compiler
as well as apply proper flags to generate literal values as
inline, in the case that the sqltext is a Core expression and
not just a plain string. This was long-ago fixed for table-level
check constraints in 0.9 as part of #2742, which more commonly
feature Core SQL expressions as opposed to plain string expressions.¶
References: #3957
[sql] [bug] Fixed bug where a SQL-oriented Python-side column default could fail to be executed properly upon INSERT in the “pre-execute” codepath, if the SQL itself were an untyped expression, such as plain text. The “pre- execute” codepath is fairly uncommon however can apply to non-integer primary key columns with SQL defaults when RETURNING is not used.¶
References: #3923
[sql] [bug] The expression used for COLLATE as rendered by the column-level
expression.collate()
and ColumnOperators.collate()
is now
quoted as an identifier when the name is case sensitive, e.g. has
uppercase characters. Note that this does not impact type-level
collation, which is already quoted.
References: #3785
[sql] [bug] Fixed bug where the use of an Alias
object in a column
context would raise an argument error when it tried to group itself
into a parenthesized expression. Using Alias
in this way
is not yet a fully supported API, however it applies to some end-user
recipes and may have a more prominent role in support of some
future Postgresql features.¶
References: #3939
[schema] [bug] An ArgumentError
is now raised if a
ForeignKeyConstraint
object is created with a mismatched
number of “local” and “remote” columns, which otherwise causes the
internal state of the constraint to be incorrect. Note that this
also impacts the condition where a dialect’s reflection process
produces a mismatched set of columns for a foreign key constraint.¶
This change is also backported to: 1.1.10
References: #3949
[postgresql] [bug] Continuing with the fix that correctly handles Postgresql version string “10devel” released in 1.1.8, an additional regexp bump to handle version strings of the form “10beta1”. While Postgresql now offers better ways to get this information, we are sticking w/ the regexp at least through 1.1.x for the least amount of risk to compatibility w/ older or alternate Postgresql databases.¶
This change is also backported to: 1.1.11
References: #4005
[postgresql] [bug] Fixed bug where using ARRAY
with a string type that
features a collation would fail to produce the correct syntax
within CREATE TABLE.¶
This change is also backported to: 1.1.11
References: #4006
[postgresql] [bug] Added “autocommit” support for GRANT, REVOKE keywords. Pull request courtesy Jacob Hayes.¶
This change is also backported to: 1.1.10
[postgresql] [bug] Added support for parsing the Postgresql version string for a development version like “PostgreSQL 10devel”. Pull request courtesy Sean McCully.¶
This change is also backported to: 1.1.8
[postgresql] [bug] Fixed bug where the base sqltypes.ARRAY
datatype would not
invoke the bind/result processors of postgresql.ARRAY
.¶
References: #3964
[postgresql] [bug] Added support for all possible “fields” identifiers when reflecting the
Postgresql INTERVAL
datatype, e.g. “YEAR”, “MONTH”, “DAY TO
MINUTE”, etc.. In addition, the postgresql.INTERVAL
datatype itself now includes a new parameter
postgresql.INTERVAL.fields
where these qualifiers can be
specified; the qualifier is also reflected back into the resulting
datatype upon reflection / inspection.
References: #3959
[mysql] [feature] Added support for MySQL’s ON DUPLICATE KEY UPDATE
MySQL-specific mysql.dml.Insert
object.
Pull request courtesy Michael Doronin.
References: #4009
[mysql] [bug] MySQL 5.7 has introduced permission limiting for the “SHOW VARIABLES” command; the MySQL dialect will now handle when SHOW returns no row, in particular for the initial fetch of SQL_MODE, and will emit a warning that user permissions should be modified to allow the row to be present.¶
This change is also backported to: 1.1.11
References: #4007
[mysql] [bug] Removed an ancient and unnecessary intercept of the UTC_TIMESTAMP MySQL function, which was getting in the way of using it with a parameter.¶
This change is also backported to: 1.1.10
References: #3966
[mysql] [bug] Fixed bug in MySQL dialect regarding rendering of table options in conjunction with PARTITION options when rendering CREATE TABLE. The PARTITION related options need to follow the table options, whereas previously this ordering was not enforced.¶
This change is also backported to: 1.1.10
References: #3961
[mysql] [bug] Added support for views that are unreflectable due to stale
table definitions, when calling MetaData.reflect()
; a warning
is emitted for the table that cannot respond to DESCRIBE
,
but the operation succeeds.¶
References: #3871
[mssql] [bug] Fixed bug where SQL Server transaction isolation must be fetched from a different view when using Azure data warehouse, the query is now attempted against both views and then a NotImplemented is raised unconditionally if failure continues to provide the best resiliency against future arbitrary API changes in new SQL Server versions.¶
This change is also backported to: 1.1.11
References: #3994
[mssql] [bug] Added a placeholder type mssql.XML
to the SQL Server
dialect, so that a reflected table which includes this type can
be re-rendered as a CREATE TABLE. The type has no special round-trip
behavior nor does it currently support additional qualifying
arguments.¶
This change is also backported to: 1.1.11
References: #3973
[mssql] [bug] The SQL Server dialect now allows for a database and/or owner name
with a dot inside of it, using brackets explicitly in the string around
the owner and optionally the database name as well. In addition,
sending the quoted_name
construct for the schema name will
not split on the dot and will deliver the full string as the “owner”.
quoted_name
is also now available from the sqlalchemy.sql
import space.
References: #2626
[oracle] [feature] [posgresql] Added new keywords Sequence.cache
and
Sequence.order
to Sequence
, to allow rendering
of the CACHE parameter understood by Oracle and PostgreSQL, and the
ORDER parameter understood by Oracle. Pull request
courtesy David Moore.¶
This change is also backported to: 1.1.12
[oracle] [feature] The Oracle dialect now inspects unique and check constraints when using
Inspector.get_unique_constraints()
,
Inspector.get_check_constraints()
.
As Oracle does not have unique constraints that are separate from a unique
Index
, a Table
that’s reflected will still continue
to not have UniqueConstraint
objects associated with it.
Pull requests courtesy Eloy Felix.
References: #4003
[oracle] [bug] Support for two-phase transactions has been removed entirely for cx_Oracle when version 6.0b1 or later of the DBAPI is in use. The two- phase feature historically has never been usable under cx_Oracle 5.x in any case, and cx_Oracle 6.x has removed the connection-level “twophase” flag upon which this feature relied.¶
This change is also backported to: 1.1.11
References: #3997
[oracle] [bug] Fixed bug in cx_Oracle dialect where version string parsing would fail for cx_Oracle version 6.0b1 due to the “b” character. Version string parsing is now via a regexp rather than a simple split.¶
This change is also backported to: 1.1.10
References: #3975
[oracle] [bug] The cx_Oracle dialect now supports “sane multi rowcount”, that is,
when a series of parameter sets are executed via DBAPI
cursor.executemany()
, we can make use of cursor.rowcount
to
verify the number of rows matched. This has an impact within the
ORM when detecting concurrent modification scenarios, in that
some simple conditions can now be detected even when the ORM
is batching statements, as well as when the more strict versioning
feature is used, the ORM can still use statement batching. The
flag is enabled for cx_Oracle assuming at least version 5.0, which
is now commonplace.¶
References: #3932
[oracle] [bug] Oracle reflection now “normalizes” the name given to a foreign key constraint, that is, returns it as all lower case for a case insensitive name. This was already the behavior for indexes and primary key constraints as well as all table and column names. This will allow Alembic autogenerate scripts to compare and render foreign key constraint names correctly when initially specified as case insensitive.
¶References: #3276
[feature] [ext] Added new flag Session.enable_baked_queries
to the
Session
to allow baked queries to be disabled
session-wide, reducing memory use. Also added new Bakery
wrapper so that the bakery returned by BakedQuery.bakery
can be inspected.¶
[bug] [ext] Protected against testing “None” as a class in the case where declarative classes are being garbage collected and new automap prepare() operations are taking place concurrently, very infrequently hitting a weakref that has not been fully acted upon after gc.¶
This change is also backported to: 1.1.10
References: #3980
[bug] [ext] Fixed bug in sqlalchemy.ext.mutable
where the
Mutable.as_mutable()
method would not track a type that had
been copied using TypeEngine.copy()
. This became more of
a regression in 1.1 compared to 1.0 because the TypeDecorator
class is now a subclass of SchemaEventTarget
, which among
other things indicates to the parent Column
that the type
should be copied when the Column
is. These copies are
common when using declarative with mixins or abstract classes.¶
This change is also backported to: 1.1.8
References: #3950
[bug] [ext] Added support for bound parameters, e.g. those normally set up
via Query.params()
, to the baked.Result.count()
method. Previously, support for parameters were omitted. Pull request
courtesy Pat Deegan.¶
This change is also backported to: 1.1.8
[bug] [ext] The AssociationProxy.any()
, AssociationProxy.has()
and AssociationProxy.contains()
comparison methods now support
linkage to an attribute that is itself also an
AssociationProxy
, recursively.
References: #3769
[bug] [ext] Implemented in-place mutation operators __ior__
, __iand__
,
__ixor__
and __isub__
for mutable.MutableSet
and __iadd__
for mutable.MutableList
so that change
events are fired off when these mutator methods are used to alter the
collection.
References: #3853
[bug] [declarative] A warning is emitted if the declared_attr.cascading
modifier
is used with a declarative attribute that is itself declared on
a class that is to be mapped, as opposed to a declarative mixin
class or __abstract__
class. The declared_attr.cascading
modifier currently only applies to mixin/abstract classes.¶
References: #3847
[bug] [ext] Improved the association proxy list collection so that premature
autoflush against a newly created association object can be prevented
in the case where list.append()
is being used, and a lazy load
would be invoked when the association proxy accesses the endpoint
collection. The endpoint collection is now accessed first before
the creator is invoked to produce the association object.¶
References: #3941
[bug] [ext] The sqlalchemy.ext.hybrid.hybrid_property
class now supports
calling mutators like @setter
, @expression
etc. multiple times
across subclasses, and now provides a @getter
mutator, so that
a particular hybrid can be repurposed across subclasses or other
classes. This now matches the behavior of @property
in standard
Python.
[bug] [ext] Fixed a bug in the sqlalchemy.ext.serializer
extension whereby
an “annotated” SQL element (as produced by the ORM for many types
of SQL expressions) could not be reliably serialized. Also bumped
the default pickle level for the serializer to “HIGHEST_PROTOCOL”.¶
References: #3918