Log message:
py-sqlalchemy: updated to 1.2.18

1.2.18:
orm

[orm] [bug] Fixed a regression in 1.2 where a wildcard/load_only loader option \ 
would not work correctly against a loader path where of_type() were used to \ 
limit to a particular subclass. The fix only works for of_type() of a simple \ 
subclass so far, not a with_polymorphic entity which will be addressed in a \ 
separate issue; it is unlikely this latter case was working previously.

[orm] [bug] Fixed fairly simple but critical issue where the \ 
SessionEvents.pending_to_persistent() event would be invoked for objects not \ 
just when they move from pending to persistent, but when they were also already \ 
persistent and just being updated, thus causing the event to be invoked for all \ 
objects on every update.

sql
[sql] [bug] Fixed issue where the JSON type had a read-only \ 
JSON.should_evaluate_none attribute, which would cause failures when making use \ 
of the TypeEngine.evaluates_none() method in conjunction with this type. Pull \ 
request courtesy Sanjana S.

mysql
[mysql] [bug] Fixed a second regression caused by 4344 (the first was 4361), \ 
which works around MySQL issue 88718, where the lower casing function used was \ 
not correct for Python 2 with OSX/Windows casing conventions, which would then \ 
raise TypeError. Full coverage has been added to this logic so that every \ 
codepath is exercised in a mock style for all three casing conventions on all \ 
versions of Python. MySQL 8.0 has meanwhile fixed issue 88718 so the workaround \ 
is only applies to a particular span of MySQL 8.0 versions.

sqlite
[sqlite] [bug] Fixed bug in SQLite DDL where using an expression as a server \ 
side default required that it be contained within parenthesis to be accepted by \ 
the sqlite parser. Pull request courtesy Bartlomiej Biernacki.

mssql
[mssql] [bug] Fixed bug where the SQL Server “IDENTITY_INSERT” logic that \ 
allows an INSERT to proceed with an explicit value on an IDENTITY column was not \ 
detecting the case where Insert.values() were used with a dictionary that \ 
contained a Column as key and a SQL expression as a value

Log message:
py-sqlalchemy: updated to 1.2.17

1.2.17

[orm] [feature] Added new event hooks QueryEvents.before_compile_update() and \ 
QueryEvents.before_compile_delete() which complement \ 
QueryEvents.before_compile() in the case of the Query.update() and \ 
Query.delete() methods.

[orm] [bug] Fixed issue where when using single-table inheritance in conjunction \ 
with a joined inheritance hierarchy that uses “with polymorphic” loading, \ 
the “single table criteria” for that single-table entity could get confused \ 
for that of other entities from the same hierarchy used in the same query.The \ 
adaption of the “single table criteria” is made more specific to the target \ 
entity to avoid it accidentally getting adapted to other tables in the query.

[postgresql] [bug] Revised the query used when reflecting CHECK constraints to \ 
make use of the pg_get_constraintdef function, as the consrc column is being \ 
deprecated in PG 12. Thanks to John A Stevenson for the tip.

[oracle] [bug] Fixed regression in integer precision logic due to the refactor \ 
of the cx_Oracle dialect in 1.2. We now no longer apply the cx_Oracle.NATIVE_INT \ 
type to result columns sending integer values (detected as positive precision \ 
with scale ==0) which encounters integer overflow issues with values that go \ 
beyond the 32 bit boundary. Instead, the output variable is left untyped so that \ 
cx_Oracle can choose the best option

Log message:
py-sqlalchemy: updated to 1.2.16

1.2.16:
engine

[engine] [bug] Fixed a regression introduced in version 1.2 where a refactor of \ 
the SQLAlchemyError base exception class introduced an inappropriate coercion of \ 
a plain string message into Unicode under python 2k, which is not handled by the \ 
Python interpreter for characters outside of the platform’s encoding \ 
(typically ascii). The SQLAlchemyError class now passes a bytestring through \ 
under Py2K for __str__() as is the behavior of exception objects in general \ 
under Py2K, does a safe coercion to unicode utf-8 with backslash fallback for \ 
__unicode__(). For Py3K the message is typically unicode already, but if not is \ 
again safe-coerced with utf-8 with backslash fallback for the __str__() method.

sql

[sql] [bug] [mysql] [oracle] Fixed issue where the DDL emitted for \ 
DropTableComment, which will be used by an upcoming version of Alembic, was \ 
incorrect for the MySQL and Oracle databases.

postgresql

[postgresql] [bug] Fixed issue where a postgresql.ENUM or a custom domain \ 
present in a remote schema would not be recognized within column reflection if \ 
the name of the enum/domain or the name of the schema required quoting. A new \ 
parsing scheme now fully parses out quoted or non-quoted tokens including \ 
support for SQL-escaped quotes.

[postgresql] [bug] Fixed issue where multiple postgresql.ENUM objects referred \ 
to by the same MetaData object would fail to be created if multiple objects had \ 
the same name under different schema names. The internal memoization the \ 
PostgreSQL dialect uses to track if it has created a particular postgresql.ENUM \ 
in the database during a DDL creation sequence now takes schema name into \ 
account.

sqlite

[sqlite] [bug] Reflection of an index based on SQL expressions are now skipped \ 
with a warning, in the same way as that of the Postgresql dialect, where we \ 
currently do not support reflecting indexes that have SQL expressions within \ 
them. Previously, an index with columns of None were produced which would break \ 
tools like Alembic.

misc

Fixed issue in “expanding IN” feature where using the same bound parameter \ 
name more than once in a query would lead to a KeyError within the process of \ 
rewriting the parameters in the query

Log message:
py-sqlalchemy: updated to 1.2.15

1.2.15

orm

[orm] [bug] Fixed bug where the ORM annotations could be incorrect for the \ 
primaryjoin/secondaryjoin a relationship if one used the pattern \ 
ForeignKey(SomeClass.id) in the declarative mappings. This pattern would leak \ 
undesired annotations into the join conditions which can break aliasing \ 
operations done within Query that are not supposed to impact elements in that \ 
join condition. These annotations are now removed up front if present.

[orm] [bug] In continuing with a similar theme as that of very recent 4349, \ 
repaired issue with RelationshipProperty.Comparator.any() and \ 
RelationshipProperty.Comparator.has() where the “secondary” selectable needs \ 
to be explicitly part of the FROM clause in the EXISTS subquery to suit the case \ 
where this “secondary” is a Join object.

[orm] [bug] Fixed regression caused by 4349 where adding the “secondary” \ 
table to the FROM clause for a dynamic loader would affect the ability of the \ 
Query to make a subsequent join to another entity. The fix adds the primary \ 
entity as the first element of the FROM list since Query.join() wants to jump \ 
from that. Version 1.3 will have a more comprehensive solution to this problem \ 
as well.

[orm] [bug] Fixed bug where chaining of mapper options using \ 
RelationshipProperty.of_type() in conjunction with a chained option that refers \ 
to an attribute name by string only would fail to locate the attribute.

orm declarative

[bug] [declarative] [orm] A warning is emitted in the case that a column() \ 
object is applied to a declarative class, as it seems likely this intended to be \ 
a Column object.

misc

Added support for the write_timeout flag accepted by mysqlclient and pymysql to \ 
be passed in the URL string.

Fixed issue where reflection of a PostgreSQL domain that is expressed as an \ 
array would fail to be recognized.

Log message:
py-sqlalchemy: updated to 1.2.14

1.2.14

orm
* Fixed bug in Session.bulk_update_mappings() where alternate mapped attribute \ 
names would result in the primary key column of the UPDATE statement being \ 
included in the SET clause, as well as the WHERE clause; while usually harmless, \ 
for SQL Server this can raise an error due to the IDENTITY column. This is a \ 
continuation of the same bug that was fixed in 3849, where testing was \ 
insufficient to catch this additional flaw.

* Fixed a minor performance issue which could in some cases add unnecessary \ 
overhead to result fetching, involving the use of ORM columns and entities that \ 
include those same columns at the same time within a query. The issue has to do \ 
with hash / eq overhead when referring to the column in different ways.

mysql
* Fixed regression caused by 4344 released in 1.2.13, where the fix for MySQL \ 
8.0’s case sensitivity problem with referenced column names when reflecting \ 
foreign key referents is worked around using the information_schema.columns \ 
view. The workaround was failing on OSX / lower_case_table_names=2 which \ 
produces non-matching casing for the information_schema.columns vs. that of SHOW \ 
CREATE TABLE, so in case-insensitive SQL modes case-insensitive matching is now \ 
used.

Log message:
py-sqlalchemy: updated to 1.2.13

SQLAlchemy release 1.2.13:
This release includes a variety of fixes within the ORM and Core components.

Log message:
py-sqlalchemy: updated to 1.2.12

Release 1.2.12 includes a series of mostly minor bugfixes, as well as one \ 
critical issue allowing the recently released version 7.0 of the cx_Oracle DBAPI \ 
to work correctly.

Log message:
py-sqlalchemy: updated to 1.2.11

SQLAlchemy release 1.2.11:
This release includes a short list of minor bug fixes that have accumulated over \ 
the past month.

Log message:
py-sqlalchemy: updated to 1.2.10

1.2.10:
[orm] [bug] Fixed bug in Bundle construct where placing two columns of the same \ 
name would be de-duplicated, when the Bundle were used as part of the rendered \ 
SQL, such as in the ORDER BY or GROUP BY of the statement.

[orm] [bug] Fixed regression in 1.2.9 due to 4287 where using a Load option in \ 
conjunction with a string wildcard would result in a TypeError.

[sql] [bug] Fixed bug where a Sequence would be dropped explicitly before any \ 
Table that refers to it, which breaks in the case when the sequence is also \ 
involved in a server-side default for that table, when using \ 
MetaData.drop_all(). The step which processes sequences to be dropped via non \ 
server-side column default functions is now invoked after the table itself is \ 
dropped.

Log message:
py-sqlalchemy: updated to 1.2.9

Version 1.2.9

Fixed issue where chaining multiple join elements inside of Query.join() might \ 
not correctly adapt to the previous left-hand side, when chaining joined \ 
inheritance classes that share the same base class.

Fixed bug in cache key generation for baked queries which could cause a \ 
too-short cache key to be generated for the case of eager loads across \ 
subclasses. This could in turn cause the eagerload query to be cached in place \ 
of a non-eagerload query, or vice versa, for a polymorhic “selectin” load, \ 
or possibly for lazy loads or selectin loads as well.

Fixed bug in new polymorphic selectin loading where the BakedQuery used \ 
internally would be mutated by the given loader options, which would both \ 
inappropriately mutate the subclass query as well as carry over the effect to \ 
subsequent queries.

Fixed regression caused by 4256 (itself a regression fix for 4228) which breaks \ 
an undocumented behavior which converted for a non-sequence of entities passed \ 
directly to the Query constructor into a single-element sequence. While this \ 
behavior was never supported or documented, it’s already in use so has been \ 
added as a behavioral contract to Query.

Fixed an issue that was both a performance regression in 1.2 as well as an \ 
incorrect result regarding the “baked” lazy loader, involving the generation \ 
of cache keys from the original Query object’s loader options. If the loader \ 
options were built up in a “branched” style using common base elements for \ 
multiple options, the same options would be rendered into the cache key \ 
repeatedly, causing both a performance issue as well as generating the wrong \ 
cache key. This is fixed, along with a performance improvement when such \ 
“branched” options are applied via Query.options() to prevent the same \ 
option objects from being applied repeatedly.