Index index by Group index by Distribution index by Vendor index by creation date index by Name Mirrors Help Search

python38-SQLAlchemy-1.4.26-1.1 RPM for armv7hl

From OpenSuSE Ports Tumbleweed for armv7hl

Name: python38-SQLAlchemy Distribution: openSUSE Tumbleweed
Version: 1.4.26 Vendor: openSUSE
Release: 1.1 Build date: Sat Nov 6 20:01:35 2021
Group: Unspecified Build host: obs-arm-11
Size: 16432657 Source RPM: python-SQLAlchemy-1.4.26-1.1.src.rpm
Summary: Database Abstraction Library
SQLAlchemy is an Object Relational Mappper (ORM) that provides a flexible,
high-level interface to SQL databases.  Database and domain concepts are
decoupled, allowing both sides maximum flexibility and power. SQLAlchemy
provides a powerful mapping layer that can work as automatically or as manually
as you choose, determining relationships based on foreign keys or letting you
define the join conditions explicitly, to bridge the gap between database and






* Wed Oct 27 2021 Dirk Müller <>
  - update to version 1.4.26:
    * a repair to the workings of the update() statement in an ORM context when
      used with hybrid and composite attributes.
    * Fixes for the with_loader_criteria() ORM option
    * adjustments to the ORM Session interface to accommodate for new API features
    * some new legacy warnings for lesser used patterns with Query.join()
    * SQL / ORM fixes for the use case of selecting from repeated, non-labeled
      column expressions, typically the null() construct when used as a
      placeholder in a UNION statement.
    * For PostgreSQL, refinements to the "expanding IN" SQL feature when used
      with PostgreSQL ARRAY datatypes as well as fixes for the mostly
      PostgreSQL-specific any_() and all_() column methods.
    * For MySQL, repaired support for new behaviors in MariaDB 10.6
    * For SQL Server, reflection fixes and improvements for foreign key
      constraints as well table /view detection.
* Sat Oct 16 2021 Dirk Müller <>
  - update to version 1.4.25:
    * Fixed regression due to :ticket:`7024` where the reorganization of the
      "platform machine" names used by the ``greenlet`` dependency mis-spelled
      "aarch64" and additionally omitted uppercase "AMD64" as is needed for
      Windows machines.
    * Fixed a bug in :meth:`_asyncio.AsyncSession.execute` and
      :meth:`` that required ``execution_options``
      to be an instance of ``immutabledict`` when defined. It now
      correctly accepts any mapping.
    * Improve the interface used by adapted drivers, like the asyncio ones,
      to access the actual connection object returned by the driver.
    * Implemented missing methods in :class:`_functions.FunctionElement` which,
      while unused, would lead pylint to report them as unimplemented abstract
    * Fixed an issue where :meth:`_reflection.has_table` returned
      ``True`` for local temporary tables that actually belonged to a
      different SQL Server session (connection). An extra check is now
      performed to ensure that the temp table detected is in fact owned
      by the current session.
    * Fixed issue where the ability of the
      :meth:`_events.ConnectionEvents.before_execute` method to alter the SQL
      statement object passed, returning the new object to be invoked, was
      inadvertently removed. This behavior has been restored.
    * Ensure that ``str()`` is called on the an
      :paramref:`_url.URL.create.password` argument, allowing usage of objects
      that implement the ``__str__()`` method as password attributes. Also
      clarified that one such object is not appropriate to dynamically change the
      password for each database connection; the approaches at
      :ref:`engines_dynamic_tokens` should be used instead.
    * Fixed ORM issue where column expressions passed to ``query()`` or
      ORM-enabled ``select()`` would be deduplicated on the identity of the
      object, such as a phrase like ``select(, null(), null())`` would
      produce only one "NULL" expression, which previously was not the case in
      1.3. However, the change also allows for ORM expressions to render as given
      as well, such as ``select(,`` will produce a result row with
      two columns.
    * Fixed issue where mypy plugin would crash when interpreting a
      ``query_expression()`` construct.
    * Added new methods :meth:`_orm.Session.scalars`,
    * Added loader options to :meth:`_orm.Session.merge` and
      :meth:`_asyncio.AsyncSession.merge` via a new
      :paramref:`_orm.Session.merge.options` parameter, which will apply the
      given loader options to the ``get()`` used internally by merge, allowing
      eager loading of relationships etc. to be applied when the merge process
      loads a new object. Pull request courtesy Daniel Stone.
    * Added initial support for the ``asyncmy`` asyncio database driver for MySQL
      and MariaDB. This driver is very new, however appears to be the only
      current alternative to the ``aiomysql`` driver which currently appears to
      be unmaintained and is not working with current Python versions. Much
      thanks to long2ice for the pull request for this dialect.
    * Fixed a two issues where combinations of ``select()`` and ``join()`` when
      adapted to form a copy of the element would not completely copy the state
      of all column objects associated with subqueries. A key problem this caused
      is that usage of the :meth:`_sql.ClauseElement.params` method (which should
      probably be moved into a legacy category as it is inefficient and error
      prone) would leave copies of the old :class:`_sql.BindParameter` objects
      around, leading to issues in correctly setting the parameters at execution
* Thu Jul 22 2021 Arun Persaud <>
  - update to version 1.4.22:
    * orm
      + Fixed issue in new Table.table_valued() method where the
      resulting TableValuedColumn construct would not respond
      correctly to alias adaptation as is used throughout the ORM,
      such as for eager loading, polymorphic loading, etc.
      + Fixed issue where usage of the Result.unique() method with an
      ORM result that included column expressions with unhashable
      types, such as JSON or ARRAY using non-tuples would silently
      fall back to using the id() function, rather than raising an
      error. This now raises an error when the Result.unique() method
      is used in a 2.0 style ORM query. Additionally, hashability is
      assumed to be True for result values of unknown type, such as
      often happens when using SQL functions of unknown return type;
      if values are truly not hashable then the hash() itself will
      + For legacy ORM queries, since the legacy Query object uniquifies
      in all cases, the old rules remain in place, which is to use
      id() for result values of unknown type as this legacy uniquing
      is mostly for the purpose of uniquing ORM entities and not
      column values.
      + Fixed an issue where clearing of mappers during things like test
      suite teardowns could cause a “dictionary changed size” warning
      during garbage collection, due to iteration of a
      weak-referencing dictionary. A list() has been applied to
      prevent concurrent GC from affecting this operation.
      + Fixed critical caching issue where the ORM’s persistence feature
      using INSERT..RETURNING would cache an incorrect query when
      mixing the “bulk save” and standard “flush” forms of INSERT.
    * engine
      + Added some guards against KeyError in the event system to
      accommodate the case that the interpreter is shutting down at
      the same time Engine.dispose() is being called, which would
      cause stack trace warnings.
    * sql
      + Fixed issue where use of the case.whens parameter passing a
      dictionary positionally and not as a keyword argument would emit
      a 2.0 deprecation warning, referring to the deprecation of
      passing a list positionally. The dictionary format of “whens”,
      passed positionally, is still supported and was accidentally
      marked as deprecated.
      + Fixed issue where type-specific bound parameter handlers would
      not be called upon in the case of using the Insert.values()
      method with the Python None value; in particular, this would be
      noticed when using the JSON datatype as well as related
      PostgreSQL specific types such as JSONB which would fail to
      encode the Python None value into JSON null, however the issue
      was generalized to any bound parameter handler in conjunction
      with this specific method of Insert.
  - changes from version 1.4.21:
    * orm
      + Modified the approach used for history tracking of scalar object
      relationships that are not many-to-one, i.e. one-to-one
      relationships that would otherwise be one-to-many. When
      replacing a one-to-one value, the “old” value that would be
      replaced is no longer loaded immediately, and is instead handled
      during the flush process. This eliminates an historically
      troublesome lazy load that otherwise often occurs when assigning
      to a one-to-one attribute, and is particularly troublesome when
      using “lazy=’raise’” as well as asyncio use cases.
      + This change does cause a behavioral change within the
      AttributeEvents.set() event, which is nonetheless currently
      documented, which is that the event applied to such a one-to-one
      attribute will no longer receive the “old” parameter if it is
      unloaded and the relationship.active_history flag is not set. As
      is documented in AttributeEvents.set(), if the event handler
      needs to receive the “old” value when the event fires off, the
      active_history flag must be established either with the event
      listener or with the relationship. This is already the behavior
      with other kinds of attributes such as many-to-one and column
      value references.
      + The change additionally will defer updating a backref on the
      “old” value in the less common case that the “old” value is
      locally present in the session, but isn’t loaded on the
      relationship in question, until the next flush occurs. If this
      causes an issue, again the normal relationship.active_history
      flag can be set to True on the relationship.
      + Fixed regression caused in 1.4.19 due to #6503 and related
      involving Query.with_entities() where the new structure used
      would be inappropriately transferred to an enclosing Query when
      making use of set operations such as Query.union(), causing the
      JOIN instructions within to be applied to the outside query as
      + Fixed regression which appeared in version 1.4.3 due to #6060
      where rules that limit ORM adaptation of derived selectables
      interfered with other ORM-adaptation based cases, in this case
      when applying adaptations for a with_polymorphic() against a
      mapping which uses a column_property() which in turn makes use
      of a scalar select that includes a aliased() object of the
      mapped table.
      + Fixed ORM regression where ad-hoc label names generated for
      hybrid properties and potentially other similar types of
      ORM-enabled expressions would usually be propagated outwards
      through subqueries, allowing the name to be retained in the
      final keys of the result set even when selecting from
      subqueries. Additional state is now tracked in this case that
      isn’t lost when a hybrid is selected out of a Core select /
    * sql
      + Added new method HasCTE.add_cte() to each of the select(),
      insert(), update() and delete() constructs. This method will add
      the given CTE as an “independent” CTE of the statement, meaning
      it renders in the WITH clause above the statement
      unconditionally even if it is not otherwise referenced in the
      primary statement. This is a popular use case on the PostgreSQL
      database where a CTE is used for a DML statement that runs
      against database rows independently of the primary statement.
      + Fixed issue in CTE constructs where a recursive CTE that
      referred to a SELECT that has duplicate column names, which are
      typically deduplicated using labeling logic in 1.4, would fail
      to refer to the deduplicated label name correctly within the
      WITH clause.
      + Fixed regression where the tablesample() construct would fail to
      be executable when constructed given a floating-point sampling
      value not embedded within a SQL function.
    * postgresql
      + Fixed issue in Insert.on_conflict_do_nothing() and
      Insert.on_conflict_do_update() where the name of a unique
      constraint passed as the constraint parameter would not be
      properly truncated for length if it were based on a naming
      convention that generated a too-long name for the PostgreSQL max
      identifier length of 63 characters, in the same way which occurs
      within a CREATE TABLE statement.
      + Fixed issue where the PostgreSQL ENUM datatype as embedded in
      the ARRAY datatype would fail to emit correctly in create/drop
      when the schema_translate_map feature were also in
      use. Additionally repairs a related issue where the same
      schema_translate_map feature would not work for the ENUM
      datatype in combination with a CAST, that’s also intrinsic to
      how the ARRAY(ENUM) combination works on the PostgreSQL dialect.
      + Fixed issue in Insert.on_conflict_do_nothing() and
      Insert.on_conflict_do_update() where the name of a unique
      constraint passed as the constraint parameter would not be
      properly quoted if it contained characters which required
    * mssql
      + Fixed regression where the special dotted-schema name handling
      for the SQL Server dialect would not function correctly if the
      dotted schema name were used within the schema_translate_map
* Sun Jul 11 2021 Antonio Larrosa <>
  - update to version 1.4.20:
    * orm
      + [orm] [bug] [regression] Fixed regression in ORM regarding
      an internal reconstitution step for the with_polymorphic()
      construct, when the user-facing object is garbage collected
      as the query is processed. The reconstitution was not
      ensuring the sub-entities for the “polymorphic” case were
      handled, leading to an AttributeError.
      References: #6680
      + [orm] [bug] [regression] Adjusted Query.union() and similar
      set operations to be correctly compatible with the new
      capabilities just added in #6661, with SQLAlchemy 1.4.19,
      such that the SELECT statements rendered as elements of the
      UNION or other set operation will include directly mapped
      columns that are mapped as deferred; this both fixes a
      regression involving unions with multiple levels of nesting
      that would produce a column mismatch, and also allows the
      undefer() option to be used at the top level of such a Query
      without having to apply the option to each of the elements
      within the UNION.
      References: #6678
      + [orm] [bug] Adjusted the check in the mapper for a callable
      object that is used as a @validates validator function or a
      @reconstructor reconstruction function, to check for
      “callable” more liberally such as to accommodate objects
      based on fundamental attributes like __func__ and __call___,
      rather than testing for MethodType / FunctionType, allowing
      things like cython functions to work properly. Pull request
      courtesy Miłosz Stypiński.
      References: #6538
    * engine
      + [engine] [bug] Fixed an issue in the C extension for the Row
      class which could lead to a memory leak in the unlikely case
      of a Row object which referred to an ORM object that then was
      mutated to refer back to the Row itself, creating a cycle.
      The Python C APIs for tracking GC cycles has been added to
      the native Row implementation to accommodate for this case.
      References: #5348
      + [engine] [bug] Fixed old issue where a select() made against
      the token “*”, which then yielded exactly one column, would
      fail to correctly organize the cursor.description column name
      into the keys of the result object.
      References: #6665
    * sql
      + [sql] [usecase] Add a impl parameter to PickleType
      constructor, allowing any arbitary type to be used in place
      of the default implementation of LargeBinary. Pull request
      courtesy jason3gb. References: #6646
      + [sql] [bug] [orm] Fixed the class hierarchy for the Sequence
      and the more general DefaultGenerator base, as these are
      “executable” as statements they need to include Executable
      in their hierarchy, not just StatementRole as was applied
      arbitrarily to Sequence previously. The fix allows Sequence
      to work in all .execute() methods including with
      Session.execute() which was not working in the case that a
      SessionEvents.do_orm_execute() handler was also established.
      References: #6668
    * schema
      + [schema] [bug] Fixed issue where passing None for the value
      of Table.prefixes would not store an empty list, but rather
      the constant None, which may be unexpected by third party
      dialects. The issue is revealed by a usage in recent versions
      of Alembic that are passing None for this value. Pull request
      courtesy Kai Mueller. References: #6685
    * mysql
      + [mysql] [usecase] Made a small adjustment in the table
      reflection feature of the MySQL dialect to accommodate for
      alternate MySQL-oriented databases such as TiDB which include
      their own “comment” directives at the end of a constraint
      directive within “CREATE TABLE” where the format doesn’t have
      the additional space character after the comment, in this
      case the TiDB “clustered index” feature. Pull request
      courtesy Daniël van Eeden.  References: #6659
    * misc
      + [bug] [ext] [regression] Fixed regression in
      sqlalchemy.ext.automap extension such that the use case of
      creating an explicit mapped class to a table that is also the
      relationship.secondary element of a relationship() that
      automap will be generating would emit the “overlaps” warnings
      introduced in 1.4 and discussed at relationship X will copy
      column Q to column P, which conflicts with relationship(s):
      ‘Y’. While generating this case from automap is still subject
      to the same caveats that the “overlaps” warning refers
      towards, as automap is intended for more ad-hoc use cases,
      the condition which produces the warning is disabled when a
      many-to-many relationship with this particular pattern is
      generated.  References: #6679
  - changes from version 1.4.19:
    * orm
      + [orm] [bug] [regression] Fixed further regressions in the
      same area as that of #6052 where loader options as well as
      invocations of methods like Query.join() would fail if the
      left side of the statement for which the option/join depends
      upon were replaced by using the Query.with_entities() method,
      or when using 2.0 style queries when using the
      Select.with_only_columns() method. A new set of state has
      been added to the objects which tracks the “left” entities
      that the options / join were made against which is memoized
      when the lead entities are changed.  References: #6253, #6503
      + [orm] [bug] Refined the behavior of ORM subquery rendering
      with regards to deferred columns and column properties to be
      more compatible with that of 1.3 while also providing for
      1.4’s newer features. As a subquery in 1.4 does not make use
      of loader options, including undefer(), a subquery that is
      against an ORM entity with deferred attributes will now
      render those deferred attributes that refer directly to
      mapped table columns, as these are needed in the outer SELECT
      if that outer SELECT makes use of these columns; however a
      deferred attribute that refers to a composed SQL expression
      as we normally do with column_property() will not be part of
      the subquery, as these can be selected explicitly if needed
      in the subquery. If the entity is being SELECTed from this
      subquery, the column expression can still render on “the
      outside” in terms of the derived subquery columns. This
      produces essentially the same behavior as when working with
      1.3. However in this case the fix has to also make sure that
      the .selected_columns collection of an ORM-enabled select()
      also follows these rules, which in particular allows
      recursive CTEs to render correctly in this scenario, which
      were previously failing to render correctly due to this
      issue.  References: #6661
    * sql
      + [sql] [bug] Fixed issue in CTE constructs mostly relevant to
      ORM use cases where a recursive CTE against “anonymous”
      labels such as those seen in ORM column_property() mappings
      would render in the WITH RECURSIVE xyz(...) section as their
      raw internal label and not a cleanly anonymized name.
      References: #6663
    * mypy
      + [mypy] [bug] Fixed issue in mypy plugin where class info for
      a custom declarative base would not be handled correctly on a
      cached mypy pass, leading to an AssertionError being raised.
      References: #6476
    * asyncio
      + [asyncio] [usecase] Implemented async_scoped_session to
      address some asyncio-related incompatibilities between
      scoped_session and AsyncSession, in which some methods
      (notably the async_scoped_session.remove() method) should
      be used with the await keyword.  References: #6583
      + [asyncio] [bug] [postgresql] Fixed bug in asyncio
      implementation where the greenlet adaptation system failed
      to propagate BaseException subclasses, most notably including
      asyncio.CancelledError, to the exception handling logic used
      by the engine to invalidate and clean up the connection, thus
      preventing connections from being correctly disposed when a
      task was cancelled. References: #6652
    * postgresql
      + [postgresql] [bug] [oracle] Fixed issue where the INTERVAL
      datatype on PostgreSQL and Oracle would produce an
      AttributeError when used in the context of a comparison
      operation against a timedelta() object. Pull request courtesy
      MajorDallas. References: #6649
      + [postgresql] [bug] Fixed issue where the pool “pre ping”
      feature would implicitly start a transaction, which would
      then interfere with custom transactional flags such as
      PostgreSQL’s “read only” mode when used with the psycopg2
      driver.  References: #6621
    * mysql
      + [mysql] [usecase] Added new construct match, which provides
      for the full range of MySQL’s MATCH operator including
      multiple column support and modifiers. Pull request courtesy
      Anton Kovalevich. References: #6132
    * mssql
      + [mssql] [change] Made improvements to the server version
      regexp used by the pymssql dialect to prevent a regexp
      overflow in case of an invalid version string.
      References: #6253, #6503
      + [mssql] [bug] Fixed bug where the “schema_translate_map”
      feature would fail to function correctly in conjunction with
      an INSERT into a table that has an IDENTITY column, where the
      value of the IDENTITY column were specified in the values of
      the INSERT thus triggering SQLAlchemy’s feature of setting
      IDENTITY INSERT to “on”; it’s in this directive where the
      schema translate map would fail to be honored.
      References: #6658
  - changes from version 1.4.18:
    * orm
      + [orm] [performance] [bug] [regression] Fixed regression
      involving how the ORM would resolve a given mapped column to
      a result row, where under cases such as joined eager loading,
      a slightly more expensive “fallback” could take place to set
      up this resolution due to some logic that was removed since
      1.3. The issue could also cause deprecation warnings
      involving column resolution to be emitted when using a 1.4
      style query with joined eager loading.  References: #6596
      + [orm] [bug] Clarified the current purpose of the
      relationship.bake_queries flag, which in 1.4 is to enable or
      disable “lambda caching” of statements within the “lazyload”
      and “selectinload” loader strategies; this is separate from
      the more foundational SQL query cache that is used for most
      statements. Additionally, the lazy loader no longer uses its
      own cache for many-to-one SQL queries, which was an
      implementation quirk that doesn’t exist for any other loader
      scenario. Finally, the “lru cache” warning that the
      lazyloader and selectinloader strategies could emit when
      handling a wide array of class/relationship combinations has
      been removed; based on analysis of some end-user cases, this
      warning doesn’t suggest any significant issue. While setting
      bake_queries=False for such a relationship will remove this
      cache from being used, there’s no particular performance gain
      in this case as using no caching vs. using a cache that needs
      to refresh often likely still wins out on the caching being
      used side. References: #6072, #6487
      + [orm] [bug] [regression] Adjusted the means by which classes
      such as scoped_session and AsyncSession are generated from
      the base Session class, such that custom Session subclasses
      such as that used by Flask-SQLAlchemy don’t need to implement
      positional arguments when they call into the superclass
      method, and can continue using the same argument styles as in
      previous releases. References: #6285
      + [orm] [bug] [regression] Fixed issue where query production
      for joinedload against a complex left hand side involving
      joined-table inheritance could fail to produce a correct
      query, due to a clause adaption issue.  References: #6595
      + [orm] [bug] Fixed issue in experimental “select ORM objects
      from INSERT/UPDATE” use case where an error was raised if
      the statement were against a single-table-inheritance
      subclass.  References: #6591
      + [orm] [bug] The warning that’s emitted for relationship()
      when multiple relationships would overlap with each other as
      far as foreign key attributes written towards, now includes
      the specific “overlaps” argument to use for each warning in
      order to silence the warning without changing the mapping.
      References: #6400
    * asyncio
      + [asyncio] [usecase] Implemented a new registry architecture
      that allows the Async version of an object, like
      AsyncSession, AsyncConnection, etc., to be locatable given
      the proxied “sync” object, i.e. Session, Connection.
      Previously, to the degree such lookup functions were used,
      an Async object would be re-created each time, which was
      less than ideal as the identity and state of the “async”
      object would not be preserved across calls.
      From there, new helper functions async_object_session(),
      async_session() as well as a new InstanceState attribute
      InstanceState.async_session have been added, which are used
      to retrieve the original AsyncSession associated with an ORM
      mapped object, a Session associated with an AsyncSession,
      and an AsyncSession associated with an InstanceState,
      respectively. This patch also implements new methods
      AsyncSession.get_nested_transaction(). References: #6319
      + [asyncio] [bug] Fixed an issue that presented itself when
      using the NullPool or the StaticPool with an async engine.
      This mostly affected the aiosqlite dialect.
      References: #6575
      + [asyncio] [bug] Added asyncio.exceptions.TimeoutError,
      asyncio.exceptions.CancelledError as so-called “exit
      exceptions”, a class of exceptions that include things
      like GreenletExit and KeyboardInterrupt, which are
      considered to be events that warrant considering a DBAPI
      connection to be in an unusable state where it should be
      recycled. References: #6592
    * postgresql
      + [postgresql] [bug] [regression] Fixed regression where using
      the PostgreSQL “INSERT..ON CONFLICT” structure would fail to
      work with the psycopg2 driver if it were used in an
      “executemany” context along with bound parameters in the
      “SET” clause, due to the implicit use of the psycopg2 fast
      execution helpers which are not appropriate for this style of
      INSERT statement; as these helpers are the default in 1.4
      this is effectively a regression. Additional checks to
      exclude this kind of statement from that particular extension
      have been added. References: #6581
    * sqlite
      + [sqlite] [bug] Add note regarding encryption-related pragmas
      for pysqlcipher passed in the url. This change is also
      backported to: 1.3.25. References: #6589
      + [sqlite] [bug] [regression] The fix for pysqlcipher released
      in version 1.4.3 #5848 was unfortunately non-working, in that
      the new on_connect_url hook was erroneously not receiving a
      URL object under normal usage of create_engine() and instead
      received a string that was unhandled; the test suite failed
      to fully set up the actual conditions under which this hook
      is called. This has been fixed. References: #6586
  - changes from version 1.4.17:
    * orm
      + [orm] [bug] [regression] Fixed regression caused by
      just-released performance fix mentioned in #6550 where a
      query.join() to a relationship could produce an
      AttributeError if the query were made against non-ORM
      structures only, a fairly unusual calling pattern.
      References: #6558
  - changes from version 1.4.16:
    * general
      + [general] [bug] Resolved various deprecation warnings which
      were appearing as of Python version 3.10.0b1.
      References: #6540, #6543
    * orm
      + [orm] [bug] Fixed issue when using
      relationship.cascade_backrefs parameter set to False, which
      per cascade_backrefs behavior deprecated for removal in 2.0
      is set to become the standard behavior in SQLAlchemy 2.0,
      where adding the item to a collection that uniquifies, such
      as set or dict would fail to fire a cascade event if the
      object were already associated in that collection via the
      backref. This fix represents a fundamental change in the
      collection mechanics by introducing a new event state which
      can fire off for a collection mutation even if there is no
      net change on the collection; the action is now suited using
      a new event hook AttributeEvents.append_wo_mutation().
      References: #6471
      + [orm] [bug] [regression] Fixed regression involving clause
      adaption of labeled ORM compound elements, such as
      single-table inheritance discriminator expressions with
      conditionals or CASE expressions, which could cause aliased
      expressions such as those used in ORM join / joinedload
      operations to not be adapted correctly, such as referring
      to the wrong table in the ON clause in a join.
      This change also improves a performance bump that was located
      within the process of invoking Select.join() given an ORM
      attribute as a target.  References: #6550
      + [orm] [bug] [regression] Fixed regression where the full
      combination of joined inheritance, global with_polymorphic,
      self-referential relationship and joined loading would fail
      to be able to produce a query with the scope of lazy loads
      and object refresh operations that also attempted to render
      the joined loader.  References: #6495
      + [orm] [bug] Enhanced the bind resolution rules for
      Session.execute() so that when a non-ORM statement such as
      an insert() construct nonetheless is built against ORM
      objects, to the greatest degree possible the ORM entity will
      be used to resolve the bind, such as for a Session that has
      a bind map set up on a common superclass without specific
      mappers or tables named in the map. References: #6484
    * engine
      + [engine] [bug] Fixed issue where an @ sign in the database
      portion of a URL would not be interpreted correctly if the
      URL also had a username:password section. References: #6482
      + [engine] [bug] Fixed a long-standing issue with URL where
      query parameters following the question mark would not be
      parsed correctly if the URL did not contain a database
      portion with a backslash. References: #6329
    * sql
      + [sql] [bug] [regression] Fixed regression in dynamic loader
      strategy and relationship() overall where the
      relationship.order_by parameter were stored as a mutable
      list, which could then be mutated when combined with
      additional “order_by” methods used against the dynamic
      query object, causing the ORDER BY criteria to continue
      to grow repetitively. References: #6549
    * mssql
      + [mssql] [usecase] Implemented support for a CTE construct to
      be used directly as the target of a delete() construct, i.e.
      “WITH … AS cte DELETE FROM cte”. This appears to be a useful
      feature of SQL Server.  References: #6464
    * misc
      + [bug] [ext] Fixed a deprecation warning that was emitted
      when using automap_base() without passing an existing Base.
      References: #6529
      + [bug] [pep484] Remove pep484 types from the code. Current
      effort is around the stub package, and having typing in two
      places makes thing worse, since the types in the SQLAlchemy
      source were usually outdated compared to the version in the
      stubs.  References: #6461
      + [bug] [ext] [regression] Fixed regression in the
      sqlalchemy.ext.instrumentation extension that prevented
      instrumentation disposal from working completely. This fix
      includes both a 1.4 regression fix as well as a fix for a
      related issue that existed in 1.3 also. As part of this
      change, the
      sqlalchemy.ext.instrumentation.InstrumentationManager class
      now has a new method unregister(), which replaces the
      previous method dispose(), which was not called as of
      version 1.4. References: #6390
  - Drop patch:
    * tests_overcome_bpo42967.patch
* Fri May 14 2021 Arun Persaud <>
  - updated line numbers in patch
  - update to version 1.4.15:
    * general
      + [general] [feature] A new approach has been applied to the
      warnings system in SQLAlchemy to accurately predict the
      appropriate stack level for each warning dynamically. This
      allows evaluating the source of SQLAlchemy-generated warnings
      and deprecation warnings to be more straightforward as the
      warning will indicate the source line within end-user code,
      rather than from an arbitrary level within SQLAlchemy’s own
      source code.
    * orm
      + [orm] [bug] [regression] Fixed additional regression caused by
      “eager loaders run on unexpire” feature #1763 where the feature
      would run for a contains_eager() eagerload option in the case
      that the contains_eager() were chained to an additional eager
      loader option, which would then produce an incorrect query as
      the original query-bound join criteria were no longer present.
      + [orm] [bug] Fixed issue in subquery loader strategy which
      prevented caching from working correctly. This would have been
      seen in the logs as a “generated” message instead of “cached”
      for all subqueryload SQL emitted, which by saturating the cache
      with new keys would degrade overall performance; it also would
      produce “LRU size alert” warnings.
    * sql
      + [sql] [bug] Adjusted the logic added as part of #6397 in 1.4.12
      so that internal mutation of the BindParameter object occurs
      within the clause construction phase as it did before, rather
      than in the compilation phase. In the latter case, the mutation
      still produced side effects against the incoming construct and
      additionally could potentially interfere with other internal
      mutation routines.
    * mysql
      + [mysql] [bug] [documentation] Added support for the
      ssl_check_hostname= parameter in mysql connection URIs and
      updated the mysql dialect documentation regarding secure
      connections. Original pull request courtesy of Jerry Zhao.
  - changes from version 1.4.14:
    * orm
      + [orm] [bug] [regression] Fixed regression involving
      lazy='dynamic' loader in conjunction with a detached object. The
      previous behavior was that the dynamic loader upon calling
      methods like .all() returns empty lists for detached objects
      without error, this has been restored; however a warning is now
      emitted as this is not the correct result. Other dynamic loader
      scenarios correctly raise DetachedInstanceError.
    * engine
      + [engine] [usecase] [orm] Applied consistent behavior to the use
      case of calling .commit() or .rollback() inside of an existing
      .begin() context manager, with the addition of potentially
      emitting SQL within the block subsequent to the commit or
      rollback. This change continues upon the change first added in
      [#6155] where the use case of calling “rollback” inside of a
      .begin() contextmanager block was proposed:
      o calling .commit() or .rollback() will now be allowed without
      error or warning within all scopes, including that of legacy
      and future Engine, ORM Session, asyncio
      AsyncEngine. Previously, the Session disallowed this.
      o The remaining scope of the context manager is then closed;
      when the block ends, a check is emitted to see if the
      transaction was already ended, and if so the block returns
      without action.
      o It will now raise an error if subsequent SQL of any kind is
      emitted within the block, after .commit() or .rollback() is
      called. The block should be closed as the state of the
      executable object would otherwise be undefined in this
      + [engine] [bug] [regression] Established a deprecation path for
      calling upon the CursorResult.keys() method for a statement that
      returns no rows to provide support for legacy patterns used by
      the “records” package as well as any other non-migrated
      applications. Previously, this would raise
      ResourceClosedException unconditionally in the same way as it
      does when attempting to fetch rows. While this is the correct
      behavior going forward, the _cursor.LegacyCursorResult object
      will now in this case return an empty list for .keys() as it did
      in 1.3, while also emitting a 2.0 deprecation warning. The
      _cursor.CursorResult, used when using a 2.0-style “future”
      engine, will continue to raise as it does now.
    * sql
      + [sql] [bug] [regression] Fixed regression caused by the “empty
      in” change just made in #6397 1.4.12 where the expression needs
      to be parenthesized for the “not in” use case, otherwise the
      condition will interfere with the other filtering criteria.
      + [sql] [bug] [regression] The TypeDecorator class will now emit a
      warning when used in SQL compilation with caching unless the
      .cache_ok flag is set to True or False. A new class-level
      attribute TypeDecorator.cache_ok may be set which will be used
      as an indication that all the parameters passed to the object
      are safe to be used as a cache key if set to True, False means
      they are not.
* Thu May 06 2021 Antonio Larrosa <>
  - Remove %ifpython2 (python2 flavor is disabled).
  - Do not use %if %{python_version_nodots} for BuildRequires.
* Wed May 05 2021 Antonio Larrosa <>
  - Remove broken %ifpython3 since the python2 flavor is disabled
* Tue May 04 2021 Antonio Larrosa <>
  - update to 1.4.13:
    * Fixed regression in selectinload loader strategy that would
      cause it to cache its internal state incorrectly when handling
      relationships that join across more than one column, such as
      when using a composite foreign key. The invalid caching would
      then cause other unrelated loader operations to fail.
      References: #6410
    * Fixed regression where Query.filter_by() would not work if the
      lead entity were a SQL function or other expression derived
      from the primary entity in question, rather than a simple
      entity or column of that entity. Additionally, improved the
      behavior of Select.filter_by() overall to work with column
      expressions even in a non-ORM context. References: #6414
    * Fixed regression where using selectinload() and subqueryload()
      to load a two-level-deep path would lead to an attribute error.
      References: #6419
    * Fixed regression where using the noload() loader strategy in
      conjunction with a “dynamic” relationship would lead to an
      attribute error as the noload strategy would attempt to apply
      itself to the dynamic loader. References: #6420
    * Restored a legacy transactional behavior that was inadvertently
      removed from the Connection as it was never tested as a known
      use case in previous versions, where calling upon the
      Connection.begin_nested() method, when no transaction is
      present, does not create a SAVEPOINT at all and instead starts
      an outer transaction, returning a RootTransaction object
      instead of a NestedTransaction object. This RootTransaction
      then will emit a real COMMIT on the database connection when
      committed. Previously, the 2.0 style behavior was present in
      all cases that would autobegin a transaction but not commit
      it, which is a behavioral change. When using a 2.0 style
      connection object, the behavior is unchanged from previous
      1.4 versions; calling Connection.begin_nested() will
      “autobegin” the outer transaction if not already present,
      and then as instructed emit a SAVEPOINT, returning the
      NestedTransaction object. The outer transaction is committed
      by calling upon Connection.commit(), as is “commit-as-you-go”
      style usage.
      In non-“future” mode, while the old behavior is restored,
      it also emits a 2.0 deprecation warning as this is a legacy
      behavior. References: #6408
    * Fixed a regression introduced by #6337 that would create an
      asyncio.Lock which could be attached to the wrong loop when
      instantiating the async engine before any asyncio loop was
      started, leading to an asyncio error message when attempting
      to use the engine under certain circumstances.
      References: #6409
    * Add support for server side cursors in the pg8000 dialect
      for PostgreSQL. This allows use of the
      Connection.execution_options.stream_results option.
      References: #6198
* Tue May 04 2021 Antonio Larrosa <>
  - Removed use of pytest-xdist which is giving intermitent
    failed builds with internal errors like:
    INTERNALERROR> E             RuntimeError: There is no current
    event loop in thread 'Dummy-1'.
    INTERNALERROR> /usr/lib/python3.9/site-packages/xdist/ AssertionError
    [gw6] node down: Not properly terminated
* Fri Apr 30 2021 Antonio Larrosa <>
  - Update to 1.4.12:
    * There are many changes between the 1.4 and 1.3 branch so please
      check the full list at:
  - Update to the 1.4 branch:
    Version 1.4 is taking on a different focus than other SQLAlchemy
    releases in that it is in many ways attempting to serve as a
    potential migration point for a more dramatic series of API
    changes currently planned for release 2.0 of SQLAlchemy.
    * Python 3.6 is the minimum Python 3 version; Python 2.7 still
    * ORM Query is internally unified with select, update, delete;
      2.0 style execution available.
    * Transparent SQL Compilation Caching added to All DQL,
      DML Statements in Core, ORM.
    * Declarative is now integrated into the ORM with new features
    * Python Dataclasses, attrs Supported w/ Declarative,
      Imperative Mappings.
    * Asynchronous IO Support for Core and ORM
    * Many Core and ORM statement objects now perform much of their
      construction and validation in the compile phase
    * Repaired internal importing conventions such that code linters
      may work correctly
    * Support for SQL Regular Expression operators
    * SQLAlchemy 2.0 Deprecations Mode
    * API and Behavioral Changes - Core
    - A SELECT statement is no longer implicitly considered to be
      a FROM clause
    - select().join() and outerjoin() add JOIN criteria to the
      current query, rather than creating a subquery
    - The URL object is now immutable
    - Changes to CreateEnginePlugin
    - select(), case() now accept positional expressions
    - All IN expressions render parameters for each value in the
      list on the fly (e.g. expanding parameters)
    - Built-in FROM linting will warn for any potential cartesian
      products in a SELECT statement
    - New Result object
    - RowProxy is no longer a “proxy”; is now called Row and
      behaves like an enhanced named tuple
    - Rationale: To behave more like a named tuple rather than
      a mapping
    - Proxying behavior goes away, was also unnecessary in
      modern usage
    - SELECT objects and derived FROM clauses allow for duplicate
      columns and column labels
    - Improved column labeling for simple column expressions using
      CAST or similar
    - New "post compile" bound parameters used for LIMIT/OFFSET
      in Oracle, SQL Server
    - Connection-level transactions can now be inactive based on
    - Enum and Boolean datatypes no longer default to "create
    * New Features - ORM
    - Raiseload for Columns
    - ORM Batch inserts with psycopg2 now batch statements with
      RETURNING in most cases
    - ORM Bulk Update and Delete use RETURNING for "fetch"
      strategy when available
    * Behavioral Changes - ORM
    - The "KeyedTuple" object returned by Query is replaced by Row
    - Session features new “autobegin” behavior
    - Viewonly relationships don’t synchronize backrefs
    - cascade_backrefs behavior deprecated for removal in 2.0
    - Eager loaders emit during unexpire operations
    - Accessing an uninitialized collection attribute on a
      transient object no longer mutates __dict__
    - The "New instance conflicts with existing identity" error
      is now a warning
    - Persistence-related cascade operations disallowed with
    - Stricter behavior when querying inheritance mappings using
      custom queries
    * Dialect Changes
    - psycopg2 version 2.7 or higher is required for the
      PostgreSQL psycopg2 dialect
    - psycopg2 dialect no longer has limitations regarding bound
      parameter names
    - psycopg2 dialect features "execute_values" with RETURNING
      for INSERT statements by default
    - Removed “join rewriting” logic from SQLite dialect;
      updated imports
    - Added Sequence support for MariaDB 10.3
    - Added Sequence support distinct from IDENTITY to SQL Server
    * For an explanation of each of those changes, check
  - For the full list of changes in each revision in the 1.4 branch
    please read:
  - Do not build the python2 flavor. Python 2.7 is supposed to be
    supported but currently fails to build.
  - Rebase patch:
    * tests_overcome_bpo42967.patch
* Tue Feb 23 2021 Matej Cepl <>
  - Add tests_overcome_bpo42967.patch to over effects of bpo#42967,
    which forbade mixing amps and semicolons in query strings as
    separators (gh#sqlalchemy/sqlalchemy#5969).
* Tue Feb 23 2021 Dirk Müller <>
  - update to 1.3.23:
    * Release 1.3.23 contains an array of bugfixes specific to dialects such as
      Oracle, PostgreSQL, and MySQL.
* Wed Jan 20 2021 John Vandenberg <>
  - Skip one failing test on Python 3.6
* Sat Dec 19 2020 Dirk Müller <>
  - update to 1.3.22:
    * Fixed regression which occured due to #5755 which implemented isolation
    level support for Oracle
    * bugfixes for various engines, see
* Mon Oct 19 2020 Adrian Schröter <>
  - added gpg pub key for source validation
  - Update to version 1.3.20
    pytest_depr_from_parent.patch is obsolete again
    * An ArgumentError with more detail is now raised if the target
      parameter for Query.join() is set to an unmapped object. Prior
      to this change a less detailed AttributeError was raised. Pull
      request courtesy Ramon Williams.  References: #4428
    * Fixed issue where using a loader option against a string attribute
      name that is not actually a mapped attribute, such as a plain
      Python descriptor, would raise an uninformative AttributeError;
      a descriptive error is now raised.  References: #4589
    * Fixed issue where a non-string object sent to SQLAlchemyError or a
      subclass, as occurs with some third party dialects, would fail to
      stringify correctly. Pull request courtesy Andrzej Bartosiński.
      References: #5599
    * Repaired a function-level import that was not using SQLAlchemy’s
      standard late-import system within the sqlalchemy.exc module.
      References: #5632
    * Fixed issue where the pickle.dumps() operation against Over construct
      would produce a recursion overflow.  References: #5644
    * Fixed bug where an error was not raised in the case where a column()
      were added to more than one table() at a time. This raised correctly
      for the Column and Table objects. An ArgumentError is now raised when
      this occurs.  References: #5618
    * The psycopg2 dialect now support PostgreSQL multiple host connections,
      by passing host/port combinations to the query string.
      References: #4392
    * Adjusted the Comparator.any() and Comparator.all() methods to implement
      a straight “NOT” operation for negation, rather than negating the
      comparison operator.  References: #5518
    * Fixed issue where the ENUM type would not consult the schema translate
      map when emitting a CREATE TYPE or DROP TYPE during the test to see if
      the type exists or not. Additionally, repaired an issue where if the
      same enum were encountered multiple times in a single DDL sequence,
      the “check” query would run repeatedly rather than relying upon a cached value.
      References: #5520
    * Adjusted the MySQL dialect to correctly parenthesize functional index
      expressions as accepted by MySQL 8. Pull request courtesy Ramon Williams.
      References: #5462
    * The “skip_locked” keyword used with with_for_update() will emit a warning
      when used on MariaDB backends, and will then be ignored. This is a
      deprecated behavior that will raise in SQLAlchemy 1.4, as an application
      that requests “skip locked” is looking for a non-blocking operation which
      is not available on those backends.
      References: #5568
    * Fixed bug where an UPDATE statement against a JOIN using MySQL multi-table
      format would fail to include the table prefix for the target table if the
      statement had no WHERE clause, as only the WHERE clause were scanned to
      detect a “multi table update” at that particular point. The target is now
      also scanned if it’s a JOIN to get the leftmost table as the primary table
      and the additional entries as additional FROM entries.
      References: #5617
    * Add new MySQL reserved words: cube, lateral added in MySQL 8.0.1 and 8.0.14,
      respectively; this indicates that these terms will be quoted if used as table
      or column identifier names.
      References: #5539
* Fri Oct 09 2020 Matej Cepl <>
  - Replace pytest_depr_from_parent.patch with the upstream commit resolving
    same issue (gh#sqlalchemy/sqlalchemy#commit40cdb9c0bf4d).
* Thu Oct 08 2020 Matej Cepl <>
  - Add pytest_depr_from_parent.patch to fix FTBGS with pytest 6.*
* Thu Aug 20 2020 Ondřej Súkup <>
  - update to 1.3.19
    * Adjusted the workings of the Mapper.all_orm_descriptors()
    * The name of the virtual column used when using the AbstractConcreteBase
      and ConcreteBase classes can now be customized
    * Repaired an issue where the “ORDER BY” clause rendering a label name rather
      than a complete expression
    * The LookupError message will now provide the user with up to four possible
      values that a column is constrained to via the Enum
    * Fixed issue where the Connection.execution_options.schema_translate_map
      feature would not take effect when the Sequence.next_value() function
      for a Sequence were used in the Column.server_default parameter
      and the create table DDL were emitted.
    * Added a **kw argument to the DeclarativeMeta.__init__() method
* Sun Jun 28 2020 Arun Persaud <>
  - update to version 1.3.18:
    * orm
      + Improve error message when using Query.filter_by() in a query
      where the first entity is not a mapped class.  References: #5326
      + Added a new parameter query_expression.default_expr to the
      query_expression() construct, which will be appled to queries
      automatically if the with_expression() option is not used. Pull
      request courtesy Haoyu Sun.  References: #5198
    * engine
      + Further refinements to the fixes to the “reset” agent fixed in
      [#5326], which now emits a warning when it is not being correctly
      invoked and corrects for the behavior. Additional scenarios have
      been identified and fixed where this warning was being emitted.
      References: #5326
      + Fixed issue in URL object where stringifying the object would
      not URL encode special characters, preventing the URL from being
      re-consumable as a real URL. Pull request courtesy Miguel
      Grinberg.  References: #5341
    * sql
      + Added a “.schema” parameter to the table() construct, allowing
      ad-hoc table expressions to also include a schema name. Pull
      request courtesy Dylan Modesitt.  References: #5309
      + Correctly apply self_group in type_coerce element.  The type
      coerce element did not correctly apply grouping rules when using
      in an expression References: #5344
      + Added Select.with_hint() output to the generic SQL string that
      is produced when calling str() on a statement. Previously, this
      clause would be omitted under the assumption that it was dialect
      specific. The hint text is presented within brackets to indicate
      the rendering of such hints varies among backends.  References:
      + Introduce IdentityOptions to store common parameters for
      sequences and identity columns.  References: #5324
      + Added .offset support to sybase dialect. Pull request courtesy
      Alan D. Snow.  References: #5294
    * schema
      + Fixed issue where dialect_options were omitted when a database
      object (e.g., Table) was copied using tometadata().  References:
    * mysql
      + Implemented row-level locking support for mysql. Pull request
      courtesy Quentin Somerville.  References: #4860
    * sqlite
      + SQLite 3.31 added support for computed column. This change
      enables their support in SQLAlchemy when targeting SQLite.
      References: #5297
      + Added “exists” to the list of reserved words for SQLite so that
      this word will be quoted when used as a label or column
      name. Pull request courtesy Thodoris Sotiropoulos.  References:
    * mssql
      + Refined the logic used by the SQL Server dialect to interpret
      multi-part schema names that contain many dots, to not actually
      lose any dots if the name does not have bracking or quoting
      used, and additionally to support a “dbname” token that has many
      parts including that it may have multiple,
      independently-bracketed sections.  References: #5364, #5366
      + Fixed an issue in the pyodbc connector such that a warning about
      pyodbc “drivername” would be emitted when using a totally empty
      URL. Empty URLs are normal when producing a non-connected
      dialect object or when using the “creator” argument to
      create_engine(). The warning now only emits if the driver name
      is missing but other parameters are still present.  References:
      + Fixed issue with assembling the ODBC connection string for the
      pyodbc DBAPI. Tokens containing semicolons and/or braces “{}”
      were not being correctly escaped, causing the ODBC driver to
      misinterpret the connection string attributes.  References:
      + Fixed issue where datetime.time parameters were being converted
      to datetime.datetime, making them incompatible with comparisons
      like >= against an actual TIME column.  References: #5339
      + Fixed an issue where the is_disconnect function in the SQL
      Server pyodbc dialect was incorrectly reporting the disconnect
      state when the exception messsage had a substring that matched a
      SQL Server ODBC error code.  References: #5359
      + Moved the supports_sane_rowcount_returning = False requirement
      from the PyODBCConnector level to the MSDialect_pyodbc since
      pyodbc does work properly in some circumstances.  References:
    * oracle
      + Fixed bug in Oracle dialect where indexes that contain the full
      set of primary key columns would be mistaken as the primary key
      index itself, which is omitted, even if there were
      multiples. The check has been refined to compare the name of the
      primary key constraint against the index name itself, rather
      than trying to guess based on the columns present in the index.
      References: #5421
    * misc
      + Added new option --raw to the examples.performance suite which
      will dump the raw profile test for consumption by any number of
      profiling visualizer tools. Removed the “runsnake” option as
      runsnake is very hard to build at this point;
* Sat May 23 2020 Arun Persaud <>
  - update to version 1.3.17:
    * orm
      + Added an accessor Comparator.expressions which provides access
      to the group of columns mapped under a multi-column
      ColumnProperty attribute.  References: #5262
      + Introduce relationship.sync_backref flag in a relationship to
      control if the synchronization events that mutate the in-Python
      attributes are added. This supersedes the previous change #5149,
      which warned that viewonly=True relationship target of a
      back_populates or backref configuration would be disallowed.
      References: #5237
      + Fixed bug where using with_polymorphic() as the target of a join
      via RelationshipComparator.of_type() on a mapper that already
      has a subquery-based with_polymorphic setting that’s equivalent
      to the one requested would not correctly alias the ON clause in
      the join.  References: #5288
      + Fixed issue in the area of where loader options such as
      selectinload() interact with the baked query system, such that
      the caching of a query is not supposed to occur if the loader
      options themselves have elements such as with_polymorphic()
      objects in them that currently are not cache-compatible. The
      baked loader could sometimes not fully invalidate itself in
      these some of these scenarios leading to missed eager loads.
      References: #5303
      + Modified the internal “identity set” implementation, which is a
      set that hashes objects on their id() rather than their hash
      values, to not actually call the __hash__() method of the
      objects, which are typically user-mapped objects. Some methods
      were calling this method as a side effect of the implementation.
      References: #5304
      + An informative error message is raised when an ORM many-to-one
      comparison is attempted against an object that is not an actual
      mapped instance. Comparisons such as those to scalar subqueries
      aren’t supported; generalized comparison with subqueries is
      better achieved using Comparator.has().  References: #5269
    * engine
      + Fixed fairly critical issue where the DBAPI connection could be
      returned to the connection pool while still in an un-rolled-back
      state. The reset agent responsible for rolling back the
      connection could be corrupted in the case that the transaction
      was “closed” without being rolled back or committed, which can
      occur in some scenarios when using ORM sessions and emitting
      .close() in a certain pattern involving savepoints. The fix
      ensures that the reset agent is always active.  References:
    * schema
      + Fixed issue where an Index that is deferred in being associated
      with a table, such as as when it contains a Column that is not
      associated with any Table yet, would fail to attach correctly if
      it also contained a non table-oriented expession.  References:
      + A warning is emitted when making use of the
      MetaData.sorted_tables attribute as well as the sort_tables()
      function, and the given tables cannot be correctly sorted due to
      a cyclic dependency between foreign key constraints. In this
      case, the functions will no longer sort the involved tables by
      foreign key, and a warning will be emitted. Other tables that
      are not part of the cycle will still be returned in dependency
      order. Previously, the sorted_table routines would return a
      collection that would unconditionally omit all foreign keys when
      a cycle was detected, and no warning was emitted.  References:
      + Add comment attribute to Column __repr__ method.  References:
    * postgresql
      + Added support for columns or type ARRAY of Enum, JSON or JSONB
      in PostgreSQL. Previously a workaround was required in these use
      cases.  References: #5265
      + Raise an explicit CompileError when adding a table with a column
      of type ARRAY of Enum configured with Enum.native_enum set to
      False when Enum.create_constraint is not set to False
      References: #5266
    * mssql
      + Fix a regression introduced by the reflection of computed column
      in MSSQL when using the legacy TDS version 4.2. The dialect will
      try to detect the protocol version of first connect and run in
      compatibility mode if it cannot detect it.  References: #5255
      + Fix a regression introduced by the reflection of computed column
      in MSSQL when using SQL server versions before 2012, which does
      not support the concat function.  References: #5271
    * oracle
      + Some modifications to how the cx_oracle dialect sets up
      per-column outputtype handlers for LOB and numeric datatypes to
      adjust for potential changes coming in cx_Oracle 8.  References:
      + Changed the implementation of fetching CLOB and BLOB objects to
      use cx_Oracle’s native implementation which fetches CLOB/BLOB
      objects inline with other result columns, rather than performing
      a separate fetch. As always, this can be disabled by setting
      auto_convert_lobs to False.
      + As part of this change, the behavior of a CLOB that was given a
      blank string on INSERT now returns None on SELECT, which is now
      consistent with that of VARCHAR on Oracle.  References: #5314
    * firebird
      + Adjusted dialect loading for firebird:// URIs so the external
      sqlalchemy-firebird dialect will be used if it has been
      installed, otherwise fall back to the (now deprecated) internal
      Firebird dialect.  References: #5278
* Thu Apr 09 2020 Arun Persaud <>
  - update to version 1.3.16:
    * orm
      + Fixed bug in orm.selectinload() loading option where two or more
      loaders that represent different relationships with the same
      string key name as referenced from a single
      orm.with_polymorphic() construct with multiple subclass mappers
      would fail to invoke each subqueryload separately, instead
      making use of a single string-based slot that would prevent the
      other loaders from being invoked.  References: #5228
      + Fixed issue where a lazyload that uses session-local “get”
      against a target many-to-one relationship where an object with
      the correct primary key is present, however it’s an instance of
      a sibling class, does not correctly return None as is the case
      when the lazy loader actually emits a load for that row.
      References: #5210
      + Modified the queries used by subqueryload and selectinload to no
      longer ORDER BY the primary key of the parent entity; this
      ordering was there to allow the rows as they come in to be
      copied into lists directly with a minimal level of Python-side
      collation. However, these ORDER BY clauses can negatively impact
      the performance of the query as in many scenarios these columns
      are derived from a subquery or are otherwise not actual primary
      key columns such that SQL planners cannot make use of
      indexes. The Python-side collation uses the native
      itertools.group_by() to collate the incoming rows, and has been
      modified to allow multiple row-groups-per-parent to be assembled
      together using list.extend(), which should still allow for
      relatively fast Python-side performance. There will still be an
      ORDER BY present for a relationship that includes an explicit
      order_by parameter, however this is the only ORDER BY that will
      be added to the query for both kinds of loading.  References:
    * orm declarative
      + The string argument accepted as the first positional argument by
      the relationship() function when using the Declarative API is no
      longer interpreted using the Python eval() function; instead,
      the name is dot separated and the names are looked up directly
      in the name resolution dictionary without treating the value as
      a Python expression. However, passing a string argument to the
      other relationship() parameters that necessarily must accept
      Python expressions will still use eval(); the documentation has
      been clarified to ensure that there is no ambiguity that this is
      in use.  See also Evaluation of relationship arguments - details
      on string evaluation References: #5238
    * sql
      + Add ability to literal compile a DateTime, Date or :class:”Time”
      when using the string dialect for debugging purposes. This
      change does not impact real dialect implementation that retain
      their current behavior.  References: #5052
    * schema
      + Added support for reflection of “computed” columns, which are
      now returned as part of the structure returned by
      Inspector.get_columns(). When reflecting full Table objects,
      computed columns will be represented using the Computed
      construct.  References: #5063
    * postgresql
      + Fixed issue where a “covering” index, e.g. those which have an
      INCLUDE clause, would be reflected including all the columns in
      INCLUDE clause as regular columns. A warning is now emitted if
      these additional columns are detected indicating that they are
      currently ignored. Note that full support for “covering” indexes
      is part of #4458. Pull request courtesy Marat Sharafutdinov.
      References: #5205
    * mysql
      + Fixed issue in MySQL dialect when connecting to a psuedo-MySQL
      database such as that provided by ProxySQL, the up front check
      for isolation level when it returns no row will not prevent the
      dialect from continuing to connect. A warning is emitted that
      the isolation level could not be detected.  References: #5239
    * sqlite
      + Implemented AUTOCOMMIT isolation level for SQLite when using
      pysqlite.  References: #5164
    * mssql
      + Added support for ColumnOperators.is_distinct_from() and
      ColumnOperators.isnot_distinct_from() to SQL Server, MySQL, and
      Oracle.  References: #5137
    * oracle
      + Implemented AUTOCOMMIT isolation level for Oracle when using
      cx_Oracle. Also added a fixed default isolation level of READ
      COMMITTED for Oracle.  References: #5200
      + Fixed regression / incorrect fix caused by fix for #5146 where
      the Oracle dialect reads from the “all_tab_comments” view to get
      table comments but fails to accommodate for the current owner of
      the table being requested, causing it to read the wrong comment
      if multiple tables of the same name exist in multiple schemas.
      References: #5146
    * misc
      + Fixed an issue that prevented the test suite from running with
      the recently released py.test 5.4.0.  References: #5201
      + Enum type now supports the parameter Enum.length to specify the
      length of the VARCHAR column to create when using non native
      enums by setting Enum.native_enum to False References: #5183
      + Ensured that the “pyproject.toml” file is not included in
      builds, as the presence of this file indicates to pip that a
      pep-517 installation process should be used. As this mode of
      operation appears to be not well supported by current tools /
      distros, these problems are avoided within the scope of
      SQLAlchemy installation by omitting the file.  References: #5207
* Sat Mar 14 2020 Dirk Mueller <>
  - update to 1.3.15:
    * Adjusted the error message emitted by :meth:`.Query.join` when a left hand
      side can't be located that the :meth:`.Query.select_from` method is the
      best way to resolve the issue.  Also, within the 1.3 series, used a
      deterministic ordering when determining the FROM clause from a given column
      entity passed to :class:`.Query` so that the same expression is determined
      each time.
    * Fixed regression in 1.3.14 due to :ticket:`4849` where a sys.exc_info()
      call failed to be invoked correctly when a flush error would occur. Test
      coverage has been added for this exception case.
    * Fixed bug where a CTE of an INSERT/UPDATE/DELETE that also uses RETURNING
      could then not be SELECTed from directly, as the internal state of the
      compiler would try to treat the outer SELECT as a DELETE statement itself
      and access nonexistent state.
    * Fixed regression caused in 1.3.13 by :ticket:`5056` where a refactor of the
      ORM path registry system made it such that a path could no longer be
      compared to an empty tuple, which can occur in a particular kind of joined
      eager loading path.   The "empty tuple" use case has been resolved so that
      the path registry is compared to a path registry in all cases;
  - Fix build for older distributions by buildrequiring a new-enough pytest
* Thu Mar 12 2020 Tomáš Chvátal <>
  - Fix build without python2
* Sun Jan 26 2020 Arun Persaud <>
  - specfile:
    * update copyright year
  - update to version 1.3.13:
    * orm
      + Added test support and repaired a wide variety of unnecessary
      reference cycles created for short-lived objects, mostly in the
      area of ORM queries. Thanks much to Carson Ip for the help on
      this.  References: #5050, #5056, #5071
      + Fixed regression in loader options introduced in 1.3.0b3 via
      [#4468] where the ability to create a loader option using
      PropComparator.of_type() targeting an aliased entity that is an
      inheriting subclass of the entity which the preceding
      relationship refers to would fail to produce a matching
      path. See also #5082 fixed in this same release which involves a
      similar kind of issue.  References: #5107
      + Fixed regression in joined eager loading introduced in 1.3.0b3
      via #4468 where the ability to create a joined option across a
      with_polymorphic() into a polymorphic subclass using
      RelationshipProperty.of_type() and then further along regular
      mapped relationships would fail as the polymorphic subclass
      would not add itself to the load path in a way that could be
      located by the loader strategy. A tweak has been made to resolve
      this scenario.  References: #5082
      + Repaired a warning in the ORM flush process that was not covered
      by test coverage when deleting objects that use the “version_id”
      feature. This warning is generally unreachable unless using a
      dialect that sets the “supports_sane_rowcount” flag to False,
      which is not typically the case however is possible for some
      MySQL configurations as well as older Firebird drivers, and
      likely some third party dialects.  References: #5068
      + Fixed bug where usage of joined eager loading would not properly
      wrap the query inside of a subquery when Query.group_by() were
      used against the query. When any kind of result-limiting
      approach is used, such as DISTINCT, LIMIT, OFFSET, joined eager
      loading embeds the row-limited query inside of a subquery so
      that the collection results are not impacted. For some reason,
      the presence of GROUP BY was never included in this criterion,
      even though it has a similar effect as using
      DISTINCT. Additionally, the bug would prevent using GROUP BY at
      all for a joined eager load query for most database platforms
      which forbid non-aggregated, non-grouped columns from being in
      the query, as the additional columns for the joined eager load
      would not be accepted by the database.  References: #5065
      + Identified a performance issue in the system by which a join is
      constructed based on a mapped relationship. The clause adaption
      system would be used for the majority of join expressions
      including in the common case where no adaptation is needed. The
      conditions under which this adaptation occur have been refined
      so that average non-aliased joins along a simple relationship
      without a “secondary” table use about 70% less function calls.
    * engine
      + Fixed issue where the collection of value processors on a
      Compiled object would be mutated when “expanding IN” parameters
      were used with a datatype that has bind value processors; in
      particular, this would mean that when using statement caching
      and/or baked queries, the same compiled._bind_processors
      collection would be mutated concurrently. Since these processors
      are the same function for a given bind parameter namespace every
      time, there was no actual negative effect of this issue,
      however, the execution of a Compiled object should never be
      causing any changes in its state, especially given that they are
      intended to be thread-safe and reusable once fully constructed.
      References: #5048
    * sql
      + A function created using GenericFunction can now specify that
      the name of the function should be rendered with or without
      quotes by assigning the quoted_name construct to the .name
      element of the object. Prior to 1.3.4, quoting was never applied
      to function names, and some quoting was introduced in #4467 but
      no means to force quoting for a mixed case name was
      available. Additionally, the quoted_name construct when used as
      the name will properly register its lowercase name in the
      function registry so that the name continues to be available via
      the func. registry.  See also GenericFunction References: #5079
    * postgresql
      + Added support for prefixes to the CTE construct, to allow
      support for Postgresql 12 “MATERIALIZED” and “NOT MATERIALIZED”
      phrases. Pull request courtesy Marat Sharafutdinov.  See also:
      HasCTE.cte() References: #5040
      + Fixed issue where the PostgreSQL dialect would fail to parse a
      reflected CHECK constraint that was a boolean-valued function
      (as opposed to a boolean-valued expression).  References: #5039
      + Improved detection of two phase transactions requirement for the
      PostgreSQL database by testing that max_prepared_transactions is
      set to a value greater than 0. Pull request courtesy Federico
      Caselli.  References: #5057
    * mssql
      + Fixed issue where a timezone-aware datetime value being
      converted to string for use as a parameter value of a
      mssql.DATETIMEOFFSET column was omitting the fractional seconds.
      References: #5045
    * misc
      + Fixed bug in sqlalchemy.ext.serializer where a unique
      BindParameter object could conflict with itself if it were
      present in the mapping itself, as well as the filter condition
      of the query, as one side would be used against the
      non-deserialized version and the other side would use the
      deserialized version. Logic is added to BindParameter similar to
      its “clone” method which will uniquify the parameter name upon
      deserialize so that it doesn’t conflict with its original.
      References: #5086
      + Fixed a few test failures which would occur on Windows due to
      SQLite file locking issues, as well as some timing issues in
      connection pool related tests; pull request courtesy Federico
      Caselli. References: #4946
* Fri Dec 20 2019 Dirk Mueller <>
  - update to version 1.3.12:
    * [orm] [bug] Fixed issue involving lazy="raise" strategy where an ORM delete
    of an object would raise for a simple “use-get” style many-to-one relationship
    that had lazy=”raise” configured. This is inconsistent vs. the change
    introduced in 1.3 as part of #4353, where it was established that a history
    operation that does not expect emit SQL should bypass the lazy="raise" check,
    and instead effectively treat it as lazy="raise_on_sql" for this case. The fix
    adjusts the lazy loader strategy to not raise for the case where the lazy load
    was instructed that it should not emit SQL if the object were not present.
    * [orm] [bug] Fixed regression introduced in 1.3.0 related to the association
    proxy refactor in #4351 that prevented composite() attributes from working in
    terms of an association proxy that references them.
    * [orm] [bug] Setting persistence-related flags on relationship() while also
    setting viewonly=True will now emit a regular warning, as these flags do not
    make sense for a viewonly=True relationship. In particular, the “cascade”
    settings have their own warning that is generated based on the individual
    values, such as “delete, delete-orphan”, that should not apply to a viewonly
    relationship. Note however that in the case of “cascade”, these settings are
    still erroneously taking effect even though the relationship is set up as
    “viewonly”. In 1.4, all persistence-related cascade settings will be disallowed
    on a viewonly=True relationship in order to resolve this issue.
    * [orm] [bug] [py3k] Fixed issue where when assigning a collection to itself
    as a slice, the mutation operation would fail as it would first erase the
    assigned collection inadvertently. As an assignment that does not change the
    contents should not generate events, the operation is now a no-op. Note that
    the fix only applies to Python 3; in Python 2, the __setitem__ hook isn’t
    called in this case; __setslice__ is used instead which recreates the list
    item-by-item in all cases.
    * [orm] [bug] Fixed issue where by if the “begin” of a transaction failed at
    the Core engine/connection level, such as due to network error or database is
    locked for some transactional recipes, within the context of the Session
    procuring that connection from the conneciton pool and then immediately
    returning it, the ORM Session would not close the connection despite this
    connection not being stored within the state of that Session. This would lead
    to the connection being cleaned out by the connection pool weakref handler
    within garbage collection which is an unpreferred codepath that in some special
    configurations can emit errors in standard error.
    * sql [sql] [bug] Fixed bug where “distinct” keyword passed to select() would
    not treat a string value as a “label reference” in the same way that the
    select.distinct() does; it would instead raise unconditionally. This keyword
    argument and the others passed to select() will ultimately be deprecated for
    SQLAlchemy 2.0.
    * [sql] [bug] Changed the text of the exception for “Can’t resolve label
    reference” to include other kinds of label coercions, namely that “DISTINCT” is
    also in this category under the PostgreSQL dialect.
* Sat Nov 16 2019 Arun Persaud <>
  - update to version 1.3.11:
    * orm
      + [orm] [bug] The relationship.omit_join flag was not intended to
      be manually set to True, and will now emit a warning when this
      occurs. The omit_join optimization is detected automatically,
      and the omit_join flag was only intended to disable the
      optimization in the hypothetical case that the optimization may
      have interfered with correct results, which has not been
      observed with the modern version of this feature. Setting the
      flag to True when it is not automatically detected may cause the
      selectin load feature to not work correctly when a non-default
      primary join condition is in use.  References: #4954
      + [orm] [bug] A warning is emitted if a primary key value is
      passed to Query.get() that consists of None for all primary key
      column positions. Previously, passing a single None outside of a
      tuple would raise a TypeError and passing a composite None
      (tuple of None values) would silently pass through. The fix now
      coerces the single None into a tuple where it is handled
      consistently with the other None conditions. Thanks to Lev
      Izraelit for the help with this.  References: #4915
      + [orm] [bug] The BakedQuery will not cache a query that was
      modified by a QueryEvents.before_compile() event, so that
      compilation hooks that may be applying ad-hoc modifications to
      queries will take effect on each run. In particular this is
      helpful for events that modify queries used in lazy loading as
      well as eager loading such as “select in” loading. In order to
      re-enable caching for a query modified by this event, a new flag
      bake_ok is added; see Using the before_compile event for
      details.  A longer term plan to provide a new form of SQL
      caching should solve this kind of issue more comprehensively.
      References: #4947
      + [orm] [bug] Fixed ORM bug where a “secondary” table that
      referred to a selectable which in some way would refer to the
      local primary table would apply aliasing to both sides of the
      join condition when a relationship-related join, either via
      Query.join() or by joinedload(), were generated. The “local”
      side is now excluded.  References: #4974
      + [orm] [usecase] Added accessor Query.is_single_entity() to
      Query, which will indicate if the results returned by this Query
      will be a list of ORM entities, or a tuple of entities or column
      expressions. SQLAlchemy hopes to improve upon the behavior of
      single entity / tuples in future releases such that the behavior
      would be explicit up front, however this attribute should be
      helpful with the current behavior. Pull request courtesy Patrick
      Hayes.  References: #4934
    * engine
      + [engine] [bug] Fixed bug where parameter repr as used in logging
      and error reporting needs additional context in order to
      distinguish between a list of parameters for a single statement
      and a list of parameter lists, as the “list of lists” structure
      could also indicate a single parameter list where the first
      parameter itself is a list, such as for an array parameter. The
      engine/connection now passes in an additional boolean indicating
      how the parameters should be considered. The only SQLAlchemy
      backend that expects arrays as parameters is that of psycopg2
      which uses pyformat parameters, so this issue has not been too
      apparent, however as other drivers that use positional gain more
      features it is important that this be supported. It also
      eliminates the need for the parameter repr function to guess
      based on the parameter structure passed.  References: #4902
      + [engine] [bug] [postgresql] Fixed bug in Inspector where the
      cache key generation did not take into account arguments passed
      in the form of tuples, such as the tuple of view name styles to
      return for the PostgreSQL dialect. This would lead the inspector
      to cache too generally for a more specific set of criteria. The
      logic has been adjusted to include every keyword element in the
      cache, as every argument is expected to be appropriate for a
      cache else the caching decorator should be bypassed by the
      dialect.  References: #4955
    * sql
      + [sql] [bug] [py3k] Changed the repr() of the quoted_name
      construct to use regular string repr() under Python 3, rather
      than running it through “backslashreplace” escaping, which can
      be misleading.  References: #4931
      + [sql] [usecase] Added new accessors to expressions of type JSON
      to allow for specific datatype access and comparison, covering
      strings, integers, numeric, boolean elements. This revises the
      documented approach of CASTing to string when comparing values,
      instead adding specific functionality into the PostgreSQL,
      SQlite, MySQL dialects to reliably deliver these basic types in
      all cases.  See also: JSON, JSON.Comparator.as_string(),
      JSON.Comparator.as_boolean(), JSON.Comparator.as_float(),
      JSON.Comparator.as_integer(), References: #4276
      + [sql] [usecase] The text() construct now supports “unique” bound
      parameters, which will dynamically uniquify themselves on
      compilation thus allowing multiple text() constructs with the
      same bound parameter names to be combined together.  References:
    * schema
      + [schema] [bug] Fixed bug where a table that would have a column
      label overlap with a plain column name, such as “ AS
      foo_id” vs. “foo.foo_id”, would prematurely generate the ._label
      attribute for a column before this overlap could be detected due
      to the use of the index=True or unique=True flag on the column
      in conjunction with the default naming convention of
      "column_0_label". This would then lead to failures when ._label
      were used later to generate a bound parameter name, in
      particular those used by the ORM when generating the WHERE
      clause for an UPDATE statement. The issue has been fixed by
      using an alternate ._label accessor for DDL generation that does
      not affect the state of the Column. The accessor also bypasses
      the key-deduplication step as it is not necessary for DDL, the
      naming is now consistently "<tablename>_<columnname>" without
      any subsequent numeric symbols when used in DDL.  References:
      + [schema] [usecase] Added DDL support for “computed columns”;
      these are DDL column specifications for columns that have a
      server-computed value, either upon SELECT (known as “virtual”)
      or at the point of which they are INSERTed or UPDATEd (known as
      “stored”). Support is established for Postgresql, MySQL, Oracle
      SQL Server and Firebird. Thanks to Federico Caselli for lots of
      work on this one.  See also: Computed (GENERATED ALWAYS AS)
      Columns References: #4894
    * mysql
      + [mysql] [bug] Added “Connection was killed” message interpreted
      from the base pymysql.Error class in order to detect closed
      connection, based on reports that this message is arriving via a
      pymysql.InternalError() object which indicates pymysql is not
      handling it correctly.  References: #4945
    * mssql
      + [mssql] [bug] Fixed issue in MSSQL dialect where an
      expression-based OFFSET value in a SELECT would be rejected,
      even though the dialect can render this expression inside of a
      ROW NUMBER-oriented LIMIT/OFFSET construct.  References: #4973
      + [mssql] [bug] Fixed an issue in the Engine.table_names() method
      where it would feed the dialect’s default schema name back into
      the dialect level table function, which in the case of SQL
      Server would interpret it as a dot-tokenized schema name as
      viewed by the mssql dialect, which would cause the method to
      fail in the case where the database username actually had a dot
      inside of it. In 1.3, this method is still used by the
      MetaData.reflect() function so is a prominent codepath. In 1.4,
      which is the current master development branch, this issue
      doesn’t exist, both because MetaData.reflect() isn’t using this
      method nor does the method pass the default schema name
      explicitly. The fix nonetheless guards against the default
      server name value returned by the dialect from being interpreted
      as dot-tokenized name under any circumstances by wrapping it in
      quoted_name().  References: #4923
    * oracle
      + [oracle] [bug] [firebird] Modified the approach of “name
      normalization” for the Oracle and Firebird dialects, which
      converts from the UPPERCASE-as-case-insensitive convention of
      these dialects into lowercase-as-case-insensitive for
      SQLAlchemy, to not automatically apply the quoted_name construct
      to a name that matches itself under upper or lower case
      conversion, as is the case for many non-european characters. All
      names used within metadata structures are converted to
      quoted_name objects in any case; the change here would only
      affect the output of some inspection functions.  References:
      + [oracle] [bug] The sqltypes.NCHAR datatype will now bind to the
      cx_Oracle.FIXED_NCHAR DBAPI data bindings when used in a bound
      parameter, which supplies proper comparison behavior against a
      variable-length string. Previously, the sqltypes.NCHAR datatype
      would bind to cx_oracle.NCHAR which is not fixed length; the
      sqltypes.CHAR datatype already binds to cx_Oracle.FIXED_CHAR so
      it is now consistent that sqltypes.NCHAR binds to
      cx_Oracle.FIXED_NCHAR.  References: #4913
      + [oracle] [usecase] Added dialect-level flag encoding_errors to
      the cx_Oracle dialect, which can be specified as part of
      create_engine(). This is passed to SQLAlchemy’s unicode decoding
      converter under Python 2, and to cx_Oracle’s cursor.var() object
      as the encodingErrors parameter under Python 3, for the very
      unusual case that broken encodings are present in the target
      database which cannot be fetched unless error handling is
      relaxed. The value is ultimately one of the Python “encoding
      errors” parameters passed to decode().  References: #4799
    * firebird
      + [firebird] [bug] Added additional “disconnect” message “Error
      writing data to the connection” to Firebird disconnection
      detection. Pull request courtesy lukens.  References: #4903
    * misc
      + [bug] [tests] Fixed test failures which would occur with newer
      SQLite as of version 3.30 or greater, due to their addition of
      nulls ordering syntax as well as new restrictions on aggregate
      functions. Pull request courtesy Nils Philippsen.  References:
      + [bug] [installation] [windows] Added a workaround for a
      setuptools-related failure that has been observed as occurring
      on Windows installations, where setuptools is not correctly
      reporting a build error when the MSVC build dependencies are not
      installed and therefore not allowing graceful degradation into
      non C extensions builds.  References: #4967
* Thu Nov 14 2019 Tomáš Chvátal <>
  - This package needs full fledged python on runtime so make sure
    we require it
* Wed Oct 30 2019 Tomáš Chvátal <>
  - Update to 1.3.10:
    * Fixed regression in selectinload loader strategy
    * Passing a plain string expression to Session.query() is deprecated
    * A warning is emitted for a condition in which the Session may
      implicitly swap an object out of the identity map for another one
      with the same primary key
* Sat Aug 31 2019 Arun Persaud <>
  - update to version 1.3.8:
    * orm
      + Fixed bug where Load objects were not pickleable due to
      mapper/relationship state in the internal context
      dictionary. These objects are now converted to picklable using
      similar techniques as that of other elements within the loader
      option system that have long been serializable.  References:
      + Added support for the use of an Enum datatype using Python
      pep-435 enumeration objects as values for use as a primary key
      column mapped by the ORM. As these values are not inherently
      sortable, as required by the ORM for primary keys, a new
      TypeEngine.sort_key_function attribute is added to the typing
      system which allows any SQL type to implement a sorting for
      Python objects of its type which is consulted by the unit of
      work. The Enum type then defines this using the database value
      of a given enumeration. The sorting scheme can be also be
      redefined by passing a callable to the Enum.sort_key_function
      parameter. Pull request courtesy Nicolas Caniart.  References:
    * engine
      + Added new parameter create_engine.hide_parameters which when set
      to True will cause SQL parameters to no longer be logged, nor
      rendered in the string representation of a StatementError
      object.  References: #4815
      + Fixed an issue whereby if the dialect “initialize” process which
      occurs on first connect would encounter an unexpected exception,
      the initialize process would fail to complete and then no longer
      attempt on subsequent connection attempts, leaving the dialect
      in an un-initialized, or partially initialized state, within the
      scope of parameters that need to be established based on
      inspection of a live connection. The “invoke once” logic in the
      event system has been reworked to accommodate for this
      occurrence using new, private API features that establish an
      “exec once” hook that will continue to allow the initializer to
      fire off on subsequent connections, until it completes without
      raising an exception. This does not impact the behavior of the
      existing once=True flag within the event system.  References:
    * postgresql
      + Revised the approach for the just added support for the psycopg2
      “execute_values()” feature added in 1.3.7 for #4623. The
      approach relied upon a regular expression that would fail to
      match for a more complex INSERT statement such as one which had
      subqueries involved. The new approach matches exactly the string
      that was rendered as the VALUES clause.  References: #4623
      + Fixed bug where Postgresql operators such as
      postgresql.ARRAY.Comparator.contains() and
      postgresql.ARRAY.Comparator.contained_by() would fail to
      function correctly for non-integer values when used against a
      postgresql.array object, due to an erroneous assert statement.
      References: #4822
      + Added support for reflection of CHECK constraints that include
      the special PostgreSQL qualifier “NOT VALID”, which can be
      present for CHECK constraints that were added to an exsiting
      table with the directive that they not be applied to existing
      data in the table. The PostgreSQL dictionary for CHECK
      constraints as returned by Inspector.get_check_constraints() may
      include an additional entry dialect_options which within will
      contain an entry "not_valid": True if this symbol is
      detected. Pull request courtesy Bill Finn.  References: #4824
    * sqlite
      + Fixed bug where a FOREIGN KEY that was set up to refer to the
      parent table by table name only without the column names would
      not correctly be reflected as far as setting up the “referred
      columns”, since SQLite’s PRAGMA does not report on these columns
      if they weren’t given explicitly. For some reason this was
      harcoded to assume the name of the local column, which might
      work for some cases but is not correct. The new approach
      reflects the primary key of the referred table and uses the
      constraint columns list as the referred columns list, if the
      remote column(s) aren’t present in the reflected pragma
      directly.  References: #4810
* Sun Aug 25 2019 Arun Persaud <>
  - update to version 1.3.7:
    * orm
      + Fixed regression caused by new selectinload for many-to-one
      logic where a primaryjoin condition not based on real foreign
      keys would cause KeyError if a related object did not exist for
      a given key value on the parent object.  References: #4777
      + Fixed bug where using Query.first() or a slice expression in
      conjunction with a query that has an expression based “offset”
      applied would raise TypeError, due to an “or” conditional
      against “offset” that did not expect it to be a SQL expression
      as opposed to an integer or None.  References: #4803
    * sql
      + Fixed issue where Index object which contained a mixture of
      functional expressions which were not resolvable to a particular
      column, in combination with string-based column names, would
      fail to initialize its internal state correctly leading to
      failures during DDL compilation.  References: #4778
      + Fixed bug where TypeEngine.column_expression() method would not
      be applied to subsequent SELECT statements inside of a UNION or
      other CompoundSelect, even though the SELECT statements are
      rendered at the topmost level of the statement. New logic now
      differentiates between rendering the column expression, which is
      needed for all SELECTs in the list, vs. gathering the returned
      data type for the result row, which is needed only for the first
      SELECT.  References: #4787
      + Fixed issue where internal cloning of SELECT constructs could
      lead to a key error if the copy of the SELECT changed its state
      such that its list of columns changed. This was observed to be
      occurring in some ORM scenarios which may be unique to 1.3 and
      above, so is partially a regression fix.  References: #4780
    * postgresql
      + Added new dialect flag for the psycopg2 dialect,
      executemany_mode which supersedes the previous experimental
      use_batch_mode flag. executemany_mode supports both the “execute
      batch” and “execute values” functions provided by psycopg2, the
      latter which is used for compiled insert() constructs. Pull
      request courtesy Yuval Dinari.  See also: Psycopg2 Fast
      Execution Helpers; References: #4623
    * mysql
      + The MySQL dialects will emit “SET NAMES” at the start of a
      connection when charset is given to the MySQL driver, to appease
      an apparent behavior observed in MySQL 8.0 that raises a
      collation error when a UNION includes string columns unioned
      against columns of the form CAST(NULL AS CHAR(..)), which is
      what SQLAlchemy’s polymorphic_union function does. The issue
      seems to have affected PyMySQL for at least a year, however has
      recently appeared as of mysqlclient 1.4.4 based on changes in
      how this DBAPI creates a connection. As the presence of this
      directive impacts three separate MySQL charset settings which
      each have intricate effects based on their presense, SQLAlchemy
      will now emit the directive on new connections to ensure correct
      behavior.  References: #4804
      + Added another fix for an upstream MySQL 8 issue where a case
      sensitive table name is reported incorrectly in foreign key
      constraint reflection, this is an extension of the fix first
      added for #4344 which affects a case sensitive column name. The
      new issue occurs through MySQL 8.0.17, so the general logic of
      the 88718 fix remains in place.  See also: - upstream bug;
      References: #4751
      + Added reserved words ARRAY and MEMBER to the MySQL reserved
      words list, as MySQL 8.0 has now made these reserved.
      References: #4783
    * sqlite
      + The dialects that support json are supposed to take arguments
      json_serializer and json_deserializer at the create_engine()
      level, however the SQLite dialect calls them _json_serilizer and
      _json_deserilalizer. The names have been corrected, the old
      names are accepted with a change warning, and these parameters
      are now documented as create_engine.json_serializer and
      create_engine.json_deserializer.  References: #4798
      + Fixed bug where usage of “PRAGMA table_info” in SQLite dialect
      meant that reflection features to detect for table existence,
      list of table columns, and list of foreign keys, would default
      to any table in any attached database, when no schema name was
      given and the table did not exist in the base schema. The fix
      explicitly runs PRAGMA for the ‘main’ schema and then the ‘temp’
      schema if the ‘main’ returned no rows, to maintain the behavior
      of tables + temp tables in the “no schema” namespace, attached
      tables only in the “schema” namespace.  References: #4793
    * mssql
      + Added new mssql.try_cast() construct for SQL Server which emits
      “TRY_CAST” syntax. Pull request courtesy Leonel Atencio.
      References: #4782
    * misc
      + Fixed issue in event system where using the once=True flag with
      dynamically generated listener functions would cause event
      registration of future events to fail if those listener
      functions were garbage collected after they were used, due to an
      assumption that a listened function is strongly referenced. The
      “once” wrapped is now modified to strongly reference the inner
      function persistently, and documentation is updated that using
      “once” does not imply automatic de-registration of listener
      functions.  References: #4794
* Mon Jul 22 2019 Todd R <>
  - update to version 1.3.6
    + orm
    * [feature] Added new loader option method Load.options()
      which allows loader options to be constructed hierarchically,
      so that many sub-options can be applied to a particular path
      without needing to call defaultload() many times.
    * [bug] Fixed regression caused by #4365 where a join from an
      entity to itself without using aliases no longer raises an
      informative error message, instead failing on an assertion.
      The informative error condition has been restored.
    * [bug] Fixed an issue where the orm._ORMJoin.join() method,
      which is a not-internally-used ORM-level method that exposes
      what is normally an internal process of Query.join(), did
      not propagate the full and outerjoin keyword arguments
    * [bug] Fixed bug where a many-to-one relationship that
      specified uselist=True would fail to update correctly during
      a primary key change where a related column needs to change.
    * [bug] Fixed bug where the detection for many-to-one or
      one-to-one use with a “dynamic” relationship, which is an
      invalid configuration, would fail to raise if the
      relationship were configured with uselist=True. The current
      fix is that it warns, instead of raises, as this would
      otherwise be backwards incompatible, however in a future
      release it will be a raise.
    * [bug] Fixed bug where a synonym created against a mapped
      attribute that does not exist yet, as is the case when it
      refers to backref before mappers are configured, would raise
      recursion errors when trying to test for attributes on it
      which ultimately don’t exist (as occurs when the classes are
      run through Sphinx autodoc), as the unconfigured state of
      the synonym would put it into an attribute not found loop.
    * [performance] The optimzation applied to selectin loading
      in #4340 where a JOIN is not needed to eagerly load related
      items is now applied to many-to-one relationships as well,
      so that only the related table is queried for a simple join
      condition. In this case, the related items are queried based
      on the value of a foreign key column on the parent; if these
      columns are deferred or otherwise not loaded on any of the
      parent objects in the collection, the loader falls back to the
      JOIN method.
    + engine
    * [bug] Fixed bug where using reflection function such as
      MetaData.reflect() with an Engine object that had execution
      options applied to it would fail, as the resulting
      OptionEngine proxy object failed to include a .engine
      attribute used within the reflection routines.
    + sql
    * [bug] Adjusted the initialization for Enum to minimize how
      often it invokes the .__members__ attribute of a given
      PEP-435 enumeration object, to suit the case where this
      attribute is expensive to invoke, as is the case for some
      popular third party enumeration libraries.
    * [bug] [postgresql] Fixed issue where the array_agg construct
      in combination with FunctionElement.filter() would not
      produce the correct operator precedence in combination
      with the array index operator.
    * [bug] Fixed an unlikely issue where the “corresponding
      column” routine for unions and other CompoundSelect objects
      could return the wrong column in some overlapping column
      situtations, thus potentially impacting some ORM operations
      when set operations are in use, if the underlying select()
      constructs were used previously in other similar kinds of
      routines, due to a cached value not being cleared.
    + postgresql
    * [usecase] Added support for reflection of indexes on
      PostgreSQL partitioned tables, which was added to PostgreSQL
      as of version 11.
    * [usecase] Added support for multidimensional Postgresql array
      literals via nesting the postgresql.array object within
      another one. The multidimensional array type is detected
    + mysql
    * [bug] Fixed bug where the special logic to render “NULL” for
      the TIMESTAMP datatype when nullable=True would not work if the
      column’s datatype were a TypeDecorator or a Variant. The logic
      now ensures that it unwraps down to the original TIMESTAMP so
      that this special case NULL keyword is correctly rendered when
    * [bug] Enhanced MySQL/MariaDB version string parsing to
      accommodate for exotic MariaDB version strings where the
      “MariaDB” word is embedded among other alphanumeric
      characters such as “MariaDBV1”. This detection is critical
      in order to correctly accommodate for API features that have
      split between MySQL and MariaDB such as the
      “transaction_isolation” system variable.
    + sqlite
    * [usecase] Added support for composite (tuple) IN operators
      with SQLite, by rendering the VALUES keyword for this backend.
      As other backends such as DB2 are known to use the same syntax,
      the syntax is enabled in the base compiler using a dialect-level
      flag tuple_in_values. The change also includes support for
      “empty IN tuple” expressions for SQLite when using “in_()”
      between a tuple value and an empty set.
    + mssql
    * [bug] Ensured that the queries used to reflect indexes and
      view definitions will explicitly CAST string parameters into
      NVARCHAR, as many SQL Server drivers frequently treat string
      values, particularly those with non-ascii characters or
      larger string values, as TEXT which often don’t compare
      correctly against VARCHAR characters in SQL Server’s
      information schema tables for some reason. These CAST
      operations already take place for reflection queries against
      SQL Server information_schema. tables but were missing from
      three additional queries that are against sys.tables.
* Mon Jun 24 2019 Arun Persaud <>
  - update to version 1.3.5:
    * orm
      + Fixed a series of related bugs regarding joined table
      inheritance more than two levels deep, in conjunction with
      modification to primary key values, where those primary key
      columns are also linked together in a foreign key relationship
      as is typical for joined table inheritance. The intermediary
      table in a three-level inheritance hierachy will now get its
      UPDATE if only the primary key value has changed and
      passive_updates=False (e.g. foreign key constraints not being
      enforced), whereas before it would be skipped; similarly, with
      passive_updates=True (e.g. ON UPDATE CASCADE in effect), the
      third-level table will not receive an UPDATE statement as was
      the case earlier which would fail since CASCADE already modified
      it. In a related issue, a relationship linked to a three-level
      inheritance hierarchy on the primary key of an intermediary
      table of a joined-inheritance hierarchy will also correctly have
      its foreign key column updated when the parent object’s primary
      key is modified, even if that parent object is a subclass of the
      linked parent class, whereas before these classes would not be
      counted.  References: #4723
      + Fixed bug where the Mapper.all_orm_descriptors accessor would
      return an entry for the Mapper itself under the declarative
      __mapper___ key, when this is not a descriptor. The
      .is_attribute flag that’s present on all InspectionAttr objects
      is now consulted, which has also been modified to be True for an
      association proxy, as it was erroneously set to False for this
      object.  References: #4729
      + Fixed regression in Query.join() where the aliased=True flag
      would not properly apply clause adaptation to filter criteria,
      if a previous join were made to the same entity. This is because
      the adapters were placed in the wrong order. The order has been
      reversed so that the adapter for the most recent aliased=True
      call takes precedence as was the case in 1.2 and earlier. This
      broke the “elementtree” examples among other things.
      References: #4704
      + Replaced the Python compatbility routines for getfullargspec()
      with a fully vendored version from Python 3.3. Originally,
      Python was emitting deprecation warnings for this function in
      Python 3.8 alphas. While this change was reverted, it was
      observed that Python 3 implementations for getfullargspec() are
      an order of magnitude slower as of the 3.4 series where it was
      rewritten against Signature. While Python plans to improve upon
      this situation, SQLAlchemy projects for now are using a simple
      replacement to avoid any future issues.  References: #4674
      + Reworked the attribute mechanics used by AliasedClass to no
      longer rely upon calling __getattribute__ on the MRO of the
      wrapped class, and to instead resolve the attribute normally on
      the wrapped class using getattr(), and then unwrap/adapt
      that. This allows a greater range of attribute styles on the
      mapped class including special __getattr__() schemes; but it
      also makes the code simpler and more resilient in general.
      References: #4694
    * sql
      + Fixed a series of quoting issues which all stemmed from the
      concept of the literal_column() construct, which when being
      “proxied” through a subquery to be referred towards by a label
      that matches its text, the label would not have quoting rules
      applied to it, even if the string in the Label were set up as a
      quoted_name construct. Not applying quoting to the text of the
      Label is a bug because this text is strictly a SQL identifier
      name and not a SQL expression, and the string should not have
      quotes embedded into it already unlike the literal_column()
      which it may be applied towards. The existing behavior of a
      non-labeled literal_column() being propagated as is on the
      outside of a subquery is maintained in order to help with manual
      quoting schemes, although it’s not clear if valid SQL can be
      generated for such a construct in any case.  References: #4730
    * postgresql
      + Fixed bug where PostgreSQL dialect could not correctly reflect
      an ENUM datatype that has no members, returning a list with None
      for the get_enums() call and raising a TypeError when reflecting
      a column which has such a datatype. The inspection now returns
      an empty list.  References: #4701
      + Added support for column sorting flags when reflecting indexes
      for PostgreSQL, including ASC, DESC, NULLSFIRST, NULLSLAST. Also
      adds this facility to the reflection system in general which can
      be applied to other dialects in future releases. Pull request
      courtesy Eli Collins.  References: #4717
    * mysql
      + Fixed bug where MySQL ON DUPLICATE KEY UPDATE would not
      accommodate setting a column to the value NULL. Pull request
      courtesy Lukáš Banič.  References: #4715
* Sat Jun 08 2019 Arun Persaud <>
  - update to version 1.3.4:
    * orm
      + Fixed issue where the AttributeEvents.active_history flag would
      not be set for an event listener that propgated to a subclass
      via the AttributeEvents.propagate flag. This bug has been
      present for the full span of the AttributeEvents system.
      References: #4695
      + Fixed regression where new association proxy system was still
      not proxying hybrid attributes when they made use of the
      @hybrid_property.expression decorator to return an alternate SQL
      expression, or when the hybrid returned an arbitrary
      PropComparator, at the expression level. This involved futher
      generalization of the heuristics used to detect the type of
      object being proxied at the level of QueryableAttribute, to
      better detect if the descriptor ultimately serves mapped classes
      or column expressions.  References: #4690
      + Applied the mapper “configure mutex” against the declarative
      class mapping process, to guard against the race which can occur
      if mappers are used while dynamic module import schemes are
      still in the process of configuring mappers for related
      classes. This does not guard against all possible race
      conditions, such as if the concurrent import has not yet
      encountered the dependent classes as of yet, however it guards
      against as much as possible within the SQLAlchemy declarative
      process.  References: #4686
      + A warning is now emitted for the case where a transient object
      is being merged into the session with Session.merge() when that
      object is already transient in the Session. This warns for the
      case where the object would normally be double-inserted.
      References: #4647
      + Fixed regression in new relationship m2o comparison logic first
      introduced at Improvement to the behavior of many-to-one query
      expressions when comparing to an attribute that is persisted as
      NULL and is in an un-fetched state in the mapped instance. Since
      the attribute has no explicit default, it needs to default to
      NULL when accessed in a persistent setting.  References: #4676
    * engine
      + Moved the “rollback” which occurs during dialect initialization
      so that it occurs after additional dialect-specific initialize
      steps, in particular those of the psycopg2 dialect which would
      inadvertently leave transactional state on the first new
      connection, which could interfere with some psycopg2-specific
      APIs which require that no transaction is started. Pull request
      courtesy Matthew Wilkes.  References: #4663
    * sql
      + Fixed that the GenericFunction class was inadvertently
      registering itself as one of the named functions. Pull request
      courtesy Adrien Berchet.  References: #4653
      + Fixed issue where double negation of a boolean column wouldn’t
      reset the “NOT” operator.  References: #4618
      + The GenericFunction namespace is being migrated so that function
      names are looked up in a case-insensitive manner, as SQL
      functions do not collide on case sensitive differences nor is
      this something which would occur with user-defined functions or
      stored procedures. Lookups for functions declared with
      GenericFunction now use a case insensitive scheme, however a
      deprecation case is supported which allows two or more
      GenericFunction objects with the same name of different cases to
      exist, which will cause case sensitive lookups to occur for that
      particular name, while emitting a warning at function
      registration time. Thanks to Adrien Berchet for a lot of work on
      this complicated feature.  References: #4569
    * postgresql
      + Fixed an issue where the “number of rows matched” warning would
      emit even if the dialect reported
      “supports_sane_multi_rowcount=False”, as is the case for
      psycogp2 with use_batch_mode=True and others.  References: #4661
    * mysql
      + Added support for DROP CHECK constraint which is required by
      MySQL 8.0.16 to drop a CHECK constraint; MariaDB supports plain
      DROP CONSTRAINT. The logic distinguishes between the two
      syntaxes by checking the server version string for MariaDB
      presence. Alembic migrations has already worked around this
      issue by implementing its own DROP for MySQL / MariaDB CHECK
      constraints, however this change implements it straight in Core
      so that its available for general use. Pull request courtesy
      Hannes Hansen.  References: #4650
    * mssql
      + Added support for SQL Server filtered indexes, via the
      mssql_where parameter which works similarly to that of the
      postgresql_where index function in the PostgreSQL dialect.  See
      also: Filtered Indexes References: #4657
      + Added error code 20047 to “is_disconnect” for pymssql. Pull
      request courtesy Jon Schuff.  References: #4680
    * misc
      + Removed errant “” symbol from which
      created an undesirable warning message.  References: #4625
* Sun Apr 21 2019 Arun Persaud <>
  - update to version 1.3.3:
    * orm
      + Fixed 1.3 regression in new “ambiguous FROMs” query logic
      introduced in Query.join() handles ambiguity in deciding the
      “left” side more explicitly where a Query that explicitly places
      an entity in the FROM clause with Query.select_from() and also
      joins to it using Query.join() would later cause an “ambiguous
      FROM” error if that entity were used in additional joins, as the
      entity appears twice in the “from” list of the Query. The fix
      resolves this ambiguity by folding the standalone entity into
      the join that it’s already a part of in the same way that
      ultimately happens when the SELECT statement is rendered.
      References: #4584
      + Adjusted the Query.filter_by() method to not call and()
      internally against multiple criteria, instead passing it off to
      Query.filter() as a series of criteria, instead of a single
      criteria. This allows Query.filter_by() to defer to
      Query.filter()’s treatment of variable numbers of clauses,
      including the case where the list is empty. In this case, the
      Query object will not have a .whereclause, which allows
      subsequent “no whereclause” methods like Query.select_from() to
      behave consistently.  References: #4606
    * postgresql
      + Fixed regression from release 1.3.2 caused by #4562 where a URL
      that contained only a query string and no hostname, such as for
      the purposes of specifying a service file with connection
      information, would no longer be propagated to psycopg2
      properly. The change in #4562 has been adjusted to further suit
      psycopg2’s exact requirements, which is that if there are any
      connection parameters whatsoever, the “dsn” parameter is no
      longer required, so in this case the query string parameters are
      passed alone.  References: #4601
    * mssql
      + Fixed issue in SQL Server dialect where if a bound parameter
      were present in an ORDER BY expression that would ultimately not
      be rendered in the SQL Server version of the statement, the
      parameters would still be part of the execution parameters,
      leading to DBAPI-level errors. Pull request courtesy Matt
      Lewellyn.  References: #4587
    * misc
      + Fixed behavioral regression as a result of deprecating the
      “use_threadlocal” flag for Pool, where the SingletonThreadPool
      no longer makes use of this option which causes the “rollback on
      return” logic to take place when the same Engine is used
      multiple times in the context of a transaction to connect or
      implicitly execute, thereby cancelling the transaction. While
      this is not the recommended way to work with engines and
      connections, it is nonetheless a confusing behavioral change as
      when using SingletonThreadPool, the transaction should stay open
      regardless of what else is done with the same engine in the same
      thread. The use_threadlocal flag remains deprecated however the
      SingletonThreadPool now implements its own version of the same
      logic.  References: #4585
      + Fixed bug where using copy.copy() or copy.deepcopy() on
      MutableList would cause the items within the list to be
      duplicated, due to an inconsistency in how Python pickle and
      copy both make use of __getstate__() and __setstate__()
      regarding lists. In order to resolve, a __reduce_ex__ method had
      to be added to MutableList. In order to maintain backwards
      compatibility with existing pickles based on __getstate__(), the
      __setstate__() method remains as well; the test suite asserts
      that pickles made against the old version of the class can still
      be deserialized by the pickle module.  References: #4603
* Wed Apr 10 2019 Arun Persaud <>
  - update to version 1.3.2:
    * orm
      + [orm] [bug] [ext] Restored instance-level support for plain
      Python descriptors, e.g. @property objects, in conjunction with
      association proxies, in that if the proxied object is not within
      ORM scope at all, it gets classified as “ambiguous” but is
      proxed directly. For class level access, a basic class
      level"__get__()" now returns the
      AmbiguousAssociationProxyInstance directly, rather than raising
      its exception, which is the closest approximation to the
      previous behavior that returned the AssociationProxy itself
      that’s possible. Also improved the stringification of these
      objects to be more descriptive of current state.  References:
      [#4573], #4574
      + [orm] [bug] Fixed bug where use of with_polymorphic() or other
      aliased construct would not properly adapt when the aliased
      target were used as the Select.correlate_except() target of a
      subquery used inside of a column_property(). This required a fix
      to the clause adaption mechanics to properly handle a selectable
      that shows up in the “correlate except” list, in a similar
      manner as which occurs for selectables that show up in the
      “correlate” list. This is ultimately a fairly fundamental bug
      that has lasted for a long time but it is hard to come across
      it.  References: #4537
      + [orm] [bug] Fixed regression where a new error message that was
      supposed to raise when attempting to link a relationship option
      to an AliasedClass without using PropComparator.of_type() would
      instead raise an AttributeError. Note that in 1.3, it is no
      longer valid to create an option path from a plain mapper
      relationship to an AliasedClass without using
      PropComparator.of_type().  References: #4566
    * sql
      + [sql] [bug] [documentation] Thanks to TypeEngine methods
      bind_expression, column_expression work with Variant,
      type-specific types, we no longer need to rely on recipes that
      subclass dialect-specific types directly, TypeDecorator can now
      handle all cases. Additionally, the above change made it
      slightly less likely that a direct subclass of a base SQLAlchemy
      type would work as expected, which could be
      misleading. Documentation has been updated to use TypeDecorator
      for these examples including the PostgreSQL “ArrayOfEnum”
      example datatype and direct support for the “subclass a type
      directly” has been removed.  References: #4580
    * postgresql
      + [postgresql] [feature] Added support for parameter-less
      connection URLs for the psycopg2 dialect, meaning, the URL can
      be passed to create_engine() as "postgresql+psycopg2://" with no
      additional arguments to indicate an empty DSN passed to libpq,
      which indicates to connect to “localhost” with no username,
      password, or database given. Pull request courtesy Julian
      Mehnle.  References: #4562
      + [postgresql] [bug] Modified the Select.with_for_update.of
      parameter so that if a join or other composed selectable is
      passed, the individual Table objects will be filtered from it,
      allowing one to pass a join() object to the parameter, as occurs
      normally when using joined table inheritance with the ORM. Pull
      request courtesy Raymond Lu.  References: #4550
* Sun Mar 10 2019 Arun Persaud <>
  - specfile:
    * removed test.patch (included upstream)
  - update to version 1.3.1:
    * orm
      + [orm] [bug] [ext] Fixed regression where an association proxy
      linked to a synonym would no longer work, both at instance level
      and at class level.  References: #4522
    * mssql
      + [mssql] [bug] A commit() is emitted after an isolation level
      change to SNAPSHOT, as both pyodbc and pymssql open an implicit
      transaction which blocks subsequent SQL from being emitted in
      the current transaction.  References: #4536
      + [mssql] [bug] Fixed regression in SQL Server reflection due to
      [#4393] where the removal of open-ended **kw from the Float
      datatype caused reflection of this type to fail due to a “scale”
      argument being passed.  References: #4525
* Wed Mar 06 2019 Tomáš Chvátal <>
  - Add patch to fix test failure from upstream test.patch
* Wed Mar 06 2019 Tomáš Chvátal <>
  - Update to versrion 1.3.0 (bsc#1124593, CVE-2019-7164, CVE-2019-7548):
    * See
      for deprecation list with this version
    * For the changes see
* Fri Feb 22 2019 John Vandenberg <>
  - Re-add build dependency on python-devel, removed December 2018,
    used for optional C extensions, and
  - update to v1.2.18
    Bugfix releases, find details at
* Thu Feb 21 2019 Adrian Schröter <>
  - version update to 1.2.17
* Sat Feb 09 2019 Adrian Schröter <>
  - update to version 1.2.16:
    Bugfix releases, find details at
  - 1.2.16 includes the fix to maintain compiled_params / replacement_expressions
    within expanding IN (bsc#1176953)
* Tue Dec 04 2018 Matej Cepl <>
  - Remove superfluous devel dependency for noarch package
* Mon Nov 12 2018 Arun Persaud <>
  - update to version 1.2.14:
    * orm
      + [orm] [bug] 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.
      References: #4357
      + [orm] [bug] 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.
      References: #4347
    * mysql
      + [mysql] [bug] 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.  References: #4361
* Thu Nov 01 2018 Arun Persaud <>
  - update to version 1.2.13:
    * orm
      + [orm] [bug] Fixed bug where “dynamic” loader needs to explicitly
      set the “secondary” table in the FROM clause of the query, to
      suit the case where the secondary is a join object that is
      otherwise not pulled into the query from its columns alone.
      References: #4349
    * orm declarative
      + [bug] [declarative] [orm] Fixed regression caused by #4326 in
      version 1.2.12 where using declared_attr with a mixin in
      conjunction with orm.synonym() would fail to map the synonym
      properly to an inherited subclass.  References: #4350
      + [bug] [declarative] [orm] The column conflict resolution
      technique discussed at Resolving Column Conflicts is now
      functional for a Column that is also a primary key
      column. Previously, a check for primary key columns declared on
      a single-inheritance subclass would occur before the column copy
      were allowed to pass.  References: #4352
    * sql
      + [sql] [feature] Refactored SQLCompiler to expose a
      SQLCompiler.group_by_clause() method similar to the
      SQLCompiler.order_by_clause() and SQLCompiler.limit_clause()
      methods, which can be overridden by dialects to customize how
      GROUP BY renders. Pull request courtesy Samuel Chou.
      + [sql] [bug] Fixed bug where the Enum.create_constraint flag on
      the Enum datatype would not be propagated to copies of the type,
      which affects use cases such as declarative mixins and abstract
      bases.  References: #4341
    * postgresql
      + [postgresql] [bug] Added support for the aggregate_order_by
      function to receive multiple ORDER BY elements, previously only
      a single element was accepted.  References: #4337
    * mysql
      + [mysql] [bug] Added word function to the list of reserved words
      for MySQL, which is now a keyword in MySQL 8.0 References: #4348
      + [mysql] [bug] Added a workaround for a MySQL bug #88718
      introduced in the 8.0 series, where the reflection of a foreign
      key constraint is not reporting the correct case sensitivity for
      the referred column, leading to errors during use of the
      reflected constraint such as when using the automap
      extension. The workaround emits an additional query to the
      information_schema tables in order to retrieve the correct case
      sensitive name.  References: #4344
    * misc
      + [misc] [bug] Fixed issue where part of the utility language
      helper internals was passing the wrong kind of argument to the
      Python __import__ builtin as the list of modules to be
      imported. The issue produced no symptoms within the core library
      but could cause issues with external applications that redefine
      the __import__ builtin or otherwise instrument it. Pull request
      courtesy Joe Urciuoli.
      + [misc] [bug] [py3k] Fixed additional warnings generated by
      Python 3.7 due to changes in the organization of the Python
      collections and packages. Previous collections
      warnings were fixed in version 1.2.11. Pull request courtesy
      xtreak.  References: #4339
      + [bug] [ext] Added missing .index() method to list-based
      association collections in the association proxy extension.
* Sat Sep 22 2018 Arun Persaud <>
  - update to version 1.2.12:
    * orm
      + [orm] [bug] Added a check within the weakref cleanup for the
      InstanceState object to check for the presence of the dict
      builtin, in an effort to reduce error messages generated when
      these cleanups occur during interpreter shutdown. Pull request
      courtesy Romuald Brunet.
      + [orm] [bug] Fixed bug where use of Lateral construct in
      conjunction with Query.join() as well as
      Query.select_entity_from() would not apply clause adaption to
      the right side of the join. “lateral” introduces the use case of
      the right side of a join being correlatable. Previously,
      adaptation of this clause wasn’t considered. Note that in 1.2
      only, a selectable introduced by Query.subquery() is still not
      adapted due to #4304; the selectable needs to be produced by the
      select() function to be the right side of the “lateral” join.
      References: #4334
      + [orm] [bug] Fixed 1.2 regression caused by #3472 where the
      handling of an “updated_at” style column within the context of a
      post-update operation would also occur for a row that is to be
      deleted following the update, meaning both that a column with a
      Python-side value generator would show the now-deleted value
      that was emitted for the UPDATE before the DELETE (which was not
      the previous behavor), as well as that a SQL- emitted value
      generator would have the attribute expired, meaning the previous
      value would be unreachable due to the row having been deleted
      and the object detached from the session.The “postfetch” logic
      that was added as part of #3472 is now skipped entirely for an
      object that ultimately is to be deleted.  References: #4327
    * orm declarative
      + [bug] [declarative] [orm] Fixed bug where the declarative scan
      for attributes would receive the expression proxy delivered by a
      hybrid attribute at the class level, and not the hybrid
      attribute itself, when receiving the descriptor via the
      @declared_attr callable on a subclass of an already-mapped
      class. This would lead to an attribute that did not report
      itself as a hybrid when viewed within
      Mapper.all_orm_descriptors.  References: #4326
    * postgresql
      + [postgresql] [bug] Fixed bug in PostgreSQL dialect where
      compiler keyword arguments such as literal_binds=True were not
      being propagated to a DISTINCT ON expression.  References: #4325
      + [postgresql] [bug] Fixed the postgresql.array_agg() function,
      which is a slightly altered version of the usual
      functions.array_agg() function, to also accept an incoming
      “type” argument without forcing an ARRAY around it, essentially
      the same thing that was fixed for the generic function in 1.1 in
      [#4107].  References: #4324
      + [postgresql] [bug] Fixed bug in PostgreSQL ENUM reflection where
      a case-sensitive, quoted name would be reported by the query
      including quotes, which would not match a target column during
      table reflection as the quotes needed to be stripped off.
      References: #4323
    * oracle
      + [oracle] [bug] Fixed issue for cx_Oracle 7.0 where the behavior
      of Oracle param.getvalue() now returns a list, rather than a
      single scalar value, breaking autoincrement logic throughout the
      Core and ORM. The dml_ret_array_val compatibility flag is used
      for cx_Oracle 6.3 and 6.4 to establish compatible behavior with
      7.0 and forward, for cx_Oracle 6.2.1 and prior a version number
      check falls back to the old logic.  References: #4335
    * misc
      + [bug] [ext] Fixed issue where BakedQuery did not include the
      specific query class used by the Session as part of the cache
      key, leading to incompatibilities when using custom query
      classes, in particular the ShardedQuery which has some different
      argument signatures.  References: #4328
* Sat Aug 25 2018
  - update to version 1.2.11:
    * orm declarative
      + [bug] [declarative] [orm] Fixed issue in previously untested use
      case, allowing a declarative mapped class to inherit from a
      classically-mapped class outside of the declarative base,
      including that it accommodates for unmapped intermediate
      classes. An unmapped intermediate class may specify
      __abstract__, which is now interpreted correctly, or the
      intermediate class can remain unmarked, and the classically
      mapped base class will be detected within the hierarchy
      regardless. In order to anticipate existing scenarios which may
      be mixing in classical mappings into existing declarative
      hierarchies, an error is now raised if multiple mapped bases are
      detected for a given class.   References: #4321
    * sql
      + [sql] [bug] Fixed issue that is closely related to #3639 where
      an expression rendered in a boolean context on a non-native
      boolean backend would be compared to 1/0 even though it is
      already an implcitly boolean expression, when
      ColumnElement.self_group() were used. While this does not affect
      the user-friendly backends (MySQL, SQLite) it was not handled by
      Oracle (and possibly SQL Server). Whether or not the expression
      is implicitly boolean on any database is now determined up front
      as an additional check to not generate the integer comparison
      within the compliation of the statement.  References: #4320
      + [sql] [bug] Added missing window function parameters
      WithinGroup.over.range_ and WithinGroup.over.rows parameters to
      the WithinGroup.over() and FunctionFilter.over() methods, to
      correspond to the range/rows feature added to the “over” method
      of SQL functions as part of #3049 in version 1.1.  References:
      + [sql] [bug] Fixed bug where the multi-table support for UPDATE
      and DELETE statements did not consider the additional FROM
      elements as targets for correlation, when a correlated SELECT
      were also combined with the statement. This change now includes
      that a SELECT statement in the WHERE clause for such a statement
      will try to auto-correlate back to these additional tables in
      the parent UPDATE/DELETE or unconditionally correlate if
      Select.correlate() is used. Note that auto-correlation raises an
      error if the SELECT statement would have no FROM clauses as a
      result, which can now occur if the parent UPDATE/DELETE
      specifies the same tables in its additional set of tables;
      specify Select.correlate() explicitly to resolve.  References:
    * oracle
      + [oracle] [bug] For cx_Oracle, Integer datatypes will now be
      bound to “int”, per advice from the cx_Oracle
      developers. Previously, using cx_Oracle.NUMBER caused a loss in
      precision within the cx_Oracle 6.x series.  References: #4309
    * misc
      + [bug] [py3k] Started importing “collections” from
      “” under Python 3.3 and greater for Python 3.8
      compatibility. Pull request courtesy Nathaniel Knight.
      + Fixed issue where the “schema” name used for a SQLite database
      within table reflection would not quote the schema name
      correctly. Pull request courtesy Phillip Cloud.
* Sat Jul 14 2018
  - update to version 1.2.10:
    * orm
      + [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.  References: #4295
      + [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.  References: #4298
    * sql
      + [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.  References: #4300
* Sun Jul 01 2018
  - removed patch fix_test_reflection.patch (included upstream)
  - update to version 1.2.9:
    * orm
      + [orm] [bug] 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.
      References: #3505
      + [orm] [bug] 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.
      References: #4287
      + [orm] [bug] 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
      References: #4286
      + [orm] [bug] 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.
      References: #4269
      + [orm] [bug] 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.
      References: #4270
    * sql
      + [sql] [bug] Fixed regression in 1.2 due to #4147 where a Table
      that has had some of its indexed columns redefined with new
      ones, as would occur when overriding columns during reflection
      or when using Table.extend_existing, such that the
      Table.tometadata() method would fail when attempting to copy
      those indexes as they still referred to the replaced column. The
      copy logic now accommodates for this condition.
      References: #4279
    * mysql
      + [mysql] [bug] Fixed percent-sign doubling in
      mysql-connector-python dialect, which does not require
      de-doubling of percent signs. Additionally, the mysql-
      connector-python driver is inconsistent in how it passes the
      column names in cursor.description, so a workaround decoder has
      been added to conditionally decode these
      randomly-sometimes-bytes values to unicode only if needed. Also
      improved test support for mysql-connector-python, however it
      should be noted that this driver still has issues with unicode
      that continue to be unresolved as of yet.
      + [mysql] [bug] Fixed bug in index reflection where on MySQL 8.0
      an index that includes ASC or DESC in an indexed column
      specfication would not be correctly reflected, as MySQL 8.0
      introduces support for returning this information in a table
      definition string.
      References: #4293
      + [mysql] [bug] Fixed bug in MySQLdb dialect and variants such as
      PyMySQL where an additional “unicode returns” check upon
      connection makes explicit use of the “utf8” character set, which
      in MySQL 8.0 emits a warning that utf8mb4 should be used. This
      is now replaced with a utf8mb4 equivalent. Documentation is also
      updated for the MySQL dialect to specify utf8mb4 in all
      examples. Additional changes have been made to the test suite to
      use utf8mb3 charsets and databases (there seem to be collation
      issues in some edge cases with utf8mb4), and to support
      configuration default changes made in MySQL 8.0 such as
      explicit_defaults_for_timestamp as well as new errors raised for
      invalid MyISAM indexes.
      References: #4283
      + [mysql] [bug] The Update construct now accommodates a Join
      object as supported by MySQL for UPDATE..FROM. As the construct
      already accepted an alias object for a similar purpose, the
      feature of UPDATE against a non-table was already implied so
      this has been added.
      References: #3645
    * sqlite
      + [sqlite] [bug] Fixed issue in test suite where SQLite 3.24 added
      a new reserved word that conflicted with a usage in
      TypeReflectionTest. Pull request courtesy Nils Philippsen.
    * mssql
      + [mssql] [bug] Fixed bug in MSSQL reflection where when two
      same-named tables in different schemas had same-named primary
      key constraints, foreign key constraints referring to one of the
      tables would have their columns doubled, causing errors. Pull
      request courtesy Sean Dunn.
      References: #4228
      + [mssql] [bug] [py3k] Fixed issue within the SQL Server dialect
      under Python 3 where when running against a non-standard SQL
      server database that does not contain either the
      “sys.dm_exec_sessions” or “sys.dm_pdw_nodes_exec_sessions”
      views, leading to a failure to fetch the isolation level, the
      error raise would fail due to an UnboundLocalError.
      References: #4273
    * oracle
      + [oracle] [feature] Added a new event currently used only by the
      cx_Oracle dialect, DialectEvents.setiputsizes(). The event
      passes a dictionary of BindParameter objects to DBAPI-specific
      type objects that will be passed, after conversion to parameter
      names, to the cx_Oracle cursor.setinputsizes() method. This
      allows both visibility into the setinputsizes process as well as
      the ability to alter the behavior of what datatypes are passed
      to this method.
      See als Fine grained control over cx_Oracle data binding and performance with setinputsizes
      References: #4290
      + [oracle] [bug] [mysql] Fixed INSERT FROM SELECT with CTEs for
      the Oracle and MySQL dialects, where the CTE was being placed
      above the entire statement as is typical with other databases,
      however Oracle and MariaDB 10.2 wants the CTE underneath the
      “INSERT” segment. Note that the Oracle and MySQL dialects don’t
      yet work when a CTE is applied to a subquery inside of an UPDATE
      or DELETE statement, as the CTE is still applied to the top
      rather than inside the subquery.
      References: #4275
    * misc
      + [feature] [ext] Added new attribute Query.lazy_loaded_from which
      is populated with an InstanceState that is using this Query in
      order to lazy load a relationship. The rationale for this is
      that it serves as a hint for the horizontal sharding feature to
      use, such that the identity token of the state can be used as
      the default identity token to use for the query within
      References: #4243
      + [bug] [py3k] Replaced the usage of inspect.formatargspec() with
      a vendored version copied from the Python standard library, as
      inspect.formatargspec() is deprecated and as of Python 3.7.0 is
      emitting a warning.
      References: #4291
* Tue Jun 26 2018
  - add upstream fix_test_reflection.patch to fix tests with new sqlite
* Thu Jun 21 2018
  - update to version 1.2.8:
    * orm
      + [orm] [bug] Fixed regression in 1.2.7 caused by #4228, which
      itself was fixing a 1.2-level regression, where the query_cls
      callable passed to a Session was assumed to be a subclass of
      Query with class method availability, as opposed to an
      arbitrary callable. In particular, the dogpile caching example
      illustrates query_cls as a function and not a Query subclass.
      References: #4256
      + [orm] [bug] Fixed a long-standing regression that occurred in
      version 1.0, which prevented the use of a custom MapperOption
      that alters the _params of a Query object for a lazy load,
      since the lazy loader itself would overwrite those parameters.
      This applies to the “temporal range” example on the wiki. Note
      however that the Query.populate_existing() method is now
      required in order to rewrite the mapper options associated with
      an object already loaded in the identity map.
      As part of this change, a custom defined MapperOption will now
      cause lazy loaders related to the target object to use a non-
      baked query by default unless the
      MapperOption._generate_cache_key() method is implemented. In
      particular, this repairs one regression which occured when
      using the dogpile.cache “advanced” example, which was not
      returning cached results and instead emitting SQL due to an
      incompatibility with the baked query loader; with the change,
      the RelationshipCache option included for many releases in the
      dogpile example will disable the “baked” query altogether. Note
      that the dogpile example is also modernized to avoid both of
      these issues as part of issue #4258.  References: #4128
      + [orm] [bug] Fixed bug where the new
      baked.Result.with_post_criteria() method would not interact
      with a subquery-eager loader correctly, in that the “post
      criteria” would not be applied to embedded subquery
      eager loaders. This is related to #4128 in that the post
      criteria feature is now used by the lazy loader.
      + [orm] [bug] Updated the dogpile.caching example to include new
      structures that accommodate for the “baked” query system, which
      is used by default within lazy loaders and some eager
      relationship loaders. The dogpile.caching “relationship_caching”
      and “advanced” examples were also broken due to #4256. The
      issue here is also worked-around by the fix in #4128.
      References: #4258
    * engine
      + [engine] [bug] Fixed connection pool issue whereby if a
      disconnection error were raised during the connection pool’s
      “reset on return” sequence in conjunction with an explicit
      transaction opened against the enclosing Connection object
      (such as from calling Session.close() without a rollback or
      commit, or calling Connection.close() without first closing a
      transaction declared with Connection.begin()), a double-checkin
      would result, which could then lead towards concurrent
      checkouts of the same connection. The double-checkin condition
      is now prevented overall by an assertion, as well as the
      specific double-checkin scenario has been fixed.
      References: #4252
      + [engine] [bug] Fixed a reference leak issue where the values of
      the parameter dictionary used in a statement execution would
      remain referenced by the “compiled cache”, as a result of
      storing the key view used by Python 3 dictionary keys(). Pull
      request courtesy Olivier Grisel.
    * sql
      + [sql] [bug] Fixed issue where the “ambiguous literal” error
      message used when interpreting literal values as SQL expression
      values would encounter a tuple value, and fail to format the
      message properly. Pull request courtesy Miguel Ventura.
    * mssql
      + [mssql] [bug] Fixed a 1.2 regression caused by #4061 where the
      SQL Server “BIT” type would be considered to be “native
      boolean”. The goal here was to avoid creating a CHECK
      constraint on the column, however the bigger issue is that the
      BIT value does not behave like a true/false constant and cannot
      be interpreted as a standalone expression, e.g.  “WHERE
      <column>”. The SQL Server dialect now goes back to being non-
      native boolean, but with an extra flag that still avoids
      creating the CHECK constraint.  References: #4250
    * oracle
      + [oracle] [bug] The Oracle BINARY_FLOAT and BINARY_DOUBLE
      datatypes now participate within cx_Oracle.setinputsizes(),
      passing along NATIVE_FLOAT, so as to support the NaN value.
      Additionally, oracle.BINARY_FLOAT, oracle.BINARY_DOUBLE and
      oracle.DOUBLE_PRECISION now subclass Float, since these are
      floating point datatypes, not decimal. These datatypes were
      already defaulting the Float.asdecimal flag to False in line
      with what Float already does.  References: #4264
      + [oracle] [bug] Added reflection capabilities for the
      oracle.BINARY_FLOAT, oracle.BINARY_DOUBLE datatypes.
      + [oracle] [bug] Altered the Oracle dialect such that when an
      Integer type is in use, the cx_Oracle.NUMERIC type is set up
      for setinputsizes(). In SQLAlchemy 1.1 and earlier,
      cx_Oracle.NUMERIC was passed for all numeric types
      unconditionally, and in 1.2 this was removed to allow for
      better numeric precision. However, for integers, some
      database/client setups will fail to coerce boolean values
      True/False into integers which introduces regressive behavior
      when using SQLAlchemy 1.2. Overall, the setinputsizes logic
      seems like it will need a lot more flexibility going forward so
      this is a start for that.  References: #4259
    * misc
      + [bug] [ext] The horizontal sharding extension now makes use of
      the identity token added to ORM identity keys as part of #4137,
      when an object refresh or column-based deferred load or
      unexpiration operation occurs.  Since we know the “shard” that
      the object originated from, we make use of this value when
      refreshing, thereby avoiding queries against other shards that
      don’t match this object’s identity in any case.
      References: #4247
      + [bug] [ext] Fixed a race condition which could occur if automap
      AutomapBase.prepare() were used within a multi-threaded context
      against other threads which may call configure_mappers() as a
      result of use of other mappers. The unfinished mapping work of
      automap is particularly sensitive to being pulled in by a
      configure_mappers() step leading to errors.  References: #4266
      + [bug] [tests] Fixed a bug in the test suite where if an
      external dialect returned None for server_version_info, the
      exclusion logic would raise an AttributeError.
      References: #4249
* Sat Apr 21 2018
  - update to version 1.2.7:
    * orm
      + [orm] [bug] Fixed regression in 1.2 within sharded query feature
      where the new “identity_token” element was not being correctly
      considered within the scope of a lazy load operation, when
      searching the identity map for a related many-to-one
      element. The new behavior will allow for making use of the
      “id_chooser” in order to determine the best identity key to
      retrieve from the identity map. In order to achieve this, some
      refactoring of 1.2’s “identity_token” approach has made some
      slight changes to the implementation of ShardedQuery which
      should be noted for other derivations of this class.
      References: #4228
      + [orm] [bug] Fixed issue in single-inheritance loading where the
      use of an aliased entity against a single-inheritance subclass
      in conjunction with the Query.select_from() method would cause
      the SQL to be rendered with the unaliased table mixed in to the
      query, causing a cartesian product. In particular this was
      affecting the new “selectin” loader when used against a
      single-inheritance subclass.  References: #4241
    * sql
      + [sql] [bug] Fixed issue where the compilation of an INSERT
      statement with the “literal_binds” option that also uses an
      explicit sequence and “inline” generation, as on Postgresql and
      Oracle, would fail to accommodate the extra keyword argument
      within the sequence processing routine.  References: #4231
    * postgresql
      + [postgresql] [feature] Added new PG type postgresql.REGCLASS
      which assists in casting table names to OID values. Pull request
      courtesy Sebastian Bank.  References: #4160
      + [postgresql] [bug] Fixed bug where the special “not equals”
      operator for the Postgresql “range” datatypes such as DATERANGE
      would fail to render “IS NOT NULL” when compared to the Python
      None value.  References: #4229
    * mssql
      + [mssql] [bug] Fixed 1.2 regression caused by #4060 where the
      query used to reflect SQL Server cross-schema foreign keys was
      limiting the criteria incorrectly.  References: #4234
    * oracle
      + [oracle] [bug] The Oracle NUMBER datatype is reflected as
      INTEGER if the precision is NULL and the scale is zero, as this
      is how INTEGER values come back when reflected from Oracle’s
      tables. Pull request courtesy Kent Bower.
* Sun Apr 01 2018
  - specfile:
    * run spec-cleaner
  - update to version 1.2.6:
    * orm
      + [orm] [bug] Fixed bug where using Mutable.associate_with() or
      Mutable.as_mutable() in conjunction with a class that has non-
      primary mappers set up with alternatively-named attributes would
      produce an attribute error. Since non-primary mappers are not
      used for persistence, the mutable extension now excludes
      non-primary mappers from its instrumentation steps.  References:
    * engine
      + [engine] [bug] Fixed bug in connection pool where a connection
      could be present in the pool without all of its “connect” event
      handlers called, if a previous “connect” handler threw an
      exception; note that the dialects themselves have connect
      handlers that emit SQL, such as those which set transaction
      isolation, which can fail if the database is in a non-available
      state, but still allows a connection. The connection is now
      invalidated first if any of the connect handlers fail.
      References: #4225
    * sql
      + [sql] [bug] Fixed a regression that occurred from the previous
      fix to #4204 in version 1.2.5, where a CTE that refers to itself
      after the CTE.alias() method has been called would not refer to
      iself correctly.  References: #4204
    * postgresql
      + [postgresql] [feature] Added support for “PARTITION BY” in
      Postgresql table definitions, using
      “postgresql_partition_by”. Pull request courtesy Vsevolod
    * mssql
      + [mssql] [bug] Adjusted the SQL Server version detection for
      pyodbc to only allow for numeric tokens, filtering out
      non-integers, since the dialect does tuple- numeric comparisons
      with this value. This is normally true for all known SQL Server
      / pyodbc drivers in any case.  References: #4227
    * oracle
      + [oracle] [bug] The minimum cx_Oracle version supported is 5.2
      (June 2015). Previously, the dialect asserted against version
      5.0 but as of 1.2.2 we are using some symbols that did not
      appear until 5.2.  References: #4211
    * misc
      + [bug] [declarative] Removed a warning that would be emitted when
      calling upon __table_args__, __mapper_args__ as named with a
      @declared_attr method, when called from a non-mapped declarative
      mixin. Calling these directly is documented as the approach to
      use when one is overidding one of these methods on a mapped
      class. The warning still emits for regular attribute names.
      References: #4221
* Thu Mar 08 2018
  - update to version 1.2.5:
    * orm
      + [orm] [feature] Added new feature
      Query.only_return_tuples(). Causes the Query object to return
      keyed tuple objects unconditionally even if the query is against
      a single entity. Pull request courtesy Eric Atkin.
      + [orm] [bug] Fixed bug in new “polymorphic selectin” loading when
      a selection of polymorphic objects were to be partially loaded
      from a relationship lazy loader, leading to an “empty IN”
      condition within the load that raises an error for the “inline”
      form of “IN”. References: #4199
      + [orm] [bug] Fixed 1.2 regression where a mapper option that
      contains an AliasedClass object, as is typical when using the
      QueryableAttribute.of_type() method, could not be pickled. 1.1’s
      behavior was to omit the aliased class objects from the path, so
      this behavior is restored.  References: #4209
    * sql
      + [sql] [bug] Fixed bug in :class:.`CTE` construct along the same
      lines as that of #4204 where a CTE that was aliased would not
      copy itself correctly during a “clone” operation as is frequent
      within the ORM as well as when using the ClauseElement.params()
      method.  References: #4210
      + [sql] [bug] Fixed bug in CTE rendering where a CTE that was also
      turned into an Alias would not render its “ctename AS aliasname”
      clause appropriately if there were more than one reference to
      the CTE in a FROM clause.  References: #4204
      + [sql] [bug] Fixed bug in new “expanding IN parameter” feature
      where the bind parameter processors for values wasn’t working at
      all, tests failed to cover this pretty basic case which includes
      that ENUM values weren’t working.  References: #4198
    * postgresql
      + [postgresql] [bug] [py3k] Fixed bug in Postgresql COLLATE /
      ARRAY adjustment first introduced in #4006 where new behaviors
      in Python 3.7 regular expressions caused the fix to fail.  This
      change is also backported to: 1.1.18 References: #4208
    * mysql
      + [mysql] [bug] MySQL dialects now query the server version using
      SELECT @@version explicitly to the server to ensure we are
      getting the correct version information back. Proxy servers like
      MaxScale interfere with the value that is passed to the DBAPI’s
      connection.server_version value so this is no longer reliable.
      This change is also backported to: 1.1.18 References: #4205
* Fri Feb 23 2018
  - update to version 1.2.4:
    * orm
      + [orm] [bug] Fixed 1.2 regression in ORM versioning feature where
      a mapping against a select() or alias() that also used a
      versioning column against the underlying table would fail due to
      the check added as part of #3673.  References: #4193
    * engine
      + [engine] [bug] Fixed regression caused in 1.2.3 due to fix from
      [#4181] where the changes to the event system involving Engine and
      OptionEngine did not accommodate for event removals, which would
      raise an AttributeError when invoked at the class level.
      References: #4190
    * sql
      + [sql] [bug] Fixed bug where CTE expressions would not have their
      name or alias name quoted when the given name is case sensitive
      or otherwise requires quoting. Pull request courtesy Eric Atkin.
      References: #4197
* Sun Feb 18 2018
  - update to version 1.2.3:
    * orm
      + [orm] [feature] Added new argument
      attributes.set_attribute.inititator to the
      attributes.set_attribute() function, allowing an event token
      received from a listener function to be propagated to subsequent
      set events.
      + [orm] [bug] Fixed issue in post_update feature where an UPDATE
      is emitted when the parent object has been deleted but the
      dependent object is not. This issue has existed for a long time
      however since 1.2 now asserts rows matched for post_update, this
      was raising an error.  This change is also backported to: 1.1.16
      References: #4187
      + [orm] [bug] Fixed regression caused by fix for issue #4116
      affecting versions 1.2.2 as well as 1.1.15, which had the effect
      of mis-calculation of the “owning class” of an AssociationProxy
      as the NoneType class in some declarative mixin/inheritance
      situations as well as if the association proxy were accessed off
      of an un-mapped class. The “figure out the owner” logic has been
      replaced by an in-depth routine that searches through the
      complete mapper hierarchy assigned to the class or subclass to
      determine the correct (we hope) match; will not assign the owner
      if no match is found. An exception is now raised if the proxy is
      used against an un-mapped instance.  This change is also
      backported to: 1.1.16 References: #4185
      + [orm] [bug] Fixed bug where the Bundle object did not correctly
      report upon the primary Mapper object represened by the bundle,
      if any. An immediate side effect of this issue was that the new
      selectinload loader strategy wouldn’t work with the horizontal
      sharding extension.  References: #4175
      + [orm] [bug] Fixed bug in concrete inheritance mapping where
      user-defined attributes such as hybrid properties that mirror
      the names of mapped attributes from sibling classes would be
      overwritten by the mapper as non-accessible at the instance
      level. Additionally ensured that user-bound descriptors are not
      implicitly invoked at the class level during the mapper
      configuration stage.  References: #4188
      + [orm] [bug] Fixed bug where the orm.reconstructor() event helper
      would not be recognized if it were applied to the __init__()
      method of the mapped class.  References: #4178
    * engine
      + [engine] [bug] Fixed bug where events associated with an Engine
      at the class level would be doubled when the
      Engine.execution_options() method were used. To achieve this,
      the semi-private class OptionEngine no longer accepts events
      directly at the class level and will raise an error; the class
      only propagates class-level events from its parent
      Engine. Instance-level events continue to work as before.
      References: #4181
      + [engine] [bug] The URL object now allows query keys to be
      specified multiple times where their values will be joined into
      a list. This is to support the plugins feature documented at
      CreateEnginePlugin which documents that “plugin” can be passed
      multiple times. Additionally, the plugin names can be passed to
      create_engine() outside of the URL using the new
      create_engine.plugins parameter.  References: #4170
    * sql
      + [sql] [feature] Added support for Enum to persist the values of
      the enumeration, rather than the keys, when using a Python
      pep-435 style enumerated object. The user supplies a callable
      function that will return the string values to be
      persisted. This allows enumerations against non-string values to
      be value-persistable as well. Pull request courtesy Jon Snyder.
      References: #3906
      + [sql] [bug] Fixed bug where the Enum type wouldn’t handle enum
      “aliases” correctly, when more than one key refers to the same
      value. Pull request courtesy Daniel Knell.  References: #4180
    * postgresql
      + [postgresql] [bug] Added “SSL SYSCALL error: Operation timed
      out” to the list of messages that trigger a “disconnect”
      scenario for the psycopg2 driver. Pull request courtesy André
      Cruz.  This change is also backported to: 1.1.16
      + [postgresql] [bug] Added “TRUNCATE” to the list of keywords
      accepted by the Postgresql dialect as an “autocommit”-triggering
      keyword. Pull request courtesy Jacob Hayes.  This change is also
      backported to: 1.1.16
    * sqlite
      + [sqlite] [bug] Fixed the import error raised when a platform has
      neither pysqlite2 nor sqlite3 installed, such that the
      sqlite3-related import error is raised, not the pysqlite2 one
      which is not the actual failure mode. Pull request courtesy
    * oracle
      + [oracle] [feature] The ON DELETE options for foreign keys are
      now part of Oracle reflection. Oracle does not support ON UPDATE
      cascades. Pull request courtesy Miroslav Shubernetskiy.
      + [oracle] [bug] Fixed bug in cx_Oracle disconnect detection, used
      by pre_ping and other features, where an error could be raised
      as DatabaseError which includes a numeric error code; previously
      we weren’t checking in this case for a disconnect code.
      References: #4182
    * misc
      + [bug] [pool] Fixed a fairly serious connection pool bug where a
      connection that is acquired after being refreshed as a result of
      a user-defined DisconnectionError or due to the 1.2-released
      “pre_ping” feature would not be correctly reset if the
      connection were returned to the pool by weakref cleanup
      (e.g. the front-facing object is garbage collected); the weakref
      would still refer to the previously invalidated DBAPI connection
      which would have the reset operation erroneously called upon it
      instead. This would lead to stack traces in the logs and a
      connection being checked into the pool without being reset,
      which can cause locking issues.  This change is also backported
      to: 1.1.16 References: #4184
      + [bug] [tests] A test added in 1.2 thought to confirm a Python
      2.7 behavior turns out to be confirming the behavior only as of
      Python 2.7.8. Python bug #8743 still impacts set comparison in
      Python 2.7.7 and earlier, so the test in question involving
      AssociationSet no longer runs for these older Python 2.7
      versions.  References: #3265
* Sun Jan 28 2018
  - update to version 1.2.2:
    * orm
      + [orm] [bug] Fixed 1.2 regression regarding new bulk_replace
      event where a backref would fail to remove an object from the
      previous owner when a bulk-assignment assigned the object to a
      new owner.  References: #4171
    * mysql
      + [mysql] [bug] Added more MySQL 8.0 reserved words to the MySQL
      dialect for quoting purposes. Pull request courtesy Riccardo
    * mssql
      + [mssql] [bug] Added ODBC error code 10054 to the list of error
      codes that count as a disconnect for ODBC / MSSQL server.
      References: #4164
    * oracle
      + [oracle] [bug] The cx_Oracle dialect now calls setinputsizes()
      with cx_Oracle.NCHAR unconditionally when the NVARCHAR2
      datatype, in SQLAlchemy corresponding to sqltypes.Unicode(), is
      in use. Per cx_Oracle’s author this allows the correct
      conversions to occur within the Oracle client regardless of the
      setting for NLS_NCHAR_CHARACTERSET.  References: #4163
* Wed Jan 17 2018
  - update to version 1.2.1:
    * orm
      + [orm] [bug] Fixed bug where an object that is expunged during a
      rollback of a nested or subtransaction which also had its
      primary key mutated would not be correctly removed from the
      session, causing subsequent issues in using the session.
      + [orm] [bug] Fixed regression where pickle format of a Load /
      _UnboundLoad object (e.g. loader options) changed and
      __setstate__() was raising an UnboundLocalError for an object
      received from the legacy format, even though an attempt was made
      to do so. tests are now added to ensure this works.
      + [orm] [bug] Fixed regression caused by new lazyload caching
      scheme in #3954 where a query that makes use of loader options
      with of_type would cause lazy loads of unrelated paths to fail
      with a TypeError.
      + [orm] [bug] Fixed bug in new “selectin” relationship loader
      where the loader could try to load a non-existent relationship
      when loading a collection of polymorphic objects, where only
      some of the mappers include that relationship, typically when
      PropComparator.of_type() is being used.
    * sql
      + [sql] [bug] Fixed bug in Insert.values() where using the
      “multi-values” format in combination with Column objects as keys
      rather than strings would fail. Pull request courtesy Aubrey
    * mssql
      + [mssql] [bug] Fixed regression in 1.2 where newly repaired
      quoting of collation names in #3785 breaks SQL Server, which
      explicitly does not understand a quoted collation name. Whether
      or not mixed-case collation names are quoted or not is now
      deferred down to a dialect-level decision so that each dialect
      can prepare these identifiers directly.
    * oracle
      + [oracle] [bug] Fixed regression where the removal of most
      setinputsizes rules from cx_Oracle dialect impacted the
      TIMESTAMP datatype’s ability to retrieve fractional seconds.
      + [oracle] [bug] Fixed regression in Oracle imports where a
      missing comma caused an undefined symbol to be present. Pull
      request courtesy Miroslav Shubernetskiy.
    * misc
      + [bug] [ext] Fixed regression in association proxy due to #3769
      (allow for chained any() / has()) where contains() against an
      association proxy chained in the form (o2m relationship,
      associationproxy(m2o relationship, m2o relationship)) would
      raise an error regarding the re-application of contains() on the
      final link of the chain.
      + [bug] [tests] Removed an oracle-specific requirements rule from
      the public test suite that was interfering with third party
      dialect suites.
      + [bug] [tests] Added a new exclusion rule
      group_by_complex_expression which disables tests that use “GROUP
      BY <expr>”, which seems to be not viable for at least two third
      party dialects.
* Wed Jan 03 2018
  - specfile:
    * updated test requirements
* Sun Dec 31 2017
  - update to version 1.2.0:
    * See
* Mon Sep 25 2017
  - update to version 1.1.14:
    * orm
      + [orm] [bug] Fixed bug in Session.merge() following along similar
      lines as that of #4030, where an internal check for a target
      object in the identity map could lead to an error if it were to
      be garbage collected immediately before the merge routine
      actually retrieves the object. References: #4069
      + [orm] [bug] Fixed bug where an undefer_group() option would not
      be recognized if it extended from a relationship that was
      loading using joined eager loading. Additionally, as the bug led
      to excess work being performed, Python function call counts are
      also improved by 20% within the initial calculation of result
      set columns, complementing the joined eager load improvements of
      [#3915].    References: #4048
      + [orm] [bug] Fixed race condition in ORM identity map which would
      cause objects to be inappropriately removed during a load
      operation, causing duplicate object identities to occur,
      particularly under joined eager loading which involves
      deduplication of objects. The issue is specific to garbage
      collection of weak references and is observed only under the
      Pypy interpreter.    References: #4068
      + [orm] [bug] Fixed bug in Session.merge() where objects in a
      collection that had the primary key attribute set to None for a
      key that is typically autoincrementing would be considered to be
      a database-persisted key for part of the internal deduplication
      process, causing only one object to actually be inserted in the
      database.    References: #4056
      + [orm] [bug] An InvalidRequestError is raised when a synonym() is
      used against an attribute that is not against a MapperProperty,
      such as an association proxy. Previously, a recursion overflow
      would occur trying to locate non-existent attributes.  References: #4067
    * sql
      + [sql] [bug] Altered the range specification for window functions
      to allow for two of the same PRECEDING or FOLLOWING keywords in
      a range by allowing for the left side of the range to be
      positive and for the right to be negative, e.g. (1, 3) is “1
      FOLLOWING AND 3 FOLLOWING”.    References: #4053
  - changes from version 1.1.13:
    * oracle
      + [oracle] [bug] [py2k] [performance] Fixed performance regression
      caused by the fix for #3937 where cx_Oracle as of version 5.3
      dropped the .UNICODE symbol from its namespace, which was
      interpreted as cx_Oracle’s “WITH_UNICODE” mode being turned on
      unconditionally, which invokes functions on the SQLAlchemy side
      which convert all strings to unicode unconditionally and causing
      a performance impact. In fact, per cx_Oracle’s author the
      “WITH_UNICODE” mode has been removed entirely as of 5.1, so the
      expensive unicode conversion functions are no longer necessary
      and are disabled if cx_Oracle 5.1 or greater is detected under
      Python 2. The warning against “WITH_UNICODE” mode that was
      removed under #3937 is also restored.
      This change is also backported to: 1.0.19
      References: #4035
* Tue Aug 08 2017
  - update to 1.1.12:
    * See
* Fri Jul 07 2017
  - Update to 1.1.11:
    * See
  - Update to 1.1.10:
    * See
* Sat May 06 2017
  - Don't provide python2-sqlalchemy, singlespec packages should use
    correct name.
* Mon May 01 2017
  - Add literal python-sqlalchemy provides.
* Tue Apr 18 2017
  - Update to 1.1.9:
    * See
  - Update to 1.1.8:
    * See
  - Update to 1.1.7:
    * See
  - Update to 1.1.6:
    * See
  - Update to 1.1.5:
    * See
  - Update to 1.1.4:
    * See
  - Update to 1.1.3:
    * See
  - Update to 1.1.2:
    * See
  - Update to 1.1.1:
    * See
  - Update to 1.1.0:
    * See
  - Update to 1.0.18:
    * See
  - Update to 1.0.17:
    * See
  - Update to 1.0.16:
    * See
  - Implement single-spec version.
* Thu Sep 15 2016
  - Update to 1.0.15:
    * See
* Mon Jun 06 2016
  - fix source url
* Fri Jun 03 2016
  - update to 1.0.13:
    * see
    Remove 0001-fix-sqlite3.10.0-test.patch. Applied upstream.
* Thu Feb 11 2016
  - Add 0001-fix-sqlite3.10.0-test.patch
    Backport fix after SQLite3.10 upgrade
* Mon Jan 11 2016
  - update to 1.0.11:
    * see
* Sun Oct 04 2015
  - update to 1.0.8:
    * see
* Mon Jun 15 2015
  - update to version 1.0.5:
    * see
* Sun May 24 2015
  - update to 1.0.4:
    + see
    + see
* Wed Apr 22 2015
  - update to 0.9.9:
    + See
* Thu Jan 08 2015
  - Update to version 0.9.8:
    + See
* Fri Sep 12 2014
  - update to 0.9.7:
    + See
* Wed Jul 02 2014
  -update to 0.9.6:
    + See
  -Remove obsolete sqlalchemy-0.7-setup_test.patch
  -Add python-pytest dependency
* Tue Apr 08 2014
  - update to 0.8.6:
    + See
* Wed Oct 30 2013
  - Update to version 0.8.3:
    + See
  - Drop outdated patches
    + SQLAlchemy-0.7.10-SLES-drop-failing-tests.patch
    + sqlalchemy-0.7-logging.patch
* Thu Oct 24 2013
  - Require python-setuptools instead of distribute (upstreams merged)
* Thu Aug 01 2013
  - Add SQLAlchemy-0.7.10-SLES-drop-failing-tests.patch: Cheat with
    dropping tests to fix testsuite on SLE-11
* Mon Jul 22 2013
  - fixing build requirement from python-sqlite to python-pysqlite
* Mon Jul 15 2013
  - apply patch to fix TypeError, when running python test
* Sun Jul 14 2013
  - add python-sqlite build dep for the test rig
  - apply a patch, that fixes TB of the test rig
* Fri Mar 08 2013
  - update to 0.7.10:
    * orm
    + [bug] Fixed Session accounting bug whereby replacing
      a deleted object in the identity map with another
      object of the same primary key would raise a
      "conflicting state" error on rollback(),
      if the replaced primary key were established either
      via non-unitofwork-established INSERT statement
      or by primary key switch of another instance.
    * oracle
    + [bug] changed the list of cx_oracle types that are
      excluded from the setinputsizes() step to only include
      STRING and UNICODE; CLOB and NCLOB are removed.  This
      is to work around cx_oracle behavior which is broken
      for the executemany() call.  In 0.8, this same change
      is applied however it is also configurable via the
      exclude_setinputsizes argument. [ticket:2561]
    * mysql
    + [feature] Added "raise_on_warnings" flag to OurSQL
      dialect.  [ticket:2523]
    + [feature] Added "read_timeout" flag to MySQLdb
      dialect.  [ticket:2554]
* Wed Jan 02 2013
  - Fix building on SLES
* Wed Dec 19 2012
  - The doc package is noarch
* Fri Nov 02 2012
  - do not require python-pysqlite package.
  - update to 0.7.9:
    * orm
    - [bug] Fixed bug mostly local to new AbstractConcreteBase helper
      where the "type" attribute from the superclass would not be overridden
      on the subclass to produce the "reserved for base" error message,
      instead placing a do-nothing attribute there. This was inconsistent
      vs. using ConcreteBase as well as all the behavior of classical
      concrete mappings, where the "type" column from the polymorphic base
      would be explicitly disabled on subclasses, unless overridden
    - [bug] A warning is emitted when lazy='dynamic' is combined with
      uselist=False. This is an exception raise in 0.8.
    - [bug] Fixed bug whereby user error in related-object assignment could
      cause recursion overflow if the assignment triggered a backref of the
      same name as a bi-directional attribute on the incorrect class to the
      same target. An informative error is raised now.
    - [bug] Fixed bug where incorrect type information would be passed when
      the ORM would bind the "version" column, when using the "version"
      feature. Tests courtesy Daniel Miller. [ticket:2539]
    - [bug] Extra logic has been added to the "flush" that occurs within
      Session.commit(), such that the extra state added by an after_flush()
      or after_flush_postexec() hook is also flushed in a subsequent flush,
      before the "commit" completes. Subsequent calls to flush() will
      continue until the after_flush hooks stop adding new state. An
      "overflow" counter of 100 is also in place, in the event of a broken
      after_flush() hook adding new content each time.  [ticket:2566]
    * engine
    - [feature] Dramatic improvement in memory usage of the event system;
      instance-level collections are no longer created for a particular type of
      event until instance-level listeners are established for that
      event. [ticket:2516]
    - [bug] Fixed bug whereby a disconnect detect + dispose that occurs when
      the QueuePool has threads waiting for connections would leave those
      threads waiting for the duration of the timeout on the old pool (or
      indefinitely if timeout was disabled). The fix now notifies those
      waiters with a special exception case and has them move onto the new
      pool. [ticket:2522]
    - [bug] Added gaerdbms import to mysql/, the absense of which
      was preventing the new GAE dialect from being loaded. [ticket:2529]
    - [bug] Fixed cextension bug whereby the "ambiguous column error" would
      fail to function properly if the given index were a Column object and
      not a string. Note there are still some column-targeting issues here
      which are fixed in 0.8. [ticket:2553]
    - [bug] Fixed the repr() of Enum to include the "name" and "native_enum"
      flags. Helps Alembic autogenerate.
    * sql
    - [bug] Fixed the DropIndex construct to support an Index associated with
      a Table in a remote schema. [ticket:2571]
    - [bug] Fixed bug in over() construct whereby passing an empty list for
      either partition_by or order_by, as opposed to None, would fail to
      generate correctly. Courtesy Gunnlaugur Þór Briem. [ticket:2574]
    - [bug] Fixed CTE bug whereby positional bound parameters present in the
      CTEs themselves would corrupt the overall ordering of bound
      parameters. This primarily affected SQL Server as the platform with
      positional binds + CTE support. [ticket:2521]
    - [bug] Fixed more un-intuitivenesses in CTEs which prevented referring
      to a CTE in a union of itself without it being aliased. CTEs now render
      uniquely on name, rendering the outermost CTE of a given name only -
      all other references are rendered just as the name. This even includes
      other CTE/SELECTs that refer to different versions of the same CTE
      object, such as a SELECT or a UNION ALL of that SELECT. We are somewhat
      loosening the usual link between object identity and lexical identity
      in this case. A true name conflict between two unrelated CTEs now
      raises an error.
    - [bug] quoting is applied to the column names inside the WITH RECURSIVE
      clause of a common table expression according to the quoting rules for
      the originating Column. [ticket:2512]
    - [bug] Fixed regression introduced in 0.7.6 whereby the FROM list of a
      SELECT statement could be incorrect in certain "clone+replace"
      scenarios. [ticket:2518]
    - [bug] Fixed bug whereby usage of a UNION or similar inside of an
      embedded subquery would interfere with result-column targeting, in the
      case that a result-column had the same ultimate name as a name inside
      the embedded UNION. [ticket:2552]
    - [bug] Fixed a regression since 0.6 regarding result-row targeting. It
      should be possible to use a select() statement with string based
      columns in it, that is select(['id', 'name']).select_from('mytable'),
      and have this statement be targetable by Column objects with those
      names; this is the mechanism by which
      query(MyClass).from_statement(some_statement) works. At some point the
      specific case of using select(['id']), which is equivalent to
      select([literal_column('id')]), stopped working here, so this has been
      re-instated and of course tested. [ticket:2558]
    - [bug] Added missing operators is_(), isnot() to the ColumnOperators
      base, so that these long-available operators are present as methods
      like all the other operators. [ticket:2544]
    * postgresql
    - [bug] Columns in reflected primary key constraint are now returned in
      the order in which the constraint itself defines them, rather than how
      the table orders them. Courtesy Gunnlaugur Þór Briem.. [ticket:2531]
    - [bug] Added 'terminating connection' to the list of messages we use to
      detect a disconnect with PG, which appears to be present in some
      versions when the server is restarted. [ticket:2570]
    * mysql
    - [bug] Updated mysqlconnector interface to use updated "client flag" and
      "charset" APIs, courtesy David McNelis.
    * sqlite
    - [feature] Added support for the localtimestamp() SQL function
      implemented in SQLite, courtesy Richard Mitchell.
    - [bug] Adjusted a very old bugfix which attempted to work around a
      SQLite issue that itself was "fixed" as of sqlite 3.6.14, regarding
      quotes surrounding a table name when using the "foreign_key_list"
      pragma. The fix has been adjusted to not interfere with quotes that are
      actually in the name of a column or table, to as much a degree as
      possible; sqlite still doesn't return the correct result for
      foreign_key_list() if the target table actually has quotes surrounding
      its name, as part of its name (i.e. """mytable"""). [ticket:2568]
    - [bug] Adjusted column default reflection code to convert non-string
      values to string, to accommodate old SQLite versions that don't deliver
      default info as a string. [ticket:2265]
    * mssql
    - [bug] Fixed compiler bug whereby using a correlated subquery within an
      ORDER BY would fail to render correctly if the stament also used
      LIMIT/OFFSET, due to mis-rendering within the ROW_NUMBER() OVER
      clause. Fix courtesy sayap [ticket:2538]
    - [bug] Fixed compiler bug whereby a given select() would be modified if
      it had an "offset" attribute, causing the construct to not compile
      correctly a second time. [ticket:2545]
    - [bug] Fixed bug where reflection of primary key constraint would double
      up columns if the same constraint/table existed in multiple schemas.
  - update to 0.7.8:
    * orm
    - [feature] The 'objects' argument to flush() is no longer deprecated, as
      some valid use cases have been identified.
    - [bug] Fixed bug whereby subqueryload() from a polymorphic mapping to a
      target would incur a new invocation of the query for each distinct
      class encountered in the polymorphic result. [ticket:2480]
    - [bug] Fixed bug in declarative whereby the precedence of columns in a
      joined-table, composite column (typically for id) would fail to be
      correct if the columns contained names distinct from their attribute
      names. This would cause things like primaryjoin conditions made against
      the entity attributes to be incorrect. Related to as this was supposed
      to be part of that, this is. [ticket:2491, 1892]
    - [bug] Fixed identity_key() function which was not accepting a scalar
      argument for the identity. . [ticket:2508]
    - [bug] Fixed bug whereby populate_existing option would not propagate to
      subquery eager loaders. . [ticket:2497]
    * engine
    - [bug] Fixed memory leak in C version of result proxy whereby DBAPIs
      which don't deliver pure Python tuples for result rows would fail to
      decrement refcounts correctly. The most prominently affected DBAPI is
      pyodbc. [ticket:2489]
    - [bug] Fixed bug affecting Py3K whereby string positional parameters
      passed to engine/connection execute() would fail to be interpreted
      correctly, due to __iter__ being present on Py3K string.. [ticket:2503]
    * sql
    - [bug] added BIGINT to types.__all__, BIGINT, BINARY, VARBINARY to
      sqlalchemy module namespace, plus test to ensure this breakage doesn't
      occur again. [ticket:2499]
    - [bug] Repaired common table expression rendering to function correctly
      when the SELECT statement contains UNION or other compound expressions,
      courtesy btbuilder. [ticket:2490]
    - [bug] Fixed bug whereby append_column() wouldn't function correctly on
      a cloned select() construct, courtesy Gunnlaugur Þór
      Briem. [ticket:2482]
    * postgresql
    - [bug] removed unnecessary table clause when reflecting enums,. Courtesy
      Gunnlaugur Þór Briem. [ticket:2510]
    * mysql
    - [feature] Added a new dialect for Google App Engine. Courtesy Richie
      Foreman. [ticket:2484]
    * oracle
    - [bug] Added ROWID to oracle.*. [ticket:2483]
* Wed May 23 2012
  - python3 package added
  - removed BuildRequires update-desktop-files, because there is no
    desktop files in package
  - minor spec improvement
* Sun May 06 2012
  - update to 0.7.7:
    * orm
    - [bug] Fixed issue in unit of work whereby setting a non-None
      self-referential many-to-one relationship to None would fail
      to persist the change if the former value was not already loaded.
    - [feature] Added prefix_with() method to Query, calls upon
      select().prefix_with() to allow placement of MySQL SELECT
      directives in statements.  Courtesy Diana Clarke [ticket:2443]
    - [bug] Fixed bug in 0.7.6 introduced by [ticket:2409] whereby
      column_mapped_collection used against columns that were mapped as
      joins or other indirect selectables would fail to function.
    - [feature] Added new flag to @validates include_removes. When True,
      collection remove and attribute del events will also be sent to
      the validation function, which accepts an additional argument
      "is_remove" when this flag is used.
    - [bug] Fixed bug whereby polymorphic_on column that's not otherwise
      mapped on the class would be incorrectly included in a merge()
      operation, raising an error. [ticket:2449]
    - [bug] Fixed bug in expression annotation mechanics which could
      lead to incorrect rendering of SELECT statements with aliases
      and joins, particularly when using column_property(). [ticket:2453]
    - [bug] Fixed bug which would prevent OrderingList from being
      pickleable [ticket:2454].  Courtesy Jeff Dairiki
    - [bug] Fixed bug in relationship comparisons whereby calling
      unimplemented methods like
      would produce a recursion overflow, instead of NotImplementedError.
    * sql
    - [bug] Removed warning when Index is created with no columns;
      while this might not be what the user intended, it is a valid use case
      as an Index could be a placeholder for just an index of a certain name.
    - [feature] Added new connection event dbapi_error(). Is called for
      all DBAPI-level errors passing the original DBAPI exception before
      SQLAlchemy modifies the state of the cursor. "with engine.begin()",
      the newly acquired Connection is closed explicitly before propagating
      the exception onward normally.
    - [bug] Add BINARY, VARBINARY to types.__all__, [ticket:2474]
    * mssql
    - [feature] Added interim create_engine flag supports_unicode_binds
      to PyODBC dialect, to force whether or not the dialect passes
      Python unicode literals to PyODBC or not.
    - [bug] Repaired the use_scope_identity create_engine() flag when
      using the pyodbc dialect. Previously this flag would be ignored if
      set to False.  When set to False, you'll get "SELECT @@identity"
      after each INSERT to get at the last inserted ID, for those tables
      which have "implicit_returning" set to False.
    - [bug] UPDATE..FROM syntax with SQL Server requires that the updated
      table be present in the FROM clause when an alias of that table is
      also present in the FROM clause. The updated table is now always present
      in the FROM, when FROM is present in the first place.  Courtesy sayap.
    * postgresql
    - [feature] Added new for_update/with_lockmode() options for Postgresql:
      for_update="read"/ with_lockmode("read"), for_update="read_nowait"/
      with_lockmode("read_nowait"). These emit "FOR SHARE" and "FOR SHARE
      NOWAIT", respectively.  Courtesy Diana Clarke [ticket:2445]
    - [bug] removed unnecessary table clause when reflecting domains, [ticket:2473]
    * mysql
    - [bug] Fixed bug whereby column name inside of "KEY" clause for autoincrement
      composite column with InnoDB would double quote a name that's a reserved
      word.  Courtesy Jeff Dairiki. [ticket:2460]
    - [bug] Fixed bug whereby get_view_names() for "information_schema" schema
      would fail to retrieve views marked as "SYSTEM VIEW". courtesy Matthew Turland.
    - [bug] Fixed bug whereby if cast() is used on a SQL expression whose type
      is not supported by cast() and therefore CAST isn't rendered by the
      dialect, the order of evaluation could change if the casted expression
      required that it be grouped; grouping is now applied to those expressions.
    * sqlite
    - [feature] Added SQLite execution option "sqlite_raw_colnames=True", will
      bypass attempts to remove "." from column names returned by SQLite
      cursor.description. [ticket:2475]
* Mon Apr 30 2012
  - Update to 0.7.6
    * orm
    - [bug] Fixed event registration bug
      which would primarily show up as
      events not being registered with
      sessionmaker() instances created
      after the event was associated
      with the Session class.  [ticket:2424]
    - [bug] Fixed bug whereby a primaryjoin
      condition with a "literal" in it would
      raise an error on compile with certain
      kinds of deeply nested expressions
      which also needed to render the same
      bound parameter name more than once.
    - [feature] Added "no_autoflush" context
      manager to Session, used with with:
      will temporarily disable autoflush.
    - [feature] Added cte() method to Query,
      invokes common table expression support
      from the Core (see below). [ticket:1859]
    - [bug] Removed the check for number of
      rows affected when doing a multi-delete
      against mapped objects.   If an ON DELETE
      CASCADE exists between two rows, we can't
      get an accurate rowcount from the DBAPI;
      this particular count is not supported
      on most DBAPIs in any case, MySQLdb
      is the notable case where it is.
    - [bug] Fixed bug whereby objects using
      attribute_mapped_collection or
      column_mapped_collection could not be
      pickled.  [ticket:2409]
    - [bug] Fixed bug whereby MappedCollection
      would not get the appropriate collection
      instrumentation if it were only used
      in a custom subclass that used
    - [bug] Fixed bug whereby SQL adaption mechanics
      would fail in a very nested scenario involving
      joined-inheritance, joinedload(), limit(), and a
      derived function in the columns clause.
    - [bug] Fixed the repr() for CascadeOptions to
      include refresh-expire.  Also reworked
      CascadeOptions to be a <frozenset>.
    - [feature] Added the ability to query for
      Table-bound column names when using
    - [bug] Improved the "declarative reflection"
      example to support single-table inheritance,
      multiple calls to prepare(), tables that
      are present in alternate schemas,
      establishing only a subset of classes
      as reflected.
    - [bug] Scaled back the test applied within
      flush() to check for UPDATE against partially
      NULL PK within one table to only actually
      happen if there's really an UPDATE to occur.
    - [bug] Fixed bug whereby if a method name
      conflicted with a column name, a
      TypeError would be raised when the mapper
      tried to inspect the __get__() method
      on the method object.  [ticket:2352]
    * sql
    - [bug] Fixed memory leak in core which would
      occur when C extensions were used with
      particular types of result fetches,
      in particular when orm query.count()
      were called.  [ticket:2427]
    - [bug] Fixed issue whereby attribute-based
      column access on a row would raise
      AttributeError with non-C version,
      NoSuchColumnError with C version.  Now
      raises AttributeError in both cases.
    - [feature] Added support for SQL standard
      common table expressions (CTE), allowing
      SELECT objects as the CTE source (DML
      not yet supported).  This is invoked via
      the cte() method on any select() construct.
    - [bug] Added support for using the .key
      of a Column as a string identifier in a
      result set row.   The .key is currently
      listed as an "alternate" name for a column,
      and is superseded by the name of a column
      which has that key value as its regular name.
      For the next major release
      of SQLAlchemy we may reverse this precedence
      so that .key takes precedence, but this
      is not decided on yet.  [ticket:2392]
    - [bug] A warning is emitted when a not-present
      column is stated in the values() clause
      of an insert() or update() construct.
      Will move to an exception in 0.8.
    - [bug] A significant change to how labeling
      is applied to columns in SELECT statements
      allows "truncated" labels, that is label names
      that are generated in Python which exceed
      the maximum identifier length (note this is
      configurable via label_length on create_engine()),
      to be properly referenced when rendered inside
      of a subquery, as well as to be present
      in a result set row using their original
      in-Python names.   [ticket:2396]
    - [bug] Fixed bug in new "autoload_replace" flag
      which would fail to preserve the primary
      key constraint of the reflected table.
    - [bug] Index will raise when arguments passed
      cannot be interpreted as columns or expressions.
      Will warn when Index is created
      with no columns at all.  [ticket:2380]
    * engine
    - [feature] Added "no_parameters=True" execution
      option for connections.   If no parameters
      are present, will pass the statement
      as cursor.execute(statement), thereby invoking
      the DBAPIs behavior when no parameter collection
      is present; for psycopg2 and mysql-python, this
      means not interpreting % signs in the string.
      This only occurs with this option, and not
      just if the param list is blank, as otherwise
      this would produce inconsistent behavior
      of SQL expressions that normally escape percent
      signs (and while compiling, can't know ahead of
      time if parameters will be present in
      some cases).  [ticket:2407]
    - [bug] Added execution_options() call to
      MockConnection (i.e., that used with
      strategy="mock") which acts as a pass through
      for arguments.
    - [feature] Added pool_reset_on_return argument
      to create_engine, allows control over
      "connection return" behavior.  Also added
      new arguments 'rollback', 'commit', None
      to pool.reset_on_return to allow more control
      over connection return activity. [ticket:2378]
    - [feature] Added some decent context managers
      to Engine, Connection:
      with engine.begin() as conn:
      <work with conn in a transaction>
      with engine.connect() as conn:
      <work with conn>
      Both close out the connection when done,
      commit or rollback transaction with errors
      on engine.begin().
    * sqlite
    - [bug] Fixed bug in C extensions whereby
      string format would not be applied to a
      Numeric value returned as integer; this
      affected primarily SQLite which does
      not maintain numeric scale settings.
    * mssql
    - [feature] Added support for MSSQL INSERT,
      UPDATE, and DELETE table hints, using
      new with_hint() method on UpdateBase.
    * mysql
    - [feature] Added support for MySQL index and
      primary key constraint types
      (i.e. USING) via new mysql_using parameter
      to Index and PrimaryKeyConstraint,
      courtesy Diana Clarke.  [ticket:2386]
    - [feature] Added support for the "isolation_level"
      parameter to all MySQL dialects.  Thanks
      to mu_mind for the patch here. [ticket:2394]
    * oracle
    - [feature] Added a new create_engine() flag
      coerce_to_decimal=False, disables the precision
      numeric handling which can add lots of overhead
      by converting all numeric values to
      Decimal.  [ticket:2399]
    - [bug] Added missing compilation support for
      LONG [ticket:2401]
    - [bug] Added 'LEVEL' to the list of reserved
      words for Oracle.  [ticket:2435]
    * examples
    - [bug] Altered _params_from_query() function
      in Beaker example to pull bindparams from the
      fully compiled statement, as a quick means
      to get everything including subqueries in the
      columns clause, etc.
* Wed Feb 22 2012
  - Fixed SLE_11 build by disabling the testsuite for it
* Thu Feb 09 2012
  - Update to 0.7.5:
    * Fixed issue where modified session state established after a
      failed flush would be committed as part of the subsequent
      transaction that begins automatically after manual call to
    * Improved the API for add_column() such that if the same column
      is added to its own table, an error is not raised and the
      constraints don't get doubled up.
    * Fixed issue where the "required" exception would not be raised
      for bindparam() with required=True, if the statement were given
      no parameters at all.
    * for more details see the CHANGES file.
* Thu Nov 10 2011
  - Add depenendency on pysqlite
* Wed Sep 21 2011
  - Update to version 0.7.2:
    * A rework of "replacement traversal"
    * Fixed bug where query.join() + aliased=True
    * Fixed regression from 0.6 where Session.add()
      against an object which contained None
    - See CHANGES for more...
  - Run testsuite
* Wed Jul 20 2011
  - Let doc package require base package instead of recommends
* Wed Jul 20 2011
  - Dropped unused BuildRequires for fdupes and python-sqlite2
* Wed Jul 20 2011
  - Initial version, replaces python-sqlalchemy
    * Much simpler spec file
    * Packaged LICENSE, CHANGES and README files



Generated by rpm2html 1.8.1

Fabrice Bellet, Sat Dec 18 00:00:00 2021